@whaletalk/dsh-codex-collab 0.1.6 → 0.1.9

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+## 0.1.9 — 2026-10-13
+
+> **0.1.8 从未发布到 npm。** `v0.1.8` tag 建立后，CI 的 Linux gate 在 `test/codex-associations.test.mjs` 暴露了一个**仅测试代码**的跨平台断言缺陷：
+> 读取"目录位置被文件占住"的路径时，Linux 报 `ENOTDIR`（抛 `store-unreadable`）、Windows 报 `ENOENT`（落 `unknown-task`），而原断言只认后者。
+> 已把该断言改为跨平台不变量（写失败必须抛错；读失败必须响亮、且不得带出 record）。按"不得覆盖既有 tag/version"的规定，本版改用 **0.1.9** 发布；
+> **功能内容与 0.1.8 完全相同**（tag `v0.1.8` 仍指向当时的提交，未被移动）。
+
+### 来源关联（R1）：Codex 派活 → DSH 执行 → 按来源精确收回
+
+- **持久绑定**：`dsh_task` / `dsh_review`（MCP）、`POST /api/dsh-bridge/task|review` 与 CLI 新增可选 `originThreadId`（发起这次派活的 Codex 对话 id）。
+  网关在**执行前**把「来源对话 → taskId → 执行目标」落盘到 `~/.dsh-codex-task-assoc/<namespace>/bindings.jsonl`（追加型 JSONL + 独占写锁，`DSH_CODEX_TASK_ASSOC_DIR` / `DSH_BRIDGE_ASSOC_NAMESPACE` 可覆盖）；
+  **首次绑定失败就不启动执行**，终态/失败/取消/交付确认都写回。
+- **跨回合/跨进程收取**：`dsh_task_status`（MCP）与 `dsh-task --my-tasks` / `--status <taskId> --origin <id>`（CLI）按 `origin + taskId` 精确取值，或只给来源列出该对话登记过的任务（找回丢失的 taskId）。
+  缺来源 → `origin-required`、错来源 → `origin-mismatch`，**绝不返回别的对话的结果**；旧的无来源调用保持兼容。
+- **会话任务按请求回合关联结果**（不再依赖"派发前基线 + 全会话 idle"）：`prompt.requestId` → `user/message.source.rpcId` → 按 `seq` 有序跟踪未闭合 turn → 只收**自己那个 turn** 的助手文本；
+  **只有 `turn/end` 的 `reason.kind === completed` 算成功**，`aborted/blocked/error/max-tokens/interrupted/forked` 是明确失败（部分文字进 `partialResult`）。
+  follow 开场的 `snapshot.records` 也会被检查（快任务可能已跑完）；`api-session/status` 只当作"读一次日志的机会"，**不是**完成证明；没有证据 → `status:"unknown"` + `resend:false`（不猜 done、不重发）。
+- **带来源时拒绝 `steer`**（`origin-steer-unsupported`，执行前拒绝、零投递）：若干请求会共用同一个 turn，无法为单个请求保证归属。
+- **能力握手**：`/status`、`/tasks`、`/debug` 上报 `capabilities.originBinding`；MCP/CLI 带来源时先只读核验（不靠包版本猜），旧网关 → **零执行拒绝**；
+  网关接受请求但未回显匹配的 `originThreadId` → 按"未确认、不要重发"上报（CLI 退出码 8）。
+- **同通道单在途**：同一 `cwd + lane`（评审=同目录）有在途任务时明确 `worker-bucket-busy` / `reviewer-bucket-busy` 拒绝，避免完成结果归属靠猜；不同 lane/目录仍并行。
+
+### DSH → Codex 收件箱与只读探针
+
+- `mcp/codex-inbox.mjs` + `harness/codex-outbox.mjs`：追加型事件日志 + **单把独占写锁**（`harness/fs-lock.mjs`，与关联存储共用同一实现；在线竞争期间绝不自动回收，死持有者/不可确认元数据都 fail closed 并给人工清理步骤）。
+- `mcp/codex-desktop-probe.mjs`：只读能力探针；采集层 `-ErrorAction Stop` + 显式 payload 标记，**非终止错误不会被当成"扫描成功且为空"**；
+  桌面身份要求祖先链先遇到安装式桌面 App（穿过另一份 app-server 的派生实例单列）。
+- **桌面自动唤醒仍为 blocked**（M0：本机桌面 app-server 以 `stdio://` 由 `ChatGPT.exe` 私有持有，无可附着端点）；`canWakeIdle` 恒为 `false`，本版不宣称自动唤醒。
+
+### 验证
+
+`node --test test/*.test.mjs`：**117 项**通过（含真实 `http.Server` + 独立 MCP/CLI 进程的跨回合收取、重启恢复、旧网关零执行拒绝等端到端用例）；
+另通过 Codex 侧独立正向契约检查（入口 12/12、会话关联 4/4）与真实 canary。

package/README.md

@@ -204,11 +204,11 @@ tunnel-client run --profile dsh
 ```jsonc
 // 1) 找到会话（只读）
 dsh_sessions({ "query": "按文档启动OKX策略实验计划" })
-// → { "items": [{ "sessionId": "session-8d481ad9-…", "snippet": "按文档启动OKX策略实验计划",
+// → { "items": [{ "sessionId": "session-example-…", "snippet": "按文档启动OKX策略实验计划",
 //                 "agentAvailable": true }], "matchedBy": "list" }
 
 // 2) 投递进那条会话
-dsh_task({ "instruction": "继续推进第 3 步…", "sessionId": "session-8d481ad9-…" })
+dsh_task({ "instruction": "继续推进第 3 步…", "sessionId": "session-example-…" })
 // deliver 可选 "queue"（默认，排队）或 "steer"（插入当前回合）
 ```
 
@@ -218,8 +218,9 @@ dsh_task({ "instruction": "继续推进第 3 步…", "sessionId": "session-8d48
 # 新建子代理（默认行为）
 dsh-task --in "<指令>" --cwd "<目录>" [--lane backend] [--model fast|pro] [--commit]
 
-# 接进已有会话：先找，再派
+# 接进已有会话：先找（或先空跑验证），再派
 dsh-task --sessions "<标题关键词>"                    # 只读列候选，拿 sessionId
+dsh-task --dry-run --find "<标题关键词>"               # 只解析目标、回显命中，不投递任何消息
 dsh-task --in "<指令>" --session "<sessionId>" [--steer]
 dsh-task --in "<指令>" --find "<标题关键词>"           # 唯一命中才派；否则退出码 4
 
@@ -232,16 +233,24 @@ dsh-task --list | --status <taskId> | --cancel <taskId> [--force]
 ```bash
 # 1) 找到（只读，不创建任何东西）
 dsh-task --sessions "按文档启动OKX策略实验计划"
-# → {"items":[{"sessionId":"session-8d481ad9-…","snippet":"按文档启动OKX策略实验计划",
+# → {"items":[{"sessionId":"session-example-…","snippet":"按文档启动OKX策略实验计划",
 #              "agentAvailable":true}],"total":1,"matchedBy":"list"}
 
+# 1b) 没命中时会给近似候选（按标题相似度 + 最近更新排序），换词重查或改用 sessionId——
+#     绝不要发一条消息去"试探命中"（它会落进对方会话并跑成回合，污染对话）
+dsh-task --dry-run --find "量化框架"
+# → {"resolved":false,"reason":"session-query-empty",
+#    "candidates":[{"sessionId":"1c0f99f8-…","snippet":"你是一个量化研究项目的技术","score":0.333}, …]}
+
 # 2) 接通（投递进那条会话；这一轮的助手回复作为汇报返回，只回报本轮新增文本）
-dsh-task --in "<继续推进的指令>" --session "session-8d481ad9-…"
+dsh-task --in "<继续推进的指令>" --session "session-example-…"
 ```
 
 `matchedBy` 说明"找到"走了哪条路：`search` = 会话搜索索引；`list` = 索引被部署禁用时退回遍历列表 + 标题投影（都不激活 Agent）。
 
-失败一律返回稳定 `reason` 且**不创建任何会话/工作区**：`session-query-empty`（没命中）、`session-ambiguous`（多条命中，附 `candidates`）、`session-not-found`、`session-busy`、`session-writer-held`（会话被别的写入方占用）、`session-archived`、`session-not-accepted`、`session-timeout`、`session-cancel-refused`（取消会话目标默认被拒，需 `--force`）。
+**`delivered` 与排队语义**（重要）：`prompt` 一旦被目标会话接受，就表示消息**已经进了它的队列**，响应里会带 `delivered: true`；此后即便我们的观察超时（会话可能正跑一个很长的回合），也**不要重发**——重发会让同一份内容在用户会话里出现两次。`queue` 模式不再用 120s 判失败：没在 120s 内开跑只记一条 note 并继续等，最终由总预算（默认 1h）收口为 `session-timeout` + `delivered: true`。
+
+失败返回稳定 `reason` 且**不创建任何会话/工作区**：`session-query-empty`（没命中，附 `candidates`）、`session-ambiguous`（多条命中，附 `candidates`）、`session-not-found`、`session-busy`、`session-writer-held`（会话被别的写入方占用）、`session-archived`、`session-not-accepted`（仅当 prompt **未被接受**）、`session-timeout`、`session-cancel-refused`（取消会话目标默认被拒，需 `--force`）。
 
 ## 反向通道：让 DSH 调用 Codex
 
@@ -295,6 +304,91 @@ codex exec "把刚才的 diff 审一遍，只回结论" --cd E:\proj
 
 > 注意：插件自带的 `dsh_collab_send` / `dsh_collab_review` 是 **DSH 侧入口**，只回到同一个网关，**不经过 Codex**。要"叫 Codex 干活"用上面 A/B；要"让 Codex 那条对话继续"，只能等 Codex 自己下一轮（`dsh_task --wait` 或 `dsh_task_status`）。
 
+## DSH → Codex 收件箱（桌面自动唤醒：blocked）
+
+目标形态是"DSH 主动往 Codex Desktop 正在用的那条聊天发一条消息，并让它开始处理"。**M0 实测本机做不到**：桌面 app-server 以默认 `stdio://` 启动、端点归 `ChatGPT.exe` 私有，既没有 `--listen` 出的 ws/TCP 端点，也没有文档所说的 app-server 控制套接字——详见 [`docs/codex-desktop-attachment-evidence.md`](docs/codex-desktop-attachment-evidence.md)。
+
+因此先交付可独立验证的一半（用法见 [`docs/DSH_TO_CODEX_INBOX.md`](docs/DSH_TO_CODEX_INBOX.md)）：
+
+```bash
+node mcp/codex-desktop-probe.mjs --schema        # 只读能力探针：还要不要继续谈唤醒，看它
+node mcp/codex-inbox.mjs capabilities            # 能力如实上报：deliveryMode=inbox, canWakeIdle=false
+node mcp/codex-inbox.mjs bind --binding <id> --thread <codexThreadId> [--source <DSH会话id>]
+node mcp/codex-inbox.mjs send --binding <id> --text "<正文>" [--key <幂等键>]
+node mcp/codex-inbox.mjs pending                 # Codex 侧/用户主动来读
+```
+
+- 收件箱：追加型事件日志 + **单把独占写锁**（幂等检查 / seq 分配 / 绑定更新 / 追加都在锁内）。
+  锁是 `<root>/.write.lock` 这个共享路径上的**一次原子独占创建**（硬链接发布 / `wx`），谁创建成功谁进临界区；
+  **在线竞争期间绝不自动回收**（"检查共享路径再删除"无法原子化，会删掉别人刚建的新锁）。
+  持有者活着 → 有限等待后 `lock-timeout`；持有者已死 → **二次确认**后 `lock-stale-holder`；元数据不可确认 → `lock-unverified-holder`；
+  后两者都是**可恢复错误 + 人工清理**（文档给了步骤），宁可阻塞也不冒双写者风险。
+  追加前修复**记录边界**，残尾不会吞掉后续写入；状态机 `queued → delivered → acked`（另有 `failed` / `delivery-unknown`）；
+  存储损坏明确报错，不伪装成空收件箱。
+- **未绑定一律拒绝**，不猜目标、不从最近使用里挑默认；授权线程 ID 只存在于本地绑定，不作为发布默认值。
+- CLI 参数严格：带值旗标缺值或未知旗标一律 exit 2，且在打开存储之前拒绝。
+- 明确不宣称：**自动唤醒、观察回合事件均未实现**；死持有者需人工清理（非自动恢复）、断电级持久性、
+  跨机（网络文件系统）锁语义均未验证/不自动（见用法文档 §4）。
+- 现有六个 MCP 工具与 `dsh_collab_send` 语义未改动。
+
+验证：`node test/codex-outbox.test.mjs`（24 项，含真多进程并发、6 进程压测、活持有者期间零写入）、
+`node test/codex-inbox-cli.test.mjs`（6 项）、`node test/codex-desktop-probe.test.mjs`（11 项，含采集层失败判定）、
+`node mcp/codex-desktop-probe.mjs --schema`（现场能力报告）。
+
+## 来源关联：Codex 对话 → 任务 → 结果（跨回合精确收取）
+
+"本来就是 Codex 驱使 DSH 派活"这件事现在有**显式身份**了：派活时带上发起对话 id（`originThreadId`），
+网关在**执行前**把「来源对话 → taskId → 执行目标」持久落盘；之后任何回合（哪怕是新的 MCP 进程、网关重载后的新实例）
+都能按 `originThreadId + taskId` 精确取回这次任务的结果。详见 [`docs/CODEX_DSH_TASK_REPLY_PLAN.md`](docs/CODEX_DSH_TASK_REPLY_PLAN.md)。
+
+```bash
+# 派活（MCP 工具 dsh_task / dsh_review 的 originThreadId 参数同理，必须显式传当前对话 id）
+dsh-task --in "<指令>" --cwd "<目录>" --origin "<当前 Codex 对话 id>"
+
+# 下一个回合：只凭来源找回 taskId，再精确取结果
+dsh-task --my-tasks --origin "<当前 Codex 对话 id>"
+dsh-task --status "<taskId>" --origin "<当前 Codex 对话 id>"
+```
+
+- **持久关联记录**：`{originThreadId, taskId, target, status, createdAt, updatedAt, delivered, result/error}`，
+  追加型 JSONL + 与收件箱**同一套独占写锁**；位置在用户数据目录 `~/.dsh-codex-task-assoc/<namespace>/bindings.jsonl`
+  （`DSH_CODEX_TASK_ASSOC_DIR` / `DSH_BRIDGE_ASSOC_NAMESPACE` 可覆盖；**测试全部用临时 root，绝不默认写仓库**）。
+  namespace 是**校验过的短标识**且 origin/taskId 从不参与路径拼接；日志追加 + taskId 全局唯一 ⇒ 多个网关不会互相覆盖记录。
+- **绑定不可改投**：同一 taskId 换来源直接拒绝；`originThreadId` 必须是合法非空字符串——**字段未传**才是旧的无关联模式，
+  显式给空串 / null / 纯空白 / 非字符串一律在执行前拒绝（`invalid-origin`），绝不静默回落或改用环境变量。
+- **执行前落盘**：首次持久绑定失败就**不启动 DSH 执行**（绝不出现"执行了却没绑定"）；终态/失败/取消/交付确认都写回。
+- **派活前只读核验网关能力**：`/status`、`/tasks`、`/debug` 上报 `capabilities.originBinding.supported`；
+  MCP/CLI 带来源时必须先确认它为 true（**不靠包版本猜**）——旧网关会忽略 `originThreadId` 却照常返回 accepted，
+  从而产生未绑定任务，所以不支持时**零执行拒绝**。旧的无来源调用完全兼容。
+- **会话任务的结果归属**（带来源时）：不能再用"派发前基线 + 全会话 idle"（那会把别的请求的输出算给当前 taskId）。
+  改用 `prompt.requestId`（=taskId）→ DSH 的 `user/message.source.rpcId` → 按 `seq` 有序跟踪未闭合回合 → 只收**自己那个 turn** 的助手文本，
+  并且**只有该 turn 的 `turn/end.reason.kind === 'completed'` 才算成功**（其余 aborted/blocked/error/max-tokens/interrupted/forked 是明确失败，
+  部分文字放 `partialResult`）。follow 开场的 `snapshot.records` 也会被检查（快任务可能已经跑完）；`api-session/status` 只当作"读一次日志的机会"，
+  **不是**完成证明。落盘并回显（内存分支与恢复分支都给）：`requestId`（=taskId）与匹配到的 `dshTurn`；
+  `turnEndKind`/`partialResult` 以及未确认时的 `resend`/`note` **只在活任务的内存响应里**出现（不在持久记录里；
+  重启后非终态记录由恢复分支合成 `unknown` + `resend:false`）。
+- **带来源时拒绝 `steer`**（`origin-steer-unsupported`，执行前拒绝、零投递）：steer 会把一批请求合进同一个回合，无法为单个请求保证归属。
+- **没有证据就是未确认**：无匹配 `rpcId` 的终态、quiet/预算到期 → `status:"unknown"` + `resend:false`，绝不猜 done、绝不重发。
+- **网关必须回显并匹配 `originThreadId` 才算确认绑定/取值**：能力检查通过≠这次绑定成功（网关可能中途重载/旧 handler）。
+  未确认时 MCP/CLI 都按"未确认 + 禁止重发"上报（CLI 退出码 8），**不返回**那种响应里的结果。
+- **读结果必须匹配来源**：缺来源 → `origin-required`、错来源 → `origin-mismatch`（内存与重启后一致，`/cancel` 同样检查），
+  **绝不返回别的对话的结果**；只有真正未关联的旧任务保持"只给 taskId"兼容查询。
+- **同一通道（cwd+lane，评审=目录）同时只允许一个在途任务**：第二个明确 `worker-bucket-busy` / `reviewer-bucket-busy` 拒绝——
+  完成事件只能归属到通道里最老的那个任务，并发派活会让结果归属变成猜测。不同 lane/目录仍并行；上一任务结束后可继续复用同一子代理。
+- **恢复边界**：已完成结果在网关重载/新实例后仍能按 `origin+taskId` 取回；**没跑完**的任务（精确查询或只给来源列表）一律返回
+  `status: "unknown"` + `resend: false`（执行/交付状态未能确认，保留已知 `delivered` 与原目标），**不谎报完成、不自动重发、不去猜 DSH 最近助手文本**。
+  内存 200 条上限只淘汰**终态**任务（活任务永不被挤掉），持久记录不受影响。
+- 不按"最近/标题/时间"猜发起对话；`taskId` 是关联标识，**不是授权凭据**，也不等于线程 id。
+- **自动唤醒仍然 `false`**：来源关联解决的是"派活回报精确归属"，不是"唤醒空闲桌面聊天"。
+
+验证：`node test/codex-r1-contracts.test.mjs`（8 项：非法来源零执行、已关联任务缺/错来源拒绝、通道 busy、旧网关零执行拒绝、能力上报、
+能力通过但未确认来源 → 未确认+禁止重发、列表 unknown 语义、CLI 严格参数）、
+`node test/codex-session-correlation.test.mjs`（8 项：真实 SDK 字段的请求↔回合关联：排队请求忽略先前回合、只有自己 turn/end 才完成、
+error/blocked 不得 done、snapshot.records、重复投递不串文本、快照缺前半段回填、无匹配 rpcId → 未确认、steer 拒绝）、
+`node test/codex-association-e2e.test.mjs`（3 项：**真实 HTTP + 独立 MCP 进程 + 独立 CLI 进程** 的跨回合收取与重启恢复）、
+`node test/codex-associations.test.mjs`（13 项：存储/不可改投/来源校验/失败不泄漏 record/跨重启/命名空间隔离/真多进程并发/任务表淘汰）、
+`node test/dsh-bridge.test.mjs`（13 项：非法来源 400、执行前落盘、新实例恢复、200+ 记录、存储故障拒绝派活）。
+
 ## 环境变量
 
 | 变量 | 默认 | 说明 |
@@ -306,6 +400,8 @@ codex exec "把刚才的 diff 审一遍，只回结论" --cd E:\proj
 | `DSH_BRIDGE_SESSION_DISPATCH_TIMEOUT_MS` | `120000` | 会话任务被接受后、迟迟没开始跑的容忍时间（仍在排队则报 `session-not-accepted`） |
 | `DSH_BRIDGE_SESSION_QUIET_TIMEOUT_MS` | `600000` | 见过 running 之后多久没有新助手文本算跑完 |
 | `DSH_BRIDGE_SESSION_TOTAL_TIMEOUT_MS` | `3600000` | 单个会话任务的总预算 |
+| `DSH_CODEX_TASK_ASSOC_DIR` | `~/.dsh-codex-task-assoc` | 任务关联记录的存储根（**默认只在用户目录，绝不写仓库**） |
+| `DSH_BRIDGE_ASSOC_NAMESPACE` | `default` | 关联记录的命名空间（`[A-Za-z0-9._-]{1,64}`）；多 profile 可各自一个来分隔存储 |
 
 ## 已知限制
 
@@ -317,7 +413,11 @@ codex exec "把刚才的 diff 审一遍，只回结论" --cd E:\proj
 - **冷会话可能接不上**：DSH 激活 Agent 需要会话投影（`Agent activation requires a projected Session observation`），未激活的会话会返回 `session-not-activatable`；归档会话的回合会以 `blocked` 收口（`session-archived`）
 - **评审不支持会话目标**：评审员必须与编码会话隔离，"独立评审"才成立
 - session 目标不使用 `cwd`/`lane`/`model`/`--commit`（会话自带这些语义），传了会被判 `invalid-target`
-- 网关重启会丢失内存中的任务表（含 session 观察器），这是既有设计
+- 网关重启会丢失内存中的任务表（含 session 观察器），这是既有设计；**但来源关联任务的终态结果在持久记录里**，重启后仍可按 `origin+taskId` 取回；没跑完的会明确返回 `unknown` + `resend:false`（不谎报、不重发）
+- 关联记录只对**显式带 `originThreadId`** 的派活生效；不带来源的旧任务是"无关联"的（只能按 taskId 查活在内存里的状态，查询到就返回 0，查不到退出码 6）
+- 恢复路径**不重新观察**已失去运行时上下文的活任务（未实现），因此这类任务只能得到 `unknown`；要去现实里确认就自己去看目标会话/工作目录——**不要重发**
+- **同一通道同时只允许一个在途任务**（含评审：同一目录一个）：第二个被 `worker-bucket-busy` / `reviewer-bucket-busy` 拒绝，避免完成结果被猜给错误的任务。这是为了保护结果归属，代价是"同 lane 快速连发"需要等前一条结束（或换 lane）
+- **MCP 侧用 `fetch` 调网关**：若网关端口落在 fetch 规范的禁用端口（`1/7/9/…/6000/6665-6669/6697/10080` 等），undici 会直接以 `bad port` 拒绝连接（表现为"网关在跑但 MCP 全部失败、且没有任何网关日志"）。默认端口（3080 / GUI 端口）不受影响；CLI 用 `node:http`，不受该限制。
 - **替换包内容不会热重载**：升级后必须重启 profile 进程，否则跑的还是旧 JS 模块（HMR 只重挂组合，不复用新代码）
 - **组合包被取消选中 = 插件完全不挂载**：此时所有 `/api/dsh-bridge/*` 都落到网关鉴权层返回 401（不是 404，容易误判成没装）
 - **DSH profile 的 pnpm 供应链冷却**：新发布的版本约 24 小时内会被 `minimumReleaseAge` 拒绝安装（`ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`）；管理器会把它写进 `pnpm-workspace.yaml` 的 `minimumReleaseAgeExclude` 才放行。刚发版就装不上属正常，不是包的问题

package/codex-plugin/plugins/dsh/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Codex 主导的双向编码协作插件：ChatGPT 把编码任务下发给本机 DeepSeek Harness 的持久编码子代理执行，DeepSeek 在共享工作目录 D:\\Harness 中写代码并实时回传进度与汇报，Codex 读文件验收、反馈修正，直到通过。",
   "author": {
     "name": "FuJackGao"

package/codex-plugin/plugins/dsh/skills/dsh-collab/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: dsh-collab
-description: "与 DeepSeek Harness 编码协作。当用户要写代码、建项目、改代码时使用：把编码任务交给本机 DeepSeek Harness 执行（DeepSeek 写代码，你负责验收）。两种派活方式——默认在 --cwd 指定的工作目录新建编码子代理；也可以把任务投递进**用户正在用的那一条已有会话**（保留它自己的上下文，不新建会话/工作区）。DeepSeek 完成后可自动 git 提交，并可用独立评审子代理审查 diff（评审员会实际跑通构建/测试）。不通过则发修正指令迭代，直到通过再向用户汇报。"
+description: "与 DeepSeek Harness 编码协作。当用户要写代码、建项目、改代码时使用：把编码任务交给本机 DeepSeek Harness 执行（DeepSeek 写代码，你负责验收）。两种派活方式——默认在 --cwd 指定的工作目录新建编码子代理；也可以把任务投递进**用户正在用的那一条已有会话**（保留它自己的上下文，不新建会话/工作区）。派活时带 --origin（当前 Codex 对话 id）把任务与来源对话持久绑定，之后任何回合都能按 origin+taskId 精确取回这次任务的结果。DeepSeek 完成后可自动 git 提交，并可用独立评审子代理审查 diff（评审员会实际跑通构建/测试）。不通过则发修正指令迭代，直到通过再向用户汇报。"
 ---
 
 # DeepSeek Harness 编码协作
@@ -30,22 +30,30 @@ description: "与 DeepSeek Harness 编码协作。当用户要写代码、建项
 ## 找到已有会话（只读，不创建任何东西）
 
 ```bash
-dsh-task --sessions "<标题或内容关键词>"
+dsh-task --sessions "<标题或内容关键词>"          # 只读列出候选
+dsh-task --dry-run --find "<标题关键词>"          # 只解析目标、回显命中结果，不投递
 ```
 
-输出候选（`sessionId` + 片段）。**必须唯一命中**才能直接用；多条会返回 `candidates` 让你改用 `--session <id>`。退出码 `4` = 没命中或不唯一。
+输出候选（`sessionId` + 片段）。**必须唯一命中**才能直接用；多条会返回 `candidates` 让你改用 `--session <id>`。
+
+没命中时会额外给出 `candidates`（按标题相似度 + 最近更新排序）——**换词重查，或直接确认用户指的是哪一条**。
+
+> ⛔ **绝不投递任何消息来"验证命中"**（例如发一条「占位/测试/忽略本条」）。真实事故：调用方搜不到标题后发了条占位消息试探，它解析成了用户自己的会话，于是**作为一条真实用户消息落进对话并跑成回合**，会话里的 agent 还以为那是用户发的。验证命中只有两种合法手段：上面的 `--sessions` 和 `--dry-run`。
+>
+> ⛔ **看到 `delivered: true` 就不要重发**。它表示 prompt 已被那条会话接受、进了它的队列；我们只是没等到它开跑（会话可能正忙着一个很长的回合）。重发会让同一份内容在用户会话里出现两次。用 `--status <taskId>` 继续观察。
 
 ## 下发任务
 
 ```bash
 # 1) 新建子代理（原有行为）
-dsh-task --in "<完整中文指令>" --cwd "<工作目录>" [--lane <通道>] [--model fast|pro] [--commit] [--timeout 秒]
+dsh-task --in "<完整中文指令>" --cwd "<工作目录>" [--lane <通道>] [--model fast|pro] [--commit] [--timeout 秒] [--origin <Codex对话id>]
 
 # 2) 投递进已有会话
-dsh-task --in "<完整中文指令>" --session "<sessionId>" [--steer] [--timeout 秒]
+dsh-task --in "<完整中文指令>" --session "<sessionId>" [--steer] [--timeout 秒] [--origin <Codex对话id>]
 dsh-task --in "<完整中文指令>" --find "<标题关键词>"     # 唯一命中才派发，否则退出码 4
 ```
 
+- `--origin <id>`：**来源关联**——发起这次派活的 Codex 对话 id。**每个回合派活都要显式传它**（传当前这条对话的 id）：任务会在执行前把「来源对话 → taskId → 执行目标」持久落盘，之后任何回合都能按 `origin + taskId` 精确取回这次任务的结果。未显式传时，CLI 会退回本次调用的环境变量 `CODEX_THREAD_ID`；两者都没有就按"无关联"派活（旧行为）。`--require-origin` 表示"没有来源就拒绝派活"，不会静默降级。
 - `--cwd`：**默认传 Codex 当前打开的项目目录**（绝对路径，正斜杠）；不存在时自动创建并注册为 harness 工作区。与 `--session`/`--find` 互斥。
 - `--lane`：并行通道名（默认 main）。同一目录不同 lane 的任务**并行执行**；跨目录天然并行。
 - `--model`：`fast`（deepseek-v4-flash，快而省）或 `pro`（deepseek-v4-pro，质量优先）；默认继承当前模型。session 目标不使用此参数（会话自己有模型）。
@@ -53,7 +61,40 @@ dsh-task --in "<完整中文指令>" --find "<标题关键词>"     # 唯一命
 - `--steer`：仅 session 目标。默认 `queue`（排队，等它忙完再跑）；`--steer` 会插入当前回合、改变它正在做的事——**只在用户明确要求打断时用**。
 - 指令必须包含：目标与产出物、验收标准、约束。`--wait` 为默认行为（结果直接回本对话），长任务加 `--timeout 1800`。
 
-退出码：`0` 成功 / `1` 失败 / `2` 用法 / `3` 超时 / `4` 会话未命中或不唯一 / `5` session 目标取消被拒。
+退出码：`0` 成功 / `1` 失败 / `2` 用法（含缺少来源、`--origin` 缺值、网关不支持来源绑定） / `3` 超时 / `4` 会话未命中或不唯一 / `5` session 目标取消被拒 / `6` 按 taskId 查询取不到（未知任务 / 已关联但缺来源 / 来源不匹配） / `7` 派活被拒（通道忙） / `8` 网关未确认来源绑定（可能已执行，**不要重发**）。
+
+## 跨回合精确收取（来源关联，推荐每个回合都做）
+
+```bash
+# 派活时带来源（显式 --origin，或本次调用环境里的 CODEX_THREAD_ID）
+dsh-task --in "<指令>" --cwd "<目录>" --origin "<当前对话id>"
+
+# 下一个回合：只凭来源找回这次对话派过的任务（找回丢失的 taskId）
+dsh-task --my-tasks --origin "<当前对话id>"
+
+# 按来源 + taskId 精确取结果
+dsh-task --status "<taskId>" --origin "<当前对话id>"
+```
+
+- **归属靠来源，收取靠 taskId**：来源对话 id 决定"这次任务属于哪条对话"，taskId 决定"是哪一次派活"。两者都不匹配时查询**明确拒绝**（退出码 6，绝不返回别的对话的结果）。
+- `taskId` 是**关联标识**，不是授权凭据，也不是线程 id；`originThreadId` 只是关联元数据。
+- **来源必须在派活前核验网关真的支持**（只读能力查询，不是猜版本）：旧网关会忽略 `originThreadId` 却照常返回 accepted，从而产生"未绑定"任务——所以带来源的派活/查询在**不支持时直接拒绝、零执行**。旧的无来源调用仍然兼容。
+- **显式来源必须合法**：空串 / null / 纯空白 / 非字符串一律拒绝（退出码 2 / `invalid-origin`），**不会**回落到无关联模式，也不会改用环境变量。
+- **同一通道（`--cwd` + `--lane`）同时只允许一个在途任务**：第二个会被明确拒绝（`worker-bucket-busy` / `reviewer-bucket-busy`，退出码 7）——因为完成事件只能归属到"通道里最老的那个任务"。等它结束，或换一个 `--lane` 并行。不同 lane / 不同目录天然并行。
+- **已关联任务必须带来源才能读**：缺来源 → `origin-required`、错来源 → `origin-mismatch`（退出码 6），内存与重启后一致；只有旧的未关联任务保持"只给 taskId"兼容查询。
+- **授递进已有会话时的结果归属（带 `--origin`）**：任务靠 `requestId`（=taskId，写进 DSH 的 `user/message.source.rpcId`）关联到**自己那个 DSH 回合**，
+  只收该回合的助手文本；只有该回合并以 `completed` 结束才算成功，`aborted/blocked/error/max-tokens/interrupted/forked`
+  一律是**明确失败**（部分文字放在 `partialResult`，仅内存可见；落盘的是 `status`/`error`/`reason`/`requestId`/`dshTurn`）。
+  因此"会话里别的回合跑完"不会把你的任务判成完成。
+- **带来源时不能用 `--steer`**：steer 会把一批请求合进同一个回合，无法为你的请求单独保证归属；会被**执行前拒绝**（`origin-steer-unsupported`，零投递）。
+  旧的无来源 steer 行为保留。
+- **没有证据就是未确认**：`api-session/status` 只表示 agent 是否在跑，**不是**你的请求完成的证明。
+  若一直没观察到匹配回合的结束（例如快照/日志里缺前半段），到时会返回 `status: "unknown"` + `resend: false`——**不要重发**。
+- **网关必须回显来源才算确认**：派活/取值的响应里必须带**匹配的** `originThreadId`；若网关接受了请求却没回显（例如中途重载/旧 handler），
+  一律按"未确认、不要重发"上报（退出码 8），绝不当成功、也绝不把那种响应里的结果当精确取值。
+- **超时但 `delivered: true`**：消息已在目标会话队列里 → **查原 taskId，不要重发**。
+- **网关重启后**：已完成的关联任务仍能按 `origin + taskId` 取回（持久记录）；没跑完的任务会返回 `status: "unknown"` + `resend: false`（执行/交付状态未能确认，**不要重发**，也不要去猜"最近一条助手文本"）。只给来源列任务时同样：没有本实例运行上下文的记录一律显示 `unknown`，不会谎报"还在跑"。
+- 不按"最近使用的对话"猜目标，也不自动重发。
 
 ## 读取汇报与验收
 
@@ -74,8 +115,10 @@ dsh-review --cwd "<工作目录>" [--diff git|git-staged|@文件|"diff 文本"]
 ## 任务管理
 
 ```bash
-dsh-task --list                        # 最近任务列表
+dsh-task --list                        # 最近任务列表（可加 --origin <id> 只看本对话的）
 dsh-task --status <taskId>             # 查询单个任务（含 target 回显）
+dsh-task --status <taskId> --origin <id>   # 按来源精确取值（推荐；取不到时退出码 6）
+dsh-task --my-tasks --origin <id>      # 列出该来源登记过的任务（找回丢失的 taskId）
 dsh-task --cancel <taskId>             # 取消 worker 任务
 dsh-task --cancel <taskId> --force     # 取消 session 目标任务（会打断用户自己的回合，默认被拒）
 ```

package/codex-plugin/plugins/dsh/skills/dsh-collab/scripts/task.mjs

@@ -2,7 +2,9 @@
 // Codex → DeepSeek Harness 任务脚本：POST 指令到桥网关，可轮询等待结果。
 // 功能：--cwd 工作目录 / --lane 并行通道 / --model 模型别名 / --commit 完成后 Git 提交
 //       --wait 等待结果（默认）/ --list 任务列表 / --cancel <taskId> / --status <taskId>
-// 用法: node task.mjs --in "<指令>" [--cwd 目录] [--lane 名] [--model fast|pro] [--commit] [--timeout 秒]
+//       --origin <Codex对话id> 来源关联（跨回合精确收取；显式参数优先，其次本次调用的 CODEX_THREAD_ID）
+//       --my-tasks 列出本来源登记过的任务（找回丢失的 taskId）/ --require-origin 无来源则如实拒绝
+// 用法: node task.mjs --in "<指令>" [--cwd 目录] [--lane 名] [--model fast|pro] [--commit] [--timeout 秒] [--origin <id>]
 import fs from 'node:fs'
 import http from 'node:http'
 import path from 'node:path'
@@ -22,7 +24,7 @@ const HISTORY_CANDIDATES = process.env.DSH_BRIDGE_HISTORY
 const HISTORY_MAX = 40
 
 function parseArgs(argv) {
-  const out = { wait: true, timeoutSec: 600, instruction: '', cwd: '', lane: '', model: '', commit: false, list: false, cancel: '', status: '', sessions: '', sessionId: '', find: '', steer: false, force: false }
+  const out = { wait: true, timeoutSec: 600, instruction: '', cwd: '', lane: '', model: '', commit: false, list: false, cancel: '', status: '', sessions: '', sessionId: '', find: '', steer: false, force: false, origin: '', myTasks: false, requireOrigin: false }
   const rest = []
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
@@ -41,13 +43,34 @@ function parseArgs(argv) {
     else if (a === '--session') { out.sessionId = argv[++i] || '' }
     else if (a === '--find') { out.find = argv[++i] || '' }
     else if (a === '--steer') { out.steer = true }
+    else if (a === '--dry-run') { out.dryRun = true }
     else if (a === '--force') { out.force = true }
+    else if (a === '--origin') {
+      // 严格：来源 id 必须紧跟一个非空、不以 -- 开头的值；否则按用法错误处理（不静默降级）。
+      const v = argv[++i]
+      if (v === undefined || v.trim() === '' || v.startsWith('--')) { out.originError = '--origin 需要一个值（Codex 对话 id）'; continue }
+      out.origin = v.trim()
+    }
+    else if (a === '--my-tasks') { out.myTasks = true }
+    else if (a === '--require-origin') { out.requireOrigin = true }
     else { rest.push(a) }
   }
   if (!out.instruction && rest.length > 0) out.instruction = rest.join(' ')
   return out
 }
 
+/**
+ * 解析来源对话 id：**显式参数优先**，其次本次调用的 CODEX_THREAD_ID（CLI 每次都是独立进程，
+ * 因此这个环境变量确实是"这一次调用"的上下文）。绝不使用常驻进程的启动环境或"最近对话"推断。
+ * @returns {{originThreadId?: string, source: 'explicit'|'env'|'none'}}
+ */
+function resolveOrigin(opts) {
+  if (typeof opts.origin === 'string' && opts.origin.trim() !== '') return { originThreadId: opts.origin.trim(), source: 'explicit' }
+  const fromEnv = typeof process.env.CODEX_THREAD_ID === 'string' ? process.env.CODEX_THREAD_ID.trim() : ''
+  if (fromEnv !== '') return { originThreadId: fromEnv, source: 'env' }
+  return { source: 'none' }
+}
+
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
 // ---- 请求层：node:http + Connection: close，避免 undici keep-alive 退出断言 ----
@@ -81,6 +104,51 @@ function request(method, urlStr, body) {
   })
 }
 
+/**
+ * 只读核验网关是否真的支持"持久来源绑定"（GET /status，不会派活）。
+ * **不靠包版本猜**：旧网关会忽略 originThreadId 并照常 accepted → 产生"未绑定"任务。
+ */
+async function originBindingSupported() {
+  try {
+    const res = await request('GET', GATEWAY + '/api/dsh-bridge/status')
+    const body = res.json
+    return body !== null && typeof body === 'object'
+      && body.capabilities !== null && typeof body.capabilities === 'object'
+      && body.capabilities.originBinding !== null && typeof body.capabilities.originBinding === 'object'
+      && body.capabilities.originBinding.supported === true
+  } catch (e) {
+    return false
+  }
+}
+
+/** 只要这次调用真的会带上来源，就必须先确认网关支持；否则明确拒绝（绝不静默变成无关联派活）。 */
+async function requireOriginSupport(origin) {
+  if (origin.originThreadId === undefined) return true
+  if (await originBindingSupported()) return true
+  console.error('task.mjs: 该网关不支持持久来源绑定（/status 未上报 capabilities.originBinding）。旧网关会忽略 originThreadId 并照常 accepted，从而产生"未绑定"的任务。')
+  console.error('已拒绝执行；请先升级 DSH profile 里的 dsh-codex-collab 插件，或去掉 --origin 使用旧的无关联模式。')
+  return false
+}
+
+/** 网关自己给出的"明确拒绝"reason：原样透传（这些不是"成功了但没确认"）。 */
+const REFUSAL_REASONS = new Set(['origin-required', 'origin-mismatch', 'invalid-origin', 'unknown-task', 'execution-state-unconfirmed'])
+
+/** 网关必须**回显并匹配**我们请求的 originThreadId，才算确认了这次绑定/取值。 */
+function originConfirmed(payload, origin) {
+  return payload !== null && typeof payload === 'object' && payload.originThreadId === origin.originThreadId
+}
+
+/**
+ * 能力检查通过 ≠ 这次绑定被确认：网关可能中途换过处理者（重载/旧 handler），接受了请求却没写关联。
+ * 此时任务**可能已经执行**——既不能说成功，也绝不能重发。
+ */
+function unconfirmedExit(origin, extra) {
+  console.error('task.mjs: 网关接受了请求但没有确认来源绑定（响应里没有匹配的 originThreadId）。这次任务可能已经在无关联模式下执行——**不要重发**；请用 --my-tasks/--status 复核，并检查 DSH profile 里的 dsh-codex-collab 插件版本。')
+  console.error('task.mjs: 来源关联 originThreadId=' + origin.originThreadId + '（' + (origin.source === 'explicit' ? '--origin' : 'CODEX_THREAD_ID') + '）')
+  console.log(JSON.stringify({ phase: 'unconfirmed', reason: 'origin-not-confirmed', resend: false, ...extra }))
+  finish(8)
+}
+
 // ---- 历史：多位置读取合并 + 逐级降级写入 ----
 function readHistory() {
   const entries = []
@@ -150,21 +218,54 @@ function gitCommit(cwd, message) {
 
 async function main() {
   const opts = parseArgs(process.argv.slice(2))
+  const origin = resolveOrigin(opts)
+
+  if (opts.originError !== undefined) {
+    console.error('task.mjs: ' + opts.originError)
+    finish(2)
+  }
+
+  // --my-tasks：只给来源时列出该对话登记过的任务，用来找回丢失的 taskId。
+  // 没有任何来源（既没显式给，也没有本次调用的 CODEX_THREAD_ID）→ 如实拒绝，绝不猜"最近对话"。
+  if (opts.myTasks) {
+    if (origin.originThreadId === undefined) {
+      console.error('task.mjs: --my-tasks 需要来源对话 id：请显式传 --origin <Codex对话id>，或确保本次调用的环境里有 CODEX_THREAD_ID')
+      finish(2)
+    }
+    if (!(await requireOriginSupport(origin))) finish(2)
+    const res = await request('GET', GATEWAY + '/api/dsh-bridge/status?originThreadId=' + encodeURIComponent(origin.originThreadId))
+    if (res.json !== null && typeof res.json === 'object' && !originConfirmed(res.json, origin)) unconfirmedExit(origin, {})
+    console.log(JSON.stringify(res.json, null, 2))
+    finish(res.status === 200 ? 0 : 1)
+  }
 
   if (opts.list) {
-    const res = await request('GET', GATEWAY + '/api/dsh-bridge/tasks')
+    if (!(await requireOriginSupport(origin))) finish(2)
+    const res = await request('GET', GATEWAY + '/api/dsh-bridge/tasks' + (origin.originThreadId === undefined ? '' : '?originThreadId=' + encodeURIComponent(origin.originThreadId)))
+    if (origin.originThreadId !== undefined && res.json !== null && typeof res.json === 'object' && !originConfirmed(res.json, origin)) unconfirmedExit(origin, {})
     console.log(JSON.stringify(res.json, null, 2))
     finish(0)
   }
   if (opts.cancel) {
-    const res = await request('POST', GATEWAY + '/api/dsh-bridge/cancel', { taskId: opts.cancel, force: opts.force === true })
+    if (!(await requireOriginSupport(origin))) finish(2)
+    const res = await request('POST', GATEWAY + '/api/dsh-bridge/cancel', { taskId: opts.cancel, force: opts.force === true, ...(origin.originThreadId === undefined ? {} : { originThreadId: origin.originThreadId }) })
+    if (origin.originThreadId !== undefined && res.json !== null && typeof res.json === 'object' && res.json.cancelled === true && !originConfirmed(res.json, origin)) unconfirmedExit(origin, { taskId: opts.cancel })
     console.log(JSON.stringify(res.json, null, 2))
     finish(res.status === 409 ? 5 : 0)
   }
   if (opts.status) {
-    const res = await request('GET', GATEWAY + '/api/dsh-bridge/status?taskId=' + encodeURIComponent(opts.status))
-    console.log(JSON.stringify(res.json, null, 2))
-    finish(0)
+    if (!(await requireOriginSupport(origin))) finish(2)
+    const res = await request('GET', GATEWAY + '/api/dsh-bridge/status?taskId=' + encodeURIComponent(opts.status) + (origin.originThreadId === undefined ? '' : '&originThreadId=' + encodeURIComponent(origin.originThreadId)))
+    const body = res.json
+    const refused = body !== null && typeof body === 'object' && typeof body.reason === 'string' && REFUSAL_REASONS.has(body.reason)
+    // 精确取值必须由网关**确认来源**；没确认就不算读到（也绝不把网关 body 里的结果打出来）。
+    if (origin.originThreadId !== undefined && !refused && !originConfirmed(body, origin)) {
+      unconfirmedExit(origin, { taskId: opts.status })
+    }
+    console.log(JSON.stringify(body, null, 2))
+    // 非 200 = 没读到任务（未知 taskId / 已关联但缺来源 / 来源不匹配）→ 明确非零。
+    // 读到任务（含旧的无来源未关联任务）仍是 0，兼容不变。
+    finish(res.status === 200 ? 0 : 6)
   }
   if (opts.sessions) {
     const res = await request('POST', GATEWAY + '/api/dsh-bridge/sessions', { query: opts.sessions, inspect: true, limit: 20 })
@@ -175,22 +276,55 @@ async function main() {
     }
     console.log(JSON.stringify(res.json, null, 2))
     const items = Array.isArray(res.json.items) ? res.json.items : []
+    if (items.length === 0 && Array.isArray(res.json.candidates) && res.json.candidates.length > 0) {
+      console.error('未命中。候选（改用 --session <id>，或换个关键词）:')
+      for (const c of res.json.candidates) console.error('  ' + c.sessionId + '  ' + c.snippet + (c.score === undefined ? '' : '  score=' + c.score))
+      console.error('提示: 验证命中用 --dry-run，不要投递消息去试探。')
+    }
     finish(items.length > 0 ? 0 : 4)
   }
 
   const instruction = opts.instruction.trim()
+  const cwd = (opts.cwd || process.env.DSH_BRIDGE_CWD || '').trim()
+  const sessionId = (opts.sessionId || '').trim()
+  const find = (opts.find || '').trim()
+  const sessionTarget = sessionId !== '' ? { sessionId } : (find !== '' ? { sessionQuery: find } : null)
+
+  // --dry-run：只解析目标、回显命中结果，什么都不投递。验证"这条查询会命中哪条会话"就用它，
+  // 绝不要投递一条消息去试探（那会落进用户会话并跑成回合，污染对话）。
+  if (opts.dryRun) {
+    if (instruction === '' && sessionTarget === null && cwd === '') {
+      console.error('用法: node task.mjs --dry-run (--find "<标题关键词>" | --session <会话id> | --cwd <目录>)')
+      finish(2)
+    }
+    const res = await request('POST', GATEWAY + '/api/dsh-bridge/task', {
+      instruction: instruction === '' ? '(dry-run)' : instruction,
+      dryRun: true,
+      ...(sessionTarget === null ? (cwd ? { cwd } : {}) : sessionTarget),
+    })
+    console.log(JSON.stringify(res.json, null, 2))
+    if (res.json === null || typeof res.json !== 'object') finish(1)
+    if (res.json.resolved !== true) {
+      if (Array.isArray(res.json.candidates) && res.json.candidates.length > 0) {
+        console.error('未命中。候选（改用 --session <id>，或换个关键词）:')
+        for (const c of res.json.candidates) console.error('  ' + c.sessionId + '  ' + c.snippet + (c.score === undefined ? '' : '  score=' + c.score))
+      }
+      finish(4)
+    }
+    finish(0)
+  }
+
   if (!instruction) {
-    console.error('用法: node task.mjs --in "<指令>" [--cwd 目录] [--lane 名] [--model fast|pro] [--commit] [--timeout 秒] [--no-wait]')
+    console.error('用法: node task.mjs --in "<指令>" [--cwd 目录] [--lane 名] [--model fast|pro] [--commit] [--timeout 秒] [--no-wait] [--origin <Codex对话id>]')
     console.error('      node task.mjs --in "<指令>" (--session <会话id> | --find "<标题关键词>") [--steer]   # 投递进已有会话')
     console.error('查找: node task.mjs --sessions "<标题关键词>"   # 只读列出候选, 拿 sessionId 再派活')
-    console.error('管理: node task.mjs --list | --status <taskId> | --cancel <taskId> [--force]')
-    console.error('退出码: 0 成功 / 1 失败 / 2 用法 / 3 超时 / 4 会话未命中或不唯一 / 5 session 目标取消被拒')
+    console.error('      node task.mjs --dry-run (--find "<关键词>" | --session <id>)   # 只解析目标, 不投递（验证命中用这个）')
+    console.error('管理: node task.mjs --list [--origin <id>] | --status <taskId> [--origin <id>] | --cancel <taskId> [--force] [--origin <id>]')
+    console.error('来源: node task.mjs --my-tasks [--origin <id>]   # 列出该 Codex 对话登记过的任务（找回丢失的 taskId）')
+    console.error('      来源 id 优先取 --origin，其次本次调用的环境变量 CODEX_THREAD_ID；--require-origin 表示没有来源就拒绝派活。')
+    console.error('退出码: 0 成功 / 1 失败 / 2 用法（含缺少来源） / 3 超时 / 4 会话未命中或不唯一 / 5 session 目标取消被拒 / 6 查询不到该任务（未知或来源不匹配）')
     finish(2)
   }
-  const cwd = (opts.cwd || process.env.DSH_BRIDGE_CWD || '').trim()
-  const sessionId = (opts.sessionId || '').trim()
-  const find = (opts.find || '').trim()
-  const sessionTarget = sessionId !== '' ? { sessionId } : (find !== '' ? { sessionQuery: find } : null)
   if (sessionTarget !== null && (cwd !== '' || opts.commit)) {
     console.error('task.mjs: --session/--find 不能与 --cwd/--commit 同时使用（已有会话自带工作目录，本工具不替它提交）')
     finish(2)
@@ -202,8 +336,17 @@ async function main() {
     }
   }
   const history = sessionTarget === null ? readHistory() : []
+  // --require-origin：要求这次派活必须带上来源关联；拿不到来源就如实拒绝（不静默降级成无关联）。
+  if (opts.requireOrigin === true && origin.originThreadId === undefined) {
+    console.error('task.mjs: --require-origin 已指定，但拿不到来源对话 id：请显式传 --origin <Codex对话id>，或确保本次调用的环境里有 CODEX_THREAD_ID。')
+    console.error('（不会降级成"无关联派活"——那会让结果无法按来源精确收回。）')
+    finish(2)
+  }
+  // 要带来源就必须先确认网关真的支持（只读 GET，不派活）；不支持 → 零执行拒绝。
+  if (!(await requireOriginSupport(origin))) finish(2)
   const posted = await request('POST', GATEWAY + '/api/dsh-bridge/task', {
     instruction,
+    ...(origin.originThreadId === undefined ? {} : { originThreadId: origin.originThreadId }),
     ...(sessionTarget === null
       ? {
           ...{ history },
@@ -222,7 +365,14 @@ async function main() {
     console.error(String(posted.text || '').slice(0, 200))
     finish(1)
   }
-  console.log(JSON.stringify({ phase: 'submitted', ...task }))
+  if (origin.originThreadId !== undefined && task.taskId !== undefined && !originConfirmed(task, origin)) {
+    // 网关接受了请求，却没有回显我们的来源：绑定**未被确认**（可能已经无关联地执行了）→ 不要重发。
+    unconfirmedExit(origin, { taskId: task.taskId })
+  }
+  if (origin.originThreadId !== undefined) {
+    console.error('task.mjs: 来源关联 originThreadId=' + origin.originThreadId + '（' + (origin.source === 'explicit' ? '--origin' : 'CODEX_THREAD_ID') + '）')
+  }
+  console.log(JSON.stringify({ phase: task.taskId === undefined ? 'rejected' : 'submitted', ...task }))
   if (task.reason === 'session-ambiguous' || task.reason === 'session-query-empty') {
     console.error('task.mjs: ' + (task.error || task.reason))
     if (Array.isArray(task.candidates) && task.candidates.length > 0) {
@@ -231,6 +381,11 @@ async function main() {
     }
     finish(4)
   }
+  if (task.taskId === undefined) {
+    // 网关明确拒绝了这次派活（例如同一通道还有在途任务、来源非法）——非零退出，别让调用方以为派出去了。
+    console.error('task.mjs: 派活被拒绝: ' + (task.error || 'unknown error') + (task.reason === undefined ? '' : '（reason=' + task.reason + '）'))
+    finish(task.reason === 'worker-bucket-busy' || task.reason === 'reviewer-bucket-busy' ? 7 : 1)
+  }
   if (posted.status !== 202 || task.status === 'error') {
     console.error('task.mjs: ' + (task.error || task.reason || 'submission failed'))
     finish(1)
@@ -246,6 +401,11 @@ async function main() {
       console.log(JSON.stringify({ phase: 'finished', ...status }))
       console.log('=== DeepSeek 汇报 ===')
       console.log(status.result || status.error || '(无内容)')
+      // delivered=true 表示 prompt 已被那条会话接受（进了它的队列）：即便我们等超时了，
+      // 消息也可能会跑，**不要重发**（重发会让同一份内容在用户会话里出现两次）。
+      if (status.status === 'error' && status.delivered === true) {
+        console.error('注意: 消息已投递进该会话的队列（delivered=true），只是我们没等到它开跑。不要重发；可用 --status ' + task.taskId + ' 继续观察。')
+      }
       if (status.status === 'done') {
         // session 目标的记忆就在那条会话里，不再往协作历史里塞一份。
         if (sessionTarget === null) {