@sema-agent/server 7.104.0 → 7.106.0

package/dist/runtime-governance.d.ts

@@ -150,12 +150,12 @@ export declare function autonomyOverrides(autonomy: Autonomy | undefined): Parti
  */
 export declare function governanceMandatesShellGateAlways(governance: {
     autonomy?: Autonomy;
-    manualModeShellGate?: "always" | "classify";
+    manualModeShellGate?: ShellGateDoctrine;
 }): boolean;
 /** [ref] 归因的部署侧入参(两个治理旋钮;判据属主见 {@link governanceMandatesShellGateAlways})。 */
 export interface GovernancePosture {
     autonomy?: Autonomy;
-    manualModeShellGate?: "always" | "classify";
+    manualModeShellGate?: ShellGateDoctrine;
 }
 /**
  * [ref]:推「这道门是运维治理层下的吗」。判据是**合取**,两半各管一件事:
@@ -172,8 +172,9 @@ export interface GovernancePosture {
  * ⚠️ 残留(双向失真的窄在场向 + 根治路径)与「只收窄」的那一个裁决读者,都登记在
  * {@link governanceMandatesShellGateAlways} 的顶注,别在这里复述。
  *
- * 🔴 `"classify"` 档**刻意不标**:那一档由 core 的分类器逐调用裁决,一次 shell ask 可能出自分类器(治理)
- * 也可能出自 `APPROVAL_REQUIRE` 这类别的门,行上无从分辨 —— 与活卡腿同一条「宁缺毋假」纪律。
+ * 🔴 **形状档的 ask 刻意不标**(S-877 起它不再是一个档位词:core 7.34.0 把形状档装在**每一种模式**的全权 shell 上,
+ * 行上的 `shellGateDoctrine` 只在运维地板 `"always"` 铸门时出现):形状档的一次 shell ask 出自引擎自己的判断,
+ * 也可能叠着 `APPROVAL_REQUIRE` 这类别的门,行上无从分辨 —— 与活卡腿同一条「宁缺毋假」纪律。
  *
  * 🔴 **单一属主,四个读者**(不在任何读面另写一份判据 —— 这一位恰恰是靠「行上取证 ∧ 部署姿态」的合取才不
  * 谎报的,两份必漂):409 体的待批门材料(`http/active-run-conflict.ts`)、两条 durable 读面
@@ -196,10 +197,6 @@ export declare function governanceOriginOf(gate: {
         shellGateDoctrine?: ShellGateDoctrine;
     };
 } | undefined, governance: GovernancePosture | undefined): true | undefined;
-/** spec 序里的秩(0 起,越大越严)。入参收 `string`(fail-loud 边界:schema `trustRank` 同款姿势)——词表外 ⇒
- *  RangeError,绝不 undefined/NaN 让比较静默成 false。导出只为对表钉(test/safety-merge-spec-consumption.test.ts,
- *  [ref] 件4)——运行时消费仍走上表(键类型闭集)。 */
-export declare function shellGateRank(word: string): number;
 /**
  * Apply the operator's runtime governance (autonomy + commandPolicy + manualModeShellGate) onto a base
  * `TaskSpec`, TIGHTEN-ONLY, in a SINGLE {@link tightenTaskSpec} call: commandPolicy compiles to a `toolPolicy`
@@ -212,8 +209,8 @@ export declare function shellGateRank(word: string): number;
  * (task-settings deriveSettingsPolicy 的 default/auto/acceptEdits 三臂)让一个**部署级 tighten-only 旋钮
  * 的生死由客户端表态在场性决定**:body 无 settings/permissionMode(cli print/headless 腿按设计不 stamp)
  * ⇒ 旋钮静默失效(clay 实机 Monitor 案「门根本没铸」);bypassPermissions 一句话掀掉部署闸;非 host lane
- * fsWriteGate wiring 不建 ⇒ 沙箱 lane 全失效。governance 层与 autonomy 同拍施加后三者全闭。rank 合成:
- * autonomy 派生值与旋钮取大(ask→"always" 压过 "classify"),再对 base 只升不降(防 tightenTaskSpec throw)。
+ * fsWriteGate wiring 不建 ⇒ 沙箱 lane 全失效。governance 层与 autonomy 同拍施加后三者全闭。S-877 起地板只有
+ * `"always"` 一个词,合成退化成在场性(两个来源同词),不再有秩比较。
  *
  * [ref]([ref] issue #29,**邻仓 test AI 的 46 格真机矩阵**实证——不是本仓的钉,别到本仓文件里数 46;
  * 本仓的类级门是 test/operator-knob-client-posture-matrix.test.ts 的 旋钮×表态×lane 矩阵):
@@ -231,7 +228,7 @@ export declare function shellGateRank(word: string): number;
 export declare function applyRuntimeGovernance(base: TaskSpec, governance: {
     autonomy?: Autonomy;
     commandPolicy?: CommandRule[];
-    manualModeShellGate?: "always" | "classify";
+    manualModeShellGate?: ShellGateDoctrine;
     sensitivePathPolicy?: ToolPolicy;
     /** [ref]/[ref] `governanceForced` 的标记表(缺省 = **当前 run 腿的 ALS 表**,见
      *  `governance-ask-marks.ts` 顶注「作用域」段)。注入口只为测试与将来的多实例形。 */

package/dist/runtime-governance.js

@@ -1,7 +1,7 @@
-import { combinePolicies, COARSE_SHELL_TOOLS as CORE_COARSE_SHELL_TOOLS, createCoarseCommandNamePolicy, DEFAULT_SUBAGENT_TOOL_NAME, parseLeadingCommandName, tightenTaskSpec, } from "@sema-agent/core";
-import { GovernanceConfig, SAFETY_MERGE_SPEC } from "@sema-agent/settings-schema";
+import { combinePolicies, COARSE_SHELL_TOOLS as CORE_COARSE_SHELL_TOOLS, createCoarseCommandNamePolicy, DEFAULT_SUBAGENT_TOOL_NAME, parseLeadingCommandName, tightenTaskSpec, wrapToolPolicy, } from "@sema-agent/core";
+import { GovernanceConfig } from "@sema-agent/settings-schema";
 import { currentGovernanceAskMarks } from "./governance-ask-marks.js";
-import { operatorAsk } from "./operator-ask.js";
+import { operatorAsk, withDeploymentAuthorship } from "./operator-ask.js";
 const COMMAND_RULE_SHAPE = GovernanceConfig.shape.commandPolicy.unwrap().element.shape;
 const COMMAND_DECISIONS = COMMAND_RULE_SHAPE.decision.options;
 export const AUTONOMY_MODES = GovernanceConfig.shape.autonomy.unwrap().options;
@@ -124,14 +124,12 @@ export function governanceOriginOf(gate, governance) {
 function createGovernanceAskMarkingPolicy(inner, marksOf) {
     const note = (d, req) => {
         marksOf()?.setMarked(req.toolCallId, d.action === "ask");
-        return d;
-    };
-    return {
-        check(req, signal) {
-            const decision = inner.check(req, signal);
-            return decision instanceof Promise ? decision.then((d) => note(d, req)) : note(decision, req);
-        },
+        return d.action === "ask" ? withDeploymentAuthorship(d) : d;
     };
+    return wrapToolPolicy(inner, (req, signal) => {
+        const decision = inner.check(req, signal);
+        return decision instanceof Promise ? decision.then((d) => note(d, req)) : note(decision, req);
+    });
 }
 function createGovernanceShellGateMarkPolicy(marksOf, tools = COARSE_SHELL_TOOLS) {
     const shellTools = new Set(tools);
@@ -143,28 +141,6 @@ function createGovernanceShellGateMarkPolicy(marksOf, tools = COARSE_SHELL_TOOLS
         },
     };
 }
-const SHELL_GATE_RANK = (() => {
-    const tighten = SAFETY_MERGE_SPEC.shellGate.tighten;
-    const rule = tighten.rule;
-    if (tighten.rule !== "enumRank")
-        throw new Error(`SAFETY_MERGE_SPEC.shellGate.tighten.rule=${rule} — 不是 enumRank,shellGate 秩无从派生`);
-    const table = { off: -1, classify: -1, always: -1 };
-    for (const [i, w] of tighten.order.entries()) {
-        if (!(w in table))
-            throw new Error(`SAFETY_MERGE_SPEC.shellGate 序里有本仓词表外的词:${w}`);
-        table[w] = i;
-    }
-    for (const [w, r] of Object.entries(table))
-        if (r < 0)
-            throw new Error(`SAFETY_MERGE_SPEC.shellGate 序缺词:${w}`);
-    return table;
-})();
-export function shellGateRank(word) {
-    const r = SHELL_GATE_RANK[word];
-    if (r === undefined)
-        throw new RangeError(`unknown shellGate word: ${word}`);
-    return r;
-}
 export function applyRuntimeGovernance(base, governance) {
     const marksOf = () => governance.askMarks ?? currentGovernanceAskMarks();
     const overrides = { ...autonomyOverrides(governance.autonomy) };
@@ -175,15 +151,8 @@ export function applyRuntimeGovernance(base, governance) {
         : undefined;
     if (governancePolicy !== undefined)
         overrides.toolPolicy = governancePolicy;
-    if (governance.manualModeShellGate !== undefined) {
-        const candidate = overrides.shellGate !== undefined && SHELL_GATE_RANK[overrides.shellGate] >= SHELL_GATE_RANK[governance.manualModeShellGate]
-            ? overrides.shellGate
-            : governance.manualModeShellGate;
-        if (SHELL_GATE_RANK[candidate] >= SHELL_GATE_RANK[base.shellGate ?? "off"])
-            overrides.shellGate = candidate;
-        else
-            delete overrides.shellGate;
-    }
+    if (governance.manualModeShellGate === "always")
+        overrides.shellGate = "always";
     if (overrides.shellGate === "always") {
         const shellObserver = createGovernanceShellGateMarkPolicy(marksOf);
         overrides.toolPolicy = governancePolicy === undefined ? shellObserver : combinePolicies(governancePolicy, shellObserver);

package/dist/sealed-key.d.ts

@@ -50,46 +50,6 @@ export interface SealedKeyCapability {
  *  omits the key entirely (present-iff this process built its custody store — see the route for the two meanings
  *  of absence). */
 export declare function projectSealedKeyCapability(face: SealedKeyPublicFace | undefined): SealedKeyCapability | undefined;
-/** Why a model's sealed key could not be unsealed (the poison-pill diagnosis, see SealedKeyPoison). CUSTODY failures only:
- *  a sealedApiKey that is malformed (alg other than the pinned v1 SEALED_KEY_ALG, non-base64 ciphertext) makes the whole
- *  catalog entry unavailable instead (S-704 `config.model_entry_invalid`, settings-schema `SealedApiKey` is the shape
- *  owner) — the former `unsupported_alg` reason was retired with that move (it could no longer be reached). */
-export type SealedKeyPoisonReason = "sealed_decrypt_failed" | "stale_ciphertext" | "no_key_store";
-/**
- * Poison-pill entry for the per-model key map (`config.modelApiKeys`): planted by applyEffective when
- * a model CARRIES `sealedApiKey` but the ciphertext cannot be unsealed. We deliberately do NOT drop
- * the model from the map — dropping made "sealed key broken" indistinguishable from "no per-model key
- * configured", and when the deployment also has a gateway MODEL_API_KEY the model's tasks silently
- * fell back onto the shared account (the exact hole the no-apiKeyEnv-fallback contract exists to
- * close). createKeyResolver turns this marker into a task-level `SealedKeyPoisonedError` — never
- * `undefined`, because undefined IS the "use the gateway key" semantic. Carries DIAGNOSIS only:
- * never the ciphertext, never any plaintext.
- */
-export interface SealedKeyPoison {
-    readonly sealedKeyPoison: true;
-    readonly publicKeyId: string;
-    readonly reason: SealedKeyPoisonReason;
-    /** Error CLASS of the unseal failure (e.g. "Error") — never the message (message text is logged
-     *  at plant time; keeping the object minimal keeps every serialization face trivially secret-free). */
-    readonly errKind?: string;
-    /** ISO timestamp of the apply that detected the failure. */
-    readonly at: string;
-}
-export declare function sealedKeyPoison(publicKeyId: string, reason: SealedKeyPoisonReason, errKind?: string): SealedKeyPoison;
-export declare function isSealedKeyPoison(v: unknown): v is SealedKeyPoison;
-/**
- * The task-level fail-loud face of a poison pill: thrown by the key resolver on EVERY brain call that
- * would otherwise authenticate this model, so a broken sealed key fails the task visibly (same family
- * as a rotation-leg auth failure) instead of silently burning the gateway account. Message carries the
- * sealed-failure marker (reason + publicKeyId + detection time) plus the operator fix — and nothing
- * secret (no ciphertext, no plaintext, by construction of SealedKeyPoison).
- */
-export declare class SealedKeyPoisonedError extends Error {
-    readonly publicKeyId: string;
-    readonly reason: SealedKeyPoisonReason;
-    readonly at: string;
-    constructor(modelName: string, poison: SealedKeyPoison);
-}
 /** Default id = fingerprint of the RAW public-key bytes: `exec-<sha256(pk)[0..12) hex>`.
  *  Deterministic → regenerating the id from the same key file is stable across boots. */
 export declare function deriveKeyId(publicKeyRaw: Uint8Array): string;

package/dist/sealed-key.js

@@ -17,26 +17,6 @@ export function projectSealedKeyCapability(face) {
         return undefined;
     return { alg: SEALED_KEY_ALG, publicKeyId: face.latest.publicKeyId, publicKey: face.latest.publicKey };
 }
-export function sealedKeyPoison(publicKeyId, reason, errKind) {
-    return { sealedKeyPoison: true, publicKeyId, reason, ...(errKind ? { errKind } : {}), at: new Date().toISOString() };
-}
-export function isSealedKeyPoison(v) {
-    return typeof v === "object" && v !== null && v.sealedKeyPoison === true;
-}
-export class SealedKeyPoisonedError extends Error {
-    publicKeyId;
-    reason;
-    at;
-    constructor(modelName, poison) {
-        super(`sealed api key for model "${modelName}" is unusable (${poison.reason}; publicKeyId "${poison.publicKeyId}"; detected ${poison.at}) — ` +
-            `refusing the gateway-key fallback. Fix custody: re-paste the key in the web UI (it seals against the newest registered public key), ` +
-            `or restore this host's private key for that id / complete the rotation so the ciphertext targets a held key.`);
-        this.name = "SealedKeyPoisonedError";
-        this.publicKeyId = poison.publicKeyId;
-        this.reason = poison.reason;
-        this.at = poison.at;
-    }
-}
 export function deriveKeyId(publicKeyRaw) {
     return `exec-${createHash("sha256").update(publicKeyRaw).digest("hex").slice(0, 12)}`;
 }

package/dist/server-secret-env.d.ts

@@ -69,9 +69,9 @@ export declare const CATALOG_SECRET_ENV_NAMES: ReadonlySet<string>;
  * 目录臂的计数恰好就是 core 形状规则的缺口读数;名单型旋钮臂只记前两臂都漏下的(今天 = 不在服务目录里的 `BAKE_ENV_ALLOW`)。
  * 各腿不直接调它 —— 经 {@link hostSubprocessEnv}(剥 + 放回 + 留痕一只口)。
  *
- * **只为宿主子进程组合**:子进程与本进程同平台 ⇒ core `scrubSecretEnv` 的平台尾参(core 7.33.6 #1159:git 的 env 配置记录按子进程的平台读 ——
- * POSIX 只认大写名,win32 大小写折叠)取缺省 `process.platform` 即对。本包跑在别的平台上的子进程(ssh / k8s / adb / e2b / docker 车道)的 env
- * 不经本函数:那些车道不继承本进程 env,只交调用方显式给的 env 与部署方点名的键(`E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV`,经 {@link allowlistedEnv})。
+ * **只为宿主子进程组合**。本包跑在别的平台上的子进程(ssh / k8s / adb / e2b / docker 车道)的 env 不经本函数:那些车道不继承本进程 env,只交
+ * 调用方显式给的 env 与部署方点名的键(`E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV`,经 {@link allowlistedEnv})。(core 7.33.6 #1159 的平台尾参随
+ * core 7.35.0 #1201 删除 —— git 的 env 配置族成了豁免族,不再有「按子进程平台读记录」这件事,S-877。)
  */
 export declare function scrubServerSecrets(env: NodeJS.ProcessEnv, findings: ServerSecretEnvFinding[]): NodeJS.ProcessEnv;
 /**
@@ -87,15 +87,14 @@ export declare function scrubServerSecrets(env: NodeJS.ProcessEnv, findings: Ser
  * 返回 `NodeJS.ProcessEnv` 形(值可能是 `undefined` 的键本来就不会进子进程);调用方显式要交的键(`LC_ALL`、`cfg.env` …)叠在它之上。
  * 调用时机 = 每次要交 env 时现算一次(`process.env` 在本仓是 boot 期输入,各次同值;计数因此是「每组合一次」)。
  *
- * 🔴 **git 的 env 配置组(`GIT_CONFIG_COUNT` + `GIT_CONFIG_KEY_<i>` / `GIT_CONFIG_VALUE_<i>`)只有 core 一只写手**(7.103.1:车PG 退役本层,车PK 提 core 7.33.6):
- * 一条配置(KEY + VALUE)一次判定;COUNT 以内被扣的一条**原位**换占位(`GIT_CONFIG_KEY_<i>=sema.withheld` / `GIT_CONFIG_VALUE_<i>=""`,git 读成一条没人用的
- * 配置)、不重排、COUNT 原样(#1160);COUNT 之外 / 没有 COUNT 的被扣条目整条不交;COUNT 按 git 的 `strtoul` 读(#1162);记录按子进程的平台读(#1159,见
- * {@link scrubServerSecrets})。本层 7.103.0 的「整组扣」与 7.103.1 中间态的「按 pair 扣留 + 重编号」(D-7)都已退役,本层不重判(同一语义面上不留第二只写手)。
- * 本仓按名两臂(目录 secret 名 / 名单型旋钮)不含这一族的名字(钉:`test/secret-env-git-config-pair.test.ts`「一只写手」格)。
- * 点名放回按名叠在 scrub 结果之上 ⇒ 放回一条被扣配置要把 KEY 与 VALUE 两只一并点名(只点一只 = 与另一只的占位半条配成一对)。
- * 🔴 **披露谓词 = 「这个名字没有按原样交给子进程」**(输入值 vs 输出值;core 7.33.6 pickup 注:「not handed on as written」)。被扣的记录成员在输出里
- * **仍在**(装着占位半条)⇒「组合结果里有没有这个名字」恒为有;点名放回的名字取回源值 ⇒ 与输入同值 ⇒ 不是剥除;占位半条恰与输入同值的成员(KEY 里
- * 带凭据、VALUE 本就是空串)子进程拿到的正是原值 ⇒ 也不披露。一只谓词盖住「剥掉」「换占位」「点名放回」三形,不按形分臂。
+ * 🔴 **git 的 env 配置族与代理变量一族只有 core 一只写手**:core 7.35.0 #1201(S-877,CC 2.1.280 形)起它们是 core 的**豁免族** ——
+ * `GIT_CONFIG_COUNT` / `GIT_CONFIG_PARAMETERS` / `GIT_CONFIG_KEY_<数字>` / `GIT_CONFIG_VALUE_<数字>`(大写)与 `http(s)_proxy` / `all_proxy` / `no_proxy` /
+ * `npm_config_*proxy` …(任意大小写),名与值都不读、**原样交出,凭据在内**(7.33.2–7.33.8 的逐条扣 / 原位占位 `sema.withheld` / 整只扣全部退役;
+ * 部署面:凭据不放本进程 env —— `docs/DEPLOY-PREREQS.md`)。本层 7.103.0 的「整组扣」与 7.103.1 中间态的「按 pair 扣留 + 重编号」(D-7)更早退役,
+ * 本层不重判(同一语义面上不留第二只写手;在下游把 core 的豁免改回扣 = 源头修复宪法禁止的改写)。本仓按名两臂(目录 secret 名 / 名单型旋钮)不含
+ * `GIT_CONFIG_` 这一族的名字(钉:`test/secret-env-git-config-pair.test.ts`「一只写手」格)。
+ * 🔴 **披露谓词 = 「这个名字没有按原样交给子进程」**(输入值 vs 输出值)。core 对一个变量的动作恒为「整只删」(从不改写值,#1201),点名放回的名字
+ * 取回源值 ⇒ 与输入同值 ⇒ 不是剥除。一只谓词盖住「剥掉」「点名放回」两形,不按形分臂(7.33.6–7.33.8 还有第三形「换占位」,随 #1201 消失)。
  */
 export declare function hostSubprocessEnv(o: {
     site: SecretEnvScrubSite;

package/dist/session-policy-wire.d.ts

@@ -16,10 +16,16 @@
  *        自陈「Malformed shape → 400(never a downstream TypeError)」,这一半没守);
  *      · `loosenReasons` 的每一臂都从 `prior` 出发,**prior 为空时恒回空集** ⇒ tighten-only 门对一条
  *        全新的会话放行任何内容,坏形因此连「收紧门」这一层都碰不到。
- * ⇒ 类修:一只读者,键集由 `keyof SessionPermissionRules` **派生**(下方 `RULE_FIELD_PRESENCE` 的
- * `satisfies Record<keyof SessionPermissionRules, true>`:core 加桶 ⇒ 缺键**编译红**;core 删桶 ⇒
+ * ⇒ 类修:一只读者,键集由 `keyof SessionPermissionRules` **派生**(下方 `RULE_FIELD_ROLE` 的
+ * `satisfies Record<keyof SessionPermissionRules, RuleFieldRole>`:core 加桶 ⇒ 缺键**编译红**;core 删桶 ⇒
  * 多键**编译红**),两条腿同调。
  *
+ * ── S-800(7.105.0):同一只读者多判一问 —— 写得进却跑不了的工具名 ─────────────────────────────────
+ * 两条写入腿是 server 往会话规则店写的**全部**写口,所以「写口 fail-closed」收成一只**写口读者**
+ * ({@link readWritableSessionPermissionRules} = 形读者 + {@link legacyToolNameOf}),两腿同调,将来第三条写入腿
+ * 调同一只也同得。判词多一种(`legacy-tool-name`),两腿各把它映射成 `400 rules.legacy_tool_name`(映射点仍在各自
+ * 站点:码位只放字面量)。形读者本身不变 —— SQL 店的读回也用它,读回不许判名字(理由见写口读者头注)。
+ *
  * ── 文案也在这里(codex 一轮追加:两条腿各铸一份句子 = 第二份手抄)───────────────────────────────
  * 初版把 wire 文案留在两个路由各自铸,理由是错误文案冻结门(`test/api-error-text-freeze.test.ts`)锚的是
  * `src/http/` 桶里的 `sendError` 站点。codex 一轮指出那等于**把同一句话写了两遍**(`sessions.ts` 与
@@ -28,10 +34,54 @@
  * 渲染器对每一种判词的输出字节,且对判词闭集穷尽(加一种判词 ⇒ 那一格编译红)。文案一个字节未改。
  */
 import type { SessionPermissionRules, SessionPolicyError, SessionRulesRecord } from "@sema-agent/core";
+declare const RULE_FIELD_ROLE: {
+    readonly toolAllow: "tool-name";
+    readonly toolDeny: "tool-name";
+    readonly allowDirs: "path";
+    readonly commandAllow: "command";
+    readonly commandDeny: "command";
+};
 /** core `SessionPermissionRules` 的桶名全集(派生,不是手抄)。 */
 export declare const SESSION_PERMISSION_RULE_FIELDS: readonly (keyof SessionPermissionRules)[];
-/** 一条规则体的形问题。判词而非文案(见文件头注的「文案属主」一段)。 */
-export type SessionPermissionRulesProblem = 
+/** 装工具名的那几桶(由 {@link RULE_FIELD_ROLE} 派生的型)。 */
+export type ToolNameRuleField = {
+    [K in keyof typeof RULE_FIELD_ROLE]: (typeof RULE_FIELD_ROLE)[K] extends "tool-name" ? K : never;
+}[keyof typeof RULE_FIELD_ROLE];
+/**
+ * S-800(client-core [ref] CC-226;server [ref];core [ref])—— 「写得进、跑不了、撤不掉」的工具名。
+ *
+ * 两臂,逐字对应 core 7.33.8 准备阶段名审计抛 `config.legacy_tool_name` 的那两臂(判据只用 core **导出**的
+ * 两件,零镜像表 —— 表随 core 钉版走):
+ *  · `"retired"`:名字在 core 的 `RETIRED_TOOL_NAMES` 里;`guidance` = 那张表给它的一句现役指引(原样);
+ *  · `"unprefixed-namespace"`:名字里有 `"__"` 分隔符,而 `protocolOf(name)` 认不出它属于哪个协议。
+ *
+ * 为什么在**写口**判:会话规则店只准非 operator 收紧,删掉一条 deny 算放宽 ⇒ 写进去的这种名字属主自己删不掉,
+ * 而准备阶段见它就整只拒启 ⇒ 这个会话之后的每一跑都起不来。写口是唯一还来得及说「不」的地方。
+ *
+ * ⚠️ **比准备阶段严一格**(方向安全,与 client-core 0.83.6 的 KL-157 同向):准备阶段对**本 run 名册里挂着**的
+ * 同名工具放行(部署自己挂了一只叫 `Task` 的工具就不审计它),写口看不到将来哪一跑的名册 ⇒ 一律拒。
+ * 受伤的是「部署自带与退役名同名的工具、又要在会话规则里点它」的形;出路 = 部署级工具策略(不经会话规则店)。
+ * ⚠️ **过渡形**:core 已表态(#1156)把这两臂抽成一只导出纯函数并在会话规则店写口即拒 —— 到货后本函数
+ * 换成调 core 那只(拒因原样透传),三份判定收成一份。**S-877 提货复核(core 7.35.0)**:#1156 **未随版**(发车帖 [ref] 逐字
+ * 「照 #1156 未随本版」);同版新导出的 `rosterToolName` / `ruleNamesOf`(#1194)是**别名归一**(一个名字在名册上落到哪只行的线名 /
+ * 一次调用可被规则拼成的名字集),不回答「这个名字会不会让准备阶段拒启」,不能替本函数 ⇒ 本函数照留,等 #1156。
+ *
+ * 🔴 **为什么不复用 `config.ts` 的 `findUnmatchableToolNames`**(本仓另一只按名字判的单点;读过实现后裁):两只回答的
+ * 不是同一个问题。那一只问「部署名单里这条名字会不会**永远匹配不上**活工具」—— 它刻意豁免 `allow`(白名单匹配不上 =
+ * fail-closed 且当场可见),并且拒两段 MCP 名 `mcp__srv`(一名两义)与 core 文法编不出的串。本函数问的是「引擎见到这条
+ * 会话规则会不会**拒启**」:引擎准备阶段的名审计对 `allow` 桶照样抛(豁免它 = 放过一条砖化路径),对 `mcp__srv` 却
+ * **不**抛(会话层自 core 5.55 / 5.56 起把它当整对端覆盖形真命中)。判据只能逐字跟 core 那两臂走,不能借另一只的口径。
+ * 两只在「退役名」「无前缀 `__` 名」两臂上同源(都读 core 导出的同两件),#1156 到货的那一批一并换调 core 的导出函数。
+ */
+export type LegacyToolName = {
+    why: "retired";
+    guidance: string;
+} | {
+    why: "unprefixed-namespace";
+};
+export declare function legacyToolNameOf(name: string): LegacyToolName | undefined;
+/** 一条规则体的**形**问题。判词而非文案(见文件头注的「文案属主」一段)。 */
+export type SessionPermissionRulesShapeProblem = 
 /** 整体不是一只普通对象(`null` / 数组 / 标量 / 缺席)。 */
 {
     kind: "not-an-object";
@@ -41,22 +91,45 @@ export type SessionPermissionRulesProblem =
     kind: "field-not-string-array";
     field: keyof SessionPermissionRules;
 };
-/** {@link readSessionPermissionRules} 的读数:坏形给判词,好形给**已收窄**的规则体(调用方零 cast)。 */
-export type SessionPermissionRulesRead = {
-    problem: SessionPermissionRulesProblem;
+/** 一条**要写进店**的规则体的问题 = 形问题 ∪ S-800 的名字问题(判据 {@link legacyToolNameOf})。 */
+export type SessionPermissionRulesProblem = SessionPermissionRulesShapeProblem
+/** S-800:形对,但工具名桶里有一条写进去就跑不了的名字。 */
+ | {
+    kind: "legacy-tool-name";
+    field: ToolNameRuleField;
+    name: string;
+    legacy: LegacyToolName;
+};
+/** 两只读者的读数:有问题给判词,没问题给**已收窄**的规则体(调用方零 cast)。`P` = 这只读者会给的判词集。 */
+export type SessionPermissionRulesRead<P extends SessionPermissionRulesProblem = SessionPermissionRulesProblem> = {
+    problem: P;
     rules?: undefined;
 } | {
     problem?: undefined;
     rules: SessionPermissionRules;
 };
 /**
- * 读一只 wire 上的 `SessionPermissionRules`:形不对给判词,形对给**只含五桶**的规则体。
+ * **形读者**:读一只 `SessionPermissionRules`,形不对给判词,形对给**只含五桶**的规则体。三个消费者:两条写入腿
+ * (经 {@link readWritableSessionPermissionRules})与 SQL 店的**读回**(`session-policy-store-sql.ts` 的
+ * `readSessionRulesBody`:读不出形的行判 `corrupt`)。
  *
  * 认识面窄得刻意:**只判形**,不判内容(桶内字符串的 pattern 文法、路径是否可达、tighten-only 是否成立
- * 都不在这里 —— 前两者归 core 的 rule 文法与 `normalizeRules`,后者归 `putRules` 的收紧门)。
- * 未知键**照旧忽略**(不是新的拒因):core 的 `normalizeRules` 本来就只搬这五桶,本读者与它同口径。
+ * 都不在这里 —— 前两者归 core 的 rule 文法与 `normalizeRules`,后者归 `putRules` 的收紧门;S-800 的名字判官
+ * 只在**写口**那一只读者里,见下)。未知键**照旧忽略**(不是新的拒因):core 的 `normalizeRules` 本来就只搬这五桶,
+ * 本读者与它同口径。
  */
-export declare function readSessionPermissionRules(raw: unknown): SessionPermissionRulesRead;
+export declare function readSessionPermissionRules(raw: unknown): SessionPermissionRulesRead<SessionPermissionRulesShapeProblem>;
+/**
+ * **写口读者**(S-800)= 形读者 + 名字判官:两条写入腿(`PUT /v1/sessions/:id/policy`、sync/import 的 `policy`
+ * 面经 {@link readSessionRulesRecords})往会话规则店写之前的**唯一**判据。两问,按序:
+ *  ① 形(同 {@link readSessionPermissionRules};一份坏形的体答形的 400);
+ *  ② 工具名桶里的每一条过 {@link legacyToolNameOf} —— 写进去之后属主撤不掉、会话之后每一跑都起不来的名字,
+ *     写口是唯一来得及拒的地方。
+ * 🔴 **只在写口,不在读回**:SQL 店读回同一行时只判形(形读者)。一条早先写进去的退役名行必须**读得出来** ——
+ * 那是运营方清掉它的唯一路径(operator 的 PUT 先读写前快照),也是 core 准备阶段报 `config.legacy_tool_name`
+ * 而不是一只 500 `corrupt` 的前提。把判官放进形读者会让读回把它判坏(7.105.0 车QQ 双库套件实抓,修在同批)。
+ */
+export declare function readWritableSessionPermissionRules(raw: unknown): SessionPermissionRulesRead;
 /** 一条 `SessionRulesRecord` 的形问题(`policy[]` 的元素级;桶级问题原样转载在 `rules` 位)。 */
 export type SessionRulesRecordProblem = 
 /** `policy` 本身不是数组。 */
@@ -90,6 +163,8 @@ export type SessionRulesRecordsRead = {
 };
 /**
  * 读 sync/import 的 `policy` 面(`SessionRulesRecord[]`)。好形返回**已收窄**的记录数组,坏形给判词。
+ * 它只服务那一条**写入**腿(导入的记录随后 `putRules` 进店),所以每条记录的规则体走**写口读者**
+ * {@link readWritableSessionPermissionRules}(与 PUT 腿同一只判官)。
  *
  * `rev`:记录里带的 `rev` 是**导出端的**乐观锁读数,`putRules` 侧一进门就 `stripRev` 掉(`sameRulesContent`
  * 也比的是去 rev 的字节形),所以它在本读者里只是过境位 —— 非数字即当缺席(不是拒因:一个坏 rev 改变不了
@@ -98,6 +173,15 @@ export type SessionRulesRecordsRead = {
 export declare function readSessionRulesRecords(raw: unknown): SessionRulesRecordsRead;
 /** 桶级判词 → 人话。闭集穷尽:{@link SessionPermissionRulesProblem} 加一种判词 ⇒ 本 switch 编译红。 */
 export declare function describeSessionPermissionRulesProblem(p: SessionPermissionRulesProblem): string;
+/**
+ * S-800:一只 `policy[]` 判词**是不是**「写得进却跑不了的名字」那一类 —— 是就交回那一格(桶 + 名字),
+ * 调用点据此发 `rules.legacy_tool_name`,否则发形的码。闭集穷尽两层:记录级判词或桶级判词加一种 ⇒ 编译红,
+ * 新判词不会静默落进某一个码。
+ */
+export declare function legacyToolNameProblemOf(p: SessionRulesRecordProblem): {
+    field: ToolNameRuleField;
+    name: string;
+} | undefined;
 /** `policy[]` 判词 → 人话(sync/import 腿在它前面拼 `policy: `)。闭集穷尽同上。 */
 export declare function describeSessionRulesRecordProblem(p: SessionRulesRecordProblem): string;
 /**
@@ -115,7 +199,10 @@ export declare function describeSessionRulesRecordProblem(p: SessionRulesRecordP
  *
  * 逐词:
  *  · `conflict`(409)—— CAS 输了,重读 `rev` 再来。**码位与状态逐字不变**。
- *  · `loosen_forbidden`(403)—— 非 operator 想放松。**码位与状态逐字不变**。
+ *  · `loosen_forbidden`(403)—— 非 operator 想放松。**码位与状态逐字不变**。⚠️ 这个词还有**第二个铸点**(S-546 B5,
+ *    如实登记、未改):PG 后端的 SQL 双生对含 NUL / 孤代理字节的规则拒收时借用了它
+ *    (`plugins/session-policy-store-sql.ts` 的 `pgHasUnstorable` 臂)—— 那一形**既非放宽也非越权**,operator 写同样撞上;
+ *    core 的闭集里没有「输入不可存」这个词,改码位要先裁定新码与 PUT / 2c 导入两条入口同判(DEBTS S-546 B5)。
  *  · `corrupt`(**500**)—— 店读不出它自己该读的那份字节(记号/行被列外篡改或撕裂)。
  *    不是 4xx:调用方没做错任何事,它也改不了这件事;不是 503:重试改不了判(core 成文的修复路径是
  *    **人**去改回或删掉那一行,而删记号要交出它握着的那个号)。
@@ -124,4 +211,5 @@ export declare function sessionPolicyErrorHttp(code: SessionPolicyError["code"])
     status: number;
     errorCode: string;
 };
+export {};
 //# sourceMappingURL=session-policy-wire.d.ts.map

package/dist/session-policy-wire.js

@@ -1,11 +1,24 @@
-const RULE_FIELD_PRESENCE = {
-    toolAllow: true,
-    toolDeny: true,
-    allowDirs: true,
-    commandAllow: true,
-    commandDeny: true,
+import { PROTOCOL_TABLE, RETIRED_TOOL_NAMES, protocolOf } from "@sema-agent/core";
+const RULE_FIELD_ROLE = {
+    toolAllow: "tool-name",
+    toolDeny: "tool-name",
+    allowDirs: "path",
+    commandAllow: "command",
+    commandDeny: "command",
 };
-export const SESSION_PERMISSION_RULE_FIELDS = Object.keys(RULE_FIELD_PRESENCE);
+export const SESSION_PERMISSION_RULE_FIELDS = Object.keys(RULE_FIELD_ROLE);
+const TOOL_NAME_RULE_FIELDS = SESSION_PERMISSION_RULE_FIELDS.filter((f) => RULE_FIELD_ROLE[f] === "tool-name");
+export function legacyToolNameOf(name) {
+    const guidance = RETIRED_TOOL_NAMES.get(name);
+    if (guidance !== undefined)
+        return { why: "retired", guidance };
+    if (name.includes("__") && protocolOf(name) === undefined)
+        return { why: "unprefixed-namespace" };
+    return undefined;
+}
+function protocolToolNameShapes() {
+    return PROTOCOL_TABLE.map((ns) => `${ns.prefix}<peer>__<tool>`).join(" or ");
+}
 export function readSessionPermissionRules(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw))
         return { problem: { kind: "not-an-object" } };
@@ -21,6 +34,19 @@ export function readSessionPermissionRules(raw) {
     }
     return { rules };
 }
+export function readWritableSessionPermissionRules(raw) {
+    const read = readSessionPermissionRules(raw);
+    if (read.problem !== undefined)
+        return read;
+    for (const field of TOOL_NAME_RULE_FIELDS) {
+        for (const name of read.rules[field] ?? []) {
+            const legacy = legacyToolNameOf(name);
+            if (legacy !== undefined)
+                return { problem: { kind: "legacy-tool-name", field, name, legacy } };
+        }
+    }
+    return read;
+}
 export function readSessionRulesRecords(raw) {
     if (!Array.isArray(raw))
         return { problem: { kind: "not-an-array" } };
@@ -32,7 +58,7 @@ export function readSessionRulesRecords(raw) {
         const { principal, rules, rev } = e;
         if (principal !== undefined && typeof principal !== "string")
             return { problem: { kind: "principal-not-a-string", index } };
-        const read = readSessionPermissionRules(rules);
+        const read = readWritableSessionPermissionRules(rules);
         if (read.problem !== undefined)
             return { problem: { kind: "rules", index, problem: read.problem } };
         const innerRev = rules?.rev;
@@ -45,12 +71,49 @@ export function describeSessionPermissionRulesProblem(p) {
     switch (p.kind) {
         case "not-an-object": return "rules must be a SessionPermissionRules object";
         case "field-not-string-array": return `${p.field} must be an array of strings`;
+        case "legacy-tool-name": return describeLegacyToolName(p.field, p.name, p.legacy);
         default: {
             const unhandled = p;
             throw new Error(`unhandled SessionPermissionRules problem: ${JSON.stringify(unhandled)}`);
         }
     }
 }
+function describeLegacyToolName(field, name, legacy) {
+    switch (legacy.why) {
+        case "retired":
+            return `${field} names "${name}", a retired tool name (${legacy.guidance}); with that rule in place this session could not start another run, so nothing was written — use the current tool name`;
+        case "unprefixed-namespace":
+            return `${field} names "${name}", which contains "__" but no protocol prefix; with that rule in place this session could not start another run, so nothing was written — a protocol tool is named ${protocolToolNameShapes()}`;
+        default: {
+            const unhandled = legacy;
+            throw new Error(`unhandled legacy tool name arm: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+export function legacyToolNameProblemOf(p) {
+    switch (p.kind) {
+        case "not-an-array":
+        case "record-not-an-object":
+        case "principal-not-a-string":
+            return undefined;
+        case "rules":
+            switch (p.problem.kind) {
+                case "not-an-object":
+                case "field-not-string-array":
+                    return undefined;
+                case "legacy-tool-name":
+                    return { field: p.problem.field, name: p.problem.name };
+                default: {
+                    const unhandled = p.problem;
+                    throw new Error(`unhandled SessionPermissionRules problem: ${JSON.stringify(unhandled)}`);
+                }
+            }
+        default: {
+            const unhandled = p;
+            throw new Error(`unhandled SessionRulesRecord problem: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
 export function describeSessionRulesRecordProblem(p) {
     switch (p.kind) {
         case "not-an-array": return "must be an array of {principal, rules} records";

package/dist/session-titler.d.ts

@@ -54,6 +54,17 @@ export interface SessionTitler {
 export declare const TITLE_MAX_CHARS = 80;
 /** Single line, control chars stripped, hard cap; surrounding quotes (a common LLM tic) trimmed. */
 export declare function sanitizeTitle(raw: string): string;
+/**
+ * S-236 ②(7.106.0,cli L-687)—— objective 里**用户自己写的**那部分:剥掉全部 `<system-reminder>…</system-reminder>` 块(跨行、
+ * 多块、夹在正文中间都剥;**未闭合**的块剥到末尾 —— 被截断的附件同样不是用户写的)后 trim。
+ *
+ * 为什么:壳把附件(技能清单一类的 `<system-reminder>` 块)拼在正文**之前**提交,标题器取前 {@link OBJECTIVE_SNIPPET_CHARS} 字
+ * 去起名 ⇒ 标题成了技能清单。判据只认这一个**字面标签**(CC 的附件信封),不按内容猜「像不像用户写的」——
+ * 正文里提到这个词的普通文字不是块,原样保留。剥完是空串 ⇒ 调用方走「空 objective 不起名」的既有臂。
+ * ⚠️ 只治这一类:S-236 原件(fresh `/decide` 腿把指路文本当 objective 提交)是另一类非用户文本,没有信封可剥,本函数刻意不加
+ * 按内容猜的第二臂(要么 fresh 腿传席,要么另立一臂 —— 候裁,见车RA 收车档)。
+ */
+export declare function userAuthoredObjectiveText(objective: string): string;
 export declare function buildTitlePrompt(objective: string): string;
 export declare function createSessionTitler(deps: SessionTitlerDeps): SessionTitler;
 //# sourceMappingURL=session-titler.d.ts.map

package/dist/session-titler.js

@@ -12,8 +12,12 @@ export function sanitizeTitle(raw) {
     const unquoted = oneLine.replace(/^["'「『]+/, "").replace(/["'」』]+$/, "").trim();
     return unquoted.length > TITLE_MAX_CHARS ? `${unquoted.slice(0, TITLE_MAX_CHARS - 1)}…` : unquoted;
 }
+export function userAuthoredObjectiveText(objective) {
+    return objective.replace(/<system-reminder>[\s\S]*?(?:<\/system-reminder>|$)/g, "").trim();
+}
 export function buildTitlePrompt(objective) {
-    const snippet = objective.length > OBJECTIVE_SNIPPET_CHARS ? `${objective.slice(0, OBJECTIVE_SNIPPET_CHARS)}…` : objective;
+    const text = userAuthoredObjectiveText(objective);
+    const snippet = text.length > OBJECTIVE_SNIPPET_CHARS ? `${text.slice(0, OBJECTIVE_SNIPPET_CHARS)}…` : text;
     const fenced = snippet.replace(/<(\/?)request>/gi, "<\u200b$1request>");
     return ("Write a short title (at most 8 words) summarizing the user request below. " +
         "Reply with ONLY the title on a single line — no quotes, no preamble. " +
@@ -34,7 +38,7 @@ export function createSessionTitler(deps) {
         .catch(() => ({ state: continueWord, unreadable: true }));
     return {
         maybeTitle(sessionId, objective, model) {
-            if (!sessionId || !objective.trim())
+            if (!sessionId || !userAuthoredObjectiveText(objective))
                 return;
             if (seen.has(sessionId))
                 return;

package/dist/sql-engine-posture.d.ts

@@ -11,7 +11,7 @@
  *
  * `sql-driver.ts` 的连接初始化在**每条池连接**上钉死这两件事并**回读复核**(`@contract txn.read-semantics`)。
  * 本模块把那份读数拿出来,一次推导两个读面:operator 面(`GET /v1/diagnostics/wiring` 的 `sqlEngine` 段,
- * 全量)与消费端面(`GET /v1/capabilities` 的 `sql` 位,窄投影)。两面同源 —— 「诊断页说悲观、能力位说
+ * 全量)与消费端面(`GET /v1/capabilities` 的 `store.sql` 位(7.106.0 起;此前顶层 `sql`,S-866 ①),窄投影)。两面同源 —— 「诊断页说悲观、能力位说
  * 乐观」在结构上不可能。
  *
  * ## 两条诚实纪律(与 memory-posture 同源)
@@ -27,7 +27,7 @@
 import { type SqlEngineFacts } from "./plugins/sql-driver.js";
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-/** 消费端窄投影(`GET /v1/capabilities` 的 `sql` 位)。`null` = 本部署没有 SQL 后端。 */
+/** 消费端窄投影(`GET /v1/capabilities` 的 `store.sql` 位;7.106.0 前是顶层 `sql`,S-866 ①)。`null` = 驱动此刻给不出事实 ⇒ `store.sql` 缺席。 */
 export interface SqlEngineCapability {
     engine: SqlEngineFacts["engine"];
     isolation: string;