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

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

@@ -709,6 +709,22 @@ var init_sqlite_task_store = __esm(() => {
       const limit = options.limit || 20;
       return ops.slice(offset, offset + limit);
     }
+    async listOperationsFresh(options) {
+      await this.initialize();
+      const stmt = this.db.prepare("SELECT * FROM task_operation WHERE task_id = ? ORDER BY id DESC");
+      const rows = stmt.all(options.taskId);
+      let ops = rows.map((row) => this.rowToOperation(row));
+      const filterType = options.milestoneType ?? options.actionType;
+      if (filterType) {
+        ops = ops.filter((op) => op.milestoneType === filterType);
+      }
+      const offset = options.offset || 0;
+      const limit = options.limit || 20;
+      return ops.slice(offset, offset + limit);
+    }
+    invalidateOperationsCache(taskId) {
+      this.operationsCache.delete(taskId);
+    }
     async getTaskIdBySessionId(sessionId) {
       await this.initialize();
       if (!sessionId)
@@ -716,6 +732,13 @@ var init_sqlite_task_store = __esm(() => {
       const row = this.db.prepare("SELECT task_id FROM task_operation WHERE session_id = ? AND milestone_type = 'create' ORDER BY timestamp ASC LIMIT 1").get(sessionId);
       return typeof row?.task_id === "number" ? row.task_id : undefined;
     }
+    async getTaskIdsBySessionId(sessionId) {
+      await this.initialize();
+      if (!sessionId)
+        return [];
+      const rows = this.db.prepare("SELECT DISTINCT task_id FROM task_operation WHERE session_id = ? ORDER BY task_id ASC").all(sessionId);
+      return rows.map((r) => r.task_id).filter((id) => typeof id === "number");
+    }
     rowToTask(row) {
       return {
         id: row.id,

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

@@ -0,0 +1,247 @@
+import {
+  init_decorator,
+  wrapFunction
+} from "./roy-agent-core-qq96p0tj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/task/plugins/task-op-watermark-plugin.ts
+init_logger();
+
+// src/env/task/plugins/fake-user-message-helper.ts
+init_decorator();
+var KIND_PRIORITY = {
+  delegate: 10,
+  "task-ops": 20,
+  "max-iter": 30
+};
+var KIND_FIELD = "__fakeUserMessageKind";
+function ensureMetadata(toolResult) {
+  if (!toolResult)
+    return;
+  if (!toolResult.result)
+    toolResult.result = {};
+  if (!toolResult.result.metadata)
+    toolResult.result.metadata = {};
+  return toolResult.result.metadata;
+}
+function stringContent(msg) {
+  const c = msg?.content;
+  return typeof c === "string" ? c : JSON.stringify(c);
+}
+function enqueueToAddFakeUserMessageImpl(toolResult, newMsg, newKind) {
+  const meta = ensureMetadata(toolResult);
+  if (!meta)
+    return { willMerge: false, finalKind: newKind };
+  const existing = meta.toAddFakeUserMessage;
+  const existingKind = meta[KIND_FIELD];
+  if (!existing) {
+    meta.toAddFakeUserMessage = newMsg;
+    meta[KIND_FIELD] = newKind;
+    return { willMerge: false, finalKind: newKind };
+  }
+  let merged;
+  if (KIND_PRIORITY[newKind] >= KIND_PRIORITY[existingKind ?? newKind]) {
+    merged = {
+      role: "user",
+      content: `${stringContent(existing)}
+
+${stringContent(newMsg)}`
+    };
+  } else {
+    merged = {
+      role: "user",
+      content: `${stringContent(newMsg)}
+
+${stringContent(existing)}`
+    };
+  }
+  meta.toAddFakeUserMessage = merged;
+  const finalKind = KIND_PRIORITY[newKind] >= KIND_PRIORITY[existingKind ?? newKind] ? newKind : existingKind ?? newKind;
+  meta[KIND_FIELD] = finalKind;
+  return { willMerge: true, finalKind };
+}
+var enqueueToAddFakeUserMessage = wrapFunction(enqueueToAddFakeUserMessageImpl, "plugin.fake-user-message.enqueue", {
+  recordParams: false,
+  recordResult: false,
+  log: true,
+  resultFilter: (result) => ({
+    "fake-user-message.will_merge": result.willMerge,
+    "fake-user-message.final_kind": result.finalKind
+  })
+});
+
+// src/env/task/plugins/task-op-watermark-plugin.ts
+var logger = createLogger("TaskOpWatermarkPlugin");
+var TASK_OP_WATERMARK_MAX_REMINDERS = 5;
+var TASK_OP_WATERMARK_MESSAGE_LIMIT = 1500;
+var TASK_OP_WATERMARK_AUDIT_INTERVAL = 15;
+var MAX_DETAIL_ITEMS = 3;
+var MAX_DESC_LENGTH = 200;
+var UNKNOWN_SESSION = "unknown";
+var TRUNCATION_SUFFIX = "…（已截断）";
+function truncate(s, max) {
+  if (s.length <= max)
+    return s;
+  return `${s.slice(0, max)}…（已截断）`;
+}
+function buildReminderMessage(taskId, taskTitle, ops) {
+  const count = ops.length;
+  const lines = [];
+  lines.push(`[task-ops] Task #${taskId}${taskTitle ? `「${taskTitle}」` : ""} 有 ${count} 条由**其他 agent** 新增的操作记录，请读取并按需调整你的行为。`);
+  lines.push("");
+  lines.push("最新记录：");
+  const details = ops.slice(0, MAX_DETAIL_ITEMS);
+  for (const op of details) {
+    const desc = op.milestoneDescription ? truncate(op.milestoneDescription.split(`
+`)[0], MAX_DESC_LENGTH) : "";
+    lines.push(`- [${op.milestoneType}] ${op.milestoneTitle}${desc ? `
+  ${desc}` : ""}`);
+  }
+  if (count > MAX_DETAIL_ITEMS) {
+    lines.push(`（其余 ${count - MAX_DETAIL_ITEMS} 条较旧记录省略，可用 task_operation_list 查看全部）`);
+  }
+  lines.push("");
+  lines.push(`请调用 task_operation_list(task_id=${taskId}) 读取全部新记录，判断是否需要修改你的计划、产出或下一步动作。`);
+  lines.push("若这些记录与你的当前工作无关，忽略即可，无需回复。");
+  return lines.join(`
+`);
+}
+
+class TaskOpWatermarkPlugin {
+  name = "TaskOpWatermarkPlugin";
+  version = "1.0.0";
+  description = "Task #5081 — agent:after.tool 水位比对：同一 task 出现他人（sessionId 过滤 + unknown 过滤）新增的 operation 时，经共享 meta-protocol 注入 user role 提醒（N 聚 1 / 限流 5 / 长度 1500 / 15 次兜底对账 / fresh 旁路绕 operationsCache）。";
+  priority = 40;
+  watermarks = new Map;
+  resolveTaskComponent;
+  constructor(config) {
+    this.resolveTaskComponent = config?.resolveTaskComponent;
+  }
+  async execute(ctx) {
+    try {
+      await this.check(ctx);
+    } catch (err) {
+      logger.warn(`[TaskOpWatermark] check failed (fail-open): ${err?.message}`);
+    }
+    return { continue: true };
+  }
+  async check(ctx) {
+    const sessionId = ctx.context?.sessionId;
+    if (!sessionId)
+      return;
+    const taskComponent = this.resolveTaskComponent?.();
+    if (!taskComponent)
+      return;
+    const taskIds = await this.resolveTaskIds(taskComponent, sessionId);
+    if (taskIds.length === 0)
+      return;
+    const taskKey = taskIds.join(",");
+    let wm = this.watermarks.get(sessionId);
+    if (!wm || wm.taskIds.join(",") !== taskKey) {
+      wm = {
+        lastSeenOpId: 0,
+        lastNotifiedOpId: 0,
+        taskIds,
+        reminderCount: 0,
+        toolsSinceAudit: 0
+      };
+      this.watermarks.set(sessionId, wm);
+    }
+    wm.toolsSinceAudit++;
+    const isAuditTurn = wm.toolsSinceAudit >= TASK_OP_WATERMARK_AUDIT_INTERVAL;
+    if (isAuditTurn)
+      wm.toolsSinceAudit = 0;
+    const lowerBound = isAuditTurn || wm.lastSeenOpId === 0 ? wm.lastNotifiedOpId : wm.lastSeenOpId;
+    let newOps = [];
+    let maxIdSeen = wm.lastSeenOpId;
+    for (const taskId of taskIds) {
+      const ops = await this.listOps(taskComponent, taskId);
+      const othersNew = ops.filter((op) => op.id > lowerBound && !this.isSelf(op, sessionId));
+      for (const op of othersNew) {
+        newOps.push(op);
+        if (op.id > maxIdSeen)
+          maxIdSeen = op.id;
+      }
+      const selfMax = ops.filter((op) => this.isSelf(op, sessionId)).reduce((m, op) => Math.max(m, op.id), 0);
+      maxIdSeen = Math.max(maxIdSeen, selfMax);
+    }
+    const seen = new Set;
+    newOps = newOps.filter((op) => seen.has(op.id) ? false : (seen.add(op.id), true)).sort((a, b) => b.id - a.id);
+    wm.lastSeenOpId = Math.max(wm.lastSeenOpId, maxIdSeen);
+    if (newOps.length === 0)
+      return;
+    if (wm.reminderCount >= TASK_OP_WATERMARK_MAX_REMINDERS) {
+      logger.info(`[TaskOpWatermark] session=${sessionId.slice(0, 12)}... reminder limit reached (${wm.reminderCount}) — watermark advanced silently`);
+      return;
+    }
+    if (!ctx.toolResult)
+      return;
+    const byTask = new Map;
+    for (const op of newOps) {
+      const arr = byTask.get(op.taskId) ?? [];
+      arr.push(op);
+      byTask.set(op.taskId, arr);
+    }
+    const sections = [];
+    for (const [taskId, ops] of byTask) {
+      const title = (await safeGetTask(taskComponent, taskId))?.title;
+      sections.push(buildReminderMessage(taskId, title, ops));
+    }
+    const content = sections.join(`
+
+`);
+    const finalContent = content.length > TASK_OP_WATERMARK_MESSAGE_LIMIT ? `${content.slice(0, TASK_OP_WATERMARK_MESSAGE_LIMIT - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}` : content;
+    enqueueToAddFakeUserMessage(ctx.toolResult, { role: "user", content: finalContent }, "task-ops");
+    wm.reminderCount++;
+    const maxNotified = newOps.reduce((m, op) => Math.max(m, op.id), 0);
+    wm.lastNotifiedOpId = Math.max(wm.lastNotifiedOpId, maxNotified);
+    logger.info(`[TaskOpWatermark] reminder injected: session=${sessionId.slice(0, 12)}..., tasks=${[...byTask.keys()].join(",")}, newOps=${newOps.length}, reminderCount=${wm.reminderCount}`);
+  }
+  isSelf(op, sessionId) {
+    return op.sessionId === sessionId || op.sessionId === UNKNOWN_SESSION;
+  }
+  async resolveTaskIds(tc, sessionId) {
+    if (typeof tc.getTaskIdsBySessionId === "function") {
+      const ids = await tc.getTaskIdsBySessionId(sessionId);
+      return Array.isArray(ids) ? ids : [];
+    }
+    if (typeof tc.getTaskIdBySessionId === "function") {
+      const id = await tc.getTaskIdBySessionId(sessionId);
+      return typeof id === "number" ? [id] : [];
+    }
+    return [];
+  }
+  async listOps(tc, taskId) {
+    if (typeof tc.listOperationsFresh === "function") {
+      return await tc.listOperationsFresh({ taskId, limit: 50 });
+    }
+    if (typeof tc.invalidateOperationsCache === "function") {
+      tc.invalidateOperationsCache(taskId);
+    }
+    return await tc.listOperations({ taskId, limit: 50 });
+  }
+}
+async function safeGetTask(tc, taskId) {
+  try {
+    return await tc.getTask(taskId);
+  } catch {
+    return;
+  }
+}
+function createTaskOpWatermarkPlugin(config) {
+  const inst = new TaskOpWatermarkPlugin(config);
+  return {
+    name: inst.name,
+    version: inst.version,
+    description: inst.description,
+    hooks: [{ point: "agent:after.tool", priority: inst.priority }],
+    execute: async (ctx) => {
+      return inst.execute(ctx);
+    }
+  };
+}
+
+export { enqueueToAddFakeUserMessage, TASK_OP_WATERMARK_MAX_REMINDERS, TASK_OP_WATERMARK_MESSAGE_LIMIT, TASK_OP_WATERMARK_AUDIT_INTERVAL, TaskOpWatermarkPlugin, createTaskOpWatermarkPlugin };

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

@@ -1,7 +1,7 @@
 import {
   LarkCardPatchNotifier,
   formatDurationMs
-} from "./roy-agent-core-nmx9934r.js";
+} from "./roy-agent-core-w0qjeq2v.js";
 import {
   WorkflowHookPoints,
   init_workflow_hook_points

package/dist/shared/@ai-setting/{roy-agent-core-11shp00p.js → roy-agent-core-m46fe3x4.js}

@@ -1,12 +1,8 @@
-// src/env/task/tools/completion-copy.ts
-var TASK_COMPLETE_ITEM_BY_ITEM = "按子项逐条验收";
-var TASK_COMPLETION_HINT_ANCHOR = "TASK_COMPLETION_HINT";
-var TASK_COMPLETE_VERIFY_DUTY = "核实义务";
-var TASK_COMPLETE_ACCEPTANCE = {
-  itemByItem: TASK_COMPLETE_ITEM_BY_ITEM,
-  hintAnchor: TASK_COMPLETION_HINT_ANCHOR,
-  verifyDuty: TASK_COMPLETE_VERIFY_DUTY
-};
+import {
+  TASK_COMPLETE_ITEM_BY_ITEM,
+  TASK_COMPLETE_VERIFY_DUTY,
+  TASK_COMPLETION_HINT_ANCHOR
+} from "./roy-agent-core-4rtg69cn.js";
 
 // src/env/task/prompt/task-discipline.ts
 var TASK_DISCIPLINE_LIFECYCLE = `### Task Lifecycle (7 steps, 0-6)
@@ -59,12 +55,15 @@ var TASK_DISCIPLINE_LIFECYCLE = `### Task Lifecycle (7 steps, 0-6)
    - Update progress (0-100%) as the work advances
    - Update status: todo → active
    - Record \`current_status\` with human-readable progress
-   - ⚠️ **不要**把 status 直接置为 \`completed\` —— 终态由验收方落（见步骤 6）
+   - ⚠️ **不要**把 status 直接置为 \`completed\` 或 \`to_validate\` ——
+     终态由验收方落、待验证由 \`task_pre_complete\` 提交（见步骤 6）
 
 5. RECORD — operation records (see Operation Discipline below)
 
-6. COMPLETE — 收尾分两种角色（Task #5007，验收权分离）
-   - **执行方（roy sub-agent）**：进度达到你判断的 100% ⇒ \`task_update(progress=100)\`
+6. COMPLETE — 收尾分两种角色（Task #5007/#5073，验收权分离）
+   - **执行方（roy sub-agent）**：进度达到你判断的 100% ⇒
+     \`task_pre_complete\` **提交待验证**（\`deliverable_storage_path\`
+     传交付物地址；status → to_validate，并触发一次 goal 检查自查）
      + 最后一条 \`task_operation_create\` ⇒ **结束并返回结果**。
      ❌ **不要调用 \`task_complete\`**（你无此权限）。
    - **验收方（default agent / 接待员）**：\`task_complete\` after item-by-item verification
@@ -163,8 +162,8 @@ Before calling \`task_complete\`, you MUST:
      (b) 确认已完成 → **用你手上有权限的写工具**落一条 \`decision\` 类操作记录
          （\`task_operation_create\`，milestone_type=decision，milestone_title=<一行结论>）
          说明子项实际已达成（说明理由）。若你没有该工具的权限（验收方场景），
-         就通过你的**委托工具**让 sub-agent 代写这条记录，或在 \`task_complete\`
-         的 \`deliverable_storage_path\` / 最终汇报里明确写出核实结论与证据。
+         就通过你的**委托工具**让 sub-agent 代写这条记录，或在最终汇报里
+         明确写出核实结论与证据。
      Never ignore it (不允许无视).
      ⚠️ **核实义务的两条路径都依赖写权限**（\`task_update\` / \`task_operation_create\`）。
      若这些工具对你**不可用**（如验收方不持有执行类工具），必须**改用委托**把动作
@@ -175,22 +174,13 @@ Before calling \`task_complete\`, you MUST:
          (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.
-   It may name **multiple paths** (multiple deliverables), space-separated
-   (\`/tmp/report.md /tmp/diff.patch\`) — the judge splits on whitespace as
-   well as \`,\` \`;\` \`、\` and \` + \`. A local path may also be written in its
-   \`file://\` form (\`file:///tmp/report.md\`) — the scheme is stripped and the
-   path kept. Declare **every** artefact you produced: a path left out reads
-   as "not produced".
-   - 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 submitted by the executor via \`task_pre_complete\`
+   (Task #5073 two-phase acceptance): they live in
+   \`context.deliverable_storage_path\` and the operation trail
+   (\`Deliverable: <path>\` lines). Cross-check them in step 2.
+   \`task_complete\` takes **no** deliverable parameter — if the
+   deliverables are missing from the record, re-delegate instead of
+   asking for a path here.`;
 var TASK_DISCIPLINE_PROMPT = [
   TASK_DISCIPLINE_LIFECYCLE,
   TASK_DISCIPLINE_OPERATION,
@@ -200,4 +190,4 @@ var TASK_DISCIPLINE_PROMPT = [
 
 `);
 
-export { TASK_COMPLETE_ITEM_BY_ITEM, TASK_COMPLETION_HINT_ANCHOR, TASK_COMPLETE_VERIFY_DUTY, TASK_COMPLETE_ACCEPTANCE, TASK_DISCIPLINE_LIFECYCLE, TASK_DISCIPLINE_OPERATION, TASK_DISCIPLINE_GOALS, TASK_DISCIPLINE_COMPLETE, TASK_DISCIPLINE_PROMPT };
+export { TASK_DISCIPLINE_LIFECYCLE, TASK_DISCIPLINE_OPERATION, TASK_DISCIPLINE_GOALS, TASK_DISCIPLINE_COMPLETE, TASK_DISCIPLINE_PROMPT };

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

@@ -1,6 +1,6 @@
 import {
   init_sqlite_task_store
-} from "./roy-agent-core-abqhkbn3.js";
+} from "./roy-agent-core-ezvpreqz.js";
 
 // src/env/task/storage/index.ts
 init_sqlite_task_store();

package/dist/shared/@ai-setting/{roy-agent-core-4gr3k7qg.js → roy-agent-core-rhtdspx6.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,
@@ -36,10 +37,20 @@ import {
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-abqhkbn3.js";
+} from "./roy-agent-core-ezvpreqz.js";
 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),
@@ -458,6 +471,15 @@ class TaskComponent extends BaseComponent {
   async getTaskIdBySessionId(sessionId) {
     return this.store.getTaskIdBySessionId(sessionId);
   }
+  async getTaskIdsBySessionId(sessionId) {
+    const store = this.store;
+    if (typeof store.getTaskIdsBySessionId === "function") {
+      const ids = await store.getTaskIdsBySessionId(sessionId);
+      return Array.isArray(ids) ? ids : [];
+    }
+    const first = await this.store.getTaskIdBySessionId(sessionId);
+    return typeof first === "number" ? [first] : [];
+  }
   async getTaskWithOperations(id) {
     const task = await this.store.getTask(id);
     if (!task)
@@ -465,6 +487,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 +519,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 +535,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 +567,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 +607,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 }
@@ -587,6 +685,16 @@ class TaskComponent extends BaseComponent {
   async listOperations(options) {
     return this.store.listOperations(options);
   }
+  async listOperationsFresh(options) {
+    const store = this.store;
+    if (typeof store.listOperationsFresh === "function") {
+      return await store.listOperationsFresh(options);
+    }
+    if (typeof store.invalidateOperationsCache === "function") {
+      store.invalidateOperationsCache(options.taskId);
+    }
+    return await this.store.listOperations(options);
+  }
   getTagService() {
     return this.tagService;
   }
@@ -630,12 +738,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([