hob-bot 1.0.4 → 1.2.0

package/server/src/memory.ts

@@ -228,6 +228,11 @@ export async function testLoreConnection(
   return { ok: true, baseUrl: rawBase };
 }
 
+/** Hob 自带的 Lore 插件版本：vendor 里放的是 Lore 正式版，换版本用 `npm run update-lore -- <版本号>`。 */
+export const LORE_PLUGIN_VERSION: string = JSON.parse(
+  readFileSync(new URL("../../vendor/lore-pi-extension/package.json", import.meta.url), "utf8"),
+).version;
+
 /** 提示词里「记忆」一节的文案：按当前提供者给，关闭时整节不出。 */
 export function memoryPromptLines(provider: MemoryProvider): string[] {
   if (provider === "local") {
@@ -239,7 +244,7 @@ export function memoryPromptLines(provider: MemoryProvider): string[] {
   if (provider === "lore") {
     return [
       "## 记忆",
-      "你和用户是长期合作。涉及过去的偏好、决定和约定时，先在 Lore 里查；遇到值得长期记住的新事实，记进 Lore。",
+      "长期记忆在 Lore：过去的偏好、决定和约定先查 Lore；值得长期记住的新事实记进 Lore。读到的记忆和你刚核实的事实对不上（过时或有错），当场改对；整条已经不成立或没用了，就删掉。",
     ];
   }
   return [];
@@ -254,11 +259,11 @@ export const MEMORY_TOOL_PATTERNS: Record<MemoryProvider, string[]> = {
 
 /**
  * 会写记忆的工具：Router 调成功后在对话里出一行「记忆已更新 · …」。
- * 名字取自捆绑插件的实际注册（pi-memory 0.4.2 的 memory_write，Lore 1.12.4 的建/改节点）。
+ * 名字取自捆绑插件的实际注册（pi-memory 0.4.2 的 memory_write，Lore 插件的建/改节点）。
  */
 export const MEMORY_WRITE_TOOLS = new Set(["memory_write", "lore_create_node", "lore_update_node"]);
 
-/** note 里的摘要：写入内容的第一行，最多 30 个字。 */
+/** note 里的摘要：写入内容的第一行，最多 80 个字符。 */
 export function memoryNoteText(params: unknown): string | undefined {
   const record = isRecord(params) ? params : {};
   for (const key of ["content", "text", "title", "new_text", "old_text"]) {
@@ -266,7 +271,9 @@ export function memoryNoteText(params: unknown): string | undefined {
     if (typeof value !== "string") continue;
     const first = value.split("\n").map((line) => line.trim()).find((line) => line !== "");
     if (!first) continue;
-    return first.length > 30 ? `${first.slice(0, 30)}…` : first;
+    const chars = Array.from(first.replace(/[:：,，;；、]+\s*$/u, ""));
+    if (!chars.length) continue;
+    return chars.length > 80 ? `${chars.slice(0, 80).join("").replace(/[:：,，;；、]+\s*$/u, "")}…` : chars.join("");
   }
   return undefined;
 }

package/server/src/now.ts

@@ -0,0 +1,33 @@
+import type { HobRuntime } from "./runtime.ts";
+import { nowText } from "./time.ts";
+
+/** 每条 Router 消息附带的当前状态，不显示在对话里。 */
+export function nowBlock(runtime: HobRuntime, assistantId: string): string {
+  const now = new Date();
+  const timezone = runtime.settings.settings.general.timezone;
+  const clock = (value: string) => new Intl.DateTimeFormat("sv-SE", {
+    timeZone: timezone, hour: "2-digit", minute: "2-digit", hour12: false,
+  }).format(new Date(value));
+  const short = (value: string) => Array.from(value).length > 20 ? `${Array.from(value).slice(0, 20).join("")}…` : value;
+  const jobs = runtime.store.jobs().filter((job) => job.assistantId === assistantId);
+  const lines = [`【现在】${nowText(timezone, now)}`];
+  const active = jobs.filter((job) => ["running", "queued", "waiting"].includes(job.status)).map((job) => {
+    const minutes = job.startedAt ? Math.floor((now.getTime() - new Date(job.startedAt).getTime()) / 60_000) : 0;
+    const status = job.status === "queued" ? "排队中" : job.status === "waiting" ? "等用户确认" : minutes < 1 ? "刚开始" : `运行 ${minutes} 分钟`;
+    return `${job.id}「${short(job.title)}」，${status}`;
+  });
+  if (active.length) lines.push(`进行中：${active.join("；")}`);
+  if (assistantId === "hob") {
+    const delegations = runtime.store.delegations().filter((item) => item.from === assistantId && (item.status === "running" || item.status === "waiting"))
+      .map((item) => `${runtime.store.assistant(item.to)?.name ?? item.to}「${short(item.text)}」，${clock(item.createdAt)} 起`);
+    if (delegations.length) lines.push(`转交中：${delegations.join("；")}`);
+  }
+  const approvals = runtime.store.approvals().filter((item) => item.assistantId === assistantId && item.status === "pending").map((item) => item.title);
+  if (approvals.length) lines.push(`等用户选：${approvals.join("；")}`);
+  const names = { done: "已完成", stuck: "受阻", failed: "失败", stopped: "已停止" } as const;
+  const recent = jobs.filter((job) => job.endedAt && !job.routineId && job.status in names && new Date(job.endedAt).getTime() >= now.getTime() - 86_400_000 && new Date(job.endedAt).getTime() <= now.getTime())
+    .sort((a, b) => b.endedAt!.localeCompare(a.endedAt!)).slice(0, 5)
+    .map((job) => `${job.id}「${short(job.title)}」${clock(job.endedAt!)} ${names[job.status as keyof typeof names]}`);
+  if (recent.length) lines.push(`最近结束：${recent.join("；")}`);
+  return lines.join("\n");
+}

package/server/src/overview.ts

@@ -9,7 +9,7 @@ const LOG_LIMIT = 10;
 const STATUS_TEXT: Record<Job["status"], string> = {
   queued: "排队中",
   running: "进行中",
-  waiting: "待确认",
+  waiting: "等你确认",
   done: "已完成",
   stuck: "受阻",
   failed: "失败",
@@ -83,13 +83,13 @@ export function overviewText(runtime: HobRuntime, sinceHours = 24): string {
       for (const entry of log) lines.push(`- ${whenText(timezone, entry.at)} ${entry.text}`);
     }
     if (asks.length) {
-      lines.push("待确认：");
+      lines.push("等你确认：");
       for (const approval of asks) lines.push(`- ${approval.title}（${whenText(timezone, approval.createdAt)}）`);
     }
     blocks.push(lines.join("\n"));
   }
 
-  const head = `最近 ${hours} 小时（${whenText(timezone, since)} 之后）：${endedCount} 件结束的任务、${liveCount} 件进行中、${pending.length} 个待确认。`;
+  const head = `最近 ${hours} 小时（${whenText(timezone, since)} 之后）：${endedCount} 件结束的任务、${liveCount} 件进行中、${pending.length} 个等你确认。`;
   if (!blocks.length) return `${head}\n\n这段时间没有记录。`;
   return `${head}\n\n${blocks.join("\n\n")}`;
 }
@@ -100,7 +100,7 @@ export function overviewTool(runtime: HobRuntime): ToolDefinition<any, any> {
     name: "overview",
     label: "查看这段时间的记录",
     description:
-      "只读：列出各助手最近一段时间的工作日志、结束的任务（标题、结果、摘要前 100 字）、进行中的任务和待确认的审批。写早报、汇总“昨晚/今天都做了什么”之前先调用它，照实编写。",
+      "查各助手一段时间内的日志和任务，用于早报、日报，或回答「这段时间做了什么」。",
     promptSnippet: "写早报/汇总时用 overview 查看各助手这段时间的记录。",
     parameters: Type.Object({
       sinceHours: Type.Optional(Type.Integer({ description: "往回看多少小时，默认 24，最多 168" })),

package/server/src/pages.ts

@@ -45,7 +45,7 @@ export function pageTool(runtime: HobRuntime, assistantId: string, router: boole
         if (!title || !summary) throw new Error("标题和摘要不能为空。");
         const path = await renderPage(runtime.home, title, summary, String(params.html ?? ""));
         await runtime.router.addItem(assistantId, { kind: "file", path, name: title, meta: summary });
-        return { content: [{ type: "text" as const, text: `页面已展示：${path}${router ? "。本轮到此结束。" : ""}` }], details: { path }, ...(router ? { terminate: true } : {}) };
+        return { content: [{ type: "text" as const, text: `页面已展示：${path}` }], details: { path }, ...(router ? { terminate: true } : {}) };
       } catch (error) {
         return { content: [{ type: "text" as const, text: error instanceof Error ? error.message : String(error) }], details: undefined, isError: true };
       }

package/server/src/pi.ts

@@ -1,6 +1,8 @@
 import {
   createAgentSession,
   createExtensionRuntime,
+  createMcpExtension,
+  createToolSearchExtension,
   DefaultResourceLoader,
   ModelRuntime,
   SessionManager,
@@ -9,12 +11,13 @@ import {
   type ResourceLoader,
 } from "@earendil-works/pi-coding-agent";
 import type { Model, Provider } from "@earendil-works/pi-ai";
-import type { AgentSession, Skill, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { mkdirSync, readFileSync } from "node:fs";
+import type { AgentSession, ExtensionFactory, Skill, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import type { MemoryProvider } from "../../shared/types.ts";
+import type { ClaudeCodeSettings, MemoryProvider } from "../../shared/types.ts";
+import { claudeStatus } from "./claude-status.ts";
 import type { ThinkingLevel } from "./config.ts";
 import { MEMORY_TOOL_PATTERNS } from "./memory.ts";
 
@@ -39,9 +42,13 @@ export interface OpenSessionOptions {
   customTools: ToolDefinition<any, any>[];
   /** 这一轮用哪个记忆提供者：决定加载哪个捆绑插件（off = 两个都不加载） */
   memory?: MemoryProvider;
+  /** 任务会话加载 MCP 服务（引擎目录的 mcp.json）；对话会话不加载。 */
+  mcp?: boolean;
   /** 任务使用的技能；对话会话不加载。 */
   skills?: Skill[];
   disabledSkills?: string[];
+  /** Router 大结果落盘目录；任务不传。 */
+  spillDir?: string;
 }
 
 export interface OpenedSession {
@@ -53,8 +60,8 @@ export interface OpenedSession {
  * pi 的 AgentSession 在构建时就把系统提示词算进缓存，之后 ResourceLoader 现读 store 也用不上，
  * 所以要每轮开始前调一次：重设一遍当前工具集会让它按 loader 重算提示词，下一轮生效。
  */
-export function refreshSystemPrompt(session: AgentSession): void {
-  session.setActiveToolsByName(session.getActiveToolNames());
+export function refreshSystemPrompt(session: AgentSession, tools = session.getActiveToolNames()): void {
+  session.setActiveToolsByName(tools);
 }
 
 const requireFromHere = createRequire(import.meta.url);
@@ -100,7 +107,8 @@ function emptyLoader(systemPrompt: () => string): ResourceLoader {
 }
 
 /**
- * 记忆插件互斥断言 + 本地记忆的工具修剪。
+ * 记忆插件互斥断言 + 本地记忆的工具修剪。只看捆绑插件（additionalExtensionPaths）：
+ * 内联工厂（MCP、按需搜索）不是记忆插件，直接放行。
  *
  * 一次只加载一家的插件：万一哪天两条路径同时挂上，这里立刻报错，而不是把用户的记忆
  * 分裂成两份。pi-memory 没带 qmd，`memory_search` 只会报错，所以在注册前就去掉。
@@ -109,9 +117,11 @@ export function filterMemoryExtensions(
   result: LoadExtensionsResult,
   provider: MemoryProvider,
 ): LoadExtensionsResult {
-  if (result.extensions.length > 1) throw new Error("记忆插件互斥：一次只能加载一个记忆插件。");
+  const isInline = (extension: LoadExtensionsResult["extensions"][number]) => extension.path.startsWith("<inline:");
+  const bundled = result.extensions.filter((extension) => !isInline(extension));
+  if (bundled.length > 1) throw new Error("记忆插件互斥：一次只能加载一个记忆插件。");
   const families = new Set<MemoryProvider>();
-  for (const extension of result.extensions) {
+  for (const extension of bundled) {
     for (const name of extension.tools?.keys() ?? []) {
       if (PI_MEMORY_TOOLS.test(name)) families.add("local");
       else if (name.startsWith("lore_")) families.add("lore");
@@ -122,13 +132,13 @@ export function filterMemoryExtensions(
   if (provider === "off" ? loaded !== undefined : loaded !== provider) {
     throw new Error(`记忆插件与当前记忆来源不一致：期望 ${provider}，实际 ${loaded ?? "无"}。`);
   }
-  const extensions = result.extensions.map((extension) => {
+  const extensions = bundled.map((extension) => {
     if (!extension.tools?.has("memory_search")) return extension;
     const tools = new Map(extension.tools);
     tools.delete("memory_search");
     return { ...extension, tools };
   });
-  return { ...result, extensions };
+  return { ...result, extensions: [...result.extensions.filter(isInline), ...extensions] };
 }
 
 /**
@@ -143,6 +153,7 @@ export class PiHost {
   /** 服务商套进引擎（设 Key、注册兼容接口）；引擎建好、返回之前调一次。 */
   configure?: (runtime: ModelRuntime) => Promise<void>;
   private runtimePromise?: Promise<ModelRuntime>;
+  private claudeFactory?: ExtensionFactory;
   /** Lore 插件在 resources_discover 中注册的目录。 */
   loreSkillPaths: string[] = [];
 
@@ -167,6 +178,35 @@ export class PiHost {
     return this.runtimePromise;
   }
 
+  /** 会话尚未打开时先注册桥的模型目录，之后会话复用同一扩展模块。 */
+  async configureClaude(runtime: ModelRuntime, home: string, config: ClaudeCodeSettings | undefined): Promise<void> {
+    const status = config?.enabled ? await claudeStatus(home, config.executable || undefined) : undefined;
+    if (!config?.enabled || !status?.found || !status.loggedIn || !status.executable) {
+      this.claudeFactory = undefined;
+      runtime.unregisterProvider("claude-bridge");
+      return;
+    }
+    mkdirSync(this.engineDir, { recursive: true });
+    writeFileSync(join(this.engineDir, "claude-bridge.json"), JSON.stringify({
+      provider: { plan: config.plan, strictMcpConfig: true, autoMemoryEnabled: false, pathToClaudeCodeExecutable: status.executable },
+      askClaude: { enabled: false },
+    }, null, 2) + "\n", { mode: 0o600 });
+    const path = new URL("../../vendor/claude-bridge/src/index.ts", import.meta.url).href;
+    const factory = (await import(path)).default as ExtensionFactory;
+    const loader = new DefaultResourceLoader({
+      cwd: home, agentDir: this.engineDir, settingsManager: SettingsManager.inMemory(),
+      noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+      extensionFactories: [factory],
+    });
+    await loader.reload();
+    const loaded = loader.getExtensions();
+    if (loaded.errors.length) throw new Error(`Claude Code 扩展加载失败：${loaded.errors[0].error}`);
+    const registration = loaded.runtime.pendingProviderRegistrations.find((entry) => entry.name === "claude-bridge");
+    if (!registration) throw new Error("Claude Code 扩展未注册模型。");
+    runtime.registerProvider(registration.name, registration.config);
+    this.claudeFactory = factory;
+  }
+
   /** 设置页先于任何会话打开时，也通过插件自己的发现流程取得目录。 */
   async discoverLoreSkills(): Promise<void> {
     const pluginDir = dirname(bundledPluginEntry(MEMORY_PACKAGES.lore));
@@ -200,7 +240,7 @@ export class PiHost {
     settingsManager: SettingsManager,
   ): Promise<ResourceLoader> {
     const provider = options.memory ?? "off";
-    const pluginPath = provider === "off" ? undefined : bundledPluginEntry(MEMORY_PACKAGES[provider]);
+    const pluginPath = provider === "off" ? undefined : provider === "lore" ? fileURLToPath(new URL("./lore-entry.ts", import.meta.url)) : bundledPluginEntry(MEMORY_PACKAGES.local);
     if (provider === "local") {
       // 会话被频繁回收，退出总结只会白花一次模型调用（和参考产品一致）
       process.env.PI_MEMORY_EXIT_SUMMARY = "0";
@@ -215,6 +255,36 @@ export class PiHost {
       noThemes: true,
       noContextFiles: true,
       additionalExtensionPaths: pluginPath ? [pluginPath] : [],
+      // 任务会话的 MCP：读引擎目录的 mcp.json，会话启动（bindExtensions）时连服务。
+      // 按需搜索（deferred）的服务靠 tool_search 加载，codemode 不提供：不加载那个扩展。
+      extensionFactories: [
+        ...(this.claudeFactory ? [this.claudeFactory] : []),
+        ...(options.mcp ? [createMcpExtension(), createToolSearchExtension()] : []),
+        ...(options.spillDir ? [((pi) => {
+          pi.on("tool_result", async (event) => {
+            if (event.toolName === "read") return;
+            const full = event.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+            if (full.length <= 4000) return;
+            const dir = resolve(options.spillDir!);
+            const file = join(dir, `${event.toolCallId.replace(/[^a-zA-Z0-9_-]/g, "") || "tool"}.txt`);
+            try {
+              mkdirSync(dir, { recursive: true });
+              writeFileSync(file, full);
+            } catch (error) {
+              console.error(`工具结果落盘失败：${file}`, error);
+              return;
+            }
+            let first = true;
+            const content = event.content.flatMap<(typeof event.content)[number]>((block) => {
+              if (block.type !== "text") return [block];
+              if (!first) return [];
+              first = false;
+              return [{ type: "text" as const, text: `${full.slice(0, 4000)}\n\n（共 ${full.length} 字，这里是前 4,000 字；全文：${file}）` }];
+            });
+            return { content };
+          });
+        }) satisfies ExtensionFactory] : []),
+      ],
       extensionsOverride: (result) => filterMemoryExtensions(result, provider),
     });
     await base.reload();
@@ -225,10 +295,11 @@ export class PiHost {
       getSkills: () => {
         if (!options.skills) return { skills: [], diagnostics: [] };
         const discovered = base.getSkills();
+        const assistant = options.skills.filter((skill) => skill.sourceInfo.source === "assistant");
         const own = options.skills.filter((skill) => skill.sourceInfo.source === "hob");
-        const common = options.skills.filter((skill) => skill.sourceInfo.source !== "hob");
+        const common = options.skills.filter((skill) => skill.sourceInfo.source !== "assistant" && skill.sourceInfo.source !== "hob");
         const seen = new Set<string>();
-        const skills = [...own, ...discovered.skills, ...common].filter((skill) => {
+        const skills = [...assistant, ...own, ...discovered.skills, ...common].filter((skill) => {
           if (discovered.skills.includes(skill) && options.disabledSkills?.includes(`lore:${skill.name}`)) return false;
           if (seen.has(skill.name)) return false;
           seen.add(skill.name);
@@ -248,7 +319,10 @@ export class PiHost {
     mkdirSync(dirname(options.file), { recursive: true });
     const model = await this.model(options.model);
     const manager = SessionManager.open(options.file, dirname(options.file), options.cwd);
-    const settingsManager = SettingsManager.inMemory({ compaction: { enabled: true }, retry: { enabled: true } });
+    const modelOverrides = options.spillDir ? Object.fromEntries((await this.runtime()).getAllModels().filter((item) => "contextWindow" in item).map((item) => [
+      `${item.provider}/${item.id}`, { reserveTokens: Math.max(16_384, item.contextWindow - 100_000) },
+    ])) : undefined;
+    const settingsManager = SettingsManager.inMemory({ compaction: { enabled: true, ...(modelOverrides ? { modelOverrides } : {}) }, retry: { enabled: true } });
     const resourceLoader = await this.resourceLoader(options, settingsManager);
     const memoryTools = MEMORY_TOOL_PATTERNS[options.memory ?? "off"];
     const { session } = await createAgentSession({
@@ -263,10 +337,12 @@ export class PiHost {
       tools: [...options.tools, ...memoryTools],
       customTools: options.customTools,
     });
-    // resources_discover 由 bindExtensions 触发；仅注册技能目录，不加载对话层技能。
+    // resources_discover 由 bindExtensions 触发；Lore 注册技能目录，MCP 连服务（都在后台）
     if (options.memory === "lore") {
       this.loreSkillPaths = [];
       await session.bindExtensions({ mode: "print" });
+    } else if (options.mcp || this.claudeFactory) {
+      await session.bindExtensions({ mode: "print" });
     }
     return { session, manager };
   }

package/server/src/prompt.ts

@@ -1,128 +1,83 @@
 import { homedir } from "node:os";
-import { PROP_IDS, PROPS } from "../../shared/sprites.ts";
 import type { GeneralSettings, MemoryProvider, ThinkingLevel } from "../../shared/types.ts";
 import type { Store } from "./store.ts";
 import { cronToChinese } from "./cron-text.ts";
 import { memoryPromptLines } from "./memory.ts";
-import { nowText } from "./time.ts";
 
-/** 提示词里列的模型：助手能派其中一个。 */
 export interface PromptModel {
   name: string;
   ref: string;
-  note: string; // 用途说明
-  thinking: ThinkingLevel; // 默认思考档
-  levels?: ThinkingLevel[]; // 模型可用的思考档
-  isDefault: boolean; // 不指定模型时用它
+  note: string;
+  thinking: ThinkingLevel;
+  levels?: ThinkingLevel[];
+  isDefault: boolean;
 }
 
-/** 派出去的活能做什么（助手设置 → 能力）。 */
 export interface Abilities {
   exec: boolean;
   write: boolean;
   image: boolean;
 }
 
-/** 提示词里要用的设置：时区、「关于你」、记忆提供者、模型、能力。 */
 export interface PromptSettings {
   timezone: string;
   aboutYou: GeneralSettings["aboutYou"];
   memory: MemoryProvider;
-  /** 这个助手能派的模型（Router 用） */
   models?: PromptModel[];
   skills?: { name: string; description: string }[];
+  assistantSkills?: { name: string; title: string; description: string; version: number; updatedAt: string }[];
+  assistantSkillsDir?: string;
+  knowledgeNames?: string[];
   thinkingChoice?: "auto" | "fixed";
-  /** 任务能做什么（Worker 用） */
   abilities?: Abilities;
 }
 
-/** 「关于你」一节：三行里有哪行填了才出哪行，全空就整节不出。 */
-function aboutLines(aboutYou: GeneralSettings["aboutYou"]): string[] {
+function aboutSection(aboutYou: GeneralSettings["aboutYou"]): string[] {
   const lines: string[] = [];
   if (aboutYou.name) lines.push(`- 称呼：${aboutYou.name}`);
   if (aboutYou.language) lines.push(`- 语言：${aboutYou.language}`);
   if (aboutYou.notes) lines.push(`- 其他：${aboutYou.notes}`);
-  return lines;
-}
-
-function aboutSection(aboutYou: GeneralSettings["aboutYou"]): string[] {
-  const lines = aboutLines(aboutYou);
-  return lines.length ? ["", "## 关于用户", ...lines] : [];
-}
-
-/** 「可以派的模型」：只有一个时整节只一行。 */
-function modelsSection(models: PromptModel[], fixed: boolean): string[] {
-  if (!models.length) return [];
-  const lines = ["", "## 可以派的模型", "聪明、成本、速度都是 0–100：越高越聪明、越贵、越快。按任务难度、可接受的花费和要多快来挑；简单的活别派给又贵又慢的模型。"];
-  if (fixed) {
-    for (const model of models) {
-      lines.push(`- ${model.ref}${model.isDefault ? "（默认）" : ""}${model.note ? ` · ${model.note}` : ""} · 思考档 ${model.thinking}`);
-    }
-    if (models.length > 1) lines.push("按任务难度和类型选择：start_job 的 model 填括号里的 ref；不确定就不填，使用默认值。");
-    return lines;
-  }
-  if (models.length === 1) {
-    const only = models[0];
-    lines.push(
-      `- ${only.ref}${only.isDefault ? "（默认）" : ""}${only.note ? ` · ${only.note}` : ""} · 思考档默认 ${only.thinking}，可选 ${(only.levels ?? [only.thinking]).join("、")}：start_job 不用填 model，需要更强推理时填 thinking。`,
-    );
-    return lines;
-  }
-  for (const model of models) {
-    lines.push(
-      `- ${model.ref}${model.isDefault ? "（默认）" : ""}${model.note ? ` · ${model.note}` : ""} · 思考档默认 ${model.thinking}，可选 ${(model.levels ?? [model.thinking]).join("、")}`,
-    );
-  }
-  lines.push("按任务难度和类型选择：start_job 的 model 填括号里的 ref，thinking 按需要填；不确定就不填，使用默认值。");
-  return lines;
+  return lines.length ? ["", "## 用户", ...lines] : [];
 }
 
-/** 「你能做什么」：把助手开关关掉的能力明确写成不能做。 */
-function abilitiesSection(abilities: Abilities): string[] {
-  const can: string[] = ["读文件（read、grep、find、ls）"];
-  const cannot: string[] = [];
-  (abilities.exec ? can : cannot).push("执行命令（bash）");
-  (abilities.write ? can : cannot).push("改文件（edit、write）");
-  (abilities.image ? can : cannot).push("生图（generate_image）");
-  const lines = ["", "## 你能做什么", `- 能做：${can.join("、")}`];
-  if (cannot.length) {
-    lines.push(`- 不能做：${cannot.join("、")}。确需该能力时用 report(stuck) 说明缺少什么，不要勉强完成。`);
-  }
-  return lines;
-}
-
-/** Router 的系统提示词：每轮现读 store，所以改了规矩/补充说明下一轮就生效。 */
 export function buildSystemPrompt(store: Store, assistantId: string, settings: PromptSettings): string {
   const assistant = store.assistant(assistantId);
   if (!assistant) throw new Error(`助手不存在：${assistantId}`);
   const rules = store.rules(assistantId);
   const routines = store.routines().filter((routine) => routine.assistantId === assistantId);
   const others = store.assistants().filter((item) => item.id !== assistantId && !item.hidden);
-
-  const lines: string[] = [
-    `你是「${assistant.name}」，用户的${assistant.primary ? "主助手" : "助手"}。`,
-    `职责：${assistant.duty}`,
+  const lines = assistant.primary ? [
+    `你是「${assistant.name}」，用户的主助手。`,
+    "你和用户在一对一的对话里合作，用户的每条消息都是对你说的。",
+  ] : [
+    `你是「${assistant.name}」，用户的助手，负责${assistant.duty}。`,
     ...(assistant.dutyLong?.trim() ? [`详细职责：${assistant.dutyLong.trim()}`] : []),
-    `现在时间：${nowText(settings.timezone)}`,
+    "你和用户在一对一的对话里合作。主助手 Hob 会把归你管的事转给你：转来的消息带着用户的原话，等同用户本人的要求，结果会自动回到 Hob。",
   ];
-
-  lines.push(...aboutSection(settings.aboutYou));
-  lines.push(...modelsSection(settings.models ?? [], settings.thinkingChoice === "fixed"));
-  if (settings.skills?.length) {
-    lines.push("", "## 任务可用的技能", ...settings.skills.map((skill) => `- ${skill.name}：${skill.description}`));
+  lines.push(
+    "用简洁、规范的书面中文回复，先给结论。",
+    "", "## 你手里有什么",
+    "你能直接看：文件和图片、任务的过程和结果、产出、网页、记忆。",
+    "跑命令、改文件、操作设备这些动手的事交给后台任务。任务是你手上的活，在自己的会话和目录里做，做完把完整结果交给你；对用户负责的是你。",
+    "任务做完还能接着做，补充和纠正交给原来那个任务，它接得上之前的上下文。",
+  );
+  if (settings.assistantSkills?.length) {
+    lines.push(`你的技能是做同类事的做法，派活时可以让任务照着做。文件在 ${settings.assistantSkillsDir}/<名字>/SKILL.md：`);
+    const format = new Intl.DateTimeFormat("sv-SE", { timeZone: settings.timezone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hour12: false });
+    for (const skill of settings.assistantSkills) lines.push(`- ${skill.name}「${skill.title}」· 第 ${skill.version} 版 · ${format.format(new Date(skill.updatedAt)).slice(5)} 更新：${skill.description}`);
   }
-
+  if (settings.knowledgeNames?.length) lines.push(`能查的知识库：${settings.knowledgeNames.join("、")}。问到可能写在这些库里的内容，先用 search_knowledge 查。`);
+  if (settings.skills?.length) lines.push(`任务能用的技能：${settings.skills.map((skill) => skill.name).join("、")}`);
+  lines.push(...aboutSection(settings.aboutYou));
   if (rules.length) {
-    lines.push("", "## 你的规则");
+    lines.push("", "## 用户定的规则");
     for (const rule of rules) lines.push(`- ${rule.mode === "ask" ? "执行前确认" : "直接执行"}：${rule.text}`);
   }
-  if (assistant.instructions.trim()) {
-    lines.push("", "## 补充说明", assistant.instructions.trim());
-  }
+  if (assistant.instructions.trim()) lines.push("", "## 补充说明", assistant.instructions.trim());
   const memory = memoryPromptLines(settings.memory);
   if (memory.length) lines.push("", ...memory);
   if (routines.length) {
-    lines.push("", "## 你的定时");
+    lines.push("", "## 定时");
     for (const routine of routines) {
       const when = routine.schedules.map(cronToChinese).join("、");
       lines.push(`- ${routine.name} · ${when}${routine.active ? "" : "（暂停）"}：${routine.instruction}`);
@@ -130,100 +85,40 @@ export function buildSystemPrompt(store: Store, assistantId: string, settings: P
   }
   if (assistant.primary && others.length) {
     lines.push("", "## 其他助手");
-    for (const other of others) {
-      const ask = store.rules(other.id).filter((rule) => rule.mode === "ask").map((rule) => rule.text);
-      lines.push(`- ${other.name}（${other.id}）：${other.duty}${other.dutyLong?.trim() ? `。详细职责：${other.dutyLong.trim()}` : ""}${ask.length ? `。执行前要确认：${ask.join("；")}` : ""}`);
-    }
-    lines.push("转交前先对照详细职责挑最合适的助手；没有合适的就自己派任务，或者提议创建新助手。");
-  }
-
-  if (!assistant.primary) {
-    lines.push("", "## 转来的事", "带「转自 Hob」的消息是主助手替用户转来的，等同于用户本人的要求：照着去做，需要执行就直接 start_job，不要只回复计划；做完不用另外给 Hob 发消息，结果会自动回到 Hob。", "", "## 不归你管的事", "主助手 Hob 负责在各助手之间分派。用户的要求明显超出你的职责时，调用 hand_back_to_hob 交回 Hob，不要硬做；在你职责内的事照常自己做。");
-  }
-
-  lines.push(
-    "",
-    "## 工作方式",
-    "- 说要做的事，就在同一条消息里调用对应工具去做；不要只描述计划然后停下等用户催。只有规则要求确认或操作不可逆时才停下来问。",
-    "- 用简洁、规范的书面中文回复，直接给出结论，不要复述步骤、不要罗列清单。",
-    "- 你不能亲自执行任何操作：没有 bash、read、edit、write 这些工具（联网搜索除外）。需要执行任务时调用 start_job 交给后台任务，任务完成后会有事件回到这里。",
-    "- 需要最新信息或核对事实时，直接用 web_search / web_fetch 查，不必为此派任务；要多步调研、写文件或跑命令时再用 start_job。",
-    "- 任务本身就是带完整工具的编码 agent：写代码、改项目、查文件都是普通任务，用 start_job 的 cwd 指定任务的工作目录。",
-    "- 只有规则标为「执行前确认」，或者操作不可逆（发送、删除、付费）时，才用 ask_user 请用户确认。",
-    "- 会产生卡片的工具（start_job、ask_user、propose_assistant）：先在同一条消息里写一句话（要做什么、等用户确认什么），再调用工具。这些工具会返回“本轮到此结束”：卡片已经出现在对话里，内容齐全，调用完立即结束这一轮，不要再补任何文字（“草稿卡在上面了”“点创建就成”这类话都是重复的废话）。",
-    "- 用 ask_user 时，如果同类操作以后很可能还会遇到（日常的常规操作；发布、删除、付费这类不可逆的事除外），第三个选项写“以后同类操作直接执行，无需确认”（always），并填一句很短的 ruleText，如“清理临时目录”。",
-    "- 用户说“以后”“别再”这类要求时，用 set_rule 记入规则，不要只做口头承诺。",
-    ...(assistant.primary
-      ? [
-          "- 用户要早报、日报，或者问“昨晚/今天都做了什么”时，先调 overview 看各助手这段时间的日志和任务，再照实写一两句汇总，不要凭印象编造。",
-        ]
-      : []),
-  );
-
-  if (assistant.primary) {
-    lines.push(
-      "- 同类任务在对话中反复出现（同一件事被要求 3 次以上），就用 propose_assistant 提议创建专属助手。",
-      "- propose_assistant 的 duty 是左栏头像下面那行小字：最多 8 个字，如「线上和机器」「模型和 agent」；更详细的职责写在 dutyLong（草稿卡里的「职责」行）。",
-      `- propose_assistant 的 sprite 按职责选：${PROP_IDS.filter((id) => id !== "hob")
-        .map((id) => `${id} ${PROPS[id].label}`)
-        .join("，")}；hob 那个火苗是主助手专用的，不要用。`,
-      "- 库里没有贴合职责的道具时，可以自己画一件：sprite 填 custom，prop_art 给出 art、pal、dx 画一件 16×16 的像素道具；画得不合适会返回原因，照着改好重发就行。",
-      "- 有更合适的助手时用 message_assistant 把任务转过去。",
-      "- 转交时把用户原话转过去，只补充对方需要的背景。不要替用户加验收标准、测试方案或额外要求，把小事写成大工程。",
-      "- 转交出去的事由对方负责到底。结果回来之前，不要自己 start_job 做同一件事。结果回来后如果没办完，转回同一个助手接着办，或者如实告诉用户。",
-    );
+    for (const other of others) lines.push(`- ${other.name}（${other.id}）：${other.duty}。${other.dutyLong?.trim() ?? ""}`);
   }
-  lines.push("- 用户问你在做什么、有什么在运行，可依据任务事件回答，不要编造进度。");
-  lines.push(
-    "- 最后重申：start_job、ask_user、propose_assistant 返回“本轮到此结束”后，你说的下一个字都是多余的，直接结束回合。",
-  );
   return lines.join("\n");
 }
 
-/** Worker 的系统提示词：所属助手、要问的事、补充说明、任务说明、必须 report 收尾。 */
 export function buildWorkerPrompt(store: Store, jobId: string, settings: PromptSettings): string {
   const job = store.job(jobId);
   if (!job) throw new Error(`任务不存在：${jobId}`);
   const assistant = store.assistant(job.assistantId);
+  const name = assistant?.name ?? job.assistantId;
   const askFirst = store.rules(job.assistantId).filter((rule) => rule.mode === "ask");
-  const lines: string[] = [
-    `你在后台执行「${assistant?.name ?? job.assistantId}」的任务。`,
-    `职责：${assistant?.duty ?? ""}`,
-    `现在时间：${nowText(settings.timezone)}`,
+  const lines = [
+    `你是「${name}」助手派出的后台任务，在自己的会话里把交给你的事做完。`,
+    `工作目录：${job.cwd ?? homedir()}。产出放在这里；读取不限目录。`,
+    `交给你的消息里有用户的原话、最近的对话、附件和「${name}」的备注。`,
+    `做完调用 report：result 写完整结果，包括结论、数据、链接和文件路径。它会交给「${name}」，由它告诉用户。`,
+    "之后用户可能还会找你补充、纠正或追问，这些都会发到这个会话里；接着做完，再调用 report。",
   ];
+  if (settings.knowledgeNames?.length) lines.push(`能查的知识库：${settings.knowledgeNames.join("、")}。问到可能写在这些库里的内容，先用 search_knowledge 查。`);
+  if (settings.abilities) {
+    const cannot = [
+      ...(!settings.abilities.exec ? ["执行命令（bash）"] : []),
+      ...(!settings.abilities.write ? ["改文件（edit、write）"] : []),
+      ...(!settings.abilities.image ? ["生图（generate_image）"] : []),
+    ];
+    if (cannot.length) lines.push(`不能做：${cannot.join("、")}。`);
+  }
   lines.push(...aboutSection(settings.aboutYou));
-  if (settings.abilities) lines.push(...abilitiesSection(settings.abilities));
   if (askFirst.length) {
-    lines.push("", "## 这些事执行前必须用 ask_user 询问用户");
+    lines.push("", "## 这些事执行前用 ask_user 问用户");
     for (const rule of askFirst) lines.push(`- ${rule.text}`);
   }
-  if (assistant?.instructions.trim()) {
-    lines.push("", "## 补充说明", assistant.instructions.trim());
-  }
+  if (assistant?.instructions.trim()) lines.push("", "## 补充说明", assistant.instructions.trim());
   const memory = memoryPromptLines(settings.memory);
   if (memory.length) lines.push("", ...memory);
-  if (assistant?.primary) {
-    lines.push(
-      "",
-      "## 早报",
-      "- 用户要早报、日报或汇总“昨晚/今天都做了什么”时，先调 overview(sinceHours) 拿各助手这段时间的日志和任务，再照实写汇总。",
-    );
-  }
-  lines.push(
-    "",
-    `## 任务：${job.title}`,
-    job.instruction,
-    ...(job.inputs?.length ? ["", "## 你收到的文件", ...job.inputs.map((file) => `- ${file}`)] : []),
-    "",
-    `工作目录：${job.cwd ?? homedir()}`,
-    "",
-    "## 要求",
-    "- 产出文件只写在工作目录里：新建的文件、下载的内容、导出的结果都放在这个目录，不要写到用户主目录或其他位置。",
-    "- 读取不受目录限制：可读取任何位置的文件作参考，只是不要写入这些位置。",
-    "- 要给用户看的文件放进 report 的 files（绝对路径，文件本身在工作目录里）。",
-    "- 完成后必须调用 report 提交结果（outcome：已完成 / 受阻 / 待确认），不调用视为未完成。",
-    "- summary 用中文写给用户：一两句结论 + 关键数字，不要罗列过程。",
-    "- 受阻时调用 report(stuck) 说明受阻原因；要做不该做的、无法撤回的事就调用 ask_user。",
-  );
   return lines.join("\n");
 }