@sema-agent/server 7.149.0 → 7.151.0

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

@@ -113,25 +113,24 @@ false
 {{- 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 都调这一只。
+  单用户运维声明(env OPERATOR_SINGLE_USER)渲给 worker 的值 = 部署写的显式键 `server.operatorSingleUser`(只收布尔),原样渲:`true` / `false` 逐字,不设 ⇒ 交回空(调用处不出这一行)。
+  **图表不替部署派生它**:「谁是运维」是部署的声明;从租户词 `server.requirePrincipal` 推出它(修前:未开 ⇒ `"true"`)会让忘设 `requirePrincipal` 的团队集群升级之后每个调用方都成运维 ——
+  服务端拒句里「不止一个人调用 ⇒ 设 REQUIRE_PRINCIPAL」那一道人判,对用模板的人永远不出现。两键都没设 ⇒ 渲染即拒(句子照服务端拒句的两条出路:单人 ⇒ operatorSingleUser;多人 ⇒ requirePrincipal),不静默二选一。
+  `requirePrincipal` 在这里只读「设没设」(nil 或空串 = 没设),不读它的值、不抄服务端的布尔词表(两条规则读同一个词表是第二份真源);单人声明与多租的互斥由服务端起服拒(唯一的判官)。
+  非布尔 ⇒ 渲染即拒:字符串 "false" 在模板里恒为真,会静默声明人人运维。两只 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) -}}
+{{- $raw := .Values.server.operatorSingleUser -}}
+{{- $rp := .Values.server.requirePrincipal -}}
+{{- if kindIs "invalid" $raw -}}
+{{- if or (kindIs "invalid" $rp) (eq (toString $rp) "") -}}
+{{- fail "neither server.operatorSingleUser nor server.requirePrincipal is set — the chart does not derive the operator declaration from the tenancy setting (a team cluster that forgot requirePrincipal would silently make every caller an operator). Declare it in one line: a deployment used by one person: set server.operatorSingleUser=true (every caller of this deployment is its operator); a deployment called by more than one person is multi-tenant: set server.requirePrincipal=true instead (its operators are then named in OPERATOR_PRINCIPALS); a deployment that names its operators in OPERATOR_PRINCIPALS through its own env (this chart does not render that list) states so with server.operatorSingleUser=false" -}}
+{{- end -}}
+{{- else if kindIs "bool" $raw -}}
+{{- $raw -}}
+{{- else -}}
+{{- fail (printf "server.operatorSingleUser must be a boolean (true or false) or unset, got %s %q — a string such as \"false\" is truthy in a template and would silently declare every caller an operator" (kindOf $raw) (toString $raw)) -}}
 {{- end -}}
-{{- ternary "false" "true" (eq $rp "true") -}}
 {{- end -}}
 
 {{- /*

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

@@ -61,9 +61,11 @@ 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 }} }
+            {{/* 单用户运维声明 = 部署写的显式键 server.operatorSingleUser(只收布尔),原样渲;不设 ⇒ 不出这一行。图表不从租户词派生它;
+                 两键(operatorSingleUser / requirePrincipal)都没设 ⇒ 渲染即拒。判与句子见 _helpers.tpl 的 sema.operatorSingleUser。 */}}
+{{- with (include "sema.operatorSingleUser" .) }}
+            - { name: OPERATOR_SINGLE_USER, value: {{ . | quote }} }
+{{- end }}
             - { name: SANDBOX_PKG_SOURCE, value: {{ .Values.server.sandboxPkgSource | quote }} }
             {{/* 车道显式点名(REMOTE_EXEC)。REQUIRE_EXECUTION_LANE 是退役 env(设了即起服拒,拒句指向 REMOTE_EXEC),不再渲。
                  下面圈起来的一行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}

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

@@ -72,9 +72,11 @@ 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 }} }
+            {{/* 单用户运维声明 = 部署写的显式键 server.operatorSingleUser(只收布尔),原样渲;不设 ⇒ 不出这一行。图表不从租户词派生它;
+                 两键(operatorSingleUser / requirePrincipal)都没设 ⇒ 渲染即拒。判与句子见 _helpers.tpl 的 sema.operatorSingleUser。 */}}
+{{- with (include "sema.operatorSingleUser" .) }}
+            - { name: OPERATOR_SINGLE_USER, value: {{ . | quote }} }
+{{- end }}
             - { name: SANDBOX_PKG_SOURCE, value: {{ .Values.server.sandboxPkgSource | quote }} }
             {{/* 车道显式点名(REMOTE_EXEC)。REQUIRE_EXECUTION_LANE 是退役 env(设了即起服拒,拒句指向 REMOTE_EXEC),不再渲。
                  下面圈起来的一行取自车道表(lanes.json 的 kube 行),由生成器渲出,不要手改。 */}}

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

@@ -1,7 +1,9 @@
 # full-single(单节点 k3s dev/测试)覆盖:1 实例 PG、preferred 反亲和(required 在单机=永久
 # Pending——真踩)、2 副本 server(钥匙卷 RWO,见文末)。用法:
 #   helm upgrade --install sema-stack ./chart -n sema --create-namespace \
-#     -f chart/values-full-single.yaml --set server.image=… --set …(凭据)
+#     -f chart/values-full-single.yaml --set server.image=… --set …(凭据) --set server.operatorSingleUser=true
+# 末尾那一键是运维声明:单节点不等于单用户,本覆盖文件不替你写。只给一个人用 ⇒ server.operatorSingleUser=true;被不止一个人调用 ⇒ 改成 --set server.requirePrincipal=true;
+# 两键都不写渲染即拒(见 values.yaml 的 server 块)。
 pg:
   instances: 1
   antiAffinity: preferred

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

@@ -48,7 +48,14 @@ server:
   modelId: ""              # REQUIRED
   modelApiKey: ""          # REQUIRED
   modelVision: "false"
-  requirePrincipal: "false"   # users=multi 时 true(身份隔离;compose 路径同名 env)。只认 "true" / "false";单用户运维声明 OPERATOR_SINGLE_USER 由它派生(false ⇒ "true")
+  # 两把「谁是运维」的键 —— 部署自己写,图表不替部署派生、不给缺省:**两把都没设 ⇒ 渲染即拒**(一句话说清两条出路,不静默二选一)。
+  #   operatorSingleUser(布尔 true / false;不设 ⇒ 不渲)= 单人部署:这台的每个调用方都是运维(env OPERATOR_SINGLE_USER);只给一个人用的部署写 true。
+  #   requirePrincipal(env REQUIRE_PRINCIPAL;不设 ⇒ 渲服务端缺省 "false")= 多人部署:身份隔离,运维由具名名单另给(env OPERATOR_PRINCIPALS,本图表不渲);
+  #     被不止一个人调用的部署写 true(compose 路径同名 env)。值原样递给服务端读,图表不判词。
+  #   只有 operatorSingleUser=true 与 requirePrincipal=true 同写才互斥,由服务端起服拒,图表不抄那一判。operatorSingleUser=false 逐字渲(服务端读 false 与缺席同判):
+  #     给自己 env 补了具名运维名单 OPERATOR_PRINCIPALS 的部署用它表态「我不声明单人」。kube-up / cluster-up 按 --users 把 operatorSingleUser 写进 values。
+  operatorSingleUser: null
+  requirePrincipal: null
   # 耐久审批(env DURABLE_APPROVAL;停驻 / 续跑 / /v1/approvals 整条路由)。留空 = 图表不渲这个 env,开关归引擎按姿态定
   # (单用户 + 有耐久店 ⇒ 开;requirePrincipal=true 的多用户形 ⇒ 关);"true" / "false" = 显式表态,原样渲给每只 worker。
   # sealedKey.persistence.enabled=false 时图表固定渲 "false"(钥匙跨不过重启,停驻行就续不了);此处再写 "true" ⇒ 渲染即拒。

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

@@ -316,6 +316,7 @@ if [ "$STACK_ENGINE" = "helm" ]; then
     V_PKG_SOURCE="$([ "$REGION" = "global" ] && echo global || echo '')" \
     V_PG_INSTANCES="$PG_INSTANCES" V_PG_AA="$PG_AA" V_REPLICAS="$SERVER_REPLICAS" \
     V_REQ_PRINCIPAL="$(principal_of_users "$USERS")" \
+    V_OPERATOR_SINGLE_USER="$(operator_single_user_of_users "$USERS")" \
     python3 - > "$VALSF" < "$HERE/lib/helm-values-cluster.py"
   )
   [ -s "$VALSF" ] || die "helm values 生成失败"

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

@@ -222,7 +222,7 @@ helm_values() { # helm_values <giteaBaseUrl> <oauthId> <oauthSecret>
   V_MODEL_GATEWAY="$MODEL_GATEWAY_BASEURL" V_MODEL_ID="$MODEL_ID" \
   V_SERVER_IMAGE="$SEMA_SERVER_IMAGE" V_REPLICAS="$SERVER_REPLICAS" \
   V_PG_INSTANCES="$PG_INSTANCES" V_PG_AA="$PG_AA" V_SC="$STORAGE_CLASS" V_SK_SC="$SEALED_KEY_SC" \
-  V_RT_CLASS="$RUNTIME_CLASS" V_REQ_PRINCIPAL="$(principal_of_users "$USERS")" \
+  V_RT_CLASS="$RUNTIME_CLASS" V_REQ_PRINCIPAL="$(principal_of_users "$USERS")" V_OPERATOR_SINGLE_USER="$(operator_single_user_of_users "$USERS")" \
   V_PKG_SOURCE="$([ "$REGION" = "global" ] && echo global || echo '')" \
   V_REG_ENABLED="$REGISTRY_ENABLED" V_REG_IMAGE="${SEMA_REGISTRY_IMAGE:-}" \
   V_REG_PW="${REGISTRY_ADMIN_PASSWORD:-}" V_REG_SS="${REGISTRY_SESSION_SECRET:-}" V_REG_PT="${REGISTRY_PULL_TOKEN:-}" \

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

@@ -24,7 +24,7 @@ FLAG_WORDS_USERS="single multi"
 principal_of_users() { [ "$1" = "multi" ] && echo true || echo false; }
 # 租户形 ⇒ 单用户运维声明 OPERATOR_SINGLE_USER 的值(唯一定义;三只脚本 / 渲染段同调):server 装配运维面时要单用户部署说出谁是运维,
 # 不声明不起服(声明与具名名单 OPERATOR_PRINCIPALS 二选一;本工具渲前者)。single = 这台只有一个人 ⇒ 他就是运维(true);
-# multi = 多租,运维由具名名单另给 ⇒ 不声明(false;多租形上声明本身会被 server 拒)。chart 从 server.requirePrincipal 同一句派生。
+# multi = 多租,运维由具名名单另给 ⇒ 不声明(false;多租形上声明本身会被 server 拒)。helm 图表不派生它:kube-up / cluster-up 的 helm 路径把这一句的结果写进 values 的 server.operatorSingleUser。
 operator_single_user_of_users() { [ "$1" = "multi" ] && echo false || echo true; }
 
 # users_decide <显式给了 USERS 吗(1 / 空)> —— kube 两条装配路径(kube-up / cluster-up)的租户形决策,与 sema-up 的

package/deploy/sema-up/lib/helm-values-cluster.py

@@ -10,6 +10,8 @@ print(json.dumps({
     "modelGatewayBaseurl": e["V_MODEL_GATEWAY"], "modelId": e["V_MODEL_ID"],
     "modelApiKey": e["V_MODEL_KEY"], "sandboxPkgSource": e["V_PKG_SOURCE"],
     "requirePrincipal": e["V_REQ_PRINCIPAL"],
+    # 单用户运维声明由部署工具按 --users 写(图表不派生);值是 flagshape 那一句翻译的 true / false,JSON 布尔 = 图表只收的类型。
+    "operatorSingleUser": e["V_OPERATOR_SINGLE_USER"] == "true",
   },
   # chart 0.3.0 起 registry.enabled 默认 true(单机档语义)——machines 多机路径的 registry/git
   # 面还没接线,必须显式关,不然 helm 撞 registry.image required(2026-07-12 自查)

package/deploy/sema-up/lib/helm-values-kube.py

@@ -17,6 +17,8 @@ v = {
     "serviceAuthToken": e["V_SVC_TOKEN"], "modelGatewayBaseurl": e["V_MODEL_GATEWAY"],
     "modelId": e["V_MODEL_ID"], "modelApiKey": e["V_MODEL_KEY"],
     "sandboxPkgSource": e["V_PKG_SOURCE"], "requirePrincipal": e["V_REQ_PRINCIPAL"],
+    # 单用户运维声明由部署工具按 --users 写(图表不派生);值是 flagshape 那一句翻译的 true / false,JSON 布尔 = 图表只收的类型。
+    "operatorSingleUser": e["V_OPERATOR_SINGLE_USER"] == "true",
   },
   "sandbox": {"runtimeClass": e["V_RT_CLASS"],
               "networkPolicy": {"nodeCidrs": json.loads(e["V_NODE_CIDRS"])}},

package/dist/adoption/import.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { SessionError } from "@sema-agent/core";
-import { createStagedLogFeed, MalformedImportEntryError, newStagingToken, StagedCommitOwnerChangedError } from "../session-sync-kernel.js";
+import { createStagedLogFeed, MalformedImportEntryError, newStagingToken, StagedCommitOccupantChangedError } 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";
@@ -93,11 +93,11 @@ async function importOne(target, clientSessionId, entries) {
         throw e;
     }
     try {
-        await handle.commit(target.toPrincipal, { expectedOwner: undefined });
+        await handle.commit(target.toPrincipal, { expectedOccupant: undefined });
     }
     catch (e) {
         await handle.abort().catch(() => undefined);
-        if (e instanceof StagedCommitOwnerChangedError)
+        if (e instanceof StagedCommitOccupantChangedError)
             return { clientSessionId, outcome: "already_imported", sessionId };
         throw e;
     }

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

@@ -18,7 +18,7 @@ export declare const MAX_DECISION_NOTE_CHARS = 2048;
 /**
  * 回决回执上「理由记上了吗」(`noteRecorded`)一格的**唯一判官与唯一组句器** —— 两口回决(live
  * `POST /v1/tool-approvals/:id/respond` 与耐久 `POST /v1/tasks/:taskId/asks/:askId/decision`)的每一个 200
- * 回体(PARKED 行经赎回腿受理的那一腿除外:它的理由走检查点回决链、不写 ask 行,尚无「记在哪张行」的定义,契约里点名为未覆盖)都经这两只函数说这件事,
+ * 回体(含 PARKED 行经停驻赎回受理的那一腿:停驻门受理之后决定记在这只问的行上,理由就在那一列)都经这两只函数说这件事,
  * 不在各自的回体字面量里手写第二份。
  *
  * 三态同一份契约:请求**没带** `note` ⇒ 键缺席(不是 `false`);带了 ⇒ `true | false`:`true` = **已确认**持久行上那段文本就是这次提交的

package/dist/approval-card.d.ts

@@ -408,7 +408,7 @@ type ClosedWordOf<S extends ClosedWordSeat> = S extends AskClosedWordSeat ? NonN
  * {@link parkRowFacts} 读它);`CheckpointSummary` 不回显(core 原句「read the row」)⇒ inbox 行不带。
  *
  * 判据(display,不是裁决输入 —— 裁决在 core 的仲裁点,本仓无人值守腿的按类作答读的是 core 交来的 `AskRequest.classes` 本身,不经本函数):
- *  · **两键都缺席 ⇒ 缺席**(不计数):老引擎(core 7.37.0 之前)、老行(续跑不补,KL-1214-b)、不盖 `origin` 的站(KL-1214-a)。缺席从不编默认类;
+ *  · **两键都缺席 ⇒ 缺席**(不计数):老引擎(core 7.37.0 之前)、老行(续跑不补,[ref])、不盖 `origin` 的站([ref])。缺席从不编默认类;
  *  · **在场 ⇒ 读法就是 core 的屏** `screenAskClassMembers`([ref] ⑥,core 7.38.0 [ref] 导出;引擎在写停车行前用的同一只):`askClass` 在集、`classes`
  *    非空数组且每员在集、无重复、按 `ASK_CLASSES` 规范序取首员 === `askClass`;屏收 ⇒ 投屏给的规范序副本。屏拒(半对 / 集外词 / 首员不符 /
  *    重复员)⇒ **两键都不投**(卡上少一行类 ≪ 卡上出现生词或半只对)+ 计一次 `server.approval-card.closed-word-out-of-set`([ref] 族,detail 前缀
@@ -590,8 +590,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
     inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
     allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
         member: z.ZodEnum<{
-            request: "request";
             deployment: "deployment";
+            request: "request";
             skill: "skill";
             hook: "hook";
             persisted: "persisted";
@@ -768,8 +768,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
         inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
         allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
             member: z.ZodEnum<{
-                request: "request";
                 deployment: "deployment";
+                request: "request";
                 skill: "skill";
                 hook: "hook";
                 persisted: "persisted";

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

@@ -3,7 +3,7 @@
  *
  * ## 病灶(为什么要有这一只)
  * 问账行 `PARKED` 是终态(`approval-ask-machine.ts`:`PARKED: []`):赎回腿的单赢者是 **checkpoint 的 CAS**,取消腿动的也是 checkpoint(先 `expire` 门、再驱 run 终局),
- * 两条腿都不写 ask 行。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
+ * 两条腿都不改 ask 行的态(赎回受理之后只把决定记在行上,行仍 `PARKED`;门被引擎重开了行也不知道)。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
  * 而应答口对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
  *
  * ## 判官
@@ -61,7 +61,7 @@
  * 行没了 ⇒ `unknown`(`row_absent`;应答口 PARKED 臂的 404 `not_found.approval` 同判)。
  *
  * ## 盲区(core 的筛仍不判的一处,如实写下)
- *  · 种类 × 当事方的配对(结算种类与 `settlement.who` 的当事方是否相配)—— 筛不判(core KL-1265-b),本判官也不核:读的是种类。只有坏行 / 手改行才走得到。
+ *  · 种类 × 当事方的配对(结算种类与 `settlement.who` 的当事方是否相配)—— 筛不判(core [ref]),本判官也不核:读的是种类。只有坏行 / 手改行才走得到。
  *  (时刻与方向两处自 core 7.56.0 [ref] 起由筛判:I10 / I11。trace 投影读同一种记录、经同一只筛,零改即得 I10 —— 坏时刻在两个读者那里是同一个答法。)
  */
 import { type Checkpoint, type CheckpointToken, type SettlementKind } from "@sema-agent/core";

package/dist/audit.d.ts

@@ -36,7 +36,7 @@ export interface SessionAudit {
  * 真源 = `resume_anchor`(锚店 `listBySession` 的读数),本表只是它对**一位读者**的一次投影。
  */
 export type RewindHandles = ReadonlyMap<string, string>;
-/** 会话视图读口(`ServiceDeps.sessionAudit`)的读者参数:`reader` = 读这张视图的**已验身份**(无身份 = `null`)。给了 ⇒ 这是一次**视图读**:用户消息行投回退手柄、体顶层投 `agent`(`session-agent.ts` 的 `readSessionAgent`);
+/** 会话视图读口(`ServiceDeps.sessionAudit`)的读者参数:`reader` = 读这张视图的**已验身份**(无身份 = `null`)。给了 ⇒ 这是一次**视图读**:用户消息行投回退手柄、体顶层投 `agent`(`http/owner-access.ts` 的 `readSessionAgent`);
  *  不给(只要归属的调用方:memory-status / 自助抹除)⇒ 两样投影的读都不付。 */
 export interface SessionAuditReadOpts {
     readonly reader: Subject | null;

package/dist/audit.js

@@ -4,7 +4,7 @@ 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";
-import { projectToolStructured } from "./trace/tool-output-media.js";
+import { projectToolCard } from "./trace/tool-card.js";
 import { INJECTED_BLOCK_RE, isAttachmentFrame } from "./user-authored-text.js";
 import { ownerKeyOf, sameKey } from "./owner-faces.js";
 export function buildRewindHandles(anchors, reader) {
@@ -68,7 +68,7 @@ function withRewindHandles(messages, entries, handles) {
 }
 const deepScrub = (v) => redactDeepWith(v, redactModelText);
 const textSlot = (v) => (typeof v === "string" ? redactModelText(v) : deepScrub(v));
-const readToolCard = (v) => projectToolStructured(v, deepScrub);
+const readToolCard = (v) => projectToolCard(v, deepScrub);
 function readLeaf(treatment, v) {
     switch (treatment) {
         case "text": return textSlot(v);

package/dist/auth-bridge.d.ts

@@ -1,5 +1,6 @@
 import { VerifiedIdentity, type AuthBridgeErrorCode } from "@sema-agent/settings-schema/api/auth-bridge";
 import { type TokenScopeRefusal } from "@sema-agent/settings-schema/api/scopes";
+import type { ServiceConfig } from "./config-types.js";
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 export interface WebAdminJwtVerifierOptions {
@@ -58,6 +59,25 @@ type ReportedOutcome = {
  * (调用方按验证失败处置:不设身份 ⇒ 门答 generic 401)。验证失败的结局验证器自己已记过账,这里只答「不装」。
  */
 export declare function admitBridgeIdentity(outcome: ReportedOutcome, sinks: BridgeSinks): BridgeIdentity | undefined;
+/**
+ * [ref] —— 「本 worker 把登录令牌绑在哪个 scope」的**唯一读口**(判官 {@link ssoForeignScope} 与起服行 `auth_bridge_enabled` 同读)。
+ *  · fleet 成员(`FLEET_GENERATION` 在场 —— 「是不是 fleet 形」在本仓的那一个读数,配置目录行「缺席 ⇔ 非 fleet 成员」)⇒ `config.fleetScope`:
+ *    env `FLEET_SCOPE` 的唯一读数(缺席 = 契约缺省 scope),排空口的身份比对读的就是这一个值 —— 一个事实一个读数,不另读 env。
+ *    编排器给每台受管引擎同拍渲成员代际与 `FLEET_SCOPE`;成员却缺 `FLEET_SCOPE` ⇒ 绑在缺省 scope(偏多拒,与排空口同读,不读成「不绑」)。
+ *  · 非成员(手接 / 壳起的个人引擎)⇒ `undefined` = 不绑:令牌的 scope 就是它的用户自己的空间,准入不比对(本仓不为这一形猜一个空间)。
+ */
+export declare function ssoBoundScopeOf(config: Pick<ServiceConfig, "fleetGeneration" | "fleetScope">): string | undefined;
+/**
+ * [ref] —— **sso 准入的 scope 相等判**(唯一判官;唯一调用点 = `http/dispatch.ts` 的入口预认证)。入参是**已装**的桥身份({@link admitBridgeIdentity} 交出的,
+ * scope 已由 `readTokenScope` 读定、恒在)。本 worker 绑了 scope 而令牌的 scope 不是它 ⇒ 拒,交回两只 scope(只进运维日志;HTTP 体不带本 worker 的 scope ——
+ * 那是另一个空间的名字);不绑或相等 ⇒ `undefined`(装)。逐字比较,不规范化(两边都是 scope id 形;不同就是不同)。
+ */
+export declare function ssoForeignScope(identity: {
+    readonly scope: string;
+}, config: Pick<ServiceConfig, "fleetGeneration" | "fleetScope">): {
+    readonly tokenScope: string;
+    readonly boundScope: string;
+} | undefined;
 /**
  * The live object `createWebAdminJwtVerifier` produces — a single `verify` entry point over the process-level JWKS cache, and the issuer it verifies for.
  * This is also the type of the injected seat (`ServiceDeps.webAdminJwtVerifier`): an embedder's verifier states which issuer it verifies, so `createHttpServer`

package/dist/auth-bridge.js

@@ -23,6 +23,15 @@ export function admitBridgeIdentity(outcome, sinks) {
     }
     return { ...rest, scope: scoped.scope, ...(inc.data !== undefined ? { principalInc: inc.data } : {}) };
 }
+export function ssoBoundScopeOf(config) {
+    return config.fleetGeneration === undefined ? undefined : config.fleetScope;
+}
+export function ssoForeignScope(identity, config) {
+    const boundScope = ssoBoundScopeOf(config);
+    if (boundScope === undefined || identity.scope === boundScope)
+        return undefined;
+    return { tokenScope: identity.scope, boundScope };
+}
 export const DEFAULT_JWKS_TTL_SEC = 15 * 60;
 export const JWKS_FETCH_TIMEOUT_MS = 10_000;
 const MAX_JWKS_BYTES = 256 * 1024;

package/dist/background-session-reap.d.ts

@@ -42,13 +42,13 @@ export interface SessionHardReap {
  *     `no_pgid`(未确认)、linux ⇒ `killed`;已收割 ⇒ `already_gone`。受据按观察答([ref] 车PA 删了「已硬收过」闩:组信号任一成员收到即
  *     成功,闩在部分送达时把活着读成没了),本函数也不为「让硬面先打」挪任何一拍。
  *
- * `scope` = 会话行属主 `owner ?? "default"`(与 core 注册铸值 `spec.principal ?? "default"` 同源 —— 缺席 scope 在 core 的
+ * `scope` = 会话的引擎租户分区 `sessionTenantScope`(唯一换算 `engineScopeOfOwner`,与 core 注册铸值同源 —— 缺席 scope 在 core 的
  * `canAccess` 上 fail-closed、一行都收不到,[ref] 钉过这一病)。
  *
  * 两处调用(见文件头 ①),都 `await`:E21 删除级联 `includeRetained:false`(显式活服务照留);停止口照传请求体。应答在硬面之后发,
  * 代价 = 有 shell 行刚被软停的会话,DELETE / 停止口的应答慢到最后一行的「软停 + 宽限」(通常一次宽限;操作员旋钮 `HOST_BG_KILL_GRACE_MS`,缺省 1000;要几乎不等写 `1` ——
  * `numEnvOr` 把 `0` 读作缺席、回落缺省,与它供的其余执行车道旋钮同一条语义)。
- * 受委托帮手的 shell 挂在帮手自己的会话上,本函数碰不到(core KL-1107a / [ref],候 core)。
+ * 受委托帮手的 shell 挂在帮手自己的会话上,本函数碰不到(core [ref] / [ref],候 core)。
  * 注册表是**进程内**的:只收本副本上的行(多副本部署里别的副本上的行由那个副本自己的出口收)。
  */
 export declare function reapSessionBackgroundHard(sessionId: string, scope: string, opts: {

package/dist/bake-runner/main.d.ts

@@ -16,7 +16,8 @@ interface RunnerEnv {
 }
 /**
  * bake-runner 的 **env 契约**(本进程只读这些;成文另见 USAGE.md §9.7):
- *  · 必填:`IMAGE_API_BASE`(image-api 根,尾斜杠去掉)、`BAKE_RUNNER_TOKEN`(claim / heartbeat 的运维主体 bearer;不进日志、不进子进程)。
+ *  · 必填:`IMAGE_API_BASE`(image-api 根,尾斜杠去掉)、`BAKE_RUNNER_TOKEN`(claim / heartbeat 的运维主体 bearer;不进日志、不进子进程 —— 它是本包的自有凭据,
+ *    登记在 `config-catalog.ts` `BAKE_RUNNER_CREDENTIAL_ENV`,起服第一步按名与按值向引擎声明:任何子进程组都拿不到它与它的同值副本,`BAKE_ENV_ALLOW` 点到它 ⇒ 拒启)。
  *  · `BAKE_RUNNER_ID`(缺省 `bake-runner-<HOSTNAME>`)、`RECIPE_REF`(缺省 `HEAD` = 用现成 checkout)、`RECIPE_DIR`(缺省 `/opt/recipes`)、
  *    `BUILD_SH_PATH`(缺省 `e2b-template/dev-sandbox/build.sh`)、`BAKE_DATA_DIR`(缺省 `/data`)、`LOG_LEVEL`(缺省 info)。
  *  · 数值四键(`parseNumOrFailNonNegative`,非数 / 负数拒启):`BAKE_HEARTBEAT_MS`(30000)、`BAKE_IDLE_POLL_MS`(5000)、
@@ -24,7 +25,8 @@ interface RunnerEnv {
  *  · `BAKE_ENV_ALLOW=NAME,NAME`(7.103.0,[ref] 残余):本进程 spawn 的每一只子进程组(build.sh 与 git fetch / docker push /
  *    docker image inspect / df)的 env 缺省 = 本进程 env 剥密(runner 自己的 `BAKE_RUNNER_TOKEN` 在内);名单点到的键从本进程 env **原样**
  *    放回(部署方显式承担 —— 例如配方脚本真要一枚 `*_PASSWORD` 做 registry 登录)。与服务侧 `LSP_ENV_ALLOW` **同一只**解析器
- *    (`config.ts` `parseEnvNameAllowlist`)与同一只放行谓词:形错(空段 / 尾逗号 / 非变量名形 / 点名任一只名单型旋钮)⇒ **拒启**,拒句点名
+ *    (`config.ts` `parseEnvNameAllowlist`)与同一只放行谓词:形错(空段 / 尾逗号 / 非变量名形 / 点名任一只名单型旋钮 / 点名本包自有凭据 —— 名是,
+ *    或值是,runner 自己的 `BAKE_RUNNER_TOKEN` 在内)⇒ **拒启**,拒句点名
  *    旋钮与段号、不回显值;本进程环境里没有的名 ⇒ 起服 `config_env_entry_rejected` 只报序号、不放行;旋钮原文本身按凭据类,不进子进程。
  *    没有多租户姿态(构建宿主守护进程没有主体 / 租户);生效名单见起服行 `bake_runner_start.envAllow`(只键名)。
  *    ⚠️ 这不是服务配置目录里的键(目录 `BAKE_*` 行是服务侧 bake API 的旋钮),服务进程不读它。

package/dist/bind-host.d.ts

@@ -7,9 +7,8 @@ export interface BindHostConfig {
     authToken?: string;
     authTokens?: Record<string, string>;
 }
-/** 这台部署配了任何一把 service 凭据吗(`SERVICE_AUTH_TOKEN` / `SERVICE_AUTH_TOKENS`)。 */
-export declare function anyServiceCredential(config: Pick<BindHostConfig, "authToken" | "authTokens">): boolean;
-/** 无鉴权写面(`ALLOW_UNAUTHED_WRITES`)+ 零凭据 ⇒ 起服把监听地址收窄到 loopback(见 {@link resolveBindHost})。 */
+/** 无鉴权写面(`ALLOW_UNAUTHED_WRITES`)+ 全局凭据门不武装(没配 service 凭据,`hasServiceAuth`)⇒ 起服把监听地址收窄到 loopback(见 {@link resolveBindHost})。
+ *  逃生口开着时写门不拒,而门不武装 ⇒ 能连上这个口的都能写 —— 鉴权桥在不在不改这一句(验不过 / 不带令牌的调用方照样过)。 */
 export declare function bindMustNarrow(config: Pick<BindHostConfig, "allowUnauthedWrites" | "authToken" | "authTokens">): boolean;
 /**
  * 这台进程的监听地址(绑址旋钮 + 无鉴权自收窄)。`undefined` = Node 缺省全接口。

package/dist/bind-host.js

@@ -1,10 +1,8 @@
 import { isIP } from "node:net";
 import { canonicalAddress } from "./net-address.js";
-export function anyServiceCredential(config) {
-    return Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
-}
+import { hasServiceAuth } from "./identity-source.js";
 export function bindMustNarrow(config) {
-    return Boolean(config.allowUnauthedWrites) && !anyServiceCredential(config);
+    return Boolean(config.allowUnauthedWrites) && !hasServiceAuth(config);
 }
 export function resolveBindHost(config) {
     const mustNarrow = bindMustNarrow(config);

package/dist/boot/budget-tracing.js

@@ -34,7 +34,7 @@ export function createBudgetAndTracing(ctx) {
     const tracer = createTracer(metrics, costQuota, modelUsageTracker, fleetUsage, fleetLease, (m) => config.modelQuotaWeights[m] ?? 1, promptManifestTracker);
     const sideQueryAccounting = createSideQueryAccountant(metrics, costQuota, fleetUsage, fleetLease, (m) => config.modelQuotaWeights[m] ?? 1);
     const toolResultStore = backend?.toolResult ? backend.toolResult() : undefined;
-    const sessionPolicyStore = backend ? backend.sessionPolicy(logger) : undefined;
+    const sessionPolicyStore = backend ? backend.sessionPolicy() : undefined;
     const { store: fileHistoryStore, erasure: fileHistoryErasure } = assembleFileHistory(backend);
     return {
         brain, degradeRouteWatch, pricing, counterDegradeHook, costQuota, modelUsageTracker, promptManifestTracker,

package/dist/boot/deferred-sandbox-path-env.d.ts

@@ -17,7 +17,9 @@
  *
  * ## 三条不可动的裁定
  *
- *  1. **`absolutePath` 一面不转发**,沿用词法规则(POSIX 绝对形归一 / NUL 拒 / 非绝对形 err)。
+ *  1. **`absolutePath` 一面不转发**,只读执行缝路径律(`plugins/exec-path-law.ts`):POSIX 绝对形**原样**交出(`..` / `.` 不折 ——
+ *     不折才与工具同读:七条车道的工具也原样把它交给沙箱的文件系统,`..` 由那块盘解;门的真身判决随后经下面四腿转发问的正是这只拼法)/
+ *     NUL 拒 / 非绝对形 err。
  *     真 env 的 `absolutePath` 会按 **env 自己的 cwd** 解析相对路径,而工具真写处按 engine 跟踪的
  *     cwd 解析——两个基准不同,转发它等于拿错基准铸 canonical key,而**错误的 allow 比没有门更糟**。
  *     相对形 / `~` / 盘符形因此照旧 err ⇒ `canonicalizeTarget` 失败 ⇒ 写门 `ask`(fail-closed)。
@@ -115,7 +117,7 @@ export interface DeferredSandboxPathEnvOptions {
     logger?: SandboxPathEnvLogger;
 }
 /**
- * 写门用的 ExecutionEnv 代理(见文件头)。fs **读**原语转发 slot 里的真 env,`absolutePath` 保留词法形,
+ * 写门用的 ExecutionEnv 代理(见文件头)。fs **读**原语转发 slot 里的真 env,`absolutePath` 绝对形原样(不折,见裁定 1),
  * 其余一切(写面 / shell 面 / listDir …)继承 `StubExecutionEnv` 的 `not_supported`。
  *
  * **继承而非逐一手写**是刻意的:core 日后给 `ExecutionEnv` 加必填面时,新面会随 `StubExecutionEnv`
@@ -130,7 +132,7 @@ export declare class DeferredSandboxPathEnv extends StubExecutionEnv {
     constructor(opts: DeferredSandboxPathEnvOptions);
     /** 取真 env;取不到就地铸 fail-closed 错误(并留痕一次)。 */
     private bound;
-    /** 词法一面,**不**转发 —— 理由见文件头裁定 1。 */
+    /** 只读路径律的一面,**不**转发 —— 理由见文件头裁定 1。绝对形原样:门与工具读同一只拼法,`..` 交给沙箱的文件系统(经四腿转发的真身判决)。 */
     absolutePath(path: string): Promise<Result<string, FileError>>;
     exists(path: string, abortSignal?: AbortSignal): Promise<Result<boolean, FileError>>;
     canonicalPath(path: string, abortSignal?: AbortSignal): Promise<Result<string, FileError>>;

package/dist/boot/deferred-sandbox-path-env.js

@@ -1,5 +1,4 @@
 import { FileError, StubExecutionEnv, err, ok } from "@sema-agent/core";
-import { normalizeAbsolutePathLexically } from "../task-cwd.js";
 const MAX_BOUND_SESSIONS = 4096;
 export class SandboxPathEnvSlots {
     bySession = new Map();
@@ -128,7 +127,7 @@ export class DeferredSandboxPathEnv extends StubExecutionEnv {
         if (!path.startsWith("/")) {
             return Promise.resolve(err(new FileError("not_supported", "this gate cannot resolve a non-absolute path (the sandbox working directory is not the gate's to guess)", path)));
         }
-        return Promise.resolve(ok(normalizeAbsolutePathLexically(path)));
+        return Promise.resolve(ok(path));
     }
     async exists(path, abortSignal) {
         const b = this.bound(path, "exists");

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

@@ -245,6 +245,9 @@ export interface EngineLeaseExitReport {
  *  · `tickMs` = 自退检查的采样拍。自退发生在**生效窗**满之后、至多再晚一拍(顶注 8);生效窗恒 ≥ `lingerMs`(`lingerMs` 是各窗里最短的一个),所以触点比 `lingerMs` 密 ⇒ 在任何状态下都先于自退。
  *    读数**不预言**自退时刻:父还活着时生效的是 owned 窗,自退只会更晚。
  *  · `lane`([ref])= 此刻的车道(与自退判据同一只派生函数,每次现读)。
+ *  · `attached`([ref])= 本副本此刻**打开着的 SSE 流**条数 —— 与自退判据第一合取(`attachedStreams() === 0`)读**同一只**读口(`deps.attachedStreams()`),每次现读,不是采样拍的缓存。
+ *    哪些算、哪些不算写在契约 `/health` 节计法表的「附着」一列(与 `inflightBreakdown` 的「总数 / 阻断」两列同一张表):订阅流与流式提交腿算,后台腿、无流的同步腿、leader 腿不算。
+ *    它是**附着流条数,不是活跃调用方**:纯轮询壳(零 SSE)与毫秒级请求的下采样读到 0 合法 —— 判「这台引擎此刻有没有人在用」要连 `inflight` 与最近触点一起读(顶注 3),不能拿 `attached === 0` 当「没人」。
  *
  * ## 一源
  * 与租约腿自己的行为同一处铸出:`engine_lease_armed` 日志、自退判据用的窗、拍频推导(`tickMs = min(15s, 最短窗)`)和本读数读的是同一组数 ——
@@ -255,6 +258,8 @@ export interface EngineLeaseFacts {
     readonly tickMs: number;
     /** [ref]:此刻的车道。 */
     readonly lane: EngineLane;
+    /** [ref]:此刻打开着的 SSE 附着流条数(整数,≥ 0;语义与读口见上「报的是什么」一条 —— 附着流条数,不是活跃调用方)。 */
+    readonly attached: number;
     /** [ref] 首窗格({@link EngineLeaseFirstAttachFacts}):候首触窗有限(owned 窗有限)才在场 —— 永不到期的窗不上 wire(同上一段那条律)。 */
     readonly firstAttach?: EngineLeaseFirstAttachFacts;
     /** [ref] 交接格({@link EngineHandoverFacts}):只在 handover 车道在场。 */

package/dist/boot/engine-lease.js

@@ -184,6 +184,7 @@ export function createEngineLeaseTracker(deps) {
                 lingerMs: shortestLingerMs,
                 tickMs,
                 lane: laneNow().lane,
+                attached: deps.attachedStreams(),
                 ...(firstAttach !== undefined ? { firstAttach } : {}),
                 ...(handover !== undefined ? { handover } : {}),
             });

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

@@ -19,6 +19,7 @@ import { type LocalDockerCapacity } from "../plugins/local-docker-capacity.js";
 import * as facts from "../capability-facts.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { TaskInheritEnv } from "../request-value-closure.js";
+import { type SessionBindings, type SessionBindingSeat } from "../session-bindings.js";
 import { type HeadRead } from "../session-incarnation.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
 import { type SessionResidentCounts } from "../session-resident-background.js";
@@ -43,20 +44,11 @@ import { type SessionResidentCounts } from "../session-resident-background.js";
  * 那一个副本上发生。跨副本的陈值靠「读面必经本副本的一次提交 ⇒ 必过本副本的围栏」兜住 —— 这条推理成立
  * 是因为 run 在受理它的那个副本上执行(ARCHITECTURE 副本模型)。device lane 的部署形本身也是单副本(§4.6)。
  */
-export interface SessionScopedRegistries {
+export interface SessionScopedRegistries extends SessionBindingSeat {
     readonly perSessionCwd: Map<string, string>;
     readonly perSessionShellEnv: Map<string, Record<string, string>>;
-    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
+    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装。 */
     readonly perSessionInheritEnv: ReadonlyMap<string, TaskInheritEnv>;
-    setSessionCwd(sid: string, cwd: string): void;
-    setSessionShellEnv(sid: string, env: Record<string, string>): void;
-    /**
-     * [ref] —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
-     * `undefined` = **清掉**这一格(不是「不动」):`inheritEnv` 是「本条请求要什么」,缺席的请求要的是缺省清洗 ——
-     * 与 cwd / shellEnv 的「缺席 = 留着上一条的值」刻意不同(那两位由壳每条请求重发,粘住无害;这一位粘住 = 替一个没说话的
-     * 请求放宽凭据面)。
-     */
-    setSessionInheritEnv(sid: string, policy: TaskInheritEnv | undefined): void;
     /** 本进程见过的会话 → 属主(围栏表本身,只读视图;`null` = 匿名)。**会话驻留后台行的枚举源**:`session-resident-background.ts` 逐会话问注册表
      *  (core 的访问元组要带 scope,没有进程总数的读口),读的就是这一张 —— 每次提交写一笔、`dropSession` 清一笔、LRU 有界,不另立第二张会话名册。 */
     readonly sessionOwners: ReadonlyMap<string, string | null>;
@@ -178,9 +170,11 @@ export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     perTaskImage: PerTaskImageRegistry;
     sessionEnvSelection: SessionEnvironmentSelection;
     perSessionCwd: Map<string, string>;
-    setSessionCwd: (sid: string, cwd: string) => void;
-    setSessionShellEnv: (sid: string, env: Record<string, string>) => void;
-    setSessionInheritEnv: (sid: string, policy: TaskInheritEnv | undefined) => void;
+    sessionBindings: {
+        commitSessionBindings: (sessionId: string, bindings: SessionBindings) => import("../session-bindings.js").SessionBindingReceipt;
+        withdrawSessionBindings: (receipt: import("../session-bindings.js").SessionBindingReceipt) => boolean;
+        settleSessionBindings: (receipt: import("../session-bindings.js").SessionBindingReceipt) => boolean;
+    };
     fenceSessionOwner: (sid: string, owner: string | null, incarnation?: string) => void;
     dropSessionScoped: (sid: string) => void;
     dropSessionScopedOf: (sid: string, incarnation: string) => boolean;