@metagptx/deepflow-suite-cli 0.3.1 → 0.3.2

package/bundle/deepflow-release.json

@@ -2,13 +2,13 @@
   "schemaVersion": 1,
   "distribution": "deepflow-suite",
   "package": "@metagptx/deepflow-suite-cli",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "platform": "any",
   "arch": "any",
   "cli": {
     "name": "deepflow-suite",
     "package": "@metagptx/deepflow-suite-cli",
-    "version": "0.3.1",
+    "version": "0.3.2",
     "command": "deepflow-suite"
   },
   "skills": [
@@ -80,8 +80,8 @@
         },
         {
           "path": "references/fact-types.md",
-          "size": 3974,
-          "sha256": "5dd10c73e652d018ce20617ec8a5e1becb55fb935f15a366831050063a8989fc"
+          "size": 6174,
+          "sha256": "efab99cb46ad24100e834efd3e7ed4ab5e5004bb4b32320cff08ac14d5fa0070"
         },
         {
           "path": "references/query-scope.md",
@@ -95,8 +95,8 @@
         },
         {
           "path": "SKILL.md",
-          "size": 13393,
-          "sha256": "cd1ffc54bf884f02e540ddd4b75c805ed868e32d298d20abcecb3c8af51feb8b"
+          "size": 14374,
+          "sha256": "357d805b8260d0e67a46a7edaef4f443c7be58dec075bfc2f176a83e88ebb5d1"
         }
       ]
     },
@@ -184,8 +184,8 @@
       "files": [
         {
           "path": "SKILL.md",
-          "size": 3492,
-          "sha256": "f04a22e7967727217003071b7ad7c9268fde9058af4e1f8d3de22e28e18ac718"
+          "size": 4577,
+          "sha256": "8c9020f12674d83e0ea88088c4d556a2dc76c39f8372f0f54a26d95b85277352"
         }
       ]
     }

package/bundle/skills/df-agentrt-repo/SKILL.md

@@ -81,6 +81,10 @@ stderr 上的话是给你看的，照着做：
 - 说「remain configured」——仓库加上了，只是检出没成功，可以用 `multica repo checkout <URL>` 重试；
 - 其余的错误信息来自服务端，已经写清楚了原因和下一步。
 
+公司 GitLab 的 SSH 检出因主机校验或 `Permission denied (publickey)` 失败时，个人 Token 和共享 Token 均应通过 HTTPS 使用，不按有没有个人 Token 选择 SSH。若尚未生成工作副本，可将会话中已授权的 `git@gitlab.deepwisdomai.com:<组>/<仓库>.git` 换为同项目的 `https://gitlab.deepwisdomai.com/<组>/<仓库>.git`，保留原 ref，通过 `df-agentrt repo add <HTTPS地址> --ref <原ref>` 注册并检出；原配置未指定 ref 时省略 `--ref`。不要直接把改写后的 URL 交给 `multica repo checkout`，它尚不在精确匹配的白名单中。HTTPS 仍失败时按实际错误报告，不扩大仓库范围或自行提供凭据。
+
+已有工作副本时，不为切换传输方式再次 `repo add` 或 `checkout`，以免重置已有工作；在原目录使用同项目 HTTPS 完成所需 fetch，提交推送遵循已加载的 Git skill。daemon 缓存按仓库 host/path 复用，并不按 SSH/HTTPS 分成两份；检出成功不能证明最新远端 ref 已拉取，按所需 ref 核对远端和实际起点。
+
 ## 加完之后
 
 检出目录和你当前的工作目录是同级的。用 `repo add` 打印出来的绝对路径访问，

package/bundle/skills/df-task/SKILL.md

@@ -31,6 +31,12 @@ metadata 的 `source`、`query_keys` 用于可选软范围过滤，`data` 由业
 
 托管 Run 中 `df-task` 由 Runtime 镜像提供。命令缺失或 `--help` 无法执行时，报告执行环境异常并结束；不要在 Run 中安装、编译 CLI 或猜测绝对路径来继续。非托管的本地开发可按项目 README 安装 CLI。**注意不要把 runtime 的地址填成 Task 服务的地址** —— `df-agentrt` 和 `df-task` 是两个服务、两个端口、两套授权。
 
+## 创建来源与人工参与请求
+
+涉及人的协作时，从 `get` 的不可变 `creator.kind/id` 核对创建来源；owner、当前成员、经办人及正文不能代替。读取来源未知时保持未知。是否选人、何时求助、授予什么责任，由当前 Agent 定义和本次授权判断。
+
+普通 `handoff --ask` 只写公开交接，不请求成员加入。需要实际人工参与时，读取[人工参与请求与回执](references/fact-types.md#请求实际人工参与)，使用 `handoff --participation ensure_member --assignee <真实账号>`；明确授予该人主经办责任时才附加 `--task-assignee`。请求写入成功不等于成员、通知或分配已生效；按请求事实序号核对平台回执，部分成功、失败与未知分别保留。旧 CLI 缺少这些参数时，只有在已加载协议且平台支持的前提下，才可用通用 `append` 提交同一载荷，不能猜字段或把公开答复当作实际邀请。
+
 ## 读日志
 
 先确定本轮要作出的判断，再按需选择事实；不要求每轮先通读全部日志。当前描述与版本用上文的 `get` 读取，事实用于补足决策依据。

package/bundle/skills/df-task/references/fact-types.md

@@ -6,8 +6,8 @@
 
 | 类型 | 谁写 | 必填 | 可选 |
 | --- | --- | --- | --- |
-| `user_message` | 人 | `text` | `wake_policy`、`agent_ids` |
-| `external_result` | 外部系统 | `source`、`ref`、`result` | —— |
+| `user_message` | 人或 bot | `text` | `wake_policy`、`agent_ids` |
+| `external_result` | 外部系统或 bot | `source`、`ref`、`result` | —— |
 
 `wake_policy` 由产品端写入，缺失时按 `default` 处理。`passive` 表示多人对话里人和人之间的讨论，它**不触发**调度，被别的事件唤醒时也只能当作上下文，不能单独据此派活。`agent_ids` 只是人提到的 Agent，作为提示；派给谁仍由调度根据全局事实决定。
 
@@ -32,7 +32,7 @@
 | --- | --- | --- | --- |
 | `dispatch_intent` | `agent`、`instruction`、`mode`；`mode=message` 时还必须有 `target_run_id` | `agent_version`（Driver 读取的正整数版本） | `new_run` 必须省略 `target_run_id`，由 Driver 根据 `task_id + intent_seq` 派生逻辑 Run；`message` 指向已有逻辑 Run并复用原 Session/AgentData，不切换版本。简写 `df-task dispatch` 不支持版本/幂等键，需固定时用 `append` |
 | `waiting_reason` | `waiting_on`、`reason` | `waiting_run_id`（实际执行 ID） | 给人和给下一轮调度的上下文，**不是推进器的门** |
-| `handoff_to_human` | `ask` | `assignee` | 交球和派活是同一条事实，区别只在 `ask` 的内容 |
+| `handoff_to_human` | `ask` | `assignee`、`participation`、`task_assignee` | 交球和派活是同一条事实，区别只在 `ask` 的内容 |
 | `adjudication` | `subject`、`verdict` | `reason` | `subject` 是被裁决那条事实的**序号**（数字，不是字符串） |
 | `run_terminated` | `run_id`、`confirmed_status` | —— | 已经停完并确认之后记录的既成事实 |
 
@@ -48,3 +48,29 @@
 | `attempt_failed` | `watermark`、`reason` | `intent_seq` | 推进失败 |
 
 **「有 started 没有 accepted」是合法的中间状态**，含义是「正在启动，结果未知」。读日志时不要把它当成异常 —— 推进器会靠幂等键重投把它推进到 accepted。`run_kind` 只能是 `scheduler` 或 `task`；只有调度唤起带 `input_watermark`。
+
+## 请求实际人工参与
+
+公开 handoff 本身不等于邀请。平台支持时，scheduler_run 可用以下命令写入实际参与请求；账号须已由调用方核验，`ask` 向接收人说明具体协助事项和相关成果。
+
+```bash
+# 邀请并定向通知；保留现有经办人
+df-task handoff "$DF_TASK_ID" --participation ensure_member \
+  --assignee "$human_id" --ask "$handoff_text" --json
+# 同时明确授予同一人主经办责任
+df-task handoff "$DF_TASK_ID" --participation ensure_member \
+  --assignee "$human_id" --task-assignee "$assignment_json" \
+  --ask "$handoff_text" --json
+```
+
+`assignment_json` 是 `{"kind":"human","id":"与 assignee 相同的真实账号"}`。省略该参数不改经办人，普通答复、补信息与审核不得因定向交接自动改派。通用 `append --type handoff_to_human --file <JSON>` 可提交同一协议：`ask`、`assignee`、`participation: "ensure_member"`，以及明确需要时的 `task_assignee`；不新增另一套操作语义。
+
+命令成功只确认请求事实已写入。读取 `external_result`，以 `source="human_participation"`、`ref="请求事实序号"` 关联回执；`details.request_seq` 应与该序号一致：
+
+- `succeeded`：核对 `member_confirmed`、`member_id`、`notification_id`；请求分配时再核对 `task_assignee`，并读回当前成员与经办人。
+- `failed`：保留错误码及部分成功字段。成员已加入或通知已生成，不代表分配也成功；不得把失败请求当作已交接全部责任。
+- `unknown` 或尚无回执：结果未确认，后续核对同一请求；平台恢复会沿原请求兑现，不因暂未确认而重复邀请。后续真实成功回执可补充先前未知结果，按实际操作及当前状态判断。
+
+通知记录生成不证明人已阅读、回复或批准。邀请、经办人设置、人的实际处理和审核意见是不同事实；本协议不决定何时求助、选择谁或是否接受审核结果。
+
+创建身份从 `df-task get` 的不可变 `creator` 读取，不能从 owner、成员人数或任意 metadata 推断为 bot。未知身份保持未知。

package/manifest.json

@@ -56,5 +56,6 @@
       "project": "deepflow-agent-runtime",
       "entry": "cli/df-agentrt.mjs"
     }
-  ]
+  ],
+  "version": "0.3.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metagptx/deepflow-suite-cli",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Agent-friendly installer and distribution CLI for the DeepFlow suite.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/df-agentctrl/release.json

@@ -1 +1 @@
-{"version":"0.3.1","project":"deepflow-agent-ctrl","sourceCommit":"10e745773559f4712b04ab61915a018995e30630","sourceDirty":false}
+{"version":"0.3.2","project":"deepflow-agent-ctrl","sourceCommit":"dee1a88615b09bd979562902cebc631f81b1859b","sourceDirty":false}

package/runtime/df-agentrt/release.json

@@ -1 +1 @@
-{"version":"0.3.1","project":"deepflow-agent-runtime","sourceCommit":"420ebb91ed4cf92ca81eb8c295cc111f94b9da2c","sourceDirty":false}
+{"version":"0.3.2","project":"deepflow-agent-runtime","sourceCommit":"4492edf7279289b6ca1d29d3d2b444c0757f2b81","sourceDirty":false}

package/runtime/df-task/commands.mjs

@@ -3,7 +3,7 @@ export const help = `df-task — DeepFlow Task fact log CLI
 Usage:
   df-task ls [--limit <n>] [--metadata-source <source>] [--metadata-query-key <key>]
   df-task get <task-id> [--fields <paths> --json] [--metadata-source <source>] [--metadata-query-key <key>]
-  df-task create --title <text> [--description <text>] [--message <text>] [--metadata <json>]
+  df-task create --title <text> [--description <text>] [--message <text>] [--metadata <json>] [--idempotency-key <key>]
   df-task facts <task-id> [--after <seq>] [--types <a,b>] [--limit <n>] [--metadata-source <source>] [--metadata-query-key <key>]
   df-task facts <task-id> --all --output-file <path> --json [--max-pages <n>] [--max-bytes <n>]
   df-task append <task-id> --type <type> --file payload.json [--idempotency-key <k>]
@@ -14,7 +14,7 @@ Usage:
 Scheduling shorthands (each one is a wrapper around append):
   df-task dispatch <task-id> --agent <name> --instruction <text> [--run <run-id>]
   df-task wait <task-id> --on <what> --reason <text> [--waiting-run <run-id>]
-  df-task handoff <task-id> --ask <text> [--assignee <who>]
+  df-task handoff <task-id> --ask <text> [--assignee <who>] [--participation ensure_member] [--task-assignee <json>]
 
 Global options (before or after the command):
   --base-url <url>   Service URL (or DF_TASK_BASE_URL)
@@ -23,7 +23,7 @@ Global options (before or after the command):
 
 Environment:
   DF_TASK_BASE_URL     Service URL, default http://127.0.0.1:8090
-  DF_TASK_ACTOR_KIND   Write identity: human | external | task_run | scheduler_run | driver
+  DF_TASK_ACTOR_KIND   Write identity: human | bot | external | task_run | scheduler_run | driver
   DF_TASK_ACTOR_ID     Write identity id, e.g. the current run id
 
 Facts are append-only. The API has no way to change or remove a fact, so neither does this CLI.
@@ -54,13 +54,14 @@ export const commands = {
     "writes": false
   },
   "create": {
-    "usage": "create --title <text> [--description <text>] [--message <text>] [--metadata <json>]",
+    "usage": "create --title <text> [--description <text>] [--message <text>] [--metadata <json>] [--idempotency-key <key>]",
     "description": "Create a task, optionally with its first user message in the same transaction.",
     "flags": [
       "--title",
       "--description",
       "--message",
-      "--metadata"
+      "--metadata",
+      "--idempotency-key"
     ],
     "required": [
       "--title"
@@ -173,11 +174,14 @@ export const commands = {
     "writes": true
   },
   "handoff": {
-    "usage": "handoff <task-id> --ask <text> [--assignee <who>]",
+    "usage": "handoff <task-id> --ask <text> [--assignee <who>] [--participation ensure_member] [--task-assignee <json>]",
     "description": "Append a handoff to a human. Handing the ball back and asking a human to do a step are the same fact.",
     "flags": [
       "--ask",
-      "--assignee"
+      "--assignee",
+      "--participation",
+      "--task-assignee",
+      "--idempotency-key"
     ],
     "required": [
       "--ask"

package/runtime/df-task/df-task.mjs

@@ -58,8 +58,21 @@ export function validate(o, env) {
   }
   if (spec.writes) {
     if (!env.DF_TASK_ACTOR_KIND?.trim() || !env.DF_TASK_ACTOR_ID?.trim()) throw Error('writing a fact requires DF_TASK_ACTOR_KIND and DF_TASK_ACTOR_ID');
+    if (o.command === 'create') {
+      const key = o.values['--idempotency-key'] || '';
+      if (key.length > 200 || /[^\x21-\x7e]/.test(key) || (env.DF_TASK_ACTOR_KIND === 'bot' && key.length < 8)) throw Error('creation idempotency key must be at most 200 visible ASCII bytes; bot creation requires at least 8 bytes');
+    }
     if (!actorKinds.includes(env.DF_TASK_ACTOR_KIND)) throw Error(`unknown DF_TASK_ACTOR_KIND ${env.DF_TASK_ACTOR_KIND}`);
-    if (o.command === 'metadata' && env.DF_TASK_ACTOR_KIND !== 'human') throw Error('metadata requires DF_TASK_ACTOR_KIND=human');
+    if (o.command === 'metadata' && !['human','bot'].includes(env.DF_TASK_ACTOR_KIND)) throw Error('metadata requires DF_TASK_ACTOR_KIND=human or bot');
+  }
+  if (o.command === 'handoff' && ('--participation' in o.values || '--task-assignee' in o.values)) {
+    const target = o.values['--assignee'];
+    if (o.values['--participation'] !== 'ensure_member') throw Error('--participation must be ensure_member for member operations');
+    if (!target || target.trim() !== target || Buffer.byteLength(target) > 200) throw Error('member operations require a non-empty --assignee of at most 200 bytes without surrounding whitespace');
+    if ('--task-assignee' in o.values) {
+      const assignment = object(o.values['--task-assignee'], '--task-assignee must be a JSON object');
+      if (Object.keys(assignment).length !== 2 || assignment.kind !== 'human' || assignment.id !== target) throw Error('--task-assignee must identify the same human as --assignee');
+    }
   }
   validateReadOptions(o);
 }
@@ -95,8 +108,8 @@ export async function requestFor(o) {
   let type, payload;
   if (c === 'dispatch') { type = 'dispatch_intent'; payload = { agent: v['--agent'], instruction: v['--instruction'], mode: v['--run'] ? 'message' : 'new_run', ...(v['--run'] ? { target_run_id: v['--run'] } : {}) }; }
   if (c === 'wait') { type = 'waiting_reason'; payload = { waiting_on: v['--on'], reason: v['--reason'], ...(v['--waiting-run'] ? { waiting_run_id: v['--waiting-run'] } : {}) }; }
-  if (c === 'handoff') { type = 'handoff_to_human'; payload = { ask: v['--ask'], ...(v['--assignee'] ? { assignee: v['--assignee'] } : {}) }; }
-  return post(`${path}/facts`, { type, payload });
+  if (c === 'handoff') { type = 'handoff_to_human'; payload = { ask: v['--ask'], ...(v['--assignee'] ? { assignee: v['--assignee'] } : {}), ...(v['--participation'] ? { participation: v['--participation'] } : {}), ...(v['--task-assignee'] ? { task_assignee: object(v['--task-assignee'], '--task-assignee must be a JSON object') } : {}) }; }
+  return post(`${path}/facts`, { type, payload, ...(v['--idempotency-key'] ? {idempotency_key:v['--idempotency-key']} : {}) });
 }
 function human(command, data, stdout) {
   const page = JSON.parse(data, (_key, value, context) => typeof value === 'number' && !Number.isSafeInteger(value) && /^-?\d+$/.test(context.source) ? BigInt(context.source) : value) || {};
@@ -149,6 +162,7 @@ export async function run(args, { env = process.env, stdout = process.stdout, st
   const request = async (options, limit = 0) => {
     const req = options === o ? initialRequest : await requestFor(options);
     const headers = req.body ? { 'Content-Type': 'application/json' } : {};
+    if (o.command === 'create' && o.values['--idempotency-key']) headers['Idempotency-Key'] = o.values['--idempotency-key'];
     if (req.method !== 'GET') { headers['X-DF-Actor-Kind'] = env.DF_TASK_ACTOR_KIND; headers['X-DF-Actor-Id'] = env.DF_TASK_ACTOR_ID; }
     const response = await fetch(base.replace(/\/+$/, '') + req.path, { method: req.method, body: req.body, headers, signal: AbortSignal.timeout(30000) });
     const data = await readResponse(response, limit);

package/runtime/df-task/protocol.mjs

@@ -1,3 +1,3 @@
 // Generated by generate-protocol.mjs from internal/model/fact.go.
 export const factTypes = ["task_lifecycle","user_message","external_result","artifact_published","summary","help_requested","run_outcome","dispatch_intent","waiting_reason","handoff_to_human","adjudication","run_terminated","invocation_started","invocation_accepted","invocation_ended","attempt_failed"];
-export const actorKinds = ["human","external","task_run","scheduler_run","driver"];
+export const actorKinds = ["human","bot","external","task_run","scheduler_run","driver"];

package/runtime/df-task/read.mjs

@@ -18,7 +18,7 @@ export function validateReadOptions(o) {
   const v = o.values;
   if ('--fields' in v) {
     if (!o.json) throw Error('--fields requires --json');
-    const roots = o.command === 'get' ? ['id', 'title', 'description', 'description_version', 'metadata', 'created_at', 'updated_at'] : ['seq', 'type', 'actor_kind', 'actor_id', 'payload', 'idempotency_key', 'created_at'];
+    const roots = o.command === 'get' ? ['id', 'title', 'description', 'description_version', 'creator', 'metadata', 'created_at', 'updated_at'] : ['seq', 'type', 'actor_kind', 'actor_id', 'payload', 'idempotency_key', 'created_at'];
     const paths = v['--fields'].split(',');
     paths.forEach((field, i) => {
       const parts = field.split('.');

package/runtime/df-task/release.json

@@ -1 +1 @@
-{"version":"0.3.1","project":"deepflow-task","sourceCommit":"a5b9064298158aad2fef2a67f0baa0a638c89f4b","sourceDirty":false}
+{"version":"0.3.2","project":"deepflow-task","sourceCommit":"cc53e86834b19e8a4fe73f9e9a08d76853d51e51","sourceDirty":false}

package/runtime/df-taskdriver/release.json

@@ -1 +1 @@
-{"version":"0.3.1","project":"deepflow-task-driver","sourceCommit":"c05efdc13dfd0d7a9043007f7421dbd1ac6daab2","sourceDirty":false}
+{"version":"0.3.2","project":"deepflow-task-driver","sourceCommit":"c05efdc13dfd0d7a9043007f7421dbd1ac6daab2","sourceDirty":false}

package/runtime/df-workbench/df-workbench.mjs

@@ -48,6 +48,7 @@ export function parseArgs(argv, env = process.env) {
     after: "",
     limit: "",
     scope: "mine",
+    offset: "",
     squadId: undefined,
     file: undefined,
     attachmentIds: [],
@@ -60,6 +61,7 @@ export function parseArgs(argv, env = process.env) {
       options.json = true;
       continue;
     }
+    if(argument==='--receipt-only'){options.receiptOnly=true;continue;}
     if (argument === "--help" || argument === "-h") {
       options.help = true;
       continue;
@@ -78,19 +80,27 @@ export function parseArgs(argv, env = process.env) {
         "--after",
         "--limit",
         "--scope",
+        "--offset",
         "--squad-id",
         "--file",
         "--attachment-id",
         "--member-id",
-        "--expected-owner",
-        "--owner-id",
+        "--assignee-id",
+        "--expected-assignee",
         "--participant-id",
+        "--creation-mode",
+        "--request-seq",
+        "--followup-context",
       ].includes(name)
     ) {
       const parsed =
         inline === undefined ? valueAfter(argv, index, name) : inline;
       if (inline === undefined) index += 1;
       if (name === "--base-url") options.baseUrl = parsed;
+      if (name === "--creation-mode") {
+        if(!['atomic','staged'].includes(parsed))throw new UsageError('--creation-mode 需为 atomic 或 staged。');
+        options.creationMode=parsed;
+      }
       if (name === "--workspace") options.workspace = parsed;
       if (name === "--expected-actor") {
         if (!parsed.trim() || parsed.length > 160 || /[\r\n]/.test(parsed))
@@ -103,12 +113,30 @@ export function parseArgs(argv, env = process.env) {
       if (name === "--after") options.after = parsed;
       if (name === "--limit") options.limit = parsed;
       if (name === "--scope") options.scope = parsed;
+      if (name === "--offset") options.offset = parsed;
       if (name === "--squad-id") options.squadId = parsed;
       if (name === "--file") options.file = parsed;
       if (name === "--attachment-id") options.attachmentIds.push(parsed);
       if (name === "--member-id") options.memberId = parsed;
-      if (name === "--expected-owner") options.expectedOwner = parsed;
-      if (name === "--owner-id") options.ownerId = parsed;
+      if (name === "--request-seq") options.requestSeq=parsed;
+      if (name === "--followup-context") {
+        let value;try{value=JSON.parse(parsed);}catch{throw new UsageError('--followup-context 需要原提醒关联 JSON。');}
+        if(!value||Array.isArray(value)||Object.keys(value).length!==4||Object.keys(value).some(k=>!['task_instance_id','recipient_id','request_seq','version'].includes(k))||
+          typeof value.task_instance_id!=='string'||!value.task_instance_id||value.task_instance_id.length>2048||/[\u0000-\u001f\u007f]/.test(value.task_instance_id)||
+          typeof value.recipient_id!=='string'||!/^[\w-]{1,160}$/.test(value.recipient_id)||!Number.isSafeInteger(value.request_seq)||value.request_seq<1||typeof value.version!=='string'||!/^[a-f0-9]{64}$/.test(value.version))throw new UsageError('--followup-context 原提醒关联无效。');
+        options.followupContext=value;
+      }
+      if (name === "--assignee-id") options.assigneeId = parsed;
+      if (name === "--expected-assignee") {
+        let baseline;
+        try { baseline=JSON.parse(parsed); } catch { throw new UsageError('--expected-assignee 需要 JSON 原值基线。'); }
+        const v=baseline?.value;
+        if(!baseline || Array.isArray(baseline) || typeof baseline.present!=='boolean' ||
+          Object.keys(baseline).some(k=>!['present','value'].includes(k)) ||
+          (baseline.present ? !Object.hasOwn(baseline,'value') || v!==null && (!v || !['human','agent'].includes(v.kind) || !/^[\w-]{1,100}$/.test(v.id||'') || Object.keys(v).some(k=>!['kind','id'].includes(k))) : Object.hasOwn(baseline,'value')))
+          throw new UsageError('--expected-assignee 原值基线无效。');
+        options.expectedAssignee=baseline;
+      }
       if (name === "--participant-id") options.participantIds.push(parsed);
       continue;
     }
@@ -200,6 +228,7 @@ async function request(options, path, requestOptions = {}, context = {}) {
   const baseUrl = normalizeBaseUrl(options.baseUrl);
   const url = new URL(path, `${baseUrl}/`);
   const headers = requestHeaders(options, context, requestOptions.key);
+  if(requestOptions.receiptOnly)headers['X-Deepflow-Message-Receipt']='lookup';
   if (requestOptions.body !== undefined)
     headers["Content-Type"] = "application/json";
   let response;
@@ -241,7 +270,7 @@ async function request(options, path, requestOptions = {}, context = {}) {
   return data;
 }
 
-async function currentContext(options) {
+async function currentContext(options,requireWorkspace=true) {
   const me = await request(
     options,
     "/api/v1/me",
@@ -249,12 +278,12 @@ async function currentContext(options) {
     options.workspace ? { workspace: options.workspace } : {},
   );
   const workspace = options.workspace || me.workspaceId;
-  if (!workspace)
+  if (!workspace&&requireWorkspace)
     throw new RequestError("Workbench 没有返回当前工作区。", {
       code: "workspace_missing",
     });
   if (
-    Array.isArray(me.workspaces) &&
+    workspace && Array.isArray(me.workspaces) &&
     !me.workspaces.some((item) => item.id === workspace)
   )
     throw new RequestError(`当前用户无权访问工作区：${workspace}`, {
@@ -277,6 +306,8 @@ async function currentContext(options) {
 
 async function loadConfig(options) {
   const context = await currentContext(options);
+  if(context.me.user.principalKind==='bot')return {baseUrl:normalizeBaseUrl(options.baseUrl),identity:context.me.user,workspaces:context.me.workspaces,
+    workspace:context.me.workspaces.find(w=>w.id===context.workspace),authentication:context.me.authentication,capabilities:context.me.capabilities};
   const [platform, auth, readiness, capabilities] = await Promise.all([
     request(options, "/api/v1/platform-state"),
     request(options, "/api/v1/auth/config"),
@@ -451,18 +482,21 @@ function help() {
   df-workbench squad create --file <配置.json> [--idempotency-key <key>] [--json]
   df-workbench squad update <squad-id> --file <配置.json> [--idempotency-key <key>] [--json]
   df-workbench workspace members [--json]
-  df-workbench task create --message <消息> [--title <标题>] [--squad-id <squad-id>] [--owner-id <user-id>] [--participant-id <user-id>] [--idempotency-key <key>]
+  df-workbench task create --message <消息> [--title <标题>] [--squad-id <squad-id>] [--assignee-id <user-id>] [--creation-mode <atomic|staged>] [--participant-id <user-id>] [--idempotency-key <key>]
+  df-workbench task assign <task-id> --member-id <user-id> [--expected-assignee <JSON基线>] [--idempotency-key <key>]
   df-workbench task member-options <task-id>
   df-workbench task invite <task-id> --member-id <user-id> [--idempotency-key <key>]
-  df-workbench task transfer-owner <task-id> --member-id <user-id> --expected-owner <user-id> [--idempotency-key <key>]
   df-workbench task send <task-id> --message <消息> [--idempotency-key <key>]
+  df-workbench task followup-context <task-id> --member-id <user-id> [--request-seq <seq>]
+  df-workbench task delivery-context <task-id> --member-id <user-id>
   df-workbench task lookup <DF-number> [--json]
   df-workbench task get <task-id> [--json]
   df-workbench task facts <task-id> [--after <seq>] [--limit <n>] [--json]
-  df-workbench task list [--scope <mine|workspace>] [--limit <n>] [--json]
+  df-workbench task list [--scope <mine|workspace>] [--limit <n>] [--offset <n>] [--json]
   df-workbench attachment upload --file <文件> [--idempotency-key <key>] [--json]
 
 task create/send 可重复传入 --attachment-id <id>，每次最多 10 个。
+task send 可携带 --followup-context <原提醒JSON>；--receipt-only 仅核对原幂等键的消息回执，不创建新消息。
 
 全局配置：
   DF_WORKBENCH_BASE_URL       Workbench 根地址，默认 http://127.0.0.1:8793
@@ -481,11 +515,13 @@ async function run(options) {
     process.stdout.write(`${help()}\n`);
     return;
   }
-  if ((options.ownerId !== undefined || options.participantIds.length) && !(command === "task" && subject === "create")) throw new UsageError("--owner-id 和 --participant-id 仅用于 task create。");
-  if (options.ownerId !== undefined && !/^[\w-]{1,100}$/.test(options.ownerId)) throw new UsageError("初始负责人 ID 无效。");
-  if ((options.memberId !== undefined && !(command === "task" && ["invite","transfer-owner"].includes(subject))) ||
-      (options.expectedOwner !== undefined && !(command === "task" && subject === "transfer-owner")))
-    throw new UsageError("成员和负责人参数只用于对应的任务成员命令。");
+  if ((options.assigneeId !== undefined || options.participantIds.length) && !(command === "task" && subject === "create")) throw new UsageError("--assignee-id 和 --participant-id 仅用于 task create。");
+  if (options.assigneeId !== undefined && !/^[\w-]{1,100}$/.test(options.assigneeId)) throw new UsageError("初始负责人 ID 无效。");
+  if (options.memberId !== undefined && !(command === "task" && ["invite","assign","followup-context","delivery-context"].includes(subject))) throw new UsageError("--member-id 仅用于邀请、指定负责人或核对提醒对象。");
+  if(options.followupContext && !(command==='task'&&subject==='send'))throw new UsageError('--followup-context 仅用于向原任务回复。');
+  if(options.receiptOnly && !(command==='task'&&subject==='send'))throw new UsageError('--receipt-only 仅用于核对原消息回执。');
+  if(options.requestSeq!==undefined && !(command==='task'&&subject==='followup-context'))throw new UsageError('--request-seq 仅用于核对原提醒。');
+
   if (
     options.squadId !== undefined &&
     !(command === "task" && subject === "create")
@@ -553,12 +589,12 @@ async function run(options) {
     return;
   }
   if (command === "me") {
-    const context = await currentContext(options);
+    const context = await currentContext(options,false);
     writeResult(
       context.me,
       options,
       (value) =>
-        `用户: ${value.user.name} (${value.user.id})\n工作区: ${value.workspaceId}`,
+        `身份: ${value.user.principalKind||"human"} · ${value.user.name} (${value.user.id})\n工作区: ${value.workspaceId}`,
     );
     return;
   }
@@ -579,17 +615,50 @@ async function run(options) {
     writeResult(value,options,value => value.members.map(member=>`${member.userId} ${member.name || ""}`).join("\n"));return;
   }
   if (command !== "task") throw new UsageError(`不支持的命令：${command}`);
-  if (["member-options", "invite", "transfer-owner"].includes(subject)) {
+  if (subject === 'transfer-owner') throw new UsageError('此任务操作已停用。');
+  if(subject==='capabilities') {
+    const context=await currentContext(options),value=await request(options,'/api/v1/task-ui/capabilities',{},context);
+    writeResult(value,options,value=>JSON.stringify(value));return;
+  }
+  if(['followup-context','delivery-context'].includes(subject)) {
+    const taskId=rest[0];
+    if(!/^[\w-]{1,160}$/.test(taskId||'')||!/^[\w-]{1,160}$/.test(options.memberId||''))throw new UsageError('需要任务 ID 和 --member-id 提醒对象。');
+    const context=await currentContext(options),query=new URLSearchParams({recipient_id:options.memberId});
+    if(options.requestSeq!==undefined)query.set('request_seq',String(integerOption(options.requestSeq,'--request-seq',0,1,Number.MAX_SAFE_INTEGER)));
+    const value=await request(options,`/api/v1/task-ui/tasks/${encodeURIComponent(taskId)}/${subject}?${query}`,{},context);
+    if(value?.taskId!==taskId||value.recipientId!==options.memberId||typeof value.taskInstanceId!=='string'||!value.taskInstanceId||!Number.isSafeInteger(value.requestSeq)||value.requestSeq<1||!/^[a-f0-9]{64}$/.test(value.version||''))throw new RequestError('原提醒关联回执不匹配。',{code:'task_lookup_mismatch'});
+    if(subject==='delivery-context'&&(value.kind!=='delivery'||!Array.isArray(value.artifacts)||!value.artifacts.length||!Number.isSafeInteger(value.startedSeq)||!Number.isSafeInteger(value.endedSeq)))throw new RequestError('交付版本回执不匹配。',{code:'task_lookup_mismatch'});
+    writeResult(value,options,value=>`原请求 #${value.requestSeq}：${value.text}`);return;
+  }
+  if (["member-options", "invite", "assign"].includes(subject)) {
     const taskId = rest[0];
     if (!taskId || !/^[\w-]{1,160}$/.test(taskId)) throw new UsageError("需要有效的 Task ID。");
     const writes = subject !== "member-options";
     if (writes && !/^[\w-]{1,100}$/.test(options.memberId || "")) throw new UsageError("需要 --member-id 指定有效的 DF 用户 ID。");
-    if (subject === "transfer-owner" && !/^[\w-]{1,100}$/.test(options.expectedOwner || "")) throw new UsageError("需要 --expected-owner 指定当前负责人 ID。");
     const context = await currentContext(options);
-    const path = subject === "member-options" ? `/api/v1/task-ui/tasks/${encodeURIComponent(taskId)}/property-options`
-      : `/api/v1/tasks/${encodeURIComponent(taskId)}/${subject === "invite" ? "member-invitations" : "owner-transfer"}`;
-    const value = await request(options, path, writes ? {method:"POST", key:idempotencyKey(options), body:subject === "invite"
-      ? {invitee_ids:[options.memberId]} : {new_owner_id:options.memberId,expected_owner_id:options.expectedOwner}} : {}, context);
+    let value;
+    if(subject==='assign') {
+      const current=(await request(options,`/api/v1/tasks/${encodeURIComponent(taskId)}`,{},context)).task;
+      if(current?.id!==taskId||current.metadata?.data?.workspace_id!==context.workspace)throw new RequestError('任务范围未确认。',{code:'task_metadata_mismatch'});
+      const presentation=current.metadata.data.presentation||{},key=idempotencyKey(options);
+      const assignee=Object.hasOwn(presentation,'assignee')?{present:true,value:presentation.assignee}:{present:false};
+      if(options.expectedAssignee) {
+        const expected=options.expectedAssignee;
+        const same=expected.present===assignee.present && (!expected.present || expected.value===null&&assignee.value===null || expected.value?.kind===assignee.value?.kind&&expected.value?.id===assignee.value?.id);
+        const alreadyAssigned=presentation.assignee?.kind==='human' && presentation.assignee.id===options.memberId;
+        if(!same&&!alreadyAssigned)throw new RequestError('负责人已变化，请重新核对分配要求。',{code:'task_assignee_changed',status:409});
+      }
+      // The original baseline is part of the idempotent command, including after
+      // a successful write whose response was lost.
+      const baselineAssignee=options.expectedAssignee || assignee;
+      value=await request(options,`/api/v1/tasks/${encodeURIComponent(taskId)}/presentation`,{method:'POST',key,body:{changes:{assignee:{kind:'human',id:options.memberId}},baseline:{assignee:baselineAssignee}}},context);
+      const saved=value?.task,data=saved?.metadata?.data;
+      if(saved?.id!==taskId||data?.workspace_id!==context.workspace||data.presentation?.assignee?.kind!=='human'||data.presentation.assignee.id!==options.memberId)
+        throw new RequestError('负责人保存回执未确认，请保留原幂等键核对。',{code:'task_metadata_mismatch',outcome:'unknown',taskId,idempotencyKey:key});
+    } else {
+      const path=subject==='member-options'?`/api/v1/task-ui/tasks/${encodeURIComponent(taskId)}/property-options`:`/api/v1/tasks/${encodeURIComponent(taskId)}/member-invitations`;
+      value=await request(options,path,writes?{method:'POST',key:idempotencyKey(options),body:{invitee_ids:[options.memberId]}}:{},context);
+    }
     writeResult(value, options, value => JSON.stringify(value));
     return;
   }
@@ -599,17 +668,24 @@ async function run(options) {
       options.title,
       options.squadId,
     );
-    if (options.ownerId) {
-      if (![options.ownerId,...options.participantIds].every(id=>/^[\w-]{1,100}$/.test(id))) throw new UsageError("初始负责人和参与人 ID 无效。");
-      body.initial_owner_id=options.ownerId;
-      body.first_message="";
+    if (options.assigneeId) {
+      if (![options.assigneeId,...options.participantIds].every(id=>/^[\w-]{1,100}$/.test(id))) throw new UsageError("初始负责人和参与人 ID 无效。");
+      if(options.creationMode==='atomic') {body.initial_presentation={assignee:{kind:'human',id:options.assigneeId}};body.first_message=messageValue(options.message);}
+      else {body.initial_assignee_id=options.assigneeId;body.first_message="";}
       body.invitee_ids=[...new Set(options.participantIds)].sort();
-    } else if(options.participantIds.length) throw new UsageError("--participant-id 需要同时指定 --owner-id。");
-    if (options.attachmentIds.length && !options.ownerId)
+    } else if(options.participantIds.length) throw new UsageError("--participant-id 需要同时指定 --assignee-id。");
+    if (options.attachmentIds.length && (!options.assigneeId || options.creationMode==='atomic'))
       body.attachment_ids = options.attachmentIds;
     const context = await currentContext(options);
+    if(context.me.user.principalKind==='bot') {
+      if(options.assigneeId||options.squadId||options.attachmentIds.length)throw new UsageError('Bot 创建任务不支持指定人工负责人、小队或初始附件；附件可在创建后通过 task send 提交。');
+      delete body.conversation;
+      body.title ||= Array.from(body.description.split('\n')[0]).slice(0,80).join('');
+    }
     const key = idempotencyKey(options);
-    let value = await request(
+    let atomicCreation=options.creationMode==='atomic';
+    let value;
+    try {value = await request(
       options,
       "/api/v1/tasks",
       {
@@ -618,7 +694,17 @@ async function run(options) {
         body,
       },
       context,
-    );
+    );} catch(error) {
+      // A checked validation rejection has not applied the staged command. An
+      // idempotency conflict can also be an atomic receipt from before upgrade.
+      // Reuse the original key; never fall back after an unknown write outcome.
+      const rejected=error instanceof RequestError && (error.status===422 && error.code==='invalid_input' || error.status===409 && error.code==='idempotency_conflict');
+      if(!options.assigneeId || atomicCreation || !rejected)throw error;
+      const atomicBody={...body,first_message:messageValue(options.message),initial_presentation:{assignee:{kind:'human',id:options.assigneeId}},...(options.attachmentIds.length?{attachment_ids:options.attachmentIds}:{})};
+      delete atomicBody.initial_assignee_id;
+      value=await request(options,'/api/v1/tasks',{method:'POST',key,body:atomicBody},context);
+      atomicCreation=true;
+    }
     if (
       body.squad_id &&
       value?.task?.metadata?.data?.squad?.squadId !== body.squad_id
@@ -632,10 +718,13 @@ async function run(options) {
           idempotencyKey: key,
         },
       );
-    if (options.ownerId) {
+    if (options.assigneeId) {
       const task=value?.task,data=task?.metadata?.data;
-      if (!task?.id || data?.workspace_id!==context.workspace || data.owner_id!==options.ownerId || data.created_by!==context.actorId ||
-        ![context.actorId,options.ownerId,...options.participantIds].every(id=>data.members?.includes(id))) throw new RequestError("已创建的任务初始负责人或成员回执不匹配，请保留原幂等键核对，不要重建。",{code:"task_metadata_mismatch",outcome:"unknown",taskId:task?.id,idempotencyKey:key});
+      if (!task?.id || data?.workspace_id!==context.workspace || (data.presentation?.assignee?.kind!=='human'||data.presentation.assignee.id!==options.assigneeId) || data.created_by!==context.actorId ||
+        ![context.actorId,options.assigneeId,...options.participantIds].every(id=>data.members?.includes(id))) throw new RequestError("已创建的任务初始负责人或成员回执不匹配，请保留原幂等键核对，不要重建。",{code:"task_metadata_mismatch",outcome:"unknown",taskId:task?.id,idempotencyKey:key});
+      // Atomic creation freezes the initial message and squad in the server's
+      // creation receipt; only the staged protocol needs a second message.
+      if(!atomicCreation) {
       // Current squad edits must never change a retry of the original message.
       const agentId=data.initial_message_context?.agentId;
       if (!agentId) throw new RequestError("任务已创建，但创建时的小队快照没有可接收首条消息的伙伴；请保留原任务与幂等键核对。",{code:"initial_agent_unavailable",outcome:"unknown",taskId:task.id,idempotencyKey:key});
@@ -648,6 +737,7 @@ async function run(options) {
       }
       if (!Number.isSafeInteger(first?.fact?.seq) || first.fact.task_id!==task.id) throw new RequestError("初始消息回执不匹配；保留原任务与幂等键重试。",{code:"initial_message_unconfirmed",outcome:"unknown",taskId:task.id,idempotencyKey:key});
       value={...value,first_fact:first.fact,first_fact_seq:first.fact.seq};
+      }
     }
     writeResult(value, options, taskSummary);
     return;
@@ -663,8 +753,10 @@ async function run(options) {
       {
         method: "POST",
         key,
+        receiptOnly:options.receiptOnly===true,
         body: {
           text: messageValue(options.message),
+          ...(options.followupContext?{followup_context:options.followupContext}:{}),
           ...(options.attachmentIds.length
             ? { attachment_ids: options.attachmentIds }
             : {}),
@@ -750,6 +842,7 @@ async function run(options) {
       `/api/v1/tasks?${new URLSearchParams({
         scope: options.scope,
         limit: String(limit),
+        offset: String(integerOption(options.offset, "--offset", 0, 0, 1048576)),
         include_state: "1",
       })}`,
       {},

package/runtime/df-workbench/release.json

@@ -1 +1 @@
-{"version":"0.3.1","project":"deepflow-workbench","sourceCommit":"b83963f15f4ed187164464dddbfd2ea460f52971","sourceDirty":false}
+{"version":"0.3.2","project":"deepflow-workbench","sourceCommit":"adfb558b1c3532b338b5a8b0d5c11a43739e4ca6","sourceDirty":false}