@ai-setting/roy-agent-core 1.7.72 → 1.7.75

package/dist/shared/@ai-setting/roy-agent-core-2akfd64z.js

@@ -0,0 +1,374 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/tool/built-in/query-background-process-tool.ts
+import { z } from "zod";
+var QueryBackgroundProcessParameters = z.object({
+  bgProcessId: z.string().min(1, "bgProcessId must not be empty").describe("The background process ID returned by delegate_task " + "(format: process_<timestamp>_<random>).")
+});
+function backgroundTaskToOutput(task) {
+  return {
+    alive: task.status === "pending" || task.status === "running",
+    status: task.status,
+    createdAt: task.createdAt,
+    lastUpdatedAt: task.lastUpdatedAt ?? task.completedAt ?? task.startedAt ?? task.createdAt,
+    description: task.description,
+    ...task.result !== undefined ? { result: task.result } : {},
+    ...task.error !== undefined ? { error: task.error } : {}
+  };
+}
+function notFoundOutput(bgProcessId) {
+  const now = Date.now();
+  return {
+    alive: false,
+    status: "not_found",
+    createdAt: now,
+    lastUpdatedAt: now,
+    description: `No background process found with id '${bgProcessId}'.`
+  };
+}
+var queryBackgroundProcessTool = {
+  name: "query_background_process",
+  description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+  parameters: QueryBackgroundProcessParameters,
+  permission: {
+    level: "safe",
+    requireConfirmation: false
+  },
+  metadata: {
+    category: "task",
+    tags: ["background", "delegate", "query", "status", "diagnostic"],
+    version: "1.0.0",
+    allowedAgentTypes: ["default"]
+  },
+  execute: async (args, ctx) => createQueryBackgroundProcessTool(null).execute(args, ctx)
+};
+function createQueryBackgroundProcessTool(manager = null) {
+  return {
+    name: "query_background_process",
+    description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+    parameters: QueryBackgroundProcessParameters,
+    permission: {
+      level: "safe",
+      requireConfirmation: false
+    },
+    metadata: {
+      category: "task",
+      tags: ["background", "delegate", "query", "status", "diagnostic"],
+      version: "1.0.0",
+      allowedAgentTypes: ["default"]
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const params = QueryBackgroundProcessParameters.parse(args);
+      const { bgProcessId } = params;
+      if (!manager) {
+        return {
+          success: false,
+          output: "",
+          error: "query_background_process is not initialized: no BackgroundTaskManager " + "has been bound. TaskComponent should call " + "createQueryBackgroundProcessTool(manager) and register the tool " + "during startup.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      let task;
+      try {
+        task = manager.getTask(bgProcessId);
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `failed to query background task: ${err.message}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (task) {
+        const currentSessionId = ctx.session_id;
+        if (!currentSessionId || task.parentSessionId !== currentSessionId) {
+          return {
+            success: true,
+            output: JSON.stringify(notFoundOutput(bgProcessId), null, 2),
+            metadata: {
+              execution_time_ms: Date.now() - startTime,
+              bgProcessId,
+              status: "not_found",
+              alive: false
+            }
+          };
+        }
+      }
+      const output = task ? backgroundTaskToOutput(task) : notFoundOutput(bgProcessId);
+      if (output.alive) {
+        try {
+          const activity = await manager.getSubSessionActivity?.(bgProcessId);
+          if (activity) {
+            output.lastUpdatedAt = Math.max(output.lastUpdatedAt, activity.updatedAt);
+            output.messageCount = activity.messageCount;
+            output.subSessionUpdatedAt = activity.updatedAt;
+          }
+        } catch {}
+      }
+      return {
+        success: true,
+        output: JSON.stringify(output, null, 2),
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          bgProcessId,
+          status: output.status,
+          alive: output.alive
+        }
+      };
+    }
+  };
+}
+
+// src/env/tool/built-in/compact-session-tool.ts
+init_logger();
+import { z as z2 } from "zod";
+var logger = createLogger("compact-session-tool");
+var CompactSessionParameters = z2.object({
+  session_id: z2.string().min(1, "session_id must not be empty").describe("The sub-session ID to compact (format: session_xxx or oc_xxx). " + "Must be a sub-session previously created via delegate_task " + "(the bgProcess notification reports its subSessionId).")
+});
+function compactSessionNotFoundOutput(sessionId) {
+  return {
+    status: "not_found",
+    sessionId
+  };
+}
+function findTaskBySubSessionId(manager, sessionId) {
+  const tasks = manager.listTasks() ?? [];
+  const bySubSession = tasks.find((t) => t.subSessionId === sessionId);
+  if (bySubSession)
+    return bySubSession;
+  return manager.getTask(sessionId);
+}
+function isOwnSubSession(task, currentSessionId) {
+  if (!task || !currentSessionId)
+    return false;
+  return task.parentSessionId === currentSessionId;
+}
+function isTaskActive(task) {
+  return task?.status === "running" || task?.status === "pending";
+}
+function createCompactSessionTool(backgroundTaskManager = null, sessionComponent = null) {
+  return {
+    name: "compact_session",
+    description: "Compact (compress) a sub-agent session by summarizing its history " + "into a checkpoint and archiving the old messages, so the session " + "can be REUSED with delegate_task(sub_session_id=...) without " + `exceeding the context threshold.
+
+` + `Use this tool when:
+` + "  - A delegated sub-agent returned 'Context threshold exceeded' " + "(e.g. 125575/120000 tokens) and you want to continue the SAME " + `sub-session instead of losing all its progress.
+` + "  - A sub-session is very long and the next resume would likely " + `hit the context limit again.
+
+` + `Behavior:
+` + "  1. Generates a checkpoint (natural-language summary of the " + `conversation so far)
+` + "  2. Archives the old messages (they remain queryable but leave " + `the active context)
+` + `  3. Returns a JSON summary of the compaction
+
+` + `After compaction succeeds, resume the sub-session with:
+` + '  delegate_task(subagent_type="...", sub_session_id="<same id>", ' + `prompt="continue from the checkpoint")
+
+` + `Guards:
+` + `  - You CANNOT compact your own current session (self-destruction).
+` + `  - You can only compact sub-sessions YOU delegated (ownership check).
+` + "  - A session whose background task is still running/pending cannot " + `be compacted (stop_task it first to avoid corrupting live state).
+
+` + "Only the default receptionist agent has this tool.",
+    parameters: CompactSessionParameters,
+    permission: {
+      level: "safe",
+      requireConfirmation: false
+    },
+    metadata: {
+      category: "task",
+      tags: ["compact", "session", "delegate", "checkpoint", "context"],
+      version: "1.0.0",
+      allowedAgentTypes: ["default"]
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const params = CompactSessionParameters.parse(args);
+      const sessionId = params.session_id;
+      if (!backgroundTaskManager || !sessionComponent) {
+        return {
+          success: false,
+          output: "",
+          error: "compact_session is not initialized: no BackgroundTaskManager " + "or SessionComponent has been bound. TaskComponent should call " + "createCompactSessionTool(manager, sessionComponent) and " + "register the tool during startup.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      const currentSessionId = ctx.session_id;
+      if (currentSessionId && sessionId === currentSessionId) {
+        return {
+          success: false,
+          output: "",
+          error: `Refusing to compact session '${sessionId}': it is your OWN ` + `current session. Compacting it would destroy your own active ` + `context. Only sub-sessions you delegated can be compacted.`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (!currentSessionId) {
+        return {
+          success: false,
+          output: "",
+          error: "compact_session requires a current session context " + "(ctx.session_id) to verify ownership, but none was provided.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      const task = findTaskBySubSessionId(backgroundTaskManager, sessionId);
+      if (!task || !isOwnSubSession(task, currentSessionId)) {
+        logger.warn("[compact_session] not_found (unknown or foreign sub-session)", { sessionId, currentSessionId });
+        return {
+          success: true,
+          output: JSON.stringify(compactSessionNotFoundOutput(sessionId), null, 2),
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            status: "not_found"
+          }
+        };
+      }
+      if (isTaskActive(task)) {
+        return {
+          success: false,
+          output: "",
+          error: `Cannot compact session '${sessionId}': its background task ` + `'${task.id}' is still ${task.status}. The sub-agent writes ` + `to this session every ReAct iteration; archiving messages ` + `now would corrupt live state. Run ` + `stop_task(task_id="${task.id}") first, then compact the ` + `session.`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            bgProcessId: task.id,
+            taskStatus: task.status
+          }
+        };
+      }
+      let preview;
+      try {
+        preview = await sessionComponent.previewCompact(sessionId);
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `failed to preview compaction for session '${sessionId}': ` + `${err.message}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (!preview || preview.messageCountToCompact < 3) {
+        return {
+          success: false,
+          output: "",
+          error: `Cannot compact session '${sessionId}': minimum 3 compactable ` + `messages required (found ` + `${preview?.messageCountToCompact ?? 0}).`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            messageCountToCompact: preview?.messageCountToCompact ?? 0
+          }
+        };
+      }
+      let scenarioHint = "";
+      try {
+        scenarioHint = await sessionComponent.generateCompactHint(sessionId);
+      } catch (err) {
+        logger.warn("[compact_session] hint generation failed, continuing with empty hint", { sessionId, error: err.message });
+        scenarioHint = "";
+      }
+      let compactResult;
+      try {
+        compactResult = await sessionComponent.compact(sessionId, {
+          scenarioHint
+        });
+      } catch (err) {
+        const message = err.message;
+        logger.error(`[compact_session] compact failed: ${message}`, {
+          sessionId
+        });
+        return {
+          success: false,
+          output: "",
+          error: `compaction failed for session '${sessionId}': ${message}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId
+          }
+        };
+      }
+      try {
+        const env = backgroundTaskManager.env;
+        env?.pushEnvEvent?.({
+          type: "context.compacted",
+          metadata: { sessionId },
+          payload: {
+            checkpointId: compactResult.checkpoint.id,
+            messagesCompacted: compactResult.deletedMessageCount,
+            scenarioHintUsed: scenarioHint.length > 0,
+            source: "compact_session_tool"
+          }
+        });
+      } catch (err) {
+        logger.warn("[compact_session] failed to push context.compacted event", { sessionId, error: err.message });
+      }
+      const output = {
+        status: "compacted",
+        sessionId,
+        checkpointId: compactResult.checkpoint.id,
+        checkpointTitle: compactResult.checkpoint.title,
+        contentLength: compactResult.checkpoint.content?.length ?? 0,
+        originalMessages: preview.messageCountToCompact,
+        deletedMessages: compactResult.deletedMessageCount,
+        remainingMessages: compactResult.remainingMessageCount,
+        hintUsed: scenarioHint.length > 0
+      };
+      logger.info("[compact_session] session compacted", {
+        sessionId,
+        checkpointId: output.checkpointId,
+        deletedMessages: output.deletedMessages,
+        remainingMessages: output.remainingMessages
+      });
+      return {
+        success: true,
+        output: JSON.stringify(output, null, 2),
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          sessionId,
+          status: "compacted",
+          checkpointId: output.checkpointId
+        }
+      };
+    }
+  };
+}
+var compactSessionTool = createCompactSessionTool(null, null);
+
+export { queryBackgroundProcessTool, createQueryBackgroundProcessTool, createCompactSessionTool, compactSessionTool };

package/dist/shared/@ai-setting/{roy-agent-core-yhwxpj12.js → roy-agent-core-3e6gg17d.js}

@@ -3,7 +3,7 @@ import {
   TASK_COMPLETE_VERIFY_DUTY,
   TASK_COMPLETION_HINT_ANCHOR,
   TASK_DISCIPLINE_PROMPT
-} from "./roy-agent-core-4jjwewvw.js";
+} from "./roy-agent-core-11shp00p.js";
 
 // src/env/prompt/prompts-index.ts
 var builtInPrompts = {
@@ -14,7 +14,8 @@ var builtInPrompts = {
 > **本 prompt 中部分段落（如 \`delegate_task(...)\` 调用模板、行为规则 6 里的引用）是**你转交给 sub-agent（通常是 \`roy\`）的示例指令**，不代表你自己能直接调用其中提到的所有工具**。
 >
 > 具体来说：
-> - \`delegate_task(...)\` 调用里的 prompt 模板中可能提到 \`task_create\` / \`task_update\` / \`task_operation_create\` / \`task_complete\` 等工具 —— 这些是**指示子 agent 用的**，不是你自己的工具（你已被 \`deniedTools\` 禁用）。
+> - \`delegate_task(...)\` 调用里的 prompt 模板中可能提到 \`task_create\` / \`task_update\` / \`task_operation_create\` 等工具 —— 这些是**指示子 agent 用的**，不是你自己的工具（你已被 \`deniedTools\` 禁用）。
+> - ⚠️ **例外（Task #5007）**：\`task_complete\` / \`task_cancel\` 是**你自己的验收工具**（见"## 任务验收职责"），不在禁用列表里。
 > - 你**自己**真正可用的工具，**严格以下方"## 你的工具"区块中的工具表为准**。
 >
 > 如果你读到 prompt 里有工具名但下方工具表里没有该工具 —— **不要尝试调用**，那是给子 agent 的示例。
@@ -52,6 +53,8 @@ var builtInPrompts = {
 | \`delegate_task\` | **执行** | 委托复杂/多步骤任务给子智能体执行（后台模式，立即返回） |
 | \`query_background_process\` | **执行** | 查询由 \`delegate_task\` 启动的后台进程当前状态（仅 default agent 可见） |
 | \`bash\` | **执行** | 仅用于执行一行简单的 shell 命令 |
+| \`task_complete\` | **验收** | 验收通过 ⇒ 任务置为 completed（触发 goal 检查 decision model） |
+| \`task_cancel\` | **验收** | 验收不通过 / 用户要求 ⇒ 任务置为 cancelled |
 
 ### 查询工具（可直接使用）
 
@@ -132,7 +135,7 @@ var builtInPrompts = {
 - ✅ 功能开发、bug 修复、重构、文档生成
 - ✅ 网络搜索和研究
 
-**roy** 的提示词中内置了任务生命周期——它知道如何使用 \`task_create\`、\`task_update\`、\`task_operation_create\` 和 \`task_complete\` 来跟踪每项工作。task_complete 时会${TASK_COMPLETE_VERIFY_DUTY}：按子项逐条验收（${TASK_COMPLETE_ITEM_BY_ITEM}），若收到 [${TASK_COMPLETION_HINT_ANCHOR}] 必须核实并二选一（重开 / 落 decision 说明理由）。
+**roy** 的提示词中内置了任务生命周期——它知道如何使用 \`task_create\`、\`task_update\`、\`task_operation_create\` 来跟踪每项工作并留下操作记录。⚠️ **Task #5007**：roy **没有** \`task_complete\` 权限 —— 它把进度推到 100% 即视为完成并结束返回，**最终验收（${TASK_COMPLETE_ITEM_BY_ITEM} + goal 检查 decision model）由你（default agent）来触发**。若验收时收到 [${TASK_COMPLETION_HINT_ANCHOR}]，按工具描述里的${TASK_COMPLETE_VERIFY_DUTY}二选一（重开 / 落 decision 说明理由）。
 
 推荐使用：
 \`\`\`
@@ -140,7 +143,9 @@ delegate_task(
   description="简要 3-5 字摘要",
   prompt="详细说明。
 
-重要：遵循任务作为一等公民原则 — 使用 \`task_create\` 创建任务，使用 \`task_update\` 跟踪进度，使用 \`task_operation_create\` 记录里程碑，并使用 \`task_complete\` 完成任务。",
+重要：遵循任务作为一等公民原则 — 使用 \`task_create\` 创建任务，使用 \`task_update\` 跟踪进度，使用 \`task_operation_create\` 记录里程碑。
+
+⚠️ 不要调用 \`task_complete\`（你无此权限）：进度达到 100% 后直接结束并返回结果，验收由主智能体（default agent）负责。",
   subagent_type="roy",
   similar_task_ids=[]  // 必填：先使用 task_search 搜索相似任务，将找到的 ID 填入此处（最多 3 个）
 )
@@ -212,13 +217,60 @@ delegate_task(
 )
 \`\`\`
 
+## 任务验收职责（Task #5007 —— 你是裁判，roy 是运动员）
+
+> **架构约定**：执行与验收**分离**。sub-agent（\`roy\`）负责**干活 + 记操作记录 + 报进度**；
+> **你（default agent）负责最终验收**。sub-agent **没有** \`task_complete\` 权限 ——
+> 它把进度推到 100% 就结束返回，由**你**来判定这活到底算不算做完。
+>
+> **为什么这样分**：
+> ① **裁判 ≠ 运动员** —— 同一个 agent 既写又批，容易自己给自己放行；
+> ② **状态不会烂尾** —— sub-agent 可能超时 / 崩掉 / 没来得及更新状态，
+>    任务就会长期挂在 active。你能主动查、主动补验收、主动取消。
+
+### 何时验收
+
+| 触发时机 | 你要做什么 |
+|---|---|
+| 收到 sub-agent **完成通知** | 走下面的"验收四步" |
+| 收到 **timeout / failed** 通知 | 判断是否值得重试；不值得就 \`task_cancel\` |
+| 用户问"那个任务怎么样了" | \`task_get\` 查实际状态，落后于进度就补验收 |
+| 用户说"取消 / 停掉这个任务" | \`task_cancel\`（若 sub-agent 还在跑，先 \`stop_task\` 掐进程） |
+
+### 验收四步（⚠️ 不要跳过第 1 步）
+
+1. **核对实际产出** —— \`task_get(task_id=<id>)\` 读任务的 \`goal\`（description）、
+   \`delivery\`（goals_and_expected_deliverables）和**操作记录链**（\`task_operation_list\`），
+   再对照真实交付物：文件是否存在、测试是否通过、review 结论是什么。
+   ⚠️ **不接受 sub-agent 的自述作为验收依据** —— 它说"做完了"不算，产出在才算。
+2. **逐条对照子项** —— goals 是**编号子项**，一条一条核（文件断言 / 进程断言 / 测试断言 / 状态断言）。
+3. **决定**：
+   - ✅ 全部达成 → \`task_complete(task_id=<id>, deliverable_storage_path="<交付物地址>")\`
+     （这一步会触发 goal 检查的 decision model；可能收到 \`[TASK_COMPLETION_HINT]\`，
+     收到就按工具描述里的**核实义务**处理：重开 or 落 decision 说明理由）
+   - ⚠️ 差距不大 → 重新委托（\`delegate_task\` + \`sub_session_id\` 续跑），别急着取消
+   - ❌ 不值得继续 / 用户要求 → \`task_cancel(task_id=<id>, reason="<原因>")\`
+4. **留痕** —— 验收结论要写进任务上下文（\`task_get\` 能看到的状态）或汇报给用户。
+
+### ⚠️ 你不做执行
+
+你**不创建**任务、**不更新**进度 —— \`task_create\` / \`task_update\` 仍在你的 \`deniedTools\` 里。
+执行是 sub-agent 的活，验收是你的活。
+
+### ✅ 你可以记操作记录（Task #5007 后续优化）
+
+\`task_operation_create\` **已从** \`deniedTools\` **移除**。你可以用它把用户的反馈 / 说明 / 强调点
+记录到任务操作记录中。sub-agent 续推时通过 \`task_operation_list\` 读取最新记录来理解上下文。
+操作记录因此成为 agents 间的通信介质（不只是人工日志）。
+
 ## 如何处理用户请求
 
 1. **理解** — 用户到底想要什么？
 2. **分类** — 如果需要任何超出简单对话的操作 → 委托。如果是问候/一次性回答 → 直接回复。
 3. **选择智能体** — \`roy\`（默认）、\`workflow-runner\`（调用 workflow）、\`workflow-creator\`（用户主动构建 workflow）
-4. **搜索相似任务并委托** — 在委托前，先使用 \`task_search\` 搜索与当前请求相关的历史任务，将找到的相似任务 ID 填入 \`similar_task_ids\` 参数。在给子智能体的提示词中，始终包含简要指令，要求将工作视为任务一等公民：创建任务（\`task_create\`）、跟踪进度并完成。
-5. **汇报结果** — 向用户总结结果
+4. **搜索相似任务并委托** — 在委托前，先使用 \`task_search\` 搜索与当前请求相关的历史任务，将找到的相似任务 ID 填入 \`similar_task_ids\` 参数。在给子智能体的提示词中，始终包含简要指令，要求将工作视为任务一等公民：创建任务（\`task_create\`）、跟踪进度（\`task_update\`）、记录里程碑（\`task_operation_create\`）。
+5. **验收** — 收到 sub-agent 完成通知后，按上方"任务验收职责"核对产出，再决定 \`task_complete\` / 重新委托 / \`task_cancel\`。
+6. **汇报结果** — 向用户总结结果
 
 ## Workflow 创建委托指南（重要）
 
@@ -261,7 +313,8 @@ delegate_task(
 4. **首选 roy** — 首次委托默认使用 \`roy\`
 5. **workflow-runner** — 凡是走 workflow 解决的任务（包括兼容旧名 \`strict-task-agent\` / \`code-review\` / \`bench-agent-host\` / \`workspace-analyzer\` / \`test-workflow-agent\`，自动重写），都委托给它
 5a. ⚠️ **workflow-creator** — 用户说"帮建 workflow" / "封装成 workflow" / "再造个变体" / "想基于 XXX workflow 改造"，**必须委托**，default agent 自己**禁止**用 bash \`workflow add/validate/tag list\` 手撸。手撸已废弃，统一走 workflow-creator（与 workflow-extract one-shot 不同，workflow-creator 是多轮对话式协作）
-6. **始终包含任务生命周期** — 每次委托时，指示子智能体使用 \`task_create\` → \`task_update\` → \`task_operation_create\` → \`task_complete\`
+6. **始终包含任务生命周期** — 每次委托时，指示子智能体使用 \`task_create\` → \`task_update\` → \`task_operation_create\`（⚠️ **不要**指示它用 \`task_complete\` —— 验收权在你手上，Task #5007）
+6a. **⚠️ 验收权在你（default agent）** — sub-agent 交回结果后，**你**用 \`task_complete\` / \`task_cancel\` 落终态（见"任务验收职责"）。不要在委托 prompt 里让 sub-agent 自己 \`task_complete\` —— 那是它没有的权限（会被 deniedTools 拦掉，白白浪费一轮迭代）。
 7. **简单回复** — 对于问候、简单问答或结果总结，可以直接回复
 8. **⚠️ 不要 sleep 等待后台任务结果** — \`delegate_task\` 总是后台模式（参见下方"子代理通知自主处理规则"），委托后**立即返回**。**禁止**调用 \`sleep\`、\`wait\`、\`sleep N\` 等任何同步等待命令试图"等子智能体跑完"。原因：
    - \`sleep\` 会阻塞当前 ReAct 循环，导致**无法及时接收**后台进程或子智能体的通知消息
@@ -276,13 +329,16 @@ delegate_task(
 当你通过 \`delegate_task\` 委托任务给子智能体后，会收到后台任务通知。你必须**自主处理**这些通知，而不是询问用户：
 
 ### 1. 任务成功通知（✅ completed）
-- 分析子代理的完成结果，校验是否达到预期目标
-- 如果达到目标：继续推进后续工作或等待用户下一步指示
-- 如果未完全达到：分析差距，决定是否需要重新委托或调整方案
+- ⚠️ **这不等于验收通过** —— sub-agent 只负责把进度推到 100%，**判定权在你**
+- 按"任务验收职责"的**验收四步**走：\`task_get\` 核对实际产出 → 逐条对照 goals 子项 → 决定
+  - ✅ 达成 → \`task_complete(task_id=<id>, deliverable_storage_path="<交付物地址>")\`
+  - ⚠️ 差距不大 → \`delegate_task\` + \`sub_session_id\` 重新委托续跑
+  - ❌ 不值得继续 / 用户要求 → \`task_cancel(task_id=<id>, reason="<原因>")\`
+- 如果 sub-agent **没有**告诉你任务号，用 \`task_search\` 按标题/描述找回关联的 Task
 
 ### 2. 任务失败通知（❌ failed）
 - 分析失败原因，尝试提出修复方案并重新委托子代理执行
-- 最多尝试 2-3 次，如果仍然失败，记录失败原因并知会用户
+- 最多尝试 2-3 次，如果仍然失败，记录失败原因并知会用户；确定不再继续时 \`task_cancel\` 收尾
 
 ### 3. 任务需要决策通知（\uD83D\uDD04 progress update）
 - 子代理在推进过程中遇到需要决策的问题时
@@ -819,7 +875,6 @@ roy-agent <command> <subcmd> --help
 | \`task_get\` | Get detailed information about a specific task |
 | \`task_update\` | Update task status, progress, priority, or properties |
 | \`task_list\` | List tasks with optional filters for status/priority |
-| \`task_complete\` | Mark a task as completed (progress=100, status=completed). Creates an operation record. |
 | \`task_delete\` | Delete a task and all its operation records |
 | \`task_operation_create\` | Create operation records — **双维度**: milestone_* (状态/里程碑) + process_description (过程, 100-500 字符) |
 | \`task_operation_list\` | List operation records for a task |
@@ -832,6 +887,29 @@ roy-agent <command> <subcmd> --help
 |------|-----------|-------------|
 | \`delegate_task\` | 子 agent 委托入口，由 \`default\` 接待员独占 | 直接用 \`bash\` / \`read_file\` / \`edit_file\` 等工具自己完成任务；若是真正的复杂多步任务，建议用户切换到 \`default\` agent |
 | \`stop_task\` | 后台进程管理入口，由 \`default\` 接待员独占 | 你无法启动后台进程，自然不需要 \`stop_task\` |
+| \`task_complete\` | **验收权归 \`default\` 接待员**（Task #5007，裁判 ≠ 运动员） | 把进度推到 100%、记完操作记录，然后**结束并返回结果**；验收由主智能体用 \`task_complete\` 落终态 |
+
+### ⚠️ 你的职责边界：执行 + 记录，不做验收（Task #5007）
+
+> **架构约定**：执行与验收**分离**。你是**执行方**（运动员），主智能体（\`default\` 接待员）是**验收方**（裁判）。
+>
+> **你负责的**：
+> 1. \`task_create\` 建任务（goals 写成**编号子项**，可逐条验收）
+> 2. \`task_update\` 跟踪进度（0→100%）
+> 3. \`task_operation_create\` 记录里程碑 / 过程 / 结论（**边干边记**，别事后补）
+>
+> **你不负责的**：
+> - ❌ **不要调用 \`task_complete\`** —— 你没有这个权限（调用会被 deniedTools 拦掉，白白浪费一轮迭代）
+> - ❌ 不要自己宣布"任务完成"就当结束 —— 你的完成只是"我这边干完了"
+>
+> **你怎么"完成"**：
+> 进度达到你判断的 **100%** 时，把 \`task_update(progress=100)\` 和最后一条
+> \`task_operation_create\` 落下，**然后结束当前回合，把结果返回给主智能体**。
+> 主智能体收到后会核对实际产出（文件在不在、测试过没过、review 结论），
+> 再决定 \`task_complete\` / 重新委托 / 取消。
+>
+> ⚠️ 如果你因为超时 / 崩溃没能把状态更新到位，主智能体**也会**来兜底验收 ——
+> 但你**主动**把进度和操作记录写全，能让验收更快更准。
 
 ${TASK_DISCIPLINE_PROMPT}
 ### {{memory}}`,

package/dist/shared/@ai-setting/{roy-agent-core-skyc30qx.js → roy-agent-core-3fh1f7s7.js}

@@ -1,9 +1,9 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-attpry6g.js";
+} from "./roy-agent-core-dqxec05w.js";
 import"./roy-agent-core-1db4vpc6.js";
-import"./roy-agent-core-e25xkv53.js";
+import"./roy-agent-core-mkc3zshb.js";
 import"./roy-agent-core-cpcd24n2.js";
 import"./roy-agent-core-qqaak24r.js";
 import"./roy-agent-core-7cbpmk4q.js";

package/dist/shared/@ai-setting/{roy-agent-core-2gzt2q8c.js → roy-agent-core-4gr3k7qg.js}

@@ -1,19 +1,22 @@
 import {
+  compactSessionTool,
+  createCompactSessionTool,
   createQueryBackgroundProcessTool
-} from "./roy-agent-core-58804s3j.js";
+} from "./roy-agent-core-2akfd64z.js";
 import {
   createStopTool
 } from "./roy-agent-core-jm136jzh.js";
 import {
   BackgroundTaskManager,
   createDelegateTool
-} from "./roy-agent-core-7qvw65jt.js";
+} from "./roy-agent-core-jg65qnwa.js";
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
 import {
   batchArchiveTaskTool,
   batchDeleteTaskTool,
+  cancelTaskTool,
   completeTaskTool,
   createTaskTool,
   deleteTaskTool,
@@ -22,7 +25,7 @@ import {
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-7sj9xs9c.js";
+} from "./roy-agent-core-hnyk1by7.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -336,6 +339,9 @@ class TaskComponent extends BaseComponent {
       await this.registerTools();
       this.toolComponent.register(createQueryBackgroundProcessTool(this.backgroundTaskManager), "built-in");
       logger2.debug("[TaskComponent] Injected BackgroundTaskManager into query_background_process tool (factory pattern)");
+      const sessionComponent = this.env?.getComponent("session");
+      this.toolComponent.register(createCompactSessionTool(this.backgroundTaskManager, sessionComponent ?? null), "built-in");
+      logger2.debug("[TaskComponent] Registered compact_session tool (factory pattern)");
     } else {
       logger2.warn("[TaskComponent] ToolComponent not found, skipping tool registration");
     }
@@ -352,6 +358,12 @@ class TaskComponent extends BaseComponent {
       } catch (err) {
         logger2.warn(`[TaskComponent] Failed to reset query_background_process tool: ${err.message}`);
       }
+      try {
+        this.toolComponent.register(compactSessionTool, "built-in");
+        logger2.debug("[TaskComponent] Reset compact_session tool to no-deps default (cleanup)");
+      } catch (err) {
+        logger2.warn(`[TaskComponent] Failed to reset compact_session tool: ${err.message}`);
+      }
     }
     if (this.backgroundTaskManager) {
       await this.backgroundTaskManager.dispose(this.skipAbortRunningTasksOnDispose ? {
@@ -378,7 +390,8 @@ class TaskComponent extends BaseComponent {
       batchDeleteTaskTool(this),
       updateTaskTool(this),
       deleteTaskTool(this),
-      completeTaskTool(this)
+      completeTaskTool(this),
+      cancelTaskTool(this)
     ];
     const operationToolsList = [
       createOperationTool(this),

package/dist/shared/@ai-setting/{roy-agent-core-y12kyxwa.js → roy-agent-core-60jbrfye.js}

@@ -1,9 +1,6 @@
 import {
   defaultLarkCliRunner
 } from "./roy-agent-core-bxkjk7zx.js";
-import {
-  notifyReactFailure
-} from "./roy-agent-core-add1zqsh.js";
 import {
   cliCommandHandler
 } from "./roy-agent-core-v0hf14bj.js";
@@ -13,17 +10,20 @@ import {
   createPerTaskGroupChatPlugin,
   extractPerTaskChatId,
   extractPerTaskChatName
-} from "./roy-agent-core-5gw0qa8m.js";
+} from "./roy-agent-core-y7x2qzwc.js";
 import {
   getSharedEventStore
 } from "./roy-agent-core-na18zwj0.js";
 import {
   createLarkCliWorkflowNotifyHook
-} from "./roy-agent-core-1w9y7mxj.js";
+} from "./roy-agent-core-p3zv1mx5.js";
 import {
   LarkCardPatchNotifier,
   buildTaskCard
-} from "./roy-agent-core-46rv4d7d.js";
+} from "./roy-agent-core-nmx9934r.js";
+import {
+  notifyReactFailure
+} from "./roy-agent-core-6cy43nss.js";
 import {
   normalizeLarkAtMentions
 } from "./roy-agent-core-m880qz3y.js";