feat(27-P3C): 批 4 并行执行 + 批 3 复核遗留四条

## 批 4：解除「一家公司同时只有一个 active root run」 - DROP idx_graph_runs_one_active_root（建表块删掉 + 迁移块显式 DROP， CREATE ... IF NOT EXISTS 对存量库不生效） - max_parallel_tasks 从 company.json 调用时读（不是模块加载时快照，否则改配置要重启才生效且不报错）；缺省 1、非法回落 1 并留声、硬上限 20 - 准入判据「从活跃集外进入活跃集」按额度计数 **生死线用 8 个真进程并发抢坑实测**（不是纸面论证）：max=1/2/3/5 四组，每组恰好抢到 max 个、库里活跃数 = max，落选进程各吃 40 次 RunSlotBusyError，零 other 错误。唯一索引没了之后，准入事务是真守卫。 ## 批 3 对抗复核的四条遗留 - N1 🔴 cancelQueuedRun 的前提被批 3 自己的 requeueBlockedRootRun 改没了： queued 的 run 现在可以是跑过一半的。探针实测取消后子 run 残留 paused/stop_requested=0 —— 那条 running 的子 run 继续调 agent 烧 token。改为无条件走 engine.stopRun - L1 ⚠️ 恢复路径对 manual 只兑现一半：注释写着「T1 永远回不来这个后果因此消失」，但调度器故意不碰 manual → 退回队列后没人接。定案：「manual 不自动出队」约束的是首次起跑的授权，已被人亲手起过的不算新授权。判据用 attempt>0 而不是 started_at —— 后者会被 requeue 清成 NULL，恰好在需要它的那一刻是空的（实测踩过） - N2 🟠「退回队列」对用户完全不可见：200 + ok:true + 按钮全灰 + 图消失 + 一句「节点状态一律 pending」的假提示。加 notice 明说 - N3 🟠 isSlotRaceError 把 InvalidTransitionError 当竞态吞掉，而探针证伪了那条注释：被推走时条件更新返回 0 不抛，真正抛它的只有「调用方声明了非法转换」。删掉该分支，让它吵起来四条里三条是同一个模式：注释承诺的前提被本轮自己的改动改没了，注释还留着。文档 §十三.3 / §十四.4 已就这个模式立过两次案，这是第三、四、五次。 ## 文档 §十五实施记录，含 §15.4 一次流程事故：87b776c 由第三方会话在对抗复核完成前误提，提交说明的「1201 用例全绿」压在一份尚未通过复核的代码上。全量：128 文件 / 1240 测试全绿，web:build 通过。 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

feat(27-P3C): 批 4 并行执行 + 批 3 复核遗留四条
## 批 4：解除「一家公司同时只有一个 active root run」 - DROP idx_graph_runs_one_active_root（建表块删掉 + 迁移块显式 DROP， CREATE ... IF NOT EXISTS 对存量库不生效） - max_parallel_tasks 从 company.json 调用时读（不是模块加载时快照，否则改配置要重启才生效且不报错）；缺省 1、非法回落 1 并留声、硬上限 20 - 准入判据「从活跃集外进入活跃集」按额度计数 **生死线用 8 个真进程并发抢坑实测**（不是纸面论证）：max=1/2/3/5 四组，每组恰好抢到 max 个、库里活跃数 = max，落选进程各吃 40 次 RunSlotBusyError，零 other 错误。唯一索引没了之后，准入事务是真守卫。 ## 批 3 对抗复核的四条遗留 - N1 🔴 cancelQueuedRun 的前提被批 3 自己的 requeueBlockedRootRun 改没了： queued 的 run 现在可以是跑过一半的。探针实测取消后子 run 残留 paused/stop_requested=0 —— 那条 running 的子 run 继续调 agent 烧 token。改为无条件走 engine.stopRun - L1 ⚠️ 恢复路径对 manual 只兑现一半：注释写着「T1 永远回不来这个后果因此消失」，但调度器故意不碰 manual → 退回队列后没人接。定案：「manual 不自动出队」约束的是首次起跑的授权，已被人亲手起过的不算新授权。判据用 attempt>0 而不是 started_at —— 后者会被 requeue 清成 NULL，恰好在需要它的那一刻是空的（实测踩过） - N2 🟠「退回队列」对用户完全不可见：200 + ok:true + 按钮全灰 + 图消失 + 一句「节点状态一律 pending」的假提示。加 notice 明说 - N3 🟠 isSlotRaceError 把 InvalidTransitionError 当竞态吞掉，而探针证伪了那条注释：被推走时条件更新返回 0 不抛，真正抛它的只有「调用方声明了非法转换」。删掉该分支，让它吵起来四条里三条是同一个模式：注释承诺的前提被本轮自己的改动改没了，注释还留着。文档 §十三.3 / §十四.4 已就这个模式立过两次案，这是第三、四、五次。 ## 文档 §十五实施记录，含 §15.4 一次流程事故：87b776c 由第三方会话在对抗复核完成前误提，提交说明的「1201 用例全绿」压在一份尚未通过复核的代码上。全量：128 文件 / 1240 测试全绿，web:build 通过。 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
yibo
1 parent 401840b6
Showing 17 changed files with 1676 additions and 234 deletions
docs/todo/system-design/27-p3c-goal-task-model.md
server/routes/company.js
server/routes/graph-run.js
server/services/task-scheduler.js
server/services/work-graph-db.js
server/tests/unit/goal-task-acceptance.test.js
server/tests/unit/goal-task-model.test.js
server/tests/unit/graph-run-route-slot-busy.test.js
server/tests/unit/task-queue-acceptance.test.js
server/tests/unit/task-queue-routes.test.js
server/tests/unit/task-scheduler.test.js
server/tests/unit/task-slots-parallel.test.js
web/src/components/graph-console/GoalTaskPane.vue
web/src/components/graph-console/GraphRunPane.vue
web/src/components/graph-console/NewGoalForm.vue
web/src/components/graph-console/goal-task-model.js
web/src/views/GraphConsole.vue
@@ -2,7 +2,7 @@
 > **所属**: [27 Graph Agent 架构](./27-graph-agent-architecture.md) 的 **P3 收尾**（P3C），直接续 [27-P3/P4 执行控制台](./27-p3-p4-work-graph-console.md) §四.B 与 [27-P3B 真跑跑道](./27-p3b-real-run-runway.md)。
 > **日期**: 2026-08-18
-> **状态**: **批 1、批 2 已实施并全绿**（2026-08-18，见 §十三 / §十四 实施记录）。批 3-5 未开工。开放问题已全部关闭。
+> **状态**: **批 1-4 已实施并全绿**（见 §十三 / §十四 / §十五 实施记录）。批 5 未开工，预研方案已就绪。开放问题已全部关闭。
 > **⚠️ 批次与 phase 的对应不是一一对齐的**，判断「这份能不能搬进 done」时按批看，别按文档名看：
 > · **批 1-3 = 真正的 P3 收尾**（goal/task 两级模型 + `task-planning` + 排队），本文档的主体；
 > · **批 4（并行）归 [27-P4](./27-p4-parallel-and-artifacts.md) §一.3**，那边是设计权威，本文档只服从（见 §五.2 的警示块）；
@@ -983,3 +983,85 @@ grep 确认 `reportRunOutcome` 无其它调用方（连它自己那行 `module.e
 2. **汇报语义是 at-least-once**：exactly-once 要 `/api/agent/task/report` 认幂等键（goal id + 收敛时间），属接收侧改动。
 3. **拆分超时只在本进程存活期间成立**：进程中途被杀会留下 `status='planning'` 的 goal，需要启动时扫描重推（与批 3 的中断恢复一起做）。
 4. `io-model.check.js` 仍是零调用方（同款前科，批 2 已把 `goal-task-model.check.js` 转成真测试）。
+
+---
+
+## 十五、批 3 + 批 4 实施记录（2026-08-19）
+
+> 体例同 §十三 / §十四：**设计正文不改写，只在这里对账；冲突处以本节为准。**
+
+### 15.1 落地了什么
+
+**批 3 · 排队**（commit `87b776c`，**该提交由第三方会话在对抗复核完成前误提，见 §15.4**）
+`run_status='queued'` + `RUN_TRANSITIONS` + `syncRunNodesToDef` + `task-scheduler.js`（tick / sweep /
+依赖推导）+ 入队/取消/rerun 端点 + 控制台队列显示与三处可见性修复。
+
+**批 4 · 并行**（本次）
+`idx_graph_runs_one_active_root` **已 DROP**；`max_parallel_tasks` 从 `company.json` **调用时读**
+（缺省 1、非法回落 1 并留声、硬上限 20）；准入判据「从活跃集外进入活跃集」按额度计数。
+
+全量：**128 文件 / 1240 测试全绿**，`npm run web:build` 通过。
+
+### 15.2 批 4 的生死线：超发（真进程实跑，不是纸面论证）
+
+删掉唯一索引 = 删掉最后一道 DB 兜底，此后全靠 `updateRunStatus` 的准入事务。**用 8 个真 node 进程
+并发抢坑实测**（每进程最多重试 40 次），四组：
+
+| max | 抢到坑的进程 | 库里实际活跃 root run | 判定 |
+|---|---|---|---|
+| 1 | 1 | 1 | ✅ |
+| 2 | 2 | 2 | ✅ |
+| 3 | 3 | 3 | ✅ |
+| 5 | 5 | 5 | ✅ |
+
+落选进程全部吃 `RunSlotBusyError`（各 40 次全被拒），零 `other` 错误。准入的四步缺一不可：
+`BEGIN IMMEDIATE` → 事务内重读 → 事务内计数 → 同事务条件更新。
+
+### 15.3 批 3 复核的 4 条遗留（本次修完）
+
+**N1 🔴 `cancelQueuedRun` 的前提被批 3 自己改没了**
+它的注释说「对一条还没开跑、没有子 run 的排队 run，`stopRun` 是多余的一圈」——
+而 `requeueBlockedRootRun` 落地后，`queued` 的 run **可以是跑过一半的**（有 success 节点、
+有活着的子 run；预算撞顶时引擎只把 root 置 blocked，子 run 要到节点边界才落 paused）。
+探针实测：取消后节点残留 `ready`+`success`、子 run 残留 `paused / stop_requested=0` ——
+**那条 running 的子 run 继续调 agent 烧 token**。改为无条件走 `engine.stopRun`。
+
+**L1 ⚠️ 恢复路径对 manual 只兑现一半**
+`graph-engine.js` 写着「『T1 永远回不来』这个后果因此消失」，但调度器 `filter(execution_mode === 'auto')`
+故意不碰 manual → 人点「启动」→ 退回队列 → 坑空了 → **没人接**。
+定案：**「manual 不自动出队」约束的是首次起跑的授权**；一条已被人亲手起过、因坑满被退回队列的
+manual，授权早就给过了，让它自己接回来是**兑现人刚才那次点击**，不是新授权。
+判据用 **`attempt > 0`** 而不是 `started_at` —— 后者看着更贴切，但 `requeueBlockedRootRun`
+退回队列时会把它清成 NULL，**恰好在需要它的那一刻是空的**（实测踩过）。
+
+**N2 🟠「退回队列」对用户完全不可见**
+`startRunSync` 早返回 200 + `{ok:true, requeued:true}`，而 `GraphRunPane.act()` 只在 `!r.ok` 时写
+`err` → 界面零提示；随后按钮全灰、run 面板换成定义视图、提示语说「节点状态一律 pending」（**假的**）。
+`requeued` 字段全前端零处读取。现加 `notice` 一行明说「已退回队列排队，坑一空会自动接着跑」。
+
+**N3 🟠 `isSlotRaceError` 的判据被探针证伪**
+注释称 `InvalidTransitionError` = 「已被别人从 queued 推走」。实测：被推走时条件更新
+**返回 0、不抛**；真正抛它的只有「**调用方声明了非法转换**」。那一支把调用方的 bug 当竞态吞掉
+且不留日志。已删除该分支（与批 4 删 UNIQUE 那支同一理由：让它吵起来）。
+
+> **4 条里有 3 条是同一个模式：注释承诺的前提被本轮自己的改动改没了，注释还留着。**
+> §十三.3 / §十四.4 已经就这个模式立过两次案，这是第三、四、五次。
+
+### 15.4 一次流程事故：代码在复核完成前被第三方提交
+
+`87b776c` 由另一个会话（`lemonboss-68`）在 16:56 提交，**而批 3 的对抗复核 17:00 才出结果**
+（就是 §15.3 那 4 条）。提交说明里的「1201 用例全绿」准确描述了当时那次测试运行，但它压在一份
+尚未通过复核的代码上，读起来像质量背书。该会话已写交接文档 `27-p3c-batch3-handover.md` 并更正记录。
+
+**教训**：多会话共用同一个 worktree 时，「工作区里的改动」不等于「可以提交的改动」——
+未提交本身可能就是一种状态声明（这里是「在等复核」）。提交前问一句的成本，远低于把一份
+已知有缺陷的代码写进 main 的成本。
+
+### 15.5 留给下一轮
+
+1. **边界守卫会误判并行会话的改动**：它比对整仓 `git status` 差集，那里面**没有「谁写的」这一维**，
+   多会话共用 worktree 时必然把开发会话的改动算到当时在跑的图节点头上（实测已导致一条 run 被判
+   `boundary_escape`）。批 3 修的是这条日志的**可见性**（列出文件清单），**误判本身没修**。
+2. **机器级闸门仍然不存在**：`SessionPool` 没有 `maxSessions`，`task-queue.js` 另有个 `MAX_CONCURRENT=3`
+   抢同一台机器。批 4 只放开了公司级额度（硬上限 20），机器压不压得住没有任何守卫。
+3. 批 5（两套任务体系统一）未开工，预研方案已就绪。
@@ -1207,11 +1207,13 @@ router.post(&#39;/:companyId/org-graph/replan&#39;, (req, res) =&gt; {
 // 但只在 **goal 粒度**复用一次，见 `services/task-settle.js` 与下方缺陷 3 那段注释。
 /**
- * v1 约束：一家公司同时只有一个 active root run（27-P3P4 §一非目标）。
+ * 「这条 root run 占着执行位」的取值域（27-P3P4 §一非目标；批 4 起同时能占几个由
+ * `company.json.max_parallel_tasks` 定，缺省 1 —— 取值域本身没变）。
  *
- * **取值域只有一个持有者**：`work-graph-db.ACTIVE_ROOT_RUN_STATUS` —— 它同时是唯一索引
- * `idx_graph_runs_one_active_root` 的 WHERE 子句、是准入事务数坑的判据、是调度器判「坑空了没」
- * 的判据。本文件以前抄了一份字面量在这里，而 work-graph-db 的注释白纸黑字写着「这里是全仓库
+ * **取值域只有一个持有者**：`work-graph-db.ACTIVE_ROOT_RUN_STATUS` —— 它是准入事务数位子的
+ * 判据、是调度器判「还有没有空位」的判据（批 4 之前它还兼任唯一索引
+ * `idx_graph_runs_one_active_root` 的 WHERE，那条索引已 DROP，判据只剩准入事务这一处）。
+ * 本文件以前抄了一份字面量在这里，而 work-graph-db 的注释白纸黑字写着「这里是全仓库
  * 唯一的定义处」—— **注释是对的、代码没兑现**，正是 §十四.3 第 3 条记着的那个形状。
  * 现在改成取过来。惰性取值（模块加载期 require 会与路由的加载顺序纠缠）。
  */
@@ -1223,9 +1225,9 @@ const activeRootRunStatus = () =&gt; require(&#39;../services/work-graph-db&#39;).ACTIVE_RO
  * = 上面那个活跃集 **+ `blocked`**，而且必须由它派生、不许再抄一份字面量：§九.1 记着的教训就是
  * `ACTIVE_ROOT_RUN_STATUS` 在两个文件里逐字重复，改一处漏一处。
  *
- * 为什么 `blocked` 不直接并进 `ACTIVE_ROOT_RUN_STATUS`：那个常量是
- * `idx_graph_runs_one_active_root` 这条唯一索引的镜像（索引里就没有 blocked），
- * 动它等于悄悄改「一家公司同时只能有一个 active root run」的口径。
+ * 为什么 `blocked` 不直接并进 `ACTIVE_ROOT_RUN_STATUS`：那个常量是**准入事务数位子**的判据
+ * （批 4 之前还兼任唯一索引 `idx_graph_runs_one_active_root` 的 WHERE，索引里就没有 blocked），
+ * 动它等于悄悄改「一条 run 占不占执行位」的口径 —— blocked 的 run 不占位，可以再起别的任务。
  * 但对归档来说 blocked 恰恰**不能**放行：run 转 blocked 会把 task 也写成 blocked，
  * 人加完预算 `POST /api/graph-runs/:id/start` 就接着烧钱，而 task 行仍停在 blocked ——
  * 只看 `task.status === 'running'` 的旧守卫会放行，用户就把一条正在跑的 run 从界面上藏掉了。
@@ -1345,9 +1347,10 @@ function writeTaskGoalArtifact(companyId, rootRunId, payload) {
 //
 // 本批（批 1）只落地同步的那一半：建行 / 改行 / 归档 / 下达即起 run。
 // **排队不在本批**（run_status='queued'、调度器、depends_on 的出队判据都是批 3），
-// **自动拆分也不在**（task-planning 是批 2）。所以这里一次只起得来一条 run，起不来就是 409 ——
-// 与既有唯一索引 idx_graph_runs_one_active_root 的语义保持一致，绝不假装「已排上队」：
+// **自动拆分也不在**（task-planning 是批 2）。所以批 1 一次只起得来一条 run，起不来就是 409 ——
+// 与当时那条唯一索引 idx_graph_runs_one_active_root 的语义一致，绝不假装「已排上队」：
 // 仓库里还没有出队的 worker，排进去的任务不会被消费，那是一条会静默丢任务的路。
+// （批 3 有了调度器之后下达改成入队、不再 409；批 4 DROP 了那条索引，执行位数改为 per-company。）
 /**
  * 数据层的两个专有错误 → HTTP（§四.4 描述冻结 / §六.3 依赖校验）。
@@ -1412,14 +1415,36 @@ function deriveTitle(text) {
   return t.length > 60 ? `${t.slice(0, 60)}…` : t;
 }
-/** 当前占着坑的那条 root run；没有返回 null */
-function activeRootRun(companyId) {
-  const { listCompanyRuns } = require('../services/work-graph-db');
-  return (
-    listCompanyRuns(companyId, { rootOnly: true }).find((r) =>
-      activeRootRunStatus().includes(r.run_status)
-    ) || null
-  );
+/**
+ * 这家公司此刻的执行位：`{ max, used, free, holders }`。
+ *
+ * **形状与判据都不在这里**，取 `routes/graph-run.js` 那唯一一份（它同时供 409 用）。
+ * 批 4 之前这里是 `activeRootRun(companyId)`：`listCompanyRuns(...).find(活跃)`，
+ * 两个调用方各自误用它的一半，max 一放开两处都错：
+ *   · `startNextIfSlotFree` 拿它当「满没满」——它的语义是「有没有」，
+ *     3 个位空着 2 个时 manual 任务永远起不来，端点还照常回「排队中」（写不进去还不报错）；
+ *   · `/tasks/:id/start` 的 409 拿它当「谁挡着我」—— 它取的是 created_at **DESC** 的第一条，
+ *     而 `RunSlotBusyError.heldBy` 是 **ASC**，同一次拒绝的两个字段会指向不同的占位者。
+ */
+function slotsOf(companyId) {
+  return require('./graph-run').slotState(companyId);
+}
+
+/**
+ * 列表端点上给界面的那份执行位快照：`{ max, used, free }`。
+ *
+ * 为什么落在 `GET /goals` 与 `GET /tasks` 上而不是 `GET /graph-runs`：控制台就是靠这两个
+ * 端点轮询左栏的，多一个请求就多一个「两份数据不同时刻」的窗口；而 graph-runs 那边只是列 run，
+ * 在它上面再数一遍 root run 就是第三个持有者（批 4 把它的 canDispatch 删掉正是为此）。
+ *
+ * **holders 不给**：列表页只回答「还能不能下达 / 要不要等」，不需要点名谁占着；
+ * 真被拒绝时 409 会带着 holders 回来（同一个 `slotState` 产出，形状逐字相同）。
+ * 前端 `goal-task-model.readSlots` 也只读这三个数，且**不自己做 `max - used`** ——
+ * free 带着「max 被改小时截断到 0」的语义，减法算不出来。
+ */
+function slotsView(companyId) {
+  const { max, used, free } = slotsOf(companyId);
+  return { max, used, free };
 }
 /** goal 行 → 对外形状。库里是 snake_case，API 一律 camelCase（同 getRunState 口径） */
@@ -1564,8 +1589,8 @@ function isSlotRace(err) {
  * 并把 task 推到 `queued`（27-P3C 批 3 §五.1）。
  *
  * 与批 1/批 2 的 `launchTaskRun` 的差别就是「不起跑」：
- *   · `createRun({runStatus:'queued'})` **不占** `idx_graph_runs_one_active_root` 的坑
- *     （索引的 WHERE 只认 ready/running/paused），所以队列可以任意长，入队永不 409；
+ *   · `createRun({runStatus:'queued'})` **不占执行位**（占位的取值域只认 ready/running/paused，
+ *     见 `activeRootRunStatus`），所以队列可以任意长，入队永不 409；
  *   · 起跑那一跳（queued → ready → running）只有两个执行者：auto 归 `task-scheduler.tick`，
  *     manual 归 `promoteQueuedTask`（人点了「下达 / 入队 / 重跑」才走）。
  *
@@ -1725,36 +1750,65 @@ function abandonRun(runId, why) {
  * 候选顺序取自 `scheduler.listQueue` —— 队列位次（priority → seq → created_at）全仓库
  * 只有那一个持有者，这里再排一遍就是第二个持有者（canDispatch 那次事故的形状）。
  * 队首可能属于**别的 goal**：队列是公司级的，「我下达的是 goal A，起跑的却是 goal B 的活」
- * 正是排队本来的含义，响应里的 started 会如实点名是哪一条。
+ * 正是排队本来的含义，响应里的 started 会如实点名是哪几条。
+ *
+ * 批 4：一次可能起跑**不止一条**（公司有 N 个执行位），所以返回数组。批 3 那两处
+ * 「只报第一条 / 抢不到就不再试下一条」在 max=1 时等价，max>1 时一个漏说、一个漏起。
  *
- * @returns {{runId, run, task}|null} 本次真起跑了哪条；null = 没有（坑被占 / 队里没人够格）
+ * @returns {Array<{runId, run, task}>} 本次真起跑了哪几条（空数组 = 一条都没起）
  */
 function startNextIfSlotFree(companyId) {
   const scheduler = require('../services/task-scheduler');
   const wdb = require('../services/work-graph-db');
   const ticked = scheduler.tick(companyId);
+  const started = [];
-  // **tick 起走的那条同样要报出来。** 少了这一段，auto 模式下 dispatch 明明起跑了一条任务，
+  // **tick 起走的那几条同样要报出来。** 少了这一段，auto 模式下 dispatch 明明起跑了任务，
   // 响应里却没有 `started` —— 前端 `dispatchedTaskId` 于是退回 `queued[0]`，选中态跳到
   // 一条还在排队的任务上，用户点了「全部下达」却看不到正在跑的那张图，而接口回的是 201。
   // 「做了但不说」和「说了没做」是同一类撒谎，都在本批要消灭的名单上。
-  if (ticked.started && ticked.started.length) {
-    const s = ticked.started[0];
+  // 批 4 从 `started[0]` 改成全部：一次 tick 就能填满剩余的 N 个位，只报第一条是同一句谎。
+  for (const s of ticked.started || []) {
     const task = wdb.getTask(s.taskId);
-    if (task) return { runId: s.runId, run: wdb.getRun(s.runId) || {}, task };
+    if (task) started.push({ runId: s.runId, run: wdb.getRun(s.runId) || {}, task });
   }
-  // 坑被占着就到此为止：v1 一次只跑一条（MAX_ACTIVE_ROOT_RUNS）
-  if (activeRootRun(companyId)) return null;
-
   for (const t of scheduler.listQueue(companyId)) {
     // auto 归调度器：这里再抢一次会绕开它「起不来就把 task 收回可见终态」的整套善后
     if (t.execution_mode !== 'manual') continue;
     if (blockersOf(t).length) continue; // 上游没做完，依赖是硬约束
-    // 抢不到就**不再试下一条**：坑只有一个，抢不到说明它已经没了
-    return promoteQueuedTask(t);
-  }
-  return null;
+    // 到这儿才问「还有位吗」，且每一轮都**重算**：刚起跑一条就少一个，而且别人也在抢。
+    // 批 4 之前这里是循环外一句 `if (activeRootRun(companyId)) return null;` ——
+    // 「有没有」当成「满没满」，3 个位空着 2 个时 manual 任务永远起不来，端点却照常回「排队中」。
+    // ponytail: 每轮两次读（活跃 root run 一条查询 + company.json 一次 readFile）。
+    // 两条便宜的过滤排在它前面，所以只有真候选才付这个钱；长队列真成问题时把 free 缓存进循环、
+    // 按起跑数递减即可，别把判据挪到别处去。
+    if (slotsOf(companyId).free <= 0) break;
+    const promoted = promoteQueuedTask(t);
+    if (promoted) started.push(promoted);
+    // 没抢到**不等于没位了**：promoteQueuedTask 把「位满」「被别人推走」「认领失败」都归成 null，
+    // 而后两种下一条照样起得来。真满了由上面那句 free<=0 在下一轮 break —— 判据只留一处。
+  }
+  return started;
+}
+
+/** 起跑了哪条 → 对外形状（三个端点此前各拼了一份，字段还不完全一样） */
+function startedView(s) {
+  return { taskId: s.task.id, goalId: s.task.goal_id, runId: s.runId, runStatus: (s.run || {}).run_status };
+}
+
+/**
+ * 响应里「本次起跑了什么」的两个字段。
+ *
+ * `started` 仍是**单数**——前端 `dispatchedTaskId` 认的就是它，形状与批 3 逐字相同，
+ * 不是破坏性变更；`startedTasks` 是本次起跑的全部。
+ * 两者**同源**：`started = startedTasks[0]`，不是另算一遍，所以分叉不出来。
+ */
+function startedFields(list) {
+  const arr = (Array.isArray(list) ? list : [list]).filter(Boolean);
+  if (!arr.length) return {};
+  const views = arr.map(startedView);
+  return { started: views[0], startedTasks: views };
 }
 /**
@@ -1764,9 +1818,18 @@ function startNextIfSlotFree(companyId) {
  * `task-settle` 把 task 收成 cancelled（`RUN_TO_TASK_STATUS.stopped = 'cancelled'`）——
  * 于是「取消排队」这件事在库里、时间线上、界面上是同一件事，不用在这里再写一遍 task 状态。
  *
- * 不用 `engine.stopRun`：它会先把树上所有 run 置 `stop_requested=1` 再自底向上收，
- * 对一条还没开跑、没有子 run 的排队 run 是多余的一圈；而且它转的是 `fresh.run_status → stopped`，
- * 语义上看不出「这条是从队列里撤下来的」。
+ * ⚠️ **这里原本写着「不用 engine.stopRun：对一条还没开跑、没有子 run 的排队 run 是多余的一圈」，
+ * 那个前提被批 3 自己的 `requeueBlockedRootRun` 改没了。** 恢复类转换撞坑满会把 run 退回队列，
+ * 所以 `run_status='queued'` 的 run **可以是跑过一半的**：有 success 节点、有 ready 节点、
+ * 还可能挂着活着的子 run（预算撞顶时引擎只把 root 置 blocked，子 run 要到节点边界才落 paused，
+ * 也就是父 blocked 时子 run 可以仍在 running）。
+ *
+ * 探针实测过后果：只发一次 `queued → stopped` 的话，root 落 stopped、task 显示「已取消」，
+ * 而那条 running 的子 run **既没收到 stop_requested、也没被 settle，继续调 agent 烧 token**。
+ *
+ * 所以改成无条件走 `engine.stopRun`：它置整棵树的 `stop_requested`、自底向上收敛、
+ * 把 pending/ready 节点 skip 掉。对一条真·空白的排队 run，多出来的那一圈只是几条命中 0 行的
+ * 条件更新 —— **拿这点开销换「绝不留下还在烧钱的子 run」是划算的**。
  *
  * @returns {boolean} true = 本次由我撤下的；false = 它已经不在队里了（被抢跑 / 已撤过）
  */
@@ -1776,10 +1839,10 @@ function cancelQueuedRun(task) {
   if (!runId) return false;
   const run = wdb.getRun(runId);
   if (!run || run.run_status !== 'queued') return false;
-  return Boolean(require('../services/graph-run-sse').transitionRun(runId, 'queued', 'stopped', {}, {
-    summary: `取消排队：queued → stopped（task ${task.id}）`,
-    task_id: task.id,
-  }));
+  // stopRun 内部逐层走 transitionRun（同一个漏斗），所以 timeline / SSE / task-settle 的
+  // 收敛回写照旧；这里只负责把「整棵树」交给它，不再自己发那一条转换。
+  require('../services/graph-engine').stopRun(runId);
+  return Boolean(wdb.getRun(runId) && wdb.getRun(runId).run_status === 'stopped');
 }
 /**
@@ -1787,7 +1850,11 @@ function cancelQueuedRun(task) {
  *
  * `started` 只在**本次请求真的把某条 task 起跑了**时出现，且它可能不是 body 里那条
  * （队首属于别的 goal 时）—— 前端 `dispatchedTaskId` 认的就是它。
+ * 批 4 起一次可能起跑多条（N 个执行位），全部在 `startedTasks` 里，`started` = 它的第一条。
  * `queuePosition` 一律现算（`task-scheduler.queuePosition`），起跑了的那条不在队里 → null。
+ *
+ * @param {Array|object|null} started `startNextIfSlotFree` 的返回值（数组），
+ *   或 `promoteQueuedTask` 的单条返回值 —— `startedFields` 两种都收。
  */
 function queueReply(companyId, task, started) {
   const { queuePosition } = require('../services/task-scheduler');
@@ -1801,9 +1868,7 @@ function queueReply(companyId, task, started) {
     runId,
     status: fresh.status,
     queuePosition: queuePosition(companyId, fresh.id) || null,
-    ...(started
-      ? { started: { taskId: started.task.id, goalId: started.task.goal_id, runId: started.runId, runStatus: started.run.run_status } }
-      : {}),
+    ...startedFields(started),
     ...(runId ? { links: runLinks(runId) } : {}),
   };
 }
@@ -2089,7 +2154,7 @@ router.get(&#39;/:companyId/goals&#39;, (req, res) =&gt; {
     const goals = wdb.listCompanyGoals(companyId, { status: req.query.status || null, includeArchived });
     if (req.query.withTasks !== '1' && req.query.withTasks !== 'true') {
-      return res.json({ goals: goals.map((g) => goalView(g)) });
+      return res.json({ goals: goals.map((g) => goalView(g)), slots: slotsView(companyId) });
     }
     const tasks = wdb.listCompanyTasks(companyId, { includeArchived });
@@ -2111,6 +2176,7 @@ router.get(&#39;/:companyId/goals&#39;, (req, res) =&gt; {
             .map((t) => taskView(t, progress.get(t.current_run_id), positions))
         )
       ),
+      slots: slotsView(companyId),
     });
   } catch (err) {
     console.error('[TaskEntry] Error:', err.message);
@@ -2323,13 +2389,14 @@ router.patch(&#39;/:companyId/goals/:goalId&#39;, (req, res) =&gt; {
 /**
  * POST /api/company/:companyId/goals/:goalId/dispatch — 下达这个 goal
  *
- * **批 1 的语义 = 下达即执行，不入队**：给 goal 盖上 dispatched_at（描述从此冻结），
- * 然后按 seq 起**第一条上游就绪的** draft task 的 run。其余 draft 原地不动，响应里如实列出来。
+ * **现在的语义（批 3 起）= 下达即入队**：给 goal 盖上 dispatched_at（描述从此冻结），
+ * 把它下面**所有** draft task 入队，再推一次队伍（见下方 startNextIfSlotFree）；
+ * 起跑了哪几条如实写在响应的 `started` / `startedTasks` 里。
  *
- * 为什么不是「全部入队」：v1 一家公司同时只有一个 active root run（唯一索引
- * idx_graph_runs_one_active_root），而出队的 worker 是批 3 才有的东西。把 N 条都标成
- * 「已入队」而没有任何东西会把它们推走，就是把「静默丢任务」写进数据 —— 宁可让用户看到
- * 「还有 2 条待下达」，也不要给一个不兑现的承诺。
+ * 批 1 的语义是「只起第一条上游就绪的，其余原地不动」，理由是：当时一家公司同时只有一个
+ * active root run（唯一索引 idx_graph_runs_one_active_root），而出队的 worker 是批 3 才有的
+ * 东西 —— 把 N 条都标成「已入队」而没有任何东西会把它们推走，就是把「静默丢任务」写进数据。
+ * 批 3 有了调度器，这条理由消失；批 4 DROP 了那条索引，执行位数改为 per-company。
  *
  * **依赖是硬约束**（缺陷 F6 + 第二轮复核 缺陷 4）：绝不起一条上游没跑完的 task ——
  * 「接口收下了 depends_on、返回成功、随后无声地违反它」比不支持依赖更糟：用户设了
@@ -2363,8 +2430,8 @@ router.post(&#39;/:companyId/goals/:goalId/dispatch&#39;, (req, res) =&gt; {
     // ⚠️ **这里以前有一道「公司已有 active root run → 409」的预检查，批 3 删掉了它** ——
     // 那正是本批要消灭的东西：下达不再因为「有别的任务在跑」被拒绝，而是排队。
-    // 并发下真正的守卫仍在（`updateRunStatus` 的准入事务 + 唯一索引），只是它现在守的是
-    // **出队**那一跳，不是入队。入队永不因坑满失败：queued 的 run 不占坑。
+    // 并发下真正的守卫仍在（`updateRunStatus` 的准入事务；批 4 DROP 掉唯一索引之后它是唯一那道），
+    // 只是它守的是**出队**那一跳，不是入队。入队永不因位满失败：queued 的 run 不占执行位。
     //
     // 同样删掉的还有「挑第一条跑得动的 draft、全都跑不动就 409」那一段。§六.2 写的是
     // 「把该 goal 下**所有** draft task 入队」—— 有了队列，依赖没就绪不再是拒绝的理由，
@@ -2396,13 +2463,12 @@ router.post(&#39;/:companyId/goals/:goalId/dispatch&#39;, (req, res) =&gt; {
       goalStatus: dispatchedGoal.status,
       // 本次入队的全部 task 及其位次。起跑了的那条不在队里 → position 为 null（不是 0）
       queued: enqueued.map((e) => ({ taskId: e.task.id, runId: e.runId, queuePosition: positions.get(e.task.id) || null })),
-      // `started` 只在本次请求真的把某条 task 起跑了时出现，**且它未必是本次入队的那几条**：
-      // 队列是公司级的，坑空时顶上来的可能是别的 goal 早就排着的活。前端 dispatchedTaskId
-      // 认的就是它 —— 如实点名比假装「你下达的那条起跑了」有用。
-      ...(started
-        ? { started: { taskId: started.task.id, goalId: started.task.goal_id, runId: started.runId, runStatus: started.run.run_status } }
-        : {}),
-      ...(started ? { links: runLinks(started.runId) } : {}),
+      // `started` / `startedTasks` 只在本次请求真的把 task 起跑了时出现，**且未必是本次入队的那几条**：
+      // 队列是公司级的，位子空时顶上来的可能是别的 goal 早就排着的活。前端 dispatchedTaskId
+      // 认的就是 `started` —— 如实点名比假装「你下达的那条起跑了」有用。
+      // 批 4：公司有 N 个执行位时一次能起跑多条，全在 `startedTasks` 里（`started` = 它的第一条）。
+      ...startedFields(started),
+      ...(started.length ? { links: runLinks(started[0].runId) } : {}),
     });
   } catch (err) {
     console.error('[TaskEntry] Error:', err.message);
@@ -2511,7 +2577,10 @@ router.get(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
     });
     const progress = progressOf(tasks);
     const positions = queuePositions(req.params.companyId);
-    res.json({ tasks: tasks.map((t) => taskView(t, progress.get(t.current_run_id), positions)) });
+    res.json({
+      tasks: tasks.map((t) => taskView(t, progress.get(t.current_run_id), positions)),
+      slots: slotsView(req.params.companyId),
+    });
   } catch (err) {
     console.error('[TaskEntry] Error:', err.message);
     res.status(500).json({ error: err.message });
@@ -2572,7 +2641,7 @@ router.post(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
     // ⚠️ **这里以前有一道「公司已有 active root run → 409」的预检查，批 3 删掉了它。**
     // 这条 409 就是本批要消灭的那个东西：外部 agent 的 curl（URL 与请求体写在 tools-base.md 里，
     // 等于所有 agent 的提示词）撞上它只能自己重试或放弃。现在改成入队 —— 建一条
-    // `run_status='queued'` 的 root run，它**不占**唯一索引的坑，所以入队永不失败。
+    // `run_status='queued'` 的 root run，它**不占**执行位，所以入队永不失败。
     const createdBy = body.created_by || body.from || 'human';
     let goal;
     if (body.goal_id) {
@@ -2601,7 +2670,7 @@ router.post(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
         description,
         executionMode: mode,
         priority: body.priority || goal.priority,
-        // 落库（缺陷 F3）：本次起不来 run 时（唯一索引 409）这行就是草稿，hint 让用户稍后
+        // 落库（缺陷 F3）：本次起不来 run 时（批 3 之前是 409，现在是排队）这行就是草稿，hint 让用户稍后
         // dispatch —— 那时请求体早没了，不存下来 dispatch 只能用默认额度，而用户以为自己填的算数。
         budgetJson: body.budget !== undefined ? body.budget : null,
         // 显式传 report_to 优先，其次继承 goal 的（数据层也会兜一次，这里传的是本次请求的意图）
@@ -2641,9 +2710,9 @@ router.post(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
       task: description,
       taskGoalArtifact: path.relative(REPO_ROOT, launched.artifact),
       budget: body.budget || DEFAULT_TASK_BUDGET,
-      ...(started && started.task.id !== taskRow.id
-        ? { started: { taskId: started.task.id, goalId: started.task.goal_id, runId: started.runId } }
-        : {}),
+      // 本次这条已经在上面逐字报过了（runId / status / runStatus），这里只报**别人**：
+      // 顶上来的可能是别的 goal 早就排着的活，一次可能不止一条（批 4 的 N 个执行位）。
+      ...startedFields(started.filter((s) => s.task.id !== taskRow.id)),
       links: runLinks(launched.runId),
     });
   } catch (err) {
@@ -2825,20 +2894,24 @@ router.post(&#39;/:companyId/tasks/:taskId/start&#39;, (req, res) =&gt; {
     // 别回 200 让界面显示「已开始」而实际什么都没跑。
     const started = promoteQueuedTask(task);
     if (!started) {
-      const active = activeRootRun(companyId);
+      // 「位子满了」和「这一瞬间被别人推走了」是两件事，答复也不同。
+      // 判据与形状都取 graph-run.js 的 slotState（= 409 run-slot-busy 那一份）：
+      // 批 4 之前这里自己 `.find()` 一条 active run + 三个单数字段，
+      // N 个执行位时只点名一条，用户停掉它之后发现还是起不来（其余的位仍占着）。
+      const slots = slotsOf(companyId);
+      const busy = slots.free <= 0;
+      const { slotBusyHint } = require('./graph-run');
       return res.status(409).json({
-        error: active
-          ? `公司 ${companyId} 的执行坑被 run ${active.id} 占着，这条还得排着`
+        error: busy
+          ? `公司 ${companyId} 的执行位已满（${slots.used}/${slots.max}），这条还得排着`
           : `task ${task.id} 这一瞬间被别人推走了，没抢到`,
+        // 与 graph-run.js 的 409 逐字同形（reason / active / max / holders），
+        // 免得同一件事在两个端点上有两套字段名
+        ...(busy ? { reason: 'run-slot-busy', active: slots.used, max: slots.max, holders: slots.holders } : {}),
         queuePosition: require('../services/task-scheduler').queuePosition(companyId, task.id) || null,
-        ...(active ? { activeRunId: active.id, activeTaskId: active.task_id, activeRunStatus: active.run_status } : {}),
-        // 「先停掉」这句只在它此刻真停得掉时给：占坑的那条可能还在 ready，
-        // 而 /stop 的可用条件里没有 ready —— 照着做就是一个 400（判据取自 graph-run.js 那一份）
-        hint: active
-          ? (require('./graph-run').STOPPABLE_RUN_STATUS.includes(active.run_status)
-            ? `等它收敛，或先停掉：POST /api/graph-runs/${active.id}/stop`
-            : `等它收敛（它现在是 ${active.run_status}，还停不掉）`)
-          : '刷新后重试',
+        // 「先停掉」这句只在它此刻真停得掉时给：占位的那条可能还在 ready，
+        // 而 /stop 的可用条件里没有 ready —— 照着做就是一个 400（判据在 slotBusyHint 里，只此一份）
+        hint: busy ? slotBusyHint(slots) : '刷新后重试',
       });
     }
     res.status(201).json(queueReply(companyId, started.task, started));
@@ -18,7 +18,7 @@
  *   400 { error, op, runStatus, allowed }             操作在当前 run_status 下不可用（非法状态转换，明确说清）
  *   400 { error, scope, from, to }                    引擎抛 InvalidTransitionError
  *   400 { error }                                     入参不合法
- *   409 { error, reason:'run-slot-busy', holders, hint } 公司的执行坑被别人占着（引擎抛 RunSlotBusyError）
+ *   409 { error, reason:'run-slot-busy', active, max, holders, hint } 公司的执行位已满（引擎抛 RunSlotBusyError）
  *   500 { error }                                     其它
  */
@@ -35,6 +35,8 @@ const {
   listLoopRecords,
   edgeContracts,
   findFiles,
+  listActiveRootRunIds,
+  maxActiveRootRuns,
   InvalidTransitionError,
   RunSlotBusyError,
 } = require('../services/work-graph-db');
@@ -82,27 +84,19 @@ function sendError(res, err) {
   // （「导出了、零人使用」是这个仓库反复立案的惯犯）。全仓 work-graph-db 只有相对路径
   // require，同一个模块实例，instanceof 成立。
   if (err instanceof RunSlotBusyError) {
-    const holders = slotHolders(err);
-    const first = holders[0] || null;
+    const slots = slotState(err.companyId, err);
     return res.status(409).json({
       error: err.message,
       reason: 'run-slot-busy',
       companyId: err.companyId,
       runId: err.runId, // 想进活跃集却被挡住的那条（= 本次操作的对象）
-      active: err.active,
-      max: err.max,
+      active: slots.used,
+      max: slots.max,
       // 「挡我的是谁」：没有它，用户只知道「坑满」，无从判断该等谁、该停谁。
-      // 数组而不是单数：max 今天恒为 1，批 4 放开并行之后这里会有多条，
-      // 那时改形状就是又一次前端跟着改的破坏性变更。
-      holders,
-      // 「先停掉它」这句只在**它此刻真的停得掉**时才给：ready 的 run 不在 STOPPABLE_RUN_STATUS
-      // 里，对它写 /stop 就是又一条指向不存在行为的提示（打过去 400）。
-      hint: first
-        ? `坑被 run ${first.runId}${first.taskId ? `（task ${first.taskId}）` : ''} 占着，等它收敛后重试；`
-          + (STOPPABLE_RUN_STATUS.includes(first.runStatus)
-            ? `不想等就先停掉它：POST /api/graph-runs/${first.runId}/stop`
-            : `它现在是 ${first.runStatus}，还停不掉（/stop 只认 ${STOPPABLE_RUN_STATUS.join(' / ')}），马上就会开跑`)
-        : '坑刚刚才空出来（占坑的那条已经收敛），直接重试本次操作即可',
+      // 数组而不是单数：批 4 放开并行之后这里真的会有多条（max = 该公司的
+      // company.json.max_parallel_tasks），形状从批 3 起就按多条写好了，这次没动。
+      holders: slots.holders,
+      hint: slotBusyHint(slots),
     });
   }
@@ -110,22 +104,57 @@ function sendError(res, err) {
 }
 /**
- * 「谁占着坑」→ 可读的行。
+ * 「这家公司此刻的执行位」→ `{ max, used, free, holders }`。**这个形状全仓库只有这一份**，
+ * `routes/company.js` 的 409 也从这里取（它以前自己 `.find()` 一条 active run 再拼三个
+ * 单数字段，那就是第二个持有者：批 4 之后两处会各自指向不同的占位者，因为
+ * `activeRootRun` 取 created_at **DESC** 的第一条、准入事务给的 heldBy 是 **ASC**）。
  *
- * 首选 `err.heldBy`：那是准入事务在 BEGIN IMMEDIATE 里**当场**数出来的 run id，
- * 比事后再查一次准（等 HTTP 响应写出去时，占坑的那条可能已经换人了）。
- * 只有 heldBy 为空 / 那几行已经不在时才回落到查询，取值域用本文件的 ACTIVE_ROOT_RUN_STATUS
- * （与唯一索引逐字一致的那一份），不在这里再写一遍 ——
- * canDispatch 那次事故就是取值域被第二个持有者复述了一遍。
+ * 三样东西各有唯一来源，这里一样都不重算：
+ *   · 取值域（哪些 run_status 算占位）= `work-graph-db.listActiveRootRunIds` 那条 WHERE。
+ *     本文件以前抄过一份 `new Set([...])` 做回落查询 —— 那正是 canDispatch 事故的形状，已删；
+ *   · 额度 = `work-graph-db.maxActiveRootRuns(companyId)`（读 company.json 的
+ *     max_parallel_tasks，缺省 1）。**不在这里写第二个默认值**；
+ *   · 拒绝当下的实况优先用 `err.heldBy / err.active / err.max` —— 那是准入事务在
+ *     BEGIN IMMEDIATE 里**当场**数出来的，比事后再查一次准（等 HTTP 响应写出去时，
+ *     占位的那条可能已经换人了）。只有 heldBy 空 / 那几行已经不在时才回落到查询，
+ *     于是「执行位刚刚才空出来」这条 hint 仍然给得出来。
+ *
+ * @param {string} companyId
+ * @param {RunSlotBusyError} [err] 有它就用它当场测的那一份
  */
-function slotHolders(err) {
-  const view = (r) => ({ runId: r.id, taskId: r.task_id, goalId: r.goal_id, runStatus: r.run_status });
-  const named = (Array.isArray(err.heldBy) ? err.heldBy : []).map((id) => getRun(id)).filter(Boolean);
-  if (named.length) return named.map(view);
-  if (!err.companyId) return [];
-  return listCompanyRuns(err.companyId, { rootOnly: true })
-    .filter((r) => ACTIVE_ROOT_RUN_STATUS.has(r.run_status))
-    .map(view);
+function slotState(companyId, err = null) {
+  const view = (id) => {
+    const r = getRun(id);
+    return r ? { runId: r.id, taskId: r.task_id, goalId: r.goal_id, runStatus: r.run_status } : null;
+  };
+  const named = (err && Array.isArray(err.heldBy) ? err.heldBy : []).map(view).filter(Boolean);
+  const holders = named.length || !companyId
+    ? named
+    : listActiveRootRunIds(companyId).map(view).filter(Boolean);
+  const max = err && Number.isInteger(err.max) ? err.max : maxActiveRootRuns(companyId);
+  const used = err && Number.isInteger(err.active) ? err.active : holders.length;
+  return { max, used, free: Math.max(0, max - used), holders };
+}
+
+/**
+ * 执行位满时那句「现在该干什么」。
+ *
+ * 两条规矩没变，只是从「唯一那条占位者」推广到 N 条：
+ *   · 「先停掉它」只在**它此刻真的停得掉**时才给 —— ready 的 run 不在 STOPPABLE_RUN_STATUS 里，
+ *     对它写 /stop 就是又一条指向不存在行为的提示（打过去 400）；
+ *   · 一条都停不掉时明说原因，别让人照着一条必然失败的路走一遍。
+ * N 条时列出**所有**停得掉的那几条：只点名第一条，用户停掉它发现还是起不来（其余仍占着位）。
+ */
+function slotBusyHint({ used, max, holders }) {
+  if (!holders.length) return '执行位刚刚才空出来（占位的那条已经收敛），直接重试本次操作即可';
+  const who = holders
+    .map((h) => `run ${h.runId}${h.taskId ? `（task ${h.taskId}）` : ''}`)
+    .join('、');
+  const stoppable = holders.filter((h) => STOPPABLE_RUN_STATUS.includes(h.runStatus));
+  const head = `执行位已满（${used}/${max}），占位的是 ${who}，等其中任一条收敛后重试；`;
+  return head + (stoppable.length
+    ? `不想等就先停掉其中一条：${stoppable.map((h) => `POST /api/graph-runs/${h.runId}/stop`).join(' 或 ')}`
+    : `它们现在都还停不掉（/stop 只认 ${STOPPABLE_RUN_STATUS.join(' / ')}），马上就会开跑`);
 }
 /** 取 run，不存在直接回 404 并返回 null（调用方 return 掉即可） */
@@ -428,34 +457,25 @@ router.get(&#39;/:id/stream&#39;, (req, res) =&gt; {
 /**
  * GET /api/company/:companyId/graph-runs — 某公司的 run 列表
- * query: rootOnly=1 只列 root run（v1 一家公司同时只有一个 active root run，见 §一非目标）
+ * query: rootOnly=1 只列 root run
  * 公司无 run 时返回空数组，不报错（与 GET /api/company/:cid/org-graph 的处理一致）。
- */
-/**
- * 「同一 company 只允许一个 active root run」的取值域。
  *
- * **不在这里写字面量**：唯一持有者是 `work-graph-db.ACTIVE_ROOT_RUN_STATUS` —— 它同时是
- * 唯一索引 `idx_graph_runs_one_active_root` 的 WHERE、是准入事务数坑的判据、是调度器判
- * 「坑空了没」的判据。本文件以前抄了一份 `new Set([...])`，那就是第二个持有者：
- * canDispatch 那次事故（前端复述取值域还多写一个 blocked，公司失败一次后再也下不了任务）
- * 就是这个形状。**注意 blocked 不在里面** —— blocked 的 run 不占坑，可以再下一个任务。
+ * ⚠️ **批 4 删掉了 `canDispatch` / `activeRootRunId` 两个字段**，没有换成 `slots`。
+ * 理由（§九.4quater 的规矩：零消费方的字段要么接上要么删掉）：
+ *   · 两个字段自批 2 起就**零消费方** —— 全仓只剩注释在引用它们当反面教材，
+ *     `GraphConsole.vue` 的 loadRuns 只取 `j.runs`，用例一条都没断言过它们；
+ *   · 它们的判据在批 4 之后必然**算错**：`canDispatch: !activeRoot` 的含义是「一个都不许有」，
+ *     而 max=3 的公司占了 1 个位照样能下达。留着 = 一个没人读、还回错值的字段；
+ *   · 换成 `slots:{max,used,free}` 就是把同一个事实**第三次**摊到 HTTP 上
+ *     （409 的 `{active,max,holders}` 已经是权威形状），而且同样零消费方。
+ *     真要给界面画并发，落点是随 taskView 一起给的那一份（与 409 同源，见 slotState），
+ *     不是在这个「列 run」的端点上把 root run 再数一遍。
  */
-const ACTIVE_ROOT_RUN_STATUS = new Set(
-  require('../services/work-graph-db').ACTIVE_ROOT_RUN_STATUS
-);
-
 companyRouter.get('/:companyId/graph-runs', h((req, res) => {
   const rootOnly = req.query.rootOnly === '1' || req.query.rootOnly === 'true';
-  const runs = listCompanyRuns(req.params.companyId, { rootOnly });
-  // canDispatch 由**服务端**算：前端此前自己复述了一份取值域并且多写了一个 blocked，
-  // 于是一家公司只要失败过一次，控制台上就再也下不了第二个任务（后端其实放行）。
-  // 规则只留一处，前端照抄结果即可（P3B 第三次真跑发现）。
-  const activeRoot = runs.find((r) => !r.parent_run_id && ACTIVE_ROOT_RUN_STATUS.has(r.run_status));
   res.json({
     companyId: req.params.companyId,
-    runs,
-    canDispatch: !activeRoot,
-    activeRootRunId: activeRoot ? activeRoot.id : null,
+    runs: listCompanyRuns(req.params.companyId, { rootOnly }),
   });
 }));
@@ -463,3 +483,8 @@ module.exports = router;
 module.exports.companyRouter = companyRouter;
 // company.js 的 409 hint 要照它判「这条 run 现在停不停得掉」（理由见常量注释）
 module.exports.STOPPABLE_RUN_STATUS = STOPPABLE_RUN_STATUS;
+// 「执行位」的形状与那句下一步：company.js 的 POST /tasks/:id/start 与 startNextIfSlotFree
+// 都用这两个，别在那边再写一份（批 4 之前那边是 `.find(active)` + 三个单数字段，
+// 与这里的 holders[] 各说各话）。
+module.exports.slotState = slotState;
+module.exports.slotBusyHint = slotBusyHint;
@@ -5,12 +5,13 @@
  *
  * 它把 v1 那条硬约束从「拒绝」改成「排队」：
  *   下达任务时不再因为「公司已有 active root run」吃 409，而是建一条 `run_status='queued'`
- *   的 run（不占唯一索引的坑）+ 一条 `status='queued'` 的 task；坑一空，这里把它拉起来。
+ *   的 run（不占执行坑）+ 一条 `status='queued'` 的 task；坑一空，这里把它拉起来。
  *
  * 三件事必须一起成立，少一件排队就是「静默丢任务」（正是当初否决排队的那条理由）：
  *   1. **出队是原子的** —— `updateRunStatus(runId,'queued','ready')` 一条 CAS，且「数坑 + 占坑」
  *      整段包在 `BEGIN IMMEDIATE` 里（守卫在 `updateRunStatus`，不在这里 —— 能把 root run
- *      推进活跃集的路径有 6 条，枚举一次漏一次）；`idx_graph_runs_one_active_root` 留作兜底；
+ *      推进活跃集的路径有 6 条，枚举一次漏一次）。批 4 DROP 掉了 `idx_graph_runs_one_active_root`
+ *      那道 DB 兜底，那个事务从此是**唯一**的守卫；
  *   2. **触发不靠枚举** —— 挂在 `graph-run-sse.transitionRun` 这个唯一漏斗上
  *      （`stopRun` 与「预算耗尽 → blocked」都不走 `settleRun`，枚举一次漏一次）；
  *   3. **躺在队里的任务不许假装在排队** —— 依赖已不可能满足的，就地推导成 blocked 并写明原因。
@@ -19,11 +20,13 @@
  */
 /**
- * 并行度上限的唯一持有者在 `work-graph-db.MAX_ACTIVE_ROOT_RUNS`（挨着唯一索引与准入事务）。
- * 这里**不重新写一个 1** —— 两个持有者迟早分叉，那正是 `canDispatch` 那次事故的形状。
+ * 并行度上限的唯一持有者在 `work-graph-db.maxActiveRootRuns(companyId)`（挨着准入事务）。
+ * 这里**不重新写一个默认值、也不缓存** —— 两个持有者迟早分叉，那正是 `canDispatch`
+ * 那次事故的形状。批 4 起它是 per-company 的（读 company.json.max_parallel_tasks），
+ * 所以签名必须带 companyId：一个无参的 getter 表达不了 per-company，只会变成又一个假上限。
  * 惰性取值（模块加载期 require work-graph-db 会成环）。
  */
-const maxParallelTasks = () => wdb().MAX_ACTIVE_ROOT_RUNS;
+const maxParallelTasks = (companyId) => wdb().maxActiveRootRuns(companyId);
 /**
  * 依赖「已经死了」的上游状态。
@@ -127,7 +130,7 @@ function queuePosition(companyId, taskId) {
 /**
  * 当前占着坑的 root run 数。
  *
- * 计数 SQL 本身在 `work-graph-db.countActiveRootRuns`（与唯一索引、与准入事务同源），
+ * 计数 SQL 本身在 `work-graph-db.countActiveRootRuns`（与准入事务的判据同源），
  * 这里只是取来用 —— 调度器这一份**只是给界面看的快照**，不是准入判据：
  * 真正决胜的是 `updateRunStatus` 里那个 BEGIN IMMEDIATE 的事务（见下方第 3 步注释）。
  */
@@ -208,7 +211,7 @@ function abandonRun(runId, why) {
  * 调度一次（§五.1 六步）。**绝不 throw**：它挂在状态转换的尾巴上，抛出去会把一次正常的
  * run 收敛也带崩（调用方拿到异常，但状态和 SSE 事件已经发出去了）。
  *
- * @returns {{companyId:string, skipped?:string, started:object[], blocked:object[], requeued:string[], active?:number}}
+ * @returns {{companyId:string, skipped?:string, started:object[], blocked:object[], requeued:string[], active?:number, max?:number}}
  */
 function tick(companyId) {
   if (!companyId) return { companyId, skipped: 'no-company', started: [], blocked: [], requeued: [] };
@@ -240,23 +243,41 @@ function tickInner(companyId) {
   //    队列可以变（另一个进程/另一次 tick），check-then-act 在这里天然不成立。
   //    权威判据在 `updateRunStatus` 的准入事务里（BEGIN IMMEDIATE 内数坑 + 占坑一步做完），
   //    坑被抢走时它抛 RunSlotBusyError，由 5c 的 catch + isRaceError 当成「这轮没抢到」。
-  //    ponytail: max 恒为 1（批 3 只做排队）；读 company.json.max_parallel_tasks 与
-  //    DROP 唯一索引一起归批 4 / 27-P4。
-  const max = maxParallelTasks();
+  //    批 4 起 max 是 per-company 的（company.json.max_parallel_tasks，缺省 1）。
+  const max = maxParallelTasks(companyId);
   const active = activeRootRunCount(companyId);
   const started = [];
-  if (active >= max) return { companyId, skipped: 'no-slot', active, started, blocked, requeued };
+  if (active >= max) return { companyId, skipped: 'no-slot', active, max, started, blocked, requeued };
   // 4. 选候选：queued + 依赖全 completed + auto。
   //    manual **不参与自动出队**（§五.2bis）：startRun(manual) 只点亮入口节点就停下等 /next，
   //    而那时 run 已经是 running、占着坑 —— 没人点「下一步」它就把后面所有任务无限期堵死，
   //    而队列界面上看不出任何异常。manual 只能由人在控制台上显式点「开始」。
+  //
+  //    **不 slice**：批 3 这里是 `.slice(0, max - active)`，用的是「候选数 = 能起的条数」这个
+  //    在 max=1 时看不出错的假设 —— 只要队首那条起跑失败（5a 缺 run 行 / 5d 认领失败），
+  //    这一轮就白跑，空着的坑要等下一次钩子或 60s sweep 才被填上。max>1 时这类空转会成倍出现。
+  //    改成按**真的起来了几条**收敛：循环里自己数，坑满就 break。
+  //    ⚠️ **但 `started_at` 非空的 manual 要放进来**（批 3 复核 L1）：
+  //    「manual 不自动出队」约束的是**首次起跑的授权** —— 人要盯着一步步推，不该半夜被自动拉起。
+  //    而一条**已经被人亲手启动过**、跑到一半因为坑满被 `admitOrRequeue` 退回队列的 manual 任务，
+  //    授权早就给过了；让它自己接回来不是新授权，是**把人刚才那次点击兑现掉**。
+  //    不放进来的后果实测过：人点「启动」→ 退回队列 → 坑空了 → **没人接**，任务躺着、
+  //    sweep 每 60s 空转，而 `graph-engine.js` 那句「『T1 永远回不来』这个后果因此消失」
+  //    对 manual 根本不成立 —— 又一条只兑现一半的注释。
+  //    判据用 **`attempt > 0`** 而不是 `started_at`：后者看着更贴切，但
+  //    `requeueBlockedRootRun` 退回队列时会把 `started_at` 清成 NULL（它记的是「本次尝试何时开跑」，
+  //    退回队列后本次尝试就没了），于是那个字段恰好在我需要它的那一刻是空的 —— 实测踩过。
+  //    `attempt` 由 `claimQueuedTask` 每次认领 +1、退回队列时不清，它才是「这条被人起过没有」的事实。
   const candidates = listQueue(companyId)
-    .filter((t) => t.execution_mode === 'auto' && dependenciesSatisfied(t))
-    .slice(0, max - active);
+    .filter((t) => (t.execution_mode === 'auto' || t.attempt > 0) && dependenciesSatisfied(t));
-  // 5. 逐条出队，整条包在 try/catch 里
+  // 5. 逐条出队，每条独立 try/catch —— 一条失败绝不能中止整轮（那等于把后面的坑白白空着）
   for (const t of candidates) {
+    // 本轮已经填满就收工。`active` 是进循环前的快照、`started.length` 是本轮的战果，
+    // 两者都只会低估空位（跑着的 run 可能中途收敛让出坑），保守一点即可：
+    // 少起的那条由漏斗钩子上的下一次 scheduleTick 接手，而不是在这里赌一个更新的计数。
+    if (active + started.length >= max) break;
     const runId = t.current_run_id;
     try {
       // 5a. 入队时必须已经建好 queued 的 run 行；没有就是入队做了一半，
@@ -278,11 +299,10 @@ function tickInner(companyId) {
       //     由 updateRunStatus 的 BEGIN IMMEDIATE 事务保护，超发的那条拿不到坑。
       //     走 transitionRun 而不是裸的 updateRunStatus，是为了让这一跳同样落 timeline、
       //     推 SSE（控制台要看见任务起跑）；`to='ready'` 在活跃集里，所以它不会反手再触发一次调度。
-      //     三种「没抢到」的形态：
-      //       · changes=0            → transitionRun 返回 null（这条 run 已被别人推走）；
-      //       · RunSlotBusyError     → 主守卫在事务里判出坑满（**不是** changes=0）；
-      //       · UNIQUE constraint    → 兜底索引（批 4 DROP 前一直在），
-      //     后两种都是抛出来的，落到下面的 catch → isRaceError → continue。
+      //     两种「没抢到」的形态（批 4 DROP 唯一索引后，兜底那一层没有了）：
+      //       · changes=0            → transitionRun 返回 null（这条 run 已被别人推走）→ 试下一条；
+      //       · RunSlotBusyError     → 主守卫在事务里判出坑满（**不是** changes=0）→ 整轮到此为止。
+      //     抛出来的那种落到下面的 catch。
       if (!sse().transitionRun(runId, 'queued', 'ready', {}, {
         summary: `出队：queued → ready（task ${t.id}）`,
         task_id: t.id,
@@ -301,7 +321,11 @@ function tickInner(companyId) {
       engine().startRun(runId, { mode: t.execution_mode, task: t.description });
       started.push({ taskId: t.id, runId, goalId: t.goal_id });
     } catch (err) {
-      if (isRaceError(err)) continue; // 没抢到，正常
+      // 坑满：这一刻公司真的没位置了，后面的候选一个都进不去 —— 继续试只是白白多抛几次。
+      // 与下面那种「这一条没抢到」区分开：那种要接着试下一条，否则 max>1 时一条被别人
+      // 推走就会让剩下的坑空着（正是本轮 slice 去掉的那类空转）。
+      if (err instanceof wdb().RunSlotBusyError) break;
+      if (isRaceError(err)) continue; // 这一条没抢到（已被别人从 queued 推走），试下一条
       // 到这儿说明 run 可能已经出队但没能起跑：task 已标 running 而没有活的 run，
       // 这正是要消灭的那类「写了但没生效还不报错」。收回 run，让 task 落到可见的终态。
       if (runId && (getRun(runId) || {}).run_status === 'ready') {
@@ -312,7 +336,7 @@ function tickInner(companyId) {
     }
   }
-  return { companyId, active, started, blocked, requeued };
+  return { companyId, active, max, started, blocked, requeued };
 }
 /**
@@ -384,6 +408,7 @@ module.exports = {
   sweep,
   startSweeper,
   stopSweeper,
-  // 转发 work-graph-db 的那一份，别在这里存第二个副本
-  get MAX_PARALLEL_TASKS() { return maxParallelTasks(); },
+  // 批 4 删掉了 `get MAX_PARALLEL_TASKS()`：它无参，表达不了 per-company 的额度，
+  // 而且全仓零调用方 —— 一个「导出了、没人用、还恰好是错的」的形状。
+  // 要额度就调 `work-graph-db.maxActiveRootRuns(companyId)`，那是唯一持有者。
 };
@@ -32,27 +32,90 @@ const { validateGraph, normalizeContracts } = require(&#39;./org-graph-service&#39;);
 /**
  * 「这条 root run 正占着公司的执行坑」的取值域。
  *
- * **它同时是 `idx_graph_runs_one_active_root` 那个唯一索引的 WHERE 子句**（下面 getDb 里直接
- * 拼进去），所以这里是全仓库唯一的定义处，调度器 / 路由复用它而不是再抄一份字面量。
+ * 全仓库唯一的定义处，调度器 / 路由 / 准入事务复用它而不是再抄一份字面量。
  * 为什么强调这件事：`canDispatch` 那次事故就是前端把这三个值复述了一遍、还多写了一个
  * `blocked`，于是公司失败一次之后再也下不了任务 —— 取值域一旦有第二个持有者就会分叉。
  *
  * ⚠️ **`queued` 故意不在里面**：排队中的 run 不占坑，一家公司可以同时躺着任意多条。
- * 这正是「出队原子性」的**全部依赖** —— 出队那一跳 `queued → ready` 会撞上这个唯一索引，
- * 超发的那一条被 DB 直接拒（SqliteError），而不是靠应用层「先查后插」的乐观检查。
- * 改这个数组之前先读 27-P3C §四.3 与 §五.2；批 4 放开并行时要连索引一起动。
+ * 这是「入队不占坑、出队才占坑」的全部依据 —— 出队那一跳 `queued → ready` 是「从活跃集外
+ * 进入活跃集」，会被 `updateRunStatus` 的准入事务数一次坑。
+ * 改这个数组之前先读 27-P3C §四.3 与 §五.2。
+ *
+ * 批 4 之前这个数组还兼任 `idx_graph_runs_one_active_root` 的 WHERE 子句（拼进建表 SQL）。
+ * 那条索引已 DROP（见 getDb 的迁移块），现在它只有一个用途：准入事务的判据。
  */
 const ACTIVE_ROOT_RUN_STATUS = ['ready', 'running', 'paused'];
 /**
- * 一家公司同时能占几个执行坑。
+ * 一家公司同时能占几个执行坑 —— 缺省值。
+ * **缺省必须是 1**：读不到配置的公司（没建目录的单测、被 delete() 改名的公司、`_unknown`）
+ * 一律回落到批 3 的行为。回落成 0 是「永远不出队 = 静默全停」，回落成 Infinity 是超发。
+ */
+const DEFAULT_MAX_ACTIVE_ROOT_RUNS = 1;
+
+/**
+ * 硬上限。配置里写个 100000 不该被当真 —— 每个坑对应一条真在跑的 root run（一个 Claude CLI
+ * 子进程量级的开销），机器级闸门（SessionPool.maxSessions）至今不存在（登记在 28-followups）。
+ * 超过就按上限截断并打日志，不静默当成无限。
+ */
+const MAX_ACTIVE_ROOT_RUNS_CAP = 20;
+
+/** 同一份非法配置不必每次准入都刷一行日志 */
+const warnedMaxParallel = new Set();
+
+function warnMaxParallelOnce(companyId, raw, why) {
+  const key = `${companyId}:${raw}`;
+  if (warnedMaxParallel.has(key)) return;
+  warnedMaxParallel.add(key);
+  console.warn(`[work-graph-db] company ${companyId} 的 max_parallel_tasks=${JSON.stringify(raw)} ${why}`);
+}
+
+/**
+ * 这家公司同时能占几个执行坑（27-P3C 批 4 / 27-P4 §一.3）。
+ *
+ * **调用时读，不在模块加载时快照**。`company-paths.js` 顶上那条教训就是这个：镜像时代两个
+ * 模块各自快照 GRAPH_RUNS_DIR，加载顺序不同就算出不同的根。这里同理 —— 公司配置随时可改，
+ * 快照一次就意味着「改了配置要重启才生效」，而且不报错。
+ *
+ * 读的是 `companyRootDir(companyId)/company.json` 的 `max_parallel_tasks`（snake_case，
+ * 与 27-P4 §一.3 的字段名逐字一致；**不认 camelCase 的 maxParallelTasks** —— 两个键并存
+ * 就是又一个双持有者）。走 `company-paths.companyRootDir` 而不是 `company-service.get`：
+ *   · 前者认 GRAPH_RUNS_DIR，后者不认。准入判据一旦去读 company.json，设了 GRAPH_RUNS_DIR
+ *     的单测就会去读**真仓库**的 data/companies/，撞上同名公司就读到真配置（§六 缺陷 A 同型）；
+ *   · 顺带避开 `company-service → graph-service → graph-db` 那条 require 环。
+ * 两者在生产下算出的是同一个路径（都是 REPO_ROOT/data/companies/{cid}）。
+ *
+ * 非法值（0 / 负数 / 小数 / 非数字 / 文件坏了）一律回落 DEFAULT 并打一次日志：
+ * 「配置写错了就当没配」必须是能看见的，否则就是一次静默降级。
  *
- * ponytail: 批 3 硬编码为 1，与 `idx_graph_runs_one_active_root`（UNIQUE(company_id)）
- * 表达的是同一件事。批 4 放开并行时这里改成读 `company.json.max_parallel_tasks`
- * 并 DROP 那个索引 —— 到那时 `updateRunStatus` 里的准入事务就是**唯一**的守卫，
- * 所以它今天就得是对的，而不是等索引没了再回头补。
+ * ponytail: 每次准入读一次盘（一个几百字节的 JSON）。准入是低频事件（一次出队/恢复一次），
+ * 没加缓存。真到高频时加一层 mtime 缓存，别改成模块级快照。
  */
-const MAX_ACTIVE_ROOT_RUNS = 1;
+function maxActiveRootRuns(companyId) {
+  if (!companyId) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
+  let raw;
+  try {
+    const { companyRootDir } = require('./company-paths');
+    const fp = require('path').join(companyRootDir(companyId), 'company.json');
+    const fs = require('fs');
+    if (!fs.existsSync(fp)) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
+    raw = JSON.parse(fs.readFileSync(fp, 'utf-8')).max_parallel_tasks;
+  } catch (err) {
+    // company.json 坏了不该让一次出队变成 500：回落缺省，但必须留声
+    warnMaxParallelOnce(companyId, null, `读取失败（${err.message}），按 ${DEFAULT_MAX_ACTIVE_ROOT_RUNS} 处理`);
+    return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
+  }
+  if (raw === undefined || raw === null) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
+  if (!Number.isInteger(raw) || raw < 1) {
+    warnMaxParallelOnce(companyId, raw, `不是 ≥1 的整数，按 ${DEFAULT_MAX_ACTIVE_ROOT_RUNS} 处理`);
+    return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
+  }
+  if (raw > MAX_ACTIVE_ROOT_RUNS_CAP) {
+    warnMaxParallelOnce(companyId, raw, `超过硬上限，按 ${MAX_ACTIVE_ROOT_RUNS_CAP} 处理`);
+    return MAX_ACTIVE_ROOT_RUNS_CAP;
+  }
+  return raw;
+}
 /**
  * 坑满：一条 root run 想从活跃集外进入活跃集，但公司的执行坑已经占满。
@@ -71,6 +134,11 @@ const MAX_ACTIVE_ROOT_RUNS = 1;
  * 那个形状（§十四.3 第 3 条：注释是对的、代码没兑现；这次反过来）。
  * 现在文本不再是任何人的判据：唯一的判据是 `isSlotRaceError`（下面那个函数），按类型判。
  * message 里那句 `active-root-run constraint` 只当人读的说明留着，改它不会弄坏任何分支。
+ *
+ * ⚠️ **待拆（批 4 留下的）**：批 4 已 DROP 掉同名的唯一索引，`constraint` 这个词会让读者
+ * 以为 DB 层还有一道约束 —— 该换成 `limit`。本批**故意不动这个词**：路由层正由另一个 agent
+ * 并行改造，万一那边还留着按文本嗅探的分支，改早了会把一次 409 退化成 500。等路由那批落地、
+ * 确认全仓只剩 `instanceof` / `isSlotRaceError` 之后换掉它并删本段。
  */
 class RunSlotBusyError extends Error {
   /**
@@ -103,17 +171,29 @@ class RunSlotBusyError extends Error {
  * 一次正常竞争当成故障去 `abandonRun`（run 收成 stopped、task 收成 cancelled = 丢任务），
  * 而路由那边照常 409。这正是 `canDispatch` 那次事故的形状，只是换了个取值域。
  *
- * 三种形态，三道防线各一种：
- *   · `RunSlotBusyError`         主守卫：准入事务在 BEGIN IMMEDIATE 里数出坑已满；
- *   · `SQLITE_CONSTRAINT_UNIQUE` 兜底：真有两条同时写进活跃集时唯一索引直接拒（批 4 DROP 它后消失）。
- *     判 `code` 而不是判 message：better-sqlite3 的 SqliteError 自带这个字段，文案换了它不变；
- *   · `InvalidTransitionError`   这条 run 已经被别人从 queued 推走了。
+ * **现在只有一种形态**：`RunSlotBusyError` —— 准入事务在 `BEGIN IMMEDIATE` 里数出坑已满。
+ *
+ * ⚠️ 批 3 那版还把 `InvalidTransitionError` 算作竞态，注释写着「这条 run 已经被别人从 queued
+ * 推走了」。**探针实测证伪了这句话**：被别人推走时 `updateRunStatus` 走的是条件更新
+ * `WHERE id=? AND run_status=@from`，**返回 0、不抛异常**。真正抛 `InvalidTransitionError` 的
+ * 只有一种情况 —— **调用方声明了一个非法转换**（`expected = from` 是调用方传进来的声明值，
+ * `canTransitionRun` judge 的是 `expected → to`，不是 `cur.run_status → to`）。
+ * 也就是说那一支把「调用方写错了转换」当成「这轮没抢到」吞掉，还不留日志：
+ * 调度器会 `continue`，任务永远排队，界面与正常排队一模一样 —— 又一条「写不进去但不报错」。
+ * 已删除该分支，理由与下面删 UNIQUE 那支完全相同：让它吵起来。
+ *
+ * ⚠️ 批 4 **删掉了 `err.code === 'SQLITE_CONSTRAINT_UNIQUE'` 那一支**，这是一次故意的行为改变。
+ * 它当初的语义是「兜底那道唯一索引拒了」。索引 DROP 之后，这一跳再吐出 UNIQUE 冲突只剩一个
+ * 可能：**索引被建回来了**（旧版本进程启动时又跑了一遍它的 `CREATE UNIQUE INDEX IF NOT EXISTS`，
+ * 见 getDb 迁移块那段告示）。那种情况下 max>1 会被悄悄压回 1 —— 留着这一支的话，调度器把它
+ * 当「这轮没抢到」`continue` 掉，任务永远排队、日志一行没有、界面和正常排队一模一样，
+ * 正是要消灭的「写不进去但不报错」。删掉之后它会一路抛到 `abandonRun` / 500，吵得人能看见。
+ *
+ * 判类型而不是判 message：改一句报错文案不该改变任何分支（这是批 3 那次分叉的根因）。
  */
 function isSlotRaceError(err) {
   if (!err) return false;
-  return err instanceof InvalidTransitionError
-    || err instanceof RunSlotBusyError
-    || err.code === 'SQLITE_CONSTRAINT_UNIQUE';
+  return err instanceof RunSlotBusyError;
 }
 // ────────────────────────────────────────────────────────────────
@@ -237,13 +317,10 @@ function getDb() {
       created_at         TEXT NOT NULL,
       updated_at         TEXT NOT NULL
     );
-    -- v1 约束：同一 company 至多一个「活跃」root run。取值域从 ACTIVE_ROOT_RUN_STATUS 拼进来，
-    -- 不再手抄一份 —— 索引的 WHERE 和调度器判「坑满没满」的判据必须是同一个数组（§五.1）。
-    -- 注意 queued 不在其中：排队的 run 不占坑，这是出队 CAS 的依据（见该常量注释）。
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_graph_runs_one_active_root
-      ON graph_runs(company_id)
-      WHERE parent_run_id IS NULL
-        AND run_status IN (${ACTIVE_ROOT_RUN_STATUS.map((s) => `'${s}'`).join(',')});
+    -- 批 4 之前这里建过 idx_graph_runs_one_active_root（UNIQUE(company_id) WHERE 活跃且是 root），
+    -- 即「一家公司同时只有一条活跃 root run」那条 v1 硬约束。它与 max_parallel_tasks > 1 直接冲突，
+    -- 已删除，并在下面的迁移块里显式 DROP。**别把它加回来**：加回来 = 把并行悄悄压回 1
+    -- （症状见 isSlotRaceError 那段注释）。守卫现在只有一处，在 updateRunStatus 的准入事务里。
     CREATE TABLE IF NOT EXISTS graph_run_nodes (
       id            TEXT PRIMARY KEY,
@@ -433,6 +510,29 @@ function getDb() {
   // 存量库迁移（写法照抄 graph-db.js migrate()：hasColumn 判断 + ALTER TABLE ADD COLUMN，
   // 新建库走上面的 CREATE TABLE 就已经是目标形态，这里是 no-op）。
+
+  // ── 批 4：DROP 掉「一家公司只许一条活跃 root run」的唯一索引 ────────────────
+  //
+  // 从建表块里删掉那条 CREATE **对存量库无效**（`IF NOT EXISTS` 只管不重复建，不会把已有的
+  // 删掉），所以必须在这里显式 DROP —— 与 graph-db.js:76 那处
+  // `DROP INDEX IF EXISTS idx_org_graph_nodes_company_role` 同一写法。
+  // 不套 hasColumn：那个函数 pragma 的是 table_info，承载不了索引；`DROP INDEX IF EXISTS`
+  // 本身就是幂等的，重复跑、并发跑都安全（SQLite 把 DDL 序列化，慢的那个等 busy_timeout）。
+  //
+  // ⚠️ 删索引 = 删掉最后一道 DB 兜底。删之前先确认主守卫是**真的**主守卫 ——
+  // `updateRunStatus` 的准入是四步一体、缺一步就重新出现超发窗口：
+  //   1. `BEGIN IMMEDIATE`：读之前就拿写锁，杜绝两个连接各自数出「还有空位」；
+  //   2. 事务内**重读** run_status：状态已被别人推走时返回 0（幂等 no-op），不误报坑满；
+  //   3. 事务内 `listActiveRootRunIds` 计数，判据是「从活跃集外进入活跃集」（集内移动不重复占坑）；
+  //   4. 同一事务内做条件更新 `WHERE id=? AND run_status=@from`（写进去的 to 不在 WHERE 里）。
+  // 三个测试文件钉着这四步：task-scheduler.test.js「准入守卫」那组、task-queue-acceptance.test.js
+  // 的超发用例、graph-run-slot-recovery.test.js 的拒绝-退队列路径。
+  //
+  // ⚠️ **上线要求全停再起**：DROP 之后只要有**旧版本代码**的进程再调一次 getDb()，
+  // 它那条 `CREATE UNIQUE INDEX IF NOT EXISTS` 会把索引原样建回来，于是 max>1 的第二条准入
+  // 吃一句 SQLite 原文的 500（isSlotRaceError 已不再吞它，就是为了让这一幕吵起来）。
+  db.exec(`DROP INDEX IF EXISTS idx_graph_runs_one_active_root`);
+
   // R4-F1：graph_run_nodes 追加 remediation_note，可空，旧行 NULL = 「没有留给下一轮的话」。
   if (!hasColumn(db, 'graph_run_nodes', 'remediation_note')) {
     db.exec(`ALTER TABLE graph_run_nodes ADD COLUMN remediation_note TEXT`);
@@ -837,8 +937,9 @@ function readDefGraph(kind, graphId) {
  * root run：不传 parentRunId，root_run_id = 自身 id，budget_json 只在这里非空（§四.A.3）。
  * 子 run：  传 parentRunId + parentNodeRunId，root_run_id 从父 run 继承（冗余存储避免上溯）。
  *
- * 同一 company 只允许一个 active root run（idx_graph_runs_one_active_root）；
- * 冲突时抛 SqliteError，调用方自己决定是拒绝还是复用已有 run。
+ * **建 run 本身不占坑，也不做额度检查**（批 4 起唯一的坑约束是 `updateRunStatus` 的准入事务）。
+ * 建出来的 run 只有走「进入活跃集」那一跳时才会被数一次坑 —— 计数守卫**故意不放在这里**：
+ * 建 run 与进活跃集之间隔着排队，放在这里等于把「此刻有没有位置」当成「以后有没有位置」。
  *
  * @returns {{ok: true, id, nodeRunIds: Map<defNodeId,string>}}
  */
@@ -1137,9 +1238,9 @@ const RUN_PATCH_COLUMNS = {
 /**
  * 当前占着这家公司执行坑的 root run 数。
  *
- * WHERE 与 `idx_graph_runs_one_active_root` **逐字同源**（同一个 ACTIVE_ROOT_RUN_STATUS 拼出来）。
- * 一旦两边分叉，症状是「事务守卫放行、索引拒绝」的 500 —— 一个把关的说行、另一个说不行，
- * 而报出来的只有一句 SQLite 原文。所以计数只有这一个持有者，调度器也调它，不许自己再写一遍 SQL。
+ * WHERE 从 ACTIVE_ROOT_RUN_STATUS 拼出来，与准入事务的判据同源。计数只有这一个持有者，
+ * 调度器 / 路由都调它，不许自己再写一遍 SQL —— 批 4 DROP 掉唯一索引之后这条 SQL 就是
+ * 「坑满没满」的**全部**依据，多一个持有者就多一个能悄悄分叉的地方。
  *
  * @param {string} companyId
  * @param {object} [db] 传进来是为了让准入的计数与随后的 UPDATE 落在**同一个事务**里
@@ -1222,10 +1323,17 @@ function updateRunStatus(runId, from, to, patch = {}) {
     && !ACTIVE_ROOT_RUN_STATUS.includes(expected);
   if (!admitting) return write();
-  // BEGIN IMMEDIATE：**读之前**就拿到写锁，于是「数出 0 个活跃」到「自己占上」之间
-  // 不可能有第二个连接插进来各自数出 0（check-then-act 的经典超发）。
+  // 额度在**进事务之前**解析：它要读一次盘（company.json）+ JSON.parse，塞进 BEGIN IMMEDIATE
+  // 就是拿着 SQLite 写锁去做 syscall，而且文件坏掉时会在事务里抛。
+  // 这一步不需要在事务里：需要原子的是「数坑 + 占坑」，不是「读配置」——
+  // 这一刻读到的额度即使下一毫秒被人改了，最多影响这一次调度，不影响任何不变量。
+  const max = maxActiveRootRuns(cur.company_id);
+
+  // BEGIN IMMEDIATE：**读之前**就拿到写锁，于是「数出还有空位」到「自己占上」之间
+  // 不可能有第二个连接插进来各自数出还有空位（check-then-act 的经典超发）。
   // 同进程内 better-sqlite3 是同步单写者本来就串行，这把锁防的是多进程 / 多连接。
-  // 唯一索引仍在，是兜底那一层：主守卫（本事务）与兜底（DB 约束）并存，批 4 只 DROP 后者。
+  // 批 4 起这是**唯一**的守卫：`idx_graph_runs_one_active_root` 那道 DB 兜底已经 DROP
+  // （理由与四步论证见 getDb 迁移块），所以下面这四行今天就得是对的，没有第二道网接着。
   return db.transaction(() => {
     // 事务内重读才是权威的。状态已经不是 expected → 这次调用本来就是幂等 no-op
     // （下面 UPDATE 的 WHERE 同样匹配不到），返回 0。**绝不能**当成坑满抛错：
@@ -1234,8 +1342,8 @@ function updateRunStatus(runId, from, to, patch = {}) {
     if (!fresh || fresh.run_status !== expected) return 0;
     const heldBy = listActiveRootRunIds(cur.company_id, db);
-    if (heldBy.length >= MAX_ACTIVE_ROOT_RUNS) {
-      throw new RunSlotBusyError(cur.company_id, runId, heldBy, MAX_ACTIVE_ROOT_RUNS);
+    if (heldBy.length >= max) {
+      throw new RunSlotBusyError(cur.company_id, runId, heldBy, max);
     }
     return write();
   }).immediate();
@@ -2285,7 +2393,7 @@ module.exports = {
   updateNodeStatus,
   bumpNodeAttempt,
   updateRunStatus,
-  // 「坑满没满」的唯一计数处（WHERE 与唯一索引同源），调度器复用它
+  // 「坑满没满」的唯一计数处（WHERE 与准入事务同源），调度器 / 路由复用它
   countActiveRootRuns,
   listActiveRootRunIds,
   setRunFlags,
@@ -2347,10 +2455,14 @@ module.exports = {
   // 状态机
   NODE_TRANSITIONS,
   RUN_TRANSITIONS,
-  // 唯一索引的 WHERE 与调度器的「坑满没满」判据共用这一个数组，别再抄字面量
+  // 准入事务与调度器的「坑满没满」判据共用这一个数组，别再抄字面量
   ACTIVE_ROOT_RUN_STATUS,
-  // 并行度上限：批 3 恒为 1，批 4 改成读 company.json。调度器取这里，不许再写一个 1
-  MAX_ACTIVE_ROOT_RUNS,
+  // 并行度上限：per-company，读 company.json.max_parallel_tasks。
+  // **故意不导出一个常量**：批 3 那个 `MAX_ACTIVE_ROOT_RUNS = 1` 一旦留下来，
+  // 就会有人拿它当「上限」用，而它对一家 max=3 的公司是错的（且不报错）。
+  maxActiveRootRuns,
+  DEFAULT_MAX_ACTIVE_ROOT_RUNS,
+  MAX_ACTIVE_ROOT_RUNS_CAP,
   canTransitionNode,
   canTransitionRun,
   InvalidTransitionError,
@@ -1549,7 +1549,7 @@ describe(&#39;27-P3C 批 1 验收（§八 4 / 5 / 6 / 10 / 11 / 12b）&#39;, () =&gt; {
       for (let t = 0; t < 3; t++) {
         const task = wdb.createTask({ goalId: goal.id, title: `T${g}-${t}`, description: `活 ${g}-${t}` });
         // 每条 task 挂一条 run + 2 个节点行：没有 run 的 task 走不到进度查询，挡不住 N+1。
-        // run_status 用 completed —— idx_graph_runs_one_active_root 只许一条活跃 root run，
+        // run_status 用 completed —— 活跃 root run 是要占公司执行坑的（批 4 前还有一条同名唯一索引），
         // 而这里要的是 15 条历史 run 同时出现在列表上（那正是 N+1 最疼的形态）。
         const runId = `run_n1_${g}_${t}`;
         db.prepare(`INSERT INTO graph_runs (id, graph_kind, graph_id, company_id, root_run_id, run_status, created_at, updated_at)
@@ -23,7 +23,7 @@ import {
   dependsLabel, pickDefaultSelection, findTask, runStateToTaskPatch,
   RUN_TERMINAL_TO_TASK_STATUS,
   queueBadge, parseBlockedReason, blockedLabel, taskActions, queueStat, queueNoteText,
-  dispatchedTaskId, pendingRunHint, hasStartedRun, UPSTREAM_BLOCK_PREFIX,
+  dispatchedTaskId, pendingRunHint, hasStartedRun, UPSTREAM_BLOCK_PREFIX, readSlots,
 } from '../../../web/src/components/graph-console/goal-task-model.js';
 const T0 = Date.parse('2026-08-18T10:00:00.000Z');
@@ -332,6 +332,139 @@ describe(&#39;「新目标」的队列提示&#39;, () =&gt; {
   });
 });
+describe('执行位（批 4 · 一家公司可以同时跑几条）', () => {
+  it('三个数全部读服务端的，free 连减法都不做 —— 一做减法就是第二个持有者', () => {
+    expect(readSlots({ max: 3, used: 2, free: 1 })).toEqual({ max: 3, used: 2, free: 1 });
+    expect(readSlots({ max: 1, used: 0, free: 1 })).toEqual({ max: 1, used: 0, free: 1 });
+    // max 刚被改小时服务端给的是截断过的 free（slotState 里的 Math.max(0, …)），原样带走
+    expect(readSlots({ max: 3, used: 5, free: 0 })).toEqual({ max: 3, used: 5, free: 0 });
+    // holders 一起来也不碍事：这里只读三个数
+    expect(readSlots({ max: 3, used: 3, free: 0, holders: [{ runId: 'r1' }] }))
+      .toEqual({ max: 3, used: 3, free: 0 });
+  });
+
+  it('形状不对一律 null —— 界面宁可少说一句，也不能凭空说出一个执行位总数', () => {
+    expect(readSlots(null)).toBeNull();
+    expect(readSlots({})).toBeNull();
+    expect(readSlots({ max: 3, used: 1 })).toBeNull();       // 缺 free
+    expect(readSlots({ used: 1, free: 2 })).toBeNull();      // 缺 max
+    expect(readSlots({ max: '3', used: '1', free: '2' })).toBeNull(); // 字符串不认
+    expect(readSlots({ max: 3, used: 1.5, free: 1.5 })).toBeNull();
+    expect(readSlots({ max: 0, used: 0, free: 0 })).toBeNull(); // max=0 = 永远不出队，不是能显示的值
+    // 这两条钉的是「不许走 Number() 转换」：Number(null)/Number('') 都是 0，
+    // 一个字段缺失的响应会被读成「0 个执行位在用」并原样显示出去
+    expect(readSlots({ max: 3, used: null, free: 3 })).toBeNull();
+    expect(readSlots({ max: 3, used: '', free: 3 })).toBeNull();
+  });
+
+  it('形状逐字同服务端唯一那一份（routes/graph-run.js#slotState 的返回值）', () => {
+    // slotState(companyId) → { max, used, free, holders }；这里连字段名都不翻译
+    const fromServer = { max: 3, used: 3, free: 0, holders: [{ runId: 'r1', taskId: 'T-1' }] };
+    expect(readSlots(fromServer)).toEqual({ max: 3, used: 3, free: 0 });
+  });
+});
+
+describe('并行下的队列文案', () => {
+  it('有 slots 就报「几分之几个执行位」——「1 个在跑」在 3 坑公司里读起来像满了', () => {
+    const txt = queueNoteText({ running: 1, queued: 2, blocked: 0 }, { max: 3, used: 1, free: 2 });
+    expect(txt).toContain('1/3 个执行位在用');
+    expect(txt).toContain('2 个在排队');
+    expect(txt).toContain('还空着 2 个执行位');
+    expect(txt).not.toMatch(/第\s*\d+\s*位/); // 位次照旧一个都不编
+  });
+
+  it('坑满时不说「还空着」，退回「排在它们后面」', () => {
+    const txt = queueNoteText({ running: 3, queued: 1, blocked: 0 }, { max: 3, used: 3, free: 0 });
+    expect(txt).toContain('3/3 个执行位在用');
+    expect(txt).not.toContain('还空着');
+    expect(txt).toContain('坑一空就自动开跑');
+  });
+
+  it('slots 给不出时逐字退回批 3 原样 —— 今天服务端还没吐这个字段，走的就是这一支', () => {
+    const before = queueNoteText({ running: 1, queued: 2, blocked: 1 });
+    expect(before).toBe(queueNoteText({ running: 1, queued: 2, blocked: 1 }, null));
+    expect(before).toBe(queueNoteText({ running: 1, queued: 2, blocked: 1 }, { max: 3 }));
+    expect(before).toContain('1 个任务在跑');
+    expect(before).not.toContain('执行位');
+  });
+
+  it('used 与 running 对不上时两个都报，不替服务端断言它们该相等', () => {
+    // used 数的是活跃 root run（含 ready/paused），running 数的是 task 行 —— 不是同一件事
+    const txt = queueNoteText({ running: 1, queued: 0, blocked: 0 }, { max: 3, used: 2, free: 1 });
+    expect(txt).toContain('2/3 个执行位在用');
+    expect(txt).toContain('1 个任务在跑');
+  });
+
+  it('队里空但有执行位在用时也要说话（在跑的那条不在 queueStat 的三个数里也算数）', () => {
+    expect(queueNoteText({ running: 0, queued: 0, blocked: 0 }, { max: 3, used: 1, free: 2 }))
+      .toContain('1/3 个执行位在用');
+    // 真的一个都没有：还是不说话
+    expect(queueNoteText({ running: 0, queued: 0, blocked: 0 }, { max: 3, used: 0, free: 3 })).toBe('');
+  });
+});
+
+describe('排队中的任务：还要等多久', () => {
+  it('位次 ≤ 空位 = 下一轮就开跑，不是「要等前面的收敛」', () => {
+    const h = pendingRunHint({ status: 'queued', mode: 'auto', queuePosition: 2 }, { max: 3, used: 1, free: 2 });
+    expect(h).toContain('排在第 2 位');
+    expect(h).toContain('还空着 2 个');
+    expect(h).toContain('下一轮调度');
+    expect(h).not.toContain('要等');
+  });
+
+  it('坑满时说「还要等几个执行位腾出来」，不是「前面还有几个任务」', () => {
+    // 位次 4、3 个坑全满：空位会先被前 3 条占掉，我要等 4 个坑腾出来才轮到
+    const h = pendingRunHint({ status: 'queued', mode: 'auto', queuePosition: 4 }, { max: 3, used: 3, free: 0 });
+    expect(h).toContain('还要等 4 个执行位腾出来');
+    expect(h).not.toContain('要等 0 个');
+    // 队首 + 满坑 = 等 1 个（旧文案在这里会说「前面还有 0 个」）
+    expect(pendingRunHint({ status: 'queued', mode: 'auto', queuePosition: 1 }, { max: 1, used: 1, free: 0 }))
+      .toContain('还要等 1 个执行位腾出来');
+  });
+
+  it('manual 的排队任务：空位再多也不会自己动 —— 调度器只出队 auto', () => {
+    const h = pendingRunHint({ status: 'queued', mode: 'manual', queuePosition: 1 }, { max: 3, used: 0, free: 3 });
+    expect(h).toContain('手动');
+    expect(h).toContain('立即开始');
+    expect(h).not.toContain('自动开跑');
+    // 没有 slots 时同样要说，这条与并行无关
+    expect(pendingRunHint({ status: 'queued', mode: 'manual', queuePosition: 1 })).toContain('立即开始');
+  });
+
+  it('slots 给不出时逐字退回批 3 原样', () => {
+    expect(pendingRunHint({ status: 'queued', mode: 'auto', queuePosition: 3 }))
+      .toContain('前面还有 2 个任务');
+    expect(pendingRunHint({ status: 'queued', mode: 'auto', queuePosition: 1 }))
+      .toContain('排在队首');
+    expect(pendingRunHint({ status: 'queued', mode: 'auto' }, { max: 3, used: 1, free: 2 }))
+      .toContain('服务端没给位次');
+  });
+});
+
+describe('并行下左栏每一行', () => {
+  it('位次只对 queued 有意义：N 条同时 running 一个位次都不标', () => {
+    expect(queueBadge({ status: 'running', queuePosition: 1 })).toBeNull();
+    expect(queueBadge({ status: 'running', queuePosition: 2 })).toBeNull();
+    expect(queueBadge({ status: 'blocked', queuePosition: 3 })).toBeNull();
+    expect(queueBadge({ status: 'queued', queuePosition: 3 }).text).toBe('排队 #3');
+  });
+
+  it('N 条并行时默认选中最新那条，且重复调用结果稳定（不会每轮轮询跳一条）', () => {
+    const goals = [{
+      goalId: 'G-1',
+      tasks: [
+        { taskId: 'T-a', status: 'running', createdAt: '2026-08-18T10:00:00Z' },
+        { taskId: 'T-b', status: 'running', createdAt: '2026-08-18T12:00:00Z' },
+        { taskId: 'T-c', status: 'running', createdAt: '2026-08-18T11:00:00Z' },
+      ],
+    }];
+    expect(pickDefaultSelection(goals)).toEqual({ goalId: 'G-1', taskId: 'T-b' });
+    // 数组顺序变了也选同一条：排序只看 createdAt，不吃调用方的顺序
+    const shuffled = [{ goalId: 'G-1', tasks: [goals[0].tasks[1], goals[0].tasks[2], goals[0].tasks[0]] }];
+    expect(pickDefaultSelection(shuffled)).toEqual({ goalId: 'G-1', taskId: 'T-b' });
+  });
+});
+
 describe('dispatch 响应 → 选中态', () => {
   it('起了 run（started）与入了队（queued[]）两种形状都认；认不出就返回空串，不猜一条出来', () => {
     expect(dispatchedTaskId({ started: { taskId: 'T-1' } })).toBe('T-1');
@@ -111,7 +111,10 @@ describe(&#39;POST /api/graph-runs/... 撞上坑满 → 409（不是 500）&#39;, () =&gt; 
     expect(r.status).toBe(409); // 修之前：500 + 一句 "company … 的执行坑已满" 原文
     expect(body.reason).toBe('run-slot-busy');
     expect(body.companyId).toBe(CID);
-    expect(body.max).toBe(wdb.MAX_ACTIVE_ROOT_RUNS);
+    // 批 4 起额度是 per-company 的（company.json.max_parallel_tasks，这家没配 → 缺省 1）。
+    // 钉的是「409 里报的额度 = 准入真的用的那个额度」，不是钉某个常量。
+    expect(body.max).toBe(wdb.maxActiveRootRuns(CID));
+    expect(body.max).toBe(wdb.DEFAULT_MAX_ACTIVE_ROOT_RUNS);
     // 「挡我的是谁」：run id 与 task id 都要给得出来，否则界面上只剩「坑满」
     expect(body.holders).toEqual([
@@ -276,20 +276,37 @@ describe(&#39;批 3 排队 · §八 验收&#39;, () =&gt; {
   const runStatus = (id) => wdb.getRun(id).run_status;
   // ──────────────────────────────────────────────────────────────
-  // 唯一索引：queued 不在 WHERE 里
+  // 批 4：唯一索引已 DROP —— 事务准入是唯一的守卫
   // ──────────────────────────────────────────────────────────────
-  it('唯一索引的 WHERE 里没有 queued —— 出队原子性的全部依赖，直接对着建表 SQL 断言', () => {
+  /**
+   * 批 3 这一条钉的是「唯一索引的 WHERE 里没有 queued」（当时出队原子性靠它兜底）。
+   * 批 4 把索引 DROP 了 —— 但要钉的事情**没变**：超发必须拦得住。所以这一条整体反转：
+   *   · 索引必须**不存在**（`CREATE ... IF NOT EXISTS` 对存量库不生效，所以必须显式 DROP。
+   *     它要是还在，max>1 的第二条准入会在事务放行之后吃一句 SQLite 原文的 500）；
+   *   · 主守卫必须**真的**是主守卫，而且此刻就在拦超发（下面直接演示）。
+   * 断言索引不在，而不只是断言 JS 常量没了：两者一旦分叉，只看常量的用例照样绿。
+   */
+  it('唯一索引已 DROP，且主守卫独自拦得住超发 —— 删兜底之后 max=1 的行为一个字不变', () => {
     const row = wdb.getDb()
       .prepare(`SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'idx_graph_runs_one_active_root'`)
       .get();
-    expect(row).toBeTruthy();
-    // 断言的是**索引自己的 SQL**，不是 JS 常量：常量与索引一旦分叉，只看常量的用例照样绿
-    expect(row.sql).toMatch(/parent_run_id IS NULL/);
-    expect(row.sql).not.toMatch(/queued/);
-    for (const s of ['ready', 'running', 'paused']) expect(row.sql).toContain(`'${s}'`);
-    // 反过来也要成立：JS 侧那份取值域与索引逐字同源
+    expect(row).toBeUndefined();
+
+    // 取值域仍是准入判据的唯一持有者（queued 不在里面 = 排队不占坑）
     expect(wdb.ACTIVE_ROOT_RUN_STATUS).toEqual(['ready', 'running', 'paused']);
-    expect(wdb.MAX_ACTIVE_ROOT_RUNS).toBe(1);
+    expect(wdb.ACTIVE_ROOT_RUN_STATUS).not.toContain('queued');
+    // 没配 max_parallel_tasks 的公司回落 1 —— 存量行为不变的那条保证
+    const companyId = nextCompany();
+    expect(wdb.maxActiveRootRuns(companyId)).toBe(1);
+
+    // 主守卫单独上阵：第一条进坑，第二条被事务拒（RunSlotBusyError，不是 SqliteError）
+    const goalId = newGoal(companyId);
+    const a = enqueue(companyId, goalId, { title: 'a' });
+    const b = enqueue(companyId, goalId, { title: 'b' });
+    expect(wdb.updateRunStatus(a.runId, 'queued', 'ready')).toBe(1);
+    expect(() => wdb.updateRunStatus(b.runId, 'queued', 'ready')).toThrow(wdb.RunSlotBusyError);
+    expect(wdb.getRun(b.runId).run_status).toBe('queued'); // 拒绝是干净的：一个字都没写
+    expect(wdb.countActiveRootRuns(companyId)).toBe(1);
   });
   // ──────────────────────────────────────────────────────────────
@@ -585,6 +602,43 @@ describe(&#39;批 3 排队 · §八 验收&#39;, () =&gt; {
     expect(wdb.countActiveRootRuns(companyId)).toBe(1);
   });
+  it('L1：人亲手起过的 manual 被退回队列后，坑一空自己接回来（不用再点一次）', async () => {
+    const companyId = nextCompany();
+    const goalId = newGoal(companyId);
+    hangingExecutor();
+
+    // 人亲手起跑一条 manual —— 这一步就是「授权」，started_at 在这里被写上
+    const m = enqueue(companyId, goalId, { title: 'm', mode: 'manual', priority: 'P0' });
+    expect(humanStart(wdb.getTask(m.taskId))).toBeTruthy();
+    expect(wdb.getTask(m.taskId).attempt).toBeGreaterThan(0);   // 授权的事实记在 attempt 上
+
+    // 它撞上预算/挂起被退回队列（直接用数据层那条退路，等价于 admitOrRequeue 走到的分支）
+    expect(sse.transitionRun(m.runId, 'running', 'blocked', {}, { summary: '用例：预算耗尽' })).toBeTruthy();
+    expect(wdb.requeueBlockedRootRun(m.runId)).toBeTruthy();
+    expect(taskStatus(m.taskId)).toBe('queued');
+    expect(runStatus(m.runId)).toBe('queued');
+
+    // 坑是空的 —— 批 3 那版这里会永远躺着（调度器 filter 只认 auto），人得**另外**再点一次
+    expect(wdb.countActiveRootRuns(companyId)).toBe(0);
+    scheduler.tick(companyId);
+
+    // 现在它自己回来了：人刚才那次点击被兑现，而不是被吞掉
+    expect(taskStatus(m.taskId)).toBe('running');
+    expect(runStatus(m.runId)).toBe('running');
+  });
+
+  it('L1 反面：从没被人起过的 manual 仍然不许自动出队（首次起跑的授权不能省）', () => {
+    const companyId = nextCompany();
+    const goalId = newGoal(companyId);
+    hangingExecutor();
+    const m = enqueue(companyId, goalId, { title: 'm', mode: 'manual', priority: 'P0' });
+    expect(wdb.getTask(m.taskId).attempt).toBe(0);              // 从没被人起过
+    scheduler.tick(companyId);
+    scheduler.tick(companyId);
+    expect(taskStatus(m.taskId)).toBe('queued');
+    expect(wdb.countActiveRootRuns(companyId)).toBe(0);
+  });
+
   // ──────────────────────────────────────────────────────────────
   // 验收 23：blocked 是推导出来的，不是落死的
   // ──────────────────────────────────────────────────────────────
@@ -226,17 +226,24 @@ describe(&#39;批 3 排队 · HTTP 端点（27-P3C §六.3）&#39;, () =&gt; {
   // /start —— manual 任务唯一的起跑路径（§五.2bis）
   // ────────────────────────────────────────────────────────────────
-  it('/start 把排队中的 manual 拉起来；坑被占着时回 409 + 当前位次，绝不假装已开始', async () => {
+  it('/start 把排队中的 manual 拉起来；执行位满时回 409 + 当前位次，绝不假装已开始', async () => {
     const cid = newCompany();
     const goal = await newGoal(cid, [{ description: 'a' }, { description: 'b' }]);
     const [, dispatched] = await call('POST', `/api/company/${cid}/goals/${goal.goalId}/dispatch`);
     const runningId = dispatched.started.taskId;
     const queuedId = goal.tasks.find((t) => t.taskId !== runningId).taskId;
-    // 坑被占着：如实回 409。回 200 的话界面会显示「已开始」而实际什么都没跑
+    // 执行位被占满：如实回 409。回 200 的话界面会显示「已开始」而实际什么都没跑
     const [busy, err] = await call('POST', `/api/company/${cid}/tasks/${queuedId}/start`);
     expect(busy).toBe(409);
-    expect(err.activeRunId).toBe(dispatched.started.runId);
+    // 批 4：形状与 graph-run.js 的 run-slot-busy 逐字同源（那边 holders 从批 3 起就是数组）。
+    // 这里以前是 activeRunId 一个单数字段 —— N 个执行位时只点名一条，用户停掉它发现还是起不来。
+    expect(err.reason).toBe('run-slot-busy');
+    expect(err.max).toBe(wdb.maxActiveRootRuns(cid)); // 这家没配 max_parallel_tasks → 缺省 1
+    expect(err.active).toBe(1);
+    expect(err.holders).toEqual([
+      expect.objectContaining({ runId: dispatched.started.runId, taskId: runningId, runStatus: 'running' }),
+    ]);
     expect(err.queuePosition).toBe(1);
     expect(wdb.getTask(queuedId).status).toBe('queued'); // 状态一个字节都没动
@@ -250,6 +257,57 @@ describe(&#39;批 3 排队 · HTTP 端点（27-P3C §六.3）&#39;, () =&gt; {
     expect(wdb.getTask(queuedId).attempt).toBe(1);
   });
+  it('max_parallel_tasks=3：一次下达把 3 个执行位填满并全部报出来；满了才 409，空一个就起得来', async () => {
+    const cid = newCompany();
+    // 额度是 per-company 的，写在 company.json 里（走 company-paths，认 GRAPH_RUNS_DIR）。
+    // 别用 CompanyService：那份 stub 不认这个字段，而准入读的也不是它。
+    const dir = path.join(runsDir, '_companies', cid);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'company.json'), JSON.stringify({ id: cid, max_parallel_tasks: 3 }));
+    expect(wdb.maxActiveRootRuns(cid)).toBe(3);
+
+    const goal = await newGoal(cid, [
+      { description: 'a' }, { description: 'b' }, { description: 'c' }, { description: 'd' },
+    ]);
+    const [st, body] = await call('POST', `/api/company/${cid}/goals/${goal.goalId}/dispatch`);
+    expect(st).toBe(201);
+
+    // 批 4 之前这里只会起 1 条（`if (activeRootRun) return null`），而且只报第一条。
+    // 两个毛病都是「不报错的少做 / 少说」，界面上与正常排队一模一样。
+    expect(body.startedTasks).toHaveLength(3);
+    expect(body.started).toEqual(body.startedTasks[0]); // 单数字段与数组同源，不是另算一遍
+    expect(body.queued.filter((q) => q.queuePosition).map((q) => q.queuePosition)).toEqual([1]);
+
+    // 左栏轮询的两个端点要给得出「几分之几个执行位」——前端 readSlots 读的就是这三个数，
+    // 它**不自己算 free**（free 带着「max 被改小时截断到 0」的语义）。给不出 = 文案退回批 3。
+    const [gs, tree] = await call('GET', `/api/company/${cid}/goals?withTasks=1`);
+    expect(gs).toBe(200);
+    expect(tree.slots).toEqual({ max: 3, used: 3, free: 0 });
+    const [ts, list] = await call('GET', `/api/company/${cid}/tasks`);
+    expect(ts).toBe(200);
+    expect(list.slots).toEqual({ max: 3, used: 3, free: 0 });
+
+    const startedIds = body.startedTasks.map((s) => s.taskId);
+    const waiting = goal.tasks.find((t) => !startedIds.includes(t.taskId)).taskId;
+
+    // 位子真满了才 409，而且要说得出「几条在跑 / 上限几 / 谁占着」
+    const [busy, err] = await call('POST', `/api/company/${cid}/tasks/${waiting}/start`);
+    expect(busy).toBe(409);
+    expect(err.reason).toBe('run-slot-busy');
+    expect(err.active).toBe(3);
+    expect(err.max).toBe(3);
+    expect(err.holders.map((h) => h.runId).sort()).toEqual(body.startedTasks.map((s) => s.runId).sort());
+    // hint 要点名**所有**停得掉的那几条：只给一条的话，用户停掉它发现还是起不来
+    for (const s of body.startedTasks) expect(err.hint).toContain(`/api/graph-runs/${s.runId}/stop`);
+
+    // 腾出一个位 → manual 立刻起得来（3 个位空着 1 个还拒绝，正是批 4 要消灭的那个 bug）
+    sse.transitionRun(body.startedTasks[0].runId, 'running', 'completed', {}, { summary: '用例直推终态' });
+    const [ok, res] = await call('POST', `/api/company/${cid}/tasks/${waiting}/start`);
+    expect(ok).toBe(201);
+    expect(res.started.taskId).toBe(waiting);
+    expect(wdb.countActiveRootRuns(cid)).toBe(3);
+  });
+
   it('/start 对 draft 与「上游没做完」各给各的 409，并点名挡我的是谁', async () => {
     const cid = newCompany();
     const goal = await newGoal(cid, [
@@ -272,7 +330,8 @@ describe(&#39;批 3 排队 · HTTP 端点（27-P3C §六.3）&#39;, () =&gt; {
     const [depStatus, depErr] = await call('POST', `/api/company/${cid}/tasks/${deploy.taskId}/start`);
     expect(depStatus).toBe(409);
     expect(depErr.blockedBy).toEqual([build.taskId]);
-    expect(depErr.activeRunId).toBeUndefined();
+    expect(depErr.reason).toBeUndefined(); // 不是 run-slot-busy：别把人引去 stop 那条没用的路
+    expect(depErr.holders).toBeUndefined();
     // 上游被停掉（cancelled = 永远不会 completed）之后，下一轮 tick 把它推导成 blocked
     // 并写明是谁挡的 —— 不许让它继续以 queued 的样子躺在队里假装在排队（§五.1.2）
@@ -7,7 +7,7 @@
  *   15 排队期间 replan → 出队后按新图跑（syncRunNodesToDef）
  *   23 上游失败 → 下游 blocked，上游恢复后自动回 queued（blocked 是推导出来的，不落死）
  * 外加 §九.1 那张「queued 混进 run_status」的回归表里点名要钉死的三条断言：
- *   · 唯一索引不覆盖 queued（出队原子性的全部依赖）
+ *   · queued 不在活跃集里（排队不占坑，出队那一跳才被准入事务数一次）
  *   · advanceOne 挡住 queued run（防止 queued run 被误推进的唯一一道闸）
  *   · startRun 拒绝 queued run（出队顺序不能反过来）
  *
@@ -105,7 +105,7 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
   // ── 夹具 ──────────────────────────────────────────────────────
   let seq = 0;
-  /** 每个用例一家独立公司：唯一索引是按 company 约束的 */
+  /** 每个用例一家独立公司：执行坑是按 company 数的 */
   const nextCompany = () => `sched-co-${++seq}`;
   function ensureAgents(ids) {
@@ -172,7 +172,7 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
   // §九.1 回归表：queued 不被误当可执行
   // ──────────────────────────────────────────────────────────────
   describe('queued 混进 run_status 的三道闸', () => {
-    it('唯一索引不覆盖 queued：同一公司可以躺任意多条 queued root run，而出队时超发被 DB 拒', () => {
+    it('queued 不占坑：同一公司可以躺任意多条 queued root run，而出队时超发被准入事务拒', () => {
       const companyId = nextCompany();
       const goalId = newGoal(companyId);
@@ -190,12 +190,17 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
       // 第二条被**主守卫**（准入事务里数坑）拒：抛 RunSlotBusyError，**不是** changes = 0
       expect(() => wdb.updateRunStatus(b.runId, 'queued', 'ready')).toThrow(wdb.RunSlotBusyError);
       expect(wdb.getRun(b.runId).run_status).toBe('queued');
-      // 兜底那一层必须真的还在（注释里承诺了「两道守卫并存」，就得能演示出来）：
-      // 绕开 updateRunStatus 直接写库，唯一索引照样拒。批 4 DROP 它之后这一条要一起删。
+      // 批 3 这里演示的是「兜底那一层（唯一索引）也还在」：绕开 updateRunStatus 直接写库照样被拒。
+      // 批 4 DROP 了那条索引，所以这一段反过来钉两件事 ——
+      //   ① 索引确实没了：裸写库现在**写得进去**（这正是「删掉了最后一道 DB 兜底」的样子，
+      //      要能演示出来，否则「已 DROP」只是一句注释）；
+      //   ② 于是唯一的守卫只剩上面那个准入事务，它今天就得是对的。
       expect(() =>
         wdb.getDb().prepare(`UPDATE graph_runs SET run_status = 'ready' WHERE id = ?`).run(b.runId)
-      ).toThrow(/UNIQUE constraint failed/);
-      expect(wdb.getRun(b.runId).run_status).toBe('queued');
+      ).not.toThrow();
+      expect(wdb.getRun(b.runId).run_status).toBe('ready');
+      // 把裸写的这条放回 queued，别让它污染后面的断言（它是绕过守卫写进去的，不是准入放行的）
+      wdb.getDb().prepare(`UPDATE graph_runs SET run_status = 'queued' WHERE id = ?`).run(b.runId);
       // 同一条重复出队 = changes 0（幂等 no-op，不抛）
       expect(wdb.updateRunStatus(a.runId, 'queued', 'ready')).toBe(0);
       // queued 有出路：撤出队列
@@ -262,9 +267,11 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
        * 理由写着「routes/company.js 那两处 catch 至今是按文本嗅探的」—— **批 3 把那两处
        * catch 整段删了**（下达不再因坑满失败，改成入队）。于是这条用例一直绿着，钉的却是
        * 一个没有任何调用方的契约，还反过来禁止清理那句报文。
-       * 现在钉真正的那条：判据只有 `work-graph-db.isSlotRaceError` 一个持有者，按类型判，
-       * 三种形态一个都不能漏 —— 漏一种，调度器就会把一次正常竞争当故障去 abandonRun（丢任务），
+       * 现在钉真正的那条：判据只有 `work-graph-db.isSlotRaceError` 一个持有者，按类型判。
+       * 该认的一个都不能漏 —— 漏一种，调度器就会把一次正常竞争当故障去 abandonRun（丢任务），
        * 而路由那边照常 409，两边对同一件事给出相反结论。
+       * 不该认的也一个都不能多认（批 4 起 SQLITE_CONSTRAINT_UNIQUE 就在这一侧，见下）：
+       * 认宽了是把真 bug 当正常竞争 continue 掉，那是静默。
        */
       it('「没抢到坑」的判据只有一个持有者，且按类型判 —— 改一句报错文案不该改变任何分支', () => {
         const companyId = nextCompany();
@@ -278,16 +285,23 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
         expect(caught).toBeInstanceOf(wdb.RunSlotBusyError);
         expect(wdb.isSlotRaceError(caught)).toBe(true);
-        // 兜底那一层（唯一索引）也必须被认出来：它抛的是 SqliteError，带 code 不带类型
-        let dbErr;
-        try {
-          wdb.getDb().prepare(`UPDATE graph_runs SET run_status = 'ready' WHERE id = ?`).run(b.runId);
-        } catch (e) { dbErr = e; }
-        expect(dbErr.code).toBe('SQLITE_CONSTRAINT_UNIQUE');
-        expect(wdb.isSlotRaceError(dbErr)).toBe(true);
-
-        // 第三种：这条 run 已经被别人推走了
-        expect(wdb.isSlotRaceError(new wdb.InvalidTransitionError('run', 'x', 'queued', 'ready'))).toBe(true);
+        // 批 3 这里钉的是「兜底那一层（唯一索引）抛的 SqliteError 也必须被认成『没抢到』」。
+        // 批 4 DROP 了索引，于是这条判据**反过来**：一个 SQLITE_CONSTRAINT_UNIQUE 再出现在
+        // 这条路上，只可能是索引被旧版本进程建回来了（max>1 被悄悄压回 1）。
+        // 认成「没抢到」的话调度器会 continue 掉，任务永远排队、日志一行没有 ——
+        // 正是要消灭的「写不进去但不报错」。所以它必须**不**算竞争，一路抛到人能看见的地方。
+        const fakeUniqueErr = Object.assign(new Error('UNIQUE constraint failed: graph_runs.company_id'), {
+          code: 'SQLITE_CONSTRAINT_UNIQUE',
+        });
+        expect(wdb.isSlotRaceError(fakeUniqueErr)).toBe(false);
+
+        // ⚠️ 批 3 这里断言 InvalidTransitionError 也算「没抢到」，注释写着「这条 run 已经被别人
+        // 从 queued 推走了」。**探针实测证伪**：被别人推走时 updateRunStatus 走的是条件更新
+        // `WHERE id=? AND run_status=@from`，**返回 0、不抛异常**；真正抛 InvalidTransitionError
+        // 的只有「调用方声明了非法转换」（expected 是调用方传进来的声明值，canTransitionRun
+        // judge 的是 expected→to 而不是 cur.run_status→to）。
+        // 把调用方的 bug 当成正常竞争吞掉、还不留日志 —— 与上面那条 UNIQUE 同一个病。
+        expect(wdb.isSlotRaceError(new wdb.InvalidTransitionError('run', 'x', 'queued', 'ready'))).toBe(false);
         // 别的错误一律不算「没抢到」—— 认宽了就是把真 bug 当成正常竞争 continue 掉
         expect(wdb.isSlotRaceError(new Error('UNIQUE constraint failed: 别处的错'))).toBe(false);
         expect(wdb.isSlotRaceError(null)).toBe(false);
@@ -315,6 +329,116 @@ describe(&#39;task-scheduler&#39;, () =&gt; {
       });
     });
+    /**
+     * 批 4：额度从「模块级常量 1」变成 per-company 的 `company.json.max_parallel_tasks`。
+     *
+     * 这组用例的重点不是「并行能跑」，而是**回落**那一条：全仓几乎所有单测的公司都没有
+     * company.json（`sched-co-*` 只是个字符串），一旦回落算错，1195 条测试会一起变色 ——
+     * 所以「读不到 = 1」是保护存量的那条断言，必须先钉。
+     *
+     * 配置写在 `company-paths.companyRootDir()` 下而不是 `data/companies/` 下：
+     * 前者认 GRAPH_RUNS_DIR，本文件设了它，于是这组用例不会去碰仓库里的真公司目录
+     * （准入判据一旦去读真 data/，撞上同名公司就读到真配置 —— §六 缺陷 A 同型）。
+     */
+    describe('每家公司自己的执行坑数（company.json.max_parallel_tasks）', () => {
+      /** 给这家公司写一份 company.json；`n === null` 表示写一个没有该字段的配置 */
+      function setMaxParallel(companyId, n) {
+        const { companyRootDir } = require('../../services/company-paths');
+        const dir = companyRootDir(companyId);
+        fs.mkdirSync(dir, { recursive: true });
+        const cfg = { id: companyId, name: companyId };
+        if (n !== null) cfg.max_parallel_tasks = n;
+        fs.writeFileSync(path.join(dir, 'company.json'), JSON.stringify(cfg));
+        return companyId;
+      }
+
+      it('没有 company.json 的公司回落 1 —— 存量单测与存量公司的行为一个字不变', () => {
+        const companyId = nextCompany();
+        expect(wdb.maxActiveRootRuns(companyId)).toBe(wdb.DEFAULT_MAX_ACTIVE_ROOT_RUNS);
+        expect(wdb.DEFAULT_MAX_ACTIVE_ROOT_RUNS).toBe(1);
+        // 有 company.json 但没写这个字段，同样回落
+        expect(wdb.maxActiveRootRuns(setMaxParallel(nextCompany(), null))).toBe(1);
+      });
+
+      it('非法值一律回落 1，不静默当成无限：0 / 负数 / 小数 / 字符串 / 超上限', () => {
+        for (const bad of [0, -3, 1.5, '3', true, null]) {
+          expect(wdb.maxActiveRootRuns(setMaxParallel(nextCompany(), bad))).toBe(1);
+        }
+        // 超上限按上限截断（不是回落 1，也不是当真）
+        const huge = setMaxParallel(nextCompany(), 100000);
+        expect(wdb.maxActiveRootRuns(huge)).toBe(wdb.MAX_ACTIVE_ROOT_RUNS_CAP);
+      });
+
+      it('max=3：前三条准入放行，第 4 条被拒且 active / max / heldBy 三个字段都对', () => {
+        const companyId = setMaxParallel(nextCompany(), 3);
+        const goalId = newGoal(companyId);
+        const runs = ['a', 'b', 'c', 'd'].map((title) => enqueue(companyId, goalId, { title }).runId);
+
+        for (const [i, runId] of runs.slice(0, 3).entries()) {
+          expect(wdb.updateRunStatus(runId, 'queued', 'ready')).toBe(1);
+          expect(wdb.countActiveRootRuns(companyId)).toBe(i + 1);
+        }
+
+        let caught;
+        try { wdb.updateRunStatus(runs[3], 'queued', 'ready'); } catch (e) { caught = e; }
+        expect(caught).toBeInstanceOf(wdb.RunSlotBusyError);
+        expect(caught.max).toBe(3);
+        expect(caught.active).toBe(3);
+        // heldBy 点得出**具体是谁**占着 —— 少了它 409 上只剩「坑满」，人无从判断该等谁
+        expect(caught.heldBy.slice().sort()).toEqual(runs.slice(0, 3).slice().sort());
+        expect(wdb.getRun(runs[3]).run_status).toBe('queued'); // 拒绝是干净的
+
+        // 让出一个坑，第 4 条同一跳立刻过（额度是「同时几条」，不是「一共几条」）
+        expect(wdb.updateRunStatus(runs[0], 'ready', 'running')).toBe(1);   // 集内移动，不占新坑
+        expect(wdb.updateRunStatus(runs[0], 'running', 'completed')).toBe(1);
+        expect(wdb.updateRunStatus(runs[3], 'queued', 'ready')).toBe(1);
+      });
+
+      it('额度是 per-company 的：A 公司放开到 3，B 公司照样只有 1', () => {
+        const a = setMaxParallel(nextCompany(), 3);
+        const b = nextCompany(); // 没配 → 1
+        const aRuns = ['a1', 'a2'].map((t) => enqueue(a, newGoal(a), { title: t }).runId);
+        const bRuns = ['b1', 'b2'].map((t) => enqueue(b, newGoal(b), { title: t }).runId);
+
+        for (const runId of aRuns) expect(wdb.updateRunStatus(runId, 'queued', 'ready')).toBe(1);
+        expect(wdb.updateRunStatus(bRuns[0], 'queued', 'ready')).toBe(1);
+        expect(() => wdb.updateRunStatus(bRuns[1], 'queued', 'ready')).toThrow(wdb.RunSlotBusyError);
+        expect(wdb.countActiveRootRuns(a)).toBe(2);
+        expect(wdb.countActiveRootRuns(b)).toBe(1);
+      });
+
+      it('一次 tick 把空坑填满，不是一条一条来（max=3 → 三条同时起跑）', async () => {
+        const companyId = setMaxParallel(nextCompany(), 3);
+        const goalId = newGoal(companyId);
+        hangingExecutor();
+        const tasks = ['a', 'b', 'c', 'd'].map((title) => enqueue(companyId, goalId, { title }));
+
+        const res = scheduler.tick(companyId);
+        expect(res.max).toBe(3);
+        expect(res.started.map((s) => s.taskId)).toEqual(tasks.slice(0, 3).map((t) => t.taskId));
+        await flush();
+        expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+        expect(wdb.getTask(tasks[3].taskId).status).toBe('queued'); // 第 4 条还在队里
+        // 再 tick 一次不该超发：坑满就原地返回
+        expect(scheduler.tick(companyId).skipped).toBe('no-slot');
+      });
+
+      it('候选里有一条起不来时，不该白占一个名额 —— 剩下的坑照样被填满', () => {
+        const companyId = setMaxParallel(nextCompany(), 2);
+        const goalId = newGoal(companyId);
+        hangingExecutor();
+        // 队首这条的 run 行被抹掉 = 入队做了一半（5a 那条分支），它必须被跳过而不是吃掉一个坑
+        const broken = enqueue(companyId, goalId, { title: 'broken' });
+        wdb.getDb().prepare(`UPDATE tasks SET current_run_id = NULL WHERE id = ?`).run(broken.taskId);
+        const ok = ['a', 'b'].map((title) => enqueue(companyId, goalId, { title }));
+
+        const res = scheduler.tick(companyId);
+        // 批 3 的 `.slice(0, max - active)` 会把 broken 算进名额，于是只起来一条
+        expect(res.started.map((s) => s.taskId)).toEqual(ok.map((t) => t.taskId));
+        expect(wdb.getTask(broken.taskId).status).toBe('blocked');
+      });
+    });
+
     it('advanceOne 挡住 queued run：不推进、不报错、节点一个都不点亮', async () => {
       const companyId = nextCompany();
       const { runId } = enqueue(companyId, newGoal(companyId), { title: 'a' });
+/**
+ * Unit Tests — 批 4 · 「一家公司同时只有一个 active root run」解除之后的执行位（27-P3C 批 4 / 27-P4 §一.3）
+ *
+ * 与既有三份的分工（都不重复它们已经钉住的形状）：
+ *   · `task-scheduler.test.js`        —— 单个原语的形状（准入判据、CAS 的 WHERE、per-company 额度的回落）
+ *   · `task-queue-acceptance.test.js` —— 端到端「队伍自己往前走」
+ *   · `task-queue-routes.test.js`     —— HTTP 端点的字段形状
+ * 这一份钉的是批 4 拆掉唯一索引之后**只剩一道守卫**的那几条性质，每一条都在「不成立时会静默」的位置上：
+ *   ① max=1（缺省）时行为与批 3 逐字一致 —— 这是回归防线：绝大多数公司没写 max_parallel_tasks，
+ *      回落算错的话不是报错，而是「并行度悄悄变了」；
+ *   ② max=3 时三条真的同时在跑、第四条排队、收敛一条自动补位（补位那一跳靠漏斗钩子，漏了就是永远排队）；
+ *   ③ **超发拦得住**。索引没了，`updateRunStatus` 的 BEGIN IMMEDIATE 是唯一的守卫，所以这里不满足于
+ *      串行连打，还越过**进程边界**打一次：8 个独立进程越过同一个时间栅栏同时抢 3 个位。
+ *      同进程内 better-sqlite3 是同步单写者，怎么打都串行 —— 那测不到这把锁存在的理由；
+ *   ④ 坑满时人点「启动」拿到的是 409（不是 500）、点得出**全部**占位者，位子一空同一个请求就成功；
+ *   ⑤ 配置非法（0 / 负数 / 字符串 / 缺失）一律回落 1 **并留声**，绝不回落成 0（永远不出队 = 静默全停）
+ *      或无限（超发）；
+ *   ⑥ DROP 迁移：带旧索引的存量库启动一次索引就没了，重复启动、多进程同时启动都不打架。
+ *
+ * 隔离手法同 task-scheduler.test.js：**先设 GRAPH_DB_PATH / GRAPH_RUNS_DIR 再 require**
+ * （graph-run-sse 在模块加载时快照 GRAPH_RUNS_DIR，反过来会往仓库 data/companies/ 写而且不报错）。
+ * DB 路径与其它测试文件故意不同：vitest 默认按文件并行，共用一个 sqlite 文件会互相 DELETE 对方的行。
+ */
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import express from 'express';
+
+const TEST_DB_PATH = '/tmp/test-task-slots-parallel.sqlite';
+const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
+const MODULES = [
+  '../../services/graph-db',
+  '../../services/org-graph-service',
+  '../../services/work-graph-db',
+  '../../services/company-paths',
+  '../../services/graph-run-sse',
+  '../../services/graph-engine',
+  '../../services/task-settle',
+  '../../services/task-scheduler',
+  '../../routes/graph-run',
+];
+
+/** 存量库里那条索引的**原样** SQL（从批 4 的 diff 里逐字抄来，用于伪造「升级前的库」） */
+const LEGACY_INDEX_SQL = `
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_graph_runs_one_active_root
+    ON graph_runs(company_id)
+    WHERE parent_run_id IS NULL
+      AND run_status IN ('ready','running','paused')
+`;
+const INDEX_EXISTS_SQL = `
+  SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_graph_runs_one_active_root'
+`;
+
+/**
+ * 子进程脚本：本文件唯一能真正测到「跨进程」的手段。
+ * 只依赖 work-graph-db 的公开 API（路径由 WGDB_MODULE 传进来），不碰任何私有函数。
+ */
+const WORKER_SRC = `
+const wdb = require(process.env.WGDB_MODULE);
+const [mode, ...args] = process.argv.slice(2);
+const out = (o) => console.log(JSON.stringify(o));
+try {
+  if (mode === 'boot') {
+    // 「一个进程启动了一次」= 跑一遍 getDb()（建表 + 迁移块，DROP INDEX 就在里面）
+    const db = wdb.getDb();
+    out({ index: !!db.prepare(${JSON.stringify(INDEX_EXISTS_SQL)}).get() });
+  } else if (mode === 'seed') {
+    const [cid, n] = args;
+    const db = wdb.getDb();
+    const now = new Date().toISOString();
+    db.prepare(
+      "INSERT OR IGNORE INTO system_agents (id,name,scope,owner_company_id,source_kind,legacy_path,status,created_at,updated_at)"
+      + " VALUES ('solo','solo','public',NULL,'global_agent','system/agents/solo','active',?,?)"
+    ).run(now, now);
+    const g = wdb.createWorkGraph({ companyId: cid, nodes: ['solo'], edges: [] });
+    if ((g.errors || []).length) throw new Error(JSON.stringify(g.errors));
+    const runs = [];
+    for (let i = 0; i < Number(n); i += 1) {
+      runs.push(wdb.createRun({ graphKind: 'work', graphId: g.id, companyId: cid, runStatus: 'queued' }).id);
+    }
+    out({ runs });
+  } else if (mode === 'race') {
+    const [runId, startAt] = args;
+    // 忙等到同一个时间栅栏：sleep 的精度不够，而这里要的正是「同时」
+    while (Date.now() < Number(startAt)) { /* spin */ }
+    out({ changes: wdb.updateRunStatus(runId, 'queued', 'ready') });
+  } else if (mode === 'count') {
+    out({ active: wdb.countActiveRootRuns(args[0]), max: wdb.maxActiveRootRuns(args[0]) });
+  }
+} catch (err) {
+  out({ err: err.name, code: err.code, msg: err.message });
+}
+`;
+
+describe('批 4 · 公司级执行位（max_parallel_tasks）', () => {
+  let wdb;
+  let engine;
+  let sse;
+  let scheduler;
+  let runsDir;
+  let workerPath;
+  let server;
+  let origin;
+  /** 挂起的 executor promise，afterAll 统一放掉，免得留下永不 settle 的 driver */
+  const pending = [];
+
+  beforeAll(async () => {
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch { /* 本来就没有 */ } }
+    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
+    runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'task-slots-parallel-'));
+    process.env.GRAPH_RUNS_DIR = runsDir;
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+
+    wdb = require('../../services/work-graph-db');
+    sse = require('../../services/graph-run-sse');
+    engine = require('../../services/graph-engine');
+    scheduler = require('../../services/task-scheduler');
+
+    workerPath = path.join(runsDir, 'slot-worker.cjs');
+    fs.writeFileSync(workerPath, WORKER_SRC);
+
+    const app = express();
+    app.use(express.json());
+    app.use('/api/graph-runs', require('../../routes/graph-run'));
+    await new Promise((resolve) => { server = app.listen(0, resolve); });
+    origin = `http://127.0.0.1:${server.address().port}`;
+  });
+
+  /**
+   * `advanceOne` 的 ensureProjectRoot 会在**仓库的** data/companies/ 下给每家公司建项目根
+   * （它不认 GRAPH_RUNS_DIR）。只删本文件造的那些前缀目录，且必须确认里面没有 company.json
+   * —— 那是真公司，删了就是删用户数据。（写法与 task-scheduler.test.js 一致）
+   */
+  function cleanupLeakedCompanyDirs() {
+    const root = path.resolve(__dirname, '../../../data/companies');
+    if (!fs.existsSync(root)) return;
+    for (const cid of fs.readdirSync(root)) {
+      if (!cid.startsWith('slots-co-')) continue;
+      const dir = path.join(root, cid);
+      if (fs.existsSync(path.join(dir, 'company.json'))) continue;
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* 删不掉就留着 */ }
+    }
+  }
+
+  afterAll(async () => {
+    // 先放掉挂起的 executor 再等一拍：auto driver 恢复后还会跑一轮 advanceOne，
+    // 而 ensureProjectRoot 会把刚删掉的公司目录原样建回来 —— 顺序反了就等于没清理
+    for (const p of pending) p();
+    await new Promise((r) => setTimeout(r, 120));
+    scheduler.stopSweeper();
+    if (server) server.close();
+    cleanupLeakedCompanyDirs();
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch { /* 已经删了 */ } }
+    delete process.env.GRAPH_DB_PATH;
+    try { fs.rmSync(runsDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    delete process.env.GRAPH_RUNS_DIR;
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+  });
+
+  beforeEach(() => {
+    const db = wdb.getDb();
+    db.pragma('foreign_keys = OFF');
+    db.exec(`
+      DELETE FROM graph_run_loop_records;
+      DELETE FROM graph_run_nodes;
+      DELETE FROM graph_runs;
+      DELETE FROM tasks;
+      DELETE FROM goals;
+      DELETE FROM work_graph_edges;
+      DELETE FROM work_graph_nodes;
+      DELETE FROM work_graphs;
+      DELETE FROM system_agents;
+    `);
+    db.pragma('foreign_keys = ON');
+    engine.setAgentExecutor(null);
+  });
+
+  // ── 夹具 ──────────────────────────────────────────────────────
+  let seq = 0;
+  /** 每个用例一家独立公司：执行位是按 company 数的 */
+  const nextCompany = () => `slots-co-${++seq}`;
+
+  function ensureAgents(ids) {
+    const now = new Date().toISOString();
+    const ins = wdb.getDb().prepare(`
+      INSERT OR IGNORE INTO system_agents
+        (id, name, scope, owner_company_id, source_kind, legacy_path, status, created_at, updated_at)
+      VALUES (?, ?, 'public', NULL, 'global_agent', ?, 'active', ?, ?)
+    `);
+    for (const id of new Set(ids)) ins.run(id, id, `system/agents/${id}`, now, now);
+  }
+
+  function buildGraph(companyId, nodes = ['solo']) {
+    ensureAgents(nodes);
+    const edges = nodes.slice(1).map((to, i) => ({ from: nodes[i], to }));
+    const g = wdb.createWorkGraph({ companyId, nodes, edges });
+    expect(g.errors || []).toEqual([]);
+    return g.id;
+  }
+
+  const newGoal = (companyId) => wdb.createGoal({ companyId, title: 'g', description: 'g' }).id;
+
+  /** 入队：建 task 行 → 建 queued 的 run 行（不占位）→ task 标 queued + 挂 current_run_id */
+  function enqueue(companyId, goalId, { title, mode = 'auto' } = {}) {
+    const task = wdb.createTask({
+      goalId, companyId, title, description: `${title} 的描述`, executionMode: mode,
+    });
+    const run = wdb.createRun({
+      graphKind: 'work',
+      graphId: buildGraph(companyId),
+      companyId,
+      goalId,
+      taskId: task.id,
+      executionMode: mode,
+      runStatus: 'queued',
+    });
+    wdb.updateTask(task.id, { status: 'queued', currentRunId: run.id, queuedAt: new Date().toISOString() });
+    return { taskId: task.id, runId: run.id };
+  }
+
+  /** 永不 resolve 的 executor：让起跑的 run 稳稳停在 running，好观察执行位 */
+  function hangingExecutor(onCall) {
+    engine.setAgentExecutor((ctx) => {
+      if (onCall) onCall(ctx);
+      return new Promise((resolve) => pending.push(() => resolve({ status: 'success' })));
+    });
+  }
+
+  const flush = () => new Promise((r) => setImmediate(() => setImmediate(r)));
+
+  /** 给这家公司写一份 company.json（走 company-paths，认 GRAPH_RUNS_DIR，绝不碰真 data/companies/） */
+  function setMaxParallel(companyId, n) {
+    const { companyRootDir } = require('../../services/company-paths');
+    const dir = companyRootDir(companyId);
+    fs.mkdirSync(dir, { recursive: true });
+    const cfg = { id: companyId, name: companyId };
+    if (n !== undefined) cfg.max_parallel_tasks = n;
+    fs.writeFileSync(path.join(dir, 'company.json'), JSON.stringify(cfg));
+    return companyId;
+  }
+
+  const statuses = (ids) => ids.map((id) => wdb.getTask(id).status);
+
+  /** 起一个子进程跑 worker，拿回 { code, json, stdout, stderr } */
+  function runWorker(args, { dbPath = TEST_DB_PATH } = {}) {
+    return new Promise((resolve) => {
+      const child = spawn(process.execPath, [workerPath, ...args], {
+        env: {
+          ...process.env,
+          GRAPH_DB_PATH: dbPath,
+          GRAPH_RUNS_DIR: runsDir,
+          WGDB_MODULE: require.resolve('../../services/work-graph-db'),
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', (d) => { stdout += d; });
+      child.stderr.on('data', (d) => { stderr += d; });
+      child.on('close', (code) => {
+        let json = null;
+        try { json = JSON.parse(stdout.trim().split('\n').pop()); } catch { /* 留给断言去报 */ }
+        resolve({ code, json, stdout, stderr });
+      });
+    });
+  }
+
+  // ────────────────────────────────────────────────────────────────
+  // ① max=1：默认配置下的行为必须与批 3 逐字一致
+  // ────────────────────────────────────────────────────────────────
+  describe('① max=1（缺省）：批 4 之后一个字都不该变', () => {
+    it('没配 company.json 的公司：一次只放一条、其余照排、收敛后自动接力，全程 active ≤ 1', async () => {
+      const companyId = nextCompany();
+      const goalId = newGoal(companyId);
+      hangingExecutor();
+      // 「读不到配置 = 1」是保护全仓存量公司与存量单测的那条断言
+      expect(wdb.maxActiveRootRuns(companyId)).toBe(1);
+
+      const ids = ['a', 'b', 'c'].map((title) => enqueue(companyId, goalId, { title }));
+      const first = scheduler.tick(companyId);
+      expect(first.max).toBe(1);
+      expect(first.started.map((s) => s.taskId)).toEqual([ids[0].taskId]);
+      await flush();
+      expect(statuses(ids.map((t) => t.taskId))).toEqual(['running', 'queued', 'queued']);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(1);
+
+      // 再 tick 一次绝不能多起一条（批 3 这里就是 no-slot）
+      expect(scheduler.tick(companyId).skipped).toBe('no-slot');
+      expect(wdb.countActiveRootRuns(companyId)).toBe(1);
+      // 位次口径没变：跑着的那条不在队里，b 是第 1
+      expect(scheduler.queuePosition(companyId, ids[1].taskId)).toBe(1);
+      expect(scheduler.queuePosition(companyId, ids[2].taskId)).toBe(2);
+
+      // 收敛一条 → 漏斗钩子自己把下一条拉起来，**没有人再 tick 一次**
+      sse.transitionRun(ids[0].runId, 'running', 'completed', {}, { summary: '用例直推终态' });
+      await flush();
+      expect(statuses(ids.map((t) => t.taskId))).toEqual(['completed', 'running', 'queued']);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(1);
+
+      sse.transitionRun(ids[1].runId, 'running', 'completed', {}, { summary: '用例直推终态' });
+      await flush();
+      expect(statuses(ids.map((t) => t.taskId))).toEqual(['completed', 'completed', 'running']);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(1);
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
+  // ② max=3：三条同时在跑
+  // ────────────────────────────────────────────────────────────────
+  describe('② max=3：三条无依赖的任务同时进入 running', () => {
+    it('前三条同时跑、第四条排队；收敛一条之后第四条自动补位（补位靠漏斗钩子，不靠人再点一次）', async () => {
+      const companyId = setMaxParallel(nextCompany(), 3);
+      const goalId = newGoal(companyId);
+      hangingExecutor();
+      const ids = ['a', 'b', 'c', 'd'].map((title) => enqueue(companyId, goalId, { title }));
+
+      const res = scheduler.tick(companyId);
+      expect(res.max).toBe(3);
+      expect(res.started.map((s) => s.taskId)).toEqual(ids.slice(0, 3).map((t) => t.taskId));
+      await flush();
+
+      // 「同时在跑」要三条都验：任务行是 running，run 行在活跃集里，计数是 3
+      expect(statuses(ids.map((t) => t.taskId))).toEqual(['running', 'running', 'running', 'queued']);
+      for (const t of ids.slice(0, 3)) {
+        expect(wdb.ACTIVE_ROOT_RUN_STATUS).toContain(wdb.getRun(t.runId).run_status);
+      }
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+      expect(wdb.getRun(ids[3].runId).run_status).toBe('queued'); // 第四条一个位都没占
+      expect(scheduler.queuePosition(companyId, ids[3].taskId)).toBe(1);
+      expect(scheduler.tick(companyId).skipped).toBe('no-slot'); // 满了就是满了
+
+      // 收敛一条 → 第四条自己顶上来，且顶上来之后仍然是 3（不是 4）
+      sse.transitionRun(ids[0].runId, 'running', 'completed', {}, { summary: '用例直推终态' });
+      await flush();
+      expect(statuses(ids.map((t) => t.taskId))).toEqual(['completed', 'running', 'running', 'running']);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
+  // ③ 超发拦得住 —— 索引已 DROP，这一节是全批最重要的一条
+  // ────────────────────────────────────────────────────────────────
+  describe('③ 超发：唯一索引没了之后，活跃数永不超过 max', () => {
+    it('8 条抢 3 个位：恰好 3 条进得去，其余全是干净的拒绝（一个字都没写进去）', () => {
+      const companyId = setMaxParallel(nextCompany(), 3);
+      const goalId = newGoal(companyId);
+      const runs = Array.from({ length: 8 }, (_, i) => enqueue(companyId, goalId, { title: `t${i}` }).runId);
+
+      const results = runs.map((runId) => {
+        try {
+          return { ok: wdb.updateRunStatus(runId, 'queued', 'ready') };
+        } catch (err) {
+          return { err: err.name, active: err.active, max: err.max };
+        }
+      });
+      expect(results.filter((r) => r.ok === 1)).toHaveLength(3);
+      // 被拒的每一条都必须是 RunSlotBusyError（别的错 = 别的毛病，不许混过去），
+      // 而且拒绝当下报的 active 恒等于 max —— 报成别的数就说明计数和判据不同源
+      for (const r of results.filter((x) => !x.ok)) {
+        expect(r).toEqual({ err: 'RunSlotBusyError', active: 3, max: 3 });
+      }
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+      // 拒绝是干净的：没进去的那 5 条一条都没被改写
+      expect(runs.filter((id) => wdb.getRun(id).run_status === 'queued')).toHaveLength(5);
+    });
+
+    it('出队过程中反手再 tick 一次（漏斗钩子的真实形状）：活跃数一刻都没超过 max', async () => {
+      const companyId = setMaxParallel(nextCompany(), 3);
+      const goalId = newGoal(companyId);
+      const observed = [];
+      const nested = [];
+      // executor 在起跑的栈里被调用 —— 这正是「tick 起 run → run 转状态 → 钩子又 tick」那条回路
+      hangingExecutor(() => {
+        observed.push(wdb.countActiveRootRuns(companyId));
+        nested.push(scheduler.tick(companyId));
+      });
+      const ids = Array.from({ length: 8 }, (_, i) => enqueue(companyId, goalId, { title: `t${i}` }));
+
+      scheduler.tick(companyId);
+      await flush();
+      await flush();
+
+      expect(observed.length).toBeGreaterThan(0);
+      expect(Math.max(...observed)).toBeLessThanOrEqual(3); // 中途一刻都没超发
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+      expect(statuses(ids.map((t) => t.taskId)).filter((s) => s === 'running')).toHaveLength(3);
+      // 嵌套那次要么被重入闸门挡回（同一次 tick 的栈里），要么老老实实报坑满 —— 都不许多起一条
+      for (const r of nested) {
+        expect(['reentrant', 'no-slot', undefined]).toContain(r.skipped);
+        if (!r.skipped) expect(r.started).toEqual([]);
+      }
+    });
+
+    it('多进程同时抢：8 个独立进程越过同一个时间栅栏，活跃数仍然只有 3', async () => {
+      // 单独一个库文件：跨进程这一节要测的是 BEGIN IMMEDIATE 那把写锁，
+      // 与本文件其它用例共用一个库只会让计数互相污染。
+      const dbPath = path.join(runsDir, 'mp-race.sqlite');
+      const companyId = setMaxParallel(`slots-mp-${++seq}`, 3);
+
+      const seeded = await runWorker(['seed', companyId, '8'], { dbPath });
+      expect(seeded.code, seeded.stderr).toBe(0);
+      const runIds = seeded.json.runs;
+      expect(runIds).toHaveLength(8);
+
+      // 同一个时间栅栏：子进程各自忙等到这一刻再打（起进程本身要几十毫秒，不留余量就变成串行）
+      const startAt = Date.now() + 1500;
+      const results = await Promise.all(runIds.map((runId) => runWorker(['race', runId, String(startAt)], { dbPath })));
+      for (const r of results) expect(r.code, r.stderr).toBe(0);
+
+      const admitted = results.filter((r) => r.json && r.json.changes === 1);
+      const refused = results.filter((r) => r.json && r.json.err);
+      expect(admitted).toHaveLength(3);
+      // 拒绝的一律是 RunSlotBusyError —— 出现 SQLITE_BUSY / UNIQUE 就说明守卫不是靠事务成立的
+      expect(refused.map((r) => r.json.err)).toEqual(['RunSlotBusyError', 'RunSlotBusyError',
+        'RunSlotBusyError', 'RunSlotBusyError', 'RunSlotBusyError']);
+      const counted = await runWorker(['count', companyId], { dbPath });
+      expect(counted.json).toEqual({ active: 3, max: 3 });
+    }, 60000);
+
+    it('旧版本进程把唯一索引建回来时必须吵：SQLITE_CONSTRAINT_UNIQUE 不算「没抢到」', () => {
+      const companyId = setMaxParallel(nextCompany(), 3);
+      const goalId = newGoal(companyId);
+      const a = enqueue(companyId, goalId, { title: 'a' });
+      const b = enqueue(companyId, goalId, { title: 'b' });
+      const db = wdb.getDb();
+
+      db.exec(LEGACY_INDEX_SQL); // 伪造「旧版本进程启动了一次」
+      try {
+        expect(wdb.updateRunStatus(a.runId, 'queued', 'ready')).toBe(1);
+        // max=3 明明还有位，索引却把第二条按 v1 的规矩拒了 —— 并行被悄悄压回 1
+        let caught;
+        try { wdb.updateRunStatus(b.runId, 'queued', 'ready'); } catch (e) { caught = e; }
+        expect(caught).toBeDefined();
+        expect(caught.code).toBe('SQLITE_CONSTRAINT_UNIQUE');
+        // 关键：**不能**被当成正常竞争。当成竞争的话调度器 continue 掉，
+        // 这条任务永远排队、日志一行没有、界面与正常排队一模一样。
+        expect(wdb.isSlotRaceError(caught)).toBe(false);
+      } finally {
+        db.exec('DROP INDEX IF EXISTS idx_graph_runs_one_active_root');
+      }
+      // 索引一没，同一跳立刻过 —— 证明刚才那次拒绝确实是索引干的，不是额度不够
+      expect(wdb.updateRunStatus(b.runId, 'queued', 'ready')).toBe(1);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(2);
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
+  // ④ 恢复路径：坑满 → 409（不是 500）→ 位子一空同一个请求就成功
+  // ────────────────────────────────────────────────────────────────
+  describe('④ 位满时人点「启动」：409 且点名全部占位者，位子一空能回来', () => {
+    it('max=3 全占满 → 409 + holders 三条都在 + hint 指向每一条真停得掉的；腾一个位就 200', async () => {
+      const companyId = setMaxParallel(nextCompany(), 3);
+      const goalId = newGoal(companyId);
+      // 占位的三条：直推 running（用例不需要真跑 agent）
+      const holders = ['h1', 'h2', 'h3'].map((title) => {
+        const { taskId, runId } = enqueue(companyId, goalId, { title });
+        wdb.getDb().prepare(`UPDATE graph_runs SET run_status = 'running' WHERE id = ?`).run(runId);
+        return { taskId, runId };
+      });
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3);
+
+      // 被挡的那条：**没有 task** 的已收敛 run（裸 run 退不回队列，错误才会一路抛到路由层）
+      const dead = wdb.createRun({ graphKind: 'work', graphId: buildGraph(companyId, ['solo2']), companyId });
+      wdb.getDb().prepare(`UPDATE graph_runs SET run_status = 'completed' WHERE id = ?`).run(dead.id);
+      const nodeId = wdb.getRunState(dead.id).nodes[0].id;
+      wdb.getDb().prepare(`UPDATE graph_run_nodes SET status = 'fail' WHERE id = ?`).run(nodeId);
+
+      const url = `${origin}/api/graph-runs/${dead.id}/nodes/${nodeId}/retry`;
+      const r1 = await fetch(url, { method: 'POST' });
+      const body = await r1.json();
+      expect(r1.status).toBe(409); // 500 会让调用方去重试 / 报故障，而这里唯一有用的动作是等或停
+      expect(body.reason).toBe('run-slot-busy');
+      expect({ active: body.active, max: body.max }).toEqual({ active: 3, max: 3 });
+      // 三条占位者一条都不能少：只点名一条的话，用户停掉它发现还是起不来
+      expect(body.holders.map((h) => h.runId).sort()).toEqual(holders.map((h) => h.runId).sort());
+      expect(body.holders.map((h) => h.taskId).sort()).toEqual(holders.map((h) => h.taskId).sort());
+      for (const h of holders) expect(body.hint).toContain(`/api/graph-runs/${h.runId}/stop`);
+      // 拒绝是干净的：节点没被动过
+      expect(wdb.getRunNode(nodeId).status).toBe('fail');
+      expect(wdb.getRunNode(nodeId).attempt).toBe(0);
+
+      // 腾出一个位 → 同一个请求就成功（这才叫「回得来」）
+      sse.transitionRun(holders[0].runId, 'running', 'completed', {}, { summary: '用例直推终态' });
+      await flush();
+      const r2 = await fetch(url, { method: 'POST' });
+      const ok = await r2.json();
+      expect(r2.status).toBe(200);
+      expect(ok.ok).toBe(true);
+      // 它真的占上了刚空出来的那个位（ready 还是已经被驱动推到 running 都算 —— 判据是活跃集，
+      // 不是某个具体状态：按具体状态断言的话，哪天驱动早半拍这条用例就会假红）
+      expect(wdb.ACTIVE_ROOT_RUN_STATUS).toContain(wdb.getRun(dead.id).run_status);
+      expect(wdb.countActiveRootRuns(companyId)).toBe(3); // 3 个位：走了一条、进来一条
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
+  // ⑤ 配置非法 → 回落 1 并留声
+  // ────────────────────────────────────────────────────────────────
+  describe('⑤ 配置非法：回落 1，绝不回落成 0（静默全停）或无限（超发）', () => {
+    it('0 / -1 / "abc" / true / 小数 / 缺字段 / 没文件 / 坏 JSON 一律 1，且每一次都真的打了日志', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        for (const bad of [0, -1, 'abc', true, 1.5, '3']) {
+          const cid = setMaxParallel(nextCompany(), bad);
+          warn.mockClear();
+          expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+          // 「配置写错了就当没配」必须是能看见的，否则就是一次静默降级
+          expect(warn).toHaveBeenCalledTimes(1);
+          expect(String(warn.mock.calls[0][0])).toContain(cid);
+        }
+
+        // 坏掉的 JSON：不许把一次出队变成 500，但同样必须留声
+        const broken = nextCompany();
+        const { companyRootDir } = require('../../services/company-paths');
+        fs.mkdirSync(companyRootDir(broken), { recursive: true });
+        fs.writeFileSync(path.join(companyRootDir(broken), 'company.json'), '{ 这不是 JSON');
+        warn.mockClear();
+        expect(wdb.maxActiveRootRuns(broken)).toBe(1);
+        expect(warn).toHaveBeenCalledTimes(1);
+
+        // 没文件 / 没这个字段：这是绝大多数公司的常态，不该刷日志
+        warn.mockClear();
+        expect(wdb.maxActiveRootRuns(nextCompany())).toBe(1);
+        expect(wdb.maxActiveRootRuns(setMaxParallel(nextCompany(), undefined))).toBe(1);
+        expect(warn).not.toHaveBeenCalled();
+
+        // 超上限截断到 CAP（不是回落 1，也不是当真）——「无限」在这里同样不许出现
+        const huge = setMaxParallel(nextCompany(), 1e6);
+        warn.mockClear();
+        expect(wdb.maxActiveRootRuns(huge)).toBe(wdb.MAX_ACTIVE_ROOT_RUNS_CAP);
+        expect(Number.isFinite(wdb.MAX_ACTIVE_ROOT_RUNS_CAP)).toBe(true);
+        expect(warn).toHaveBeenCalledTimes(1);
+      } finally {
+        warn.mockRestore();
+      }
+    });
+
+    it('同一份非法配置只吵一次（日志不刷屏），但**回落值每次都算**，不是缓存下来的', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const cid = setMaxParallel(nextCompany(), 0);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(warn).toHaveBeenCalledTimes(1);
+
+        // 把配置改对：**不重启、不清缓存**，下一次准入就该按新值走（额度是调用时读盘，不是模块级快照）
+        setMaxParallel(cid, 2);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(2);
+        const goalId = newGoal(cid);
+        const runs = ['a', 'b', 'c'].map((t) => enqueue(cid, goalId, { title: t }).runId);
+        expect(wdb.updateRunStatus(runs[0], 'queued', 'ready')).toBe(1);
+        expect(wdb.updateRunStatus(runs[1], 'queued', 'ready')).toBe(1);
+        expect(() => wdb.updateRunStatus(runs[2], 'queued', 'ready')).toThrow(wdb.RunSlotBusyError);
+
+        // 再改回非法值：回落 1 立刻生效，坑满的判据跟着变（此刻 2 条在跑 > 1，新的一条必被拒）
+        setMaxParallel(cid, -5);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        let caught;
+        try { wdb.updateRunStatus(runs[2], 'queued', 'ready'); } catch (e) { caught = e; }
+        expect(caught).toBeInstanceOf(wdb.RunSlotBusyError);
+        expect(caught.max).toBe(1);
+      } finally {
+        warn.mockRestore();
+      }
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
+  // ⑥ DROP 迁移：存量库（带旧索引）启动一次就没了
+  // ────────────────────────────────────────────────────────────────
+  describe('⑥ 迁移：带 idx_graph_runs_one_active_root 的存量库', () => {
+    const Database = require('better-sqlite3');
+    /** 直接开一个连接看索引在不在 —— 不经过 work-graph-db，免得「自己证明自己」 */
+    function indexExists(dbPath) {
+      const db = new Database(dbPath, { readonly: true });
+      try { return !!db.prepare(INDEX_EXISTS_SQL).get(); } finally { db.close(); }
+    }
+    function createLegacyIndex(dbPath) {
+      const db = new Database(dbPath);
+      try { db.exec(LEGACY_INDEX_SQL); } finally { db.close(); }
+    }
+
+    it('启动一次索引就没了；再启动两次不报错（DROP INDEX IF EXISTS 本身幂等）', async () => {
+      const dbPath = path.join(runsDir, 'migrate-seq.sqlite');
+      const first = await runWorker(['boot'], { dbPath });
+      expect(first.code, first.stderr).toBe(0);
+
+      // 伪造存量库：把批 4 删掉的那条索引原样建回去
+      createLegacyIndex(dbPath);
+      expect(indexExists(dbPath)).toBe(true);
+
+      const second = await runWorker(['boot'], { dbPath });
+      expect(second.code, second.stderr).toBe(0);
+      expect(second.json).toEqual({ index: false }); // 进程自己看到的
+      expect(indexExists(dbPath)).toBe(false);       // 库里真的没了
+
+      for (let i = 0; i < 2; i += 1) {
+        const again = await runWorker(['boot'], { dbPath });
+        expect(again.code, again.stderr).toBe(0);
+        expect(again.json).toEqual({ index: false });
+      }
+    }, 30000);
+
+    it('多进程同时启动不打架：5 个进程一起跑迁移，全部退出码 0，索引没了', async () => {
+      const dbPath = path.join(runsDir, 'migrate-parallel.sqlite');
+      expect((await runWorker(['boot'], { dbPath })).code).toBe(0);
+      createLegacyIndex(dbPath);
+      expect(indexExists(dbPath)).toBe(true);
+
+      const boots = await Promise.all(Array.from({ length: 5 }, () => runWorker(['boot'], { dbPath })));
+      for (const b of boots) {
+        expect(b.code, b.stderr).toBe(0);   // SQLITE_BUSY / "no such index" 都会在这里现形
+        expect(b.json).toEqual({ index: false });
+      }
+      expect(indexExists(dbPath)).toBe(false);
+    }, 30000);
+
+    it('本文件这个库自己也没有那条索引（新建库走 CREATE TABLE 块，那里已经没有它了）', () => {
+      expect(wdb.getDb().prepare(INDEX_EXISTS_SQL).get()).toBeUndefined();
+    });
+  });
+});
@@ -13,6 +13,7 @@
     <NewGoalForm
       :company-id="companyId"
       :queue-stat="stat"
+      :slots="slots"
       @changed="$emit('refresh')"
       @dispatched="onDispatched"
     />
@@ -150,6 +151,8 @@ const props = defineProps({
   loading: { type: Boolean, default: false },
   selectedTaskId: { type: String, default: '' },
   selectedGoalId: { type: String, default: '' },
+  /** 执行位 `{ max, used, free }`，服务端原样给的；没给就是 null（见 goal-task-model.readSlots） */
+  slots: { type: Object, default: null },
 });
 const emit = defineEmits(['select', 'refresh']);
@@ -32,6 +32,8 @@
     </div>
     <p v-if="err" class="err">{{ err }}</p>
+    <!-- 200 但结果不是用户以为的那个：坑满 → 退回队列。不说的话界面上什么都看不出来 -->
+    <p v-if="notice" class="notice">{{ notice }}</p>
     <WorkGraphCanvas
       :nodes="nodes"
@@ -102,6 +104,8 @@ const selectedDefId = ref(null);
 const loading = ref(false);
 const busy = ref(false);
 const err = ref('');
+/** 非错误、但必须让用户看见的一句话（例：启动被退回队列）。与 err 互斥。 */
+const notice = ref('');
 const mode = ref('manual');
 const confirmAuto = ref(false);
 const sseStatus = ref('idle');
@@ -225,7 +229,17 @@ async function act(op, body) {
       body: JSON.stringify(body || {}),
     });
     const j = await r.json().catch(() => ({}));
-    err.value = r.ok ? '' : (j.error || `HTTP ${r.status}`);
+    // ⚠️ 200 不等于「你要的事发生了」。坑满时「启动」会走 admitOrRequeue 把这条 run
+    // **退回队列**，返回的是 200 + { ok:true, requeued:true, runStatus:'queued' }。
+    // 只判 r.ok 的话界面上一个字都不会说，而随后按钮全灰、run 面板换成定义视图 ——
+    // 用户点了「启动」，得到的是「什么都没说、图不见了」（批 3 复核 N2）。
+    if (r.ok && j.requeued) {
+      err.value = '';
+      notice.value = '执行位已满，这条任务已退回队列排队 —— 坑一空会自动接着跑，不用再点。';
+    } else {
+      notice.value = '';
+      err.value = r.ok ? '' : (j.error || `HTTP ${r.status}`);
+    }
   } catch (e) {
     err.value = e.message;
   } finally {
@@ -339,6 +353,8 @@ function fmtNum(n) { return (n || 0).toLocaleString(); }
 .btn.retry { border-color:#c96a00; color:#c96a00; }
 .next-hint { font-size:11px; color:#666; }
 .next-hint code { background:#eef4ff; padding:1px 5px; border-radius:3px; }
+.notice { color: var(--text-secondary); background: var(--bg-overlay); border: 1px dashed var(--border-primary);
+  border-radius: 6px; padding: 6px 8px; font-size: 12px; line-height: 1.5; margin: 6px 0; }
 .err { color:#c00; font-size:12px; margin:0; background:#fff5f5; border-left:3px solid #c00; padding:5px 8px; }
 .compact .ctrl .btn { padding:3px 7px; font-size:11px; }
@@ -159,6 +159,13 @@ const props = defineProps({
   companyId: { type: String, required: true },
   /** { running, queued, blocked } —— 由父组件从整棵目标树数出来（goal-task-model.queueStat） */
   queueStat: { type: Object, default: () => ({ running: 0, queued: 0, blocked: 0 }) },
+  /**
+   * 执行位 `{ max, used, free }` —— **服务端原样给的**（形状逐字同
+   * `server/routes/graph-run.js#slotState`，409 `run-slot-busy` 也从它取），前端一个数都不推导。
+   * 服务端没给（今天就是这样）时传 null，文案自动退回批 3 原样。
+   * 判据与退化分支都钉在 goal-task-model.test.js 的 readSlots / queueNoteText 两组用例里。
+   */
+  slots: { type: Object, default: null },
 });
 /**
  * changed —— 库里的 goal/task 变了，父组件重拉整棵树（建 goal / 改 task / 删 task 都发）。
@@ -175,7 +182,7 @@ const ADD_ROW_DISABLED =
  * 和「正在提交」）：批 3 之后下达就是入队，公司里有任务在跑不再是拒绝的理由，
  * 把按钮灰掉等于把一条现在走得通的路继续锁着。文案是纯函数，测试在 goal-task-model.test.js。
  */
-const queueNote = computed(() => queueNoteText(props.queueStat));
+const queueNote = computed(() => queueNoteText(props.queueStat, props.slots));
 /** closed → step1 →（split? splitting : —）→ step2。creating 是 step1 的提交中态 */
 const phase = ref('closed');
@@ -228,6 +228,39 @@ export function taskActions(task) {
   return acts;
 }
+// ────────────────────────────────────────────────────────────────────────────
+// 执行位（批 4：一家公司可以同时跑 max_parallel_tasks 条 root run）
+// ────────────────────────────────────────────────────────────────────────────
+
+/**
+ * 服务端给的「执行位」快照 → `{ max, used, free }`，给不出就是 `null`。
+ *
+ * **形状逐字沿用服务端唯一那一份**：`server/routes/graph-run.js#slotState` 返回
+ * `{ max, used, free, holders }`（409 `run-slot-busy` 的 body 与 `routes/company.js`
+ * 的 409 都从它取）。这里连 `free` 都**读**服务端的、不自己 `max - used` ——
+ * 一做减法就是第二个持有者，而 `slotState` 那边的 free 还带着「max 刚改小」的截断语义。
+ *
+ * 校验从严、给不出就返回 null：`max` 是 per-company 配置（`company.json.max_parallel_tasks`），
+ * 服务端没吐、吐了个字符串，都不能让界面凭空说出一个「3 个执行位」来。
+ * null 时所有文案退回**批 3 的原样**（只说在跑几个、不提总数），少说一句好过说错一句。
+ *
+ * ⚠️ **今天还没有任何端点把它吐给前端**：`slotState` 只喂 409 的 body，
+ * `GET /:cid/goals` 与 `GET /:cid/tasks` 都还没带 `slots`。所以现在走的恒是 null 那一支
+ * = 与批 3 完全一致。服务端补的时候直接把 `slotState(companyId)` 的返回值挂上去即可
+ * （holders 可留可去，这里不读），别在那条路上写第二份取值域。
+ */
+export function readSlots(raw) {
+  const s = raw || {};
+  // **只认真正的 number**，不走 Number() 转换：`Number(null)` / `Number('')` 都是 0，
+  // 于是一个字段缺失的响应会被读成「0 个执行位在用」并原样显示出去 —— 那正是本函数要挡的
+  // 「凭空说出一个数」。字符串数字同理：服务端吐 '3' 说明那一头的形状已经不对了，
+  // 该让文案退回批 3 原样并被人看见，而不是替它纠正。
+  const { max, used, free } = s;
+  if (![max, used, free].every(Number.isInteger)) return null;
+  if (max < 1 || used < 0 || free < 0) return null;
+  return { max, used, free };
+}
+
 /**
  * 全公司在途统计，喂「新目标」表单那句提示。
  * 只数后端给的 status，不推断位次 —— 一条**还没建出来**的任务排第几，谁都算不准
@@ -259,19 +292,37 @@ export function queueStat(goals = []) {
  *
  * @returns {string} 队里空空如也时返回 ''（没有队伍就没什么好说的）
  */
-export function queueNoteText(stat) {
+export function queueNoteText(stat, rawSlots) {
   const s = stat || {};
   const running = Number(s.running) || 0;
   const queued = Number(s.queued) || 0;
   const blocked = Number(s.blocked) || 0;
-  if (!running && !queued && !blocked) return '';
+  const slots = readSlots(rawSlots);
+  if (!running && !queued && !blocked && !(slots && slots.used)) return '';
   const parts = [];
-  if (running) parts.push(`${running} 个任务在跑`);
+  // 有 slots 就报「几分之几个执行位」——「1 个任务在跑」在 3 坑的公司里读起来像「满了」，
+  // 而它其实还空着 2 个，这是批 4 之后这句话唯一会骗人的地方。
+  //
+  // **两个数各归各的来源，不互相换算**：执行位用服务端的 slots.used（数的是活跃 root run，
+  // 含 ready/paused），在跑几条任务用 stat.running（数的是 task 行）。两者绝大多数时候相等，
+  // 但不是同一件事 —— 拿一个去顶另一个就是又一次「前端自己推导后端的取值域」。
+  if (slots) parts.push(`${slots.used}/${slots.max} 个执行位在用`);
+  else if (running) parts.push(`${running} 个任务在跑`);
+  // 两个数对不上时**两个都报**：藏掉一个就等于替服务端断言它们该相等
+  if (slots && running && running !== slots.used) parts.push(`${running} 个任务在跑`);
   if (queued) parts.push(`${queued} 个在排队`);
   if (blocked) parts.push(`${blocked} 个卡在上游`);
-  return `当前${parts.join('、')}。「全部下达」照常可点：本次的任务会进同一个队列，`
-    + '排在它们后面，坑一空就自动开跑 —— 确切位次由服务端算，下达后显示在左栏每一行上。';
+
+  // 尾巴分两支：知道还有几个空位时就说「有空位」（这才是用户此刻真正在问的「我要等吗」），
+  // 不知道就退回批 3 原样。**不预测本次会不会立刻开跑**：那取决于 priority / 依赖 / 执行模式，
+  // 三样都只有服务端算得准，写死一句「马上开跑」就是编一个承诺。
+  const tail = slots && slots.free > 0
+    ? `还空着 ${slots.free} 个执行位。「全部下达」照常可点：本次的任务会进同一个队列，`
+      + '有空位就会被调度器直接拉起来 —— 确切位次由服务端算，下达后显示在左栏每一行上。'
+    : '「全部下达」照常可点：本次的任务会进同一个队列，'
+      + '排在它们后面，坑一空就自动开跑 —— 确切位次由服务端算，下达后显示在左栏每一行上。';
+  return `当前${parts.join('、')}。${tail}`;
 }
 /**
@@ -306,13 +357,42 @@ export function dispatchedTaskId(d) {
 /**
  * 选中一条还没起过 run 的 task 时，org 栏顶上那句话。
  * 排队中的那条要说清「前面还有几个」—— 这是「为什么点了下达却什么都没发生」的唯一答案。
+ *
+ * 批 4 之后位次单独一个数**答不了「我还要等吗」**：3 个执行位的公司里排第 3 位是「马上就跑」，
+ * 1 个执行位的公司里排第 2 位就是「要等一整轮」。所以 slots 给得出来时把空位一起说了。
+ * `slots` 给不出（服务端还没吐这个字段）就退回批 3 原样 —— 见 readSlots 上那段。
+ *
+ * **manual 的排队任务单独一句**：调度器只出队 `execution_mode==='auto'` 的
+ * （`server/services/task-scheduler.js#tickInner`，§五.2bis 明写它故意不碰 manual），
+ * 所以对一条 manual 任务说「有空位就自动开跑」是纯粹的谎 —— 它会一直排在那里，
+ * 直到有人点 ⋯ 菜单里的「立即开始」。这一条与并行无关，是批 3 就在的，批 4 顺手补上。
  */
-export function pendingRunHint(task) {
+export function pendingRunHint(task, rawSlots) {
   const t = task || {};
   const tail = '下面是 org graph 定义本身，节点状态一律 pending。';
   if (t.status !== 'queued') return `还没有起过 run（${taskStyle(t.status).label}），${tail}`;
+
+  const slots = readSlots(rawSlots);
+  const free = slots ? slots.free : null;
+  // 手动模式：空位有多少都不会让它自己动起来，先把这件事说清楚
+  if (t.mode === 'manual') {
+    return '排队中。这条是「手动」模式，调度器不会自动拉起它'
+      + `（它只出队自动模式的任务${free ? `，${free} 个执行位空着也一样` : ''}）；`
+      + `用任务行的 ⋯ 菜单「立即开始」抢一个执行位，${tail}`;
+  }
+
   const n = Number(t.queuePosition);
   if (!Number.isInteger(n) || n <= 0) return `排队中（服务端没给位次），${tail}`;
+  if (slots && n <= free) {
+    return `排在第 ${n} 位，${slots.used}/${slots.max} 个执行位在用、还空着 ${free} 个 ——`
+      + ` 下一轮调度就会被拉起来（最迟 60s 的兜底扫描），${tail}`;
+  }
+  if (slots) {
+    // 「还要等几个」= 还差几个执行位腾出来（n - free），不是「前面还有几个任务」（n-1）：
+    // 空位会先被前 free 条占掉，剩下的每腾出一个坑才轮下去一位。free=0 时这句就是「等 n 个」
+    return `排在第 ${n} 位，${slots.used}/${slots.max} 个执行位在用、没有空位 ——`
+      + ` 还要等 ${n - free} 个执行位腾出来才轮到（按服务端的队列口径），${tail}`;
+  }
   if (n === 1) return `排在队首，前面的任务一收敛就自动开跑，${tail}`;
   return `排队中，前面还有 ${n - 1} 个任务，${tail}`;
 }
@@ -376,6 +456,12 @@ export function dependsLabel(task, siblings = []) {
  * 默认选中：最近一条 running 的 task，没有就最近创建的 task。
  * 「最近」按 createdAt 倒序；goals 列表本身已经是 created_at DESC，但不能依赖调用方的顺序 ——
  * 轮询回来的数组顺序变了就会让选中态莫名其妙跳一次。
+ *
+ * 批 4（一家公司可以同时跑多条）之后 running 会有 N 条，这里挑「最新那条」。
+ * **不会因此抖动**：排序只看 createdAt，与谁先跑完无关；而且调用方只在选中态失效时才问一次
+ * （`GraphConsole.ensureSelection`），选中之后 20s 轮询不会重挑。
+ * 上限：N 条 createdAt 完全相同时顺序由 localeCompare 的稳定性决定 —— 那种并列本身就没有
+ * 「更该选哪条」的答案，不值得为它引入第二个排序键。
  */
 export function pickDefaultSelection(goals = []) {
   const all = [];
@@ -49,6 +49,7 @@
           :loading="goalsLoading"
           :selected-task-id="selectedTaskId"
           :selected-goal-id="selectedGoalId"
+          :slots="slots"
           @select="selectTask"
           @refresh="reloadTree"
         />
@@ -80,7 +81,7 @@
                跟左栏的中文标签是两套说法 -->
           <p class="hint">
             <template v-if="selectedTask">
-              「{{ selectedTask.title }}」{{ pendingRunHint(selectedTask) }}
+              「{{ selectedTask.title }}」{{ pendingRunHint(selectedTask, slots) }}
             </template>
             <template v-else>
               从最左栏选一条任务；没有选中时这里画的是 org graph 定义本身，节点状态一律 pending。
@@ -200,6 +201,17 @@ const defEdges = ref([]);
 const goals = ref([]);
 const goalsLoading = ref(false);
+/**
+ * 执行位 `{ max, used, free }` —— 批 4 之后一家公司可以同时跑多条 root run，
+ * 「在跑几条」不再等于「满了没有」。这个值**只从服务端读**，前端不数 goals 里的 running 去凑：
+ * used 数的是活跃 root run（含 ready/paused），max 是 per-company 配置
+ * （company.json.max_parallel_tasks），两个都不在这棵目标树里 —— 自己算就是 canDispatch 那次事故的第二版。
+ *
+ * ⚠️ 服务端今天还没把它挂到任何响应上（`routes/graph-run.js#slotState` 目前只喂 409 的 body），
+ * 所以它恒为 null，界面文案自动退回批 3 原样。补的时候直接把 `slotState(companyId)` 的返回值
+ * 挂到 `GET /:cid/goals`（或随 taskView 的那一份）上即可，别在那条路上写第二份取值域。
+ */
+const slots = ref(null);
 const selectedGoalId = ref('');
 const selectedTaskId = ref('');
@@ -342,6 +354,9 @@ async function loadGoals() {
     if (!r.ok) return;
     const j = await r.json();
     goals.value = j.goals || [];
+    // 服务端没给就明确置回 null（不是保留上一份）：坑位数过期比没有更坏 ——
+    // 「还空着 1 个」在真的满了之后还挂在屏幕上，用户就会去点一个必然 409 的按钮
+    slots.value = j.slots || null;
     ensureSelection();
   } catch { /* 轮询失败保留上一份树，别把已经画出来的东西清空 */ } finally {
     goalsLoading.value = false;