@sema-agent/server 7.86.0 → 7.87.1

package/dist/http/routes/approvals-assistant.d.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { QuestionAnswer } from "@sema-agent/core";
 import type { CheckpointStoreFull } from "../../plugins/store-backend.js";
+import { type ToolApprovalCoordinator } from "../../tool-approval.js";
 import { type GovernancePosture } from "../active-run-conflict.js";
 import { type RouteCtx, type RouteMatch, type RouteIdsOf } from "../route-ctx.js";
 import { type KeyClosureIssue } from "../../request-key-closure.js";
@@ -49,35 +50,46 @@ export declare function planReviewBodyKeyIssue(raw: unknown): KeyClosureIssue |
 export declare function decisionReasonOf(body: {
     reason?: unknown;
 }): string | undefined;
-/** Structural check for an operator-supplied QuestionAnswer (durable ask resume, TC-5.4). Strict on the
- *  load-bearing shape — `answers[]` non-empty, each `{header: string, selected: string[], note?: string}` —
- *  so a typo'd payload fails the request instead of resuming the task with an answer the tool can't use. */
-export declare function isQuestionAnswer(v: unknown): v is QuestionAnswer;
+/** {@link checkQuestionAnswer} 的判词。两种拒各配**一个既有的**错误码,不铸第三种。 */
+export type QuestionAnswerCheck = {
+    readonly ok: true;
+    readonly value: QuestionAnswer;
+}
+/** 形不对(不是对象 / `answers` 空 / 某一位的值形不对)⇒ 400 `request.body_shape`,文案逐字不变。 */
+ | {
+    readonly ok: false;
+    readonly kind: "shape";
+}
+/** 词表外的键 ⇒ 400 `request.field_invalid`,**点名键路径**(`answer.answers[0].selection`)。 */
+ | {
+    readonly ok: false;
+    readonly kind: "unknown_key";
+    readonly keyPaths: readonly string[];
+};
+/**
+ * Structural check for an operator-supplied QuestionAnswer (durable ask resume, TC-5.4). Strict on the
+ * load-bearing shape — `answers[]` non-empty, each `{header: string, selected: string[], note?: string}` —
+ * so a typo'd payload fails the request instead of resuming the task with an answer the tool can't use.
+ * S-452 起**同时闭键**:词表外的键(拼错 / 未来键 / `__proto__`)拒不丢。
+ */
+export declare function checkQuestionAnswer(v: unknown): QuestionAnswerCheck;
 /** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
  *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 export declare function handleApprovalsAssistant(req: IncomingMessage, res: ServerResponse, match: RouteMatch<ApprovalsAssistantRouteId>, ctx: RouteCtx): Promise<void>;
+export declare function streamApprovals(req: IncomingMessage, res: ServerResponse, cs: Pick<CheckpointStoreFull, "listPending">, 
 /**
- * GET /v1/approvals/stream ([ref] native push): SSE — pushes pending-approval deltas so the portal
- * SUBSCRIBES ONCE instead of polling GET /v1/approvals every ~10s (better UX: near-real-time + no client poll
- * loop). Polls listPending(scope) and diffs against the prior snapshot: `pending` for a new suspend, `resolved`
- * for a decided/expired/gone one. Cross-replica BY CONSTRUCTION — the poll reads the SHARED checkpoint table,
- * so a suspend on ANY replica is seen by an operator streaming on a DIFFERENT replica. A transient DB blip
- * heartbeats + retries (never kills the stream); a 15-min cap + req-close end it (parity with streamTaskTrace).
- * Poll-granularity caveat (**narrowed** by [ref]②): the delta now re-emits a `pending` frame whenever a key's
- * WIRE PROJECTION changes (upsert), not only when the key enters — so a same-key re-suspend within one interval
- * IS visible as long as anything on the row differs. What still shows no delta is the strictly degenerate case:
- * a resolve + re-suspend on the same (session,toolCallId) whose projection is BYTE-IDENTICAL — indistinguishable
- * by construction, and harmless (the card the operator sees is the card that is pending). Pins: the two halves of
- * `test/wire-pairing-approvals-stream.test.ts` S3b (changed ⇒ re-emit with the NEW payload; unchanged ⇒ silence).
+ * 🔴 S-454:**第二条 diff 源** —— `GET /v1/approvals` 的 `livePending` 那**同一只**读函数
+ * (`Pick` 而不是另立接口:同源是结构事实,不是两处各写一份的约定)。
+ *
+ * 为什么必须同源:消费方(client-core `hitl/approvalsFeed`)对 stream 上任一非 heartbeat 事件的
+ * 反应是**重取权威 `list()`** —— 推与拉读两份数据时,一条只在推面存在的行会让 feed 空转,
+ * 一条只在拉面存在的行则永远等不到催人事件。
  *
- * [ref](2026-08-09 亲验定性=设计接受,非欠账):每连接自跑 pollMs 轮询打共享 checkpoint 表,
- * 之所以不建 fan-out/单轮询器基建——①消费方=portal 运营面,并发连接数量级为个位(不是用户面);
- * ②listPending 走 (scope,status) 索引,单查成本与一次 /v1/approvals 轮询同阶,而本路正是替代客户端
- * ~10s 轮询的(净负载持平或更低);③DB blip 已 fail-soft(心跳+下拍重试),15-min cap 兜顶。连接
- * 数假设若被打破(portal 多开成常态),届时把 poll 收敛为进程内单轮询器多路复用——那是量级触发的
- * 演化,不是现在的缺陷。
+ * `undefined` = 本部署无 live 审批面(`TOOL_APPROVAL_ENABLED=false` ⇒ 协调器未装配)⇒ 本源整个
+ * 缺席,流的字节与 S-454 之前逐字相同(能力缺席 = 零变化,不是空数组)。**位置在 `pollMs` 之前**
+ * 与 `governance` 同一条理由:`pollMs` 只有测试传,而本参数是每个生产调用点都必须表态的那一个。
  */
-export declare function streamApprovals(req: IncomingMessage, res: ServerResponse, cs: Pick<CheckpointStoreFull, "listPending">, scope: string | undefined, 
+live: Pick<ToolApprovalCoordinator, "listLivePending"> | undefined, scope: string | undefined, 
 /** [ref]②:出身归因的部署侧一半(缺席 ⇒ 归不出治理出身 ⇒ 键缺席,与 best-effort 同方向)。**位置在
  *  `pollMs` 之前**是刻意的:`pollMs` 只有测试传,而本参数是每个生产调用点都必须给的那一个。 */
 governance?: GovernancePosture, pollMs?: number): Promise<void>;

package/dist/http/routes/approvals-assistant.js

@@ -6,11 +6,11 @@ import { APPROVAL_GATE_KINDS } from "../../tool-approval.js";
 import { isParkedRunStatus } from "../../plugins/store-contracts.js";
 import { principalFrom, decodeCheckpointScope, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../../security.js";
 import { editedPlanBinding, isWellFormedUnicode, verifyDirectDoorProof } from "../../principal-jwt.js";
-import { MAX_APPROVAL_REASON_CHARS } from "../../approval-hmac.js";
+import { MAX_APPROVAL_REASON_CHARS, projectQuestionAnswer, questionAnswerFromProjection } from "../../approval-hmac.js";
 import { PLAN_APPROVE_PERMISSION_MODES_AFTER, isPlanApprovePermissionModeAfter, storedBodyPermissionMode } from "../../task-settings.js";
 import { MAX_APPROVAL_NONCE_CHARS } from "../../plugins/approval-nonce-store.js";
 import { redactedPreview, redactSecrets } from "../../trace/redact.js";
-import { redactRiskDescriptor } from "../../observability/run-terminal-log.js";
+import { redactRiskDescriptor } from "../../observability/run-terminal.js";
 import { fleetRunLabels } from "../../fleet/fleet-bus.js";
 import { sleep } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
@@ -23,6 +23,8 @@ import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "../../request-ke
 const DECIDE_BODY_DECLARED_KEYS = [
     "answer", "boundCallId", "boundInputHash", "checkpointToken", "decision", "reason", "remember", "updatedInput",
 ];
+const DECIDE_PROOF_COVERED_KEYS = ["answer", "boundCallId", "boundInputHash", "decision", "reason"];
+const DECIDE_NOT_IN_PROOF_KEYS = ["checkpointToken", "remember", "updatedInput"];
 const ACCEPTED_DECIDE_BODY = new Set(DECIDE_BODY_DECLARED_KEYS);
 const UNSUPPORTED_DECIDE_BODY = new Set(["editedPlan", "sessionId", "taskId"]);
 export function decideBodyKeyIssue(raw) {
@@ -50,6 +52,23 @@ export function decideBodyKeyIssue(raw) {
 const PLAN_REVIEW_BODY_DECLARED_KEYS = [
     "boundCallId", "decision", "editedPlan", "permissionModeAfter", "reason",
 ];
+const PLAN_REVIEW_PROOF_COVERED_KEYS = ["boundCallId", "decision", "editedPlan", "permissionModeAfter", "reason"];
+const PLAN_REVIEW_NOT_IN_PROOF_KEYS = [];
+const PROOF_SLOT_OF = {
+    answer: "answer",
+    boundCallId: "boundCallId",
+    boundInputHash: "boundInputHash",
+    decision: "decision",
+    editedPlan: "boundInputHash",
+    permissionModeAfter: "permissionModeAfter",
+    reason: "reason",
+};
+function buildApprovalEnvelope(sessionId, covered, reading) {
+    const envelope = { sessionId, decision: reading.decision };
+    for (const key of covered)
+        Object.assign(envelope, { [PROOF_SLOT_OF[key]]: reading[key] });
+    return envelope;
+}
 const ACCEPTED_PLAN_REVIEW_BODY = new Set(PLAN_REVIEW_BODY_DECLARED_KEYS);
 const UNSUPPORTED_PLAN_REVIEW_BODY = new Set([
     "answer", "boundInputHash", "checkpointToken", "permissionMode", "remember", "sessionId", "taskId", "updatedInput",
@@ -79,13 +98,27 @@ export function planReviewBodyKeyIssue(raw) {
 export function decisionReasonOf(body) {
     return typeof body.reason === "string" && body.reason !== "" ? body.reason : undefined;
 }
-export function isQuestionAnswer(v) {
+const QUESTION_ANSWER_TOP_KEYS = ["answers"];
+const QUESTION_ANSWER_ITEM_KEYS = ["header", "selected", "note"];
+const ACCEPTED_QUESTION_ANSWER_TOP = new Set(QUESTION_ANSWER_TOP_KEYS);
+const ACCEPTED_QUESTION_ANSWER_ITEM = new Set(QUESTION_ANSWER_ITEM_KEYS);
+const NO_TOLERATED_KEYS = new Set();
+export function checkQuestionAnswer(v) {
     if (!v || typeof v !== "object" || Array.isArray(v))
-        return false;
+        return { ok: false, kind: "shape" };
     const a = v.answers;
     if (!Array.isArray(a) || a.length === 0)
-        return false;
-    return a.every((it) => {
+        return { ok: false, kind: "shape" };
+    const buckets = { unknown: [], unsupported: [] };
+    scanKeyClosure(v, "answer.", ACCEPTED_QUESTION_ANSWER_TOP, NO_TOLERATED_KEYS, buckets);
+    a.forEach((it, i) => {
+        if (!it || typeof it !== "object" || Array.isArray(it))
+            return;
+        scanKeyClosure(it, `answer.answers[${i}].`, ACCEPTED_QUESTION_ANSWER_ITEM, NO_TOLERATED_KEYS, buckets);
+    });
+    if (buckets.unknown.length > 0)
+        return { ok: false, kind: "unknown_key", keyPaths: buckets.unknown.sort().slice(0, MAX_KEY_ECHO) };
+    const shapeOk = a.every((it) => {
         if (!it || typeof it !== "object" || Array.isArray(it))
             return false;
         const { header, selected, note } = it;
@@ -95,6 +128,7 @@ export function isQuestionAnswer(v) {
             selected.every((s) => typeof s === "string") &&
             (note === undefined || typeof note === "string"));
     });
+    return shapeOk ? { ok: true, value: v } : { ok: false, kind: "shape" };
 }
 async function decideIdempotentReplay(cs, args) {
     const { sessionId, out, binding, decision, payload, deciderPrincipal, explicitOperator, warn } = args;
@@ -173,7 +207,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
             const scope = operator
                 ? (new URLSearchParams(match.search).get("owner") ?? undefined)
                 : (principal ?? "__none__");
-            await streamApprovals(req, res, cs, scope, deps.config);
+            await streamApprovals(req, res, cs, deps.toolApproval, scope, deps.config);
             return;
         }
         if (match.decl.id === "approvals-list") {
@@ -464,7 +498,13 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 }
                 const storeNowMs = await store.nowMs();
                 const hdr = (n) => { const h = req.headers[n]; return Array.isArray(h) ? h[0] : h; };
-                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, { sessionId: run.sessionId, boundCallId: planNonce ?? null, boundInputHash: decision === "edit" ? editedPlanBinding(body.editedPlan) : null, decision, reason: typeof body.reason === "string" ? body.reason : null, ...(isPlanApprovePermissionModeAfter(body.permissionModeAfter) ? { permissionModeAfter: body.permissionModeAfter } : {}) }, deps.config, { actionBinding: false, nowSec: Math.floor(storeNowMs / 1000) });
+                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, buildApprovalEnvelope(run.sessionId, PLAN_REVIEW_PROOF_COVERED_KEYS, {
+                    boundCallId: planNonce ?? null,
+                    decision,
+                    editedPlan: decision === "edit" ? editedPlanBinding(body.editedPlan) : null,
+                    permissionModeAfter: isPlanApprovePermissionModeAfter(body.permissionModeAfter) ? body.permissionModeAfter : undefined,
+                    reason: typeof body.reason === "string" ? body.reason : null,
+                }), deps.config, { actionBinding: false, nowSec: Math.floor(storeNowMs / 1000) });
                 if (!proof.ok) {
                     sendError(res, proof.status, proof.errorCode, proof.error);
                     return;
@@ -556,12 +596,19 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 remember = true;
             }
             let answer;
+            let answerProjection;
             if (body.answer !== undefined) {
-                if (!isQuestionAnswer(body.answer)) {
-                    sendError(res, 400, "request.body_shape", "malformed answer — expected { answers: [{ header, selected: string[], note? }] }");
+                const checked = checkQuestionAnswer(body.answer);
+                if (!checked.ok) {
+                    if (checked.kind === "shape") {
+                        sendError(res, 400, "request.body_shape", "malformed answer — expected { answers: [{ header, selected: string[], note? }] }");
+                        return;
+                    }
+                    sendError(res, 400, "request.field_invalid", `answer: unrecognized key(s) — refused rather than dropped, because a dropped key reads as "in effect" to the caller (a misspelled selected key silently drops part of the operator's answer). ${keyClosureClause([...checked.keyPaths], "unknown (not a question-answer key — check the spelling)")}. Accepted: answers, answers[].header, answers[].selected, answers[].note`, { unknownKeys: [...checked.keyPaths] });
                     return;
                 }
-                answer = body.answer;
+                answerProjection = projectQuestionAnswer(checked.value);
+                answer = questionAnswerFromProjection(answerProjection);
             }
             for (const f of ["checkpointToken", "boundCallId", "boundInputHash"]) {
                 if (body[f] !== undefined && typeof body[f] !== "string") {
@@ -573,6 +620,10 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 sendError(res, 400, "updated_input_not_in_proof", "updatedInput is not supported on a direct-door worker (not covered by the decision proof)");
                 return;
             }
+            if (deps.config.directDoorActive && body.checkpointToken !== undefined) {
+                sendError(res, 400, "checkpoint_token_not_in_proof", "checkpointToken is not supported on a direct-door worker (not covered by the decision proof); bind the decision with boundCallId and boundInputHash instead");
+                return;
+            }
             const binding = {
                 checkpointToken: body.checkpointToken,
                 boundCallId: body.boundCallId,
@@ -585,7 +636,13 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                     const h = req.headers[n];
                     return Array.isArray(h) ? h[0] : h;
                 };
-                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, { sessionId, boundCallId: binding.boundCallId, boundInputHash: binding.boundInputHash, decision, reason: typeof body.reason === "string" ? body.reason : null }, deps.config);
+                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, buildApprovalEnvelope(sessionId, DECIDE_PROOF_COVERED_KEYS, {
+                    answer: answerProjection,
+                    boundCallId: binding.boundCallId,
+                    boundInputHash: binding.boundInputHash,
+                    decision,
+                    reason: typeof body.reason === "string" ? body.reason : null,
+                }), deps.config);
                 if (!proof.ok) {
                     sendError(res, proof.status, proof.errorCode, proof.error);
                     return;
@@ -664,7 +721,24 @@ function projectPendingForWire(row, governance) {
     const governanceForced = governanceOriginOf({ riskDescriptor: row.riskDescriptor ?? undefined }, governance);
     return governanceForced ? { ...redacted, governanceForced } : redacted;
 }
-export async function streamApprovals(req, res, cs, scope, governance, pollMs = APPROVALS_STREAM_POLL_MS) {
+function createSseDeltaLane(res, spec) {
+    let prev = new Map();
+    return {
+        tick(rows) {
+            const cur = new Map(rows.map((r) => [spec.keyOf(r), { row: r, bytes: spec.bytesOf(r) }]));
+            for (const [k, v] of cur) {
+                if (prev.get(k)?.bytes !== v.bytes)
+                    res.write(`event: ${spec.upsertEvent}\ndata: ${JSON.stringify(spec.upsertData(v.row, Date.now()))}\n\n`);
+            }
+            for (const [k, v] of prev) {
+                if (!cur.has(k))
+                    res.write(`event: ${spec.exitEvent}\ndata: ${JSON.stringify(spec.exitData(v.row, Date.now()))}\n\n`);
+            }
+            prev = cur;
+        },
+    };
+}
+export async function streamApprovals(req, res, cs, live, scope, governance, pollMs = APPROVALS_STREAM_POLL_MS) {
     const keyOf = (p) => JSON.stringify([p.sessionId, p.toolCallId ?? null]);
     sseHeaders(res);
     res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, mode: "approvals-delta", pollMs: APPROVALS_STREAM_POLL_MS })}\n\n`);
@@ -672,13 +746,29 @@ export async function streamApprovals(req, res, cs, scope, governance, pollMs =
     bindSseLifecycle(req, res, () => { closed = true; });
     const start = Date.now();
     let lastBeat = Date.now();
-    let prev = new Map();
-    let prevFrames = new Map();
+    const durableLane = createSseDeltaLane(res, {
+        upsertEvent: "pending",
+        exitEvent: "resolved",
+        keyOf,
+        bytesOf: (p) => JSON.stringify({ type: "pending", ...p }),
+        upsertData: (p, nowMs) => ({ type: "pending", ...p, serverNowMs: nowMs }),
+        exitData: (p, nowMs) => ({ type: "resolved", sessionId: p.sessionId, toolCallId: p.toolCallId, serverNowMs: nowMs }),
+    });
+    const liveLane = createSseDeltaLane(res, {
+        upsertEvent: "live_pending",
+        exitEvent: "live_resolved",
+        keyOf: (r) => r.approvalId,
+        bytesOf: (r) => JSON.stringify({ type: "live_pending", ...r }),
+        upsertData: (r, nowMs) => ({ type: "live_pending", ...r, serverNowMs: nowMs }),
+        exitData: (r, nowMs) => ({ type: "live_resolved", approvalId: r.approvalId, serverNowMs: nowMs }),
+    });
     let first = true;
     while (!closed) {
         let pending;
+        let livePending;
         try {
             pending = (await cs.listPending(scope)).map((r) => projectPendingForWire(r, governance));
+            livePending = live ? live.listLivePending(scope) : [];
         }
         catch {
             if (!res.writableEnded)
@@ -686,25 +776,12 @@ export async function streamApprovals(req, res, cs, scope, governance, pollMs =
             await sleep(pollMs);
             continue;
         }
-        const cur = new Map(pending.map((p) => [keyOf(p), p]));
-        const curFrames = new Map([...cur].map(([k, p]) => [k, JSON.stringify({ type: "pending", ...p })]));
-        const pendingFrame = (k) => JSON.stringify({ type: "pending", ...cur.get(k), serverNowMs: Date.now() });
+        durableLane.tick(pending);
+        liveLane.tick(livePending);
         if (first) {
-            for (const k of curFrames.keys())
-                res.write(`event: pending\ndata: ${pendingFrame(k)}\n\n`);
             res.write(`event: synced\ndata: ${JSON.stringify({ type: "synced", count: pending.length })}\n\n`);
             first = false;
         }
-        else {
-            for (const [k, frame] of curFrames)
-                if (prevFrames.get(k) !== frame)
-                    res.write(`event: pending\ndata: ${pendingFrame(k)}\n\n`);
-            for (const [k, p] of prev)
-                if (!cur.has(k))
-                    res.write(`event: resolved\ndata: ${JSON.stringify({ type: "resolved", sessionId: p.sessionId, toolCallId: p.toolCallId, serverNowMs: Date.now() })}\n\n`);
-        }
-        prev = cur;
-        prevFrames = curFrames;
         if (Date.now() - start > SSE_MAX_STREAM_MS) {
             res.write(`event: error\ndata: ${JSON.stringify({ type: "error", errorCode: "STREAM_MAX_DURATION", message: "approvals stream reached its 15-minute cap — reconnect to continue" })}\n\n`);
             break;

package/dist/http/routes/capabilities.js

@@ -14,6 +14,7 @@ import { projectWriteProtectionCapability } from "../../write-protection.js";
 import { projectSqlEngineCapability } from "../../sql-engine-posture.js";
 import { projectWebSearchCapability } from "../../plugins/web-search.js";
 import { projectExecutionLaneCapability } from "../../capabilities/execution-lane.js";
+import { projectApprovalsStreamLiveCapability } from "../../capabilities/approvals-push.js";
 import { workflowModelAllowlistFor, selfOrchestrationDenial } from "../../task-workflow.js";
 import { centerEntitlementSourceWired } from "../../runtime-caps-resolver.js";
 import { judgeAutoModeArming } from "../../auto-mode-face.js";
@@ -138,6 +139,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 mcpElicitation: Boolean(deps.elicitation),
                 askUserQuestion: Boolean(deps.question),
                 toolApproval: Boolean(deps.toolApproval),
+                approvalsStreamLive: projectApprovalsStreamLiveCapability(deps),
                 streamApproval: resolveStreamApprovalGate({
                     toolApprovalEnabled: Boolean(deps.toolApproval),
                     streamApprovalEnabled: deps.config.streamApproval?.enabled === true,

package/dist/http/routes/fleet.js

@@ -40,7 +40,7 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
         const visW = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
         const SCOPED_TASK_KEY_DISPOSITION = {
             id: "keep", parentId: "keep", parentToolCallId: "keep", workflowRunId: "keep", status: "keep",
-            startedAt: "keep", elapsedMs: "keep", tokens: "keep", queuedCount: "keep",
+            startedAt: "keep", elapsedMs: "keep", tokens: "keep",
             awaitingPlanApproval: "keep", toolUses: "keep", usage: "keep", resumable: "keep", sourceLane: "keep",
             cycleSeq: "keep", retiredBy: "keep",
             name: "rewrite", scope: "strip", sessionId: "strip",
@@ -61,7 +61,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     ...(rest.startedAt !== undefined ? { startedAt: rest.startedAt } : {}),
                     ...(rest.elapsedMs !== undefined ? { elapsedMs: rest.elapsedMs } : {}),
                     ...(rest.tokens !== undefined ? { tokens: rest.tokens } : {}),
-                    ...(rest.queuedCount !== undefined ? { queuedCount: rest.queuedCount } : {}),
                     ...(rest.awaitingPlanApproval !== undefined ? { awaitingPlanApproval: rest.awaitingPlanApproval } : {}),
                     ...(rest.toolUses !== undefined ? { toolUses: rest.toolUses } : {}),
                     ...(rest.usage !== undefined ? { usage: rest.usage } : {}),

package/dist/http/routes/runs.js

@@ -1,5 +1,5 @@
 import { persistedPlaneOf } from "../../terminal.js";
-import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactHead, redactLedgerEventData, redactTerminalResult } from "../../observability/run-terminal-log.js";
+import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactHead, redactLedgerEventData, redactTerminalResult } from "../../observability/run-terminal.js";
 import { isModelTextLedgerEventType } from "../../trace/ledger-events.js";
 import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, validatePendingSteer } from "@sema-agent/core";
@@ -89,7 +89,7 @@ async function subagentReadGate(req, res, ctx, runId, search) {
 }
 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");
+        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. Read the run's own outcome via GET /v1/runs/:id");
         return true;
     }
     if (run.status === "running" && runProvenElsewhere(run, thisInstanceId)) {

package/dist/http/routes/tasks.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { runWithVerification, runCascade, uuidv7, terminalProjection } from "@sema-agent/core";
 import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, resumeAtHttpStatus, HEARTBEAT_MS } from "../../runs.js";
 import { stripResumeToken } from "../../terminal.js";
@@ -414,7 +414,7 @@ export async function handleTasks(req, res, match, ctx) {
                                     finalizeTaskResult(ev.result, principal, prepared.spec.objective, prepared.spec.sessionId);
                                     noteRunOutcome(finalResult);
                                     putRewindAnchor();
-                                    settleFleet(finalResult ? terminalProjection(finalResult.terminal).status : "completed", fleetRunResiduals(finalResult));
+                                    settleFleet(terminalProjection(finalResult.terminal).status, fleetRunResiduals(finalResult));
                                     if (ledgerSink && finalResult) {
                                         if (usageKey && deps.modelUsage && deps.runStore && durableTaskId) {
                                             const rs2 = deps.runStore;

package/dist/http/routes/workflows.js

@@ -5,7 +5,7 @@ import { redactSteerIn, STEER_IN_MAX_CHARS, STEER_IN_MAX_REQUEST_CHARS } from ".
 import { journalEntryOfRow, journalEntryPayload, journalRowPayloadOf } from "../../orchestration/workflow-journal-entry.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { createHash } from "node:crypto";
-import { redactErrorMessage, redactHead } from "../../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead } from "../../observability/run-terminal.js";
 const JOURNAL_PROJECTION_MEMO_CAP = 1024;
 const journalProjectionMemo = new Map();
 import { sendJson, sendError, sseHeaders } from "../send.js";

package/dist/http/server.d.ts

@@ -28,8 +28,8 @@ import type { ModelUsageTracker, PromptManifestTracker } from "../budget.js";
 import { scopedIdempotencyKey } from "./idempotency.js";
 export { scopedIdempotencyKey };
 import type { ConsolidationSeatLabel } from "../boot/memory-consolidation.js";
-import { streamApprovals, isQuestionAnswer } from "./routes/approvals-assistant.js";
-export { streamApprovals, isQuestionAnswer };
+import { streamApprovals, checkQuestionAnswer } from "./routes/approvals-assistant.js";
+export { streamApprovals, checkQuestionAnswer };
 import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";

package/dist/http/server.js

@@ -1,5 +1,5 @@
 import http from "node:http";
-import { redactHead } from "../observability/run-terminal-log.js";
+import { redactHead } from "../observability/run-terminal.js";
 import { validatePendingSteer, terminalProjection } from "@sema-agent/core";
 import {} from "../config-center/facade.js";
 import { HttpError } from "../security.js";
@@ -12,8 +12,8 @@ import {} from "../tool-approval.js";
 import {} from "../observability/rate-limit.js";
 import { IdempotencyCache, scopedIdempotencyKey } from "./idempotency.js";
 export { scopedIdempotencyKey };
-import { streamApprovals, isQuestionAnswer } from "./routes/approvals-assistant.js";
-export { streamApprovals, isQuestionAnswer };
+import { streamApprovals, checkQuestionAnswer } from "./routes/approvals-assistant.js";
+export { streamApprovals, checkQuestionAnswer };
 import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";

package/dist/leader/diffout.js

@@ -1,4 +1,4 @@
-import { redactHead } from "../observability/run-terminal-log.js";
+import { redactHead } from "../observability/run-terminal.js";
 export const DEFAULT_MAX_DIFF_BYTES = 5 * 1024 * 1024;
 const DEFAULT_READ_TIMEOUT_MS = 30_000;
 const SAFE_REV = /^[A-Za-z0-9._/-]{1,200}$/;

package/dist/leader/endpoint.js

@@ -1,5 +1,5 @@
 import { uuidv7 } from "@sema-agent/core";
-import { redactErrorMessage, redactHead, redactLeaderResult, redactLeaderResultWithFlag } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead, redactLeaderResult, redactLeaderResultWithFlag } from "../observability/run-terminal.js";
 import { withPrincipal } from "../observability/principal-context.js";
 import { leaderIdemKey } from "../plugins/leader-run-store-sql.js";
 function statusForLeaderResult(result) {

package/dist/leader/fanout.js

@@ -1,5 +1,5 @@
 import { terminalProjection } from "@sema-agent/core";
-import { redactErrorMessage, redactWorkerReportError } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactWorkerReportError } from "../observability/run-terminal.js";
 import { pausedCauseOf } from "../terminal.js";
 class Semaphore {
     max;

package/dist/leader/leader.js

@@ -1,5 +1,5 @@
 import { fanOut } from "./fanout.js";
-import { redactErrorMessage, redactHead } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead } from "../observability/run-terminal.js";
 import { pullDiff } from "./diffout.js";
 import { mergeBranches } from "./merge.js";
 import { Runner, runWithVerification, resumeWithVerification, terminalProjection } from "@sema-agent/core";

package/dist/leader/merge.js

@@ -1,5 +1,5 @@
 import { delimitUntrusted } from "@sema-agent/core";
-import { OVERSIZED_DIAG_PLACEHOLDER, redactArtifactText, redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal-log.js";
+import { OVERSIZED_DIAG_PLACEHOLDER, redactArtifactText, redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal.js";
 import { applyAndGrade, changedFilesOutOfAllowlist } from "./grader-env-factory.js";
 import { shellQuote as Q } from "../plugins/remote-shell.js";
 const CONFLICT_FILES_MAX = 200;

package/dist/leader/planner.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal.js";
 export function economicGuard(objective, opts = {}) {
     if (opts.fanoutEnabled === false)
         return { single: true, reason: "fan-out disabled by deployment (A6)" };

package/dist/leader/repair-oracle.js

@@ -1,7 +1,7 @@
 import { runExecGate, } from "@sema-agent/core";
 import { createHash } from "node:crypto";
 import { shellQuote as sq } from "../plugins/remote-shell.js";
-import { redactHead, redactTail } from "../observability/run-terminal-log.js";
+import { redactHead, redactTail } from "../observability/run-terminal.js";
 const sha = (s) => createHash("sha256").update(s).digest("hex").slice(0, 16);
 function changedFilesOf(patch) {
     const out = new Set();

package/dist/leader/repair-wire.js

@@ -1,7 +1,7 @@
 import { runRepairLoop, delimitUntrusted, } from "@sema-agent/core";
 import { mkRepairOracle } from "./repair-oracle.js";
 import { terminalProjection } from "@sema-agent/core";
-import { redactHead } from "../observability/run-terminal-log.js";
+import { redactHead } from "../observability/run-terminal.js";
 function statusForTerminal(t) {
     return t === "fixed" || t === "candidate_only" ? "completed" : "failed";
 }

package/dist/leader/wire.js

@@ -16,7 +16,7 @@ import { attachRepairLoopDeps } from "./repair-wire.js";
 import { routePlanWithFallback, validateSubtasks } from "./planner.js";
 import { createEngineNoticeSeat } from "../boot/runner-deps.js";
 import { currentPrincipal } from "../observability/principal-context.js";
-import { redactHead } from "../observability/run-terminal-log.js";
+import { redactHead } from "../observability/run-terminal.js";
 const REPAIR_LOOP_WIRED = true;
 const sh = (env) => async (cmd) => {
     const r = await env.exec(`bash -lc ${JSON.stringify(cmd)}`);

package/dist/model-provider.d.ts

@@ -0,0 +1,77 @@
+/**
+ * S-461 —— **模型 provider 词表的唯一属主**(闭集 + 路由腿的穷举判词 + 域外拒因)。
+ *
+ * ## 病
+ * `MODEL_PROVIDER` 此前收**任意字符串**(`config.ts` 里就是一句 `process.env.MODEL_PROVIDER`),而消费它的
+ * 只有一处「非 anthropic 即 gateway」的二分。于是最自然的误填 —— 把**厂商名**写成 provider,
+ * `MODEL_PROVIDER=deepseek` —— 起得来、静默走网关栈(实测改前读数:`model.provider="deepseek"`、
+ * `api="openai-completions"`)。运维以为自己点了一条专用路线,拿到的是默认腿,而读数上没有任何异常。
+ * 这与 [ref] 件⑤ / S-188 的三根模型线路旋钮是**同一条族律**([ref] A 档:坏值拒启,不静默折默认)。
+ *
+ * ## 词源:取不到型,就取那句自述 + 一格钉
+ * 词表的上游属主是 `@sema-agent/settings-schema` 的 `ModelEntry.provider`。它的 zod 形是
+ * `z.string().min(1).default("gateway")` —— **没有可取的型**(与 `RemoteExecProvider` / `WebSearchProvider`
+ * 那两张能取型的表不同),但它的 JSDoc 逐字写着三词与各自的腿:
+ *   > Routes the brain in the service (createRoutingBrain by provider): "gateway"/"vllm" → OpenAI brain,
+ *   > "anthropic" → Anthropic brain.
+ * 于是本仓建闭集常量,并由 `test/config-coverage-model-plane.test.ts` 的 S-461 ④ 格**钉住它与那句自述同集**
+ * (读的是装载的那份 dist,不手抄第二份词表)。上游哪天把词表写进 zod enum,那一格会告诉我们该改成取型。
+ *
+ * ## 三条腿各自的边界(刻意分开写)
+ *  · {@link isModelProvider} / {@link modelProviderRefusal} —— **env 面**的闭集判据与拒因。它管的是
+ *    `MODEL_PROVIDER`(以及缺省推断产出的那个词),执法点在 `config.ts` 的模型面装配 + `config-invariants.ts`
+ *    的 `model-provider-word` 条(热路径同判,不是第二份判据);
+ *  · {@link modelBrainLane} —— **穷举 switch**([ref]:词表是闭集,加一词不补臂 = 编译红);
+ *  · {@link catalogBrainLane} —— **目录词**那一侧。见它自己的头注:目录条目的 provider **不过** boot 闸,
+ *    所以那里必须有一条「认不出」的臂,而那条臂是**既有语义的书面化**,不是本批新开的兜底。
+ */
+/**
+ * `MODEL_PROVIDER` 的闭集。**声明序 = 语义序**:两条 OpenAI 兼容腿在前,Anthropic 腿在后
+ * (与上游那句自述的行文同序,方便逐字对读)。
+ */
+export declare const MODEL_PROVIDER_WORDS: readonly ["gateway", "vllm", "anthropic"];
+/** 闭集成员型。加一词 ⇒ {@link modelBrainLane} 的穷举 switch 当场编译红。 */
+export type ModelProvider = (typeof MODEL_PROVIDER_WORDS)[number];
+/** 这个词在闭集里吗(`undefined` / 空串一律 false —— 「未设」不是一个 provider,由调用点自己折缺省)。 */
+export declare function isModelProvider(word: string | undefined): word is ModelProvider;
+/**
+ * 域外值的**拒因**(`undefined` = 这个词合法)。
+ *
+ * 🔴 **机读码 `config.model_provider_invalid` 逐字在句子里**(clay 令 2026-09-18):拒启原话是运维与壳
+ * 唯一拿得到的东西,一句纯散文只能靠人读。码的拼法随 `config.<键名蛇形>_invalid` 既有族
+ * (`config.retention_policy_invalid` / `config.execution_env_home_dir_invalid` / `config.placement_root_invalid`),
+ * 方括号形与本仓既有那一处(`plugins/remote-env-device.ts`)逐字同形。**出现位置**:boot 期 `loadConfig()`
+ * 抛出的 Error.message ⇒ 进程以非零退出,这句话落在 **stderr 首屏**(未捕获异常的栈首行)。
+ *
+ * 拒因三件齐:**码** + **违例值**(照原样带引号,前后空格/大小写一眼可见) + **闭集三词**。
+ */
+export declare function modelProviderRefusal(word: string): string | undefined;
+/** 一只 provider 词走哪条 brain 腿。闭集 ⇒ 两个值,没有第三种。 */
+export type ModelBrainLane = "anthropic" | "gateway";
+/**
+ * **穷举判词**([ref]:词表是闭集,加一词而不补臂是 COMPILE 错,不是运行期漏判)。
+ *
+ * `"vllm"` 与 `"gateway"` 同腿**不是**兜底,是上游那句自述的逐字转写(两者都是 OpenAI 兼容端点,
+ * 差别在部署形而不在协议);它们哪天要分家,分的是这张表,而不是某个调用点的 `if`。
+ */
+export declare function modelBrainLane(provider: ModelProvider): ModelBrainLane;
+/**
+ * **目录条目**(`config.models[*].provider`)那一侧的判词。
+ *
+ * 🔴 为什么它与 {@link modelBrainLane} 不是同一只函数:两者的**输入保证不同**。
+ *  · `MODEL_PROVIDER` 走 boot 闸(域外拒启)⇒ 到达 {@link modelBrainLane} 的恒是闭集词;
+ *  · **目录条目**来自 settings-schema 的 `z.string()`,可以从 config-center **热应用**进来 —— 那条路上
+ *    没有、也不该有「拒启」这回事(一次热发布不能让在跑的副本死),所以这里必然存在一条「认不出」的臂。
+ *
+ * 🔴 那条臂**就是今天的语义,本批一个字节都没改**([ref]「不可避免的运行期 miss 臂必须说出来」):
+ * core 的 `createRoutingBrain({anthropic}, {fallback: gatewayStack})` 本身就把一切非 `anthropic` 的词
+ * 路由到网关栈(`brain.ts` 顶注那句 "everything else → the local gateway stack (also the fallback for an
+ * unrecognized provider)" 是它的原话)。本函数做的只是把那句散文变成**一个有名字的判词**,于是
+ * 「目录里写了个没人认识的 provider」这件事在代码里有一处可指的坐标,而不是散在两个 `=== "anthropic"` 里。
+ *
+ * ⚠️ **未闭环**(S-461 收车档登记):目录词今天仍然**无声**地落进网关腿。要让它也响亮,需要的是一条
+ * **热路径上的**告警/拒收(config-center 应用期逐条校验 + 运维可读的拒因),那是另一件事、另一台车 ——
+ * 在这里加一个 throw 会让一次热发布打死在跑的副本,方向反了。
+ */
+export declare function catalogBrainLane(provider: string | undefined): ModelBrainLane;
+//# sourceMappingURL=model-provider.d.ts.map

package/dist/model-provider.js

@@ -0,0 +1,26 @@
+export const MODEL_PROVIDER_WORDS = ["gateway", "vllm", "anthropic"];
+export function isModelProvider(word) {
+    return word !== undefined && MODEL_PROVIDER_WORDS.includes(word);
+}
+export function modelProviderRefusal(word) {
+    if (isModelProvider(word))
+        return undefined;
+    return (`env MODEL_PROVIDER="${word}" is not a known model provider [config.model_provider_invalid] — ` +
+        `valid: ${MODEL_PROVIDER_WORDS.join(" | ")}. ` +
+        "An unknown word used to start FINE and silently route to the gateway stack (a vendor name like " +
+        '"deepseek" in this slot is the natural mis-fill), so the operator got the default leg while believing ' +
+        "they had pinned a dedicated one — nothing in the readings showed it (#210 A 档:坏值拒启,不静默折默认).");
+}
+export function modelBrainLane(provider) {
+    switch (provider) {
+        case "anthropic":
+            return "anthropic";
+        case "gateway":
+        case "vllm":
+            return "gateway";
+    }
+}
+export function catalogBrainLane(provider) {
+    return isModelProvider(provider) ? modelBrainLane(provider) : "gateway";
+}
+//# sourceMappingURL=model-provider.js.map