@sema-agent/server 7.121.0 → 7.123.0

package/dist/http/resume-legs.js

@@ -29,7 +29,7 @@ import { reasoningDeltaBytes, reasoningSegmentEventId } from "../trace/model-seg
 import { errorText } from "../observability/err-text.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
-import { storedBodyPermissionMode } from "../task-settings.js";
+import { planReviewDecisionExitsPlan, storedBodyPermissionMode } from "../task-settings.js";
 import { acceptedResumingReceipt, buildHostLegOutcome } from "./route-ctx.js";
 import { mintAndDriveDurableRun } from "./durable-run-leg.js";
 import { createSessionsLocal } from "./routes/sessions.js";
@@ -43,7 +43,8 @@ import { commitSessionInheritEnv } from "./session-inherit-env.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../approval-content-kind.js";
 import { deploymentListAsks } from "../approval.js";
 import { readResumeCtx, resumeCtxCorruptAnswer } from "./resume-ctx-read.js";
-import { resumeBlockedByPolicyAnswer, storedBodyReplayAnswer, storedBodyReplayLogFields, storedBodyReplayRefusal } from "./checkpoint-ctx.js";
+import { resumeBlockedByPolicyAnswer, storedBodyReplayAnswer, storedBodyReplayLogFields, withPermissionModeRewritten } from "./checkpoint-ctx.js";
+import { storedBodyReplayRefusal } from "./stored-body-replay.js";
 import { httpErrorCode } from "./send.js";
 function isCheckpointReopenedFailure(r) {
     const code = failureCodeOf(r.terminal);
@@ -422,7 +423,7 @@ export function createResumeLegs(ctx) {
         return storedBodyReplayAnswer(refusal);
     };
     const resolveResumeSpecOrBlocked = async (ctx, req, auth) => {
-        const replay = storedBodyReplayRefusal(ctx);
+        const replay = storedBodyReplayRefusal(ctx, deps.config.autonomy);
         if (replay !== undefined)
             return { ok: false, answer: refuseStoredBodyReplay(auth.sessionId, replay) };
         try {
@@ -1352,7 +1353,7 @@ export function createResumeLegs(ctx) {
             return refuse(resumeCtxCorruptAnswer(ctxRead.where));
         if (ctxRead.kind === "absent")
             return refuse({ status: 409, body: { error: "resume context missing — cannot rebuild task config", errorCode: "conflict.resume_context_unavailable" } });
-        const replay = storedBodyReplayRefusal(ctxRead.ctx);
+        const replay = storedBodyReplayRefusal(ctxRead.ctx, deps.config.autonomy);
         if (replay !== undefined)
             return refuse(refuseStoredBodyReplay(sessionId, replay));
         return { ok: true, prepared: { sessionId, token, cp, ctx: ctxRead.ctx } };
@@ -1364,11 +1365,10 @@ export function createResumeLegs(ctx) {
         const auth = { sessionId: cp.sessionId, principal: decodeCheckpointScope(cp.scope), memoryScope: ctx.memoryScope };
         const effMode = storedBodyPermissionMode(ctx.body);
         if (permissionModeAfter !== undefined && effMode !== "plan") {
-            throw new Error("drivePlanReview: permissionModeAfter was passed for a task that was not submitted with permissionMode \"plan\" — the caller must refuse this before any state changes (see the plan_review route's pre-nonce gate)");
+            throw new Error("drivePlanReview: permissionModeAfter was passed for a task whose stored permission mode is not \"plan\" — the caller must refuse this before any state changes (see the plan_review route's pre-nonce gate)");
         }
-        const approvedMode = decision === "approve" && effMode === "plan" ? (permissionModeAfter ?? "default") : undefined;
-        const resumeBody = approvedMode === undefined ? ctx.body : { ...ctx.body, permissionMode: approvedMode };
-        const rebuildCtx = { ...ctx, body: resumeBody };
+        const approvedMode = planReviewDecisionExitsPlan(decision) && effMode === "plan" ? (permissionModeAfter ?? "default") : undefined;
+        const rebuildCtx = approvedMode === undefined ? ctx : withPermissionModeRewritten(ctx, { ...ctx.body, permissionMode: approvedMode });
         const resolved = await resolveResumeSpecOrBlocked(rebuildCtx, req, auth);
         if (!resolved.ok)
             return resolved.answer;

package/dist/http/route-ctx.d.ts

@@ -168,6 +168,14 @@ export interface CheckpointCtx {
      * 写点只有 `buildCheckpointCtx`(同模块;新的持久化写);续跑腿的写回传原 ctx / 其展开 ⇒ 记号随行。体里没有 `allow` 的行不写它。
      */
     permissionsAllowReading?: import("./checkpoint-ctx.js").PermissionsAllowReading;
+    /**
+     * 体里**模式词的读法记号**(闭集只有当前一词 `"entry_word"`):在场 = 这一行体的顶层 `permissionMode` 是这条 run 模式词唯一的源(提交入口盖过运维
+     * `AUTONOMY=plan` 的地板;`plan_review` 写回改它),续跑照它读。**服务端写、不来自请求体**。缺席(7.121.x 及以前写下的行 —— 那时运维的 plan 由治理层每段重钳)
+     * 而本部署此刻有入口地板、体的词被地板钳会变 ⇒ 续跑腿响亮拒、行字节不动(规则与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注第三问)。
+     * 写点两个(写模式词的人盖记号,同模块):`buildCheckpointCtx`(每一次新的持久化写都写)与 `withPermissionModeRewritten`(`plan_review` 改词的写回);
+     * 不改词的续跑腿写回传原 ctx ⇒ 记号随行。
+     */
+    permissionModeReading?: import("./checkpoint-ctx.js").PermissionModeReading;
 }
 /** B4①(命名化):`driveResumeIntoRunLog` 的入参形(resume 家族共用)——原为 9 成员内联匿名对象。 */
 export interface DriveResumeArgs {
@@ -448,8 +456,8 @@ export interface RouteLegs {
     drivePlanReview(prepared: PreparedPlanReview, decision: "approve" | "edit" | "reject", editedPlan: string | undefined, reason: string | undefined, req: IncomingMessage | undefined, 
     /** [ref] 件 S-1:透传给 {@link DriveResumeArgs.acceptEarly}(200 受理语义)。HTTP `/plan_review` 腿传 `true`。 */
     acceptEarly?: boolean, 
-    /** S-433:批准之后这条会话继续用的 permission mode(闭集 `PLAN_APPROVE_PERMISSION_MODES_AFTER`;只在 `approve`
-     *  上有意义,缺席 ⇒ `"default"`)。语义与判据的唯一属主 = `resume-legs.ts` 的同名形参顶注。 */
+    /** S-433:批准之后这条会话继续用的 permission mode(闭集 `PLAN_APPROVE_PERMISSION_MODES_AFTER`;只在把计划带出 plan 的决定
+     *  —— `approve` / `edit` —— 上有意义,缺席 ⇒ `"default"`)。语义与判据的唯一属主 = `resume-legs.ts` 的同名形参顶注。 */
     permissionModeAfter?: PlanApprovePermissionModeAfter): Promise<{
         status: number;
         body: object;
@@ -586,7 +594,7 @@ export interface RouteDeclFacts {
      *  503 照旧罩着(它判的是「这台机能不能收写」,与方法无关,且必须在解析请求体之前)。 */
     readonly methodDispatched?: true;
 }
-/** **可分派行**多出来的两列(S-146 第三刀):身份 + 它真认的方法。纯门行两列都没有(见下)。 */
+/** **可分派行**多出来的列(S-146 第三刀):身份 + 它真认的方法(+ S-1281 的订阅类)。纯门行一列都没有(见下)。 */
 interface RouteDeclIdentity {
     /** **全表唯一**的行名(kebab 闭集词)。这是声明行的身份:域 handler 用
      *  `switch (match.decl.id)` 闭集分派(漏一口 = 编译红),所以它必须稳定、唯一、且与路径解耦
@@ -601,6 +609,14 @@ interface RouteDeclIdentity {
      *     ② 2 条「一条路径住着两只域」的跨域行按方法拆成两行各归各域(`/v1/tasks` = trace-usage 的 GET +
      *     tasks 的 POST;`/v1/memory/export` = memory-policy 的 GET + memory-bundle 的 POST)。 */
     readonly methods: readonly RouteMethod[];
+    /**
+     * 「这条 GET 开的是一条**只读订阅**」—— 一条 SSE 读面(推送队列 / 账本 tail),它看着别人干活,自己不是活(S-1281)。
+     * 在场 ⇒ 分派器不把它记进在飞(`drainState.inflight()`:排空等的、`/health` 报的、SIGHUP 空闲窗与附着租约读的那一只),只记进附着
+     * (`attachedStreams()`:壳还挂在这只引擎上);排空进入那一拍(以及硬停起点)由分派器发一帧 `draining` 终帧后关掉它
+     * (`drainState.endSubscriptions`)。闭集 = 八条 GET SSE 读面,逐行理由见各行注;**唯一**一条「在飞腿的流」`POST /v1/tasks/stream`
+     * 不带它 —— 那条流就是 sync 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
+     */
+    readonly subscription?: true;
 }
 /**
  * **可分派行**:一条真路由。匹配式二选一 —— `path`(精确;标签**就是** path 自身,所以没有 label 列,

package/dist/http/route-table.d.ts

@@ -141,6 +141,9 @@ export declare function billableKindOf(url: string): BillableKind | undefined;
  *  `billable=false`(零模型工作),塞进那张名单会让它们连带吃 drain 与 roster-pending 两道 503 ——
  *  而收编与规则读写在排空期/roster 未落时做完全无害。 */
 export declare function isCredentialGatedRewrite(method: string, url: string): boolean;
+/** S-1281:这次请求是不是一条**只读订阅**(`RouteDeclFacts.subscription` 那一列;方法也要对上 —— 订阅行恒只认 GET)。
+ *  分派器在 admission 那一拍(第一个 await 之前)同步判它:订阅不进在飞计数,只进附着集与订阅集。 */
+export declare function isSubscriptionRequest(method: string, url: string): boolean;
 /** 见 `RouteDeclFacts.methodDispatched` 的头注(单 URL 多方法端点)。 */
 export declare function isMethodDispatchedSubmitPath(url: string): boolean;
 /** 一次分派查找的结果:命中的行与它的参数,外加**这条路径上所有行**的方法并集(405 的 `Allow`)。 */

package/dist/http/route-table.js

@@ -111,6 +111,7 @@ const LABEL_BY_PATH = new Map(ROUTE_DECLARATIONS.flatMap((d) => ("path" in d ? [
 const SHAPED_LABEL_DECLS = ROUTE_DECLARATIONS.filter((d) => !("path" in d) && typeof d.label === "string");
 const BILLABLE_DECLS = ROUTE_DECLARATIONS.filter((d) => d.billable !== undefined);
 const METHOD_DISPATCHED_DECLS = ROUTE_DECLARATIONS.filter((d) => d.methodDispatched === true);
+const SUBSCRIPTION_DECLS = ROUTE_DECLARATIONS.filter(isDispatchDecl).filter((d) => d.subscription === true);
 const CREDENTIAL_GATED_BY_METHOD = (() => {
     const m = new Map();
     for (const d of ROUTE_DECLARATIONS)
@@ -142,6 +143,9 @@ export function isCredentialGatedRewrite(method, url) {
     const rows = CREDENTIAL_GATED_BY_METHOD.get(method.toUpperCase());
     return rows !== undefined && rows.some((d) => declMatches(d, url));
 }
+export function isSubscriptionRequest(method, url) {
+    return SUBSCRIPTION_DECLS.some((d) => d.methods.includes(method) && matchDecl(d, url) !== null);
+}
 export function isMethodDispatchedSubmitPath(url) {
     return METHOD_DISPATCHED_DECLS.some((d) => declMatches(d, url));
 }

package/dist/http/routes/admin-drain.d.ts

@@ -6,8 +6,11 @@
  * 进入排空经 `drainState.enter`(收尾链装的唯一入口)。
  *  · 门序 = operator 面的既有口径(`routes/retention-ops.ts` 逐字):身份 → 授权 → 验型;billable=false,**刻意不吃排空 503**
  *    (排空中的重放必须能拿到 `already_draining` 回执,吃了就自锁)。
- *  · 体坏 ⇒ 400 `request.field_invalid`(零状态变化);身份不符 ⇒ 409 `conflict.fleet_identity`(零状态变化;拒句点名不符的字段,不回显值);
- *    没有收尾链(嵌入宿主 / 测试夹具)⇒ 501 `capability.drain_state_required`。
+ *  · 判序:体坏 ⇒ 400 `request.field_invalid`(零状态变化)→ 没有收尾链(嵌入宿主 / 测试夹具)⇒ 501 `capability.drain_state_required`
+ *    → 身份不符 ⇒ 409 `conflict.fleet_identity`(零状态变化;拒句点名不符的字段,不回显值)→ 入口:已在排空 / 硬停已在进行 ⇒ 200 回执
+ *    (这一发的期限不会被采用);这一发会进入排空而 `deadlineAt` 离进入那一拍超过 `FLEET_LEASE_OUTAGE_MAX_MS`(`config.fleetLeaseOutageMaxMs`,
+ *    本口随入参声明的准入上界,`fleet/drain-entry.ts` 规则 2)⇒ 入口答拒、本口 400 `request.field_invalid`(零状态变化;拒句点名字段、上界的
+ *    席名与值,不回显请求带的期限)。
  *  · 首次 ⇒ 200 回执 `state:"draining"`;同一 `actionId`(或别的动作)再来 ⇒ 200 `already_draining`,回显第一次的 `since` / `deadlineAt`,不重置。
  *  · 人手形:`actionId` 自取(推荐 `manual:<uuid>`),身份照样四元比对 —— 非 fleet 成员不带 `expectedGeneration`(缺席对缺席);
  *    `instanceId` 在场才比(从本机 `/health` 读);不带 `scope` = 点名缺省 scope(多租引擎要带它自己的 `FLEET_SCOPE`)。

package/dist/http/routes/admin-drain.js

@@ -39,8 +39,20 @@ export async function handleAdminDrain(req, res, match, ctx) {
                 sendError(res, 409, "conflict.fleet_identity", `the drain request names a different instance than this engine (mismatched: ${mismatched.join(", ")}) — nothing was changed; compare with this engine's GET /health (worker comes from SEMA_REGISTRY_WORKER, generation from FLEET_GENERATION, scope from FLEET_SCOPE — unset, and a request without scope, mean "${fleetScopeOf(undefined)}")`);
                 return;
             }
-            sendJson(res, 200, enter({ actionId: request.actionId, deadlineAt: request.deadlineAt }));
-            return;
+            const answer = enter({ actionId: request.actionId, deadlineAt: request.deadlineAt, deadlineBoundMs: deps.config.fleetLeaseOutageMaxMs });
+            switch (answer.state) {
+                case "deadline_beyond_bound":
+                    sendError(res, 400, "request.field_invalid", `the drain request's deadlineAt is further from now than FLEET_LEASE_OUTAGE_MAX_MS (${answer.boundMs} ms) on this engine's clock — the longest this engine stays up without serving; send a nearer deadline — nothing was changed`);
+                    return;
+                case "draining":
+                case "already_draining":
+                    sendJson(res, 200, answer);
+                    return;
+                default: {
+                    const unhandled = answer;
+                    throw new Error(`drain entry: unknown answer ${JSON.stringify(unhandled)}`);
+                }
+            }
         }
         default:
             return assertNever(match.decl.id);

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

@@ -151,6 +151,7 @@ export declare const APPROVALS_ASSISTANT_ROUTES: readonly [{
     readonly id: "approvals-stream";
     readonly path: "/v1/approvals/stream";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "assistant-inbox";
     readonly path: "/v1/assistant/inbox";

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

@@ -7,7 +7,7 @@ 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, projectQuestionAnswer, questionAnswerFromProjection } from "../../approval-hmac.js";
-import { PLAN_APPROVE_PERMISSION_MODES_AFTER, isPlanApprovePermissionModeAfter, storedBodyPermissionMode } from "../../task-settings.js";
+import { PLAN_APPROVE_PERMISSION_MODES_AFTER, isPlanApprovePermissionModeAfter, planReviewDecisionExitsPlan, 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.js";
@@ -59,7 +59,7 @@ const DECISION_DOOR_FAMILY = {
     "assistant-task-plan-review": {
         accepted: PLAN_REVIEW_BODY_DECLARED_KEYS,
         requestNoun: "plan-review-request",
-        costliestTypo: "a misspelled `permissionModeAfter` silently leaves this task read-only after you approved its plan",
+        costliestTypo: "a misspelled `permissionModeAfter` silently leaves this task asking before every write after you approved its plan",
     },
 };
 const SUBMIT_BODY_NEAR_MISS_KEYS = ["permissionMode"];
@@ -534,8 +534,8 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 sendError(res, 400, "request.field_invalid", `permissionModeAfter must be one of ${PLAN_APPROVE_PERMISSION_MODES_AFTER.map((m) => JSON.stringify(m)).join(" | ")} when present (the permission mode this task continues in once the plan is approved; absent = "default", which keeps asking before each write)`);
                 return;
             }
-            if (decision !== "approve" && body.permissionModeAfter !== undefined) {
-                sendError(res, 400, "request.field_conflict", `permissionModeAfter is only valid with decision 'approve' (got '${decision}')`);
+            if (!planReviewDecisionExitsPlan(decision) && body.permissionModeAfter !== undefined) {
+                sendError(res, 400, "request.field_conflict", `permissionModeAfter is only valid with a decision that carries the plan out ('approve' or 'edit'; got '${decision}')`);
                 return;
             }
             if (body.reason !== undefined && typeof body.reason !== "string") {
@@ -610,7 +610,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
             if (body.permissionModeAfter !== undefined) {
                 const storedCtx = plan.prepared.ctx;
                 if (storedCtx.body !== undefined && storedBodyPermissionMode(storedCtx.body) !== "plan") {
-                    sendError(res, 400, "request.field_conflict", "permissionModeAfter does not apply to this task: it was not submitted with permissionMode \"plan\", so approving the plan lifts no read-only restriction");
+                    sendError(res, 400, "request.field_conflict", "permissionModeAfter does not apply to this task: it was not started in plan mode (its stored permission mode is not \"plan\"), so approving the plan returns it to the mode it was in before planning");
                     return;
                 }
             }
@@ -910,7 +910,7 @@ export async function streamApprovals(req, res, cs, live, scope, governance, pol
 }
 export const APPROVALS_ASSISTANT_ROUTES = [
     { id: "approvals-list", path: "/v1/approvals", methods: ["GET"] },
-    { id: "approvals-stream", path: "/v1/approvals/stream", methods: ["GET"] },
+    { id: "approvals-stream", path: "/v1/approvals/stream", methods: ["GET"], subscription: true },
     { id: "assistant-inbox", path: "/v1/assistant/inbox", methods: ["GET"] },
     { id: "assistant-tasks", path: "/v1/assistant/tasks", methods: ["GET"] },
     { id: "approval-decide", pattern: /^\/v1\/approvals\/(?<sessionId>[^/]+)\/decide$/, label: "/v1/approvals/:id/decide", methods: ["POST"] },

package/dist/http/routes/capabilities.js

@@ -1,10 +1,12 @@
 import { PERMISSION_MODES, expandTiers, reasoningEffortLevelsOf, routePairingStatus } from "@sema-agent/core";
 import { modelImageInput, isModelAllowlisted, selectableCatalog } from "../../model-select.js";
+import { buildDroppedEntriesWire } from "../../config-center/read-warnings.js";
 import { modelKeyPoisonOf, resolveModelApiKey } from "../../key-resolver.js";
 import { projectSealedKeyCapability } from "../../sealed-key.js";
 import { cwdHonored, deviceCwdHonored } from "../../task-cwd.js";
 import { taskWriteFaceRefusal } from "../../hosted-posture.js";
-import { autonomyOverrides } from "../../runtime-governance.js";
+import { leaderEntryRefusal, leaderRunEntry } from "../../leader/run-entry.js";
+import { autonomyKeepsOpenWriteFace, autonomyModeFloor } from "../../runtime-governance.js";
 import { DEVICE_PROTOCOL_VERSION, DEVICE_WS_PATH } from "../../device-ws-protocol.js";
 import { a2aInjectionHonored } from "../../task-a2a.js";
 import { buildEmptyMcpProbeFace, buildMcpInjectionRefusal, buildMcpProbeCacheKey, buildMcpProbeInflightRefusal, buildMcpProbeRateKey, buildMcpProbeRateRefusal, createMcpProbeLocal, buildMcpProbeDeclarationRefusal, buildMcpProbeIncompleteRefusal, McpProbeIncomplete, MCP_PROBE_HTTP_STATUS, MCP_PROBE_MAX_INFLIGHT, MCP_PROBE_VERDICT_TIMEOUT_MS, createMcpProbeWalk, readMcpProbeBody, } from "../../capabilities/mcp-probe.js";
@@ -64,7 +66,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 return;
             }
             const entitlementSource = centerEntitlementSourceWired(deps.config);
-            const { fault: autoModeFault, ...autoMode } = await judgeAutoModeArming(deps.autoModeFace, { requestedMode, principal: gatedPrincipal(req, deps.config), localDeny: deps.config.permissionsDisableAutoMode });
+            const { fault: autoModeFault, ...autoMode } = await judgeAutoModeArming(deps.autoModeFace, { requestedMode, floor: autonomyModeFloor(deps.config.autonomy), principal: gatedPrincipal(req, deps.config), localDeny: deps.config.permissionsDisableAutoMode });
             if (autoModeFault !== undefined)
                 deps.logger?.warn("auto_mode_face_resolver_fault", { fault: autoModeFault });
             const rulesLaneForCaller = facts.ruleLaneForCaller(deps, gatedPrincipal(req, deps.config)).available;
@@ -82,7 +84,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                     ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "engine", hookFailureNotice: true, leaseClient: true, generationEcho: true }
                     : false,
                 workspace: facts.workspaceBrowse().available,
-                leader: facts.leaderLane(deps).available,
+                leader: facts.leaderLane(deps).available && leaderEntryRefusal(leaderRunEntry(deps.config.autonomy)) === undefined,
                 images: facts.imagePool(deps).available,
                 memory: false,
                 memoryWrite: false,
@@ -144,7 +146,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 skillToolLists: true,
                 projectContext: cwdHonored(deps.config),
                 callerCwd: cwdHonored(deps.config) || deviceCwdHonored(deps.config),
-                taskWriteFaceOpen: taskWriteFaceRefusal(deps.config) === undefined && autonomyOverrides(deps.config.autonomy).writeFace !== "roots",
+                taskWriteFaceOpen: taskWriteFaceRefusal(deps.config) === undefined && autonomyKeepsOpenWriteFace(deps.config.autonomy),
                 executionLane: projectExecutionLaneCapability(deps.config),
                 mcpInjection: facts.mcpInjection(deps).available,
                 a2a: true,
@@ -253,7 +255,7 @@ export async function handleCapabilities(req, res, match, ctx) {
             }));
             const nonAlias = Object.entries(deps.config.models).filter(([n]) => n !== "default");
             const defaultName = (nonAlias.find(([, m]) => m === deps.config.model) ?? nonAlias.find(([, m]) => m.id === deps.config.model.id))?.[0];
-            sendJson(res, 200, { models, default: deps.config.model.id, defaultModel: { id: deps.config.model.id, ...(defaultName ? { name: defaultName } : {}) } });
+            sendJson(res, 200, { models, default: deps.config.model.id, defaultModel: { id: deps.config.model.id, ...(defaultName ? { name: defaultName } : {}) }, droppedEntries: buildDroppedEntriesWire(deps.config.droppedCatalogEntries) });
             return;
         }
         default:

package/dist/http/routes/fleet.d.ts

@@ -14,6 +14,7 @@ export declare const FLEET_ROUTES: readonly [{
     readonly id: "fleet-stream";
     readonly path: "/v1/fleet/stream";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }];
 /** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
 export type FleetRouteId = RouteIdsOf<typeof FLEET_ROUTES>;

package/dist/http/routes/fleet.js

@@ -239,6 +239,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
     });
 }
 export const FLEET_ROUTES = [
-    { id: "fleet-stream", path: "/v1/fleet/stream", methods: ["GET"] },
+    { id: "fleet-stream", path: "/v1/fleet/stream", methods: ["GET"], subscription: true },
 ];
 //# sourceMappingURL=fleet.js.map

package/dist/http/routes/images.d.ts

@@ -55,6 +55,7 @@ export declare const IMAGES_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/images/bakes/:id/events";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "image-bake-cancel";
     readonly pattern: RegExp;

package/dist/http/routes/images.js

@@ -643,7 +643,7 @@ export const IMAGES_ROUTES = [
     { id: "image-bake-claim-next", path: "/v1/images/bakes/claim", methods: ["POST"] },
     { id: "image-select", path: "/v1/images/select", methods: ["POST"] },
     { id: "image-register", path: "/v1/images/register", methods: ["POST"] },
-    { id: "image-bake-events", pattern: /^\/v1\/images\/bakes\/(?<bakeId>[^/]+)\/events$/, label: "/v1/images/bakes/:id/events", methods: ["GET"] },
+    { id: "image-bake-events", pattern: /^\/v1\/images\/bakes\/(?<bakeId>[^/]+)\/events$/, label: "/v1/images/bakes/:id/events", methods: ["GET"], subscription: true },
     { id: "image-bake-cancel", pattern: /^\/v1\/images\/bakes\/(?<bakeId>[^/]+)\/cancel$/, label: "/v1/images/bakes/:id/cancel", methods: ["POST"] },
     { id: "image-bake-claim", pattern: /^\/v1\/images\/bakes\/(?<bakeId>[^/]+)\/claim$/, label: "/v1/images/bakes/:id/claim", methods: ["POST"] },
     { id: "image-bake-ingest", pattern: /^\/v1\/images\/bakes\/(?<bakeId>[^/]+)\/ingest$/, label: "/v1/images/bakes/:id/ingest", methods: ["POST"] },

package/dist/http/routes/leader.js

@@ -2,6 +2,7 @@ import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, headerStr, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
+import { leaderEntryRefusal, leaderRunEntry } from "../../leader/run-entry.js";
 export const LEADER_SUBMIT_PATH = "/v1/leader";
 export async function handleLeader(req, res, match, ctx) {
     switch (match.decl.id) {
@@ -35,6 +36,11 @@ export async function handleLeader(req, res, match, ctx) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
+        const laneRefusal = leaderEntryRefusal(leaderRunEntry(deps.config.autonomy));
+        if (laneRefusal !== undefined) {
+            sendError(res, 422, "request.autonomy_lane_refused", laneRefusal);
+            return;
+        }
         const r = await endpoint.handle("POST", LEADER_SUBMIT_PATH, body, requester, headerStr(req.headers["idempotency-key"]) ?? null);
         if (r) {
             sendJson(res, r.status, r.body);

package/dist/http/routes/runs.d.ts

@@ -72,6 +72,7 @@ export declare const RUNS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/runs/:id/events";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "run-detail";
     readonly pattern: RegExp;
@@ -90,6 +91,7 @@ export declare const RUN_VERBS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/runs/:id/subagents/:sub/*";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "run-subagent-steer";
     readonly pattern: RegExp;

package/dist/http/routes/runs.js

@@ -33,7 +33,8 @@ import { mintAndDriveDurableRun } from "../durable-run-leg.js";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { readResumeCtx } from "../resume-ctx-read.js";
-import { storedBodyReplayAnswer, storedBodyReplayLogFields, storedBodyReplayRefusal } from "../checkpoint-ctx.js";
+import { storedBodyReplayAnswer, storedBodyReplayLogFields } from "../checkpoint-ctx.js";
+import { storedBodyReplayRefusal } from "../stored-body-replay.js";
 const STEER_PRIORITY_WORDS = INJECTION_TIERS.map((tier) => `'${tier}'`);
 const STEER_PRIORITY_UNION = STEER_PRIORITY_WORDS.join(" | ");
 const STEER_PRIORITY_CHOICES = STEER_PRIORITY_WORDS.length <= 2 ? STEER_PRIORITY_WORDS.join(" or ") : `${STEER_PRIORITY_WORDS.slice(0, -1).join(", ")}, or ${STEER_PRIORITY_WORDS[STEER_PRIORITY_WORDS.length - 1]}`;
@@ -647,7 +648,7 @@ export async function handleRuns(req, res, match, ctx) {
                     mintResult.noResumeCtx = true;
                     return;
                 }
-                const unservable = storedBodyReplayRefusal(resumeRead.ctx);
+                const unservable = storedBodyReplayRefusal(resumeRead.ctx, deps.config.autonomy);
                 if (unservable !== undefined) {
                     mintResult.unservable = unservable;
                     return;
@@ -1662,12 +1663,12 @@ export const RUNS_ROUTES = [
     { id: "run-detach", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/detach$/, label: "/v1/runs/:id/detach", methods: ["POST"] },
     { id: "run-cancel", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/cancel$/, label: "/v1/runs/:id/cancel", methods: ["POST"] },
     { id: "run-compact", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/compact$/, label: "/v1/runs/:id/compact", methods: ["POST"] },
-    { id: "run-events", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/events$/, label: "/v1/runs/:id/events", methods: ["GET"] },
+    { id: "run-events", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/events$/, label: "/v1/runs/:id/events", methods: ["GET"], subscription: true },
     { id: "run-detail", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)$/, label: "/v1/runs/:id", methods: ["GET"] },
 ];
 export const RUN_VERBS_ROUTES = [
     { id: "run-subagent-output", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/subagents\/(?<sub>[^/]+)\/output$/, label: "/v1/runs/:id/subagents/:sub/*", methods: ["GET"] },
-    { id: "run-subagent-stream", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/subagents\/(?<sub>[^/]+)\/stream$/, label: "/v1/runs/:id/subagents/:sub/*", methods: ["GET"] },
+    { id: "run-subagent-stream", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/subagents\/(?<sub>[^/]+)\/stream$/, label: "/v1/runs/:id/subagents/:sub/*", methods: ["GET"], subscription: true },
     { id: "run-subagent-steer", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/subagents\/(?<sub>[^/]+)\/steer$/, label: "/v1/runs/:id/subagents/:sub/*", methods: ["POST"] },
     { id: "run-subagent-resume", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/subagents\/(?<sub>[^/]+)\/resume$/, label: "/v1/runs/:id/subagents/:sub/*", billable: "resume", methods: ["POST"] },
     { id: "run-task-output", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/tasks\/(?<tid>[^/]+)\/output$/, label: "/v1/runs/:id/tasks/:tid/*", methods: ["GET"] },

package/dist/http/routes/sessions.d.ts

@@ -79,6 +79,7 @@ export declare const SESSIONS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/sessions/:id/$verb";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "session-fork";
     readonly pattern: RegExp;

package/dist/http/routes/sessions.js

@@ -794,15 +794,12 @@ export async function handleSessions(req, res, match, ctx) {
                     case "not-an-object":
                         sendError(res, 400, "request.body_shape", describeSessionPermissionRulesProblem(read.problem));
                         return;
-                    case "field-not-string-array":
+                    case "field-not-rule-list":
                         sendError(res, 400, "request.field_invalid", describeSessionPermissionRulesProblem(read.problem));
                         return;
                     case "legacy-tool-name":
                         sendError(res, 400, "rules.legacy_tool_name", describeSessionPermissionRulesProblem(read.problem), { ...read.problem.refusal });
                         return;
-                    case "unreachable-tool-name":
-                        sendError(res, 400, "request.field_invalid", describeSessionPermissionRulesProblem(read.problem));
-                        return;
                     default: {
                         const unhandled = read.problem;
                         throw new Error(`unhandled SessionPermissionRules problem: ${JSON.stringify(unhandled)}`);
@@ -844,7 +841,7 @@ export const SESSIONS_ROUTES = [
     { id: "session-mcp", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/mcp$/, label: "/v1/sessions/:id/$verb", methods: ["GET"] },
     { id: "session-a2a", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/a2a$/, label: "/v1/sessions/:id/$verb", methods: ["GET"] },
     { id: "session-head", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/head$/, label: "/v1/sessions/:id/$verb", methods: ["GET"] },
-    { id: "session-events", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/events$/, label: "/v1/sessions/:id/$verb", methods: ["GET"] },
+    { id: "session-events", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/events$/, label: "/v1/sessions/:id/$verb", methods: ["GET"], subscription: true },
     { id: "session-fork", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/fork$/, label: "/v1/sessions/:id/$verb", methods: ["POST"] },
     { id: "session-policy-get", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/policy$/, label: "/v1/sessions/:id/$verb", methods: ["GET"] },
     { id: "session-policy-put", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/policy$/, label: "/v1/sessions/:id/$verb", methods: ["PUT"] },

package/dist/http/routes/trace-usage.d.ts

@@ -38,6 +38,7 @@ export declare const TRACE_USAGE_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/tasks/:id/$sub";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "task-trace-artifacts";
     readonly pattern: RegExp;

package/dist/http/routes/trace-usage.js

@@ -302,7 +302,7 @@ export const TRACE_USAGE_ROUTES = [
     { id: "task-trace-list", path: "/v1/tasks", methods: ["GET"] },
     { id: "task-tool-result", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/tool-results\/(?<ref>[^/]+)$/, label: "/v1/tasks/:id/tool-results/:ref", methods: ["GET"] },
     { id: "task-trace-turns", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/turns$/, label: "/v1/tasks/:id/$sub", methods: ["GET"] },
-    { id: "task-trace-stream", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/stream$/, label: "/v1/tasks/:id/$sub", methods: ["GET"] },
+    { id: "task-trace-stream", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/stream$/, label: "/v1/tasks/:id/$sub", methods: ["GET"], subscription: true },
     { id: "task-trace-artifacts", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/artifacts$/, label: "/v1/tasks/:id/$sub", methods: ["GET"] },
     { id: "usage-analytics", pattern: /^\/v1\/usage\/(?<sub>summary|series|breakdown)$/, label: "/v1/usage/$sub", methods: ["GET"] },
 ];

package/dist/http/routes/workflows.d.ts

@@ -15,6 +15,7 @@ export declare const WORKFLOWS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/workflows/:id/$sub";
     readonly methods: readonly ["GET"];
+    readonly subscription: true;
 }, {
     readonly id: "workflow-journal";
     readonly pattern: RegExp;

package/dist/http/routes/workflows.js

@@ -416,7 +416,7 @@ function sendWorkflowsUnavailable(res, why) {
 }
 export const WORKFLOWS_ROUTES = [
     { id: "workflows-list", path: "/v1/workflows", methods: ["GET"] },
-    { id: "workflow-stream", pattern: /^\/v1\/workflows\/(?<runId>[^/]+)\/stream$/, label: "/v1/workflows/:id/$sub", methods: ["GET"] },
+    { id: "workflow-stream", pattern: /^\/v1\/workflows\/(?<runId>[^/]+)\/stream$/, label: "/v1/workflows/:id/$sub", methods: ["GET"], subscription: true },
     { id: "workflow-journal", pattern: /^\/v1\/workflows\/(?<runId>[^/]+)\/journal$/, label: "/v1/workflows/:id/$sub", methods: ["GET"] },
     { id: "workflow-detail", pattern: /^\/v1\/workflows\/(?<runId>[^/]+)$/, label: "/v1/workflows/:id", methods: ["GET"] },
 ];

package/dist/http/send.d.ts

@@ -47,6 +47,19 @@ export declare const SSE_MAX_STREAM_MS: number;
  * 要么给 approvals 减 type=消费端破坏),属候裁,不在本批的零行为码范围内。
  */
 export declare const SSE_HEARTBEAT_IDLE_MS = 15000;
+/**
+ * S-1281 —— 服务端**主动**收一条已开的 SSE 流:一帧 `event: error`(帧形与流帽那一帧同一套 `{type:"error", errorCode, message}`,
+ * 消费端按既有「服务端收流 ⇒ 重连」协议处置,SDK 的流读口把它当一帧事件交出再重连)后 `end()`。
+ *
+ * 收流的是分派器,不是流自己的泵:泵此刻可能正停在一次 await 上,醒来还会写一帧。Node 上 `end()` 之后、`close` 之前的那一写会发一个
+ * `error` 事件(实测 v24.2.0:无监听 ⇒ 进程级未捕获;`close` 之后的写只回 `false`,不再发)。⇒ 先挂一只**只吸收这一种**
+ * (`ERR_STREAM_WRITE_AFTER_END`)的监听再 `end()`:那一帧本来就无处可去(连接是我们关的),别的错照旧抛(不改既有失败形)。
+ * 已收尾的流不碰(幂等;排空入口与硬停起点各调一次)。
+ */
+export declare function endSseWithError(res: ServerResponse, frame: {
+    readonly errorCode: string;
+    readonly message: string;
+}): void;
 export declare function sendJson(res: ServerResponse, status: number, body: unknown): void;
 /** A6([ref] lens1 §C3/lens3 §C3a): canonical error-response sender for sites that already carry a
  *  machine `errorCode` — `errorCode` is a required positional arg (not optional-bag) so a call site

package/dist/http/send.js

@@ -17,6 +17,15 @@ export function sseHeaders(res, extra) {
 }
 export const SSE_MAX_STREAM_MS = 15 * 60 * 1000;
 export const SSE_HEARTBEAT_IDLE_MS = 15_000;
+export function endSseWithError(res, frame) {
+    if (res.writableEnded || res.destroyed)
+        return;
+    res.on("error", (err) => {
+        if (err.code !== "ERR_STREAM_WRITE_AFTER_END")
+            throw err;
+    });
+    res.end(`event: error\ndata: ${JSON.stringify({ type: "error", errorCode: frame.errorCode, message: frame.message })}\n\n`);
+}
 export function sendJson(res, status, body) {
     res.writeHead(status, { "content-type": "application/json" });
     res.end(JSON.stringify(body));

package/dist/http/server.d.ts

@@ -684,6 +684,9 @@ export interface ServiceDeploymentDeps {
      *  • [ref]:`attachedStreams` 同样 ASSIGNED BY createServer —— 本副本当前打开着的 SSE 流条数
      *    (= 引擎附着租约集的大小)。消费方是 `boot/engine-lease.ts` 的自退判据;与 `inflight` 同族,
      *    同一个共享盒子,不另开第二条 main↔server 的通道。
+     *  • S-1281:`inflight` 只数**工作** —— 只读订阅流(路由表 `subscription` 列的八条 GET SSE 读面)不进 admission 计数,只进
+     *    `attachedStreams`;`endSubscriptions`(同样 ASSIGNED BY createServer)发 `draining` 终帧后关掉它们,收尾链在排空进入那一拍与
+     *    硬停起点各调一次。
      */
     drainState?: import("../fleet/drain-entry.js").DrainState;
     /** 编排器片 2 件 3:服务租约此刻的读数(`fleet/serving-lease.ts` 的客户端交出;引擎信号铸点与计费准入判同读)。缺席 = 没装租约客户端

package/dist/http/stored-body-replay.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 「这条停驻行的持久化体在本版上能否重放」—— **唯一**判据(三问一只;五个问点同调:续跑驱动段 `resume-legs.ts` `resolveResumeSpecOrBlocked`、
+ * plan_review 的 prepare 段、SLA 拒扫腿的跳过臂 `approval-sweeps.ts`、终态 run 的 steer 铸唤醒卡之前 `routes/runs.ts`;`resolveSpec` 本身留作提交腿的拒点)。
+ * 三问的规则、记号、拒句与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注;答复 = 那里的 `storedBodyReplayAnswer`。
+ *
+ * 为什么判据住在这里而不是 `checkpoint-ctx.ts`:第三问要读体的**生效模式词**(`task-settings.ts` `storedBodyPermissionMode`,请求设置的解析层)与本部署此刻的
+ * **入口地板**(`runtime-governance.ts` `autonomyModeFloor`)—— 这两只属主带着配置层的包外依赖;`checkpoint-ctx.ts` 被随包的本地排空脚本经编译产物 import,
+ * 它的闭包只许 node 内建 / 引擎包根(`test/drain-check-local.test.ts` 的闭包门)。判据只有这一只,前两问的谓词照旧住在各自属主里。
+ */
+import type { PermissionMode } from "@sema-agent/core";
+import { type Autonomy } from "../runtime-governance.js";
+import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
+import type { CheckpointCtx } from "./route-ctx.js";
+/**
+ * 第三问:本行体里的模式词能否按当前读法重放。不能 ⇔ 本部署此刻有入口地板 ∧ 行上没有当前的模式词读法记号 ∧ 体的生效词进这块地板会变
+ * (`runtime-governance.ts` `entryPermissionMode`,与提交入口的盖章同一只函数;判的是「词变不变」而不是 `clamped` —— 体无词的旧行进地板取地板本身,
+ * 那也是变)⇒ 返回拒因的两个事实(体的词、地板);能 ⇒ `undefined`。
+ */
+export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor: PermissionMode | undefined): {
+    stored: PermissionMode | undefined;
+    floor: PermissionMode;
+} | undefined;
+/**
+ * 三问一只判据:不能重放 ⇒ 返回拒的那条规则;能 ⇒ `undefined`。顺序:allow 读法记号 → 技能拒侧读成空 → 模式词读法记号(几问同中时答先中的那一问 ——
+ * 任一问中都不重放,句子只需一句)。`autonomy` = 本部署**此刻**的 `config.autonomy`(活 config:热改即生效);地板由它的唯一属主算,问点不自己算。
+ */
+export declare function storedBodyReplayRefusal(ctx: CheckpointCtx, autonomy: Autonomy | undefined): StoredBodyReplayRefusal | undefined;
+//# sourceMappingURL=stored-body-replay.d.ts.map

package/dist/http/stored-body-replay.js

@@ -0,0 +1,22 @@
+import { storedBodyPermissionMode } from "../task-settings.js";
+import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
+import { skillDenyInertEntryOf } from "../rule-entry-list.js";
+import { allowListReadingEraOf, allowListReadingUnstated, permissionModeReadingStated } from "./checkpoint-ctx.js";
+export function permissionModeReadingUnstated(ctx, floor) {
+    if (floor === undefined || permissionModeReadingStated(ctx))
+        return undefined;
+    const stored = storedBodyPermissionMode(ctx.body);
+    return entryPermissionMode(stored, floor).effective === stored ? undefined : { stored, floor };
+}
+export function storedBodyReplayRefusal(ctx, autonomy) {
+    if (allowListReadingUnstated(ctx))
+        return { kind: "allow_list_reading", era: allowListReadingEraOf(ctx) };
+    const entry = skillDenyInertEntryOf(ctx.body);
+    if (entry !== undefined)
+        return { kind: "skill_deny_inert", entry };
+    const mode = permissionModeReadingUnstated(ctx, autonomyModeFloor(autonomy));
+    if (mode !== undefined)
+        return { kind: "permission_mode_reading", ...mode };
+    return undefined;
+}
+//# sourceMappingURL=stored-body-replay.js.map

package/dist/index.d.ts

@@ -29,5 +29,7 @@ export { createKeyResolver, resolveModelApiKey, type ModelKeyRef } from "./key-r
 export { isModelKeyPoison, ModelKeyPoisonedError, type ModelKeyPoison, type ModelKeyPoisonReason } from "./key-resolver.js";
 export { RETIRED_ENVS, type RetiredEnv, type RetiredEnvKind, type RetiredEnvWire } from "./config.js";
 export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES, type CatalogEntryHeaderName } from "./model-entry-headers.js";
+export { judgeModelRouteGap, type ModelRouteGapReading, type ModelRouteGapOptions } from "./model-route-gap.js";
+export type { ModelRouteGap } from "./model-route-endpoint.js";
 export type { UserInputLedgerStore, UserInputAcceptance, NewUserInputAcceptance, OpenScanCursor, OpenScanPage, SettleHow, WriterGoneEvidence } from "./user-input-ledger.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -26,4 +26,5 @@ export { createKeyResolver, resolveModelApiKey } from "./key-resolver.js";
 export { isModelKeyPoison, ModelKeyPoisonedError } from "./key-resolver.js";
 export { RETIRED_ENVS } from "./config.js";
 export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES } from "./model-entry-headers.js";
+export { judgeModelRouteGap } from "./model-route-gap.js";
 //# sourceMappingURL=index.js.map