@sema-agent/server 7.151.0 → 7.152.0

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

@@ -18,26 +18,54 @@
 # ── 词表(单一属主)──────────────────────────────────────────────────────────────────────────────
 FLAG_WORDS_PROFILE="full-single data-center local-plus full-cluster"
 FLAG_WORDS_USERS="single multi"
+# 租户形的释义 —— 拒句(flag_users_required)按词表逐词取,与词表同批改(词表加一个词而这里没有它 ⇒ 拒句生成处非零退出,不静默少一条出路)。
+users_gloss() {
+  case "$1" in
+    single) printf '%s' "只给一个人用:这台部署的每个调用方都是它的运维,身份隔离关" ;;
+    multi) printf '%s' "被不止一个人调用(团队):身份隔离开,运维由具名名单 OPERATOR_PRINCIPALS 另给" ;;
+    *) return 1 ;;
+  esac
+}
 # 租户形 ⇒ 容器上 REQUIRE_PRINCIPAL 的值 —— 这条翻译的**唯一**定义(7.105.0 从 sema-up.sh 搬来):sema-up 的 compose 生成段 /
 # 事实核对,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; }
+# cluster-up 一份都没有 ⇒ --users=multi 在 --kube=machines 路径上被静默丢成单用户)。**闭集**:只认 single / multi 两词,
+# 别的词(含空串)⇒ 非零退出、零输出 —— 不再有「认不出的词当 single」那一臂(缺省派生藏在翻译里,就是部署脚本替部署选了人数)。
+principal_of_users() { case "$1" in multi) echo true ;; single) echo false ;; *) return 1 ;; esac; }
 # 租户形 ⇒ 单用户运维声明 OPERATOR_SINGLE_USER 的值(唯一定义;三只脚本 / 渲染段同调):server 装配运维面时要单用户部署说出谁是运维,
 # 不声明不起服(声明与具名名单 OPERATOR_PRINCIPALS 二选一;本工具渲前者)。single = 这台只有一个人 ⇒ 他就是运维(true);
-# multi = 多租,运维由具名名单另给 ⇒ 不声明(false;多租形上声明本身会被 server 拒)。helm 图表不派生它:kube-up / cluster-up 的 helm 路径把这一句的结果写进 values 的 server.operatorSingleUser。
-operator_single_user_of_users() { [ "$1" = "multi" ] && echo false || echo true; }
+# multi = 多租,运维由具名名单另给 ⇒ 不声明(false;多租形上声明本身会被 server 拒)。同样是闭集(别的词 / 空串 ⇒ 非零、零输出)。
+# 这句翻译只翻**部署自己给的那一词**(`--users` / `-f` 配置 / 这台部署上一次落下的事实 / 向导里人答的那一句);词没有给 ⇒ 过不到这里(见 users_decide /
+# flag_users_required)。helm 图表不派生它:kube-up / cluster-up 的 helm 路径把这一句的结果写进 values 的 server.operatorSingleUser。
+operator_single_user_of_users() { case "$1" in single) echo true ;; multi) echo false ;; *) return 1 ;; esac; }
+# flag_users_required <称呼> —— `--users`(几个人用)**必填,没有缺省**:这一词是部署自己的声明,部署脚本 / 模板不替它选。缺省 single 会让
+# 用模板起团队集群又忘设人数的部署每个调用方都成运维(服务端拒句里「不止一个人调用 ⇒ 设 REQUIRE_PRINCIPAL」那一道人判,对用脚本的人永远不出现);
+# 缺省 multi 同样是替部署选(替单人部署开身份隔离)。拒 = log 两行 + exit 1。**拒句只在这里写一次**(sema-up / kube-up / cluster-up 同调;词从
+# FLAG_WORDS_USERS 取,释义从 users_gloss 取),与随包 helm 图表的「两键都没设 ⇒ 渲染即拒」同一律同一组出路。
+flag_users_required() {
+  local w g out=""
+  for w in $FLAG_WORDS_USERS; do
+    g="$(users_gloss "$w")" || { log "⛔ 内部不一致:租户词 $w 在 FLAG_WORDS_USERS 里却没有释义 —— 词表与 users_gloss 要同批改"; exit 1; }
+    out="${out:+$out / }--users=$w($g)"
+  done
+  log "⛔ $1 没给 —— 几个人用是这台部署自己的声明:部署脚本不替你选(缺省 single = 忘设人数的团队集群每个调用方都成运维;缺省 multi = 替单人部署开身份隔离)"
+  log "   ↳ 下一步(二选一):$out;kube-up.sh / cluster-up.sh 单独跑时同一个词写成环境变量 USERS=<词>"
+  exit 1
+}
 
 # users_decide <显式给了 USERS 吗(1 / 空)> —— kube 两条装配路径(kube-up / cluster-up)的租户形决策,与 sema-up 的
-# compose 档同一条规则:**决策 = 显式 USERS ∨ 上一次落在 $ENVF 的部署事实 REQUIRE_PRINCIPAL ∨ single**;显式值与事实
-# 不一致 ⇒ 拒并点名两处(不静默把一台多租部署降成单用户,也不静默把单用户升成多租)。事实 → 租户词只经
+# compose 档同一条规则:**决策 = 显式 USERS ∨ 上一次落在 $ENVF 的部署事实 REQUIRE_PRINCIPAL;都没有 ⇒ 拒(flag_users_required,没有缺省)**;
+# 显式值与事实不一致 ⇒ 拒并点名两处(不静默把一台多租部署降成单用户,也不静默把单用户升成多租)。事实 → 租户词只经
 # principal_of_users 反查(两词逐个过正向比,不另写反表);认不出的事实值 ⇒ 拒。设 USERS。
 # codex 一轮 [high]:machines 路径开始认 --users 之后,一次不带旗的重跑会拿缺省 single 把多租部署的
-# REQUIRE_PRINCIPAL 翻回 false(kube-up 路径此前就同形)—— 事实由两只脚本各自在写凭据的同一处 resetk 落盘。
+# REQUIRE_PRINCIPAL 翻回 false(kube-up 路径此前就同形)—— 事实由两只脚本各自在写凭据的同一处 resetk 落盘;缺省 single 本身随后退役(没有缺省)。
 # 调用方先 source lib/envf.sh 并定好 ENVF(文件可以还不存在 = 首装,无事实)。
 users_decide() {
   local given="$1" fact fact_users="" u
   fact="$(envf_get REQUIRE_PRINCIPAL)" || exit 1
-  [ -n "$fact" ] || return 0
+  if [ -z "$fact" ]; then
+    [ -n "$given" ] || flag_users_required "--users(USERS)"
+    return 0
+  fi
   for u in $FLAG_WORDS_USERS; do [ "$(principal_of_users "$u")" = "$fact" ] && fact_users="$u"; done
   if [ -z "$fact_users" ]; then
     log "⛔ 部署事实 $ENVF 里 REQUIRE_PRINCIPAL=$(flag_show "$fact"):本工具只读自己写出的两形 $(principal_of_users multi) / $(principal_of_users single)"

package/deploy/sema-up/machines.example.yaml

@@ -3,7 +3,9 @@
 # 凭据二选一:password(bootstrap 用它铺 ssh key,不落盘不入日志)或 ssh_key(已互信)。
 profile: full-cluster   # full-cluster | full-single | data-center | local-plus
 region: auto            # auto | cn | global(auto=连通性探测,--region 可覆盖)
-users: single           # single(超管 turnkey,推荐)| multi(身份隔离+能力默认全开)
+# users: single|multi   # 必填(这里不写缺省,也不替你选):几个人用是这台部署自己的声明。取消注释写一个,或每次带 sema-up 的 --users=<词>;
+#                       # single = 只给一个人用(每个调用方都是运维;超管 turnkey)| multi = 一个团队(身份隔离+能力默认全开,运维由具名名单另给)。
+#                       # 重跑沿用 ~/.sema-up/<project>/.env 里上一次落下的,不必再写;都没有 ⇒ sema-up 拒并给两条出路。
 # server_image: ghcr.io/sema-agent/sema-server:<tag>   # 引擎镜像 registry 引用(GHCR/Docker Hub 公开仓,
 #                         # 匿名可拉;CN 兜底=内网 Gitea registry。SWR 已弃用 2026-07-13);
 #                         # 不填则要 env SEMA_SERVER_IMAGE 或 SEMA_SERVER_IMAGE_TAR(tar 预灌)

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

@@ -56,7 +56,7 @@ usage() {
   cat "$HERE/lib/usage-head.txt"
   # 闭集词表从 lib/flagshape.sh 渲(单一属主):加 / 删一个词,这几行自己跟着变
   printf '  --profile=P            %s\n' "$(printf '%s' "$FLAG_WORDS_PROFILE" | tr ' ' '|')"
-  printf '  --users=U              %s\n' "$(printf '%s' "$FLAG_WORDS_USERS" | tr ' ' '|')"
+  printf '  --users=U              %s(必填,没有缺省;重跑沿用 .env 里上一次落下的;data-center 档不装 agent,不用)\n' "$(printf '%s' "$FLAG_WORDS_USERS" | tr ' ' '|')"
   printf '  --region=R             %s\n' "$(printf '%s' "$FLAG_WORDS_REGION" | tr ' ' '|')"
   cat "$HERE/lib/usage-flags.txt"
   # 词表从 lib/lanes.json 渲(单一属主):加/删一条车道,这行自己跟着变
@@ -327,7 +327,7 @@ fi
   "data-center:只装数据面(PG+MinIO+备份)——agent 在你自己机器上,数据放这里" \
   "full-cluster:k8s 准生产——3 机 ssh 装配 / 已有集群 kubeconfig / 本机装 k3s" \
   "local-plus:本机只跑 agent,连一个已经部署好的 data-center 数据面")
-# ── 两个决策(租户形 / 车道)同一条规则:决策 = 显式旗 ∨ 部署事实 ∨ 表缺省 ─────────────────────
+# ── 两个决策(租户形 / 车道)同一条规则:决策 = 显式旗 ∨ 部署事实 ∨ 表缺省 —— 租户形**没有表缺省**(见下)─────────────────────
 # 「部署事实」= 同一只 `$WORK/.env`:compose 的 agent 档由本脚本写,full-cluster 由 kube-up / cluster-up 在写凭据的同一处
 # 写(修前 kube 两条路径不落这条事实 ⇒ 不带旗重跑拿缺省 single 把多租部署降回单用户);data-center 不起 agent。事实 → 决策词只经属主翻译,本脚本不抄第二份:
 #   · REQUIRE_PRINCIPAL → --users:只认 sema-up 自己写出的两形 true / false(别的写法 ⇒ 拒;不复刻 server 的布尔词表);
@@ -335,18 +335,20 @@ fi
 # 不带旗重跑 ⇒ 沿用事实(多租部署重跑不必再带 --users=multi);显式旗与事实不一致 ⇒ fact_conflict 拒并点名两处。
 # 🔴 为什么缺省不能先于事实(合并复审两条真案):把表缺省当成意图去和事实比,合法的无旗重跑就被拒;
 # 反过来若只比不拒,保留的多租 `.env` 在缺省 single 下会被车道表判成 host —— 容器拿到 REQUIRE_PRINCIPAL=true ∧ host。
+# 🔴 租户形不取缺省(单用户声明由部署写,脚本不替它选):显式旗(`--users` / `-f` 配置)∨ 部署事实 ∨ 向导里人答的那一句,都没有 ⇒ 拒
+# (`flag_users_required`,拒句与 kube-up / cluster-up 同一只判官)。缺省 single = 用模板起团队集群又忘设人数的部署人人是运维;缺省 multi 同样是
+# 替部署选。data-center 档不装 agent,没有声明可言:不问、不拒(USERS 留空,汇总行写 n/a)。
 # 租户形 ⇒ 容器上 REQUIRE_PRINCIPAL 的值:`principal_of_users`(lib/flagshape.sh,三只脚本共用的唯一定义;kube-up /
-# cluster-up 也调它)。正向(生成段 setk、事实核对)与反向(事实 → --users 缺省)都经它:反向是拿两个租户词逐个过这只函数去比,
+# cluster-up 也调它)。正向(生成段 setk、事实核对)与反向(事实 → 向导问句的缺省词)都经它:反向是拿两个租户词逐个过这只函数去比,
 # 不另写一张反表(与车道的 `lanes choice-of` 同一姿势)。
-USERS_DEF="single" RP_FACT="" RP_FACT_SRC=""
+USERS_DEF="" RP_FACT="" RP_FACT_SRC="" REQUIRE_PRINCIPAL_WANT=""
 case "$PROFILE" in
   # full-cluster 也读 —— kube-up / cluster-up 在写凭据的同一处把 REQUIRE_PRINCIPAL 落进同一只 .env(它们自己
   # 单独跑时也按同一条规则判,见 lib/flagshape.sh 的 users_decide)。
   full-single|local-plus|full-cluster)
     deploy_fact REQUIRE_PRINCIPAL; RP_FACT="$FACT_VAL" RP_FACT_SRC="$FACT_SRC"
     if [ -n "$RP_FACT" ]; then
-      USERS_DEF=""
-      for _u in single multi; do [ "$(principal_of_users "$_u")" = "$RP_FACT" ] && USERS_DEF="$_u"; done
+      for _u in $FLAG_WORDS_USERS; do [ "$(principal_of_users "$_u")" = "$RP_FACT" ] && USERS_DEF="$_u"; done
       if [ -z "$USERS_DEF" ]; then
         log "⛔ 部署事实 REQUIRE_PRINCIPAL=$RP_FACT(来自 $RP_FACT_SRC):本脚本只读自己写出的两形 $(principal_of_users multi) / $(principal_of_users single)"
         log "   ↳ 下一步:改成 REQUIRE_PRINCIPAL=$(principal_of_users multi)(多人,身份隔离)或 REQUIRE_PRINCIPAL=$(principal_of_users single)(单人),再重跑"
@@ -354,13 +356,17 @@ case "$PROFILE" in
         exit 1
       fi
     fi
+    if [ -z "$USERS" ]; then
+      # 无人值守没有人答 ⇒ 没有事实就没有词:拒。向导(tty / json)里问句的缺省只有事实词(重跑),没有事实 ⇒ 缺省为空,空答由 ask 的闭集句拒(同样列两词)。
+      if [ -z "$USERS_DEF" ] && [ "$MODE_INTERACTIVE" = "none" ]; then flag_users_required "--users(USERS)"; fi
+      USERS=$(ask users "几个人用?" "$USERS_DEF" "这是这台部署自己的声明,没有缺省(重跑沿用上一次落下的);单人可跳过全部权限配置,多人要开身份隔离" \
+        "single:就我一个(超级管理员 turnkey,零权限配置)" \
+        "multi:一个团队(身份隔离 ON,能力默认全开,之后可用 policy 收紧)")
+    fi
+    REQUIRE_PRINCIPAL_WANT="$(principal_of_users "$USERS")"
+    fact_conflict REQUIRE_PRINCIPAL "$RP_FACT" "$RP_FACT_SRC" "$REQUIRE_PRINCIPAL_WANT" "--users=$USERS"
     ;;
 esac
-[ -z "$USERS" ] && USERS=$(ask users "几个人用?" "$USERS_DEF" "单人可跳过全部权限配置,多人要开身份隔离" \
-  "single:就我一个(超级管理员 turnkey,零权限配置)" \
-  "multi:一个团队(身份隔离 ON,能力默认全开,之后可用 policy 收紧)")
-REQUIRE_PRINCIPAL_WANT="$(principal_of_users "$USERS")"
-fact_conflict REQUIRE_PRINCIPAL "$RP_FACT" "$RP_FACT_SRC" "$REQUIRE_PRINCIPAL_WANT" "--users=$USERS"
 
 # registry:各档默认带上(clay 2026-07-12 拍;显式 --registry=false 可关)。
 # local-plus 例外默认 false——它的数据面在远端,配置中心应随数据面部署,本机再起一个=两个配置中心。
@@ -544,7 +550,7 @@ HOSTIP=$(host_ip)
 # test srv796 实测 NEW-5)。7.104.0 起REGISTRY_ENABLED 在建工作目录之前已过形判(只会是 true / false,或空 =
 # 走档位缺省,缺省在上面已落定),registry 仍收成 on/off 决策词。region/profile/users/lane/git 到这里都已定死
 # (形判在参数解析之后、交互答案在 ask() 里、车道在车道块)。
-log "region=$REGION profile=$PROFILE users=$USERS sandbox=${SANDBOX_LANE:-n/a} lane=${LANE_REMOTE_EXEC:-n/a} registry=$([ "$REGISTRY_ENABLED" = "true" ] && echo on || echo off) git=$GIT_MODE"
+log "region=$REGION profile=$PROFILE users=${USERS:-n/a} sandbox=${SANDBOX_LANE:-n/a} lane=${LANE_REMOTE_EXEC:-n/a} registry=$([ "$REGISTRY_ENABLED" = "true" ] && echo on || echo off) git=$GIT_MODE"
 
 # ── 数据根(一条规则 —— 数据根归一个项目所有;判据全在 lib/dataroot.sh)───────────────────────────
 # 取哪条根:`.env` 首装值(已装的项目不漂移,不搬数据)∨ --data-root / -f 的 DATA_ROOT ∨ 多盘机自动选大容量盘
@@ -616,7 +622,7 @@ fi
 if $DRY_RUN; then
   {
     echo "══════ sema-up dry-run(不写文件、不起容器)══════"
-    echo " profile=$PROFILE users=$USERS region=$REGION registry=$REGISTRY_ENABLED git=$GIT_MODE"
+    echo " profile=$PROFILE users=${USERS:-n/a} region=$REGION registry=$REGISTRY_ENABLED git=$GIT_MODE"
     echo " compose profiles: $COMPOSE_PROFILES(project=$PROJECT)"
     echo " 凭据文件: $ENVF $([ -f "$ENVF" ] && echo '(已存在:只补缺,已有凭据不轮换)' || echo '(将新建,0600)')"
     echo " 将执行:"
@@ -680,8 +686,8 @@ 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 补上。
+  # 单用户运维声明:由部署自己给的那一个租户词翻译(`--users` / 配置 / 上一次的事实 / 向导答案;缺了就在上面拒,没有缺省;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"
@@ -1084,7 +1090,7 @@ else
     echo " 数据卷    $(printf ',%s,' "$COMPOSE_PROFILES" | grep -q ',pg,' && printf '%s_pgdata ' "$PROJECT")$(printf ',%s,' "$COMPOSE_PROFILES" | grep -q ',s3,' && printf '%s_miniodata ' "$PROJECT")$([ "$REGISTRY_ENABLED" = "true" ] && printf '%s_registrydata ' "$PROJECT")$([ "$GIT_MODE" = "provision" ] && printf '%s_gitdata ' "$PROJECT")$(printf ',%s,' "$COMPOSE_PROFILES" | grep -q ',agent,' && printf '%s_sealedkey' "$PROJECT")$([ -n "$DATA_ROOT" ] && printf '(bind 落 %s)' "$DATA_ROOT")"
     echo " 重入      再跑同命令=幂等升级(凭据不轮换);验证=smoke.sh --project=$PROJECT"
     echo " 卸载      $0 --project=$PROJECT --teardown(留数据)/--teardown-volumes(连卷删)"
-    [ "$PROFILE" = "data-center" ] && echo " 接入      别处 agent 连这个数据面 = sema-up.sh --profile=local-plus --pg-host=$HOSTIP --minio-endpoint=http://$HOSTIP:$MINIO_PORT + 两个密码(本机 .env 里)"
+    [ "$PROFILE" = "data-center" ] && echo " 接入      别处 agent 连这个数据面 = sema-up.sh --profile=local-plus --users=<single|multi> --pg-host=$HOSTIP --minio-endpoint=http://$HOSTIP:$MINIO_PORT + 两个密码(本机 .env 里)"
     echo "═══════════════════════════════════════════════════════════"
   } >&2
 fi

package/dist/approval-ask-audit-store.d.ts

@@ -166,7 +166,7 @@
  * 本店是协调器侧的审计 sink,不是跨后端 store 契约的一员(SQL 车道有真 ask 店,永不装本店)——
  * 装配点在 `boot/coordinators.ts`(判据:`toolApprovalEnabled` ∧ `backend.kind === "local"` ∧
  * `config.localDataRoot` 在场;真实 boot 恒铸 `localDataRoot`,缺席只发生在 stub-harness 上,判据
- * 理由照 `StreamApprovalGateInput.streamApprovalEnabled` 顶注的同款论证)。root 与 `LocalBackend`
+ * 只填被测键的 harness 要的必然是「别碰真盘」)。root 与 `LocalBackend`
  * 同源(`store-backend.ts:780` 的 `config.localDataRoot`),数据落 `<root>/approval-ask-audit/`。
  *
  * ## 体量与保留

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

@@ -6,19 +6,13 @@ export declare const ASK_TERMINAL: ReadonlySet<AskState>;
 /** 批侧终态集合(无出边的 2 态)。 */
 export declare const BATCH_TERMINAL: ReadonlySet<BatchState>;
 /**
- * [ref]:回决理由(`AskRow.decisionNote` → `decision_note` 列)的字符上限,**两条回决腿共用一个常量**。
- *
- * 🔴 为什么住在这个模块:两个消费者分别是 durable 腿的 zod 体(`http/routes/runs.ts` 的
- * `AskDecisionBodySchema`)与 live 腿的手写 parser(`tool-approval.ts` 的 `parseToolApprovalResponse`),
- * 两处都在 ask 状态机的**同一张行**上写同一列。上限各写一份字面量 = 同一列上两个口径,而分歧只会在
- * 「一条腿收下、另一条腿 400」的那天才被发现。本模块是两腿唯一的共同上游(askId/batchId 铸造与转移表
- * 都在这里),放这里不引新依赖边。
+ * [ref]:回决理由(`AskRow.decisionNote` → `decision_note` 列)的字符上限 —— 列的口径住在行的状态机模块里(askId/batchId 铸造与转移表都在这里),
+ * 唯一的人决口(`http/routes/runs.ts` 的 `AskDecisionBodySchema`)读它。
  */
 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 行经停驻赎回受理的那一腿:停驻门受理之后决定记在这只问的行上,理由就在那一列)都经这两只函数说这件事,
+ * 回决回执上「理由记上了吗」(`noteRecorded`)一格的**唯一判官与唯一组句器** —— 决断口 `POST /v1/tasks/:taskId/asks/:askId/decision` 的每一个 200
+ * 回体(活卡首决 / 回放,与 PARKED 行经停驻赎回受理的那一腿:停驻门受理之后决定记在这只问的行上,理由就在那一列)都经这两只函数说这件事,
  * 不在各自的回体字面量里手写第二份。
  *
  * 三态同一份契约:请求**没带** `note` ⇒ 键缺席(不是 `false`);带了 ⇒ `true | false`:`true` = **已确认**持久行上那段文本就是这次提交的

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

@@ -43,7 +43,7 @@ import type { BackgroundAgentRecord } from "@sema-agent/core";
 export declare const APPROVAL_ASK_RETENTION_DEFAULT_MS: number;
 /**
  * 正值的下限:1 天(低于即钳到 1 天并点名)。还能动的 run 的问本来就不删(见文件头);下限管的是**刚结束**的 run:
- * 客户端在 run 结束后还可能对它的卡做幂等重试 / 晚答(决断口回放首决、晚答口回 409 / 410 而不是 404),一天吸收这一段。
+ * 客户端在 run 结束后还可能对它的卡做幂等重试 / 晚答(决断口对已决行同键回放首决、否则 409,对作废行 410,而不是 404),一天吸收这一段。
  */
 export declare const APPROVAL_ASK_RETENTION_FLOOR_MS = 86400000;
 /** 两次清扫之间的最短间隔(见文件头「节律」)。 */

package/dist/approval-card.d.ts

@@ -723,7 +723,7 @@ export type ApprovalCard = z.infer<typeof ApprovalCardSchema>;
  * `schema_version` 列同值,列供 SQL 侧过滤,信封里这份供读面在解出内容**之前**判形)。
  *
  * `approvalId` = 这张卡**呈出时**的 wire 身份。7.133.0 起它恒等于行的键 `askId`(一只 ask 一只 wire 身份),本服务的活读者(重放帧 /
- * 应答口 / 读口)一律读行的键、不读这一格;写它是给滚动升级窗里上一版的副本(它们的 strict 信封 schema 要求这一格并照它重放)。
+ * 决断口 / 读口)一律读行的键、不读这一格;写它是给滚动升级窗里上一版的副本(它们的 strict 信封 schema 要求这一格并照它重放)。
  * 唯一读这一格的是 local 车道的启动收敛 —— 拿它去审计账里查前世这只 ask 的成因:审计行记的就是当时呈出的那个 id
  * (更早写下的行上是当年的登记本地 id)。
  *
@@ -1032,8 +1032,8 @@ export declare function buildApprovalRequestFrame(input: {
  * ({@link adoptStoredLiveFacts};行 = 真源)。带 NUL / 孤代理的一组不落座(某个后端存不下逐字的那一份,见 {@link buildApprovalCardEnvelope})。
  * 卡面(`ApprovalCardSchema`)照旧不带这十一位(`approvalCard` 除外,见本注末段):
  * 它们在帧顶层、不在 `card` 里,信封上是卡旁边的一座,不是卡的键。
- * `readRootCandidate` 随重放的射程与卡上 `ruleOffers` 同一句(`ApprovalCardSchema.ruleOffers` 顶注):回授经重放帧自己的 `approvalId` 走活应答口,
- * 有等待腿的副本兑得动;接管登记 / 耐久回决口上没有等待腿,应答照收、目录不加(没有 `approval.read_root_granted` 通告 = 什么都没加)。
+ * `readRootCandidate` 随重放的射程与卡上 `ruleOffers` 同一句(`ApprovalCardSchema.ruleOffers` 顶注):回授经重放帧自己的 `askId` 走决断口的 live 形(体键 `readRootGrant`),
+ * 有等待腿的副本兑得动;接管登记上没有等待腿,决定照收、目录不加;停驻形带它 ⇒ 400、没有等待腿可交(没有 `approval.read_root_granted` 通告 = 什么都没加)。
  *
  * `requiresRealApproval` 不在表里:卡上 `risk.requiresRealApproval` 是同一个事实(铸卡第三参就是它),一个事实一个读法。
  * ⚠️ **`approvalCard` 是表里唯一一位 7.136.0 起同时在卡上的座**(`ApprovalCardSchema.approvalCard`:断连重放的卡要渲回同一张专卡,卡词必须进卡;
@@ -1054,9 +1054,8 @@ export declare function adoptStoredLiveFacts(frame: ApprovalRequestLiveFacts, se
 /**
  * [ref] §3.1 的呈卡帧(设计稿 §4.1 逐字)。
  *
- * 🔴 **一条腿一个帧族**:呈卡协议在一条腿上场(腿的审批上下文族词 `approval_request`)⇒ 这条腿上一只 ask 的开卡 / 消卡 / 撤卡只走本族
- * (`approval_request` / {@link ApprovalCompleteFrame} / {@link ApprovalRevokeFrame}),旧族 `tool_approval` / `tool_approval_complete`
- * 一帧都不发;协议未上场的腿只发旧族。同一只 ask 在同一条腿上不再有两种开卡帧,消费方不再按 `approvalId` 去重。
+ * 🔴 **审批只有这一个帧族**:一只 ask 的开卡 / 消卡 / 撤卡只走本族(`approval_request` / {@link ApprovalCompleteFrame} / {@link ApprovalRevokeFrame});
+ * 呈卡协议不上场的 worker 不呈卡(问交无人值守政策口),没有回退发的另一族。
  * 开卡的全部事实因此在本帧上:卡(`card`,耐久信封)+ 活面事实座({@link ApprovalRequestLiveFacts};活铸帧与重放帧同一份,见 {@link APPROVAL_REQUEST_LIVE_FACT_KEYS} 顶注)。
  */
 export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
@@ -1066,7 +1065,7 @@ export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
      * 活铸帧恒不带;行上有座的重放帧不带(座里缺的那一位就是真缺席)。不回填:存量行随窗到期收敛。
      */
     liveFactsUnknown?: true;
-    /** = SSE 具名事件名(与 `tool_approval` 同约定)。 */
+    /** = SSE 具名事件名。 */
     type: "approval_request";
     schemaVersion: 1;
     /** `deriveAskId` 派生(持久层主键;八元身份元组 —— 7.109.0 起含这一问的类集,7.143.0 起含展示的动作(工具名 + 入参摘要) —— 见 approval-ask-machine.ts)。 */
@@ -1082,22 +1081,21 @@ export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
     expiresAtMs: number;
     serverNowMs: number;
     /**
-     * server 扩(不在设计字面):`POST /v1/tool-approvals/:id/respond` / `GET /v1/tool-approvals/:id` 的 id —— **恒等于 `askId`**(行的键就是这只 ask
-     * 唯一的 wire 身份;本族的消卡帧({@link ApprovalCompleteFrame})同带它)。
+     * server 扩(不在设计字面):**恒等于 `askId`**(行的键就是这只 ask 唯一的 wire 身份;本族的消卡帧({@link ApprovalCompleteFrame})同带它)。
+     * 7.152.0 起读它的两条口已删(决断口 / 读口按 `askId` 寻址),这一键只剩自指。
      */
     approvalId: string;
 }
 /**
  * 呈卡族的**单卡消卡帧**(`approval_complete`)—— 一只 ask 落定时发给每一条**收到过它的呈卡帧**的呈卡腿连接。
  *
- * 语义与旧族 `tool_approval_complete` 逐字同一件事(同一次 settle 的同一份判决:`outcome` 三词、非人结局的 `cause`、park 路由的
- * `parked`),只是它属于本族:键与开卡帧对位(`askId` / `taskId` / `approvalId`,开卡帧上有的身份这里都有),消卡按开卡那一帧的键。
+ * 一次 settle 的判决(`outcome` 三词、非人结局的 `cause`、park 路由的 `parked`):键与开卡帧对位(`askId` / `taskId` / `approvalId`,开卡帧上有的身份这里都有),消卡按开卡那一帧的键。
  * 与 {@link ApprovalRevokeFrame} 的分工:撤卡帧是**批级**的(兄弟被赢家连坐成 `VOID` 的那一批,名单 = 那一次原子事务的行集,
  * 不带逐卡终局);本帧是**单卡**的终局(人答 / 窗到期 / park 路由 / 取消 …)。同一只 ask 两帧都可能收到(被撤的兄弟自己的
  * 登记也按 settle 收场)—— 按 `askId` 清卡即可,两帧不冲突。
  *
  * 投递 = 开卡帧的同一只腿传输(`hitl-delivery.ts`:先本 run 账本、再直写 —— sync 腿有 durable run 行时两只都有,bg / resume 腿只有账本)。
- * 门 = 这条连接上**接下过开卡帧的那几只 sink**(没见过开卡帧的 sink 收到消卡帧就是孤儿 close,与旧族同一条门;配对在竞速机一处)。
+ * 门 = 这条连接上**接下过开卡帧的那几只 sink**(没见过开卡帧的 sink 收到消卡帧就是孤儿 close;配对在竞速机一处)。
  */
 export interface ApprovalCompleteFrame {
     /** = SSE 具名事件名(同 `approval_request` 约定)。 */

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

@@ -1,20 +1,20 @@
 /**
- * 一张停驻审批卡的「门」此刻还是不是它 —— 应答口判 `approval_stale` 与按问读口 `state` 的**同一只判官**。
+ * 一张停驻审批卡的「门」此刻还是不是它 —— 续跑腿判 `approval_stale`(`/decide` 与决断口的停驻形都经它)与按问读口 `state` 的**同一只判官**。
  *
  * ## 病灶(为什么要有这一只)
  * 问账行 `PARKED` 是终态(`approval-ask-machine.ts`:`PARKED: []`):赎回腿的单赢者是 **checkpoint 的 CAS**,取消腿动的也是 checkpoint(先 `expire` 门、再驱 run 终局),
  * 两条腿都不改 ask 行的态(赎回受理之后只把决定记在行上,行仍 `PARKED`;门被引擎重开了行也不知道)。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
- * 而应答口对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
+ * 而 7.151.x 及以前的应答口(7.152.0 起已删)对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
  *
  * ## 判官
- * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(应答口的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
+ * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(续跑腿的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
  *  · {@link sightsCurrentGate} —— 「决断方回显的**门身份**(token / `checkpointId`)是不是当前门的同一面」的**唯一**比较(`approval_stale` 律,两道决断门一条,见下一节);
  *    本仓每一处拿**决断方 / 读口给的那把**门身份比「是不是当前门」都经它(`/decide` 的 token 回显、计划审阅的身份回显、下面的 {@link readGateCurrency});
  *    服务端对**自己选出的那张卡**的复核不是回显比较,不经它(`drivePlanReview` 的卡令牌复核答认领输家 `409 conflict.not_resumable`、唤醒腿的赢家比较);
  *    射程:本判官问的是「**哪扇门**」;`/decide` 的 [ref] 第二源问的是「**哪只调用**」(回显的 `boundCallId` vs 载入行的 `toolCallId`)—— 两问不同,所以是两条比较,
  *    不是「不能并」:它们共用同一个 409 答复,缺值规则各按各的问题定(说不出门身份 ⇒ 判「不是」;行上没有 `toolCallId` ⇒ 那一问不判,交引擎的绑定等值校验 fail-closed 兜)。
  *    过期决断的 409 一族(门身份 / 调用绑定两问怎么排成一族、老行那一形答哪个码)是 7.138.0 的设计票(DEBTS-server,主会话开票);
- *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);应答口读它,读口读它,别处不再内联第二份;
+ *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);续跑腿的 stale 臂读它,读口读它,别处不再内联第二份;
  *  · {@link readGateCurrency} —— 一把 token 对着它的读数:`current`(带那一行)/ `absent`(店里没有这一行)/ `settled`(行在,但不再是当前待决门:已结算、已过期、被取代);
  *  · {@link createParkedGateRead} —— 协调器读口的门读席:把读数译成读口要的四种读法({@link ParkedGateReading}),`state` 闭集不加字。
  *
@@ -46,19 +46,19 @@
  * ## `settled` 怎么译(读口只说 checkpoint 上有凭据的话;一条规矩)
  * 落盘的行不受类型面约束(旧版 / 手改 / 坏体 / 更新版本 core 写下的行可带闭集外的词或坏形),所以已结算门只按**一条规矩**读:
  *  ① 两个闭集词(行的 `status`、结算记录的种类 `settlement.kind`)各查一张穷举表,**同一查法**({@link throughTable}:只认表自己的键,非字符串不进表):
- *    表明说 `decided` ⇒ 往下读;明说 `void` ⇒ `void`(没有人决过它,答案无处兑现 —— 已过期〔取消 / 收割〕、仍待决却不是当前门〔被取代,应答口答 stale〕、
+ *    表明说 `decided` ⇒ 往下读;明说 `void` ⇒ `void`(没有人决过它,答案无处兑现 —— 已过期〔取消 / 收割〕、仍待决却不是当前门〔被取代,决断口的停驻形答 `approval_stale`〕、
  *    结算种类是引擎窗到期 / 宿主 SLA 扫 / 无人可答的失败族);**表外 ⇒ `unknown`**(读不懂的词撑不起「有人决过」,也撑不起「没有人决过它」);
  *  ② 结算赢家的门记录 `resolvedOutcome.gateOutcome` 先过 core 唯一的门记录筛 `screenGateOutcome`(**档案读法**:读回的耐久行,闭集 = 今日成员 ∪ 已退役词;
  *    坏形记缺陷、绝不抛;本仓 `trace/project.ts` 投影同一种记录也只经这一只筛),有缺陷 ⇒ `unknown`,过了筛才读它的成员。core 7.56.0 [ref] 起筛自己判
  *    I10(`settlement.when` 是有限数)与 I11(调用方把赢家的 `decision` 一并交给筛:它是赢家拿得出的词,方向与记录的结算种类 / 处置同向)—— 本判官在同一次筛调用里
  *    交 `winnerDecision`,时刻与方向的手判随之退役;
  *  ③ 分类之前记录要**读得全**:有结算记录、赢家绑的是这一行的调用且判词是 allow / deny(与
- *    `findDecidedApprovalsForBinding` 同一只 {@link approvalDecisionOfWinner})—— 缺一个都是 `unknown`(**不编一个首决**;读口答 404,应答口对已结算的门答 409 `approval_stale`,两口不同判;
+ *    `findDecidedApprovalsForBinding` 同一只 {@link approvalDecisionOfWinner})—— 缺一个都是 `unknown`(**不编一个首决**;读口答 404,决断口的停驻臂读作门上没站着决定;
  *    `void` 也要读得全:绑在别的调用上的结算说的不是这张卡);读全了再按**结算种类**表分类:人 / 策略的四个种类 ⇒ `decided`(理由取自赢家的 `reason`),其余十个 ⇒ `void`
  *    (按种类不按当事方:跨版本稳定的是种类词,变过义的是当事方词 —— 此前版本的策略拒记 `policy_refused` + `who.party:"none"`,此后记 `"policy"`,按当事方查会把那一代合法历史记录读成 `void`);
  *  ④ 读的只是行的内容、不碰店:内容坏到读的时候抛(行上缺了必填成员)同样是坏行 ⇒ `unknown`,不冒成店故障(读口对店故障退回 `parked`)。
  * `unknown` 的这一类(`decision_unreadable`)带上读不出的那几处(缺陷句,非空):读口答 404 `tool_approval.not_pending`,并记一行 error(首句 + 计数)。
- * 行没了 ⇒ `unknown`(`row_absent`;应答口 PARKED 臂的 404 `not_found.approval` 同判)。
+ * 行没了 ⇒ `unknown`(`row_absent`;赎回席对「checkpoint 行没了」的 404 `not_found.approval`〔决断口渲成 `not_found.ask`〕同判)。
  *
  * ## 盲区(core 的筛仍不判的一处,如实写下)
  *  · 种类 × 当事方的配对(结算种类与 `settlement.who` 的当事方是否相配)—— 筛不判(core [ref]),本判官也不核:读的是种类。只有坏行 / 手改行才走得到。
@@ -99,7 +99,7 @@ export interface GateCurrencyStore {
 }
 /**
  * 该会话**当前待决的审批门**的 token:审批门型({@link APPROVAL_GATE_KINDS})优先 —— 同会话 `task_done` 纯 park 与新 run 的审批 park 可以并存(表无 per-session pending 唯一约束),
- * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。应答口的 stale 臂与按问读口读这一只。
+ * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。续跑腿的 stale 臂与按问读口读这一只。
  */
 export declare function currentApprovalGateToken(cs: Pick<GateCurrencyStore, "findPendingTokenBySession">, sessionId: string): Promise<CheckpointToken | null | undefined>;
 /** 一把 gate token 对着判官的读数(`current` / `settled` 带分类用的那一行)。 */

package/dist/approval-gate-currency.js

@@ -91,21 +91,20 @@ function readWinner(checkpoint, gateBoundCallId) {
     if (byKind !== "decided")
         return byKind;
     const note = typeof winner?.reason === "string" && winner.reason !== "" ? winner.reason : undefined;
-    return { kind: "decided", decision: direction === "approve" ? "allow" : "deny", decidedAtMs: settlement.when, ...(note !== undefined ? { decisionNote: note } : {}) };
+    return { kind: "decided", decision: direction, decidedAtMs: settlement.when, ...(note !== undefined ? { decisionNote: note } : {}) };
 }
 function isReopenReason(word) {
     return typeof word === "string" && REOPEN_REASONS.includes(word);
 }
 function openReading(checkpoint, gateBoundCallId) {
-    const generation = checkpointRevOf(checkpoint);
     const reason = checkpoint.reopenReason;
     if (!isReopenReason(reason))
-        return { kind: "open", generation };
+        return { kind: "open" };
     const prior = decisionReading(checkpoint, gateBoundCallId);
     const reopened = prior.kind === "decided"
         ? { reason, decision: prior.decision, decidedAtMs: prior.decidedAtMs, ...(prior.decisionNote !== undefined ? { decisionNote: prior.decisionNote } : {}) }
         : { reason };
-    return { kind: "open", generation, reopened };
+    return { kind: "open", reopened };
 }
 export function createParkedGateRead(cs) {
     return async ({ gateToken, gateBoundCallId }) => {

package/dist/approval-hmac.d.ts

@@ -1,3 +1,4 @@
+import type { ParsedPersistRule } from "./tool-approval.js";
 import type { QuestionAnswer } from "@sema-agent/core";
 import type { ApprovalHmacKey } from "./auth-keys.js";
 /**
@@ -76,6 +77,15 @@ export declare function projectQuestionAnswer(a: QuestionAnswer): QuestionAnswer
  *  而是先投影(签它)、再由本函数重建(送它)—— 中间没有第二条路径,所以「签了 A 却转发了 A′」
  *  在结构上不可能。`note` 为 `null` ⇒ **不造键**(与 core `QuestionAnswerItem.note?` 的缺席同义)。 */
 export declare function questionAnswerFromProjection(p: QuestionAnswerProjection): QuestionAnswer;
+/**
+ * 「不再询问」规则位(`/decide` 体上的 `persistRule`,已过唯一体形判官)在签名载荷里的**投影**:一只定序元组 —— batch 臂 `["batch", 下标]`,文本两臂
+ * `["text", 规则文本, edited]`。签的是投影、转发的是由同一份投影重建的那一位({@link persistRuleFromProjection}),「签了 A 却兑了 A′」结构上不可能(与 `answer` 同形)。
+ * 不送它的签名器零改动(扩展位,缺席 ⇒ 一个字节都不追加)。
+ */
+export type PersistRuleProjection = readonly ["batch", number] | readonly ["text", string, boolean];
+export declare function projectPersistRule(slot: ParsedPersistRule): PersistRuleProjection;
+/** 投影 → 兑付收的那一位(**「签的 = 兑的」的兑现点**)。 */
+export declare function persistRuleFromProjection(p: PersistRuleProjection): ParsedPersistRule;
 /**
  * 信封的**扩展键闭集**(字典序 = 声明序 = `ext` 的 JSON 键序)。
  *
@@ -83,7 +93,7 @@ export declare function questionAnswerFromProjection(p: QuestionAnswerProjection
  * 下面那两条编译期门当场红。**不许有第三种在场判**:恒 `!== undefined`(不是真值判、也不是 `?? null`
  * 折叠)—— `null` 与缺席在扩展位上是两个不同的被签值(「签名方明说这次不动」≠「签名方不知道有这个键」)。
  */
-export declare const APPROVAL_ENVELOPE_EXT_KEYS: readonly ["answer", "checkpointId", "permissionModeAfter"];
+export declare const APPROVAL_ENVELOPE_EXT_KEYS: readonly ["answer", "checkpointId", "permissionModeAfter", "persistRule"];
 export type ApprovalEnvelopeExtKey = (typeof APPROVAL_ENVELOPE_EXT_KEYS)[number];
 /** The canonical envelope both {@link approvalHmacMessage} (the signer's/verifier's shared byte-rule) and
  *  {@link verifyApprovalHmac} take — ONE named type so the two signatures cannot silently drift into two
@@ -128,6 +138,12 @@ export interface ApprovalEnvelope {
      * —— 证明是瞬时物不是持久数据,没有迁移面,消费方的 401 就是通知(宪法「hard breaking 三句」)。
      */
     permissionModeAfter?: string | null;
+    /**
+     * `/decide` 的「不再询问」规则位(投影形 {@link PersistRuleProjection})进签名载荷。一条规则就是一条常驻放行 —— 与 `answer` / `permissionModeAfter` 同一条判据:
+     * **凡改变续跑能做什么 / 落什么账的决裁字段都在签名信封里**。直连门部署上停驻卡只有 `/decide` 这一扇口,拒收它就在这里造出一处「行说有、门拒键」。
+     * 在场才进扩展对象;缺席 ⇒ 字节与不认识它的签名器逐字相同(既有签名器零改动);带了不签 ⇒ `401 approval_mac_invalid`。
+     */
+    persistRule?: PersistRuleProjection;
 }
 export declare function approvalHmacMessage(env: ApprovalEnvelope): string;
 /** 签名载荷里 `reason` 的字符上限。**拒**而不是截 —— 截断在这条路径上**结构上不可行**:服务端截过的字节

package/dist/approval-hmac.js

@@ -5,7 +5,13 @@ export function projectQuestionAnswer(a) {
 export function questionAnswerFromProjection(p) {
     return { answers: p.map(([header, selected, note]) => ({ header, selected: [...selected], ...(note === null ? {} : { note }) })) };
 }
-export const APPROVAL_ENVELOPE_EXT_KEYS = ["answer", "checkpointId", "permissionModeAfter"];
+export function projectPersistRule(slot) {
+    return slot.kind === "batch" ? ["batch", slot.batchOfferIndex] : ["text", slot.rule, slot.edited];
+}
+export function persistRuleFromProjection(p) {
+    return p[0] === "batch" ? { kind: "batch", batchOfferIndex: p[1] } : { kind: "text", rule: p[1], edited: p[2] };
+}
+export const APPROVAL_ENVELOPE_EXT_KEYS = ["answer", "checkpointId", "permissionModeAfter", "persistRule"];
 const APPROVAL_ENVELOPE_HEAD_KEYS = ["sessionId", "boundCallId", "boundInputHash", "decision", "reason"];
 export function approvalHmacMessage(env) {
     const head = [env.sessionId, env.boundCallId ?? null, env.boundInputHash ?? null, env.decision, env.reason ?? null];

package/dist/approval-queue-kind.d.ts

@@ -4,7 +4,7 @@
  * ## 规则(一句)
  * `GET /v1/approvals` 的 `pending[]`(与 `/v1/approvals/stream` 的 `pending` / `resolved` 帧)= **决断口是 `POST /v1/approvals/:id/decide` 的全部行**;
  * 每一行自报它属于哪一族(`kind`,本闭集一词),消费方**先按 `kind` 分支**,再读那一族的键。数组名仍是决断口的判据(`livePending[]` 的口是
- * `POST /v1/tool-approvals/:approvalId/respond`,不在本闭集里);本闭集回答的是「同一扇门后面是哪一种卡」。
+ * 决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`,不在本闭集里);本闭集回答的是「同一扇门后面是哪一种卡」。
  *
  *  · `checkpoint` —— 停驻门(durable park):行 = 店的 `listPending` 那一行(键集照旧,另带 `kind`),门的 `:id` = 行的 `sessionId`,
  *    再按 `gateKind`(core 的门型闭集)分路;

package/dist/approval.d.ts

@@ -71,8 +71,8 @@ export declare function gateIntentUnserviceableReason(config: GateIntentView, ch
 /**
  * [ref] C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
  *
- * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(`TOOL_APPROVAL_ENABLED`)也没有
- * durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
+ * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(只在呈卡协议上场时构造:`TOOL_APPROVAL_ENABLED` ∧ store backend ∧
+ * park 设施)也没有 durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
  * 运维要在 **boot** 就知道,否则会把随之而来的拒绝读成故障。两条 warn 按「ask 从哪来」**划分车道**,互补不重叠:
  *  · `fs_write_gate_no_responder` —— 写门的 Write/Edit ask。它只在**手写本机盘**时才会发生(写门挂在 host
  *    语义上,而 ask 要有手去触发)⇒ 判据 = {@link handsOnWorkerFilePlane}(今天 = `host`)。改前写的是

package/dist/approval.js

@@ -39,7 +39,7 @@ export function buildNoResponderBootWarns(input) {
         out.push({
             event: "fs_write_gate_no_responder",
             fields: {
-                hint: "host-semantics lane with no approval face: the engine's write-gate asks (permissionMode default/auto, absent reads as default; acceptEdits outside the write roots) will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
+                hint: "host-semantics lane with no approval face: the engine's write-gate asks (permissionMode default/auto, absent reads as default; acceptEdits outside the write roots) will auto-deny (fail-closed); wire DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to answer them (approval cards additionally need TOOL_APPROVAL_ENABLED)",
             },
         });
     }
@@ -47,7 +47,7 @@ export function buildNoResponderBootWarns(input) {
         out.push({
             event: "workflow_gate_no_responder",
             fields: {
-                hint: "self-orchestration with no approval face: run_workflow asks (every permission mode but bypassPermissions, which releases them, and dontAsk, which refuses them; absent reads as default) will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
+                hint: "self-orchestration with no approval face: run_workflow asks (every permission mode but bypassPermissions, which releases them, and dontAsk, which refuses them; absent reads as default) will auto-deny (fail-closed); wire DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to answer them (approval cards additionally need TOOL_APPROVAL_ENABLED)",
             },
         });
     }

package/dist/bind-host.d.ts

@@ -1,8 +1,6 @@
 /** 读监听地址要的那几格(取自配置的同名键)。 */
 export interface BindHostConfig {
     bindHost?: string;
-    /** 缝合审 M5:`bindHost` 的**来源**决定它算不算 operator 明示,见 {@link resolveBindHost}。 */
-    bindHostSource?: "BIND_HOST" | "HOST";
     allowUnauthedWrites?: boolean;
     authToken?: string;
     authTokens?: Record<string, string>;
@@ -12,7 +10,7 @@ export interface BindHostConfig {
 export declare function bindMustNarrow(config: Pick<BindHostConfig, "allowUnauthedWrites" | "authToken" | "authTokens">): boolean;
 /**
  * 这台进程的监听地址(绑址旋钮 + 无鉴权自收窄)。`undefined` = Node 缺省全接口。
- * `BIND_HOST`(兼容 `HOST`)显式值恒生效;缺省:**无鉴权写面(`allowUnauthedWrites` 且零凭据)自动收窄到 127.0.0.1**,其余维持全接口。
+ * `BIND_HOST` 显式值恒生效(绑址的唯一来源:`HOST` 不读);缺省:**无鉴权写面(`allowUnauthedWrites` 且零凭据)自动收窄到 127.0.0.1**,其余维持全接口。
  */
 export declare function resolveBindHost(config: BindHostConfig): string | undefined;
 /**

package/dist/bind-host.js

@@ -5,10 +5,9 @@ export function bindMustNarrow(config) {
     return Boolean(config.allowUnauthedWrites) && !hasServiceAuth(config);
 }
 export function resolveBindHost(config) {
-    const mustNarrow = bindMustNarrow(config);
-    if (config.bindHost && !(mustNarrow && config.bindHostSource === "HOST"))
+    if (config.bindHost)
         return config.bindHost;
-    return mustNarrow ? "127.0.0.1" : undefined;
+    return bindMustNarrow(config) ? "127.0.0.1" : undefined;
 }
 export function listensLoopbackOnly(bindHost) {
     if (bindHost === undefined)

package/dist/boot/coordinators.d.ts

@@ -38,7 +38,7 @@ export interface LiveCoordinatorsCtx {
      *  提交了没有」—— 审计 settle 行等 park 提交落定才写。缺席 = 没有 park 设施(core 在 ask 回调处就收场,没有提交这一步)。 */
     parkCommits?: ParkCommitWatch;
     /** [ref]:checkpoint 店(stage-06 的**同一只**,与 `parkCommits` 同源;在场 ⇔ 有 park 设施)。协调器的按问读口据它判一张 `PARKED` 卡的门此刻还是不是该会话当前待决的审批门
-     *  (判官 = `approval-gate-currency.ts`,应答口判 `approval_stale` 读的同一只)。缺席 ⇒ 读口只能说行说的话(`parked`)。
+     *  (判官 = `approval-gate-currency.ts`,续跑腿判 `approval_stale` 读的同一只)。缺席 ⇒ 读口只能说行说的话(`parked`)。
      *  也是流内审批协议上场门的 park 设施位:在场性与实例是一个事实 —— 门的 `active` 臂交出去的就是这一只,缺席 ⇒ 协议不上场(`no_park_facility`)。 */
     checkpointStore?: GateCurrencyStore;
 }

package/dist/boot/coordinators.js

@@ -19,18 +19,18 @@ export function createLiveCoordinators(ctx) {
     const durableEnabled = parkStore !== undefined;
     const streamApprovalGate = resolveStreamApprovalGate({
         toolApprovalEnabled: config.toolApprovalEnabled === true,
-        streamApprovalEnabled: config.streamApproval.enabled,
         backend,
         checkpointStore: parkStore,
     });
-    if (config.streamApproval.enabled && !streamApprovalGate.active) {
-        logger.info("stream_approval_disabled", {
+    if (!streamApprovalGate.active && streamApprovalGate.reason !== "no_tool_approval") {
+        logger.warn("approval_cards_unavailable", {
             reason: streamApprovalGate.reason,
             backendKind: backend?.kind ?? null,
             checkpointStore: backend?.checkpoint !== undefined,
             durableApproval: config.durableApproval === true,
-            toolApproval: config.toolApprovalEnabled === true,
-            askWindowMs: config.streamApproval.windowMs,
+            unattendedPolicy: config.unattendedApprovalPolicy,
+            note: "no approval card is presented on ANY leg of this worker (approval cards need a durable approval ledger: a store backend plus a park facility), so every gated tool call is refused fail-closed. " +
+                "Set DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to get approval cards.",
         });
     }
     if (config.toolApprovalEnabled === true && config.streamApproval.windowMs === 0) {
@@ -47,12 +47,11 @@ export function createLiveCoordinators(ctx) {
         ? new FileApprovalAskAuditStore(config.localDataRoot)
         : undefined;
     const approvalExemptionStore = backend ? backend.approvalExemption() : undefined;
-    const toolApproval = config.toolApprovalEnabled
+    const toolApproval = streamApprovalGate.active
         ? new ToolApprovalCoordinator({
             ttlMs: config.streamApproval.windowMs,
-            ...(streamApprovalGate.active
-                ? { askStore: streamApprovalGate.askStore, unreachedTtlMs: config.streamApproval.unreachedTtlMs }
-                : {}),
+            askStore: streamApprovalGate.askStore,
+            unreachedTtlMs: config.streamApproval.unreachedTtlMs,
             windowMarginMs: config.streamAskWindowMarginMs,
             admitMaxPerTask: config.streamApproval.admitMaxPerTask,
             admitMaxPerOwner: config.streamApproval.admitMaxPerOwner,
@@ -103,7 +102,7 @@ export function createLiveCoordinators(ctx) {
         const send = sendFileLedger
             ? withLedgerRecording(rawSend, {
                 ledger: sendFileLedger,
-                deleteObject: (bucket, key) => issuer.deleteObject(bucket, key),
+                deleteObject: (bucket, key, track) => issuer.deleteObject(bucket, key, track),
                 warn: (msg, meta) => logger.warn(msg, meta),
             })
             : rawSend;