release: v2.2.0-rc0

bump_version.sh now also rewrites backend/packages/harness/pyproject.toml
(deerflow-harness is a workspace member, so `uv lock` moves its
backend/uv.lock entry too), and verify_versions.sh gates on it in both
tag and mutual-equality modes. RELEASING.md and AGENTS.md describe the
five version sources.

Co-Authored-By: Claude Code <noreply@anthropic.com>

AGENTS.md

@@ -238,12 +238,14 @@ Repo-wide conventions:
 - **Skill text encoding** — use explicit UTF-8 for textual skill resources.
   Read `SKILL.md` with `encoding="utf-8-sig"` to strip a leading BOM; write with
   `encoding="utf-8"`. Never rely on the platform locale.
-- **Version lockstep** — keep `backend/pyproject.toml`,
+- **Version sources must stay in lockstep** — a release version must match identically in
-  `backend/packages/harness/pyproject.toml`, `frontend/package.json`, and
+  `backend/pyproject.toml`, `backend/packages/harness/pyproject.toml`, `frontend/package.json`,
-  `deploy/helm/deer-flow/Chart.yaml` (`version`/`appVersion`) identical.
+  and `deploy/helm/deer-flow/Chart.yaml` (`version` + `appVersion`), and `backend/uv.lock` must
-  `backend/uv.lock` must match both `deer-flow` and `deerflow-harness` in PEP 440 form.
+  record the same version for the root `deer-flow` and `deerflow-harness` workspace members
-  Run `scripts/bump_version.sh <ver>` (requires `uv` on `PATH`) to update all five
+  (uv stores its PEP 440 form, e.g. `2.1.0rc0`). Pushing a `v*` git tag triggers CI
-  fields and the lock, then `scripts/verify_versions.sh <ver>`. `v*` tag CI blocks
+  that runs `scripts/verify_versions.sh` and **blocks all publishing** if any source drifts.
-  all publishing on drift. See [RELEASING.md](RELEASING.md).
+  Before bumping a version, run `scripts/bump_version.sh <ver>` (aligns the five fields and
+  refreshes `backend/uv.lock` at once — it needs `uv` on `PATH`) and
+  `scripts/verify_versions.sh <ver>` to catch drift early. See [RELEASING.md](RELEASING.md).
 - **Don't edit `CLAUDE.md`** — it only contains `@AGENTS.md`. All agent guidance changes
   belong here in `AGENTS.md`; `CLAUDE.md` is a thin import shim.

CHANGELOG.md

@@ -7,39 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-This section accumulates work toward the **2.3.0** milestone
-([2.3.0](https://github.com/bytedance/deer-flow/milestone/4)).
-
-### Added
-
-- **chat:** Running Web chats offer Queue and Steer in the composer. Queue
-  waits for the next turn; Steer lets the main Agent handle updates while
-  native subagents pause and resume. Unconfirmed messages can be retried
-  after a Gateway restart. ([#7729])
-
-### Fixed
-
-- **dev:** `scripts/dev_multi_instance.sh logs all` now prints the nginx logs
-  as well as both Gateway logs; it printed only the Gateway logs, the same as
-  `logs` with no argument. `logs nginx` and `logs all` also include `nginx.log`,
-  the nginx start command's own output, which no option printed before.
-  ([#7723])
-
-- **memory:** `GET /api/memory/config` and `/api/memory/status` now mask
-  credential values in `backend_config` (`api_key`, tokens, passwords,
-  `Authorization` headers, at any depth) as `***`. They returned the config as
-  loaded, with `$VAR` references already resolved, so a DeerMem extraction
-  model key or a Honcho `api_key` reached every caller with `memory:read` in
-  plaintext, which with authorization disabled (the default) is every
-  signed-in user. Non-secret knobs, `api_key_env` names and unset values are
-  unchanged. ([#7665])
-- **gateway:** `GET /threads/{thread_id}/token-usage` now resolves the live
-  config in a worker thread. `build_context_usage` called the accessor inline,
-  and `get_app_config()` revalidates on every call — it digests the whole
-  `config.yaml`, then `extensions_config.json` — so a config edit landing just
-  before a thread view stalled the Gateway event loop that runs, streams and
-  every other thread share. The response is unchanged. ([#7727])
-
 ## [2.2.0] — 2026-10-29
 
 This section accumulates work toward the **2.2.0** milestone
@@ -13871,7 +13838,8 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 - **ci:** Consolidate PR/issue labeling and fix the reviewing-job crash and
   label thrash. ([#3455])
 
-[Unreleased]: https://github.com/bytedance/deer-flow/compare/v2.1.0...HEAD
+[Unreleased]: https://github.com/bytedance/deer-flow/compare/v2.2.0...HEAD
+[2.2.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.2.0
 [2.1.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.1.0
 [2.0.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.0.0
 
@@ -14713,7 +14681,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5217]: https://github.com/bytedance/deer-flow/pull/5217
 [#5219]: https://github.com/bytedance/deer-flow/pull/5219
 [#5221]: https://github.com/bytedance/deer-flow/pull/5221
-[#5224]: https://github.com/bytedance/deer-flow/commit/572744975d369fda88168aaa7b481282f939affe
+[#5224]: https://github.com/bytedance/deer-flow/pull/5224
 [#5225]: https://github.com/bytedance/deer-flow/pull/5225
 [#5227]: https://github.com/bytedance/deer-flow/pull/5227
 [#5228]: https://github.com/bytedance/deer-flow/pull/5228
@@ -14722,9 +14690,9 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5236]: https://github.com/bytedance/deer-flow/pull/5236
 [#5238]: https://github.com/bytedance/deer-flow/pull/5238
 [#5239]: https://github.com/bytedance/deer-flow/pull/5239
-[#5244]: https://github.com/bytedance/deer-flow/commit/9ce6fdcb2252ea005b4fa98ca50bd3857e1f681a
+[#5244]: https://github.com/bytedance/deer-flow/pull/5244
 [#5245]: https://github.com/bytedance/deer-flow/pull/5245
-[#5247]: https://github.com/bytedance/deer-flow/commit/fa89a125267be4213009376ec0e232a0c2411ca8
+[#5247]: https://github.com/bytedance/deer-flow/pull/5247
 [#5249]: https://github.com/bytedance/deer-flow/pull/5249
 [#5251]: https://github.com/bytedance/deer-flow/pull/5251
 [#5254]: https://github.com/bytedance/deer-flow/pull/5254
@@ -14781,7 +14749,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5367]: https://github.com/bytedance/deer-flow/pull/5367
 [#5369]: https://github.com/bytedance/deer-flow/pull/5369
 [#5371]: https://github.com/bytedance/deer-flow/pull/5371
-[#5373]: https://github.com/bytedance/deer-flow/commit/d5ae3882b6708fa9af7289a0c3c0be3eee157203
+[#5373]: https://github.com/bytedance/deer-flow/pull/5373
 [#5374]: https://github.com/bytedance/deer-flow/pull/5374
 [#5375]: https://github.com/bytedance/deer-flow/pull/5375
 [#5377]: https://github.com/bytedance/deer-flow/pull/5377
@@ -14808,7 +14776,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5408]: https://github.com/bytedance/deer-flow/pull/5408
 [#5410]: https://github.com/bytedance/deer-flow/pull/5410
 [#5411]: https://github.com/bytedance/deer-flow/pull/5411
-[#5413]: https://github.com/bytedance/deer-flow/commit/daf32cd24632f2cc7465aeb62f2a1e1e768eceb2
+[#5413]: https://github.com/bytedance/deer-flow/pull/5413
 [#5415]: https://github.com/bytedance/deer-flow/pull/5415
 [#5416]: https://github.com/bytedance/deer-flow/pull/5416
 [#5418]: https://github.com/bytedance/deer-flow/pull/5418
@@ -14991,8 +14959,8 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5736]: https://github.com/bytedance/deer-flow/pull/5736
 [#5738]: https://github.com/bytedance/deer-flow/pull/5738
 [#5739]: https://github.com/bytedance/deer-flow/pull/5739
-[#5740]: https://github.com/bytedance/deer-flow/commit/e7128dc7d6b4d49153b10f7276f010384ec4e6af
+[#5740]: https://github.com/bytedance/deer-flow/pull/5740
-[#5741]: https://github.com/bytedance/deer-flow/commit/363b0fc1b4a5bd6c142d1f1df9fb9743cca550a3
+[#5741]: https://github.com/bytedance/deer-flow/pull/5741
 [#5745]: https://github.com/bytedance/deer-flow/pull/5745
 [#5748]: https://github.com/bytedance/deer-flow/pull/5748
 [#5750]: https://github.com/bytedance/deer-flow/pull/5750
@@ -15005,7 +14973,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5760]: https://github.com/bytedance/deer-flow/pull/5760
 [#5761]: https://github.com/bytedance/deer-flow/pull/5761
 [#5762]: https://github.com/bytedance/deer-flow/pull/5762
-[#5763]: https://github.com/bytedance/deer-flow/commit/39351315bf5d096fc84ad8307d3702b6aa5b3e24
+[#5763]: https://github.com/bytedance/deer-flow/pull/5763
 [#5767]: https://github.com/bytedance/deer-flow/pull/5767
 [#5769]: https://github.com/bytedance/deer-flow/pull/5769
 [#5775]: https://github.com/bytedance/deer-flow/pull/5775
@@ -15073,7 +15041,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5880]: https://github.com/bytedance/deer-flow/pull/5880
 [#5881]: https://github.com/bytedance/deer-flow/pull/5881
 [#5883]: https://github.com/bytedance/deer-flow/pull/5883
-[#5884]: https://github.com/bytedance/deer-flow/commit/e8cb5e9c4f5f274401eeb555aff62e713035cbf4
+[#5884]: https://github.com/bytedance/deer-flow/pull/5884
 [#5888]: https://github.com/bytedance/deer-flow/pull/5888
 [#5890]: https://github.com/bytedance/deer-flow/pull/5890
 [#5892]: https://github.com/bytedance/deer-flow/pull/5892
@@ -15135,9 +15103,9 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#5999]: https://github.com/bytedance/deer-flow/pull/5999
 [#6000]: https://github.com/bytedance/deer-flow/pull/6000
 [#6008]: https://github.com/bytedance/deer-flow/pull/6008
-[#6009]: https://github.com/bytedance/deer-flow/commit/b87ebd940227465d611084e5bf49582aaeb4e9bd
+[#6009]: https://github.com/bytedance/deer-flow/pull/6009
 [#6013]: https://github.com/bytedance/deer-flow/pull/6013
-[#6015]: https://github.com/bytedance/deer-flow/commit/f87a04e581829ff35afd4fa228240071b486192f
+[#6015]: https://github.com/bytedance/deer-flow/pull/6015
 [#6017]: https://github.com/bytedance/deer-flow/pull/6017
 [#6018]: https://github.com/bytedance/deer-flow/pull/6018
 [#6020]: https://github.com/bytedance/deer-flow/pull/6020
@@ -15161,7 +15129,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#6060]: https://github.com/bytedance/deer-flow/pull/6060
 [#6062]: https://github.com/bytedance/deer-flow/pull/6062
 [#6063]: https://github.com/bytedance/deer-flow/pull/6063
-[#6066]: https://github.com/bytedance/deer-flow/commit/73fdbcfdf4b5f4037b62bc2ce9d8b60ec04e69f8
+[#6066]: https://github.com/bytedance/deer-flow/pull/6066
 [#6067]: https://github.com/bytedance/deer-flow/pull/6067
 [#6068]: https://github.com/bytedance/deer-flow/pull/6068
 [#6069]: https://github.com/bytedance/deer-flow/pull/6069
@@ -15187,7 +15155,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#6105]: https://github.com/bytedance/deer-flow/pull/6105
 [#6107]: https://github.com/bytedance/deer-flow/pull/6107
 [#6109]: https://github.com/bytedance/deer-flow/pull/6109
-[#6112]: https://github.com/bytedance/deer-flow/commit/52b21d13ac6e674a19cb76013d097e73f108c994
+[#6112]: https://github.com/bytedance/deer-flow/pull/6112
 [#6113]: https://github.com/bytedance/deer-flow/pull/6113
 [#6115]: https://github.com/bytedance/deer-flow/pull/6115
 [#6117]: https://github.com/bytedance/deer-flow/pull/6117
@@ -15288,7 +15256,7 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#6298]: https://github.com/bytedance/deer-flow/pull/6298
 [#6299]: https://github.com/bytedance/deer-flow/pull/6299
 [#6302]: https://github.com/bytedance/deer-flow/pull/6302
-[#6304]: https://github.com/bytedance/deer-flow/commit/b85e4ae74bb407e1e2396243a8a6e8f5b2420e3f
+[#6304]: https://github.com/bytedance/deer-flow/pull/6304
 [#6305]: https://github.com/bytedance/deer-flow/pull/6305
 [#6306]: https://github.com/bytedance/deer-flow/pull/6306
 [#6307]: https://github.com/bytedance/deer-flow/pull/6307
@@ -15672,7 +15640,6 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#7017]: https://github.com/bytedance/deer-flow/pull/7017
 [#7018]: https://github.com/bytedance/deer-flow/pull/7018
 [#7020]: https://github.com/bytedance/deer-flow/pull/7020
-[#7022]: https://github.com/bytedance/deer-flow/issues/7022
 [#7023]: https://github.com/bytedance/deer-flow/pull/7023
 [#7024]: https://github.com/bytedance/deer-flow/pull/7024
 [#7031]: https://github.com/bytedance/deer-flow/pull/7031
@@ -15945,7 +15912,3 @@ with **180 merged pull requests** since the first 2.0 milestone tag.
 [#7643]: https://github.com/bytedance/deer-flow/pull/7643
 [#7651]: https://github.com/bytedance/deer-flow/pull/7651
 [#7659]: https://github.com/bytedance/deer-flow/pull/7659
-[#7665]: https://github.com/bytedance/deer-flow/pull/7665
-[#7723]: https://github.com/bytedance/deer-flow/pull/7723
-[#7727]: https://github.com/bytedance/deer-flow/pull/7727
-[#7729]: https://github.com/bytedance/deer-flow/pull/7729

CHANGELOG_zh.md

@@ -9,32 +9,6 @@
 
 ## [未发布]
 
-本节累积面向 **2.3.0** 里程碑（[2.3.0](https://github.com/bytedance/deer-flow/milestone/4)）的工作。
-截至 2026-10-28，该里程碑已合并 **1068 个拉取请求**。
-
-### 新增
-
-- **对话：** 网页端在任务运行时，可在输入框选择 Queue（排队执行）或 Steer（调整当前任务）。
-  Queue 等当前任务结束后再执行下一条消息；Steer 让主 Agent 先处理新要求，原生子 Agent 可暂停后恢复。
-  Gateway 重启后，尚未确认生效的消息可以手动重试。([#7729])
-
-### 修复
-
-- **开发：** `scripts/dev_multi_instance.sh logs all` 现在除两个 Gateway 日志外也会输出
-  nginx 日志；此前它只输出 Gateway 日志，与不带参数的 `logs` 相同。`logs nginx` 与
-  `logs all` 还会包含 `nginx.log`（nginx 启动命令自身的输出），此前没有任何选项会输出它。
-  ([#7723])
-
-- **记忆：** `GET /api/memory/config` 与 `/api/memory/status` 现在会把 `backend_config`
-  中的凭据值（`api_key`、token、密码、`Authorization` 请求头，任意层级）遮蔽为 `***`。
-  此前它们按加载结果原样返回配置，而 `$VAR` 引用此时已被解析，因此 DeerMem 提取模型的密钥
-  或 Honcho 的 `api_key` 会以明文返回给所有拥有 `memory:read` 的调用方；在默认关闭授权时，
-  这就是所有已登录用户。非机密配置项、`api_key_env` 变量名和未设置的值保持不变。([#7665])
-- **网关：** `GET /threads/{thread_id}/token-usage` 现在在工作线程里解析实时配置。
-  此前 `build_context_usage` 直接内联调用该访问器，而 `get_app_config()` 每次调用都会重新校验
-  ——它先对整个 `config.yaml` 取摘要，再对 `extensions_config.json` 做同样的事——所以在有人打开
-  会话视图前刚好改了配置，就会让运行、消息流与其他线程共用的网关事件循环整段停顿。响应内容不变。([#7727])
-
 ## [2.2.0] — 2026-10-29
 
 本节累积面向 **2.2.0** 里程碑（[2.2.0](https://github.com/bytedance/deer-flow/milestone/3)）的工作。
@@ -10635,7 +10609,8 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 - **CI：** 统一 PR / issue 打标签逻辑，修复 reviewing 任务的崩溃与标签抖动。
   ([#3455])
 
-[未发布]: https://github.com/bytedance/deer-flow/compare/v2.1.0...HEAD
+[未发布]: https://github.com/bytedance/deer-flow/compare/v2.2.0...HEAD
+[2.2.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.2.0
 [2.1.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.1.0
 [2.0.0]: https://github.com/bytedance/deer-flow/releases/tag/v2.0.0
 
@@ -11477,7 +11452,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5217]: https://github.com/bytedance/deer-flow/pull/5217
 [#5219]: https://github.com/bytedance/deer-flow/pull/5219
 [#5221]: https://github.com/bytedance/deer-flow/pull/5221
-[#5224]: https://github.com/bytedance/deer-flow/commit/572744975d369fda88168aaa7b481282f939affe
+[#5224]: https://github.com/bytedance/deer-flow/pull/5224
 [#5225]: https://github.com/bytedance/deer-flow/pull/5225
 [#5227]: https://github.com/bytedance/deer-flow/pull/5227
 [#5228]: https://github.com/bytedance/deer-flow/pull/5228
@@ -11486,9 +11461,9 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5236]: https://github.com/bytedance/deer-flow/pull/5236
 [#5238]: https://github.com/bytedance/deer-flow/pull/5238
 [#5239]: https://github.com/bytedance/deer-flow/pull/5239
-[#5244]: https://github.com/bytedance/deer-flow/commit/9ce6fdcb2252ea005b4fa98ca50bd3857e1f681a
+[#5244]: https://github.com/bytedance/deer-flow/pull/5244
 [#5245]: https://github.com/bytedance/deer-flow/pull/5245
-[#5247]: https://github.com/bytedance/deer-flow/commit/fa89a125267be4213009376ec0e232a0c2411ca8
+[#5247]: https://github.com/bytedance/deer-flow/pull/5247
 [#5249]: https://github.com/bytedance/deer-flow/pull/5249
 [#5251]: https://github.com/bytedance/deer-flow/pull/5251
 [#5254]: https://github.com/bytedance/deer-flow/pull/5254
@@ -11545,7 +11520,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5367]: https://github.com/bytedance/deer-flow/pull/5367
 [#5369]: https://github.com/bytedance/deer-flow/pull/5369
 [#5371]: https://github.com/bytedance/deer-flow/pull/5371
-[#5373]: https://github.com/bytedance/deer-flow/commit/d5ae3882b6708fa9af7289a0c3c0be3eee157203
+[#5373]: https://github.com/bytedance/deer-flow/pull/5373
 [#5374]: https://github.com/bytedance/deer-flow/pull/5374
 [#5375]: https://github.com/bytedance/deer-flow/pull/5375
 [#5377]: https://github.com/bytedance/deer-flow/pull/5377
@@ -11572,7 +11547,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5408]: https://github.com/bytedance/deer-flow/pull/5408
 [#5410]: https://github.com/bytedance/deer-flow/pull/5410
 [#5411]: https://github.com/bytedance/deer-flow/pull/5411
-[#5413]: https://github.com/bytedance/deer-flow/commit/daf32cd24632f2cc7465aeb62f2a1e1e768eceb2
+[#5413]: https://github.com/bytedance/deer-flow/pull/5413
 [#5415]: https://github.com/bytedance/deer-flow/pull/5415
 [#5416]: https://github.com/bytedance/deer-flow/pull/5416
 [#5418]: https://github.com/bytedance/deer-flow/pull/5418
@@ -11755,8 +11730,8 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5736]: https://github.com/bytedance/deer-flow/pull/5736
 [#5738]: https://github.com/bytedance/deer-flow/pull/5738
 [#5739]: https://github.com/bytedance/deer-flow/pull/5739
-[#5740]: https://github.com/bytedance/deer-flow/commit/e7128dc7d6b4d49153b10f7276f010384ec4e6af
+[#5740]: https://github.com/bytedance/deer-flow/pull/5740
-[#5741]: https://github.com/bytedance/deer-flow/commit/363b0fc1b4a5bd6c142d1f1df9fb9743cca550a3
+[#5741]: https://github.com/bytedance/deer-flow/pull/5741
 [#5745]: https://github.com/bytedance/deer-flow/pull/5745
 [#5748]: https://github.com/bytedance/deer-flow/pull/5748
 [#5750]: https://github.com/bytedance/deer-flow/pull/5750
@@ -11769,7 +11744,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5760]: https://github.com/bytedance/deer-flow/pull/5760
 [#5761]: https://github.com/bytedance/deer-flow/pull/5761
 [#5762]: https://github.com/bytedance/deer-flow/pull/5762
-[#5763]: https://github.com/bytedance/deer-flow/commit/39351315bf5d096fc84ad8307d3702b6aa5b3e24
+[#5763]: https://github.com/bytedance/deer-flow/pull/5763
 [#5767]: https://github.com/bytedance/deer-flow/pull/5767
 [#5769]: https://github.com/bytedance/deer-flow/pull/5769
 [#5775]: https://github.com/bytedance/deer-flow/pull/5775
@@ -11837,7 +11812,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5880]: https://github.com/bytedance/deer-flow/pull/5880
 [#5881]: https://github.com/bytedance/deer-flow/pull/5881
 [#5883]: https://github.com/bytedance/deer-flow/pull/5883
-[#5884]: https://github.com/bytedance/deer-flow/commit/e8cb5e9c4f5f274401eeb555aff62e713035cbf4
+[#5884]: https://github.com/bytedance/deer-flow/pull/5884
 [#5888]: https://github.com/bytedance/deer-flow/pull/5888
 [#5890]: https://github.com/bytedance/deer-flow/pull/5890
 [#5892]: https://github.com/bytedance/deer-flow/pull/5892
@@ -11899,9 +11874,9 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#5999]: https://github.com/bytedance/deer-flow/pull/5999
 [#6000]: https://github.com/bytedance/deer-flow/pull/6000
 [#6008]: https://github.com/bytedance/deer-flow/pull/6008
-[#6009]: https://github.com/bytedance/deer-flow/commit/b87ebd940227465d611084e5bf49582aaeb4e9bd
+[#6009]: https://github.com/bytedance/deer-flow/pull/6009
 [#6013]: https://github.com/bytedance/deer-flow/pull/6013
-[#6015]: https://github.com/bytedance/deer-flow/commit/f87a04e581829ff35afd4fa228240071b486192f
+[#6015]: https://github.com/bytedance/deer-flow/pull/6015
 [#6017]: https://github.com/bytedance/deer-flow/pull/6017
 [#6018]: https://github.com/bytedance/deer-flow/pull/6018
 [#6020]: https://github.com/bytedance/deer-flow/pull/6020
@@ -11925,7 +11900,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#6060]: https://github.com/bytedance/deer-flow/pull/6060
 [#6062]: https://github.com/bytedance/deer-flow/pull/6062
 [#6063]: https://github.com/bytedance/deer-flow/pull/6063
-[#6066]: https://github.com/bytedance/deer-flow/commit/73fdbcfdf4b5f4037b62bc2ce9d8b60ec04e69f8
+[#6066]: https://github.com/bytedance/deer-flow/pull/6066
 [#6067]: https://github.com/bytedance/deer-flow/pull/6067
 [#6068]: https://github.com/bytedance/deer-flow/pull/6068
 [#6069]: https://github.com/bytedance/deer-flow/pull/6069
@@ -11951,7 +11926,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#6105]: https://github.com/bytedance/deer-flow/pull/6105
 [#6107]: https://github.com/bytedance/deer-flow/pull/6107
 [#6109]: https://github.com/bytedance/deer-flow/pull/6109
-[#6112]: https://github.com/bytedance/deer-flow/commit/52b21d13ac6e674a19cb76013d097e73f108c994
+[#6112]: https://github.com/bytedance/deer-flow/pull/6112
 [#6113]: https://github.com/bytedance/deer-flow/pull/6113
 [#6115]: https://github.com/bytedance/deer-flow/pull/6115
 [#6117]: https://github.com/bytedance/deer-flow/pull/6117
@@ -12052,7 +12027,7 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#6298]: https://github.com/bytedance/deer-flow/pull/6298
 [#6299]: https://github.com/bytedance/deer-flow/pull/6299
 [#6302]: https://github.com/bytedance/deer-flow/pull/6302
-[#6304]: https://github.com/bytedance/deer-flow/commit/b85e4ae74bb407e1e2396243a8a6e8f5b2420e3f
+[#6304]: https://github.com/bytedance/deer-flow/pull/6304
 [#6305]: https://github.com/bytedance/deer-flow/pull/6305
 [#6306]: https://github.com/bytedance/deer-flow/pull/6306
 [#6307]: https://github.com/bytedance/deer-flow/pull/6307
@@ -12436,7 +12411,6 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#7017]: https://github.com/bytedance/deer-flow/pull/7017
 [#7018]: https://github.com/bytedance/deer-flow/pull/7018
 [#7020]: https://github.com/bytedance/deer-flow/pull/7020
-[#7022]: https://github.com/bytedance/deer-flow/issues/7022
 [#7023]: https://github.com/bytedance/deer-flow/pull/7023
 [#7024]: https://github.com/bytedance/deer-flow/pull/7024
 [#7031]: https://github.com/bytedance/deer-flow/pull/7031
@@ -12709,7 +12683,3 @@ DeerFlow 2.0 是围绕"超级智能体"框架的彻底重写，核心包含子
 [#7643]: https://github.com/bytedance/deer-flow/pull/7643
 [#7651]: https://github.com/bytedance/deer-flow/pull/7651
 [#7659]: https://github.com/bytedance/deer-flow/pull/7659
-[#7665]: https://github.com/bytedance/deer-flow/pull/7665
-[#7723]: https://github.com/bytedance/deer-flow/pull/7723
-[#7727]: https://github.com/bytedance/deer-flow/pull/7727
-[#7729]: https://github.com/bytedance/deer-flow/pull/7729

README.md

@@ -694,11 +694,7 @@ DeerFlow still uses `Forwarded` / `X-Forwarded-*` headers to recover the browser
 > The producer-lease recovery behavior above is gated by `stream_bridge.producer_lease_recovery_enabled`. Keep it disabled while old Gateway binaries or their runs remain; enable it on every instance only after the writer rollout and drain complete.
 >
 > With run ownership heartbeats enabled, terminal success requires acknowledgment
-> from that worker's own durable write. Run creation and replacement serialize
+> from that worker's own durable write. A matching database row alone cannot
-> per conversation: a slow admission does not hold the manager-wide lock needed
-> by another conversation's cached run reads or heartbeat snapshots. Their own
-> Store I/O can still encounter database or pool contention. New runs remain
-> hidden until their initial Store write succeeds. A matching database row alone cannot
 > confirm success, and completion metadata cannot retry a rejected terminal
 > transition. Each run renews independently, so a stalled store operation does
 > not delay other runs. If acknowledgment remains unavailable when the last
@@ -722,10 +718,6 @@ DeerFlow still uses `Forwarded` / `X-Forwarded-*` headers to recover the browser
 > normal `end` signal. A new reader whose initial attachment loses the race with
 > cleanup receives a gap so it can recover the saved result.
 >
-> In-memory stream events retain the payload as it was published. Reusing a
-> producer's data object or editing a received event does not change another
-> subscriber's output or reconnect replay.
->
 > During SSE replay-gap recovery, the Web UI preserves a reconnect pointer claimed by another run while durable state is loading. An older recovery cannot overwrite that pointer when it rejoins its own stream. Even a stale foreign pointer is preserved, so the next reload may first check that run before active-run recovery rejoins, adding a reconnect cycle.
 >
 > Store-only SSE and `/wait` consumers can finish after a heartbeat when run-manager
@@ -1106,14 +1098,6 @@ Signed-in users' notification toggle, default model, conversation mode, and reas
 In a new chat, the submitted question stays above its streamed reasoning and
 tool steps while the server creates the conversation and confirms the message.
 
-While a Web task is running, choose **Queue** to send text for the next turn or
-**Steer** to update the current work. Native subagents pause at a safe boundary
-while the main Agent handles the update; active tool calls finish first. Stop
-keeps the Goal, while explicitly replacing the work can clear it. Unapplied
-messages survive database-backed Gateway restarts and require **Send again**;
-interrupted child side effects are not replayed automatically. Existing execution
-limits still apply. Busy input currently accepts text only.
-
 Markdown and JSON conversation exports from the chat header or sidebar read all
 persisted history pages, including earlier turns outside the loaded view or
 compacted model context. A failed history read stops the export instead of
@@ -1357,7 +1341,6 @@ Notes:
 - Telegram shutdown retains ongoing cleanup across a timeout or cancellation so a retry can finish it. Stopping during startup also cancels initialization and closes the partially initialized bot's HTTP clients before retiring its worker loop. If the Telegram loop has already stopped, shutdown warns that download clients may remain open and releases the abandoned cleanup state; later stops do not repeat that warning.
 - Slack stop waits up to five seconds for an in-flight Socket Mode connection and its cleanup. If cleanup is still pending, the previous instance stays tracked and a restart can be retried after it finishes. SDK cleanup failures report their original error and remain retryable.
 - In Telegram private chats, text, attachment and streaming replies (including "Working on it...") can still be delivered if their referenced user or bot message was deleted, such as after clearing chat history during a run. Group reply-target requirements remain unchanged to preserve forum routing.
-- In Telegram groups, replying to a delivered bot response or attachment continues its DeerFlow conversation. Reply mappings survive restarts and stay scoped to the user's connection when one is bound. New, unrelated group messages still start separate conversations; private-chat routing is unchanged.
 - Feishu/Lark now queues rapid follow-up messages per mapped DeerFlow `thread_id` instead of immediately surfacing the generic busy reply, and topic replies keep a per-message card with a compact source-message preview across queued/running/final patches.
 - Streaming IM channels treat backend `error` events like transport failures and follow the same reply and retry path. The channel logs the error type and message for diagnosis.
 
@@ -1786,8 +1769,6 @@ Discovery follows operator-managed directory symlinks, but skips links back to a
 
 Skill Markdown and bundled text resources use UTF-8. Skill-creator CLI and review utilities read and write text explicitly as UTF-8 so localized skills behave consistently across operating systems.
 
-For standalone skill exports, the bundled skill creator's `scripts/package_skill.py` can be run by file path from any directory, or as `python -m scripts.package_skill` from the skill-creator directory. Both entry points validate the skill before writing a `.skill` archive.
-
 Custom-skill writes and security-scan staging preserve submitted line endings
 on every platform, so the scanner checks the bytes that will be stored.
 
@@ -2233,7 +2214,7 @@ Follow-up suggestions also check `model:use` before calling the selected model,
 For vision-capable agents, `view_image` and the subsequent model-context image read also require `sandbox:execute`. Allowing the tool name alone does not grant image-file access; a role denied sandbox execution cannot reread previously recorded image metadata after its permissions change. External run input and thread-state updates cannot set `viewed_images` or `thread_data`; when a saved image is read from a host copy, its path must resolve to the current user's thread and the recorded virtual image path.
 Each model request includes at most four recently viewed images and 28 MiB of base64 image data. Images excluded by these limits are reported as omitted; the agent can call `view_image` again to bring one back into context.
 
-Advanced deployments can also extend the agent runtime itself by declaring `AgentMiddleware` classes under `extensions.middlewares` in `config.yaml` or `extensions_config.json`. Each entry is a `module.path:ClassName` string (zero-argument constructor) or an object `{class, kwargs, apply_to}` whose `kwargs` are passed to the constructor. Optional `apply_to` selects `both` (default), `lead`, or `subagent`; legacy strings still apply to both chains. `kwargs` values must be JSON types (object, array, string, number, boolean, or null); YAML dates and timestamps are coerced to ISO strings so they match JSON. DeerFlow loads the selected configured entries into the lead-agent and subagent pipelines after their built-in runtime middlewares and loop/token guards, but before the terminal-response/safety/clarification tail, so enterprise forks can add domain guardrails, tool-call governance, or observability hooks without patching the built-in middleware builders. Missing packages, invalid classes, broken modules, and constructor errors fail loudly at agent creation. Treat `config.yaml` and `extensions_config.json` as trusted operator-controlled files: middleware paths are code execution, just like custom tool, model, sandbox, guardrail, MCP server, and MCP interceptor declarations. Gateway skill/MCP toggle endpoints preserve this field but do not expose an API write path for `extensions.middlewares`. Entries excluded from a chain are not imported or constructed there. Invalid scope values fail configuration validation, and selected entries retain their relative order. Packaged extensions continue to use their existing `AgentScope` contract.
+Advanced deployments can also extend the agent runtime itself by declaring `AgentMiddleware` classes under `extensions.middlewares` in `config.yaml` or `extensions_config.json`. Each entry is a `module.path:ClassName` string (zero-argument constructor) or an object `{class, kwargs}` whose `kwargs` are passed to the constructor. `kwargs` values must be JSON types (object, array, string, number, boolean, or null); YAML dates and timestamps are coerced to ISO strings so they match JSON. DeerFlow loads the same configured list into the lead-agent and subagent pipelines after their built-in runtime middlewares and loop/token guards, but before the terminal-response/safety/clarification tail, so enterprise forks can add domain guardrails, tool-call governance, or observability hooks without patching the built-in middleware builders. Missing packages, invalid classes, broken modules, and constructor errors fail loudly at agent creation. Treat `config.yaml` and `extensions_config.json` as trusted operator-controlled files: middleware paths are code execution, just like custom tool, model, sandbox, guardrail, MCP server, and MCP interceptor declarations. Gateway skill/MCP toggle endpoints preserve this field but do not expose an API write path for `extensions.middlewares`. Separate lead-only/subagent-only middleware lists are not supported yet.
 
 For packaged and configurable runtime integrations, use DeerFlow's extension manager.
 It accepts a Python package requirement, a public HTTPS Git URL, or a local directory, installs the
@@ -2476,8 +2457,6 @@ Unsent Web UI composer drafts survive page reloads and switching between convers
 
 If an attachment upload reports `success: false`, the Web UI stops the send even when the HTTP response is 200. The upload error is shown and the composer keeps its draft and attachments for correction or retry. Files already accepted by a partially successful upload remain on the server; this does not roll them back.
 
-Document conversion reads the live PDF-converter setting and parses documents in a background worker, keeping configuration-file checks off the Gateway event loop.
-
 The Web UI composer supports `@` references at the cursor or through the `@` button. Search enabled skills, documents in the current project, and other conversations in a grouped picker; selected references appear inline alongside the draft text and can be removed with normal editing. Multiple skills can be selected in one message (up to 16 unique skills); selecting a checked skill again removes it, with each selection checked against the current user registry and agent allowlist. Project files are attached only after ingestion succeeds; conversation references require the `read_conversation` capability and retain its per-run limit. If capability discovery fails, saved conversation references remain intact and sending waits for a successful retry. Polishing preserves complete reference labels when instructions are reordered. The file group also offers local uploads. `/goal`, `/compact`, and legacy `/skill-name` input remain supported.
 
 After picking an inline reference, typing continues immediately after it. Moving the cursor keeps the position you chose, including when editing text beside a reference.
@@ -2807,8 +2786,6 @@ Explicitly enabled nested `task` delegation propagates omitted opaque source IDs
 
 If an item's final lease expires after exhausting the retry budget, the batch reaches a terminal state once all items are terminal: `failed` when none succeeded, or `completed` when at least one succeeded. The item remains `failed` in both cases so partial results stay visible.
 
-Paused batches also reconcile expired attempts after a worker exits. Retryable items remain queued without starting new work until you explicitly resume the batch; exhausted attempts become failed and can be retried individually.
-
 Direct `create_deerflow_agent(...)` integrations can own the same boundary explicitly instead of relying on Gateway startup. Construct one `SubagentRuntime` and share it across every graph in that application; its `max_running`, ordinary per-run total, bound `task` tool, and optional durable-batch tools then use the same caller-owned snapshot and execution controller. A runtime with a batch repository owns a worker and must be started before graph construction and stopped during application shutdown:
 
 ```python
@@ -2835,8 +2812,6 @@ The factory still does not load YAML or create SQL infrastructure: the caller su
 
 Administrators can add, edit, disable, and delete reusable worker definitions from **Settings → Subagents**. Built-in and `config.yaml` definitions remain visible there as read-only entries. The default Lead Agent can use every enabled runtime sub-agent; each page-created Custom Agent can instead allow all, none, or a selected set. That selection is enforced both in the model-visible directory and by the server-side `task` tool. Managed definitions are deployment-wide in this version and follow `agent_storage.backend`: atomic files for a local deployment or the shared application database for multiple instances.
 
-Native workers support per-subagent `thinking_enabled` and `reasoning_effort` through YAML configuration and the managed-subagent API. Unconfigured workers keep the existing thinking-off request; the selected model's required-thinking policy, supported effort values and aliases still apply. These settings do not inherit the lead agent's thinking preferences.
-
 For example, independent read-only research can run concurrently when the wall-clock savings outweigh duplicated discovery and synthesis cost, while a repository refactor with shared files and sequential test feedback remains with the lead agent. When `max_concurrent_subagents` is `1`, parallel and multi-batch routing guidance is disabled; delegation remains available only for material specialist or context-isolation benefit.
 
 ### Sandbox & File System
@@ -3001,8 +2976,6 @@ Each task gets its own execution environment with a full filesystem view — ski
 
 The read-before-write gate ties each read mark to that `read_file` call's result, including custom tools returning multi-message `Command` updates. An unrelated result cannot authorize a write after a failed read or hide a successful read.
 
-Deeply nested JSON returned by tools, including `read_file`, keeps its original content when result analysis reaches the JSON parser's depth limit. Explicit tool failures remain errors with an unknown category when depth prevents analysis.
-
 On Linux and macOS, local sandbox `write_file` replacements and `str_replace` stage complete text before replacing the destination, so write, flush or publication errors retain the previous file. Existing write access is checked; ownership, permission bits, ACLs and extended attributes are transferred before writing staging content. Failure to transfer metadata aborts the save. Successful revisions get a fresh modification time, including empty saves; source-descriptor cleanup errors are warnings and do not change the save result. Files with set-id bits, macOS file flags or content-bound Linux privilege attributes are refused unchanged. Replacement requires parent-directory write access and publishes a new inode; other hard links retain the previous version. Symlinks follow the existing path-validation rules. Append writes, other host platforms (including Windows), shell writes and remote providers keep their existing behavior. This is not a concurrent-writer or power-loss recovery guarantee.
 
 Loop warnings let agents save collected results before their final answer. If the save is blocked by the read-before-write gate, the agent may read the target file and retry the save once. A looping or stopped tool must be replaced by an available alternative; if no permitted save path exists or the retry fails, the final answer includes the collected results and reports that the file was not saved. When `present_files` is available, the warning also asks the agent to present the files it already created in `/mnt/user-data/outputs` before answering, so finished outputs are delivered. Recovery calls still count toward the loop limits, and a hard stop prevents further tool execution.
@@ -3074,7 +3047,7 @@ recording the others. A concurrent scratch-file removal therefore does not
 discard the whole snapshot or suppress detection of other produced outputs.
 This remains a best-effort scan, not an atomic filesystem snapshot.
 
-Files presented through `present_files` remain part of the thread's artifact state, and the Web UI restores the artifact panel and selected document after a page refresh. Long artifact lists scroll within the panel on desktop and in the mobile drawer, keeping every file reachable. When a completed response successfully presents between 2 and 50 files, its final file card also offers one ZIP download. Archive membership comes from the terminal delivery receipt rather than browser-supplied paths, and the ZIP contains the current file versions, which may have changed since the response. The currently selected formal artifact is refreshed once when the run finishes so edits become visible without a manual reload. Existing UTF-8 text artifacts under `/mnt/user-data/outputs` can also be edited and explicitly saved from the panel on Unix and Windows while the thread is idle; saves use content revisions to prevent overwriting agent changes. A delayed background read cannot replace a successfully saved revision in the editor; cancelled preview and full-file reads also abort their HTTP requests. Source previews also recognize extensionless `Dockerfile` and `Makefile` artifacts by their file names. Unknown file types, including names such as `constructor` and `__proto__`, retain the download fallback.
+Files presented through `present_files` remain part of the thread's artifact state, and the Web UI restores the artifact panel and selected document after a page refresh. Long artifact lists scroll within the panel on desktop and in the mobile drawer, keeping every file reachable. When a completed response successfully presents between 2 and 50 files, its final file card also offers one ZIP download. Archive membership comes from the terminal delivery receipt rather than browser-supplied paths, and the ZIP contains the current file versions, which may have changed since the response. The currently selected formal artifact is refreshed once when the run finishes so edits become visible without a manual reload. Existing UTF-8 text artifacts under `/mnt/user-data/outputs` can also be edited and explicitly saved from the panel on Unix and Windows while the thread is idle; saves use content revisions to prevent overwriting agent changes. Source previews also recognize extensionless `Dockerfile` and `Makefile` artifacts by their file names. Unknown file types, including names such as `constructor` and `__proto__`, retain the download fallback.
 
 Unsaved artifact edits survive switching chats, workspace pages, or visiting the
 home page and returning in the same browser tab. Drafts stay in memory for the
@@ -3246,8 +3219,6 @@ Then uncomment the `group: browser` tool entries in `config.yaml` (`browser_navi
 
 Existing, non-mock Custom Agent chats expose the same Browser Live controls when browser control is available and the agent either leaves `tool_groups` unrestricted or includes the `browser` group. An explicit tool-group allowlist without `browser` keeps those controls hidden.
 
-Closing a login popup returns browser control to a surviving tab in the same session, preserving cookies and site storage. If every tab closes, the next browser action opens a tab in that same session. Recovered tabs are brought to the front in DeerFlow-managed browsers; CDP-attached Chrome keeps the user's current tab focus.
-
 The workspace Browser Live client negotiates binary JPEG WebSocket frames,
 keeps only the newest pending frame per display refresh, and revokes replaced
 object URLs. Gateway control messages remain JSON, and clients that do not
@@ -3275,12 +3246,6 @@ when retries are exhausted. Turn Live off and on to start a fresh retry budget.
 **Visible Tool-Run Completion**: For interactive turns, DeerFlow retries an empty post-tool final response once, then surfaces a visible error instead of reporting a silent successful run.
 
 **Run History**: Image-only user input is recorded once per run, even when the agent makes multiple model calls. Its media content remains in history without requiring a text summary.
-Web history keeps separate tool results in their original positions when a
-provider reuses a tool-call ID across turns or runs. Copies of the same result
-are matched by their message ID. Legacy results without message IDs are kept
-separately because their provider ID alone cannot identify an invocation.
-A result delivered before its assistant still resolves when that call is unique
-in the turn. Rebuilt results from the same current invocation keep one history entry.
 
 ### Reading a Referenced Conversation
 
@@ -3315,11 +3280,6 @@ become available in the next batch, when rejected additions can be retried.
 
 ### Long-Term Memory
 
-DeerMem trims oversized user/history summaries against the configured token
-counter, including the omission marker and retained facts. Mixed-language text
-does not rely on an average character/token ratio; the existing guaranteed-fact
-allowance remains unchanged.
-
 Settings > Appearance > Language also supplies the preferred language for replies
 and new automatic DeerMem facts and summary updates on subsequent chat turns and
 replays. Explicit user language requests take precedence. Existing memories are
@@ -3530,10 +3490,6 @@ Thread IDs may be supplied by callers and do not have to be UUIDs. Explicit
 IDs must contain 1–64 ASCII letters, digits, hyphens, or underscores
 (`^[A-Za-z0-9_-]{1,64}$`). DeerFlow generates a UUID only when `thread_id` is
 omitted or `None`; an explicitly supplied empty string is invalid.
-Concurrent `POST /api/threads` requests and automatic run metadata creation share
-same-ID admission in one Gateway, preserving the first thread's metadata and status.
-HTTP retries also preserve its current checkpoint. SQL-backed Gateways retain
-duplicate-insert recovery across workers.
 Existing route-addressable threads created under older, looser rules remain
 readable and deletable, but cannot start new runs or create new filesystem or
 sandbox state. Legacy deletion skips local path cleanup when the ID is not

README_ko.md

@@ -1195,7 +1195,7 @@ Agent settings에서 **Tool access**는 설정된 모든 도구 그룹을 상속
 비전을 지원하는 에이전트의 경우 `view_image`와 그 뒤에 이어지는 모델 컨텍스트 이미지 읽기에도 `sandbox:execute`가 필요합니다. 도구 이름만 허용해서는 이미지 파일 접근 권한이 부여되지 않으며, 샌드박스 실행이 거부된 역할은 권한이 변경된 후 이전에 기록된 이미지 메타데이터를 다시 읽을 수 없습니다. 외부 실행 입력과 스레드 상태 업데이트로는 `viewed_images`나 `thread_data`를 설정할 수 없습니다. 저장된 이미지를 호스트 사본에서 읽을 때는 해당 경로가 현재 사용자의 스레드와 기록된 가상 이미지 경로로 해석되어야 합니다.
 각 모델 요청에는 최근에 본 이미지가 최대 4개, base64 이미지 데이터가 최대 28 MiB까지 포함됩니다. 이 제한으로 제외된 이미지는 생략된 것으로 보고되며, 에이전트는 `view_image`를 다시 호출해 이미지를 컨텍스트로 다시 가져올 수 있습니다.
 
-고급 배포에서는 `config.yaml` 또는 `extensions_config.json`의 `extensions.middlewares` 아래에 `AgentMiddleware` 클래스를 선언하여 에이전트 런타임 자체를 확장할 수도 있습니다. 각 항목은 `module.path:ClassName` 문자열(인자 없는 생성자) 또는 객체 `{class, kwargs, apply_to}`이며, 객체의 `kwargs`는 생성자에 전달됩니다. `kwargs` 값은 JSON 타입(객체, 배열, 문자열, 숫자, 불리언, null)이어야 하며, YAML 날짜와 타임스탬프는 JSON과 일치하도록 ISO 문자열로 변환됩니다. DeerFlow는 각 체인에 대해 선택된 설정 항목을 리드 에이전트와 서브에이전트 파이프라인에 불러오며, 그 위치는 기본 제공 런타임 미들웨어와 루프/토큰 가드 뒤, 그리고 terminal-response/safety/clarification 꼬리 앞입니다. 따라서 엔터프라이즈 포크는 기본 제공 미들웨어 빌더를 패치하지 않고도 도메인 가드레일, 도구 호출 거버넌스, 관측성 훅을 추가할 수 있습니다. 패키지 누락, 잘못된 클래스, 손상된 모듈, 생성자 오류는 에이전트 생성 시점에 명확한 오류로 실패합니다. `config.yaml`과 `extensions_config.json`은 운영자가 제어하는 신뢰된 파일로 취급하세요. 커스텀 도구, 모델, 샌드박스, 가드레일, MCP 서버, MCP 인터셉터 선언과 마찬가지로 미들웨어 경로는 곧 코드 실행입니다. Gateway의 스킬/MCP 토글 엔드포인트는 이 필드를 보존하지만 `extensions.middlewares`에 대한 API 쓰기 경로는 제공하지 않습니다. 객체의 선택적 `apply_to`는 `both`(기본값), `lead`, `subagent`를 지원하며, 문자열 항목과 이 필드를 생략한 객체는 계속 두 파이프라인 모두에 적용됩니다. 해당 체인에서 제외된 항목은 임포트하거나 인스턴스화하지 않습니다.
+고급 배포에서는 `config.yaml` 또는 `extensions_config.json`의 `extensions.middlewares` 아래에 `AgentMiddleware` 클래스를 선언하여 에이전트 런타임 자체를 확장할 수도 있습니다. 각 항목은 `module.path:ClassName` 문자열(인자 없는 생성자) 또는 객체 `{class, kwargs}`이며, 객체의 `kwargs`는 생성자에 전달됩니다. `kwargs` 값은 JSON 타입(객체, 배열, 문자열, 숫자, 불리언, null)이어야 하며, YAML 날짜와 타임스탬프는 JSON과 일치하도록 ISO 문자열로 변환됩니다. DeerFlow는 설정된 같은 목록을 리드 에이전트와 서브에이전트 파이프라인에 불러오며, 그 위치는 기본 제공 런타임 미들웨어와 루프/토큰 가드 뒤, 그리고 terminal-response/safety/clarification 꼬리 앞입니다. 따라서 엔터프라이즈 포크는 기본 제공 미들웨어 빌더를 패치하지 않고도 도메인 가드레일, 도구 호출 거버넌스, 관측성 훅을 추가할 수 있습니다. 패키지 누락, 잘못된 클래스, 손상된 모듈, 생성자 오류는 에이전트 생성 시점에 명확한 오류로 실패합니다. `config.yaml`과 `extensions_config.json`은 운영자가 제어하는 신뢰된 파일로 취급하세요. 커스텀 도구, 모델, 샌드박스, 가드레일, MCP 서버, MCP 인터셉터 선언과 마찬가지로 미들웨어 경로는 곧 코드 실행입니다. Gateway의 스킬/MCP 토글 엔드포인트는 이 필드를 보존하지만 `extensions.middlewares`에 대한 API 쓰기 경로는 제공하지 않습니다. 리드 에이전트 전용/서브에이전트 전용 미들웨어 목록을 따로 지정하는 기능은 아직 지원되지 않습니다.
 
 패키지화되고 설정 가능한 런타임 통합에는 DeerFlow의 확장 관리자를 사용하세요. 확장 관리자는 Python 패키지 요구 사항, 공개 HTTPS Git URL, 또는 로컬 디렉터리를 받아 백엔드 전용 `extensions` 의존성 그룹에 패키지를 설치하고, `backend/uv.lock`을 업데이트하며, 시작 시에만 읽는 `config.yaml`의 최상위 `plugins:` 목록에 활성화된 항목을 추가합니다.
 

backend/README.md

@@ -156,8 +156,8 @@ to a boundary (SQLite) or causing the search to fail (PostgreSQL).
 | `POST /api/skills/install` | Install skill from `.skill` archive |
 | `GET /api/memory` | Retrieve memory data |
 | `POST /api/memory/reload` | Force memory reload |
-| `GET /api/memory/config` | Memory configuration; credential values in `backend_config` are masked |
+| `GET /api/memory/config` | Memory configuration |
-| `GET /api/memory/status` | Combined config (masked the same way) + data |
+| `GET /api/memory/status` | Combined config + data |
 | `GET /api/threads/{id}/runs/{run_id}/events` | Debug/audit events for one run; filter `event_types=context:memory` for effective memory identity |
 | `POST /api/threads/{id}/uploads` | Upload files (optional PDF/PPT/Excel/Word-to-Markdown conversion, rejects directory paths, auto-renames duplicate filenames in one request) |
 | `GET /api/threads/{id}/uploads/list` | List uploaded files |

backend/README_zh.md

@@ -126,8 +126,8 @@ FastAPI 应用程序，为前端集成提供 REST 接口：
 | `POST /api/skills/install` | 从 `.skill` 归档文件安装技能 |
 | `GET /api/memory` | 获取记忆数据 |
 | `POST /api/memory/reload` | 强制重新加载记忆 |
-| `GET /api/memory/config` | 获取记忆配置；`backend_config` 中的凭据值会被遮蔽 |
+| `GET /api/memory/config` | 获取记忆配置 |
-| `GET /api/memory/status` | 获取组合后的配置（同样遮蔽凭据）和数据状态 |
+| `GET /api/memory/status` | 获取组合后的配置和数据状态 |
 | `GET /api/threads/{id}/runs/{run_id}/events` | 获取某次运行的调试或审计事件；可使用 `event_types=context:memory` 筛选实际记忆标识 |
 | `POST /api/threads/{id}/uploads` | 上传文件（可选地将 PDF、PPT、Excel、Word 转换为 Markdown；拒绝目录路径；自动重命名单次请求中的重复文件名） |
 | `GET /api/threads/{id}/uploads/list` | 列出已上传的文件 |

backend/app/channels/AGENTS.md

@@ -47,7 +47,7 @@ Shared attachment feedback uses public `attachment_delivery_text`, preserves rou
 6. Slack/Discord chat: `runs.wait()` → extract final response → publish outbound
 6b. GitHub chat (`ChannelRunPolicy.fire_and_forget=True`): `runs.create()` returns once the run is `pending`; the manager does not wait for the final state and does not publish an outbound; the agent posts its own reply via sandbox `gh`. `ConflictError` on a busy thread still trips the standard `THREAD_BUSY_MESSAGE` path (log-only on GitHub); with `buffer_followups_on_busy=True` (GitHub's default) the triggering message is captured into a per-thread buffer so a concurrent comment is not silently dropped (see "Follow-up buffering while busy").
 7. Feishu patches one card per source (`config.update_multi=true`), with topic previews and queued → running → final states. Opt-in cards show context/question; bounded tokens preserve request ID/source. Originator/option checks consume once; consumption fails closed across workers (`feishu_card_interaction.py`). Card replies keep bound aliases in fields/metadata; ordinary replies preserve `/new`. Accepted intake retires only that card's buttons/text hint before terminal PATCH; rejected intake keeps text fallback. Non-final chunks store each thread alias once per reply; the final rewrites all.
-8. Telegram previews: 1s private/3s group, 20/min, 4096 chars; drop rate-limited updates, split final overflow. Only private sends (`chat_id > 0`) use `allow_sending_without_reply`; degrade missing targets atomically. Preserve group/forum routing/retries and durable owner aliases. Stream mapping errors log one traceback/answer, then debug; delivery/retries continue.
+8. Telegram edits the "Working on it..." stream target: 1s private/3s group throttle (20 msg/min), 4096-char truncation, rate-limited updates dropped; final edits split overflow. Text/preview/photo/document reply sends use `allow_sending_without_reply` only for `chat_id > 0`: missing private targets degrade atomically; group/forum routing and transport retries stay unchanged.
 9. DingTalk AI Cards (`card_template_id`): `runs.stream()` → create card with initial text → `PUT /v1.0/card/streaming` → finalize (`is_final=True`). Creation/streaming failure uses `sampleMarkdown`; tables preserve escaped pipes and empty edge cells. Card calls get the channel token, not the SDK's.
 10. For commands (`/new`, `/status`, `/models`, `/model`, `/memory`, `/goal`, `/agent`, `/help`): handle locally or query Gateway API. `/agent list` reads the effective owner's Custom Agents; `/agent use <name>` validates in the same owner bucket, creates a new thread, and persists `channel_agent_name` in its metadata. A Custom Agent writes canonical `metadata.agent_name` so thread-search routes Web continuation to `/workspace/agents/<name>/chats/<thread_id>`; `lead_agent` omits it and stays on the ordinary chat route. 
 `/model <name>` persists `channel_model_name` in the *current* thread's metadata (in place, no fresh thread); `/model` reports the effective model, `/model default` clears it (stale pins self-clear).

backend/app/channels/discord.py

@@ -28,7 +28,6 @@ from app.channels.message_bus import (
     OutboundMessage,
     ResolvedAttachment,
 )
-from deerflow.utils.atomic_write import publish_bytes_atomically
 from deerflow.utils.file_io import await_drained
 
 logger = logging.getLogger(__name__)
@@ -276,10 +275,7 @@ class DiscordChannel(Channel):
             try:
                 snapshot = dict(self._active_threads)
                 self._thread_store_path.parent.mkdir(parents=True, exist_ok=True)
-                # Publish through the shared helper: it fsyncs the staged bytes
+                self._thread_store_path.write_text(json.dumps(snapshot, indent=2), encoding="utf-8", newline="")
-                # before the rename (so a machine crash cannot leave an empty
-                # mapping behind) and re-applies an existing file's mode.
-                publish_bytes_atomically(self._thread_store_path, json.dumps(snapshot, indent=2).encode("utf-8"))
             except Exception:
                 logger.exception("[Discord] failed to persist thread mappings")
 

backend/app/channels/telegram.py

@@ -323,20 +323,14 @@ class TelegramChannel(Channel):
 
         if not msg.is_final:
             await self._send_stream_update(chat_id, key, msg.text, reply_to=self._parse_message_id(msg.thread_ts))
-            state = self._stream_messages.get(key)
-            if state is not None:
-                binding = (msg.thread_id, msg.connection_id, msg.owner_user_id, msg.thread_ts, state["message_id"])
-                if state.get("thread_binding") != binding and await self._remember_reply_thread(msg, state["message_id"], stream_state=state):
-                    state["thread_binding"] = binding
             return
 
         state = self._stream_messages.pop(key, None)
         if state is not None:
-            await self._remember_reply_thread(msg, state["message_id"], stream_state=state)
             if self._can_send_rich(msg.text) and await self._edit_rich_message(chat_id, state["message_id"], msg.text):
                 self._last_bot_message[msg.chat_id] = state["message_id"]
                 return
-            await self._finalize_stream_message(chat_id, msg.chat_id, state, msg.text, msg)
+            await self._finalize_stream_message(chat_id, msg.chat_id, state, msg.text)
             return
 
         if self._can_send_rich(msg.text):
@@ -346,51 +340,10 @@ class TelegramChannel(Channel):
                 logger.warning("[Telegram] Rich Message send failed in chat=%s; falling back to plain text: %s", chat_id, exc)
                 message_id = None
             if message_id is not None:
-                await self._remember_reply_thread(msg, message_id)
                 return
 
         for chunk in self._split_message(msg.text):
-            message_id = await self._send_new_message(chat_id, msg.chat_id, chunk, _max_retries=_max_retries)
+            await self._send_new_message(chat_id, msg.chat_id, chunk, _max_retries=_max_retries)
-            await self._remember_reply_thread(msg, message_id)
-
-    async def _remember_reply_thread(self, msg: OutboundMessage, message_id: int | None, *, stream_state: dict[str, Any] | None = None) -> bool:
-        """Keep group replies on their source thread, without undoing a later /new."""
-        if not msg.thread_id or message_id is None or int(msg.chat_id) >= 0:
-            return True
-        store = self.config.get("channel_store")
-        if msg.connection_id:
-            # Bound conversations must never fall back to the shared legacy store.
-            if self._connection_repo is None or not msg.owner_user_id:
-                return False
-        elif store is None:
-            return False
-        topic_ids = {str(message_id)}
-        if msg.thread_ts:
-            topic_ids.add(msg.thread_ts)
-        try:
-            for topic_id in topic_ids:
-                if msg.connection_id:
-                    await self._connection_repo.claim_thread_id(
-                        connection_id=msg.connection_id,
-                        owner_user_id=msg.owner_user_id,
-                        provider=self.name,
-                        external_conversation_id=msg.chat_id,
-                        external_topic_id=topic_id,
-                        thread_id=msg.thread_id,
-                    )
-                else:
-                    await store.claim_thread_id(self.name, msg.chat_id, msg.thread_id, topic_id=topic_id)
-        except Exception:
-            # Delivery has already succeeded. Retry the binding on the next update,
-            # not the Telegram send, which could duplicate a visible reply.
-            if stream_state is not None and stream_state.get("thread_binding_error_logged"):
-                logger.debug("[Telegram] reply thread mapping retry failed in chat=%s", msg.chat_id)
-            else:
-                logger.exception("[Telegram] failed to remember reply thread mapping in chat=%s", msg.chat_id)
-                if stream_state is not None:
-                    stream_state["thread_binding_error_logged"] = True
-            return False
-        return True
 
     async def _send_stream_update(self, chat_id: int, key: str, text: str, reply_to: int | None = None) -> None:
         """Edit the in-flight streamed message with accumulated text.
@@ -456,7 +409,7 @@ class TelegramChannel(Channel):
         state["last_edit_at"] = _monotonic()
         state["last_text"] = display
 
-    async def _finalize_stream_message(self, chat_id: int, chat_key: str, state: dict[str, Any], text: str, msg: OutboundMessage) -> None:
+    async def _finalize_stream_message(self, chat_id: int, chat_key: str, state: dict[str, Any], text: str) -> None:
         """Apply the final text: edit the streamed message, splitting overflow into follow-ups."""
         bot = self._application.bot
         chunks = self._split_message(text or "")
@@ -470,12 +423,10 @@ class TelegramChannel(Channel):
         else:
             # Edit could not be applied (e.g. message deleted) — deliver the
             # first chunk as a fresh message with the standard retry policy.
-            message_id = await self._send_new_message(chat_id, chat_key, chunks[0])
+            await self._send_new_message(chat_id, chat_key, chunks[0])
-            await self._remember_reply_thread(msg, message_id, stream_state=state)
 
         for chunk in chunks[1:]:
-            message_id = await self._send_new_message(chat_id, chat_key, chunk)
+            await self._send_new_message(chat_id, chat_key, chunk)
-            await self._remember_reply_thread(msg, message_id, stream_state=state)
 
     async def _edit_final_chunk(self, bot, chat_id: int, message_id: int, text: str) -> bool:
         """Edit with one rate-limit retry. Returns False if the edit could not be applied."""
@@ -610,7 +561,6 @@ class TelegramChannel(Channel):
                 sent = await bot.send_document(**kwargs)
 
             self._last_bot_message[msg.chat_id] = sent.message_id
-            await self._remember_reply_thread(msg, sent.message_id)
             logger.info("[Telegram] file sent: %s to chat=%s", attachment.filename, msg.chat_id)
             return True
         except Exception:

backend/app/channels/wechat.py

@@ -32,7 +32,6 @@ from app.channels.commands import is_known_channel_command
 from app.channels.connection_identity import attach_connection_identity
 from app.channels.credential_staging import cleanup_stale_credential_staging, credential_staging_prefix
 from app.channels.message_bus import INBOUND_FILE_CLEANUP_KEY, InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment, cleanup_inbound_files
-from deerflow.utils.atomic_write import publish_bytes_atomically
 from deerflow.utils.file_io import await_drained
 
 logger = logging.getLogger(__name__)
@@ -1708,10 +1707,7 @@ class WechatChannel(Channel):
             return
         try:
             self._cursor_path.parent.mkdir(parents=True, exist_ok=True)
-            # Publish through the shared helper: it fsyncs the staged bytes
+            self._cursor_path.write_text(json.dumps({"get_updates_buf": self._get_updates_buf}, ensure_ascii=False, indent=2), encoding="utf-8", newline="")
-            # before the rename (so a machine crash cannot leave a truncated
-            # cursor behind) and re-applies an existing file's mode.
-            publish_bytes_atomically(self._cursor_path, json.dumps({"get_updates_buf": self._get_updates_buf}, ensure_ascii=False, indent=2).encode("utf-8"))
         except OSError:
             logger.warning("[WeChat] failed to persist cursor state to %s", self._cursor_path)
 

backend/app/gateway/AGENTS.md

@@ -4,11 +4,6 @@ Reject external `sandbox`, `thread_data`, `viewed_images`, `goal_outcome`. Non-n
 
 Studio retains sanitized creation metadata.
 
-HTTP and run metadata creation share `goal_thread_lock`. Lock in detached
-`_ensure_thread_metadata`; preserve await-free attachment and cancel/drain
-ownership. Its 5s budget covers admission and I/O: timeout fails strict starts;
-others omit incarnation (MCP fails closed). Tests: `test_thread_create_run_metadata_race.py`.
-
 Capability Center's `business` adapter validates bundled credentials and creates
 an MCP connection. The MCP API permits only its isolated launcher and credential
 environment keys; reject arbitrary commands and manifest-policy bypasses. Keep
@@ -81,32 +76,28 @@ OIDC redirects retain existing endpoint query bytes (RFC 6749 section 3.1).
 Malformed IdP bodies raise `OIDCError` (502/`sso_failed`).
 `tests/test_oidc_auth.py` pins query, state-cookie, nonce and PKCE agreement.
 
-PATs (`app.gateway.auth.pat`, `Authorization: Bearer dfp_...`) act as their owner.
+Personal Access Tokens (`app.gateway.auth.pat`, `Authorization: Bearer dfp_...`) run as their owning user: an invalid Bearer is a hard 401 with no cookie fallback, which keeps `CSRFMiddleware`'s Bearer skip safe (origin checks still run). Scopes narrow within the allowlisted threads/runs/projects routes (including `POST /api/threads/{id}/move`); every other authenticated route 403s PAT callers (admin included). PAT management and `/change-password` require session auth; only SHA-256 digests are stored (`0017`).
-Invalid Bearers return 401 without cookie fallback, keeping `CSRFMiddleware`'s
-Bearer skip safe; origin checks still run. Scopes narrow allowlisted thread/run/
-project routes, including `POST /api/threads/{id}/move`; other authenticated
-routes reject PATs with 403, even for admins. PAT management and `/change-password`
-require session auth. Store only SHA-256 digests (`0017`).
 
-Thread→project membership is written only by thread creation (`POST /api/threads`
+Thread→project membership is written by thread creation (`POST /api/threads` with
-with validated `project_id`), branch creation (inherit the source project;
+a validated `project_id`), branch creation (the new row inherits the source
-archived/deleted projects become unassigned rather than failing), and explicit
+thread's project; an archived/deleted project degrades the branch to unassigned
-`POST /api/threads/{id}/move`. Run admission pins resolved project context
+instead of failing), and explicit moves (`POST /api/threads/{id}/move`); run
-read-only and never changes membership. Server-reserved `deerflow_project_id`
+admission never modifies membership; it only pins the resolved project context
-metadata exposes `threads_meta.project_id` read-only and is stripped from client writes.
+read-only into the run context. The server-reserved `deerflow_project_id`
+metadata key is a read-only exposure of the `threads_meta.project_id` column and
+is stripped from client writes.
 
-Localhost persistence trusts direct `Host`, not `Forwarded`/`X-Forwarded-Host`.
+Localhost persistence deliberately reads the direct request `Host` and ignores `Forwarded` / `X-Forwarded-Host`. Scheme and auth-origin reconstruction still consume forwarding headers. The bundled nginx sets `X-Forwarded-Proto`, but preserves an upstream HTTPS value and does not overwrite every forwarded header, so the outer trusted proxy must replace or strip client-supplied forwarding headers before traffic reaches DeerFlow.
-Scheme/auth-origin reconstruction still uses forwarding headers. Nginx sets
-`X-Forwarded-Proto` but preserves upstream HTTPS and some other forwarded headers;
-the outer trusted proxy must replace/strip client copies before DeerFlow.
 
-Recognize standalone Studio only by upstream `Auth.types.StudioUser`, never its
+Standalone local LangGraph Studio is recognized only through the upstream
-reusable identity string. Resolve the type once at import; older SDKs without
+`Auth.types.StudioUser` principal type, never by its reusable identity string.
-it retain normal owner scoping. For its assistant reads/searches,
+The type is resolved once at import; an older SDK without it degrades to normal
-`langgraph_auth.add_owner_filter` admits genuine server-registered assistants
+owner scoping.
-and Studio-owned rows; other resources stay owner-scoped. Assistant create/update
+For that principal's assistant reads/searches, `langgraph_auth.add_owner_filter`
-forces server-owned `user_id` and `created_by=user`: LangGraph treats
+selects genuine server-registered assistants plus assistants owned by Studio;
-`created_by=system` as privileged run ownership. The
+all other resources remain owner-scoped. Assistant create/update handlers make
+both `user_id` and `created_by=user` server-owned, because LangGraph gives
+`created_by=system` privileged ownership semantics during run creation. The
 custom application module in `langgraph_studio.py` is imported before the
 locked in-memory runtime lifespan. At that pre-runtime boundary it derives
 genuine system assistant IDs from the CLI-provided graph registry, removes

backend/app/gateway/context_usage.py

@@ -66,10 +66,7 @@ def build_context_usage_payload(*, token_count: int, max_context_tokens: int | N
 async def build_context_usage(request: Request, thread_id: str, run_store: Any, user_id: str | None = None) -> dict[str, Any] | None:
     """Return approximate usage for the latest materialized thread checkpoint."""
     try:
-        # ``get_config`` revalidates ``config.yaml`` and
+        app_config = get_config()
-        # ``extensions_config.json`` on every call (stat + full-file hash), so
-        # reading it here would put that IO on the loop every thread view pays.
-        app_config = await asyncio.to_thread(get_config)
     except HTTPException:
         return None
 

backend/app/gateway/extension_agent_runs.py

@@ -245,40 +245,6 @@ class _BoundAgentRuns:
         async with self._request("threads:read", thread_id) as request:
             return (await get_thread_state(thread_id, request)).model_dump(mode="json")
 
-    async def send_input(self, *, thread_id, run_id, text, mode, request_id, context=None):
-        from app.gateway.routers.thread_runs import create_run_input
-        from app.gateway.run_inputs import RunInputRequest
-
-        async with self._request("runs:create", thread_id) as request:
-            body = RunInputRequest(request_id=request_id, text=text, mode=mode, context=_json_object(context) or {})
-            body = body.model_copy(update={"request_id": hashlib.sha256(f"{self._plugin_namespace or 'host'}:{body.request_id}".encode()).hexdigest()})
-            return await create_run_input(thread_id, run_id, body, request)
-
-    async def dispatch_input(self, *, thread_id, run_id, input_id):
-        from app.gateway.run_inputs import dispatch_one_input
-
-        async with self._request("runs:create", thread_id) as request:
-            return await dispatch_one_input(thread_id, run_id, input_id, request)
-
-    async def list_inputs(self, *, thread_id):
-        from app.gateway.routers.thread_runs import get_thread_inputs
-
-        async with self._request("threads:read", thread_id) as request:
-            return await get_thread_inputs(thread_id, request)
-
-    async def authorize_control(self, *, thread_id, run_id, clear_goal=False):
-        from app.gateway.deps import get_run_manager
-
-        async with self._request("runs:cancel", thread_id) as request:
-            run = await get_run_manager(request).get(run_id, user_id=self._user_id)
-            if run is None or run.thread_id != thread_id:
-                raise AgentRunError(404, "Run unavailable")
-            if run.status not in ("pending", "running"):
-                raise AgentRunError(409, "Run already stopped")
-        if clear_goal:
-            async with self._request("threads:write", thread_id):
-                pass
-
     async def cancel(self, *, thread_id, run_id, execution_fence=None) -> None:
         from app.gateway.routers.thread_runs import cancel_run
 

backend/app/gateway/routers/AGENTS.md

@@ -1,11 +1,5 @@
 # Router contracts
 
-HTTP creation holds `goal_thread_lock` from the idempotency lookup through the
-initial checkpoint write. Same-id HTTP creates must return the existing row,
-including in memory mode; retain the native memory store's overwrite contract
-and SQL duplicate-insert recovery across workers. Release on failure/cancellation
-without blocking different thread IDs. Tests: `test_thread_create_idempotency.py`.
-
 `GET /api/plugins/diagnostics` uses `require_admin_user` before reading the
 canonical runtime diagnostic snapshot. Return bounded entry-point identifiers,
 known levels and fixed summaries; raw messages stay in logs. Never clear the

backend/app/gateway/routers/features.py

@@ -93,7 +93,6 @@ class FeaturesResponse(BaseModel):
     knowledge_base: KnowledgeBaseFeature
     scheduled_tasks: ScheduledTasksFeature
     thread_activity: ThreadActivityFeature
-    run_inputs: bool = False
 
 
 @router.get(
@@ -107,7 +106,6 @@ async def list_features(request: Request, config: AppConfig = Depends(get_config
     browser = browser_capability(config)
     subagent_batch_worker_running = bool(getattr(request.app.state, "subagent_batches_available", False))
     return FeaturesResponse(
-        run_inputs=getattr(getattr(request.app.state, "run_manager", None), "input_store", None) is not None,
         agents_api=AgentsApiFeature(enabled=config.agents_api.enabled),
         browser_control=BrowserControlFeature(enabled=browser.available),
         # MCP task bindings and the submitter are startup-scoped. Report the

backend/app/gateway/routers/mcp.py

@@ -15,7 +15,6 @@ from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_valida
 from app.gateway.deps import require_admin_user
 from app.gateway.mcp_oauth_tokens import forget_unconfigured_mcp_oauth_tokens
 from app.gateway.persistent_writes import run_drained_write
-from app.gateway.secret_masking import MASKED_VALUE, mask_secret_values, normalize_config_key
 from deerflow.config.extensions_config import (
     ExtensionsConfig,
     McpRoutingConfig,
@@ -553,19 +552,29 @@ class McpCacheResetResponse(BaseModel):
     message: str = Field(description="Human-readable reset status")
 
 
-_MASKED_VALUE = MASKED_VALUE
+_MASKED_VALUE = "***"
 _SENSITIVE_EXTRA_KEY_RE = re.compile(
     r"(^|_)(api_key|apikey|access_key|private_key|client_secret|secret|token|password|passwd|credential|credentials|authorization|bearer)(_|$)",
     re.IGNORECASE,
 )
 
 
+def _normalize_config_key(key: str) -> str:
+    with_boundaries = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", key)
+    with_boundaries = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", with_boundaries)
+    return re.sub(r"[^a-z0-9]+", "_", with_boundaries.lower()).strip("_")
+
+
 def _is_sensitive_extra_key(key: str) -> bool:
-    return bool(_SENSITIVE_EXTRA_KEY_RE.search(normalize_config_key(key)))
+    return bool(_SENSITIVE_EXTRA_KEY_RE.search(_normalize_config_key(key)))
 
 
 def _mask_sensitive_extra_value(value: Any) -> Any:
-    return mask_secret_values(value, _is_sensitive_extra_key)
+    if isinstance(value, dict):
+        return {key: _MASKED_VALUE if _is_sensitive_extra_key(str(key)) else _mask_sensitive_extra_value(nested) for key, nested in value.items()}
+    if isinstance(value, list):
+        return [_mask_sensitive_extra_value(item) for item in value]
+    return value
 
 
 def _contains_masked_sensitive_extra_value(key: str, value: Any) -> bool:

backend/app/gateway/routers/memory.py

@@ -1,7 +1,6 @@
 """Memory API router for retrieving and managing global memory data."""
 
 import asyncio
-import re
 from typing import Any, Literal
 
 from fastapi import APIRouter, HTTPException, Request
@@ -10,7 +9,6 @@ from pydantic import BaseModel, Field, field_validator
 from app.gateway.authz import require_permission
 from app.gateway.internal_auth import get_trusted_internal_owner_user_id
 from app.gateway.persistent_writes import run_drained_write
-from app.gateway.secret_masking import mask_secret_values, normalize_config_key
 from deerflow.agents.memory import MemoryConflictError, MemoryCorruptionError, MemoryManager, get_memory_manager
 from deerflow.config.agents_config import AGENT_NAME_PATTERN
 from deerflow.config.memory_config import get_memory_config
@@ -236,18 +234,6 @@ class FactPatchRequest(BaseModel):
     confidence: float | None = Field(default=None, ge=0.0, le=1.0, description="Confidence score (0-1)")
 
 
-# Anchored at the end of the key: DeerMem knobs such as ``token_counting`` and
-# ``guaranteed_token_budget`` are not secrets, and ``api_key_env`` names an
-# environment variable rather than holding the key. This is a denylist: plural
-# ``tokens`` stays out because ``max_injection_tokens`` is a knob, and bare
-# ``key``, ``auth`` or ``session`` are too generic to mask.
-_SECRET_CONFIG_KEY_RE = re.compile(r"(^|_)(api_?keys?|access_keys?|secret_keys?|private_keys?|auth_keys?|secrets?|token|passwords?|passwds?|credentials?|authorization|bearer|cookies?)$")
-
-
-def _is_secret_config_key(key: str) -> bool:
-    return bool(_SECRET_CONFIG_KEY_RE.search(normalize_config_key(key)))
-
-
 class MemoryConfigResponse(BaseModel):
     """Response model for memory configuration."""
 
@@ -256,13 +242,7 @@ class MemoryConfigResponse(BaseModel):
     injection_enabled: bool = Field(..., description="Whether memory is injected into the system prompt (call-site gate).")
     shutdown_flush_timeout_seconds: float = Field(..., description="Hard budget (s) to drain pending memory updates on Gateway graceful shutdown; must fit inside the pod's K8s terminationGracePeriodSeconds.")
     manager_class: str = Field(..., description="Active memory backend selector (backend name or dotted path).")
-    backend_config: dict = Field(..., description="Backend-private config (self-interpreted by the backend); credential values such as api_key are masked as ***.")
+    backend_config: dict = Field(..., description="Backend-private config (self-interpreted by the backend).")
-
-    @field_validator("backend_config")
-    @classmethod
-    def _mask_backend_secrets(cls, value: dict) -> dict:
-        """Config loading already resolved ``$VAR`` references, so keys would be plaintext."""
-        return mask_secret_values(value, _is_secret_config_key, keep_unset=True)
 
 
 class MemoryStatusResponse(BaseModel):

backend/app/gateway/routers/subagents.py

@@ -35,8 +35,6 @@ class SubagentResponse(BaseModel):
     disallowed_tools: list[str] | None = None
     skills: list[str] | None = None
     model: str = "inherit"
-    thinking_enabled: bool | None = None
-    reasoning_effort: str | None = None
     max_turns: int = 50
     timeout_seconds: int = 900
     enabled: bool = True
@@ -59,8 +57,6 @@ class ManagedSubagentCreateRequest(BaseModel):
     disallowed_tools: list[str] | None = None
     skills: list[str] | None = None
     model: str = "inherit"
-    thinking_enabled: bool | None = None
-    reasoning_effort: str | None = None
     max_turns: int = Field(default=50, ge=1)
     timeout_seconds: int = Field(default=900, ge=1)
     enabled: bool = True
@@ -74,8 +70,6 @@ class ManagedSubagentUpdateRequest(BaseModel):
     disallowed_tools: list[str] | None = None
     skills: list[str] | None = None
     model: str | None = None
-    thinking_enabled: bool | None = None
-    reasoning_effort: str | None = None
     max_turns: int | None = Field(default=None, ge=1)
     timeout_seconds: int | None = Field(default=None, ge=1)
     enabled: bool | None = None
@@ -100,7 +94,7 @@ def _explicit_overrides(name: str, app_config) -> dict[str, Any]:
     if override is None:
         return {}
     result: dict[str, Any] = {}
-    for field in ("timeout_seconds", "max_turns", "model", "thinking_enabled", "reasoning_effort", "skills"):
+    for field in ("timeout_seconds", "max_turns", "model", "skills"):
         if field not in override.model_fields_set:
             continue
         value = getattr(override, field)
@@ -125,8 +119,6 @@ def _catalog(include_system_prompt: bool) -> SubagentsListResponse:
                 disallowed_tools=definition.disallowed_tools,
                 skills=definition.skills,
                 model=definition.model,
-                thinking_enabled=definition.thinking_enabled,
-                reasoning_effort=definition.reasoning_effort,
                 max_turns=definition.max_turns,
                 timeout_seconds=definition.timeout_seconds,
                 source="builtin",
@@ -144,8 +136,6 @@ def _catalog(include_system_prompt: bool) -> SubagentsListResponse:
                 disallowed_tools=definition.disallowed_tools,
                 skills=definition.skills,
                 model=definition.model,
-                thinking_enabled=definition.thinking_enabled,
-                reasoning_effort=definition.reasoning_effort,
                 max_turns=definition.max_turns,
                 timeout_seconds=definition.timeout_seconds,
                 source="config",

backend/app/gateway/routers/thread_runs.py

@@ -54,7 +54,6 @@ from app.gateway.conversation_reader import (
 from app.gateway.deps import get_current_user, get_feedback_repo, get_run_event_store, get_run_manager, get_run_store, get_stream_bridge
 from app.gateway.internal_auth import INTERNAL_SYSTEM_ROLE, get_trusted_internal_owner_user_id
 from app.gateway.pagination import trim_run_message_page
-from app.gateway.run_inputs import RunInputRequest, change_run_input, list_thread_inputs, submit_run_input
 from app.gateway.run_models import RunCreateRequest
 from app.gateway.services import (
     abuild_checkpoint_state_accessor,
@@ -82,32 +81,6 @@ from deerflow.workspace_changes import get_workspace_changes_response
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/threads", tags=["runs"])
-
-
-@router.post("/{thread_id}/runs/{run_id}/inputs")
-@require_permission("runs", "create", owner_check=True, require_existing=True)
-async def create_run_input(thread_id: ThreadId, run_id: str, body: RunInputRequest, request: Request):
-    return await submit_run_input(thread_id, run_id, body, request)
-
-
-@router.get("/{thread_id}/inputs")
-@require_permission("threads", "read", owner_check=True, require_existing=True)
-async def get_thread_inputs(thread_id: ThreadId, request: Request):
-    return await list_thread_inputs(thread_id, request)
-
-
-@router.delete("/{thread_id}/runs/{run_id}/inputs/{input_id}")
-@require_permission("runs", "cancel", owner_check=True, require_existing=True)
-async def remove_run_input(thread_id: ThreadId, run_id: str, input_id: str, request: Request):
-    return await change_run_input(thread_id, run_id, input_id, request)
-
-
-@router.post("/{thread_id}/runs/{run_id}/inputs/{input_id}/retry")
-@require_permission("runs", "create", owner_check=True, require_existing=True)
-async def retry_run_input(thread_id: ThreadId, run_id: str, input_id: str, request: Request):
-    return await change_run_input(thread_id, run_id, input_id, request, retry=True)
-
-
 REGENERATE_HISTORY_SCAN_LIMIT = 200
 # Doubled to keep ~200 effective checkpoints when duration-only checkpoints
 # (one per successful run in steady state) consume roughly half of history.
@@ -780,19 +753,9 @@ async def _require_successful_source_run(thread_id: str, run_id: str, request: R
         raise HTTPException(status_code=409, detail="Could not find source run for assistant message")
     if _run_status_value(record) != RunStatus.success.value:
         raise HTTPException(status_code=409, detail="Only successful assistant runs can be edited and rerun")
-    await _reject_multi_input_replay(run_id, request, user_id=user_id)
     return record
 
 
-async def _reject_multi_input_replay(run_id: str, request: Request, *, user_id=None) -> None:
-    store = getattr(get_run_manager(request), "input_store", None)
-    if getattr(store, "supports_run_inputs", False) is not True:
-        return
-    row = await store.get(run_id, user_id=user_id)
-    if row is not None and any(entry.get("mode") == "steer" and entry.get("status") != "cancelled" for entry in (row.get("run_inputs") or {}).get("items", [])):
-        raise HTTPException(409, "This Run was adjusted while working; send a new message instead of replaying part of it")
-
-
 async def _find_interrupted_target_run_id(
     thread_id: str,
     source_human: Any,
@@ -869,7 +832,6 @@ async def _prepare_regenerate_payload(thread_id: str, message_id: str, request:
         raise HTTPException(status_code=409, detail="Could not find the user message for this assistant response")
     if target_run_id is None:
         raise HTTPException(status_code=409, detail="Could not find source run for assistant message")
-    await _reject_multi_input_replay(target_run_id, request, user_id=await _run_scope_user_id(request, thread_id))
     previous_human_id = _message_id(previous_human)
     if not previous_human_id:
         raise HTTPException(status_code=409, detail="The source user message is missing an id")

backend/app/gateway/routers/threads.py

@@ -965,17 +965,11 @@ async def create_thread(body: ThreadCreateRequest, request: Request) -> ThreadRe
     and an empty checkpoint (so state endpoints work immediately).
     Idempotent: returns the existing record when ``thread_id`` already exists.
     """
-    thread_id = resolve_thread_id(body.thread_id)
-    async with goal_thread_lock(thread_id):
-        return await _create_thread_locked(body, request, thread_id)
-
-
-async def _create_thread_locked(body: ThreadCreateRequest, request: Request, thread_id: str) -> ThreadResponse:
-    """Keep the idempotency read and initial writes in one lifecycle lock."""
     from app.gateway.deps import get_thread_store
 
     checkpointer = get_checkpointer(request)
     thread_store = get_thread_store(request)
+    thread_id = resolve_thread_id(body.thread_id)
     now = now_iso()
     thread_owner_user_id = get_trusted_internal_owner_user_id(request)
     thread_owner_kwargs = {"user_id": thread_owner_user_id} if thread_owner_user_id else {}
@@ -1012,13 +1006,13 @@ async def _create_thread_locked(body: ThreadCreateRequest, request: Request, thr
         raise HTTPException(status_code=404, detail="Thread not found") from None
     except IntegrityError:
         # The idempotency read above and this insert are not atomic: a
-        # another worker's request for the same thread_id can commit in between, so
+        # concurrent request for the same thread_id can commit in between, so
         # the SQL-backed store rejects ours on the duplicate primary key.
         # Honour the documented idempotency contract by resolving the
         # now-existing record — running the same owner reconciliation the fast
-        # path does — instead of surfacing the conflict as a 500. Same-process
+        # path does — instead of surfacing the conflict as a 500. The memory
-        # HTTP creates share the lifecycle lock; the memory store retains its
+        # store serializes same-id creates under its per-thread lock and keeps
-        # historical overwrite behavior for direct callers.
+        # its historical overwrite behavior, so it does not reach this branch.
         existing_record = await _resolve_existing_thread(thread_store, thread_id, thread_owner_user_id, thread_owner_kwargs)
         if existing_record is not None:
             return _existing_thread_response(thread_id, existing_record)

backend/app/gateway/run_inputs.py

@@ -1,179 +0,0 @@
-"""HTTP admission and ordinary AgentRuns dispatch for in-flight user inputs."""
-
-import copy
-import json
-import logging
-from typing import Literal
-from uuid import NAMESPACE_URL, uuid5
-
-from fastapi import HTTPException, Request
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-from app.gateway.deps import get_current_user, get_run_context, get_run_manager
-from deerflow.runtime.runs.inputs import InputConflict, RunInputs
-
-logger = logging.getLogger(__name__)
-
-
-class RunInputRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    request_id: str = Field(min_length=1, max_length=96)
-    text: str = Field(min_length=1, max_length=16 * 1024)
-    mode: Literal["queue", "steer"]
-    context: dict = Field(default_factory=dict)
-
-    @model_validator(mode="after")
-    def bounded_context(self):
-        if len(json.dumps(self.context, ensure_ascii=True, allow_nan=False).encode()) > 32 * 1024:
-            raise ValueError("Input context exceeds 32 KiB")
-        return self
-
-
-def _store(request):
-    store = get_run_manager(request).input_store
-    if store is None:
-        raise HTTPException(503, "Run inputs are unavailable")
-    return store
-
-
-async def submit_run_input(thread_id: str, run_id: str, body: RunInputRequest, request: Request):
-    manager = get_run_manager(request)
-    user_id = await get_current_user(request)
-    if user_id is None:
-        raise HTTPException(401, "Authentication required")
-    run = await manager.get(run_id, user_id=user_id)
-    if run is None or run.thread_id != thread_id:
-        raise HTTPException(404, "Run not found")
-    if get_run_context(request).agent_runs is None:
-        raise HTTPException(503, "Run inputs require an authenticated session")
-    row = await _store(request).get(run_id, user_id=user_id)
-    if row is None or row.get("run_inputs") is None:
-        raise HTTPException(409, "This Run has not enabled interactive inputs")
-    try:
-        from app.gateway.services import _CONTEXT_CONFIGURABLE_KEYS
-        from deerflow.runtime.run_origin import admit_origin
-
-        context = {key: value for key, value in body.context.items() if key in _CONTEXT_CONFIGURABLE_KEYS and key not in ("agent_name", "is_bootstrap")}
-        if isinstance(body.context.get("locale"), str):
-            context["locale"] = body.context["locale"]
-        source = "extension" if admit_origin(getattr(request.state, "run_origin", None)) is not None else "user"
-        item = await RunInputs(_store(request), run_id, user_id).submit(body.request_id, body.text, body.mode, context=context, source=source)
-    except InputConflict as exc:
-        raise HTTPException(409, str(exc)) from exc
-    return {**item, "target_run_id": run_id}
-
-
-async def list_thread_inputs(thread_id: str, request: Request):
-    user_id = await get_current_user(request)
-    if user_id is None:
-        raise HTTPException(401, "Authentication required")
-    rows = await _store(request).list_input_runs(thread_id, user_id=user_id)
-    items = []
-    for row in reversed(rows):
-        for entry in (row.get("run_inputs") or {}).get("items", []):
-            status = entry["status"]
-            if status in ("pending", "applying") and (row["status"] not in ("pending", "running", "success") or row.get("stop_reason")):
-                status = "not_applied"
-            items.append({key: value for key, value in {**entry, "status": status, "target_run_id": row["run_id"]}.items() if key != "context"})
-    return {"items": items[-32:], "active_run_id": await _store(request).active_input_run(thread_id, user_id=user_id)}
-
-
-async def dispatch_queued_inputs(inputs: RunInputs, *, agent_runs, thread_id: str):
-    """Use normal admission/authorization and its stable idempotency key.
-
-    This runs after the previous worker has fully finalized. No second main
-    Agent, task queue service or recovery scheduler is introduced.
-    """
-    row = await inputs.store.get(inputs.run_id, user_id=inputs.user_id)
-    if row is None or row["status"] != "success" or row.get("stop_reason"):
-        return
-    state = await inputs.read()
-    for entry in state["items"]:
-        if entry["mode"] != "queue" or entry["status"] != "pending":
-            continue
-        try:
-            run = await agent_runs.dispatch_input(thread_id=thread_id, run_id=inputs.run_id, input_id=entry["id"])
-            while run.status in ("pending", "running"):
-                # AgentRuns.wait retains its capped backoff and revocation
-                # checks; a long task exceeding a wait window is still live.
-                try:
-                    run = await agent_runs.wait(thread_id=thread_id, run_id=run.run_id, timeout=60)
-                except TimeoutError:
-                    continue
-            if run.status != "success" or run.stop_reason:
-                await inputs.pause()
-                return
-        except Exception:
-            # Unknown admission outcomes retain the original key and input;
-            # retrying can reconcile the same Run instead of running it twice.
-            logger.warning("Queued input remains undelivered for Run %s", inputs.run_id, exc_info=True)
-            return
-
-
-async def dispatch_one_input(thread_id, run_id, input_id, request, *, retry=False):
-    from deerflow_extension_api.agent_runs import AgentRun
-
-    from app.gateway.routers.thread_runs import create_run, get_run
-    from app.gateway.run_models import RunCreateRequest
-    from app.gateway.services import resolve_thread_assistant_id
-
-    user_id = await get_current_user(request)
-    if user_id is None:
-        raise HTTPException(401, "Authentication required")
-    source = await _store(request).get(run_id, user_id=user_id)
-    if source is None or source["thread_id"] != thread_id:
-        raise HTTPException(404, "Run not found")
-    inputs = RunInputs(_store(request), run_id, user_id)
-    entry = await inputs.claim(input_id, retry=retry)
-    if entry.get("run_id"):
-        run = await get_run(thread_id, entry["run_id"], request)
-        return AgentRun(thread_id, run.run_id, run.status, run.assistant_id, run.stop_reason)
-    message_id = str(uuid5(NAMESPACE_URL, f"deerflow-dispatch:{inputs.run_id}:{input_id}"))
-    context = entry.get("context", {})
-    source_config = (source.get("kwargs") or {}).get("config") or {}
-    limit = source_config.get("recursion_limit")
-    config = {"recursion_limit": limit} if type(limit) is int else None
-    # Carry only the parent's admitted retrieval scope, never its files,
-    # credentials or framework markers. Normal admission rechecks access.
-    from deerflow.knowledge_scope import KNOWLEDGE_SCOPE_KEY
-
-    scope = None
-    for message in ((source.get("kwargs") or {}).get("input") or {}).get("messages", []):
-        if message.get("type", message.get("role")) in ("human", "user"):
-            scope = message.get("additional_kwargs", {}).get(KNOWLEDGE_SCOPE_KEY)
-    message = {"role": "user", "content": entry["text"], "id": message_id}
-    if scope is not None:
-        message["additional_kwargs"] = {KNOWLEDGE_SCOPE_KEY: copy.deepcopy(scope)}
-    if entry.get("source", "user") == "user":
-        # This fact comes from the stored, authenticated input, not from text
-        # or an arbitrary extension-supplied metadata flag.
-        request.state.run_origin = None
-    body = RunCreateRequest(assistant_id=await resolve_thread_assistant_id(request, thread_id, fail_closed=True), input={"messages": [message]}, context=context, config=config, on_disconnect="continue")
-    run = await create_run(thread_id, body, request, idempotency_key=f"run-input:{run_id}:{input_id}")
-    await inputs.dispatched(entry["id"], run.run_id)
-    return AgentRun(thread_id, run.run_id, run.status, run.assistant_id, run.stop_reason)
-
-
-async def change_run_input(thread_id: str, run_id: str, input_id: str, request: Request, *, retry=False):
-    user_id = await get_current_user(request)
-    if user_id is None:
-        raise HTTPException(401, "Authentication required")
-    run = await get_run_manager(request).get(run_id, user_id=user_id)
-    if run is None or run.thread_id != thread_id:
-        raise HTTPException(404, "Run not found")
-    inputs = RunInputs(_store(request), run_id, user_id)
-    try:
-        if retry:
-            handle = get_run_context(request).agent_runs
-            if handle is None:
-                raise HTTPException(503, "Run inputs require an authenticated session")
-            from deerflow.runtime.run_origin import admit_origin
-
-            if admit_origin(getattr(request.state, "run_origin", None)) is not None:
-                raise HTTPException(403, "An unapplied input requires an explicit user retry")
-            dispatched = await dispatch_one_input(thread_id, run_id, input_id, request, retry=True)
-            return {"run_id": dispatched.run_id}
-        await inputs.cancel(input_id)
-        return {"removed": True}
-    except InputConflict as exc:
-        raise HTTPException(409, str(exc)) from exc

backend/app/gateway/secret_masking.py

@@ -1,30 +0,0 @@
-"""Shared masking for credential values that Gateway routes echo back from config."""
-
-import re
-from collections.abc import Callable
-from typing import Any
-
-MASKED_VALUE = "***"
-
-
-def normalize_config_key(key: str) -> str:
-    """Snake-case a config key so ``apiKey``, ``API-Key`` and ``api_key`` compare equal."""
-    with_boundaries = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", key)
-    with_boundaries = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", with_boundaries)
-    return re.sub(r"[^a-z0-9]+", "_", with_boundaries.lower()).strip("_")
-
-
-def mask_secret_values(value: Any, is_secret_key: Callable[[str], bool], *, keep_unset: bool = False) -> Any:
-    """Return a copy of ``value`` with every value under a secret-named key masked, at any depth.
-
-    A secret-named key masks its whole value, containers included: a
-    ``credentials`` mapping can hold keys under arbitrary names, so masking only
-    its secret-named leaves could pass one through. With ``keep_unset``, a
-    ``None`` or ``""`` value stays as it is, so a response still shows that no
-    secret is configured.
-    """
-    if isinstance(value, dict):
-        return {key: MASKED_VALUE if is_secret_key(str(key)) and not (keep_unset and nested in (None, "")) else mask_secret_values(nested, is_secret_key, keep_unset=keep_unset) for key, nested in value.items()}
-    if isinstance(value, list):
-        return [mask_secret_values(item, is_secret_key, keep_unset=keep_unset) for item in value]
-    return value

backend/app/gateway/services.py

@@ -164,8 +164,6 @@ _TERMINAL_RUN_STATUSES = {
 _TERMINAL_STREAM_RECOVERED = "recovered"
 _TERMINAL_STREAM_PRODUCER_EXPIRED = "producer_expired"
 
-# Includes same-thread create admission and metadata I/O; timeout rejects strict
-# starts and leaves non-strict starts without verified metadata (MCP fails closed).
 _THREAD_METADATA_SETUP_TIMEOUT_SECONDS = 5.0
 
 # Message metadata a scheduled launch puts on its prompt: the task, run and the
@@ -202,10 +200,6 @@ _SERVER_OWNED_MESSAGE_METADATA_KEYS = (
             SUBAGENT_RECEIPT_VERDICT_KEY,
             SUBAGENT_ACCEPTANCE_VERDICT_KEY,
             UNTRUSTED_INPUT_KEY,
-            "run_input_id",
-            "run_input_source",
-            "origin_task_id",
-            "subagent_pending",
         }
     )
     | PROVENANCE_KEYS
@@ -267,18 +261,6 @@ async def _ensure_thread_metadata(
     require_existing_thread: bool = False,
 ) -> dict[str, Any]:
     """Ensure an admitted run's thread exists without delaying task attachment."""
-    async with goal_thread_lock(record.thread_id):
-        return await _ensure_thread_metadata_locked(run_ctx, record, owner_user_id=owner_user_id, require_existing_thread=require_existing_thread)
-
-
-async def _ensure_thread_metadata_locked(
-    run_ctx: RunContext,
-    record: RunRecord,
-    *,
-    owner_user_id: str | None,
-    require_existing_thread: bool,
-) -> dict[str, Any]:
-    """Share create admission with HTTP while retaining detached task ownership."""
     thread_store = run_ctx.thread_store
     existing = await thread_store.get(record.thread_id)
     if existing is None and owner_user_id:
@@ -639,7 +621,7 @@ def _normalize_input_messages(
 
 #: State channels only the server writes. ``goal_outcome`` is the "goal met"
 #: record that clearing a satisfied goal writes; a caller copy would forge one.
-SERVER_OWNED_STATE_CHANNELS = frozenset({"sandbox", "thread_data", "viewed_images", "goal_outcome", "applied_run_inputs"})
+SERVER_OWNED_STATE_CHANNELS = frozenset({"sandbox", "thread_data", "viewed_images", "goal_outcome"})
 
 
 def _normalize_external_goal(value: Any, *, location: str) -> dict[str, Any] | None:
@@ -936,7 +918,6 @@ _SERVER_OWNED_RUNTIME_CONTEXT_KEYS: frozenset[str] = (
             "__run_loop_detection_recorder",
             "__run_tool_promotion_recorder",
             "__run_tool_progress_recorder",
-            "__run_input_control",
             "langgraph_auth_user",
             "langgraph_auth_user_id",
             THREAD_INCARNATION_METADATA_GUARD_KEY,
@@ -2633,11 +2614,6 @@ async def start_run(
                 knowledge_scope=admitted_knowledge_scope,
                 **incarnation_kwargs,
             )
-            if execution_context.agent_runs is not None and run_mgr.input_store is not None:
-                from app.gateway.run_inputs import dispatch_queued_inputs
-                from deerflow.runtime.runs.inputs import RunInputs
-
-                await dispatch_queued_inputs(RunInputs(run_mgr.input_store, record.run_id, record.user_id), agent_runs=execution_context.agent_runs, thread_id=thread_id)
 
         try:
             async with goal_thread_lock(thread_id):

backend/app/mcp_tasks/service.py

@@ -1689,60 +1689,11 @@ class McpTaskService:
             _CANCELLATION_DRAIN_TIMEOUT_SECONDS,
         )
 
-    def _log_pending_compensation_tasks(self, *, reason: str) -> None:
-        pending_count = sum(not task.done() for task in self._compensation_tasks)
-        if pending_count:
-            logger.warning(
-                "%s; %d MCP compensation task(s) remain in the background",
-                reason,
-                pending_count,
-            )
-
-    async def _drain_compensation_tasks(self, *, deadline: float) -> None:
-        """Drain service-owned compensation work before Gateway dependencies close."""
-        loop = asyncio.get_running_loop()
-        while self._compensation_tasks:
-            tasks = tuple(self._compensation_tasks)
-            remaining = deadline - loop.time()
-            if remaining <= 0:
-                break
-            done, _ = await asyncio.wait(
-                tasks,
-                timeout=remaining,
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-            if not done:
-                break
-            # Run completion callbacks before taking the next snapshot. A
-            # handoff may finish one task while registering another.
-            await asyncio.sleep(0)
-
-        self._log_pending_compensation_tasks(
-            reason="MCP compensation drain reached its deadline",
-        )
-
-    async def _drain_compensation_tasks_preserving_cancellation(self, *, deadline: float) -> None:
-        """Finish the bounded drain before propagating caller cancellation."""
-        drain_task = asyncio.create_task(
-            self._drain_compensation_tasks(deadline=deadline),
-            name="deerflow-mcp-compensation-drain",
-        )
-        try:
-            await asyncio.shield(drain_task)
-        except asyncio.CancelledError:
-            await wait_for_task_until(drain_task, deadline=deadline)
-            if drain_task.done():
-                drain_task.result()
-            raise
-
     async def stop(self) -> None:
-        loop = asyncio.get_running_loop()
         task = self._task
         if task is None:
-            await self._drain_compensation_tasks_preserving_cancellation(
-                deadline=loop.time() + _CANCELLATION_DRAIN_TIMEOUT_SECONDS,
-            )
             return
+        loop = asyncio.get_running_loop()
         if self._stopping_task is not task:
             self._stopping_task = task
             self._stop_deadline = loop.time() + _CANCELLATION_DRAIN_TIMEOUT_SECONDS
@@ -1759,19 +1710,9 @@ class McpTaskService:
         except asyncio.CancelledError:
             if not await wait_for_task_until(task, deadline=deadline):
                 self._log_stop_timeout(task)
-                self._log_pending_compensation_tasks(
-                    reason="MCP task poller cleanup reached its deadline before compensation drain could start",
-                )
-            else:
-                await self._drain_compensation_tasks_preserving_cancellation(deadline=deadline)
             raise
         if task not in done:
             self._log_stop_timeout(task)
-            self._log_pending_compensation_tasks(
-                reason="MCP task poller cleanup reached its deadline before compensation drain could start",
-            )
-            return
-        await self._drain_compensation_tasks_preserving_cancellation(deadline=deadline)
 
     async def _run_loop(self) -> None:
         while not self._stop.is_set():

backend/docs/AUTH_TEST_PLAN.md

@@ -1494,7 +1494,7 @@ done
 docker logs deer-flow-gateway 2>&1 | grep -E "ChannelManager|channel" | head -10
 ```
 
-**预期：** 无 auth 相关错误。渠道不依赖浏览器 cookie；服务端通过内部认证头接受请求，run 归入绑定 owner 的用户桶（未绑定时为规范化后的平台用户 ID；仅 `DEER_FLOW_AUTH_DISABLED=1` 时为 `default`）。
+**预期：** 无 auth 相关错误。渠道不依赖浏览器 cookie；服务端通过内部认证头把请求归入 `default` 用户桶。
 
 #### TC-DOCKER-05: reset_admin 密码写入 0600 凭证文件（不再走日志）
 

backend/docs/AUTH_UPGRADE.md

@@ -127,7 +127,7 @@ python -c "import secrets; print(secrets.token_urlsafe(32))"
 - **本地开发**（`make dev`）：Gateway embedded runtime 完全兼容；无 admin 时访问 `/setup` 初始化
 - **Gateway embedded runtime**：标准脚本、Docker dev 和生产部署均通过 Gateway 提供认证与 LangGraph-compatible API
 - **Docker 部署**：完全兼容，`.deer-flow/data/deerflow.db` 需持久化卷挂载
-- **IM 渠道**（Feishu/Slack/Telegram）：通过 Gateway 内部认证通信。已通过 `/connect` 绑定的发送者使用绑定 owner 的用户桶，未绑定的发送者使用规范化后的平台用户 ID；只有设置 `DEER_FLOW_AUTH_DISABLED=1` 的单用户模式才统一使用 `default` 用户桶。详见 [IM_CHANNEL_CONNECTIONS.md](IM_CHANNEL_CONNECTIONS.md)
+- **IM 渠道**（Feishu/Slack/Telegram）：通过 Gateway 内部认证通信，使用 `default` 用户桶
 - **DeerFlowClient**（嵌入式）：不经过 HTTP，不受认证影响
 
 ## 故障排查

backend/docs/CONFIGURATION.md

@@ -813,7 +813,7 @@ Notes:
 scripts/dev_multi_instance.sh up             # containers, config, Gateway A, then B, then nginx
 scripts/dev_multi_instance.sh check          # automated cross-instance checks (below)
 scripts/dev_multi_instance.sh stop b --kill  # SIGKILL B to simulate a crash; `start b` brings it back
-scripts/dev_multi_instance.sh logs a -f      # follow Gateway A; also b, nginx, or all (both Gateways and nginx)
+scripts/dev_multi_instance.sh logs a -f
 scripts/dev_multi_instance.sh down
 ```
 

backend/docs/STREAMING.md

@@ -143,7 +143,7 @@ sequenceDiagram
 关键组件：
 
 - `runtime/runs/worker.py::run_agent` — 在 `asyncio.Task` 里跑 `agent.astream()`，把每个 chunk 通过 `serialize(chunk, mode=mode)` 转成 JSON，再 `bridge.publish()`。
-- `runtime/stream_bridge` — 抽象 Queue。`publish/subscribe` 解耦生产者和消费者，支持 `Last-Event-ID` 重连、心跳、多订阅者 fan-out。`stream_bridge.heartbeat_interval_seconds`（默认 15 秒）是 bridge 实例的默认心跳周期，统一作用于 Gateway SSE、`/wait` 和内部 channel watcher；显式传给 `subscribe()` 的值仍可覆盖单次订阅。Memory 和 Redis 都只保留 `queue_maxsize` 条数据事件。`MemoryStreamBridge` 在分配事件 ID 前深拷贝发布的 payload，并在 stream Condition 外为每个订阅者返回独立深拷贝，因此生产者复用 payload 或订阅者修改数据都不会影响保留帧及重连重放；心跳与 END sentinel 保持对象身份。游标早于保留水位线时返回 `StreamGap`，不会从当前最早事件静默部分重放。Redis backend 会在写入数据或首个 END 时刷新 retained stream key TTL；启动恢复与基于 worker lease 的周期恢复共用 Gateway stream terminalization 路径：`RunManager` 先将 orphan run 持久化为 `error` 并写入显式的 `stop_reason=orphan_recovered`，随后 Gateway 发布 `END_SENTINEL` 并安排 stream cleanup。周期扫描、逐行状态写入和 Gateway callback 作为一个受监督的 single-flight 后台 task 执行；慢任务不会堆积，也不会阻塞唯一的 lease heartbeat。shutdown 优先收敛活跃 run，再处理恢复 task；尚未执行的延迟 stream cleanup 会改为立即删除。只有 runtime `yield` 前、无并发请求的启动恢复会把最新受影响 thread 标记为 error；周期恢复不做非原子的 thread 投影。普通 durable terminal status 本身仍不足以证明尾帧已发布；Redis producer 在 durable admission 前取得短租约，经 request task、worker、finalizer 转移并保留到 END。只有显式 `orphan_recovered` 或 durable terminal 加已失效的 tracked producer lease 才能在 heartbeat 上触发 END fallback；lease loss 会阻止后续 stream 写入，active 或 untracked producer 继续等待，避免截断尾帧。Redis END 通过同一个 Lua 原子完成 lease 校验、既有 END 检查和必要写入，因此重复调用、owner/recovery 竞争和 ACK 丢失重试至多追加一个 END；当 END 已位于 stream 尾部时，后续事件写入会被拒绝；旧 stream 中 END 后已有迟到数据时，仍允许继续写入数据。cleanup 后无 owner 的迟到 END 重试是成功 no-op，不会复活已删除的 stream。普通事件只做 O(1) 尾部 END 检查。`stream_bridge.legacy_end_scan_enabled` 默认 `true`：尾部不是 END 时扫描整个保留窗口，包括正常 run 的首次 END；原子 Lua 的耗时随保留条目数量和 payload 总字节数增长，期间会阻塞其他 Redis 客户端。只有全部旧 writer 停止且旧 replay buffer 已过期或清除后，才可设为 `false` 并重启所有 Gateway，使 END 检查也只看尾部。TTL 为 0 时必须显式清除旧 buffer。TTL 仍是 Redis 内存和故障安全网，不是正常的 subscriber 终止机制。
+- `runtime/stream_bridge` — 抽象 Queue。`publish/subscribe` 解耦生产者和消费者，支持 `Last-Event-ID` 重连、心跳、多订阅者 fan-out。`stream_bridge.heartbeat_interval_seconds`（默认 15 秒）是 bridge 实例的默认心跳周期，统一作用于 Gateway SSE、`/wait` 和内部 channel watcher；显式传给 `subscribe()` 的值仍可覆盖单次订阅。Memory 和 Redis 都只保留 `queue_maxsize` 条数据事件；游标早于保留水位线时返回 `StreamGap`，不会从当前最早事件静默部分重放。Redis backend 会在写入数据或首个 END 时刷新 retained stream key TTL；启动恢复与基于 worker lease 的周期恢复共用 Gateway stream terminalization 路径：`RunManager` 先将 orphan run 持久化为 `error` 并写入显式的 `stop_reason=orphan_recovered`，随后 Gateway 发布 `END_SENTINEL` 并安排 stream cleanup。周期扫描、逐行状态写入和 Gateway callback 作为一个受监督的 single-flight 后台 task 执行；慢任务不会堆积，也不会阻塞唯一的 lease heartbeat。shutdown 优先收敛活跃 run，再处理恢复 task；尚未执行的延迟 stream cleanup 会改为立即删除。只有 runtime `yield` 前、无并发请求的启动恢复会把最新受影响 thread 标记为 error；周期恢复不做非原子的 thread 投影。普通 durable terminal status 本身仍不足以证明尾帧已发布；Redis producer 在 durable admission 前取得短租约，经 request task、worker、finalizer 转移并保留到 END。只有显式 `orphan_recovered` 或 durable terminal 加已失效的 tracked producer lease 才能在 heartbeat 上触发 END fallback；lease loss 会阻止后续 stream 写入，active 或 untracked producer 继续等待，避免截断尾帧。Redis END 通过同一个 Lua 原子完成 lease 校验、既有 END 检查和必要写入，因此重复调用、owner/recovery 竞争和 ACK 丢失重试至多追加一个 END；当 END 已位于 stream 尾部时，后续事件写入会被拒绝；旧 stream 中 END 后已有迟到数据时，仍允许继续写入数据。cleanup 后无 owner 的迟到 END 重试是成功 no-op，不会复活已删除的 stream。普通事件只做 O(1) 尾部 END 检查。`stream_bridge.legacy_end_scan_enabled` 默认 `true`：尾部不是 END 时扫描整个保留窗口，包括正常 run 的首次 END；原子 Lua 的耗时随保留条目数量和 payload 总字节数增长，期间会阻塞其他 Redis 客户端。只有全部旧 writer 停止且旧 replay buffer 已过期或清除后，才可设为 `false` 并重启所有 Gateway，使 END 检查也只看尾部。TTL 为 0 时必须显式清除旧 buffer。TTL 仍是 Redis 内存和故障安全网，不是正常的 subscriber 终止机制。
 - `stream_bridge.producer_lease_recovery_enabled` 是上述 producer-lease fallback 的 restart-required activate gate。升级时先保持 `false` 完成所有 writer 的滚动发布并排空旧 run，再在所有 Gateway 上同时设为 `true` 并重启；mixed-version 阶段不得启用。
 - `app/gateway/services.py::sse_consumer` — 从 bridge 订阅，格式化为 SSE wire 帧。
 - `runtime/serialization.py::serialize` — mode-aware 序列化；`messages` mode 下 `serialize_messages_tuple` 把 `(chunk, metadata)` 转成 `[chunk.model_dump(), metadata]`。

backend/docs/runtime-guidance-details.md

@@ -45,7 +45,7 @@ once the feed's loaded page window no longer reaches back to it.
 store already assigned, keyed by
 `runtime/events/message_identity.py::message_identity` — the backend half of
 the identity rule `frontend/src/core/threads/hooks.ts::messageIdentity` applies
-(tool results by their own message ID; `X` / `X__user` human copies collapse to
+(tool messages by `tool_call_id`; `X` / `X__user` human copies collapse to
 one). The two halves must stay in sync: a mismatch is silent, degrading
 placement rather than raising. `runs/worker.py::_MessageSeqStamper` attaches
 the result as `additional_kwargs.deerflow_seq` on root `values` frames only —
@@ -74,26 +74,6 @@ fetch-and-decode of every message row's tool outputs on long threads.
 client input, because a welded-in seq goes stale when a fork re-seeds the feed
 (#4380).
 
-`RunJournal` assigns missing ToolMessage IDs on the returned message object
-before serializing callback results, including `Command` message updates, so
-the graph checkpoint and feed retain the same ID. Middleware results receive
-the same treatment when reconciled. Provider `tool_call_id` values may repeat
-within a run and across runs; they remain protocol correlation data, never
-thread-global result identities. Legacy results without message IDs have no
-dedupe identity or seq lookup rather than aliasing unrelated invocations.
-For a registered lead-agent call, the journal remembers the captured result ID
-until a new canonical assistant response emits that call ID again. Reconciliation
-restores the remembered ID on a copy serialized before its first capture, so
-the copy does not append another result or consume a sequence. An explicit
-message ID is preserved. A later invocation starts fresh even if its provider
-ID and output content are identical; duplicate callbacks for the same LLM run
-do not reset this bookkeeping. Callbacks without a registered lead call still
-assign distinct IDs to their returned objects. This cache is journal-local and
-is cleared on detach, not a fallback identity for historical rows.
-The web execution timeline and write-file preview resolve a provider call ID
-only inside its originating assistant-message occurrence; UI keys include that
-occurrence while outgoing protocol IDs remain unchanged.
-
 **Run delivery receipts** (`runtime/journal.py` + `runs/worker.py`):
 `RunJournal` records each non-empty artifact update once per tool `Command` for
 the terminal `run.delivery` event. When a command contains multiple messages, a
@@ -353,25 +333,6 @@ Checkpointer storage runs in one of two channel modes, selected by `checkpoint_c
 
 ## Deferred terminal commits and lease ownership
 
-RunManager serializes creation, replacement and assembly publication per thread.
-The global registry lock never spans Store I/O; unrelated cached reads and
-heartbeat snapshots do not queue behind an admission gate. Their own Store I/O
-can still encounter database or connection-pool contention. A pending-ID map
-lets readers of preallocated run IDs join the same-thread gate before the record
-is published. Failed or cancelled admissions remove that temporary membership;
-normal creation registers only after its initial write succeeds. Heartbeats use
-the short registry snapshot, not the thread gate, so an admitted run can renew
-while its replacement awaits a Store result. Preserve terminal-attribution and
-cancellation compensation below; changing lock granularity does not grant a new
-worker authority over a durable row.
-
-Assembly evidence persists a full row snapshot. Serialize that write with the
-same run's lease renewal and local acknowledgment, so it cannot restore an old
-lease after renewal. Lock order is thread gate, then snapshot gate, then the
-short registry lock. Renewal uses only the snapshot gate and must release it
-before signaling local cancellation, which acquires the thread gate. Keep the
-lease-expiry timer armed while waiting for the snapshot gate.
-
 **Deferred terminal commit:** With an event store, the worker stages its terminal
 status locally and commits it only after finalization's receipt and duration
 writes. `RunRecord.terminal_commit_pending` keeps `_renew_leases()` renewing that

backend/packages/extension-api/deerflow_extension_api/agent_runs.py

@@ -76,22 +76,6 @@ class AgentRuns(Protocol):
         """
         ...
 
-    async def send_input(self, *, thread_id: str, run_id: str, text: str, mode: str, request_id: str, context: Mapping[str, Any] | None = None) -> dict[str, Any]:
-        """Queue a new turn or steer the active Run; never change its model."""
-        ...
-
-    async def list_inputs(self, *, thread_id: str) -> dict[str, Any]:
-        """Read host-recorded input IDs/status, including across reconnects."""
-        ...
-
-    async def authorize_control(self, *, thread_id: str, run_id: str, clear_goal: bool = False) -> None:
-        """Recheck cancellation and optional Goal-write authority, without a write."""
-        ...
-
-    async def dispatch_input(self, *, thread_id: str, run_id: str, input_id: str) -> AgentRun:
-        """Dispatch a stored queued input after its Run, using ordinary admission."""
-        ...
-
     async def configuration_evidence(self, *, thread_id: str, run_id: str) -> dict[str, Any]:
         """Read immutable host evidence captured from this run's actual assembly.
 

backend/packages/harness/deerflow/AGENTS.md

@@ -58,9 +58,15 @@ logout and restores the complete old tree on any switch failure.
 Offload config/DDGS together. Only returned empties mean `No images found`;
 the SDK sentinel can hide timeouts. See `tests/test_image_search_errors.py`.
 
-### Browser Automation
+### Browser Progress Screenshots (`community/browser_automation/`)
 
-Screenshot and session rules: [browser guidance](community/browser_automation/AGENTS.md).
+Hidden per-action browser progress frames use JPEG at quality 80 to keep their
+storage and transfer cost bounded relative to lossless PNG. The explicit
+`browser_screenshot` tool remains PNG because it creates a user-requested
+artifact. New automatic capture entry points must reuse the shared progress
+encoding definition in `tools.py` so the byte encoding and `.jpg` suffix cannot
+drift. `browser_screenshot` never replaces an `outputs/` file: it hard-links
+onto the first free `-N` name.
 
 ### Embedded Client (`packages/harness/deerflow/client.py`)
 

backend/packages/harness/deerflow/agents/lead_agent/agent.py

@@ -750,7 +750,7 @@ def build_middlewares(
     if custom_middlewares:
         middlewares.extend(custom_middlewares)
 
-    configured_middlewares = load_configured_extension_middlewares(resolved_app_config, scope="lead")
+    configured_middlewares = load_configured_extension_middlewares(resolved_app_config)
     if configured_middlewares:
         middlewares.extend(configured_middlewares)
 
@@ -777,17 +777,6 @@ def build_middlewares(
     # ClarificationMiddleware should always be last
     middlewares.append(ClarificationMiddleware())
 
-    from deerflow.runtime.runs.input_control import run_input_control
-
-    if run_input_control(cfg) is not None:
-        from deerflow.agents.middlewares.run_input_middleware import RunInputAdmissionMiddleware, RunInputMiddleware
-
-        # New direct input goes through the ordinary sanitization chain.
-        middlewares.insert(0, RunInputAdmissionMiddleware())
-        # after_agent runs in reverse order: decide whether to continue before
-        # sandbox and other terminal cleanup hooks execute.
-        middlewares.append(RunInputMiddleware())
-
     # Extension contributions are merged only here, once the full stack exists.
     # Doing it inside build_lead_runtime_middlewares() would place
     # MODEL_PHYSICAL contributions above the lead-specific middlewares appended

backend/packages/harness/deerflow/agents/memory/AGENTS.md

@@ -383,17 +383,6 @@ Do not add embedded OpenViking imports, root-key access, or trusted identity hea
 Honcho is a remote HTTP adapter for user-model memory.
 It creates one workspace per resolved `user_id`.
 A missing user fails closed to no memory.
-Capture stable-ID messages incrementally using remote `deerflow_source_id`
-metadata, scoped by session and including owner/role/text in the opaque identity.
-Never deduplicate distinct source IDs by text. Consume every filtered lookup page
-before appending a batch; failed/malformed lookups must not become blind replays.
-Cap each lookup at 10 pages, aborting over-budget captures without partial results;
-duplicate stored identities may span pages. Distinguish lookup/write warnings.
-Bound batches to Honcho's 100-message limit. Keep lookup + append under the
-process-local session lock; do not claim cross-process exactly-once delivery.
-ID-less direct callers remain append-only; legacy records lack capture identities.
-Pin cumulative graph turns, restart/compaction, failures and pagination through
-the real HTTP client in `tests/test_honcho_incremental_capture.py`.
 Its async methods offload synchronous HTTP work with `asyncio.to_thread`.
 Honcho's `from_config` consumes the `should_keep_hidden_message` host hook.
 Its write path drops hidden human messages unless that hook accepts them;
@@ -422,10 +411,6 @@ Checkpoint reuse requires the block to exist before the run.
 Gateway input handling removes forged dynamic-context markers.
 
 `prompt.py::_count_tokens` controls the injection budget.
-Oversized summaries use bounded prefix search, counting each assembled candidate
-with its omission marker, separators and protected Facts block. Only counted
-fits replace the facts-only fallback; BPE prefix counts need not be monotone,
-so the search guarantees a fitting candidate rather than the longest prefix.
 Default `tiktoken` mode loads and caches its encoding lazily.
 A failed load uses character estimation for a 600-second cooldown.
 Concurrent callers use character estimation while one load is active.

backend/packages/harness/deerflow/agents/memory/backends/deermem/deermem/core/prompt.py

@@ -734,27 +734,27 @@ def format_memory_for_injection(
         # equation collapses to the original prefix-truncation against
         # ``max_tokens``, so backward compatibility is preserved.
         facts_block = (facts_header + "\n".join(all_fact_lines)) if all_fact_lines else ""
+        facts_block_tokens = _count_tokens(facts_block, use_tiktoken=use_tiktoken)
+        separator_tokens = _count_tokens("\n\n", use_tiktoken=use_tiktoken)
+        budget_for_non_facts = max(
+            0,
+            effective_limit - facts_block_tokens - (separator_tokens if facts_block else 0),
+        )
+
         # Build the preceding (non-facts) portion from *sections* excluding
         # the trailing Facts block.
         preceding_sections = sections[:-1] if all_fact_lines else sections
         preceding = "\n\n".join(preceding_sections)
 
-        result = facts_block
         if preceding:
-            # Average density does not bound a prefix's cost, and BPE counts
+            preceding_tokens = _count_tokens(preceding, use_tiktoken=use_tiktoken)
-            # need not be monotone. Count each assembled candidate and retain
+            if preceding_tokens > budget_for_non_facts:
-            # only fitting prefixes; this need not find the longest one.
+                char_per_token = len(preceding) / max(preceding_tokens, 1)
-            low, high = 0, len(preceding)
+                target_chars = int(budget_for_non_facts * char_per_token * 0.95)
-            while low <= high:
+                preceding = preceding[:target_chars].rstrip() + "\n..."
-                middle = (low + high) // 2
+            result = (preceding + "\n\n" + facts_block) if facts_block else preceding
-                candidate = preceding[:middle].rstrip() + "\n..."
+        else:
-                if facts_block:
+            result = facts_block
-                    candidate += "\n\n" + facts_block
-                if _count_tokens(candidate, use_tiktoken=use_tiktoken) <= effective_limit:
-                    result = candidate
-                    low = middle + 1
-                else:
-                    high = middle - 1
 
     return result
 

backend/packages/harness/deerflow/agents/memory/backends/honcho/README.md

@@ -71,39 +71,6 @@ cannot see each other's memory by construction.
   workspace-scoped search, while the passive per-turn write middleware is
   retained because Honcho's deriver learns from `add()` writes.
 
-## Incremental conversation capture
-
-Checkpoint history is cumulative. For messages with stable source IDs, the
-adapter stores an opaque `deerflow_source_id` in Honcho message metadata and
-checks the session's metadata-filtered `messages/list` endpoint before appending
-new messages. This requires session-read access as well as message-write access.
-Lookups and writes use batches of at most 100 messages. Each lookup requests
-100 records per page and consumes at most 10 pages before publishing that batch.
-All advertised pages must be consumed; a larger page count aborts capture rather
-than using partial results. The budget allows multiple stored records per source
-identity, but exceptionally duplicate-heavy histories may exceed it.
-
-The identity includes the owner, source message ID, role, peer and normalized
-text. Distinct messages with identical text are retained; edited source messages
-are captured as new versions, not replacements of old Honcho records. Stored
-identities survive manager/process restarts and overlapping compacted history.
-An unavailable, malformed or over-budget lookup aborts that capture with a
-`capture lookup failed` warning instead of assuming the history is new.
-This is distinct from `write failed` for setup or message-write errors; a later
-capture can retry normally once the lookup succeeds.
-
-Lookup and append are serialized per endpoint/workspace/session within one
-process, including across manager instances. This is **not exactly-once delivery**:
-independent processes must serialize access to a session upstream. A retry can
-recognize an earlier write whose response was lost once the committed records
-are visible to the lookup, but Honcho does not provide an atomic deduplication
-constraint here.
-
-Direct callers without stable message IDs retain append-on-every-call behavior.
-Records written before this metadata was introduced cannot be matched reliably:
-the first capture after upgrading may replay that older history once. This
-change does not remove historical duplicates or migrate existing records.
-
 ## Limitations
 
 - No DeerMem-style fact CRUD: `create_fact`/`delete_fact`/`update_fact`,
@@ -114,10 +81,8 @@ change does not remove historical duplicates or migrate existing records.
   unsupported-operation error; conversation writes still happen through the
   retained middleware. DeerMem remains the default backend.
 - No migration of existing DeerMem data.
-- Writes run synchronously within each call. Failed captures are logged; no
+- Writes are fire-and-forget per call: a failed write is logged and dropped
-  retry is scheduled or buffered locally, so `shutdown_flush` is a no-op.
+  (at-most-once); nothing is buffered locally, so `shutdown_flush` is a no-op.
-  A later call can retry messages still present in its history, while stored
-  source identities suppress already committed messages.
 - `agent_name` is not mapped — Honcho models the user, not per-agent facts.
 
 ## Async execution and failure behavior

backend/packages/harness/deerflow/agents/memory/backends/honcho/client.py

@@ -1,7 +1,7 @@
 """Minimal synchronous Honcho v3 HTTP client for the memory backend.
 
-Deliberately dependency-light: plain httpx against the v3 REST API. Peers and
+Deliberately dependency-light: plain httpx against the v3 REST API (peers and
-sessions are get-or-create server-side; message creation is append-only.
+sessions are get-or-create server-side, so every call here is idempotent).
 Moving to the official ``honcho-ai`` SDK is a possible follow-up, mirroring the
 OpenViking custom-HTTP -> official-adapter arc.
 """
@@ -14,10 +14,6 @@ import httpx
 
 from .config import HonchoConfig
 
-SOURCE_ID_KEY = "deerflow_source_id"
-MESSAGE_BATCH_SIZE = 100
-MAX_LOOKUP_PAGES = 10
-
 
 class HonchoRequestError(RuntimeError):
     """A Honcho API call failed (transport error or non-2xx response)."""
@@ -61,40 +57,9 @@ class HonchoClient:
     def set_session_peers(self, workspace: str, session_id: str, peer_ids: list[str]) -> None:
         self._post(f"/v3/workspaces/{workspace}/sessions/{session_id}/peers", {peer_id: {} for peer_id in peer_ids})
 
-    def add_messages(self, workspace: str, session_id: str, messages: list[dict[str, Any]]) -> None:
+    def add_messages(self, workspace: str, session_id: str, messages: list[dict[str, str]]) -> None:
         self._post(f"/v3/workspaces/{workspace}/sessions/{session_id}/messages", {"messages": messages})
 
-    def existing_source_ids(self, workspace: str, session_id: str, source_ids: list[str]) -> set[str]:
-        """Consume all lookup pages within a bounded budget, or fail the batch."""
-        if not source_ids:
-            return set()
-        requested = set(source_ids)
-        payload = {"filters": {"OR": [{"metadata": {SOURCE_ID_KEY: key}} for key in source_ids]}}
-        found: set[str] = set()
-        page = 1
-        while True:
-            data = self._post(f"/v3/workspaces/{workspace}/sessions/{session_id}/messages/list?page={page}&size=100", payload)
-            if not isinstance(data, dict) or not isinstance(data.get("items"), list):
-                raise HonchoRequestError("Honcho message lookup returned an invalid page")
-            pages = data.get("pages")
-            if type(pages) is not int or pages < 0 or type(data.get("page")) is not int or data["page"] != page:
-                raise HonchoRequestError("Honcho message lookup returned invalid pagination")
-            if pages < page and not (page == 1 and pages == 0 and not data["items"]):
-                raise HonchoRequestError("Honcho message lookup returned inconsistent pagination")
-            # Duplicate stored identities can span multiple pages even for one
-            # requested key. Bound requests, not the number of matching rows.
-            if pages > MAX_LOOKUP_PAGES:
-                raise HonchoRequestError(f"Honcho message lookup exceeded the {MAX_LOOKUP_PAGES}-page limit")
-            for item in data["items"]:
-                metadata = item.get("metadata") if isinstance(item, dict) else None
-                key = metadata.get(SOURCE_ID_KEY) if isinstance(metadata, dict) else None
-                if not isinstance(key, str) or key not in requested:
-                    raise HonchoRequestError("Honcho message lookup returned an invalid source identity")
-                found.add(key)
-            if page >= pages:
-                return found
-            page += 1
-
     def working_representation(self, workspace: str, peer_id: str, *, max_conclusions: int = 25) -> str:
         data = self._post(f"/v3/workspaces/{workspace}/peers/{peer_id}/representation", {"max_conclusions": max_conclusions})
         if isinstance(data, dict):

backend/packages/harness/deerflow/agents/memory/backends/honcho/honcho_manager.py

@@ -35,10 +35,7 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
-import json
 import logging
-import threading
-import weakref
 from typing import Any, ClassVar, Literal
 
 from pydantic import PrivateAttr
@@ -46,27 +43,12 @@ from pydantic import PrivateAttr
 # ABC contract -- the ONE allowed `from deerflow` import in this backend folder.
 from deerflow.agents.memory.manager import MemoryManager, MemoryManagerError, MemoryReadError
 
-from .client import MESSAGE_BATCH_SIZE, SOURCE_ID_KEY, HonchoClient
+from .client import HonchoClient
 from .config import HonchoConfig, sanitize_id
 
 logger = logging.getLogger(__name__)
 
 _UTC_NOW_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
-_CaptureKey = tuple[str, str, str]
-_capture_locks: weakref.WeakValueDictionary[_CaptureKey, threading.RLock] = weakref.WeakValueDictionary()
-_capture_locks_guard = threading.Lock()
-
-
-def _capture_lock(base_url: str, workspace: str, session_id: str) -> threading.RLock:
-    # Serialize lookup + append across managers in this process without retaining
-    # inactive sessions. Independent processes still need upstream admission.
-    key = (base_url.rstrip("/"), workspace, session_id)
-    with _capture_locks_guard:
-        lock = _capture_locks.get(key)
-        if lock is None:
-            lock = threading.RLock()
-            _capture_locks[key] = lock
-        return lock
 
 
 def _now_iso() -> str:
@@ -110,10 +92,10 @@ class HonchoMemoryManager(MemoryManager):
     """MemoryManager backed by a Honcho v3 instance (self-hosted or hosted).
 
     Known limitation: ``search`` scopes ``category`` server-side to messages
-    stored with ``metadata.category``, but ``add()`` sets only source-identity
+    stored with ``metadata.category``, but ``add()`` writes plain metadata-less
-    metadata and fact CRUD is unsupported, so nothing this backend stores ever
+    messages and fact CRUD is unsupported, so nothing this backend stores ever
     carries a category — category queries return empty results here until the
-    write path gains category support (see ``search``).
+    write path gains metadata support (see ``search``).
     """
 
     _config: HonchoConfig = PrivateAttr(default=None)
@@ -203,8 +185,7 @@ class HonchoMemoryManager(MemoryManager):
             return
         user_peer = self._user_peer(user_id)
         assistant_peer = self._config.assistant_peer
-        outgoing: list[dict[str, Any]] = []
+        outgoing: list[dict[str, str]] = []
-        seen: set[str] = set()
         for message in messages or []:
             msg_type = getattr(message, "type", None)
             if msg_type == "human":
@@ -221,46 +202,22 @@ class HonchoMemoryManager(MemoryManager):
             if not text:
                 continue
             if msg_type == "human":
-                peer_id = user_peer
+                outgoing.append({"peer_id": user_peer, "content": text[: self._config.message_char_limit]})
             elif msg_type in ("ai", "AIMessageChunk"):
-                peer_id = assistant_peer
+                outgoing.append({"peer_id": assistant_peer, "content": text[: self._config.message_char_limit]})
-            else:
-                continue
-            item: dict[str, Any] = {"peer_id": peer_id, "content": text[: self._config.message_char_limit]}
-            message_id = getattr(message, "id", None)
-            if isinstance(message_id, str) and message_id:
-                # Include owner and role even when operators deliberately share
-                # workspace/peer overrides; edits of the same source remain new.
-                source = json.dumps([user_id, message_id, "human" if msg_type == "human" else "ai", peer_id, text], ensure_ascii=True)
-                source_id = hashlib.sha256(source.encode("utf-8")).hexdigest()
-                if source_id in seen:
-                    continue
-                seen.add(source_id)
-                item["metadata"] = {SOURCE_ID_KEY: source_id}
-            outgoing.append(item)
         if not outgoing:
             return
         session_id = f"df-{_stable_id(thread_id)}"
-        operation = "write"
         try:
-            with _capture_lock(self._config.base_url, workspace, session_id):
+            self._client.get_or_create_peer(workspace, user_peer)
-                self._client.get_or_create_peer(workspace, user_peer)
+            self._client.get_or_create_peer(workspace, assistant_peer)
-                self._client.get_or_create_peer(workspace, assistant_peer)
+            self._client.get_or_create_session(workspace, session_id)
-                self._client.get_or_create_session(workspace, session_id)
+            self._client.set_session_peers(workspace, session_id, [user_peer, assistant_peer])
-                self._client.set_session_peers(workspace, session_id, [user_peer, assistant_peer])
+            self._client.add_messages(workspace, session_id, outgoing)
-                for offset in range(0, len(outgoing), MESSAGE_BATCH_SIZE):
-                    batch = outgoing[offset : offset + MESSAGE_BATCH_SIZE]
-                    source_ids = [item["metadata"][SOURCE_ID_KEY] for item in batch if "metadata" in item]
-                    operation = "capture lookup"
-                    existing = self._client.existing_source_ids(workspace, session_id, source_ids) if source_ids else set()
-                    operation = "write"
-                    pending = [item for item in batch if item.get("metadata", {}).get(SOURCE_ID_KEY) not in existing]
-                    if pending:
-                        self._client.add_messages(workspace, session_id, pending)
         except MemoryManagerError:
             raise
         except Exception as exc:
-            logger.warning("honcho memory: %s failed for thread %s: %s", operation, thread_id, exc)
+            logger.warning("honcho memory: write failed for thread %s: %s", thread_id, exc)
 
     # ── Tier 1: read ─────────────────────────────────────────────────────
     def get_context(
@@ -294,10 +251,10 @@ class HonchoMemoryManager(MemoryManager):
 
         Known limitation: that filter only matches messages stored with
         ``metadata.category``, and nothing this backend writes has it — ``add()``
-        sends source-identity metadata but no category, and
+        sends plain ``{"peer_id", "content"}`` messages with no metadata, and
         fact CRUD is unsupported, so no other write path can set it either. A
         ``category`` query therefore returns empty results in this backend
-        until the write path gains category support."""
+        until the write path gains metadata support."""
         workspace = self._workspace(user_id)
         if workspace is None:
             return []

backend/packages/harness/deerflow/agents/middlewares/AGENTS.md

@@ -1,13 +1,5 @@
 ### Middleware Chain
 
-Tool-result JSON analysis is best-effort: parser depth failures must preserve the
-original content and must not abort the graph. Explicit error results fall back
-to `unknown` / recoverable / `try_alternative`, without classifying incidental
-JSON fields as auth failures. Producer metadata remains authoritative. Keep
-depth regressions in `tests/test_tool_result_meta_json_depth.py`, including real
-LocalSandbox reads through both synchronous and asynchronous agent graphs.
-Deep graph cases must establish a real parser depth failure or report a skip.
-
 Async gate waiters own separate cross-loop futures. Cancel only their signal;
 notify outside the state lock. `_await_off_thread` drains started I/O across
 repeated cancellation.
@@ -38,13 +30,6 @@ stay `in_progress`. Never infer status from reply text.
 
 Assembly order: `tool_error_handling_middleware.py::_build_runtime_middlewares` (exposed as `build_lead_runtime_middlewares`), then `../lead_agent/agent.py::build_middlewares`. Optional entries require their config/runtime condition.
 
-Config-declared middleware uses `configured_extensions.py`; the lead and subagent
-builders pass their own required keyword-only `scope` (no implicit lead default).
-Optional `apply_to: both | lead | subagent`
-defaults to both, including legacy strings. Filter before reflection/construction;
-preserve selected entry order and create fresh instances per build. This fixed-slot
-selector does not alter packaged extensions' `AgentScope` or placement contract.
-
 **Message provenance.** Injected/rewritten messages use
 `deerflow_extension_api.provenance.provenance_kwargs()`: server-owned
 `deerflow_content_kind`, `deerflow_producer_kind`, optional entity ID, even
@@ -184,7 +169,7 @@ Before changing a later authorization phase, read the [authorization RFC](../../
 32. **TokenBudgetMiddleware** - `token_budget.enabled`: run-ID budgets survive continuations; missing/invalid IDs reset invocation state. With token usage tracking, place CompletedSubagentUsageMiddleware after the guard: reversed `after_model` hooks backfill terminal child usage before enforcement. Keep TokenUsageMiddleware earlier so current-step attribution reflects calls retained by all guards.
 33. **ModelContentCompatibilityMiddleware** - Read-time sanitizer (`wrap_model_call`/`awrap_model_call`, request view only; never writes state): rewrites URL-sourced `file` blocks (any role, gated on the `url` key; an http(s) URL is preserved when the selected model's serializer accepts it — OpenAI Responses API or Anthropic) and non-fetchable-scheme (non-`http`/`https`/`data`) `image` blocks into text placeholders whose MIME/location metadata passes the shared `neutralize_untrusted_tags` guard, so pre-MCP-fix checkpoints heal on the next turn with no migration. Uses the conversion layer's `resource_placeholder_text`/`model_visible_location` for model-visible text; artifact capture scans state messages, so healing adds neither `resource_links` nor handles. See the MCP guide for conversion and the module docstring for healing; malformed URLs degrade to location-less placeholders instead of raising. Registered after DurableContext/summarization, before the date/coalescer tail.
 34. **Custom middlewares** - *(optional)* Any `custom_middlewares` passed to `build_middlewares` are injected here, before config-declared extensions and the terminal-response/safety/clarification tail
-35. **Configured extension middlewares** - `extensions.middlewares` in `config.yaml` or `extensions_config.json` optionally accepts `module.path:ClassName` strings or `{class, kwargs, apply_to}` objects. `deerflow.reflection.resolve_class` loads `AgentMiddleware` classes; import, class, and constructor errors fail agent creation. `kwargs` must be JSON-compatible; YAML dates/timestamps become ISO strings. Order: built-ins/custom and loop/token guards → extensions → terminal-response/safety/clarification tail. Optional `apply_to` selects both chains (default), lead, or subagent before import/construction. Trusted operator config only: paths instantiate arbitrary code. Gateway skill/MCP toggles preserve it in raw JSON; adding an API write path requires explicit trust-boundary review.
+35. **Configured extension middlewares** - `extensions.middlewares` in `config.yaml` or `extensions_config.json` optionally accepts `module.path:ClassName` strings or `{class, kwargs}` objects. `deerflow.reflection.resolve_class` loads `AgentMiddleware` classes; import, class, and constructor errors fail agent creation. `kwargs` must be JSON-compatible; YAML dates/timestamps become ISO strings. Order: built-ins/custom and loop/token guards → extensions → terminal-response/safety/clarification tail. Subagents share the list before their safety tail; separate lead/subagent lists are unsupported. Trusted operator config only: paths instantiate arbitrary code. Gateway skill/MCP toggles preserve it in raw JSON; adding an API write path requires explicit trust-boundary review.
 36. **TerminalResponseMiddleware** - When a provider returns an empty terminal `AIMessage` after tool execution, injects a hidden recovery prompt and retries the model once; a second empty response is replaced in checkpoint state by a visible error fallback marked for the run worker, so the run finishes as an error instead of a silent success
 37. **ModelLengthFinishReasonMiddleware** - Responses: same-container `status=incomplete` + `incomplete_details.reason=max_output_tokens`. Suppress calls via shared cloning after clearing invalid calls; keep non-call blocks/metadata. Stamp cap markers; add notice. Also registered on subagent chains (before Safety), where `consume_stop_reason` surfaces `model_length_capped` to the executor.
 38. **SafetyFinishReasonMiddleware** - `safety_finish_reason.enabled`: suppresses valid/invalid safety-stopped calls. Responses: `status=incomplete` + `incomplete_details.reason=content_filter`. Clear invalid calls before shared cloning. Place after terminal/custom/configured hooks; `after_model` runs in reverse.

backend/packages/harness/deerflow/agents/middlewares/configured_extensions.py

@@ -1,7 +1,7 @@
 """Config-declared agent middleware loading."""
 
 import logging
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any
 
 from langchain.agents.middleware import AgentMiddleware
 
@@ -14,39 +14,34 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def _middleware_spec(entry: str | ConfiguredMiddlewareSpec | dict[str, Any]) -> ConfiguredMiddlewareSpec:
+def _middleware_constructor_args(entry: str | ConfiguredMiddlewareSpec | dict[str, Any]) -> tuple[str, dict[str, Any]]:
-    """Normalize and validate a config entry before scope selection."""
+    """Return ``(class_path, kwargs)`` for one config entry."""
     if isinstance(entry, str):
-        return ConfiguredMiddlewareSpec(class_path=entry)
+        return entry, {}
     if isinstance(entry, ConfiguredMiddlewareSpec):
-        return entry
+        return entry.class_path, dict(entry.kwargs)
-    return ConfiguredMiddlewareSpec.model_validate(entry)
+    parsed = ConfiguredMiddlewareSpec.model_validate(entry)
+    return parsed.class_path, dict(parsed.kwargs)
 
 
-def load_configured_extension_middlewares(app_config: "AppConfig", *, scope: Literal["lead", "subagent"]) -> list[AgentMiddleware]:
+def load_configured_extension_middlewares(app_config: "AppConfig") -> list[AgentMiddleware]:
     """Instantiate config-declared agent middlewares.
 
     Each entry is a ``module.path:ClassName`` string or a
-    ``ConfiguredMiddlewareSpec`` (``class`` plus optional ``kwargs`` and
+    ``ConfiguredMiddlewareSpec`` (``class`` plus optional ``kwargs``).
-    ``apply_to``). The host must explicitly supply the concrete chain scope.
-    Excluded entries are not imported or constructed.
     Import, attribute, and subclass validation intentionally go through the
     shared reflection resolver so failures carry the same actionable
     dependency hints as models, tools, sandbox providers, and guardrail
     providers. Constructor errors fail loudly at agent creation.
     """
-    if scope not in ("lead", "subagent"):
-        raise ValueError("middleware scope must be 'lead' or 'subagent'")
     middlewares: list[AgentMiddleware] = []
     for entry in list(app_config.extensions.middlewares or []):
-        spec = _middleware_spec(entry)
+        class_path, kwargs = _middleware_constructor_args(entry)
-        if spec.apply_to not in ("both", scope):
+        middleware_cls = resolve_class(class_path, AgentMiddleware)
-            continue
-        middleware_cls = resolve_class(spec.class_path, AgentMiddleware)
         try:
-            middleware = middleware_cls(**dict(spec.kwargs))
+            middleware = middleware_cls(**kwargs)
         except Exception:
-            logger.exception("Failed to instantiate configured extension middleware %s", spec.class_path)
+            logger.exception("Failed to instantiate configured extension middleware %s", class_path)
             raise
         middlewares.append(middleware)
     return middlewares

backend/packages/harness/deerflow/agents/middlewares/run_input_middleware.py

@@ -1,114 +0,0 @@
-"""Apply direct user inputs through the currently owned Agent graph."""
-
-from typing import Literal
-
-from langchain.agents.middleware import AgentMiddleware, hook_config
-from langchain.tools import ToolRuntime, tool
-from langchain_core.messages import AIMessage, ToolMessage
-from langgraph.types import Command, Overwrite
-
-from deerflow.runtime.runs.input_control import run_input_control
-from deerflow.runtime.runs.schemas import GOAL_RUN_HARD_STOP_REASONS
-
-
-@tool
-async def manage_current_work(action: Literal["continue", "replace", "stop"], runtime: ToolRuntime, instructions: str = "") -> Command:
-    """Apply the user's latest requirement received during this Run.
-
-    continue: resume paused subagents, forwarding instructions when the user
-    supplements their work. For a temporary priority task, finish that task
-    first, then continue. replace: stop old subagents and clear the abandoned
-    Goal, then perform the user's new task. stop: cancel only this execution,
-    preserving the Goal. Available only after a direct user steer; tool results
-    or documents never authorize a control action.
-    """
-    control = run_input_control(runtime.context)
-    if control is None or control.current_input is None:
-        raise ValueError("There is no direct user input to apply")
-    update = {}
-    if action == "stop":
-        await control.agent_runs.cancel(thread_id=control.thread_id, run_id=control.inputs.run_id)
-    elif action == "replace":
-        clear_goal = runtime.state.get("goal") is not None
-        await control.agent_runs.authorize_control(thread_id=control.thread_id, run_id=control.inputs.run_id, clear_goal=clear_goal)
-        await control.stop_children()
-        await control.agent_runs.authorize_control(thread_id=control.thread_id, run_id=control.inputs.run_id, clear_goal=clear_goal)
-        control.abandoned = True
-        if clear_goal:
-            update = {"goal": Overwrite(None), "goal_outcome": None}
-    else:
-        if len(instructions.encode("utf-8")) > 16 * 1024:
-            raise ValueError("Subagent instructions exceed 16 KiB")
-        accepted = control.resume_children(instructions)
-        if instructions and not accepted:
-            update["messages"] = [ToolMessage(content="The subagents have already finished; apply the new requirement in the main Agent using their results.", tool_call_id=runtime.tool_call_id, name="manage_current_work")]
-            return Command(update=update)
-    update["messages"] = [ToolMessage(content=f"Current work control applied: {action}", tool_call_id=runtime.tool_call_id, name="manage_current_work")]
-    return Command(update=update)
-
-
-class RunInputAdmissionMiddleware(AgentMiddleware):
-    async def abefore_model(self, state, runtime):
-        control = run_input_control(runtime.context)
-        return await control.deliver(state) if control is not None else None
-
-    @hook_config(can_jump_to=["model"])
-    async def aafter_model(self, state, runtime):
-        control = run_input_control(runtime.context)
-        if control is None or runtime.context.get("stop_reason") in GOAL_RUN_HARD_STOP_REASONS:
-            return None
-        message = state.get("messages", [])[-1] if state.get("messages") else None
-        if isinstance(message, AIMessage) and (message.tool_calls or message.invalid_tool_calls) and await control.pending():
-            # The reply has not entered a later provider request yet. Do not
-            # start obsolete actions after the user changed the requirements.
-            from deerflow_extension_api.provenance import ContentKind, provenance_kwargs
-
-            extra = dict(message.additional_kwargs)
-            extra.pop("tool_calls", None)
-            extra.pop("function_call", None)
-            extra.update(provenance_kwargs(ContentKind.MIDDLEWARE_INJECTION, "run_input"))
-            notice = "任务已更新，刚才计划的操作尚未执行。" if str(runtime.context.get("locale", "")).startswith("zh") else "New input arrived before the planned actions started; those actions were not executed."
-            corrected = message.model_copy(update={"tool_calls": [], "invalid_tool_calls": [], "content": notice, "additional_kwargs": extra})
-            if control.on_replan is not None:
-                control.on_replan(corrected)
-            return {"messages": [corrected], "jump_to": "model"}
-
-
-class RunInputMiddleware(AgentMiddleware):
-    tools = [manage_current_work]
-
-    async def awrap_model_call(self, request, handler):
-        control = run_input_control(request.runtime.context)
-        if control is not None:
-            await control.confirm_checkpoint()
-        if control is None or control.current_input is None:
-            request = request.override(tools=[x for x in request.tools if getattr(x, "name", None) != "manage_current_work"])
-        return await handler(request)
-
-    async def awrap_tool_call(self, request, handler):
-        control = run_input_control(request.runtime.context)
-        if control is not None and request.tool_call["name"] == "task":
-            return await control.wait_tool(request, handler)
-        return await handler(request)
-
-    @hook_config(can_jump_to=["model"])
-    async def aafter_agent(self, state, runtime):
-        control = run_input_control(runtime.context)
-        return await control.finish_graph(state, runtime) if control is not None else None
-
-
-class ChildInputMiddleware(AgentMiddleware):
-    def __init__(self, gate):
-        self.gate = gate
-
-    async def abefore_model(self, state, runtime):
-        return await self.gate.boundary()
-
-
-class ChildInputContinuationMiddleware(AgentMiddleware):
-    def __init__(self, gate):
-        self.gate = gate
-
-    @hook_config(can_jump_to=["model"])
-    async def aafter_agent(self, state, runtime):
-        return await self.gate.finish(runtime.context.get("stop_reason"))

backend/packages/harness/deerflow/agents/middlewares/tool_error_handling_middleware.py

@@ -699,7 +699,7 @@ def build_subagent_runtime_middlewares(
 
     from deerflow.agents.middlewares.configured_extensions import load_configured_extension_middlewares
 
-    middlewares.extend(load_configured_extension_middlewares(app_config, scope="subagent"))
+    middlewares.extend(load_configured_extension_middlewares(app_config))
 
     # Same provider output-length guard the lead agent uses. A subagent answer
     # cut off at the model's output limit would otherwise reach the lead as a

backend/packages/harness/deerflow/agents/middlewares/tool_result_meta.py

@@ -156,7 +156,7 @@ def _extract_json_error_text(content: str) -> str | None:
     """
     try:
         data = json.loads(content)
-    except (json.JSONDecodeError, ValueError, RecursionError):
+    except (json.JSONDecodeError, ValueError):
         return None
     error = data.get("error") if isinstance(data, dict) else None
     if not error:
@@ -305,14 +305,9 @@ def normalize_tool_message(msg: ToolMessage) -> ToolMessage:
             # the tool.  Classify raw text only when the content is not valid JSON.
             try:
                 is_json_dict = isinstance(json.loads(content), dict)
-            except RecursionError:
-                # Depth-limited analysis cannot establish an error category.
-                # Do not infer auth/stop from incidental fields in the raw JSON.
-                attrs = {**_UNKNOWN_ERROR}
             except (json.JSONDecodeError, ValueError):
-                attrs = _classify_error_text(content)
+                is_json_dict = False
-            else:
+            attrs = {**_UNKNOWN_ERROR} if is_json_dict else _classify_error_text(content)
-                attrs = {**_UNKNOWN_ERROR} if is_json_dict else _classify_error_text(content)
         meta = _make_meta(status="error", source="tool_return", **attrs)
     elif content.startswith(_ERROR_PREFIX):
         attrs = _classify_error_text(content[len(_ERROR_PREFIX) :])

backend/packages/harness/deerflow/agents/thread_state.py

@@ -384,7 +384,6 @@ class ThreadState(AgentState):
     todos: Annotated[list | None, merge_todos]
     goal: Annotated[GoalState | None, merge_goal]
     goal_outcome: NotRequired[GoalOutcomeState | None]
-    applied_run_inputs: NotRequired[dict | None]
     uploaded_files: NotRequired[list[dict] | None]
     viewed_images: Annotated[dict[str, ViewedImageData], merge_viewed_images]  # image_path -> metadata (no base64)
     promoted: Annotated[PromotedTools | None, merge_promoted]

backend/packages/harness/deerflow/community/browser_automation/AGENTS.md

@@ -1,27 +0,0 @@
-# Browser Automation
-
-### Browser Egress Resolution
-
-SOCKS DNS runs on the private Playwright loop. Use a dedicated bounded executor
-so timed-out lookups cannot starve that loop's request guard. Retain permits until
-threads exit, including after loop shutdown; reject at capacity and propagate
-ContextVars. Keep the Gateway and browser loops separate in starvation tests.
-See `backend/tests/test_browser_egress.py`.
-
-### Browser Progress Screenshots
-
-Hidden per-action browser progress frames use JPEG at quality 80 to keep their
-storage and transfer cost bounded relative to lossless PNG. The explicit
-`browser_screenshot` tool remains PNG because it creates a user-requested
-artifact. New automatic capture entry points must reuse the shared progress
-encoding definition in `tools.py` so the byte encoding and `.jpg` suffix cannot
-drift. `browser_screenshot` never replaces an `outputs/` file: it hard-links
-onto the first free `-N` name.
-
-### Session Lifecycle
-
-Contexts own cookies and origin storage: retain a live context after page
-closure; rebuild only when the browser disconnects or the context is gone.
-Reset `_request_guard_bound` / `_page_listener_bound` only on context replacement.
-Await `bring_to_front()` before `_set_active_page()` during managed-page
-recovery; CDP sessions preserve user focus and intentionally skip the request guard.

backend/packages/harness/deerflow/community/browser_automation/egress.py

@@ -18,12 +18,9 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-import contextvars
 import ipaddress
 import logging
-import threading
 from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor
 
 logger = logging.getLogger(__name__)
 
@@ -50,49 +47,6 @@ _HANDSHAKE_TIMEOUT_S = 15
 _RESOLVE_TIMEOUT_S = 15
 _CONNECT_TIMEOUT_S = 15
 _CLOSE_TIMEOUT_S = 2
-_EGRESS_RESOLVER_WORKERS = 8
-
-# A timed-out synchronous resolver keeps running in its worker thread. Keep
-# those calls out of the browser loop's default executor, and acquire a
-# permit before submission so the dedicated executor never accumulates an
-# unbounded work queue. Saturated egress fails closed instead of queuing DNS
-# behind work that may itself be stuck.
-_RESOLVER_EXECUTOR = ThreadPoolExecutor(max_workers=_EGRESS_RESOLVER_WORKERS, thread_name_prefix="browser-egress-dns")
-_RESOLVER_SLOTS = threading.BoundedSemaphore(_EGRESS_RESOLVER_WORKERS)
-
-
-class _ResolverCapacityExceeded(RuntimeError):
-    pass
-
-
-def _consume_resolver_result(future: asyncio.Future[object]) -> None:
-    """Consume abandoned results after a timeout or cancelled SOCKS handler."""
-    try:
-        future.exception()
-    except (asyncio.CancelledError, Exception):
-        pass
-
-
-async def _resolve_with_timeout(resolve: EgressResolver, host: str) -> list[str]:
-    slots = _RESOLVER_SLOTS
-    if not slots.acquire(blocking=False):
-        raise _ResolverCapacityExceeded("browser egress resolver capacity is full")
-
-    loop = asyncio.get_running_loop()
-    context = contextvars.copy_context()
-    try:
-        worker = _RESOLVER_EXECUTOR.submit(context.run, resolve, host)
-    except BaseException:
-        slots.release()
-        raise
-    # Release from the concurrent future's callback, which runs with the worker
-    # completion and does not depend on the event loop still being alive.
-    worker.add_done_callback(lambda _completed: slots.release())
-    future = asyncio.wrap_future(worker, loop=loop)
-    future.add_done_callback(_consume_resolver_result)
-    # Shield the executor future: cancellation of the SOCKS handler must not
-    # release its permit before the already-started resolver thread exits.
-    return await asyncio.wait_for(asyncio.shield(future), timeout=_RESOLVE_TIMEOUT_S)
 
 
 class _RefusedRequest(Exception):
@@ -143,15 +97,11 @@ class BrowserEgressProxy:
                 await _reply(writer, exc.reply)
                 return
             try:
-                addresses = await _resolve_with_timeout(self._resolve, host)
+                addresses = await asyncio.wait_for(asyncio.to_thread(self._resolve, host), timeout=_RESOLVE_TIMEOUT_S)
             except ValueError as exc:
                 logger.warning("browser egress refused for %s:%d: %s", host, port, exc)
                 await _reply(writer, _REPLY_NOT_ALLOWED)
                 return
-            except _ResolverCapacityExceeded:
-                logger.warning("browser egress resolution capacity full for %s:%d", host, port)
-                await _reply(writer, _REPLY_HOST_UNREACHABLE)
-                return
             except TimeoutError:
                 logger.warning("browser egress resolution timed out for %s:%d", host, port)
                 await _reply(writer, _REPLY_HOST_UNREACHABLE)

backend/packages/harness/deerflow/community/browser_automation/session.py

@@ -411,25 +411,11 @@ class BrowserSession:
         async with self._ensure_page_lock:
             if self._page is not None and not self._page.is_closed():
                 return self._page
-            # A closed popup/tab does not end the browsing session. Reuse a
-            # surviving tab, or open one in the same context to retain cookies
-            # and storage. Closed contexts disappear from browser.contexts.
-            if self._browser is not None and self._browser.is_connected() and self._context is not None and self._context in self._browser.contexts:
-                pages = [page for page in self._context.pages if not page.is_closed()]
-                page = pages[-1] if pages else await self._context.new_page()
-                if not self._connected_over_cdp:
-                    await page.bring_to_front()
-                self._set_active_page(page)
-                return self._page
-
             from playwright.async_api import async_playwright
 
             if self._playwright is None:
                 self._playwright = await async_playwright().start()
 
-            # These registrations belong to the context being replaced.
-            self._request_guard_bound = False
-            self._page_listener_bound = False
             if self._cdp_url:
                 # Attach to the user's running Chrome (started with
                 # --remote-debugging-port). Reuse its default context + an existing

backend/packages/harness/deerflow/config/AGENTS.md

@@ -191,7 +191,7 @@ Tests: `tests/test_secret_file.py`, `tests/test_credentials_key.py`.
 - `mcpServers` - Map of server name → config (enabled, type, command, args, env, url, headers, oauth, description, `routing`, `tools`, `tool_call_timeout`, `session_init_timeout`). `routing.mode="prefer"` emits `<mcp_routing_hints>` prompt guidance; if `tool_search` defers the hinted tool, `McpRoutingMiddleware` can also auto-promote matching deferred schemas before the model call. It does not hard-disable other tools. `session_init_timeout` (default `DEFAULT_MCP_SESSION_INIT_TIMEOUT` = 60s, `null` to disable) bounds server bring-up: tool discovery and persistent stdio session initialization, so a hung server cannot block agent construction indefinitely; durable HTTP/SSE task calls use it for their ephemeral session initialization too. `tool_call_timeout` bounds individual stdio calls and durable-task calls on every transport; other HTTP/SSE tools use transport-level timeouts.
 - `tool_search.auto_promote_top_k` - Global MCP routing auto-promote breadth. Default `3`, clamped to `1..5`; applies only when `tool_search.enabled=true` and only to deferred MCP tools with `routing.mode="prefer"` and non-empty keywords. For lead agents the deferred catalog is built from the full configured MCP set; auto-promotion never grants authority — it only raises visibility for tools already admitted to the agent's catalog, while assembly and execution authorization still apply independently.
 - `skills` - Map of skill name → state (enabled)
-- `middlewares` - `AgentMiddleware` entries for lead and subagent runtime extension: class-path strings or `{class, kwargs, apply_to}` objects. Optional `apply_to` is `both` (default), `lead`, or `subagent`; strings always apply to both chains. Validate all entries before building agents; excluded entries are not imported or constructed. `kwargs` values must be JSON types; YAML dates and timestamps are coerced to ISO strings so they match JSON. `config.yaml -> extensions` can override these fields after validation; overrides are replace-per-field, not list concatenation.
+- `middlewares` - `AgentMiddleware` entries for lead and subagent runtime extension: class-path strings or `{class, kwargs}` objects. `kwargs` values must be JSON types; YAML dates and timestamps are coerced to ISO strings so they match JSON. `config.yaml -> extensions` can override these fields after validation; overrides are replace-per-field, not list concatenation.
 
 Gateway API endpoints and `DeerFlowClient` methods can modify MCP servers and skill state at runtime; their `extensions_config.json` writes use the shared atomic replacement helper, while `middlewares` remains an operator-controlled config-file extension point.
 

backend/packages/harness/deerflow/config/extensions_config.py

@@ -369,10 +369,6 @@ class ConfiguredMiddlewareSpec(BaseModel):
         default_factory=dict,
         description=("Keyword arguments passed to the middleware constructor. Values must be JSON types (object, array, string, number, boolean, or null); YAML dates and timestamps are coerced to ISO strings so they match JSON."),
     )
-    apply_to: Literal["both", "lead", "subagent"] = Field(
-        default="both",
-        description="Agent chain that loads this middleware. Omitted scope preserves both chains.",
-    )
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     @field_validator("class_path")
@@ -404,7 +400,7 @@ class ExtensionsConfig(BaseModel):
         description=(
             "AgentMiddleware entries loaded into the lead-agent and subagent middleware chains. "
             "Each entry is a 'module.path:ClassName' string or an object with 'class' and optional "
-            "'kwargs' and 'apply_to' (both, lead, or subagent; default both). kwargs values must be JSON types; YAML dates and timestamps are coerced to "
+            "'kwargs'. kwargs values must be JSON types; YAML dates and timestamps are coerced to "
             "ISO strings."
         ),
     )

backend/packages/harness/deerflow/config/subagents_config.py

@@ -106,14 +106,6 @@ class SubagentOverrideConfig(BaseModel):
         min_length=1,
         description="Model name for this subagent (None = inherit from parent agent)",
     )
-    thinking_enabled: bool | None = Field(
-        default=None,
-        description="Whether to enable thinking/reasoning for this subagent (None = no override)",
-    )
-    reasoning_effort: str | None = Field(
-        default=None,
-        description="Reasoning effort accepted or mapped by the selected model (None = use its default)",
-    )
     skills: list[str] | None = Field(
         default=None,
         description="Skill names whitelist for this subagent (None = inherit all enabled skills, [] = no skills)",
@@ -154,14 +146,6 @@ class CustomSubagentConfig(BaseModel):
         default="inherit",
         description="Model to use - 'inherit' uses parent's model",
     )
-    thinking_enabled: bool | None = Field(
-        default=None,
-        description="Whether to enable thinking/reasoning for this subagent (None = no override)",
-    )
-    reasoning_effort: str | None = Field(
-        default=None,
-        description="Reasoning effort accepted or mapped by the selected model (None = use its default)",
-    )
     max_turns: int = Field(
         default=50,
         ge=1,
@@ -282,20 +266,6 @@ class SubagentsAppConfig(BaseModel):
             return override.skills
         return None
 
-    def get_thinking_enabled_for(self, agent_name: str) -> bool | None:
-        """Return an explicit per-agent thinking override, including False."""
-        override = self.agents.get(agent_name)
-        if override is not None and override.thinking_enabled is not None:
-            return override.thinking_enabled
-        return None
-
-    def get_reasoning_effort_for(self, agent_name: str) -> str | None:
-        """Return the per-agent effort request; the selected model resolves it."""
-        override = self.agents.get(agent_name)
-        if override is not None and override.reasoning_effort is not None:
-            return override.reasoning_effort
-        return None
-
     def get_token_budget_for(
         self,
         agent_name: str,
@@ -361,10 +331,6 @@ def load_subagents_config_from_dict(config_dict: dict) -> None:
             parts.append(f"max_turns={override.max_turns}")
         if override.model is not None:
             parts.append(f"model={override.model}")
-        if override.thinking_enabled is not None:
-            parts.append(f"thinking_enabled={override.thinking_enabled}")
-        if override.reasoning_effort is not None:
-            parts.append(f"reasoning_effort={override.reasoning_effort}")
         if override.skills is not None:
             parts.append(f"skills={override.skills}")
         if parts:

backend/packages/harness/deerflow/mcp/AGENTS.md

@@ -11,7 +11,7 @@ The optional background-task `status` filter flows through `McpTaskSubmitter.lis
 
 - Uses `langchain-mcp-adapters` `MultiServerMCPClient` for multi-server management
 - **OAuth expiry**: Missing, non-convertible or overflowing `expires_in` values use the one-hour default. Guard both `timedelta` construction and addition to one captured UTC `now`; avoid float-derived range ceilings. `tests/test_mcp_oauth.py` pins both overflow stages and the exact `datetime` boundary with a fixed clock.
-- **Long-running task foundation**: `mcp/tasks/` defines the protocol-neutral `McpTaskDriver` and `TaskSnapshot` states (`submitted`, `working`, `input_required`, `completed`, `failed`, `cancelled`); validate finite positive `poll_after_seconds` at that shared boundary. `persistence/mcp_tasks/` owns remote handles, schedules, notification state, leases and separate consecutive poll/delivery error counters. `app/mcp_tasks/McpTaskService` runs outside the Agent/LLM loop. Every claim gets a fresh token; releases and snapshot writes match owner/token, and results require an unexpired lease even before a peer reclaims. Each claim phase has a single-flight owner while its database outcome is ambiguous: later scans skip with a warning. Once it resolves, release that phase owner immediately and hand returned rows to bounded, service-owned release work. Token fencing protects newer generations; a stuck release must not block later claims. Expiry is the cross-process crash fallback, not normal recovery for a live service's late claim. Poll timestamps and retry schedules use remote completion time. Submission persistence failure/cancellation best-effort cancels the remote handle while preserving the original error, except `uq_mcp_tasks_user_server_remote`: an existing row owns that handle and must not be cancelled. Isolate per-task failures; unexpected poll failures recover by expiry. Shutdown cancels the poller with bounded handoff, then drains service-owned compensation work within the same deadline; timed-out work remains tracked in the background. Cancellation release clears only owner/token and preserves diagnostics, preclaim schedules and poll-failure state; cancellation is not a task failure. Real failures retain backoff and tracking degradation. `input_required` and terminal events become pending notifications; delivery budgets, idempotency and strict target rejection are detailed below. Durable recovery needs SQLite/PostgreSQL; memory leaves the service unavailable. The startup-configured `mcp_tasks` runtime is disabled by default until a concrete driver is registered and does not change ordinary tool behavior.
+- **Long-running task foundation**: `mcp/tasks/` defines the protocol-neutral `McpTaskDriver` and `TaskSnapshot` states (`submitted`, `working`, `input_required`, `completed`, `failed`, `cancelled`); validate finite positive `poll_after_seconds` at that shared boundary. `persistence/mcp_tasks/` owns remote handles, schedules, notification state, leases and separate consecutive poll/delivery error counters. `app/mcp_tasks/McpTaskService` runs outside the Agent/LLM loop. Every claim gets a fresh token; releases and snapshot writes match owner/token, and results require an unexpired lease even before a peer reclaims. Each claim phase has a single-flight owner while its database outcome is ambiguous: later scans skip with a warning. Once it resolves, release that phase owner immediately and hand returned rows to bounded, service-owned release work. Token fencing protects newer generations; a stuck release must not block later claims. Expiry is the cross-process crash fallback, not normal recovery for a live service's late claim. Poll timestamps and retry schedules use remote completion time. Submission persistence failure/cancellation best-effort cancels the remote handle while preserving the original error, except `uq_mcp_tasks_user_server_remote`: an existing row owns that handle and must not be cancelled. Isolate per-task failures; unexpected poll failures recover by expiry. Shutdown cancels the poller with bounded handoff. Cancellation release clears only owner/token and preserves diagnostics, preclaim schedules and poll-failure state; cancellation is not a task failure. Real failures retain backoff and tracking degradation. `input_required` and terminal events become pending notifications; delivery budgets, idempotency and strict target rejection are detailed below. Durable recovery needs SQLite/PostgreSQL; memory leaves the service unavailable. The startup-configured `mcp_tasks` runtime is disabled by default until a concrete driver is registered and does not change ordinary tool behavior.
 - **Control-call ownership**: Poll claims recheck eligibility with a conditional UPDATE after SELECT; cancel claims reserve SQLite writers with `BEGIN IMMEDIATE` before SELECT. PostgreSQL retains `SKIP LOCKED`. `renew_control_claim` atomically matches phase, owner, token, nonterminal state and unexpired lease, preserves `updated_at`, and never shortens expiry on a backward clock correction. `McpTaskService._with_control_lease` validates admission, renews every lease/3 with a lease/3 renewal deadline, and supervises the entire operation through persistence. Ownership loss or uncertain renewal cancels the local operation; the task-local loss fence rejects late snapshot/retry writes if the driver swallows cancellation. Bounded handoff retains operation/renewal cleanup through caller cancellation or autonomous completion/loss. Local active IDs remain excluded from poll/cancel claims and consume control capacity until cleanup settles. Notification claims use their existing independent lifecycle. Contract/tests: [control leases](../../../../docs/mcp-control-leases.md), `tests/test_mcp_task_lease_lifecycle.py`.
 - **Runtime availability boundary**: the installed process-local submitter is the source of truth for durable task-management tool exposure. `mcp_tasks` is startup-only; changing it on disk does not alter the live toolset until the Gateway restarts.
 - **Task OAuth lifetime**: `tasks/runtime.py` owns shared OAuth state only for enabled deployment servers with `task_toolsets`, from `set_mcp_task_config_snapshot(config)` until its `None` teardown. Use `_task_enabled_servers` for both snapshot and OAuth selection. Validate the frozen snapshot before reusing that state for discovery, ordinary tools, or durable calls. Cache resets must not discard it. Keep tokens and the cross-loop refresh lock together; rotate a private config copy, never the parsed snapshot or config file. Non-task servers remain reloadable and personal callers use independent managers, even on a name collision.

backend/packages/harness/deerflow/persistence/AGENTS.md

@@ -12,14 +12,6 @@ Alembic stamp/upgrade workers started inside `bootstrap_schema()` remain owned b
 
 On SQLite, `BEGIN IMMEDIATE` takes the database-wide write lock, so every unrelated writer (run status, thread metadata, the scheduler) waits for the transaction and fails with `database is locked` after `busy_timeout` (30s). Do slow work such as document conversion before opening a locked transaction; lock only to revalidate and publish, as `ProjectDocumentRepository.publish_under_live_lock` does. `tests/test_project_document_tools.py::TestConversionSerialization` pins this.
 
-## Batch lease recovery
-
-Batch lease recovery includes paused parents only when they have expired active
-items. Reconcile through the existing owner/expiry fence, then skip promotion and
-claiming while paused. Preserve explicit retry/resume and terminal projection;
-`tests/test_paused_batch_lease_recovery.py` covers HTTP, restart and export, and
-`test_batch_lease_lifecycle.py` covers a concurrent renewal.
-
 ## Unique-key upserts
 
 A repository method that creates or updates a row by a unique key must survive two first writers: both can miss the SELECT, and the later INSERT raises `IntegrityError`, a 500 for the caller. Use a dialect `on_conflict_do_update` when every key column is non-null, or retry the select-then-write after rolling back the session, as `ChannelConnectionRepository.upsert_connection` / `set_thread_id` and `FeedbackRepository.upsert` do. Feedback keeps the retry because `user_id` is nullable and a NULL key never conflicts, so ON CONFLICT would stop updating the NULL-user row.

backend/packages/harness/deerflow/persistence/managed_subagents/base.py

@@ -32,8 +32,6 @@ class ManagedSubagentDefinition(BaseModel):
     disallowed_tools: list[str] = Field(default_factory=lambda: sorted(REQUIRED_DISALLOWED_TOOLS))
     skills: list[str] | None = None
     model: str = "inherit"
-    thinking_enabled: bool | None = None
-    reasoning_effort: str | None = None
     max_turns: int = Field(default=50, ge=1)
     timeout_seconds: int = Field(default=900, ge=1)
     enabled: bool = True

backend/packages/harness/deerflow/persistence/migrations/versions/0049_run_inputs.py

@@ -1,23 +0,0 @@
-"""Bounded interactive input state on the existing run row.
-
-Revision ID: 0049_run_inputs
-Revises: 0048_extension_execution_leases
-"""
-
-import sqlalchemy as sa
-from alembic import op
-
-revision = "0049_run_inputs"
-down_revision = "0048_extension_execution_leases"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    if "run_inputs_json" not in {x["name"] for x in sa.inspect(op.get_bind()).get_columns("runs")}:
-        op.add_column("runs", sa.Column("run_inputs_json", sa.JSON(), nullable=True))
-
-
-def downgrade():
-    if "run_inputs_json" in {x["name"] for x in sa.inspect(op.get_bind()).get_columns("runs")}:
-        op.drop_column("runs", "run_inputs_json")

backend/packages/harness/deerflow/persistence/run/model.py

@@ -28,9 +28,6 @@ class RunRow(Base):
     multitask_strategy: Mapped[str] = mapped_column(String(20), default="reject")
     metadata_json: Mapped[dict] = mapped_column(JSON, default=dict)
     kwargs_json: Mapped[dict] = mapped_column(JSON, default=dict)
-    # Independent of ordinary Run snapshots so late progress writes cannot
-    # overwrite inputs accepted by another Gateway.
-    run_inputs_json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
     error: Mapped[str | None] = mapped_column(Text)
     stop_reason: Mapped[str | None] = mapped_column(String(50))
     # Final evaluator outcome, written atomically with terminal run status.

backend/packages/harness/deerflow/persistence/run/sql.py

@@ -7,7 +7,6 @@ minutes -- we don't hold connections across long execution.
 
 from __future__ import annotations
 
-import copy
 import json
 from datetime import UTC, datetime, timedelta
 from typing import Any
@@ -46,43 +45,6 @@ def _origin_kind(operation_kind: str, metadata: Any) -> str | None:
 
 
 class RunRepository(RunStore):
-    supports_run_inputs = True
-
-    async def mutate_run_inputs(self, run_id, change, *, user_id=None, owner_worker_id=None):
-        from deerflow.runtime.runs.inputs import InputConflict, empty_input_state
-
-        async with self._sf() as session:
-            # Preserve the existing global-clock -> row lock order (SQLite's
-            # first write serializes peer connections as well).
-            await self._next_change_seq(session)
-            row = (await session.execute(select(RunRow).where(RunRow.run_id == run_id).with_for_update())).scalar_one_or_none()
-            if row is None or (user_id is not None and row.user_id != user_id):
-                raise InputConflict("Run not found")
-            if owner_worker_id is not None:
-                lease = row.lease_expires_at
-                if row.owner_worker_id != owner_worker_id or (lease is not None and lease.replace(tzinfo=UTC) <= datetime.now(UTC)):
-                    raise InputConflict("Run ownership changed")
-            state = copy.deepcopy(row.run_inputs_json or empty_input_state())
-            change(state, self._row_to_dict(row))
-            row.run_inputs_json = state
-            await session.commit()
-            return copy.deepcopy(state)
-
-    async def list_input_runs(self, thread_id, *, user_id=None, limit=10):
-        async with self._sf() as session:
-            query = select(RunRow).where(RunRow.thread_id == thread_id, RunRow.run_inputs_json["items"][0]["id"].as_string().is_not(None))
-            if user_id is not None:
-                query = query.where(RunRow.user_id == user_id)
-            rows = await session.execute(query.order_by(RunRow.created_at.desc(), RunRow.run_id.desc()).limit(limit))
-            return [self._row_to_dict(row) for row in rows.scalars()]
-
-    async def active_input_run(self, thread_id, *, user_id=None):
-        async with self._sf() as session:
-            query = select(RunRow.run_id).where(RunRow.thread_id == thread_id, RunRow.status.in_(("pending", "running")), RunRow.cancel_action.is_(None), RunRow.run_inputs_json["closed"].as_boolean().is_(False))
-            if user_id is not None:
-                query = query.where(RunRow.user_id == user_id)
-            return (await session.execute(query.order_by(RunRow.created_at.desc(), RunRow.run_id.desc()).limit(1))).scalar_one_or_none()
-
     def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
         self._sf = session_factory
 
@@ -159,7 +121,6 @@ class RunRepository(RunStore):
         # Remap JSON columns to match RunStore interface
         d["metadata"] = d.pop("metadata_json", {})
         d["kwargs"] = d.pop("kwargs_json", {})
-        d["run_inputs"] = d.pop("run_inputs_json", None)
         d["idempotency_request"] = d.pop("idempotency_request_json", None)
         # Convert datetime to ISO string for consistency with MemoryRunStore.
         # SQLite drops tzinfo on read despite ``DateTime(timezone=True)`` —

backend/packages/harness/deerflow/persistence/subagent_batches/sql.py

@@ -5,7 +5,7 @@ from collections import Counter
 from datetime import UTC, datetime, timedelta
 from typing import Any
 
-from sqlalchemy import func, or_, select, update
+from sqlalchemy import func, select, update
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import defer
@@ -250,27 +250,12 @@ class SubagentBatchRepository:
         limit: int,
         exclude_item_ids: tuple[str, ...] = (),
     ) -> list[dict[str, Any]]:
-        """Recover expired attempts, then promote and claim only runnable work."""
+        """Promote pending work and atomically claim runnable items."""
         if limit <= 0:
             return []
         claimed: list[dict[str, Any]] = []
         async with self._sf() as session:
-            expired_items = select(SubagentBatchItemRow.id).where(
+            batches = list((await session.execute(select(SubagentBatchRow).where(SubagentBatchRow.status.in_(("queued", "running"))).order_by(SubagentBatchRow.created_at, SubagentBatchRow.id).with_for_update(skip_locked=True))).scalars())
-                SubagentBatchItemRow.batch_id == SubagentBatchRow.id,
-                SubagentBatchItemRow.status.in_(("leased", "running")),
-                SubagentBatchItemRow.lease_expires_at < now,
-                SubagentBatchItemRow.id.not_in(exclude_item_ids),
-            )
-            batches = list(
-                (
-                    await session.execute(
-                        select(SubagentBatchRow)
-                        .where(or_(SubagentBatchRow.status.in_(("queued", "running")), (SubagentBatchRow.status == "paused") & expired_items.exists()))
-                        .order_by(SubagentBatchRow.created_at, SubagentBatchRow.id)
-                        .with_for_update(skip_locked=True)
-                    )
-                ).scalars()
-            )
             for batch in batches:
                 if len(claimed) >= limit:
                     break
@@ -320,11 +305,6 @@ class SubagentBatchRepository:
                 if terminalized_expired:
                     await self._refresh_batch_status(session, batch, now=now)
 
-                # Pausing blocks new work, not recovery of an abandoned attempt.
-                # Retryable items remain queued until an explicit resume.
-                if batch.status == "paused":
-                    continue
-
                 counts = await self._counts(session, batch.id)
                 live = counts["queued"] + counts["leased"] + counts["running"]
                 promote_count = max(0, batch.max_live_items - live)

backend/packages/harness/deerflow/runtime/AGENTS.md

@@ -13,22 +13,6 @@ errors preserve cache fallbacks and valid neighbors, including Redis outages/pur
 Escape literal stems for SCAN; recheck byte/string keys before UNLINK. Preserve
 namespace/thread bounds, cursor iteration and outage/TTL fallback.
 
-### Run Admission
-
-Interactive Queue/Steer inputs belong to the existing RunStore row. Accept only
-owner-bound text; acknowledge it after a durable graph receipt. Queue dispatch
-uses ordinary AgentRuns admission after the old worker finalizes. Steer releases
-a native `task()` wait without marking the child completed; the same executor
-owns cooperative pause, timeout and cancellation. Only direct-user input exposes
-current-work control. Preserve permissions, pool caps and token/loop stops.
-On restart retain unapplied text for explicit retry; never replay side effects
-automatically. Regressions: `test_run_inputs.py`, `test_run_input_graph.py`.
-
-Run admission and assembly publication serialize per thread across Store I/O.
-Keep registry locks short; heartbeat snapshots must not queue on an
-admission gate. Preserve same-thread publication visibility, including reads of
-preallocated run IDs. Details: [admission isolation](../../../../docs/runtime-guidance-details.md#deferred-terminal-commits-and-lease-ownership).
-
 ### Stream Bridge Heartbeats
 
 Observed Redis streams removed during replay yield `StreamGap` with empty bounds; initially empty streams still wait. After this gap, `/wait` refreshes store-only status and completes only for a terminal run with no retained stream.
@@ -63,12 +47,6 @@ successful no-op; a live owner's write retains its existing missing-buffer
 
 ### Memory Stream Replay
 
-Memory publication snapshots the payload before allocating an event ID. Each
-subscriber receives its own deep copy outside the stream Condition, so producer
-reuse and reader edits cannot rewrite retained frames. Heartbeat/END sentinels
-keep identity. `tests/test_memory_stream_payload_isolation.py` covers nested
-payloads and Worker-to-Gateway SSE/reconnect metadata, including subgraphs.
-
 Memory keeps the exact last evicted event ID as bounded per-run metadata. A
 reconnect from that known predecessor replays all retained successors and END,
 matching a live subscriber at the same position. Older or unverifiable evicted
@@ -92,7 +70,7 @@ without querying the repository or replacing the control input.
 Before changing checkpoint modes, caches, replay lookup, state replacement or
 rollback, read the [checkpoint contracts](../../../../docs/runtime-guidance-details.md#checkpoint-channel-modes-and-replay).
 
-**Message sequence placement:** Keep backend and frontend message identity rules aligned. Tool results use their own message IDs, assigned on missing-ID callback results before persistence; provider call IDs may repeat. Restore pre-capture ID-less copies from the current lead-call result ID; reset it on a new canonical call, not a usage replay. Keep ID-less legacy rows independent. Details: `backend/docs/runtime-guidance-details.md`.
+**Message sequence placement:** Keep backend and frontend message identity rules aligned. Details: `backend/docs/runtime-guidance-details.md`.
 
 **Thread message cursors:** `list_messages` applies both exclusive bounds before `limit`, paging forward whenever `after_seq` is supplied.
 

backend/packages/harness/deerflow/runtime/events/message_identity.py

@@ -8,8 +8,8 @@ stay in sync: a mismatch is silent, degrading placement rather than raising.
 
 Two normalizations matter:
 
-* a ``ToolMessage`` is identified by its own message id, assigned by the journal
+* a ``ToolMessage`` is identified by its ``tool_call_id``, not its own id —
-  before persistence; provider ``tool_call_id`` values can repeat across turns;
+  that is the id both sides can always resolve;
 * ``DynamicContextMiddleware`` re-keys the submitted user turn from ``X`` to
   ``X__user`` (giving ``X`` to the injected reminder), so the two human copies
   must collapse to one identity.
@@ -35,6 +35,10 @@ def message_identity(message: Mapping[str, Any]) -> str | None:
     *message* is a serialized message mapping (as stored in ``run_events``
     content or carried in a checkpoint ``values`` frame), not a ``BaseMessage``.
     """
+    tool_call_id = message.get("tool_call_id")
+    if isinstance(tool_call_id, str) and tool_call_id:
+        return f"tool:{tool_call_id}"
+
     message_id = message.get("id")
     if not isinstance(message_id, str) or not message_id:
         return None

backend/packages/harness/deerflow/runtime/journal.py

@@ -28,7 +28,7 @@ from dataclasses import dataclass
 from datetime import UTC, datetime
 from functools import partial
 from typing import Any, cast
-from uuid import UUID, uuid4
+from uuid import UUID
 
 from langchain_core.callbacks import BaseCallbackHandler
 from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage, ToolMessage, messages_from_dict
@@ -406,8 +406,6 @@ class RunJournal(BaseCallbackHandler):
         self._last_ai_msg: str | None = None
         self._first_human_msg: str | None = None
         self._first_human_message_captured = False
-        self._captured_run_inputs: set[str] = set()
-        self._terminal_task_results: set[str] = set()
         self._msg_count = 0
         self._had_llm_error_fallback = False
         self._llm_error_fallback_message: str | None = None
@@ -422,7 +420,6 @@ class RunJournal(BaseCallbackHandler):
         self._llm_call_index = 0
         self._seen_llm_starts: set[str] = set()  # langchain run_ids that fired on_chat_model_start
         self._current_run_tool_call_names: dict[str, str] = {}
-        self._current_tool_result_ids: dict[str, str] = {}
         self._active_tool_names: dict[str, str] = {}
         self._persisted_ai_message_identities: set[str] = set()
         self._persisted_tool_message_identities: set[str] = set()
@@ -555,7 +552,7 @@ class RunJournal(BaseCallbackHandler):
         if caller == "lead_agent" and not self._first_human_message_captured and messages:
             for batch in reversed(messages):
                 for m in reversed(batch):
-                    if _should_persist_human_input_message(m) and not m.additional_kwargs.get("run_input_id"):
+                    if _should_persist_human_input_message(m):
                         persisted_message = restore_original_human_message(m)
                         self.set_first_human_message(self._message_text(persisted_message))
                         self._put(
@@ -569,16 +566,6 @@ class RunJournal(BaseCallbackHandler):
                 if self._first_human_message_captured:
                     break
 
-        if caller == "lead_agent":
-            for batch in messages:
-                for m in batch:
-                    input_id = m.additional_kwargs.get("run_input_id")
-                    if input_id and input_id not in self._captured_run_inputs and isinstance(m, HumanMessage):
-                        persisted = restore_original_human_message(m)
-                        self._put(event_type=LLM_HUMAN_INPUT_EVENT.event_type, category=LLM_HUMAN_INPUT_EVENT.category, content=persisted.model_dump(), metadata={"caller": caller})
-                        self._record_message_summary(persisted, caller=caller)
-                        self._captured_run_inputs.add(input_id)
-
     def on_llm_start(self, serialized: dict, prompts: list[str], *, run_id: UUID, parent_run_id: UUID | None = None, tags: list[str] | None = None, metadata: dict[str, Any] | None = None, **kwargs: Any) -> None:
         # Fallback: on_chat_model_start is preferred. This just tracks latency.
         self._llm_start_times[str(run_id)] = time.monotonic()
@@ -855,6 +842,9 @@ class RunJournal(BaseCallbackHandler):
 
     @staticmethod
     def _message_identity(message: BaseMessage) -> str | None:
+        tool_call_id = getattr(message, "tool_call_id", None)
+        if isinstance(tool_call_id, str) and tool_call_id:
+            return f"tool:{tool_call_id}"
         message_id = getattr(message, "id", None)
         if isinstance(message_id, str) and message_id:
             return f"message:{message_id}"
@@ -893,22 +883,8 @@ class RunJournal(BaseCallbackHandler):
                 continue
             name = self._tool_call_value(tool_call, "name")
             self._current_run_tool_call_names[tool_call_id] = str(name or "")
-            # A newly emitted assistant call starts a distinct occurrence,
-            # even when the provider reuses an earlier call ID in this run.
-            self._current_tool_result_ids.pop(tool_call_id, None)
-            self._terminal_task_results.discard(tool_call_id)
 
     def _persist_tool_result_message(self, message: BaseMessage) -> None:
-        # Tool callbacks run before the graph reducer assigns missing ids.
-        # Assign on the returned object so the feed and checkpoint share the
-        # same result identity even when a provider reuses its tool_call_id.
-        if isinstance(message, ToolMessage) and not message.id:
-            message.id = str(uuid4())
-        if isinstance(message, ToolMessage) and message.name == "task":
-            from deerflow.subagents.status_contract import read_subagent_result_metadata
-
-            if read_subagent_result_metadata(message.additional_kwargs) is not None:
-                self._terminal_task_results.add(message.tool_call_id)
         self._put(
             event_type=LLM_TOOL_RESULT_EVENT.event_type,
             category=LLM_TOOL_RESULT_EVENT.category,
@@ -917,25 +893,8 @@ class RunJournal(BaseCallbackHandler):
         identity = self._message_identity(message)
         if identity:
             self._persisted_tool_message_identities.add(identity)
-        if isinstance(message, ToolMessage) and message.tool_call_id in self._current_run_tool_call_names and message.id:
-            self._current_tool_result_ids[message.tool_call_id] = message.id
         self._record_message_summary(message)
 
-    def record_deferred_task_result(self, message: ToolMessage) -> None:
-        """Persist the outcome of an owned deferred task, once, for history.
-
-        A real on_tool_end result wins over a cancellation/failure fallback.
-        This never rewrites the model's earlier pending ToolMessage.
-        """
-        if not self._closed and self._current_run_tool_call_names.get(message.tool_call_id) == "task" and message.tool_call_id not in self._terminal_task_results:
-            self._persist_tool_result_message(message)
-
-    def record_steered_response(self, message: AIMessage) -> None:
-        """Append the pre-execution correction without rewriting a feed row."""
-        if not self._closed:
-            self._put(event_type=LLM_AI_RESPONSE_EVENT.event_type, category=LLM_AI_RESPONSE_EVENT.category, content=message.model_dump(), metadata={"caller": "lead_agent", "adjusted_by_input": True})
-            self._record_message_summary(message, caller="lead_agent")
-
     def record_interrupted_ai_responses(self, messages: Iterable[AIMessage]) -> int:
         """Persist visible streamed text that never reached ``on_llm_end``.
 
@@ -1000,12 +959,8 @@ class RunJournal(BaseCallbackHandler):
         # re-attributed here.
         if self._current_run_tool_call_names.get(tool_call_id) is None:
             return False
-        if not message.id:
-            # A copy serialized before the first capture still lacks its ID.
-            # Restore that occurrence's ID before checking for a replay.
-            message.id = self._current_tool_result_ids.get(tool_call_id)
         identity = self._message_identity(message)
-        return identity is None or identity not in self._persisted_tool_message_identities
+        return identity is not None and identity not in self._persisted_tool_message_identities
 
     def _reconcile_tool_messages(self, messages: Iterable[Any]) -> None:
         for message in messages:
@@ -1868,7 +1823,6 @@ class RunJournal(BaseCallbackHandler):
         self._llm_start_times.clear()
         self._seen_llm_starts.clear()
         self._current_run_tool_call_names.clear()
-        self._current_tool_result_ids.clear()
         self._persisted_ai_message_identities.clear()
         self._persisted_tool_message_identities.clear()
         self._produced_artifacts.clear()

backend/packages/harness/deerflow/runtime/runs/input_control.py

@@ -1,282 +0,0 @@
-"""Run-owned input delivery and native task supervision; no model polling."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import threading
-from uuid import uuid4
-
-from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
-
-from .inputs import RunInputs
-from .schemas import GOAL_RUN_HARD_STOP_REASONS
-
-
-class ChildInputGate:
-    def __init__(self, *, can_queue=True):
-        self.result_id = str(uuid4())
-        self.can_queue = can_queue
-        self.closed = False
-        self.resume = threading.Event()
-        self.resume.set()
-        self.paused = threading.Event()
-        self._lock = threading.Lock()
-        self._instructions: list[str] = []
-
-    async def boundary(self):
-        if not self.resume.is_set():
-            self.paused.set()
-            while not self.resume.is_set():
-                await asyncio.sleep(0.05)
-            self.paused.clear()
-        with self._lock:
-            text = "\n".join(self._instructions)
-            self._instructions.clear()
-        if text:
-            return {"messages": [HumanMessage(content=text, additional_kwargs={"hide_from_ui": True, "untrusted_input": True})]}
-        return None
-
-    def release(self, instructions=""):
-        with self._lock:
-            accepted = not self.closed
-            if instructions and accepted:
-                self._instructions.append(instructions)
-        self.resume.set()
-        return accepted
-
-    def close(self):
-        with self._lock:
-            self.closed = True
-        self.resume.set()
-
-    async def finish(self, stop_reason=None):
-        if stop_reason in GOAL_RUN_HARD_STOP_REASONS:
-            self.close()
-            return None
-        while True:
-            update = await self.boundary()
-            if update is not None:
-                return {**update, "jump_to": "model"}
-            with self._lock:
-                if not self._instructions and self.resume.is_set():
-                    self.closed = True
-                    return None
-
-
-class RunInputControl:
-    def __init__(self, inputs: RunInputs, *, agent_runs, thread_id: str, checkpointer, on_result=None, on_replan=None):
-        self.inputs, self.agent_runs, self.thread_id, self.checkpointer = inputs, agent_runs, thread_id, checkpointer
-        self.delivered: set[str] = set()
-        self.acknowledged: set[str] = set()
-        self.calls: dict[str, dict] = {}
-        self.delegations: list[dict] = []
-        self.current_input: str | None = None
-        self.steering_active = False
-        self.tasks: set[asyncio.Task] = set()
-        self.observed_tasks: set[asyncio.Task] = set()
-        self.children: dict[str, tuple[ChildInputGate, str | None]] = {}
-        self.interrupted_children: set[str] = set()
-        self.receipts: list[HumanMessage] = []
-        self.pending_calls: set[str] = set()
-        self.finished_calls: set[str] = set()
-        self.on_result = on_result
-        self.on_replan = on_replan
-        self.abandoned = False
-
-    def child(self, call_id):
-        if call_id in self.children and not self.children[call_id][0].closed:
-            return self.children[call_id][0]
-        gate = ChildInputGate(can_queue=not any(not old.resume.is_set() and not old.closed for old, _ in self.children.values()))
-        self.children[call_id] = (gate, None)
-        return gate
-
-    def bind_execution(self, call_id, execution_id):
-        gate, _ = self.children[call_id]
-        self.children[call_id] = (gate, execution_id)
-
-    async def pending(self):
-        state = await self.inputs.read()
-        return [x for x in state["items"] if x["mode"] == "steer" and x["status"] in ("pending", "applying") and x["id"] not in self.delivered]
-
-    async def deliver(self, state):
-        entries = await self.pending()
-        if entries:
-            entries = await self.inputs.claim_steer([x["id"] for x in entries])
-        messages = self.receipts[:]
-        self.receipts.clear()
-        if entries:
-            self.abandoned = False
-            self.steering_active = True
-            self.interrupted_children = set(self.children)
-        for entry in entries:
-            self.delivered.add(entry["id"])
-            direct = entry.get("source", "user") == "user"
-            if direct:
-                self.current_input = entry["id"]
-            messages.append(
-                HumanMessage(
-                    content=entry["text"],
-                    id=entry["message_id"],
-                    name=None if direct else "extension-input",
-                    additional_kwargs={"run_input_id": entry["id"], "run_input_source": entry.get("source", "user"), "run_id": self.inputs.run_id, **({"hide_from_ui": True, "untrusted_input": True} if not direct else {})},
-                )
-            )
-        if not messages:
-            return None
-        update = {"messages": messages, "applied_run_inputs": {"run_id": self.inputs.run_id, "ids": sorted(self.delivered)}}
-        if self.delegations:
-            update["delegations"] = self.delegations[:]
-            self.delegations.clear()
-        return update
-
-    async def confirm_checkpoint(self):
-        # Confirm the graph's own durable write, including when summaries have
-        # removed the original HumanMessage. Acceptance is never an ack.
-        if self.checkpointer is None or self.delivered <= self.acknowledged:
-            return
-        value = await self.checkpointer.aget_tuple({"configurable": {"thread_id": self.thread_id, "checkpoint_ns": ""}})
-        progress = value.checkpoint.get("channel_values", {}).get("applied_run_inputs", {}) if value else {}
-        if progress.get("run_id") == self.inputs.run_id:
-            ids = progress.get("ids", [])
-            await self.inputs.acknowledge(ids)
-            self.acknowledged.update(ids)
-
-    async def wait_tool(self, request, handler):
-        self.calls[request.tool_call["id"]] = dict(request.tool_call)
-        self.finished_calls.discard(request.tool_call["id"])
-        # Create the gate before scheduling: an immediately available input
-        # can arrive before the tool handler reaches the native executor.
-        gate = self.child(request.tool_call["id"])
-        native = asyncio.create_task(handler(request))
-        native.add_done_callback(lambda _: gate.close())
-        self.tasks.add(native)
-        try:
-            while not native.done():
-                if await self.pending():
-                    for gate, _ in self.children.values():
-                        gate.resume.clear()
-                    call_id = request.tool_call["id"]
-                    self.pending_calls.add(call_id)
-                    self.observed_tasks.add(native)
-                    watcher = asyncio.create_task(self._observe(native, call_id))
-                    self.tasks.add(watcher)
-                    return ToolMessage(
-                        id=gate.result_id,
-                        content="The subagent result is pending and will arrive in this Run. The user has sent an updated requirement.",
-                        tool_call_id=call_id,
-                        name="task",
-                        additional_kwargs={"subagent_pending": True, "run_id": self.inputs.run_id},
-                    )
-                await asyncio.wait([native], timeout=0.5)
-            return await native
-        except BaseException:
-            native.cancel()
-            await asyncio.gather(native, return_exceptions=True)
-            raise
-
-    async def _observe(self, native, call_id):
-        try:
-            result = await native
-            message = result.update["messages"][0] if hasattr(result, "update") else result
-        except asyncio.CancelledError:
-            raise
-        except Exception:
-            message = self._failure(call_id, "failed", "The subagent result could not be collected")
-        from deerflow.agents.middlewares.delegation_ledger import extract_delegations
-
-        self.finished_calls.add(call_id)
-        self.delegations.extend({**entry, "run_id": self.inputs.run_id} for entry in extract_delegations([AIMessage(content="", tool_calls=[self.calls[call_id]]), message]))
-        self.receipts.append(
-            HumanMessage(
-                content=json.dumps({"source": "subagent", "task_call_id": call_id, "result": message.content}, ensure_ascii=False),
-                name="subagent-result",
-                id="run-input-result-" + self.inputs.run_id + "-" + call_id,
-                additional_kwargs={"hide_from_ui": True, "untrusted_input": True, "origin_task_id": call_id, "run_id": self.inputs.run_id},
-            )
-        )
-
-    def _failure(self, call_id, status, text):
-        from deerflow.subagents.status_contract import make_subagent_additional_kwargs
-
-        child = self.children.get(call_id)
-        message = ToolMessage(id=child[0].result_id if child else None, content=text, tool_call_id=call_id, name="task", additional_kwargs=make_subagent_additional_kwargs(status, error=text))
-        if self.on_result is not None:
-            self.on_result(message)
-        return message
-
-    def resume_children(self, instructions=""):
-        accepted = []
-        for call_id, (gate, _) in self.children.items():
-            if call_id in self.interrupted_children:
-                if gate.release(instructions):
-                    accepted.append(call_id)
-        return accepted
-
-    async def stop_children(self, *, all_children=False):
-        from deerflow.subagents.executor import get_background_task_result, request_cancel_background_task
-
-        results = []
-        for call_id, (gate, execution_id) in list(self.children.items()):
-            if not all_children and call_id not in self.interrupted_children:
-                continue
-            if execution_id:
-                result = get_background_task_result(execution_id)
-                request_cancel_background_task(execution_id)
-                if result is not None:
-                    results.append(result)
-            gate.release()
-        for result in results:
-            while not result.execution_done_event.is_set():
-                await asyncio.sleep(0.05)
-
-    async def finish_graph(self, state, runtime):
-        await self.confirm_checkpoint()
-        if runtime.context.get("stop_reason") in GOAL_RUN_HARD_STOP_REASONS:
-            await self.stop_children(all_children=True)
-            return None
-        if self.steering_active:
-            self.steering_active = False
-            self.current_input = None
-            if not self.abandoned:
-                self.resume_children()
-        while True:
-            if await self.pending() or self.receipts:
-                return {"jump_to": "model"}
-            active = [x for x in self.tasks if not x.done()]
-            if not active:
-                # Input admission and this close serialize in the same store
-                # transaction. A concurrent accepted steer must get a turn.
-                if await self.inputs.close(self.delivered):
-                    return None
-                continue
-            done, _ = await asyncio.wait(active, timeout=0.5, return_when=asyncio.FIRST_COMPLETED)
-            for task in done:
-                if task not in self.observed_tasks and not task.cancelled() and task.exception() is not None:
-                    raise task.exception()
-
-    async def close(self):
-        from deerflow.subagents.executor import request_cancel_background_task
-
-        for gate, execution_id in self.children.values():
-            if execution_id:
-                request_cancel_background_task(execution_id)
-            gate.release()
-        for task in self.tasks:
-            if not task.done():
-                task.cancel()
-        await asyncio.gather(*self.tasks, return_exceptions=True)
-        for call_id in self.pending_calls - self.finished_calls:
-            self._failure(call_id, "cancelled", "The parent Run stopped before this subagent result was collected")
-        self.on_result = None
-        self.on_replan = None
-        self.tasks.clear()
-        self.observed_tasks.clear()
-        self.children.clear()
-
-
-def run_input_control(context) -> RunInputControl | None:
-    from .inputs import INPUT_CONTEXT_KEY
-
-    value = context.get(INPUT_CONTEXT_KEY) if isinstance(context, dict) else None
-    return value if isinstance(value, RunInputControl) else None

backend/packages/harness/deerflow/runtime/runs/inputs.py

@@ -1,148 +0,0 @@
-"""Bounded, durable inputs belonging to one admitted Run.
-
-The run store serializes mutations with status/cancellation. Only the owning
-worker may acknowledge graph input; HTTP acceptance never writes a checkpoint.
-"""
-
-from __future__ import annotations
-
-import copy
-from dataclasses import dataclass
-from typing import Any, Literal
-from uuid import NAMESPACE_URL, uuid5
-
-from deerflow.utils.time import now_iso
-
-MAX_INPUTS = 16
-MAX_INPUT_BYTES = 16 * 1024
-MAX_TOTAL_BYTES = 64 * 1024
-INPUT_CONTEXT_KEY = "__run_input_control"
-
-
-class InputConflict(ValueError):
-    """The target Run cannot accept or apply this input."""
-
-
-def empty_input_state() -> dict[str, Any]:
-    return {"closed": False, "items": []}
-
-
-@dataclass
-class RunInputs:
-    store: Any
-    run_id: str
-    user_id: str | None
-    worker_id: str | None = None
-
-    async def read(self) -> dict[str, Any]:
-        row = await self.store.get(self.run_id, user_id=self.user_id)
-        if row is None:
-            raise InputConflict("Run not found")
-        return copy.deepcopy(row.get("run_inputs") or empty_input_state())
-
-    async def _change(self, change, *, owned=False):
-        if owned and self.worker_id is None:
-            raise InputConflict("Run input application requires its owning worker")
-        return await self.store.mutate_run_inputs(self.run_id, change, user_id=self.user_id, owner_worker_id=self.worker_id if owned else None)
-
-    async def submit(self, request_id: str, text: str, mode: Literal["queue", "steer"], *, context: dict | None = None, source: Literal["user", "extension"] = "user") -> dict:
-        if not isinstance(text, str) or not text.strip() or len(text.encode("utf-8")) > MAX_INPUT_BYTES:
-            raise InputConflict("Input must contain text of at most 16 KiB")
-        if mode not in ("queue", "steer") or not isinstance(request_id, str) or not 1 <= len(request_id) <= 96:
-            raise InputConflict("Invalid input mode or request ID")
-        context = copy.deepcopy(context or {}) if mode == "queue" else {}
-
-        def change(state, row):
-            old = next((x for x in state["items"] if x["id"] == request_id), None)
-            if old is not None:
-                if (old["text"], old["mode"], old.get("context", {}), old.get("source", "user")) != (text, mode, context, source):
-                    raise InputConflict("Request ID already belongs to different input")
-                return
-            if state["closed"] or row.get("status") not in ("pending", "running") or row.get("operation_kind", "run") != "run" or row.get("cancel_action"):
-                raise InputConflict("Run is finishing or stopped; this input was not accepted")
-            if len(state["items"]) >= MAX_INPUTS or sum(len(x["text"].encode("utf-8")) for x in state["items"]) + len(text.encode("utf-8")) > MAX_TOTAL_BYTES:
-                raise InputConflict("Too many inputs for this Run; wait for it to finish")
-            state["items"].append(
-                {"id": request_id, "text": text, "mode": mode, "context": context, "source": source, "status": "pending", "message_id": str(uuid5(NAMESPACE_URL, f"deerflow-input:{self.run_id}:{request_id}")), "created_at": now_iso()}
-            )
-
-        state = await self._change(change)
-        return next(x for x in state["items"] if x["id"] == request_id)
-
-    async def acknowledge(self, ids: list[str]) -> None:
-        def change(state, row):
-            for item in state["items"]:
-                if item["id"] in ids and item["mode"] == "steer" and item["status"] == "applying":
-                    item["status"] = "applied"
-
-        await self._change(change, owned=True)
-
-    async def claim_steer(self, ids: list[str]) -> list[dict]:
-        def change(state, row):
-            if row.get("status") not in ("pending", "running") or row.get("cancel_action"):
-                raise InputConflict("Run stopped before applying input")
-            for item in state["items"]:
-                if item["id"] in ids and item["mode"] == "steer" and item["status"] == "pending":
-                    item["status"] = "applying"
-
-        state = await self._change(change, owned=True)
-        return [x for x in state["items"] if x["id"] in ids and x["mode"] == "steer" and x["status"] == "applying"]
-
-    async def close(self, delivered: set[str] | None = None) -> bool:
-        def change(state, row):
-            if not any(x["mode"] == "steer" and x["status"] in ("pending", "applying") and x["id"] not in (delivered or set()) for x in state["items"]):
-                state["closed"] = True
-
-        return (await self._change(change, owned=True))["closed"]
-
-    async def reopen(self) -> None:
-        def change(state, row):
-            if row.get("status") in ("pending", "running") and not row.get("cancel_action"):
-                state["closed"] = False
-
-        await self._change(change, owned=True)
-
-    async def pause(self) -> None:
-        def change(state, row):
-            state["closed"] = True
-            for item in state["items"]:
-                if item["status"] in ("pending", "applying"):
-                    item["status"] = "not_applied"
-
-        await self._change(change)
-
-    async def dispatched(self, input_id: str, run_id: str) -> None:
-        def change(state, row):
-            item = next(x for x in state["items"] if x["id"] == input_id)
-            if item.get("run_id") not in (None, run_id):
-                raise InputConflict("Queued input already belongs to another Run")
-            item.update(status="applied", run_id=run_id)
-
-        await self._change(change)
-
-    async def claim(self, input_id: str, *, retry=False) -> dict:
-        def change(state, row):
-            if row.get("status") in ("pending", "running"):
-                raise InputConflict("The current Run has not finished")
-            item = next((x for x in state["items"] if x["id"] == input_id), None)
-            if item is None or item["status"] == "cancelled":
-                raise InputConflict("Input not found or removed")
-            if item["status"] == "applied":
-                if not item.get("run_id"):
-                    raise InputConflict("This input was already applied")
-                return
-            if not retry and (row.get("status") != "success" or row.get("stop_reason") or item["mode"] != "queue" or item["status"] == "not_applied"):
-                raise InputConflict("Queued input requires an explicit retry")
-            item["status"] = "dispatching"
-
-        state = await self._change(change)
-        return next(x for x in state["items"] if x["id"] == input_id)
-
-    async def cancel(self, input_id: str) -> None:
-        def change(state, row):
-            item = next((x for x in state["items"] if x["id"] == input_id), None)
-            if item is None or item["status"] not in ("pending", "not_applied", "cancelled"):
-                raise InputConflict("This input is already being applied")
-            item["status"] = "cancelled"
-
-        await self._change(change)

backend/packages/harness/deerflow/runtime/runs/manager.py

@@ -10,7 +10,7 @@ import socket
 import sqlite3
 import uuid
 from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import UTC, datetime, timedelta
 from enum import StrEnum
@@ -19,7 +19,6 @@ from typing import TYPE_CHECKING, Any
 from sqlalchemy.exc import IntegrityError as SAIntegrityError
 
 from deerflow.runtime.events.terminal import RecoveryTerminalPublisher
-from deerflow.runtime.keyed_lock import AsyncKeyedLockTable
 from deerflow.runtime.user_context import AUTO, _AutoSentinel, get_current_user, resolve_user_id
 from deerflow.utils.time import is_lease_expired
 from deerflow.utils.time import now_iso as _now_iso
@@ -354,9 +353,6 @@ class RunManager:
         # preserving ``_runs`` iteration order (see ``_thread_records_locked``).
         self._runs_by_thread: dict[str, dict[str, None]] = {}
         self._lock = asyncio.Lock()
-        self._admission_locks = AsyncKeyedLockTable[str]()
-        self._snapshot_locks = AsyncKeyedLockTable[str]()
-        self._pending_admissions: dict[str, dict[str, int]] = {}
         self._store = store
         self._persistence_retry_policy = persistence_retry_policy or PersistenceRetryPolicy()
         self._worker_id = worker_id or _generate_worker_id()
@@ -374,43 +370,6 @@ class RunManager:
         self._lease_operations: dict[str, asyncio.Task] = {}
         self._lease_deadlines: dict[str, asyncio.TimerHandle] = {}
 
-    @asynccontextmanager
-    async def _admission_scope(self, thread_id: str, run_id: str) -> AsyncIterator[None]:
-        # Manager state is owned by one event loop. Register before the first
-        # await so readers of a preallocated ID also wait for its publication.
-        threads = self._pending_admissions.setdefault(run_id, {})
-        threads[thread_id] = threads.get(thread_id, 0) + 1
-        try:
-            async with self._admission_locks.hold(thread_id):
-                yield
-        finally:
-            threads[thread_id] -= 1
-            if not threads[thread_id]:
-                del threads[thread_id]
-            if not threads:
-                self._pending_admissions.pop(run_id, None)
-
-    @asynccontextmanager
-    async def _run_scope(self, run_id: str) -> AsyncIterator[None]:
-        threads = set(self._pending_admissions.get(run_id, ()))
-        record = self._runs.get(run_id)
-        if record is not None:
-            threads.add(record.thread_id)
-        async with AsyncExitStack() as stack:
-            for thread_id in sorted(threads):
-                await stack.enter_async_context(self._admission_locks.hold(thread_id))
-            yield
-
-    @asynccontextmanager
-    async def _run_registry_lock(self, run_id: str) -> AsyncIterator[None]:
-        async with self._run_scope(run_id), self._lock:
-            yield
-
-    @asynccontextmanager
-    async def _thread_registry_lock(self, thread_id: str) -> AsyncIterator[None]:
-        async with self._admission_locks.hold(thread_id), self._lock:
-            yield
-
     def _index_run_locked(self, record: RunRecord) -> None:
         """Register *record* in the thread index. Caller must hold ``self._lock``."""
         self._runs_by_thread.setdefault(record.thread_id, {})[record.run_id] = None
@@ -541,8 +500,8 @@ class RunManager:
         Initial run creation is part of the run visibility boundary: callers
         should not observe a run in memory unless its backing store row exists.
         Unlike follow-up status/model updates, failures are propagated so the
-        caller can treat creation as failed. The caller keeps the record private
+        caller can treat creation as failed. Rollback is the caller's
-        until this method returns successfully.
+        responsibility after inserting the record into ``_runs``.
         """
         if self._store is None:
             return
@@ -834,7 +793,7 @@ class RunManager:
         """Persist token usage and completion data to the backing store."""
         row_recovery_payload: dict[str, Any] | None = None
         record: RunRecord | None = None
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is not None and record.ownership_lost:
                 logger.warning("Skipped completion persistence for run %s after lease ownership was lost", run_id)
@@ -930,7 +889,7 @@ class RunManager:
     async def update_run_progress(self, run_id: str, **kwargs) -> None:
         """Persist a running token/message snapshot without changing status."""
         should_persist = True
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is not None:
                 should_persist = record.status == RunStatus.running and not record.ownership_lost
@@ -948,7 +907,7 @@ class RunManager:
     async def update_finalizing_progress(self, run_id: str, **kwargs) -> None:
         """Persist final fields while the durable row is deliberately active."""
         should_persist = False
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is not None and not record.ownership_lost:
                 should_persist = record.status not in (RunStatus.pending, RunStatus.running)
@@ -972,7 +931,7 @@ class RunManager:
 
     async def seal_completed_evidence(self, run_id: str, receipt) -> bool:
         """Best-effort evidence metadata is independent of business completion."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None or record.ownership_lost:
                 return False
@@ -983,7 +942,7 @@ class RunManager:
         return await seal(run_id, owner_worker_id=owner_worker_id, receipt=receipt)
 
     async def mark_evidence_partial(self, run_id: str, *, error: str) -> bool:
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None or record.ownership_lost:
                 return False
@@ -1039,15 +998,21 @@ class RunManager:
             evidence_origin=evidence_origin,
             evidence_agent_id=evidence_agent_id,
         )
-        async with self._admission_scope(thread_id, run_id):
+        async with self._lock:
+            self._runs[run_id] = record
+            self._index_run_locked(record)
+            persisted = False
             try:
                 await self._persist_new_run_to_store(record)
+                persisted = True
             except Exception:
-                logger.warning("Failed to persist run %s; record was not registered", run_id, exc_info=True)
+                logger.warning("Failed to persist run %s; rolled back in-memory record", run_id, exc_info=True)
                 raise
-            async with self._lock:
+            finally:
-                self._runs[run_id] = record
+                # Also covers cancellation, which bypasses ``except Exception``.
-                self._index_run_locked(record)
+                if not persisted:
+                    self._runs.pop(run_id, None)
+                    self._unindex_run_locked(run_id, record.thread_id)
         logger.info("Run created: run_id=%s thread_id=%s", run_id, thread_id)
         return record
 
@@ -1066,7 +1031,7 @@ class RunManager:
             raise_on_store_error: Propagate store hydration/mapping failures so
                 lifecycle callers can distinguish them from a missing run.
         """
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
         if record is not None:
             return record
@@ -1081,7 +1046,7 @@ class RunManager:
             return None
         # Re-check after store await: a concurrent create() may have inserted the
         # in-memory record while the store call was in flight.
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
         if record is not None:
             return record
@@ -1150,7 +1115,7 @@ class RunManager:
         def _page(records: list[RunRecord]) -> list[RunRecord]:
             return sorted(records, key=lambda record: run_sort_key(record.created_at, record.run_id), reverse=True)[:limit]
 
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             memory_records = [
                 record
                 for record in self._thread_records_locked(thread_id)
@@ -1204,7 +1169,7 @@ class RunManager:
         correct pagination.
         """
         resolved_user_id = resolve_user_id(user_id, method_name="RunManager.list_successful_regenerate_sources")
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             memory_records = [record for record in self._thread_records_locked(thread_id) if record.operation_kind == ThreadOperationKind.run and (resolved_user_id is None or record.user_id == resolved_user_id)]
 
         sources = set(await self._store.list_successful_regenerate_sources(thread_id, user_id=resolved_user_id)) if self._store is not None else set()
@@ -1275,7 +1240,7 @@ class RunManager:
                     continue
                 records_by_id[record.run_id] = record
 
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             memory_records = [record for record in self._thread_records_locked(thread_id) if resolved_user_id is None or record.user_id == resolved_user_id]
         for record in memory_records:
             records_by_id[record.run_id] = record
@@ -1284,13 +1249,13 @@ class RunManager:
 
     async def try_start(self, run_id: str) -> RunStartOutcome:
         """Transition an uncancelled pending run to running before building the agent."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
         if record is None:
             raise RunStartupError(f"Cannot start unknown run {run_id}")
 
         async with record.start_lock:
-            async with self._run_registry_lock(run_id):
+            async with self._lock:
                 if record.abort_event.is_set() or record.status != RunStatus.pending:
                     return RunStartOutcome.cancelled
 
@@ -1304,7 +1269,7 @@ class RunManager:
                 except Exception as exc:
                     raise RunStartupError(f"Failed to start run {run_id}: {exc}") from exc
                 if updated is False:
-                    async with self._run_registry_lock(run_id):
+                    async with self._lock:
                         if record.status == RunStatus.pending:
                             record.status = RunStatus.interrupted
                             record.terminal_status_persisted = False
@@ -1312,7 +1277,7 @@ class RunManager:
                             record.updated_at = _now_iso()
                     return RunStartOutcome.cancelled
 
-            async with self._run_registry_lock(run_id):
+            async with self._lock:
                 if record.abort_event.is_set() or record.status != RunStatus.pending:
                     restore_status = record.status
                     restore_error = record.error
@@ -1334,7 +1299,7 @@ class RunManager:
 
     async def fail_start_if_pending(self, run_id: str, *, error: str) -> bool:
         """Mark an admitted run as failed if its worker task could not be attached."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None or record.status != RunStatus.pending:
                 return False
@@ -1349,7 +1314,7 @@ class RunManager:
             RunStatus.error,
             error=error,
         )
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             if self._runs.get(run_id) is record:
                 record.terminal_status_persisted = persisted
         return True
@@ -1365,7 +1330,7 @@ class RunManager:
         if not run_ids:
             return {}
         resolved_user_id = resolve_user_id(user_id, method_name="RunManager.get_many_by_thread")
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             records_by_id = {
                 record.run_id: record for record in self._thread_records_locked(thread_id) if record.operation_kind == ThreadOperationKind.run and record.run_id in run_ids and (resolved_user_id is None or record.user_id == resolved_user_id)
             }
@@ -1400,7 +1365,7 @@ class RunManager:
         persist: bool = True,
     ) -> None:
         """Transition a run to a new status."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None:
                 logger.warning("set_status called for unknown run %s", run_id)
@@ -1436,7 +1401,7 @@ class RunManager:
         if persist:
             persisted = await self._persist_status(record, status, error=error, stop_reason=stop_reason)
             if status not in (RunStatus.pending, RunStatus.running):
-                async with self._run_registry_lock(run_id):
+                async with self._lock:
                     record.terminal_status_persisted = self._has_final_terminal_ack(record) if self.heartbeat_enabled and self._store is not None else persisted
             if not persisted and self.heartbeat_enabled and status == RunStatus.success and not record.ownership_lost:
                 await self._mark_ownership_lost(
@@ -1450,7 +1415,7 @@ class RunManager:
 
     async def persist_current_status(self, run_id: str) -> bool:
         """Persist the status already staged on the in-memory run record."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None:
                 logger.warning("persist_current_status called for unknown run %s", run_id)
@@ -1460,7 +1425,7 @@ class RunManager:
             stop_reason = record.stop_reason
         persisted = await self._persist_status(record, status, error=error, stop_reason=stop_reason)
         if status not in (RunStatus.pending, RunStatus.running):
-            async with self._run_registry_lock(run_id):
+            async with self._lock:
                 record.terminal_status_persisted = self._has_final_terminal_ack(record) if self.heartbeat_enabled and self._store is not None else persisted
         if not persisted and self.heartbeat_enabled and status == RunStatus.success and not record.ownership_lost:
             await self._mark_ownership_lost(
@@ -1492,7 +1457,7 @@ class RunManager:
             )
             return None
 
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None or record.store_only or record.ownership_lost:
                 return None
@@ -1542,7 +1507,7 @@ class RunManager:
 
     async def set_finalizing(self, run_id: str, finalizing: bool) -> None:
         """Mark whether a run is performing post-cancel cleanup."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None:
                 logger.warning("set_finalizing called for unknown run %s", run_id)
@@ -1560,7 +1525,7 @@ class RunManager:
     ) -> None:
         """Wait until older same-thread runs have finished post-cancel cleanup."""
         while True:
-            async with self._thread_registry_lock(thread_id):
+            async with self._lock:
                 found_current = False
                 prior_finalizing = False
                 for record in self._thread_records_locked(thread_id):
@@ -1584,7 +1549,7 @@ class RunManager:
 
     async def has_later_run(self, thread_id: str, run_id: str) -> bool:
         """Return whether a newer in-memory run has been admitted for the thread."""
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             seen_current = False
             for record in self._thread_records_locked(thread_id):
                 if record.run_id == run_id:
@@ -1596,7 +1561,7 @@ class RunManager:
 
     async def has_later_started_run(self, thread_id: str, run_id: str) -> bool:
         """Return whether a newer same-thread run may have already advanced state."""
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             seen_current = False
             for record in self._thread_records_locked(thread_id):
                 if record.run_id == run_id:
@@ -1623,23 +1588,22 @@ class RunManager:
         """Publish only host assembly evidence, once, before execution."""
         from deerflow.runtime.assembly_evidence import EVIDENCE_KEY
 
-        async with self._run_scope(run_id), self._snapshot_locks.hold(run_id):
+        async with self._lock:
-            async with self._lock:
+            record = self._runs.get(run_id)
-                record = self._runs.get(run_id)
+            if record is None or evidence.get("run_id") != run_id or evidence.get("thread_id") != record.thread_id:
-                if record is None or evidence.get("run_id") != run_id or evidence.get("thread_id") != record.thread_id:
+                raise ValueError("Assembly/run binding mismatch")
-                    raise ValueError("Assembly/run binding mismatch")
+            if EVIDENCE_KEY in record.metadata:
-                if EVIDENCE_KEY in record.metadata:
+                if record.metadata[EVIDENCE_KEY] != evidence:
-                    if record.metadata[EVIDENCE_KEY] != evidence:
+                    raise ValueError("Run assembly evidence is immutable")
-                        raise ValueError("Run assembly evidence is immutable")
+                return
-                    return
+            record.metadata = {**record.metadata, EVIDENCE_KEY: copy.deepcopy(evidence)}
-                record.metadata = {**record.metadata, EVIDENCE_KEY: copy.deepcopy(evidence)}
             if not await self._persist_to_store(record):
                 record.metadata.pop(EVIDENCE_KEY, None)
                 raise RuntimeError("Unable to persist assembly evidence")
 
     async def update_model_name(self, run_id: str, model_name: str | None) -> None:
         """Update the model name for a run."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None:
                 logger.warning("update_model_name called for unknown run %s", run_id)
@@ -1724,7 +1688,7 @@ class RunManager:
         action: str,
     ) -> None:
         """Set process-local abort state without status persistence or cleanup."""
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is None or (record.status not in (RunStatus.pending, RunStatus.running) and not self._awaits_terminal_commit(record)) or record.abort_event.is_set():
                 return
@@ -1782,7 +1746,7 @@ class RunManager:
         # ------------------------------------------------------------------
         # Local path — this worker owns the run in-memory.
         # ------------------------------------------------------------------
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is not None:
                 if record.status == RunStatus.interrupted:
@@ -1807,7 +1771,7 @@ class RunManager:
             elif outcome != CancelOutcome.lease_valid_elsewhere:
                 return outcome
 
-        async with self._run_registry_lock(run_id):
+        async with self._lock:
             record = self._runs.get(run_id)
             if record is not None:
                 if record.status == RunStatus.interrupted or record.abort_event.is_set():
@@ -1833,7 +1797,7 @@ class RunManager:
                 # cancellation; ordinary runs retain immediate persistence.
                 return CancelOutcome.cancelled
             persisted = await self._persist_status(record, RunStatus.interrupted)
-            async with self._run_registry_lock(run_id):
+            async with self._lock:
                 if self._runs.get(run_id) is record:
                     record.terminal_status_persisted = self._has_final_terminal_ack(record) if self.heartbeat_enabled and self._store is not None else persisted
             if not persisted and self._store is not None:
@@ -2037,14 +2001,14 @@ class RunManager:
                 raise RuntimeError(f"Cancelled admission {record.run_id} remains active in the run store")
 
         if stored is None:
-            async with self._run_registry_lock(record.run_id):
+            async with self._lock:
                 if self._runs.get(record.run_id) is record:
                     self._runs.pop(record.run_id, None)
                     self._unindex_run_locked(record.run_id, record.thread_id)
             return
 
         stored_status = RunStatus(stored.get("status") or RunStatus.pending.value)
-        async with self._run_registry_lock(record.run_id):
+        async with self._lock:
             if self._runs.get(record.run_id) is record:
                 record.status = stored_status
                 record.terminal_status_persisted = stored_status not in (
@@ -2080,7 +2044,7 @@ class RunManager:
         already has a pending/running run.  For ``interrupt``/``rollback``,
         cancels inflight runs before creating.
 
-        Lock ordering invariant: the per-thread admission gate is held across
+        Lock ordering invariant: the local ``self._lock`` is held across
         the local check, the store insert, and the local register, so the
         store insert can never succeed while a same-worker ConflictError
         is about to fire (which would leak a pending row in the store).
@@ -2129,53 +2093,52 @@ class RunManager:
             idempotency_request=idempotency_request,
         )
 
-        async with self._admission_scope(thread_id, run_id):
+        async with self._lock:
-            async with self._lock:
+            if idempotency_key is not None and execution_fence is None:
-                if idempotency_key is not None and execution_fence is None:
+                for existing in self._runs.values():
-                    for existing in self._runs.values():
+                    if existing.idempotency_key != idempotency_key:
-                        if existing.idempotency_key != idempotency_key:
+                        continue
-                            continue
-                        if existing.thread_id != thread_id or existing.user_id != user_id:
-                            raise RunIdempotencyKeyMismatch("Run idempotency key resolved to a different thread or user")
-                        existing.idempotency_reused = True
-                        return existing
-
-                def reuse_idempotent_run(conflict: RunIdempotencyConflict) -> RunRecord:
-                    # A locally held record for this key already returned above, so
-                    # the conflicting row belongs to a peer or to a run this worker
-                    # has cleaned up. Return a store-only handle without registering
-                    # it: nothing here finalizes or cleans up that record, so a
-                    # registered copy would keep its admission-time status, reject
-                    # later admissions for the thread, and shadow the durable row
-                    # for get(), cancel(), and orphan reconciliation.
-                    existing = self._record_from_store(conflict.existing)
                     if existing.thread_id != thread_id or existing.user_id != user_id:
-                        raise RunIdempotencyKeyMismatch("Run idempotency key resolved to a different thread or user") from conflict
+                        raise RunIdempotencyKeyMismatch("Run idempotency key resolved to a different thread or user")
                     existing.idempotency_reused = True
                     return existing
 
-                # 1) Local inflight check (same-worker guard; cross-worker is the
+            def reuse_idempotent_run(conflict: RunIdempotencyConflict) -> RunRecord:
-                #    store's partial unique index below).
+                # A locally held record for this key already returned above, so
-                local_inflight = [r for r in self._thread_records_locked(thread_id) if r.status in (RunStatus.pending, RunStatus.running) or r.finalizing or r.scheduled_goal_cleanup_pending]
+                # the conflicting row belongs to a peer or to a run this worker
+                # has cleaned up. Return a store-only handle without registering
+                # it: nothing here finalizes or cleans up that record, so a
+                # registered copy would keep its admission-time status, reject
+                # later admissions for the thread, and shadow the durable row
+                # for get(), cancel(), and orphan reconciliation.
+                existing = self._record_from_store(conflict.existing)
+                if existing.thread_id != thread_id or existing.user_id != user_id:
+                    raise RunIdempotencyKeyMismatch("Run idempotency key resolved to a different thread or user") from conflict
+                existing.idempotency_reused = True
+                return existing
 
-                if any(r.scheduled_goal_cleanup_pending for r in local_inflight):
+            # 1) Local inflight check (same-worker guard; cross-worker is the
-                    raise ConflictError(f"Thread {thread_id} has a scheduled goal awaiting finalization")
+            #    store's partial unique index below).
+            local_inflight = [r for r in self._thread_records_locked(thread_id) if r.status in (RunStatus.pending, RunStatus.running) or r.finalizing or r.scheduled_goal_cleanup_pending]
 
-                if multitask_strategy in ("interrupt", "rollback") and any(record.operation_kind != ThreadOperationKind.run for record in local_inflight):
+            if any(r.scheduled_goal_cleanup_pending for r in local_inflight):
-                    raise ConflictError(f"Thread {thread_id} has an active checkpoint write")
+                raise ConflictError(f"Thread {thread_id} has a scheduled goal awaiting finalization")
 
-                if multitask_strategy == "reject" and local_inflight:
+            if multitask_strategy in ("interrupt", "rollback") and any(record.operation_kind != ThreadOperationKind.run for record in local_inflight):
-                    raise ConflictError(f"Thread {thread_id} already has an active run")
+                raise ConflictError(f"Thread {thread_id} has an active checkpoint write")
 
-                if multitask_strategy in ("interrupt", "rollback") and local_inflight:
+            if multitask_strategy == "reject" and local_inflight:
-                    logger.info(
+                raise ConflictError(f"Thread {thread_id} already has an active run")
-                        "Preparing to cancel %d inflight run(s) on thread %s (strategy=%s)",
-                        len(local_inflight),
-                        thread_id,
-                        multitask_strategy,
-                    )
 
-            # 2) Persist with only the same-thread admission gate held. The
+            if multitask_strategy in ("interrupt", "rollback") and local_inflight:
+                logger.info(
+                    "Preparing to cancel %d inflight run(s) on thread %s (strategy=%s)",
+                    len(local_inflight),
+                    thread_id,
+                    multitask_strategy,
+                )
+
+            # 2) Persist to store while still holding the local lock. The
             #    store is the source of truth for cross-process atomicity.
             if self._store is not None:
                 if idempotency_request is not None and not _store_accepts_idempotency_parameter(self._store, "idempotency_request"):
@@ -2279,28 +2242,27 @@ class RunManager:
                     # rows as interrupted in the same transaction; no extra
                     # store write is needed for them.
 
-            async with self._lock:
+            # 3) Only now safe to register locally — store insert succeeded.
-                # 3) Only now safe to register locally — store insert succeeded.
+            self._runs[run_id] = record
-                self._runs[run_id] = record
+            self._index_run_locked(record)
-                self._index_run_locked(record)
+            self._arm_lease_deadline(record)
-                self._arm_lease_deadline(record)
 
-                # 4) Cancel local in-memory inflight (interrupt/rollback). The
+            # 4) Cancel local in-memory inflight (interrupt/rollback). The
-                #    store-side counterparts were already cancelled in step 2.
+            #    store-side counterparts were already cancelled in step 2.
-                if self._store is None and multitask_strategy in ("interrupt", "rollback"):
+            if self._store is None and multitask_strategy in ("interrupt", "rollback"):
-                    for r in local_inflight:
+                for r in local_inflight:
-                        if r.finalizing:
+                    if r.finalizing:
-                            continue
+                        continue
-                        r.abort_action = multitask_strategy
+                    r.abort_action = multitask_strategy
-                        r.abort_event.set()
+                    r.abort_event.set()
-                        task_active = r.task is not None and not r.task.done()
+                    task_active = r.task is not None and not r.task.done()
-                        r.finalizing = task_active
+                    r.finalizing = task_active
-                        if task_active:
+                    if task_active:
-                            r.task.cancel()
+                        r.task.cancel()
-                        r.status = RunStatus.interrupted
+                    r.status = RunStatus.interrupted
-                        r.terminal_status_persisted = self._store is None
+                    r.terminal_status_persisted = self._store is None
-                        r.updated_at = now
+                    r.updated_at = now
-                        interrupted_records.append(r)
+                    interrupted_records.append(r)
 
         # Outside the lock: persist interrupted status for locally-cancelled
         # runs. Store-side claimed rows are already finalised. Cancellation at
@@ -2366,7 +2328,7 @@ class RunManager:
             if reservation_task is None:
                 raise RuntimeError("Thread operation reservation requires an active asyncio task")
             lease_lost = True
-            async with self._run_registry_lock(record.run_id):
+            async with self._lock:
                 if self._runs.get(record.run_id) is record:
                     record.task = reservation_task
                     lease_lost = record.abort_event.is_set()
@@ -2393,7 +2355,7 @@ class RunManager:
                             exc_info=True,
                         )
             finally:
-                async with self._run_registry_lock(record.run_id):
+                async with self._lock:
                     removed = self._runs.pop(record.run_id, None)
                     if removed is not None:
                         self._unindex_run_locked(record.run_id, removed.thread_id)
@@ -2510,7 +2472,7 @@ class RunManager:
 
     async def has_inflight(self, thread_id: str) -> bool:
         """Return ``True`` if *thread_id* has a pending or running run."""
-        async with self._thread_registry_lock(thread_id):
+        async with self._lock:
             return any(r.operation_kind == ThreadOperationKind.run and (r.status in (RunStatus.pending, RunStatus.running) or r.finalizing) for r in self._thread_records_locked(thread_id))
 
     async def cleanup(self, run_id: str, *, delay: float = 300) -> None:
@@ -2526,21 +2488,7 @@ class RunManager:
             return
         if delay > 0:
             await asyncio.sleep(delay)
-        # A terminal worker can still own queued user turns. Retain it in
+        async with self._lock:
-        # the registry so shutdown drains it before closing shared storage.
-        async with self._run_registry_lock(run_id):
-            record = self._runs.get(run_id)
-            task = record.task if record is not None else None
-        if task is not None and task is not asyncio.current_task() and not task.done():
-            try:
-                await asyncio.shield(task)
-            except asyncio.CancelledError:
-                current = asyncio.current_task()
-                if current is not None and current.cancelling():
-                    raise
-            except Exception:
-                logger.warning("Worker for run %s failed before record cleanup", run_id, exc_info=True)
-        async with self._run_registry_lock(run_id):
             record = self._runs.pop(run_id, None)
             if record is not None:
                 self._unindex_run_locked(run_id, record.thread_id)
@@ -2555,14 +2503,9 @@ class RunManager:
         """Return this worker's unique identifier."""
         return self._worker_id
 
-    @property
-    def input_store(self):
-        """The existing store, only when it supports atomic Run inputs."""
-        return self._store if getattr(self._store, "supports_run_inputs", False) is True else None
-
     async def owns_active_admission(self, record: RunRecord) -> bool:
         """Confirm the existing run slot without holding a SQL writer transaction."""
-        async with self._run_registry_lock(record.run_id):
+        async with self._lock:
             if self._runs.get(record.run_id) is not record or record.ownership_lost:
                 return False
         if self._store is None:
@@ -2898,18 +2841,6 @@ class RunManager:
         return loop.time() < deadline and self._rollback_retry_authorized(record, initial_allow_interrupted=initial_allow_interrupted)
 
     async def _renew_one_lease(self, record: RunRecord) -> None:
-        # Assembly publication writes a complete snapshot. Keep the Store
-        # renewal and its local ACK together so that snapshot cannot restore
-        # the previous lease. Waiting for this gate retains the expiry timer.
-        self._arm_lease_deadline(record)
-        async with self._snapshot_locks.hold(record.run_id):
-            action = await self._renew_one_lease_locked(record)
-        if action is not None:
-            # Do not acquire the thread gate while holding the snapshot gate:
-            # assembly publication takes them in the opposite order.
-            await self._signal_local_cancel(record.run_id, action=action)
-
-    async def _renew_one_lease_locked(self, record: RunRecord) -> str | None:
         assert self._store is not None and self._run_ownership_config is not None
         if self._has_final_terminal_ack(record):
             await self._release_confirmed_terminal_barrier(record, timeout=0)
@@ -2984,7 +2915,7 @@ class RunManager:
                     if renewal.cancel_action is not None:
                         action = renewal.cancel_action if renewal.cancel_action in ("interrupt", "rollback") else "interrupt"
                         # Signal here, before joining any other run's decision.
-                        return action
+                        await self._signal_local_cancel(record.run_id, action=action)
                     return
                 if (
                     retry_index == 0

backend/packages/harness/deerflow/runtime/runs/schemas.py

@@ -4,7 +4,6 @@ from enum import StrEnum
 
 # Shared by Gateway admission and RunManager; values remain wire-format strings.
 EVIDENCE_ORIGINS = frozenset({"interactive", "scheduled", "extension_evaluation", "unknown"})
-GOAL_RUN_HARD_STOP_REASONS = frozenset({"token_capped", "loop_capped"})
 
 
 class ThreadOperationKind(StrEnum):

backend/packages/harness/deerflow/runtime/runs/store/base.py

@@ -118,22 +118,6 @@ def run_is_before_cursor(
 
 
 class RunStore(abc.ABC):
-    supports_run_inputs = False
-
-    async def mutate_run_inputs(self, run_id, change, *, user_id=None, owner_worker_id=None):
-        """Atomically mutate a bounded input state with the current run row.
-
-        ``change`` is a synchronous host callback, never client-supplied code.
-        Serialize against status/cancellation; reject a foreign or expired owner.
-        """
-        raise NotImplementedError("Run inputs are unavailable in this store")
-
-    async def list_input_runs(self, thread_id, *, user_id=None, limit=10):
-        raise NotImplementedError("Run inputs are unavailable in this store")
-
-    async def active_input_run(self, thread_id, *, user_id=None):
-        raise NotImplementedError("Run inputs are unavailable in this store")
-
     # Explicit idempotency_key / idempotency_request keyword parameters each
     # declare support for that field. An override accepting them only through
     # **kwargs must opt in below and persist both the key and resume identity.

backend/packages/harness/deerflow/runtime/runs/store/memory.py

@@ -21,34 +21,6 @@ from deerflow.runtime.runs.store.base import (
 
 
 class MemoryRunStore(RunStore):
-    supports_run_inputs = True
-
-    async def mutate_run_inputs(self, run_id, change, *, user_id=None, owner_worker_id=None):
-        from deerflow.runtime.runs.inputs import InputConflict, empty_input_state
-
-        row = self._runs.get(run_id)
-        if row is None or (user_id is not None and row.get("user_id") != user_id):
-            raise InputConflict("Run not found")
-        if owner_worker_id is not None:
-            lease = row.get("lease_expires_at")
-            if row.get("owner_worker_id") != owner_worker_id or (lease and datetime.fromisoformat(lease).replace(tzinfo=UTC) <= datetime.now(UTC)):
-                raise InputConflict("Run ownership changed")
-        state = copy.deepcopy(row.get("run_inputs") or empty_input_state())
-        change(state, row)
-        row["run_inputs"] = state
-        return copy.deepcopy(state)
-
-    async def list_input_runs(self, thread_id, *, user_id=None, limit=10):
-        rows = [x for x in await self.list_by_thread(thread_id, user_id=user_id, limit=len(self._runs_by_thread.get(thread_id, {}))) if (x.get("run_inputs") or {}).get("items")]
-        return copy.deepcopy(rows[:limit])
-
-    async def active_input_run(self, thread_id, *, user_id=None):
-        for run_id in reversed(self._runs_by_thread.get(thread_id, {})):
-            row = self._runs[run_id]
-            if (user_id is None or row.get("user_id") == user_id) and row.get("status") in ("pending", "running") and row.get("run_inputs") is not None and not row["run_inputs"]["closed"] and not row.get("cancel_action"):
-                return run_id
-        return None
-
     def __init__(self) -> None:
         self._runs: dict[str, dict[str, Any]] = {}
         self._change_seq = 0
@@ -129,7 +101,6 @@ class MemoryRunStore(RunStore):
             # request that may have raced a retry of an earlier snapshot.
             "cancel_action": existing.get("cancel_action") if existing else None,
             "cancel_requested_at": existing.get("cancel_requested_at") if existing else None,
-            "run_inputs": copy.deepcopy(existing.get("run_inputs")) if existing else None,
         }
         # Move membership only after the replacement snapshot was built; a
         # failed copy must leave the prior row and its index intact.

backend/packages/harness/deerflow/runtime/runs/worker.py

@@ -110,7 +110,6 @@ from deerflow.workspace_changes.types import WorkspaceSnapshot
 
 from .manager import ConflictError, RunManager, RunRecord, RunStartOutcome
 from .naming import resolve_root_run_name
-from .schemas import GOAL_RUN_HARD_STOP_REASONS as _GOAL_RUN_HARD_STOP_REASONS
 from .schemas import RunStatus, ThreadOperationKind
 from .store.base import canonical_run_created_at
 
@@ -237,7 +236,6 @@ def _release_run_scoped_references(
     """Remove worker-owned graph references once durable finalization is done."""
     internal_context_keys = {
         "__run_journal",
-        "__run_input_control",
         CURRENT_RUN_PRE_EXISTING_MESSAGE_IDS_KEY,
         CONVERSATION_READER_CONTEXT_KEY,
         SCHEDULER_CAPABILITY_CONTEXT_KEY,
@@ -617,7 +615,6 @@ _SERVER_OWNED_RUNTIME_CONTEXT_KEYS: Final[frozenset[str]] = (
             CONVERSATION_READER_CONTEXT_KEY,
             SCHEDULER_CAPABILITY_CONTEXT_KEY,
             AGENT_RUNS_CONTEXT_KEY,
-            "__run_input_control",
             THREAD_INCARNATION_CONTEXT_KEY,
             THREAD_INCARNATION_METADATA_GUARD_KEY,
             "is_subagent",
@@ -1068,7 +1065,6 @@ async def run_agent(
     goal_evaluator_model: Any | None = None
     delivery_content: dict[str, Any] | None = None
     goal_completion: _GoalCompletionCandidate | None = None
-    input_control = None
     scheduled_goal: GoalState | None = None
     final_goal_verdict: dict[str, Any] | None = None
     produced_output_paths: list[str] | None = None
@@ -1353,27 +1349,6 @@ async def run_agent(
         # runtime-internal channel; user code must not depend on the key name.
         if journal is not None:
             runtime_ctx["__run_journal"] = journal
-        if ctx.agent_runs is not None and run_manager.input_store is not None and not runtime_ctx.get("non_interactive"):
-            from .input_control import RunInputControl
-            from .inputs import INPUT_CONTEXT_KEY, RunInputs
-
-            def record_deferred_result(message):
-                if journal is not None and not record.ownership_lost:
-                    journal.record_deferred_task_result(message)
-
-            def record_steered_response(message):
-                if journal is not None and not record.ownership_lost:
-                    journal.record_steered_response(message)
-
-            input_control = RunInputControl(
-                RunInputs(run_manager.input_store, run_id, record.user_id, run_manager.worker_id),
-                agent_runs=ctx.agent_runs,
-                thread_id=thread_id,
-                checkpointer=checkpointer,
-                on_result=record_deferred_result,
-                on_replan=record_steered_response,
-            )
-            runtime_ctx[INPUT_CONTEXT_KEY] = input_control
         _install_runtime_context(config, runtime_ctx)
         runtime = Runtime(context=cast(Any, runtime_ctx), store=store)
         config.setdefault("configurable", {})["__pregel_runtime"] = runtime
@@ -1569,8 +1544,6 @@ async def run_agent(
 
         async def _stream_once(input_payload: Any, stream_config: RunnableConfig) -> None:
             nonlocal llm_error_fallback_message
-            if input_control is not None:
-                await input_control.inputs.reopen()
             file_tool_chunk_batcher = _LargeFileToolChunkBatcher() if "messages-tuple" in requested_modes else None
             try:
                 async with _checkpoint_thread_lock(thread_id):
@@ -1709,8 +1682,6 @@ async def run_agent(
 
         evidence_execution_started = True
         await _stream_once(graph_input, initial_runnable_config)
-        if input_control is not None:
-            await input_control.confirm_checkpoint()
         while not record.abort_event.is_set() and not llm_error_fallback_message and (journal is None or not journal.had_llm_error_fallback):
             continuation_input = await _prepare_goal_continuation_input(
                 bridge=bridge,
@@ -1890,15 +1861,6 @@ async def run_agent(
             nonlocal runtime_ctx, subagent_events, task_info, task_store, terminal_error_frame
 
             try:
-                if input_control is not None:
-                    try:
-                        await input_control.close()
-                        if not record.ownership_lost:
-                            await input_control.confirm_checkpoint()
-                            if record.status != RunStatus.success or record.stop_reason:
-                                await input_control.inputs.pause()
-                    except Exception:
-                        logger.warning("Could not finalize Run input receipts for %s", run_id, exc_info=True)
                 if record.ownership_lost:
                     logger.warning(
                         "Skipping durable finalization for run %s because this worker no longer owns its lease",
@@ -2340,7 +2302,7 @@ async def run_agent(
 # Helpers
 # ---------------------------------------------------------------------------
 
-
+_GOAL_RUN_HARD_STOP_REASONS = frozenset({"token_capped", "loop_capped"})
 # Stops that end the run with an error before the turn has a final reply: the
 # goal stands down without an evaluator call, since there is nothing to judge.
 _GOAL_RUN_ERROR_STOP_REASONS = frozenset({_RECURSION_CAPPED_STOP_REASON})

backend/packages/harness/deerflow/runtime/secret_context.py

@@ -192,7 +192,6 @@ REDACTED_CONTEXT_KEYS = frozenset(
     {
         SECRETS_CONTEXT_KEY,
         AGENT_RUNS_CONTEXT_KEY,
-        "__run_input_control",
         ACTIVE_SECRETS_CONTEXT_KEY,
         _SLASH_SECRET_SOURCE_KEY,
         _SECRETS_BINDING_AUDIT_KEY,

backend/packages/harness/deerflow/runtime/serialization.py

@@ -10,47 +10,29 @@ Consumers: ``deerflow.runtime.runs.worker`` (SSE publishing) and
 
 from __future__ import annotations
 
-import math
 from typing import Any
 
 
 def serialize_lc_object(obj: Any) -> Any:
-    """Recursively serialize a LangChain object to a JSON-serialisable dict.
+    """Recursively serialize a LangChain object to a JSON-serialisable dict."""
-
-    Non-finite floats (``NaN`` / ``inf`` / ``-inf``) are normalized to ``None``.
-    They are not valid JSON (RFC 8259) and reach this serializer from ordinary
-    runtime data — e.g. ``json.loads("1e400")`` yields ``inf`` for a tool parsing
-    external JSON, or a provider logprob of ``-inf`` for a zero-probability token.
-    Left untouched they break both display paths that share this serializer: the
-    SSE wire (``format_sse`` / the Redis bridge encode with the lenient default,
-    emitting bare ``NaN`` / ``Infinity`` tokens the ``langgraph-sdk`` / useStream
-    decoder rejects) and the REST surface (Starlette's ``JSONResponse`` uses
-    ``allow_nan=False`` and raises, turning a thread read into HTTP 500). This is
-    a display/wire normalization only; persisted checkpoint state is never routed
-    through here.
-    """
     if obj is None:
         return None
-    # ``bool`` is a subclass of ``int``, so it passes through unchanged here.
+    if isinstance(obj, (str, int, float, bool)):
-    if isinstance(obj, (str, int)):
         return obj
-    if isinstance(obj, float):
-        return obj if math.isfinite(obj) else None
     if isinstance(obj, dict):
         return {k: serialize_lc_object(v) for k, v in obj.items()}
     if isinstance(obj, (list, tuple)):
         return [serialize_lc_object(item) for item in obj]
-    # Pydantic v2 — recurse so non-finite floats nested in the dump (e.g. a
+    # Pydantic v2
-    # message's ``response_metadata``) are normalized too, not returned raw.
     if hasattr(obj, "model_dump"):
         try:
-            return serialize_lc_object(obj.model_dump())
+            return obj.model_dump()
         except Exception:
             pass
     # Pydantic v1 / older objects
     if hasattr(obj, "dict"):
         try:
-            return serialize_lc_object(obj.dict())
+            return obj.dict()
         except Exception:
             pass
     # Interrupt is a __slots__ class — no model_dump/dict/__dict__, so it
@@ -142,22 +124,10 @@ def serialize_channel_values_for_api(channel_values: dict[str, Any]) -> dict[str
 
 
 def serialize_messages_tuple(obj: Any) -> Any:
-    """Serialize a messages-mode tuple ``(chunk, metadata)``.
+    """Serialize a messages-mode tuple ``(chunk, metadata)``."""
-
-    The metadata dict rides the same wire as the chunk, so it goes through the
-    same canonical serializer: a non-finite float in metadata (LangGraph merges
-    caller-supplied run metadata, which can carry one) would otherwise reach
-    ``format_sse`` / the Redis bridge encode and emit a bare ``NaN`` /
-    ``Infinity`` token the SSE decoder rejects. Real LangGraph metadata also
-    contains tuples (``langgraph_triggers`` / ``langgraph_path``); they become
-    lists here, their JSON wire shape anyway.
-    """
     if isinstance(obj, tuple) and len(obj) == 2:
         chunk, metadata = obj
-        return [
+        return [serialize_lc_object(chunk), metadata if isinstance(metadata, dict) else {}]
-            serialize_lc_object(chunk),
-            serialize_lc_object(metadata) if isinstance(metadata, dict) else {},
-        ]
     return serialize_lc_object(obj)
 
 

backend/packages/harness/deerflow/runtime/stream_bridge/memory.py

@@ -7,7 +7,6 @@ import logging
 import re
 import time
 from collections.abc import AsyncIterator
-from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -117,7 +116,6 @@ class MemoryStreamBridge(StreamBridge):
     # -- StreamBridge API ------------------------------------------------------
 
     async def publish(self, run_id: str, event: str, data: Any) -> None:
-        data = deepcopy(data)
         stream = self._get_or_create_stream(run_id)
         entry = StreamEvent(id=self._next_id(run_id), event=event, data=data)
         async with stream.condition:
@@ -193,8 +191,7 @@ class MemoryStreamBridge(StreamBridge):
             if entry is END_SENTINEL:
                 yield END_SENTINEL
                 return
-            # Consumers identify sentinels with `is`; never deep-copy them.
+            yield entry
-            yield deepcopy(entry) if isinstance(entry, StreamEvent) and entry is not HEARTBEAT_SENTINEL else entry
             if should_stop:
                 return
 

backend/packages/harness/deerflow/skills/mutations/assets.py

@@ -1,11 +1,4 @@
-"""Bounded byte snapshots for managed custom packages (no links).
+"""Bounded byte snapshots for managed custom packages (POSIX, no links)."""
-
-POSIX walks the tree with ``dir_fd`` descriptors so every path component is
-anchored. Hosts without ``dir_fd``/``O_NOFOLLOW`` (Windows) use
-:func:`_capture_package_portable`, which re-checks each component with ``lstat``
-before use and compares the pre-open and post-open ``stat`` of every file, so a
-swap during the walk is still rejected instead of followed.
-"""
 
 from __future__ import annotations
 
@@ -54,7 +47,7 @@ class PackageSnapshot:
 def capture_package(root: Path) -> PackageSnapshot:
     """Caller owns mutation guard. Never read outside the opened package tree."""
     if os.name != "posix":
-        return _capture_package_portable(root)
+        raise ValueError("UNSUPPORTED_ASSET")
     files: list[PackageFile] = []
     total = 0
     entries = 0
@@ -153,101 +146,3 @@ def open_directory_chain(path: Path) -> int:
     except BaseException:
         os.close(fd)
         raise
-
-
-def _resolve_unlinked_ancestors(path: Path) -> Path:
-    """Return *path* after rejecting a link in any component above it.
-
-    The non-POSIX twin of :func:`open_directory_chain`: there is no ``dir_fd``
-    to anchor the walk, so each component is ``lstat``-ed in order and a link
-    stops the walk instead of being traversed.
-    """
-    path = path.absolute()
-    if ".." in path.parts or len(path.parts) > 128 or len(os.fsencode(path)) > 4096:
-        raise ValueError("UNSUPPORTED_ASSET")
-    current = Path(path.anchor)
-    for part in path.parts[1:]:
-        current = current / part
-        info = os.lstat(current)
-        if stat.S_ISLNK(info.st_mode) or not stat.S_ISDIR(info.st_mode):
-            raise ValueError("UNSUPPORTED_ASSET")
-    return path
-
-
-def _capture_package_portable(root: Path) -> PackageSnapshot:
-    """Capture a package where ``dir_fd``/``O_NOFOLLOW`` are unavailable.
-
-    ``os.lstat`` runs before every open and the opened descriptor is compared
-    against that ``lstat`` afterwards, so a component replaced between the two
-    calls raises ``REVISION_CONFLICT`` instead of publishing foreign bytes.
-    Windows keeps ``st_dev``/``st_ino`` for NTFS volumes, which makes that
-    comparison meaningful there; the executable bit stays unset because the
-    platform has no mode bits, and that is consistent within a host.
-    """
-    files: list[PackageFile] = []
-    total = 0
-    entries = 0
-    open_flags = os.O_RDONLY | getattr(os, "O_BINARY", 0) | getattr(os, "O_NOINHERIT", 0)
-
-    def walk(directory: Path, prefix: str = "", depth: int = 0) -> None:
-        nonlocal total, entries
-        if depth > MAX_DEPTH:
-            raise ValueError("QUOTA_EXCEEDED")
-        names = []
-        with os.scandir(directory) as iterator:
-            for entry in iterator:
-                entries += 1
-                if entries > MAX_FILES * 2:
-                    raise ValueError("QUOTA_EXCEEDED")
-                names.append(entry.name)
-        for name in sorted(names):
-            if "\\" in name or any(ord(c) < 32 for c in name):
-                raise ValueError("UNSUPPORTED_ASSET")
-            path = f"{prefix}/{name}" if prefix else name
-            if len(path.encode("utf-8")) > 1024:
-                raise ValueError("QUOTA_EXCEEDED")
-            target = directory / name
-            info = os.lstat(target)
-            if stat.S_ISLNK(info.st_mode):
-                raise ValueError("UNSUPPORTED_ASSET")
-            if stat.S_ISDIR(info.st_mode):
-                walk(target, path, depth + 1)
-                continue
-            if not stat.S_ISREG(info.st_mode):
-                raise ValueError("UNSUPPORTED_ASSET")
-            if len(files) >= MAX_FILES:
-                raise ValueError("QUOTA_EXCEEDED")
-            limit = min(MAX_PACKAGE_BYTES - total, MAX_MAIN_BYTES if path == "SKILL.md" else MAX_PACKAGE_BYTES)
-            if info.st_size > limit:
-                raise ValueError("QUOTA_EXCEEDED")
-            fd = os.open(target, open_flags)
-            try:
-                opened = os.fstat(fd)
-                if (info.st_dev, info.st_ino, info.st_mode) != (opened.st_dev, opened.st_ino, opened.st_mode):
-                    raise ValueError("REVISION_CONFLICT")
-                data = bytearray()
-                while True:
-                    chunk = os.read(fd, min(65536, limit + 1 - len(data)))
-                    if not chunk:
-                        break
-                    data.extend(chunk)
-                    if len(data) > limit:
-                        raise ValueError("QUOTA_EXCEEDED")
-                after = os.fstat(fd)
-                if (opened.st_size, opened.st_mtime_ns, opened.st_ctime_ns) != (after.st_size, after.st_mtime_ns, after.st_ctime_ns):
-                    raise ValueError("REVISION_CONFLICT")
-                total += len(data)
-                files.append(PackageFile(path, bytes(data), bool(opened.st_mode & 0o111)))
-            finally:
-                os.close(fd)
-
-    try:
-        walk(_resolve_unlinked_ancestors(root))
-    except OSError as exc:
-        raise ValueError("UNSUPPORTED_ASSET") from exc
-    result = PackageSnapshot(tuple(sorted(files, key=lambda item: item.path)))
-    try:
-        result.main_content
-    except (StopIteration, UnicodeError) as exc:
-        raise ValueError("UNSUPPORTED_ASSET") from exc
-    return result

backend/packages/harness/deerflow/subagents/AGENTS.md

@@ -76,8 +76,6 @@ by lease/3. `tests/test_batch_lease_lifecycle.py` covers real SQLite interleavin
 threaded initialization, peer cancellation and renewal drain.
 
 **Built-in Agents**: `general-purpose` (all tools except `task`) and `bash` (command specialist)
-
-Native worker reasoning settings come from YAML or managed definitions, with explicit per-agent overrides. Unset values request False/None, never parent thinking. Send original settings to the model factory to preserve validation and adjustment logs; record normalized effective settings in the assembly observer. Legacy stored definitions may omit both fields.
 **Registry and managed definitions**: Resolve built-ins → `config.yaml custom_agents` → enabled admin-managed definitions → explicit `subagents.agents.<name>` overrides. Managed definitions are deployment-wide, use Custom Agents' `agent_storage.backend`, and remain stored but inactive on built-in/config name collisions. Default Lead Agent sees the full enabled catalog. Snapshot a Custom Agent's `allowed_subagents` into run metadata (`None` = all, `[]` = deny, list = allowlist); enforce it in prompt discovery and `task`, never reload mutable caller policy inside the tool.
 **Benefit-based routing policy**: Default to direct execution. Permit `task` only when parallel latency, specialist skill or context isolation clearly outweigh startup, duplicate discovery, synthesis, state conflicts and side effects. Parallel scopes need independent outputs and disjoint mutable state; use the fewest useful agents, reassessing each batch. Bounded sequential delegation requires strong specialist/context benefit. A per-response limit of 1 permits only material specialist/context benefit: omit parallel/multi-batch benefits. Align `lead_agent/prompt.py`, the `task` description and built-in roles. Tests: `test_subagent_routing_prompt.py`, `test_subagent_prompt_security.py`, `test_lead_agent_prompt.py`.
 **User-scoped Skills**: Use `get_or_new_user_skill_storage(user_id)` with parent runtime identity (`DEFAULT_USER_ID` only if absent), preserving lead-agent custom-skill shadowing/visibility; never use the global-only catalog.

backend/packages/harness/deerflow/subagents/capacity.py

@@ -58,14 +58,14 @@ class SubagentExecutionCapacity:
             admission_policy=self._config.admission_policy,
         )
 
-    async def _acquire(self, *, wait=True) -> None:
+    async def _acquire(self) -> None:
         waiter: asyncio.Future[None] | None = None
         async with self._lock:
             if self._running < self._config.max_running:
                 self._running += 1
                 return
             queued = sum(not candidate.done() for candidate in self._waiters)
-            if not wait or self._config.admission_policy == "reject" or queued >= self._config.max_queued:
+            if self._config.admission_policy == "reject" or queued >= self._config.max_queued:
                 raise SubagentCapacityRejected(f"Subagent execution capacity is full ({self._config.max_running} running, {queued} queued)")
             waiter = asyncio.get_running_loop().create_future()
             self._waiters.append(waiter)
@@ -125,8 +125,8 @@ class SubagentExecutionCapacity:
         release_task.result()
 
     @asynccontextmanager
-    async def slot(self, *, wait=True) -> AsyncIterator[None]:
+    async def slot(self) -> AsyncIterator[None]:
-        await self._acquire(wait=wait)
+        await self._acquire()
         try:
             yield
         finally:

backend/packages/harness/deerflow/subagents/config.py

@@ -25,9 +25,6 @@ class SubagentConfig:
                 allowed-tools is compatibility metadata only and never restricts
                 this subagent's tools.
         model: Model to use - 'inherit' uses parent's model.
-        thinking_enabled: Whether to enable thinking/reasoning for this subagent.
-                None means use default (False).
-        reasoning_effort: Selected model's reasoning effort or None for its default.
         max_turns: Maximum agent turns — model call plus the tools it runs —
             before stopping. Built-in agents use the value set here
             (general-purpose=150, bash=60) unless the global
@@ -49,8 +46,6 @@ class SubagentConfig:
     disallowed_tools: list[str] | None = field(default_factory=lambda: ["task"])
     skills: list[str] | None = None
     model: str = "inherit"
-    thinking_enabled: bool | None = None
-    reasoning_effort: str | None = None
     max_turns: int = 50
     timeout_seconds: int = 900
     prompt_overlay: PromptOverlay = field(default_factory=PromptOverlay)

backend/packages/harness/deerflow/subagents/executor.py

@@ -66,8 +66,6 @@ from deerflow.utils.file_io import await_drained
 from deerflow.utils.messages import message_content_to_text
 
 if TYPE_CHECKING:
-    from deerflow.models.reasoning import ResolvedReasoning
-
     # Imported lazily at runtime inside _build_initial_state: importing
     # tool_search eagerly would run tools/builtins/__init__ -> task_tool ->
     # `from deerflow.subagents import SubagentExecutor`, which re-enters this
@@ -921,7 +919,6 @@ class SubagentExecutor:
         tool_progress_recorder: Any | None = None,
         context_snapshot: ParentContextSnapshot | None = None,
         thread_incarnation: str | None | object = _THREAD_INCARNATION_UNSET,
-        input_gate: Any | None = None,
     ):
         """Initialize the executor.
 
@@ -992,16 +989,10 @@ class SubagentExecutor:
             self.model_name: str | None = resolve_subagent_model_name(config, parent_model, app_config=app_config)
         else:
             self.model_name = None
-        # Resolve thinking_enabled: config explicit > False
-        self.thinking_enabled = config.thinking_enabled if config.thinking_enabled is not None else False
-        # Resolve reasoning_effort: config explicit > None
-        self.reasoning_effort = config.reasoning_effort
-
         self.sandbox_state = sandbox_state
         self.thread_data = thread_data
         self.uploaded_files = deepcopy(uploaded_files) if uploaded_files is not None else None
         self.context_snapshot = context_snapshot
-        self.input_gate = input_gate
         self.thread_id = thread_id
         self.thread_incarnation = thread_incarnation
         # Generate trace_id if not provided (for top-level calls)
@@ -1109,24 +1100,7 @@ class SubagentExecutor:
         app_config = self._get_resolved_app_config()
         if self.model_name is None:
             self.model_name = resolve_subagent_model_name(self.config, self.parent_model, app_config=app_config)
-        from deerflow.models.reasoning import ReasoningPolicyError, resolve_reasoning_contract, resolve_reasoning_request
+        model = create_chat_model(name=self.model_name, thinking_enabled=False, app_config=app_config, attach_tracing=False)
-
-        get_model_config = getattr(app_config, "get_model_config", None)
-        model_config = get_model_config(self.model_name) if callable(get_model_config) else None
-        if model_config is None:
-            model_config = next((profile for profile in getattr(app_config, "models", []) if profile.name == self.model_name), None)
-        try:
-            effective_reasoning = resolve_reasoning_request(resolve_reasoning_contract(model_config), thinking_enabled=self.thinking_enabled, reasoning_effort=self.reasoning_effort)
-        except ReasoningPolicyError as exc:
-            raise ValueError(f"Model {self.model_name}: {exc}") from exc
-        # Preserve the original request for the factory's validation and logs.
-        model = create_chat_model(
-            name=self.model_name,
-            thinking_enabled=self.thinking_enabled,
-            reasoning_effort=self.reasoning_effort,
-            app_config=app_config,
-            attach_tracing=False,
-        )
 
         from deerflow.agents.middlewares.tool_error_handling_middleware import build_subagent_runtime_middlewares
 
@@ -1169,11 +1143,6 @@ class SubagentExecutor:
         if mcp_routing_middleware is not None:
             middleware_kwargs["mcp_routing_middleware"] = mcp_routing_middleware
         middlewares = build_subagent_runtime_middlewares(**middleware_kwargs)
-        if self.input_gate is not None:
-            from deerflow.agents.middlewares.run_input_middleware import ChildInputContinuationMiddleware, ChildInputMiddleware
-
-            middlewares.insert(0, ChildInputMiddleware(self.input_gate))
-            middlewares.append(ChildInputContinuationMiddleware(self.input_gate))
         # Authorization Layer 1 for middleware-declared tools (e.g. extension
         # contributions): collect from the built stack, decide with the same
         # provider/principal as the ordinary pass (offloaded off the event
@@ -1249,8 +1218,7 @@ class SubagentExecutor:
         tool_node = tool_graph_node.data if tool_graph_node is not None else None
         self._return_direct_tools = {tool.name for tool in tool_node.tools_by_name.values() if tool.return_direct} if isinstance(tool_node, ToolNode) else set()
         self._describe_assembly(
-            model_config=model_config,
+            app_config=app_config,
-            effective_reasoning=effective_reasoning,
             tools=bound_tools,
             middlewares=middlewares,
             deferred_setup=deferred_setup,
@@ -1299,8 +1267,7 @@ class SubagentExecutor:
     def _describe_assembly(
         self,
         *,
-        model_config: Any,
+        app_config: Any,
-        effective_reasoning: "ResolvedReasoning",
         tools: list[Any],
         middlewares: list[Any],
         deferred_setup: "DeferredToolSetup | None",
@@ -1322,6 +1289,8 @@ class SubagentExecutor:
         from deerflow.extensions.notify import notify_agent_assembled
 
         try:
+            get_model_config = getattr(app_config, "get_model_config", None)
+            model_config = get_model_config(self.model_name) if callable(get_model_config) else None
             if model_config is None:
                 # A name the profile table does not know still has an identity;
                 # a missing profile must not blank out the whole descriptor.
@@ -1333,6 +1302,12 @@ class SubagentExecutor:
                     supports_vision=False,
                 )
             deferred_names = deferred_setup.deferred_names if deferred_setup is not None else frozenset()
+            # Subagents request thinking off; the model's reasoning contract
+            # decides what that means (a required-thinking model stays on), and
+            # the descriptor reports the effective policy the factory applied.
+            from deerflow.models.reasoning import resolve_reasoning_contract, resolve_reasoning_request
+
+            effective_reasoning = resolve_reasoning_request(resolve_reasoning_contract(model_config), thinking_enabled=False, reasoning_effort=None)
             descriptor = build_assembly_descriptor(
                 namespace="deerflow",
                 agent_name=self.config.name,
@@ -1666,8 +1641,7 @@ class SubagentExecutor:
         with ensure_trace_context(self.deerflow_trace_id):
             try:
                 capacity = self.execution_capacity or get_subagent_execution_capacity()
-                slot = capacity.slot(wait=False) if self.input_gate is not None and not self.input_gate.can_queue else capacity.slot()
+                async with capacity.slot():
-                async with slot:
                     with result._state_lock:
                         if result.status.is_terminal:
                             return result
@@ -1677,15 +1651,11 @@ class SubagentExecutor:
             except SubagentCapacityError as exc:
                 result.try_set_terminal(
                     SubagentStatus.FAILED,
-                    error="No worker slot is available while previous subagents are paused. Complete the priority work in the main Agent or resume the previous subagents first."
+                    error=str(exc),
-                    if self.input_gate is not None and not self.input_gate.can_queue
-                    else str(exc),
                     admission_failure=True,
                 )
                 return result
             finally:
-                if self.input_gate is not None:
-                    self.input_gate.close()
                 result.execution_done_event.set()
 
     async def _aexecute_admitted(self, task: str, result_holder: SubagentResult | None = None) -> SubagentResult:

backend/packages/harness/deerflow/subagents/registry.py

@@ -49,8 +49,6 @@ def _build_custom_subagent_config(name: str, *, app_config: Any | None = None) -
         disallowed_tools=custom.disallowed_tools,
         skills=custom.skills,
         model=custom.model,
-        thinking_enabled=custom.thinking_enabled,
-        reasoning_effort=custom.reasoning_effort,
         max_turns=custom.max_turns,
         timeout_seconds=custom.timeout_seconds,
     )
@@ -99,8 +97,6 @@ def _build_managed_subagent_config(name: str, *, app_config: Any | None = None)
             disallowed_tools=definition.disallowed_tools,
             skills=definition.skills,
             model=definition.model,
-            thinking_enabled=definition.thinking_enabled,
-            reasoning_effort=definition.reasoning_effort,
             max_turns=definition.max_turns,
             timeout_seconds=definition.timeout_seconds,
         )
@@ -114,7 +110,7 @@ def get_subagent_config(name: str, *, app_config: Any | None = None) -> Subagent
     1. Built-in subagents (general-purpose, bash)
     2. Custom subagents from config.yaml custom_agents section
     3. Enabled administrator-managed subagents
-    4. Per-agent overrides from config.yaml agents section (timeout, max_turns, model, thinking_enabled, reasoning_effort, skills)
+    4. Per-agent overrides from config.yaml agents section (timeout, max_turns, model, skills)
 
     Args:
         name: The name of the subagent.
@@ -177,18 +173,6 @@ def get_subagent_config(name: str, *, app_config: Any | None = None) -> Subagent
         logger.debug("Subagent '%s': skills overridden (%s -> %s)", name, config.skills, effective_skills)
         overrides["skills"] = effective_skills
 
-    # Thinking: per-agent override only (no global default)
-    effective_thinking = subagents_config.get_thinking_enabled_for(name)
-    if effective_thinking is not None and effective_thinking != config.thinking_enabled:
-        logger.debug("Subagent '%s': thinking_enabled overridden (%s -> %s)", name, config.thinking_enabled, effective_thinking)
-        overrides["thinking_enabled"] = effective_thinking
-
-    # Reasoning effort: per-agent override only (no global default)
-    effective_reasoning = subagents_config.get_reasoning_effort_for(name)
-    if effective_reasoning is not None and effective_reasoning != config.reasoning_effort:
-        logger.debug("Subagent '%s': reasoning_effort overridden (%s -> %s)", name, config.reasoning_effort, effective_reasoning)
-        overrides["reasoning_effort"] = effective_reasoning
-
     if overrides:
         config = replace(config, **overrides)
 

backend/packages/harness/deerflow/tools/builtins/task_tool.py

@@ -8,7 +8,6 @@ import time
 import uuid
 from contextvars import ContextVar
 from dataclasses import replace
-from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING, Annotated, Any, Literal, cast
 
@@ -698,7 +697,6 @@ def _merge_skill_allowlists(parent: list[str] | None, child: list[str] | None) -
 def _task_result_command(
     *,
     tool_call_id: str,
-    message_id: str | None = None,
     status: SubagentStatusValue,
     result: str | None = None,
     error: str | None = None,
@@ -730,7 +728,6 @@ def _task_result_command(
         update={
             "messages": [
                 ToolMessage(
-                    id=message_id,
                     content=content,
                     tool_call_id=tool_call_id,
                     name="task",
@@ -873,15 +870,8 @@ async def task_tool(
             keep the subagent's configured/inherited model. Does not change the
             parent conversation or the saved subagent configuration.
     """
-    from deerflow.runtime.runs.input_control import run_input_control
-
-    parent_context = getattr(runtime, "context", None)
-    parent_context = parent_context if isinstance(parent_context, dict) else {}
-    input_control = run_input_control(parent_context)
-    input_gate = input_control.child(tool_call_id) if input_control is not None else None
-    result_command = partial(_task_result_command, message_id=input_gate.result_id) if input_gate is not None else _task_result_command
     if context_mode not in {"isolated", "snapshot"}:
-        return result_command(tool_call_id=tool_call_id, status="failed", error=f"Unknown context_mode '{context_mode}'. Use isolated or snapshot.")
+        return _task_result_command(tool_call_id=tool_call_id, status="failed", error=f"Unknown context_mode '{context_mode}'. Use isolated or snapshot.")
     runtime_app_config = _get_runtime_app_config(runtime)
     metadata: dict = runtime.config.get("metadata", {}) if runtime is not None else {}
     allowed_subagents = metadata.get("allowed_subagents")
@@ -895,7 +885,7 @@ async def task_tool(
     if subagent_type == "bash":
         host_bash_allowed = is_host_bash_allowed(runtime_app_config) if runtime_app_config is not None else is_host_bash_allowed()
         if not host_bash_allowed:
-            return result_command(
+            return _task_result_command(
                 tool_call_id=tool_call_id,
                 status="failed",
                 error=LOCAL_BASH_SUBAGENT_DISABLED_MESSAGE,
@@ -911,7 +901,7 @@ async def task_tool(
         else:
             available = "none"
         error = f"Unknown subagent type '{subagent_type}'. Available: {available}"
-        return result_command(
+        return _task_result_command(
             tool_call_id=tool_call_id,
             status="failed",
             error=error,
@@ -969,9 +959,11 @@ async def task_tool(
     # None when absent (e.g. internal-auth runs) so guardrail behavior is
     # unchanged. Without this, role-aware policy silently mis-attributes any
     # tool call delegated to a subagent (user_role=None).
+    parent_context = runtime.context if runtime is not None else None
+    parent_context = parent_context if isinstance(parent_context, dict) else {}
     requested_model = parent_context.get("subagent_model_name")
     if model_name is not None and requested_model is not None and model_name != requested_model:
-        return result_command(tool_call_id=tool_call_id, status="failed", error="The child model conflicts with the user's selection.")
+        return _task_result_command(tool_call_id=tool_call_id, status="failed", error="The child model conflicts with the user's selection.")
     selected_model = model_name if model_name is not None else requested_model
     if selected_model is not None:
         resolved_config = runtime_app_config or await run_assembly(get_app_config)
@@ -980,7 +972,7 @@ async def task_tool(
                 raise ValueError("A configured model name is required.")
             await run_assembly(authorize_selected_model, selected_model, context=parent_context, app_config=resolved_config)
         except ValueError as exc:
-            return result_command(tool_call_id=tool_call_id, status="failed", error=str(exc))
+            return _task_result_command(tool_call_id=tool_call_id, status="failed", error=str(exc))
         runtime_app_config = resolved_config
         config = replace(config, model=selected_model)
     if parent_context.get(THREAD_INCARNATION_METADATA_GUARD_KEY) is True:
@@ -1103,15 +1095,11 @@ async def task_tool(
     explicit_capacity = _explicit_execution_capacity.get()
     if explicit_capacity is not None:
         executor_kwargs["execution_capacity"] = explicit_capacity
-    if input_gate is not None:
-        executor_kwargs["input_gate"] = input_gate
     executor = SubagentExecutor(**executor_kwargs)
 
     # Keep the provider tool-call ID for stream/message correlation, but use a
     # server-generated execution ID for process-wide background task control.
     execution_id = executor.execute_async(prompt, task_id=tool_call_id)
-    if input_control is not None:
-        input_control.bind_execution(tool_call_id, execution_id)
 
     # Poll for task completion in backend (removes need for LLM to poll)
     poll_count = 0
@@ -1149,7 +1137,7 @@ async def task_tool(
                 )
                 cleanup_background_task(execution_id)
                 error = f"Task {tool_call_id} disappeared from background tasks"
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="failed",
                     error=error,
@@ -1231,7 +1219,7 @@ async def task_tool(
                         )
                     except Exception:
                         logger.warning(f"[trace={trace_id}] Acceptance checklist failed for task {tool_call_id}; result flows back unchecked", exc_info=True)
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="completed",
                     result=result.result,
@@ -1261,7 +1249,7 @@ async def task_tool(
                 # A turn-capped run with no usable output surfaces as failed +
                 # stop_reason=turn_capped; the cap note lets the lead tell "out
                 # of budget" from "broken subagent".
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="failed",
                     error=result.error,
@@ -1285,7 +1273,7 @@ async def task_tool(
                 )
                 logger.info(f"[trace={trace_id}] Task {tool_call_id} cancelled: {result.error}")
                 cleanup_background_task(execution_id)
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="cancelled",
                     error=result.error,
@@ -1315,7 +1303,7 @@ async def task_tool(
                     result,
                 )
                 cleanup_background_task(execution_id)
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="timed_out",
                     error=result.error,
@@ -1352,7 +1340,7 @@ async def task_tool(
                 request_cancel_background_task(execution_id)
                 _schedule_deferred_subagent_cleanup(runtime, execution_id, trace_id, max_poll_count)
                 message = f"Task polling timed out after {timeout_minutes} minutes. This may indicate the background task is stuck. Status: {result.status.value}"
-                return result_command(
+                return _task_result_command(
                     tool_call_id=tool_call_id,
                     status="polling_timed_out",
                     error=message,

backend/packages/harness/deerflow/utils/AGENTS.md

@@ -136,13 +136,6 @@ pins offload, executor isolation, request context, and failure ordering.
 
 Tool and agent assembly re-enters `get_available_tools()` and may block on MCP discovery, so the four async assembly entry points — `run_agent`'s `agent_factory` call, `task_tool`, durable batch `_execute_item`, and `abuild_checkpoint_state_accessor` — dispatch through `deerflow.utils.assembly_io.run_assembly`, a dedicated ContextVar-preserving bounded executor (`DEER_FLOW_ASSEMBLY_WORKERS`, default 8) rather than the loop's default executor; a hung MCP server therefore parks an assembly worker instead of queueing unrelated default-executor work, and the pool logs a warning when pending assemblies exceed the worker count. `tests/blocking_io/test_tool_assembly_offloop.py` pins all four offloads plus the ContextVar propagation.
 
-### Document Conversion
-
-`file_conversion.convert_file_to_markdown` resolves the live PDF converter in
-its drained parsing worker. Config cache hits still stat/hash files; keep them
-off-loop with parsing. Cold/cache-hit coverage uses real temporary configs in
-`tests/blocking_io/test_file_conversion_offloop.py`.
-
 ### Uploaded Document Summaries
 
 Outlines skip root-level HTML comment blocks (`<!--` with up to three leading

backend/packages/harness/deerflow/utils/file_conversion.py

@@ -8,9 +8,9 @@ PDF conversion strategy (auto mode):
      total when page count is unavailable), treat as image-based and fall back to MarkItDown.
   3. If pymupdf4llm is not installed, use MarkItDown directly (existing behaviour).
 
-Configuration resolution and all document parsing run in a thread pool via
+All document parsing runs in a thread pool via asyncio.to_thread() so compressed
-asyncio.to_thread() so config reads, compressed Office files and small PDFs cannot
+Office files and small PDFs cannot block the serving event loop. Source byte
-block the serving event loop. Source byte size does not bound parsing time.
+size does not bound parsing time.
 
 No FastAPI or HTTP dependencies — pure utility functions.
 """
@@ -154,17 +154,12 @@ async def convert_file_to_markdown(file_path: Path, output_path: Path | None = N
     Returns:
         Path to the generated .md file, or None if conversion failed.
     """
-
-    def convert_source() -> str:
-        return _do_convert(file_path, _get_pdf_converter())
-
     try:
-        # Config resolution also stats and hashes files, including cache hits.
+        pdf_converter = _get_pdf_converter()
-        # Keep it in the same drained worker as parsing.
         # Compressed size cannot predict parsing cost (e.g. a small XLSX can
         # contain many cells). Always offload, and drain across cancellation so
         # the caller retains its source until the converter finishes reading.
-        text = await await_drained(asyncio.to_thread(convert_source))
+        text = await await_drained(asyncio.to_thread(_do_convert, file_path, pdf_converter))
 
         md_path = output_path if output_path is not None else file_path.with_suffix(".md")
         # Drain the write-back across caller cancellation: run_file_io awaits

backend/packages/harness/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deerflow-harness"
-version = "2.3.0-dev"
+version = "2.2.0-rc0"
 description = "DeerFlow agent harness framework"
 requires-python = ">=3.12"
 dependencies = [

backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deer-flow"
-version = "2.3.0-dev"
+version = "2.2.0-rc0"
 description = "LangGraph-based AI agent system with sandbox execution capabilities"
 readme = "README.md"
 requires-python = ">=3.12"

backend/tests/AGENTS.md

@@ -220,13 +220,6 @@ contract probes execute the actual migration test setup through SQLAlchemy's
 dialect argument conversion, stopping before database acquisition; the real
 SQLite/PostgreSQL cases still exercise upgrade, downgrade and re-upgrade.
 
-## Batch lease renewal races
-
-`test_batch_lease_lifecycle.py` parks recovery after the per-item expiry SELECT,
-identified by selected item columns; the parent query can contain the same expiry
-predicate. Assert one rejected item UPDATE as well as the preserved row, so an
-empty expiry scan cannot satisfy the concurrency guard.
-
 ## DingTalk stream tasks
 
 DingTalk stream lifecycle tests drive `_serve_stream` with a fake websocket and

backend/tests/blocking_io/test_context_usage_config_read.py

@@ -1,132 +0,0 @@
-"""Regression anchor: ``/threads/{id}/token-usage`` must read the live config off the loop.
-
-``build_context_usage`` resolves the model capacity for its payload through
-``app.gateway.deps.get_config``, which routes to ``get_app_config()``. That
-loader revalidates on every call — it stats and hashes the whole
-``config.yaml``, then does the same for ``extensions_config.json`` (see
-**Config Caching** in ``deerflow/config/AGENTS.md``) — and reparses both after
-an edit. ``GET /threads/{thread_id}/token-usage`` builds this payload on every
-request, while runs, streams and other threads share the same Gateway loop, so
-a view requested just after a config edit made that request stall the loop for
-the whole reload. The token count a few lines below the read was already
-offloaded with ``asyncio.to_thread``; the config read now joins it.
-
-Each anchor performs a real filesystem read and asserts the capacity that only
-the bytes on disk can produce, so it cannot pass because the read was stubbed
-away, and it records the calling thread so a dropped wrapper is attributed.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import threading
-from collections.abc import AsyncIterator
-from pathlib import Path
-from types import SimpleNamespace
-from typing import Any
-
-import pytest
-import pytest_asyncio
-from blockbuster import BlockingError
-from fastapi import HTTPException
-from langchain_core.messages import HumanMessage
-
-from app.gateway import context_usage
-
-pytestmark = pytest.mark.asyncio
-
-_CAPACITY_ON_DISK = 4096
-_CONFIG_TEXT = f"model: disk-model\ntoken_capacity: {_CAPACITY_ON_DISK}\n"
-
-
-class _RecordingConfigLoader:
-    """``get_config`` stand-in that reads from disk, and remembers where it ran."""
-
-    def __init__(self, path: Path) -> None:
-        self.path = path
-        self.calls = 0
-        self.on_loop_thread = False
-
-    def __call__(self) -> SimpleNamespace:
-        self.calls += 1
-        self.on_loop_thread = threading.current_thread() is threading.main_thread()
-        name, capacity = self.path.read_text(encoding="utf-8").splitlines()
-        model_name = name.split(":", 1)[1].strip()
-        return SimpleNamespace(
-            models=[SimpleNamespace(name=model_name)],
-            get_model_config=lambda requested: SimpleNamespace(context_window=int(capacity.split(":", 1)[1])) if requested == model_name else None,
-        )
-
-
-class _Accessor:
-    async def aget(self, config: dict[str, Any]) -> SimpleNamespace:
-        return SimpleNamespace(values={"messages": [HumanMessage(content="context window probe")]})
-
-
-async def _stub_accessor_builder(request, *, thread_id: str):
-    return _Accessor(), {"configurable": {"thread_id": thread_id}}
-
-
-class _RunStore:
-    async def list_by_thread(self, thread_id: str, *, limit: int = 1, user_id: str | None = None):
-        return [{"model_name": "disk-model"}]
-
-
-def _write_capacity_file(path: Path) -> Path:
-    path.write_text(_CONFIG_TEXT, encoding="utf-8")
-    return path
-
-
-@pytest_asyncio.fixture
-async def loader(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> AsyncIterator[_RecordingConfigLoader]:
-    # The strict gate wraps setup as well as the call, so the fixture's own
-    # write goes through a worker.
-    config_file = await asyncio.to_thread(_write_capacity_file, tmp_path / "capacity.yaml")
-    recorder = _RecordingConfigLoader(config_file)
-    monkeypatch.setattr(context_usage, "get_config", recorder)
-    monkeypatch.setattr(context_usage, "build_thread_checkpoint_state_accessor", _stub_accessor_builder)
-    yield recorder
-    await asyncio.to_thread(config_file.unlink)
-
-
-async def test_build_context_usage_reads_capacity_off_the_loop(loader: _RecordingConfigLoader) -> None:
-    payload = await context_usage.build_context_usage(SimpleNamespace(), "thread-1", _RunStore())
-
-    assert payload is not None
-    # The capacity only the file on disk can produce: the read was not stubbed away.
-    assert payload["max_context_tokens"] == _CAPACITY_ON_DISK
-    assert payload["token_count"] > 0
-    assert payload["percentage"] == pytest.approx(round(payload["token_count"] / _CAPACITY_ON_DISK * 100, 1))
-    assert loader.calls == 1
-    assert not loader.on_loop_thread, "the live config read ran on the event loop thread"
-
-
-async def test_offloaded_read_still_reports_an_unavailable_config(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """Control: moving the read to a worker must not turn a 503 into a payload."""
-
-    def raise_unavailable() -> SimpleNamespace:
-        raise HTTPException(status_code=503, detail="Configuration not available")
-
-    monkeypatch.setattr(context_usage, "get_config", raise_unavailable)
-    monkeypatch.setattr(context_usage, "build_thread_checkpoint_state_accessor", _stub_accessor_builder)
-
-    assert await context_usage.build_context_usage(SimpleNamespace(), "thread-1", _RunStore()) is None
-
-
-async def test_inline_config_read_actually_trips_the_gate(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """Meta-check: the gate is live around this module, so the anchor above is not vacuous.
-
-    The strict gate only trips when the blocking read sits under an ``app`` or
-    ``deerflow`` frame, so this calls the loader ``deps.get_config`` routes to.
-    That accessor maps every failure to 503, which would hide the
-    ``BlockingError``, hence the loader itself.
-    """
-    from deerflow.config.app_config import get_app_config, reset_app_config
-
-    monkeypatch.setenv("DEER_FLOW_CONFIG_PATH", str(tmp_path / "capacity.yaml"))
-    await asyncio.to_thread(reset_app_config)
-    try:
-        with pytest.raises(BlockingError):
-            get_app_config()
-    finally:
-        await asyncio.to_thread(reset_app_config)

backend/tests/blocking_io/test_file_conversion_offloop.py

@@ -93,56 +93,3 @@ async def test_cancelled_conversion_cleanup_failure_preserves_cancellation(
         finish.set()
 
     assert any("partial conversion output" in record.getMessage() for record in caplog.records), "cleanup failure should be logged inside the handler, not escaped"
-
-
-@pytest.mark.parametrize("pdf_converter", ["markitdown", "pymupdf4llm"])
-@pytest.mark.parametrize("warm_cache", [False, True], ids=["cold_config", "cached_config"])
-async def test_conversion_resolves_real_config_in_the_parser_worker(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, pdf_converter: str, warm_cache: bool) -> None:
-    from deerflow.config.app_config import AppConfig, get_app_config, reset_app_config
-    from deerflow.config.extensions_config import reset_extensions_config
-    from deerflow.utils import file_conversion
-
-    config_path = tmp_path / "config.yaml"
-    extensions_path = tmp_path / "extensions_config.json"
-    source = tmp_path / "document.pdf"
-
-    def seed_files() -> None:
-        config_path.write_text(f"sandbox:\n  use: deerflow.sandbox.local:LocalSandboxProvider\nuploads:\n  pdf_converter: {pdf_converter}\n", encoding="utf-8")
-        extensions_path.write_text('{"mcpServers": {}, "skills": {}}', encoding="utf-8")
-        source.write_text("synthetic source", encoding="utf-8")
-
-    await asyncio.to_thread(seed_files)
-    monkeypatch.setenv("DEER_FLOW_CONFIG_PATH", str(config_path))
-    monkeypatch.setenv("DEER_FLOW_EXTENSIONS_CONFIG_PATH", str(extensions_path))
-    reset_app_config()
-    reset_extensions_config()
-    config_threads: list[int] = []
-    parser_threads: list[int] = []
-    selected: list[str] = []
-    loop_thread = threading.get_ident()
-
-    def load_config() -> AppConfig:
-        config_threads.append(threading.get_ident())
-        return get_app_config()
-
-    def parse_document(path: Path, converter: str) -> str:
-        parser_threads.append(threading.get_ident())
-        selected.append(converter)
-        return path.read_text(encoding="utf-8") + " converted"
-
-    monkeypatch.setattr(file_conversion, "get_app_config", load_config)
-    monkeypatch.setattr(file_conversion, "_do_convert", parse_document)
-    try:
-        if warm_cache:
-            await asyncio.to_thread(get_app_config)
-        output = await file_conversion.convert_file_to_markdown(source)
-    finally:
-        reset_app_config()
-        reset_extensions_config()
-
-    assert config_threads == parser_threads
-    assert len(config_threads) == 1 and config_threads[0] != loop_thread
-    assert selected == [pdf_converter]
-    assert output is not None
-    assert output == source.with_suffix(".md")
-    assert output.read_text(encoding="utf-8") == "synthetic source converted"

backend/tests/blocking_io/test_honcho_memory_backend.py

@@ -16,8 +16,6 @@ class _BlockingFakeClient:
 
     def __init__(self, probe_dir: Path):
         self._probe = probe_dir / "probe.txt"
-        self.looked_up = False
-        self.written = False
 
     def _block(self) -> None:
         self._probe.write_text("blocked io")
@@ -33,12 +31,6 @@ class _BlockingFakeClient:
 
     def add_messages(self, ws: str, sid: str, msgs: list[Any]) -> None:
         self._block()
-        self.written = True
-
-    def existing_source_ids(self, ws: str, sid: str, source_ids: list[str]) -> set[str]:
-        self._block()
-        self.looked_up = True
-        return set()
 
     def working_representation(self, ws: str, pid: str, *, max_conclusions: int = 25) -> str:
         self._block()
@@ -73,8 +65,6 @@ async def test_async_honcho_operations_do_not_block_event_loop(
         messages,
         user_id="alice",
     )
-    assert manager._client.looked_up
-    assert manager._client.written
     assert await manager.aget_context("alice") is not None
     assert (
         await manager.asearch(

backend/tests/blocking_io/test_summarization_memory_flush.py

@@ -65,10 +65,6 @@ class _FakeHonchoClient:
     def set_session_peers(self, ws: str, sid: str, pids: list[str]) -> None:
         pass
 
-    def existing_source_ids(self, ws: str, sid: str, source_ids: list[str]) -> set[str]:
-        self._writes.write([])
-        return set()
-
     def add_messages(self, ws: str, sid: str, msgs: list[dict[str, str]]) -> None:
         self._writes.write([message["content"] for message in msgs])
 

backend/tests/test_agent_guidance_check.py

@@ -23,7 +23,6 @@ EXPECTED_GUIDANCE_PATHS = {
     "backend/packages/harness/deerflow/agents/memory/AGENTS.md",
     "backend/packages/harness/deerflow/agents/task_continuity/AGENTS.md",
     "backend/packages/harness/deerflow/community/brave/AGENTS.md",
-    "backend/packages/harness/deerflow/community/browser_automation/AGENTS.md",
     "backend/packages/harness/deerflow/community/groundroute/AGENTS.md",
     "backend/packages/harness/deerflow/community/image_search/AGENTS.md",
     "backend/packages/harness/deerflow/community/infoquest/AGENTS.md",
@@ -34,7 +33,6 @@ EXPECTED_GUIDANCE_PATHS = {
     "backend/packages/harness/deerflow/community/ddg_search/AGENTS.md",
     "backend/packages/harness/deerflow/community/e2b_sandbox/AGENTS.md",
     "backend/packages/harness/deerflow/community/aio_sandbox/AGENTS.md",
-    "backend/packages/harness/deerflow/community/browser_automation/AGENTS.md",
     "backend/packages/harness/deerflow/community/opensandbox/AGENTS.md",
     "backend/packages/harness/deerflow/config/AGENTS.md",
     "backend/packages/harness/deerflow/extensions/AGENTS.md",

backend/tests/test_agent_teams_plugin.py

@@ -652,28 +652,6 @@ async def test_externally_advanced_state_is_never_misattributed(plugin):
     assert "Unrelated result" not in str(view["messages"])
 
 
-@pytest.mark.asyncio
-@pytest.mark.parametrize("verified", [False, True])
-async def test_same_run_steer_requires_host_input_record_before_result_attribution(plugin, verified):
-    _, actions, service = plugin
-    runs = Runs()
-    team = await create(actions, runs)
-    member = team["members"][0]
-    job = await actions["send"]({"team_id": team["id"], "member_id": member["id"], "text": "Check", "request_id": "steer"}, context(runs))
-    await service.tick()
-    messages = runs.threads[member["thread_id"]]["values"]["messages"]
-    messages.append({"type": "human", "id": "steered__user", "content": "Include the appendix", "additional_kwargs": {"run_id": job["id"], "run_input_id": "direct"}})
-
-    async def list_inputs(**kwargs):
-        return {"items": [{"id": "direct", "message_id": "steered", "mode": "steer", "status": "applied", "target_run_id": job["id"]}] if verified else []}
-
-    runs.list_inputs = list_inputs
-    runs.finish(job["id"], "Appendix checked.")
-    await service.tick()
-    view = await actions["get"]({"team_id": team["id"]}, context(runs))
-    assert view["jobs"][0]["status"] == ("completed" if verified else "failed")
-
-
 @pytest.mark.asyncio
 async def test_service_lock_prevents_two_workers_and_releases_on_shutdown(plugin):
     import sqlite3

backend/tests/test_app_config_reload.py

@@ -1107,27 +1107,3 @@ def test_get_app_config_keeps_config_yaml_extension_override_after_extensions_re
         assert get_app_config().extensions.middlewares == ["pkg.from_yaml:YamlMiddleware"]
     finally:
         _reset_config_singletons()
-
-
-def test_middleware_scope_reloads_from_extensions_and_yaml_override(tmp_path, monkeypatch):
-    entry = {"class": "example:Observer", "kwargs": {"label": "observer"}, "apply_to": "lead"}
-    extensions_path = _stage_singleton_configs(tmp_path, monkeypatch, middlewares=[entry])
-    try:
-        assert get_app_config().extensions.middlewares[0].apply_to == "lead"
-        _peer_writes_extensions(extensions_path, middlewares=[{**entry, "apply_to": "subagent"}])
-        assert get_app_config().extensions.middlewares[0].apply_to == "subagent"
-
-        config_path = tmp_path / "config.yaml"
-        raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))
-        raw["extensions"] = {"middlewares": [{**entry, "apply_to": "both"}]}
-        config_path.write_text(yaml.safe_dump(raw), encoding="utf-8")
-        assert get_app_config().extensions.middlewares[0].apply_to == "both"
-
-        _peer_writes_extensions(extensions_path, middlewares=[entry])
-        assert get_app_config().extensions.middlewares[0].apply_to == "both"
-        raw["extensions"]["middlewares"][0]["apply_to"] = "invalid"
-        config_path.write_text(yaml.safe_dump(raw), encoding="utf-8")
-        with pytest.raises(ValidationError, match="apply_to"):
-            AppConfig.from_file(str(config_path))
-    finally:
-        _reset_config_singletons()

backend/tests/test_batch_lease_lifecycle.py

@@ -308,31 +308,17 @@ async def test_each_scheduler_claim_has_a_fresh_ownership_generation(repository,
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("batch_paused", [False, True])
+async def test_recovery_does_not_overwrite_a_renewal_after_its_expiry_read(repository, monkeypatch):
-async def test_recovery_does_not_overwrite_a_renewal_after_its_expiry_read(repository, monkeypatch, batch_paused):
     await create_batch(repository)
     now = datetime.now(UTC)
     item = (await repository.claim_items(now=now, lease_owner="live-worker", lease_seconds=10, limit=1))[0]
-    if batch_paused:
-        await repository.pause_batch("batch-lease-test", user_id="user-1")
     paused, release = asyncio.Event(), asyncio.Event()
     original = AsyncSession.execute
     recovery = None
-    recovery_update_rowcounts = []
 
     async def execute(session, statement, *args, **kwargs):
         result = await original(session, statement, *args, **kwargs)
-        if asyncio.current_task() is recovery and getattr(statement, "is_update", False) and statement.table.name == SubagentBatchItemRow.__tablename__:
+        if asyncio.current_task() is recovery and not paused.is_set() and getattr(statement, "is_select", False) and "lease_expires_at <" in str(statement):
-            recovery_update_rowcounts.append(result.rowcount)
-        if (
-            asyncio.current_task() is recovery
-            and not paused.is_set()
-            and getattr(statement, "is_select", False)
-            and "lease_expires_at <" in str(statement)
-            and any(getattr(column, "table", None) is SubagentBatchItemRow.__table__ for column in statement.selected_columns)
-        ):
-            # The parent SELECT also contains the expiry predicate via EXISTS.
-            # Park only after the expired item itself has been read.
             paused.set()
             await release.wait()
         return result
@@ -346,7 +332,6 @@ async def test_recovery_does_not_overwrite_a_renewal_after_its_expiry_read(repos
     finally:
         release.set()
         claimed = await asyncio.wait_for(recovery, 3)
-    assert recovery_update_rowcounts == [0], "recovery must attempt an item update and reject the renewed lease"
     assert claimed == []
     assert await row_snapshot(repository, item["id"]) == expected
 

backend/tests/test_browser_automation.py

@@ -608,146 +608,6 @@ async def test_ensure_page_serializes_concurrent_rebuilds():
     context.new_page.assert_awaited_once()
 
 
-@pytest.fixture
-def fake_playwright_api(monkeypatch):
-    """Lifecycle unit tests do not require the optional browser extra."""
-    async_api = ModuleType("playwright.async_api")
-    async_api.async_playwright = MagicMock()
-    playwright = ModuleType("playwright")
-    playwright.async_api = async_api
-    monkeypatch.setitem(sys.modules, "playwright", playwright)
-    monkeypatch.setitem(sys.modules, "playwright.async_api", async_api)
-
-
-@pytest.mark.parametrize("surviving_tab", [True, False])
-@pytest.mark.parametrize("cdp", [False, True])
-@pytest.mark.asyncio
-async def test_ensure_page_reuses_context_after_active_tab_closes(surviving_tab, cdp, fake_playwright_api):
-    """Closing an OAuth popup or the final tab must retain session storage."""
-    session = BrowserSession(MagicMock(), headless=True, timeout_ms=1000, viewport={"width": 1000, "height": 500})
-    closed = MagicMock()
-    closed.is_closed.return_value = True
-    page = MagicMock()
-    page.is_closed.return_value = False
-    focused = False
-
-    async def focus_page():
-        nonlocal focused
-        assert session._page is closed
-        await asyncio.sleep(0)
-        focused = True
-
-    page.bring_to_front = AsyncMock(side_effect=focus_page)
-    original_set_active_page = session._set_active_page
-
-    def adopt_page(target):
-        assert focused is not cdp
-        original_set_active_page(target)
-
-    session._set_active_page = MagicMock(side_effect=adopt_page)
-    context = MagicMock()
-    context.pages = [page] if surviving_tab else []
-    creation_started = asyncio.Event()
-    release_creation = asyncio.Event()
-
-    async def new_page():
-        creation_started.set()
-        await release_creation.wait()
-        return page
-
-    context.new_page = AsyncMock(side_effect=new_page)
-    browser = MagicMock()
-    browser.is_connected.return_value = True
-    browser.contexts = [context]
-    browser.new_context = AsyncMock(side_effect=AssertionError("discarded the existing context"))
-    session._browser = browser
-    session._connected_over_cdp = cdp
-    session._context = context
-    session._page = closed
-    session._request_guard_bound = True
-    session._page_listener_bound = True
-    session._playwright = MagicMock()
-
-    if surviving_tab:
-        assert await session._ensure_page() is page
-        context.new_page.assert_not_awaited()
-    else:
-        first = asyncio.create_task(session._ensure_page())
-        try:
-            # Await the operation too, so a broken implementation fails without
-            # stranding a caller while waiting for the creation signal.
-            signal = asyncio.create_task(creation_started.wait())
-            await asyncio.wait({first, signal}, return_when=asyncio.FIRST_COMPLETED)
-            if first.done():
-                await first
-            second = asyncio.create_task(session._ensure_page())
-            release_creation.set()
-            assert await asyncio.gather(first, second) == [page, page]
-        finally:
-            release_creation.set()
-            signal.cancel()
-            await asyncio.gather(first, signal, return_exceptions=True)
-        context.new_page.assert_awaited_once()
-
-    assert session._context is context
-    assert session._page is page
-    assert session._request_guard_bound is True
-    assert session._page_listener_bound is True
-    browser.new_context.assert_not_awaited()
-    context.on.assert_not_called()
-    session._set_active_page.assert_called_once_with(page)
-    if cdp:
-        page.bring_to_front.assert_not_awaited()
-    else:
-        page.bring_to_front.assert_awaited_once_with()
-
-
-@pytest.mark.parametrize("cdp", [False, True])
-@pytest.mark.asyncio
-async def test_ensure_page_rebinds_hooks_when_context_is_replaced(cdp, fake_playwright_api):
-    session = BrowserSession(
-        MagicMock(),
-        headless=True,
-        timeout_ms=1000,
-        viewport={"width": 1000, "height": 500},
-        cdp_url="http://127.0.0.1:9222" if cdp else None,
-        url_guard=lambda _url: None,
-    )
-    page = MagicMock()
-    page.is_closed.return_value = False
-    closed = MagicMock()
-    closed.is_closed.return_value = True
-    old_context = MagicMock()
-    context = MagicMock()
-    context.pages = [page] if cdp else []
-    context.new_page = AsyncMock(return_value=page)
-    context.route = AsyncMock()
-    browser = MagicMock()
-    browser.is_connected.return_value = True
-    browser.contexts = [context] if cdp else []
-    browser.new_context = AsyncMock(return_value=context)
-    session._browser = browser
-    session._context = old_context
-    session._page = closed
-    session._request_guard_bound = True
-    session._page_listener_bound = True
-    session._playwright = MagicMock()
-
-    assert await session._ensure_page() is page
-    context.on.assert_called_once()
-    event, on_page = context.on.call_args.args
-    assert event == "page"
-    popup = MagicMock()
-    on_page(popup)
-    assert session._page is popup
-    if cdp:
-        context.route.assert_not_awaited()
-        assert session._request_guard_bound is False
-    else:
-        context.route.assert_awaited_once()
-        assert session._request_guard_bound is True
-
-
 @pytest.mark.asyncio
 async def test_tabs_report_active_page():
     session = BrowserSession(
@@ -1251,47 +1111,6 @@ async def test_real_playwright_navigate_click_type():
         session_mod.reset_browser_session_manager()
 
 
-@pytest.mark.asyncio
-async def test_real_playwright_preserves_context_after_popup_closes():
-    """Real popup/tab closure keeps the opener, login cookie and local storage."""
-    pytest.importorskip("playwright.async_api")
-    session = BrowserSession(MagicMock(), headless=True, timeout_ms=5000, viewport={"width": 800, "height": 600})
-    try:
-        opener = await session._ensure_page()
-        context = session._context
-
-        async def app_page(route):
-            await route.fulfill(body="<title>Authenticated app</title><button>Continue</button>", content_type="text/html")
-
-        await context.route("https://app.example/**", app_page)
-        await session._navigate("https://app.example/home")
-        await opener.evaluate("localStorage.setItem('account', 'alice')")
-        async with context.expect_page() as popup_event:
-            await opener.evaluate("window.open('/login')")
-        popup = await popup_event.value
-        await popup.wait_for_load_state("domcontentloaded")
-        assert session._page is popup
-        await popup.evaluate("document.cookie = 'logged_in=yes; path=/'")
-        await popup.close()
-
-        tabs = await session._tabs()
-        assert [(tab.url, tab.active) for tab in tabs] == [("https://app.example/home", True)]
-        assert session._page is opener
-        assert session._context is context
-        assert len(session._browser.contexts) == 1
-        assert await opener.evaluate("localStorage.getItem('account')") == "alice"
-        assert any(cookie["name"] == "logged_in" for cookie in await context.cookies())
-
-        await opener.close()
-        replacement = await session._ensure_page()
-        assert session._context is context
-        await replacement.goto("https://app.example/home")
-        assert await replacement.evaluate("localStorage.getItem('account')") == "alice"
-        assert any(cookie["name"] == "logged_in" for cookie in await context.cookies())
-    finally:
-        await session._close()
-
-
 class _FakeRoute:
     def __init__(self, url: str):
         self.request = SimpleNamespace(url=url)

backend/tests/test_browser_egress.py

@@ -14,15 +14,12 @@ import ipaddress
 import socket
 import sys
 import threading
-from concurrent.futures import ThreadPoolExecutor
-from contextvars import ContextVar
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from types import ModuleType, SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from app.gateway import context_usage
 from deerflow.community import url_safety
 from deerflow.community.browser_automation import egress
 from deerflow.community.browser_automation import session as session_mod
@@ -226,193 +223,6 @@ async def test_proxy_bounds_a_stuck_resolution(monkeypatch):
     assert reply == 0x04
 
 
-def test_timed_out_egress_resolution_does_not_starve_browser_request_guard(monkeypatch):
-    browser_loop = session_mod._PlaywrightLoopThread()
-    browser_executor = ThreadPoolExecutor(max_workers=1)
-    gateway_executor = ThreadPoolExecutor(max_workers=1)
-    resolver_executor = ThreadPoolExecutor(max_workers=1)
-    monkeypatch.setattr(egress, "_RESOLVER_EXECUTOR", resolver_executor, raising=False)
-    monkeypatch.setattr(egress, "_RESOLVER_SLOTS", threading.BoundedSemaphore(1), raising=False)
-    monkeypatch.setattr(egress, "_RESOLVE_TIMEOUT_S", 0.1)
-    resolver_started = threading.Event()
-    release_resolver = threading.Event()
-    resolver_calls: list[str] = []
-
-    def resolve(host: str) -> list[str]:
-        resolver_calls.append(host)
-        resolver_started.set()
-        release_resolver.wait(timeout=10)
-        return ["127.0.0.1"]
-
-    guard = MagicMock(return_value=None)
-    session = BrowserSession(browser_loop, headless=True, timeout_ms=1000, viewport={}, url_guard=guard, egress_resolver=resolve)
-    session._context = SimpleNamespace(route=AsyncMock(), close=AsyncMock())
-
-    async def start_session_proxy():
-        asyncio.get_running_loop().set_default_executor(browser_executor)
-        await session._install_request_guard()
-        return (await session._egress_proxy_settings())["server"]
-
-    async def scenario():
-        gateway_loop = asyncio.get_running_loop()
-        gateway_loop.set_default_executor(gateway_executor)
-        assert gateway_loop is not browser_loop._loop
-        assert gateway_executor is not browser_executor
-
-        messages = [SimpleNamespace(content="hello")]
-        snapshot = SimpleNamespace(values={"messages": messages})
-
-        class Accessor:
-            async def aget(self, _config):
-                return snapshot
-
-        model = SimpleNamespace(name="test-model", context_window=1000)
-        app_config = SimpleNamespace(models=[model], get_model_config=lambda _name: model)
-
-        class RunStore:
-            async def list_by_thread(self, *_args, **_kwargs):
-                return []
-
-        async def build_accessor(_request, *, thread_id):
-            return Accessor(), {"configurable": {"thread_id": thread_id}}
-
-        monkeypatch.setattr(context_usage, "_count_messages_approximately", lambda _messages: 250)
-        monkeypatch.setattr(context_usage, "build_thread_checkpoint_state_accessor", build_accessor)
-        monkeypatch.setattr(context_usage, "get_config", lambda: app_config)
-
-        connect_task = None
-        guard_task = None
-        try:
-            # Use the production session entry point: SOCKS DNS runs on the
-            # private Playwright loop, not the caller's Gateway loop.
-            proxy_url = await browser_loop.run(start_session_proxy())
-            connect_task = asyncio.create_task(_socks_connect(proxy_url, 0x03, _domain("wedged.example"), 80))
-            assert await asyncio.wait_for(asyncio.to_thread(resolver_started.wait, 2), timeout=3)
-            _method, reply, _reader, writer = await asyncio.wait_for(connect_task, timeout=2)
-            writer.close()
-            await writer.wait_closed()
-            assert reply == 0x04
-            assert not release_resolver.is_set()
-
-            _method, overloaded_reply, _reader, overloaded_writer = await asyncio.wait_for(_socks_connect(proxy_url, 0x03, _domain("second.example"), 80), timeout=2)
-            overloaded_writer.close()
-            await overloaded_writer.wait_closed()
-            assert overloaded_reply == 0x04
-            assert resolver_calls == ["wedged.example"]
-
-            # Gateway token counting has its own default pool and succeeds on
-            # both the base and PR head while the browser resolver is held.
-            assert await asyncio.wait_for(
-                context_usage.build_context_usage(request=SimpleNamespace(app=SimpleNamespace()), thread_id="thread-1", run_store=RunStore()),
-                timeout=2,
-            ) == {"token_count": 250, "max_context_tokens": 1000, "percentage": 25.0}
-
-            # The actual contention is on the browser loop: its installed route
-            # callback must still run the synchronous request guard.
-            route = SimpleNamespace(request=SimpleNamespace(url="https://public.example/"), continue_=AsyncMock(), abort=AsyncMock())
-            route_handler = session._context.route.await_args.args[1]
-            guard_task = asyncio.create_task(browser_loop.run(route_handler(route)))
-            await asyncio.wait_for(guard_task, timeout=2)
-            guard.assert_called_once_with("https://public.example/")
-            route.continue_.assert_awaited_once()
-            route.abort.assert_not_awaited()
-            assert not release_resolver.is_set()
-        finally:
-            release_resolver.set()
-            for task in (connect_task, guard_task):
-                if task is not None:
-                    task.cancel()
-                    await asyncio.gather(task, return_exceptions=True)
-            await browser_loop.run(session._close())
-            await browser_loop.run(browser_loop._loop.shutdown_default_executor())
-
-    try:
-        asyncio.run(scenario())
-    finally:
-        release_resolver.set()
-        resolver_executor.shutdown(wait=True, cancel_futures=True)
-        browser_executor.shutdown(wait=True, cancel_futures=True)
-        gateway_executor.shutdown(wait=True, cancel_futures=True)
-        browser_loop._loop.call_soon_threadsafe(browser_loop._loop.stop)
-        browser_loop._thread.join(timeout=3)
-        assert not browser_loop._thread.is_alive()
-        browser_loop._loop.close()
-
-
-@pytest.mark.asyncio
-async def test_egress_resolver_propagates_caller_context(monkeypatch):
-    executor = ThreadPoolExecutor(max_workers=1)
-    monkeypatch.setattr(egress, "_RESOLVER_EXECUTOR", executor)
-    monkeypatch.setattr(egress, "_RESOLVER_SLOTS", threading.BoundedSemaphore(1))
-    resolver_context = ContextVar("test_browser_egress_context", default="worker-default")
-    token = resolver_context.set("request-context")
-    try:
-        assert await egress._resolve_with_timeout(lambda _host: [resolver_context.get()], "public.example") == ["request-context"]
-    finally:
-        resolver_context.reset(token)
-        executor.shutdown(wait=True, cancel_futures=True)
-    assert resolver_context.get() == "worker-default"
-
-
-@pytest.mark.asyncio
-async def test_egress_resolver_submission_failure_releases_slot(monkeypatch):
-    executor = ThreadPoolExecutor(max_workers=1)
-    slots = threading.BoundedSemaphore(1)
-    monkeypatch.setattr(egress, "_RESOLVER_EXECUTOR", executor)
-    monkeypatch.setattr(egress, "_RESOLVER_SLOTS", slots)
-    try:
-        executor.shutdown(wait=True)
-        with pytest.raises(RuntimeError, match="cannot schedule new futures after shutdown"):
-            await egress._resolve_with_timeout(MagicMock(), "public.example")
-        assert slots.acquire(blocking=False), "failed submission must return its permit"
-        slots.release()
-    finally:
-        executor.shutdown(wait=True, cancel_futures=True)
-
-
-def test_timed_out_resolver_releases_slot_after_event_loop_closes(monkeypatch):
-    executor = ThreadPoolExecutor(max_workers=1)
-    slots = threading.BoundedSemaphore(1)
-    monkeypatch.setattr(egress, "_RESOLVER_EXECUTOR", executor)
-    monkeypatch.setattr(egress, "_RESOLVER_SLOTS", slots)
-    monkeypatch.setattr(egress, "_RESOLVE_TIMEOUT_S", 0.05)
-
-    resolver_started = threading.Event()
-    release_resolver = threading.Event()
-    resolver_finished = threading.Event()
-
-    def resolve(_host: str) -> list[str]:
-        resolver_started.set()
-        release_resolver.wait(timeout=10)
-        resolver_finished.set()
-        return ["127.0.0.1"]
-
-    async def time_out_resolver():
-        task = asyncio.create_task(egress._resolve_with_timeout(resolve, "wedged.example"))
-        try:
-            # Cancelling to_thread's awaiter cannot interrupt Event.wait itself.
-            assert await asyncio.wait_for(asyncio.to_thread(resolver_started.wait, 2), timeout=3)
-            with pytest.raises(TimeoutError):
-                await task
-        finally:
-            task.cancel()
-            await asyncio.gather(task, return_exceptions=True)
-
-    loop = asyncio.new_event_loop()
-    try:
-        try:
-            loop.run_until_complete(time_out_resolver())
-        finally:
-            loop.close()
-            release_resolver.set()
-        assert resolver_finished.wait(timeout=2)
-        assert slots.acquire(timeout=2), "resolver worker completion must release capacity without its event loop"
-        slots.release()
-    finally:
-        release_resolver.set()
-        executor.shutdown(wait=True, cancel_futures=True)
-
-
 @pytest.mark.asyncio
 async def test_proxy_close_is_bounded_by_a_tunnel_it_could_not_sweep(monkeypatch):
     monkeypatch.setattr(egress, "_CLOSE_TIMEOUT_S", 0.2)

backend/tests/test_changelog_reference_links.py

@@ -1,70 +0,0 @@
-"""The change logs must render every ``[#1234]`` mention as a link.
-
-Both change logs list pull requests with reference-style links: the entry text
-carries ``[#1234]`` and a ``[#1234]: <url>`` line at the bottom supplies the
-target. A missing definition renders as the literal characters ``[#1234]``, and a
-definition whose number or repository differs from its key silently points at a
-different page. Neither is visible while reviewing an entry, so pin both here.
-
-These checks read the two files only — no network, no fixtures.
-"""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-CHANGELOGS = ("CHANGELOG.md", "CHANGELOG_zh.md")
-
-_DEFINITION = re.compile(r"^\[\s*#?(?P<key>\d+)\s*\]:\s*(?P<url>\S+)\s*$")
-# ``[#1234]`` used as reference text. A following ``(`` or ``[`` makes it an
-# inline link (``[#1234](url)``), which needs no definition.
-_REFERENCE = re.compile(r"\[#(\d+)\](?![\[(])")
-_SAME_REPO_TARGET = re.compile(r"^https://github\.com/bytedance/deer-flow/(?:pull|issues)/(?P<number>\d+)$")
-_COMMIT_PERMALINK = re.compile(r"^https://github\.com/bytedance/deer-flow/commit/[0-9a-f]{40}$")
-
-
-def _scan(path: Path) -> tuple[set[int], dict[int, str]]:
-    """Return the ``[#n]`` tokens used in prose and the ``[#n]:`` definitions."""
-    used: set[int] = set()
-    defined: dict[int, str] = {}
-    in_fence = False
-    for line in path.read_text(encoding="utf-8").splitlines():
-        stripped = line.strip()
-        if stripped.startswith("```"):
-            in_fence = not in_fence
-            continue
-        definition = _DEFINITION.match(stripped)
-        if definition:
-            defined[int(definition.group("key"))] = definition.group("url")
-            continue
-        if in_fence:
-            continue
-        used.update(int(match.group(1)) for match in _REFERENCE.finditer(line))
-    return used, defined
-
-
-@pytest.mark.parametrize("changelog", CHANGELOGS)
-def test_every_reference_mention_has_a_definition(changelog: str) -> None:
-    used, defined = _scan(REPO_ROOT / changelog)
-
-    missing = sorted(used - set(defined))
-    assert not missing, f"{changelog} mentions {['#' + str(n) for n in missing]} as [#n] reference text without a '[#n]: <url>' definition, so it renders as literal text."
-
-
-@pytest.mark.parametrize("changelog", CHANGELOGS)
-def test_definitions_target_their_own_number_in_this_repository(changelog: str) -> None:
-    _, defined = _scan(REPO_ROOT / changelog)
-
-    drifted = []
-    for number, url in defined.items():
-        same_repo = _SAME_REPO_TARGET.match(url)
-        if same_repo is not None:
-            if int(same_repo.group("number")) != number:
-                drifted.append(f"[#{number}]: {url}")
-        elif _COMMIT_PERMALINK.match(url) is None:
-            drifted.append(f"[#{number}]: {url}")
-    assert not drifted, f"{changelog} defines a reference outside bytedance/deer-flow, or aimed at a different number than its key: {drifted[:5]}"

backend/tests/test_channel_state_atomic_publish.py

@@ -1,148 +0,0 @@
-"""Channel JSON state must be published whole, never truncated in place.
-
-``DiscordChannel._persist_thread_mappings`` and ``WechatChannel._save_state``
-write state a crash could otherwise truncate: the Discord mapping would fail to
-load and the WeChat cursor buffer would be lost, re-reading from the start. Both
-now stage a sibling and replace it, and a stage that cannot be discarded is
-reported instead of replacing the outcome.
-"""
-
-from __future__ import annotations
-
-import json
-import threading
-from pathlib import Path
-
-from app.channels.discord import DiscordChannel
-from app.channels.wechat import WechatChannel
-
-
-def _discord(tmp_path):
-    channel = DiscordChannel.__new__(DiscordChannel)
-    channel._thread_store_lock = threading.Lock()
-    channel._active_threads = {"a": {"thread_id": "t1"}}
-    channel._thread_store_path = tmp_path / "state" / "discord-threads.json"
-    return channel
-
-
-def _wechat(tmp_path):
-    channel = WechatChannel.__new__(WechatChannel)
-    channel._cursor_path = tmp_path / "state" / "wechat-cursor.json"
-    channel._get_updates_buf = "cursor-1"
-    return channel
-
-
-def _fail_staged_write(monkeypatch):
-    """Fail the staged write the way a full disk would, before any rename.
-
-    With the shared helper this is the earliest injectable point: the bytes are
-    written to a sibling, fsync fails, and the rename never happens. The point of
-    the test is that the live file is untouched by that failure.
-    """
-
-    def failing_fsync(_fd):
-        raise OSError("disk full")
-
-    monkeypatch.setattr("deerflow.utils.atomic_write.os.fsync", failing_fsync)
-
-
-def _no_sidecar(target: Path) -> bool:
-    prefix = f".{target.name}."
-    return [p.name for p in target.parent.iterdir() if p.name.startswith(prefix)] == []
-
-
-def test_discord_state_is_replaced_whole(tmp_path):
-    channel = _discord(tmp_path)
-    target = tmp_path / "state" / "discord-threads.json"
-
-    channel._persist_thread_mappings()
-
-    assert json.loads(target.read_text(encoding="utf-8")) == {"a": {"thread_id": "t1"}}
-    assert _no_sidecar(target)
-
-
-def test_discord_failed_staged_write_keeps_the_previous_mapping(tmp_path, monkeypatch):
-    channel = _discord(tmp_path)
-    target = tmp_path / "state" / "discord-threads.json"
-    target.parent.mkdir(parents=True)
-    target.write_text('{"kept": true}', encoding="utf-8")
-    _fail_staged_write(monkeypatch)
-
-    channel._persist_thread_mappings()
-
-    assert target.read_text(encoding="utf-8") == '{"kept": true}'
-    assert json.loads(target.read_text(encoding="utf-8")) == {"kept": True}
-    assert _no_sidecar(target)
-
-
-def test_wechat_state_is_replaced_whole(tmp_path):
-    channel = _wechat(tmp_path)
-    target = tmp_path / "state" / "wechat-cursor.json"
-
-    channel._save_state()
-
-    assert json.loads(target.read_text(encoding="utf-8")) == {"get_updates_buf": "cursor-1"}
-    assert _no_sidecar(target)
-
-
-def test_wechat_failed_staged_write_keeps_the_previous_cursor(tmp_path, monkeypatch):
-    channel = _wechat(tmp_path)
-    target = tmp_path / "state" / "wechat-cursor.json"
-    target.parent.mkdir(parents=True)
-    target.write_text('{"get_updates_buf": "kept"}', encoding="utf-8")
-    _fail_staged_write(monkeypatch)
-
-    channel._save_state()
-
-    assert json.loads(target.read_text(encoding="utf-8")) == {"get_updates_buf": "kept"}
-    assert _no_sidecar(target)
-
-
-def _fail_staged_write_and_cleanup(monkeypatch):
-    """Fail the staged write, and fail discarding the staged sibling too."""
-
-    def failing_fsync(_fd):
-        raise OSError("disk full")
-
-    real_unlink = Path.unlink
-
-    def failing_unlink(self, *args, **kwargs):
-        if self.name.startswith(".") and self.name.endswith(".tmp"):
-            raise PermissionError("staging is still open")
-        return real_unlink(self, *args, **kwargs)
-
-    monkeypatch.setattr("deerflow.utils.atomic_write.os.fsync", failing_fsync)
-    monkeypatch.setattr(Path, "unlink", failing_unlink)
-
-
-def test_discord_failed_cleanup_still_reports_and_keeps_the_outcome(tmp_path, monkeypatch, caplog):
-    """A discard that fails must not escape, and both failures stay visible."""
-    channel = _discord(tmp_path)
-    target = tmp_path / "state" / "discord-threads.json"
-    target.parent.mkdir(parents=True)
-    target.write_text('{"kept": true}', encoding="utf-8")
-    _fail_staged_write_and_cleanup(monkeypatch)
-    caplog.clear()
-
-    with caplog.at_level("WARNING"):
-        channel._persist_thread_mappings()
-
-    assert target.read_text(encoding="utf-8") == '{"kept": true}'
-    assert "failed to persist thread mappings" in caplog.text
-    assert "Failed to remove temporary output file" in caplog.text
-
-
-def test_wechat_failed_cleanup_still_reports_and_keeps_the_outcome(tmp_path, monkeypatch, caplog):
-    channel = _wechat(tmp_path)
-    target = tmp_path / "state" / "wechat-cursor.json"
-    target.parent.mkdir(parents=True)
-    target.write_text('{"get_updates_buf": "kept"}', encoding="utf-8")
-    _fail_staged_write_and_cleanup(monkeypatch)
-    caplog.clear()
-
-    with caplog.at_level("WARNING"):
-        channel._save_state()
-
-    assert target.read_text(encoding="utf-8") == '{"get_updates_buf": "kept"}'
-    assert "failed to persist cursor state" in caplog.text
-    assert "Failed to remove temporary output file" in caplog.text

backend/tests/test_channel_state_encoding.py

@@ -22,8 +22,10 @@ def _state_io_calls(filename: str, class_name: str, method_name: str, call_name:
     ("filename", "class_name", "method_name", "call_name"),
     [
         ("store.py", "JsonChannelStore", "_save", "NamedTemporaryFile"),
+        ("discord.py", "DiscordChannel", "_persist_thread_mappings", "write_text"),
         ("runtime_config_store.py", "ChannelRuntimeConfigStore", "_save", "NamedTemporaryFile"),
         ("buzz_seen_events.py", "BuzzSeenEventStore", "_write_snapshot", "NamedTemporaryFile"),
+        ("wechat.py", "WechatChannel", "_save_state", "write_text"),
         ("wechat.py", "WechatChannel", "_save_auth_state", "NamedTemporaryFile"),
     ],
 )
@@ -55,67 +57,3 @@ def test_discord_state_read_is_explicitly_utf8() -> None:
         keywords = {keyword.arg: keyword.value for keyword in call.keywords}
         encoding = keywords.get("encoding")
         assert isinstance(encoding, ast.Constant) and encoding.value == "utf-8"
-
-
-def test_discord_thread_mappings_publish_utf8_lf_bytes(tmp_path: Path) -> None:
-    import threading
-
-    from app.channels.discord import DiscordChannel
-
-    channel = DiscordChannel.__new__(DiscordChannel)
-    channel._thread_store_lock = threading.Lock()
-    channel._active_threads = {"微信:资源": {"thread_id": "thread-讨论"}}
-    channel._thread_store_path = tmp_path / "discord-threads.json"
-
-    channel._persist_thread_mappings()
-
-    text = channel._thread_store_path.read_bytes().decode("utf-8")
-    assert "\r" not in text
-    assert json.loads(text)["微信:资源"]["thread_id"] == "thread-讨论"
-
-
-def test_wechat_cursor_state_publishes_utf8_lf_bytes(tmp_path: Path) -> None:
-    from app.channels.wechat import WechatChannel
-
-    channel = WechatChannel.__new__(WechatChannel)
-    channel._cursor_path = tmp_path / "wechat-cursor.json"
-    channel._get_updates_buf = "游标-1"
-
-    channel._save_state()
-
-    text = channel._cursor_path.read_bytes().decode("utf-8")
-    assert "\r" not in text
-    assert json.loads(text) == {"get_updates_buf": "游标-1"}
-
-
-def _method_calls(filename: str, class_name: str, method_name: str) -> list[ast.Call]:
-    module = ast.parse((CHANNELS / filename).read_text(encoding="utf-8"))
-    owner = next(node for node in module.body if isinstance(node, ast.ClassDef) and node.name == class_name)
-    method = next(node for node in owner.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == method_name)
-    return [node for node in ast.walk(method) if isinstance(node, ast.Call)]
-
-
-@pytest.mark.parametrize(
-    ("filename", "class_name", "method_name"),
-    [
-        ("discord.py", "DiscordChannel", "_persist_thread_mappings"),
-        ("wechat.py", "WechatChannel", "_save_state"),
-    ],
-)
-def test_json_channel_state_writers_publish_through_the_helper(filename: str, class_name: str, method_name: str) -> None:
-    """Platform-independent: the call shape, not just the bytes it happens to emit.
-
-    CI runs with ``PYTHONUTF8=1``, so a regression to ``write_text(...)`` without
-    ``encoding=`` would still produce valid UTF-8 there; only a source-level check
-    catches it on every platform.
-    """
-    calls = _method_calls(filename, class_name, method_name)
-    names = [call.func.attr if isinstance(call.func, ast.Attribute) else call.func.id for call in calls if isinstance(call.func, (ast.Attribute, ast.Name))]
-    assert "publish_bytes_atomically" in names, f"{filename}:{class_name}.{method_name} must publish through the helper"
-
-    for call in calls:
-        if not isinstance(call.func, ast.Attribute) or call.func.attr not in {"write_text", "write_bytes"}:
-            continue
-        keywords = {keyword.arg: keyword.value for keyword in call.keywords}
-        encoding = keywords.get("encoding")
-        assert isinstance(encoding, ast.Constant) and encoding.value == "utf-8", f"{filename}:{call.lineno} writes text without an explicit utf-8 encoding"

backend/tests/test_configured_extensions.py

@@ -37,7 +37,7 @@ def _config(*entries) -> SimpleNamespace:
 
 
 def test_string_entry_still_zero_arg():
-    loaded = load_configured_extension_middlewares(_config(f"{__name__}:ZeroArgMiddleware"), scope="lead")
+    loaded = load_configured_extension_middlewares(_config(f"{__name__}:ZeroArgMiddleware"))
 
     assert len(loaded) == 1
     assert isinstance(loaded[0], ZeroArgMiddleware)
@@ -46,7 +46,7 @@ def test_string_entry_still_zero_arg():
 def test_dict_entry_passes_constructor_kwargs():
     entry = ConfiguredMiddlewareSpec.model_validate({"class": f"{__name__}:RecordingMiddleware", "kwargs": {"max_tool_calls": 3}})
 
-    loaded = load_configured_extension_middlewares(_config(entry), scope="lead")
+    loaded = load_configured_extension_middlewares(_config(entry))
 
     assert len(loaded) == 1
     assert isinstance(loaded[0], RecordingMiddleware)
@@ -54,7 +54,7 @@ def test_dict_entry_passes_constructor_kwargs():
 
 
 def test_raw_dict_entry_passes_constructor_kwargs():
-    loaded = load_configured_extension_middlewares(_config({"class": f"{__name__}:RecordingMiddleware", "kwargs": {"max_tool_calls": 2}}), scope="lead")
+    loaded = load_configured_extension_middlewares(_config({"class": f"{__name__}:RecordingMiddleware", "kwargs": {"max_tool_calls": 2}}))
 
     assert len(loaded) == 1
     assert isinstance(loaded[0], RecordingMiddleware)
@@ -63,13 +63,13 @@ def test_raw_dict_entry_passes_constructor_kwargs():
 
 def test_malformed_raw_dict_fails_at_load():
     with pytest.raises(ValidationError):
-        load_configured_extension_middlewares(_config({"class": f"{__name__}:RecordingMiddleware", "unexpected": "lead"}), scope="lead")
+        load_configured_extension_middlewares(_config({"class": f"{__name__}:RecordingMiddleware", "apply_to": "lead"}))
 
 
 def test_empty_kwargs_matches_zero_arg_constructor():
     entry = ConfiguredMiddlewareSpec.model_validate({"class": f"{__name__}:RecordingMiddleware"})
 
-    loaded = load_configured_extension_middlewares(_config(entry), scope="lead")
+    loaded = load_configured_extension_middlewares(_config(entry))
 
     assert loaded[0].max_tool_calls == 10
 
@@ -78,7 +78,7 @@ def test_unknown_constructor_kwarg_fails_loudly():
     entry = ConfiguredMiddlewareSpec.model_validate({"class": f"{__name__}:ZeroArgMiddleware", "kwargs": {"not_a_param": 1}})
 
     with pytest.raises(TypeError):
-        load_configured_extension_middlewares(_config(entry), scope="lead")
+        load_configured_extension_middlewares(_config(entry))
 
 
 def test_extensions_config_keeps_string_entries():
@@ -106,7 +106,7 @@ def test_extensions_config_parses_class_and_kwargs():
 
 def test_extensions_config_rejects_unknown_entry_fields():
     with pytest.raises(ValidationError):
-        ExtensionsConfig.model_validate({"middlewares": [{"class": "pkg:Middleware", "unexpected": "lead"}]})
+        ExtensionsConfig.model_validate({"middlewares": [{"class": "pkg:Middleware", "apply_to": "lead"}]})
 
 
 def test_extensions_config_rejects_blank_class_path():
@@ -154,7 +154,7 @@ def test_raw_file_round_trips_kwargs_entries(tmp_path, monkeypatch):
     raw = {
         "middlewares": [
             "pkg:Plain",
-            {"class": "pkg:WithArgs", "kwargs": {"max_tool_calls": 5, "token": "$DEERFLOW_TEST_MIDDLEWARE_TOKEN"}, "apply_to": "lead"},
+            {"class": "pkg:WithArgs", "kwargs": {"max_tool_calls": 5, "token": "$DEERFLOW_TEST_MIDDLEWARE_TOKEN"}},
         ]
     }
     config_path.write_text(json.dumps(raw), encoding="utf-8")
@@ -172,5 +172,4 @@ def test_raw_file_round_trips_kwargs_entries(tmp_path, monkeypatch):
     assert dumped["middlewares"][1]["class"] == "pkg:WithArgs"
     assert dumped["middlewares"][1]["kwargs"] == {"max_tool_calls": 5, "token": "$DEERFLOW_TEST_MIDDLEWARE_TOKEN"}
     assert restored.middlewares[1].class_path == "pkg:WithArgs"
-    assert restored.middlewares[1].apply_to == "lead"
     assert restored.middlewares[1].kwargs == {"max_tool_calls": 5, "token": "test-secret"}

backend/tests/test_configured_middleware_scope.py

@@ -1,136 +0,0 @@
-"""Scope selection for operator-configured middleware, through real builders."""
-
-from types import SimpleNamespace
-
-import pytest
-from langchain.agents.middleware import AgentMiddleware
-from pydantic import ValidationError
-
-from deerflow.agents.middlewares.configured_extensions import load_configured_extension_middlewares
-from deerflow.config.app_config import AppConfig
-from deerflow.config.extensions_config import ConfiguredMiddlewareSpec, ExtensionsConfig
-
-
-class ScopedMiddleware(AgentMiddleware):
-    def __init__(self, label="legacy"):
-        self.label = label
-
-
-class BrokenMiddleware(AgentMiddleware):
-    def __init__(self):
-        raise RuntimeError("constructor executed")
-
-
-def _entry(label, scope):
-    return {"class": f"{__name__}:ScopedMiddleware", "kwargs": {"label": label}, "apply_to": scope}
-
-
-def _config(entries):
-    return SimpleNamespace(extensions=ExtensionsConfig.model_validate({"middlewares": entries}))
-
-
-@pytest.mark.parametrize("scope", ["both", "lead", "subagent"])
-def test_scope_survives_config_serialization(scope):
-    config = ExtensionsConfig.model_validate({"middlewares": [_entry("configured", scope)]})
-    restored = ExtensionsConfig.model_validate_json(config.model_dump_json(by_alias=True))
-    assert restored.middlewares[0].apply_to == scope
-    assert restored.middlewares[0].kwargs == {"label": "configured"}
-
-
-@pytest.mark.parametrize("invalid", [None, "", "worker", "LEAD", ["lead"], {}, True, 1])
-def test_invalid_scope_is_rejected_even_for_an_unavailable_class(invalid):
-    with pytest.raises(ValidationError, match="apply_to"):
-        ExtensionsConfig.model_validate({"middlewares": [{"class": "unavailable_module:Middleware", "apply_to": invalid}]})
-
-
-@pytest.mark.parametrize("scope", ["lead", "subagent"])
-def test_legacy_entries_and_order_are_preserved(scope):
-    config = _config(
-        [
-            f"{__name__}:ScopedMiddleware",
-            {"class": f"{__name__}:ScopedMiddleware", "kwargs": {"label": "object-default"}},
-            _entry("lead", "lead"),
-            _entry("both", "both"),
-            _entry("subagent", "subagent"),
-        ]
-    )
-    loaded = load_configured_extension_middlewares(config, scope=scope)
-    expected = ["legacy", "object-default", "lead", "both"] if scope == "lead" else ["legacy", "object-default", "both", "subagent"]
-    assert [mw.label for mw in loaded] == expected
-    again = load_configured_extension_middlewares(config, scope=scope)
-    assert all(first is not second for first, second in zip(loaded, again, strict=True))
-    assert config.extensions.middlewares[2].kwargs == {"label": "lead"}
-
-
-@pytest.mark.parametrize("scope,excluded", [("lead", "subagent"), ("subagent", "lead")])
-@pytest.mark.parametrize("class_path", ["unavailable_module:Middleware", f"{__name__}:BrokenMiddleware"])
-def test_excluded_entries_are_not_imported_or_constructed(scope, excluded, class_path):
-    config = _config([{"class": class_path, "apply_to": excluded}, _entry("selected", scope)])
-    loaded = load_configured_extension_middlewares(config, scope=scope)
-    assert [mw.label for mw in loaded] == ["selected"]
-
-
-@pytest.mark.parametrize("scope", ["lead", "subagent"])
-def test_selected_constructor_failure_still_propagates(scope):
-    config = _config([{"class": f"{__name__}:BrokenMiddleware", "apply_to": scope}])
-    with pytest.raises(RuntimeError, match="constructor executed"):
-        load_configured_extension_middlewares(config, scope=scope)
-
-
-@pytest.mark.parametrize("scope", ["lead", "subagent"])
-@pytest.mark.parametrize("class_path", ["unavailable_module:Middleware", "types:SimpleNamespace"])
-def test_selected_import_and_subclass_failures_still_propagate(scope, class_path):
-    config = _config([{"class": class_path, "apply_to": scope}])
-    with pytest.raises((ImportError, ValueError)):
-        load_configured_extension_middlewares(config, scope=scope)
-
-
-def test_raw_dict_scope_is_validated_before_skipping():
-    raw = {"class": "unavailable_module:Middleware", "apply_to": "subagent", "unexpected": True}
-    config = SimpleNamespace(extensions=SimpleNamespace(middlewares=[raw]))
-    with pytest.raises(ValidationError, match="unexpected"):
-        load_configured_extension_middlewares(config, scope="lead")
-
-
-def test_raw_dict_and_model_entries_are_filtered():
-    config = SimpleNamespace(extensions=SimpleNamespace(middlewares=[_entry("lead", "lead"), ConfiguredMiddlewareSpec.model_validate(_entry("subagent", "subagent"))]))
-    assert [mw.label for mw in load_configured_extension_middlewares(config, scope="lead")] == ["lead"]
-
-
-@pytest.mark.parametrize("scope", ["both", "invalid", None])
-def test_loader_requires_a_concrete_host_scope(scope):
-    with pytest.raises(ValueError, match="scope"):
-        load_configured_extension_middlewares(_config([]), scope=scope)
-
-
-def test_loader_requires_explicit_scope():
-    config = _config([_entry("lead", "lead"), _entry("subagent", "subagent")])
-    with pytest.raises(TypeError, match="required keyword-only argument: 'scope'"):
-        load_configured_extension_middlewares(config)
-
-
-def test_real_lead_and_subagent_builders_select_their_own_scope(tmp_path, monkeypatch):
-    from deerflow.agents.lead_agent.agent import build_middlewares
-    from deerflow.agents.middlewares.tool_error_handling_middleware import build_subagent_runtime_middlewares
-    from deerflow.extensions import get_agent_build_extensions
-
-    monkeypatch.setenv("DEER_FLOW_HOME", str(tmp_path / "runtime"))
-    app_config = AppConfig.model_validate(
-        {
-            "sandbox": {"use": "deerflow.sandbox.local:LocalSandboxProvider"},
-            "models": [],
-            "memory": {"enabled": False},
-            "summarization": {"enabled": False},
-            "extensions": {"middlewares": [_entry("lead", "lead"), _entry("shared", "both"), _entry("subagent", "subagent")]},
-        }
-    )
-    extensions = get_agent_build_extensions()
-    lead = build_middlewares({}, None, app_config=app_config, memory_enabled=False, available_skills=set(), extensions=extensions)
-    subagent = build_subagent_runtime_middlewares(app_config=app_config, available_skills=set(), extensions=extensions)
-    assert [mw.label for mw in lead if isinstance(mw, ScopedMiddleware)] == ["lead", "shared"]
-    assert [mw.label for mw in subagent if isinstance(mw, ScopedMiddleware)] == ["shared", "subagent"]
-    assert next(mw for mw in lead if isinstance(mw, ScopedMiddleware) and mw.label == "shared") is not next(mw for mw in subagent if isinstance(mw, ScopedMiddleware) and mw.label == "shared")
-    for chain in (lead, subagent):
-        configured_end = max(i for i, mw in enumerate(chain) if isinstance(mw, ScopedMiddleware))
-        length_guard = next(i for i, mw in enumerate(chain) if type(mw).__name__ == "ModelLengthFinishReasonMiddleware")
-        assert configured_end < length_guard

backend/tests/test_dev_multi_instance_script.py

@@ -607,47 +607,6 @@ def test_shell_script_rejects_unknown_commands(tmp_path):
     assert "Unknown command" in result.stderr
 
 
-_GATEWAY_LOGS = ("gateway-a.log", "gateway-b.log")
-_NGINX_LOGS = ("nginx.log", "nginx-error.log", "nginx-access.log")
-
-
-@pytest.mark.parametrize(
-    ("args", "expected"),
-    [((), _GATEWAY_LOGS), (("b",), ("gateway-b.log",)), (("nginx",), _NGINX_LOGS), (("all",), _GATEWAY_LOGS + _NGINX_LOGS)],
-    ids=["default", "b", "nginx", "all"],
-)
-def test_shell_script_logs_prints_the_selected_files(tmp_path, args, expected):
-    logs = tmp_path / "state" / "logs"
-    logs.mkdir(parents=True)
-    for name in _GATEWAY_LOGS + _NGINX_LOGS:
-        (logs / name).write_text(f"line from {name}\n", encoding="utf-8")
-    env = {**os.environ, "DEERFLOW_MI_STATE_DIR": str(tmp_path / "state")}
-
-    result = subprocess.run([require_script_bash(), str(SHELL_PATH), "logs", *args], capture_output=True, text=True, timeout=30, env=env)
-
-    assert result.returncode == 0, result.stderr
-    headers = [line.removeprefix("==> ").removesuffix(" <==") for line in result.stdout.splitlines() if line.startswith("==> ")]
-    assert [Path(header).name for header in headers] == list(expected)
-    for name in expected:
-        assert f"line from {name}" in result.stdout
-
-
-@pytest.mark.parametrize(("args", "expected"), [(("all",), _GATEWAY_LOGS), (("nginx",), ())], ids=["all", "nginx"])
-def test_shell_script_logs_skips_nginx_files_when_nginx_never_started(tmp_path, args, expected):
-    # start_nginx bails on a missing binary or busy port, leaving only Gateway logs.
-    logs = tmp_path / "state" / "logs"
-    logs.mkdir(parents=True)
-    for name in _GATEWAY_LOGS:
-        (logs / name).write_text(f"line from {name}\n", encoding="utf-8")
-    env = {**os.environ, "DEERFLOW_MI_STATE_DIR": str(tmp_path / "state")}
-
-    result = subprocess.run([require_script_bash(), str(SHELL_PATH), "logs", *args], capture_output=True, text=True, timeout=30, env=env)
-
-    assert result.returncode == 0, result.stderr
-    headers = [line.removeprefix("==> ").removesuffix(" <==") for line in result.stdout.splitlines() if line.startswith("==> ")]
-    assert [Path(header).name for header in headers] == list(expected)
-
-
 def test_makefile_exposes_harness_targets():
     makefile = (REPO_ROOT / "Makefile").read_text(encoding="utf-8")
 

backend/tests/test_features_router.py

@@ -77,7 +77,6 @@ def test_features_reports_agents_api_enabled() -> None:
     assert response.status_code == 200
     assert response.json() == {
         "agents_api": {"enabled": True},
-        "run_inputs": False,
         "browser_control": {"enabled": False},
         "mcp_tasks": {"enabled": False},
         "subagent_batches": {
@@ -101,7 +100,6 @@ def test_features_reports_agents_api_disabled() -> None:
     assert response.status_code == 200
     assert response.json() == {
         "agents_api": {"enabled": False},
-        "run_inputs": False,
         "browser_control": {"enabled": False},
         "mcp_tasks": {"enabled": False},
         "subagent_batches": {

backend/tests/test_gateway_secret_masking.py

@@ -1,31 +0,0 @@
-"""Shared credential masking used by the MCP and memory config routes."""
-
-import pytest
-
-from app.gateway.secret_masking import MASKED_VALUE, mask_secret_values, normalize_config_key
-
-
-@pytest.mark.parametrize(
-    ("key", "normalized"),
-    [("api_key", "api_key"), ("apiKey", "api_key"), ("APIKey", "api_key"), ("API-Key", "api_key"), ("accessToken", "access_token"), ("X-Api-Key", "x_api_key")],
-)
-def test_normalize_config_key_snake_cases_spellings(key: str, normalized: str) -> None:
-    assert normalize_config_key(key) == normalized
-
-
-def _is_secret(key: str) -> bool:
-    return key in {"api_key", "credentials"}
-
-
-def test_mask_secret_values_masks_at_any_depth_without_mutating() -> None:
-    value = {"api_key": "sk-top", "nested": {"api_key": "sk-nested", "model": "m"}, "items": [{"api_key": "sk-list"}, "plain"], "credentials": {"client_id": "id", "client_secret": "s"}}
-
-    masked = mask_secret_values(value, _is_secret)
-
-    assert masked == {"api_key": MASKED_VALUE, "nested": {"api_key": MASKED_VALUE, "model": "m"}, "items": [{"api_key": MASKED_VALUE}, "plain"], "credentials": MASKED_VALUE}
-    assert value["nested"]["api_key"] == "sk-nested"
-
-
-@pytest.mark.parametrize(("keep_unset", "expected"), [(False, {"api_key": MASKED_VALUE, "credentials": MASKED_VALUE}), (True, {"api_key": None, "credentials": ""})])
-def test_mask_secret_values_keeps_unset_values_only_when_asked(keep_unset: bool, expected: dict) -> None:
-    assert mask_secret_values({"api_key": None, "credentials": ""}, _is_secret, keep_unset=keep_unset) == expected