@downcity/agent 1.1.25 → 1.1.32

package/src/service/builtins/shell/runtime/ShellActionRuntimeSupport.ts

@@ -1,398 +0,0 @@
-/**
- * Shell action 运行时辅助能力。
- *
- * 关键点（中文）
- * - 统一承载 ShellActionRuntime 的内部共享逻辑：环境组装、持久化、waiter 协调、session 查找。
- * - 对外暴露给 ShellActionRuntime 的只有纯运行时辅助函数，不直接承担 service action 编排。
- */
-
-import path from "node:path";
-import fs from "fs-extra";
-import type { AgentContext } from "@/core/AgentContextTypes.js";
-import type {
-  ShellServiceState,
-  ShellSessionRuntimeState,
-} from "@/service/builtins/shell/ShellRuntimeTypes.js";
-import type {
-  ShellQueryRequest,
-  ShellSessionSnapshot,
-  ShellSessionStatus,
-} from "@/service/builtins/shell/types/ShellService.js";
-import { getShellOutputPath, getShellSnapshotPath } from "./Paths.js";
-import { resolveOwnerContextId } from "./ShellRuntimeEnvironment.js";
-export {
-  buildShellEnv,
-  resolveOwnerContextId,
-  resolveShellCwd,
-} from "./ShellRuntimeEnvironment.js";
-export {
-  buildActionResponse,
-  createOutputChunk,
-} from "./ShellActionResponse.js";
-
-const MAX_ACTIVE_SHELLS = 64;
-const SESSION_CLEANUP_DELAY_MS = 10 * 60 * 1000;
-const MAX_IN_MEMORY_OUTPUT_CHARS = 1_000_000;
-const MIN_WAIT_MS = 50;
-const MAX_WAIT_MS = 30_000;
-const OUTPUT_PREVIEW_CHARS = 280;
-
-/**
- * shell.start 默认内联等待时间。
- */
-export const DEFAULT_INLINE_WAIT_MS = 1_200;
-
-/**
- * shell.wait 默认等待超时。
- */
-export const DEFAULT_WAIT_TIMEOUT_MS = 10_000;
-
-/**
- * shell.exec 默认总超时。
- */
-export const DEFAULT_EXEC_TIMEOUT_MS = 60_000;
-
-/**
- * 创建 shell service 初始状态。
- */
-export function createShellServiceState(): ShellServiceState {
-  return {
-    sessions: new Map<string, ShellSessionRuntimeState>(),
-    boundRuntime: null,
-  };
-}
-
-/**
- * 返回当前毫秒时间戳。
- */
-export function nowMs(): number {
-  return Date.now();
-}
-
-/**
- * 归一化 wait/timeout 参数。
- */
-export function clampWaitMs(value: number | undefined, fallback: number): number {
-  const raw =
-    typeof value === "number" && Number.isFinite(value)
-      ? Math.floor(value)
-      : fallback;
-  return Math.min(MAX_WAIT_MS, Math.max(MIN_WAIT_MS, raw));
-}
-
-function normalizeOutputChunk(raw: string): string {
-  if (!raw) return "";
-  return raw
-    .replace(/\r\n/g, "\n")
-    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
-}
-
-function deriveExitStatus(exitCode: number | undefined): ShellSessionStatus {
-  if (exitCode === -9 || exitCode === 137) return "killed";
-  if (typeof exitCode === "number" && exitCode === 0) return "completed";
-  return "failed";
-}
-
-/**
- * 判断 shell 是否已进入终态。
- */
-export function isTerminalStatus(status: ShellSessionStatus): boolean {
-  return (
-    status === "completed" ||
-    status === "failed" ||
-    status === "killed" ||
-    status === "expired"
-  );
-}
-
-function extractExternalRefsFromText(
-  text: string,
-  current: ShellSessionSnapshot["externalRefs"],
-): ShellSessionSnapshot["externalRefs"] {
-  const next = [...current];
-  const register = (kind: string, value: string, label?: string): void => {
-    const normalized = String(value || "").trim();
-    if (!normalized) return;
-    if (next.some((item) => item.kind === kind && item.value === normalized)) return;
-    next.push({ kind, value: normalized, ...(label ? { label } : {}) });
-  };
-
-  const threadIdRegex = /thread_id[:=]\s*([a-zA-Z0-9_-]{6,})/g;
-  for (const match of text.matchAll(threadIdRegex)) {
-    register("thread_id", String(match[1] || ""), "external thread id");
-  }
-  return next;
-}
-
-/**
- * 持久化 shell snapshot。
- */
-export async function persistSnapshot(session: ShellSessionRuntimeState): Promise<void> {
-  await fs.ensureDir(path.dirname(session.snapshotFilePath));
-  await fs.writeJson(session.snapshotFilePath, session.snapshot, { spaces: 2 });
-}
-
-function enqueuePersistedAppend(
-  session: ShellSessionRuntimeState,
-  text: string,
-): Promise<void> {
-  session.writeChain = session.writeChain.then(async () => {
-    await fs.ensureDir(path.dirname(session.outputFilePath));
-    await fs.appendFile(session.outputFilePath, text, "utf-8");
-  });
-  return session.writeChain;
-}
-
-function notifyWaiters(session: ShellSessionRuntimeState): void {
-  for (const waiter of Array.from(session.waiters)) {
-    clearTimeout(waiter.timer);
-    session.waiters.delete(waiter);
-    waiter.resolve();
-  }
-}
-
-async function emitChatCompletionEvent(
-  context: AgentContext,
-  snapshot: ShellSessionSnapshot,
-): Promise<void> {
-  const ownerContextId = String(snapshot.ownerContextId || "").trim();
-  if (!ownerContextId || snapshot.notificationSent !== false) return;
-
-  const meta = await context.chat.readMetaBySessionId(ownerContextId);
-  if (!meta) return;
-
-  const lines = [
-    "[内部 shell 状态通知]",
-    `shell_id: ${snapshot.shellId}`,
-    `status: ${snapshot.status}`,
-    `exit_code: ${typeof snapshot.exitCode === "number" ? snapshot.exitCode : "null"}`,
-    `cmd: ${snapshot.cmd}`,
-  ];
-  if (snapshot.lastOutputPreview) {
-    lines.push(`last_output_preview: ${snapshot.lastOutputPreview}`);
-  }
-  if (snapshot.externalRefs.length > 0) {
-    const refs = snapshot.externalRefs.map((item) => `${item.kind}=${item.value}`);
-    lines.push(`external_refs: ${refs.join(", ")}`);
-  }
-  lines.push("请根据当前 shell 的状态，主动向用户简洁汇报结果或最新进展。");
-  const text = lines.join("\n");
-
-  await context.chat.appendExecSessionMessage({
-    sessionId: ownerContextId,
-    text,
-    extra: {
-      note: "shell_session_auto_notify",
-      internal: true,
-      shellId: snapshot.shellId,
-      shellStatus: snapshot.status,
-      exitCode:
-        typeof snapshot.exitCode === "number" ? snapshot.exitCode : null,
-    },
-  });
-
-  context.chat.enqueue({
-    kind: "exec",
-    channel: meta.channel,
-    targetId: meta.chatId,
-    sessionId: ownerContextId,
-    text,
-    ...(meta.targetType ? { targetType: meta.targetType } : {}),
-    ...(typeof meta.threadId === "number" ? { threadId: meta.threadId } : {}),
-    ...(meta.messageId ? { messageId: meta.messageId } : {}),
-    ...(meta.actorId ? { actorId: meta.actorId } : {}),
-    ...(meta.actorName ? { actorName: meta.actorName } : {}),
-    sessionPersisted: true,
-    extra: {
-      note: "shell_session_auto_notify",
-      internal: true,
-      shellId: snapshot.shellId,
-      shellStatus: snapshot.status,
-      exitCode:
-        typeof snapshot.exitCode === "number" ? snapshot.exitCode : null,
-    },
-  });
-}
-
-/**
- * 更新 session snapshot 并唤醒等待者。
- */
-export async function updateSessionSnapshot(
-  session: ShellSessionRuntimeState,
-  updater: (snapshot: ShellSessionSnapshot) => void | ShellSessionSnapshot,
-): Promise<void> {
-  const result = updater(session.snapshot);
-  if (result) {
-    session.snapshot = result;
-  }
-  session.snapshot.updatedAt = nowMs();
-  session.snapshot.version += 1;
-  await persistSnapshot(session);
-  notifyWaiters(session);
-}
-
-/**
- * 追加 shell 输出并同步更新快照。
- */
-export async function appendSessionOutput(
-  session: ShellSessionRuntimeState,
-  raw: string,
-): Promise<void> {
-  const text = normalizeOutputChunk(raw);
-  if (!text) return;
-
-  session.outputText += text;
-  if (session.outputText.length > MAX_IN_MEMORY_OUTPUT_CHARS) {
-    const overflow = session.outputText.length - MAX_IN_MEMORY_OUTPUT_CHARS;
-    session.outputText = session.outputText.slice(overflow);
-    session.snapshot.droppedChars += overflow;
-  }
-
-  session.snapshot.outputChars += text.length;
-  session.snapshot.lastOutputAt = nowMs();
-  session.snapshot.lastOutputPreview = session.outputText
-    .slice(-OUTPUT_PREVIEW_CHARS)
-    .trim();
-  session.snapshot.externalRefs = extractExternalRefsFromText(
-    text,
-    session.snapshot.externalRefs,
-  );
-  await enqueuePersistedAppend(session, text);
-  await updateSessionSnapshot(session, () => undefined);
-}
-
-/**
- * 为终态 shell 安排延迟清理。
- */
-export function scheduleCleanup(state: ShellServiceState, shellId: string): void {
-  const session = state.sessions.get(shellId);
-  if (!session) return;
-  if (session.cleanupTimer) clearTimeout(session.cleanupTimer);
-  session.cleanupTimer = setTimeout(() => {
-    const current = state.sessions.get(shellId);
-    if (!current) return;
-    state.sessions.delete(shellId);
-  }, SESSION_CLEANUP_DELAY_MS);
-  if (typeof session.cleanupTimer.unref === "function") {
-    session.cleanupTimer.unref();
-  }
-}
-
-/**
- * 控制 in-memory shell session 容量。
- */
-export function ensureCapacity(state: ShellServiceState): void {
-  if (state.sessions.size < MAX_ACTIVE_SHELLS) return;
-  const removable = Array.from(state.sessions.values())
-    .filter((item) => item.snapshot.status !== "running" && item.snapshot.status !== "starting")
-    .sort((a, b) => a.snapshot.updatedAt - b.snapshot.updatedAt);
-  for (const item of removable) {
-    if (state.sessions.size < MAX_ACTIVE_SHELLS) break;
-    state.sessions.delete(item.snapshot.shellId);
-  }
-  if (state.sessions.size >= MAX_ACTIVE_SHELLS) {
-    throw new Error(
-      `Too many active shell sessions (${state.sessions.size}). Please close or wait older sessions first.`,
-    );
-  }
-}
-
-async function loadPersistedSnapshot(
-  context: AgentContext,
-  shellId: string,
-): Promise<ShellSessionSnapshot | null> {
-  const file = getShellSnapshotPath(context.rootPath, shellId);
-  if (!(await fs.pathExists(file))) return null;
-  const raw = await fs.readJson(file).catch(() => null);
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const snapshot = raw as ShellSessionSnapshot;
-  return typeof snapshot.shellId === "string" ? snapshot : null;
-}
-
-async function readPersistedOutput(
-  context: AgentContext,
-  shellId: string,
-): Promise<string> {
-  const file = getShellOutputPath(context.rootPath, shellId);
-  if (!(await fs.pathExists(file))) return "";
-  return await fs.readFile(file, "utf-8");
-}
-
-/**
- * 按 shellId 或 ownerContext 解析目标 session。
- */
-export async function resolveSession(
-  state: ShellServiceState,
-  context: AgentContext,
-  query: ShellQueryRequest,
-): Promise<ShellSessionRuntimeState | { snapshot: ShellSessionSnapshot; outputText: string } | null> {
-  const explicitShellId = String(query.shellId || "").trim();
-  if (explicitShellId) {
-    const inMemory = state.sessions.get(explicitShellId);
-    if (inMemory) return inMemory;
-    const snapshot = await loadPersistedSnapshot(context, explicitShellId);
-    if (!snapshot) return null;
-    return {
-      snapshot,
-      outputText: await readPersistedOutput(context, explicitShellId),
-    };
-  }
-
-  const ownerContextId = resolveOwnerContextId(query.ownerContextId);
-  const cmd = String(query.cmd || "").trim().toLowerCase();
-  if (!ownerContextId) return null;
-  const includeCompleted = query.includeCompleted === true;
-  const matched = Array.from(state.sessions.values())
-    .filter((item) => {
-      if (item.snapshot.ownerContextId !== ownerContextId) return false;
-      if (!includeCompleted) {
-        if (
-          item.snapshot.status !== "running" &&
-          item.snapshot.status !== "starting"
-        ) {
-          return false;
-        }
-      }
-      if (!cmd) return true;
-      return item.snapshot.cmd.toLowerCase().includes(cmd);
-    })
-    .sort((a, b) => b.snapshot.updatedAt - a.snapshot.updatedAt);
-  return matched[0] || null;
-}
-
-/**
- * 判断解析出的 session 是否仍在内存中活动。
- */
-export function isInMemorySession(
-  value: ShellSessionRuntimeState | { snapshot: ShellSessionSnapshot; outputText: string },
-): value is ShellSessionRuntimeState {
-  return "child" in value;
-}
-
-/**
- * 处理 shell 退出后的状态收口。
- */
-export async function finalizeExit(
-  state: ShellServiceState,
-  session: ShellSessionRuntimeState,
-  exitCode: number,
-): Promise<void> {
-  await updateSessionSnapshot(session, (snapshot) => {
-    snapshot.status = deriveExitStatus(exitCode);
-    snapshot.exitCode = exitCode;
-    snapshot.endedAt = nowMs();
-    snapshot.pid = session.child.pid ?? snapshot.pid;
-  });
-  session.resolveCompletion();
-  scheduleCleanup(state, session.snapshot.shellId);
-
-  if (
-    session.snapshot.autoNotifyOnExit &&
-    session.snapshot.notificationSent === false &&
-    state.boundRuntime
-  ) {
-    await emitChatCompletionEvent(state.boundRuntime, session.snapshot);
-    session.snapshot.notificationSent = true;
-    await persistSnapshot(session);
-  }
-}

package/src/service/builtins/shell/runtime/ShellProcessEvents.ts

@@ -1,65 +0,0 @@
-/**
- * Shell 子进程事件绑定辅助。
- *
- * 关键点（中文）
- * - 集中处理 stdout/stderr 追加、process error 与 close 事件。
- * - close 到达时先等待输出写入链 drain，再统一进入终态收口，避免尾部输出丢读。
- */
-
-import type { ShellServiceState, ShellSessionRuntimeState } from "@/service/builtins/shell/ShellRuntimeTypes.js";
-import {
-  appendSessionOutput,
-  finalizeExit,
-} from "./ShellActionRuntimeSupport.js";
-
-async function finalizeExitAfterOutputDrain(
-  state: ShellServiceState,
-  session: ShellSessionRuntimeState,
-  exitCode: number,
-): Promise<void> {
-  // 关键点（中文）
-  // - `close` 事件到达时，stdout / stderr 的异步 append 链可能刚刚开始收尾。
-  // - 这里先让出一个事件循环 tick，再等待当前 writeChain，可显著降低“终态已到但尾部输出尚未可读”的竞态。
-  await new Promise<void>((resolve) => {
-    const timer = setImmediate(resolve);
-    if (typeof timer.unref === "function") timer.unref();
-  });
-  await session.writeChain.catch(() => undefined);
-  await finalizeExit(state, session, exitCode);
-}
-
-/**
- * 绑定 shell 子进程事件。
- */
-export function attachShellProcessEventHandlers(params: {
-  /**
-   * 当前 shell service 状态。
-   */
-  state: ShellServiceState;
-  /**
-   * 当前 shell runtime session。
-   */
-  session: ShellSessionRuntimeState;
-}): void {
-  const { state, session } = params;
-  const { child } = session;
-  child.stdout.on("data", (chunk: string | Buffer) => {
-    void appendSessionOutput(session, String(chunk ?? "")).catch(() => undefined);
-  });
-  child.stderr.on("data", (chunk: string | Buffer) => {
-    void appendSessionOutput(session, String(chunk ?? "")).catch(() => undefined);
-  });
-  child.on("error", (error: Error) => {
-    void appendSessionOutput(session, `\n[process error] ${String(error)}\n`).catch(
-      () => undefined,
-    );
-    void finalizeExitAfterOutputDrain(state, session, -1).catch(() => undefined);
-  });
-  child.on("close", (code: number | null) => {
-    void finalizeExitAfterOutputDrain(
-      state,
-      session,
-      typeof code === "number" ? code : -1,
-    ).catch(() => undefined);
-  });
-}

package/src/service/builtins/task/Index.ts

@@ -1,9 +0,0 @@
-/**
- * Task service 静态导出入口。
- *
- * 关键点（中文）
- * - Index 只保留导出职责，不再承载 task service 的具体实现。
- * - 真正的类实现收敛到 `TaskService.ts`。
- */
-
-export { TaskService } from "./TaskService.js";

package/src/service/builtins/task/PROMPT.ts

@@ -1,9 +0,0 @@
-/**
- * 自动生成文件，请勿手改。
- * 源文件：由同路径 `*.ts.txt` 生成。
- */
-
-// Source: src/service/builtins/task/PROMPT.ts.txt
-const TEXT_MODULE_CONTENT = "# Task Service\n\n你可以通过 `task` service 管理任务定义、执行、调度与状态控制。\n\n## 任务模型\n\n每个任务定义在 `./.downcity/task/<title>/task.md`，包含：\n- frontmatter（结构化字段）\n- body（任务正文）\n\nfrontmatter 核心字段：\n- `title`：任务唯一标识（唯一）\n- `description`：任务描述\n- `when`：触发条件，支持：`@manual` / cron / `time:<ISO8601-with-timezone>`\n- `sessionId`：任务执行会话\n- `status`：`enabled|paused|disabled`\n- `kind`：`agent|script`（默认 `agent`）\n\n执行时会产生 run 目录：\n- `./.downcity/task/<title>/<timestamp>/`\n\n常见产物：\n- `input.md`\n- `output.md`（本次任务的最终输出正文）\n- `result.md`（执行摘要）\n- `run.json`\n- `run-progress.json`\n- `dialogue.md` / `dialogue.json`（agent 多轮）\n- `error.md`（失败时）\n\n## 执行类型（kind）\n\n1. `kind=agent`\n- 将正文交给 agent 执行\n- 默认单轮完成；仅当 frontmatter 显式设置 `review: true` 时启用模拟用户多轮复核\n- 适合研究、分析、报告生成\n\n2. `kind=script`\n- 将正文当作 shell 脚本执行\n- 正文不能为空，必须是可执行脚本\n\n## 可用 action\n\n- `list`\n- `create`\n- `run`\n- `delete`\n- `update`\n- `status`\n- `enable`\n- `disable`\n\n## CLI 示例\n\n- `city task list [--status enabled|paused|disabled]`\n- `city task create --title '...' --description '...' --session-id <sessionId> [--when '@manual'] [--kind agent|script] [--status ...|--activate]`\n- `city task run <title> [--reason '...']`\n- `city task update <title> [--title ...] [--description ...] [--when ...] [--status ...|--activate] [--session-id ...]`\n- `city task delete <title>`\n\n## 关键约束\n\n- `title` 唯一；create 去重仅按 `title` 精确匹配。\n- `when=time:...` 触发后会自动置为 `paused`，并回退为 `when=@manual`。\n- `run` 为异步受理：立即返回 `accepted=true`、`message`、`executionId`；调用方应把它视为“任务已进入后台执行，结果会自动通过 chat service 发送，当前流程无需阻塞等待”。\n- 如果 `run` 返回 `accepted=true`：\n  - 不要手动把 task 产出再转发给用户。\n  - 不要主动读取 run 目录、`run-progress.json`、`output.md` 做轮询。\n  - 只有当用户明确要求排查、查看产物或确认执行细节时，才进入 run 目录检查。\n- agent 任务默认只要求产生有效输出；仅当任务正文明确要求外发时，才应发送到外部 channel。\n\n## 如何设计 task 正文\n\n### agent task 推荐结构\n\n建议正文至少包含这些标题：\n\n```md\n# 任务目标\n\n- 这次任务要交付什么最终结果\n\n# 背景与输入\n\n- 数据来源、范围、约束、参考材料\n\n# 执行步骤\n\n1. 先做什么\n2. 再做什么\n3. 关键中间产物落在哪里\n\n# 输出要求\n\n- 最终结果用什么格式返回\n- 是否需要表格 / JSON / Markdown\n- 不要包含什么内容\n\n# 触发与状态建议\n\n- 这个任务为什么适合 `@manual` / cron / `time:...`\n- 当前应该是 `paused` 还是 `enabled`\n\n# 注意事项\n\n- 风险、边界、不要做什么\n```\n\n### agent task 正文编写约束\n\n- task 正文必须像一份“交付合同”，让另一个执行器拿到后可以直接执行，不依赖当前聊天语境补全含义。\n- `# 任务目标` 必须写清楚最终要交付什么，不要只写“看一下”“研究一下”“处理一下”这类模糊目标。\n- `# 背景与输入` 必须写清来源、范围、对象、时间、限制条件；不要假设执行器还能看到原始聊天上下文。\n- `# 执行步骤` 应描述任务流程，不应描述 task 管理动作；不要写“先检查有没有同名任务”“再创建任务”“然后触发任务”。\n- `# 输出要求` 必须清楚声明最终成品的格式、结构、语气、长度，以及“不要输出什么”。\n- 要明确写出：**最后一条 assistant 返回会被直接写入 `output.md` 并发送给用户**；因此最终回答必须直接等于成品内容。\n- 内容生成类任务（如日报、提醒、晨读、摘要、报告）必须明确要求“最终输出直接是成品正文”，不要让执行器输出过程说明。\n- 如果任务要把结果发给用户，正文应要求“输出可直接发送的正文内容”，而不是要求执行器解释自己已经发送了什么。\n- 除非确有需要，不要在正文中要求执行器复述 task title、sessionId、执行时间、状态等元信息。\n- 正文中的约束要可执行、可判断，尽量避免“适当”“尽量”“看情况”这类弱约束词。\n- 不要把创建 task、更新 task、查看 task 状态、确认 task 是否存在等管理动作写进正文；这些属于 task service 的职责，不属于 task 正文交付物。\n\n### agent task 正文禁止写法\n\n- 不要把正文写成聊天回复口吻，例如：\n  - “我来为你……”\n  - “首先让我……”\n  - “我先检查一下……”\n  - “我看到已经有一个同名任务……”\n- 不要把正文写成任务管理说明，例如：\n  - “如果任务已存在则更新，否则创建”\n  - “先 list 再 run”\n  - “完成后告诉用户任务已启动”\n- 不要把正文写成状态汇报模板，例如：\n  - “任务状态总结”\n  - “已发送 / 已完成 / 已更新”\n  - “当前任务配置如下”\n- 不要只描述动作，不描述成品，例如：\n  - “去搜集一些资料”\n  - “生成一个内容看看”\n  - “做完后反馈结果”\n- 不要把正文写成依赖当前上下文的指代，例如：\n  - “按上面说的做”\n  - “继续刚才那个”\n  - “把这个发出去”\n\n### 如何判断正文写得对不对\n\n- 如果把 task 正文单独复制出来给另一个 agent，它仍然能理解任务目标、输入、步骤和交付物，说明正文合格。\n- 如果最终输出章节删掉后，正文只剩“去做一下”式描述，说明正文不合格。\n- 如果正文更像“创建/更新任务的操作说明”，而不是“任务执行说明”，说明分层错了，必须重写。\n- 如果正文天然会诱导执行器输出过程汇报，而不是最终成品，说明 `# 输出要求` 写得不够强，必须补充禁止项。\n\n### script task 推荐结构\n\n- 正文必须是纯 shell 脚本，不要混入解释性自然语言。\n- 开头尽量写注释说明脚本目的、输入依赖、失败条件。\n- 输出保持稳定，便于直接作为最终结果发送给用户。\n- 如需生成文件，写到 run 目录或明确的项目路径。\n\n### 输出设计原则\n\n- task 完成后，系统会自动把**最终结果正文**通过 chat service `send` 发回 `sessionId` 绑定的 chat。\n- 当前实现采用最简规则：**最后一条 assistant 返回**会被直接视为最终结果正文，并写入 `output.md`。\n- 因此正文里的“输出要求”要面向最终用户阅读，不要只写给开发者看。\n- 对于面向用户的 agent task，正文应要求“最后一条 assistant 返回直接输出最终交付物本身”，不要让执行器在最后回答里输出自己如何创建、检查、更新、触发或发送任务。\n- 如果任务是内容生成类（例如日报、提醒、晨读、摘要），最后输出应直接是那段内容本身，不要附带“我来为你处理”“任务已发送”“任务状态总结”等过程汇报。\n- 默认不要在正文里再次要求执行器调用 `city chat send`。\n- 只有在“跨会话发送”“额外抄送”“多渠道通知”这类场景下，才显式要求 `city chat send`。\n\n### `when` / `status` 怎么选\n\n- task 创建默认就是 `status=enabled`；如果还在试任务、容易失败、需要人工确认，再显式切到 `paused`。\n- 已经验证稳定、需要自动运行：直接使用 cron + `status=enabled`。\n- 明确只执行一次：使用 `time:<带时区 ISO 时间>`；执行后系统会自动回退到 `@manual` + `paused`。\n- 如果用户只是“先存起来以后再跑”，不要直接启用调度。\n\n## 正文模板\n\n### agent 模板\n\n```md\n# 任务目标\n\n- 产出一份可直接发给用户的最终结果。\n\n# 背景与输入\n\n- 在这里补充上下文、文件、链接、范围和假设。\n\n# 执行步骤\n\n1. 理解任务目标与完成标准。\n2. 收集必要信息并执行任务。\n3. 把关键中间产物写入 run 目录。\n4. 输出最终结果正文。\n\n# 输出要求\n\n- 最后一条 assistant 返回直接作为最终结果，不要附带冗长日志。\n- 最后一条 assistant 返回直接输出交付物本身，不要输出任务管理过程、发送过程或状态汇报。\n- 不要使用“我来为你…… / 首先让我…… / 已发送……”这类元话术。\n- 默认不要再次调用 `city chat send`。\n\n# 触发与状态建议\n\n- 默认创建后立即启用；如果只是先保存草稿或等待人工确认，再改成 `paused`。\n\n# 注意事项\n\n- 仅在明确需要跨会话或额外通知时，才调用 `city chat send`。\n```\n\n### script 模板\n\n```bash\n# 任务目标：一句话说明脚本要做什么\n# 输入依赖：列出环境变量、文件、命令依赖\n# 失败条件：列出应该 exit 1 的情况\n\nset -euo pipefail\n\n# 1. 准备输入\n\n# 2. 执行主逻辑\n\n# 3. 输出最终结果（这段输出会被直接发送给用户）\n```\n\n## 建议\n\n- 先 `list`，再 `create`/`update`。\n- 简单内容生成任务优先保持默认单轮；只有确实需要“先生成、再复核、再修订”时再设置 `review: true`。\n- script 任务正文保持纯脚本，不要混入冗余自然语言。\n- 如果用户只是先存起来以后再跑，创建后显式设成 `paused`；否则保持默认启用。\n- task 正文要写“最终结果长什么样”，不要只写“去做一下看看”。\n- 对内容生成任务，要明确写“最后一条 assistant 返回只能是成品正文”，避免执行器把过程说明误当成最终结果。\n";
-
-export default TEXT_MODULE_CONTENT;

package/src/service/builtins/task/TaskService.ts

@@ -1,167 +0,0 @@
-/**
- * TaskService：task service 的类实例实现。
- *
- * 关键点（中文）
- * - task 的长期运行态（cron engine）归属于 TaskService 实例。
- * - task 的 prompt、action input、action execution 都已拆到独立模块。
- * - 当前文件只保留实例骨架与 lifecycle，不再依赖旧的模块级 `taskService` 单例。
- */
-
-import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
-import { BaseService } from "@/service/builtins/BaseService.js";
-import type { ServiceActions } from "@/service/types/Service.js";
-import type { AgentContext } from "@/core/AgentContextTypes.js";
-import type {
-  TaskCronRegisterResult,
-  TaskSchedulerReloadResult,
-} from "@/service/builtins/task/types/TaskService.js";
-import { TaskCronTriggerEngine } from "@/service/builtins/task/runtime/CronTrigger.js";
-import { registerTaskCronJobs } from "@/service/builtins/task/Scheduler.js";
-import {
-  createTaskServiceActions,
-} from "@/service/builtins/task/runtime/TaskServiceActions.js";
-import {
-  reloadTaskSchedulerAfterMutation,
-} from "@/service/builtins/task/runtime/TaskActionExecution.js";
-import { TASK_SERVICE_PROMPT } from "@/service/builtins/task/runtime/TaskServiceSystem.js";
-
-const TASK_LOG_PREFIX = "[TASK]";
-
-function formatTaskLogMessage(message: string): string {
-  return `${TASK_LOG_PREFIX} ${message}`;
-}
-
-/**
- * task service 类实现。
- */
-export class TaskService extends BaseService {
-  /**
-   * 当前 service 名称。
-   */
-  readonly name = "task";
-
-  /**
-   * task service 的 system 文本提供器。
-   */
-  readonly system = (): string => TASK_SERVICE_PROMPT;
-
-  /**
-   * task service 的 action 定义表。
-   */
-  readonly actions: ServiceActions;
-
-  /**
-   * 当前实例持有的 cron engine。
-   *
-   * 关键点（中文）
-   * - 这是 per-service-instance 的长期运行态。
-   * - 不再复用 module-global 单例。
-   */
-  public cronEngine: TaskCronTriggerEngine | null = null;
-
-  constructor(agent: AgentRuntime | null) {
-    super(agent);
-
-    this.actions = createTaskServiceActions({
-      reloadSchedulerAfterMutation: async (params) =>
-        this.reloadSchedulerAfterMutation(params),
-    });
-
-    this.lifecycle = {
-      start: async (context) => {
-        const result = await this.startCronRuntime(context);
-        if (!result) return;
-        context.logger.info(
-          formatTaskLogMessage(
-            `Task cron trigger started (tasks=${result.tasksFound}, jobs=${result.jobsScheduled})`,
-          ),
-        );
-      },
-      stop: async (context) => {
-        const stopped = await this.stopCronRuntime();
-        if (!stopped) return;
-        context.logger.info(formatTaskLogMessage("Task cron trigger stopped"));
-      },
-      command: async ({ context, command }) => {
-        if (command !== "reschedule" && command !== "reload") {
-          return {
-            success: false,
-            message: `Unknown task command: ${command}`,
-          };
-        }
-
-        const result = await this.restartCronRuntime(context);
-        context.logger.info(
-          formatTaskLogMessage(
-            `Task cron trigger reloaded (tasks=${result.tasksFound}, jobs=${result.jobsScheduled})`,
-          ),
-        );
-        return {
-          success: true,
-          message: "task scheduler reloaded",
-        };
-      },
-    };
-  }
-
-  /**
-   * 启动当前实例的 cron runtime。
-   */
-  async startCronRuntime(
-    context: AgentContext,
-  ): Promise<TaskCronRegisterResult | null> {
-    if (this.cronEngine) return null;
-
-    const engine = new TaskCronTriggerEngine();
-    const registerResult = await registerTaskCronJobs({
-      context,
-      engine,
-    });
-    await engine.start();
-    this.cronEngine = engine;
-    return registerResult;
-  }
-
-  /**
-   * 停止当前实例的 cron runtime。
-   */
-  async stopCronRuntime(): Promise<boolean> {
-    if (!this.cronEngine) return false;
-    const previous = this.cronEngine;
-    this.cronEngine = null;
-    await previous.stop();
-    return true;
-  }
-
-  /**
-   * 重启当前实例的 cron runtime。
-   */
-  async restartCronRuntime(
-    context: AgentContext,
-  ): Promise<TaskCronRegisterResult> {
-    await this.stopCronRuntime();
-    const started = await this.startCronRuntime(context);
-    return (
-      started || {
-        tasksFound: 0,
-        jobsScheduled: 0,
-      }
-    );
-  }
-
-  /**
-   * 任务定义变更后重载 scheduler。
-   */
-  private async reloadSchedulerAfterMutation(params: {
-    context: AgentContext;
-    action: "create" | "update" | "delete" | "status";
-    title: string;
-  }): Promise<TaskSchedulerReloadResult> {
-    return await reloadTaskSchedulerAfterMutation({
-      context: params.context,
-      action: params.action,
-      title: params.title,
-      reloadScheduler: async (context) => this.restartCronRuntime(context),
-    });
-  }
-}