@sema-agent/server 7.145.0 → 7.147.0

package/dist/http/run-concurrency-cap.js

@@ -0,0 +1,54 @@
+import { gatedPrincipal } from "./principal-gate.js";
+import { refusalBody } from "./refusal-body.js";
+import { sendError } from "./send.js";
+export function liveRunIdsOf(inflightRuns, steerableRuns) {
+    return new Set([...inflightRuns.keys(), ...steerableRuns.keys()]);
+}
+export const RUN_CONCURRENCY_CAP_REASON = "run_concurrency_cap";
+export const RATE_EXCEEDED_REASONS = [RUN_CONCURRENCY_CAP_REASON];
+export const RUN_CONCURRENCY_RETRY_AFTER_SEC = 5;
+const UNTRACKED_SLOT = { release: () => undefined };
+export function runConcurrencyRefusalOf() {
+    return {
+        status: 429,
+        body: refusalBody({
+            errorCode: "limit.rate_exceeded",
+            message: "too many runs are in flight on this server right now — nothing was started; retry after the Retry-After interval",
+            facts: { reason: RUN_CONCURRENCY_CAP_REASON, retryAfterSec: RUN_CONCURRENCY_RETRY_AFTER_SEC },
+        }),
+        retryAfterSec: RUN_CONCURRENCY_RETRY_AFTER_SEC,
+    };
+}
+export function createRunConcurrencyGate(ctx) {
+    const { deps, inflightRuns, steerableRuns } = ctx;
+    const seats = new Set();
+    function admitRun(req, res) {
+        const { runMaxConcurrent: globalCap, runMaxConcurrentPerPrincipal: ownCap } = deps.config;
+        if (globalCap === 0 && ownCap === 0)
+            return UNTRACKED_SLOT;
+        const owner = gatedPrincipal(req, deps.config);
+        const live = liveRunIdsOf(inflightRuns, steerableRuns);
+        const inFlight = live.size + seats.size;
+        let scope;
+        if (globalCap > 0 && inFlight >= globalCap)
+            scope = "global";
+        else if (ownCap > 0 && owner !== undefined) {
+            const holders = [...[...live].map((id) => inflightRuns.get(id)?.owner), ...[...seats].map((seat) => seat.owner)];
+            if (holders.filter((o) => o === owner).length >= ownCap)
+                scope = "principal";
+        }
+        if (scope !== undefined) {
+            deps.logger?.info?.("run_concurrency_cap_refused", { scope, inFlight, cap: scope === "global" ? globalCap : ownCap, hasPrincipal: owner !== undefined });
+            const refusal = runConcurrencyRefusalOf();
+            const { error, errorCode, ...extra } = refusal.body;
+            res.setHeader("retry-after", String(refusal.retryAfterSec));
+            sendError(res, refusal.status, errorCode, error, extra);
+            return undefined;
+        }
+        const seat = { owner };
+        seats.add(seat);
+        return { release: () => void seats.delete(seat) };
+    }
+    return { admitRun };
+}
+//# sourceMappingURL=run-concurrency-cap.js.map

package/dist/http/server.d.ts

@@ -2,7 +2,7 @@ import http from "node:http";
 import type { MemoryComplianceFaces, MemoryOriginFaces, SessionMemoryStatusFace } from "../memory-operator-faces.js";
 import type { SideQueryAccounting } from "../budget.js";
 import type { IncomingMessage } from "node:http";
-import { type Runner, type RunnerDeps, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type ConsolidationRunReceipt, type ConsolidationDriverRunRow, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
+import { type Runner, type RunnerDeps, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
 import type { TaskRequestBody } from "./wire-types.js";
 import type { ServiceConfig } from "../config-types.js";
 import { type SessionMirrorRuling } from "../web-admin-client/facade.js";
@@ -21,6 +21,7 @@ import type { SubagentSteerRegistry } from "../orchestration/subagent-steer.js";
 import { type WorkflowCompletionInbox } from "../orchestration/workflow-completion-inbox.js";
 import type { FleetLeaseManager } from "../fleet-lease.js";
 import { type FleetEventBus } from "../fleet/fleet-bus.js";
+import type { SessionResidentCounts } from "../session-resident-background.js";
 import type { ElicitationCoordinator } from "../elicitation.js";
 import type { QuestionCoordinator } from "../question.js";
 import { type ParkedAskRedeem, type ToolApprovalCoordinator } from "../tool-approval.js";
@@ -31,7 +32,7 @@ import type { Metrics } from "../observability/metrics.js";
 import { type RateGate } from "../observability/rate-limit.js";
 import type { QuotaTracker } from "../observability/cost-quota.js";
 import type { ModelUsageTracker, PromptManifestTracker } from "../budget.js";
-import type { ConsolidationSeatLabel, ConsolidationValve } from "../boot/memory-consolidation.js";
+import type { ConsolidationValve, MemoryConsolidationFaces } from "../boot/memory-consolidation.js";
 import { streamApprovals, checkQuestionAnswer } from "./routes/approvals-assistant.js";
 export { streamApprovals, checkQuestionAnswer };
 import { cascadeConfig } from "./run-meta.js";
@@ -100,7 +101,9 @@ export interface ServiceCoreDeps {
     /**
      * Map an inbound request body + resolved auth to a TaskSpec. The SERVICE/deployment owns model
      * + tools + mcp here (callers only supply content). `auth` carries the principal-derived memory scope —
-     * prefer it over anything in the body.
+     * prefer it over anything in the body. The root session is not read from `auth` either: the resolver's one reading of
+     * "which session is this leg on" is `opts.execution.root` (`auth.sessionId` is the authorizer's hand-off to the server's
+     * execution-context resolver, not a second reading for the resolver).
      * The root session is NOT the resolver's to write: the return type carries no `sessionId`
      * (`ResolvedTaskSpec`); the server stamps the root the authorizer resolved onto every spec it executes
      * (`http/execution-context.ts` `stampSpecRoot`). A resolver that needs the root reads `opts.execution.root`.
@@ -155,7 +158,8 @@ export interface ServiceCoreDeps {
      * `principalCaps`、同一份部署缺省):凡回答「此主体在此场景能看见哪些 MCP 服务器 / A2A 对端」的口 —— `GET /v1/capabilities/mcp` 的状态面、
      * `GET /v1/sessions/:id/mcp` 与 `…/a2a` 两张会话面板 —— 的场景名都由它给,**点名与缺席都问**:点名 ⇒ 判在册 / allowlist,
      * 拒体(400 `scenario_unknown` 附在册词表 / 400 `scenario_not_allowed` 附 allowlist)与任务提交腿逐字同;缺席 ⇒ 指派链(中心 ruling 胜者,
-     * 否则部署缺省),与这位主体 run 时同一读法(指派悬空 ⇒ 503 `state.scenario_assignment_unknown`,同提交腿)。
+     * 否则部署缺省),与这位主体 run 时同一读法(指派悬空 ⇒ 503 `state.scenario_assignment_unknown`,同提交腿)。中心配了却答不出这位主体的裁定 ⇒
+     * 点名与缺席同答 503 `state.scenario_assignment_unavailable`(同提交腿)。
      * 读面上这只门走**只读腿**(`createScenarioGate(…, "peek")`):问中心裁定时 center 抖动的那一拍,不替这个主体的真提交留下 fail-closed 降级项
      * (提交腿自己是 `"enforce"`)。
      * 🔴 **必填**:读口的场景名只有这一个来源,没有「缺接缝 ⇒ 读部署缺省 / 点名 404」这类第二种读法 —— 漏接是**编译错**(嵌入方自己装配时,工厂与它的型从包根导出:
@@ -581,15 +585,9 @@ export interface ServiceSeamDeps {
      *  **启动期**就被拒了(`boot/memory-consolidation.ts`),那些机器根本起不来。⇒ 缺席形是 **404 族**
      *  (整域不挂),刻意**不是** 501:501 说「换部署形态」,这里的动作是「把旋钮打开」。全文见
      *  `routes/memory-consolidation.ts` 头注。
-     *  🔴 `seat` 的词表单一真源 = `boot/memory-consolidation.ts` 的 {@link ConsolidationSeatLabel}
-     *  (type-only import,tsc 擦除、非装载边)——在这里再写一遍字面量联合就是第二份会漂的词表。 */
-    memoryConsolidation?: {
-        readonly seat: ConsolidationSeatLabel;
-        readonly model: string;
-        readonly scopes: readonly string[];
-        run(scope: string): Promise<ConsolidationRunReceipt>;
-        lastRun(scope: string): ConsolidationDriverRunRow | undefined;
-    };
+     *  🔴 形的单一真源 = `boot/memory-consolidation.ts` 的 {@link MemoryConsolidationFaces}(type-only import,tsc 擦除、非装载边)——
+     *  在这里再写一遍成员表就是第二份会漂的形(core 7.63.0 把 `lastRun` 改成异步时这里的手抄形正好漂了一次)。 */
+    memoryConsolidation?: MemoryConsolidationFaces;
     /** [ref] §3.1 / [ref] §1.3([ref] S-2):per-principal memory-capture opt-out 授权表的管理面
      *  (`/v1/admin/memory-optout` 四口,operator-only)—— `backend.memoryOptOutGrant()` 的同一只(与
      *  `RuntimeCaps.allowMemoryOptOut` 的 resolver 腿读同一张表,零缓存直读 ⇒ 写后下一次 prepare 即生效)。
@@ -723,13 +721,24 @@ export interface ServiceDeploymentDeps {
      * composition root 装起来的夹具)⇒ 两键都缺席,两面与没有声明的部署逐字节同。
      */
     deploymentModPackages?: number;
+    /**
+     * 会话 → 调用方登记的工作目录(提交体 `cwd` 的唯一写口 `setSessionCwd` 写的那一张进程内表,`boot/execution-env.ts` `createSessionScopedRegistries`)。
+     * **只读**,读者只有 run 外回退口(`POST /v1/sessions/:id/rewind-files`):host 工厂按 `effectiveHostWorkspace(本表.get(会话), ctx)` 定根(`execution-env.ts`
+     * host 臂),口在交引擎之前用**同一只函数、同一份入参**问「工厂这一次会不会落到一只用完即删的临时目录」—— 会 ⇒ 拒,不让台账说恢复了而项目没动。
+     * 缺席(夹具 / 嵌入方没接)⇒ 读作「没有登记」⇒ host 车道上口拒(fail-closed)。
+     */
+    perSessionCwd?: ReadonlyMap<string, string>;
     /**
      * Graceful drain — shared mutable state between main.ts (flips `draining` on SIGTERM) and this server:
      *  • while `draining`, NEW model-running submissions (the billable submit paths) get 503 + Retry-After, so an
      *    orchestrator/shell retries against the replacement instance; read paths + in-flight verbs (steer/cancel/
      *    respond/subagent) stay open so the runs we are waiting on can still finish/interact.
      *  • `inflight` is ASSIGNED BY createServer (a live union of this replica's in-flight legs: durable bg/resume
-     *    `inflightRuns` + live sync/resume streams `steerableRuns`) — main.ts polls it to know when drain is done.
+     *    `inflightRuns` + live sync/resume streams `steerableRuns`, the leader leg, the background sub-agents that outlived the leg
+     *    that spawned them, and the session-resident background shells/monitors — `inflightBreakdown` is the same read split into its
+     *    four terms) — an observable fact (`/health.inflight`).
+     *    `blockingInflight` (also ASSIGNED BY createServer) is the SAME breakdown function minus the session-resident shell term: "is there still
+     *    work that must be waited out" — the drain wait main.ts polls after SIGTERM, the orphan/lease windows and the SIGHUP idle window read THAT.
      *  • /health carries `draining:true` + `version` (build self-description); draining is a readiness reason
      *    (`http/readiness.ts`) ⇒ `/readyz` 503 + `/health` `ready:false` (the k8s readiness 摘流信号).
      *  • [ref]:`attachedStreams` 同样 ASSIGNED BY createServer —— 本副本当前打开着的 SSE 流条数
@@ -740,6 +749,14 @@ export interface ServiceDeploymentDeps {
      *    硬停起点各调一次。
      */
     drainState?: import("../fleet/drain-entry.js").DrainState;
+    /**
+     * 会话驻留后台行的读口:本进程活过起它的腿、仍在跑的**后台子代理**与**后台 shell / monitor**,一次走查交出两项(`session-resident-background.ts` 的
+     * `countSessionResidentBackground` 在 composition root 绑上围栏表;法与边界见该文件头)。`createHttpServer` 把两项并进**唯一的分项函数** `inflightBreakdown`:
+     * `backgroundAgents` 进阻断集 `drainState.blockingInflight`(排空 / 孤儿窗与附着租约自退 / SIGHUP 空闲窗判停读它)与总数,`sessionResident` 只进总数 `drainState.inflight`。
+     * 读口**不许抛**:判停路径每拍读它,排空首读在期限计时器装上之前 —— 一抛就永不硬停(组合根那只按会话收住读失败、计 1 并报出)。
+     * 缺席(嵌入方 / 夹具)= 两项恒 0,两个读数逐字同 7.145.x。
+     */
+    sessionResidentBackground?: () => SessionResidentCounts;
     /** 编排器片 2 件 3:服务租约此刻的读数(`fleet/serving-lease.ts` 的客户端交出;引擎信号铸点与计费准入判同读)。缺席 = 没装租约客户端
      *  (非 fleet 成员 / 没接中心 / 测试夹具)⇒ `none`(与没有租约的引擎逐字同)。 */
     servingLease?: () => import("../fleet/engine-signal.js").ServingLeaseView;

package/dist/http/server.js

@@ -9,6 +9,7 @@ import {} from "../memory-sync.js";
 import {} from "../orchestration/workflow-agent-steer.js";
 import {} from "../orchestration/workflow-completion-inbox.js";
 import {} from "../fleet/fleet-bus.js";
+import { blockingInflightOf, inflightTotal } from "../fleet/drain-entry.js";
 import {} from "../tool-approval.js";
 import {} from "../observability/rate-limit.js";
 import { IdempotencyCache } from "./idempotency.js";
@@ -20,10 +21,12 @@ import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
 import { sendError, sendHttpError, sendOpenFaceFault, logRequestError } from "./send.js";
 import { createRequestGuards } from "./request-guards.js";
+import { createRunConcurrencyGate, liveRunIdsOf } from "./run-concurrency-cap.js";
 import { sqlEngineSeatIssue } from "../sql-engine-posture.js";
 import { parkDecisionStoreRefusal } from "../orchestration/workflow-park-decision.js";
 import { CHECKPOINT_CTX_SEALING_REQUIRED } from "./checkpoint-ctx.js";
 import { PARKED_REVIVE_EXECUTION_SEAT_REQUIRED } from "../parked-decide.js";
+import { operatorDeclarationRefusal } from "../config-invariants.js";
 import { retiredServiceDepsRefusal } from "./retired-service-deps.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
@@ -74,6 +77,12 @@ export function createHttpServer(rawDeps) {
         if (retired !== undefined)
             throw new Error(retired);
     }
+    {
+        const operatorDeclarationFailure = operatorDeclarationRefusal(deps.config);
+        if (operatorDeclarationFailure !== undefined) {
+            throw new Error(operatorDeclarationFailure);
+        }
+    }
     {
         const issue = sqlEngineSeatIssue(deps.backend, deps.sqlEngine);
         if (issue !== undefined) {
@@ -104,16 +113,32 @@ export function createHttpServer(rawDeps) {
     const steerableRuns = new Map();
     const wakeParkMints = new Map();
     const counters = { uncountedBillableInflight: 0, admittedInflight: 0 };
-    if (deps.drainState)
-        deps.drainState.inflight = () => new Set([...inflightRuns.keys(), ...steerableRuns.keys()]).size + counters.uncountedBillableInflight + counters.admittedInflight + (deps.leaderEndpoint?.inflight?.() ?? 0);
+    const inflightBreakdown = () => {
+        const resident = deps.sessionResidentBackground?.() ?? { backgroundAgents: 0, sessionResident: 0 };
+        return {
+            http: liveRunIdsOf(inflightRuns, steerableRuns).size + counters.uncountedBillableInflight + counters.admittedInflight,
+            leader: deps.leaderEndpoint?.inflight?.() ?? 0,
+            backgroundAgents: resident.backgroundAgents,
+            sessionResident: resident.sessionResident,
+        };
+    };
+    if (deps.drainState) {
+        deps.drainState.inflightBreakdown = inflightBreakdown;
+        deps.drainState.inflight = () => inflightTotal(inflightBreakdown());
+        deps.drainState.blockingInflight = () => blockingInflightOf(inflightBreakdown());
+    }
     let lastBillableActivityAt = performance.now();
+    let firstBillableActivityAt = null;
     const noteActivity = (url) => {
         if (isProbePath(url))
             return;
         lastBillableActivityAt = performance.now();
+        firstBillableActivityAt ??= lastBillableActivityAt;
     };
     if (deps.drainState)
         deps.drainState.lastActivityAt = () => lastBillableActivityAt;
+    if (deps.drainState)
+        deps.drainState.firstActivityAt = () => firstBillableActivityAt;
     if (deps.drainState)
         deps.drainState.yieldInflight = () => preemptableRuns.yieldAll();
     if (deps.hookWakeBus) {
@@ -155,7 +180,8 @@ export function createHttpServer(rawDeps) {
     }
     const { quotaExceeded, ownerCostQuotaDenied, ownerFleetLeaseDenied, ownerLeaseDenied, ownerQuotaDenied, leaseDenied, usageWindowDenialFor, usageWindowDenied, rateLimited, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, readJson, readRawBody } = createRequestGuards({ deps });
     const { prepareSpec } = createAdmission({ deps, readJson, runnerFor });
-    const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake, sessionNotifyDoor } = createResumeLegs({ deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor });
+    const { admitRun } = createRunConcurrencyGate({ deps, inflightRuns, steerableRuns });
+    const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake, sessionNotifyDoor } = createResumeLegs({ deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, admitRun, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor });
     const { denyExpiredApprovals, redeemParkedAsk } = createApprovalSweeps({ deps, resumeCheckpoint, mayDiscloseRowError });
     const { handle } = createDispatch({ deps, noteActivity, routeCtxBase, counters });
     const server = http.createServer((req, res) => {

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

@@ -1,19 +1,21 @@
 /**
- * 「这条停驻行的持久化体在本版上能否重放」—— **唯一**判据(四问一只;五个问点同调:续跑驱动段 `resume-legs.ts` `resolveResumeSpecOrBlocked`、
+ * 「这条停驻行的持久化体在本版上能否重放」—— **唯一**判据(四问一只,外加 `settings.env` 凭据一臂;五个问点同调:续跑驱动段 `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`,请求设置的解析层)与本部署此刻的
+ * 为什么判据住在这里而不是 `checkpoint-ctx.ts`:模式词问要读体的**生效模式词**(`task-settings.ts` `storedBodyPermissionMode`,请求设置的解析层)与本部署此刻的
  * **入口地板**(`runtime-governance.ts` `autonomyModeFloor`)—— 这两只属主带着配置层的包外依赖;`checkpoint-ctx.ts` 被随包的本地排空脚本经编译产物 import,
- * 它的闭包只许 node 内建 / 引擎包根(`test/drain-check-local.test.ts` 的闭包门)。判据只有这一只,前两问的谓词照旧住在各自属主里。
+ * 它的闭包只许 node 内建 / 引擎包根(`test/drain-check-local.test.ts` 的闭包门)。判据只有这一只,allow 读法问、工具名清单问与退役请求键问的谓词照旧住在各自属主里。
  */
 import type { PermissionMode } from "@sema-agent/core";
 import { type Autonomy } from "../runtime-governance.js";
 import { type ExecutionConfigRootDeployment } from "../execution-config-root.js";
+import { type UnreadMembersDeployment } from "../unread-request-members.js";
+import { type ModelApiKeyEnvTable } from "../server-secret-env.js";
 import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
 import type { CheckpointCtx } from "./route-ctx.js";
 /**
- * 第三问:本行体里的模式词能否按当前读法重放。不能 ⇔ 本部署此刻有入口地板 ∧ 行上没有当前的模式词读法记号 ∧ 体的生效词进这块地板会变
+ * 模式词问:本行体里的模式词能否按当前读法重放。不能 ⇔ 本部署此刻有入口地板 ∧ 行上没有当前的模式词读法记号 ∧ 体的生效词进这块地板会变
  * (`runtime-governance.ts` `entryPermissionMode`,与提交入口的盖章同一只函数;判的是「词变不变」而不是 `clamped` —— 体无词的旧行进地板取地板本身,
  * 那也是变)⇒ 返回拒因的两个事实(体的词、地板);能 ⇒ `undefined`。
  */
@@ -22,13 +24,16 @@ export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor:
     floor: PermissionMode;
 } | undefined;
 /**
- * 预判读的部署配置:`autonomy`(第三问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)与配置根的几位(user 设置层 `/` 规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
+ * 预判读的部署配置:`autonomy`(模式词问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)、配置根的几位(user 设置层 `/` 规则那一问)与「请求成员读不出」那一问的
+ * 租户轴 / 两只注入闸的否决位。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
  */
-export type StoredReplayDeployment = ExecutionConfigRootDeployment & {
+export type StoredReplayDeployment = ExecutionConfigRootDeployment & UnreadMembersDeployment & {
     readonly autonomy?: Autonomy | undefined;
+    /** 生效配置模型条目 name → `apiKeyEnv`(`settings.env` 凭据判据的名单一臂;缺席 = 没有模型条目,与 `serverCredentialValueSources` 的缺省同读)。 */
+    readonly modelApiKeyEnv?: ModelApiKeyEnvTable | undefined;
 };
 /**
- * 四问一只判据:不能重放 ⇒ 返回拒的那条规则;能 ⇒ `undefined`。顺序:allow 读法记号 → 请求设置里的条目表(**与拒点同序**:桶门〔形 / 空串 / 超帽〕→ 工具名清单读成空〔**只问限制方向**:放行方向的存量条目读成空,续跑照旧、只留一行运维 warn〕→ deny / ask 的名字层 + 规则文法)→ 模式词读法记号 → 体里的退役请求键(几问同中时答先中的那一问 ——
+ * 四问一只判据:不能重放 ⇒ 返回拒的那条规则;能 ⇒ `undefined`。顺序:allow 读法(体里带非空 `allow` 而写者版本证不出 ≥ 7.117.0;常设,按写者版本)→ 请求设置里的条目表(**与拒点同序**:桶门〔形 / 空串 / 超帽〕→ 工具名清单读成空〔**只问限制方向**:放行方向的存量条目读成空,续跑照旧、只留一行运维 warn〕→ 请求成员读不出〔hooks / env / MCP transport / A2A headers …,判据 `unread-request-members.ts`〕→ deny / ask 的名字层 + 规则文法)→ 模式词读法记号 → 体里的退役请求键(几问同中时答先中的那一问 ——
  * 任一问中都不重放,句子只需一句)。`deployment` = 本部署**此刻**的 `config`(活 config:热改即生效):`autonomy` 的地板由它的唯一属主算,`~/` 形规则的 home 由 `executionLaneHomeDir` 算,问点都不自己算。
  */
 export declare function storedBodyReplayRefusal(ctx: CheckpointCtx, deployment: StoredReplayDeployment): StoredBodyReplayRefusal | undefined;

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

@@ -1,4 +1,4 @@
-import { REQUEST_SETTINGS_REFUSAL_PREFIX, SETTINGS_PERMISSION_BUCKETS, SETTINGS_RULE_REFUSAL_CODE, neverAutoNamesRefusal, rulePolicyBucketsRefusal, settingsPermissionBucketIssue, storedBodyPermissionMode } from "../task-settings.js";
+import { REQUEST_SETTINGS_REFUSAL_PREFIX, SETTINGS_PERMISSION_BUCKETS, SETTINGS_RULE_REFUSAL_CODE, neverAutoNamesRefusal, readSettingsEnv, rulePolicyBucketsRefusal, settingsEnvCredentialIssue, settingsPermissionBucketIssue, storedBodyPermissionMode } from "../task-settings.js";
 import { readTightenOnlySeats, tightenOnlySeatField, tightenOnlySeatIssue } from "../tighten-only-seats.js";
 import { entryProblemsFacts } from "../entry-problems.js";
 import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
@@ -6,7 +6,11 @@ import { inertToolListEntryOf, replayInertEntry } from "../rule-entry-list.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { executionConfigRootOf } from "../execution-config-root.js";
 import { migrationWindowEnd } from "../plugins/one-time-migrations.js";
-import { allowListReadingEraOf, allowListReadingUnstated, permissionModeReadingStated, retiredRequestKeyOf } from "./checkpoint-ctx.js";
+import { storedEnvCredentialsDropM38 } from "../stored-request-env-credentials-m38.js";
+import { storedToolAxesRereadM19 } from "../stored-request-tool-axes-m19.js";
+import { MAX_NAMED_MEMBERS, unreadRequestMembers, unreadRequestMembersRefusal } from "../unread-request-members.js";
+import { serverCredentialValueSources } from "../server-secret-env.js";
+import { allowListWriterUnproven, permissionModeReadingStated, retiredRequestKeyOf } from "./checkpoint-ctx.js";
 export function permissionModeReadingUnstated(ctx, floor) {
     if (floor === undefined || permissionModeReadingStated(ctx))
         return undefined;
@@ -57,11 +61,30 @@ function storedRulePolicyRefusal(body, deployment) {
     const neverAutoRefused = neverAutoNamesRefusal(neverAuto);
     return neverAutoRefused === undefined ? undefined : replayInertEntry(tightenOnlySeatField("neverAuto"), "deny", SETTINGS_RULE_REFUSAL_CODE, `${REQUEST_SETTINGS_REFUSAL_PREFIX}${neverAutoRefused.message}`, { ...entryProblemsFacts(neverAutoRefused.problems) });
 }
+function storedEnvCredentialRefusal(body, deployment) {
+    const issue = settingsEnvCredentialIssue(readSettingsEnv(body?.settings).reaching, serverCredentialValueSources(deployment.modelApiKeyEnv));
+    if (issue === null || storedEnvCredentialsDropM38(new Date().toISOString().slice(0, 10)))
+        return undefined;
+    return { errorCode: "request.env_credential_refused", message: issue.message, facts: { ...issue.fields } };
+}
 export function storedBodyReplayRefusal(ctx, deployment) {
     const writer = ctx.writerVersion !== undefined ? { writerVersion: ctx.writerVersion } : {};
-    if (allowListReadingUnstated(ctx))
-        return { kind: "allow_list_reading", era: allowListReadingEraOf(ctx), ...writer };
-    const entry = storedPermissionBucketRefusal(ctx.body) ?? storedTightenOnlySeatRefusal(ctx.body) ?? inertToolListEntryOf(ctx.body, ["deny"]) ?? storedRulePolicyRefusal(ctx.body, deployment);
+    if (allowListWriterUnproven(ctx))
+        return { kind: "allow_list_reading", ...writer };
+    const early = storedPermissionBucketRefusal(ctx.body) ?? storedTightenOnlySeatRefusal(ctx.body);
+    if (early !== undefined)
+        return { kind: "inert_tool_list", entry: early };
+    const envCredential = storedEnvCredentialRefusal(ctx.body, deployment);
+    if (envCredential !== undefined)
+        return { kind: "settings_env_credential", refusal: envCredential };
+    const inert = inertToolListEntryOf(ctx.body, ["deny"]);
+    if (inert !== undefined)
+        return { kind: "inert_tool_list", entry: inert };
+    const today = new Date().toISOString().slice(0, 10);
+    const unread = unreadRequestMembers({ settings: ctx.body.settings, mcpServers: ctx.body.mcpServers, a2aPeers: ctx.body.a2aPeers }, deployment, { replay: true, today, storedToolAxes: storedToolAxesRereadM19(today) });
+    if (unread.length > 0)
+        return { kind: "unread_members", refusal: unreadRequestMembersRefusal(unread), members: unread.slice(0, MAX_NAMED_MEMBERS), memberCount: unread.length };
+    const entry = storedRulePolicyRefusal(ctx.body, deployment);
     if (entry !== undefined)
         return { kind: "inert_tool_list", entry };
     const mode = permissionModeReadingUnstated(ctx, autonomyModeFloor(deployment.autonomy));

package/dist/http/wire-types.d.ts

@@ -46,7 +46,8 @@ export interface TaskRequestBody {
      *  `scenario_unknown`, a known-but-not-allowed one a typed 400 `scenario_not_allowed`; absent ⇒ the ruling's
      *  assigned scenario, else `DEFAULT_SCENARIO` (consumed at `boot/resolve-spec.ts` via `gateScenarioRequest`). A name
      *  on that default chain this deployment does not have is NEVER folded to `default`: an assigned one is a typed 503
-     *  `state.scenario_assignment_unknown`, a dangling `DEFAULT_SCENARIO` refuses to boot.
+     *  `state.scenario_assignment_unknown`, a dangling `DEFAULT_SCENARIO` refuses to boot. On a center-wired deployment whose
+     *  center cannot answer for this principal, named or absent alike is a typed 503 `state.scenario_assignment_unavailable`.
      *  ⚠️ scenario-SPECIFIC keys (`repo`/`lenses`/`rounds`, read through `ScenarioRequest`'s index signature) are
      *  deliberately NOT declared here — they belong to one scenario each, not to the shared submit surface. */
     scenario?: string;
@@ -172,9 +173,14 @@ export interface TaskRequestBody {
      *  `outputSchema` (core ignores it there). */
     outputRetries?: number;
     /** Within-task compaction tuning (core [ref] `TaskSpec.compaction`). ⚠️ ONLY `clampTolerance` is a caller
-     *  knob — the rest of core's compaction object is an OPERATOR axis and is deliberately not on the wire, so this
-     *  type is narrower than core's field on purpose. `boot/resolve-spec.ts` accepts a finite number in [0,1] and
-     *  omits the whole `compaction` key otherwise. Pairs with `compactionModel` (which gear compacts). */
+     *  knob HERE — the rest of core's compaction object is an OPERATOR axis and is deliberately not on the wire, so this
+     *  type is narrower than core's field on purpose. `spec-fields.ts` `compactionSpecFragment` accepts a finite number
+     *  in [0,1] and omits the whole `compaction` key otherwise. Pairs with `compactionModel` (which gear compacts).
+     *  The other caller-owned member of core's `compaction`, the automatic-compaction seat `autoCompact`, rides the CC
+     *  settings key `settings.autoCompactEnabled` (boolean; 7.146.0, capability bit `taskSettings.autoCompactEnabled`) —
+     *  ONE seat per fact: it is deliberately NOT repeated here (`compaction.autoCompact` in the body is not read). Both
+     *  members are minted into the one `TaskSpec.compaction` object by the same mapper. The manual seat `manualCompact`
+     *  (the pass `POST /v1/runs/:id/compact` asks for) is not caller-writable: it takes the deployment's / engine's default. */
     compaction?: {
         clampTolerance?: number;
     };
@@ -184,10 +190,12 @@ export interface TaskRequestBody {
      *  400 (fail-loud, never silently dropped — the body.model silent-drop bug class). Absent ⇒ core uses the resolved
      *  role's default thinking. NEVER `budgetTokens`/`fast_mode` (provider-neutral by omission). */
     reasoningEffort?: string;
-    /** Resume-at (shell-host contract E18): the E2 message `eventId` to rewind the conversation to — core branches the
-     *  session at that prior message before running the new objective ("rewind to this message, ask differently").
-     *  The service resolves eventId→the persisted SessionTreeEntry.id (the anchor map) in resolveSpec; an unknown
-     *  eventId is a 4xx (never silently dropped). Requires a session. Absent ⇒ continue from the current leaf. */
+    /** Resume-at (shell-host contract E18): the history-anchor handle of the prior message to rewind the conversation to
+     *  (a message's E2 `eventId`, or a prompt's `taskId` — the anchor map holds both) — core branches the session at
+     *  that message before running the new objective ("rewind to this message, ask differently"). The service resolves
+     *  handle → the persisted SessionTreeEntry.id through the ONE anchor reader (`history-anchor.ts`) in resolveSpec; an
+     *  unknown handle is a 404 `resume_at.unknown_event` (never silently dropped). Requires a session. Absent ⇒ continue
+     *  from the current leaf. */
     resumeAt?: string;
     /** [ref] rewind exclusive mode (core 1.292 `TaskSpec.resumeAtMode`): qualifies the `resumeAt` target. `"at"`
      *  (default when absent — zero regression) keeps the target message in the branched context; `"before"` branches at
@@ -219,12 +227,18 @@ export interface TaskRequestBody {
      *  either way. Requires a FileHistoryStore. */
     restoreFiles?: boolean;
     /** DV-15: opt-in tolerance for a PARTIAL file restore (default = loud terminal failure carrying the per-file
-     *  ledger; `true` = keep going and disclose the same ledger on the result's rewindNotes). */
+     *  ledger; `true` = keep going and disclose the same ledger on the result's rewindNotes). A RUN-seat policy only
+     *  ("may the agent keep working on a mixed tree"): the out-of-run `POST /v1/sessions/:id/rewind-files` has no such
+     *  key — the engine's out-of-run rewind has no partial policy and that route answers the ledger as it stands. */
     acceptPartialRestore?: boolean;
     /** R8 code-only rewind (CC "Restore code" mode): converge the TRACKED set to the history boundary at a prior
-     *  USER message WITHOUT forking the conversation (the session leaf is untouched — only the files move). The
-     *  value is the same handle as `resumeAt` (the prompt's taskId); the service resolves it → the entry id. Honored ONLY
-     *  when `resumeAt` is ABSENT (the two modes are mutually exclusive). Requires the anchor map + a FileHistoryStore. */
+     *  USER message WITHOUT forking the conversation (the session leaf is untouched — only the files move). The value is
+     *  a history-anchor handle, NOT a SessionTreeEntry.id: the prompt's `taskId` (`messages[].taskId` on the session view;
+     *  the same handle space `resumeAt` reads) — the service resolves it → the entry id through the one anchor reader
+     *  (unknown ⇒ 404 `rewind_files_to.unknown_event`). Honored ONLY when `resumeAt` is ABSENT (the two modes are mutually
+     *  exclusive). Requires the anchor map + a FileHistoryStore + the session store's head read (capability
+     *  `rewindFilesTo`). Its out-of-run twin — no run, no model call — is `POST /v1/sessions/:id/rewind-files` with the same
+     *  handle in `to` (capability `sessionRewindFiles`). */
     rewindFilesTo?: string;
     /** [ref](core 7.31.0 [ref] `TaskSpec.fileHistory`)—— 请求级的**文件历史关断词**,唯一词 `"disabled"`(core 的拼法,
      *  与 `checkpointStore` 同;没有 `"enabled"` —— 缺席就是「部署说了算」的唯一形,声明只能单向收紧)。`"disabled"` ⇒
@@ -452,7 +466,7 @@ export interface TaskRequestBody {
      *  · `"scrub"` —— 缺省清洗(剥凭据形变量),**任何车道、任何部署**都受理(它就是缺省;7.106.0 合并复审 X7)。
      * **缺席 = 缺省清洗**:不带键的请求把本会话的绑定清掉(不继承上一条请求的声明 —— 这一位是「本条请求要什么」,
      * 粘到下一条上就是替一个没说话的请求放宽)。名单形(`string[]`)**不上 wire**(那是嵌入方构造执行环境的选项)。
-     * 🔒 **只有 host 车道有消费点**:别的车道(e2b / k8s / local-docker / ssh / adb / device / in-process)带 `"all"` ⇒
+     * 🔒 **只有 host 车道有消费点**:别的车道(e2b / k8s / local-docker / ssh / adb / device / none)带 `"all"` ⇒
      * 400 `request.field_invalid`(`reason: lane_not_host`)「applies to the host lane only」,不静默忽略、不映射到别的车道的 env 名单;`"scrub"` 在那些车道上照受理(无消费点,无害)。
      * Rides the persisted body onto resume legs:重放照射程与车道重判(部署由单用户改托管后 revive ⇒ 同一只拒,
      * resume-legs 折成 `409 resume_blocked_by_policy`)。

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { loadConfig, type ServiceConfig } from "./config.js";
-export { composeExecutionLane, assertExecutionLaneInvariants, type ExecutionLaneComposeCtx } from "./boot/execution-lane.js";
+export { composeExecutionLane, assertExecutionLaneInvariants, HTTP_SERVICE_LANE_ENTRY, type ExecutionLaneComposeCtx, type ExecutionLaneEntry } from "./boot/execution-lane.js";
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend, type StoreBackend, type SessionCaptureRecordSource } from "./plugins/store-backend.js";
 export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
-export { LocalDataRootSchemaMismatchError, type LocalSidecarMismatch } from "./plugins/local-session-store.js";
+export { LocalDataRootSchemaMismatchError, type LocalDataRootMismatch } from "./plugins/local-session-store.js";
 export { CachingSessionStore, type CachingOptions } from "./plugins/caching-session-store.js";
 export type { RunRecord, RunEvent } from "./plugins/store-contracts.js";
 export { runInBackground } from "./runs.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { loadConfig } from "./config.js";
-export { composeExecutionLane, assertExecutionLaneInvariants } from "./boot/execution-lane.js";
+export { composeExecutionLane, assertExecutionLaneInvariants, HTTP_SERVICE_LANE_ENTRY } from "./boot/execution-lane.js";
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend } from "./plugins/store-backend.js";

package/dist/instruction-source-notice.d.ts

@@ -10,7 +10,7 @@
  *
  * ## 基线 = 会话的服务端元数据
  * 基线是「同一 session 上一次 run 选中的链成员相对路径」(不是指纹:指纹密钥每进程随机,跨进程不可比)。它住在会话店的
- * 服务端元数据面 —— SQL 两孪生是 `session_meta.instruction_source` 一列,local 文件店是一只 sidecar —— 所以重启 /
+ * 服务端元数据面 —— SQL 两孪生是 `session_ext.instruction_source` 一列,local 文件店是一只 sidecar —— 所以重启 /
  * 跨副本都读得到、随会话删除一起消失,且不进模型上下文、不进 wire 会话面。不接这张面的店(core 的内存 dev 店、
  * `run-local` 的 core 文件店)⇒ 席缺席 ⇒ 一帧不发(诚实缺席:那两形的会话本来就活不过进程,或没有会话流可投)。
  *

package/dist/json-body-limit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 一切 JSON 请求体的字节上限 —— `readJson` 边读边计,越过即 413 `request.payload_too_large`(一条一直都在的门,`http/request-guards.ts`)。
+ *
+ * 住叶子(零依赖)而不是守门族里:依它定帽的面要读同一个数 —— 收编批量导入的「每个会话信封最多多少字节」只有落在它之下才可达
+ * (一个越过它的信封根本进不了门,把旋钮设到那里就是一只永远够不着的帽),配置的上帽从这里算(`adoption/import-limits.ts`)。
+ */
+export declare const MAX_JSON_BODY_BYTES: number;
+//# sourceMappingURL=json-body-limit.d.ts.map

package/dist/json-body-limit.js

@@ -0,0 +1,2 @@
+export const MAX_JSON_BODY_BYTES = 8 * 1024 * 1024;
+//# sourceMappingURL=json-body-limit.js.map

package/dist/leader/diffout.d.ts

@@ -45,7 +45,7 @@ export type PullDiffResult = {
  * 而它**本就已经** `import { safeRev } from "./diffout.js"` —— 依赖边在,共享零成本。两份手抄的后果不是
  * 「多写一行」,是**单边改值后上行/pull 两腿对同一个 diff 的过/拒判定分家**:同一份补丁在一条腿上过、
  * 另一条腿上被截断,而两处都「按自己的常量」正确工作,没有任何一处会报错。
- * (同族先例:`checkpoint-store-sql.ts` 的 `export const TERMINAL_GRACE_MS`。)
+ * (同族先例:`checkpoint-store-face.ts` 的 `export const TERMINAL_GRACE_MS`。)
  */
 export declare const DEFAULT_MAX_DIFF_BYTES: number;
 export declare function safeRev(rev: string): boolean;

package/dist/local-data-root.d.ts

@@ -7,8 +7,8 @@
  * `scripts/drain-check-local.mjs`(经 `dist/local-data-root.js` 取同一只函数,缺省数据根不再自抄一份链:抄本只对了一半,
  * 设了 `AGENT_DATA_DIR` 的部署不带参数跑脚本会读到另一个目录并报「干净」)。纯叶、零反向依赖 ⇒ 脚本引它不会把整个服务装载起来。
  *
- * ⚠️ 与**配置根**(`configLocalRoot`:`CONFIG_LOCAL_DIR` → `AGENT_DATA_DIR` → `~/.ai-agent`,不吃 `LOCAL_DATA_ROOT`)不是同一条链 —— 两根分家的那一形由
- * boot 期的 `local_roots_split` 告警说出来,本函数不改那条解析。
+ * ⚠️ 与**配置根**(`configLocalRoot`:`CONFIG_LOCAL_DIR` → `AGENT_DATA_DIR` → `~/.ai-agent`,不吃 `LOCAL_DATA_ROOT`)不是同一条链 —— 两根一声不响分家的那一形
+ * (没给 `CONFIG_LOCAL_DIR`)由 boot 期的 `local_roots_split` 告警说出来,本函数不改那条解析。
  */
 export declare function resolveLocalDataRoot(env: Readonly<Record<string, string | undefined>>, home: string): string;
 //# sourceMappingURL=local-data-root.d.ts.map

package/dist/memory-embedder-reembed.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `memory-embedder-reembed.ts` —— 「清列重嵌」**确认口令**的单一属主:`MEMORY_EMBEDDER_REEMBED=<model>/<dimensions>`。
+ *
+ * ## 律(一句)
+ *
+ * embedder 指纹门(`plugins/memory-embedder-fingerprint.ts`)从不凭自己的判断清列:记下的身份与配置的身份对不上
+ * (changed / unattributed / unreadable 三态)⇒ 拒启;唯一出路是运维显式确认「把向量列清掉、按**这个**身份重嵌」——
+ * 口令的值就是**配置的那个身份**。口令绑定身份,所以它天然是一次性的:清完并记下这个身份之后,下一次起服判「相等」,
+ * 口令不再有东西可确认;之后再换一次模型,留着的旧口令对不上新配置 ⇒ 起服拒(不会替下一次换模型静默清列)。
+ *
+ * ## 为什么是一只顶层叶模块
+ *
+ * 两个消费方在不同层:`config.ts` 在 boot 期解析并判口令(拼错 / 对不上配置 ⇒ 拒启),指纹门在拒句里**写出**这条口令。
+ * config 层不得值引 plugins 层;口令的读写形只有一份,两层各按需引 —— 这是本文件存在的全部理由。零依赖。
+ *
+ * 句子里写给运维**照抄**的那条赋值只有一个写者 {@link formatReembedAssignment}:值按 POSIX 单引号包起(模型名可以含空格 / `$` / 引号,
+ * 不包就粘不进 shell);引号只是 shell 的写法,shell 读完赋给 env 的值仍是 `<model>/<dimensions>` 本身(config 读的就是它)。
+ */
+/** 口令那一键的名字(config 读它、门的拒句写它)。 */
+export declare const MEMORY_EMBEDDER_REEMBED_ENV = "MEMORY_EMBEDDER_REEMBED";
+/** 口令所确认的身份形(与指纹门的 `EmbedderIdentity` 同形;本叶不引 zod)。 */
+export interface EmbedderIdentityToken {
+    readonly model: string;
+    readonly dimensions: number;
+}
+/** 身份 → 口令值:`<model>/<dimensions>`。模型名自身可以含 `/`(`BAAI/bge-m3`)—— 维度恒在**最后一个** `/` 之后。 */
+export declare function formatEmbedderIdentityToken(identity: EmbedderIdentityToken): string;
+/**
+ * 运维照抄的那条赋值:`MEMORY_EMBEDDER_REEMBED='<model>/<dimensions>'`。POSIX 单引号:值内唯一的元字符是 `'` 本身,写成 `'\''`
+ * (关引号、转义一个 `'`、再开引号)。拒句与 config 的出路句都经这里写,不各拼一份。
+ */
+export declare function formatReembedAssignment(identity: EmbedderIdentityToken): string;
+/**
+ * 口令值 → 身份;形不对 ⇒ `undefined`(调用方拒启并给出期望形,不猜)。判据:最后一个 `/` 之前非空(模型名),
+ * 之后是十进制正整数(无前导零、无符号、无空白)。`true` / `1` / `yes` 这类「开关形」一律不是口令。
+ */
+export declare function parseEmbedderIdentityToken(raw: string): EmbedderIdentityToken | undefined;
+//# sourceMappingURL=memory-embedder-reembed.d.ts.map

package/dist/memory-embedder-reembed.js

@@ -0,0 +1,20 @@
+export const MEMORY_EMBEDDER_REEMBED_ENV = "MEMORY_EMBEDDER_REEMBED";
+export function formatEmbedderIdentityToken(identity) {
+    return `${identity.model}/${identity.dimensions}`;
+}
+export function formatReembedAssignment(identity) {
+    return `${MEMORY_EMBEDDER_REEMBED_ENV}='${formatEmbedderIdentityToken(identity).replace(/'/g, "'\\''")}'`;
+}
+export function parseEmbedderIdentityToken(raw) {
+    const cut = raw.lastIndexOf("/");
+    if (cut <= 0)
+        return undefined;
+    const digits = raw.slice(cut + 1);
+    if (!/^[1-9][0-9]*$/.test(digits))
+        return undefined;
+    const dimensions = Number(digits);
+    if (!Number.isSafeInteger(dimensions))
+        return undefined;
+    return { model: raw.slice(0, cut), dimensions };
+}
+//# sourceMappingURL=memory-embedder-reembed.js.map

package/dist/memory-incident-sink.d.ts

@@ -1,31 +1,3 @@
-/**
- * 记忆引擎 **incident 席**在本仓的唯一落点形。
- *
- * ## 为什么要一只共用工厂(而不是每个宿主各写一行 `logger.warn`)
- * core 的记忆引擎有**两条**到宿主的披露路:
- *  · **mount 路**——`MemoryEngine` 自己的 `onIncident`,由 core 的 Runner 在 `prepare-memory` 里桥到
- *    `RunnerDeps.onError(err, { phase: "memory", sessionId })`(亲读 `dist/core/runner/prepare-memory.js`
- *    的 `const onEngineIncident = (err) => deps.onError?.(err, { phase: "memory", sessionId })`);
- *  · **无锁公开面路**——`FileMemoryEngineBackend` 的**构造期** `onIncident`,是那条腿上唯一的披露口
- *    (`adoptLayoutLocked` 取 `onIncident ?? this.onIncident`)。
- * 同一条事实(例如一次性的目录布局搬家)会按调用路径落到其中**一条**,而本仓有**两个宿主**
- * (HTTP 服务的 `boot/runner-deps.ts` 与 `run-local.ts`)各自持有 `onError` 座。四个落点各写一行 =
- * 四份会各自漂移的形;实际已经漂过一次:服务腿把整族印成 `memory_consolidation_failed`(只有一支是
- * consolidation),run-local 腿把整族印成 `engine_error` 并用 `String(err)` 抹掉 `err.code`。
- *
- * ## 形(一处定义,四处引用)
- * `memory_engine_incident` + `{ sessionId?, code?, detail }`,并计 `memory_engine_incident_total{code?}`。
- * 🔴 `code` 是**结构化字段**而不是被折进散文:它是运维唯一能按名告警的那一位,而这一族里最要紧的几条
- * (一次性布局搬家、无主根内容、控制面写失败)一辈子只发生一次 —— 折平就等于没说。
- * 码的读法与 `boot/runner-deps.ts` 的 `onError` 汇点其余七条行**同一只**(`terminal.ts` 的 `codeFieldOf`:不抛的读口 + 码判官 `isCodeToken`):是码才带;
- * 无码(core 里有大量不带 `.code` 的记忆相 Error)、不是串 / 空串、非 `Error` 抛出物、读取时抛、或带的不是码(超长 / 含空白 / 凭据形 —— 引擎错上的 `code` 是别人写的串)⇒ 行里**没有** `code` 键、
- * 计数**没有** `code` 标签:不编码,也不写 `null` / `"none"` 之类的占位。
- *
- * ⚠️ 与三只 **operator 面**引擎座(`memory_compliance_incident` / `memory_origin_incident` /
- * `memory_consolidation_incident`)**事件名刻意不合并**:那三条的事件名回答「哪一张操作面」,是三个产品面的
- * 分辨位;本工厂回答「引擎事故席」,是同一件事的四个落点。合并会丢掉前者的分辨位。三座有自己的工厂
- * {@link createOperatorFaceIncidentSink}(事件名由装配处点名),`code` 位与本工厂读同一只 `codeFieldOf`。
- */
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 /** 落点依赖。`metrics` 可缺席(run-local 的 backend 构造期座就没有计数面的消费者)。 */

package/dist/memory-incident-sink.js

@@ -1,3 +1,5 @@
+import { recordFailOpen } from "./observability/fail-open.js";
+import { isStoreFormRefusalCode } from "./memory-store-refusal.js";
 import { redactIncarnations } from "./session-incarnation.js";
 import { codeFieldOf } from "./terminal.js";
 import { seatText } from "./trace/exit-seat.js";
@@ -10,6 +12,9 @@ export function createMemoryEngineIncidentSink(deps) {
             detail: redactIncarnations(String(err)),
         });
         deps.metrics?.inc("memory_engine_incident_total", { ...codeField });
+        const { code } = codeField;
+        if (isStoreFormRefusalCode(code))
+            recordFailOpen("server.memory.store-form-refused-step-skipped", `code=${code}`);
     };
 }
 export function createOperatorFaceIncidentSink(deps, event) {