hob-bot 1.1.0 → 1.2.0

package/dist/web/index.html

@@ -23,8 +23,8 @@
     <meta name="apple-mobile-web-app-title" content="Hob" />
     <meta name="apple-mobile-web-app-status-bar-style" content="default" />
     <title>Hob</title>
-    <script type="module" crossorigin src="/assets/index-B-8ISOr1.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Cu1Pf8yX.css">
+    <script type="module" crossorigin src="/assets/index-y09i1RGd.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Di5lyTHO.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hob-bot",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A self-hosted personal assistant that runs real work as background jobs.",
   "license": "MIT",
   "repository": {

package/server/src/assistant-skills.ts

@@ -46,6 +46,17 @@ function description(file: string): string {
   if (!line) throw new Error("技能说明缺失");
   return JSON.parse(line.slice("description: ".length));
 }
+export function readAssistantSkillBody(path: string): string {
+  const text = readFileSync(path, "utf8");
+  const end = text.indexOf("\n---\n");
+  if (!text.startsWith("---\n") || end < 0) throw new Error("技能 frontmatter 无效");
+  return text.slice(end + 5).replace(/^\n/, "");
+}
+
+export function skillInstruction(title: string, instruction: string): string {
+  return `按技能「${title}」做（先读它的 SKILL.md）。\n${instruction}`;
+}
+
 export function listAssistantSkills(home: string, assistantId: string): AssistantSkill[] {
   const dir = checkedDir(home, assistantId);
   return Object.entries(metadata(dir)).map(([name, data]) => {
@@ -72,8 +83,11 @@ export function readSkillFiles(cwd: string, files: unknown): SkillInput["files"]
   let root: string | undefined;
   return files.map((file) => {
     const { path, content, from } = (file ?? {}) as { path?: unknown; content?: unknown; from?: unknown };
-    if ((content === undefined) === (from === undefined)) throw new Error("附件要给 content 或 from，只给一个");
-    if (from === undefined) return { path, content } as { path: string; content: string };
+    // 有的模型会把每个字段都填上，没用的那个给空串：空串当没给
+    const hasFrom = from !== undefined && from !== "";
+    const hasContent = content !== undefined && !(hasFrom && content === "");
+    if (hasContent === hasFrom) throw new Error("附件要给 content 或 from，只给一个");
+    if (!hasFrom) return { path, content } as { path: string; content: string };
     if (typeof from !== "string" || !from.trim()) throw new Error("附件的 from 无效");
     let real: string;
     try { root ??= realpathSync(cwd); real = realpathSync(resolve(root, from)); }
@@ -86,7 +100,7 @@ export function readSkillFiles(cwd: string, files: unknown): SkillInput["files"]
     return { path, content: readFileSync(real, "utf8") } as { path: string; content: string };
   });
 }
-export function saveAssistantSkill(home: string, assistantId: string, input: SkillInput, jobId?: string, replaceFiles = false): AssistantSkill {
+export function saveAssistantSkill(home: string, assistantId: string, input: SkillInput, jobId?: string, replaceFiles = false, options?: { overwriteVersion?: boolean }): AssistantSkill {
   validName(input.name);
   if (typeof input.title !== "string" || !input.title.trim() || typeof input.description !== "string" || !input.description.trim() || [...input.description].length > 120 || typeof input.content !== "string") throw new Error("技能内容无效");
   const body = `---\nname: ${JSON.stringify(input.name)}\ndescription: ${JSON.stringify(input.description)}\nmetadata:\n  title: ${JSON.stringify(input.title)}\n---\n\n${input.content}`;
@@ -125,7 +139,7 @@ export function saveAssistantSkill(home: string, assistantId: string, input: Ski
     const parts = path.split("/");
     for (let i = 2; i < parts.length; i++) if (combined.has(parts.slice(0, i).join("/"))) throw new Error("附件路径冲突");
   }
-  if (old) {
+  if (old && !options?.overwriteVersion) {
     const history = join(target, ".history");
     mkdirSync(history, { recursive: true });
     const snapshot = join(history, String(old.version));
@@ -133,7 +147,7 @@ export function saveAssistantSkill(home: string, assistantId: string, input: Ski
     for (const entry of readdirSync(target)) if (entry !== ".history") cpSync(join(target, entry), join(snapshot, entry), { recursive: true });
     const versions = readdirSync(history).filter((n) => /^\d+$/.test(n)).map(Number).sort((a, b) => b - a);
     for (const version of versions.slice(5)) rmSync(join(history, String(version)), { recursive: true, force: true });
-  } else mkdirSync(target);
+  } else if (!old) mkdirSync(target);
   if (replaceFiles) for (const folder of ["scripts", "references"]) rmSync(join(target, folder), { recursive: true, force: true });
   writeFileSync(join(target, "SKILL.md"), body);
   for (const file of files) {
@@ -142,7 +156,7 @@ export function saveAssistantSkill(home: string, assistantId: string, input: Ski
     writeFileSync(dest, file.content);
   }
   const now = new Date().toISOString();
-  all[input.name] = { title: input.title, version: (old?.version ?? 0) + 1, createdAt: old?.createdAt ?? now, updatedAt: now, ...(jobId ? { fromJobId: jobId } : old?.fromJobId ? { fromJobId: old.fromJobId } : {}), uses: old?.uses ?? 0, ...(old?.lastUsedAt ? { lastUsedAt: old.lastUsedAt } : {}), enabled: old?.enabled ?? true };
+  all[input.name] = { title: input.title, version: old && options?.overwriteVersion ? old.version : (old?.version ?? 0) + 1, createdAt: old?.createdAt ?? now, updatedAt: now, ...(jobId ? { fromJobId: jobId } : old?.fromJobId ? { fromJobId: old.fromJobId } : {}), uses: old?.uses ?? 0, ...(old?.lastUsedAt ? { lastUsedAt: old.lastUsedAt } : {}), enabled: old?.enabled ?? true };
   saveMetadata(dir, all);
   return listAssistantSkills(home, assistantId).find((skill) => skill.name === input.name)!;
 }

package/server/src/job-view.ts

@@ -0,0 +1,52 @@
+import type { Approval, Job, JobStatus, JobStep } from "../../shared/types.ts";
+import type { AssistantSkill } from "../../shared/skills.ts";
+
+const statusText: Record<JobStatus, string> = { queued: "排队中", running: "进行中", waiting: "等用户确认", done: "已完成", stuck: "受阻", failed: "失败", stopped: "已停止" };
+
+export function duration(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  if (seconds < 60) return `${seconds} 秒`;
+  const minutes = Math.floor(seconds / 60);
+  return minutes < 60 ? `${minutes} 分钟` : `${Math.floor(minutes / 60)} 小时 ${minutes % 60} 分钟`;
+}
+
+/** 任务过程按时间倒序，供任务查看和超时通知共用。 */
+export function jobProcessLines(steps: JobStep[], timezone: string, now = new Date()): string[] {
+  const visible = steps.filter((step) => step.kind === "tool" || (step.kind === "text" && (step.from === "assistant" || step.from === "user")));
+  const format = new Intl.DateTimeFormat("sv-SE", { timeZone: timezone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hour12: false });
+  const today = format.format(now).slice(0, 10);
+  return visible.reverse().map((step) => {
+    const time = format.format(new Date(step.at));
+    const clock = time.slice(0, 10) === today ? time.slice(11) : time.slice(5);
+    const detail = step.kind === "tool"
+      ? `${step.title ?? step.name ?? "工具"}${step.running ? ` · 还在跑，${Math.max(0, Math.floor((now.getTime() - Date.parse(step.at)) / 60000))} 分钟` : ""}${step.isError ? " · 出错" : ""}`
+      : `${step.from === "user" ? "收到" : "说"}：${step.text ?? ""}`;
+    const line = `${clock} ${detail}`.replace(/\s+/g, " ").trim();
+    const chars = [...line];
+    return chars.length > 160 ? `${chars.slice(0, 159).join("")}…` : line;
+  });
+}
+
+export function jobView(job: Job, steps: JobStep[], approvals: Approval[], skills: AssistantSkill[], timezone: string, now = new Date()): string {
+  const ended = !["queued", "running", "waiting"].includes(job.status);
+  const elapsed = Math.max(0, now.getTime() - Date.parse(job.startedAt ?? job.createdAt));
+  const state = job.status === "queued" ? "排队中" : ended
+    ? `${statusText[job.status]}，用时 ${duration(job.durationMs ?? (job.endedAt ? Date.parse(job.endedAt) - Date.parse(job.startedAt ?? job.createdAt) : 0))}`
+    : `${statusText[job.status]}，已运行 ${elapsed < 60000 ? "不到 1 分钟" : `${Math.floor(elapsed / 60000)} 分钟`}`;
+  const lines = [`任务「${job.title}」（${job.id}）：${state}${job.rounds?.length ? `（第 ${job.rounds.length + 1} 轮）` : ""}`];
+  if (job.statusReason) lines.push(`原因：${job.statusReason}`);
+  for (const approval of approvals.filter((item) => item.jobId === job.id && item.status === "pending")) lines.push(`在等用户回答：${approval.title}`);
+  if (job.skillsUsed?.length) lines.push(`用到的技能：${job.skillsUsed.map((name) => { const skill = skills.find((item) => item.name === name); return skill ? `${skill.title}（第 ${skill.version} 版）` : name; }).join("、")}`);
+  if (ended) {
+    if (job.summary) {
+      const chars = [...job.summary];
+      lines.push(chars.length > 1000 ? `结果（共 ${chars.length} 字，全文：${job.reportPath ?? "无"}）：${chars.slice(0, 1000).join("")}` : `结果：${job.summary}`);
+    }
+    if (job.reportPath) lines.push(`报告：${job.reportPath}`);
+  }
+  if (job.rounds?.length) lines.push(`之前的轮次：${job.rounds.map((round, i) => `第 ${i + 1} 轮 ${statusText[round.status]}，用时 ${duration(round.durationMs ?? (round.startedAt && round.endedAt ? Date.parse(round.endedAt) - Date.parse(round.startedAt) : 0))}`).join("；")}`);
+  lines.push(`工作目录：${job.cwd ?? "未指定"}`);
+  const process = jobProcessLines(steps, timezone, now);
+  lines.push(`过程（新的在前，共 ${process.length} 步）：`, ...process);
+  return lines.join("\n");
+}

package/server/src/jobs.ts

@@ -22,6 +22,7 @@ import { imageConfigured } from "./image.ts";
 import { boundKnowledge, findKnowledgeTool, searchKnowledgeTool } from "./knowledge-tools.ts";
 import { MCP_SESSION_TOOLS, mcpEnabled, mcpServerDisplay } from "./mcp.ts";
 import { jobModel } from "./models.ts";
+import { duration, jobProcessLines } from "./job-view.ts";
 import { overviewTool } from "./overview.ts";
 import { pageTool } from "./pages.ts";
 import { pushApproval, pushJobEnd } from "./push.ts";
@@ -83,6 +84,7 @@ export interface StartJobInput {
   model?: string;
   thinking?: string;
   routineId?: string;
+  expectMinutes?: number;
   delegationId?: string;
 }
 
@@ -94,6 +96,9 @@ interface WorkerState {
   lastText?: string;
   askedFollowUp: boolean;
   lastActivityAt: number;
+  pausedMs: number;
+  pausedAt?: number;
+  nextReminder: number;
   finishTimer?: NodeJS.Timeout;
   ask?: (label: string) => void;
   /** 用户叫停了：收尾期间这个 worker 的 report/追问都不再算数 */
@@ -114,7 +119,9 @@ const EVENT_SUMMARY_MAX = 3000;
 export function jobResultEvent(job: Job, prefix = `任务「${job.title}」`): string {
   const status = job.status === "done" ? "已完成" : job.status === "stuck" ? "受阻" : job.status === "stopped" ? "已停止" : "失败";
   const result = job.summary;
-  const header = `${prefix}（${job.id}）${status}。`;
+  const header = job.expect && job.durationMs !== undefined
+    ? `${prefix}（${job.id}）${status}，用时 ${duration(job.durationMs)}，预计 ${job.expect.minutes} 分钟。`
+    : `${prefix}（${job.id}）${status}。`;
   if (!result) return `${header}\n${job.statusReason ?? "没有结果"}`;
   return result.length > EVENT_SUMMARY_MAX
     ? `${header}\n结果（共 ${result.length} 字，以下是前 3,000 字；全文：${job.reportPath}）：\n${result.slice(0, EVENT_SUMMARY_MAX)}`
@@ -231,6 +238,14 @@ export class JobManager {
       ...(hasImageFiles(input.files) ? { hasImages: true } : {}),
     });
     const id = this.nextJobId();
+    const durations = input.routineId ? (this.store.routine(input.routineId)?.runs ?? [])
+      .filter((run) => run.status === "done" && run.durationMs !== undefined && Number.isFinite(run.durationMs) && run.durationMs >= 0)
+      .slice(0, 5).map((run) => run.durationMs!).sort((a, b) => a - b) : [];
+    const middle = Math.floor(durations.length / 2);
+    const median = durations.length % 2 ? durations[middle] : (durations[middle - 1] + durations[middle]) / 2;
+    const expect: NonNullable<Job["expect"]> = input.routineId && durations.length
+      ? { minutes: Math.max(1, Math.ceil(median / 60_000)), source: "routine", runs: durations.length }
+      : input.expectMinutes !== undefined ? { minutes: input.expectMinutes, source: "assistant" } : { minutes: 10, source: "default" };
     const job: Job = {
       id,
       assistantId,
@@ -238,6 +253,7 @@ export class JobManager {
       title: input.title,
       instruction: input.instruction,
       status: "queued",
+      expect,
       createdAt: new Date().toISOString(),
       stats: { reads: 0, commands: 0, edits: 0 },
       activity: [],
@@ -353,6 +369,8 @@ export class JobManager {
       manager: opened.manager,
       askedFollowUp: false,
       lastActivityAt: Date.now(),
+      pausedMs: 0,
+      nextReminder: running.expect?.source === "routine" ? 1.5 : 1,
       steps: new Map(),
       readPaths: new Map(),
       queued: [],
@@ -740,7 +758,7 @@ export class JobManager {
       const usage = job.usage && previous.every((round) => round.usage) ? { input: job.usage.input - used.input, output: job.usage.output - used.output, cost: Number((job.usage.cost - used.cost).toFixed(6)) } : undefined;
       const ended: JobRound = { status: job.status, statusReason, startedAt: job.startedAt, endedAt, durationMs, summary, files, usage, reportPath: savedReport, followUp: text };
       const rounds = [...previous, ended];
-      const queued: Job = { ...rest, rounds, status: "queued", startedAt: new Date().toISOString() };
+      const queued: Job = { ...rest, rounds, status: "queued", expect: { minutes: 10, source: "default" }, startedAt: undefined };
       this.store.saveJob(queued);
       try {
         await this.runtime.router.addItem(job.assistantId, { kind: "job", jobId, round: rounds.length });
@@ -801,6 +819,7 @@ export class JobManager {
 
   private async sedimentRound(job: Job, state: { cancelled: boolean; session?: AgentSession }, source: "manual" | "auto"): Promise<void> {
     let calledSave = false;
+    const savedSkills = new Set<string>();
     let lastText = "";
     const skillTool = {
       name: "save_skill", label: "保存技能",
@@ -816,14 +835,18 @@ export class JobManager {
         calledSave = true;
         if (state.cancelled || this.store.job(job.id)?.status !== "done") throw new Error("任务已继续，取消沉淀");
         const files = readSkillFiles(job.cwd ?? this.store.workDir(job.id), params.files);
-        const skill = saveAssistantSkill(this.runtime.home, job.assistantId, { ...params, files }, job.id);
-        let text = skill.version === 1 ? `已沉淀技能「${skill.title}」` : `已更新技能「${skill.title}」· 第 ${skill.version} 版`;
-        const routine = job.routineId && this.store.routine(job.routineId);
-        if (routine && !routine.skill) {
-          this.runtime.routines.update(routine.id, { skill: skill.name });
-          text = `已沉淀技能「${skill.title}」，以后定时执行按它做`;
+        const overwriteVersion = savedSkills.has(params.name);
+        const skill = saveAssistantSkill(this.runtime.home, job.assistantId, { ...params, files }, job.id, false, { overwriteVersion });
+        savedSkills.add(skill.name);
+        if (!overwriteVersion) {
+          let text = skill.version === 1 ? `已沉淀技能「${skill.title}」` : `已更新技能「${skill.title}」· 第 ${skill.version} 版`;
+          const routine = job.routineId && this.store.routine(job.routineId);
+          if (routine && !routine.skill) {
+            this.runtime.routines.update(routine.id, { skill: skill.name });
+            text = `已沉淀技能「${skill.title}」，以后定时执行按它做`;
+          }
+          await this.runtime.router.addItem(job.assistantId, { kind: "note", icon: "skill", text, path: skill.path });
         }
-        await this.runtime.router.addItem(job.assistantId, { kind: "note", icon: "skill", text, path: skill.path });
         this.bus.emit({ type: "skills", assistantId: job.assistantId });
         return { content: [{ type: "text" as const, text: "技能已保存。" }], details: undefined };
       },
@@ -870,7 +893,7 @@ export class JobManager {
     } finally { opened.session.dispose(); }
   }
 
-  async stop(jobId: string): Promise<void> {
+  async stop(jobId: string, reason = "你叫停了"): Promise<void> {
     const job = this.store.job(jobId);
     if (!job) throw new Error("没有这个任务。");
     const worker = this.workers.get(jobId);
@@ -882,7 +905,7 @@ export class JobManager {
       // abort 会把正在执行的工具（bash 子进程）一起终止
       await worker.session?.abort().catch(() => undefined);
     }
-    await this.finish(jobId, "stopped", undefined, "你叫停了");
+    await this.finish(jobId, "stopped", undefined, reason);
   }
 
   /** Worker 的 ask_user：出审批卡、把任务标成待确认，阻塞到用户答复。 */
@@ -913,7 +936,7 @@ export class JobManager {
     const waiting: Job = { ...job, status: "waiting" };
     this.store.saveJob(waiting);
     this.bus.emit({ type: "job", job: waiting });
-    if (worker) worker.job = waiting;
+    if (worker) { worker.job = waiting; worker.pausedAt = Date.now(); }
     return await new Promise<string>((resolve) => {
       if (worker) worker.ask = resolve;
       else resolve("（任务未在运行）");
@@ -933,6 +956,8 @@ export class JobManager {
     worker?.ask?.(answer);
     if (worker) {
       worker.ask = undefined;
+      if (worker.pausedAt !== undefined) worker.pausedMs += Date.now() - worker.pausedAt;
+      worker.pausedAt = undefined;
       worker.lastActivityAt = Date.now();
     }
   }
@@ -949,6 +974,24 @@ export class JobManager {
   checkStalls(now = Date.now()): void {
     const idleMs = this.runtime.settings.settings.work.jobStallMinutes * 60_000;
     for (const [jobId, worker] of this.workers) {
+      const job = this.store.job(jobId);
+      if (job?.status === "running" && job.startedAt && job.expect && worker.pausedAt === undefined) {
+        const elapsed = Math.max(0, now - Date.parse(job.startedAt) - worker.pausedMs);
+        if (elapsed >= job.expect.minutes * 60_000 * worker.nextReminder) {
+          while (elapsed >= job.expect.minutes * 60_000 * worker.nextReminder) worker.nextReminder *= 2;
+          const source = job.expect.source === "assistant" ? "派活时估的" : job.expect.source === "routine" ? `这个定时任务以前 ${job.expect.runs} 次的中位数` : "默认 10 分钟";
+          const routine = job.routineId && this.store.routine(job.routineId);
+          const prefix = routine ? `定时任务「${routine.name}」` : `任务「${job.title}」`;
+          const steps = this.transcript(jobId);
+          for (const step of worker.steps.values()) {
+            const index = steps.findIndex((item) => item.id === step.id);
+            if (index >= 0) steps[index] = step; else steps.push(step);
+          }
+          const lines = jobProcessLines(steps, this.runtime.settings.settings.general.timezone, new Date(now)).slice(0, 10);
+          const text = `${prefix}（${job.id}）已运行 ${Math.floor(elapsed / 60_000)} 分钟，超过预计的 ${job.expect.minutes} 分钟（${source}）。\n最近的过程（新的在前）：${lines.length ? `\n${lines.join("\n")}` : ""}`;
+          void this.runtime.router.event(job.assistantId, text).catch((error) => console.error("任务超时通知失败：", error));
+        }
+      }
       // 在等用户答提问不算没响应：等多久都是用户的事
       if (!worker.ask && now - worker.lastActivityAt > idleMs) {
         void this.finish(jobId, "stuck", undefined, `${Math.round(idleMs / 60_000)} 分钟无响应`);

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")}`;
 }

package/server/src/prompt.ts

@@ -25,7 +25,8 @@ export interface PromptSettings {
   memory: MemoryProvider;
   models?: PromptModel[];
   skills?: { name: string; description: string }[];
-  assistantSkills?: { title: string; description: string }[];
+  assistantSkills?: { name: string; title: string; description: string; version: number; updatedAt: string }[];
+  assistantSkillsDir?: string;
   knowledgeNames?: string[];
   thinkingChoice?: "auto" | "fixed";
   abilities?: Abilities;
@@ -56,11 +57,15 @@ export function buildSystemPrompt(store: Store, assistantId: string, settings: P
   lines.push(
     "用简洁、规范的书面中文回复，先给结论。",
     "", "## 你手里有什么",
-    "你能直接看：文件和图片、任务的结果和产出、网页、记忆。",
-    "跑命令、改文件、操作设备这些动手的事在后台任务手里：任务在自己的会话和目录里做，做完把完整结果发回给你。",
-    "任务结束后还能接着做。一件事交给任务或其他助手后由它负责到底，跟进也交给它。",
+    "你能直接看：文件和图片、任务的过程和结果、产出、网页、记忆。",
+    "跑命令、改文件、操作设备这些动手的事交给后台任务。任务是你手上的活，在自己的会话和目录里做，做完把完整结果交给你；对用户负责的是你。",
+    "任务做完还能接着做，补充和纠正交给原来那个任务，它接得上之前的上下文。",
   );
-  if (settings.assistantSkills?.length) lines.push(`你沉淀过的技能：${settings.assistantSkills.map((skill) => `${skill.title}：${skill.description}`).join("、")}。派同类的活时在指令里写明按哪个技能做。`);
+  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));

package/server/src/router-activity.ts

@@ -8,6 +8,8 @@ export function activityLabel(name: string, args: Record<string, unknown> = {},
   switch (name) {
     case "read": label = withValue("正在读", basename(value("path"))); break;
     case "start_job": label = withValue("派任务", value("title")); break;
+    case "check_job": label = "看任务"; break;
+    case "edit_skill": label = "改技能"; break;
     case "reply_job": label = "补充任务要求"; break;
     case "stop_job": label = "停止任务"; break;
     case "ask_user": label = "准备问你"; break;

package/server/src/router-tools.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));

package/server/src/router.ts

@@ -287,6 +287,7 @@ export class RouterManager {
           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,
         });

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/shared/types.ts

@@ -380,6 +380,7 @@ 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 的完整结果
   reportPath?: string; // 完整报告