@sema-agent/server 7.145.0 → 7.147.0

package/deploy/sema-up/chart/templates/server-v4pro.yaml

@@ -61,13 +61,14 @@ spec:
             - { name: MODEL_VISION, value: {{ .Values.server.modelVision | quote }} }
             {{/* 租户姿态与主 worker 同值(文件头「同 env 面」的承诺;修前缺席 ⇒ 主 worker 多租时本只仍单用户)。 */}}
             - { name: REQUIRE_PRINCIPAL, value: {{ .Values.server.requirePrincipal | default "false" | quote }} }
+            {{/* 单用户运维声明 = 租户姿态的否定(同一个值派生,不另开 values 键):单用户 ⇒ 这台的调用方就是运维;多租 ⇒ 不声明(运维由具名名单另给)。
+                 server 装配运维面时要单用户部署说出谁是运维,缺了这一行单用户 worker 起服拒。派生与「只认 true / false」见 _helpers.tpl 的 sema.operatorSingleUser。 */}}
+            - { name: OPERATOR_SINGLE_USER, value: {{ include "sema.operatorSingleUser" . | quote }} }
             - { name: SANDBOX_PKG_SOURCE, value: {{ .Values.server.sandboxPkgSource | quote }} }
-            {{/* 车道点名了就显式表态「这台有手」——REQUIRE_EXECUTION_LANE 让「车道被谁改没了」
-                 变成拒启而不是安静的无手 worker。server 侧默认仍 off,sema-up 产物一律写 true。
-                 下面圈起来的两行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}
+            {{/* 车道显式点名(REMOTE_EXEC)。REQUIRE_EXECUTION_LANE 是退役 env(设了即起服拒,拒句指向 REMOTE_EXEC),不再渲。
+                 下面圈起来的一行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}
             {{/* @generated-begin kube-lane-env */}}
             - { name: REMOTE_EXEC, value: "k8s" }
-            - { name: REQUIRE_EXECUTION_LANE, value: "true" }
             {{/* @generated-end kube-lane-env */}}
             - { name: K8S_API_URL, value: "https://kubernetes.default.svc" }
 {{- if .Values.server.k8sInsecureTls }}
@@ -77,6 +78,10 @@ spec:
             - { name: K8S_RUNTIME_CLASS, value: {{ .Values.sandbox.runtimeClass }} }
             - { name: K8S_SANDBOX_IMAGE, value: {{ .Values.sandbox.image | quote }} }
             - { name: K8S_SANDBOX_IPV6, value: {{ .Values.sandbox.ipv6 | quote }} }
+{{- /* 沙箱特性开关(sandbox.workspaceCacheVolume / sandbox.sandboxEnv)同一个值写引擎旋钮与沙箱 Role 规则,见 _helpers.tpl。 */}}
+{{- with (include "sema.sandbox.switchEnv" . | trim) }}
+{{ . | indent 12 }}
+{{- end }}
             - { name: K8S_TOKEN, valueFrom: { secretKeyRef: { name: sema-runner-token-copy, key: token } } }
 {{- /* 耐久审批的显式表态与停驻封签钥匙卷同源(助手 sema.durableApproval / sema.sealedKey.*,见 _helpers.tpl):关持久 ⇒ 显式 false;留空 ⇒ 不渲。 */}}
 {{- with (include "sema.sealedKey.env" .) }}

package/deploy/sema-up/chart/templates/server.yaml

@@ -72,13 +72,14 @@ spec:
             - { name: MODEL_API_KEY, valueFrom: { secretKeyRef: { name: sema-server-env, key: MODEL_API_KEY } } }
             - { name: MODEL_VISION, value: {{ .Values.server.modelVision | quote }} }
             - { name: REQUIRE_PRINCIPAL, value: {{ .Values.server.requirePrincipal | default "false" | quote }} }
+            {{/* 单用户运维声明 = 租户姿态的否定(同一个值派生,不另开 values 键):单用户 ⇒ 这台的调用方就是运维;多租 ⇒ 不声明(运维由具名名单另给)。
+                 server 装配运维面时要单用户部署说出谁是运维,缺了这一行单用户 worker 起服拒。派生与「只认 true / false」见 _helpers.tpl 的 sema.operatorSingleUser。 */}}
+            - { name: OPERATOR_SINGLE_USER, value: {{ include "sema.operatorSingleUser" . | quote }} }
             - { name: SANDBOX_PKG_SOURCE, value: {{ .Values.server.sandboxPkgSource | quote }} }
-            {{/* 车道点名了就显式表态「这台有手」——REQUIRE_EXECUTION_LANE 让「车道被谁改没了」
-                 变成拒启而不是安静的无手 worker。server 侧默认仍 off,sema-up 产物一律写 true。
-                 下面圈起来的两行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}
+            {{/* 车道显式点名(REMOTE_EXEC)。REQUIRE_EXECUTION_LANE 是退役 env(设了即起服拒,拒句指向 REMOTE_EXEC),不再渲。
+                 下面圈起来的一行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}
             {{/* @generated-begin kube-lane-env */}}
             - { name: REMOTE_EXEC, value: "k8s" }
-            - { name: REQUIRE_EXECUTION_LANE, value: "true" }
             {{/* @generated-end kube-lane-env */}}
             - { name: K8S_API_URL, value: "https://kubernetes.default.svc" }
 {{- if .Values.server.k8sInsecureTls }}
@@ -90,6 +91,10 @@ spec:
 {{- end }}
             - { name: K8S_SANDBOX_IMAGE, value: {{ .Values.sandbox.image | quote }} }
             - { name: K8S_SANDBOX_IPV6, value: {{ .Values.sandbox.ipv6 | quote }} }
+{{- /* 沙箱特性开关(sandbox.workspaceCacheVolume / sandbox.sandboxEnv)同一个值写引擎旋钮与沙箱 Role 规则,见 _helpers.tpl。 */}}
+{{- with (include "sema.sandbox.switchEnv" . | trim) }}
+{{ . | indent 12 }}
+{{- end }}
             - { name: K8S_TOKEN, valueFrom: { secretKeyRef: { name: sema-runner-token-copy, key: token } } }
 {{- /* 耐久审批的显式表态与停驻封签钥匙卷同源(助手 sema.durableApproval / sema.sealedKey.*,见 _helpers.tpl):关持久 ⇒ 显式 false;留空 ⇒ 不渲。 */}}
 {{- with (include "sema.sealedKey.env" .) }}

package/deploy/sema-up/chart/values.yaml

@@ -48,7 +48,7 @@ server:
   modelId: ""              # REQUIRED
   modelApiKey: ""          # REQUIRED
   modelVision: "false"
-  requirePrincipal: "false"   # users=multi 时 true(身份隔离;compose 路径同名 env)
+  requirePrincipal: "false"   # users=multi 时 true(身份隔离;compose 路径同名 env)。只认 "true" / "false";单用户运维声明 OPERATOR_SINGLE_USER 由它派生(false ⇒ "true")
   # 耐久审批(env DURABLE_APPROVAL;停驻 / 续跑 / /v1/approvals 整条路由)。留空 = 图表不渲这个 env,开关归引擎按姿态定
   # (单用户 + 有耐久店 ⇒ 开;requirePrincipal=true 的多用户形 ⇒ 关);"true" / "false" = 显式表态,原样渲给每只 worker。
   # sealedKey.persistence.enabled=false 时图表固定渲 "false"(钥匙跨不过重启,停驻行就续不了);此处再写 "true" ⇒ 渲染即拒。
@@ -149,6 +149,13 @@ sandbox:
   #   每个节点的 kubelet 要 --allowed-unsafe-sysctls 点名它们,否则沙箱 pod 起不来;沙箱 ns 不能 enforce PodSecurity baseline。
   #   enabled = 不动 pod(缺省):只执行 IPv4 的出网策略(k3s 单栈缺省即是)管不到 pod 的 IPv6,server 起服每次一行提醒。
   ipv6: enabled
+  # 沙箱特性开关 —— 同一个值既写引擎旋钮、又决定沙箱 Role 带不带对应规则(「哪条规则由哪个开关决定」只写在 server 源码的规则表 src/sandbox-rbac-rules.ts):
+  #   workspaceCacheVolume(布尔,只收 true / false)= 按工作区空间的构建缓存卷:true ⇒ 引擎 env WORKSPACE_CACHE=volume,Role 加 persistentvolumeclaims 的
+  #     get / create / delete / deletecollection;false(缺省)⇒ 引擎不建卷、Role 不授这四个动词。前提:集群有缺省 StorageClass、引擎有存储后端(本 chart 恒有 PG)。
+  #   sandboxEnv(名单字符串 NAME,NAME)= 沙箱带外 env 名单:非空 ⇒ 引擎 env K8S_SANDBOX_ENV=<名单>,Role 加 secrets 的 create;空(缺省)⇒ 都不加。
+  #     名单点到的键的**值**要在引擎进程的环境里(本 chart 不替部署提供值的来源);点到而环境里没有的键不转发。
+  workspaceCacheVolume: false
+  sandboxEnv: ""
   # 沙箱出网策略(NetworkPolicy,egress 白名单;要集群 CNI 带 NetworkPolicy 控制器 —— k3s 缺省自带):
   #   放行 = DNS(kube-dns)+ 对象存储(chart 自带的 MinIO 9000,加 objectStore 点名的脸)+ IPv4 公网面;
   #   拒   = 私网 / 共享 / 链路本地 / 环回六段(10/8、172.16/12、192.168/16、100.64/10、169.254/16、127/8)整段,

package/deploy/sema-up/cluster-up.sh

@@ -399,6 +399,7 @@ RENDERED="$WORK/sema-stack-cluster.rendered.yaml"
   R_PKG_SOURCE="$([ "$REGION" = "global" ] && echo global || echo '')" \
   R_PG_INSTANCES="$PG_INSTANCES" R_PG_AA="$PG_AA" R_REPLICAS="$SERVER_REPLICAS" \
   R_REQ_PRINCIPAL="$(principal_of_users "$USERS")" \
+  R_OPERATOR_SINGLE_USER="$(operator_single_user_of_users "$USERS")" \
   python3 - "$HERE/stack/sema-stack-cluster.yaml" > "$RENDERED" <<'PY'
 import os, sys
 MAP = {"__MINIO_PW__":"R_MINIO_PW", "__SVC_TOKEN__":"R_SVC_TOKEN", "__MODEL_KEY__":"R_MODEL_KEY",
@@ -406,7 +407,7 @@ MAP = {"__MINIO_PW__":"R_MINIO_PW", "__SVC_TOKEN__":"R_SVC_TOKEN", "__MODEL_KEY_
        "__SERVER_IMAGE__":"R_SERVER_IMAGE", "__SERVER_PULL_POLICY__":"R_PULL_POLICY",
        "__PKG_SOURCE__":"R_PKG_SOURCE", "__PG_INSTANCES__":"R_PG_INSTANCES",
        "__PG_ANTI_AFFINITY__":"R_PG_AA", "__SERVER_REPLICAS__":"R_REPLICAS",
-       "__REQUIRE_PRINCIPAL__":"R_REQ_PRINCIPAL"}
+       "__REQUIRE_PRINCIPAL__":"R_REQ_PRINCIPAL", "__OPERATOR_SINGLE_USER__":"R_OPERATOR_SINGLE_USER"}
 t = open(sys.argv[1], encoding="utf-8").read()
 for ph, env in MAP.items():
     v = os.environ.get(env)

package/deploy/sema-up/lib/flagshape.sh

@@ -22,6 +22,10 @@ FLAG_WORDS_USERS="single multi"
 # 事实核对,kube-up 的 helm values,cluster-up 的渲染清单与 helm values 同调这一只(修前 kube-up 另写一份同义翻译;
 # cluster-up 一份都没有 ⇒ --users=multi 在 --kube=machines 路径上被静默丢成单用户)。只认两词,别的词先过 flag_enum。
 principal_of_users() { [ "$1" = "multi" ] && echo true || echo false; }
+# 租户形 ⇒ 单用户运维声明 OPERATOR_SINGLE_USER 的值(唯一定义;三只脚本 / 渲染段同调):server 装配运维面时要单用户部署说出谁是运维,
+# 不声明不起服(声明与具名名单 OPERATOR_PRINCIPALS 二选一;本工具渲前者)。single = 这台只有一个人 ⇒ 他就是运维(true);
+# multi = 多租,运维由具名名单另给 ⇒ 不声明(false;多租形上声明本身会被 server 拒)。chart 从 server.requirePrincipal 同一句派生。
+operator_single_user_of_users() { [ "$1" = "multi" ] && echo false || echo true; }
 
 # users_decide <显式给了 USERS 吗(1 / 空)> —— kube 两条装配路径(kube-up / cluster-up)的租户形决策,与 sema-up 的
 # compose 档同一条规则:**决策 = 显式 USERS ∨ 上一次落在 $ENVF 的部署事实 REQUIRE_PRINCIPAL ∨ single**;显式值与事实

package/deploy/sema-up/lib/lanes.json

@@ -5,8 +5,7 @@
       "choice": "host",
       "users": ["single"],
       "env": {
-        "REMOTE_EXEC": "host",
-        "REQUIRE_EXECUTION_LANE": "true"
+        "REMOTE_EXEC": "host"
       },
       "isolation": "unsupported",
       "note": "server 容器本身就是沙箱:agent 的手落在这只容器里(worktree 隔离在、OS 级隔离不在)。只给单用户 —— 多租户下一个租户的输入会把手指向另一个租户的文件与进程。"
@@ -17,7 +16,6 @@
       "users": ["single", "multi"],
       "env": {
         "REMOTE_EXEC": "e2b",
-        "REQUIRE_EXECUTION_LANE": "true",
         "E2B_API_KEY": null
       },
       "isolation": "supported",
@@ -29,12 +27,11 @@
       "users": ["single", "multi"],
       "env": {
         "REMOTE_EXEC": "k8s",
-        "REQUIRE_EXECUTION_LANE": "true",
         "K8S_SANDBOX_IMAGE": null,
         "K8S_NAMESPACE": null
       },
       "isolation": "supported",
-      "note": "kube 路径**不选词**:runtime 由 kube-up.sh 按 runtimeClass `kata-qemu` 在不在自动定(在 ⇒ kata VM,不在 ⇒ runc 容器),沙箱镜像与沙箱命名空间由 chart/清单给。本行只为对表(能力表 / 必需键 / REQUIRE_EXECUTION_LANE 三面),不进 --sandbox 词表。"
+      "note": "kube 路径**不选词**:runtime 由 kube-up.sh 按 runtimeClass `kata-qemu` 在不在自动定(在 ⇒ kata VM,不在 ⇒ runc 容器),沙箱镜像与沙箱命名空间由 chart/清单给。本行只为对表(能力表 / 必需键两面),不进 --sandbox 词表。"
     }
   ],
   "retired": [

package/deploy/sema-up/sema-up.sh

@@ -705,6 +705,9 @@ if [ "$PROFILE" = "full-single" ] || [ "$PROFILE" = "local-plus" ]; then
   setk MODEL_ID "$MODEL"
   [ -n "$MODEL_KEY" ] && setk MODEL_API_KEY "$MODEL_KEY"
   setk REQUIRE_PRINCIPAL "$REQUIRE_PRINCIPAL_WANT"
+  # 单用户运维声明:由租户词派生(lib/flagshape.sh 唯一定义),每次重写 —— 它不是第二个部署事实,是 REQUIRE_PRINCIPAL 那一个事实的另一根键。
+  # 不写 ⇒ 单用户 server 起服拒(没人能当运维);升级路径上旧 .env 没有这一行,resetk 补上。
+  resetk OPERATOR_SINGLE_USER "$(operator_single_user_of_users "$USERS")"
   setk SANDBOX_PKG_SOURCE "$([ "$REGION" = "global" ] && echo global || echo '')"
   [ -n "${SEMA_SERVER_IMAGE:-}" ] && setk SEMA_SERVER_IMAGE "$SEMA_SERVER_IMAGE"
   # 执行车道落 .env(从上面 `lanes resolve` 的结果渲,脚本里零车道词)。
@@ -800,10 +803,11 @@ shq() { printf "'%s'" "$(printf '%s' "$1" | sed "s/'/'\\\\''/g")"; }
 # ── 渲染对账(生成 .env 之后、compose up 之前)──────────────────────────────────
 # .env 的写口 / 读口都按物理行判,认不出 compose dotenv 的跨行引号值等边角;唯一能确知「容器真正拿到
 # 什么」的是 compose 自己。所以在 up 之前跑一次 `compose config`——与 up **同一组 -f / profile / 同一 shell
-# 环境**(于是运维导出的空串等也算进来)——从渲染结果取 agent 服务的 REQUIRE_PRINCIPAL / REMOTE_EXEC /
-# REQUIRE_EXECUTION_LANE,与本次决策逐值对比,不一致 ⇒ 拒并点名渲染值与决策值。**以 compose 为唯一属主**。
+# 环境**(于是运维导出的空串等也算进来)——从渲染结果取 agent 服务的 REQUIRE_PRINCIPAL / REMOTE_EXEC,
+# 与本次决策逐值对比,不一致 ⇒ 拒并点名渲染值与决策值。**以 compose 为唯一属主**。
 # docker 不可达在上面 `command -v docker` 那道已 fail-loud 拦下;config 本身失败(YAML/插值坏)也拒,
-# 不新铸降级臂:未经对账就不 up。只有 agent 面有这三个决策键,别的档跳过。
+# 不新铸降级臂:未经对账就不 up。只有 agent 面有这两个决策键,别的档跳过。
+# (REQUIRE_EXECUTION_LANE 是退役 env —— 设了即起服拒 —— 产物不再渲它,也不再对账它。)
 #
 # 拒因分两种、各给各的出路(7.98.0 曾把 stderr 并进 stdout 当 JSON 解析 ⇒ compose 的任何警告都让它 traceback,
 # 拒因还冒充「不一致」):
@@ -813,7 +817,7 @@ shq() { printf "'%s'" "$(printf '%s' "$1" | sed "s/'/'\\\\''/g")"; }
 # 插值警告里的变量名也可能是凭据的一段)。
 RECON_PY='
 import json, sys
-want = {"REQUIRE_PRINCIPAL": sys.argv[1], "REMOTE_EXEC": sys.argv[2], "REQUIRE_EXECUTION_LANE": sys.argv[3]}
+want = {"REQUIRE_PRINCIPAL": sys.argv[1], "REMOTE_EXEC": sys.argv[2]}
 try:
     d = json.loads(sys.stdin.read())
     env = d["services"]["server"].get("environment") or {}
@@ -833,8 +837,7 @@ if bad:
 '
 reconcile_render() {
   case ",$COMPOSE_PROFILES," in *,agent,*) : ;; *) return 0 ;; esac
-  local exp_rp="$REQUIRE_PRINCIPAL_WANT" exp_re="$LANE_REMOTE_EXEC" exp_rl rendered errf nerr rc=0 prc=0 repro a
-  exp_rl="$(printf '%s\n' "$LANE_ENV" | sed -n 's/^REQUIRE_EXECUTION_LANE=//p')"
+  local exp_rp="$REQUIRE_PRINCIPAL_WANT" exp_re="$LANE_REMOTE_EXEC" rendered errf nerr rc=0 prc=0 repro a
   # 复现命令:与这次 config 同一个 compose 入口、同一张全局参数表、同一组 profile(从源渲,不手抄)。
   dc_argv; compose_globals
   repro="(cd $(shq "$HERE/stack") && COMPOSE_PROFILES=$(shq "$COMPOSE_PROFILES") ${DC_ARGV[*]}"
@@ -848,12 +851,12 @@ reconcile_render() {
     log "   ↳ 下一步:在本机亲跑 $repro 看 compose 的报文(本脚本不转印它:.env 解析失败的报文会原样引用那一行,可能带凭据);常见成因是手改过的 .env 行"
     exit 1
   fi
-  printf '%s' "$rendered" | python3 -c "$RECON_PY" "$exp_rp" "$exp_re" "$exp_rl" || prc=$?
+  printf '%s' "$rendered" | python3 -c "$RECON_PY" "$exp_rp" "$exp_re" || prc=$?
   case "$prc" in
     0) : ;;
     3)
       log "⛔ 渲染对账:渲染值与决策值不一致 —— compose 渲染出的容器决策值与本次决策对不上;以 compose 为唯一属主,拒绝 up"
-      log "   ↳ 下一步:检查 $ENVF 里 REQUIRE_PRINCIPAL / REMOTE_EXEC / REQUIRE_EXECUTION_LANE,以及 shell / -f 里是否**导出**了同名变量(compose 插值 shell 优先于 --env-file,导出为空会盖掉 .env);亲跑 $repro 可看容器 environment"
+      log "   ↳ 下一步:检查 $ENVF 里 REQUIRE_PRINCIPAL / REMOTE_EXEC,以及 shell / -f 里是否**导出**了同名变量(compose 插值 shell 优先于 --env-file,导出为空会盖掉 .env);亲跑 $repro 可看容器 environment"
       exit 1 ;;
     4)
       log "⛔ 渲染对账:渲染结果解析失败 —— docker compose config 退出 0,但 stdout 不是可解析的 compose JSON(或其中没有 server 服务;compose 另在 stderr 输出了 $nerr 行,本脚本不转印),无法确认容器会拿到什么 —— 拒绝在未对账的情况下 up"
@@ -864,7 +867,7 @@ reconcile_render() {
       log "   ↳ 下一步:确认本机 python3 可用(python3 -c 'import json'),然后重跑"
       exit 1 ;;
   esac
-  log "渲染对账通过:REQUIRE_PRINCIPAL=$exp_rp REMOTE_EXEC=$exp_re REQUIRE_EXECUTION_LANE=$exp_rl(compose 渲染逐值一致)$([ "$nerr" -gt 0 ] && printf ';compose 另在 stderr 输出了 %s 行(多为插值警告;本脚本不转印,up 时 compose 会自己打出来)' "$nerr")"
+  log "渲染对账通过:REQUIRE_PRINCIPAL=$exp_rp REMOTE_EXEC=$exp_re(compose 渲染逐值一致)$([ "$nerr" -gt 0 ] && printf ';compose 另在 stderr 输出了 %s 行(多为插值警告;本脚本不转印,up 时 compose 会自己打出来)' "$nerr")"
 }
 
 # ── 外接端点连接检测(装配前 fail-loud;只验兼容可用,不校验证书——内网自签是常态)────────────

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

@@ -93,14 +93,15 @@ services:
       MODEL_ID: ${MODEL_ID:-}
       MODEL_API_KEY: ${MODEL_API_KEY:-}
       REQUIRE_PRINCIPAL: ${REQUIRE_PRINCIPAL:-false}
+      # 单用户运维声明(sema-up 由 --users 渲进 .env:single ⇒ true,multi ⇒ false)。刻意不给缺省:手工起这份 compose 而 .env 里没有它的
+      # 单用户部署,server 起服拒并给出那一行(不在模板里替运维表态「人人是运维」)。
+      OPERATOR_SINGLE_USER: ${OPERATOR_SINGLE_USER:-}
       SANDBOX_PKG_SOURCE: ${SANDBOX_PKG_SOURCE:-}
       # 执行车道:值由 sema-up.sh 从 lib/lanes.json 渲进 .env(resetk,每次重写)。
-      # `REQUIRE_EXECUTION_LANE` 缺省 true —— 手工起这份 compose 而没点名车道时,server 拒启
-      # 并说「没有手」,而不是安静地起成一个什么都干不了的 worker。
-      # 下面圈起来的几行(车道键、缺省、compose 路径上各车道运维自备的键)由车道表生成,不要手改。
+      # 不再渲 `REQUIRE_EXECUTION_LANE`:它是退役 env(设了即起服拒,拒句指向 REMOTE_EXEC);车道只由 REMOTE_EXEC 点名。
+      # 下面圈起来的几行(车道键、compose 路径上各车道运维自备的键)由车道表生成,不要手改。
       # @generated-begin lane-env
       REMOTE_EXEC: ${REMOTE_EXEC:-}
-      REQUIRE_EXECUTION_LANE: ${REQUIRE_EXECUTION_LANE:-true}
       E2B_API_KEY: ${E2B_API_KEY:-}
       # @generated-end lane-env
     ports:

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

@@ -1,5 +1,5 @@
 # sema-stack(full-cluster 形态,Phase 1b as-built;cluster-up.sh 渲染 __占位符__ 后 apply)
-# 占位符:__MINIO_PW__ __SVC_TOKEN__ __MODEL_KEY__ __MODEL_GATEWAY__ __MODEL_ID__ __REQUIRE_PRINCIPAL__
+# 占位符:__MINIO_PW__ __SVC_TOKEN__ __MODEL_KEY__ __MODEL_GATEWAY__ __MODEL_ID__ __REQUIRE_PRINCIPAL__ __OPERATOR_SINGLE_USER__
 #         __SERVER_IMAGE__ __SERVER_PULL_POLICY__(tar 预灌=Never / registry 拉取=IfNotPresent)
 # 前置(cluster-up.sh 负责):Longhorn 默认 SC、kata-deploy(runtimeclass kata-qemu)、CNPG operator 1.30、
 #         runner token 跨 ns 复制成 sema/sema-runner-token-copy、MinIO 建桶 sema-pg-backup
@@ -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
@@ -203,11 +219,12 @@ spec:
             - { name: MODEL_VISION, value: "false" }
             # 租户姿态与 chart 主 worker 同值(cluster-up 由 --users 渲:multi ⇒ true,否则 false);修前整块缺席 ⇒ 恒单用户
             - { name: REQUIRE_PRINCIPAL, value: "__REQUIRE_PRINCIPAL__" }
+            # 单用户运维声明与租户姿态同一次翻译(cluster-up 由 --users 渲:single ⇒ true,multi ⇒ false);缺了它单用户 server 起服拒
+            - { name: OPERATOR_SINGLE_USER, value: "__OPERATOR_SINGLE_USER__" }
             - { name: SANDBOX_PKG_SOURCE, value: "__PKG_SOURCE__" }
-            # 显式表态「这台有手」(车道被改没了 ⇒ 拒启,不是安静的无手 worker);下面圈起来的两行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改
+            # 车道显式点名(REMOTE_EXEC;REQUIRE_EXECUTION_LANE 是退役 env,设了即起服拒,不再渲);下面圈起来的一行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改
             # @generated-begin kube-lane-env
             - { name: REMOTE_EXEC, value: "k8s" }
-            - { name: REQUIRE_EXECUTION_LANE, value: "true" }
             # @generated-end kube-lane-env
             - { name: K8S_API_URL, value: "https://kubernetes.default.svc" }
             - { name: K8S_INSECURE_TLS, value: "true" }

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(正控 / 缺席 / 空串三臂)。
  */