@sema-agent/server 7.140.0 → 7.142.0

package/dist/http/server.d.ts

@@ -13,6 +13,7 @@ import type { ExecutionRoot, ResolvedTaskSpec } from "./execution-context.js";
 import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchorStore, ApprovalExemptionStore, ApprovalNonceStore, ServiceSessionPolicyStore, ServiceFileHistoryStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
 import type { RuleConsentLane } from "../rules-consent.js";
 import { type MemorySyncRequest, type MemorySyncResponse } from "../memory-sync.js";
+import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { LeaderEndpoint } from "../leader/endpoint.js";
 import { type WorkflowAgentRegistry } from "../orchestration/workflow-agent-steer.js";
@@ -463,7 +464,8 @@ export interface ServiceSeamDeps {
     }>;
     /** 142-S5 §1.4: per-scope memory export reader (main.ts wires `exportMemoryScope` over the DB memory
      *  backend). Enables GET /v1/memory/export — present ONLY on a DB memory plane (MEMORY_ENGINE_BACKEND=
-     *  pg|tidb); absent / file posture ⇒ 501 (single-user file memory exports by copying the memory dir). */
+     *  pg|mysql); absent ⇒ 501 (single-user file memory exports by copying the memory dir). The gate and the capability bit
+     *  `memoryExport` read ONE fact (`capability-facts.ts` `memoryExport`) — whether this face is wired, never the backend name. */
     memoryExport?: (scope: string) => Promise<MemoryEntry[]>;
     /**
      * [ref](core 5.57.0 `routePairingStatus`)—— **key↔URL 配对读面**:`GET /v1/models` 每行的
@@ -479,8 +481,10 @@ export interface ServiceSeamDeps {
     /** 142-S2.5(设计 §2.5;裁定 plan 随数据走,core 零运行时半场):one full sync round for one
      *  (scope, peer) — main.ts wires `performMemorySync` over the DB memory backend + the sync-cursor
      *  store. Enables POST /v1/memory/sync/:scope — present ONLY on a DB memory plane
-     *  (MEMORY_ENGINE_BACKEND=pg|tidb); absent / file posture ⇒ 501 honestly (a single-user file plane
-     *  IS the TOC side of a sync — it has no central-authority half to serve). */
+     *  (MEMORY_ENGINE_BACKEND=pg|mysql); absent ⇒ 501 honestly (a single-user file plane
+     *  IS the TOC side of a sync — it has no central-authority half to serve). [ref]: the face also needs the center's
+     *  declared sync identity (`config.memorySyncServeIdentity`) — the gate and the capability bit `memorySyncServe` read ONE
+     *  fact (`capability-facts.ts` `memorySyncServe`). */
     memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncResponse>;
     /** [ref] v2-c(core 5.40.0 `MemoryEngine.exportMemoryScopes`):治理完备包的**携出**面。main.ts 把它接到
      *  装配好的 memory engine 上。启用 `POST /v1/memory/export`(operator-only)。
@@ -533,6 +537,14 @@ export interface ServiceSeamDeps {
      * 装配漏接 ⇒ tsc 红(本行就是通知);测试桩在 `test/helpers/boot.ts` 显式给 false。
      */
     memoryAutoConsolidationArmed: boolean;
+    /**
+     * [ref] —— 本**部署**的记忆同步腿(客户端半场):`MEMORY_SYNC_URL` 设了且 file 记忆引擎亮着、执行器起了才在场(`boot/stores.ts`)。
+     * `GET /v1/sessions/:id/memory-status` 的 `memorySync` 格只读它的 `parked()` —— 停驻事实的唯一读口(写者 = 执行器的轮,运维行 `memory_sync_layer_parked` 读同一份);
+     * 缺席 ⇒ 那一格缺席(没有同步腿)。与 `memoryAutoConsolidationArmed` 同类:部署事实,不随会话、不随层座。
+     * [ref]:会话记忆同步触发口(`POST /v1/sessions/:id/memory/sync`)读它的 `peer`(目标比对)与 `syncOnce`(一轮,交回每层每次调用;从不 reject)——
+     * 能力事实 `sessionMemorySync` 的第一格就是它在不在。
+     */
+    memorySyncLeg?: Pick<MemorySyncRunner, "parked" | "peer" | "syncOnce">;
     /**
      * [ref] / [ref] + 车PI 修复轮 ④ —— 记忆整理阀门的**生效判决**(boot 第 4 段 `createConsolidationValve`:显式词,或出厂缺省按
      * 装配结果派生)。配置目录那一行(`GET /v1/config/catalog` 的 `MEMORY_CONSOLIDATION_DRIVER` `effectiveValue`)读它 —— 那一列的契约是
@@ -691,10 +703,11 @@ export interface ServiceDeploymentDeps {
     /** [ref] ②:caps `centerWiring` 的读面(`capabilities/center-wiring.ts` `createCenterWiringReader`;入参 = 请求的已验 principal)。
      *  缺席 = 没接中心(或测试夹具)⇒ 键整个缺席。 */
     centerWiring?: (principal: string | undefined) => import("../capabilities/center-wiring.js").CenterWiring;
-    /** The member git-credential plane's one reading (`sandbox-git-plane.ts`; stage 5 computes it once — config premises + the boot's secret
-     *  seat answer + the static patch judge). Caps `credentialPlane.sandboxGit` projects it as is. Absent = not built by the composition root
-     *  (a fixture) ⇒ the same judge on config alone, the seat counted as not asked. */
-    sandboxGitPlane?: import("../sandbox-git-plane.js").SandboxGitPlane;
+    /** The member git-credential plane's read function (`sandbox-git-plane.ts` `createSandboxGitPlaneSeat`'s `now`: the judge over the boot readings — the
+     *  secret seat answer stage 5 settles, the static patch judge — and the live config, whose `sandboxGit` block hot-swaps with each effective-config commit).
+     *  Caps `credentialPlane.sandboxGit` calls it on every read and projects the answer as is. Absent = not built by the composition root (a fixture) ⇒
+     *  the same judge on config alone, the seat counted as not asked. */
+    sandboxGitPlane?: () => import("../sandbox-git-plane.js").SandboxGitPlane;
     /**
      * 本进程起服装上的**运维声明** mod 包数(部署座装配口 `assembleDeploymentMods` 的 `loaded.length`;本服务自铸的注册不算)。一个事实两个出口,同读这一格:
      * `/health` 的 `mods: { deploymentPackages }` 与 `/v1/capabilities` 的 `modsDeploymentPackages: true` —— 都只在 > 0 时在场;0 / 缺席(没声明,或不是由

package/dist/http/server.js

@@ -18,7 +18,7 @@ import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
-import { sendError, sendHttpError, sendSessionError, logRequestError } from "./send.js";
+import { sendError, sendHttpError, sendOpenFaceFault, logRequestError } from "./send.js";
 import { createRequestGuards } from "./request-guards.js";
 import { sqlEngineSeatIssue } from "../sql-engine-posture.js";
 import { parkDecisionStoreRefusal } from "../orchestration/workflow-park-decision.js";
@@ -169,13 +169,11 @@ export function createHttpServer(rawDeps) {
                 res.end();
                 return;
             }
-            if (sendSessionError(res, err, "open"))
-                return;
             if (err instanceof SessionForkInProgressError) {
                 sendError(res, 409, err.code, err.message);
                 return;
             }
-            sendError(res, 500, "internal.error", "internal error");
+            sendOpenFaceFault(res, err);
         });
     });
     const deviceLane = facts.deviceLane(deps);

package/dist/http/sse-log.d.ts

@@ -70,15 +70,10 @@ export declare const SSE_PREAMBLE_TIMEOUT_MS = 2000;
  * `ApprovalAskStore.listPendingBySession` 的注)。丢结果这条语义不变:preamble 只读,丢弃零副作用。
  *
  * 导出给 `routes/tasks.ts` 的 sync 腿直接用 —— 那条腿不走 `streamSseLog`(它不是账本 tail),但
- * 「有界 + fail-open」这条判据必须是**同一份实现**,不能各腿各写一遍。
+ * 「有界 + fail-open」这条判据必须是**同一份实现**,不能各腿各写一遍。帧型是调用方的(本泵写 `{ event, data }`,
+ * sync 腿把卡帧原样交给它自己的写口 `http/live-frame.ts`),所以按帧型泛化。
  */
-export declare function collectSsePreamble(preamble: (signal: AbortSignal) => Promise<Array<{
-    event: string;
-    data: unknown;
-}>>, onFailure?: (reason: "timeout" | "error", err?: unknown) => void, timeoutMs?: number): Promise<Array<{
-    event: string;
-    data: unknown;
-}>>;
+export declare function collectSsePreamble<F>(preamble: (signal: AbortSignal) => Promise<F[]>, onFailure?: (reason: "timeout" | "error", err?: unknown) => void, timeoutMs?: number): Promise<F[]>;
 /** The shared resumable SSE pump (P2.8) — provider supplies the log-specific differences; the liveness/
  *  heartbeat/terminal-re-fetch/15-min-cap logic is identical for task_run + image_bake.
  *

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

@@ -9,7 +9,7 @@
  */
 import type { PermissionMode } from "@sema-agent/core";
 import { type Autonomy } from "../runtime-governance.js";
-import { type LaneHomeDeployment } from "../execution-lane-caps.js";
+import { type ExecutionConfigRootDeployment } from "../execution-config-root.js";
 import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
 import type { CheckpointCtx } from "./route-ctx.js";
 /**
@@ -22,9 +22,9 @@ export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor:
     floor: PermissionMode;
 } | undefined;
 /**
- * 预判读的部署配置:`autonomy`(第三问的模式词地板)与执行车道的 home 两位(`~/` 形规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
+ * 预判读的部署配置:`autonomy`(第三问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)与配置根的几位(user 设置层 `/` 规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
  */
-export type StoredReplayDeployment = LaneHomeDeployment & {
+export type StoredReplayDeployment = ExecutionConfigRootDeployment & {
     readonly autonomy?: Autonomy | undefined;
 };
 /**

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

@@ -4,6 +4,7 @@ import { entryProblemsFacts } from "../entry-problems.js";
 import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
 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";
 export function permissionModeReadingUnstated(ctx, floor) {
@@ -35,7 +36,8 @@ function storedRulePolicyRefusal(body, deployment) {
     if (permissions === undefined)
         return undefined;
     const home = executionLaneHomeDir(deployment);
-    const refused = rulePolicyBucketsRefusal({ ...(Array.isArray(permissions["ask"]) ? { ask: permissions["ask"] } : {}), ...(Array.isArray(permissions["deny"]) ? { deny: permissions["deny"] } : {}) }, home !== undefined ? { home } : {});
+    const configRoot = executionConfigRootOf(deployment);
+    const refused = rulePolicyBucketsRefusal({ ...(Array.isArray(permissions["ask"]) ? { ask: permissions["ask"] } : {}), ...(Array.isArray(permissions["deny"]) ? { deny: permissions["deny"] } : {}) }, { ...(home !== undefined ? { home } : {}), ...(configRoot !== undefined ? { configRoot } : {}) });
     if (refused !== undefined)
         return replayInertEntry(`settings.permissions.${refused.bucket}`, "deny", SETTINGS_RULE_REFUSAL_CODE, `${REQUEST_SETTINGS_REFUSAL_PREFIX}${refused.message}`, { ...entryProblemsFacts(refused.problems) });
     const neverAuto = readTightenOnlySeats({ permissions }).values.neverAuto;

package/dist/http/submit-replay.d.ts

@@ -18,9 +18,10 @@
  *
  * ## 回执两形(按提交腿)
  *  · `durable`(`POST /v1/runs`、A2A `message/send`)—— `202 { taskId, sessionId, status }`(这条腿首答的既有形);
- *  · `sync`(`POST /v1/tasks`;`/v1/tasks/stream` 把同一份体放进 `done.result`)—— `200 { …run 行读面, replay: true }`
- *    (读面 = `GET /v1/runs/:id` 的 200 体,同一只投影口 `readRunFace`)。同步腿的首答是引擎结果,而重放时手里只有行;
- *    `replay: true` 是这一形的判别位。
+ *  · `sync`(`POST /v1/tasks`;`/v1/tasks/stream` 把同一份体放进 `done.result`)—— `200 { …首答的信封, replay: true }`:
+ *    首答的信封由 `http/sync-submit-body.ts` 铸(`buildSyncSubmitBody`),重放经同文件的 `syncSubmitBodyOfRow` 读行 ——
+ *    终局 / 停驻行上有结果 ⇒ 与首答同形(结果的键在顶层,`result` 是串);行上没有结果可交(首投还在跑)⇒ 轮询回执 `{ taskId, sessionId, status }`。
+ *    `replay: true` 是重放的判别位(本函数叠上,不在信封里)。
  */
 import type { RunIdemBinding, RunRecord } from "../plugins/store-contracts.js";
 import type { RunStore } from "../plugins/store-backend.js";

package/dist/http/submit-replay.js

@@ -1,5 +1,5 @@
 import { runRowReadable } from "./owner-access.js";
-import { readRunFace } from "./run-read-face.js";
+import { syncSubmitBodyOfRow } from "./sync-submit-body.js";
 import { refusalBody } from "./refusal-body.js";
 export function isRunExistsConflictBody(body) {
     return typeof body === "object" && body !== null && body.errorCode === "conflict.run_exists";
@@ -19,7 +19,7 @@ export async function replayOfExistingRun(row, caller, face, deps, runStore) {
         case "durable":
             return { status: 202, body: { taskId: row.taskId, sessionId: row.sessionId, status: row.status } };
         case "sync":
-            return { status: 200, body: { ...(await readRunFace(deps, runStore, row)), replay: true } };
+            return { status: 200, body: { ...syncSubmitBodyOfRow(deps, row), replay: true } };
         default: {
             const unknown = face;
             throw new Error(`replayOfExistingRun: unknown submit face ${String(unknown)}`);

package/dist/http/sync-submit-body.d.ts

@@ -25,14 +25,19 @@
  * (`observability/run-terminal.ts`),调用方铸一次交进来;本函数只负责「体长什么样」。凭据(`paused.token` /
  * `failed.nestedPause.token`)因此在进本函数之前就已摘掉,幂等缓存存的正是本函数的产物,重放体同体同脱。
  */
-import type { ParkedRunStatus, PersistedTaskResult } from "../plugins/store-contracts.js";
-/** park 中的 run 在同步 200 体上带的 poll 回执三键(修前 park 体的全部内容,值逐字不变)。 */
-export interface SyncParkReceipt {
+import { type ParkedRunStatus, type PersistedTaskResult, type RunRecord } from "../plugins/store-contracts.js";
+import { type RunFaceDeps } from "./run-read-face.js";
+/** 同步 200 体上的 poll 回执三键:一条 run 的 poll 键、会话、对外词。park 体叠在结果之上带它({@link SyncParkReceipt});重放命中一条还没有结果可交的行时,它**就是**整个体({@link syncSubmitBodyOfRow})。 */
+export interface SyncRunReceipt {
     /** 同步腿提交时铸的 durable run id —— `GET /v1/runs/:taskId` 的 poll 键。 */
     taskId: string;
     /** 提交的会话。 */
     sessionId: string;
-    /** 对外词 = `GET /v1/runs/:id` 行上的 `status`(park 两词之一,闭集从 `RUN_STATUS_CLASS` 派生)。 */
+    /** 对外词 = `GET /v1/runs/:id` 行上的 `status`。 */
+    status: RunRecord["status"];
+}
+/** park 中的 run 在同步 200 体上带的 poll 回执三键(修前 park 体的全部内容,值逐字不变);`status` 是 park 两词之一(闭集从 `RUN_STATUS_CLASS` 派生)。 */
+export interface SyncParkReceipt extends SyncRunReceipt {
     status: ParkedRunStatus;
 }
 /**
@@ -40,4 +45,16 @@ export interface SyncParkReceipt {
  * 返回的是纯数据(无方法、无闭包)⇒ `build*`。
  */
 export declare function buildSyncSubmitBody<R extends PersistedTaskResult>(exitResult: R, parkReceipt?: SyncParkReceipt): R | (R & SyncParkReceipt);
+/**
+ * **同键重放读行的出口** —— 同一条 run 的同步 200 体,首答与重放读**同一只信封**:终局行 / 停驻行上有结果 ⇒ 经 {@link buildSyncSubmitBody} 铸
+ * (终局 = 结果本身;停驻 = 结果 + 回执三键),与首答的三个 200 出口逐字同形 —— 首答恒 = 「出口封口 + 脱敏后的引擎结果」,那份对象就是落在行上的那一份
+ * (调用方铸一次、既落行又进体),重放读到的是它被读入口(同一只 {@link runRowExitResult},`GET /v1/runs/:id` 的 `result` 读的也是它)再封再脱的样子。
+ * 行上没有结果可交(首投还在跑、在别的副本上没落定;或终局行的结果已被收割清空)⇒ 首答在这一刻**不存在**,体只剩 {@link SyncRunReceipt} 三键 —— 去 `GET /v1/runs/:taskId` 轮询,
+ * 不把「读面」塞进同步体里充首答(失联折叠与读面同一只判据 {@link runRowStale}:折成 `failed`)。
+ *
+ * 首答体上另有两类**本次请求**的附注(`notice` / `warnings`,见 `routes/tasks.ts` 的 `withSyncSubmitKeys`):重放在 `prepareSpec` 之前就答了,
+ * 结构上不知道本次请求带没带 verify / cascade、放行侧选择器里有没有空条目 ⇒ 重放体没有它们。判别位 `replay: true` 由重放出口(`submit-replay.ts`)叠上,不在信封里。
+ * 纯数据 ⇒ `build*` 的近亲;名字取 `…OfRow`(行 → 体的读法),与 `buildSyncSubmitBody` 同文件同铸点。
+ */
+export declare function syncSubmitBodyOfRow(deps: RunFaceDeps, row: RunRecord): ReturnType<typeof buildSyncSubmitBody> | SyncRunReceipt;
 //# sourceMappingURL=sync-submit-body.d.ts.map

package/dist/http/sync-submit-body.js

@@ -1,4 +1,17 @@
+import { isParkedRunStatus, isTerminalRunStatus } from "../plugins/store-contracts.js";
+import { runRowExitResult, runRowStale } from "./run-read-face.js";
 export function buildSyncSubmitBody(exitResult, parkReceipt) {
     return parkReceipt === undefined ? exitResult : { ...exitResult, ...parkReceipt };
 }
+export function syncSubmitBodyOfRow(deps, row) {
+    const stale = runRowStale(deps, row);
+    const exit = stale ? undefined : runRowExitResult(row);
+    if (exit !== undefined) {
+        if (isTerminalRunStatus(row.status))
+            return buildSyncSubmitBody(exit);
+        if (isParkedRunStatus(row.status))
+            return buildSyncSubmitBody(exit, { taskId: row.taskId, sessionId: row.sessionId, status: row.status });
+    }
+    return { taskId: row.taskId, sessionId: row.sessionId, status: stale ? "failed" : row.status };
+}
 //# sourceMappingURL=sync-submit-body.js.map

package/dist/identity-source.d.ts

@@ -12,9 +12,13 @@
  * 3. **缺席一种读法**:`null` = 这一行**没有「属主在受理时验过的凭据」的记录** —— 三列存在之前写下的行、没有任何验过凭据的受理(无鉴权写面
  *    `ALLOW_UNAUTHED_WRITES`)、以及别人替属主按下的那一跑(受理请求验过的主体不是这一行的属主:唤醒 / 决定投递铸的新一跑)。读者一律按「不合格」处置
  *    (fail-closed),不分辨三种成因;存量行不回填(没有事实可回填)。
+ * 4. **令牌声明装不进它的列就不记**(不截断:截断 = 两个不同的值折成一个):`sso` 臂从验过的令牌铸元组时,某一格装不进它的列宽({@link RUN_IDENTITY_CLAIM_COLUMNS})
+ *    ⇒ 那一格「未记录」—— 可空的格(化身号)记 `null`;必填的格(scope)装不下就铸不出合形元组 ⇒ 无元组。两格结果不同来自元组的型,不是两条规则:
+ *    同一只判({@link runIdentityClaimOverflow})、同一行告警 `run_identity_claim_unrecorded { claim, chars, max }`(凭据门的铸点发;只名与长度,不带值)。
  *
- * 化身号 `principalInc`:令牌 `sub_inc` 声明原样,经契约包 `VerifiedIdentity.principalInc` 读(settings-schema 14.7.0 加的可选字段,已提货:验证腿随身份带出);本版接线未做 ⇒ 恒 `null`,
- * 接线点在 `admitRunIdentity` 的 `sso` 臂(不在本仓另定一份读法)。
+ * 化身号 `principalInc`:令牌 `sub_inc` 声明原样(契约包 `VerifiedIdentity.principalInc`)。来源链只有一条 —— 验证器读出 → 注入边界再判形(`auth-bridge.ts` 的
+ * `admitBridgeIdentity`)→ 入口预认证挂 request-local(`security.ts` 的 `setSsoPrincipalInc`)→ 凭据门 `admitRunIdentity` 的 `sso` 臂铸进元组(律 4)→ 建行原样写入。
+ * `null` 化身号只有一种读法:**未记录**(契约 §12.8「缺 ⇒ 化身号未记录」)—— 存量行、令牌没带、装不下,三种成因同一读法。
  */
 /** 验过的身份来源的**闭集**(序 = 判定次序 = `/health.auth.kinds` 的出现序;加一个来源 = 加一个词,读它的各只穷举 `switch` 不接就编译红)。 */
 export declare const IDENTITY_SOURCES: readonly ["service_token", "sso", "direct_door_jwt"];
@@ -36,6 +40,21 @@ export type RunIdentity = {
 export declare const RUN_IDENTITY_SCOPE_MAX_CHARS = 190;
 /** `identity_principal_inc` 的列宽(字符):化身号是签发方插入时铸的不透明随机串(与会话化身同宽)。 */
 export declare const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
+/** 令牌声明 → 它落的那一列的列宽(字符;律 4 的判读这一张)。 */
+export declare const RUN_IDENTITY_CLAIM_COLUMNS: {
+    readonly scope: 190;
+    readonly principalInc: 64;
+};
+export type RunIdentityClaim = keyof typeof RUN_IDENTITY_CLAIM_COLUMNS;
+/**
+ * 律 4 的判:这一格令牌声明装不装得进它的列(按码点数,与两方言 VARCHAR 同口径)。装得下 ⇒ `undefined`;装不下 ⇒ 告警行 `run_identity_claim_unrecorded` 的载荷
+ * (`claim` 名 + 码点数 + 列宽,不带值)。调用方按格的型处置:可空格记 `null`,必填格无元组。
+ */
+export declare function runIdentityClaimOverflow(claim: RunIdentityClaim, value: string): {
+    readonly claim: RunIdentityClaim;
+    readonly chars: number;
+    readonly max: number;
+} | undefined;
 /**
  * `task_run` 三列的列定义 —— 两方言各一段,**唯一属主**:中央建表语句(`tidb-pool.ts` / `pg-pool.ts` 的 `CREATE TABLE task_run`)内插这同一段;
  * 存量库缺列时起服列册对账(`schema-consistency.ts`)拒启,拒句里的 `ALTER TABLE task_run ADD COLUMN …` 由同一份建表语句解析生成 ⇒

package/dist/identity-source.js

@@ -1,6 +1,12 @@
 export const IDENTITY_SOURCES = ["service_token", "sso", "direct_door_jwt"];
 export const RUN_IDENTITY_SCOPE_MAX_CHARS = 190;
 export const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
+export const RUN_IDENTITY_CLAIM_COLUMNS = { scope: RUN_IDENTITY_SCOPE_MAX_CHARS, principalInc: RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS };
+export function runIdentityClaimOverflow(claim, value) {
+    const chars = [...value].length;
+    const max = RUN_IDENTITY_CLAIM_COLUMNS[claim];
+    return chars > max ? { claim, chars, max } : undefined;
+}
 export const RUN_IDENTITY_COLUMNS = {
     mysql: [
         "identity_source VARCHAR(32) NULL",

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

@@ -79,8 +79,15 @@ export declare function createInstructionSourceSeat(sessionStore: unknown, emit:
  * 超时**(codex che-NM r2 [high];S-9 `write-behind-counter.ts` 先例:mysql2 `{sql, timeout}` / pg `query_timeout`,pg-pool
  * 超时即销毁那条连接)—— 只放手不截断,卡住的查询会一直占着池里的连接。超期后仍在飞的写由 CAS 挡住,不会盖掉更新的基线。
  * 数值与 core 给 `probeInstructionSources` 的 2s 天花板同量级:一行 PK 读写在健康库上是毫秒级。
+ * 第二个读者:回退锚写入(`runs.ts` 的 `settleResumeAnchor`)—— 同为单行 PK 写、同在腿的关键路径上(流式腿的终帧等它),
+ * 同为披露类(F)放手,所以读同一只数、同一只 {@link withinIoDeadline}。
  */
 export declare const BASELINE_IO_DEADLINE_MS = 2000;
+/** {@link withinIoDeadline} 到点放手。**具名型**:调用方据它分诊「超期」与「店报错」,不比对文案。 */
+export declare class IoDeadlineExceeded extends Error {
+}
+/** 单行店操作的有界等待:`op` 在 {@link BASELINE_IO_DEADLINE_MS} 内落定就原样交出,否则 reject {@link IoDeadlineExceeded}。只放手不取消 —— 超期后仍在飞的那次操作照常落定(迟到的 reject 被吞,不成未处理拒绝)。 */
+export declare function withinIoDeadline<T>(op: () => Promise<T>): Promise<T>;
 /**
  * **唯一铸点**:本次 prepare 选中的来源 `current`(链成员相对路径;没有 = `null`)与基线比。
  *  · 没有基线 ⇒ 只写不发(新会话首 run);

package/dist/instruction-source-notice.js

@@ -27,14 +27,14 @@ export function createInstructionSourceSeat(sessionStore, emit) {
 }
 const describeSource = (source) => source ?? "no project instruction file";
 export const BASELINE_IO_DEADLINE_MS = 2_000;
-class BaselineDeadlineExceeded extends Error {
+export class IoDeadlineExceeded extends Error {
 }
-function withinDeadline(op) {
+export function withinIoDeadline(op) {
     const running = Promise.resolve().then(op);
     running.catch(() => undefined);
     let timer;
     const deadline = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new BaselineDeadlineExceeded(`no answer within ${BASELINE_IO_DEADLINE_MS}ms`)), BASELINE_IO_DEADLINE_MS);
+        timer = setTimeout(() => reject(new IoDeadlineExceeded(`no answer within ${BASELINE_IO_DEADLINE_MS}ms`)), BASELINE_IO_DEADLINE_MS);
         timer.unref?.();
     });
     return Promise.race([running, deadline]).finally(() => clearTimeout(timer));
@@ -42,7 +42,7 @@ function withinDeadline(op) {
 export async function announceInstructionSource(seat, sessionId, current) {
     let baseline;
     try {
-        baseline = await withinDeadline(() => seat.store.readInstructionSource(sessionId));
+        baseline = await withinIoDeadline(() => seat.store.readInstructionSource(sessionId));
     }
     catch (e) {
         degraded("read", sessionId, e);
@@ -65,14 +65,14 @@ export async function announceInstructionSource(seat, sessionId, current) {
         }
     }
     try {
-        await withinDeadline(() => seat.store.recordInstructionSource(sessionId, baseline, current));
+        await withinIoDeadline(() => seat.store.recordInstructionSource(sessionId, baseline, current));
     }
     catch (e) {
         degraded("write", sessionId, e);
     }
 }
 function degraded(op, sessionId, e) {
-    const why = e instanceof BaselineDeadlineExceeded ? `timeout=${BASELINE_IO_DEADLINE_MS}ms` : `err=${e instanceof Error ? e.message : String(e)}`;
+    const why = e instanceof IoDeadlineExceeded ? `timeout=${BASELINE_IO_DEADLINE_MS}ms` : `err=${e instanceof Error ? e.message : String(e)}`;
     recordFailOpen("server.instruction-source.announce-degraded", `op=${op} session=${sessionId} ${why}`);
 }
 //# sourceMappingURL=instruction-source-notice.js.map

package/dist/mcp-assertion-header.d.ts

@@ -36,6 +36,8 @@
 import type { McpServerSpec } from "@sema-agent/core";
 import type { RequestMcpTransport } from "@sema-agent/settings-schema";
 import type { McpDraft } from "./peer-seat.js";
+/** 请求面 `transport.kind` 的种类词(契约包请求传输形的判别键):`GET /v1/capabilities.mcpTransportKinds` 的元素型,也是自铸登记表 `mcpTransportKind` 集的键型。 */
+export type McpRequestTransportKind = RequestMcpTransport["kind"];
 /** 请求面 stdio 传输的形(契约包):引擎的 stdio 传输去掉凭据引用位、加上 `env`(件)。 */
 export type RequestStdioMcpTransport = Extract<RequestMcpTransport, {
     kind: "stdio";
@@ -66,6 +68,8 @@ export declare const MCP_HTTP_TRANSPORT_DISPOSITION: {
     readonly principalHeader: "engine";
     readonly url: "engine";
 };
+/** 位的值:请求面读器的传输种类(书写序 = 表序,冻结;能力位每次响应取一份拷贝)。 */
+export declare const MCP_REQUEST_TRANSPORT_KINDS: readonly McpRequestTransportKind[];
 /**
  * 请求面条目 → 草稿:传输按它那一臂的处置表拆(`env` / `headers` 进件,`assertionHeader` 两边都不进,其余进声明);条目层的键原样进声明。件缺席或空 ⇒ 草稿不带件(登记时什么都不留)。
  * 纯函数:不登记、不读部署状态;被扣下的 `assertionHeader` 由调用方另说一行 info。

package/dist/mcp-assertion-header.js

@@ -1,6 +1,11 @@
 import { splitDeclaration } from "./plain-string-record.js";
 export const MCP_STDIO_TRANSPORT_DISPOSITION = { args: "engine", command: "engine", env: "seat", kind: "engine" };
 export const MCP_HTTP_TRANSPORT_DISPOSITION = { assertionHeader: "withheld", headers: "seat", kind: "engine", principalHeader: "engine", url: "engine" };
+const MCP_REQUEST_TRANSPORT_ARMS = {
+    stdio: MCP_STDIO_TRANSPORT_DISPOSITION,
+    http: MCP_HTTP_TRANSPORT_DISPOSITION,
+};
+export const MCP_REQUEST_TRANSPORT_KINDS = Object.freeze(Object.keys(MCP_REQUEST_TRANSPORT_ARMS));
 export function toMcpDraft(spec) {
     const { transport, ...entry } = spec;
     const split = transport.kind === "http" ? splitDeclaration(transport, MCP_HTTP_TRANSPORT_DISPOSITION) : splitDeclaration(transport, MCP_STDIO_TRANSPORT_DISPOSITION);

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

@@ -14,14 +14,17 @@
  * consolidation),run-local 腿把整族印成 `engine_error` 并用 `String(err)` 抹掉 `err.code`。
  *
  * ## 形(一处定义,四处引用)
- * `memory_engine_incident` + `{ sessionId?, code, detail }`,并计 `memory_engine_incident_total{code}`。
+ * `memory_engine_incident` + `{ sessionId?, code?, detail }`,并计 `memory_engine_incident_total{code?}`。
  * 🔴 `code` 是**结构化字段**而不是被折进散文:它是运维唯一能按名告警的那一位,而这一族里最要紧的几条
- * (一次性布局搬家、无主根内容、控制面写失败)一辈子只发生一次 —— 折平就等于没说。无码的成员
- * (core 里有大量不带 `.code` 的记忆相 Error)落 `null` / 计数标签 `"none"`,**不编**一个码。
+ * (一次性布局搬家、无主根内容、控制面写失败)一辈子只发生一次 —— 折平就等于没说。
+ * 码的读法与 `boot/runner-deps.ts` 的 `onError` 汇点其余七条行**同一只**(`terminal.ts` 的 `codeFieldOf`:不抛的读口 + 码判官 `isCodeToken`):是码才带;
+ * 无码(core 里有大量不带 `.code` 的记忆相 Error)、不是串 / 空串、非 `Error` 抛出物、读取时抛、或带的不是码(超长 / 含空白 / 凭据形 —— 引擎错上的 `code` 是别人写的串)⇒ 行里**没有** `code` 键、
+ * 计数**没有** `code` 标签:不编码,也不写 `null` / `"none"` 之类的占位。
  *
- * ⚠️ 与 `main.ts` 三只 **operator 面**引擎座(`memory_compliance_incident` / `memory_origin_incident` /
- * `memory_consolidation_incident`)**刻意不合并**:那三条的事件名回答「哪一张操作面」,是三个产品面的
- * 分辨位;本工厂回答「引擎事故席」,是同一件事的四个落点。合并会丢掉前者的分辨位。
+ * ⚠️ 与三只 **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";
@@ -34,4 +37,14 @@ export interface MemoryEngineIncidentSinkDeps {
 export declare function createMemoryEngineIncidentSink(deps: MemoryEngineIncidentSinkDeps): (err: unknown, ctx?: {
     sessionId?: string;
 }) => void;
+/** 三只 operator 面引擎座的事件名(闭集):事件名回答「哪一张操作面」—— 出处 / 抹除合规 · 外源标记人面 · 整理三面,由装配处点名。 */
+export type OperatorFaceIncidentEvent = "memory_compliance_incident" | "memory_origin_incident" | "memory_consolidation_incident";
+/**
+ * operator 面引擎座(各面工厂的 `onIncident` 形参:`(err: Error & { code?: string }) => void`)的唯一落点形:`<事件名>` + `{ code?, detail }`。
+ * 这三座此前各在装配处写一份 `{ code: err.code ?? null, detail }` —— 引擎错上的 `code` 是别人写的串,什么都照写(凭据形也进行),无码写 `null` 占位;
+ * 现在 `code` 位读 `codeFieldOf`(与 `onError` 汇点其余各行、{@link createMemoryEngineIncidentSink} 同一只):是码才带,其余键缺席;`detail` 句只经运维文本座。
+ */
+export declare function createOperatorFaceIncidentSink(deps: Pick<MemoryEngineIncidentSinkDeps, "logger">, event: OperatorFaceIncidentEvent): (err: Error & {
+    code?: string;
+}) => void;
 //# sourceMappingURL=memory-incident-sink.d.ts.map

package/dist/memory-incident-sink.js

@@ -1,14 +1,18 @@
 import { redactIncarnations } from "./session-incarnation.js";
+import { codeFieldOf } from "./terminal.js";
+import { seatText } from "./trace/exit-seat.js";
 export function createMemoryEngineIncidentSink(deps) {
     return (err, ctx) => {
-        const code = err?.code;
-        const codeText = typeof code === "string" && code !== "" ? code : undefined;
+        const codeField = codeFieldOf(err);
         deps.logger.warn("memory_engine_incident", {
             ...(ctx?.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
-            code: codeText ?? null,
+            ...codeField,
             detail: redactIncarnations(String(err)),
         });
-        deps.metrics?.inc("memory_engine_incident_total", { code: codeText ?? "none" });
+        deps.metrics?.inc("memory_engine_incident_total", { ...codeField });
     };
 }
+export function createOperatorFaceIncidentSink(deps, event) {
+    return (err) => deps.logger.warn(event, { ...codeFieldOf(err), detail: seatText("operator-log-text", err.message) });
+}
 //# sourceMappingURL=memory-incident-sink.js.map

package/dist/memory-posture.d.ts

@@ -29,7 +29,7 @@ export type MemoryVectorRung = "native" | "portable" | "lexical";
 export type MemoryDarkReason = 
 /** operator 显式关停(`MEMORY_ENGINE=off`)。 */
 "engine_off"
-/** 多租户 + file 底座:file 基座无租户隔离,fail-closed 不点亮(改 `MEMORY_ENGINE_BACKEND=pg|tidb`)。 */
+/** 多租户 + file 底座:file 基座无租户隔离,fail-closed 不点亮(改 `MEMORY_ENGINE_BACKEND=pg|mysql`)。 */
  | "multi_tenant_file_backend"
 /** 平面分裂车道:模型的文件工具在沙箱 fs、引擎在 worker fs,harvest 看不到沙箱写入 ⇒ fail-closed。 */
  | "remote_lane_split";

package/dist/memory-scope.d.ts

@@ -46,7 +46,7 @@ export declare function memoryLayersNamedBy(config: Pick<ServiceConfig, "require
  *     **读列表的第二层**,不是写家:写家是该任务的**项目层**,由 {@link memoryProjectKeyFor} 按任务根派生、经
  *     {@link memorySpecForRequest} 的 `projectKey` 位铸进 spec(读 = [项目, 本 scope],`writeScope` 显式 = 项目)。
  *     本函数在授权期调(还不知道任务根),所以项目层不在这里。
- *  ② MULTI-TENANT + DB 后端(`requirePrincipal === true` ∧ `memoryEngineBackend` ∈ {`pg`, `tidb`}):按**验过的**
+ *  ② MULTI-TENANT + DB 后端(`requirePrincipal === true` ∧ `memoryEngineBackend` ∈ {`pg`, `mysql`}):按**验过的**
  *     principal 铸 v2 typed 键 —— 无 projectId ⇒ `user:<tenant>`(core `formatUserScope`),有形状合法的
  *     projectId ⇒ `proj:<tenant>/<projectId>`(core `formatProjScope`);principal 缺席(匿名 run)⇒ `undefined`
  *     (无记忆)。scope 列是租户分区,授权就是「验过的 principal 进、一个租户的 scope 出」这一绑定;身份永远不来自
@@ -128,7 +128,7 @@ export declare function memoryEngineRemoteLanePosture(config: ServiceConfig): {
  * N0 启动告警的**文案**(纯,可单测;boot/stores.ts 的装配点只负责喂「引擎这一腿真的接上了吗」并打日志)。
  *
  * 为什么要按引擎真身分腿(2026-08-12 复扫,已核真):{@link memoryEngineRemoteLanePosture} 的 `dark` 只对
- * **file** 引擎腿有裁决权 —— 车道门的唯一消费者是 {@link memoryEngineBackendFor}。`MEMORY_ENGINE_BACKEND=pg|tidb`
+ * **file** 引擎腿有裁决权 —— 车道门的唯一消费者是 {@link memoryEngineBackendFor}。`MEMORY_ENGINE_BACKEND=pg|mysql`
  * 的两条腿在 boot/stores.ts 里**先于**任何车道判断就被点亮(库是持久真身,与手的文件平面无关),于是同一次
  * 启动会先打 `memory_engine_enabled {enabled:true, backend:"pg"}`,几行之后再打一句「memory dark
  * (fail-closed) … Set MEMORY_ENGINE_REMOTE_LANE=allow」—— 两句直接对撞,而且把运维指向一个在该腿上**不接线**
@@ -172,13 +172,13 @@ engineWired: boolean): {
  * (壳布局 `~/.sema/engine-data`)」时分家 ⇒ 记忆库每一次 Write 被硬拒(7.58.0 放行 ⇒ 回归);反向
  * (`CONFIG_LOCAL_DIR=~/.sema` 当 dataRoot)则让配置根自身免检。两根本就是两件事:店根归誊本门,引擎根归本函数。
  *
- * 形与 boot/stores.ts 逐字同律:DB 记忆腿(pg/tidb)的根 = `<localDataRoot ?? localRoot>/memory-work`
+ * 形与 boot/stores.ts 逐字同律:DB 记忆腿(pg/mysql)的根 = `<localDataRoot ?? localRoot>/memory-work`
  * (per-worker 物化区);file 腿 = boot file 后端的链 `resolveMemoryEngineRoot(memoryEngineDir)`。**不判引擎是否
  * 启用**——纯路径推导,禁用态下豁免根仍以「若开引擎会写到哪」为根(boot 的 `engineDataRoot` 恒铸,经共享基座交每只 Runner)。
  */
 export declare function memoryEngineRootFor(config: Pick<ServiceConfig, "memoryEngineBackend" | "memoryEngineDir" | "localDataRoot">, localRoot?: string): string;
 /** file 后端的根链(`MEMORY_ENGINE_DIR ?? fallback ?? $AGENT_DATA_DIR ?? ~/.ai-agent`)—— 与后端选择器**无关**:
- *  `memoryEngineBackendFor` 恒造 file 后端(run-local 从 env 继承 `MEMORY_ENGINE_BACKEND=pg|tidb` 时仍是 file),
+ *  `memoryEngineBackendFor` 恒造 file 后端(run-local 从 env 继承 `MEMORY_ENGINE_BACKEND=pg|mysql` 时仍是 file),
  *  所以它的根必须走这条链而不是 `memoryEngineRootFor` 的分派(codex 修复验证轮 [medium]:分派会把 run-local 的
  *  记忆搬到 `<localDataRoot>/memory-work`,存量记忆与控制面升级后隐形)。 */
 export declare function fileMemoryEngineRoot(config: Pick<ServiceConfig, "memoryEngineDir">, fallbackRoot?: string): string;

package/dist/memory-scope.js

@@ -29,7 +29,7 @@ export function memoryLayersNamedBy(config) {
 export { MEMORY_SCOPE_COLUMN_CHARS, assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
 export function memoryScopeFor(config, principal, projectId) {
     if (config.requirePrincipal === true) {
-        if (config.memoryEngineBackend === "pg" || config.memoryEngineBackend === "tidb") {
+        if (config.memoryEngineBackend === "pg" || config.memoryEngineBackend === "mysql") {
             if (!principal)
                 return undefined;
             const scope = projectId ? formatProjScope(principal, projectId) : formatUserScope(principal);