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

package/dist/shared/@ai-setting/{roy-agent-core-7sj9xs9c.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-4jjwewvw.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,13 @@ 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 记录，便于事后追溯验收结论。")
 });
 var BatchArchiveToolSchema = z.object({
   task_ids: z.array(z.number()).describe("要归档的任务 ID 列表"),
@@ -113,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 一致）。")
@@ -699,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,
@@ -828,6 +841,22 @@ function updateTaskTool(taskComponent) {
             };
           }
         }
+        const callerAgentType = ctx.metadata?.agentType ?? undefined;
+        const callerAgentName = ctx.metadata?.agentName ?? undefined;
+        if (params.status === "completed" && callerAgentType === "sub") {
+          const agentComponent = taskComponent.env?.getComponent?.("agent");
+          const callerAgent = callerAgentName && agentComponent?.getAgent ? agentComponent.getAgent(callerAgentName) : undefined;
+          const cfg = callerAgent?.config;
+          const hasCompletePermission = cfg ? Array.isArray(cfg.allowedTools) && cfg.allowedTools.includes("task_complete") || !Array.isArray(cfg.allowedTools) && !(Array.isArray(cfg.deniedTools) && cfg.deniedTools.includes("task_complete")) : false;
+          if (!hasCompletePermission) {
+            return {
+              success: false,
+              output: "",
+              error: `Cannot set status="completed" without acceptance permission (Task #5007 — 验收权分离). ` + `执行方只能推进进度：用 task_update(progress=100) 表示"我这边干完了"，` + `再 task_operation_create 记录结论，然后结束返回；` + `任务终态必须由验收方（default agent / 主智能体）调用 task_complete 落定。`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+        }
         const task = await taskComponent.updateTask(params.task_id, {
           title: params.title,
           description: params.description,
@@ -921,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:
 
@@ -949,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 {
@@ -991,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,
@@ -1001,11 +1051,188 @@ 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: `Task completed: #${task.id} - ${task.title}`,
+          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/cancel-tool.ts
+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.
+
+**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\`
+  (which takes a bg-process id from \`delegate_task\`). If the sub-agent is still
+  running, call \`stop_task\` **first**, then \`task_cancel\` to close the record.
+
+**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")\`.
+
+**Parameters**:
+- \`task_id\` (required): the task to cancel
+- \`reason\` (optional): why it is being cancelled — recorded in the operation trail
+`.trim();
+function cancelTaskTool(taskComponent) {
+  return {
+    name: "task_cancel",
+    description: TASK_CANCEL_DESCRIPTION,
+    parameters: CancelTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = CancelTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const current = await taskComponent.getTask(params.task_id);
+        if (!current) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (NON_CANCELLABLE_STATUSES.has(current.status)) {
+          return {
+            success: false,
+            output: "",
+            error: `Cannot cancel task #${params.task_id}: it is already in terminal status "${current.status}".`,
+            metadata: { execution_time_ms: 0, task_id: params.task_id }
+          };
+        }
+        const task = await taskComponent.updateTask(params.task_id, {
+          status: "cancelled",
+          current_status: params.reason ? `${TASK_CANCELLED_STATUS_WORD}：${params.reason}` : TASK_CANCELLED_STATUS_WORD
+        });
+        if (!task) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        await taskComponent.createOperation({
+          taskId: params.task_id,
+          sessionId,
+          milestoneType: "decision",
+          milestoneTitle: `Task cancelled: #${params.task_id}`,
+          milestoneDescription: params.reason ? `Cancelled by acceptance side. Reason: ${params.reason}` : "Cancelled by acceptance side (no reason given)."
+        });
+        logger5.info(`[cancelTask] Task #${params.task_id} cancelled (previous status: ${current.status})`);
+        return {
+          success: true,
+          output: `Task cancelled: #${params.task_id} - ${task.title}`,
+          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/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 completed: #${task.id} - ${task.title}
-Deliverable (context + operation): ${params.deliverable_storage_path}` : `Task completed: #${task.id} - ${task.title}
+          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 }
         };
@@ -1158,4 +1385,4 @@ function treeTasksTool(taskComponent) {
     }
   };
 }
-export { createTaskTool, getTaskTool, listTasksTool, searchTasksTool, batchArchiveTaskTool, batchDeleteTaskTool, updateTaskTool, deleteTaskTool, completeTaskTool, treeTasksTool };
+export { createTaskTool, getTaskTool, listTasksTool, searchTasksTool, batchArchiveTaskTool, batchDeleteTaskTool, updateTaskTool, deleteTaskTool, completeTaskTool, cancelTaskTool, preCompleteTaskTool, treeTasksTool };

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

@@ -1,28 +1,32 @@
 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-aa2j7bk9.js";
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
 import {
   batchArchiveTaskTool,
   batchDeleteTaskTool,
+  cancelTaskTool,
   completeTaskTool,
   createTaskTool,
   deleteTaskTool,
   getTaskTool,
   listTasksTool,
+  preCompleteTaskTool,
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-7sj9xs9c.js";
+} from "./roy-agent-core-vffccgf6.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -37,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";
@@ -84,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
@@ -184,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)
@@ -336,6 +351,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 +370,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 +402,9 @@ class TaskComponent extends BaseComponent {
       batchDeleteTaskTool(this),
       updateTaskTool(this),
       deleteTaskTool(this),
-      completeTaskTool(this)
+      completeTaskTool(this),
+      cancelTaskTool(this),
+      preCompleteTaskTool(this)
     ];
     const operationToolsList = [
       createOperationTool(this),
@@ -452,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,
@@ -459,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,
@@ -469,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;
   }
@@ -513,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 = {};
@@ -549,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 }
@@ -617,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([