hob-bot 1.1.0 → 1.3.0

package/server/src/router-tools.ts

@@ -1,7 +1,7 @@
 import { Type } from "@earendil-works/pi-ai";
 import { createReadToolDefinition, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { basename, extname, join, resolve } from "node:path";
+import { basename, dirname, extname, join, resolve } from "node:path";
 import { readFile } from "node:fs/promises";
 import { IMAGE_TYPES } from "../../shared/media.ts";
 import { lookupFile } from "./files.ts";
@@ -29,6 +29,8 @@ import { pushApproval } from "./push.ts";
 import { searchTools } from "./search.ts";
 import type { HobRuntime } from "./runtime.ts";
 import { clampDuty } from "./text.ts";
+import { listAssistantSkills, readAssistantSkillBody, saveAssistantSkill, skillInstruction, usableAssistantSkills } from "./assistant-skills.ts";
+import { jobView } from "./job-view.ts";
 
 type Tool = ToolDefinition<any, any>;
 
@@ -98,6 +100,46 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
     detectImageMimeType: async (path) => IMAGE_TYPES[extname(checkFile(path)).toLowerCase()],
   } }) as unknown as Tool;
   const tools: Tool[] = [
+    {
+      name: "check_job",
+      label: "看任务",
+      description: "看一个任务现在的状态和过程：做到哪一步、跑过哪些命令、说过什么、用了哪个技能、在等什么。",
+      parameters: Type.Object({ jobId: Type.String({ description: "任务 id" }) }),
+      execute: async (_id, params: { jobId: string }) => {
+        const job = store.job(params.jobId);
+        if (!job || (!assistant().primary && job.assistantId !== assistantId)) return fail(`没有这个任务：${params.jobId}`);
+        try {
+          return ok(jobView({ ...job, cwd: job.cwd ?? store.workDir(job.id) }, jobs.transcript(job.id), store.approvals(), listAssistantSkills(runtime.home, job.assistantId), runtime.settings.settings.general.timezone));
+        } catch (error) { return fail(error instanceof Error ? error.message : String(error)); }
+      },
+    },
+    {
+      name: "edit_skill",
+      label: "改技能",
+      description: "改这个助手某个技能的正文（SKILL.md）：把一段原文换成新的文字，旧版会保留。要改脚本的，交给任务去改。",
+      parameters: Type.Object({
+        name: Type.String({ description: "技能名" }),
+        edits: Type.Array(Type.Object({ old: Type.String(), new: Type.String() }), { description: "一处或几处修改：old 是正文里的原文，要一字不差、只出现一次；new 是换成的文字" }),
+      }),
+      execute: async (_id, params: { name: string; edits: { old: string; new: string }[] }) => {
+        try {
+          const skill = listAssistantSkills(runtime.home, assistantId).find((item) => item.name === params.name);
+          if (!skill) return fail(`没有这个技能：${params.name}`);
+          let body = readAssistantSkillBody(skill.path);
+          for (const edit of params.edits) {
+            if (!edit.old) return fail("原文不能为空");
+            const count = body.split(edit.old).length - 1;
+            if (!count) return fail(`正文里找不到这段原文：${[...edit.old].slice(0, 30).join("")}`);
+            if (count > 1) return fail(`这段原文出现了 ${count} 次，多带几个字`);
+            body = body.replace(edit.old, () => edit.new);
+          }
+          const saved = saveAssistantSkill(runtime.home, assistantId, { name: skill.name, title: skill.title, description: skill.description, content: body });
+          await router.addItem(assistantId, { kind: "note", icon: "skill", text: `已更新技能「${saved.title}」· 第 ${saved.version} 版`, path: saved.path });
+          bus.emit({ type: "skills", assistantId });
+          return ok(`已更新技能「${saved.title}」，第 ${saved.version} 版。`);
+        } catch (error) { return fail(error instanceof Error ? error.message : String(error)); }
+      },
+    },
     {
       name: "save_job_as_skill",
       label: "沉淀技能",
@@ -160,6 +202,8 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
             description: "要交给任务的文件路径（用户发来的附件）；图片会直接给模型看",
           }),
         ),
+        skill: Type.Optional(Type.String({ description: "可选，按这个助手的哪个技能做，填技能名。" })),
+        expect_minutes: Type.Optional(Type.Number({ description: "可选，预计多少分钟能交结果。超过了会通知你；不填按 10 分钟。" })),
         model: Type.Optional(Type.String({ description: `可选，不填用默认。聪明、成本、速度 0–100，越高越聪明、越贵、越快：\n${modelText}` })),
         thinking: Type.Optional(
           Type.String({ description: modelSettings.thinkingChoice === "fixed" ? "当前设置为固定思考档，此参数会被忽略，不要填。" : "可选：思考档以可分派模型列表里每个模型标的为准。不填用模型的默认思考档。" }),
@@ -167,12 +211,19 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
       }),
       execute: async (_id, params: any) => {
         try {
+          if (params.expect_minutes != null && (!Number.isInteger(params.expect_minutes) || params.expect_minutes < 1 || params.expect_minutes > 10080)) return fail("expect_minutes 要在 1 到 10080 之间");
           const note = params.note == null ? "" : String(params.note);
           if ([...note].length > 200) return fail("备注最多 200 字；用户原话和最近的对话会自动带上，备注只写从原话里看不出的背景。");
+          // 有的模型会把没用的可选参数填成空串：空串当没填
+          const wanted = params.skill ? String(params.skill) : "";
+          const skills = usableAssistantSkills(runtime.home, assistantId);
+          const skill = wanted ? skills.find((item) => item.name === wanted) : undefined;
+          if (wanted && !skill) return fail(`没有这个技能：${wanted}。能用的有：${skills.map((item) => item.name).join("、") || "无"}`);
           const original = router.originalWords(assistantId, note, true, Array.isArray(params.files) ? params.files.map(String) : []);
           const job = await jobs.start(assistantId, {
             title: String(params.title),
-            instruction: original.text,
+            ...(params.expect_minutes != null ? { expectMinutes: params.expect_minutes } : {}),
+            instruction: skill ? skillInstruction(skill.title, original.text) : original.text,
             ...(params.cwd ? { cwd: String(params.cwd) } : {}),
             ...(original.files.length ? { files: original.files } : {}),
             ...(params.model ? { model: String(params.model) } : {}),
@@ -181,7 +232,7 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
           });
           if (job.status === "failed") return fail(`任务启动失败：${job.statusReason ?? "原因不明"}`);
           return endTurn(
-            `任务「${job.title}」（${job.id}）已开始。`,
+            `任务「${job.title}」（${job.id}）已开始，预计 ${job.expect?.minutes ?? 10} 分钟${params.expect_minutes == null ? "（默认）" : ""}。`,
           );
         } catch (error) {
           return fail(error instanceof Error ? error.message : String(error));
@@ -214,7 +265,7 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
       parameters: Type.Object({ jobId: Type.String({ description: "任务 id" }) }),
       execute: async (_id, params: any) => {
         try {
-          await jobs.stop(String(params.jobId));
+          await jobs.stop(String(params.jobId), `${assistant().name}叫停了`);
           return ok("已停止。");
         } catch (error) {
           return fail(error instanceof Error ? error.message : String(error));
@@ -381,13 +432,21 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
     {
       name: "send_file",
       label: "发送文件",
-      description: "把任务产出的文件作为文件卡片发送到对话里。",
+      description: "把一个文件（任务产出、截图、生成的图）作为卡片发到对话里，图片直接显示。",
       parameters: Type.Object({ path: Type.String({ description: "文件的绝对路径" }) }),
       execute: async (_id, params: any) => {
         const path = String(params.path);
         if (!existsSync(path)) return fail(`文件不存在：${path}`);
-        const meta = fileMeta(path);
-        await router.addItem(assistantId, { kind: "file", path, name: basename(path), ...(meta ? { meta } : {}) });
+        let name = basename(path);
+        let meta = fileMeta(path);
+        if (dirname(resolve(path)) === resolve(runtime.home, "pages") && extname(path).toLowerCase() === ".html") {
+          const html = await readFile(path, "utf8");
+          const title = html.match(/<title>([\s\S]*?)<\/title>/)?.[1];
+          const summary = html.match(/<header class="hd"><h1>[\s\S]*?<\/h1><p>([\s\S]*?)<\/p><\/header>/)?.[1];
+          const unescape = (value: string) => value.replace(/&(amp|lt|gt|quot);/g, (_, key: string) => ({ amp: "&", lt: "<", gt: ">", quot: '"' })[key]!);
+          if (title !== undefined && summary !== undefined) { name = unescape(title); meta = unescape(summary); }
+        }
+        await router.addItem(assistantId, { kind: "file", path, name, ...(meta ? { meta } : {}) });
         return ok("已发送。");
       },
     },
@@ -494,7 +553,7 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
     });
   }
 
-  if (runtime.settings.settings.general.showPage !== false) tools.push(pageTool(runtime, assistantId, true));
+  if (runtime.settings.settings.general.showPage !== false) tools.push(pageTool(runtime, assistantId));
 
   if (assistant().primary) {
     tools.push(
@@ -502,7 +561,7 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
       {
         name: "propose_assistant",
         label: "提议创建专属助手",
-        description: "同类事情反复出现、又没有合适的助手时，提议新建一个专属助手。生成草稿卡，用户点「创建」才会建。",
+        description: "同类事情反复出现、又没有合适的助手时，提议新建一个专属助手。生成草稿卡，用户点「创建」才会建。怎么做事是所有助手共用的模板和全局规则定的，草稿里只写这个助手特有的东西。",
         parameters: Type.Object({
           name: Type.String({ description: "助手名字：职责加一个亲切的昵称，四五个字，如「运维小子」「写稿搭子」「代理管家」；不要只写「代理」「运维」这种光秃秃的词" }),
           duty: Type.String({ description: "左栏头像下面那行小字，最多 8 个字，如「线上和机器」「模型和 agent」" }),
@@ -535,10 +594,9 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
               { description: "可选。根据上下文判断这个助手需不需要定期做的事，不是每个助手都要有。拿不准就先问用户，问清楚再加。" },
             ),
           ),
-          askFirst: Type.Optional(Type.Array(Type.String(), { description: "执行前需确认的事项" })),
-          instructions: Type.Optional(
-            Type.Array(Type.String(), { description: "这个助手特有的做法（每项一行，写进新助手的补充说明）" }),
-          ),
+          askFirst: Type.Optional(Type.Array(Type.String(), { description: "这个领域特有、做之前要先问用户的事，每项一条；全局规则已经列的不重复。" })),
+          // 必填：可选时模型第一次总是漏掉，被打回再补，白走一轮（评测 G5 三次都这样）
+          facts: Type.Array(Type.String(), { description: "这个助手特有的事实，每项一行：管什么、不管什么（归谁管）、东西在哪（目录、服务）。只写事实，不写做法和规矩。例：「博客源码在 ~/sites/blog，用 Hugo 构建」「报销归「财务」助手管，这里不碰」" }),
           conversations: Type.Optional(Type.Integer({ description: "需要迁移的对话段数，默认 0" })),
         }),
         execute: async (_id, params: any) => {
@@ -552,6 +610,8 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
           if (given?.prop === "custom" && !checked?.ok) {
             return fail("sprite 是 custom 时要同时给 prop_art（art、pal、dx）画一件。");
           }
+          const facts = Array.isArray(params.facts) ? params.facts.filter((fact: unknown): fact is string => typeof fact === "string").map((fact: string) => fact.trim()).filter(Boolean) : [];
+          if (!facts.length) return fail("facts 至少写一条：这个助手管什么、不管什么。");
           const routinesInput: { name: string; instruction: string; schedule: string }[] =
             params.routines ?? [];
           const taken = store.assistants().map((a) => a.sprite);
@@ -570,7 +630,7 @@ export function buildRouterTools(runtime: HobRuntime, assistantId: string): Tool
             routines: routinesInput,
             routinesText: routinesInput.map((item) => `${item.name} · ${cronToChinese(item.schedule)}`).join("、"),
             askFirst: (params.askFirst as string[]) ?? [],
-            instructions: (params.instructions as string[]) ?? [],
+            instructions: facts,
             carry: { conversations: Number(params.conversations ?? 0) },
             createdAt: new Date().toISOString(),
           };

package/server/src/router.ts

@@ -1,6 +1,6 @@
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { parseStreamingJson } from "@earendil-works/pi-ai/utils/json-parse";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { mkdirSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import type { AgentSession, AgentSessionEvent, SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
@@ -30,6 +30,7 @@ import { activityLabel, thinkingLine } from "./router-activity.ts";
 import { imageContents } from "./jobs.ts";
 import { nowBlock } from "./now.ts";
 import { monthDayTimeText } from "./time.ts";
+import { DesktopToolSession } from "./desktop-tools.ts";
 
 export const ITEM_TYPE = "hob.item";
 export const ITEM_UPDATE_TYPE = "hob.item.update";
@@ -65,7 +66,7 @@ interface RouterState {
   /** 这一轮最后一次有动静的时间，看门狗用它判断“没响应” */
   lastEventAt: number;
   stallTimer?: NodeJS.Timeout;
-  /** 已经因为没响应被叫停：这一轮的错误不再写一条重复的 note */
+  /** 这一轮已经被叫停（没响应，或用户按了停止）：之后的报错不再写「回复失败」 */
   stalled: boolean;
   /** 记忆提供者换了：跑着的这一轮结束就释放会话，下一轮按新提供者重新打开 */
   releaseAfterTurn?: boolean;
@@ -78,6 +79,7 @@ interface RouterState {
   knowledgeNames?: string[];
   delegationReply?: string[];
   terminatingTools?: Set<string>;
+  desktop?: DesktopToolSession;
 }
 
 function readEntries(file: string): SessionEntry[] {
@@ -186,6 +188,7 @@ export function deriveItems(entries: SessionEntry[]): Item[] {
 
 export class RouterManager {
   private routers = new Map<string, RouterState>();
+  private itemCache = new Map<string, { manager?: SessionManager; version: string; result: ReturnType<typeof walk>; positions: Map<string, number>; assistantTimes: string[]; last?: { text: string; at: Iso } }>();
   private livePages = new Map<string, Map<string, { page: PageLive; timer?: NodeJS.Timeout; last: number }>>();
   private liveJson = new Map<string, string>();
 
@@ -250,6 +253,37 @@ export class RouterManager {
     return readEntries(this.store.routerFile(assistantId));
   }
 
+  private derived(assistantId: string) {
+    const manager = this.routers.get(assistantId)?.manager;
+    const file = this.store.routerFile(assistantId);
+    let version: string;
+    if (manager) version = String(manager.getEntryCount());
+    else {
+      try {
+        const stat = statSync(file);
+        version = `${stat.size}:${stat.mtimeMs}`;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        version = "missing";
+      }
+    }
+    const cached = this.itemCache.get(assistantId);
+    if (cached && cached.manager === manager && cached.version === version) return cached;
+    const result = walk(manager ? manager.getEntries() : readEntries(file));
+    const positions = new Map<string, number>();
+    const assistantTimes: string[] = [];
+    let last: { text: string; at: Iso } | undefined;
+    result.items.forEach((item, index) => {
+      positions.set(item.id, index);
+      if (item.kind === "assistant") assistantTimes.push(item.at);
+      if (item.kind === "assistant" || item.kind === "user" || item.kind === "note") last = { text: item.text, at: item.at };
+    });
+    assistantTimes.sort();
+    const next = { manager, version, result, positions, assistantTimes, last };
+    this.itemCache.set(assistantId, next);
+    return next;
+  }
+
   async ensure(assistantId: string): Promise<RouterState> {
     const assistant = this.assistant(assistantId);
     let state = this.routers.get(assistantId);
@@ -271,6 +305,10 @@ export class RouterManager {
     await this.runtime.models.get();
     const pick = conversationPick(this.runtime.settings.settings.models, assistant);
     state.knowledgeNames = (await boundKnowledge(this.runtime, assistant.id)).map((collection) => collection.name);
+    state.desktop = new DesktopToolSession(this.runtime, assistant.id, () => !!state.session?.model?.input.includes("image"), undefined, true);
+    const tools = [...buildRouterTools(this.runtime, assistant.id), ...state.desktop.tools().filter((tool) => tool.name.startsWith("browser_"))];
+    const desktop = this.runtime.desktop.view();
+    const enabled = desktop.enabled && !!desktop.url && desktop.tokenConfigured;
     const opened = await this.runtime.pi.open({
       file: this.store.routerFile(assistant.id),
       spillDir: join(dirname(this.store.routerFile(assistant.id)), "spill"),
@@ -280,19 +318,25 @@ export class RouterManager {
       memory: this.runtime.settings.memory().provider,
       systemPrompt: () => {
         const { timezone, aboutYou } = this.runtime.settings.settings.general;
+        const desktop = this.runtime.desktop.view();
         return buildSystemPrompt(this.store, assistant.id, {
           timezone,
           aboutYou,
           memory: this.runtime.settings.memory().provider,
+          searchEnabled: this.runtime.settings.settings.search.some((provider) => provider.enabled),
+          imageEnabled: this.runtime.settings.settings.image.source !== "off",
+          desktopEnabled: desktop.enabled && !!desktop.url && desktop.tokenConfigured,
+          publicDesktop: desktop.publicAssistants.includes(assistant.id),
           models: this.promptModels(assistant.id),
           skills: availableSkills(this.runtime.home, undefined, this.runtime.settings.settings.skills?.disabled, this.runtime.settings.memory().provider === "lore" ? this.runtime.pi.loreSkillPaths : []),
           assistantSkills: usableAssistantSkills(this.runtime.home, assistant.id),
+          assistantSkillsDir: resolve(this.runtime.home, "assistants", assistant.id, "skills"),
           thinkingChoice: this.runtime.settings.settings.models.thinkingChoice,
           knowledgeNames: state.knowledgeNames,
         });
       },
-      tools: buildRouterTools(this.runtime, assistant.id).map((tool) => tool.name),
-      customTools: buildRouterTools(this.runtime, assistant.id),
+      tools: tools.filter((tool) => enabled || !tool.name.startsWith("browser_")).map((tool) => tool.name),
+      customTools: tools,
     });
     state.session = opened.session;
     if (!state.knowledgeNames.length) refreshSystemPrompt(opened.session, opened.session.getActiveToolNames().filter((name) => name !== "search_knowledge"));
@@ -304,8 +348,10 @@ export class RouterManager {
 
   private async refreshTools(state: RouterState): Promise<void> {
     state.knowledgeNames = (await boundKnowledge(this.runtime, state.assistantId)).map((collection) => collection.name);
-    const names = state.session!.getActiveToolNames().filter((name) => name !== "search_knowledge");
+    const names = state.session!.getActiveToolNames().filter((name) => name !== "search_knowledge" && !name.startsWith("browser_"));
     if (state.knowledgeNames.length) names.push("search_knowledge");
+    const desktop = this.runtime.desktop.view();
+    if (desktop.enabled && desktop.url && desktop.tokenConfigured) names.push(...state.desktop!.tools().filter((tool) => tool.name.startsWith("browser_")).map((tool) => tool.name));
     refreshSystemPrompt(state.session!, names);
   }
 
@@ -391,7 +437,7 @@ export class RouterManager {
     }
     if (event.type === "message_start" && event.message.role === "custom" && event.message.customType === EVENT_TYPE) {
       const details = event.message.details as EventDetails | undefined;
-      const users = deriveItems(this.entries(assistantId)).filter((item) => item.kind === "user");
+      const users = this.derived(assistantId).result.items.filter((item) => item.kind === "user");
       const source = details?.sourceUserId ? users.find((item) => item.id === details.sourceUserId) : undefined;
       state.currentUserId = (source ?? users.at(-1))?.id;
       if (details?.delegationId && details.delegationId !== state.currentDelegationId) {
@@ -470,7 +516,7 @@ export class RouterManager {
             at: new Date().toISOString(),
             text: "",
             streaming: true,
-            ...(walk(this.entries(assistantId)).lead ? { lead: true } : {}),
+            ...(this.derived(assistantId).result.lead ? { lead: true } : {}),
           },
         });
       }
@@ -501,7 +547,7 @@ export class RouterManager {
   }
 
   private emitSettledAssistant(assistantId: string, text: string, expectedId?: string): void {
-    const list = deriveItems(this.entries(assistantId)).filter((item) => item.kind === "assistant");
+    const list = this.derived(assistantId).result.items.filter((item) => item.kind === "assistant");
     const item = list.find((entry) => entry.id === expectedId) ?? list.filter((entry) => entry.text === text).pop();
     if (item) this.bus.emit({ type: "item", assistantId, item });
     this.touch(assistantId);
@@ -579,8 +625,11 @@ export class RouterManager {
     if (state.idleTimer) clearTimeout(state.idleTimer);
     state.idleTimer = undefined;
     state.session?.dispose();
+    void state.desktop?.dispose();
+    state.desktop = undefined;
     state.session = undefined;
     state.manager = undefined;
+    this.itemCache.delete(state.assistantId);
   }
 
   /**
@@ -596,6 +645,7 @@ export class RouterManager {
 
   /** 助手没了（归档）：关掉它的会话，内存里也不留 —— 它的目录随后会被移进归档。 */
   forget(assistantId: string): void {
+    this.itemCache.delete(assistantId);
     const state = this.routers.get(assistantId);
     if (!state) return;
     this.close(state);
@@ -617,7 +667,7 @@ export class RouterManager {
   // ---------- 事件与条目 ----------
   async addItem(assistantId: string, item: NewItem): Promise<Item> {
     const state = await this.ensure(assistantId);
-    const lead = walk(this.entries(assistantId)).lead;
+    const lead = this.derived(assistantId).result.lead;
     const id = state.manager!.appendCustomEntry(ITEM_TYPE, item);
     const full = { ...item, ...(lead ? { lead: true } : {}), id, at: this.entryAt(state, id) } as Item;
     this.bus.emit({ type: "item", assistantId, item: full });
@@ -631,7 +681,7 @@ export class RouterManager {
 
   async updateImage(assistantId: string, id: string, update: { status: "done" | "failed"; path?: string; error?: string }): Promise<void> {
     const state = await this.ensure(assistantId);
-    const item = deriveItems(this.entries(assistantId)).find((entry) => entry.id === id && entry.kind === "image");
+    const item = this.derived(assistantId).result.items.find((entry) => entry.id === id && entry.kind === "image");
     if (!item) throw new Error(`图片条目不存在：${id}`);
     state.manager!.appendCustomEntry(ITEM_UPDATE_TYPE, { id, ...update });
     this.bus.emit({ type: "item", assistantId, item: { ...item, ...update } });
@@ -646,7 +696,7 @@ export class RouterManager {
 
   /** 取当前回合来源及其之前的可见对话；事件取最近用户消息。 */
   originalWords(assistantId: string, note?: string, recent = false, extraFiles: string[] = []): { text: string; files: string[] } {
-    const items = deriveItems(this.entries(assistantId));
+    const items = this.derived(assistantId).result.items;
     const state = this.routers.get(assistantId);
     const source = items.find((item) => item.kind === "user" && item.id === state?.currentUserId)
       ?? items.findLast((item) => item.kind === "user");
@@ -742,7 +792,8 @@ export class RouterManager {
    */
   private async reportTurnError(state: RouterState): Promise<void> {
     const last = state.session?.messages.findLast((message) => message.role === "assistant");
-    if (!last || last.role !== "assistant" || last.stopReason !== "error") return;
+    // 停下的那一轮：有的服务商（Claude 订阅桥）把停止报成 error，不是回复失败
+    if (state.stalled || !last || last.role !== "assistant" || last.stopReason !== "error") return;
     await this.addItem(state.assistantId, { kind: "note", icon: "info", text: `回复失败：${briefModelError(last.errorMessage)}。发送任意消息即可重试。` });
   }
 
@@ -875,7 +926,10 @@ export class RouterManager {
 
   async stop(assistantId: string): Promise<void> {
     const state = this.routers.get(assistantId);
-    if (state) this.setActivity(state, null);
+    if (state) {
+      state.stalled = true;
+      this.setActivity(state, null);
+    }
     if (state?.session) await state.session.abort();
   }
 
@@ -907,14 +961,12 @@ export class RouterManager {
   }
 
   items(assistantId: string, options: { before?: string; limit?: number } = {}): ItemsPage {
-    const all = deriveItems(this.entries(assistantId));
+    const derived = this.derived(assistantId);
+    const all = derived.result.items;
     const limit = Math.max(1, Math.min(options.limit ?? 50, 200));
-    let list = all;
-    if (options.before) {
-      const index = all.findIndex((item) => item.id === options.before);
-      if (index !== -1) list = all.slice(0, index);
-    }
-    const page = list.slice(-limit);
+    const end = options.before ? derived.positions.get(options.before) ?? all.length : all.length;
+    const start = Math.max(0, end - limit);
+    const page = all.slice(start, end);
     const jobIds = new Set(page.filter((item) => item.kind === "job").map((item) => (item as { jobId: string }).jobId));
     const draftIds = new Set(
       page.filter((item) => item.kind === "draft").map((item) => (item as { draftId: string }).draftId),
@@ -928,15 +980,14 @@ export class RouterManager {
       for (const id of delegation.jobIds) jobIds.add(id);
       for (const id of delegation.approvalIds ?? []) approvalIds.add(id);
     }
-    for (const approval of this.store.approvals()) if (approval.jobId && jobIds.has(approval.jobId)) approvalIds.add(approval.id);
     return {
       ...(!options.before ? { pageLive: [...(this.livePages.get(assistantId)?.values() ?? [])].map((live) => live.page) } : {}),
       items: page,
       approvals: this.store.approvals().filter((approval) => approvalIds.has(approval.id)),
-      jobs: this.store.jobs().filter((job) => jobIds.has(job.id)),
+      jobs: [...jobIds].flatMap((id) => { const job = this.store.job(id); return job ? [job] : []; }),
       drafts: this.store.drafts().filter((draft) => draftIds.has(draft.id)),
       delegations,
-      hasMore: list.length > page.length,
+      hasMore: start > 0,
     };
   }
 
@@ -946,21 +997,23 @@ export class RouterManager {
 
   unread(assistantId: string): number {
     const readAt = this.store.state(assistantId).readAt;
-    if (!readAt) return 0;
-    return deriveItems(this.entries(assistantId)).filter(
-      (item) => item.kind === "assistant" && item.at > readAt,
-    ).length;
+    // 从没记过已读：从现在开始算，以前的都当读过。不记的话未读永远是 0，前端也就永远不会来标已读
+    if (!readAt) {
+      this.read(assistantId);
+      return 0;
+    }
+    const times = this.derived(assistantId).assistantTimes;
+    let lo = 0, hi = times.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (times[mid] <= readAt) lo = mid + 1;
+      else hi = mid;
+    }
+    return times.length - lo;
   }
 
   last(assistantId: string): { text: string; at: Iso } | undefined {
-    const items = deriveItems(this.entries(assistantId));
-    for (let i = items.length - 1; i >= 0; i -= 1) {
-      const item = items[i];
-      if (item.kind === "user" || item.kind === "assistant" || item.kind === "note") {
-        return { text: item.text, at: item.at };
-      }
-    }
-    return undefined;
+    return this.derived(assistantId).last;
   }
 
   summary(assistant: Assistant): AssistantSummary {
@@ -969,6 +1022,7 @@ export class RouterManager {
       ...assistant,
       ...(last ? { last } : {}),
       unread: this.unread(assistant.id),
+      ...(this.store.state(assistant.id).readAt ? { readAt: this.store.state(assistant.id).readAt } : {}),
       busy: this.isBusy(assistant.id),
       activity: this.routers.get(assistant.id)?.activity ?? null,
     };
@@ -992,7 +1046,7 @@ export class RouterManager {
         .jobs()
         .filter((job) => job.status === "running" || job.status === "queued" || job.status === "waiting" || (job.endedAt ?? job.createdAt) > jobCutoff),
       routines: this.store.routines(),
-      approvals: this.store.approvals().filter((approval) => approval.status === "pending"),
+      approvals: this.store.approvals().filter((approval) => approval.status === "pending" && approval.source !== "job"),
       delegations: this.store.delegations(),
       settings: this.runtime.settings.get(),
     };
@@ -1000,11 +1054,9 @@ export class RouterManager {
 
   /** 进程退出或测试收尾：释放所有 Router 会话。 */
   disposeAll(): void {
-    for (const state of this.routers.values()) {
-      if (state.idleTimer) clearTimeout(state.idleTimer);
-      state.session?.dispose();
-    }
+    for (const state of this.routers.values()) this.close(state);
     this.routers.clear();
+    this.itemCache.clear();
   }
 
   /** 直接走事件的 followUp 队列，实际收到这条消息时才开始关联任务。 */

package/server/src/routines.ts

@@ -2,7 +2,7 @@ import { Cron } from "croner";
 import type { Job, Routine } from "../../shared/types.ts";
 import type { HobRuntime } from "./runtime.ts";
 import { newId } from "./ids.ts";
-import { listAssistantSkills, usableAssistantSkills } from "./assistant-skills.ts";
+import { listAssistantSkills, skillInstruction, usableAssistantSkills } from "./assistant-skills.ts";
 
 export interface RoutineInput {
   assistantId: string;
@@ -58,7 +58,7 @@ export class RoutineScheduler {
 
   private instruction(routine: Routine): string {
     const skill = routine.skill && usableAssistantSkills(this.runtime.home, routine.assistantId).find((item) => item.name === routine.skill);
-    return skill ? `按技能「${skill.title}」做（先读它的 SKILL.md）。\n${routine.instruction}` : routine.instruction;
+    return skill ? skillInstruction(skill.title, routine.instruction) : routine.instruction;
   }
 
   private async fire(routineId: string): Promise<void> {

package/server/src/store.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, appendFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { newId } from "./ids.ts";
 import type {
   Approval,
   Assistant,
@@ -56,6 +57,25 @@ export class Store {
     for (const dir of ["assistants", "jobs", "uploads"]) {
       mkdirSync(join(this.home, dir), { recursive: true });
     }
+    if (!existsSync(join(this.home, "rules.json"))) {
+      const changedAt = new Date().toISOString();
+      this.saveGlobalRules([
+        ...["删除或覆盖文件、数据和备份", "对外发送（消息、邮件、发布）、付费、充值、改计费", "停止或重启别人正在使用的服务和设备", "修改可能让你失去远程访问的设置（网络、防火墙、登录方式）"].map((text) => ({ id: newId("r-"), text, mode: "ask" as const, changedAt })),
+        ...["过去的记录是线索不是现状：动手前先核实实际状态。", "改配置、改数据前先留好退路（备份或记下原值）；改完用实际效果验证，不只看命令返回。", "凭据（密码、密钥、令牌、Cookie）只在用的时候读取，不回显，不写进文件和报告，也不存起来。"].map((text) => ({ id: newId("r-"), text, mode: "allow" as const, changedAt })),
+      ]);
+    }
+  }
+
+  globalRules(): Rule[] {
+    const path = join(this.home, "rules.json");
+    if (!existsSync(path)) return [];
+    const rules = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    if (!Array.isArray(rules)) throw new Error("全局规则文件格式无效");
+    return rules as Rule[];
+  }
+
+  saveGlobalRules(rules: Rule[]): void {
+    writeJsonAtomic(join(this.home, "rules.json"), rules);
   }
 
   // ---------- 助手 ----------

package/server/src/worker-tools.ts

@@ -19,8 +19,8 @@ export function registerReportTool(runtime: HobRuntime, jobId: string): ToolDefi
       outcome: Type.Unsafe<"done" | "stuck" | "need_approval">(
         Type.String({ description: "done 做完 / stuck 做不下去（写明缺什么）/ need_approval 需要用户拍板" }),
       ),
-      result: Type.String({ description: "完整结果：结论、数据、链接、文件路径；写给派活的助手。" }),
-      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) => {
       // 不认识的结果不能当成已完成：退回让模型重新调用
@@ -46,7 +46,7 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
   return {
     name: "ask_user",
     label: "询问用户",
-    description: "在对话里出选择题卡片（2 到 3 个选项），等用户选，返回用户的选择。用于用户定的规则要求先确认的事，或发送、删除、付费这类撤不回的事。",
+    description: "问你的助手，等它回复：它会自己答，或者去问用户。用于用户定的规则要求先确认的事，或发送、删除、付费这类撤不回的事。其他拿不准的不问，按合理的假设做下去，把假设写进 result。",
     promptSnippet: "规则要求执行前确认的事，执行前必须调用 ask_user。",
     parameters: Type.Object({
       title: Type.String({ description: "问题，一句话" }),
@@ -57,27 +57,20 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
         }),
         { description: "2 到 3 个选项", minItems: 2, maxItems: 3 },
       ),
-      remember: Type.Optional(Type.String({ description: "同类事以后可以不再问时，填这类事的简称（如「清理临时目录」）；卡片会多一个「以后直接做」的选项。" })),
     }),
     execute: async (_id, params: any) => {
       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),
       }));
-      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,
-        ...(remember ? { ruleText: remember } : {}),
       });
       // 用户可能没选给出的选项，而是自己写了一段：answer 已经是回给模型的整句
       return ok(answer);

package/shared/skills.ts

@@ -15,6 +15,8 @@ export interface SkillsView {
   skills: SkillView[];
   loreActive: boolean;
   loreUrl: string | null;
+  /** Lore 目录没取到的原因；其他技能照常列出。 */
+  loreError?: string;
 }
 
 export interface ImportSkill {
@@ -42,7 +44,7 @@ export interface SkillImportResult {
  */
 export interface AssistantSkill {
   name: string; // 目录名：小写字母、数字、连字符
-  title: string; // 界面上显示的名字，如「网关每日巡检」
+  title: string; // 界面上显示的名字，如「每周周报」
   description: string; // 一句话：什么时候用
   path: string; // SKILL.md 的绝对路径（预览用）
   version: number; // 每次修补 +1，旧版在 skills/<name>/.history/<版本>/