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

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

@@ -10,7 +10,7 @@ import {
   createPerTaskGroupChatPlugin,
   extractPerTaskChatId,
   extractPerTaskChatName
-} from "./roy-agent-core-y7x2qzwc.js";
+} from "./roy-agent-core-ghnagzrh.js";
 import {
   getSharedEventStore
 } from "./roy-agent-core-na18zwj0.js";
@@ -3327,6 +3327,32 @@ function renderRuleNoticeSection(ruleNotice, headline) {
   return `❌ **回执未送达**（原因：${ruleNotice.error ?? "unknown"}）
 ` + `→ 用户目前**还不知道**「${headline}」这件事，必须由你在回复里讲清楚，` + `并且不要假装系统已经通知过。`;
 }
+function renderActionSection(notifyType, taskId, scopeWord) {
+  const completeCall = taskId !== "?" ? `task_complete(task_id=${taskId})` : `task_complete(task_id=<用 task_search 找回的任务号>)`;
+  if (notifyType === "task.background.completed") {
+    return `**第一步 —— 验收（⚠️ 不可跳过）**：Task #${taskId} 的最终验收由**你**（default agent）负责 —— sub-agent 只负责干完活并调 task_pre_complete 提交待验证（status=to_validate），**判定权在你**（Task #5073 两阶段验收）。
+1. \`task_get(task_id=${taskId})\` **核对实际产出**：读 goal / delivery / 操作记录链（交付物在 \`context.deliverable_storage_path\` 和 operation 的 Deliverable 行里），再对照真实产出（文件是否存在、测试是否通过、review 结论是什么）。⚠️ **不接受 sub-agent 的自述作为验收依据** —— 它说"做完了"不算，产出在才算。
+2. **逐条对照 goals 的编号子项**（文件断言 / 进程断言 / 测试断言 / 状态断言），一条一条核。
+3. 全部达成 → **必须实际调用** \`${completeCall}\` 把任务落终态（completed）。
+   ⚠️ **只回消息不算完成** —— 任务会一直挂在 \`to_validate\`，下游（任务卡片 / goal 检查 / 进度统计）都读不到最终状态。
+   ⚠️ 本工具**不带**交付物参数（交付物通道 = task_pre_complete）—— 若发现交付物缺失，重新委托补做，不要在这一步补传。
+4. 有差距 → 用 \`delegate_task(sub_session_id=...)\` 续跑或重新委托；**不要**因为"验收不通过"就 \`task_cancel\`（\`task_cancel\` 仅限**用户明令**）。
+
+**第二步 —— 汇报**
+5. 用 2~5 行总结：这次完成了什么 / 卡在哪（依据上面的输出与子 session）
+6. 给出 1~3 个下一步选项（继续推进 / 拆小 / 放弃），并**问用户选哪个**
+7. 用 lark-cli 把回复发到上面的${scopeWord}（见下）`;
+  }
+  return `**第一步 —— 找根因 → 继续推进（不要甩尾放弃）**
+1. **先找根因**：读上面的输出与子 session，判断这次失败/超时/停止的真实原因（sub-agent 没做完？环境问题？指令不清？超时其实是工具撞硬超时但后台仍在跑？）。
+2. **继续推进**：能用 \`delegate_task(sub_session_id=...)\` 续跑就续跑（继承子 session 历史，不必从零重来）；不能续跑就按根因重新委托。
+3. ⚠️ **不要**用 \`task_cancel\` 结束这个任务 —— \`task_cancel\` 仅限**用户明令**。确实推不动（外部依赖挂了 / 用户另有安排）就如实告诉用户「卡在哪 + 需要用户做什么决定」，等用户决定。
+
+**第二步 —— 汇报**
+4. 用 2~5 行总结：这次完成了什么 / 卡在哪（依据上面的输出与子 session）
+5. 给出 1~3 个下一步选项（继续推进 / 拆小 / 放弃），并**问用户选哪个**
+6. 用 lark-cli 把回复发到上面的${scopeWord}（见下）`;
+}
 function extractCommandText(rawEvent) {
   const event = rawEvent;
   const innerEvent = event.event;
@@ -3454,9 +3480,7 @@ ${receiptSection}
 ${result}
 
 ### \uD83D\uDC49 你要做什么
-1. 用 2~5 行总结：这次完成了什么 / 卡在哪（依据上面的输出与子 session）
-2. 给出 1~3 个下一步选项（继续推进 / 拆小 / 放弃），并**问用户选哪个**
-3. 用 lark-cli 把回复发到上面的${scopeWord}（见下）
+${renderActionSection(notifyType, taskId, scopeWord)}
 
 ### 发送方式（渠道 = lark-cli）
 ${canReply ? `  ${replyCommand}` : `⚠️ 没有可用的 chatId —— 无法投递到触发会话。请在会话内汇报，并说明「未投递」的原因。`}

package/dist/shared/@ai-setting/{roy-agent-core-hnyk1by7.js → roy-agent-core-vffccgf6.js}

@@ -3,11 +3,16 @@ import {
   NEW_TASK_ID_PLACEHOLDER
 } from "./roy-agent-core-tr3ep81v.js";
 import {
+  TASK_DISCIPLINE_GOALS
+} from "./roy-agent-core-m46fe3x4.js";
+import {
+  TASK_ARCHIVED_STATUS_WORD,
+  TASK_CANCELLED_STATUS_WORD,
   TASK_COMPLETE_ITEM_BY_ITEM,
   TASK_COMPLETE_VERIFY_DUTY,
   TASK_COMPLETION_HINT_ANCHOR,
-  TASK_DISCIPLINE_GOALS
-} from "./roy-agent-core-11shp00p.js";
+  TERMINAL_NON_ACCEPTABLE_STATUSES
+} from "./roy-agent-core-4rtg69cn.js";
 import {
   getEnvContextOrEmpty,
   init_env_context,
@@ -63,7 +68,7 @@ var GetTaskToolSchema = withLegacyTaskId({
   include_operations: z.boolean().optional().default(true).describe("Include operation records (milestones / process log) with the task. " + "Defaults to true — the task's operation history is part of its detail. " + "Pass false for a lean task-only response.")
 });
 var ListTasksToolSchema = z.object({
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional(),
+  status: z.enum(["todo", "active", "to_validate", "completed", "paused", "cancelled", "archived"]).optional(),
   priority: z.enum(["low", "medium", "high"]).optional(),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("Filter by task type"),
   limit: z.number().optional().default(20),
@@ -75,7 +80,7 @@ var SearchTasksToolSchema = z.object({
   keywords: z.array(z.string()).describe("关键词列表（AND 逻辑，匹配 title/description/goals/tags/operations）"),
   limit: z.number().optional().default(20).describe("返回数量"),
   offset: z.number().optional().default(0).describe("偏移量"),
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional().describe("按状态筛选"),
+  status: z.enum(["todo", "active", "to_validate", "completed", "paused", "cancelled", "archived"]).optional().describe("按状态筛选"),
   priority: z.enum(["low", "medium", "high"]).optional().describe("按优先级筛选"),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("按类型筛选"),
   exclude_task_id: z.number().optional().describe("排除的 task ID"),
@@ -85,7 +90,7 @@ var SearchTasksToolSchema = z.object({
 var UpdateTaskToolSchema = withLegacyTaskId({
   title: z.string().optional(),
   description: z.string().optional(),
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional(),
+  status: z.enum(["todo", "active", "to_validate", "completed", "paused", "cancelled", "archived"]).optional(),
   priority: z.enum(["low", "medium", "high"]).optional(),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("Task type"),
   progress: z.number().min(0).max(100).optional(),
@@ -100,8 +105,10 @@ var UpdateTaskToolSchema = withLegacyTaskId({
 var DeleteTaskToolSchema = z.object({
   task_id: z.number().describe("Task ID")
 });
-var CompleteTaskToolSchema = withLegacyTaskId({
-  deliverable_storage_path: z.string().optional().describe("交付物的寻址地址（路径 / URL / 分支名等）。" + "调用本工具前，请先读取任务的 goal（description）和 delivery（goals_and_expected_deliverables）栏位，" + "建议验证目标和交付物是否符合预期，然后将实际交付物的寻址地址填入此参数。")
+var CompleteTaskToolSchema = withLegacyTaskId({});
+var PreCompleteTaskToolSchema = withLegacyTaskId({
+  deliverable_storage_path: z.string().optional().describe("交付物的寻址地址（路径 / URL / 分支名等）。" + "会持久化到 task.context.deliverable_storage_path，" + "并写入 operation 记录（Deliverable 行），供验收方 task_complete 时逐条对照。"),
+  current_status: z.string().optional().describe("本次交付的进展摘要（可选）。" + "会拼进「待验证：」文案，作为任务当前状态展示给验收方（default agent）。")
 });
 var CancelTaskToolSchema = withLegacyTaskId({
   reason: z.string().optional().describe("取消原因（可选）。会写入该任务的 operation 记录，便于事后追溯验收结论。")
@@ -116,7 +123,7 @@ var BatchDeleteToolSchema = z.object({
 var TreeTasksToolSchema = z.object({
   depth: z.number().optional().default(2).describe("树的展开深度。默认 2 (根 + 一层子任务 + 二层孙任务)。" + "0 = 只返回根任务，不展开任何子节点。" + "-1 或负数 = 无限层级（全部展开）。"),
   parent_task_id: z.number().optional().describe("只看指定父任务的子树。不传则从所有根任务（forest）开始。"),
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]).optional().describe("按状态过滤（与 task_list 一致）。"),
+  status: z.enum(["todo", "active", "to_validate", "completed", "paused", "cancelled", "archived"]).optional().describe("按状态过滤（与 task_list 一致）。"),
   priority: z.enum(["low", "medium", "high"]).optional().describe("按优先级过滤。"),
   type: z.enum(["normal", "cycle", "longterm"]).optional().describe("按任务类型过滤。"),
   include_archived: z.boolean().optional().default(false).describe("是否包含已归档任务（默认 false，与 task_list 一致）。")
@@ -702,7 +709,10 @@ function batchArchiveTaskTool(taskComponent) {
       let archivedCount = 0;
       for (const taskId of taskIds) {
         try {
-          const task = await taskComponent.updateTask(taskId, { status: "archived" });
+          const task = await taskComponent.updateTask(taskId, {
+            status: "archived",
+            current_status: params.reason ? `${TASK_ARCHIVED_STATUS_WORD}：${params.reason}` : TASK_ARCHIVED_STATUS_WORD
+          });
           if (task) {
             await taskComponent.createOperation({
               taskId,
@@ -940,7 +950,11 @@ init_env_context();
 init_logger();
 var logger4 = createLogger("task:tools:complete");
 var TASK_COMPLETE_DESCRIPTION = `
-Mark a task as completed (progress=100, status=completed). Creates an operation record.
+Final acceptance of a submitted task: set status=completed, progress=100
+(two-phase acceptance, Task #5073).
+
+**Who should call this** — the **acceptance side** (default agent). The
+executor (sub-agent) has NO permission to call it (deniedTools, Task #5007).
 
 **Before calling this tool**, you MUST:
 
@@ -968,21 +982,27 @@ Mark a task as completed (progress=100, status=completed). Creates an operation
          (milestone_type=decision) — the reason **must** land in the
          operation record (必须落到操作记录里), not merely a line in
          your final report (不能只在报告里带一句).
-3. **Provide \`deliverable_storage_path\`** parameter with the deliverable's address:
-   - Feishu doc URL (e.g., https://my.feishu.cn/docx/abc)
-   - Local file path (e.g., /tmp/report.md)
-   - Git branch or worktree path (e.g., feature/my-feature)
-   - GitHub commit URL or PR URL
-   - Cloud drive URL (e.g., https://my.feishu.cn/file/abc)
-   - Or any other locator that points to where the work product lives
-
-The \`deliverable_storage_path\` will be persisted to the task's \`context.deliverable_storage_path\` for future reference and traceability.
+3. Deliverables were already submitted by the executor via
+   \`task_pre_complete\` (they live in \`context.deliverable_storage_path\`
+   and the operation trail — Task #5073 design: task_complete takes **no**
+   deliverable parameter). Cross-check them in step 2; do NOT ask the
+   executor to resubmit.
 
 **Restrictions**:
 - Cannot complete cycle-type tasks (they are periodic). Use \`task_update\` to reset progress instead.
 - Marks the task as 100% complete; use \`task_update\` to record partial progress first if needed.
 
-**Backward compatibility**: \`deliverable_storage_path\` is optional. Existing callers that omit it continue to work as before.
+**Side effects**:
+- Sets \`status = "completed"\`, \`progress = 100\` **and refreshes \`current_status\`**
+  to the completed wording. You do **NOT** need a follow-up
+  \`task_update(current_status=...)\` call — a task must never keep a stale
+  pre-completion progress sentence (e.g. "paused, not committed") that would
+  contradict \`status = "completed"\`.
+- The goal-check decision model does **NOT** run here — it already ran at
+  \`task_pre_complete\` time (Task #5073 design v2). This tool is the final
+  state commit by the acceptance side.
+- Cannot complete a task that is already in a terminal state (cancelled /
+  archived) — reopen it first via \`task_update(status="active")\`.
 `.trim();
 function completeTaskTool(taskComponent) {
   return {
@@ -1010,7 +1030,18 @@ function completeTaskTool(taskComponent) {
             metadata: { execution_time_ms: 0 }
           };
         }
-        const task = await taskComponent.completeTask(params.task_id, sessionId, params.deliverable_storage_path);
+        const TERMINAL_NON_ACCEPTABLE = new Set([
+          ...TERMINAL_NON_ACCEPTABLE_STATUSES
+        ]);
+        if (TERMINAL_NON_ACCEPTABLE.has(currentTask.status)) {
+          return {
+            success: false,
+            output: "",
+            error: `Cannot complete task #${params.task_id}: it is already in terminal status "${currentTask.status}". Reopen it first via task_update(status="active") if acceptance should proceed.`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const task = await taskComponent.completeTask(params.task_id, sessionId);
         if (!task) {
           return {
             success: false,
@@ -1020,12 +1051,10 @@ function completeTaskTool(taskComponent) {
           };
         }
         setCurrentTaskId(undefined);
-        logger4.info(`[completeTask] Trace: Task #${params.task_id} completed, deliverable=${params.deliverable_storage_path || "(none)"}, currentTaskId cleared from EnvContext`);
+        logger4.info(`[completeTask] Trace: Task #${params.task_id} completed (acceptance committed), currentTaskId cleared from EnvContext`);
         return {
           success: true,
-          output: params.deliverable_storage_path ? `Task completed: #${task.id} - ${task.title}
-Deliverable (context + operation): ${params.deliverable_storage_path}` : `Task completed: #${task.id} - ${task.title}
-Deliverable: (no path provided)`,
+          output: `Task completed: #${task.id} - ${task.title}`,
           metadata: { execution_time_ms: 0, task }
         };
       } catch (error) {
@@ -1044,13 +1073,17 @@ init_logger();
 var logger5 = createLogger("tool:cancel-task");
 var NON_CANCELLABLE_STATUSES = new Set(["completed", "cancelled", "archived"]);
 var TASK_CANCEL_DESCRIPTION = `
-Cancel a task (task.status = "cancelled"). This is the **acceptance-side** cancel:
-use it when the work is abandoned, the user asked to stop, or acceptance failed.
+Cancel a task (task.status = "cancelled"). This is the **acceptance-side** cancel.
 
-**When to use**:
-- The user asks to cancel / stop / drop the task
-- Acceptance failed and re-delegation is not worth it
-- The sub-agent timed out or went off-track and the task is no longer relevant
+**When to use** — ONLY when the user explicitly asks (用户明令):
+- The user asks to cancel / stop / drop the task (用户明令取消 / 停掉 / 放弃这个任务)
+
+**When NOT to use**:
+- ❌ A sub-agent failed / timed out / went off-track — that is NOT a cancellation.
+  Find the root cause, propose a fix, and re-delegate (with \`sub_session_id\` to resume).
+  If it truly cannot be moved forward, report the situation to the user and **wait for
+  the user's decision** — do NOT cancel it on your own.
+- ❌ Acceptance found gaps but re-delegation is still possible — re-delegate instead.
 
 **What it does NOT do**:
 - It does **NOT** stop a running background process — that is \`stop_task\`
@@ -1060,6 +1093,9 @@ use it when the work is abandoned, the user asked to stop, or acceptance failed.
 **Side effects**:
 - Sets \`status = "cancelled"\` and fires the task terminal-state hooks
   (notifications / card state machine converge to the cancelled state).
+- Also refreshes \`current_status\` to the cancelled wording (with your \`reason\`
+  appended when given) — the task no longer keeps a stale pre-cancel progress
+  sentence that would contradict \`status = "cancelled"\`.
 - Writes an operation record so the cancellation reason stays auditable.
 - A cancelled task can be reopened later with \`task_update(status="active")\`.
 
@@ -1094,7 +1130,8 @@ function cancelTaskTool(taskComponent) {
           };
         }
         const task = await taskComponent.updateTask(params.task_id, {
-          status: "cancelled"
+          status: "cancelled",
+          current_status: params.reason ? `${TASK_CANCELLED_STATUS_WORD}：${params.reason}` : TASK_CANCELLED_STATUS_WORD
         });
         if (!task) {
           return {
@@ -1128,6 +1165,88 @@ function cancelTaskTool(taskComponent) {
     }
   };
 }
+// src/env/task/tools/pre-complete-tool.ts
+init_logger();
+var logger6 = createLogger("task:tools:pre-complete");
+var TASK_PRE_COMPLETE_DESCRIPTION = `
+Submit a task for acceptance (two-phase acceptance, Task #5073).
+
+**Who should call this** — the **executor** (sub-agent) when it believes
+the work is done and deliverables are ready.
+
+**What it does**:
+- Sets \`status = "to_validate"\` (待验证) — the task enters the
+  acceptance queue. This is **NOT** a terminal state.
+- Persists \`deliverable_storage_path\` to \`task.context.deliverable_storage_path\`
+  and writes a \`Deliverable: <path>\` line into the operation trail.
+- Refreshes \`current_status\` to the to-validate wording
+  (with your progress summary appended when given).
+- Creates an operation record so the submission stays auditable.
+
+**What it does NOT do**:
+- It does **NOT** mark the task completed — final acceptance
+  (\`task_complete\`) belongs to the **default agent** (验收权分离, Task #5007).
+
+**Goal self-check (design v2)**:
+- Submitting **does** fire the completion goal-check hook once
+  (\`terminalStatus="to_validate"\`) as a self-check gate — the
+  decision model reviews your goals/operations at submission time.
+  If it produces a hint, read it and address the gaps **before**
+  ending your turn. The final acceptance (\`task_complete\`) does
+  **not** re-run the goal check.
+
+**After calling**:
+- Push progress to 100 via \`task_update(progress=100)\` if not already,
+  then **end your turn and return the result** to the main agent.
+- The default agent will pick up the notification, verify the goals
+  item-by-item, and call \`task_complete\` (or re-delegate on gaps).
+
+**Parameters**:
+- \`task_id\` (required): the task to submit
+- \`deliverable_storage_path\` (optional): where the work product lives
+  (file path / Feishu doc URL / git branch / PR URL ...)
+- \`current_status\` (optional): a one-line progress summary shown to the
+  acceptance side (e.g. "实现完成，测试全绿")
+
+**Restrictions**:
+- Cannot pre-complete cycle-type tasks (they are periodic).
+`.trim();
+function preCompleteTaskTool(taskComponent) {
+  return {
+    name: "task_pre_complete",
+    description: TASK_PRE_COMPLETE_DESCRIPTION,
+    parameters: PreCompleteTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = PreCompleteTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const task = await taskComponent.preCompleteTask(params.task_id, sessionId, params.deliverable_storage_path, params.current_status);
+        if (!task) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: params.deliverable_storage_path ? `Task submitted for acceptance (to_validate): #${task.id} - ${task.title}
+Deliverable (context + operation): ${params.deliverable_storage_path}` : `Task submitted for acceptance (to_validate): #${task.id} - ${task.title}
+Deliverable: (no path provided)`,
+          metadata: { execution_time_ms: 0, task }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
 // src/env/task/tools/task-tree-tool.ts
 function compareTasksDesc(a, b) {
   if (a.updatedAt < b.updatedAt)
@@ -1266,4 +1385,4 @@ function treeTasksTool(taskComponent) {
     }
   };
 }
-export { createTaskTool, getTaskTool, listTasksTool, searchTasksTool, batchArchiveTaskTool, batchDeleteTaskTool, updateTaskTool, deleteTaskTool, completeTaskTool, cancelTaskTool, treeTasksTool };
+export { createTaskTool, getTaskTool, listTasksTool, searchTasksTool, batchArchiveTaskTool, batchDeleteTaskTool, updateTaskTool, deleteTaskTool, completeTaskTool, cancelTaskTool, preCompleteTaskTool, treeTasksTool };

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

@@ -9,7 +9,7 @@ import {
 import {
   BackgroundTaskManager,
   createDelegateTool
-} from "./roy-agent-core-jg65qnwa.js";
+} from "./roy-agent-core-aa2j7bk9.js";
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
@@ -22,10 +22,11 @@ import {
   deleteTaskTool,
   getTaskTool,
   listTasksTool,
+  preCompleteTaskTool,
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-hnyk1by7.js";
+} from "./roy-agent-core-vffccgf6.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -40,6 +41,16 @@ import {
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
+import {
+  TASK_ARCHIVED_STATUS_WORD,
+  TASK_CANCELLED_STATUS_WORD,
+  TASK_COMPLETED_STATUS_WORD,
+  TASK_DELIVERABLE_RECORDED,
+  TASK_REOPENED_STATUS_WORD,
+  TASK_TERMINAL_STATUS_WORDS,
+  TASK_TO_VALIDATE_STATUS_WORD,
+  TERMINAL_NON_ACCEPTABLE_STATUSES
+} from "./roy-agent-core-4rtg69cn.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";
@@ -87,16 +98,6 @@ var TASK_CONFIG_REGISTRATION = {
 
 // src/env/task/task-component.ts
 init_global_hook_manager();
-
-// src/env/task/hooks/contexts.ts
-var TASK_COMPLETE_TERMINAL_STATUSES = [
-  "completed",
-  "failed",
-  "cancelled",
-  "timeout"
-];
-
-// src/env/task/task-component.ts
 init_env_context();
 
 // src/env/task/tag-service.ts
@@ -187,6 +188,17 @@ class DefaultTagService {
 // src/env/task/task-component.ts
 init_decorator();
 var logger2 = createLogger("task");
+function isTerminalTaskStatus(status) {
+  return status === "completed" || status === "cancelled" || status === "archived";
+}
+function looksLikeSystemTerminalWording(currentStatus) {
+  if (!currentStatus)
+    return false;
+  const trimmed = currentStatus.trim();
+  if (!trimmed)
+    return false;
+  return TASK_TERMINAL_STATUS_WORDS.some((word) => trimmed.startsWith(word));
+}
 var DELIVERABLE_OPERATION_PREFIX = "Deliverable: ";
 function formatDeliverableForOperation(deliverableStoragePath) {
   if (!deliverableStoragePath)
@@ -391,7 +403,8 @@ class TaskComponent extends BaseComponent {
       updateTaskTool(this),
       deleteTaskTool(this),
       completeTaskTool(this),
-      cancelTaskTool(this)
+      cancelTaskTool(this),
+      preCompleteTaskTool(this)
     ];
     const operationToolsList = [
       createOperationTool(this),
@@ -465,6 +478,31 @@ class TaskComponent extends BaseComponent {
     const operations = await this.store.listOperations({ taskId: id });
     return { ...task, operations, task };
   }
+  withTerminalCurrentStatus(options, previousTask) {
+    const status = options.status;
+    if (!status)
+      return options;
+    if (options.current_status !== undefined)
+      return options;
+    let terminalWord;
+    switch (status) {
+      case "completed":
+        terminalWord = TASK_COMPLETED_STATUS_WORD;
+        break;
+      case "cancelled":
+        terminalWord = TASK_CANCELLED_STATUS_WORD;
+        break;
+      case "archived":
+        terminalWord = TASK_ARCHIVED_STATUS_WORD;
+        break;
+      default:
+        if (previousTask && isTerminalTaskStatus(previousTask.status) && looksLikeSystemTerminalWording(previousTask.current_status)) {
+          return { ...options, current_status: TASK_REOPENED_STATUS_WORD };
+        }
+        return options;
+    }
+    return { ...options, current_status: terminalWord };
+  }
   async updateTask(id, options) {
     const updateCtx = {
       id,
@@ -472,7 +510,13 @@ class TaskComponent extends BaseComponent {
       tagService: this.tagService
     };
     await this.executeHook(TaskHookPoints.BEFORE_UPDATE, updateCtx);
-    const task = await this.store.updateTask(id, updateCtx.options);
+    const requestedStatus = updateCtx.options.status;
+    let previousTask;
+    if (requestedStatus && !isTerminalTaskStatus(requestedStatus)) {
+      previousTask = await this.store.getTask(id);
+    }
+    const effectiveOptions = this.withTerminalCurrentStatus(updateCtx.options, previousTask);
+    const task = await this.store.updateTask(id, effectiveOptions);
     if (task) {
       const resultCtx = {
         task,
@@ -482,18 +526,6 @@ class TaskComponent extends BaseComponent {
       await this.executeHook(TaskHookPoints.AFTER_UPDATE, resultCtx);
       this.publishEvent(TaskEntityEventTypes.UPDATED, { task, changes: options, sessionId: "" }, "");
       logger2.info(`[TaskComponent] Task updated: ${id}`);
-      if (options.status && TASK_COMPLETE_TERMINAL_STATUSES.includes(options.status)) {
-        const env = getEnvContextOrEmpty();
-        const completeCtx = {
-          task,
-          changes: options,
-          terminalStatus: options.status,
-          sessionId: env.sessionId ?? "",
-          tagService: this.tagService
-        };
-        await this.executeHook(TaskHookPoints.AFTER_COMPLETE, completeCtx);
-        logger2.info(`[TaskComponent] Task completed (AFTER_COMPLETE fired): ${id} -> ${options.status}`);
-      }
     }
     return task;
   }
@@ -526,9 +558,13 @@ class TaskComponent extends BaseComponent {
     if (existing && existing.type === "cycle") {
       throw new Error(`Cannot complete cycle task: #${id} - ${existing.title}. Cycle tasks are not meant to be completed.`);
     }
+    if (existing && TERMINAL_NON_ACCEPTABLE_STATUSES.includes(existing.status)) {
+      throw new Error(`Cannot complete task: #${id} - ${existing.title}. ` + `It is already in terminal status "${existing.status}". ` + `Reopen it first via task_update(status="active") if acceptance should proceed.`);
+    }
     const updateOptions = {
       status: "completed",
-      progress: 100
+      progress: 100,
+      current_status: deliverableStoragePath ? `${TASK_COMPLETED_STATUS_WORD}（${TASK_DELIVERABLE_RECORDED}：${deliverableStoragePath}）` : TASK_COMPLETED_STATUS_WORD
     };
     if (deliverableStoragePath) {
       let existingContext = {};
@@ -562,6 +598,59 @@ class TaskComponent extends BaseComponent {
   async updateTaskContext(id, context) {
     return this.store.updateTask(id, { context });
   }
+  async preCompleteTask(id, sessionId, deliverableStoragePath, progressSummary) {
+    const existing = await this.store.getTask(id);
+    if (existing && existing.type === "cycle") {
+      throw new Error(`Cannot pre-complete cycle task: #${id} - ${existing.title}. Cycle tasks are not meant to be completed or submitted for acceptance.`);
+    }
+    const toValidateWording = progressSummary ? `${TASK_TO_VALIDATE_STATUS_WORD}：${progressSummary}` : TASK_TO_VALIDATE_STATUS_WORD;
+    const updateOptions = {
+      status: "to_validate",
+      current_status: toValidateWording
+    };
+    if (deliverableStoragePath) {
+      let existingContext = {};
+      if (existing?.context) {
+        try {
+          const parsed = JSON.parse(existing.context);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            existingContext = parsed;
+          }
+        } catch {
+          logger2.warn(`[TaskComponent] Task #${id} context is not valid JSON, ignoring when merging deliverable`);
+        }
+      }
+      existingContext.deliverable_storage_path = deliverableStoragePath;
+      updateOptions.context = JSON.stringify(existingContext);
+    }
+    const task = await this.updateTask(id, updateOptions);
+    if (task) {
+      const env = getEnvContextOrEmpty();
+      const completeCtx = {
+        task,
+        changes: updateOptions,
+        terminalStatus: "to_validate",
+        sessionId: env.sessionId ?? sessionId,
+        tagService: this.tagService
+      };
+      await this.executeHook(TaskHookPoints.AFTER_COMPLETE, completeCtx);
+      const descParts = [];
+      const deliverableLine = formatDeliverableForOperation(deliverableStoragePath);
+      if (deliverableLine)
+        descParts.push(deliverableLine);
+      if (progressSummary)
+        descParts.push(progressSummary);
+      await this.createOperation({
+        taskId: id,
+        sessionId,
+        milestoneType: "milestone",
+        milestoneTitle: `${TASK_TO_VALIDATE_STATUS_WORD}（to_validate）：Task #${id} submitted for acceptance`,
+        milestoneDescription: descParts.join(" / ") || TASK_TO_VALIDATE_STATUS_WORD
+      });
+      logger2.info(`[TaskComponent] Task submitted for acceptance (to_validate): ${id}, deliverable=${deliverableStoragePath || "(none)"}`);
+    }
+    return task;
+  }
   async createOperation(options) {
     const createCtx = {
       options: { ...options }
@@ -630,12 +719,15 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("task.component.completeTask", { recordParams: true, recordResult: true, log: true })
 ], TaskComponent.prototype, "completeTask", null);
+__legacyDecorateClassTS([
+  TracedAs("task.component.preCompleteTask", { recordParams: true, recordResult: true, log: true })
+], TaskComponent.prototype, "preCompleteTask", null);
 __legacyDecorateClassTS([
   TracedAs("task.component.createOperation", { recordParams: true, recordResult: true, log: true })
 ], TaskComponent.prototype, "createOperation", null);
 // src/env/task/types.ts
 import { z } from "zod";
-var TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled", "archived"]);
+var TaskStatusEnum = z.enum(["todo", "active", "to_validate", "completed", "paused", "cancelled", "archived"]);
 var TaskPriorityEnum = z.enum(["low", "medium", "high"]);
 var TaskTypeEnum = z.enum(["normal", "cycle", "longterm"]);
 var ActionTypeEnum = z.enum([

package/dist/shared/@ai-setting/{roy-agent-core-snvh4s2p.js → roy-agent-core-zycadbpx.js}

@@ -2,7 +2,7 @@ import {
   createAutoTaskPlugin,
   createLayaDecisionPlugin,
   registerLayaCompletionTaskHook
-} from "./roy-agent-core-y7x2qzwc.js";
+} from "./roy-agent-core-ghnagzrh.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.75",
+  "version": "1.7.76",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",