@sema-agent/server 7.144.0 → 7.146.0

package/deploy/sema-up/stack/sema-stack-cluster.yaml

@@ -92,7 +92,10 @@ kind: Service
 metadata: { name: sema-minio, namespace: sema }
 spec: { selector: { app: sema-minio }, ports: [{ name: s3, port: 9000 }, { name: console, port: 9001 }] }
 ---
-# ── 沙箱 lane RBAC(k8s+kata;pod 五动词 + 缓存卷四动词 + 沙箱秘密座 create + 出网自检的两只只读:本 ns 的 NetworkPolicy、集群的节点表)────────────────────────────────
+# ── 沙箱 lane RBAC(k8s+kata):pod 生命周期 / exec / log、出网自检的两只只读(本 ns 的 NetworkPolicy、集群的节点表)恒授;
+#    缓存卷的 persistentvolumeclaims 与沙箱秘密座的 secrets create 只在对应引擎旋钮(WORKSPACE_CACHE=volume / K8S_SANDBOX_ENV)开着时授 ——
+#    本清单的引擎 env 两个都没设,所以这两条规则渲成注释块,开了旋钮就取消注释。
+#    「哪条规则由哪个开关决定」只写在 server 源码的规则表 src/sandbox-rbac-rules.ts;下面两个规则区由 scripts/gen-deploy-lanes.ts 从它生成,不要手改。────────────────────────────────
 apiVersion: v1
 kind: ServiceAccount
 metadata: { name: sema-runner, namespace: sema-sandbox }
@@ -109,29 +112,38 @@ apiVersion: rbac.authorization.k8s.io/v1
 kind: Role
 metadata: { name: sema-runner, namespace: sema-sandbox }
 rules:
+  # @generated-begin sandbox-role-rules
+  # 沙箱 pod 的生命周期:remote-env-k8s.ts#createPod 建(POST pods)并读就绪(GET pods/<名>)· remote-env-k8s.ts#listSandboxPods 按标签列(GET pods?labelSelector)· remote-env-k8s.ts#reconnect 读存活(GET pods/<名>)· remote-env-k8s.ts#deletePod 删(DELETE pods/<名>)
+  # 兼容保留:chart 一直授着,适配器没有 watch 调用
   - apiGroups: [""]
     resources: [pods]
     verbs: [get, list, watch, create, delete]
+  # 在沙箱 pod 里执行命令:remote-env-k8s.ts#execUrl 拼 pods/<名>/exec 的连接地址
+  # 兼容保留:chart 一直授着,适配器没有 attach 调用
   - apiGroups: [""]
     resources: [pods/exec, pods/attach]
-    verbs: [create, get]
+    verbs: [get, create]
+  # 兼容保留:chart 一直授着,适配器没有读日志的调用
   - apiGroups: [""]
     resources: [pods/log]
     verbs: [get]
-  # 按工作区空间的构建缓存卷(WORKSPACE_CACHE=volume):连沙箱时按名读、没有就建;空间结束(会话删除 / 留存 sweep)按标签回收
-  - apiGroups: [""]
-    resources: [persistentvolumeclaims]
-    verbs: [get, create, delete, deletecollection]
-  # 沙箱秘密座:K8S_SANDBOX_ENV 点名的值只进每只 pod 自己的 Secret(pod spec 只带 secretKeyRef;Secret 属于 pod,随 pod 由集群回收)
-  # 动词 = 适配器为 env Secret 真发的调用:create;不读回(无 get)、不删(随属主 pod 由集群 GC)。名单非空而缺它 ⇒ server 起服拒(起服 SelfSubjectAccessReview 问的正是它)
-  # 成员 git 凭据平面(本版恒关)打开时,租约 Secret 还要 patch —— 那时再加
-  - apiGroups: [""]
-    resources: [secrets]
-    verbs: [create]
-  # 起服的出网自检读本 ns 的 NetworkPolicy(只读)
+  # 按工作区空间的构建缓存卷:remote-env-k8s.ts#ensureCacheClaim 按名读、没有就建(GET / POST persistentvolumeclaims)· remote-env-k8s.ts#cacheClaimBound 按名读 · remote-env-k8s.ts#reclaimSpaceCache 空间结束按标签回收(DELETE persistentvolumeclaims?labelSelector = deletecollection);缺它 ⇒ 缓存卷拿不到,适配器按 fail-open 照起、不挂卷(计数 server.workspace-cache.unavailable)
+  # 兼容保留:chart 一直授着,适配器回收只发按标签的 deletecollection,没有按名 delete 的调用
+  # 默认不授(本清单的 server env 没有 WORKSPACE_CACHE=volume):设了它就取消下面三行的注释:
+  # - apiGroups: [""]
+  #   resources: [persistentvolumeclaims]
+  #   verbs: [get, create, delete, deletecollection]
+  # 沙箱秘密座:动词取自 SANDBOX_SECRET_SEAT_VERBS.env —— 起服门(boot/execution-env.ts ensureSandboxSecretSeat)问的与 remote-env-k8s.ts#createOwnedSecret 为 env Secret 真发的(POST secrets)是同一行;起服门只在有效转发集合非空(名单点到的键在服务进程环境里有值)时问:答 denied ⇒ server 起服拒,问不到 ⇒ 告警 sandbox_secret_seat_unverified 照起;名单非空而有效集合为空时本行是保守多授(安装器看不到服务进程的运行时环境,引擎此时既不问也不调)
+  # 默认不授(本清单的 server env 没有 K8S_SANDBOX_ENV=NAME,NAME):设了它就取消下面三行的注释:
+  # - apiGroups: [""]
+  #   resources: [secrets]
+  #   verbs: [create]
+  # 起服的出网自检读本 ns 的 NetworkPolicy 集合:remote-env-k8s.ts#egressPolicyGaps(GET .../networkpolicies)
+  # 兼容保留:chart 一直授着,适配器只读集合(list),没有按名 get
   - apiGroups: [networking.k8s.io]
     resources: [networkpolicies]
     verbs: [get, list]
+  # @generated-end sandbox-role-rules
 ---
 apiVersion: rbac.authorization.k8s.io/v1
 kind: RoleBinding
@@ -139,14 +151,18 @@ metadata: { name: sema-runner, namespace: sema-sandbox }
 roleRef: { apiGroup: rbac.authorization.k8s.io, kind: Role, name: sema-runner }
 subjects: [{ kind: ServiceAccount, name: sema-runner, namespace: sema-sandbox }]
 ---
-# 出网自检读节点表(集群级对象 ⇒ ClusterRole;只读两动词)。与 chart 的 sandbox-rbac.yaml 同形。
+# 出网自检读节点表(集群级对象 ⇒ ClusterRole + Binding 给同一只服务账号)。与 chart 的 sandbox-rbac.yaml 读同一张规则表。
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata: { name: sema-runner-nodes-sema-sandbox }
 rules:
+  # @generated-begin sandbox-clusterrole-rules
+  # 出网自检读节点表(节点是集群级对象 ⇒ ClusterRole + Binding 给同一只服务账号):remote-env-k8s.ts#egressPolicyGaps(GET /api/v1/nodes)
+  # 兼容保留:chart 一直授着,适配器只读集合(list),没有按名 get
   - apiGroups: [""]
     resources: [nodes]
     verbs: [get, list]
+  # @generated-end sandbox-clusterrole-rules
 ---
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding

package/dist/adoption/import-limits.d.ts

@@ -0,0 +1,6 @@
+export declare const ADOPTION_IMPORT_MAX_SESSIONS_DEFAULT = 100;
+export declare const ADOPTION_IMPORT_MAX_SESSIONS_FLOOR = 1;
+export declare const ADOPTION_IMPORT_MAX_SESSION_BYTES_DEFAULT: number;
+export declare const ADOPTION_IMPORT_MAX_SESSION_BYTES_FLOOR: number;
+export declare const ADOPTION_IMPORT_MAX_SESSION_BYTES_CEILING: number;
+//# sourceMappingURL=import-limits.d.ts.map

package/dist/adoption/import-limits.js

@@ -0,0 +1,7 @@
+import { MAX_JSON_BODY_BYTES } from "../json-body-limit.js";
+export const ADOPTION_IMPORT_MAX_SESSIONS_DEFAULT = 100;
+export const ADOPTION_IMPORT_MAX_SESSIONS_FLOOR = 1;
+export const ADOPTION_IMPORT_MAX_SESSION_BYTES_DEFAULT = 6 * 1024 * 1024;
+export const ADOPTION_IMPORT_MAX_SESSION_BYTES_FLOOR = 1024 * 1024;
+export const ADOPTION_IMPORT_MAX_SESSION_BYTES_CEILING = MAX_JSON_BODY_BYTES - Buffer.byteLength(JSON.stringify({ sessions: [] }), "utf8");
+//# sourceMappingURL=import-limits.js.map

package/dist/adoption/import.d.ts

@@ -0,0 +1,62 @@
+import type { AdoptionLogStore, AdoptionRow } from "../plugins/adoption-log-sql.js";
+import { type ImportStagingStore } from "../session-sync-kernel.js";
+import { type AdoptionImportCapability, type AdoptionImportResult } from "./wire.js";
+/**
+ * 幂等键 → 云端会话 id(②)。sha256 的原像是 `JSON.stringify([域, adoptionId, clientSessionId])` —— JSON 数组的编码是**单射**的(拿分隔符拼接不是:
+ * 任一半里出现分隔符就能伪造另一对),取前 16 字节,版本半字节写 `8`(RFC 9562 自定义形)、变体写 `10`,铸成 canonical uuid。
+ * 会话 id 的形门(`security.ts` 的 `isUuidShape`)收任何版本的 canonical uuid,所以这一只 id 在每扇带会话 id 的门上都可达;
+ * 版本 8 也让它与 core 铸的 uuidv7 永不同形(不会撞上一只普通会话)。
+ */
+export declare function buildAdoptionImportSessionId(adoptionId: string, clientSessionId: string): string;
+/** 一条收编行对一位调用者的判(①;闭集四臂,门按臂穷举下发)。 */
+export type AdoptionImportBinding = {
+    readonly kind: "bound";
+    readonly adoptionId: string;
+    readonly toPrincipal: string;
+} | {
+    readonly kind: "absent";
+} | {
+    readonly kind: "not_source";
+} | {
+    readonly kind: "not_adopted";
+};
+/** ① 的唯一判官:行不在 ⇒ `absent`;调用者不**逐字**等于源主体 ⇒ `not_source`(先于收编态:不是源主体的调用方读不出这一行走到了哪);
+ *  收编没走完 / 被拒 ⇒ `not_adopted`;否则 `bound`(目的地 = 行的目的主体)。 */
+export declare function judgeAdoptionImportBinding(row: AdoptionRow | null, caller: string): AdoptionImportBinding;
+/** 两只帽的当前值(配置 env 腿解析过的那一份;数字属主 `import-limits.ts`)。 */
+export interface AdoptionImportLimits {
+    readonly adoptionImportMaxSessions: number;
+    readonly adoptionImportMaxSessionBytes: number;
+}
+/**
+ * 能力位 `adoptionImport` 的唯一铸点:部署半不在 / 没有已验身份 ⇒ 缺席;按调用者读它作为源主体的那一行(`from_principal` 唯一,恰一行或没有),
+ * 过 ① 的同一只判官,`bound` 才在场。读收编日志失败 ⇒ 缺席并走登记过的 F 类臂(能力面不为一次库抖动整只 500;缺席的方向是「入口藏起来」)。
+ */
+export declare function readAdoptionImportCapability(face: {
+    readonly available: false;
+} | {
+    readonly available: true;
+    readonly backend: {
+        adoptionLog(): AdoptionLogStore;
+    };
+}, caller: string | undefined, limits: AdoptionImportLimits): Promise<AdoptionImportCapability | undefined>;
+/** 请求体的形(恰 `{sessions: [...]}`)。读不出 ⇒ `undefined`(路由答 400 `request.body_shape`)。 */
+export declare function readAdoptionImportBody(raw: unknown): readonly unknown[] | undefined;
+/** 导入要的会话店那几口:只有暂存导入核(「已导过」由提交的属主判答,不读头);`evict` 在场 ⇒ 提交后丢掉缓存层的热句柄(提交经原始店写,绕过了缓存 —— 第二阶段同理)。 */
+export type AdoptionImportSessionStore = ImportStagingStore & {
+    evict?(sessionId: string): void;
+};
+export interface AdoptionImportTarget {
+    readonly adoptionId: string;
+    readonly toPrincipal: string;
+    readonly maxSessionBytes: number;
+    readonly sessionStorage: AdoptionImportSessionStore;
+}
+/**
+ * 逐元素跑一批(顺序跑:体已整只在内存里且 ≤ JSON 体上限,逐个落暂存 + 提交)。每个元素的判序固定:
+ * 信封形(`invalid_envelope`)→ 同批重复 id(`duplicate_client_session_id`:同批第一个读得出这个 id 的元素认领它,不论它自己的结局)
+ * → 字节帽(`too_large`)→ 导入(②③;条目日志没过 core 的导入门 ⇒ `invalid_envelope`)。
+ * 店故障原样上抛(整请求 5xx;已落的元素重投答 `already_imported`)。
+ */
+export declare function runAdoptionImport(target: AdoptionImportTarget, sessions: readonly unknown[]): Promise<AdoptionImportResult[]>;
+//# sourceMappingURL=import.d.ts.map

package/dist/adoption/import.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { SessionError } from "@sema-agent/core";
+import { createStagedLogFeed, MalformedImportEntryError, newStagingToken, StagedCommitOwnerChangedError } from "../session-sync-kernel.js";
+import { STAGED_IMPORT_INVALID_SENTENCE } from "../session-error-wire.js";
+import { recordFailOpen } from "../observability/fail-open.js";
+import { AdoptionImportBodySchema, AdoptionImportEnvelopeSchema, ADOPTION_IMPORT_CLIENT_SESSION_ID_MAX_CHARS } from "./wire.js";
+export function buildAdoptionImportSessionId(adoptionId, clientSessionId) {
+    const b = Buffer.from(createHash("sha256").update(JSON.stringify(["sema.adoption-import", adoptionId, clientSessionId])).digest().subarray(0, 16));
+    b[6] = (b[6] & 0x0f) | 0x80;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const hex = b.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export function judgeAdoptionImportBinding(row, caller) {
+    if (row === null)
+        return { kind: "absent" };
+    if (row.fromPrincipal !== caller)
+        return { kind: "not_source" };
+    switch (row.state) {
+        case "adopted":
+            return { kind: "bound", adoptionId: row.adoptionId, toPrincipal: row.toPrincipal };
+        case "in_flight":
+        case "rejected":
+            return { kind: "not_adopted" };
+        default: {
+            const unknownState = row.state;
+            throw new Error(`adoption import: unknown adoption state ${JSON.stringify(unknownState)}`);
+        }
+    }
+}
+export async function readAdoptionImportCapability(face, caller, limits) {
+    if (!face.available || caller === undefined)
+        return undefined;
+    let row;
+    try {
+        row = await face.backend.adoptionLog().getByFrom(caller);
+    }
+    catch (err) {
+        recordFailOpen("server.capabilities.adoption-import-unreadable", err instanceof Error ? err.name : "non-error throw");
+        return undefined;
+    }
+    const binding = judgeAdoptionImportBinding(row, caller);
+    return binding.kind === "bound" ? { adoptionId: binding.adoptionId, maxSessions: limits.adoptionImportMaxSessions, maxSessionBytes: limits.adoptionImportMaxSessionBytes } : undefined;
+}
+export function readAdoptionImportBody(raw) {
+    const parsed = AdoptionImportBodySchema.safeParse(raw);
+    return parsed.success ? parsed.data.sessions : undefined;
+}
+const INVALID_ENVELOPE_SHAPE = `a session envelope is exactly {clientSessionId, entries}: clientSessionId a string of 1-${ADOPTION_IMPORT_CLIENT_SESSION_ID_MAX_CHARS} characters, entries an array of session entries (oldest first) — no other keys`;
+function envelopeBytes(raw) {
+    return Buffer.byteLength(JSON.stringify(raw), "utf8");
+}
+export async function runAdoptionImport(target, sessions) {
+    const claimed = new Set();
+    const results = [];
+    for (const raw of sessions) {
+        const parsed = AdoptionImportEnvelopeSchema.safeParse(raw);
+        if (!parsed.success) {
+            results.push({ outcome: "rejected", code: "invalid_envelope", detail: INVALID_ENVELOPE_SHAPE });
+            continue;
+        }
+        const { clientSessionId, entries } = parsed.data;
+        if (claimed.has(clientSessionId)) {
+            results.push({ clientSessionId, outcome: "rejected", code: "duplicate_client_session_id" });
+            continue;
+        }
+        claimed.add(clientSessionId);
+        const bytes = envelopeBytes(raw);
+        if (bytes > target.maxSessionBytes) {
+            results.push({ clientSessionId, outcome: "rejected", code: "too_large", count: bytes, cap: target.maxSessionBytes });
+            continue;
+        }
+        results.push(await importOne(target, clientSessionId, entries));
+    }
+    return results;
+}
+async function importOne(target, clientSessionId, entries) {
+    const sessionId = buildAdoptionImportSessionId(target.adoptionId, clientSessionId);
+    const store = target.sessionStorage;
+    const handle = store.beginImportStaging(sessionId, newStagingToken());
+    try {
+        const feed = createStagedLogFeed(handle);
+        for (const e of entries)
+            await feed.push(e);
+        await feed.finish();
+    }
+    catch (e) {
+        await handle.abort().catch(() => undefined);
+        if (e instanceof MalformedImportEntryError)
+            return { clientSessionId, outcome: "rejected", code: "invalid_envelope", detail: e.message };
+        if (e instanceof SessionError && e.code === "invalid_session")
+            return { clientSessionId, outcome: "rejected", code: "invalid_envelope", detail: STAGED_IMPORT_INVALID_SENTENCE };
+        throw e;
+    }
+    try {
+        await handle.commit(target.toPrincipal, { expectedOwner: undefined });
+    }
+    catch (e) {
+        await handle.abort().catch(() => undefined);
+        if (e instanceof StagedCommitOwnerChangedError)
+            return { clientSessionId, outcome: "already_imported", sessionId };
+        throw e;
+    }
+    store.evict?.(sessionId);
+    return { clientSessionId, outcome: "imported", sessionId };
+}
+//# sourceMappingURL=import.js.map

package/dist/adoption/wire.d.ts

@@ -253,4 +253,56 @@ export declare const AdoptionRequestSchema: z.ZodObject<{
     fromPrincipal: z.ZodString;
     toPrincipal: z.ZodString;
 }, z.core.$strict>;
+/** 请求体:恰一键 `sessions`(会话信封数组)。`.strict()` —— 写面纪律;请求体里**没有**点名目的地的位置(目的地 = 收编行的目的主体)。 */
+export declare const AdoptionImportBodySchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+/** `clientSessionId` 的长度上界(调用方本地 id;不进任何列 —— 它只进派生 id 的哈希原像,并在结局里原样回显)。 */
+export declare const ADOPTION_IMPORT_CLIENT_SESSION_ID_MAX_CHARS = 255;
+/**
+ * 一个会话信封 = 调用方本地的一只会话:`clientSessionId`(它的本地 id,幂等键的一半)+ `entries`(会话的条目日志,最老在前 —— 与会话同步
+ * 推送面逐行流的同一种条目,由 core 的导入门判)。恰这两键:多一个不认识的键 ⇒ 整个元素 `rejected` / `invalid_envelope`(不静默跳过)。
+ */
+export declare const AdoptionImportEnvelopeSchema: z.ZodObject<{
+    clientSessionId: z.ZodString;
+    entries: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export type AdoptionImportEnvelope = z.infer<typeof AdoptionImportEnvelopeSchema>;
+/** `rejected` 的具名码**闭集**(三词,穷举;消费方按码给用户话):超字节 / 信封形不认识(含条目日志没过 core 的导入门)/ 同一批里第二个带同一 id 的元素。
+ *  跨批重投同一 id 不是 `duplicate_client_session_id` —— 那是 `already_imported`(幂等)。 */
+export declare const ADOPTION_IMPORT_REJECT_CODES: readonly ["too_large", "invalid_envelope", "duplicate_client_session_id"];
+export type AdoptionImportRejectCode = (typeof ADOPTION_IMPORT_REJECT_CODES)[number];
+/**
+ * 一个元素的结局(结果数组与请求的 `sessions` **按位对应**:N 个进 ⇒ N 个出)。`clientSessionId` 在信封读得出时回显(信封形不认识时缺席 —— 位置就是对应关系)。
+ *  · `imported` / `already_imported`:带云端 `sessionId`(= `(adoptionId, clientSessionId)` 的纯函数,两次答同一个);
+ *  · `rejected` + `too_large`:带量到的信封字节 `count` 与当时的帽 `cap`;
+ *  · `rejected` + `invalid_envelope`:带一句 `detail`(固定句,不回显条目内容);
+ *  · `rejected` + `duplicate_client_session_id`:同批第一个带这个 id 的元素认领它,之后的都拒(不静默去重 —— 「提交了 N 条」与「云上有 N-1 条」对不上账)。
+ */
+export type AdoptionImportResult = {
+    readonly clientSessionId: string;
+    readonly outcome: "imported" | "already_imported";
+    readonly sessionId: string;
+} | {
+    readonly clientSessionId: string;
+    readonly outcome: "rejected";
+    readonly code: "too_large";
+    readonly count: number;
+    readonly cap: number;
+} | {
+    readonly clientSessionId: string;
+    readonly outcome: "rejected";
+    readonly code: "duplicate_client_session_id";
+} | {
+    readonly clientSessionId?: string;
+    readonly outcome: "rejected";
+    readonly code: "invalid_envelope";
+    readonly detail: string;
+};
+/** 能力位 `adoptionImport` 的值(present-iff 调用者是一条已收编行的源主体):导入口的 id + 两只帽的**当前值**(客户端据此分批,不撞 400 再收缩)。 */
+export interface AdoptionImportCapability {
+    readonly adoptionId: string;
+    readonly maxSessions: number;
+    readonly maxSessionBytes: number;
+}
 //# sourceMappingURL=wire.d.ts.map

package/dist/adoption/wire.js

@@ -77,4 +77,13 @@ export const AdoptionRequestSchema = z
     toPrincipal: z.string().min(1).max(190),
 })
     .strict();
+export const AdoptionImportBodySchema = z.object({ sessions: z.array(z.unknown()) }).strict();
+export const ADOPTION_IMPORT_CLIENT_SESSION_ID_MAX_CHARS = 255;
+export const AdoptionImportEnvelopeSchema = z
+    .object({
+    clientSessionId: z.string().min(1).max(ADOPTION_IMPORT_CLIENT_SESSION_ID_MAX_CHARS),
+    entries: z.array(z.unknown()),
+})
+    .strict();
+export const ADOPTION_IMPORT_REJECT_CODES = ["too_large", "invalid_envelope", "duplicate_client_session_id"];
 //# sourceMappingURL=wire.js.map

package/dist/approval-ask-machine.d.ts

@@ -36,8 +36,8 @@ export declare function canAskTransition(from: AskState, to: AskState): boolean;
 export declare function canBatchTransition(from: BatchState, to: BatchState): boolean;
 /**
  * `AskRequest.boundInputHash` 的**边界窄读**(唯一一只):ask 身份第四轴的入参那一半与行上 `bound_input_hash` 列(收敛器判据 1 的对账键)读的都是它。
- * core 在闸站铸值(`onAsk({ ...bare, boundInputHash: boundInputHashOf(presented.value), … })`,core 5.15.0 起每一只经 `resolveAsk` 的问都带);
- * `boundInputHashOf` 不在 core 的公开导出面上(包 `exports` 只有 `.` / `./bench` / `./fixtures`),本服务既算不出也不该算 —— 只原样读。
+ * core 在闸站铸值(`onAsk({ ...bare, boundInputHash: exactBoundInputHashOf(req.toolName, presented.value), … })`,core 5.15.0 起每一只经 `resolveAsk` 的问都带;
+ * 7.63.0 起摘的是 `{ tool, input }`,此前只摘入参);`exactBoundInputHashOf` 不在 core 的公开导出面上(包 `exports` 只有 `.` / `./bench` / `./fixtures`),本服务既算不出也不该算 —— 只原样读。
  * 非字符串 / 空串一律按缺席:一个形不对的摘要比没有摘要更危险(它会让「硬相等」这道门在一个垃圾值上偶然成立)。
  * 钉:`test/stream-approval-on-e2e.test.ts` 件4(正控 / 缺席 / 空串三臂)。
  */

package/dist/approval-card.d.ts

@@ -54,7 +54,7 @@ export declare const MAX_RULE_OFFER_BATCH_MEMBERS = 8;
 /**
  * **一条**「不再询问」OFFER 的形(core 5.58.0 / [ref] §3.1 —— **BREAKING**,取代退役的
  * `RuleSuggestion`)。同步腿(`ApprovalCardSchema.ruleOffers` / `card_json`)与耐久腿(durable park 行的
- * `PendingCheckpoint.ruleOffers`,由 `plugins/checkpoint-store-sql.ts` 窄读)**共用这一份**。
+ * `PendingCheckpoint.ruleOffers`,由 `plugins/checkpoint-store-face.ts` 的 `boundedRuleOffers` 窄读)**共用这一份**。
  *
  * 🔴 单一属主(宪法 [ref]「schema 单一属主禁复制」):两条腿投的是 core 的**同一个** `RuleOffer`
  * (同步腿 = `AskRequest.ruleOffers`,耐久腿 = `PendingAction.ruleOffers`,core
@@ -138,7 +138,7 @@ export interface ReadRuleOffer {
     readonly offer: RuleOffer;
 }
 /**
- * **规则提议列表的唯一读者**(core 7.55.0 [ref] P1 阶段二)—— 两条腿同调:耐久腿(`checkpoint-store-sql.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行)
+ * **规则提议列表的唯一读者**(core 7.55.0 [ref] P1 阶段二)—— 两条腿同调:耐久腿(`checkpoint-store-face.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行)
  * 与同步腿(`tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`)。判官是 core 的 `readRuleOffers`:逐元素判、保原始下标、多余键逐级剥、
  * 闭集词(offer / 成员的 `kind`、`match`)不认 ⇒ 整只丢(batch 不拆成员)、无 `kind` 的存量成员读作 command、明细座不是「每个计数段一行」⇒ 只丢座。
  * 修前本仓自己一份不限长 zod 形,前面垫两只预筛(无 `kind` 成员的回填、明细座的座级筛)—— 读的是 core 铸的形,读法却是本仓一份;core 对两者的 76 种形逐一对过,不同的三种是本仓的明细座行数帽(留在这里)与两种非 JSON 值(数组带属性、类实例)。
@@ -149,15 +149,6 @@ export interface ReadRuleOffer {
  * 缺席(`undefined`)= 没有提议,答空、不计。展示帽(条数、成员前缀、扫描窗)、脱敏与截长归调用方 —— 它们是各腿的展示纪律,不是读法。
  */
 export declare function readRuleOfferList(raw: unknown): readonly ReadRuleOffer[];
-/**
- * 一份(已解码的)规则提议列表里,**带着无 `kind` 存量成员**的 batch offer 有几只 —— 判官是 core `readRuleOffers` 给每只读出的 offer 打的 `kindlessForm` 记号
- * (「这一只 batch 里至少一个成员是经无 `kind` 的存量形读的」;与 {@link readRuleOfferList} 同一只读者,不是本仓自己再写一遍「成员没有 `kind` 键」)。
- * 起服普查(`approval-batch-census.ts`)用它给存量行记数:读者那条存量臂退役的前提是「零行还靠它读」。
- *
- * **只数,不落任何痕迹**:读不出的元素(`dropped`)与整只值不是列表(`problem`)是 {@link readRuleOfferList} 的计数口径(`server.rule-offers.offer-dropped`),这里不重复记,
- * 它们也不是「靠存量臂读出来」的 —— 一个读不出的无 `kind` 成员(缺文本键)退役前后同样被丢,不改变任何一行的读法,所以不计入。
- */
-export declare function countKindlessBatchOffers(raw: unknown): number;
 /**
  * 卡面/帧面共用的 offer **投影型**(= {@link RuleOfferSchema} 的输出形)。判别位 `kind` 上闭集,
  * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员是判别联合(`command` | `directoryRead`),
@@ -518,7 +509,7 @@ export declare function parkRowFacts(stored: unknown): ParkRowFacts;
  * 本仓**不重算哈希**(core 的 `boundInputHashOf` 不在公开导出面上,清单校验读口 `readBoundBinding` 同样不导出),所以**不许**拿寄存行 `pendingAction` 上的原清单直接投 ——
  * 原值上的清单是未经哈希校验的(这正是它此前不上队列行的原因,见 `trace/core-keyset-guard.ts` ⑧b 记账的旧注)。两只店各自拿到「这一行的摘要」的办法不同
  * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生在判官要的那一次整行读里调 core 的 `summarizeCheckpoint` —— 两位与 `rowVerdict` 同一次读、
- * 同一份按字节摘要的记忆,见 `plugins/checkpoint-store-sql.ts` 的 `storedRowProjections`),
+ * 同一份按字节摘要的记忆,见 `stores-sql/checkpoint-store-sql.ts` 的 `storedRowProjections`),
  * 但投影只有这一只:OMIT 契约 —— 缺席即缺席,恒不铸 `undefined` 值的键。
  *
  * `boundGrants` 是**部署文本**(技能名、清单条目):本函数不脱敏、不转义,与收件箱行逐字同口径 —— 渲染按上下文转义是客户端的事(契约同句)。

package/dist/approval-card.js

@@ -64,10 +64,6 @@ export function readRuleOfferList(raw) {
     reading.dropped.forEach((d) => recordOfferDropped(d.problem, d.index));
     return reading.offers.map(withDetailSeatBounded);
 }
-export function countKindlessBatchOffers(raw) {
-    const reading = readRuleOffers(raw);
-    return "problem" in reading ? 0 : reading.offers.filter((o) => o.kindlessForm === true).length;
-}
 function withoutOverCapDetailSeat(item, index) {
     if (typeof item !== "object" || item === null)
         return item;

package/dist/approval-gate-currency.d.ts

@@ -65,7 +65,7 @@
  *  (时刻与方向两处自 core 7.56.0 [ref] 起由筛判:I10 / I11。trace 投影读同一种记录、经同一只筛,零改即得 I10 —— 坏时刻在两个读者那里是同一个答法。)
  */
 import { type Checkpoint, type CheckpointToken, type SettlementKind } from "@sema-agent/core";
-import { type PendingRowBinding } from "./plugins/checkpoint-store-sql.js";
+import { type PendingRowBinding } from "./plugins/checkpoint-store-face.js";
 import { type ParkedGateRead } from "./tool-approval.js";
 /**
  * 决断方回显的「我看到的那道门」—— 门的两个身份面之一(两面的来历与读法见模块头注「`approval_stale` 律」)。

package/dist/approval-gate-currency.js

@@ -1,5 +1,5 @@
 import { REOPEN_REASONS, checkpointRevOf, screenGateOutcome } from "@sema-agent/core";
-import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-sql.js";
+import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-face.js";
 import {} from "./tool-approval.js";
 import { APPROVAL_GATE_KINDS } from "./approval-content-kind.js";
 import { trustedCheckpointId } from "./checkpoint-identity.js";

package/dist/approval-reconciler.d.ts

@@ -1,7 +1,7 @@
 import type { AskRow, ApprovalAskStore } from "./plugins/approval-ask-store-sql.js";
 import type { UnattendedApprovalPolicy } from "./tool-approval.js";
 import type { BatchState } from "./approval-ask-machine.js";
-import type { CheckpointAskCandidate } from "./plugins/checkpoint-store-sql.js";
+import type { CheckpointAskCandidate } from "./plugins/checkpoint-store-face.js";
 import { type RunRecord } from "./plugins/store-contracts.js";
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";

package/dist/audit.d.ts

@@ -1,4 +1,4 @@
-import { type SessionPlacementRecord, type StoredPromptEpoch } from "@sema-agent/core";
+import { type StoredPromptEpoch } from "@sema-agent/core";
 import type { Pool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type LocalSessionRows } from "./plugins/local-session-window.js";
@@ -30,31 +30,12 @@ export interface SessionAudit {
      *  the key entirely (undefined). */
     promptEpoch?: StoredPromptEpoch;
 }
-/**
- * 会话视图体顶层 additive 键 `agent` —— **这只会话是哪只委派子代的转录**(`GET /v1/sessions/:id`;读法:终端侧链投影方按 fleet 帧的 `transcriptId`
- * 读同一只会话读面,从体上拿到子代身份,不必再回头翻 fleet 行 —— 行一离场就没有了)。
- *
- * 只投影**存下来的 placement 元组**(`session_meta` 的 `placement_*` 列,首写不可变;店的 `placementOf` 一行 PK 探针),**不另铸**:
- *  · `id` = 元组里的 `handle` —— 耐久 agent 行的 `a…` 键,与 fleet 行的 `id`、`GET /v1/agents/roster` 的 `handle` 是同一个串(core 铸元组时 `handle: taskId`);
- *  · `parentSessionId` / `rootSessionId` = 元组里的同名格(派它的会话 / 委派树的根会话);
- *  · 元组缺哪一格这里就缺哪一格(present-iff;不铸空串);元组的 `scope`(租户键)/ `placedAt` / `kind` 不上 wire。
- * 键在场 = 这是一只委派子代的转录(哪怕元组只存了 `kind`,那时 `agent` 是 `{}`);键缺席 = 普通会话,**或这台部署的店不存 placement 元组**
- * (local 后端:子代转录停驻前住私有短 TTL 店、停驻时拷进来的那一份是普通会话行 —— 事实没存就不报,消费方在 fleet 行 / `GET /v1/agents/roster` 上本就有 `id`)。
- * 元组由引擎在**后台**委派子代(带耐久 agent 行、店声明了 placements)建会话时铸;同步委派的子代转录不落宿主店,没有元组。
- */
-export interface SessionAgent {
-    id?: string;
-    parentSessionId?: string;
-    rootSessionId?: string;
-}
-/** {@link SessionAgent} 的唯一投影:店答出的 placement 元组 → 体上的 `agent` 值;`undefined`(普通会话 / 店没有这一面)⇒ 调用方不铸键。 */
-export declare function sessionAgentOf(placement: SessionPlacementRecord | undefined): SessionAgent | undefined;
 /**
  * 用户消息行的**回退手柄**表:用户条目 id → 回退时交给 `resumeAt` 的那个 `event_id`(R8 用户消息锚按 run 的 taskId 键入)。
  * 真源 = `resume_anchor`(锚店 `listBySession` 的读数),本表只是它对**一位读者**的一次投影。
  */
 export type RewindHandles = ReadonlyMap<string, string>;
-/** 会话视图读口(`ServiceDeps.sessionAudit`)的读者参数:`reader` = 读这张视图的**已验身份**(无身份 = `null`)。给了 ⇒ 这是一次**视图读**:用户消息行投回退手柄、体顶层投 `agent`({@link sessionAgentOf});
+/** 会话视图读口(`ServiceDeps.sessionAudit`)的读者参数:`reader` = 读这张视图的**已验身份**(无身份 = `null`)。给了 ⇒ 这是一次**视图读**:用户消息行投回退手柄、体顶层投 `agent`(`session-agent.ts` 的 `readSessionAgent`);
  *  不给(只要归属的调用方:memory-status / 自助抹除)⇒ 两样投影的读都不付。 */
 export interface SessionAuditReadOpts {
     readonly reader: string | null;

package/dist/audit.js

@@ -6,15 +6,6 @@ import { redactModelText } from "./observability/run-terminal.js";
 import { redactDeepWith } from "./trace/redact.js";
 import { projectToolStructured } from "./trace/tool-output-media.js";
 import { INJECTED_BLOCK_RE, isAttachmentFrame } from "./user-authored-text.js";
-export function sessionAgentOf(placement) {
-    if (placement === undefined)
-        return undefined;
-    return {
-        ...(placement.handle !== undefined ? { id: placement.handle } : {}),
-        ...(placement.parentSessionId !== undefined ? { parentSessionId: placement.parentSessionId } : {}),
-        ...(placement.rootSessionId !== undefined ? { rootSessionId: placement.rootSessionId } : {}),
-    };
-}
 export function buildRewindHandles(anchors, reader) {
     const byEntry = new Map();
     for (const a of anchors) {

package/dist/boot/deployment-mods.d.ts

@@ -40,11 +40,21 @@ export interface LoadedModPackage {
     /** 读包者交回的三件字节摘要(`ModPackageRegistration.digest`,按给值记)—— 认得出「装的是哪几份字节」,不是代码完整性凭据。 */
     readonly digest: string;
 }
-/** 装配的结果:部署座的注册(自铸在前、声明在后,整列已过引擎准入)与装上的声明包(只数声明的包,自铸的不算)。 */
+/** 装配的结果:部署座的注册(自铸在前、声明在后,整列已过引擎准入)、装上的声明包(只数声明的包,自铸的不算)与部署座的链站点式样。 */
 export interface DeploymentModsAssembly {
     readonly registrations: readonly ModRegistration<EngineDollar>[];
     readonly loaded: readonly LoadedModPackage[];
+    /** 部署座在**任务座之下**挂了链成员(不是观察者)的站点式样 —— 引擎这一次准入的记录读出({@link belowTaskChainPatternsOf})。读者:请求 `settings.hooks` 托管车道的只许收紧判据(`hooks/hook-runner.ts` 的 `managedTightenOnlyOn`)。 */
+    readonly belowTaskChainPatterns: readonly string[];
 }
+/**
+ * 部署座在**任务座之下**挂了链成员的站点式样(去重,按准入序)。「之下」按引擎的跑序读:先按档(`MOD_TIERS` 的序),同档里部署座在任务座之前 ⇒
+ * 只有档排在任务座档之后的部署注册(今天是 `append`)在任务座之下;`prepend` 与同档 `user` 的部署注册在任务座之上(它们先判、再在答回来的结果上判,运维 handler 恒在请求钩子之上)。
+ * 每张准入了的、站在任务座之下的部署注册取 `events`(引擎记下的、它真挂了 handler 的式样)减去 `observe`(那张注册在该式样上只挂了观察者)。
+ * 读的是引擎的准入记录,不是注册自报的 `uses` —— 一处事实一个读法。式样的文法(精确站名或 `<前缀>.*`)由读者按引擎的定义读(`hooks/hook-runner.ts` 的 `chainsBelowTaskOn`)。
+ * 是**上界**:记录不带匹配器,带匹配器的 handler 在不中的那一次派发里不进链(引擎按派发取链)⇒ 读者只拿它收紧、从不拿它换挂法或放宽。
+ */
+export declare function belowTaskChainPatternsOf(records: readonly ModAdmissionRecord[]): readonly string[];
 /** 部署座的唯一装配口(两只起服入口同调;三段与失败见文件头注)。 */
 export declare function assembleDeploymentMods(input: {
     readonly metrics: Pick<Metrics, "inc">;

package/dist/boot/deployment-mods.js

@@ -1,6 +1,6 @@
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, relative, sep } from "node:path";
-import { admitModChain, KERNEL_CONTRACT_VERSION, loadModPackage } from "@sema-agent/core";
+import { admitModChain, KERNEL_CONTRACT_VERSION, loadModPackage, MOD_TIERS } from "@sema-agent/core";
 import { createBrandIdentityRegistration } from "../capabilities/brand-identity.js";
 import { createPermissionDeniedMeter, createToolTracer } from "../observability/tool-trace.js";
 import { errorCodeOf, errorText } from "../observability/err-text.js";
@@ -14,6 +14,19 @@ export function createDeploymentMods(input) {
         ...(input.brandIdentity === true ? [createBrandIdentityRegistration()] : []),
     ].map((registration) => ({ ...registration, provenance: MOD_PROVENANCE.minted }));
 }
+const TASK_SEAT_TIER = "user";
+export function belowTaskChainPatternsOf(records) {
+    const out = new Set();
+    const taskTier = MOD_TIERS.indexOf(TASK_SEAT_TIER);
+    for (const r of records) {
+        if (r.seat !== "deployment" || "refusedBy" in r || MOD_TIERS.indexOf(r.tier) <= taskTier)
+            continue;
+        for (const p of r.events)
+            if (!(r.observe ?? []).includes(p))
+                out.add(p);
+    }
+    return [...out];
+}
 export async function assembleDeploymentMods(input) {
     const minted = createDeploymentMods(input);
     const resolved = resolveDeclaredPackages(input.declaration);
@@ -25,7 +38,7 @@ export async function assembleDeploymentMods(input) {
     const loaded = resolved.map(({ pkg }, i) => ({ name: pkg.name, tier: admittedRecordOf(records, pkg.name).tier, contract: KERNEL_CONTRACT_VERSION, digest: declared[i].digest }));
     for (const row of loaded)
         input.logger.info("mods_package_loaded", { name: sanitizeWireText(row.name), tier: row.tier, contract: row.contract, digest: row.digest });
-    return { registrations, loaded };
+    return { registrations, loaded, belowTaskChainPatterns: belowTaskChainPatternsOf(records) };
 }
 function fsCauseOf(e) {
     const code = errorCodeOf(e);

package/dist/boot/device-lane.js

@@ -30,12 +30,14 @@ export function createDeviceLane(ctx) {
         ...(knobs?.reconnectGraceMs != null ? { reconnectGraceMs: knobs.reconnectGraceMs } : {}),
         ...(knobs?.maxInflightPerDevice != null ? { maxInflightPerDevice: knobs.maxInflightPerDevice } : {}),
         ...(knobs?.maxPreAuthPerRemote !== undefined ? { maxPreAuthConnectionsPerRemote: knobs.maxPreAuthPerRemote } : {}),
+        ...(knobs?.trustedProxyCidrs !== undefined ? { trustedProxyCidrs: knobs.trustedProxyCidrs } : {}),
         ...(knobs?.supersede ? { supersede: knobs.supersede } : {}),
     });
     logger.info("device_lane_enabled", {
         replicaId,
         maxInflightPerDevice: knobs?.maxInflightPerDevice ?? 4,
         maxPreAuthPerRemote: knobs?.maxPreAuthPerRemote ?? 8,
+        trustedProxyCidrs: knobs?.trustedProxyCidrs?.length ?? 0,
         enrollRateLimit: `${DEVICE_ENROLL_RATE_POLICY.limit}/${DEVICE_ENROLL_RATE_POLICY.windowMs / 1000}s per caller identity (per replica; independent of RATE_LIMIT_RPM)`,
     });
     return { store, enrollment, hub, seat };