@sema-agent/server 7.146.0 → 7.147.0

package/deploy/facts/lanes.json

@@ -49,6 +49,13 @@
       "isolation": "unsupported",
       "requiredEnv": ["DEVICE_RELAY_URL"],
       "requiredSecretEnv": []
+    },
+    {
+      "lane": "none",
+      "tenantSeparation": "supported",
+      "isolation": "unsupported",
+      "requiredEnv": [],
+      "requiredSecretEnv": []
     }
   ]
 }

package/deploy/sema-up/README.md

@@ -51,7 +51,7 @@ summary 会打印手动接法。
 | flag | 默认 | 说明 |
 |---|---|---|
 | `--profile=P` | 交互问 | `full-single`/`data-center`/`local-plus`/`full-cluster` |
-| `--users=U` | `single` | `single`(超管 turnkey)/`multi`(身份隔离 REQUIRE_PRINCIPAL=true) |
+| `--users=U` | `single` | `single`(超管 turnkey;落 `OPERATOR_SINGLE_USER=true` = 每个调用方都是运维,server 单用户形起服要这一行)/`multi`(身份隔离 REQUIRE_PRINCIPAL=true;`OPERATOR_SINGLE_USER=false`)。两根键由同一个租户词派生,重跑即按租户词重写;具名运维名单(`OPERATOR_PRINCIPALS`)本脚本不渲 |
 | `--region=R` | `auto` | `cn`/`global`;auto=对 aliyun/npmjs 探测延迟 |
 | `--project=NAME` | `sema` | compose project 名;并行试验/多套共存用。也是工作目录 `~/.sema-up/<名>` 与自动数据根 `<盘>/sema-data/<名>` 的一段 ⇒ 只收小写字母 / 数字 / `-` / `_`,首字符是字母或数字(别的写法在建任何目录之前拒) |
 | `--dry-run` | — | 只打印执行计划,不写 .env、不起容器 |
@@ -87,7 +87,7 @@ summary 会打印手动接法。
 
 - **`host`**(compose 路径) — 可选 `--users`:`single`;落盘 `REMOTE_EXEC=host`;运维自备的键:无;隔离:`unsupported`。server 容器本身就是沙箱:agent 的手落在这只容器里(worktree 隔离在、OS 级隔离不在)。只给单用户 —— 多租户下一个租户的输入会把手指向另一个租户的文件与进程。
 - **`e2b-cloud`**(compose 路径) — 可选 `--users`:`single` / `multi`;落盘 `REMOTE_EXEC=e2b`;运维自备的键:`E2B_API_KEY`;隔离:`supported`。E2B 云沙箱:每任务一只 microVM。E2B_API_KEY 由运维自备(sema-up 只登记键名,绝不写值)。
-- **kube 路径(不选词)** — 可选 `--users`:`single` / `multi`;落盘 `REMOTE_EXEC=k8s`;运维自备的键:`K8S_SANDBOX_IMAGE`、`K8S_NAMESPACE`;隔离:`supported`。kube 路径**不选词**:runtime 由 kube-up.sh 按 runtimeClass `kata-qemu` 在不在自动定(在 ⇒ kata VM,不在 ⇒ runc 容器),沙箱镜像与沙箱命名空间由 chart/清单给。本行只为对表(能力表 / 必需键 / REQUIRE_EXECUTION_LANE 三面),不进 --sandbox 词表。
+- **kube 路径(不选词)** — 可选 `--users`:`single` / `multi`;落盘 `REMOTE_EXEC=k8s`;运维自备的键:`K8S_SANDBOX_IMAGE`、`K8S_NAMESPACE`;隔离:`supported`。kube 路径**不选词**:runtime 由 kube-up.sh 按 runtimeClass `kata-qemu` 在不在自动定(在 ⇒ kata VM,不在 ⇒ runc 容器),沙箱镜像与沙箱命名空间由 chart/清单给。本行只为对表(能力表 / 必需键两面),不进 --sandbox 词表。
 
 已退役的词(收到即非零退出并指路):
 

package/deploy/sema-up/chart/templates/_helpers.tpl

@@ -104,6 +104,28 @@ false
 {{- end -}}
 {{- end -}}
 
+{{- /*
+  单用户运维声明(env OPERATOR_SINGLE_USER)渲给 worker 的值 = 租户姿态 `server.requirePrincipal` 的否定(同一个值派生,不另开 values 键):
+  单用户 ⇒ "true"(这台的调用方就是运维;server 装配运维面时要单用户部署说出谁是运维,缺了起服拒);多租 ⇒ "false"(运维由具名名单另给)。
+  `server.requirePrincipal` 只认 "true" / "false"(布尔与字符串写法同义,大小写不论;缺省 / null = "false");其它词渲染即拒 —— server 读
+  REQUIRE_PRINCIPAL 用的是更宽的布尔词表,图表若按「不是 true 就是单用户」读,"yes" / "1" / "on" 在 server 读成多租、在这里读成单用户 ⇒
+  两根键互斥、起服拒;抄一份那张词表又是第二份真源。两只 worker 都调这一只。
+*/ -}}
+{{- define "sema.operatorSingleUser" -}}
+{{- $raw := .Values.server.requirePrincipal -}}
+{{- $rp := "" -}}
+{{- if not (kindIs "invalid" $raw) -}}
+{{- $rp = lower (trim (toString $raw)) -}}
+{{- end -}}
+{{- if eq $rp "" -}}
+{{- $rp = "false" -}}
+{{- end -}}
+{{- if not (has $rp (list "true" "false")) -}}
+{{- fail (printf "server.requirePrincipal must be \"true\" or \"false\", got %q — the chart derives OPERATOR_SINGLE_USER from it, and any other word would be read one way here and another way by the server" $rp) -}}
+{{- end -}}
+{{- ternary "false" "true" (eq $rp "true") -}}
+{{- end -}}
+
 {{- /* worker 容器 env 里的耐久审批一条(`nindent 12` 之后接在 env 列表里);值为空 ⇒ 什么都不出。 */ -}}
 {{- define "sema.sealedKey.env" -}}
 {{- with (include "sema.durableApproval" .) -}}

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 }}

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 }}

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" ⇒ 渲染即拒。

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
@@ -219,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/approval-card.d.ts

@@ -574,13 +574,13 @@ export declare const ApprovalCardSchema: z.ZodObject<{
     governanceForced: z.ZodOptional<z.ZodLiteral<true>>;
     rememberRefused: z.ZodOptional<z.ZodLiteral<true>>;
     approvalCard: z.ZodOptional<z.ZodEnum<{
-        question: "question";
+        shell: "shell";
         plan: "plan";
         skill: "skill";
+        question: "question";
         "file-edit": "file-edit";
         "file-write": "file-write";
         "notebook-edit": "notebook-edit";
-        shell: "shell";
         fetch: "fetch";
         workflow: "workflow";
         generic: "generic";
@@ -752,13 +752,13 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
         governanceForced: z.ZodOptional<z.ZodLiteral<true>>;
         rememberRefused: z.ZodOptional<z.ZodLiteral<true>>;
         approvalCard: z.ZodOptional<z.ZodEnum<{
-            question: "question";
+            shell: "shell";
             plan: "plan";
             skill: "skill";
+            question: "question";
             "file-edit": "file-edit";
             "file-write": "file-write";
             "notebook-edit": "notebook-edit";
-            shell: "shell";
             fetch: "fetch";
             workflow: "workflow";
             generic: "generic";

package/dist/approval.d.ts

@@ -76,12 +76,12 @@ export declare function gateIntentUnserviceableReason(config: GateIntentView, ch
  * 运维要在 **boot** 就知道,否则会把随之而来的拒绝读成故障。两条 warn 按「ask 从哪来」**划分车道**,互补不重叠:
  *  · `fs_write_gate_no_responder` —— 写门的 Write/Edit ask。它只在**手写本机盘**时才会发生(写门挂在 host
  *    语义上,而 ask 要有手去触发)⇒ 判据 = {@link handsOnWorkerFilePlane}(今天 = `host`)。改前写的是
- *    `remoteExec === undefined || provider === "host"`(门 D R3 同义折):把没有手的 in-process 也算进来,
+ *    `remoteExec === undefined || provider === "host"`(门 D R3 同义折):把没有手的那一形(今名 `none`)也算进来,
  *    那一形上一次 Write ask 都不会发生,warn 是假话;
  *  · `workflow_gate_no_responder` —— `run_workflow` 的 ask,**每条车道都挂**(不以挂手为前提,见
  *    `createWorkflowAskPolicy`)⇒ 判据 = 自编排开着 ∧ **不在上一条的射程里**(上一条的文案已覆盖本机手的车道)。
- *    改前写的是 `remoteExec !== undefined && provider !== "host"` —— 依赖上一条对 in-process 的兜底;
- *    上一条收窄之后,in-process ∧ 自编排 ∧ 无应答面必须由这一条接住(否则整形零告警)。
+ *    改前写的是 `remoteExec !== undefined && provider !== "host"` —— 依赖上一条对无手形的兜底;
+ *    上一条收窄之后,`none` ∧ 自编排 ∧ 无应答面必须由这一条接住(否则整形零告警)。
  */
 export declare function buildNoResponderBootWarns(input: {
     /** 本部署的执行车道(归一读口 `executionLaneOf` 的答案)。 */

package/dist/audit.js

@@ -1,6 +1,6 @@
 import { StoredSession } from "@sema-agent/core";
-import { TiDBSessionStorage } from "./plugins/tidb-session-storage.js";
-import { PgSessionStorage } from "./plugins/pg-session-storage.js";
+import { TiDBSessionStorage } from "./stores-sql/tidb-session-storage.js";
+import { PgSessionStorage } from "./stores-sql/pg-session-storage.js";
 import { LocalSessionWindow } from "./plugins/local-session-window.js";
 import { redactModelText } from "./observability/run-terminal.js";
 import { redactDeepWith } from "./trace/redact.js";

package/dist/bench/s1/live-deps.js

@@ -1,6 +1,8 @@
 import { outwardPlane } from "../../terminal.js";
 import { Runner, runWithVerification, resumeWithVerification, runRepairLoop, combinePolicies, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, } from "@sema-agent/core";
 import { loadConfig } from "../../config.js";
+import { composeDeclaredExecutionLane } from "../../boot/execution-lane.js";
+import { ALL_EXECUTION_LANES } from "../../execution-lane-caps.js";
 import { assertServedModelRoute } from "../../model-route-endpoint.js";
 import { withUnattendedLeg } from "../../unattended-permission-mode.js";
 import { createBrain } from "../../brain.js";
@@ -51,7 +53,7 @@ function buildBrainIngredients(rt) {
         process.env.MODEL_COST_CACHE_READ = String(rt.costCacheRead);
     if (rt.costCacheWrite != null)
         process.env.MODEL_COST_CACHE_WRITE = String(rt.costCacheWrite);
-    const config = loadConfig();
+    const config = composeDeclaredExecutionLane(loadConfig(), { info: () => { } }, { name: "the s1 bench", runs: ALL_EXECUTION_LANES, declares: "none" });
     assertServedModelRoute(config, { envTableIsPlaceholder: false });
     const brain = createBrain(config, {});
     const pricing = buildPricing(config.models);

package/dist/boot/crash-last.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { redactSecrets } from "../trace/redact.js";
+import { OWNER_ONLY_FILE_MODE } from "../plugins/owner-only-file-mode.js";
 const CrashLastSchema = z.object({
     at: z.string(),
     version: z.string(),
@@ -25,7 +26,7 @@ export function writeCrashLast(dataRoot, info) {
             ...(info.inflight !== undefined ? { inflight: info.inflight } : {}),
             err: redactSecrets(firstLine),
         };
-        writeFileSync(crashLastPath(dataRoot), JSON.stringify(body) + "\n");
+        writeFileSync(crashLastPath(dataRoot), JSON.stringify(body) + "\n", { mode: OWNER_ONLY_FILE_MODE });
     }
     catch {
     }

package/dist/boot/device-lane.js

@@ -10,7 +10,7 @@ export function createDeviceLane(ctx) {
         throw new Error("device lane: the device store is wired but the session store carries no execution placement seat — the session↔device binding lives on the " +
             "root session row and is read only through that seat; refusing to start a device lane that could neither bind nor read a binding (assembly bug)");
     }
-    const knobs = config.remoteExec?.provider === "device" ? config.remoteExec : undefined;
+    const knobs = config.remoteExec.provider === "device" ? config.remoteExec : undefined;
     const enrollment = createDeviceEnrollment({
         store,
         seat,
@@ -48,14 +48,14 @@ export function assertDeviceLaneWired(isDeviceLane, lane, hasFactory) {
     if (!lane) {
         throw new Error("REMOTE_EXEC=device but the device lane could not be wired at boot [device-lane-unwired]: the SQL backend is " +
             "configured yet this replica did not get one, so the device registry / session↔device binding / audit tables are absent. " +
-            "Refusing to serve a lane that would silently fall back to the in-process stub env — a worker claiming to " +
+            "Refusing to serve a lane that would silently fall back to the engine's stub env with no hands mounted — a worker claiming to " +
             "execute on the employee's device while actually running inside its own process (#157). Fix the database " +
-            "(or unset REMOTE_EXEC) and restart (device-executor-lane-v2 §4.7)");
+            "(or declare another lane, e.g. REMOTE_EXEC=none) and restart (device-executor-lane-v2 §4.7)");
     }
     if (!hasFactory) {
         throw new Error("REMOTE_EXEC=device but no DeviceExecutionEnv factory was built [device-lane-unwired]: the lane's stores are up " +
-            "yet `boot/execution-env.ts` produced no factory, so core would fall back to the in-process stub env. This is " +
-            "an assembly bug, not a configuration one — refusing to start rather than silently execute in-process (#157)");
+            "yet `boot/execution-env.ts` produced no factory, so core would fall back to its stub env with no hands mounted. This is " +
+            "an assembly bug, not a configuration one — refusing to start rather than silently run with no execution environment (#157)");
     }
 }
 export async function noteDeviceRelayBindings(relay, store, logger) {

package/dist/boot/engine-lease.d.ts

@@ -28,8 +28,8 @@
  *     `ENGINE_AUTO_EXIT` / `SEMA_PARENT_PID` 的表态上。
  *  2. **自退判据 = 三合取,且必须持续满 `linger`**(`linger` = 孤儿态 `orphan.lingerMs`,否则 `lingerMs`):
  *       · 附着租约集空(`attachedStreams() === 0`);
- *       · 无必须等完的活(`inflight() === 0` —— 读 `drainState.blockingInflight` = **阻断集** `http + leader`,与排空等的、SIGHUP 空闲窗**同一只**,不另立第二判据;
- *         `/health.inflight` 是它再加会话驻留的后台 shell / monitor 的**总数**:同一份分项 `/health.inflightBreakdown` 派生的两个事实,不是两套计数,见下「已知收窄」);
+ *       · 无必须等完的活(`inflight() === 0` —— 读 `drainState.blockingInflight` = **阻断集** `http + leader + backgroundAgents`,与排空等的、SIGHUP 空闲窗**同一只**,不另立第二判据;
+ *         `/health.inflight` 是它再加会话驻留的后台 shell / monitor 的**总数**:同一只分项函数 `/health.inflightBreakdown` 派生的两个事实,不是两套计数,见下「已知收窄」);
  *       · HTTP 触点静默(`now() - lastActivityAt() >= lingerMs`),**且**最后一条附着流的**离场**
  *         也已满窗(`now() - lastAttachEndedAt() >= lingerMs` —— codex R1-F1,见该 dep 的注)。
  *     任何一条不满足即把计时清零(连续性判据,不是累计)。
@@ -67,17 +67,18 @@
  *    每 15s 无限期跑下去的定时器 —— 为它引入周期性 SQL 轮询,代价压过收益。**bg run 在跑不退**那一臂
  *    已由 `inflight()` 结构性守住;parked 行是 durable 的,引擎退掉不丢:下次起来仍可赎回(spawn 形里
  *    「下次」就是壳的下一次 spawn)。伤害面 = 一条 parked run 的赎回被推迟到下次启动,不是丢失。
- *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。
- *  · **会话驻留的后台 shell / monitor 与活过父 run 的后台子代理都不入判据**(两件事实不同,同一条判据)。
- *    阻断集 `http + leader` 是「还有没有**必须等完**的活」:HTTP 腿(在飞 run 集 · 同步计费腿 · admission 期请求)与 leader 腿。
+ *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。停驻的后台子代理(任务表 `parked`)同一条律、同样不计。
+ *  · **会话驻留的后台 shell / monitor 不入判据**。阻断集 `http + leader + backgroundAgents` 是「还有没有**必须等完**的活」:HTTP 腿(在飞 run 集 · 同步计费腿 ·
+ *    admission 期请求)、leader 腿,以及活过起它的那条 HTTP 腿、仍在跑的后台子代理(core `backgroundScope:"session"`;它是一条在干活的模型腿,干完自己收尾,不等它 = 受控退把它中断)。
  *    会话驻留的后台 shell / monitor(`session-resident-background.ts` 读;running ∧ 会话驻留 ∧ 非 retain)**报**在 `/health.inflight`(总数)与
  *    `inflightBreakdown.sessionResident` 里 —— 外部判官据此判「这台引擎此刻托管着多少活」—— 但**不阻断**自退:它不是一条腿,等它没有意义,而一只不退出的 shell
  *    (`while true`)若阻断,崩溃孤儿引擎就永生(孤儿窗 / SIGHUP 空闲窗同读阻断集,排空也每次等满窗)。窗到 / 排空完成,退出边界的后台收割
  *    (`reapAllSessionBackground` + 硬面,`boot/exit-boundary.ts`)收掉它们;retain 行按 retain 既有语义活过受控退。伤害面 = 壳没了且没人附着时,引擎照退、
- *    驻留的进程随受控退被收掉(与 7.145.x 逐字同,**本件不改这一行为**,只把它报出来)。
- *    后台**子代理**(agent 行)同样不入(codex R1 [high] 验真后如实登记,不是本件引入:[ref] 之前父死走的是**当场** drain,而 `drainThenShutdown` 读的是同一只 `inflight()` ⇒ 同一个缺口):
- *    core 侧 `backgroundScope:"session"` 的子代理可以**活过**生它的那条 HTTP 腿,那之后它在本腿眼里是 0;伤害面 = 一条还在跑的后台子代理会随引擎的受控退被中断(它的账本行照常落终态,不是静默丢)。
- *    这条收窄**成文在此**,不许再被读成「bg 全被守住」。
+ *    驻留的进程随受控退被收掉(与 7.145.x 逐字同,只把它报出来)。
+ *  · **活过起它的腿的 workflow 不入判据**:任务表对它只投 `running`,一条腿停在审批门上等人时也是 `running`,读法分不出「在干活」与「在等人」;
+ *    等人的活若阻断,一张没人答的审批就让崩溃孤儿引擎永生(同上一条的病)。伤害面 = 壳没了且没人附着时,一条还在干活的 workflow 随受控退被收掉
+ *    (与 7.146.x 同)。停驻位由 core 任务表投出后按停驻律分(见 `session-resident-background.ts` 头注)。
+ *    (修前后台子代理也在这一条里:它们活过生它的 HTTP 腿之后在本腿眼里是 0,受控退把还在跑的子代理中断 —— 7.147.0 起收进阻断集,这条收窄只剩上面两类。)
  *  · **`/health` 探针不算触点**:`lastActivityAt` 的属主(`http/server.ts` 的 `noteActivity`)按既有契约
  *    把 `/health` 与 `/metrics*` 排除在活性时钟之外(常态采样噪音不得把空闲窗永远撑开)。⇒ 一只**只**
  *    轮询 `/health` 的壳不构成租约。这与 SIGHUP 空闲窗的判据同源,刻意保持一致而非在本腿另开一份。
@@ -278,7 +279,7 @@ export interface EngineLeaseFirstAttachFacts {
  * [ref] —— 交接格(`GET /health` 的 `engineLease.handover`;交接口 200 体 = 其中 `since` / `lingerMs` / `backgroundShells` 三键加 `lane`)。
  *  · `since` = 进入交接车道的时刻(epoch ms,与首窗格同一只单调钟投影);幂等的再次交接回同一个值。
  *  · `lingerMs` = 交接窗;`backgroundShells` = 退出边界此刻会硬收的后台 shell 行数(现读)。窗只在它为 0、阻断集在飞为 0、且无附着与触点时起算。
- *  · 不带在飞数:阻断集在同一份 `/health` 里已由 `inflightBreakdown.http + leader` 读出(一个事实一处读);交接口 200 体若带它,读到的恒含这次请求自己。
+ *  · 不带在飞数:阻断集在同一份 `/health` 里已由 `inflightBreakdown.http + leader + backgroundAgents` 读出(一个事实一处读);交接口 200 体若带它,读到的恒含这次请求自己。
  */
 export interface EngineHandoverFacts {
     readonly since: number;
@@ -321,7 +322,7 @@ export interface EngineLeaseHandle {
 export interface EngineLeaseDeps {
     /** 活附着数 = 本副本当前**打开着的 SSE 流**条数(`drainState.attachedStreams`,由 `createHttpServer` 自赋)。 */
     attachedStreams: () => number;
-    /** 必须等完的活的数 —— **阻断集** `drainState.blockingInflight`(`http + leader`;与排空等的、SIGHUP 空闲窗同一只 getter。会话驻留的后台 shell / monitor 在
+    /** 必须等完的活的数 —— **阻断集** `drainState.blockingInflight`(`http + leader + backgroundAgents`;与排空等的、SIGHUP 空闲窗同一只 getter。会话驻留的后台 shell / monitor 在
      *  `/health.inflight` 的总数里、不在这里,见顶注「已知收窄」)。不自建第二套计数:两套计数迟早分叉,而分叉的那一侧恰好是「以为没 run 了」就把引擎关掉。 */
     inflight: () => number;
     /** 最后一次**非探针** HTTP 触点的单调时刻(`drainState.lastActivityAt`)。

package/dist/boot/execution-env.d.ts

@@ -20,6 +20,7 @@ import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { TaskInheritEnv } from "../request-value-closure.js";
 import { type HeadRead } from "../session-incarnation.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
+import { type SessionResidentCounts } from "../session-resident-background.js";
 /**
  * per-session 的 **cwd / shellEnv 登记簿**(TOC cwd seam + R-survey shellEnv seam)+ 它们的**租户围栏**。
  *
@@ -174,7 +175,7 @@ export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     setSessionInheritEnv: (sid: string, policy: TaskInheritEnv | undefined) => void;
     fenceSessionOwner: (sid: string, owner: string | null) => void;
     dropSessionScoped: (sid: string) => void;
-    sessionResidentBackground: () => number;
+    sessionResidentBackground: () => SessionResidentCounts;
     executionEnvFactory: import("@sema-agent/core").ExecutionEnvFactory | undefined;
     worktreeReap: (() => Promise<void>) | undefined;
     sendUserFileTaskEnvs: TaskEnvRegistry | undefined;