@sema-agent/server 7.116.1 → 7.118.0

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { type Model, type PathRuleBases, type RuleBehavior } from "@sema-agent/core";
+import { type Model, type PathRuleBases, type PermissionRule } from "@sema-agent/core";
 import { type Autonomy } from "./runtime-governance.js";
 import { type RunnerEnvNameAllowlistKnob, type ServerEnvNameAllowlistKnob } from "./env-name-allowlist-knobs.js";
 import type { ServiceConfig, ServiceConfigFlat, ServiceConfigGroups } from "./config-types.js";
@@ -285,8 +285,9 @@ export declare function isRosterGateArmed(configCenter: ServiceConfig["configCen
  *   ① env 腿(`APPROVAL_REQUIRE`/`DENY`/`NEVER_AUTO`,下方)—— boot 拒启;
  *   ② 中心下发腿(`runtime.approvalRequire`,config-center/apply-effective.ts)—— 域级拒绝+保前值+warn
  *      (常驻进程不 crash);
- *   ③ per-request 腿(`settings.permissions.{ask,deny}`,task-settings.ts;S-654 (c) 起 `allow` 同判)—— 该请求 422;
- *   ④ env 腿 `APPROVAL_GRANT`(7.115.0,运维的 allow 规则,与 ③ 的 allow 桶同一个消费者 `rule-policy`)—— boot 拒启({@link approvalGrantRefusal})。
+ *   ③ per-request 腿(`settings.permissions.{ask,deny}`,task-settings.ts)—— 该请求 422。
+ * (两张 allow 表 —— 请求的 `settings.permissions.allow` 与运维的 `APPROVAL_GRANT` —— 自 7.117.0 / core 7.42.0 起不经这里:它们整份交给引擎的
+ *  allow 层,本仓只判形与协议名对端段,判据在 `rule-entry-list.ts`,与技能两只清单同一份。)
  *
  * 五种拼法:
  *   - CC 形规则条目(`Bash(ps:*)`/`Edit(src/**)`,[ref] [ref]§七 装机实测):CC 的权限规则 DSL 写法。这些
@@ -296,10 +297,10 @@ export declare function isRosterGateArmed(configCenter: ServiceConfig["configCen
  *   - 退役名(`bash`/`Task`/`KillShell`…)与 pre-prefix 短名(`figma__x`):S-1047(core 7.41.0 #1156)起判据是 core 导出的
  *     **那一只** `judgeRuleToolName`(准备阶段、两只会话规则店、本仓会话规则写口同调),本函数零手写臂;指引 = core 表给的现役指引 /
  *     补全协议前缀。
- *   - 够不着挂载工具的协议名:缺段(`mcp__`、`mcp__srv__`、`mcp____x`)与**对端段铸不出**(`mcp__github.com`、`mcp__github.com__*`、
- *     超长 / 归一后带连串下划线的服务器段;服务器段带通配的 `mcp__*` 单列判词 `wildcard_peer`)—— 前缀对,但引擎铸注册名时归一对端段,而规则对对端段逐字比,永不匹配。
- *     判官与句子是 `namespaced-rule-name.ts` 的那**一只**(判据 = core `mintNamespacePrefix` 的自铸对照;会话规则写口两腿与 SQL 店写口同调),
- *     本文件零手写臂。修前(7.116.0 之前)这里只有缺段一臂外加一条只排 `*` 的特例(`coversAServer`),对端段带点号 / 超长的覆盖形在每个面都照收。
+ *   - 够不着挂载工具的协议名:**对端段铸不出**(`mcp__github.com`、`mcp__github.com__*`、`mcp__*`、超长 / 归一后带连串下划线的服务器段、对端段为空的
+ *     `mcp__` / `mcp____x`)—— 前缀对,但引擎铸注册名时归一对端段,而规则对对端段逐字比,永不匹配。判官是引擎的 `judgeRuleToolName`(core 7.43.0 #1355 (b)
+ *     的判词 `unmintable_segment`,句子带它的 guidance 与 1:1 现名);本仓 7.116.0–7.117.x 那只自比 `mintNamespacePrefix` 的对照随之退役。
+ *     引擎判官放行、却一只工具都够不着的一形 —— **工具段为空**(`mcp__srv__`)—— 由本仓判(`namespaced-rule-name.ts`,会话规则写口两腿与 SQL 店写口同调)。
  *     ⚠️ 两段覆盖形 `mcp__<server>`(服务器段是自铸形)够得着(S-1047 收掉的分叉,见下)。
  *   - **core 的文法编不出来的串**(名字里带反斜杠、单条 >512 字符、空串):判词取自 core 自己的
  *     `validatePermissionRules`,见 {@link uncompilableRuleGuidance}。[ref]①([ref])补齐 ——
@@ -328,28 +329,29 @@ export interface UnmatchableToolName {
     guidance: string;
 }
 /**
- * S-177(core 7.9.0 [ref])—— **这条名单条目喂给谁**,决定「永不匹配」这句话怎么判。两个消费者形态:
+ * S-177(core 7.9.0 [ref])—— **这条名单条目喂给谁**,决定「永不匹配」这句话怎么判。三个消费者形态:
  *
  *  · `"tool-name-table"` —— 消费者按**整串工具名**比对(精确 ∪ covering):env `APPROVAL_*` 三键与
  *    中心下发 `runtime.approvalRequire`(消费者 `createDurableAskPolicy`)。带括号的内容形
  *    在这里永远匹配不上任何活工具名 —— 与引擎的规则文法认不认得它**无关**,是这条腿的比对方式决定的,
  *    所以内容形照旧响亮拒 + 指路。
- *  · `"rule-policy"` —— 消费者是 core 的**规则编译器**(`createPermissionRulePolicy`):
- *    `settings.permissions.deny` / `.ask`(S-177 / core 7.9.0 起)与 `.allow`(S-654 (c) / 7.115.0 起;修前是
- *    `createAllowDenyPolicy` 的名单位)。引擎**真的按内容匹配** deny / ask 的内容形(`Bash(rm -r:*)` /
- *    `Edit(~/.sema/**)`),所以本仓不许再替它拒 —— 判据整条交回 core 的 `validatePermissionRules`,按这张表
- *    自己的 behavior 问(allow 侧 core 只收工具名形,内容形由 core 判拒)。
- *
- * S-654 (c) 前这里还有一条「`allow` 豁免名字形与文法两族」的不对称,前提是 allow 为白名单(匹配不上 ⇒ 全拒,
- * fail-closed 且当场可见);allow 改成规则后那条前提不在了(匹配不上 ⇒ 什么也不放行、照常问,写的人收不到信号),豁免随之删除。
+ *  · `"rule-policy"` —— 消费者是 core 的**规则编译器**(`createPermissionRulePolicy`):`settings.permissions.deny` / `.ask`
+ *    (S-177 / core 7.9.0 起)。引擎**真的按内容匹配** deny / ask 的内容形(`Bash(rm -r:*)` / `Edit(~/.sema/**)`),所以本仓不许再替它拒 ——
+ *    判据整条交回 core 的 `validatePermissionRules`,按这张表自己的 behavior 问。core 7.42.0 起策略只说 deny / ask(allow 表不再是本消费者)。
+ * (7.117.0 有过第三种 `"allow-layer"` —— 请求的 `settings.permissions.allow` 只判名字。7.118.0 / core 7.43.0 #1358 起引擎的 allow 层自己按名册读条目名并通告
+ *  (`permission.allowed_tool_not_granted`,`reason: "tool_name"` / `near_miss`)⇒ 本仓的名字判退役,allow 侧整只交引擎,只剩引擎读不到的那一形在
+ *  `task-settings.ts` 经 `rule-entry-list.ts` 拒。)
  */
 export type RuleEntryConsumer = "tool-name-table" | "rule-policy";
-/** {@link unmatchableToolNamesRefusal} 的判据入参:这张表喂给谁(名表 / 规则编译器)、按哪种态度问 core 的文法、路径基。 */
-export interface UnmatchableToolNameJudgment {
+/**
+ * {@link unmatchableToolNamesRefusal} 的判据入参:这张表喂给谁(名表 / 规则编译器 / allow 层);前两种按哪种态度问 core 的文法、路径基 ——
+ * allow 层没有文法一问(见 {@link RuleEntryConsumer}),型上就不带这两位。
+ */
+export type UnmatchableToolNameJudgment = {
     readonly consumer: RuleEntryConsumer;
-    readonly behavior: RuleBehavior;
+    readonly behavior: PermissionRule["behavior"];
     readonly pathBases?: PathRuleBases;
-}
+};
 /**
  * 「这张表里有永远不会生效的条目」的**判据与拒因句,同一只函数**(返回 `undefined` = 通过;拒 ⇒ 句子 + 被点名的条目)。
  * 五条腿全调它:env `APPROVAL_REQUIRE` / `APPROVAL_DENY` / `APPROVAL_NEVER_AUTO`(拒启)、中心下发 `governance.approvalRequire`(整组拒)、
@@ -365,16 +367,17 @@ export declare function unmatchableToolNamesRefusal(source: string, names: reado
     readonly names: readonly string[];
 } | undefined;
 /**
- * 7.115.0 —— 运维 allow 规则 `APPROVAL_GRANT` 的**拒启判据与拒因句**(同一只函数;`config-invariants.ts` 的 `…Refusal` 形:
- * 返回句子 = 拒,`undefined` = 通过)。判据与请求腿的 `settings.permissions.allow` 是**同一只**:
- *  ① 名字形与 core 文法 —— {@link unmatchableToolNamesRefusal},消费者 `rule-policy`、behavior `allow`(退役名 / 无前缀短名 / 缺段或对端段铸不出的协议名 /
- *     反斜杠 / 超长 / 内容形与参数级的 allow;句子点名哪一条、为什么、怎么改);
- *  ② 整表试编一次 —— 编的就是治理折叠里那一只(`runtime-governance.ts` {@link compileApprovalGrantLayers}),于是 core 的整表帽这类
- *     只在编译时才抛的判据也在启动时响亮,而不是每个任务一次 500。
- * 没有 `pathBases`:运维的规则不挂在任何一条任务的根上,而 allow 文法本来只收工具名形(路径形的 allow core 拒编,在 ① 里就拒了)。
- * 坏值**不许**静默丢掉那一条后照常起:运维以为放行了,无人值守腿照旧拒 / 停驻,没有任何信号指回这里。
+ * 运维 allow 表 `APPROVAL_GRANT` 的**拒启判据与拒因句**(同一只函数;`config-invariants.ts` 的 `…Refusal` 形:返回句子 = 拒,`undefined` = 通过)。
+ * 7.117.0(core 7.42.0)起这张表整份投 `RunnerDeps.allowedTools`(引擎 allow 层的部署成员,构造时读一次),判据是**引擎的读法**,与请求的两张
+ * allow 表同一份(`rule-entry-list.ts`):
+ *  ① 值不是字符串表 ⇒ 拒(env 的 CSV 恒给字符串表;判在这里是为了「值一旦换了来源,第一道判仍在」);
+ *  ② 引擎读不到的那一形(工具段为空的协议名)⇒ 拒(与技能清单、请求 allow 桶同一只函数);
+ *  ③ 引擎读成空的条目(`compileAllowList(names, "allow", 名册 = 空集).inert` 非空 —— `*`、`mcp__*`、写路径 / 域名形、带空白或畸形的名字,以及
+ *     core 7.43.0 起条目名过引擎判官读成 `tool_name` 的退役名 / 无前缀短名 / 对端段铸不出)⇒ 拒,句子点名条目、引擎给的原因词(名字层带判词与现名)、
+ *     该怎么写。请求的 allow 侧对 ③ 只收通告;运维这一侧拒启:这是运维自己的配置,写错了当场改,而引擎对读成空的部署条目只在每一跑发一条通告。
+ * 文法随引擎:工具名、协议名覆盖形、`Bash(...)` 命令规则、`Read(//dir/**)` 读目录都收(内容形里带逗号的写不进 CSV —— 这张表的分隔符就是逗号)。
  */
-export declare function approvalGrantRefusal(names: readonly string[]): string | undefined;
+export declare function approvalGrantRefusal(names: unknown): string | undefined;
 /**
  * [ref] 件B/C/D —— 三条**部署治理声明**的 env 解析(auth 域的一段,fail-loud 全在这里)。
  *

package/dist/config.js

@@ -18,11 +18,12 @@ import { buildReadFacePostureNotice, readFaceForPosture } from "./read-face-post
 import { THINKING_LEVELS, THINKING_FORMATS, buildModelCompat, isThinkingFormat, isThinkingTier } from "./model-compat.js";
 import {} from "./posture-source.js";
 import { CONTROL_AND_BIDI_STRIP_RE } from "./text-bidi.js";
-import { describeUnreachableNamespacedRuleName, ruleEntryToolName, unreachableNamespacedRuleNameOf } from "./namespaced-rule-name.js";
+import { describeUnmatchableRuleName, ruleEntryToolName, unmatchableRuleNameOf } from "./namespaced-rule-name.js";
 import { bakeOperatorPrincipalsRefusal, bakeRunnerCredentialRefusal, halfOpenDirectDoorRefusal, leaderDurableStoreRefusal, operatorPrincipalsRequiredRefusal } from "./config-invariants.js";
 import { REMOTE_EXEC_PROVIDER_WORDS, executionLaneOf, executionLaneRequiredRefusal, isSingleMachineDefaultLane, laneRequiredEnv } from "./execution-lane-caps.js";
 import { MEMORY_ENGINE_BACKENDS, SESSION_BACKENDS, STORE_BACKENDS } from "@sema-agent/settings-schema/execution-lanes";
-import { APPROVAL_GRANT_SOURCE, AUTONOMY_MODES, compileApprovalGrantLayers } from "./runtime-governance.js";
+import { AUTONOMY_MODES } from "./runtime-governance.js";
+import { allowLayerEntryCountIssue, describeEmptyToolSegmentEntry, describeInertRuleEntries, emptyToolSegmentEntryOf, inertRuleEntriesOf, ruleEntryListShapeOk } from "./rule-entry-list.js";
 import { createCenterCredentialSource, readCenterCredentialDeclaration } from "./center-credential.js";
 import { parseCenterCredentialRenewLeadMs } from "./center-credential-renewer.js";
 import { modelProviderRefusal } from "./model-provider.js";
@@ -1227,11 +1228,6 @@ function uncompilableRuleGuidance(name, behavior, pathBases) {
     const issue = issues[0];
     if (issue === undefined)
         return undefined;
-    if (behavior === "allow" && (issue.code === "unsupported.bash_prefix" || issue.code === "unsupported.file_glob" || issue.code === "invalid.allow_param_rule")) {
-        return (`${issue.code} — ${issue.message}. An allow rule list compiles tool-name rules only (an exact name, or mcp__<server>__* / ` +
-            `a2a__<peer>__* for every tool on that peer); a content-form standing approval lives in the persisted-rule store ` +
-            `(/v1/rules/cc-import, or keep the rule when you answer the call's card)`);
-    }
     return (`${issue.code} — core's rule grammar cannot compile this name (${issue.message}), so a table keyed by it matches nothing. ` +
         `Tool names carry no backslashes and are far shorter than the 512-character rule cap; check the spelling, and use ` +
         `mcp__<server>__* / a2a__<peer>__* for "every tool on that peer"`);
@@ -1247,9 +1243,9 @@ function findUnmatchableToolNames(names, opts) {
             }
         }
         const subject = opts.consumer === "tool-name-table" ? name : ruleEntryToolName(name);
-        const verdict = judgeRuleToolName(subject, NO_DECLARED_TOOL_NAMES);
-        if (verdict.kind === "retired") {
-            out.push({ name, guidance: verdict.guidance });
+        const verdict = unmatchableRuleNameOf(subject);
+        if (verdict?.kind === "retired") {
+            out.push({ name, guidance: describeUnmatchableRuleName(verdict, subject) });
             continue;
         }
         const uncompilable = uncompilableRuleGuidance(name, opts.behavior, opts.pathBases);
@@ -1257,17 +1253,11 @@ function findUnmatchableToolNames(names, opts) {
             out.push({ name, guidance: uncompilable });
             continue;
         }
-        if (verdict.kind === "unprefixed_namespace") {
-            out.push({ name, guidance: `pre-prefix short form — the live name carries a protocol prefix: ${PROTOCOL_TABLE.map((e) => `${e.prefix}${presentToolName(name)}`).join(" or ")}` });
-            continue;
-        }
-        const unreachable = unreachableNamespacedRuleNameOf(subject);
-        if (unreachable !== undefined)
-            out.push({ name, guidance: describeUnreachableNamespacedRuleName(unreachable) });
+        if (verdict !== undefined)
+            out.push({ name, guidance: describeUnmatchableRuleName(verdict, subject) });
     }
     return out;
 }
-const NO_DECLARED_TOOL_NAMES = new Set();
 export function unmatchableToolNamesRefusal(source, names, judgment) {
     const bad = findUnmatchableToolNames(names, judgment);
     if (bad.length === 0)
@@ -1277,16 +1267,19 @@ export function unmatchableToolNamesRefusal(source, names, judgment) {
         bad.map((b) => `${presentToolName(b.name)} → ${b.guidance}`).join("; ")).replace(CONTROL_AND_BIDI_STRIP_RE, "");
     return { message, names: bad.map((b) => b.name) };
 }
+const APPROVAL_GRANT_ENV = "APPROVAL_GRANT";
 export function approvalGrantRefusal(names) {
-    const unmatchable = unmatchableToolNamesRefusal(APPROVAL_GRANT_SOURCE, names, { consumer: "rule-policy", behavior: "allow" });
-    if (unmatchable !== undefined)
-        return unmatchable.message;
-    try {
-        compileApprovalGrantLayers(names);
-    }
-    catch (e) {
-        return e instanceof Error ? e.message : String(e);
-    }
+    if (!ruleEntryListShapeOk(names))
+        return `${APPROVAL_GRANT_ENV} must be a list of permission-rule strings — refusing to start rather than running without it`;
+    const over = allowLayerEntryCountIssue(APPROVAL_GRANT_ENV, names);
+    if (over !== undefined)
+        return `${over.message} — refusing to start rather than running with a truncated list`;
+    const empty = emptyToolSegmentEntryOf(names);
+    if (empty !== undefined)
+        return `${describeEmptyToolSegmentEntry(APPROVAL_GRANT_ENV, empty)} — refusing to start rather than running without it`;
+    const inert = inertRuleEntriesOf(names, "allow");
+    if (inert.length > 0)
+        return `${describeInertRuleEntries(APPROVAL_GRANT_ENV, inert)} — the engine would grant nothing for ${inert.length === 1 ? "it" : "them"}; refusing to start rather than running with an allow rule that never takes effect`;
     return undefined;
 }
 function streamApprovalConfig(gates) {

package/dist/deployment-governance.d.ts

@@ -1,5 +1,4 @@
 import { FileError, StubExecutionEnv, type ExecutionEnv, type Result, type ToolPolicy } from "@sema-agent/core";
-import { type DurableAskOptions } from "./approval.js";
 import type { ServiceConfig } from "./config.js";
 import type { applyRuntimeGovernance } from "./runtime-governance.js";
 /** `applyRuntimeGovernance` 的 governance 实参 —— 从折叠属主的签名位**推导**,不复制形状
@@ -11,9 +10,6 @@ export interface DeploymentGovernanceConfigView {
     readonly commandPolicy?: ServiceConfig["commandPolicy"];
     readonly manualModeShellGate?: ServiceConfig["manualModeShellGate"];
     readonly sensitiveWritePatterns: ServiceConfig["sensitiveWritePatterns"];
-    /** 7.115.0:运维的 allow 规则(`APPROVAL_GRANT`)—— 原串交给折叠属主编成叶(`runtime-governance.ts` `compileApprovalGrantLayers`)。
-     *  必填:三条消费腿的切面都要点名它,漏了是编译错,不是一条腿上静默没有这只旋钮。 */
-    readonly approvalGrant: ServiceConfig["approvalGrant"];
     /**
      * 本部署的**本地店根**(`LOCAL_DATA_ROOT → CONFIG_LOCAL_DIR → AGENT_DATA_DIR → ~/.ai-agent`)—— 在本口只喂
      * **誊本门**(`<localDataRoot>/sessions`)。S-133 起它**不再**当守卫集的 `dataRoot`(那是引擎记忆根,见
@@ -95,12 +91,8 @@ export interface DurableApprovalSeat {
     readonly kind: "durable";
     /** 活体问答面;`undefined` ⇒ 恒 durable park 的原形门。 */
     readonly question: LiveQuestionFace | undefined;
-    /** 每会话「本会话不再询问」探针(canonical toolName 键空间)。 */
-    readonly exempt?: DurableAskOptions["exempt"];
-    /** 豁免短路时的审计钩子。 */
-    readonly onExempted?: DurableAskOptions["onExempted"];
 }
-/** live 席:Runner 的活 onAsk 当场服 ask(无 park、无会话豁免店)。 */
+/** live 席:Runner 的活 onAsk 当场服 ask(无 park)。 */
 export interface LiveApprovalSeat {
     readonly kind: "live";
 }
@@ -233,17 +225,16 @@ export interface GateSeatView {
  * 此前是「这个部署一个门都没接」这个 misconfig 的**唯一**提示,而守卫集只挡那二十来个路径段、其余写
  * 目标照旧无裁决 —— 信号不能因为我们铺了基线就静默消失,所以由我们自己按同一判据说一次。
  *
- * 判据(与信号消失的条件逐字互补):**非门的部署叶在场**(守卫集,或 7.115.0 起运维的 allow 规则 `APPROVAL_GRANT` —— 两者都让
- * `spec.toolPolicy` 在场、又都不是门:一个只拒守卫段,一个只表态 allow)∧ 这条腿的审批基线**没有席**(`absent`)∧ 单用户
- * auto-accept 基线不适用。事件名 `tool_policy_only_sensitive_baseline` 是allow 规则之前定的,保留不改(运维的日志告警按它匹配),
- * 哪一片叶在场写在 `detail` 与 `guardedPatterns` / `grantRules` 两个计数里。三个量都是部署常量 ⇒ 消费腿在 boot 期说一次,不是每任务一次。
+ * 判据(与信号消失的条件逐字互补):**守卫集在场**(它让 `spec.toolPolicy` 在场、又不是门:只拒守卫段)∧ 这条腿的审批基线**没有席**
+ * (`absent`)∧ 单用户 auto-accept 基线不适用。三个量都是部署常量 ⇒ 消费腿在 boot 期说一次,不是每任务一次。
+ * (7.115.0–7.116.x 运维的 allow 表 `APPROVAL_GRANT` 也是这里的一片非门叶;7.117.0 起它住在 Runner 的部署席、不再是策略,随之出列。)
  * S-694:席读的是喂审批基线的**同一只**({@link ApprovalSeat})—— `durable` / `live` 两形都有人服 ask、名单
  * 进策略,「守卫集是唯一的策略」这句话在它们上面不成立。今天真发的只剩 HTTP 腿「durable 关 ∧ 多租户」那一形。
  *
  * ⚠️ 单一属主([ref] 件三):HTTP 腿与 run-local 腿共用本判据与文案。两处各写一份 = 一处改了另一处
  * 没改,而两份都长得像对的 —— 那正是本文件存在的理由。
  */
-export declare function buildOnlySensitiveBaselineWarning(config: Pick<DeploymentGovernanceConfigView, "sensitiveWritePatterns" | "approvalGrant">, seat: GateSeatView): OperatorWarning | undefined;
+export declare function buildOnlySensitiveBaselineWarning(config: Pick<DeploymentGovernanceConfigView, "sensitiveWritePatterns">, seat: GateSeatView): OperatorWarning | undefined;
 /**
  * `applyRuntimeGovernance` 的 governance 实参预铸([ref] 件一)。
  *
@@ -259,17 +250,20 @@ export declare function buildOnlySensitiveBaselineWarning(config: Pick<Deploymen
  */
 export declare function createDeploymentGovernanceInputs(config: DeploymentGovernanceConfigView, pathAdjudication: PathAdjudication, roots: DeploymentGovernanceRoots): DeploymentGovernanceInputs;
 /**
- * 7.115.0 —— 运维 allow 规则的**起服通告**载荷(纯数据 ⇒ `build*`;HTTP 腿与 run-local 腿各在装配时说一次,用 info 级)。
- * 规则名不是秘密(它们是工具名),所以原样列出;空表 ⇒ `undefined`(不打)。运维只读面上同一个事实另有一处:
- * `GET /v1/diagnostics/wiring` 的 `serverGates.approvalGrant`。
+ * 运维 allow 表 `APPROVAL_GRANT` 的**起服通告**载荷(纯数据 ⇒ `build*`;HTTP 腿与 run-local 腿各在装配时说一次,用 info 级)。规则不是秘密
+ * (它们是工具名 / 命令规则),所以原样列出;空表 ⇒ `undefined`(不打)。运维只读面上同一个事实另有一处:`GET /v1/diagnostics/wiring` 的
+ * `serverGates.approvalGrant`。`note` 是这只旋钮**本版的效果**的真话(7.117.0 起语义变宽,三问在 CHANGELOG / MIGRATION):清什么、永远清不掉什么。
+ * 不在本口读席位:表经部署姿态座席族(`boot/runner-deps.ts` `buildDeploymentPostureSeats`)交给每只 Runner,本口只说它在场。
  */
-export declare function buildApprovalGrantNotice(config: Pick<DeploymentGovernanceConfigView, "approvalGrant">): OperatorWarning | undefined;
+export declare function buildApprovalGrantNotice(config: {
+    readonly approvalGrant: ServiceConfig["approvalGrant"];
+}): OperatorWarning | undefined;
 /**
  * 审批基线 —— `applyRuntimeGovernance` 那个 base 的 `toolPolicy` 座([ref] 件一)。**恒非
  * `undefined`**:治理层是 tighten-only 的叠加层,没有基线可叠时它自己也产不出「门在场」这件事。
  *
  * 三形,按席穷举(S-694,席的定义见 {@link ApprovalSeat}):
- *  · `durable` ⇒ AskUserQuestion 判决门 + 三张名单的审批门(deny/neverAuto/预算/会话豁免全在
+ *  · `durable` ⇒ AskUserQuestion 判决门 + 三张名单的审批门(deny/neverAuto/预算全在
  *    `createDurableAskPolicy` 里)。gated `ask` 由 core 变成 durable checkpoint suspend。
  *  · `live`    ⇒ **同一只**三张名单审批门,不叠问答门。gated `ask` 由 core 交给 Runner 的活 onAsk 席
  *    (本口**不**做 ask→deny 映射:无人可问时的拒由那只席说,判据与文案都归它)。

package/dist/deployment-governance.js

@@ -61,7 +61,7 @@ export function assertGuardPatternsUsable(config) {
     }
 }
 export function buildOnlySensitiveBaselineWarning(config, seat) {
-    if ((config.sensitiveWritePatterns.length === 0 && config.approvalGrant.length === 0) || seat.singleUserAutoAcceptBaseline)
+    if (config.sensitiveWritePatterns.length === 0 || seat.singleUserAutoAcceptBaseline)
         return undefined;
     switch (seat.approvalSeat) {
         case "durable":
@@ -74,17 +74,12 @@ export function buildOnlySensitiveBaselineWarning(config, seat) {
             throw new Error(`approval seat "${String(unhandled)}" has no arm in the only-sensitive-baseline warning`);
         }
     }
-    const nonGateLayers = [
-        ...(config.sensitiveWritePatterns.length > 0 ? ["the sensitive-path DENY baseline (SENSITIVE_WRITE_PATTERNS)"] : []),
-        ...(config.approvalGrant.length > 0 ? ["the APPROVAL_GRANT allow rules"] : []),
-    ];
     return {
         event: "tool_policy_only_sensitive_baseline",
         fields: {
-            detail: `${nonGateLayers.join(" and ")} ${nonGateLayers.length > 1 ? "are" : "is"} this deployment's ONLY tool policy and not a gate — writes outside the guarded segments are unadjudicated, and core's own UNGATED warning no longer fires because a policy is now always present`,
+            detail: "the sensitive-path DENY baseline (SENSITIVE_WRITE_PATTERNS) is this deployment's ONLY tool policy and not a gate — writes outside the guarded segments are unadjudicated, and core's own UNGATED warning no longer fires because a policy is now always present",
             remedy: "wire an approval face (DURABLE_APPROVAL / APPROVAL_REQUIRE with a store) or accept the single-user auto-accept baseline",
             guardedPatterns: config.sensitiveWritePatterns.length,
-            grantRules: config.approvalGrant.length,
         },
     };
 }
@@ -113,7 +108,6 @@ export function createDeploymentGovernanceInputs(config, pathAdjudication, roots
         commandPolicy: config.commandPolicy,
         ...(config.manualModeShellGate ? { manualModeShellGate: config.manualModeShellGate } : {}),
         ...(sensitivePathLayers ? { sensitivePathLayers } : {}),
-        ...(config.approvalGrant.length > 0 ? { approvalGrant: config.approvalGrant } : {}),
     };
 }
 export function buildApprovalGrantNotice(config) {
@@ -124,16 +118,17 @@ export function buildApprovalGrantNotice(config) {
         fields: {
             rules: config.approvalGrant.length,
             names: [...config.approvalGrant],
-            note: "APPROVAL_GRANT states the allow for the tools these rules name on every leg it is installed on (HTTP submit, durable resume, cross-replica revival of parked background agents, run-local) — those calls are no longer asked for want of a statement; any layer's own deny or ask (approval lists, request settings, session rules, the engine's mode gates) still wins",
+            note: "APPROVAL_GRANT is the deployment's member of the engine's allow layer (RunnerDeps.allowedTools on every Runner this process builds): a call these rules cover is no longer asked for an ordinary question (a file write, a shell command, a server tool nobody stated) — built-in tools included. " +
+                "It never clears a deny from any layer, an APPROVAL_REQUIRE / APPROVAL_NEVER_AUTO / request ask rule, the MANUAL_MODE_SHELL_GATE=always shell floor, a write-protected path, a sensitive-path deny, governance, a PreToolUse hook's ask, or the plan mode's question; a rule that matches and cannot clear is disclosed on the card (allowRuleShadowed member \"deployment\")",
         },
     };
 }
 export function createApprovalBaselinePolicy(config, seat) {
     switch (seat.kind) {
         case "durable":
-            return combinePolicies(createDurableQuestionGate(seat.question), createApprovalListPolicy(config, seat));
+            return combinePolicies(createDurableQuestionGate(seat.question), createApprovalListPolicy(config));
         case "live":
-            return createApprovalListPolicy(config, {});
+            return createApprovalListPolicy(config);
         case "absent":
             if (hasApprovalListIntent(config)) {
                 throw new Error("approval baseline: this leg has no approval seat (nobody can answer an ask), yet an approval list is in force " +
@@ -147,14 +142,12 @@ export function createApprovalBaselinePolicy(config, seat) {
         }
     }
 }
-function createApprovalListPolicy(config, memory) {
+function createApprovalListPolicy(config) {
     return createDurableAskPolicy({
         requireApproval: config.approvalRequire,
         deny: config.approvalDeny,
         autoBudget: config.approvalAutoBudget,
         neverAuto: config.approvalNeverAuto,
-        ...(memory.exempt ? { exempt: memory.exempt } : {}),
-        ...(memory.onExempted ? { onExempted: memory.onExempted } : {}),
     });
 }
 //# sourceMappingURL=deployment-governance.js.map

package/dist/governance-overrides.d.ts

@@ -0,0 +1,20 @@
+/**
+ * **收紧折叠的入参型与唯一折叠口** —— 本仓三处收紧(治理层 `applyRuntimeGovernance`、请求 settings 的 `applyTaskSettings`、SUP 姿态)都经
+ * {@link tightenGoverned} 调 core 的 `tightenTaskSpec`,入参型是 {@link GovernanceOverrides}。
+ *
+ * 🔴 为什么入参型上**没有** `allowedTools`:core 的 `tightenTaskSpec(base, overrides)` 对 `allowedTools` 不做「收紧」,而是**用覆盖值替换**
+ * base 上的表(本仓探针亲证)。请求的 allow 表有且只有一个写点(`task-settings.ts` 的 `applyTaskSettings`,在折叠之外);一只往收紧入参里
+ * 塞 `allowedTools` 的调用点会静默改写请求的表。型上禁掉它(`allowedTools?: never`),写出来就是编译红 —— 比文本扫描的静态门(方括号写法、
+ * 展开形会漏)更硬。
+ *
+ * 🔴 型禁有一个洞([ref] 合并复审 opus 腿):本仓没开 `exactOptionalPropertyTypes`,`{ allowedTools: undefined }` 过型检,而 core 的替换会把 base 上的表
+ * 抹成 `undefined`。所以折叠口再加一道**运行期**守卫:入参对象自带 `allowedTools` 键(任何值,含 `undefined`)⇒ 抛(fail-closed:宁多问一次)。
+ */
+import { type TaskSpec } from "@sema-agent/core";
+/** 收紧折叠的入参:`TaskSpec` 的字段,`allowedTools` 除外(型上禁)。 */
+export type GovernanceOverrides = Partial<Omit<TaskSpec, "allowedTools">> & {
+    readonly allowedTools?: never;
+};
+/** 本仓唯一的收紧折叠口(deny-wins 合并;core 在放宽时抛)。 */
+export declare function tightenGoverned(base: TaskSpec, overrides: GovernanceOverrides): TaskSpec;
+//# sourceMappingURL=governance-overrides.d.ts.map

package/dist/governance-overrides.js

@@ -0,0 +1,8 @@
+import { tightenTaskSpec } from "@sema-agent/core";
+export function tightenGoverned(base, overrides) {
+    if (Object.hasOwn(overrides, "allowedTools")) {
+        throw new Error("tightenGoverned: `allowedTools` is not a tightening input — the engine replaces the base list with the override instead of narrowing it; the request's allow list has exactly one write point (applyTaskSettings)");
+    }
+    return tightenTaskSpec(base, overrides);
+}
+//# sourceMappingURL=governance-overrides.js.map

package/dist/host-decision.d.ts

@@ -1,6 +1,7 @@
 /**
  * **宿主的决策事实** —— 一条耐久 park 被结算时,本服务能如实陈述的那半件事:谁结束了这次等待,以及
- * 审批通道自报的归属。一个叶子模块(只依赖 `@sema-agent/core`),四个消费点共用一个定义。
+ * 审批通道自报的归属,以及决定体上陈述「谁决定的」那一只键(`decidedBy`)的闭集、读法与映射。一个叶子模块
+ * (运行期只依赖 `@sema-agent/core`;另一处 import 是纯类型的编译期门),全部决定口共用一个定义。
  *
  * ## 为什么是「事实」而不是「结算词」(core 7.6.0 / [ref] S6-A,BREAKING)
  *
@@ -17,14 +18,12 @@
 import { type AskOutcome, type ResumeOutcome } from "@sema-agent/core";
 /**
  * 谁结束了这次等待,以及通道自报的归属。
- *  · `decidedBy: "person"` —— 运维经审批通道做的决定(两条 HTTP `/decide` 腿);
+ *  · `decidedBy: "person"` —— 一个人经审批通道做的决定(决定体缺席 `decidedBy` 即此);
  *  · `decidedBy: "sla_timeout"` —— 宿主自己的 SLA 扫在行的 deadline 上判的(FACET A;**只有** sweep 能这么说,
- *    而 sweep 结构上不能 `allow`)。
- *  · `decidedBy: "policy"`(core 7.26.2 / #1016)—— **这台部署自己的策略**拒的:答话的是机器不是人。调用方
- *    经决裁体的 `settledBy` 自报;core 据它给模型铸一句**策略句**(而不是「用户不同意,停下来等他」),
- *    并把结算记成 `policy_refused`(`who.party:"policy"`,core 7.39.0 #1265 起;此前 `"none"`)。`allow` 侧:core 7.39.0 起引擎收策略的
- *    放行(`policy_allowed`),但本仓的两条 decide 口**不开**这一形(`tool-approval.ts` 的 `SETTLED_BY_ONLY_ON_DENY` 与店列的同一条拒仍在 ——
- *    耐久车道上的机器放行是一件没裁过的新能力,不在 7.113.0 提货批内,候登)。
+ *    而 sweep 结构上不能 `allow`;wire 上永不受理,见 {@link APPROVAL_DECIDED_BY})。
+ *  · `decidedBy: "policy"` —— **这台部署自己的策略**答的:答话的是机器不是人,`allow` 与 `deny` 两向都可以。
+ *    调用方经决定体的 `decidedBy` 陈述;core 据它铸 `policy_allowed` / `policy_refused`(`who.party:"policy"`),
+ *    拒的那一向给模型一句**策略句**(而不是「用户不同意,停下来等他」)。
  *  · `approver` —— 通道自报的结算方标识串。**缺席永不读成**「没人批」或「有人批」,只意味着通道没报名字。
  */
 /**
@@ -33,9 +32,9 @@ import { type AskOutcome, type ResumeOutcome } from "@sema-agent/core";
  *  · **铸**(本仓自己观察到的事实):只有 `"timeout"` —— 同步 `onAsk` 腿的等待窗归**宿主**所有(引擎不为
  *    一个它没排程的回调起表),所以「本仓的 TTL 窗走完了、没人答」这件事引擎结构上观察不到,不自报就
  *    永远被记成「一个人拒绝了」;
- *  · **转**(调用方在回决体里自报的事实,core 7.26.2 / #1016 起):`settledBy:"policy"` = 答这张卡的是
- *    **这台部署自己的策略**,不是人。本仓**零判据、原样过境**:词的拒绝逻辑归引擎(`resolveAsk` 对
- *    自报词表外的值是响亮 fail-closed deny),本仓抄一份词表的那天 core 加词就会被静默 400 掉。
+ *  · **转**(调用方在决定体里陈述的事实):决定体的 `decidedBy:"policy"` 经 {@link liveSettledBy} 落成这一格的
+ *    `"policy"` = 答这张卡的是**这台部署自己的策略**,不是人。wire 上的词只有 {@link APPROVAL_DECIDED_BY} 两个,
+ *    映射只有那一只函数 —— 这一格的「转」不再是一个原样过境的串。
  * 逐词(词表属主恒是 core):
  *  · `"human"` —— 与「不铸这个键」逐字同义(core 缺席即按人处理);
  *  · `"aborted"` —— core **明令拒收**宿主自报(那是引擎自家 fail-closed 端的词,宿主自报等于把自己的
@@ -62,13 +61,78 @@ export type HostDecision = Extract<ResumeOutcome, {
  *  编译期先红)。今天 = `"person"` | `"sla_timeout"` | `"policy"`。 */
 export type HostDecidedBy = HostDecision["decidedBy"];
 /**
- * 一次 decide 的事实,**一处成形**(两条 HTTP decide 腿 + 活卡 PARKED 赎回席共用)。
+ * ══ 决定体的出处位 `decidedBy`:一只闭集、一只读法、一只映射 ═══════════════════════════════════════════════
  *
- * `decidedBy` = 调用方**陈述**的决策者(缺席 ⇒ `"person"`,= 本面自古以来的形:一条不说话的 decide 就是
- * 一个人按的)。🔴 **本仓零判据**:词表的属主是 core,不认识的词由它 pre-CAS 响亮拒
- * (`checkpoint.invalid_outcome`,`hostDecision.decidedBy … is outside the closed set`)。在这里再判一次
- * 就是同一语义面的第二个判官(源头修复纪律 [ref]),而且本仓抄一份词表的那天 core 加第四个词就会被
- * 静默 400 掉 —— 那正是 #1016 的 `"policy"` 加进来时本可以发生的事。
+ * 规则一句话:**一个审批决定用一只键说是谁做的** —— `decidedBy ∈ {"person","policy"}`,缺席 = `"person"`;读它的只有
+ * {@link readDecidedBy}(三条工具审批决定口共读:live `POST /v1/tool-approvals/:id/respond`、耐久 ask 账
+ * `POST /v1/tasks/:id/asks/:askId/decision`、耐久 `POST /v1/approvals/:sessionId/decide`),把它交给引擎的只有
+ * {@link liveSettledBy}(同步座 `AskOutcome.settledBy`)与 {@link hostDecisionFacts}(停驻座 `hostDecision.decidedBy`)。
+ *  · 词与决定动词**正交**:策略可以放行也可以拒(core 7.39.0 起引擎铸 `policy_allowed` / `policy_refused`)。唯一的例外是
+ *    引擎自己的那一条 —— 一张要人的卡(`requiresRealApproval`)不归策略放行,见 {@link policyCannotAllow}。
+ *  · `"sla_timeout"` **永不从 wire 收**:那是「等待到点、没人答」,只有本服务自己的截止扫说得出来(`approval-sweeps.ts`
+ *    直接铸 `{decidedBy:"sla_timeout"}`,不经本读法)。调用方说它 = 替服务端伪证一件只有服务端看得见的事。
+ *  · `plan_review` 不读这只键:引擎的 plan_review 结局形没有决定者位(core 的结局规整会把别的键整只重建掉),收下它就是
+ *    一句「已记」的空话。那一门照兄弟门字段那一族拒(`approvals-assistant.ts` 的回决门族派生),候 core 给座。
+ *
+ * 词表的来源:core 包根**没有**导出这只词表的运行期常量(只有类型 `ResumeOutcome[...]["hostDecision"]["decidedBy"]`),所以
+ * 本仓一只闭集常量 + 两道编译期门**双向**咬着 core 的型:core 加 / 退一个词 ⇒ 这里先红,不会在 wire 上静默留一个两个座都已经
+ * 不收的词,也不会把 core 新开的词静默 400 掉。core 导出词表之日,本常量改为直接镜像那一只(请托在案)。
+ */
+export declare const APPROVAL_DECIDED_BY: readonly ["person", "policy"];
+/** wire 上的出处词(决定体 `decidedBy` 的值域)。 */
+export type ApprovalDecidedBy = (typeof APPROVAL_DECIDED_BY)[number];
+/** 闭集外的拒句(三条决定口同一句;码按各口既有约定,见 {@link readDecidedBy})。 */
+export declare const DECIDED_BY_OUTSIDE_CLOSED_SET = "decidedBy must be \"person\" or \"policy\" when present \u2014 who made this decision: a person, or this deployment's own policy (absent = \"person\"); \"sla_timeout\" is never accepted from a caller (only this server's own deadline sweep says a wait ended with nobody answering)";
+/** 直连门上的拒句(与 `remember` / `updatedInput` / `checkpointToken` 同族:键不在决策证明的签名载荷里)。 */
+export declare const DECIDED_BY_NOT_IN_PROOF = "decidedBy is not supported on a direct-door worker (not covered by the decision proof)";
+/** 一张要人的卡上策略的放行(三条决定口同一句;判据 {@link policyCannotAllow})。 */
+export declare const POLICY_CANNOT_ALLOW_PERSON_ASK = "decidedBy \"policy\" cannot allow this ask \u2014 it demands a person's approval (risk.requiresRealApproval), and a policy's answer is not a person's; answer it as a person, or refuse it as the policy";
+/**
+ * 退役键 `settledBy`(7.93.3–7.117.x 的「只配 deny」那一位)的拒句。耐久两口由各自的键闭集 / strict 体拒;live `/respond` 的解析不是
+ * 键闭集的(未知键一律忽略),而这只键不是随便一个未知键:它是调用方在**明确陈述**「这是策略答的」—— 忽略它就是把缺席律(person)
+ * 套在一个说了话的体上(旧壳的策略拒记成人拒;一张要人的卡上旧形的放行被读成人的放行,绕过 {@link policyCannotAllow})。所以那条口
+ * 在裁决之前响亮拒它,与同一只 parser 里 `scope` 的拒同一条先例;那只 parser 收成键闭集之日,这一臂并进闭集门。
+ */
+export declare const SETTLED_BY_RETIRED = "settledBy is retired \u2014 send decidedBy: \"person\" | \"policy\" (who made this decision; absent = \"person\"); ignoring it would record a policy's answer as a person's";
+/** {@link readDecidedBy} 的判决(调用点做穷举 `switch` + `never` 兜底,各按自己的码约定发出)。 */
+export type DecidedByReading = {
+    kind: "accepted";
+    decidedBy: ApprovalDecidedBy;
+} | {
+    kind: "not_in_proof";
+} | {
+    kind: "outside_closed_set";
+};
+/**
+ * 决定体 `decidedBy` 的**唯一读法**。次序即契约:
+ *  ① 缺席 ⇒ `"person"`(缺席律:一条不说话的决定就是一个人按的 —— 与修前逐字同形);
+ *  ② 直连门在场且键在场 ⇒ `not_in_proof`(不论值:它不在签名载荷里,能改线上字节的一方可以把人翻成策略;
+ *     第二参给字面 `false` 的调用点 = 那条口没有决策证明,live `/respond` 即此);
+ *  ③ 闭集内 ⇒ 那个词;其余一切(`"sla_timeout"`、结算词、别的串、非串、`null`)⇒ `outside_closed_set`。
+ */
+export declare function readDecidedBy(raw: unknown, directDoorActive: false): Exclude<DecidedByReading, {
+    kind: "not_in_proof";
+}>;
+export declare function readDecidedBy(raw: unknown, directDoorActive: boolean): DecidedByReading;
+/**
+ * **同步座的映射**(`AskOutcome.settledBy`;ask 账行的 `settled_by` 列存的也是这一格):`person` ⇒ 不铸键(引擎缺席即按人读,
+ * 与修前逐字同形 —— 人的放行仍是裸 `true`),`policy` ⇒ `"policy"`。总函数,无 cast。
+ */
+export declare function liveSettledBy(decidedBy: ApprovalDecidedBy): Extract<HostSettledBy, "policy"> | undefined;
+/**
+ * 引擎自己的那一条例外:**一张要人的卡不归策略放行**(core `policyCannotAnswer` / `unjudgedAllowRefused` —— 同步座上
+ * `req.requiresRealApproval === true` 时策略的 allow 被拒成 `blanket_allow_refused`)。本仓**只在自己的副作用先于引擎落地的
+ * 两条口**上于裁决之前说这一句(live `/respond`:会话放行 / 常驻规则 / 一条按 approve 回放的 DECIDED 行;耐久 ask 账:一条
+ * 宣称 approve 的 DECIDED 行),读的是引擎读的同一个事实(卡上的 `requiresRealApproval`)。耐久 `/decide` 不判:引擎在 CAS 之前
+ * 就拒(`checkpoint.invalid_outcome`,卡留 pending),本口的副作用全在引擎受理之后 —— 在那里再判一次就是第二个判官。
+ * core 包根没有导出这只谓词(请托在案);导出之日本函数改为直接调它。
+ */
+export declare function policyCannotAllow(decidedBy: ApprovalDecidedBy, allow: boolean, demandsAPerson: boolean): boolean;
+/**
+ * 一次 decide 的**停驻座事实**,一处成形(耐久 `/decide` 与活卡 PARKED 赎回席共用;截止扫直接铸 `{decidedBy:"sla_timeout"}`)。
+ *
+ * `decidedBy` = 已经过 {@link readDecidedBy} 的 wire 词:两个词在停驻座上**就是它自己**(`person` / `policy`,
+ * 两只词表的交集由上面的编译期门证),所以这里没有 cast,也没有缺席律(缺席已在读法里落成 `"person"`)。
  *
  * `principal` = 那条腿已经验过身份的决策者(缺席 = 匿名档的部署,通道确实没有名字可报)。
  * 归属串走 core 的 `screenApproverAttribution` **先筛后带**:core 对形不合的归属是 pre-CAS 响亮拒,
@@ -76,14 +140,8 @@ export type HostDecidedBy = HostDecision["decidedBy"];
  * 被改造过的串):归属是转录,不是可以「修一修」的东西 —— 修出来的名字既不是通道报的那个,也不是
  * 「通道没报」,两头都不真。
  *
- * 🔴 归属**不按词分岔**:core 7.38.x 的 `policy_refused` 结算记录上没有归属席(`who.party:"none"`),7.39.0 #1265 起有了
- * (`who.party:"policy"`,`approver?`)—— 无论 core 的记录怎么写,**本服务观察到的事实**不变:送出这次请求的那把已验证身份是真的,本仓的
+ * 🔴 归属**不按词分岔**:无论 core 的记录怎么写,**本服务观察到的事实**不变:送出这次请求的那把已验证身份是真的,本仓的
  * 迟到结算账本(`approval-ask-audit-store.ts`)记的就是它。按词删一格 = 给账本挖一个只在某个词上出现的洞。
- *
- * 🔴 **入参是 `string`,不是 `HostDecidedBy` —— 这一格刻意让类型说真话**(wire 边界强类型宪法):两条
- * decide 腿能证得出的只有「调用方给了个串」(形门在各自的口上),**证不出**它是词表成员;把参数声明成
- * 闭集就是让类型替一件本层从没做过的检查背书。⇒ 收 `string`,在**这一处**(本座的边界)做唯一一次 cast,
- * 而那次 cast 说的是「我把一个未判词的串放到只收词的座上,判词的是座的属主(core,pre-CAS 响亮拒)」。
  */
-export declare function hostDecisionFacts(decidedBy: string | undefined, principal: string | undefined): HostDecision;
+export declare function hostDecisionFacts(decidedBy: ApprovalDecidedBy, principal: string | undefined): HostDecision;
 //# sourceMappingURL=host-decision.d.ts.map

package/dist/host-decision.js

@@ -1,6 +1,36 @@
 import { screenApproverAttribution } from "@sema-agent/core";
+export const APPROVAL_DECIDED_BY = ["person", "policy"];
+export const DECIDED_BY_OUTSIDE_CLOSED_SET = 'decidedBy must be "person" or "policy" when present — who made this decision: a person, or this deployment\'s own policy (absent = "person"); "sla_timeout" is never accepted from a caller (only this server\'s own deadline sweep says a wait ended with nobody answering)';
+export const DECIDED_BY_NOT_IN_PROOF = "decidedBy is not supported on a direct-door worker (not covered by the decision proof)";
+export const POLICY_CANNOT_ALLOW_PERSON_ASK = 'decidedBy "policy" cannot allow this ask — it demands a person\'s approval (risk.requiresRealApproval), and a policy\'s answer is not a person\'s; answer it as a person, or refuse it as the policy';
+export const SETTLED_BY_RETIRED = 'settledBy is retired — send decidedBy: "person" | "policy" (who made this decision; absent = "person"); ignoring it would record a policy\'s answer as a person\'s';
+function isApprovalDecidedBy(v) {
+    return APPROVAL_DECIDED_BY.includes(v);
+}
+export function readDecidedBy(raw, directDoorActive) {
+    if (raw === undefined)
+        return { kind: "accepted", decidedBy: "person" };
+    if (directDoorActive)
+        return { kind: "not_in_proof" };
+    return isApprovalDecidedBy(raw) ? { kind: "accepted", decidedBy: raw } : { kind: "outside_closed_set" };
+}
+export function liveSettledBy(decidedBy) {
+    switch (decidedBy) {
+        case "person":
+            return undefined;
+        case "policy":
+            return "policy";
+        default: {
+            const unreachable = decidedBy;
+            throw new Error(`liveSettledBy: unknown decidedBy ${String(unreachable)}`);
+        }
+    }
+}
+export function policyCannotAllow(decidedBy, allow, demandsAPerson) {
+    return decidedBy === "policy" && allow && demandsAPerson;
+}
 export function hostDecisionFacts(decidedBy, principal) {
     const screened = screenApproverAttribution(principal);
-    return { decidedBy: (decidedBy ?? "person"), ...(screened.approver !== undefined ? { approver: screened.approver } : {}) };
+    return { decidedBy, ...(screened.approver !== undefined ? { approver: screened.approver } : {}) };
 }
 //# sourceMappingURL=host-decision.js.map