@sema-agent/server 7.117.0 → 7.118.0

package/dist/plugins/web-search.js

@@ -1,3 +1,4 @@
+import { validateHeaderValue } from "node:http";
 import { createSearxngSearchBackend } from "@sema-agent/core";
 import { isHierarchicalUrl, redactSecrets } from "../trace/redact.js";
 export const WEB_SEARCH_PROVIDERS = ["brave", "tavily", "searxng"];
@@ -28,6 +29,34 @@ function withTimeout(signal, ms) {
 async function errorText(res) {
     return (await res.text().catch(() => "")).slice(0, 200);
 }
+export function isHttpHeaderValue(value) {
+    try {
+        const sent = new Headers([["x-probe", value]]).get("x-probe") ?? "";
+        validateHeaderValue("x-probe", sent);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const API_KEY_FORM = "must be usable as an HTTP header value (it contains a character an HTTP header cannot carry, such as a line break)";
+function apiKeyHeaderValue(provider, key) {
+    switch (provider) {
+        case "brave":
+        case "searxng":
+            return key;
+        case "tavily":
+            return `Bearer ${key}`;
+    }
+}
+function authHeaderValue(provider, cfg) {
+    if (!cfg.apiKey)
+        throw new Error(`WEB_SEARCH_API_KEY is required for the ${provider} provider`);
+    const value = apiKeyHeaderValue(provider, cfg.apiKey);
+    if (!isHttpHeaderValue(value))
+        throw new Error(`WEB_SEARCH_API_KEY ${API_KEY_FORM}`);
+    return value;
+}
 async function httpFailure(provider, res) {
     const body = await errorText(res);
     return new Error(`${provider} search failed: HTTP ${res.status}${body ? ` — ${body}` : ""}`);
@@ -61,20 +90,18 @@ function normalize(raw, pick, max, provider) {
     return out;
 }
 async function braveSearch(fetchImpl, cfg, query, max, signal) {
-    if (!cfg.apiKey)
-        throw new Error("WEB_SEARCH_API_KEY is required for the brave provider");
+    const token = authHeaderValue("brave", cfg);
     const url = new URL(cfg.endpoint || BRAVE_BASE);
     url.searchParams.set("q", query);
     url.searchParams.set("count", String(Math.min(20, max)));
-    const res = await fetchImpl(url, { headers: { Accept: "application/json", "X-Subscription-Token": cfg.apiKey }, signal });
+    const res = await fetchImpl(url, { headers: { Accept: "application/json", "X-Subscription-Token": token }, signal });
     if (!res.ok)
         throw await httpFailure("brave", res);
     const data = (await res.json());
     return normalize(data.web?.results, (r) => ({ title: r.title, url: r.url, snippet: r.description }), max, "brave");
 }
 async function tavilySearch(fetchImpl, cfg, query, max, signal, opts) {
-    if (!cfg.apiKey)
-        throw new Error("WEB_SEARCH_API_KEY is required for the tavily provider");
+    const authorization = authHeaderValue("tavily", cfg);
     const body = { query, max_results: Math.min(20, max) };
     if (opts?.allowedDomains?.length)
         body.include_domains = opts.allowedDomains.slice(0, 300);
@@ -82,7 +109,7 @@ async function tavilySearch(fetchImpl, cfg, query, max, signal, opts) {
         body.exclude_domains = opts.blockedDomains.slice(0, 150);
     const res = await fetchImpl(new URL(cfg.endpoint || TAVILY_BASE), {
         method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${cfg.apiKey}` },
+        headers: { "Content-Type": "application/json", Authorization: authorization },
         body: JSON.stringify(body),
         signal,
     });
@@ -153,12 +180,14 @@ export function shouldProbeWebSearchOnBoot(env = process.env) {
 const ABSENT = { ok: true };
 const valueOf = (j) => (j.ok ? j.value : undefined);
 const isBlank = (s) => s.trim() === "";
-function judgeText(raw) {
+function judgeApiKey(provider, raw) {
     if (raw === undefined || raw === null)
         return ABSENT;
     if (typeof raw !== "string")
         return { ok: false, issue: "must be a string" };
-    return isBlank(raw) ? ABSENT : { ok: true, value: raw };
+    if (isBlank(raw))
+        return ABSENT;
+    return isHttpHeaderValue(apiKeyHeaderValue(provider, raw)) ? { ok: true, value: raw } : { ok: false, issue: API_KEY_FORM };
 }
 const ENDPOINT_FORM = "must be an absolute URL with a scheme and a host, such as https://search.example.com (a bare host or host:port is not one)";
 const ENDPOINT_USERINFO = "must not carry userinfo (user or user:password before the host)";
@@ -254,7 +283,7 @@ export function webSearchConfigFromEnv(env = process.env) {
     if (provider === undefined)
         return undefined;
     return assembleBackendConfig(provider, {
-        apiKey: envValue("WEB_SEARCH_API_KEY", judgeText(env.WEB_SEARCH_API_KEY)),
+        apiKey: envValue("WEB_SEARCH_API_KEY", judgeApiKey(provider, env.WEB_SEARCH_API_KEY)),
         endpoint: envValue("WEB_SEARCH_ENDPOINT", judgeEndpoint(env.WEB_SEARCH_ENDPOINT)),
         searxngParams: envValue("WEB_SEARCH_SEARXNG_PARAMS", judgeSearxngParams(env.WEB_SEARCH_SEARXNG_PARAMS)),
         maxResults: envValue("WEB_SEARCH_MAX_RESULTS", judgeCount(envNumber(env.WEB_SEARCH_MAX_RESULTS))),
@@ -284,7 +313,7 @@ export function judgeRequestWebSearch(raw) {
     if (!provider.ok)
         return { kind: "malformed", issue: `settings.webSearch.provider ${provider.issue}` };
     const fields = {
-        apiKey: judgeText(s.apiKey),
+        apiKey: judgeApiKey(provider.value, s.apiKey),
         endpoint: judgeEndpoint(s.endpoint),
         searxngParams: judgeSearxngParams(s.searxngParams),
         maxResults: judgeCount(s.maxResults),

package/dist/plugins/workflow-run-store-sql.d.ts

@@ -183,25 +183,26 @@ export declare class SqlWorkflowNotifyJournalStore implements WorkflowNotifyJour
 /**
  * S-185 车CM —— **workflow 出身 park 的有界 join 索引** SQL 双生(契约与纪律的唯一属主 =
  * {@link import("../orchestration/workflow-agent-session-index.js").WorkflowAgentSessionIndex} 的文件头,
- * 这里只记方言差)。行是 `WorkflowRun` 的派生投影,写者只有一个(Journaling 装饰器的写观察点)。
+ * 这里只记方言差)。行是 `WorkflowRun` 的派生投影(一行一枚指针),写者只有一个(Journaling 装饰器的写观察点);
+ * 收割在删 run 行的同一个方法里按同一张待删 id 表删它们的指针({@link SqlWorkflowRunStore.reap})。
  *
  * ── 方言差,保持显式 ──────────────────────────────────────────────────────────────────────────
  *   - `?` 占位 vs `$n`,且 `syncRun` 的删除腿在 PG 上要按 `params.length` 记位(与 `listByScope` 同因)。
  *   - 「删掉这条 run 里已不在 rows 里的旧行」:TiDB `session_id NOT IN (?,?,…)`(动态占位数)vs
  *     PG `session_id <> ALL($n::text[])`(数组绑定)—— 两边同一件事,语句结构不同(reap 的批删同先例)。
- *   - upsert:TiDB `REPLACE INTO`(整行替换)vs PG `INSERT … ON CONFLICT (session_id) DO UPDATE`。
+ *   - upsert(主键 `(session_id, run_id)`):TiDB `REPLACE INTO`(整行替换)vs PG `INSERT … ON CONFLICT (session_id, run_id) DO UPDATE`。
  *   - schema 属主同店内其余表:TiDB DDL 在 tidb-pool.ts,PG DDL 在 pg-pool.ts(店不建表)。
  *
- * 🔴 **写序**:先 upsert 再删。反过来(先删后 upsert)会在两条语句之间留出一个**索引行不存在**的窗口,
- * 而这期间进来的 `/decide` 会诚实 miss ⇒ 一次本可受理的批准被退回。先 upsert 的最坏形是窗口内多一条
- * 旧行(读口按 session_id 精确查,取 run 后还要逐字比对赎回键 ⇒ 多余的行只会 miss,不会错配)。
+ * 🔴 **写序**:先 upsert 再删。反过来(先删后 upsert)会在两条语句之间留出一个**指针不存在**的窗口,
+ * 而这期间进来的 `/decide` 会诚实 miss ⇒ 一次本可受理的批准被退回。先 upsert 的最坏形是窗口内多一枚
+ * 旧指针(判决从记录读 ⇒ 多读一条记录,不会错配)。
  */
 export declare class SqlWorkflowAgentSessionIndex implements WorkflowAgentSessionIndex {
     private readonly db;
     constructor(db: SqlDriver);
     private q;
     syncRun(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
-    findByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow | null>;
+    listByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow[]>;
 }
 /** MySQL-protocol (TiDB) bindings — historical class names preserved; `onWarn` is an ADDITIVE optional 2nd
  *  ctor arg (existing 1-arg call sites are unaffected — see {@link SqlWorkflowRunStore}'s C5 trace channel). */

package/dist/plugins/workflow-run-store-sql.js

@@ -160,6 +160,7 @@ export class SqlWorkflowRunStore {
         if (doomed.length === 0)
             return 0;
         const res = await this.db.query(this.q(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
+        await this.db.query(this.q(`DELETE FROM workflow_agent_session WHERE scope = ? AND run_id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_agent_session WHERE scope = $1 AND run_id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
         return res.affected;
     }
 }
@@ -311,7 +312,7 @@ export class SqlWorkflowAgentSessionIndex {
     async syncRun(runId, rows) {
         for (const r of rows) {
             await this.db.query(this.q("REPLACE INTO workflow_agent_session (session_id, run_id, agent_key, scope) VALUES (?,?,?,?)", `INSERT INTO workflow_agent_session (session_id, run_id, agent_key, scope) VALUES ($1,$2,$3,$4)
-             ON CONFLICT (session_id) DO UPDATE SET run_id = EXCLUDED.run_id, agent_key = EXCLUDED.agent_key, scope = EXCLUDED.scope`), [r.sessionId, r.runId, r.agentKey, r.scope]);
+             ON CONFLICT (session_id, run_id) DO UPDATE SET agent_key = EXCLUDED.agent_key, scope = EXCLUDED.scope`), [r.sessionId, r.runId, r.agentKey, r.scope]);
         }
         const keep = rows.map((r) => r.sessionId);
         if (this.db.dialect === "tidb") {
@@ -322,12 +323,9 @@ export class SqlWorkflowAgentSessionIndex {
             await this.db.query(`DELETE FROM workflow_agent_session WHERE run_id = $1${keep.length > 0 ? " AND session_id <> ALL($2::text[])" : ""}`, keep.length > 0 ? [runId, keep] : [runId]);
         }
     }
-    async findByAgentSession(sessionId) {
-        const { rows } = await this.db.query(this.q("SELECT session_id, run_id, agent_key, scope FROM workflow_agent_session WHERE session_id = ?", "SELECT session_id, run_id, agent_key, scope FROM workflow_agent_session WHERE session_id = $1"), [sessionId]);
-        const r = rows[0];
-        if (!r)
-            return null;
-        return { sessionId: String(r.session_id), runId: String(r.run_id), agentKey: String(r.agent_key), scope: String(r.scope) };
+    async listByAgentSession(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT session_id, run_id, agent_key, scope FROM workflow_agent_session WHERE session_id = ? ORDER BY run_id", "SELECT session_id, run_id, agent_key, scope FROM workflow_agent_session WHERE session_id = $1 ORDER BY run_id"), [sessionId]);
+        return rows.map((r) => ({ sessionId: String(r.session_id), runId: String(r.run_id), agentKey: String(r.agent_key), scope: String(r.scope) }));
     }
 }
 export class TiDBWorkflowRunStore extends SqlWorkflowRunStore {

package/dist/request-key-closure.js

@@ -19,7 +19,7 @@ export function keyClosureClause(names, label) {
 }
 const TASK_BODY_DECLARED_KEYS = [
     "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents",
-    "appendSystemPrompt", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
+    "appendSystemPrompt", "approvalReach", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
     "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "disableSkills", "enableFork",
     "excludeAllTools", "excludeTools", "fileHistory",
     "finalVerification", "forwardSubagentEvents", "images", "inheritEnv", "interactiveTools", "jobId", "limits", "maxCostUsd",

package/dist/request-value-closure.d.ts

@@ -52,7 +52,7 @@ export declare const MEMORY_OFF_SPELLING_MESSAGE = "memory must be the string 'o
 export declare const FILE_HISTORY_OFF_SPELLING_MESSAGE = "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history \u2014 no backup of an edited file, and no file restore in the same request; absent = the deployment's setting \u2014 there is no 'enabled' spelling)";
 /**
  * S-724 b′(主会话裁,车PW codex r1 [high] 复现后)—— `fileHistory: "disabled"` 与还原**同体**的拒句(`request.field_conflict`)。
- * 与 `tool-approval.ts` 的 `SETTLED_BY_DENY_ONLY` / `READ_ROOT_GRANT_ALLOW_ONLY` **同一族**:「只看体就能判的矛盾,在裁决之前响亮说」。
+ * 与 `tool-approval.ts` 的 `READ_ROOT_GRANT_ALLOW_ONLY` **同一族**:「只看体就能判的矛盾,在裁决之前响亮说」。
  * 这一对是调用方自己写出的矛盾(关掉这条 run 的文件历史,又要从文件历史还原);core 也拒(`rewind.capture_disabled`)。立门时(7.104.0)
  * core 的拒落在 prepare 的**会话分叉之后**(`prepare-acquire-reconcile` 先按 `resumeAt` 把活动分支移过去,`prepare-file-history` 才判),
  * 且拒后不回滚 —— 所以本层在任何副作用之前拒。**这不是替 core 再判一次「捕获关了能不能还原」**:判的是体里两个键

package/dist/rule-entry-list.d.ts

@@ -1,28 +1,26 @@
 /**
- * **规则条目表在本仓受理口的判** —— 一份,三张表同调(core 7.42.0 起「这个调用不用问」只有一个去处:引擎的 allow 层;条目的文法、匹配、
- * auto 剔除、读成空的通告都归引擎,本仓不写第二套):
+ * **规则条目表在本仓受理口的判** —— 一份,四张表同调(core 7.42.0 起「这个调用不用问」只有一个去处:引擎的 allow 层;条目的文法、匹配、
+ * 名字、读成空的通告都归引擎,本仓不写第二套):
  *  · 请求自带技能的 `allowedTools` / `disallowedTools`(顶层 `skills[]` 与子代 `agents[].skills[]` 两处受理口,`spec-fields.ts` / `http/admission.ts`);
  *  · 请求的 `settings.permissions.allow`(整份原样投 `TaskSpec.allowedTools`,`task-settings.ts`);
  *  · 运维的 `APPROVAL_GRANT`(整份投 `RunnerDeps.allowedTools`,`config.ts` 启动校验)。
  *
- * 本仓在这些表上只剩下面三道判加名字层一问(内容形、`*`、写路径形引擎怎么读就怎么算)。**名字层四张表同一只判官**(core `judgeRuleToolName`):请求的
- * `settings.permissions.allow` 与 deny / ask 两桶经 `config.ts` `unmatchableToolNamesRefusal`,技能两只清单经 `spec-fields.ts` `skillToolListRefusal`,运维表经
- * `config.ts` `approvalGrantRefusal` —— 三只包装调的都是本文件 {@link retiredRuleEntryOf}(退役名 / 短名 / 协议名;不问文法),句子一组。
+ * 本仓在这些表上只剩下面几问(内容形、`*`、写路径形、名字引擎怎么读就怎么算):
  *  ① **形**({@link ruleEntryListShapeOk}):字符串数组。引擎逐条迭代;一个裸字符串会被逐字符读成几条(deny 侧 = 意图静默落空)。
  *     本谓词不带条数帽(引擎的 `screenAllowedToolsValue` 只判形);条数帽是另一只函数 {@link allowLayerEntryCountIssue}(`MAX_ALLOW_LAYER_ENTRIES`,
  *     请求 allow 桶、技能两只清单、运维表四张表同一只、同一句)。
- *  ④ **退役名 / 无协议前缀的短名**({@link retiredRuleEntryOf}):判官是 core 导出的 `judgeRuleToolName`(请求三桶、会话规则写口、准备阶段的名审计
- *     同一只、同一份空名册)。引擎的 allow 层对这一族今天照编一个永不命中的名字、不通告 —— 7.116.0 的运维表对它拒启,本仓不许在同一张表上
- *     由响亮变静默;翻转条件与 `config.ts` 的 `allow-layer` 消费者同一句(引擎对非现行名出通告之后退役)。
- *  ② **协议名的对端段铸不出 / 缺段 / 对端段写通配**({@link unreachableRuleEntryOf}):判官是 `namespaced-rule-name.ts` 的那一只、取名口是
- *     `ruleEntryToolName`(配置表与会话规则写口同读)。引擎今天对这一族照编、一条都不命中、不通告 —— 等引擎的判官自己给这个判词时整只退役。
- *  ③ **引擎读成空的条目**({@link inertRuleEntriesOf},判据 = 引擎包根 `compileAllowList(entries, behavior).inert`,原因词是引擎的
- *     `ALLOW_ENTRY_INERT_REASONS`):deny 侧(技能的 `disallowedTools`)⇒ 拒 —— 一条以为拒了其实什么也不拒的条目是安全轴上的静默放宽;
- *     运维的 allow 表 ⇒ 拒启(运维自己的配置,写错了当场改)。**请求的 allow 侧不拒**:引擎在开跑时发
- *     `permission.allowed_tool_not_granted`(受众 = 用户)—— 终端会把用户设置里的 allow 整份投过来,一条今天读成空的写法不能把整条请求打回。
+ *  ② **引擎读不到的一形**({@link emptyToolSegmentEntryOf}):工具段为空的协议名(`mcp__srv__`)—— 引擎的判官答 `current`、条目读成一条精确名行、永不命中;
+ *     判据与句子在 `namespaced-rule-name.ts`(配置表、会话规则写口同一只)。四张表都拒。
+ *  ③ **引擎读成空的条目**({@link inertRuleEntriesOf},判据 = 引擎包根 `compileAllowList(entries, behavior, 名册)`,名册 = 空集 `NO_DECLARED_TOOL_NAMES`
+ *     —— 条目的工具名也过引擎判官:退役名 / 无前缀短名 / 对端段铸不出读成 `tool_name`,带判词与 1:1 现名;原因词是引擎的 `ALLOW_ENTRY_INERT_REASONS`):
+ *     运维的 allow 表拒启(运维自己的配置,写错了当场改);技能的拒侧(`disallowedTools`)拒 —— 提交 400、存量体重放 409(下面的 {@link skillDenyInertEntryOf});
+ *     请求的 allow 侧(`settings.permissions.allow`、技能 `allowedTools`)不拒:引擎在开跑时发 `permission.allowed_tool_not_granted`(受众 = 用户)。
+ *     技能拒侧那一拒与引擎 #1372(core 7.43.0:那只技能不激活)是同一件事的两处 —— 7.118.0 重估过、本版**不退**:本仓的续跑腿把引擎的
+ *     `checkpoint.config_refused`(`config.skill_deny_unreadable`)答得不一(资源停车续跑腿 500、`/decide` 先结了卡、`/wake` 先铸了 run 行),先统一那一层再退
+ *     (重估读数与退役条件在下面那只函数头注)。
  */
-import { type AllowEntryInertReason, type RuleToolNameVerdict } from "@sema-agent/core";
-import { type UnreachableNamespacedRuleName } from "./namespaced-rule-name.js";
+import { compileAllowList } from "@sema-agent/core";
+import { emptyToolSegmentOf } from "./namespaced-rule-name.js";
 export declare function presentRuleEntry(entry: string): string;
 /** ① 形:字符串数组(空串也是字符串 —— 引擎把它读成 `grammar` 并通告 / 拒,见 ③)。 */
 export declare const ruleEntryListShapeOk: (v: unknown) => v is readonly string[];
@@ -32,7 +30,9 @@ export declare const ruleEntryListShapeOk: (v: unknown) => v is readonly string[
  * 与技能授予表的 `hold` 都对已有条目线性查重 ⇒ 整表平方级、同步执行;core 7.42.0 上 1 万条约 2 s、2 万条约 6 s,本仓亲测)。不设帽 = 一份
  * 8 MiB 以内的请求体能把整个进程的事件循环卡住几十秒。与 deny / ask 两桶的帽(`permission-rule-list.ts` `MAX_PERMISSION_RULES_PER_LIST`,
  * 编译口的整表帽)是两件事、两个名字,数字恰好相同。
- * 翻转条件:上游把播种改成集合查重之后,按新的开销重估这个数(或整只退役)。
+ * 7.118.0 重估(core 7.43.0 #1370 把播种改成集合查重,本仓同一只探针亲测 `AllowEntryTable.seed`:7.42.1 上 1 千条 127 ms、1 万条 4.9 s;7.44.0 上 1 千条 8 ms、
+ * 1 万条 160 ms、2 万条 226 ms、10 万条 1.08 s —— 线性了,但仍是同步工作,8 MiB 的体装得下几十万条)⇒ 帽留着、数不动:理由由「平方级」换成「线性但同步、
+ * 没有真实用法需要上千条」。抬不抬这个数是产品判断,不随提货改。
  */
 export declare const MAX_ALLOW_LAYER_ENTRIES = 1000;
 /** 超帽的拒句(不截:截掉的尾项读起来像「在生效」)—— 句子的唯一铸点(请求 allow 桶的 wire 拒体按字段重铸也调它)。 */
@@ -43,36 +43,24 @@ export declare function allowLayerEntryCountIssue(field: string, list: readonly
     readonly count: number;
     readonly cap: number;
 } | undefined;
-/** 一张表里第一条「协议名写得出、却永远匹配不到」的条目。 */
-export interface UnreachableRuleEntry {
+/** 一张表里第一条「引擎读不到、却永远匹配不到」的条目(工具段为空的协议名)。 */
+export interface EmptyToolSegmentEntry {
     readonly entry: string;
-    readonly verdict: UnreachableNamespacedRuleName;
+    readonly ns: NonNullable<ReturnType<typeof emptyToolSegmentOf>>;
 }
-/** ② 第一条够不着任何挂载工具的协议名条目(都够得着 ⇒ `undefined`)。纯字符串运算。 */
-export declare function unreachableRuleEntryOf(list: readonly string[]): UnreachableRuleEntry | undefined;
+/** ② 第一条工具段为空的协议名条目(没有 ⇒ `undefined`)。纯字符串运算。 */
+export declare function emptyToolSegmentEntryOf(list: readonly string[]): EmptyToolSegmentEntry | undefined;
 /** ② 的句子(`<field> names "<entry>", which can never match a tool (…)`;后半与配置表 / 会话规则写口同一只)。 */
-export declare function describeUnreachableRuleEntry(field: string, u: UnreachableRuleEntry): string;
-/** ④ 一张表里第一条退役名 / 无协议前缀短名的条目(都现行 ⇒ `undefined`)。名册恒空:本仓不在退役名下挂自有工具(与 `config.ts` 同注)。 */
-export interface RetiredRuleEntry {
-    readonly entry: string;
-    readonly verdict: Exclude<RuleToolNameVerdict, {
-        kind: "current";
-    }>;
-}
-export declare function retiredRuleEntryOf(list: readonly string[]): RetiredRuleEntry | undefined;
-/** ④ 的句子:退役名给 core 的现役指引;短名枚举协议表前缀(与 `config.ts` 对请求三桶的说法同口径)。 */
-export declare function describeRetiredRuleEntry(field: string, r: RetiredRuleEntry): string;
-/** 一条引擎读成空的条目与引擎给的原因词。 */
-export interface InertRuleEntry {
-    readonly entry: string;
-    readonly reason: AllowEntryInertReason;
-}
-/** ③ 引擎按 `behavior` 读这张表时读成空的条目(引擎的整表读法:allow 表里的 `*` 让整表读成空;deny 表里的 `*` 只读空它自己)。 */
+export declare function describeEmptyToolSegmentEntry(field: string, u: EmptyToolSegmentEntry): string;
+/** 一条引擎读成空的条目(引擎的形:原因词,名字层另带判词 / 1:1 现名;包根不导出这只具名型 ⇒ 从 `compileAllowList` 的返回型取,不手抄)。 */
+export type InertRuleEntry = ReturnType<typeof compileAllowList>["inert"][number];
+/** ③ 引擎按 `behavior` 读这张表时读成空的条目(引擎的整表读法:allow 表里的 `*` 让整表读成空;deny 表里的 `*` 只读空它自己);条目名过引擎判官(名册 = 空集)。 */
 export declare function inertRuleEntriesOf(list: readonly string[], behavior: "allow" | "deny"): readonly InertRuleEntry[];
 /**
  * 原因词 → 「怎么写」(闭集穷举:引擎加一个原因词 ⇒ 编译红)。句子只说这一条为什么什么也不做、换成哪种写法;原因词本身原样带在句子里。
+ * 名字层两词带引擎给的判词 / 1:1 现名(有就点名)。
  */
-export declare function inertRuleEntryGuidance(reason: AllowEntryInertReason): string;
+export declare function inertRuleEntryGuidance(i: InertRuleEntry): string;
 /** ③ 的句子(`<field> entry "<e>" reads as nothing (<reason>): <怎么写>`;多条用分号连)。 */
 export declare function describeInertRuleEntries(field: string, inert: readonly InertRuleEntry[]): string;
 /** 提交体里技能所在的层(命中句与排空读数点名用):顶层 `skills[]` / 子代 `agents[].skills[]`。 */
@@ -88,12 +76,13 @@ export interface SkillDenyInertEntry {
  * 🔴 **调用点两处**:`resolveSpec`(`boot/resolve-spec.ts`,**拒点** —— 新提交与五条续跑腿都经过它,所以「新提交会被拒的体,续跑重放时同样拒」
  * 是结构性的)与 `http/checkpoint-ctx.ts` `storedBodyReplayRefusal`(存量体重放前的**预判**,五个续跑问点同调 —— 含 SLA 拒扫的跳过臂与终态 steer
  * 铸唤醒卡之前,这两处不经 `resolveSpec`)。提交腿 ⇒ 400 `request.field_invalid`;续跑腿 ⇒ 409 `resume_blocked_by_policy`(`blockedBy: request.field_invalid`,
- * 句子同一句,铸点 `checkpoint-ctx.ts` `resumeBlockedByPolicyAnswer`),拒在认领之前,行 / 卡 / ctx 不动。
- * 为什么续跑也要判:引擎 7.41 的规则解析先去首尾空白(`"Bash "` 是一条有效的拒),7.42 逐字读(同一条读成 `grammar`,什么也不拒)——
- * 7.116.x 上停驻、体里带这种条目的行,不判就是升级后那条拒无声消失。随包排空判据 `skill-deny-inert`(`scripts/drain-check-local.mjs` 调本函数)。
- * 判据就是引擎的读法(`compileAllowList(entries, "deny").inert`),本函数只负责走提交体的两层、给出句子与层。
- * 翻转条件:引擎今天对读成空的拒侧条目只发通告、照常激活技能;上游已认改成 fail-closed(读不出的拒侧条目所守的那次激活不发生)。
- * 那一版到货后,本仓这一处与引擎的拒是同一件事的两处 —— 届时重估是否退役本判(连同随包排空判据 `skill-deny-inert`)。
+ * 句子同一句,铸点 `checkpoint-ctx.ts` `resumeBlockedByPolicyAnswer`),拒在认领之前,行 / 卡 / ctx 不动。随包排空判据 `skill-deny-inert`
+ * (`scripts/drain-check-local.mjs` 调本函数)。判据就是引擎的读法(`compileAllowList(entries, "deny", 名册 = 空集)`,与 {@link inertRuleEntriesOf} 同一只;
+ * 7.118.0 起条目名也过引擎判官,退役名 / 对端段铸不出读成 `tool_name` —— 技能清单的名字层在受理口不再另判)。
+ * 7.118.0 重估(core 7.43.0 #1372 到货:读成空的拒侧条目让那只技能不激活)—— **本版不退**。实测(本判退掉之后跑同一批夹具):引擎的拒到本仓各续跑腿的
+ * 答法不一 —— 资源停车续跑腿把 `checkpoint.config_refused` 答成 500 `internal.error`;工具审批 `/decide` 在引擎拒之前已把卡结掉;`/wake` 在引擎拒之前已铸
+ * run 行;子代 `agents[].skills[]` 不在引擎的认领前屏里(续跑放行、技能在调用时被拒)。退役条件:本仓续跑腿对引擎 `checkpoint.config_refused` 的答法
+ * 收成一只(拒在认领前、行 / 卡不动、同一个 409)之后,本判与本仓的预判一起退,排空判据随之重估。
  */
 export declare function skillDenyInertEntryOf(body: unknown): SkillDenyInertEntry | undefined;
 //# sourceMappingURL=rule-entry-list.d.ts.map

package/dist/rule-entry-list.js

@@ -1,5 +1,5 @@
-import { compileAllowList, judgeRuleToolName, PROTOCOL_TABLE } from "@sema-agent/core";
-import { describeUnreachableNamespacedRuleName, ruleEntryToolName, unreachableNamespacedRuleNameOf } from "./namespaced-rule-name.js";
+import { compileAllowList } from "@sema-agent/core";
+import { describeEmptyToolSegment, emptyToolSegmentOf, NO_DECLARED_TOOL_NAMES, ruleEntryToolName } from "./namespaced-rule-name.js";
 import { CONTROL_AND_BIDI_STRIP_RE } from "./text-bidi.js";
 const PRESENTED_ENTRY_MAX = 160;
 export function presentRuleEntry(entry) {
@@ -17,36 +17,28 @@ export function allowLayerEntryCountIssue(field, list) {
         return undefined;
     return { message: describeAllowLayerOverCap(field, list.length), count: list.length, cap: MAX_ALLOW_LAYER_ENTRIES };
 }
-export function unreachableRuleEntryOf(list) {
+export function emptyToolSegmentEntryOf(list) {
     for (const entry of list) {
-        const verdict = unreachableNamespacedRuleNameOf(ruleEntryToolName(entry));
-        if (verdict !== undefined)
-            return { entry, verdict };
+        const ns = emptyToolSegmentOf(ruleEntryToolName(entry));
+        if (ns !== undefined)
+            return { entry, ns };
     }
     return undefined;
 }
-export function describeUnreachableRuleEntry(field, u) {
-    return `${field} names "${presentRuleEntry(u.entry)}", which can never match a tool (${describeUnreachableNamespacedRuleName(u.verdict)})`;
-}
-export function retiredRuleEntryOf(list) {
-    for (const entry of list) {
-        const verdict = judgeRuleToolName(ruleEntryToolName(entry), new Set());
-        if (verdict.kind !== "current")
-            return { entry, verdict };
-    }
-    return undefined;
-}
-export function describeRetiredRuleEntry(field, r) {
-    const why = r.verdict.kind === "retired"
-        ? r.verdict.guidance
-        : `pre-prefix short form — the live name carries a protocol prefix: ${PROTOCOL_TABLE.map((e) => `${e.prefix}${presentRuleEntry(r.entry)}`).join(" or ")}`;
-    return `${field} names "${presentRuleEntry(r.entry)}", which can never match a tool (${why})`;
+export function describeEmptyToolSegmentEntry(field, u) {
+    return `${field} names "${presentRuleEntry(u.entry)}", which can never match a tool (${describeEmptyToolSegment(u.ns)})`;
 }
 export function inertRuleEntriesOf(list, behavior) {
-    return compileAllowList(list, behavior).inert;
+    return compileAllowList(list, behavior, NO_DECLARED_TOOL_NAMES).inert;
 }
-export function inertRuleEntryGuidance(reason) {
+export function inertRuleEntryGuidance(i) {
+    const reason = i.reason;
+    const write = i.currentName !== undefined ? ` — write "${presentRuleEntry(i.currentName)}"` : "";
     switch (reason) {
+        case "tool_name":
+            return `the tool name can never match a mounted tool (${i.verdict ?? "stale"})${write}`;
+        case "near_miss":
+            return `the tool name differs from a mounted tool only by case${write}`;
         case "wildcard_all":
             return "`*` names no tool (on an allow list it voids the whole list) — name the tools instead";
         case "namespace_wildcard":
@@ -66,7 +58,7 @@ export function inertRuleEntryGuidance(reason) {
     }
 }
 export function describeInertRuleEntries(field, inert) {
-    return inert.map((i) => `${field} entry "${presentRuleEntry(i.entry)}" reads as nothing (${i.reason}): ${inertRuleEntryGuidance(i.reason)}`).join("; ");
+    return inert.map((i) => `${field} entry "${presentRuleEntry(i.entry)}" reads as nothing (${i.reason}): ${inertRuleEntryGuidance(i)}`).join("; ");
 }
 const isPlainRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 function skillDenyInertSentence(skill) {

package/dist/rules-consent.js

@@ -89,6 +89,9 @@ function isSupportedRuleMatch(match) {
         case "subpath":
         case "path":
             return false;
+        case "name":
+        case "name_prefix":
+            return false;
         default: {
             const unknown = match;
             void unknown;

package/dist/run-local.js

@@ -146,6 +146,7 @@ export const NO_TTY_ASK_CLASS_ROW = {
     rule_unreadable: { remedy: "terminal_only", autoBudgetReleases: false },
     ask_rule: { remedy: "approval_lists", autoBudgetReleases: true },
     denial_limit_fallback: { remedy: "terminal_only", autoBudgetReleases: false },
+    classifier_no_ruling: { remedy: "terminal_only", autoBudgetReleases: false },
     operator_forced: { remedy: "deployment_mandate", autoBudgetReleases: false },
     shell_floor: { remedy: "shell_gate", autoBudgetReleases: false },
     write_protection_unresolved: { remedy: "terminal_only", autoBudgetReleases: false },

package/dist/runs.d.ts

@@ -316,7 +316,7 @@ pendingEngineNotices?: readonly {
 trustedInternals?: Pick<RunInternals, "workflowParkedResume">, 
 /**
  * S-928 用户输入受理账本(`src/user-input-ledger.ts`;路由层 `deps.userInputLedger`)。两手:开通告口那一拍(模型调用之前)把本会话
- * 已收敛、未告知的崩溃丢失铸成 `task.user_steer_undrained{cause:"crashed"}`;腿收场时把本腿上的 steer 受理 settle 掉。
+ * 已收敛、未告知的崩溃丢失铸成 `task.user_steer_undrained` / `task.user_followup_undrained`(`cause:"crashed"`,码按受理时的车道选);腿收场时把本腿上的受理 settle 掉。
  * 缺席 ⇒ 两手都不做(与本参数存在之前逐字相同)。
  */
 userInputLedger?: UserInputLedger): Promise<void>;

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

@@ -29,12 +29,13 @@
  * 里同点同调它;准备阶段的名审计与本仓配置表读的是同一只 `judgeRuleToolName`)—— 本仓手写的那一只(`legacyToolNameOf`)删除,零双读;
  * 「哪几桶装工具名」归 core(它的 `HOLDS_TOOL_NAMES`)。
  *
- * ── 7.116.0:写口读者再多判一问 —— 够不着挂载工具的协议名 ─────────────────────────────────────
- * 缺段(`mcp__srv__` / `mcp__`)与对端段铸不出(`mcp__github.com__*`)的协议名 core 的判官判 `current`(它只看退役名与无前缀 `__` 名),
- * 而配置表一直拒缺段名 —— 一个名字两张表两种答案,对端段那一半则两张表都照收、永不命中。判官与句子是 `namespaced-rule-name.ts` 的那一只
- * (配置表同调),码 `400 request.field_invalid`(会话规则写口既有的字段值码;不另铸新码,也不往 core 的判词闭集里塞本仓的词)。
- * 这一问要逐桶判,而 core 不导出 `HOLDS_TOOL_NAMES` 的运行期值 ⇒ 桶表 {@link TOOL_NAME_FIELDS} 的键集从 core 判官交回的 `field` 型派生(两向 tsc 配对),
- * 随这一问在 core 自己给出判词那天整只退役。SQL 店写口经 {@link assertSessionRuleNamesReachable} 同判。
+ * ── 7.116.0:写口读者再多判一问 —— 够不着挂载工具的协议名;7.118.0 收窄到引擎读不到的那一形 ─────────────────────────
+ * 对端段铸不出 / 对端段为空(`mcp__github.com__*`、`mcp__`)自 core 7.43.0 #1355 (b) 起是引擎判官自己的判词 `unmintable_segment` ——
+ * `assertSessionRuleNamesCurrent` 拒(`legacy_tool_name`,`detail.verdict`)、本仓映射 `400 rules.legacy_tool_name`,与退役名同码同句族;本仓 7.116.0 起
+ * 那只自比对端段的对照随之退役。引擎判官放行、却一只工具都够不着的只剩**工具段为空**(`mcp__srv__`):判据与句子是 `namespaced-rule-name.ts` 那一只
+ * (配置表同调),码 `400 request.field_invalid`(会话规则写口既有的字段值码;不往 core 的判词闭集里塞本仓的词)。这一问要逐桶判,而 core 不导出
+ * `HOLDS_TOOL_NAMES` 的运行期值 ⇒ 桶表 {@link TOOL_NAME_FIELDS} 的键集从 core 判官交回的 `field` 型派生(两向 tsc 配对),随引擎判官给这一形判词那天整只退役。
+ * SQL 店写口经 {@link assertSessionRuleNamesReachable} 同判。
  *
  * ── 文案也在这里(codex 一轮追加:两条腿各铸一份句子 = 第二份手抄)───────────────────────────────
  * 初版把 wire 文案留在两个路由各自铸,理由是错误文案冻结门(`test/api-error-text-freeze.test.ts`)锚的是
@@ -45,16 +46,16 @@
  */
 import { SessionPolicyError } from "@sema-agent/core";
 import type { SessionPermissionRules, SessionRuleNameRefusal, SessionRulesRecord } from "@sema-agent/core";
-import { type UnreachableNamespacedRuleName } from "./namespaced-rule-name.js";
+import { emptyToolSegmentOf } from "./namespaced-rule-name.js";
 /** core `SessionPermissionRules` 的桶名全集(派生,不是手抄)。 */
 export declare const SESSION_PERMISSION_RULE_FIELDS: readonly (keyof SessionPermissionRules)[];
-/** 工具名桶里一条够不着任何挂载工具的协议名(缺段 / 对端段铸不出);`verdict` = 判官的判词。 */
+/** 工具名桶里一条引擎判官放行、却一只工具都够不着的协议名(工具段为空);`ns` = 它的协议。 */
 export interface SessionRuleUnreachableName {
     readonly field: SessionRuleNameRefusal["field"];
     readonly name: string;
-    readonly verdict: UnreachableNamespacedRuleName;
+    readonly ns: NonNullable<ReturnType<typeof emptyToolSegmentOf>>;
 }
-/** 逐桶逐条过协议规则名判官;第一条够不着的交回,全部够得着 ⇒ `undefined`。 */
+/** 逐桶逐条问引擎读不到的那一形;第一条交回,全部够得着 ⇒ `undefined`。调用方先过引擎判官({@link legacyToolNameRefusalOf} / `assertSessionRuleNamesCurrent`)。 */
 export declare function unreachableSessionRuleNameOf(rules: SessionPermissionRules): SessionRuleUnreachableName | undefined;
 /**
  * SQL 会话规则店写口的同一问(core 判官之后、收紧门之前,与 `assertSessionRuleNamesCurrent` 同点):够不着 ⇒ 抛,一条写语句都不发。
@@ -80,7 +81,7 @@ export type SessionPermissionRulesProblem = SessionPermissionRulesShapeProblem
     kind: "legacy-tool-name";
     refusal: SessionRuleNameRefusal;
 }
-/** 形对、core 判官也放行,但工具名桶里有一条够不着任何挂载工具的协议名(缺段 / 对端段铸不出)。 */
+/** 形对、core 判官也放行,但工具名桶里有一条一只工具都够不着的协议名(工具段为空 —— 引擎读不到的那一形)。 */
  | {
     kind: "unreachable-tool-name";
     unreachable: SessionRuleUnreachableName;
@@ -109,7 +110,7 @@ export declare function readSessionPermissionRules(raw: unknown): SessionPermiss
  * 面经 {@link readSessionRulesRecords})往会话规则店写之前的**唯一**判据。两问,按序:
  *  ① 形(同 {@link readSessionPermissionRules};一份坏形的体答形的 400);
  *  ② 工具名桶里的每一条过 core 的判官({@link legacyToolNameRefusalOf})—— 写进去就让会话之后每一跑都起不来的名字,在写口拒;
- *  ③ 工具名桶里的每一条过协议规则名判官({@link unreachableSessionRuleNameOf})—— 写进去永远匹配不到任何挂载工具的协议名,在写口拒。
+ *  ③ 工具名桶里的每一条问引擎读不到的那一形({@link unreachableSessionRuleNameOf}:工具段为空的协议名)—— 写进去永远匹配不到任何挂载工具,在写口拒。
  * 🔴 **只在写口,不在读回**:SQL 店读回同一行时只判形(形读者)。一条早先写进去的退役名行(或够不着的协议名行)必须**读得出来** ——
  * 那是运营方清掉它的唯一路径(operator 的 PUT 先读写前快照),也是 core 准备阶段报 `config.legacy_tool_name`
  * 而不是一只 500 `corrupt` 的前提。把判官放进形读者会让读回把它判坏(7.105.0 车QQ 双库套件实抓,修在同批)。

package/dist/session-policy-wire.js

@@ -1,5 +1,5 @@
 import { PROTOCOL_TABLE, SessionPolicyError, assertSessionRuleNamesCurrent, judgeRuleToolName } from "@sema-agent/core";
-import { describeUnreachableNamespacedRuleName, unreachableNamespacedRuleNameOf } from "./namespaced-rule-name.js";
+import { describeEmptyToolSegment, emptyToolSegmentOf, NO_DECLARED_TOOL_NAMES } from "./namespaced-rule-name.js";
 const RULE_FIELDS = {
     toolAllow: true,
     toolDeny: true,
@@ -24,9 +24,9 @@ const TOOL_NAME_FIELDS = Object.values(TOOL_NAME_FIELD_TABLE);
 export function unreachableSessionRuleNameOf(rules) {
     for (const field of TOOL_NAME_FIELDS) {
         for (const name of rules[field] ?? []) {
-            const verdict = unreachableNamespacedRuleNameOf(name);
-            if (verdict !== undefined)
-                return { field, name, verdict };
+            const ns = emptyToolSegmentOf(name);
+            if (ns !== undefined)
+                return { field, name, ns };
         }
     }
     return undefined;
@@ -99,17 +99,22 @@ export function describeSessionPermissionRulesProblem(p) {
     }
 }
 function describeUnreachableSessionRuleName(u) {
-    return `${u.field} names "${u.name}", which can never match a tool (${describeUnreachableNamespacedRuleName(u.verdict)}), so nothing was written`;
+    return `${u.field} names "${u.name}", which can never match a tool (${describeEmptyToolSegment(u.ns)}), so nothing was written`;
 }
 function describeLegacyToolName(r) {
     switch (r.verdict) {
         case "retired": {
-            const v = judgeRuleToolName(r.name, new Set());
+            const v = judgeRuleToolName(r.name, NO_DECLARED_TOOL_NAMES);
             const guidance = v.kind === "retired" ? v.guidance : `renamed "${r.currentName ?? "?"}"`;
             return `${r.field} names "${r.name}", a retired tool name (${guidance}); with that rule in place this session could not start another run, so nothing was written — use the current tool name${r.currentName !== undefined ? ` ("${r.currentName}")` : ""}`;
         }
         case "unprefixed_namespace":
             return `${r.field} names "${r.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()}`;
+        case "unmintable_segment": {
+            const v = judgeRuleToolName(r.name, NO_DECLARED_TOOL_NAMES);
+            const guidance = v.kind === "unmintable_segment" ? v.guidance : "a protocol name whose peer segment the engine never mints";
+            return `${r.field} names "${r.name}", which can never match a tool (${guidance}), so nothing was written`;
+        }
         default: {
             const unhandled = r.verdict;
             throw new Error(`unhandled legacy tool name verdict: ${JSON.stringify(unhandled)}`);

package/dist/spec-fields.d.ts

@@ -49,20 +49,18 @@ export declare const MAX_TASK_AGENTS = 32;
  *
  * 本谓词只判「字符串数组」(core 7.42.0 起与请求的 `settings.permissions.allow`、运维的 `APPROVAL_GRANT` **同一只**:`rule-entry-list.ts` 的
  * `ruleEntryListShapeOk`):引擎直接 `for (const entry of list)` —— 一个裸字符串 `"Bash"` 会被逐字符迭代成 `B` / `a` / `s` / `h` 四条
- * (deny 侧 = 意图静默落空,安全轴上的放宽方向)。条目的**文法**归引擎:允侧读不出的条目(`*` / 写路径 / 域名)引擎在开跑时发
- * `permission.allowed_tool_not_granted`(受众 = 用户);拒侧读成空的条目在 `resolveSpec` 拒(提交 400 / 续跑 409,`rule-entry-list.ts` 的
- * `skillDenyInertEntryOf`,两处调用:提交口拒点 + 存量体重放预判)。形对之后两道门再问 {@link skillToolListRefusal}(协议名的服务器段铸不出 / 缺段 ⇒ 400)——
- * 不是文法,是「写得出却永远不生效」,判据与请求的 allow 桶、运维的 allow 表同一份(`rule-entry-list.ts`)。
- * 条数帽 = 条目表那一只(`rule-entry-list.ts` `allowLayerEntryCountIssue`,准备开销的界 —— 引擎逐条播种是平方级;与请求 allow 桶、运维表同一只),
+ * (deny 侧 = 意图静默落空,安全轴上的放宽方向)。条目的**文法与名字**是引擎的读法:允侧读不出的条目(`*` / 写路径 / 域名 / 退役名 …)引擎在开跑时发
+ * `permission.allowed_tool_not_granted`(受众 = 用户);拒侧读成空的条目(文法或名字层)在 `resolveSpec` 拒(提交 400 / 续跑 409,`rule-entry-list.ts` 的
+ * `skillDenyInertEntryOf`,判据 = 引擎的条目读法)。形对之后两道门再问 {@link skillToolListRefusal}(条数帽 + 引擎读不到的那一形 ⇒ 400)。
+ * 条数帽 = 条目表那一只(`rule-entry-list.ts` `allowLayerEntryCountIssue`,准备开销的界;与请求 allow 桶、运维表同一只),
  * 在 {@link skillToolListRefusal} 里判;无长度帽([ref])。
  */
 export declare const skillToolListOk: (v: unknown) => v is readonly string[];
 /**
  * 一条技能(形已过两道门的字符串数组判)的两只清单在受理口的拒因 —— 都过 ⇒ `undefined`。两处受理口同调:顶层 `skills[]`
- * (`http/admission.ts` 的 `validateUserSkills`)、子代 `agents[].skills[]`({@link validateTaskAgents})。判据是 `rule-entry-list.ts` 那一份:
- * 任一只清单里「协议名写得出、却永远匹配不到」的条目(与请求的 allow 桶、配置表、会话规则写口同一只判官)。
- * 拒侧读成空的条目**不在这里判**:那一问在 `resolveSpec`(`rule-entry-list.ts` 的 `skillDenyInertEntryOf`;新提交与每条续跑腿都经过那一处)与存量体重放前的
- * 预判(`http/checkpoint-ctx.ts` `storedBodyReplayRefusal`)—— 一只判、两处调用。
+ * (`http/admission.ts` 的 `validateUserSkills`)、子代 `agents[].skills[]`({@link validateTaskAgents})。两问:条数帽;引擎读不到、却永远匹配不到的
+ * 条目(工具段为空的协议名,`rule-entry-list.ts` 那一份,与配置表、会话规则写口同一只)。退役名 / 对端段铸不出 / 读成空的条目是引擎的读法(见上):
+ * 允侧交引擎通告,拒侧由 `resolveSpec` 拒。
  */
 export declare function skillToolListRefusal(skill: Record<string, unknown>): string | undefined;
 /** [ref] 单条 agent 定义的形状裁决:null=合法;否则一句可 400 的英文错误(不带索引,调用方自己加)。

package/dist/spec-fields.js

@@ -1,7 +1,7 @@
 import { isThinkingLevel } from "@sema-agent/core";
 import { taskWallClockSec } from "./task-workflow.js";
 import { isValidCwd } from "./task-cwd.js";
-import { allowLayerEntryCountIssue, describeRetiredRuleEntry, describeUnreachableRuleEntry, retiredRuleEntryOf, ruleEntryListShapeOk, unreachableRuleEntryOf } from "./rule-entry-list.js";
+import { allowLayerEntryCountIssue, describeEmptyToolSegmentEntry, emptyToolSegmentEntryOf, ruleEntryListShapeOk } from "./rule-entry-list.js";
 export function normalizeSuggestNextPrompts(v) {
     if (v === true)
         return true;
@@ -76,12 +76,9 @@ export function skillToolListRefusal(skill) {
         const over = allowLayerEntryCountIssue(`skill.${key}`, list);
         if (over !== undefined)
             return over.message;
-        const retired = retiredRuleEntryOf(list);
-        if (retired !== undefined)
-            return describeRetiredRuleEntry(`skill.${key}`, retired);
-        const unreachable = unreachableRuleEntryOf(list);
-        if (unreachable !== undefined)
-            return describeUnreachableRuleEntry(`skill.${key}`, unreachable);
+        const empty = emptyToolSegmentEntryOf(list);
+        if (empty !== undefined)
+            return describeEmptyToolSegmentEntry(`skill.${key}`, empty);
     }
     return undefined;
 }