@sema-agent/server 7.43.0 → 7.44.0

package/dist/http/routes/runs.js

@@ -24,68 +24,22 @@ import { clearTurnActivity, readTurnActivityMs } from "../../turn-activity.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { ActorAssertionWire } from "@sema-agent/registry-core";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
-// server.ts 侧的 routeLabel / isBillableSubmitPath 仍要用下面这些正则,故本模块导出(方向恒为 server.ts → routes/*)。
 export const RUN_ID_RE = /^\/v1\/runs\/([^/]+)(\/events)?$/;
 export const RUN_CANCEL_RE = /^\/v1\/runs\/([^/]+)\/cancel$/;
 export const RUN_STEER_RE = /^\/v1\/runs\/([^/]+)\/steer$/;
 export const RUN_DETACH_RE = /^\/v1\/runs\/([^/]+)\/detach$/;
 export const RUN_COMPACT_RE = /^\/v1\/runs\/([^/]+)\/compact$/;
-// E23 (shell-host contract): the shell answers an inbound MCP elicitation here. Live-only + same-replica (the pending promise
-// is in-memory) — a respond on the wrong replica / after answer/expiry → 404, like a steer on a non-live run.
-/** PAIR-REVIEW F-10:runs 面 404 文案统一富形——a\* 形 id(background-agent registry 句柄,`a`+hex 短形)
- *  是「结构性不在 run 店」的常客([1347]⑤ 记档裁量:不改路由,只给引导)。识别句法形即补引导;
- *  非 a\* 形保通用富文案(cancel 腿 [888]① 同款)。 */
-// #262:runNotFoundMessage 与 RUN_NOT_FOUND_MESSAGE 搬 route-ctx 叶子(server.ts 的 owner 门也要同串,
-// 两文件共享必须走叶子防环)——unknown 与 not-yours 两臂自此单一文案源,oracle 封口理由见叶子头注。
 export const ELICIT_RESPOND_RE = /^\/v1\/elicitations\/([^/]+)\/respond$/;
-// §4④: the shell answers the agent's AskUserQuestion here. Same live-only + same-replica shape as elicit.
 export const QUESTION_RESPOND_RE = /^\/v1\/questions\/([^/]+)\/respond$/;
 export const TOOL_APPROVAL_RESPOND_RE = /^\/v1\/tool-approvals\/([^/]+)\/respond$/;
-// ─────────────────────────────────────────────────────────────────────────────────────────────────
-// #151 车4(design/172 §3.2;稿 = design/151-172-stream-approval/151-car4-design.md,§12 折叠节为准)
-// —— 流内审批卡的 **durable 回决口**。HITL 族第四条,但与上面三条 respond 的辖域正相反:
-//   · 三条 respond = LIVE-ONLY + 同副本(解一个内存里的悬挂 promise;跨副本/窗后一律 404);
-//   · 本条 = 打 `approval_ask` 行的 **CAS**(任何副本都能受理),本副本活体窗只是「顺带同步终局」。
-// ─────────────────────────────────────────────────────────────────────────────────────────────────
 export const TASK_ASK_DECISION_RE = /^\/v1\/tasks\/([^/]+)\/asks\/([^/]+)\/decision$/;
-/** 425 的轮询提示秒数(头与体成对,§12-C F37)。 */
 const ASK_PARKING_RETRY_AFTER_SEC = 2;
-/** `decision_actor` 的展示文本上限(171 ActorAssertion 的 `label` 帽,§2)。 */
 const ASK_ACTOR_LABEL_MAX = 256;
-/**
- * 171 `ActorAssertion` 的 server 侧**读**面 schema —— **键集同源包版,严格度刻意宽读**。
- *
- * 属主收敛(#282 件1,DESIGN-282 §1):§12-D 早就裁了「schema 落 `@sema-agent/registry-core`」,车4 当时
- * 因本仓 deps 钉在 `^0.16.0`(`ActorAssertionWire` 要 0.17.1 才有)只能手写一份对齐形,并把欠账写在注里。
- * 本批把 deps 抬到 `^0.18.0` 并兑现:键集/取值域**不再有第二份拼写**,直接取包版 {@link ActorAssertionWire}。
- *
- * 🔴 但**不能裸替换**:包版是 `.strict()`(registry-core types.ts `ActorAssertionWire`),而本处是**读**面,
- * 两者的严格度取向刻意相反 ——
- *  · 包版严:它同时被**写/铸**侧当规范用,未知键 = 写的人搞错了,当场拒是对的;
- *  · 本处宽:行是**别的进程、别的版本**写下的。未来某版给 actor 加一个附加字段,一 `.strict()` 就把
- *    **整份** actor 判为不认、连 `id`/`verified` 都一起丢 —— 而「坏形只丢 actor 不 500」正是本 schema
- *    存在的意义(§12-D F12)。出处:本文件 codex 交叉复审 round2 的真 finding(红先验过);本批换装时
- *    再次机械复验 —— 裸用包版 ⇒ D-10(`test/tool-approval-e2e-http.test.ts`)当场红。
- * 故取 `.strip()`(zod 默认档):已知字段照常投影,附加字段静默丢弃(响应键集因此仍是封闭的,不转发陌生字节)。
- * `verified`/`via` 缺席不是错误(缺席 = 写那行的版本没记)。
- *
- */
 const AskDecisionActorSchema = ActorAssertionWire.strip();
-/**
- * 回决 body(稿 §3 + §12-F)。`.strict()` = 未知键当场 400,不静默吞。
- *
- * 🔴 `actor` 只收 `label`:`id`/`verified` 恒由 server 铸(171 §5.1 —— **actor 永不参与权限判定**,
- * 它是审计投影,不是凭证)。调用方给的 id 若被采信,任何持有本 ask 读权的调用方都能把回决记在别人名下。
- * 🔴 `idempotencyKey` 的形与店门口的 `assertIdempotencyKeyShape` 同规(1–255 且无首尾空白)——
- * 端点先拒 ⇒ 坏形键永远走不到店(店那道门是最后一道,不是唯一一道)。
- */
 const AskDecisionBodySchema = z
     .object({
     decision: z.enum(["approve", "deny"]),
-    /** 仅 approve 臂有意义;deny 带 = 宽收后忽略(与三条 respond 同姿势)。 */
     updatedInput: z.unknown().optional(),
-    /** 上限走**共享常量**(#229):live 腿的手写 parser 写同一列,两处各写一份 `2048` 字面量 =
-     *  同一列上两个口径,而分歧只会在「一条腿收下、另一条腿 400」的那天才暴露。 */
     note: z.string().max(MAX_DECISION_NOTE_CHARS).optional(),
     idempotencyKey: z
         .string()
@@ -96,36 +50,16 @@ const AskDecisionBodySchema = z
     actor: z.object({ label: z.string().max(ASK_ACTOR_LABEL_MAX) }).strict().optional(),
 })
     .strict();
-/** 行上的 `decision_actor`(裸 JSON)投成回显形;形不认 ⇒ undefined(调用点省略该键,不 500)。
- *  导出仅为契约门(`test/ask-decision-actor-contract.test.ts` 钉「键集同源包版 + 严格度刻意宽读」两条)
- *  —— 导出的是**行为**而不是 schema 对象:schema 的推断类型会牵出 registry-core 内嵌的 zod 路径
- *  (TS2742,不可移植),而这道门要钉的本来就是行为。非 wire 面。 */
 export function projectDecisionActor(raw) {
     const parsed = AskDecisionActorSchema.safeParse(raw);
     return parsed.success ? parsed.data : undefined;
 }
-// C2 (core 1.219): steer a still-running Task SUB-AGENT of a run. `:target` = the child's
-// parentToolCallId (spawn-time identity, unique) or its agentName (display name; 409 when ambiguous).
 export const RUN_SUBAGENT_STEER_RE = /^\/v1\/runs\/([^/]+)\/subagents\/([^/]+)\/steer$/;
-// design/122 (core 1.225): REVIVE a SETTLED sub-agent with a new prompt (CC dfe parity).
 export const RUN_SUBAGENT_RESUME_RE = /^\/v1\/runs\/([^/]+)\/subagents\/([^/]+)\/resume$/;
-// [1488]③(b): GET a BACKGROUND child's final report / current status (a… agent handle → core TaskRegistry,
-// the TaskOutput-tool face over HTTP; background_agent ONLY — wa… workflow-agent rows are observation
-// identities read via the workflow journal). Complements steer/resume (which cover SYNC children only).
 export const RUN_SUBAGENT_OUTPUT_RE = /^\/v1\/runs\/([^/]+)\/subagents\/([^/]+)\/output$/;
 export const RUN_SUBAGENT_STREAM_RE = /^\/v1\/runs\/([^/]+)\/subagents\/([^/]+)\/stream$/;
-// [1499] CC TaskOutput/TaskStop 人侧对位 — the GENERIC task-handle verbs (b* bash stdout — cursor
-// consumption depends on the handle's shape, see the handler; m* monitor batches, a* agent final report;
-// `workflow` refused — journal face owns it). SESSION-enforced from birth (new face, zero consumers):
-// a session-bound run requires the matching ?session=.
 export const RUN_TASK_OUTPUT_RE = /^\/v1\/runs\/([^/]+)\/tasks\/([^/]+)\/output$/;
 export const RUN_TASK_STOP_RE = /^\/v1\/runs\/([^/]+)\/tasks\/([^/]+)\/stop$/;
-/** The task_run SSE — a thin wrapper over `streamSseLog` that PRESERVES the existing wire shape exactly
- *  (`data: {type, ...data}`, `event: failed` stale frame). Behavior-identical to the pre-refactor reader. */
-/** [2373]C-5:subagent/task-handle 两读写面的**共享 authz 门**(principal→owner→session 三级,
- *  [1493] 模型)。此前两面逐字重写——[1493] 类修复要改两次的真风险。返回 run 行;`null`=已应答
- *  (401/404,honest 404 无存在性 oracle)。语义逐字保留:operator 双跳过(owner+session)、
- *  session-unbound run 仅 principal 门、fail-closed。 */
 async function subagentReadGate(req, res, deps, runId) {
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && principal === undefined) {
@@ -135,55 +69,21 @@ async function subagentReadGate(req, res, deps, runId) {
     const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
     const run = await deps.runStore.getRun(runId);
     if (!run || (!trusted && run.owner !== null && run.owner !== principal)) {
-        sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE); // #262:与 unknown 臂同串,oracle 封口
+        sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
         return null;
     }
     const callerSession = new URL(req.url ?? "", "http://x").searchParams.get("session");
     if (!trusted && run.sessionId && callerSession !== run.sessionId) {
-        sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE); // #262:与 unknown 臂同串,oracle 封口
+        sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
         return null;
     }
     return { run, trusted };
 }
-/**
- * #261 §3 —— a\* 句柄读腿的 **404 三分**(TaskOutput / tail / task-handle output+stop 四条腿共用)。
- *
- * ## 病灶(cli 原票的另一半)
- * 这些腿的 404 此前把三件互不相干的事说成同一句话:(i) handle 从未存在(打错字);(ii) **引擎重启后
- * registry 失忆** —— 句柄活在进程内 registry 里,宿主 run 一终局/进程一重启它就没了;(iii) **打错副本**
- * —— run 正在别的 replica 上跑,句柄在**那边**的 registry 里。壳只能猜(cli 四刀里「断流判据修正」
- * 就是在替这个缺口打补丁)。
- *
- * ## 判别材料从哪来(**零新增读**,这点是承重的)
- * 全部来自 {@link subagentReadGate} 已经读到手、且**已证明属于调用方**的那条**宿主 run 行**:
- *  · `isTerminalRunStatus(run.status)` ⇒ 宿主 run 已终局 ⇒ 它的进程内 registry 子代必然已随之离场
- *    ⇒ `not_found.task_owner_settled`;
- *  · `run.status === "running"` 且 `run.instanceId` 指向**别的**副本 ⇒ 它的句柄都在那边的 registry 里
- *    ⇒ `not_found.task_owner_elsewhere`;
- *  · 其余(本副本在跑 / park 中 / `instanceId` 为 null 的前列行)⇒ **最弱主张**,码与文案逐字不变。
- *
- * 🔴 **两个新码陈述的是「属主」,不是「这个句柄」**(codex 对抗复审 R1-F5 [medium],验真后采纳)。
- * 走到这里的 `not_found` 同样可能来自**拼错的句柄**、错的 kind、或别的 run 的句柄 —— 本函数手上
- * **没有**任何目标级证据能证明这个句柄存在过。首版的码名(`task_retired`)与文案(「它存在过,已终局」)
- * 因此是**越权断言**:一个自动客户端会据此停止查找,而真相可能只是它把 id 打错了。现在两个码逐字只说
- * 属主 run 的**状态与位置**(那是调用方本就有权读到的东西,`GET /v1/runs/:id` 直答),句柄本身仍是
- * 那句最弱主张 "no such background task handle here" —— 判别性给到了(壳能分清「registry 失忆」与
- * 「打错副本」),存在性一个字都没多说。
- *
- * 🔴 **A-041 反枚举不变式原样保留**:三分**只对自己人开**。跨 principal 的调用方在上面那道门就已经
- * 被 `not_found.run` 挡掉(与 unknown 臂同码同文,#262 oracle 封口),根本走不到这里 —— 所以这三分
- * 泄露的全部信息是「**你自己**这条 run 的状态」,而那本来就是 `GET /v1/runs/:id` 直答的东西。
- *
- * 🔴 **拿不准的恒答最弱主张**(§3 逐字):本函数不为判别性去造任何新证据 —— 不查 registry、不查
- * durable background_agent 行。`instanceId === null`(建列之前的行)是"不知道"而不是"在本机",故落最弱臂。
- */
 function sendHandleMiss(res, run, thisInstanceId) {
     if (isTerminalRunStatus(run.status)) {
         sendError(res, 404, "not_found.task_owner_settled", "no such background task handle here. Routing hint about its OWNER (not about this handle): the run has already settled, and background handles live in the replica-local registry for the parent's lifetime, so none of its handles are readable any more. Read the run's own outcome via GET /v1/runs/:id");
         return true;
     }
-    // `instanceId` 缺席(null,或建列之前/替身行上的 undefined)= **不知道它在哪**,不是"在别处" ——
-    // 落最弱主张。同理 `thisInstanceId` 缺席时本副本连自己是谁都说不上,更不能断言别人。
     if (run.status === "running" && typeof run.instanceId === "string" && run.instanceId.length > 0 && thisInstanceId !== undefined && run.instanceId !== thisInstanceId) {
         sendError(res, 404, "not_found.task_owner_elsewhere", "no such background task handle here. Routing hint about its OWNER (not about this handle): the run is executing on another replica, and this one's registry holds none of its handles. Ask the replica that owns the run, or read the run's own outcome via GET /v1/runs/:id");
         return true;
@@ -192,38 +92,13 @@ function sendHandleMiss(res, run, thisInstanceId) {
 }
 async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
     await streamSseLog(req, res, {
-        // #151 车3 §5.1:durable tail 腿的开流重放 —— 本 run 的未决审批卡按 taskId 读回并投成
-        // `approval_request` preamble 帧(时序=416 判定 + sseHeaders **之后**,见 sse-log.ts 的 hook 顶注)。
-        //
-        // 三条判据都在这几行里:
-        //  · **零写**:只 `listPendingByTask`,不 CAS、不改 expires_at_ms(投影见 buildReplayFrame 顶注);
-        //  · **坏行不炸开流**:形不合的 `card_json` 行跳过 + 一次 warn(不是每行一条,免得一张坏表刷屏);
-        //  · **读面帽**:超 `replayMax` 只投最新 N + 一次 warn。
-        //
-        // 🔴 开关谓词是**必须**的(codex 复审第二轮 high,2026-08-06):原按「关的时候表里本就没行 ⇒
-        // 无需分支」落地,但这个前提在**回滚**下不成立 —— 开着协议的副本(或更新版本)已经落下的
-        // `STREAM_PENDING` 行在关掉开关后**仍在表里**,无谓词的重放腿会把它们照常投上 wire,
-        // 「开关关 = 逐字零变化」(§6.5/§7.2)当场破。谓词同时省掉了关闭态每次开流的一次 store 往返
-        // 与那份 store 故障暴露面。钉:场景9(零帧 **且** 零 store 读 —— 只钉零帧会放过「读了但没投」)。
         preamble: async (signal) => {
-            // 🔴 A-010.7(验真后修):谓词是**上场门**,不是裸开关。
-            // 原式是 `if (!config.streamApproval.enabled) return []` + 一个 `backend?.approvalAsk()` 兜底,
-            // 那是本仓早就收编掉的「局部合取式」形(见本文件 askDecision 口的头注:车4 落地时的临时判据,
-            // 交接条件写死了「换成消费**那一个**谓词」)。两处不同源的后果在 `STREAM_APPROVAL` 默认翻 ON
-            // 之后才显形:上场门是**五**项合取(还要 toolApproval 在场、账本非易失 `kind !== "local"`、
-            // park 设施在场),而这里只看了两项 ⇒ 一个协议**没有上场**的 SQL 部署
-            // (典型:`TOOL_APPROVAL_ENABLED=false`,或没开 `DURABLE_APPROVAL` ⇒ 无 park 设施)
-            // **每一次开流都照打一次库** —— 一次纯白打的 `listPendingByTask`,外加那份 store 故障暴露面,
-            // 而它按契约永远只能投出零帧(协议没上场 ⇒ 没有任何一条 `STREAM_PENDING` 行是本协议铸的)。
-            // 换成单一谓词后,「能力面说 false」⟺「本腿零 store 往返」是结构成立的。
             const gate = resolveStreamApprovalGate({
                 toolApprovalEnabled: Boolean(deps.toolApproval),
                 streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                 backend: deps.backend,
                 parkFacility: deps.checkpointStore !== undefined,
             });
-            // 协议未上场 ⇒ 零帧**且零 store 读**(场景9 的钉打的就是这两件事,不只是零帧)。
-            // env-only worker(无 durable backend)在 `no_backend` 那条臂上一并收掉:无 ask 账 ⇒ 无对账基准。
             if (!gate.active)
                 return [];
             const store = gate.askStore;
@@ -242,9 +117,6 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
         },
         getEvents: (id, after) => runStore.getEvents(id, after),
         retainedFrom: (id) => runStore.retainedFrom(id),
-        // design/158 B2:唯一的读边界归一 —— 存量 `brain_status` 行按公开联合的名字(`status`)下发。
-        // `event:` 与 `data.type` 用**同一个**归一后的名字(此前也是同一个原始名),否则按 event 名分派的
-        // 消费端与按 data.type 分派的消费端会看到两套名字。除这一个键外全部原样透传(见 normalizeRunEventType)。
         formatEvent: (ev) => {
             const type = normalizeRunEventType(ev.type);
             return { id: ev.seq, event: type, data: { type, ...(ev.data ?? {}) } };
@@ -257,34 +129,23 @@ export async function handleRuns(req, res, url, ctx) {
     await handleRunsBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 子代理 / 任务句柄 / HITL 应答段——`handle()` 里它在 SVC-5 workflow steer **之后**,故是独立的域入口。 */
 export async function handleRunVerbs(req, res, url, ctx) {
     const miss = { fell: false };
     await handleRunVerbsBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
- *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 async function handleRunsBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { idemCache, inflightRuns, preemptableRuns, cancelledViaVerb, steerableRuns, wakeParkMints } = ctx.registry;
     const { readJson, rateLimited, quotaExceeded, leaseDenied, usageWindowDenied, runOwnerOk, runSessionAcceptOk } = ctx.helpers;
     const { prepareSpec } = ctx.legs;
     const source = ctx.req.source;
-    // Async run: create + return ids immediately, execute in the background.
     if (req.method === "POST" && url === "/v1/runs") {
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        // Idempotency-Key dedup (center blocker): a retried create returns the SAME taskId instead of starting a
-        // second background run (= second bill). Concurrent same-key requests share the one in-flight create. The
-        // replay is checked BEFORE the rate/quota gates so a retry doesn't get a fresh 429 (council).
         const rawIdem = headerStr(req.headers["idempotency-key"]);
-        // Scope by identity only when there IS a key (BL-3) — avoids reading the principal header on every
-        // submit, and keeps the no-key path independent of principal config.
-        // F-fix: scope on the VERIFIED principal (gatedPrincipal) — on a direct door a spoofable header would let a
-        // caller poison/collide another principal's idempotency cache. (BFF/gated: identical to principalFrom.)
         const idemKey = rawIdem ? scopedIdempotencyKey(rawIdem, source, gatedPrincipal(req, deps.config)) : undefined;
         const cached = idemKey ? idemCache.peek(idemKey) : undefined;
         if (cached) {
@@ -292,21 +153,14 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendJson(res, resp.status, resp.body);
             return;
         }
-        // 🔴 复审 C1:NO lease gate here — it must not sit ABOVE the durable-taskId idempotency replay
-        // below, or a retry of an already-created run (dispatch-gateway failover) would get 429 instead of its
-        // existing 202 receipt, breaking the exactly-once contract. The lease admits a genuinely-NEW run only
-        // (applied just before createRun). Rate/quota stay here (cheap pre-reject; a rate-limited replay is a
-        // transient the caller retries, unlike a persistent lease exhaustion).
         if (rateLimited(req, res) || quotaExceeded(req, res))
             return;
         const prepared = await prepareSpec(req, res);
         if (!prepared)
             return;
-        // DESIGN-269 车2 件2:建行+驱动段整段搬进具名腿 {@link createDurableRun} —— A2A 的 `message/send`
-        // 复用**同一条**提交链(第二条提交路径=第二写者,禁)。本处逐字等价于搬走前:腿返回收据,路由发它。
         const resp = await createDurableRun(req, res, ctx, prepared, idemKey);
         if (!resp)
-            return; // 腿已应答(400 body.taskId 坏形 / 409 foreign owner / 202 durable 重放 / 门拒)
+            return;
         sendJson(res, resp.status, resp.body);
         return;
     }
@@ -317,18 +171,11 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             return;
         }
         const taskId = runMatch[1];
-        // Enforce the principal requirement BEFORE the lookup so the 401/404 ordering matches the approvals
-        // endpoint (no 404-vs-401 existence oracle for an unauthenticated caller under requirePrincipal).
-        // 🔴 F-fix: gatedPrincipal (VERIFIED), not the spoofable header. On a direct door the legit owner authenticates
-        // by the JWT (no x-agent-principal header), so a `principalFrom` presence check would 401 a VALID caller — and a
-        // spoofed header must not satisfy this gate either. Mirrors runOwnerOk's verified check below. (BFF/gated: same.)
         if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
         }
         const run = await deps.runStore.getRun(taskId);
-        // NB: `runOwnerOk` is short-circuited away when `!run`, so the unknown-run case MUST send its own
-        // response — otherwise the request never completes (hung socket, invisible to access log/metrics).
         if (!run) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
@@ -336,25 +183,15 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         if (!runOwnerOk(req, res, run.owner))
             return;
         if (!runSessionAcceptOk(req, res, run, runMatch[2] ? "run.events" : "run.poll"))
-            return; // [1499] accept-phase
+            return;
         if (runMatch[2]) {
             await streamRunEvents(req, res, deps, deps.runStore, taskId, deps.config.runStaleSec * 1000);
         }
         else {
             const stale = run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
-            // design/80 b (item 3): the supervisor cost surface = core's LLM costBreakdown + the service's infra axes.
-            // Only when infra pricing is configured (else the client reads stats.costBreakdown directly) AND the run is
-            // terminal with stats — reads the event log ONCE for the tool-call count + uses the run's wall-clock span as
-            // the sandbox-walltime proxy. Skipped for running/no-rate runs (no per-poll events read in the common case).
             const infraRates = deps.config.infraCostRates;
             const needCost = Boolean(run.result?.stats && !stale && infraRates && hasInfraPricing(infraRates));
-            // E12: surface post-completion prompt suggestions on the poll (the `await suggestions()` retrieval). They land
-            // as a `suggestions` event AFTER `done` (post-terminal, fire-and-forget) — so NO live events tail (which closes
-            // at the terminal status) can carry them; a poller reads them HERE once the pass settles. Only on a COMPLETED
-            // run (the sole status with suggestions), so a running poll never pays the events read.
             const needSuggestions = !stale && run.status === "completed";
-            // Read the event log ONCE if either consumer needs it (skipped for running / no-rate to avoid a per-poll read).
-            // getEvents is a RunStore staple, but guard its presence so a degraded/partial store just omits these extras.
             const events = (needCost || needSuggestions) && deps.runStore.getEvents ? await deps.runStore.getEvents(taskId, 0).catch(() => []) : undefined;
             let supervisorCost;
             if (needCost && events && run.result?.stats) {
@@ -365,18 +202,11 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             }
             let suggestions;
             if (needSuggestions && events) {
-                const sug = [...events].reverse().find((e) => e.type === "suggestions"); // last wins (a re-run could re-emit)
+                const sug = [...events].reverse().find((e) => e.type === "suggestions");
                 const arr = sug?.data?.suggestions;
-                // 🔴 **事件在场 ⇒ 已结算**,空数组必须原样透出(2026-07-26)。此前这里要求 `arr.length`,
-                // 于是「跑完了、确实一条都没有」与「还没跑完」都变成 `undefined` ⇒ **轮询方无从判断该不该停**。
-                // 与发射侧那半(`runs.ts` 此前 `if (suggestions.length)` 才 append)是同一个态被两处叠加抹平。
-                // ⚠️ 这属于本仓刚修过的**同一类**:消费方拿终态当停止条件,而数据在终态之后才到
-                // (`setTerminal` 在 suggestions 落之前)。判据统一成:事件在 = 已结算;事件不在 = 仍在跑。
                 if (Array.isArray(arr))
                     suggestions = arr.map((s) => String(s));
             }
-            // #245 S1:poll 面的活性证据——语义/缺席纪律与 409 body 同键同源(active-run-conflict.ts 顶注)。
-            // 只在**真 running**(非 stale 折叠)时铸:stale 已被折成 failed,再带活性读数是自相矛盾的材料。
             const lastActivityAt = run.status === "running" && !stale ? readTurnActivityMs(run.taskId) : undefined;
             sendJson(res, 200, {
                 taskId: run.taskId,
@@ -385,11 +215,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 ...(lastActivityAt !== undefined ? { msSinceLastActivity: Math.max(0, Date.now() - lastActivityAt) } : {}),
                 result: run.result ?? undefined,
                 supervisorCost,
-                suggestions, // E12: present once the post-completion pass settled (undefined while pending / if none / off)
-                // Surface the structured failure code at the top level so async-run clients (OA / team skill) can
-                // branch (auth → stop, budget.*/limit.* → quota, network·server → retry/failover) without parsing
-                // the whole result. It already lives inside the persisted result JSON — no run_store schema change.
-                // A `_stale` infra timeout is not a core error, so it carries no errorCode.
+                suggestions,
                 errorCode: stale ? undefined : (run.result?.errorCode ?? undefined),
                 error: stale ? "run stalled (instance lost?)" : run.error ?? undefined,
                 jobId: run.jobId ?? undefined,
@@ -398,19 +224,12 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         }
         return;
     }
-    // POST /v1/runs/:id/cancel — stop a durable async run. Durable cross-replica flag (the owning instance's
-    // heartbeat tick honors it) + a same-replica AbortController fast path. Terminal = "failed"+errorCode
-    // "cancelled". Idempotent on a terminal run. [868] a SUSPENDED run is cancelled here too: settle the
-    // pending checkpoint (CAS expire) then terminalize the row — see cancelSuspended below.
     const cancelMatch = req.method === "POST" ? RUN_CANCEL_RE.exec(url) : null;
     if (cancelMatch) {
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        // Principal check BEFORE the lookup (parity with GET /v1/runs/:id): no 404-vs-401 existence oracle.
-        // 🔴 F-fix: gatedPrincipal (VERIFIED), not the spoofable header (parity with runOwnerOk below + the GET gate) —
-        // else a direct-door owner authenticating by JWT (no x-agent-principal header) is wrongly 401'd.
         if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
@@ -418,27 +237,13 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         const taskId = cancelMatch[1];
         const run = await deps.runStore.getRun(taskId);
         if (!run) {
-            // [888]① 文案:这个 face 覆盖本部署 run store 里的全部 run(bg/durable + interactive sync 腿都建行、
-            // 都注册快路)——404 只剩「id 属于别的进程/别的 store」一类(如另起的 server 进程配 in-memory store)。
-            sendError(res, 404, "not_found.run", runNotFoundMessage(taskId)); // #262:硬编码同串归 helper
+            sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
         }
         if (!runOwnerOk(req, res, run.owner))
-            return; // owner mismatch → 404 (no existence oracle for non-owners)
+            return;
         if (!runSessionAcceptOk(req, res, run, "run.cancel"))
-            return; // [1499] accept-phase
-        // [868] P0: cancel of a SUSPENDED run — the user's recovery handle for a locked session. Previously a flat
-        // 409 "deny the pending approval instead", which dead-ended when the deny itself failed or was swallowed
-        // (the incident: an AskUserQuestion durable park whose shell deny was lost kept the task_active claim with
-        // ZERO release paths on the file/memory lane — every later submit on the session 409'd forever). New
-        // semantics: settle the pending checkpoint FIRST via the CheckpointStore CAS `expire` (the reaper's
-        // "≈ deny" terminal — deliberately NOT resolve/resumeCheckpoint, which would drive a model continuation:
-        // cancel means the run DIES; a deny-RESUME feeds the refusal back to the model and burns tokens against
-        // the user's intent, and denying an AskUserQuestion is incoherent anyway — the reapExpired kind-split
-        // already encodes that), THEN terminalize the run row (setTerminal releases task_active = unlocks the
-        // session). Order is load-bearing: checkpoint-first means a late approve loses the CAS and is rejected
-        // honestly by /decide; terminal-first would open the window where an approve wins the CAS on a dead row
-        // and driveResume ghosts against markResuming (safe, but a lie in two ledgers).
+            return;
         const rs = deps.runStore;
         const cancelSuspended = async () => {
             const cs = deps.checkpointStore;
@@ -447,45 +252,29 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 const token = await cs.findPendingTokenBySession(run.sessionId);
                 if (token) {
                     const cp = await cs.get(token);
-                    // CAS pending→expired; `false` = a concurrent decide (or the reaper) settled the gate first.
-                    // Winning it means NO model leg can run off this gate: an approve that already won markResuming
-                    // (row=running) has its resumeStream reject on the now-expired checkpoint BEFORE any model call and
-                    // settles the row failed itself — our unconditional setTerminal below double-writes the same
-                    // terminal (harmless; claim releases once). 双腿并跑 is impossible on this path (codex H1 review).
                     const won = cp ? await cs.expire(token, cp.scope) : false;
                     if (!won) {
-                        // CAS lost — answer by the run's ACTUAL state, never pretend the cancel landed.
                         const now = await rs.getRun(taskId);
                         const st = now?.status;
-                        // 判据取词表属主(合并码重扫):park 是两个词,手抄形对 core 的词表增删两向都没有编译期钉。
                         if (st !== undefined && (isParkedRunStatus(st) || st === "running")) {
-                            // 文案中性覆盖两因(复验镜头:输家可能是 decide 也可能是 reaper 的 expire——后者无人 resuming)
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" }); // idempotent
+                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
                 }
                 else {
-                    // NO pending token. Two very different worlds share this face (codex H1):
-                    //  (a) the lockup fingerprint — deny lost / checkpoint expired-or-reaped, row parked forever;
-                    //  (b) a concurrent approve ALREADY resolved the checkpoint and its resume leg is running — an
-                    //      unconditional setTerminal here would kill/orphan that leg AND release the claim (双腿并跑).
-                    // Disambiguate with the SAME CAS the resume path uses: markResuming flips ONLY a suspended row.
-                    // Winning it = no resume leg exists nor can start (approve's own markResuming will now lose) — the
-                    // row is OURS to terminalize. Losing it = answer by the run's actual state, never pretend.
                     const claimed = await rs.markResuming(taskId);
                     if (!claimed) {
                         const now = await rs.getRun(taskId);
                         const st = now?.status;
-                        // 同上:词表属主判据(手抄形绕开 isParkedRunStatus 的 `never` 执法点)。
                         if (st !== undefined && (st === "running" || isParkedRunStatus(st))) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" }); // idempotent
+                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
@@ -493,23 +282,15 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 }
             }
             else {
-                // Minimal deployments without a checkpoint store: the run row is the only ledger — release it, say so.
                 note = "cancelled while suspended (no checkpoint store on this deployment — run row terminalized only)";
             }
-            // Run-row terminal AFTER the checkpoint settle. Two ledgers, no silent tear: if this write fails after
-            // the checkpoint already expired, report exactly how far the cancel got — a retry takes the
-            // no-pending-token path above and completes the release (idempotent recovery). The row's error text
-            // = the SAME per-path truth as the response note (a stale-park release must not claim it settled a gate).
             const err = note;
             try {
                 const result = { taskId, sessionId: run.sessionId, status: "failed", errorCode: "cancelled", errorMessage: err, stats: { turns: 0, tokens: 0 } };
-                // [888] 低危残账修:撕裂窗自愈——checkpoint 已 settle 后 setTerminal 一次瞬时失败(store 抖动)曾直接
-                // 500,把释放推给 reapStale 的整个 stale 窗(no-token 路的重试读到 running 只会挂 requestCancel 旗,
-                // 无人消费)。这里就地有界重试(2 次退避)把瞬时抖动吞掉;仍然失败才 500 交 reapStale 兜底。
                 let lastErr;
                 for (let attempt = 0;; attempt++) {
                     try {
-                        await rs.setTerminal(taskId, "failed", result, err); // TaskStatus has no 'cancelled' member — failed + errorCode 'cancelled' is the codebase-wide cancel terminal (same shape as the resume-abort settle)
+                        await rs.setTerminal(taskId, "failed", result, err);
                         lastErr = undefined;
                         break;
                     }
@@ -524,18 +305,10 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     throw lastErr;
             }
             catch (e) {
-                // 文案与 note 同源(复验镜头:no-token/无 cs 路没有 settle 任何 gate,固定文案会失真);另注:
-                // no-token 路的重试会读到 running 走 requestCancel 旗,实际释放由 reapStale 兜底(有界延迟)。
                 sendError(res, 500, "internal.cancel_not_terminalized", `cancel progressed (${note}) but could not terminalize the run row (retried) — retry cancel; a stuck row is reaped after the stale window (${e instanceof Error ? e.message : String(e)})`, { taskId });
                 return;
             }
-            // [1.207 codex M2] setTerminal 是 void 且 first-writer-wins 后 CAS 写打空不抛——退避窗内 reaper/
-            // 并发腿可能先终态化(如 approval.expired),我方写打空却仍答 "cancelled" 就是响应与账本不一致。
-            // 写后复读,照实际行应答(锁一样释放了;谁先写赢谁的 errorCode)。
             const finalRow = await rs.getRun(taskId).catch(() => undefined);
-            // 终局判据取自词表属主 `store-contracts.ts` 的穷举 `isTerminalRunStatus`(原地手抄的三连 `===`
-            // 对 core **增**一个终局态是静默的:新态会被判成「还没终局」⇒ 这里改答 "cancelled",与账本不一致,
-            // 正是本段注释要防的那件事)。
             if (finalRow && finalRow.errorCode !== "cancelled" && isTerminalRunStatus(finalRow.status)) {
                 sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
                 return;
@@ -543,43 +316,25 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", note });
         };
         if (run.status === "running") {
-            // Durable flag FIRST (only flips a still-running row), abort after: if the run suspended/terminal'd
-            // between the getRun above and here, the flag write affects 0 rows — re-read and answer by the run's
-            // ACTUAL state instead of lying "cancelling" about a run nothing will cancel.
-            let flagged = await deps.runStore.requestCancel(taskId, run.owner); // owner guard: single-DB defense-in-depth (HTTP gate already passed runOwnerOk)
-            // 抢跑输了(旗打空 0 行)⇒ 按 run 的**真实**状态重判。三向,而且 `running` 那一向必须**重挂旗**
-            // 而不是回答:
-            //  · **park**(🔴 判据取词表属主 `store-contracts.ts` 的穷举 `isParkedRunStatus`,扫描P2):原地手抄的
-            //    `=== "suspended"` 漏掉 `needs_review`(plan_review / dry-run 门的 park 落名),一条抢跑停到计划
-            //    评审上的 run 会掉进 no-op 臂被谎报终局,而行还活着、`task_active` claim 一根手指都没动 ——
-            //    [868] 会话锁死指纹的同族第二例(直连分支早已认两个词,codex M1;这条孪生臂当时漏了)。
-            //  · **running**(codex 复审 round1 [high] 二,验真):`requestCancel` 只对 running 行生效,而
-            //    park→running 的**二次跃迁**真实存在——并发 approve 的 `markResuming` 会把行从 park 翻回
-            //    running。旧码只处理「重读到 park」,重读到 running 掉进 no-op 臂:旗没挂上、腿没 abort,
-            //    **被批准的活继续跑**,而调用方以为取消是空操作。行活过来正是该重挂旗的时刻,不是该撒谎的时刻。
-            //  · 真终局 ⇒ 照旧幂等 no-op(带真实状态)。
-            // 有界(park↔running 反复跳时不许把请求钉在这):次数用尽仍 running ⇒ 如实 409 让调用方重试。
+            let flagged = await deps.runStore.requestCancel(taskId, run.owner);
             const CANCEL_RECLASSIFY_ATTEMPTS = 3;
             for (let attempt = 0; !flagged; attempt++) {
                 const now = await deps.runStore.getRun(taskId);
                 if (now !== undefined && isParkedRunStatus(now.status)) {
-                    await cancelSuspended(); // [868] lost race INTO a park — same recovery handle as the direct branch
+                    await cancelSuspended();
                     return;
                 }
                 if (now?.status === "running" && attempt < CANCEL_RECLASSIFY_ATTEMPTS) {
-                    flagged = await deps.runStore.requestCancel(taskId, run.owner); // 行又活了 ⇒ 重挂 durable 旗(赢了就走下面的快路)
+                    flagged = await deps.runStore.requestCancel(taskId, run.owner);
                     continue;
                 }
                 if (now?.status === "running") {
-                    // 文案与 cancelSuspended 的 CAS 输臂同源(同一件事:并发决议赢了,它的恢复腿正在跑)。
                     sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: now.status });
                     return;
                 }
                 sendJson(res, 202, { taskId, status: now?.status ?? "failed", note: "run already terminal — cancel is a no-op" });
                 return;
             }
-            // fast path: cancel landed on the running instance → abort now. Label FIRST ([1.207 codex H2]) so the
-            // interactive legs' settle projection sees the verb origin (bg legs already write "cancelled" themselves).
             if (inflightRuns.has(taskId)) {
                 cancelledViaVerb.add(taskId);
                 inflightRuns.get(taskId).abort();
@@ -587,61 +342,32 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendJson(res, 202, { taskId, status: "cancelling" });
         }
         else if (isParkedRunStatus(run.status)) {
-            // [868] settle the pending gate + terminalize + unlock (was a flat 409 dead-end). needs_review rides the
-            // SAME handle (codex M1): a plan-review park holds the claim identically and the old else branch lied
-            // "already terminal" about it (claim never released). 判据同上取属主(扫描P2:两处原地手抄的同一张
-            // park 词表已收敛到 `isParkedRunStatus`,再加词由 tsc 逼人表态)。
             await cancelSuspended();
         }
         else {
-            sendJson(res, 202, { taskId, status: run.status, note: "run already terminal — cancel is a no-op" }); // idempotent
+            sendJson(res, 202, { taskId, status: run.status, note: "run already terminal — cancel is a no-op" });
         }
         return;
     }
-    // POST /v1/runs/:id/steer — inject a mid-task steering message (CC-parity "运行中插话", design/47 + design/80
-    // D-A). Delivery is picked by the run's CURRENT state, surfaced via the status code (matching the spec):
-    //   • in-flight on THIS replica (a live core TaskStream in `steerableRuns`) → `stream.steer()` queues the
-    //     message into the harness, drained at the next turn boundary → 200 (applied).
-    //   • durably SUSPENDED (any replica) → `setPendingSteer` parks it on the pending checkpoint, injected by core
-    //     on the resume continuation → 202 (queued).
-    //   • running on ANOTHER replica (not live here, status "running") → 409 steering.not_running. Cross-replica
-    //     live-steer (a durable steer-signal + heartbeat poll, mirroring cancel_requested/preempt_requested) is a
-    //     fast-follow — single-replica-per-worker deployment today, so the live + parked paths cover the headline
-    //     use case; this branch is the honest seam, never a silent drop.
-    //   • terminal (done/failed/cancelled/needs_review) → 409 steering.not_running.
-    // Content carrying a `</system-reminder>` break-out or control chars → 422 steering.invalid_content, validated
-    // ONCE up front with core's `validatePendingSteer` (the same validator setPendingSteer runs) so the 422 is
-    // consistent across both delivery paths — deliberately STRICTER than core's live path (which would sanitize an
-    // untrusted break-out at injection rather than reject it), trading that edge case for a uniform wire contract.
     const steerMatch = req.method === "POST" ? RUN_STEER_RE.exec(url) : null;
     if (steerMatch) {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
-            return; // mutating + hits TiDB / runs the model
+            return;
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        // Per-tenant identity MUST come from gatedPrincipal (direct-door secure single point), NOT principalFrom:
-        // `trusted` carries OPERATOR authority (a trusted steer may ride a <system-reminder>), so deriving it from a
-        // spoofable header on a direct-door worker would be a privilege escalation (HANDOFF 铁律 + core §3 inv #1).
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
         }
         const taskId = steerMatch[1];
-        // Parse + validate the REQUEST before the run lookup: a bad body is the caller's error regardless of run
-        // state, and validating once here (not per delivery path) keeps 400/422 identical whether the run is live or
-        // suspended. `text` required non-empty; `mode` (CC `--steering-mode`) is accepted + enum-checked but a v1
-        // no-op — core's public TaskStream.steer takes only { trusted } today (harness steeringMode is build-time),
-        // so per-call mode is forward-draft pending core wiring (raised to core).
         let body;
         try {
             body = (await readJson(req));
         }
         catch (e) {
-            // TASKS-RUNS-5([2400] 审计):readJson 的 HttpError(413 超限)原样透传——裸 catch 折成
-            // 400 invalid_json 会让 9 MiB 合法 JSON 被报「JSON 非法」(compact 腿是既有对照组正确形)。
             if (e instanceof HttpError) {
                 sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
                 return;
@@ -657,34 +383,19 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.field_invalid", "mode must be 'all' or 'one-at-a-time' when present");
             return;
         }
-        // E15 (shell-host contract): per-message queue priority. Accepted + enum-validated FAIL-LOUD, but ADVISORY
-        // today — core's steer is single-slot last-writer-wins with no per-message priority / addressable drop, so the
-        // faithful priority queue + DELETE /v1/runs/:id/queue/:messageId wait on a core seam (raised to core).
         if (body.priority !== undefined && body.priority !== "now" && body.priority !== "next" && body.priority !== "later") {
             sendError(res, 400, "request.field_invalid", "priority must be 'now', 'next', or 'later' when present");
             return;
         }
         const text = body.text;
         const priority = body.priority;
-        // 🔴 core 5.14.0(#147)之后**必须**把调用方的 Idempotency-Key 接到 core 的 `inputId` 上
-        // (codex 复审 2026-08-06 F4,验真后采纳)。队列化前,重发一条 steer 是 last-writer-wins ⇒ 无害;
-        // 队列化后,「202 丢在路上、客户端照常重试」会**再追加一条**同样的操作员指令,而队列只有
-        // MAX_PENDING_STEER_ENTRIES(=3)个位子 —— 三次重试就把它填满,之后合法转向一律 409 queue_full。
-        // 这条危害是本批的队列改动**引入**的,所以修它属于本批,不是顺手加功能。
-        // 形:与 `POST /v1/runs` 同一条 scoped 口径(source+verified principal+原 key),再 sha256 收成定长
-        // 不透明串 —— core 对 inputId 只限「非空 ≤128 且非保留词」,而 scoped 原串含 \x1f 分隔符且长度无界。
-        // 缺 header ⇒ 完全按旧行为(core 自铸 uuidv7),字节零变化。
         const steerIdemRaw = headerStr(req.headers["idempotency-key"]);
         const steerScoped = steerIdemRaw ? scopedIdempotencyKey(steerIdemRaw, source, principal) : undefined;
         const steerInputId = steerScoped ? `idem-${createHash("sha256").update(steerScoped).digest("hex").slice(0, 32)}` : undefined;
-        // messageId:带 key 时**回同一个** id(重试拿到逐字相同的回执,与「这是同一条指令」一致);
-        // 不带 key 时保持历史的 uuidv7 现铸(壳的引用句柄,drop 动词候 core seam)。
         const messageId = steerInputId ?? uuidv7();
-        // trusted = explicit operator (NOT bare isOperator — its empty-list "true-for-all" would let any caller send a
-        // system-authority steer). A normal owner's steer reaches the model as a plain user message (trusted:false).
         const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         try {
-            validatePendingSteer({ text, trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) }); // throws CheckpointError(steering.invalid_content) on break-out / control chars / bad inputId
+            validatePendingSteer({ text, trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
         }
         catch (e) {
             if (e instanceof CheckpointError && e.code === "steering.invalid_content") {
@@ -698,27 +409,14 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
         }
-        // Owner-gate (parity with preempt): an EXPLICIT operator may steer any tenant's run (supervisor intervention);
-        // a normal caller only its own. 404 (not 403) for a non-owner — no existence oracle.
         if (!trusted && run.owner !== null && run.owner !== principal) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
-        } // #262 同串
+        }
         if (!runSessionAcceptOk(req, res, run, "run.steer"))
-            return; // [1499] accept-phase
-        // Durable-park helper: land the steer on this session's PENDING checkpoint. The checkpoint table — not the run
-        // row — is the AUTHORITY: core writes the pending checkpoint during a suspend (before the service flips the run
-        // row to "suspended"), and CASes on `status='pending'`, so this lands iff the run is genuinely parked. Read the
-        // checkpoint's ACTUAL scope ("_" for a no-principal run) then its token; a missing scope/token/CAS-loss means
-        // the checkpoint resolved/expired/never-existed → "no-checkpoint". "no-store" = no checkpoint store wired.
-        // core 5.14.0(#147)队列化后新出的第四态:park 的队列**满了**。core 的界是 fail-loud 的 ——
-        // 越界抛 `steering.queue_full` 而不是驱逐一条已被接受的指令(驱逐 = 把队列本来要消灭的静默丢失
-        // 原样请回来)。所以这条必须有自己的 wire 码,不能折进 `no-checkpoint`(那会谎称「已不再挂起」)。
-        // 另一个新码 `steering.duplicate_input_id` 自本批起**可达**:调用方带 `Idempotency-Key` 时它被接成
-        // core 的 `inputId`(见下),同 key 配不同正文即撞键 ⇒ 409。不带 key 的调用方永远碰不到它。
+            return;
         let parkQueueFull;
         let parkDuplicateKey;
-        /** 每个 durable park 调用点的同一份入参(带上幂等键才让 core 的 inputId 去重真正可达)。 */
         const steerInput = () => ({ text, trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
         const tryPark = async () => {
             const cs = deps.checkpointStore;
@@ -738,8 +436,6 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     parkQueueFull = e.message;
                     return "queue-full";
                 }
-                // 同一个 Idempotency-Key 配**不同**正文 —— core 拒绝(吞掉它就等于把队列要消灭的静默丢失请回来)。
-                // 与 `conflict.ask_idempotency` 同族语义:换一个 key,别复用。
                 if (e instanceof CheckpointError && e.code === "steering.duplicate_input_id") {
                     parkDuplicateKey = e.message;
                     return "duplicate-key";
@@ -749,20 +445,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         };
         const sendQueueFull = () => sendError(res, 409, "steering.queue_full", parkQueueFull ?? "the parked steering queue on this checkpoint is full");
         const sendDuplicateKey = () => sendError(res, 409, "steering.duplicate_input_id", parkDuplicateKey ?? "this Idempotency-Key is already parked with different steering content — reissue with a fresh key");
-        /**
-         * 202 park 回执。`status` 是**入参**而不是字面量(合并码重扫):park 是两个词,`403a841` 把 (b) 支的
-         * 判据拓成 `isParkedRunStatus` 之后 `needs_review` 行首次走进这条支,而回执还硬报 `"suspended"` ⇒ 同一
-         * 时刻 `GET /v1/runs/:id` 报 `needs_review`,按回执刷新本地行的消费端把「待评审」渲成「已挂起」。
-         * 姊妹位早就读真词(preempt 的 `extras.status`、本文件终局 cancel 与 wake-park 两处回执)。
-         */
         const sendParked = (status) => sendJson(res, 202, { taskId, status, delivery: "queued", messageId, ...(priority ? { priority } : {}), note: "steer parked on the checkpoint — injected when the run resumes" });
         const sendNotRunning = (error) => sendError(res, 409, "steering.not_running", error);
-        // (a) Same-replica live path: the run is streaming here → inject now (drained at the next turn boundary).
-        // core 5.35.0(#257/#259 收口,[4022] G1):live 腿把同一个 `steerInputId` 接到 `TaskStream.steer` 的
-        // `inputId` 上 —— 此前只有 parked 腿去重,「202 丢在路上、客户端照常重试」打在 live 腿上就是二次注入
-        // (parked/live 两腿一条 ingress 键,自本版起 replay-safe 等强;live 判重窗口=流内存活期,契约成文)。
-        // 同 key 同载荷重放 = 幂等 no-op(照常 200,core 零二次注入零二次 human_input 帧);同 key 异载荷 =
-        // `steering.duplicate_input_id` → 409(与 parked 腿 sendDuplicateKey 同码同文案族)。
         const live = steerableRuns.get(taskId);
         if (live) {
             try {
@@ -782,21 +466,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     return;
                 }
                 if (code !== "steering.not_running")
-                    throw e; // unexpected → outer handler 500
-                // Raced: the stream finished between the map lookup and steer(). It may have durably SUSPENDED in the SAME
-                // tick (core already wrote the pending checkpoint) — fall through to the durable park rather than a spurious
-                // 409 (the live→suspended transition window). Only a genuinely-terminal run → not_running.
-                // 🔴 回执的 status 要报「投递时刻 server 看到的行状态」,而手里那份快照是**进 handler 时**读的
-                // (这条腿上多半还是 `running`,park 发生在它之后)。所以在这里重读一次 —— 且**必须在 park 之前**
-                // (codex 复审二/三轮合并处置):
-                //  · 提交**后**再读 = 给一个已成功的写加提交后依赖。库降级时那次读可以永远挂着(`.catch` 只接
-                //    拒绝、接不住不返回),客户端拿不到 202 就重试,而不带 `Idempotency-Key` 的重试会**再追加一条**
-                //    同样的指令(队列只有 3 个位子)——把「回执更准」换成「指令重复入队」,方向反了。
-                //  · 提交**前**读则没有这个代价:此刻还没有任何东西入队,读挂了 = 这次请求超时,与 park 之前任何
-                //    一步超时同形,重试语义不变。
-                // 读不到(理论不可达:行必在)⇒ 退回快照,绝不硬编码一个 park 词。残余如实说:行的翻面与 core
-                // 写 checkpoint 不在同一步,所以这一腿仍可能读到 `running` ——判别键是 `delivery`(SDK/openapi 逐字
-                // 「branch on `delivery`, not the status」),不是 status。
+                    throw e;
                 const freshBeforePark = await deps.runStore.getRun(taskId).catch(() => undefined);
                 const raced = await tryPark();
                 if (raced === "parked") {
@@ -815,10 +485,6 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 return;
             }
         }
-        // (b) Durably PARKED → park the steer on the pending checkpoint (drained on resume). 判据取词表属主
-        // isParkedRunStatus(扫描P2 顺带件):只认 suspended 会把 needs_review park 漏到 (d) 终局支——消息
-        // 虽也 park 上同一张卡,但回执是 parked_for_wake+「run already ended,用 /wake 送」,指路错人
-        // (真相是本支的「injected when the run resumes」)。
         if (isParkedRunStatus(run.status)) {
             const outcome = await tryPark();
             if (outcome === "no-store") {
@@ -837,35 +503,21 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 sendDuplicateKey();
                 return;
             }
-            // 文案按 park **两个词**中性化(旧句只说 suspended,对一条 needs_review park 说的是别人的事)。
             sendNotRunning("run is no longer parked on a pending decision (resolved or expired)");
             return;
         }
-        // (c) running-elsewhere (cross-replica, fast-follow seam) → not_running.
         if (run.status === "running") {
             sendNotRunning("run is active on another replica — cross-replica live-steer is not yet supported");
             return;
         }
-        // (d) design/144 wake 半场(core 1.283):TERMINAL run + steer = 不再一律 409——铸一个部署侧
-        // task_done 纯 park checkpoint(PendingAction {kind:"task_done"},deployment-minted per [770]①c),
-        // 把消息 park 上去,等 POST /v1/sessions/:id/wake({gate:"wake"})把它作为续跑首轮输入消费。
-        // 先 tryPark:session 若已有 pending checkpoint(needs_review park / 先前铸的 wake park)直接park上去,
-        // 绝不双铸(一 session 一 pending 不变式)。铸造前置=checkpoint store + session leaf(leafId 锚续跑);
-        // 缺任一 = 原 409 契约(env-only/无树面诚实拒绝)。
         if (deps.checkpointStore && deps.sessionStorage?.getLeafId) {
-            // 复审 MED(陈旧 run 守卫):目标 run 终态但同 session 另有 ACTIVE run(claim 在)时,消息该去
-            // 活 run(live steer / suspended park),给这条旧终态 run 铸 park 只会造出基于活 leaf 的陈旧
-            // checkpoint + wake 撞 markResuming 409。诚实拒绝并指路。
             const activeTaskId = await deps.runStore.getActiveTaskId?.(run.sessionId).catch(() => undefined);
             if (activeTaskId !== undefined && activeTaskId !== null && activeTaskId !== taskId) {
                 sendNotRunning(`run is ${run.status} and its session has an ACTIVE run (${activeTaskId}) — steer that run instead`);
                 return;
             }
-            // per-session 串行(复审 HIGH:并发双终态 steer 的 tryPark→put 窗口双铸两个 pending park)。
             const prior = wakeParkMints.get(run.sessionId) ?? Promise.resolve();
             const mintResult = { parked: false, queueFull: false, duplicateKey: false, noResumeCtx: false };
-            // wake park 腿的 queue_full:新铸的 task_done checkpoint 队列必空,所以只可能来自「锁内重查撞到
-            // 既有 pending」或「跨副本赢家」两条既有 park 上——两处都要如实报满,不许折成「不接受转向」。
             const parkOnce = async (t, sc) => {
                 try {
                     if (await deps.checkpointStore.setPendingSteer(t, sc, steerInput()))
@@ -891,7 +543,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 if (reprobe === "parked") {
                     mintResult.parked = true;
                     return;
-                } // 锁内重查:前一位刚铸完 → 直接 park 上去
+                }
                 if (reprobe === "queue-full") {
                     mintResult.queueFull = true;
                     return;
@@ -903,26 +555,12 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 const leafId = await Promise.resolve(deps.sessionStorage.getLeafId(run.sessionId)).catch(() => undefined);
                 if (leafId === undefined || leafId === null)
                     return;
-                // 🔴 A-057.19 [CONFIRMED high](2026-08-19 三轴组复审,真机复现)—— **铸卡前先证明它赎得回**。
-                // 缺口:本支铸的 `task_done` park 只有一条出路 = `POST /v1/sessions/:id/wake`,而那条腿硬依赖
-                // `checkpoint_ctx`(server.ts 的 resumeWake:`getCtx` 为 null ⇒ 409
-                // `conflict.resume_context_unavailable`,无任何从 run 行重建的兜底);而 `reapCtx` 按**设计**在
-                // run 终态后把该行删掉(`run-store-sql.ts` 的 setTerminal 删 task_active ⇒ ctx 失去保护,
-                // reaper 每 tick 按 `REAP_RUN_STALE_SEC`(默认 120s)清理)。于是 steer-on-terminal 的真实用法
-                // (跑完隔几分钟补一句)几乎恒中:202「用 /wake 送」→ /wake 恒 409 → 消息永久搁浅在一张
-                // `GET /v1/approvals` 还照列、`/decide` 打它必 409(gate-kind 守卫)的卡上,直到 30 天
-                // terminal backstop 把它 expire 掉、消息静默蒸发。
-                // 处置照 #308 那条判例(「宁响亮拒不永久搁浅」):证不出 resume ctx 在 ⇒ **不铸**,当场诚实 409,
-                // 把真因(ctx 已随终态回收)与出路(重新提交任务)写进回体。读失败/超时同样算「证不出」——
-                // 方向 fail-closed:铸一张没人能消费的卡比拒绝一次 steer 伤得多(拒绝可重试,搁浅不可)。
-                // ⚠️ 射程只在**铸新卡**这一步:上面 reprobe 把消息 park 到**既有** pending 卡上的那条路不动
-                // (那张卡不是本腿造的,出路也未必是 /wake)。
                 const resumeCtx = await Promise.resolve(cs.getCtx(run.sessionId)).catch(() => null);
                 if (resumeCtx === null || resumeCtx === undefined) {
                     mintResult.noResumeCtx = true;
                     return;
                 }
-                const cpScope = encodeCheckpointScope(run.owner); // 匿名提交哨兵,与 main.ts putCtx 的 principal ?? "_" 同域
+                const cpScope = encodeCheckpointScope(run.owner);
                 const wakeToken = mintCheckpointToken();
                 await cs.put(wakeToken, {
                     token: wakeToken,
@@ -936,23 +574,12 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     createdAt: Date.now(),
                     sourceTaskId: taskId,
                 });
-                // 🔴 A-057.19 第二半(codex 对抗复审 high,验真后采纳):上面那次 `getCtx` 与这次 `put` 之间
-                // 仍有一个 TOCTOU 窗 —— 窗内 `reapCtx` 完全可能把 ctx 删掉(它的三守卫此刻全部成立:run 已终态
-                // ⇒ 无 task_active、卡还没铸 ⇒ 无 pending checkpoint、提交早于 cutoff),于是我们照样铸出那张
-                // 赎不回的卡。**put 本身就是关窗动作**:`reapCtx` 的谓词逐字含
-                // `session_id NOT IN (SELECT session_id FROM checkpoint WHERE status='pending')`
-                // (checkpoint-store-sql.ts 的 reapCtx / local-checkpoint-store.ts 双生同谓词),卡一落盘该 session
-                // 的 ctx 就被排除在回收之外。⇒ **put 之后再证一次**:还在 ⇒ 窗内没被删,从此也删不掉了;
-                // 不在 ⇒ 窗内正好被删,把刚铸的孤儿 expire 掉再诚实 409(绝不留一张赎不回的卡)。
-                // 读失败同样按「证不出」处置(与铸前那次同向 fail-closed)。
                 const ctxStillThere = await Promise.resolve(cs.getCtx(run.sessionId)).catch(() => null);
                 if (ctxStillThere === null || ctxStillThere === undefined) {
                     await cs.expire(wakeToken, cpScope).catch(() => undefined);
                     mintResult.noResumeCtx = true;
                     return;
                 }
-                // 跨副本纵深:put 后复核赢家——若另一副本抢先铸了别的 pending,expire 我方孤儿并把消息
-                // park 到赢家上(收敛到单 park;店无序时收敛到店的稳定扫描序,残窗如实记 fast-follow)。
                 const winner = await cs.findPendingTokenBySession(run.sessionId).catch(() => null);
                 if (winner !== null && winner !== wakeToken) {
                     await cs.expire(wakeToken, cpScope).catch(() => undefined);
@@ -967,7 +594,6 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 await job;
             }
             finally {
-                // 链尾自清:没有更晚的排队者(Map 仍指向本包装)才删,防长期泄漏;有排队者则由其链尾清。
                 if (wakeParkMints.get(run.sessionId) === wrapped)
                     wakeParkMints.delete(run.sessionId);
             }
@@ -979,8 +605,6 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 sendDuplicateKey();
                 return;
             }
-            // A-057.19:与 /wake 腿**同一个** errorCode —— 消费端对这条 session 的判断是同一件事(续跑材料没了),
-            // 两条腿给两个码只会让壳以为是两回事。
             if (mintResult.noResumeCtx) {
                 sendError(res, 409, "conflict.resume_context_unavailable", "run already ended and this session's resume context is gone — a steer parked now could never be delivered by POST /v1/sessions/:id/wake; submit a new task instead");
                 return;
@@ -993,20 +617,15 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         sendNotRunning(`run is ${run.status} — not accepting steers`);
         return;
     }
-    // K-1c (shell-host §K): POST /v1/runs/:id/compact — MANUAL compaction (un-greys the shell's `/compact`). core
-    // 1.156 added `TaskStream.compact()`: it forces a compaction at the next SAFE turn boundary (never mid-turn) and
-    // emits `compacted{trigger:"manual"}` on the run's OWN stream (the result rides that stream, like steer). So this
-    // verb only applies to a run LIVE on THIS replica (`steerableRuns`); a suspended/terminal/other-replica run has no
-    // live stream + there is NO durable "pending compact" in core (unlike steer's setPendingSteer) → 409.
     const compactMatch = req.method === "POST" ? RUN_COMPACT_RE.exec(url) : null;
     if (compactMatch) {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
-            return; // mutating + runs the model (compaction summarizes)
+            return;
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        const principal = gatedPrincipal(req, deps.config); // direct-door-secure identity, never the spoofable header
+        const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
@@ -1016,23 +635,16 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
-        } // #262 同串
-        // Owner-gate (parity with steer/preempt): an explicit operator may compact any tenant's run; a normal caller
-        // only its own. 404 (not 403) for a non-owner — no existence oracle.
+        }
         const operator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         if (!operator && run.owner !== null && run.owner !== principal) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
-        } // #262 同串
+        }
         if (!runSessionAcceptOk(req, res, run, "run.compact"))
-            return; // [1499] accept-phase
-        // core 1.293:compact(opts) 收 { instructions?, signal? }。instructions=壳 /compact 的定向摘要指令,
-        // 此处 additive 透传(空 body/无字段=现状);signal(取消腿)不在本 verb——取消需要独立动词+
-        // per-pending AbortController 台账,等壳侧 UX 契约定形再开(先到先记:[853] 知会件)。
-        // 校验在 live 查找之前(steer 同纪律):400 形状不依赖运行态,live/非 live 一致。
+            return;
         let compactBody;
         try {
-            // HttpError(413 request body too large)原样透传,不降级成语义错误的 400(交叉评审 L5)
             const parsed = await readJson(req);
             if (parsed === null || typeof parsed !== "object") {
                 sendError(res, 400, "request.invalid_json", "body must be a JSON object when present");
@@ -1048,9 +660,6 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
-        // 上限=core COMPACTION_INSTRUCTIONS_MAX_CHARS(2048 码点,auto-compaction.js:9;超长 core 会静默
-        // 截断)——HTTP 面按同口径拒收,fail-loud 而非 202 后半截指令悄悄丢(交叉评审 M1)。码点计数与
-        // core 同形([...s] 展开),防代理对 emoji 类双单元字符的错杀/漏杀。
         if (compactBody.instructions !== undefined && (typeof compactBody.instructions !== "string" || compactBody.instructions.length === 0 || [...compactBody.instructions].length > 2_048)) {
             sendError(res, 400, "request.field_invalid", "instructions must be a non-empty string of at most 2048 characters (code points) when present — the engine caps compaction instructions there");
             return;
@@ -1061,28 +670,10 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             sendError(res, 409, "compact.not_running", run.status === "running" ? "run is active on another replica — manual compact is replica-local" : `run is ${run.status} — not accepting compaction`);
             return;
         }
-        // FIRE-AND-FORGET 202 (review): `compact()` resolves only once PROCESSED at the next SAFE turn boundary — which
-        // can be a whole in-flight turn away — so awaiting it would hold the HTTP connection (gateway-timeout risk + poor
-        // UX). Ack "accepted" immediately; the compaction runs at the boundary and a `compacted{trigger:"manual"}` event
-        // rides the run's OWN stream (which the client already consumes — this matches the shell's `compacting%` spinner
-        // waiting on that event). A NO-OP compaction (nothing to summarize) emits NO event (so the shell must time out its
-        // spinner, not block forever). Swallow the benign race where the stream finished between the lookup and the call
-        // (steering.not_running) + any compact error — best-effort; failure surfaces as the absence of the event, the user
-        // can retry. (core guarantees compact() never hangs — it resolves by task end at the latest.)
-        void live.compact(compactInstructions !== undefined ? { instructions: compactInstructions } : undefined).then(
-        // core 1.257 (MF-18 BREAKING): compact() now RESOLVES WITH a CompactOutcome instead of void
-        // — "processed" alone was silent when the attempt failed or was mooted (the 202-then-silence fingerprint).
-        // Consume the outcome: "compacted" is the only one that emits a `compacted{trigger:"manual"}` event on the
-        // stream; the other five (failed/mooted/noop/blocked/disabled) each have a `compaction.*` trace counterpart
-        // and produce NO event, so the shell's spinner must fall through. Log the discriminated outcome so a
-        // "202 → no event" incident reads its reason straight from the log (not a service-wire-vs-core guess).
-        (outcome) => {
+        void live.compact(compactInstructions !== undefined ? { instructions: compactInstructions } : undefined).then((outcome) => {
             const level = outcome === "failed" ? "warn" : "info";
             deps.logger?.[level]?.("manual_compact_outcome", { taskId, outcome, note: outcome === "compacted" ? "a compacted{trigger:'manual'} event rode the run stream" : `no event (see compaction.${outcome === "mooted" ? "mooted" : outcome} trace / task terminal events)` });
         }, (e) => {
-            // The not_running rejection was fully silent — correct for the benign settle race it was
-            // designed for, but a SYSTEMATIC not_running (e.g. a verb/handle mismatch on one lane) then has zero
-            // observability. Keep it non-warn (it IS usually benign) but leave a fingerprint.
             if (e.code !== "steering.not_running") {
                 deps.logger?.warn?.("manual_compact_failed", { taskId, err: e instanceof Error ? e.message : String(e) });
             }
@@ -1093,25 +684,15 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         sendJson(res, 202, { taskId, status: "running", delivery: "accepted", note: "compaction will run at the next turn boundary; a compacted{trigger:'manual'} event rides the run stream if anything is summarized" });
         return;
     }
-    // core 1.207 (design/116 detach, CC mid-flight ctrl+b): POST /v1/runs/:id/detach {toolCallId} —
-    // move a RUNNING tool call to the background via `TaskStream.detach(toolCallId)`. Route (a) of the sync-leg
-    // detach verb design ((b)'s durable-leg fallback
-    // is blocked on TOC-local having no runStore). Core semantics: fire-and-forget + race-safe (a request landing
-    // before the tool reads its signal still detaches; after it finished = no-op; unknown toolCallId = no-op) —
-    // the detached Bash settles early with "moved to background; task_id=b*" + a `{type:"bash", detached:true}`
-    // structured card, and the G2b completion notification/spool take over. Only a detach-capable env honors it
-    // (`backgroundCapabilities.supportsDetach`; TOB envs ignore = fail-safe). Like compact, this verb is LIVE-only
-    // (replica-local `steerableRuns` handle — the sync leg now registers too): a suspended run has no running tool
-    // and there is no durable "pending detach" → 409.
     const detachMatch = req.method === "POST" ? RUN_DETACH_RE.exec(url) : null;
     if (detachMatch) {
         if (rateLimited(req, res))
-            return; // mutating, but runs no model (no quota gate — parity with cancel, not steer)
+            return;
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        const principal = gatedPrincipal(req, deps.config); // direct-door-secure identity, never the spoofable header
+        const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
@@ -1125,15 +706,11 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             if (e instanceof HttpError) {
                 sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
                 return;
-            } // TASKS-RUNS-5 同族
+            }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
         if (typeof body.toolCallId !== "string" || body.toolCallId.length === 0 || body.toolCallId.length > 256) {
-            // 🔒 The length cap is load-bearing (review MEDIUM): core's ToolDetachHub.request() is create-then-abort —
-            // an UNKNOWN id still allocates + retains a Map entry (keyed by the raw string) for the run's lifetime
-            // (gc only fires from a real tool's completion), so unbounded ids = per-run memory growth on a shared
-            // replica. Real core toolCallIds are short; 256 is generous.
             sendError(res, 400, "request.body_shape", "body must be { toolCallId: string (non-empty, ≤256 chars) }");
             return;
         }
@@ -1141,51 +718,28 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
-        } // #262 同串
-        // Owner-gate (parity with steer/compact): an explicit operator may detach on any tenant's run; a normal
-        // caller only its own. 404 (not 403) for a non-owner — no existence oracle.
+        }
         const operator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         if (!operator && run.owner !== null && run.owner !== principal) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
-        } // #262 同串
+        }
         if (!runSessionAcceptOk(req, res, run, "run.detach"))
-            return; // [1499] accept-phase
+            return;
         const live = steerableRuns.get(taskId);
         if (!live) {
             sendError(res, 409, "detach.not_running", run.status === "running" ? "run is active on another replica — detach is replica-local" : `run is ${run.status} — no running tool call to detach`);
             return;
         }
-        // Fire-and-forget by CONTRACT (`detach(toolCallId): void`) — race-safety is core's; the outcome surfaces on
-        // the run's OWN stream (the early-settled tool_end with the `detached:true` structured card, then the b* task
-        // notification), which the client already consumes. 202 = "requested", honest about no confirmation here.
         live.detach(body.toolCallId);
         sendJson(res, 202, { taskId, toolCallId: body.toolCallId, delivery: "requested", note: "if the tool call is running in a detach-capable env it settles early with 'moved to background; task_id=b*'; otherwise the request is a no-op (fail-safe)" });
         return;
     }
     miss.fell = true;
 }
-/** 同上纪律(子代理 / 任务句柄 / HITL 应答段)。 */
 async function handleRunVerbsBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { readJson, rateLimited, quotaExceeded, leaseDenied, safeDecode, runSessionAcceptOk } = ctx.helpers;
-    // C2 (core 1.219) + design/122 (core 1.225): the Task-SUB-AGENT verbs of a run —
-    //   POST /v1/runs/:runId/subagents/:target/steer  — inject fenced guidance into a STILL-RUNNING child;
-    //   POST /v1/runs/:runId/subagents/:target/resume — REVIVE a SETTLED child with a new prompt (CC dfe parity;
-    //     always async: the revived child runs in the background on its retained session, completion announced
-    //     via the deployment notify sink — requires the parent run to have set `retainSubagentSessions`).
-    // Shared plumbing (one trust gate): addressed by the PARENT run's taskId + the child's parentToolCallId (or
-    // agentName when unambiguous); replica-local handle registry (the legs' `onSubagentSpawn` sink; design/122 ③
-    // handles now live until LEG END, not child settle — resume is only legal after settle); owner-gated via the
-    // parent run row; content through `redactSteerIn`. 🔐 `handle.childSessionId` is a continuation capability
-    // — never in any response. Sync delegations only (core r1-M3: bg children have no handle).
-    // [1488]③(b): GET /v1/runs/:runId/subagents/:handle/output — the BACKGROUND child read face. The shell's
-    // fleet viewer gets bg_notification summaries only; the child's FINAL assistant body lives in the core
-    // TaskRegistry (what the TaskOutput tool reads). Auth = the runs-face read pattern (verified principal →
-    // owner-gate via the parent run row → honest 404, no existence oracle); access into the registry is the
-    // REGISTRATION tuple derived from the run row (owner=runId | sessionScoped via sessionId, scope=run
-    // owner ?? "default") — NEVER caller-supplied. Replica-local (the registry is in-process, like steer);
-    // non-blocking read: a still-running child returns its current status honestly, no long-poll (v1).
     const subOutputMatch = req.method === "GET" ? RUN_SUBAGENT_OUTPUT_RE.exec(url) : null;
     if (subOutputMatch) {
         if (!deps.runStore || !deps.subagentTaskOutput) {
@@ -1198,39 +752,20 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.path_malformed", "malformed subagent path (invalid percent-encoding)");
             return;
         }
-        const gated = await subagentReadGate(req, res, deps, runId); // [2373]C-5 共享门(principal→owner→session)
+        const gated = await subagentReadGate(req, res, deps, runId);
         if (!gated)
             return;
         const { run } = gated;
-        // [1493] SESSION 边界的完整论证(threat model/为何 caller-asserted session 足够/为何不做 capability)
-        // 已随共享门挪至 subagentReadGate 注;本面语义逐字不变。
         const out = await deps.subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const details = out.details;
-        // codex R1 (type gate): pollTask is the GENERIC registry face — same-tuple b*/m*/w* handles (bash
-        // stdout, monitor batches, workflow projections) would ride this verb otherwise, a broader egress
-        // than the documented agent-final-output contract. Only `background_agent` passes; everything else
-        // gets the SAME indistinguishable 404 (unknown / not-yours / wrong-kind — no oracle). wa* workflow-
-        // agent rows are OBSERVATION identities (never in the registry) — their read face is the workflow
-        // journal (GET /v1/workflows/:id/journal), and they land in the not_found arm here by construction.
         if (details?.error === "not_found" || details?.type !== "background_agent") {
-            // #261 §3:同 principal 前提下的 404 三分(材料全部来自已证属主的宿主 run 行,零新增读)。
-            // #261 §3:同 principal 前提下的 404 三分(材料全部来自已证属主的宿主 run 行,零新增读)。
             if (!sendHandleMiss(res, run, deps.instanceId))
                 sendError(res, 404, "not_found.subagent", `no background agent "${target}" under this run (unknown handle, not this run's child, or already reaped — bg children live in the replica-local registry for the parent's lifetime; wa… workflow-agent rows are read via the workflow journal, not this verb)`);
             return;
         }
-        // Pass the registry's honest projection through: status/retrieval_status/partial flags verbatim,
-        // `content` = the TaskOutput-tool text (the child's final assistant body once terminal). UNTRUSTED
-        // model output, same posture as the runs face's `result`.
         sendJson(res, 200, { taskId: runId, target, content: out.content, output: out.details });
         return;
     }
-    // S2([1520]{core} 提货,core 1.370 `bgAgentId`):GET /v1/runs/:id/subagents/:handle/stream —— per-agent
-    // **live tail**(SSE)。「replay+tail」的 tail 半场:replay/终报=上面的 output 面(durable 臂 1.250),
-    // 本面=从连接时刻起的 content 帧(text/reasoning delta、tool_start/end、task_progress——投影与 sync 主流
-    // forward 分支同 builder 同纪律,subagent-tail-bus.ts 顶注)。帧只在宿主 run 所在副本产生 ⇒ live 帧
-    // replica-local(meta 如实声明;他实例 running 的行=只 heartbeat,不虚构)。门=output 面逐字同形
-    // (principal→owner→session fail-closed;a* 形判;探测经同 seam,未知/非本 run/型错=同 404 无 oracle)。
     const subStreamMatch = req.method === "GET" ? RUN_SUBAGENT_STREAM_RE.exec(url) : null;
     if (subStreamMatch) {
         if (!deps.runStore || !deps.subagentTaskOutput) {
@@ -1243,70 +778,38 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.path_malformed", "malformed subagent path (invalid percent-encoding)");
             return;
         }
-        // [2373]C-5 共享门(principal→owner→session)——本腿此前逐字手写同三层([1493] 语义),与 output/stop
-        // 两腿并列;收编到同一函数后一次修复处处生效。判定顺序以共享门为准(与已收编的两腿现行为一致:
-        // 路径解码 400 先于 principal 401,门内三级次序不变)。
         const gatedTail = await subagentReadGate(req, res, deps, runId);
         if (!gatedTail)
             return;
         const { run } = gatedTail;
-        // 🔴 cli[1524] HIGH-2:**subscribe 先行,probe 在后**——原序(probe await→meta→subscribe)在
-        // probe 与 subscribe 之间留竞态窗:窗内子代 settle → task_settled 发布时无订阅者被丢(总线无
-        // replay/sticky)→ 订阅者只收 heartbeat 永挂。先建订阅,窗内 settle 自然落进队列;probe 判 404
-        // 时 it.return() 清订阅(未写任何帧,404 照常)。
         const it = defaultSubagentTailBus.subscribe(target);
-        // 归属+型探测经 output 同 seam(含 1.250 durable 臂——跨实例行也探得到 status);not_found/型错=
-        // 同一不可区分 404(无 oracle)。探测是纯读(a* 形在 seam 内先过形判门;background_agent poll 无副作用)。
         const probe = await deps.subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const probeDetails = probe.details;
         if (probeDetails?.error === "not_found" || probeDetails?.type !== "background_agent") {
             void it.return?.();
-            // #261 §3 三分(与 output 面同判据同码)
             if (!sendHandleMiss(res, run, deps.instanceId))
                 sendError(res, 404, "not_found.subagent", `no background agent "${target}" under this run (unknown handle, not this run's child, or already reaped — bg children live in the replica-local registry for the parent's lifetime; wa… workflow-agent rows are read via the workflow journal, not this verb)`);
             return;
         }
         sseHeaders(res);
-        // [2373]C-11(5.0.0 BREAKING,提货单点名):meta 帧的 run 实体键改 `taskId`——同 verb 家族的
-        // output 面(:936/:1162)一直叫 taskId,meta 独叫 runId 是家族内第三键名;5.0.0 收一。
-        // meta 声明:live 帧 replica-local + replay 指引;status=探测快照(终态=不再有帧,发 meta 即收尾,
-        // cli 拿到「走 replay 面」的信号而不是空挂)。seq=stop-cycle 世代号(settle 铸;core 1.377 起
-        // **全域投影**——进程内 live 臂投当前复活周期号 [[1533] ask 兑现,[1548]①],durable 终态 serve
-        // 同键同义;老 core 只在 durable 臂在场,缺省容忍)。1=spawn 周期,≥2=复活周期(retained revive
-        // 或 tier-3 均 bump——codex 快审 #11 纠,勿窄读成仅 tier-3)。
-        // `type: "meta"` 与 `event: meta` 同名双发(tasks/trace-usage/approvals 三流同款):部分代理只转发
-        // `data:` 行,按 data.type 分派的消费端否则认不出首帧。additive,老消费端忽略未知键。
-        // [3911] `contentFrames` = 本面的**内容帧供给形**(宿主腿登记,SubagentTailBus.TailContentMode 顶注
-        // 有全文理由):"on" = 内容帧(text/reasoning delta、tool_start/end)会来;"progress_only" = 宿主 run
-        // 提交时没带 `forwardSubagentEvents` ⇒ core 的 forward 门只放 task_progress,本流**结构上**不会有内容
-        // 帧(订阅方无法在查看态打开它,只能让宿主 run 带上那个键重开);"unknown" = 还不知道(子代还没产出
-        // 第一帧,或宿主腿在别的副本)。
-        // additive 键,老消费端忽略;它把此前「一切正常但永远空」的静默降级变成 wire 上可读的事实。
-        // 🔴 按 **target 句柄**读,不按 URL 里的 runId(codex 复审 high):session-scoped 子代活得比派它的
-        // run 久,订阅方常经**后起的另一条 run** 来看它——按 run 键答题在那一档确定性谎报。
         const contentFrames = defaultSubagentTailBus.handleContentMode(target) ?? "unknown";
         res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, taskId: runId, target, status: probeDetails.status ?? "running", ...(typeof probeDetails.seq === "number" ? { seq: probeDetails.seq } : {}), live: "replica-local", contentFrames, replayFace: "GET /v1/runs/:id/subagents/:handle/output" })}\n\n`);
-        // core 1.382([1561] 提货单③):"parked" 非活非终态(durably suspended pending approval)——跟
-        // running/pending 同归"还没完",tail 该继续等而不是收尾指去 replay 面(那是给真终态用的)。子代获批
-        // 恢复后会在**同一条**活流上继续产帧,提前收尾会让客户端误判"已经结束",错过恢复后的后续内容。
         if (probeDetails.status !== "running" && probeDetails.status !== "pending" && probeDetails.status !== "parked") {
             void it.return?.();
-            res.end(); // 终态:tail 无帧可等——replay 面才是读处(meta 已指路)
+            res.end();
             return;
         }
         let closed = false;
         const hb = setInterval(() => {
             if (!res.writableEnded)
-                res.write(`event: heartbeat\ndata: {}\n\n`); // workflow stream 同款真帧(BFF 丢注释帧案)
+                res.write(`event: heartbeat\ndata: {}\n\n`);
         }, 15_000);
         if (typeof hb.unref === "function")
             hb.unref();
-        // design/245 件1:req+res 双挂 + 一次性闸(理由全文在 `sse-lifecycle.ts` 顶注)。本腿的代价最重——
-        // 旗翻不过来时,parked 的 `next()` 会把**总线订阅**一直挂在那里,发布方继续为死对端缓冲。
         bindSseLifecycle(req, res, () => {
             closed = true;
-            clearInterval(hb); // 与 finally 同一手:`it.return()` 若没能当场解开 parked next(订阅方不配合),定时器不该比连接活得久
-            void it.return?.(); // parked next() 不观察 closed 旗——显式 return 解除 park + 清订阅(subscribeWorkflow 同案)
+            clearInterval(hb);
+            void it.return?.();
         });
         try {
             for (;;) {
@@ -1315,7 +818,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                     break;
                 res.write(`event: forward\ndata: ${JSON.stringify(n.value)}\n\n`);
                 if (n.value.type === "task_settled")
-                    break; // 复审 #3:终态帧即完整故事结束——收流,余下在 replay 面
+                    break;
             }
         }
         finally {
@@ -1326,16 +829,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
         }
         return;
     }
-    // [1499] CC TaskOutput/TaskStop 人侧对位 — the GENERIC task-handle verbs. The narrow subagents/:h/output
-    // face above stays byte-stable (公告过的 background_agent ONLY contract); THIS family serves the full
-    // registry kind set the TaskOutput/TaskStop tools serve (background_bash stdout — NB whether a read
-    // consumes the output cursor depends on the handle's shape: a spooled handle re-reads in full, a
-    // cursor-only handle returns new bytes per read; the projection's own flags are authoritative; monitor
-    // batches; background_agent final report), with `workflow` refused at the seam (the journal face owns
-    // workflow reads; a poll here would fire onServedTerminal and suppress the completion push). Addressing
-    // is EXACT task_id only — the tools' agent-name / legacy-shellId resolution is deliberately not on the
-    // wire (fail-closed 404). Gates mirror subagentOutput: verified principal → owner via the run row →
-    // SESSION (enforced from birth — new face, zero consumers, no soft phase needed).
     const taskVerbMatch = req.method === "GET" ? RUN_TASK_OUTPUT_RE.exec(url) : req.method === "POST" ? RUN_TASK_STOP_RE.exec(url) : null;
     if (taskVerbMatch) {
         const stopVerb = req.method === "POST";
@@ -1344,29 +837,19 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             return;
         }
         if (stopVerb && rateLimited(req, res))
-            return; // mutating, runs no model (parity with detach — rateLimited only, no quota/lease gate)
+            return;
         const runId = safeDecode(taskVerbMatch[1]);
         const target = safeDecode(taskVerbMatch[2]);
         if (runId === null || target === null) {
             sendError(res, 400, "request.path_malformed", "malformed task path (invalid percent-encoding)");
             return;
         }
-        const gatedB = await subagentReadGate(req, res, deps, runId); // [2373]C-5 共享门([1493] 模型,论证见门注)
+        const gatedB = await subagentReadGate(req, res, deps, runId);
         if (!gatedB)
             return;
         const { run } = gatedB;
         const q = new URL(req.url ?? "", "http://x").searchParams;
         const access = { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) };
-        // ?filter= is REFUSED on BOTH verbs, not ignored (fail-loud 400; the face shipped unreleased, zero
-        // consumers — and codex R2: a GET-only refusal would leave the stop verb silently accepting it). The
-        // tools' filter is a caller-supplied RegExp run line-by-line on the replica's shared event loop — over
-        // the wire that lets one request stall the whole replica for every tenant (pathological patterns on
-        // long output lines take unbounded time in a backtracking engine). Client-side filtering of the fetched
-        // output is the alternative, with an honest limit (codex R2): the wire serves the registry's CLIPPED
-        // projection (core filters BEFORE clipping; a client can only filter after) — matches inside a clipped
-        // middle are not recoverable over the wire, and a cursor-only bash leg consumes what it serves.
-        // Full-fidelity filtered reads stay an in-engine tool capability; if a linear-time engine lands in
-        // core, the wire filter can reopen deliberately.
         if (q.get("filter") !== null) {
             sendError(res, 400, "request.param_unsupported", "filter is not accepted on the wire — fetch the output and filter client-side (note: the wire serves the clipped projection)");
             return;
@@ -1376,42 +859,15 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             : await deps.taskHandleOutput(target, access);
         const details = out.details;
         if (details?.error === "not_found") {
-            // #261 §3 三分(GET output 与 POST stop 共这一处)
             if (!sendHandleMiss(res, run, deps.instanceId))
                 sendError(res, 404, "not_found.task_handle", `no background task "${target}" under this run (unknown handle, not this run's task, already reaped — handles live in the replica-local registry for the parent's lifetime — or a workflow handle: workflow rows read via GET /v1/workflows/:id/journal; stopping a workflow is not on this wire)`);
             return;
         }
-        // [1499] codex R3: a stop whose kill did NOT land must not read as success. Core keeps the handle
-        // honest (status stays "running", error = the env failure code) — surface that as a 409 so a
-        // status-driven client never mistakes a failed stop for a dead process. The projection rides along
-        // verbatim for diagnosis. NB the "user" attribution pre-mark stays pending on this arm (first-write-
-        // wins, no public per-handle clear) — if the task later dies of another cause it reads stoppedBy:
-        // "user"; the atomic fix is a `source` option on core's stopTask (asked on the board), same residue
-        // shape as core's own internal "parent" pre-mark.
-        // core 1.382([1561] 提货单③):parked 行的两个新 stop 结局——`parked_pending_approval`(stop 撞见
-        // 一个仍在 parked 的行,没有活跃可 kill 的进程)与 `park_resume_won`(stop 与"审批已落地→恢复"发生
-        // 竞态,恢复那侧赢了,行不再是 parked,但 status 不一定翻回 "running"——error 码本身才是权威判据,
-        // 不能靠 status 反推)。二者都不该读成 200 成功("kill 没落地"同一条纪律的延伸),各给各的
-        // errorCode(同 409 家族,additive,与既有 not_local/not_landed 同姿势)。
-        // [1596]/[1600] core 1.397 三分:仲裁器**抛错**(店不可达)此前被误吞成 park_resume_won 的假话——
-        // 「输给了并发 resume」与「根本问不到仲裁结果」是两种不同的行动建议(前者重查状态,后者原样重试
-        // stop),新码 `park_arbiter_unreachable` 让二者不再共用一个 errorCode。
-        // [4797](core 5.50)details.code 孪生对表:stop 族座位今天仍只铸 `error`(族扫未及,已上板点名),
-        // 但 core 契约方向是「code wins when both present」且未承诺新失败座位必带 error ⇒ 判类读
-        // code-优先-error-回落、在场判据双键取并,未来只铸 code 的失败座位不会漏判成 200 成功。
         const stopCode = typeof details?.code === "string" ? details.code : details?.error;
         const parkArbiterUnreachable = stopCode === "park_arbiter_unreachable";
         const parkResumeWon = stopCode === "park_resume_won";
         const stillParked = stopCode === "parked_pending_approval" || details?.status === "parked";
-        // v3.1 批2(统检第二波 high):判别方向翻转——旧形是 (status,error) 的**失败白名单**(status==="running"
-        // || 三个具名码),core 新增失败码且行状态不在 {running,parked} 时整个分支被跳过落 200,与上面注释自陈
-        // 的不变量(kill 没落地绝不读成功)正相悖(B5 联合非穷尽的 default-放行形;not_local/park 族/arbiter
-        // 三次历史新增全靠人追认)。新形:stop 动词的 error **在场即失败**(not_found 已在上方早退),具名臂
-        // 保留各自 errorCode,未知码落 stop.not_landed 兜底 409——新失败码默认可见,不默认成功。
         if (stopVerb && (details?.error !== undefined || details?.code !== undefined)) {
-            // 1.250:durable 回落臂(core stopTask agentStore 分支)对他实例 running 行应答 error="not_local"
-            // (没有 kill 被尝试)——与「kill 尝试了没落地」(stop.not_landed)是不同的失败形,各给各的
-            // errorCode(同 409 家族,additive)。
             const notLocal = stopCode === "not_local";
             sendError(res, 409, notLocal
                 ? "stop.not_local"
@@ -1432,14 +888,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                             : `stop did not land (${stopCode}) — the process may still be running`, { taskId: runId, target, content: out.content, output: out.details });
             return;
         }
-        // Registry projection passed through verbatim (status/retrieval_status/cursor flags); `content` is
-        // UNTRUSTED tool/model output, same posture as subagentOutput.
-        // G14([1833]/[1840]§五):顶层铸 `cursorSemantics` —— 此前「这次读是否消费了游标」只能从 content
-        // 文本标记(`--- stdout (full, re-readable) ---` vs `--- new stdout ---`)反解,每个消费端都得抄
-        // 字符串判别。判据(core task-registry dist 亲读):游标消费形(非 spool 的 pollBackground 路径)
-        // 的内层 details.bytesDroppedBeforeCursor **恒在**(0 也发);spool bash / monitor / background_agent
-        // 全是重读安全的 full 形。⚠️ 这仍是对 core 内形的一处嗅探——集中在 server 这一处替所有端挑担;
-        // 已在黑板请 core 出一等 flag,到货换源、wire 键不变。error/not_ready 形不铸(没有输出体,别给假语义)。
         const g14 = (() => {
             const d = out.details;
             if (!d || d.error !== undefined || d.retrieval_status === "not_ready")
@@ -1448,7 +896,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                 return { cursorSemantics: d.details && "bytesDroppedBeforeCursor" in d.details ? "cursor" : "full" };
             if (d.type === "monitor" || d.type === "background_agent")
                 return { cursorSemantics: "full" };
-            return {}; // 未知 kind:不猜
+            return {};
         })();
         sendJson(res, 200, { taskId: runId, target, content: out.content, output: out.details, ...g14 });
         return;
@@ -1457,13 +905,11 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
     if (subVerbMatch) {
         const verb = url.endsWith("/resume") ? "resume" : "steer";
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
-            return; // mutating + drives a model agent
+            return;
         if (!deps.runStore) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
-        // Identity from gatedPrincipal (direct-door-secure single point), NEVER the spoofable header — `trusted`
-        // carries operator authority (parity with RUN steer / workflow-agent steer; HANDOFF 铁律 + core §3 inv #1).
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
@@ -1483,7 +929,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             if (e instanceof HttpError) {
                 sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
                 return;
-            } // TASKS-RUNS-5 同族
+            }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
@@ -1491,28 +937,19 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.body_shape", "body must be { content: string (non-empty) }");
             return;
         }
-        // 入参上限(见 `STEER_IN_MAX_REQUEST_CHARS` 旁注):脱敏门是**同步**的,烧的是事件循环 ⇒
-        // 一次超大 steer 卡住的是**整个副本**。**拒**而不是服务端先截 —— 先截会让引擎的
-        // `[+N chars]` 披露低报,而"诚实标记不得低报"是本仓另一条钉守着的性质。
         if (body.content.length > STEER_IN_MAX_REQUEST_CHARS) {
             sendError(res, 413, "steer.content_too_large", `content exceeds ${STEER_IN_MAX_REQUEST_CHARS} characters (got ${body.content.length}); note only the first ${STEER_IN_MAX_CHARS} are delivered anyway`);
             return;
         }
-        // trusted = explicit operator (NOT bare isOperator); a normal caller may drive only their OWN run's children.
         const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         const run = await deps.runStore.getRun(runId);
-        // Owner-gate via the parent run row (the child inherits the parent's tenancy — core threads the parent's
-        // principal to the child, design/62). 404 (not 403) for a non-owner — no existence oracle.
         if (!run || (!trusted && run.owner !== null && run.owner !== principal)) {
-            sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE); // #262 同串
+            sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
         }
         if (!runSessionAcceptOk(req, res, run, `subagent.${verb}`))
-            return; // [1499] accept-phase (child write verbs, same class)
+            return;
         const send409 = (errorCode, error) => sendError(res, 409, errorCode, error);
-        // STEER-IN REDACTION GATE — same trust gate as the workflow-agent route (one owner: redactSteerIn): the
-        // human content is UNTRUSTED (host-leak/size/fence) BEFORE it reaches the child; core's handle.steer/
-        // resume fence AGAIN inside their trusted marker framing (defense in depth).
         const redacted = redactSteerIn(body.content, target);
         const resolution = deps.subagentSteerRegistry?.resolve(runId, target);
         if (resolution && resolution.count > 1) {
@@ -1523,8 +960,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
         if (handle) {
             try {
                 if (verb === "resume") {
-                    // design/122: `handle.resume` is absent when the parent run did not retain child sessions — the
-                    // same condition core's own rejection names; report it with core's code so the shell renders one story.
                     if (!handle.resume) {
                         send409("resume.retain_off", "the parent run did not retain sub-agent sessions (set retainSubagentSessions on the run to enable revival)");
                         return;
@@ -1534,14 +969,11 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                     return;
                 }
                 const marker = await handle.steer(redacted);
-                // Receipt wording aligned with CC ("Message queued for delivery…").
                 sendJson(res, 200, { taskId: runId, target, status: "running", delivery: "applied", marker, note: `Message queued for delivery to ${handle.agentName ?? target} at its next tool round.` });
                 return;
             }
             catch (e) {
                 const code = e.code;
-                // core's typed rejections → honest 409s with the core code verbatim (steer: not_running only;
-                // resume: still_running / retain_off / evicted / cap / session_not_found — design/122 D2 contract).
                 if (code === "steering.not_running") {
                     send409(code, "sub-agent just finished — no longer accepting steers");
                     return;
@@ -1554,32 +986,22 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                     send409(code, e instanceof Error ? e.message : "resume rejected");
                     return;
                 }
-                throw e; // unexpected → outer handler 500
+                throw e;
             }
         }
-        // No handle here. Either the parent run is elsewhere/terminal, the child was never registered (bg
-        // delegation — no handle by core's r1-M3 scope), or the owning leg already tore down. Honest 409.
         send409("steering.not_running", run.status === "running"
             ? "no sub-agent matches on this replica (it runs backgrounded, or the run is on another replica)"
             : `run is ${run.status} — its sub-agents are no longer addressable`);
         return;
     }
-    // E23 (shell-host contract): POST /v1/elicitations/:id/respond — the shell answers an inbound MCP elicitation. LIVE-ONLY +
-    // same-replica (the parked promise is in-memory, like a live steer): the coordinator owner-gates (404 — no
-    // existence oracle), validates the body (= core's McpElicitResponse), and resolves the promise so onElicit returns
-    // to core, which replies to the MCP server on the still-open connection. A respond on the wrong replica / after
-    // answer/TTL finds nothing → 404.
     const elicitMatch = req.method === "POST" ? ELICIT_RESPOND_RE.exec(url) : null;
     if (elicitMatch) {
         if (rateLimited(req, res))
-            return; // mutating, but only resolves an in-flight promise (no new billable work → no quota gate)
+            return;
         if (!deps.elicitation) {
             sendError(res, 501, "feature.elicitation_disabled", "inbound MCP elicitation is not enabled on this worker (MCP_ELICITATION_ENABLED)");
             return;
         }
-        // Identity from gatedPrincipal (direct-door-secure single point), NEVER the spoofable header — the answer is
-        // owner-gated against the run's owner (the END USER the elicitation was routed to). No operator bypass: an
-        // elicitation form is the user's to fill, not a supervisor's (unlike steer).
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
@@ -1598,21 +1020,14 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
         sendJson(res, status, respBody);
         return;
     }
-    // §4④: POST /v1/questions/:id/respond — the shell answers the agent's AskUserQuestion. LIVE-ONLY +
-    // same-replica (parked promise in-memory), the sibling of the elicit respond: owner-gated (404, no existence
-    // oracle), body validated (= core's QuestionAnswer), resolves the promise so onQuestion returns to core and the
-    // model continues with "The user answered: …". The security ANSWER-fence (selected ⊆ options, note untrusted-fenced)
-    // is core's AskUserQuestion tool, not here. A respond on the wrong replica / after answer/TTL finds nothing → 404.
     const questionMatch = req.method === "POST" ? QUESTION_RESPOND_RE.exec(url) : null;
     if (questionMatch) {
         if (rateLimited(req, res))
-            return; // resolves an in-flight promise (no new billable work → no quota gate)
+            return;
         if (!deps.question) {
             sendError(res, 501, "feature.ask_question_disabled", "AskUserQuestion live HITL is not enabled on this worker (ASK_QUESTION_ENABLED)");
             return;
         }
-        // Same owner-gate identity as elicit: the VERIFIED principal (gatedPrincipal), never the spoofable header. The
-        // question is the END USER's to answer (routed to their stream) — no operator bypass.
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
@@ -1631,22 +1046,14 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
         sendJson(res, status, respBody);
         return;
     }
-    // [816]/[820]②: POST /v1/tool-approvals/:id/respond — the shell answers a policy `ask` (the CC three-choice
-    // card: {decision: "allow" | "allow_session" | "deny"}). LIVE-ONLY + same-replica (parked promise in-memory),
-    // the sibling of the question respond: owner-gated (404, no existence oracle), body validated first (400 is
-    // existence-independent), resolves the promise so core's resolveAsk returns allow/deny and the tool call
-    // proceeds/denies. `allow_session` additionally arms the coordinator's per-session allow-all (fs-write family
-    // only — rationale in tool-approval.ts). A respond on the wrong replica / after settle/TTL finds nothing → 404.
     const approvalMatch = req.method === "POST" ? TOOL_APPROVAL_RESPOND_RE.exec(url) : null;
     if (approvalMatch) {
         if (rateLimited(req, res))
-            return; // resolves an in-flight promise (no new billable work → no quota gate)
+            return;
         if (!deps.toolApproval) {
             sendError(res, 501, "feature.tool_approval_disabled", "live tool-approval HITL is not enabled on this worker (TOOL_APPROVAL_ENABLED)");
             return;
         }
-        // Same owner-gate identity as question/elicit: the VERIFIED principal (gatedPrincipal), never the spoofable
-        // header. The approval is the END USER's to answer (routed to their stream) — no operator bypass.
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
@@ -1661,29 +1068,14 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
-        // #151 车2:respond() 的返回型是 union(store 缺席时同步、在场时 Promise——src/tool-approval.ts 顶注);
-        // await 对两者都是恒等/透传操作,这里统一 await 以兼容两条路径。
-        // #329:末位透传**本次请求**。它只沿「行已 PARKED 的迟到决议」那条臂流到赎回席(那条腿要真请求做
-        // 准入解析与舰队 scope,与 `/decide` 腿同姿势);live 命中路径一个字节都不看它。
         const { status, body: respBody } = await deps.toolApproval.respond(id, principal, body, req);
         sendJson(res, status, respBody);
         return;
     }
-    // #151 车4:POST /v1/tasks/:taskId/asks/:askId/decision —— durable 回决(辖域对比见 TASK_ASK_DECISION_RE 顶注)。
     const askDecisionMatch = req.method === "POST" ? TASK_ASK_DECISION_RE.exec(url) : null;
     if (askDecisionMatch) {
         if (rateLimited(req, res))
-            return; // 打的是一行 CAS,不新开模型工作 ⇒ 不过配额门(与三条 respond 同判)
-        // 协议关 / 无 durable backend ⇒ 根本没有可 CAS 的账本。501 fail-loud:静默 404 会把「本部署没接这个
-        // 面」伪装成「你的 ask 不存在」,而这两件事的处置完全相反(改部署 vs 别重试)。
-        //
-        // 🔴 **上场判据 = 单一谓词**(车3 刀 3b 收口)。车4 落地时这里是一份局部的
-        // `enabled ∧ backend ∧ kind !== "local"` 临时执行面,注释里写死了交接条件:「等能力面 `streamApproval`
-        // 那一车,把 `kind === "local"` 换成消费**那一个**谓词并同步删掉本段 —— 两份判据长期并存必然漂」。
-        // 兑现即此:`resolveStreamApprovalGate` 现在同时服务协调器注入(boot/coordinators.ts)、
-        // `/v1/capabilities` 的 `streamApproval` 格与本口的 501 门。判据由三项扩到五项(多了 `toolApproval`
-        // 在场与 **park 设施**在场,§8.4)——本口因此更严:能力面说 false 的部署,这里恒 501,不会出现
-        // 「能力面诚实说没有、端点却收下一批注定无处安放的决议」。
+            return;
         const gate = resolveStreamApprovalGate({
             toolApprovalEnabled: Boolean(deps.toolApproval),
             streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
@@ -1695,8 +1087,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendError(res, 501, "feature.approval_ask_disabled", "the durable stream-approval ask ledger is not enabled on this worker (needs STREAM_APPROVAL_ENABLED plus a DURABLE store backend — the local lane keeps asks in memory and would lose accepted decisions on restart)");
             return;
         }
-        // §12-F 前置链(逐字照三条 respond 的先例):rateLimited → principal 门 → readJson → safeParse。
-        // 身份恒取 gatedPrincipal(已验证的那份),**绝不**取可伪造的头 —— 它同时是属主门与 actor 铸造的唯一源。
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
@@ -1716,76 +1106,27 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             return;
         }
         const body = parsedBody.data;
-        // `updatedInput` 的**在场**判定读原始体:`z.unknown().optional()` 解出来的 undefined 分不清
-        // 「没给这个键」与「给了 undefined」,而 forwarded 位的语义是前者。
         const hasUpdatedInput = typeof rawBody === "object" && rawBody !== null && "updatedInput" in rawBody;
         const taskId = askDecisionMatch[1];
         const askId = askDecisionMatch[2];
-        // 404 三处同文同码(行不存在 / taskId 不属 / 属主门不过)—— 不给存在性谕示是这条门的全部意义,
-        // 三条臂只要文案分岔就等于把「它存在但不是你的」写在 wire 上(decide 面 parity)。
         const askNotFound = () => sendError(res, 404, "not_found.ask", "no such approval ask under this task (never existed, belongs to another task, or is not yours)");
         const row0 = await askStore.getAsk(askId);
         if (!row0 || row0.taskId !== taskId) {
             askNotFound();
             return;
         }
-        // §2 v1 判据 = 行 owner 一致 ∨ 显式 operator。`owner === null`(auth-off 单用户)恒过。
-        // 172 的 `task.approve` 独立动词候 center runtimeCaps 有位后再升级,v1 不 block(稿 §2)。
         const ownerOk = row0.owner === null || (principal !== undefined && row0.owner === principal);
         const operatorOk = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         if (!ownerOk && !operatorOk) {
             askNotFound();
             return;
         }
-        // CSRF:本仓无 cookie 面(身份恒来自头/凭证,浏览器不会自动附带)⇒ 不适用(§12-D F8 显式收案)。
         const actor = {
-            id: principal ?? "_", // auth-off 哨兵,与 durable scope 的 "_" 同字
+            id: principal ?? "_",
             ...(body.actor ? { label: redactSecrets(body.actor.label).slice(0, ASK_ACTOR_LABEL_MAX) } : {}),
-            verified: principal !== undefined, // auth-off 下无「验证」可言,如实 false
+            verified: principal !== undefined,
             via: ownerOk ? "owner" : "operator",
         };
-        // 回放形与首决 200 形同键集,只差 `updatedInputForwarded`(它是本副本活体状态的函数,回放不承诺
-        // 字节等同 —— §12-A 明写)。`actor` 从行上读出、safeParse 不过就省略(F12),不 500。
-        /**
-         * 🔴 见到一条 DECIDED 行 ⇒ **先把本副本活体窗同步到它**,再谈这次请求该拿 200 还是 409
-         * (codex 交叉复审 round4 [high] + round5 [high],两轮真 finding,均红先验过)。
-         *
-         * round4 抓的是回放臂:提交歧义窗自己许诺的处置(带同一把键重试)会走 200 回放,而那只活体卡
-         * 从没被结算过 —— run 一直等到窗到期,端点的头号承诺(「窗内回决 run 不停」)在它自己写下的恢复
-         * 路径上不成立。round5 抓的是同一个洞的另一半:**无幂等键**的那次歧义之后,重试落的是 409 臂,
-         * 那条臂当时同样不结算 —— 同一个 run 照样挂死;跨副本回决的本地输者也是这条臂。
-         *
-         * 收敛后的判据一句话:**响应分类不许决定本地是否结算**。行上有权威决议这件事,与「这次请求算
-         * 重试还是算冲突」完全正交 —— 前者是事实,后者只是这次调用的礼节。
-         *
-         * 三条纪律:①用**行上的**决议,不是这次请求带的(权威是首决,B-2 已钉「异决重试回放首决」);
-         * ②**不**转发这次请求的 `updatedInput`(它没有与幂等键一起持久绑定,转发等于让重试悄悄改写首决
-         * 的载荷);③因此回放恒**省略** `updatedInputForwarded`。协调器缺席/查无条目都是正常(跨副本、
-         * 窗已关),`notifyExternalDecision` 对已结算条目天然幂等(其顶注),故重复调用无害。
-         *
-         * 返回值 = 这行是否是一条**可当权威人决用**的 DECIDED 行。三个合取项(codex round5 [medium] +
-         * round6 [high],两轮各补一半),缺任一项都**既不结算也不作答**,而是记不变量 + 500:
-         *   ① `decision ∈ {approve, deny}` —— 列可空且通用 `transitionAsk` 不强制 decision 载荷,DECIDED
-         *      而无决议是可表示的坏行;把它当 200/409 交出去等于把持久层损坏包装成协议答案(契约是二值)。
-         *   ② `provisional === false` —— `AskRow.provisional` 的语义(§3.0 对账三约束②)就是「这条终态还可能
-         *      被 `resolveProvisional` 版本化收敛掉」。**未定稿的终态不是终态**:照它 `notifyExternalDecision(true)`
-         *      会在持久行还可能被补偿成 VOID 之前就放行一次不可逆工具调用 —— 结算是单向门,不可回收。
-         *   ③ `decidedAtMs !== null` —— 它是响应体与回放形的必备字段,也是「这条决议真的被 decideAsk 落过」
-         *      的印记;为空说明这行不是走回决腿铸出来的。
-         * 三者今天都没有在树上的写者会产生(人决恒走 `decideAsk`,它三项齐备),所以这是**fail-closed 的
-         * 结构性守卫**,不是对某个已知 bug 的补丁 —— 判据是「可表示即须拒」,因为代价不对称:错拒 = 一次
-         * 500,错认 = 一次不可逆放行。
-         */
-        // 判据本身(纯守卫,不结算)—— **三个入口共用一份**:CAS 赢者、CAS 输者重读、幂等预查命中。
-        // 🔴 三入口必须同守(codex round7 [high],真 finding,红先验过):此前只守了后两个,而 `decideAsk`
-        // 的 CAS 谓词只看 `state='STREAM_PENDING'`、既不谓词也不清 `provisional` —— 一条 provisional 的
-        // STREAM_PENDING 行赢下 CAS 就成了 provisional 的 DECIDED 行,赢者臂照样放行。守卫贴在「见到一条
-        // DECIDED 行」这件事上,不贴在「怎么见到的」上,才没有第四个入口能绕过去。
-        // 🔴 `state === "DECIDED"` 是第四个合取项(codex round10 [high]):赢者臂是唯一不先判 state 就调本
-        // 谓词的入口,而 `decideAsk` 提交与回读之间那条行可能已被 `resolveProvisional` 版本化收敛走
-        // (例如 provisional 的 DECIDED 被收敛成 VOID 却**留着** decision/decidedAtMs 元数据)——只验元数据
-        // 会让那条已经不是 DECIDED 的行照样放行。谓词名叫「这条 DECIDED 行权威吗」,那就把 DECIDED 本身
-        // 也验了,四个入口才真的同守。
         const decidedRowIsAuthoritative = (row) => {
             if (row.state !== "DECIDED" || row.decision !== "approve" && row.decision !== "deny" || row.provisional || row.decidedAtMs === null) {
                 deps.logger?.error?.("ask_decision_row_not_authoritative", {
@@ -1805,28 +1146,12 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             if (!decidedRowIsAuthoritative(row))
                 return false;
             const settled = deps.toolApproval?.notifyExternalDecision(row.askId, row.decision === "approve");
-            // 🔴 A-054.15:**行派生**的 approve —— 第三形参 `updatedInput` 结构上取不到(行没有那一列),交出去的
-            // 裸 `true` 会让 core 落回**原始未改写**实参执行。与 tool-approval.ts 的三个同形站点计同一个 tag
-            // (选择性登记比不登记更坏);`settled > 0` 才算 —— 本地没有闭包被结算时什么都没执行,记了是假阳性。
             if (row.decision === "approve" && (settled?.settled ?? 0) > 0) {
                 recordFailOpen("server.hitl.row-derived-approve-drops-updated-input", "runs:sync-live-from-decided-row");
             }
             return true;
         };
-        /**
-         * #229(设计稿 233 稿B v2 §2):回决理由的**读面**投影 —— 三个回体共用这一份,行上有才发。
-         *
-         * 🔴 **裁定翻面,原样记账**:本 handler 原先明写「`note` 不回显(以请求者可见权限为界的最窄安全形)」。
-         * 那条最窄形的实测代价是 `decisionNote` 全仓**只写不读** —— 一个零读面的「审计位」对任何按审计面
-         * 接它的消费端都是当场落空。现行裁定:三回体一律 additive 投,**从不发 null / 空键**(缺席 = 这条
-         * 决议没留理由,与 `updatedInputForwarded` 的「从不发 false」同族)。
-         * 读权前提没有放宽:能走到这条口的调用方本来就有权决这只 ask(属主门在本 handler 上游),而 409 支
-         * 回显的**首决**理由与它同支已经在回显的 `decision`/`decidedAtMs`/`actor` 是同一份首决投影 ——
-         * 多这一格不新开任何一条越权读路径。
-         */
         const decisionNoteEcho = (row) => (row.decisionNote === null ? {} : { decisionNote: row.decisionNote });
-        /** 200 回放形:与首决 200 同键集,只差 `updatedInputForwarded`(§12-A 明写回放不承诺字节等同)。
-         *  调用前提 = 已过 {@link syncLiveFromDecidedRow}(行合形且活体窗已同步)。 */
         const replayDecided = (row) => {
             const storedActor = projectDecisionActor(row.decisionActor);
             sendJson(res, 200, {
@@ -1838,23 +1163,16 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                 ...decisionNoteEcho(row),
             });
         };
-        // 终局分派 —— **一律按传进来的这一行**投影,不重读(§12-A:`DecideResult.row` 已是新鲜行;
-        // 补一次确认读只会引入第三个时点,让响应描述的行与 CAS 判定的行再次分家)。
         const sendTerminal = (row) => {
             switch (row.state) {
                 case "DECIDED": {
-                    // 结算**先于**响应分类(见 syncLiveFromDecidedRow 顶注:200 与 409 两臂对本地活体窗是同一件事)。
                     if (!syncLiveFromDecidedRow(row))
-                        return; // 坏行 ⇒ 已答 500
-                    // §12-A 顺序钉:**先**比幂等键。同 key 的两个并发请求都会 miss 上面的预查(那时谁都还没落键),
-                    // 输者重读时若不先比键,会把一次合法重试错报成 409。
+                        return;
                     if (body.idempotencyKey !== undefined && row.idempotencyKey === body.idempotencyKey) {
                         replayDecided(row);
                         return;
                     }
                     const first = projectDecisionActor(row.decisionActor);
-                    // 首决回显四件(#229 起含 `decisionNote`;翻面理由见 {@link decisionNoteEcho})——回显的恒是
-                    // **首决**那条理由,不是本次请求带来的那条(本次请求压根没落地)。
                     sendError(res, 409, "conflict.ask_decided", "this ask was already decided — the first decision stands and is echoed here", {
                         decision: row.decision,
                         decidedAtMs: row.decidedAtMs,
@@ -1864,8 +1182,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                     return;
                 }
                 case "PARKED":
-                    // §12-C:三件坐标,**不含 gateToken** —— checkpointToken 是从不外发的 resume 凭证
-                    // (approval-hmac 的既定不变量);壳按 sessionId 走现行 durable gate 流程。
                     sendError(res, 410, "gone.ask_parked", "the in-stream window closed and this ask was parked onto the durable approval gate — decide it through that gate for the session echoed here", {
                         sessionId: row.sessionId,
                         gateBoundCallId: row.gateBoundCallId,
@@ -1880,36 +1196,19 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                     });
                     return;
                 case "PARKING":
-                    // §12-C F44:PARKING 体**不含** gate 坐标(bindBatch 才写,此刻尚未存在)——只给轮询位置。
                     res.setHeader("retry-after", String(ASK_PARKING_RETRY_AFTER_SEC));
                     sendError(res, 425, "parking.ask_retry", "this ask is mid-park — retrying tells you where it finally landed; a retry does NOT queue this decision for acceptance", {
                         retryAfterSec: ASK_PARKING_RETRY_AFTER_SEC,
                     });
                     return;
                 default:
-                    // STREAM_PENDING 出现在这里 = 状态机转移表无回边却回去了(不变量破)。fail-loud 500 且
-                    // **禁重入 CAS**(§12-A F20):重入等于在一个已知不可信的状态上再赌一次。
                     deps.logger?.error?.("ask_decision_state_invariant", { taskId, askId, state: row.state });
                     sendError(res, 500, "internal.error", "ask decision hit an impossible row state (a CAS loser re-read a still-pending row) — no decision was recorded");
                     return;
             }
         };
-        // 🔴 **观察到即验权 + 即同步**(codex 交叉复审 round8 [high],真 finding,红先验过)。
-        //
-        // 这是 round4/round5/round8 三轮同一族缺口的收口形。前两轮把结算分别补进了 200 回放臂和 409 冲突臂,
-        // 但**跨 ask 撞键**那条臂在它们之前就 return 了:row0 明明已经是 DECIDED(这次请求已经看见了权威
-        // 决议),却因为幂等键属于另一只 ask 而直接 409 走人 —— 本副本那只活体卡照样挂到窗到期。幂等预查
-        // 本身抛错也同理(冒到外层 500,同样没同步)。
-        //
-        // 根治不是再补第三处调用,而是把这一步提到**观察到这行的那一刻**:凡这次请求手里有一条 DECIDED 行,
-        // 先验它是不是权威决议、再把本地活体窗同步到它,**之后**才谈这次请求该拿 200 / 409 / 500。于是
-        // 「响应分类不许决定本地是否结算」成为结构性成立,而不是靠每条臂各自记得调一次。
-        // (下游 `sendTerminal` 的 DECIDED 臂仍会再调一次:`notifyExternalDecision` 对已结算条目幂等,
-        //  重复调用是无操作 —— 宁可重复,不可遗漏。)
         if (row0.state === "DECIDED" && !syncLiveFromDecidedRow(row0))
             return;
-        // ①幂等回放预查(§5-4 + §12-A):命中同 askId 且已 DECIDED ⇒ 直接回放,**不打第二次 CAS**;
-        // 命中另一 askId ⇒ 409(跨 ask 回放会掩盖调用方的键管理缺陷,且 172「禁复用旧同意」排除该解,F23)。
         if (body.idempotencyKey !== undefined) {
             const hit = await askStore.getByIdempotencyKey(taskId, body.idempotencyKey);
             if (hit && hit.askId !== askId) {
@@ -1920,7 +1219,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             }
             if (hit && hit.state === "DECIDED") {
                 if (!syncLiveFromDecidedRow(hit))
-                    return; // 同上:先同步活体窗,坏行 ⇒ 500
+                    return;
                 replayDecided(hit);
                 return;
             }
@@ -1929,14 +1228,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             sendTerminal(row0);
             return;
         }
-        // 先读后分派是**优化**不是判权:CAS 仍是唯一权威,输者按它带回的新鲜行分派。
-        //
-        // 🔴 提交歧义窗(§12-A 的「行缺失 ⇒ 500 fail-loud + 日志注明」条款;codex 交叉复审 round2 抓获本
-        // 实现漏了它):`SqlApprovalAskStore.decideAsk` 是「事务提交 → **另起**一次独立 getAsk 读」的形态
-        // (approval-ask-store-sql.ts,commit() 之后那一行)。那次读若失败/读不到行,它抛 —— 而**决议此刻
-        // 可能已经持久了**。裸让它冒到外层兜底 catch 会给调用方一个不带任何线索的 500:他既不知道该不该重
-        // 试,不带幂等键重试还会撞 409(首决已在)。这里把它接住,fail-loud 但**把处置写进文案与日志**:
-        // 带**同一个** idempotencyKey 重试 ⇒ 若决议真已落地,幂等回放路径会 200 把它原样交回。
         let outcome;
         try {
             outcome = await askStore.decideAsk(askId, row0.batchId, {
@@ -1953,9 +1244,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                 hadIdempotencyKey: body.idempotencyKey !== undefined,
                 error: err instanceof Error ? err.message : String(err ?? ""),
             });
-            // 🔴 处置**按幂等键在场与否分岔**(codex round3 抓获,真 finding):无键的请求根本没有「同一把键」
-            // 可重试,而一次盲重试撞上的是已决行(409),把「可能已批准」错读成「批准冲突」。无键臂如实说
-            // 它做不到,并指出下次怎么做得到 —— 承诺一个不存在的处置比不给处置更坏(过期声明族)。
             if (body.idempotencyKey !== undefined) {
                 sendError(res, 500, "internal.error", "the ask decision store failed around commit — the decision MAY already be persisted; retry with the same idempotencyKey to replay it instead of colliding with it");
             }
@@ -1965,12 +1253,6 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             return;
         }
         if (!outcome.ok) {
-            // 🔴 同一条纪律施于**输者带回的行**(codex 交叉复审 round9 [high],真 finding,红先验过):
-            // `idempotency_conflict` 臂原先直接 409、把 `outcome.row` 丢掉,而店契约允许该臂带回目标行,
-            // SQL twin 更是在**回滚之后**才读它 —— 那一刻它完全可能已经是别人决出来的 DECIDED。于是又一条
-            // 「已经看见权威决议却不结算」的臂(活体窗挂到窗到期),外加「非权威行被撞键 409 掩盖」。
-            // 放在 reason 分派**之前** ⇒ 三个 reason 一视同仁,不靠每条臂各自记得。至此本 handler 能拿到
-            // AskRow 的**全部四个来源**(row0 / 幂等预查命中 / CAS 赢者行 / CAS 输者行)都在守卫下游。
             if (outcome.row?.state === "DECIDED" && !syncLiveFromDecidedRow(outcome.row))
                 return;
             if (outcome.reason === "idempotency_conflict") {
@@ -1980,33 +1262,21 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                 return;
             }
             if (outcome.row === null) {
-                askNotFound(); // 并发删(deleteByTask)——行没了,如实 404
+                askNotFound();
                 return;
             }
             sendTerminal(outcome.row);
             return;
         }
-        // 赢下 CAS **不等于**这行就能放行(codex round7 [high]):`decideAsk` 的谓词只看 `state`,不看也不清
-        // `provisional` —— 赢者臂同样要过那一份权威守卫,否则一条 provisional 行会从这个入口绕过去(结算是
-        // 单向门,而 `resolveProvisional` 事后还可能把它补偿成 VOID)。守卫在**结算之前**。
         if (!decidedRowIsAuthoritative(outcome.row))
             return;
-        // 🔴 结算的**每一个入参都取自行**,不取自请求(codex round10 [high]):赢者臂原先用 `askId` 与
-        // `body.decision` 结算 —— 那是本 handler 最后一处「按请求而非按行」的地方。提交与回读之间那条行
-        // 可能已被版本化收敛改写,此时按请求结算 = 放行一个与持久真相相反的决议(结算不可回收)。
         if (outcome.row.decision !== body.decision) {
-            // 行与本次请求分岔:本地仍按**行**收敛(活体窗恒随持久真相走,哪怕代价是拒),HTTP 侧 fail-loud
-            // —— 调用方提交的那个决议不是最终生效的那个,让他重读而不是以为自己批了。
             deps.logger?.error?.("ask_decision_row_diverged", { taskId, askId, requested: body.decision, stored: outcome.row.decision });
             deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcome.row.decision === "approve");
             sendError(res, 500, "internal.error", "the ask row was rewritten between commit and read-back — the decision that stands is not the one this request submitted; re-read the ask before acting on it");
             return;
         }
-        // 端点已是唯一权威。协调器缺席(TOOL_APPROVAL_ENABLED 关而 askStore 在场)⇒ 联动步
-        // optional 跳过(§12-F F31):没有活体窗要同步,持久终局已经落定。
         const settled = deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcome.row.decision === "approve", hasUpdatedInput ? body.updatedInput : undefined).settled ?? 0;
-        // `updatedInputForwarded` 只在**真结算**时发 `true`,其余一律**省略**(从不发 false,照 finishRespond
-        // 先例,§12-F)。它是「本副本活体状态」的函数,故幂等回放不承诺字节等同(§12-A)。
         const forwarded = outcome.row.decision === "approve" && hasUpdatedInput && settled > 0;
         sendJson(res, 200, {
             askId: outcome.row.askId,
@@ -2015,52 +1285,22 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             decidedAtMs: outcome.row.decidedAtMs,
             actor,
             ...(forwarded ? { updatedInputForwarded: true } : {}),
-            // #229:同上,**按行**投(不按 `body.note`)——赢者行才是这次回决的真相,而 `decideAsk` 的提交与
-            // 回读之间那条行仍可能被版本化收敛改写(同一条「每个入参都取自行」的纪律)。
             ...decisionNoteEcho(outcome.row),
         });
         return;
     }
     miss.fell = true;
 }
-/**
- * DESIGN-269 车2 件2 —— `POST /v1/runs` 的**建行 + 驱动**段,从路由体里原样搬出来的具名腿。
- *
- * 🔴 为什么提取:A2A 的 `message/send`(routes/a2a-serve.ts)必须走**同一条**提交链 —— 第二条提交
- * 路径就是第二个写者,而这条链上挂着 durable taskId 幂等重放、lease/治理窗 pre-admission、
- * `createRun` 的会话 claim、checkpoint ctx 落库、fleet 行发布、resume/rewind 锚点捕获、审批 ALS……
- * 手抄一份就是把这十来件事复制成两份会漂的实现(而漂开的那天没有任何东西会说话)。
- *
- * **纯搬运**:函数体逐字来自搬走前的路由体(唯一改动=统一去缩进两格 + 三个「已应答」的裸 `return;`
- * 写成 `return null;`,语义一字未变 —— 调用方拿到 `null` 就是「腿已经自己应答了」)。
- *
- * 契约:
- *  · 返回 `null` = **已应答**(400 `body.taskId` 坏形 / 409 foreign owner / 202 durable 重放 /
- *    lease·治理窗拒),调用方立即 return,不得再写响应体。
- *  · 返回 `{status, body}` = 本次提交的收据(202 = 新行已建并在跑;409 = 会话占用冲突,**没有**建行)。
- *    调用方自己决定怎么发(HTTP 路由 `sendJson`;A2A 腿翻成协议对象或具名 RPC 错误)。
- *  · 调用前必须先过 `prepareSpec`(本腿吃它的产物)与 `deps.runStore` 在场判据 —— 后者本腿内另有
- *    防御性复检(缺席 ⇒ 501),但两个调用方都在自己的入口先判过,那才是各自面上的正确错误形。
- */
-export async function createDurableRun(req, res, ctx, prepared, 
-/** in-memory 幂等键(`POST /v1/runs` = `Idempotency-Key` 头派生;A2A = `message.messageId` 派生)。
- *  undefined = 本次提交不参与 in-memory 去重(durable `body.taskId` 重放是独立的第二道)。 */
-idemKey) {
+export async function createDurableRun(req, res, ctx, prepared, idemKey) {
     const { deps } = ctx;
     const { idemCache, inflightRuns, preemptableRuns, steerableRuns } = ctx.registry;
     const { leaseDenied, usageWindowDenied } = ctx.helpers;
     const source = ctx.req.source;
     if (!deps.runStore) {
-        // 防御性复检:两个调用方都在自己的入口先判过(各自面上的正确错误形不同),走到这里说明有人漏判。
         sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
         return null;
     }
     const runStore = deps.runStore;
-    // dispatch-gateway failover prerequisite: OPTIONAL caller-minted `body.taskId` idempotency. Unlike the
-    // Idempotency-Key header (in-memory, per-instance), this replay reads the DURABLE run store, so a gateway that
-    // re-routes a submit to ANOTHER instance after a network error cannot start a second run. uuidv7-validated
-    // (same alphabet the server mints — a caller can't inject an arbitrary PK shape); owner-gated replay mirrors
-    // the GET /v1/runs/:id gate (a foreign taskId reads as 404-shaped conflict, not another tenant's run ids).
     const rawClientTaskId = prepared.body.taskId;
     if (rawClientTaskId !== undefined && (typeof rawClientTaskId !== "string" || !isUuidV7(rawClientTaskId))) {
         sendError(res, 400, "request.id_invalid", "body.taskId must be a uuidv7 string (caller-minted idempotency key)");
@@ -2072,50 +1312,31 @@ idemKey) {
         if (existing) {
             const verified = verifiedPrincipal(req, deps.config);
             if (existing.owner !== null && existing.owner !== verified) {
-                sendError(res, 409, "conflict.run_exists", "taskId already exists"); // foreign owner: conflict, no replay (no cross-tenant oracle)
+                sendError(res, 409, "conflict.run_exists", "taskId already exists");
                 return null;
             }
-            // 🔴 codex 轮 H2b 随修:这一臂原本自己 `sendJson(202)` 然后 return null(= 已应答)。搬成具名腿
-            // 之后那个姿势有第二个调用方了 —— A2A 腿拿到 null 只能沉默,而**响应已经以裸 HTTP 202 发出去**,
-            // 对一个 JSON-RPC 调用方就是一帧协议外的垃圾。改成**返回收据**:`/v1/runs` 那侧照旧
-            // `sendJson(res, resp.status, resp.body)`,逐字节同形;A2A 那侧把同一份收据渲成协议对象。
-            // 判词:腿只产收据,**协议渲染归调用方** —— 一条腿服务两种线协议时,这是唯一不撒谎的分工。
             return { status: 202, body: { taskId: existing.taskId, sessionId: existing.sessionId, status: existing.status } };
         }
     }
-    // 🔴 复审 C1:lease gate for a genuinely-NEW submission (past the idempotency replay above). Keyed on the
-    // VERIFIED submitter = the principal billed for this run's spend (correct principal for the sync door).
-    // design/166-T1:治理窗 pre-admission 同位(idempotency replay 之后——重放已建 run 必须拿回 202 收据,
-    // 不得因窗满改判 429;异步 202 车道的唯一 429 出路,core 进场拒是竞态窗兜底)。
     if ((await leaseDenied(req, res)) || (await usageWindowDenied(req, res)))
         return null;
     const resp = await idemCache.run(idemKey, async () => {
         const sessionId = prepared.spec.sessionId ?? uuidv7();
         const taskId = clientTaskId ?? uuidv7();
         const created = await runStore.createRun(taskId, sessionId, prepared.auth?.principal ?? null, deps.instanceId ?? "default", runMeta(prepared, source));
-        // #245 S1(codex S1-F2):新 run 行落库即清同 taskId 的旧世代活性残留——session purge 后客户端合法
-        // 复用自带 taskId 重提交时,旧记录会被读成「刚有活性」的假证据(map 无 generation 轴,清是唯一诚实解)。
         if (created.ok)
             clearTurnActivity(taskId);
         if (created.ok)
-            deps.sessionTitler?.maybeTitle(sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id); // fire-and-forget;model 跟 turn([1992]②)
+            deps.sessionTitler?.maybeTitle(sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id);
         if (!created.ok) {
-            // race twin: two concurrent same-taskId submits (gateway retry racing the original) — the loser's
-            // session claim collides with ITS OWN taskId → idempotent 202 replay, not a 409 (the run exists, once).
             if (clientTaskId && created.activeTaskId === clientTaskId) {
                 return { status: 202, body: { taskId: clientTaskId, sessionId, status: "running" } };
             }
-            // [2255]① 真出路材料:activeTaskStatus + parked 时 pendingGate{kind,decidePath}(best-effort,失败退旧形)
             return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
         }
-        // Durable F4: persist the resume rebuild inputs (sessionId-keyed) so an operator can resume from any
-        // replica even after this worker is gone — core's checkpoint blob can't carry service scenario context.
         if (deps.checkpointStore) {
             await deps.checkpointStore.putCtx(sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope });
         }
-        // E18 resume-at: capture each completed turn's (message eventId → leaf entryId) anchor so the shell can later
-        // rewind to that message. Closes over THIS run's sessionId/owner + the session store's getLeafId + the anchor
-        // store. undefined ⇒ no anchor store / no getLeafId (the env-only deploy) → resume-at simply isn't captured.
         const anchorOwner = prepared.auth?.principal ?? null;
         const getLeafId = deps.sessionStorage?.getLeafId?.bind(deps.sessionStorage);
         const captureTurnAnchor = deps.resumeAnchorStore && getLeafId
@@ -2125,44 +1346,16 @@ idemKey) {
                     await deps.resumeAnchorStore.put(sessionId, eventId, leaf, anchorOwner);
             }
             : undefined;
-        // R8 (CC-parity rewind): the USER-message anchor — keyed by THIS run's taskId (the handle the shell holds
-        // from the 202 response), value = the user-message `entryId` straight from `message_committed{role:"user"}`
-        // (always a valid resumeAt target). No `getLeafId` (the entryId is on the event), so it works even on a
-        // store that lacks getLeafId. This is the "rewind to the prompt" target = the code-restore parity path.
         const captureUserMessageAnchor = deps.resumeAnchorStore
             ? async (entryId) => { await deps.resumeAnchorStore.put(sessionId, taskId, entryId, anchorOwner); }
             : undefined;
-        // MF-Fleet: a background (202) run is a durable run → it gets a live fleet row exactly like the sync leg.
-        // runInBackground fires onStart/onEvent/onTerminal across ALL its legs (verify/cascade/plain-stream). No-op
-        // when no fleetBus is wired (the publisher is a null-object).
         const fleetPub = fleetRunPublisher(deps.fleetBus, {
             runId: taskId,
-            // 🔒 Scope the fleet row with the SAME identity GET /v1/fleet/stream FILTERS by — `gatedPrincipal`
-            // (crypto-verified on a direct door), NOT `prepared.auth.principal` (= the spoofable header). On a direct
-            // door the two diverge: a spoofed header tags the row under a victim's scope (cross-tenant leak) or under
-            // "default" while the verified owner's stream filters it OUT (the row vanishes). TOC review #6.
             scope: gatedPrincipal(req, deps.config) ?? "default",
-            // core 1.154 nested-subagent tree: rootTaskId = the run's CANONICAL core taskId (`spec.taskId ?? sessionId`).
-            // The background leg sets `spec.taskId = taskId` (runs.ts), so canonical == taskId == runId — a forwarded
-            // subagent whose `parentTaskId` equals this nests under the run; deeper ones nest under their parent subagent.
             rootTaskId: taskId,
-            ...fleetRunLabels(prepared.spec.objective), // BC-1: name = short objective preview (description = live-activity, set by the publisher onEvent tool_start)
+            ...fleetRunLabels(prepared.spec.objective),
         });
-        void runInBackground(prepared.runner, // #196:场景 hands 判别位选出的 Runner(hands=none ⇒ 无手孪生)
-        { ...prepared.spec, sessionId }, runStore, taskId, deps.metrics, prepared.auth?.principal, prepared.verify, prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, // E23: per-run elicitation context (onElicit routes inbound MCP elicitations to this run's stream)
-        gatedPrincipal(req, deps.config) ?? null, // E23: the VERIFIED principal that may answer (same source the respond gate uses — never the spoofable header)
-        captureTurnAnchor, // E18: per-turn (message eventId → leaf entryId) anchor capture
-        fleetPub, // MF-Fleet: the run-scoped fleet-row publisher (onStart/onEvent/onTerminal across all legs)
-        captureUserMessageAnchor, // R8: per-prompt (taskId → user-message entryId) anchor — CC "rewind to the prompt"
-        deps.question, // §4④: per-run AskUserQuestion context (onQuestion routes the agent's asks to this run's stream)
-        deps.workflowCompletionInbox, // P1 ①② follow-on: drain pending workflow completions into this leg's durable log at start
-        deps.subagentSteerRegistry, // C2 (core 1.219): register sync-delegation steer handles under this run's taskId
-        (m, x) => deps.logger?.info?.(m, x), // emit-target diagnostics for the bg leg's inbox drain
-        deps.sendUserFile, // SendUserFile 切片2:file_link 帧走本腿 durable append
-        deps.promptManifests, // [998]②: drained into a durable prompt_assembled event by this leg
-        // #151 车3 刀 3b:bg 腿的审批 ALS(此前这条腿无 ctx ⇒ 每只 ask 恒 "unavailable" ⇒ 恒 park)。
-        // 协议上场判据在**路由层**求值(单一谓词),执行腿只消费布尔——runs.ts 是纯执行面,不读 backend/config。
-        deps.toolApproval
+        void runInBackground(prepared.runner, { ...prepared.spec, sessionId }, runStore, taskId, deps.metrics, prepared.auth?.principal, prepared.verify, prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, gatedPrincipal(req, deps.config) ?? null, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
             ? {
                 coordinator: deps.toolApproval,
                 streamApprovalOn: resolveStreamApprovalGate({
@@ -2171,14 +1364,12 @@ idemKey) {
                     backend: deps.backend,
                     parkFacility: deps.checkpointStore !== undefined,
                 }).active,
-                // 两个窗旋钮随传:窗=0 的三源判定要在**本腿开始执行的时刻**做(那是 runInBackground 内部),
-                // 路由层只负责把配置递过去 —— runs.ts 是纯执行面,不读 config。
                 windowMs: deps.config.streamApproval?.windowMs ?? 0,
                 windowMarginMs: deps.config.streamAskWindowMarginMs,
             }
             : undefined, deps.checkpointStore);
         return { status: 202, body: { taskId, sessionId, status: "running" } };
-    }, (r) => r.status === 202); // don't cache a transient 409 (session-active, billed nothing) — let a retry re-run (council)
+    }, (r) => r.status === 202);
     return resp;
 }
 //# sourceMappingURL=runs.js.map