@sema-agent/server 7.139.0 → 7.141.0

package/dist/task-settings.d.ts

@@ -49,10 +49,11 @@
  */
 import { type PathRuleBases, type TaskSpec, type ThinkingLevel, type ToolPolicy, type PermissionMode } from "@sema-agent/core";
 import { type EntryProblem } from "./entry-problems.js";
+import { type RuleListEntry } from "./permission-rule-list.js";
 import { type KeyClosureIssue } from "./request-key-closure.js";
 import { type RunnableHooksConfig } from "./hooks/hook-runner.js";
 import type { StoredHooksRereadM20 } from "./stored-request-hooks-m20.js";
-import { type EntryPermissionMode } from "./runtime-governance.js";
+import type { EntryPermissionMode } from "./runtime-governance.js";
 import { type TightenOnlySeatValues } from "./tighten-only-seats.js";
 /**
  * 请求面 `permissionMode` 的闭集 = core `PERMISSION_MODES` **全集**(顶层 `permissionMode` / `settings.permissions.defaultMode` /
@@ -112,23 +113,21 @@ export declare function planReviewDecisionExitsPlan(decision: "approve" | "edit"
 /**
  * 运维 `AUTONOMY=plan` 的**入口词地板**盖进提交体 —— 此后一条 run 的模式词只有存储体顶层 `permissionMode` 一个源。
  *
- * 入口词 = `runtime-governance.ts` `entryPermissionMode(体的生效词, 地板).effective`(「词在地板下变成什么」的唯一一只函数;秩是 core 的)。本函数只加
- * 「写进体」这一半:地板缺席 ⇒ 体**原物**交回(零字节变化);地板在场 ⇒ 新体 `{ ...body, permissionMode: 入口词 }`,调用方的对象不改;bundle 的
- * `settings.permissions.defaultMode` 不动 —— 顶层赢过它({@link effectivePermissionMode} 的优先序),再改它就是同一语义的第二个写者。
- * 同时交回**这一次求值的读数**(`entry`:请求词 / 地板 / 生效词 / 折没折)—— 披露这一折的通告(`entry-mode-clamp-notice.ts`)读它,不另判一遍。
+ * 入口词由受理判官答(`permission-mode-admission.ts` `admitPermissionModeWord`:两口 —— 提交受理口与在飞 run 的切档口 —— 同一只;它交回的
+ * `entry` 就是「词在地板下变成什么」那一次求值的读数,秩是 core 的)。本函数只做「写进体」这一半:地板缺席 ⇒ 体**原物**交回(零字节变化);地板在场 ⇒
+ * 新体 `{ ...body, permissionMode: entry.effective }`,调用方的对象不改;bundle 的 `settings.permissions.defaultMode` 不动 —— 顶层赢过它
+ * ({@link effectivePermissionMode} 的优先序),再改它就是同一语义的第二个写者。披露这一折的通告(`entry-mode-clamp-notice.ts`)读的也是同一份 `entry`。
  *
- * 调用点一个:提交入口(`http/admission.ts` 的 `prepareSpec`:值形门全部判完之后、`resolveSpec` 之前)。那一份体就是首跑装配读的体,也是
+ * 调用点一个:提交入口的那一步 `permission-mode-admission.ts` `stampSubmissionEntryMode`(受理判官的入口一步;`http/admission.ts` 的 `prepareSpec` 调它:值形门全部判完之后、`resolveSpec` 之前)。那一份体就是首跑装配读的体,也是
  * `buildCheckpointCtx` 持久化的体 ⇒ 一处盖章同时覆盖首跑与每一次续跑重建;装配腿与续跑腿都不读地板(两处读 = 两个源)。
- * 另一个写者是 `plan_review` 写回(`http/resume-legs.ts` `drivePlanReview`,判据 {@link planReviewDecisionExitsPlan})。
- * 热改 `AUTONOMY` 只影响之后提交的任务:在飞的 run 保持它出生时盖下的词。地板的属主是 `runtime-governance.ts` 的 `autonomyModeFloor`。
+ * 另外两个写者是 `plan_review` 写回(`http/resume-legs.ts` `drivePlanReview`,判据 {@link planReviewDecisionExitsPlan})与在飞 run 的切档口写回
+ * (`http/routes/run-permission-mode.ts`,写的是同一只判官准入的词)。
+ * 热改 `AUTONOMY` 只影响之后提交的任务与之后的切档:续跑腿保持存储体里的词。地板的属主是 `runtime-governance.ts` 的 `autonomyModeFloor`。
  */
 export declare function stampEntryPermissionMode<B extends {
     permissionMode?: unknown;
     settings?: unknown;
-}>(body: B, floor: PermissionMode | undefined): {
-    readonly body: B;
-    readonly entry: EntryPermissionMode;
-};
+}>(body: B, entry: EntryPermissionMode): B;
 /**
  * [ref] —— **一条已持久化的提交体的生效 permission mode**,单点。
  *
@@ -150,8 +149,8 @@ export declare function storedBodyPermissionMode(body: {
  *  future-proof). Awareness rides for free: core composes ORCHESTRATION_AWARENESS from thinking∈{xhigh,max}, no field. */
 export declare function effectiveThinking(reasoningEffort: unknown, ultracode: boolean): ThinkingLevel | undefined;
 /**
- * [ref] §6-1 —— 本请求的**生效** permission mode,单点。优先序:顶层 `body.permissionMode`(本轮显式表态)赢过 bundle 的
- * `settings.permissions.defaultMode`;两处都没有 ⇒ `undefined` = **无表态**(调用点据此不写键,而不是替调用方选一个默认值;引擎把缺席读成 `default`)。
+ * [ref] §6-1 —— 本请求的**生效** permission mode,单点 = 调用方的词({@link requestedPermissionMode})经本任务 settings 的 kill-switch 折叠
+ * ({@link foldDisableAutoMode})。两处都没有 ⇒ `undefined` = **无表态**(调用点据此不写键,而不是替调用方选一个默认值;引擎把缺席读成 `default`)。
  *
  * 🔴 为什么必须是一只函数:同一个「生效模式」此前在 resolve-spec 里被算过两次(hooks 腿的 `permission_mode` 载荷、settings 折叠腿),
  * 两处各算各的,任何一次优先序修订都会让两面分家,而分家在这条轴上的形态是「壳发的 bundle bypass 在 A 面生效、在 B 面没生效」这种
@@ -160,6 +159,23 @@ export declare function effectiveThinking(reasoningEffort: unknown, ultracode: b
 export declare function effectivePermissionMode(body: {
     permissionMode?: unknown;
 }, settings: ParsedTaskSettings | undefined): PermissionMode | undefined;
+/**
+ * 调用方在提交体上说出的模式词 —— 顶层 `body.permissionMode`(本轮显式表态)赢过 bundle 的 `settings.permissions.defaultMode`;两处都没有 ⇒ `undefined`。
+ * 读者两个:{@link effectivePermissionMode}(存储体读法)与提交口交给受理判官入口一步的那一个词(`permission-mode-admission.ts` `stampSubmissionEntryMode`)。
+ */
+export declare function requestedPermissionMode(body: {
+    permissionMode?: unknown;
+}, settings: ParsedTaskSettings | undefined): PermissionMode | undefined;
+/**
+ * [ref] 件⑥([ref] §3.4,[ref]/[ref]):本任务 settings 的 kill-switch `permissions.disableAutoMode` 的**唯一**折叠(tighten-only,CC 250 `Ct`
+ * 棘轮形):把 auto 折 default(座不写 ⇒ 引擎不武装,与 CC「auto 不可用 ⇒ 回 default」同向)。只关 auto;缺席不动;没有放宽臂。
+ * 读者两个:存储体读法 {@link effectivePermissionMode} 与受理判官(`permission-mode-admission.ts`,提交口与切档口同一只)—— 切档口的
+ * `auto` 因此与提交口的 `auto` 在同一份 settings 下折成同一个词。`disableBypassPermissionsMode` 落点归 [ref]。
+ * 🔴 [ref] 放宽一档:折叠触发词是 **`"disable"` 或 `true`** —— 两套**已发布**的合法拼写(CC 250 `Ct` 的严极词 /
+ * `@sema-agent/sdk` 8.1.0 `SettingsPermissions.disableAutoMode?: boolean`),同义同折。显式 `false` = 「不禁」,
+ * 合法输入、**零效果**(不是「开 auto」的开关 —— 本键只有关的半场,放宽臂在这条轴上从来不存在)。
+ */
+export declare function foldDisableAutoMode(word: PermissionMode | undefined, settings: ParsedTaskSettings | undefined): PermissionMode | undefined;
 /**
  * [ref] —— [ref] 技能清单预算两旋钮的**值域谓词**(一对具名单铸点)。
  *
@@ -182,9 +198,10 @@ export declare function skillListingMaxDescOk(v: unknown): v is number;
 export interface ParsedTaskSettings {
     permissions?: {
         allow?: string[];
-        deny?: string[];
-        /** Carried for completeness; v1 folds `ask` into the gate via the deny-wins base (see {@link applyTaskSettings}). */
-        ask?: string[];
+        /** 纯串 = 请求自己写的规则;`{ rule, layer }` = 端从某个设置层读来的规则(`permission-rule-list.ts` 的 {@link RuleListEntry};层只选 `/` 的锚)。 */
+        deny?: RuleListEntry[];
+        /** 同 `deny` 的条目形;编译与 `deny` 同一口({@link deriveSettingsPolicy})。 */
+        ask?: RuleListEntry[];
         defaultMode?: PermissionMode;
         /** [ref] 件⑥([ref] §3.4,[ref];PM 裁 [ref]):CC settings 的 kill-switch `permissions.disableAutoMode`,cli 投影
          *  (settingsRulesWire.ts toWireSettings)而此前本白名单丢弃 ⇒ 用户/managed 层关 auto 到不了引擎。语义 = 只能关
@@ -276,7 +293,7 @@ export interface SettingsPermissionBucketIssue {
 /**
  * 三桶的**唯一**判据(纯函数)。`perms` 不是对象 ⇒ 不判(那一形归「settings.permissions must be an object」那道门);桶缺席 / `null`
  * ⇒ 不判(与 `permissions: null` 的「容器缺席」同一约定)。逐桶按 {@link SETTINGS_PERMISSION_BUCKETS} 的序、按该桶的条目规则:不是数组 ⇒ `bad_entry`
- * (无 `index`);`rule_policy` 桶超帽 ⇒ `over_cap`(先判,拒体有界)、首个非串 / 空串项 ⇒ `bad_entry` + 它的下标;`allow_layer` 桶首个非串项 ⇒
+ * (无 `index`);`rule_policy` 桶超帽 ⇒ `over_cap`(先判,拒体有界)、首个不合条目律的项(不是非空串、也不是合形的带层条目)⇒ `bad_entry` + 它的下标;`allow_layer` 桶首个非串项 ⇒
  * `bad_entry` + 它的下标(整表判据 = `ruleEntryListShapeOk`),超帽同样 `over_cap`(帽的理由不同,见段头)。全合法 ⇒ `null`。
  */
 export declare function settingsPermissionBucketIssue(perms: unknown): SettingsPermissionBucketIssue | null;
@@ -432,6 +449,12 @@ export interface FsWriteGateWiring {
      * 运维在**下单那一刻**就知道这条规则这条车道读不了,而不是等到跑起来每次都弹一张 ask。
      */
     taskHome?: string;
+    /**
+     * **执行环境的配置根**(唯一属主 `execution-config-root.ts` 的 `executionConfigRootOf`):user 设置层里 `/` 形路径规则的根 —— 带 `layer: "userSettings"`
+     * 且要 `root` 的条目编进只声明 `{ root: configRoot }` 的那一集(`permission-rule-list.ts` 的 `ruleRootOf`)。缺席(沙箱车道既没转 `SEMA_CONFIG_DIR`、home 也读不出)
+     * ⇒ 这样的条目由 {@link rejectUnmatchableSettingsNames} 响亮拒(422 `home_unresolvable`),不猜目录。拒点与存体预判读同一只函数。
+     */
+    configRoot?: string;
 }
 /**
  * 请求的 `settings.permissions.deny` / `ask` 有永远不生效的条目 ⇒ 拒点({@link rejectUnmatchableSettingsNames})抛的错:句子(`message`)与这一遍判下来的**全部**问题(`problems`,机读位的原料)。
@@ -454,20 +477,24 @@ export declare const RULE_POLICY_BUCKETS: readonly ["ask", "deny"];
 export type RulePolicyBucket = (typeof RULE_POLICY_BUCKETS)[number];
 /**
  * deny / ask 两桶的**完整规则判**,唯一一只(拒点 {@link rejectUnmatchableSettingsNames} 与存体预判 `http/stored-body-replay.ts` 同调):
- *  ② 按 {@link RULE_POLICY_BUCKETS} 的序逐桶问 `judgeUnmatchableToolNames`(名字层 + core 规则文法);③ 再逐桶判 `~/` 形要 home 的那一拒。答 `{ bucket, message, problems }`:`bucket` 与 `message` 是**第一处**坏处的
- *  (句子冻结,先撞上的那一条),`problems` 是**两段、两只桶判下来的全部**坏条目(机读位的原料,形的属主 `entry-problems.ts`)。
- * 入参:桶、{@link RulePolicyBases}。**home 同源**:拒点的 home 是 `resolve-spec.ts` 的 `laneHomeBase()` 经 `executionLaneHomeDir(config)` 算出的,预判传同一个函数对同一份部署配置算出的。
- * **声明给文法的基**只有拒点有(根 + home 的并集,执行车道才知道根):core 的规则文法对**没声明**的基不下判词(见 `config.ts` `uncompilableRuleGuidance`),所以预判什么也不声明、两腿逐字同句;
+ *  ② 按 {@link RULE_POLICY_BUCKETS} 的序逐桶、桶内按 `RULE_ROOTS` 的序逐集(`permission-rule-list.ts` 的 `ruleSetsOf`:判的就是要编的那一集)问 `judgeUnmatchableToolNames`(名字层 + core 规则文法);
+ *  ③ 再判「这条规则要的基本部署给不出」那一拒:`~/` 形缺 home;配置根那一集缺配置根(两者都落在执行环境的 home 上,同词 `home_unresolvable`)。答 `{ bucket, message, problems }`:`bucket` 与 `message` 是**第一处**坏处的
+ *  (句子冻结,先撞上的那一条),`problems` 是**两段、两只桶判下来的全部**坏条目(机读位的原料,形的属主 `entry-problems.ts`;`entry` = 规则原文,带层条目也一样)。
+ * 入参:桶、{@link RulePolicyBases}。**home 同源**:拒点的 home 是 `resolve-spec.ts` 的 `laneHomeBase()` 经 `executionLaneHomeDir(config)` 算出的,预判传同一个函数对同一份部署配置算出的;配置根同理(`executionConfigRootOf`)。
+ * **任务根那一集声明给文法的基**只有拒点有(根 + home 的并集,执行车道才知道根):core 的规则文法对**没声明**的基不下判词(见 `config.ts` `uncompilableRuleGuidance`),所以预判什么也不声明、两腿逐字同句;
  * 预判不能把 home 当「半个基」声明给文法 —— core 的路径族只从根推,缺根时一个合法的 Windows 形 home 会按默认族被判 `unsupported.path_base`(V6-k)。
- * ③ 排在最后:一条同时文法不成立又带 `~/` 的规则,先说文法(补上 home 它仍被文法拒,先说 home 是误导)。
+ * **配置根那一集**两腿都声明 `{ root: 配置根 }`:两腿都算得出它,`{ root }` 自带路径族(没有「半个基」),一个用不了的配置根(转进沙箱的相对值)两腿同为引擎的 `unsupported.path_base`。
+ * ③ 排在最后:一条同时文法不成立又缺基的规则,先说文法(补上基它仍被文法拒,先说基是误导)。
  */
 export interface RulePolicyBases {
-    /** 声明给 core 规则文法的路径基(这条 task 的根 + home):拒点才有;存体预判不声明。 */
+    /** 声明给 core 规则文法的任务根那一集的路径基(这条 task 的根 + home):拒点才有;存体预判不声明。 */
     readonly declared?: PathRuleBases;
     /** 执行环境的 home(`~/` 形规则的前提);这个部署解不出 ⇒ 缺席。 */
     readonly home?: string;
+    /** 执行环境的配置根(配置根那一集的根;拒点与预判都给);读不出 ⇒ 缺席。 */
+    readonly configRoot?: string;
 }
-export declare function rulePolicyBucketsRefusal(permissions: Readonly<Partial<Record<RulePolicyBucket, readonly string[]>>>, bases: RulePolicyBases): {
+export declare function rulePolicyBucketsRefusal(permissions: Readonly<Partial<Record<RulePolicyBucket, readonly RuleListEntry[]>>>, bases: RulePolicyBases): {
     readonly bucket: RulePolicyBucket;
     readonly message: string;
     readonly problems: readonly EntryProblem[];

package/dist/task-settings.js

@@ -2,14 +2,14 @@ import { combinePolicies, parseRuleText, resolveReasoningProfile, rankOf, isThin
 import { judgeUnmatchableToolNames } from "./config.js";
 import { NAME_TABLE_BEHAVIOR } from "./namespaced-rule-name.js";
 import { entryProblem } from "./entry-problems.js";
-import { MAX_PERMISSION_RULES_PER_LIST, createRuleListPolicy } from "./permission-rule-list.js";
+import { MAX_PERMISSION_RULES_PER_LIST, RULE_ROOTS, createRuleListPolicy, ruleListEntryOk, ruleSetsOf, ruleSourceOf, ruleTextOf } from "./permission-rule-list.js";
 import { allowLayerEntryCountIssue, describeAllowLayerOverCap, ruleEntryListShapeOk } from "./rule-entry-list.js";
 import { limitRefusal } from "./limit-refusal.js";
 import { tightenGoverned } from "./governance-overrides.js";
 import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "./request-key-closure.js";
 import { hooksCoordinate, parseHooksConfig } from "./hooks/hook-runner.js";
+import { SETTINGS_SOURCES } from "@sema-agent/settings-schema";
 import { heldRuleName } from "./tool-rule-names.js";
-import { entryPermissionMode } from "./runtime-governance.js";
 import { policyAskStandingAnswerFacts, standingAnswerDurablyRecordable } from "./tool-approval.js";
 import { createRequestNeverAutoPolicy } from "./approval.js";
 import { readTightenOnlySeats, tightenOnlySeatField, tightenOnlySpecSeats } from "./tighten-only-seats.js";
@@ -39,9 +39,8 @@ export function planReviewDecisionExitsPlan(decision) {
             return false;
     }
 }
-export function stampEntryPermissionMode(body, floor) {
-    const entry = entryPermissionMode(storedBodyPermissionMode(body), floor);
-    return { body: entry.floor === undefined ? body : { ...body, permissionMode: entry.effective }, entry };
+export function stampEntryPermissionMode(body, entry) {
+    return entry.floor === undefined ? body : { ...body, permissionMode: entry.effective };
 }
 export function storedBodyPermissionMode(body) {
     return effectivePermissionMode(body, parseTaskSettings(body.settings).settings);
@@ -54,11 +53,16 @@ export function effectiveThinking(reasoningEffort, ultracode) {
     return explicit && rankOf(explicit) > rankOf(ultra) ? explicit : ultra;
 }
 export function effectivePermissionMode(body, settings) {
-    const requested = coercePermissionMode(body.permissionMode) ?? settings?.permissions?.defaultMode;
+    return foldDisableAutoMode(requestedPermissionMode(body, settings), settings);
+}
+export function requestedPermissionMode(body, settings) {
+    return coercePermissionMode(body.permissionMode) ?? settings?.permissions?.defaultMode;
+}
+export function foldDisableAutoMode(word, settings) {
     const kill = settings?.permissions?.disableAutoMode;
-    if (requested === "auto" && (kill === "disable" || kill === true))
+    if (word === "auto" && (kill === "disable" || kill === true))
         return "default";
-    return requested;
+    return word;
 }
 export function skillListingBudgetFractionOk(v) {
     return typeof v === "number" && Number.isFinite(v) && v > 0 && v <= 1;
@@ -105,12 +109,12 @@ function bucketIssueMessage(f, rule) {
             switch (rule) {
                 case "rule_policy":
                     return f.index === undefined
-                        ? `${f.field} must be an array of non-empty rule strings — refused rather than ignored, because an ignored list reads as "in effect" to the caller`
-                        : `${f.field}[${f.index}] is not a non-empty rule string — every entry must be one. Refused rather than dropped, because a dropped entry reads as "in effect" to the caller`;
+                        ? `${f.field} must be an array of rule entries (a non-empty rule string, or { "rule": <rule>, "layer": <settings source> }) — refused rather than ignored, because an ignored list reads as "in effect" to the caller`
+                        : `${f.field}[${f.index}] is neither a non-empty rule string nor a { "rule", "layer" } entry (exactly those two keys; rule = a non-empty rule string; layer = one of ${SETTINGS_SOURCES.join(", ")}) — every entry must be one. Refused rather than dropped, because a dropped entry reads as "in effect" to the caller`;
                 case "allow_layer":
                     return f.index === undefined
                         ? `${f.field} must be an array of permission-rule strings — refused rather than ignored, because an ignored list reads as "in effect" to the caller`
-                        : `${f.field}[${f.index}] is not a string — every entry must be a permission-rule string. Refused rather than dropped, because a dropped entry reads as "in effect" to the caller`;
+                        : `${f.field}[${f.index}] is not a string — every entry must be a permission-rule string (a settings layer's { "rule", "layer" } entry is read in deny / ask only). Refused rather than dropped, because a dropped entry reads as "in effect" to the caller`;
             }
     }
 }
@@ -132,7 +136,7 @@ export function settingsPermissionBucketIssue(perms) {
                     if (v.length > MAX_PERMISSION_RULES_PER_LIST)
                         fields = { field, reason: "over_cap", count: v.length, cap: MAX_PERMISSION_RULES_PER_LIST };
                     else {
-                        const index = v.findIndex((x) => typeof x !== "string" || x.length === 0);
+                        const index = v.findIndex((x) => !ruleListEntryOk(x));
                         if (index >= 0)
                             fields = { field, reason: "bad_entry", index };
                     }
@@ -336,8 +340,12 @@ export function createWorkflowAskPolicy(isExempt) {
         nameSets: [{ ask: WORKFLOW_ASK_NAMES }],
     };
 }
-function rejectUnmatchableSettingsNames(perms, pathBases) {
-    const refused = rulePolicyBucketsRefusal(perms, { ...(pathBases !== undefined ? { declared: pathBases } : {}), ...(pathBases?.home !== undefined ? { home: pathBases.home } : {}) });
+function rejectUnmatchableSettingsNames(perms, pathBases, configRoot) {
+    const refused = rulePolicyBucketsRefusal(perms, {
+        ...(pathBases !== undefined ? { declared: pathBases } : {}),
+        ...(pathBases?.home !== undefined ? { home: pathBases.home } : {}),
+        ...(configRoot !== undefined ? { configRoot } : {}),
+    });
     if (refused !== undefined)
         throw new SettingsRuleRefusalError(refused.message, refused.problems);
 }
@@ -354,21 +362,40 @@ export const RULE_POLICY_BUCKETS = ["ask", "deny"];
 export function rulePolicyBucketsRefusal(permissions, bases) {
     let first;
     const problems = [];
+    const declaredFor = (root) => {
+        switch (root) {
+            case "task":
+                return bases.declared;
+            case "configuration":
+                return bases.configRoot !== undefined ? { root: bases.configRoot } : undefined;
+            default: {
+                const unhandled = root;
+                return unhandled;
+            }
+        }
+    };
     for (const bucket of RULE_POLICY_BUCKETS) {
-        const names = permissions[bucket];
-        if (!names)
+        const entries = permissions[bucket];
+        if (!entries)
             continue;
-        const judged = judgeUnmatchableToolNames(`permissions.${bucket}`, names, { consumer: "rule-policy", behavior: bucket, ...(bases.declared !== undefined ? { pathBases: bases.declared } : {}) });
-        if (judged === undefined)
-            continue;
-        first ??= { bucket, message: judged.message };
-        for (const b of judged.bad)
-            problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.permissions.${bucket}`, b.name, b.reason));
+        const sets = ruleSetsOf(entries, bucket);
+        for (const root of RULE_ROOTS) {
+            const names = sets[root].map(ruleTextOf);
+            if (names.length === 0)
+                continue;
+            const declared = declaredFor(root);
+            const judged = judgeUnmatchableToolNames(`permissions.${bucket}`, names, { consumer: "rule-policy", behavior: bucket, ...(declared !== undefined ? { pathBases: declared } : {}) });
+            if (judged === undefined)
+                continue;
+            first ??= { bucket, message: judged.message };
+            for (const b of judged.bad)
+                problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.permissions.${bucket}`, b.name, b.reason));
+        }
     }
     if (bases.home === undefined) {
         for (const bucket of RULE_POLICY_BUCKETS) {
             const field = `permissions.${bucket}`;
-            for (const name of permissions[bucket] ?? []) {
+            for (const name of (permissions[bucket] ?? []).map(ruleTextOf)) {
                 const parsed = parseRuleText(name, bucket);
                 if ("rule" in parsed && ruleToolGrammarOf(parsed.rule.tool) === "path" && parsed.rule.command.startsWith("~/")) {
                     first ??= {
@@ -382,8 +409,36 @@ export function rulePolicyBucketsRefusal(permissions, bases) {
             }
         }
     }
+    if (bases.configRoot === undefined) {
+        for (const bucket of RULE_POLICY_BUCKETS) {
+            const field = `permissions.${bucket}`;
+            for (const name of ruleSetsOf(permissions[bucket] ?? [], bucket).configuration.map(ruleTextOf)) {
+                first ??= {
+                    bucket,
+                    message: `${field} has a user-settings path rule rooted at the configuration directory (${name}) but this deployment cannot name the EXECUTION environment's configuration root — ` +
+                        `it is the SEMA_CONFIG_DIR forwarded into the sandbox, else .sema under the execution environment's home, and this lane's home is unknown; the engine never guesses one. ` +
+                        `Spell the path absolutely (${"Read(//abs/path/**)"} form), forward SEMA_CONFIG_DIR into the sandbox env, declare the lane's home with REMOTE_EXEC_HOME_DIR, or run the task on a lane whose home this worker knows.`,
+                };
+                problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.${field}`, name, "home_unresolvable"));
+            }
+        }
+    }
     return first === undefined ? undefined : { ...first, problems };
 }
+function ruleSetBases(root, taskBases, configRoot) {
+    switch (root) {
+        case "task":
+            return taskBases;
+        case "configuration":
+            if (configRoot === undefined)
+                throw new Error("a user-settings path rule reached the compiler without a configuration root — the admission judgement refuses it first (home_unresolvable); refusing rather than anchoring it at the task root");
+            return { root: configRoot };
+        default: {
+            const unhandled = root;
+            return unhandled;
+        }
+    }
+}
 export const REQUEST_SETTINGS_REFUSAL_PREFIX = "request settings cannot be applied as written: ";
 export function deriveSettingsPolicy(settings, bases) {
     const perms = settings.permissions;
@@ -396,11 +451,19 @@ export function deriveSettingsPolicy(settings, bases) {
         const pathBases = bases?.taskRoot !== undefined || bases?.taskHome !== undefined
             ? { ...(bases.taskRoot !== undefined ? { root: bases.taskRoot } : {}), ...(bases.taskHome !== undefined ? { home: bases.taskHome } : {}) }
             : undefined;
-        rejectUnmatchableSettingsNames(perms, pathBases);
-        if (deny)
-            policies.push(createRuleListPolicy(deny, "deny", RULE_SOURCE_BY_BEHAVIOR.deny, pathBases));
-        if (ask)
-            policies.push(createRuleListPolicy(ask, "ask", RULE_SOURCE_BY_BEHAVIOR.ask, pathBases));
+        rejectUnmatchableSettingsNames(perms, pathBases, bases?.configRoot);
+        for (const [bucket, entries] of [["deny", deny], ["ask", ask]]) {
+            if (!entries)
+                continue;
+            const sets = ruleSetsOf(entries, bucket);
+            for (const root of RULE_ROOTS) {
+                const set = sets[root];
+                if (set.length === 0)
+                    continue;
+                const table = RULE_SOURCE_BY_BEHAVIOR[bucket];
+                policies.push(createRuleListPolicy(set.map((e) => ({ rule: ruleTextOf(e), source: ruleSourceOf(table, e) })), bucket, table, ruleSetBases(root, pathBases, bases?.configRoot)));
+            }
+        }
     }
     if (neverAuto !== undefined) {
         const refused = neverAutoNamesRefusal(neverAuto);

package/dist/terminal.d.ts

@@ -57,13 +57,61 @@ export declare const STORE_ERROR_CODE = "internal.store_error";
  *
  * ⚠️ **辖域如实**:本臂触发条件是「码出了本仓的词法」,所以任何依赖铸出的域外码都落这里,不只 SQL 驱动。
  * 今天可观察的产出方**只有**耐久店那一层(引擎自己的传输/brain 错误在 core 侧已被分类成小写码),故码名
- * 取 `internal.store_error`;原码逐字进 message 与 warn 行,归因从不丢失。
+ * 取 `internal.store_error`;原码逐字进 message 尾注(随结果过汇点脱敏)、是码 token 时进运维 warn 行({@link isCodeToken}),归因从不丢失。
  */
 export declare function outwardFailureCode(code: string): string;
+/**
+ * 一个错误的 `code` 只在它**是**码(短 token)时才说出口 —— 码形座里装着文字的,不是码(驱动码 `ER_*` / SQLSTATE / `ECONNRESET`
+ * 全在这一形里;带空白、`=`、换行或超过 64 字符的就是一句话)。读者两只,同一条判据:折码的运维 warn 行(本文件 {@link sealResultForExit})
+ * 与执行车道占位读的故障词(`boot/execution-env.ts`)。
+ */
+export declare function isCodeToken(code: unknown): code is string;
+/**
+ * 存量结果被**再观看**的读座(闭集):`GET /v1/runs/:id → result`(终态行与停驻行同一座)与账本 `done` 行的回放(三条耐久读腿共用)。
+ * 封口在读座上折码时,运维行按 (读座, 原码) 只报一次 —— 见 {@link sealResultForExit}。
+ */
+export type StoredResultReadSeat = "run.result" | "ev.done.result";
+/**
+ * **一次耐久停驻在一条结果上够得着的全部座** —— 本仓**唯一**一张座表。两个属主共读它,不各抄一份:
+ *  · 出口封口 {@link sealResultForExit} 按它**摘凭据**(`token` 键);
+ *  · 结果汇点 `observability/run-terminal.ts` 的 `redactTerminalResult` 按它**脱门**(`gate` 键,门上有模型 / 人可控的展示文本)。
+ *
+ * 每座 = 从结果根出发的路径 + 该座上的凭据键名与门键名(引擎在两种形上给同一件事起了两套名字:因由形 `token` / `gate`,
+ * 验证器停驻形 `checkpointToken` / `checkpointGate`)。三座是**类型的形状**,不是三个特判:
+ *  · `terminal`                   —— 本腿自己 park(`paused` 臂);
+ *  · `terminal.nestedPause`       —— 嵌套边界(verify / cascade)遇到自己驱动不了的耐久暂停,在它的边界上如实报 `failed`,
+ *                                    把那次暂停整只带在这里(正是这条路径当年让凭据漏进过账本);
+ *  · `verification.verifierPause` —— 验证门里**验证器自己**的停驻(core `VerificationOutcome.verifierPause`,
+ *                                    `unverifiedReason: "verifier_paused"`):在结果因由**之外**,宿主判官看不见它,run 照常终局。
+ *
+ * 表是否完整**不靠记性**:`trace/core-keyset-guard.ts` ⑩f 从 core 的结果类型(普通腿 / verify / cascade 三种出口结果)
+ * **派生**出每一条凭据型路径与门型路径,与本表逐条对账 —— core 在结果的任何一层加一个凭据座或门座 ⇒ tsc 当场红。
+ */
+export declare const PAUSE_SEATS: readonly [{
+    readonly path: readonly ["terminal"];
+    readonly token: "token";
+    readonly gate: "gate";
+}, {
+    readonly path: readonly ["terminal", "nestedPause"];
+    readonly token: "token";
+    readonly gate: "gate";
+}, {
+    readonly path: readonly ["verification", "verifierPause"];
+    readonly token: "checkpointToken";
+    readonly gate: "checkpointGate";
+}];
+/** 座表的一行(类型门 ⑩f 从它派生「本仓摘 / 脱的路径」)。 */
+export type PauseSeat = (typeof PAUSE_SEATS)[number];
+type SeatObject = Readonly<Record<string, unknown>>;
+/**
+ * 对一条结果上**每一座**施一次 `f`,不动的座保持同一引用(一座都没动 ⇒ 整条结果同一引用)。
+ * 对任何输入安全:路径上任一层缺席 / 非普通对象(含数组)⇒ 那一座跳过,不抛、不重塑(读盘面纪律:旧持久 blob / 非 core 的 Runner 实现)。
+ */
+export declare function mapPauseSeats<T>(result: T, f: (seat: SeatObject, keys: PauseSeat) => SeatObject): T;
 /**
  * **一条结果离开引擎、进入本仓(可重放账本 / run 行 / wire)的唯一封口** —— 两件事,一个出口:
- *  ①摘掉**耐久恢复能力凭据**(`CheckpointToken`);②把**域外的失败码**折成本仓的 `internal.store_error`
- *  ({@link outwardFailureCode},[ref])。
+ *  ①摘掉**耐久恢复能力凭据**(`CheckpointToken`)—— 座表 {@link PAUSE_SEATS} 上的每一座;②把**域外的失败码**折成本仓的
+ *  `internal.store_error`({@link outwardFailureCode},[ref])。
  *
  * 🔴 为什么两件事合在一只函数里而不是并列两只(7.92.2 改名 `stripResumeToken` → `sealResultForExit`):
  * 它们是**同一个出口上的同一件事** —— 「这条结果可以见人了吗」。并列两只 = 六个结算点各自要记得调两次,
@@ -71,26 +119,33 @@ export declare function outwardFailureCode(code: string): string;
  * 旧名只说了摘凭据那一半,一个只做一半的名字会让下一个人在另一半上另开出口。
  *
  * ── ① 摘凭据 ──
- * token 就是 resume 凭据(token-as-auth,search [18] Q1b),**永不离开本服务**;非密的 `gate` /
- * `checkpointId` / `restoreMode` 有意保留(对账位)。
- *
- * 🔴 core 7.6.0 起凭据换了住址:它不再是 `TaskResult` 顶层的 `checkpointToken`,而是因由里
- * `paused` 那一臂的 `token`。而**一条结果上够得着 paused 因由的位置有两处**,这是类型的形状,不是特判:
- *  · `terminal`(kind `paused`)—— 本腿自己 park 了;
- *  · `terminal.nestedPause`(kind `failed`)—— 嵌套边界(verify / cascade)遇到自己驱动不了的耐久暂停,
- *    在**它的**边界上如实报 `failed`,而把那次暂停的因由整只带在这里(顶层调用方据此仍能恢复)。
- *    正是这条路径当年让 `checkpointToken` 漏进过账本 —— 摘除腿从来不是「理论上的对称」。
- * 两处走**同一条**摘除规则({@link stripPausedToken}),不是两条。
- *
- * wire 上的形:paused 因由**缺席 `token`**(core 类型里它是必填座,那是**引擎内**的契约;本服务的 wire
- * 契约逐字声明这一座不出服务边界 —— 见 `docs/ASSISTANT-WIRE-CONTRACT.md`)。消费端要动这次暂停,走
+ * token 就是 resume 凭据(token-as-auth,search [18] Q1b),**永不离开本服务**;非密的门 / `checkpointId` /
+ * `restoreMode` / 验证器停驻的 `status` 与 `sessionId` 有意保留(对账位;门的自由文本由结果汇点脱)。
+ * 凭据住在哪几座是 {@link PAUSE_SEATS} 一张表的事,本函数**不**在别处另开摘除臂:漏掉的那一座(验证器停驻,修前)
+ * 正是「座表只写了两座」造成的,修法是座表加一行,不是另起第二处摘字。
+ *
+ * wire 上的形:每一座**缺席**凭据键(core 类型里因由的 `token` 是必填座,那是**引擎内**的契约;本服务的 wire
+ * 契约逐字声明这一座不出服务边界 —— 见 `docs/ASSISTANT-WIRE-CONTRACT.md`)。消费端要动一次停驻,走
  * `/v1/approvals` 决策端点,凭 `checkpointId` 对账,从来不是拿 token 直连引擎。
  *
- * 对任何输入安全(非普通对象 / 无 `terminal` / 因由不带 token ⇒ **同一引用**原样返回,不重塑)。
+ * **出口全集都经这一口**:三家 run 店的行写口与账本店的 `done` 行写口在店入口调它(`observability/run-terminal.ts`),
+ * 同步 200 体 / 流 done 帧 / 续跑决定腿在铸体处调它,`GET /v1/runs/:id{,/events}` 等读面在回放前再调一次 ——
+ * 升级前落盘、还带着凭据的存量行在读面上同样摘掉。两件事都**幂等**,重复过口是同形。
+ *
+ * ── 折码的运维线索:一行定形句,两个观看点同一句 ──
+ * `[terminal] outward_failure_code_folded original=<码 | <not-a-code>> outward=<对外词> messageBytes=<n> at=<exit | 读座>`。
+ * 字段只有闭集词、数字与码 token({@link isCodeToken}):失败句只报字节数,**永不**报原文 —— 失败句是自由文本(驱动句里可以有连接串 / 口令),
+ * 结果里的那份由结果汇点脱敏,日志行没有汇点,所以日志行压根不带它;码形座里装着文字的同理只报 `<not-a-code>`。`at` 说这是哪一次观看:
+ *  · 省略 `readSeat` = 结果**第一次**离开引擎(店的写口 / 出口铸体)⇒ 每折一次报一次 —— 每次都是一件新的失败;
+ *  · 给出读座({@link StoredResultReadSeat})= 存量行的**再观看** ⇒ 同一读座同一原码(按它在行上的样子)只报一次,表有界(先进先出)——
+ *    读面每次轮询 / 每个观看者 / 每次重连都重放同一批行,逐读逐报会把一次旧失败放大成读次那么多行,而它们说的是同一件事。
+ *    折**本身**照旧逐读做(wire 上永远是对外词),去重的只是日志行。
+ *
+ * 对任何输入安全(非普通对象 / 无可摘的座 / 码在词法内 ⇒ **同一引用**原样返回,不重塑)。
  */
 export declare function sealResultForExit<T extends {
-    terminal: TerminalCause;
-}>(result: T): T;
+    readonly terminal?: unknown;
+}>(result: T, readSeat?: StoredResultReadSeat): T;
 /**
  * **投影出口的唯一属主**([ref])—— core 的 `terminalProjection` + 对外码归一,一次。
  *
@@ -129,6 +184,34 @@ export declare function nestedPauseOf(terminal: TerminalCause): PausedCause | un
  * status 恒 `"failed"`)。因由形下两条路径合成一句话,规则从二变一。
  */
 export declare function pausedCauseOf(terminal: TerminalCause): PausedCause | undefined;
+/**
+ * **宿主边界上的诚实终局** —— 宿主 run 行停不停、停在哪个词上,只问这一只判官。
+ *
+ *  · 本腿自己的 `paused` ⇒ 原样(它就是宿主腿的停驻);
+ *  · `failed.nestedPause` 且 `result.sessionId === hostSessionId` ⇒ 把那次停驻**整只**提成本腿的终局因由
+ *    (门 / 凭据 / `checkpointId` 同址;结果的其余格 —— `stats` / `verification` / … —— 原样);
+ *  · 其余 ⇒ **同一引用**原样(真失败;或嵌套停驻的卡不在宿主会话上)。
+ *
+ * 为什么判据是「停驻的那条腿跑在宿主会话上」:宿主的续跑链按会话把一张卡连回 run —— 决定腿按卡的会话找行
+ * (`getActiveTaskId`)与续跑输入(`getCtx`),取消按 run 的会话找待决卡,过期收割按会话相等连行与卡。卡在宿主会话上,
+ * 这条 run 才兑现得了它;判官只把兑现得了的停驻判成停驻。verify 的实现腿与修复轮跑在宿主会话上 ⇒ 提;cascade
+ * 每级被引擎剥掉会话、级上的卡落在级自己现铸的会话上 ⇒ 不提(照常终局)。这不是按组合器分的特例:引擎让级上的卡落到
+ * 宿主可连的会话上的那一天,答案随事实翻,本函数一个字不改。读 `result.sessionId` 而不去店里读卡:它与卡行的会话是同一次
+ * `runTask` 的同一个量,零 I/O。
+ *
+ * 前提:结果出自 core 的组合器(可信产者)—— `failed.nestedPause` 只由引擎的嵌套边界包停驻铸,`paused` 只在卡行写入确认之后返回。
+ * 判官**不**验证那张卡在不在、是不是这一张、此刻什么态;会话相等不是对卡的校验。验证器**自己**的停驻
+ * (`verification.verifierPause`)不在结果因由里,本函数看不见它 —— 那一形照常终局;它那张卡本服务兑现不了,由结算点当场作废
+ * (`verifier-pause-card.ts`),凭据由封口按座表摘。
+ *
+ * 纯函数,不读店、不抛。凭据随提升上来,摘除仍归 {@link sealResultForExit}(调用方照旧先 graft 后封口)。
+ * 判官只答「该不该停驻」;认领保不保得住是停驻写口**写成功**与否的事(行写口对 `running` / `suspended` 行 CAS)。
+ * `hostSessionId` 缺席 = 没有宿主会话 ⇒ 没有续跑链兑现得了嵌套停驻 ⇒ 原样(相等判自然为假,不另设臂)。
+ */
+export declare function atHostBoundary<T extends {
+    readonly terminal: TerminalCause;
+    readonly sessionId: string;
+}>(result: T, hostSessionId: string | undefined): T;
 /**
  * **持久 blob 的平面读面** —— 把一条**任何年代**的持久终局结果读成五词 `status` + 三个平面文本格。
  *
@@ -151,4 +234,5 @@ export declare function persistedPlaneOf(result: unknown): {
     errorMessage?: string;
     blockedReason?: string;
 };
+export {};
 //# sourceMappingURL=terminal.d.ts.map

package/dist/terminal.js

@@ -8,25 +8,75 @@ export const STORE_ERROR_CODE = "internal.store_error";
 export function outwardFailureCode(code) {
     return OUTWARD_CODE_SHAPE.test(code) ? code : STORE_ERROR_CODE;
 }
-export function sealResultForExit(result) {
-    const t = result?.terminal;
-    if (t === null || typeof t !== "object")
+export function isCodeToken(code) {
+    return typeof code === "string" && CODE_TOKEN_SHAPE.test(code);
+}
+const CODE_TOKEN_SHAPE = /^[A-Za-z0-9_.:-]{1,64}$/;
+export const PAUSE_SEATS = [
+    { path: ["terminal"], token: "token", gate: "gate" },
+    { path: ["terminal", "nestedPause"], token: "token", gate: "gate" },
+    { path: ["verification", "verifierPause"], token: "checkpointToken", gate: "checkpointGate" },
+];
+export function mapPauseSeats(result, f) {
+    let out = result;
+    for (const seat of PAUSE_SEATS)
+        out = mapSeatAt(out, seat.path, 0, (o) => f(o, seat));
+    return out;
+}
+function mapSeatAt(node, path, depth, f) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return node;
+    if (depth === path.length)
+        return f(node);
+    const key = path[depth];
+    if (!Object.hasOwn(node, key))
+        return node;
+    const child = node[key];
+    const next = mapSeatAt(child, path, depth + 1, f);
+    return Object.is(next, child) ? node : { ...node, [key]: next };
+}
+function dropCapability(seat, keys) {
+    if (!Object.hasOwn(seat, keys.token))
+        return seat;
+    const { [keys.token]: _drop, ...rest } = seat;
+    return rest;
+}
+export function sealResultForExit(result, readSeat) {
+    if (result === null || typeof result !== "object")
         return result;
-    if (t.kind === "paused")
-        return { ...result, terminal: stripPausedToken(t) };
-    if (t.kind !== "failed")
+    return foldOutwardFailureCode(mapPauseSeats(result, dropCapability), readSeat);
+}
+function foldOutwardFailureCode(result, readSeat) {
+    const t = failedCauseWithCode(result.terminal);
+    if (t === undefined)
         return result;
-    let terminal = t;
-    if (t.nestedPause !== undefined)
-        terminal = { ...terminal, nestedPause: stripPausedToken(t.nestedPause) };
-    if (t.code !== undefined) {
-        const outward = outwardFailureCode(t.code);
-        if (outward !== t.code) {
-            console.warn(`[terminal] outward_failure_code_folded original=${t.code} outward=${outward}`, { message: t.message });
-            terminal = { ...terminal, code: outward, message: `${t.message ?? "the durable store failed"} [original code: ${t.code}]` };
-        }
+    const outward = outwardFailureCode(t.code);
+    if (outward === t.code)
+        return result;
+    reportFold(t.code, outward, t.message, readSeat);
+    const message = typeof t.message === "string" ? t.message : "the durable store failed";
+    return { ...result, terminal: { ...t, code: outward, message: `${message} [original code: ${t.code}]` } };
+}
+const READ_FOLD_LATCH_CAP = 1024;
+const readFoldLatch = new Set();
+function reportFold(code, outward, message, readSeat) {
+    const original = isCodeToken(code) ? code : "<not-a-code>";
+    if (readSeat !== undefined) {
+        const key = `${readSeat} ${original}`;
+        if (readFoldLatch.has(key))
+            return;
+        if (readFoldLatch.size >= READ_FOLD_LATCH_CAP)
+            readFoldLatch.delete(readFoldLatch.values().next().value);
+        readFoldLatch.add(key);
     }
-    return terminal === t ? result : { ...result, terminal };
+    const messageBytes = typeof message === "string" ? Buffer.byteLength(message, "utf8") : 0;
+    console.warn(`[terminal] outward_failure_code_folded original=${original} outward=${outward} messageBytes=${messageBytes} at=${readSeat ?? "exit"}`);
+}
+function failedCauseWithCode(t) {
+    if (t === null || typeof t !== "object")
+        return undefined;
+    const { kind, code } = t;
+    return kind === "failed" && typeof code === "string" ? { ...t, kind, code } : undefined;
 }
 export function outwardPlane(terminal) {
     const plane = terminalProjection(terminal);
@@ -35,16 +85,18 @@ export function outwardPlane(terminal) {
     const outward = outwardFailureCode(plane.errorCode);
     return outward === plane.errorCode ? plane : { ...plane, errorCode: outward };
 }
-function stripPausedToken(paused) {
-    const { token: _drop, ...rest } = paused;
-    return rest;
-}
 export function nestedPauseOf(terminal) {
     return terminal.kind === "failed" ? terminal.nestedPause : undefined;
 }
 export function pausedCauseOf(terminal) {
     return terminal.kind === "paused" ? terminal : nestedPauseOf(terminal);
 }
+export function atHostBoundary(result, hostSessionId) {
+    const parked = nestedPauseOf(result.terminal);
+    if (parked === undefined || result.sessionId !== hostSessionId)
+        return result;
+    return { ...result, terminal: parked };
+}
 export function persistedPlaneOf(result) {
     if (result === null || typeof result !== "object")
         return {};