@sema-agent/client-core 0.77.0 → 0.77.2

package/dist/autoModeUnavailable.d.ts

@@ -1,126 +1,6 @@
-/**
- * src/autoModeUnavailable.ts — 「这一次 deny 是**分类器那一轮没能裁决**」的事实读器 + 唯一措辞铸点
- * (0.63.0 件⑧ 起;**0.67.0 随 core 7.14.0 整只换面,见下方「卡面退役 / 拒绝面继任」段**)。
- *
- * -- 它答的是哪一问 ---------------------------------------------------------------------------
- * auto 模式下,门会就一只调用去咨询分类器。分类器结束一轮有**三种**收场,而只有两种带一个**结构位**:
- *   · `unavailable` —— 分类器**跑不了**(模型那条腿抛了/被拒/跑过上限):一条**说得出口**的 fail-closed
- *     拒绝,过一会儿重试就行;
- *   · `parse_error` —— 分类器**跑了并且答了**,只是答在裁决契约之外:按 BLOCK 处置,并像一次裁决一样
- *     被拒绝上限计数;
- *   · **缺席**(在 `deniedBy: "classifier"` 旁)—— 分类器**自己的裁决**(一次 `<block>yes`)。
- * 🔴 **它是显示元数据,不是裁决位**:引擎在门上已经判完了,没有任何东西读它来决定放行与否,
- *    所以消费端只拿它渲一句话,**绝不**据它翻转任何裁决。
- * 🔴 **缺席 ≠「分类器跑成了」**:绝大多数 deny 根本没咨询过分类器(部署没武装 auto、或这次走的是
- *    别的层)。缺席只意味着「这条门记录上没有这条事实」。
- *
- * -- 🔴 卡面退役 / 拒绝面继任(0.67.0;core 7.14.0 `docs/wire-consumption/7.14.0.md` 的
- *       **Retired keys (BREAKING)** 表逐字)----------------------------------------------------
- * core 7.14.0 把 `classifierUnavailable` 这一格**从六个载体上整族删掉**(`PermissionDeniedPayload` /
- * `PermissionResult` 的 deny 与 ask 两臂 / `AskRequest` / `AskCarry`·`AskRequestCarry` /
- * `PendingAction.tool_approval`·`CheckpointSummary`),其中 **ask 那几处自 #661 起引擎就没写过**
- * (退役表逐字 "never engine-written since #661" / "dead since #661")。继任者是**一个**结构位:
- *   `GateDisposition.denied.cause ∈ {"unavailable","parse_error"}`(`dist/core/gate-outcome.d.ts:168`
- *   `CLASSIFIER_DENY_CAUSES`),挂在 `tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的
- *   resolved outcome 上,且只在 `deniedBy ∈ {classifier, policy}` 旁(`DENIED_BY_MAY_CARRY_CAUSE`)。
- * ⇒ 本模块把 `ClassifierUnavailableView` / `classifierUnavailableOf` / `classifierUnavailableDetail`
- *   **干净切**(clean-cut,不留别名、不留兼容读),换成 {@link classifierDenyCauseOf} 与
- *   {@link classifierDenyCauseDetail}。留一个读不到的读器只会让三端继续为一件上游已经不发的事实写
- *   渲染分支,而那正是「校旧物」的门自己要拦的形(登记在 `run-retired-vocabulary-census-test.mjs`)。
- * 🔴 **旧耐久行的处置 = 忽略**:一条 pre-7.14 的 park 行上仍带着 `classifierUnavailable` 时,本包
- *    **不读、不渲、不崩** —— 投影按新形办(退役表逐字「a stored key on an old row is ignored by the
- *    projection」)。
- *
- * -- 🔴 两条轴不是一张表(退役后仍然成立,只是坐标换了)--------------------------------------
- *   · {@link CLASSIFIER_DENY_CAUSES}(`unavailable` / `parse_error`)—— 「这一轮分类**是怎么收场的**」,
- *     `GateDisposition.cause` 的值域(词表属主 = core)。**闭集**:core 的 `screenGateOutcome` 把
- *     出集的 cause 列为记录缺陷(不变量 I5),而有缺陷的门记录 server 整条不上帧。
- *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout`)—— 一个 `unavailable` 背后的
- *     **为什么**。core 退役表逐字:「The WHY behind an `unavailable` (error vs timeout) is **not a
- *     branching fact**: the deny sentence spells it and the `auto_mode.classified` trace frame carries
- *     it」。⚠️ **本包今天不投影那条 trace 帧**(`src/` 全树 `auto_mode` 零命中),所以这张表在本包
- *     手上**没有到达任何一条投影臂的路**:它留在公面上是作为三端共用的**词表抄件**(core 7.16.0 仍
- *     导出它,故不构成退役),消费端**不得**期待它出现在某个 deny cause 旁边 —— 那一格的值域是上一条。
- *
- * -- 为什么是镜像而不是 import ---------------------------------------------------------------
- * `@sema-agent/core` **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的 `.d.ts` 一旦引用
- * 它,装了本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` / `toolResult.ts` /
- * `retryStatus.ts` 同一条处置:**按真字节镜像,把代价交给门** ——
- * `run-auto-mode-unavailable-test.mjs` 对**实装 devDep core** 的产物逐词双向对账,core 一动这里就先红。
- * 🔴 **候上游导出即换**:sdk 哪天镜像了 `CLASSIFIER_DENY_CAUSES` 与 `GateDisposition.cause`,
- *    本模块的表应当整只退役改成从 sdk 取。
- */
-/**
- * 一轮分类**怎么收场的** —— `GateDisposition.denied.cause` 的值域
- * (core `CLASSIFIER_DENY_CAUSES`,`gate-outcome.d.ts:168` 逐词逐序镜像,7.14.0 起两词)。
- *   · `unavailable` —— 分类器跑不了(模型那条腿抛了/被拒/跑过上限);一次说得出口的 fail-closed 拒绝,
- *     这次调用**可以过一会儿再试**;
- *   · `parse_error` —— 分类器跑了并且答了,只是答在裁决契约之外;**为安全起见拦下**,并像一次裁决一样
- *     被拒绝上限计数 —— 与上一条的下一步**不同**,所以两个词、两句话。
- *
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
 export declare const CLASSIFIER_DENY_CAUSES: readonly ["unavailable", "parse_error"];
-/** {@link CLASSIFIER_DENY_CAUSES} 的成员型(端的型面改派生,不再手抄两词)。 */
 export type ClassifierDenyCause = (typeof CLASSIFIER_DENY_CAUSES)[number];
-/**
- * 这个词是不是 {@link CLASSIFIER_DENY_CAUSES} 的成员(core `isClassifierDenyCause` 的镜像)。
- *
- * 🔴 **这一格与 `origin` / `ruleOffersAbsence` 的开集纪律刻意不同**,理由在**上游的形**上:
- *    `cause` 出闭集时 core 的 `screenGateOutcome` 判**记录缺陷**(不变量 I5),而有缺陷的门记录
- *    server **整条不上帧** ⇒ 一个表外的 cause **结构上到不了消费端**;它到达的形式是 `gate` 整键缺席。
- *    所以在这一格上按闭集判不会「把一个合法的新词吞成缺席」——真读到表外词只说明那条记录本不该长
- *    这样,而把它渲成一句成因就是替引擎编事实。(`deniedBy` 那张表在 `gateVocabulary.ts` 上同一条。)
- */
 export declare function isClassifierDenyCause(v: unknown): v is ClassifierDenyCause;
-/**
- * 一条**门记录**(`tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的 resolved outcome,
- * 或本包 `gateOutcomeOf` 投出的 {@link import('./gateOutcome.js').GateOutcomeView})→
- * 「这次 deny 是分类器那一轮**没能裁决**」的成因词;不是这一形 ⇒ `undefined`,绝不抛出。
- *
- * 🔴 **一只读器吃三处**:wire 的原始 `gate` 对象、包投出的视图、以及**带 `gate` 的整只帧**
- *    —— 三者键路同形(`disposition.kind` / `disposition.cause`),各写一份就是三份台账各漂各的,
- *    本包一贯要根治的形。
- * 🔴 **只在 `kind === "denied"` 上答**:`allowed` 臂上不存在这一位;一条读不出处置词的记录是坏记录,
- *    同样答缺席。
- * 🔴 **闭集判据**(理由见 {@link isClassifierDenyCause}):表外词 ⇒ 缺席。
- * 🔴 **不校 `deniedBy`**:core 的 `DENIED_BY_MAY_CARRY_CAUSE` 说的是 cause 只能站在 `classifier` /
- *    `policy`(继承链上祖先的冻结分类器)旁边,那是**引擎的段内不变量**,server 已按它铸;包再校一遍
- *    只会在上游合法演进的当天把一个真读数判没(与 `gateOutcome.ts` 顶注的 I1–I4 同一条处置)。
- * 🔴 **缺席不是断言**:缺席同时覆盖「分类器自己裁决 block 了」「这次不是分类器轮」「本部署没接分类器」
- *    三形,端**禁**读成「分类器好着呢」。
- */
 export declare function classifierDenyCauseOf(gate: unknown): ClassifierDenyCause | undefined;
-/**
- * 一轮分类**为什么**跑不了(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像,core 7.12.0 起两词)。
- *   · `error` —— 模型那条腿抛了/被拒(分类时的路由失败也读在这里:派生路由的前置在任何 decide
- *     之前就回落了,所以没有单独的词);
- *   · `timeout` —— 往返上限到了。
- *
- * ⚠️ **本表在本包手上没有到达任何投影臂的路**(0.67.0 如实登记,见模块顶注第三段):它是一个
- *    `auto_mode.classified` **trace 帧**上的量,而本包不投影 trace 帧。留在公面上的唯一身份是
- *    **三端共用的词表抄件**(core 7.16.0 仍导出它 ⇒ 不构成退役);消费端**不得**期待它出现在
- *    {@link classifierDenyCauseOf} 的产物旁边。
- *
- * 🔴 形制:`Object.freeze` 的数组,理由同 {@link CLASSIFIER_DENY_CAUSES}。
- */
 export declare const AUTO_MODE_UNAVAILABLE_CAUSES: readonly string[];
-/**
- * 一个 deny 成因词 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 🔴 **按自有属性查表**(与本包其余措辞铸点同一条纪律):`Object.freeze` 不移除原型,裸下标会让
- *    一个来自 wire 的 `constructor` / `toString` 命中 `Object.prototype` 上的**函数**并被当成一句话。
- * ── 🔴 0.68.0 / L-245:入参从 `unknown` 收窄成**闭集成员型** ─────────────────────────────────
- * 修前这里留着一句「its reported cause X **is a word newer than this client**」的兜底,而它
- * **结构上走不到**:唯一到达本铸点的路是 {@link classifierDenyCauseOf},那一层已经按闭集把表外词
- * 判成了缺席(理由见该函数:出闭集的 cause 在 core 那边是**记录缺陷**,server 整条不上帧 ⇒ 一个
- * 表外词根本到不了消费端)。一条走不到的兜底有两重坏处:① 它假装这一面是开集,于是没人给这张表
- * 配编译期围栏,core 加词那天这里一声不响;② 它说的那句话是**假的** —— 真有一个「比这一端新」的词
- * 时,它压根不会到这里。
- * ⇒ 入参收窄(表外词现在是**编译期**错误)+ 表型 `Record<ClassifierDenyCause, string>`(加词当天
- *   缺键红)。剩下的运行期兜底只服务一种情形:调用方 cast 绕过型面、或从旧持久态恢复出一个非成员值
- *   —— 那时它说的是「这个词不在本端的闭集里」(一句真话),而**不再**冒充「上游比我新」。
- * 🔴 渲染路径**不许抛**(本仓已定谳的病形),所以 never 分支照样交一句话,不 throw。
- */
 export declare function classifierDenyCauseDetail(cause: ClassifierDenyCause): string;

package/dist/autoModeUnavailable.js

@@ -1,101 +1,8 @@
-/**
- * src/autoModeUnavailable.ts — 「这一次 deny 是**分类器那一轮没能裁决**」的事实读器 + 唯一措辞铸点
- * (0.63.0 件⑧ 起;**0.67.0 随 core 7.14.0 整只换面,见下方「卡面退役 / 拒绝面继任」段**)。
- *
- * -- 它答的是哪一问 ---------------------------------------------------------------------------
- * auto 模式下,门会就一只调用去咨询分类器。分类器结束一轮有**三种**收场,而只有两种带一个**结构位**:
- *   · `unavailable` —— 分类器**跑不了**(模型那条腿抛了/被拒/跑过上限):一条**说得出口**的 fail-closed
- *     拒绝,过一会儿重试就行;
- *   · `parse_error` —— 分类器**跑了并且答了**,只是答在裁决契约之外:按 BLOCK 处置,并像一次裁决一样
- *     被拒绝上限计数;
- *   · **缺席**(在 `deniedBy: "classifier"` 旁)—— 分类器**自己的裁决**(一次 `<block>yes`)。
- * 🔴 **它是显示元数据,不是裁决位**:引擎在门上已经判完了,没有任何东西读它来决定放行与否,
- *    所以消费端只拿它渲一句话,**绝不**据它翻转任何裁决。
- * 🔴 **缺席 ≠「分类器跑成了」**:绝大多数 deny 根本没咨询过分类器(部署没武装 auto、或这次走的是
- *    别的层)。缺席只意味着「这条门记录上没有这条事实」。
- *
- * -- 🔴 卡面退役 / 拒绝面继任(0.67.0;core 7.14.0 `docs/wire-consumption/7.14.0.md` 的
- *       **Retired keys (BREAKING)** 表逐字)----------------------------------------------------
- * core 7.14.0 把 `classifierUnavailable` 这一格**从六个载体上整族删掉**(`PermissionDeniedPayload` /
- * `PermissionResult` 的 deny 与 ask 两臂 / `AskRequest` / `AskCarry`·`AskRequestCarry` /
- * `PendingAction.tool_approval`·`CheckpointSummary`),其中 **ask 那几处自 #661 起引擎就没写过**
- * (退役表逐字 "never engine-written since #661" / "dead since #661")。继任者是**一个**结构位:
- *   `GateDisposition.denied.cause ∈ {"unavailable","parse_error"}`(`dist/core/gate-outcome.d.ts:168`
- *   `CLASSIFIER_DENY_CAUSES`),挂在 `tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的
- *   resolved outcome 上,且只在 `deniedBy ∈ {classifier, policy}` 旁(`DENIED_BY_MAY_CARRY_CAUSE`)。
- * ⇒ 本模块把 `ClassifierUnavailableView` / `classifierUnavailableOf` / `classifierUnavailableDetail`
- *   **干净切**(clean-cut,不留别名、不留兼容读),换成 {@link classifierDenyCauseOf} 与
- *   {@link classifierDenyCauseDetail}。留一个读不到的读器只会让三端继续为一件上游已经不发的事实写
- *   渲染分支,而那正是「校旧物」的门自己要拦的形(登记在 `run-retired-vocabulary-census-test.mjs`)。
- * 🔴 **旧耐久行的处置 = 忽略**:一条 pre-7.14 的 park 行上仍带着 `classifierUnavailable` 时,本包
- *    **不读、不渲、不崩** —— 投影按新形办(退役表逐字「a stored key on an old row is ignored by the
- *    projection」)。
- *
- * -- 🔴 两条轴不是一张表(退役后仍然成立,只是坐标换了)--------------------------------------
- *   · {@link CLASSIFIER_DENY_CAUSES}(`unavailable` / `parse_error`)—— 「这一轮分类**是怎么收场的**」,
- *     `GateDisposition.cause` 的值域(词表属主 = core)。**闭集**:core 的 `screenGateOutcome` 把
- *     出集的 cause 列为记录缺陷(不变量 I5),而有缺陷的门记录 server 整条不上帧。
- *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout`)—— 一个 `unavailable` 背后的
- *     **为什么**。core 退役表逐字:「The WHY behind an `unavailable` (error vs timeout) is **not a
- *     branching fact**: the deny sentence spells it and the `auto_mode.classified` trace frame carries
- *     it」。⚠️ **本包今天不投影那条 trace 帧**(`src/` 全树 `auto_mode` 零命中),所以这张表在本包
- *     手上**没有到达任何一条投影臂的路**:它留在公面上是作为三端共用的**词表抄件**(core 7.16.0 仍
- *     导出它,故不构成退役),消费端**不得**期待它出现在某个 deny cause 旁边 —— 那一格的值域是上一条。
- *
- * -- 为什么是镜像而不是 import ---------------------------------------------------------------
- * `@sema-agent/core` **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的 `.d.ts` 一旦引用
- * 它,装了本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` / `toolResult.ts` /
- * `retryStatus.ts` 同一条处置:**按真字节镜像,把代价交给门** ——
- * `run-auto-mode-unavailable-test.mjs` 对**实装 devDep core** 的产物逐词双向对账,core 一动这里就先红。
- * 🔴 **候上游导出即换**:sdk 哪天镜像了 `CLASSIFIER_DENY_CAUSES` 与 `GateDisposition.cause`,
- *    本模块的表应当整只退役改成从 sdk 取。
- */
-/**
- * 一轮分类**怎么收场的** —— `GateDisposition.denied.cause` 的值域
- * (core `CLASSIFIER_DENY_CAUSES`,`gate-outcome.d.ts:168` 逐词逐序镜像,7.14.0 起两词)。
- *   · `unavailable` —— 分类器跑不了(模型那条腿抛了/被拒/跑过上限);一次说得出口的 fail-closed 拒绝,
- *     这次调用**可以过一会儿再试**;
- *   · `parse_error` —— 分类器跑了并且答了,只是答在裁决契约之外;**为安全起见拦下**,并像一次裁决一样
- *     被拒绝上限计数 —— 与上一条的下一步**不同**,所以两个词、两句话。
- *
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
-// 🔴 0.68.0 / L-245:形制从 `readonly string[]` 改成**字面元组**(`as const`)—— 型面交得出成员
-//    字面量,端的型面才能**派生**而不是再抄一遍两个词(与 `runTerminal.ts` 的两表分源同一条medicine)。
-//    冻结的理由一字未改(公面消费者拿到的正是这个实例)。
 export const CLASSIFIER_DENY_CAUSES = Object.freeze(['unavailable', 'parse_error']);
-/** {@link CLASSIFIER_DENY_CAUSES} 的运行期成员判据(判据用它,别在端上再抄一张表)。 */
 const DENY_CAUSE_SET = new Set(CLASSIFIER_DENY_CAUSES);
-/**
- * 这个词是不是 {@link CLASSIFIER_DENY_CAUSES} 的成员(core `isClassifierDenyCause` 的镜像)。
- *
- * 🔴 **这一格与 `origin` / `ruleOffersAbsence` 的开集纪律刻意不同**,理由在**上游的形**上:
- *    `cause` 出闭集时 core 的 `screenGateOutcome` 判**记录缺陷**(不变量 I5),而有缺陷的门记录
- *    server **整条不上帧** ⇒ 一个表外的 cause **结构上到不了消费端**;它到达的形式是 `gate` 整键缺席。
- *    所以在这一格上按闭集判不会「把一个合法的新词吞成缺席」——真读到表外词只说明那条记录本不该长
- *    这样,而把它渲成一句成因就是替引擎编事实。(`deniedBy` 那张表在 `gateVocabulary.ts` 上同一条。)
- */
 export function isClassifierDenyCause(v) {
     return typeof v === 'string' && DENY_CAUSE_SET.has(v);
 }
-/**
- * 一条**门记录**(`tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的 resolved outcome,
- * 或本包 `gateOutcomeOf` 投出的 {@link import('./gateOutcome.js').GateOutcomeView})→
- * 「这次 deny 是分类器那一轮**没能裁决**」的成因词;不是这一形 ⇒ `undefined`,绝不抛出。
- *
- * 🔴 **一只读器吃三处**:wire 的原始 `gate` 对象、包投出的视图、以及**带 `gate` 的整只帧**
- *    —— 三者键路同形(`disposition.kind` / `disposition.cause`),各写一份就是三份台账各漂各的,
- *    本包一贯要根治的形。
- * 🔴 **只在 `kind === "denied"` 上答**:`allowed` 臂上不存在这一位;一条读不出处置词的记录是坏记录,
- *    同样答缺席。
- * 🔴 **闭集判据**(理由见 {@link isClassifierDenyCause}):表外词 ⇒ 缺席。
- * 🔴 **不校 `deniedBy`**:core 的 `DENIED_BY_MAY_CARRY_CAUSE` 说的是 cause 只能站在 `classifier` /
- *    `policy`(继承链上祖先的冻结分类器)旁边,那是**引擎的段内不变量**,server 已按它铸;包再校一遍
- *    只会在上游合法演进的当天把一个真读数判没(与 `gateOutcome.ts` 顶注的 I1–I4 同一条处置)。
- * 🔴 **缺席不是断言**:缺席同时覆盖「分类器自己裁决 block 了」「这次不是分类器轮」「本部署没接分类器」
- *    三形,端**禁**读成「分类器好着呢」。
- */
 export function classifierDenyCauseOf(gate) {
     const rec = gateRecordOf(gate);
     if (rec === undefined)
@@ -106,15 +13,8 @@ export function classifierDenyCauseOf(gate) {
     const dd = d;
     if (dd.kind !== 'denied')
         return undefined;
-    // 🔴 0.68.0 / L-245:出参改**闭集成员型**(谓词已是型守卫)—— 读器闭集进、闭集出,措辞铸点
-    //    那一层的入参因此也能收窄,那条「结构不可达的兜底」于是变成编译期就闭的事(见下面那段)。
     return isClassifierDenyCause(dd.cause) ? dd.cause : undefined;
 }
-/**
- * 把三种入形归一成「一条带 `disposition` 的门记录」。
- * 🔴 顺序有意:载体**自己**带 `disposition` 时就是门记录本体;否则看 `gate` 那一格(整只帧 / 耐久行)。
- *    两条都读不出 ⇒ `undefined`(不猜第三个载体名)。
- */
 function gateRecordOf(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
         return undefined;
@@ -126,56 +26,12 @@ function gateRecordOf(v) {
         return undefined;
     return g;
 }
-/**
- * 一轮分类**为什么**跑不了(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像,core 7.12.0 起两词)。
- *   · `error` —— 模型那条腿抛了/被拒(分类时的路由失败也读在这里:派生路由的前置在任何 decide
- *     之前就回落了,所以没有单独的词);
- *   · `timeout` —— 往返上限到了。
- *
- * ⚠️ **本表在本包手上没有到达任何投影臂的路**(0.67.0 如实登记,见模块顶注第三段):它是一个
- *    `auto_mode.classified` **trace 帧**上的量,而本包不投影 trace 帧。留在公面上的唯一身份是
- *    **三端共用的词表抄件**(core 7.16.0 仍导出它 ⇒ 不构成退役);消费端**不得**期待它出现在
- *    {@link classifierDenyCauseOf} 的产物旁边。
- *
- * 🔴 形制:`Object.freeze` 的数组,理由同 {@link CLASSIFIER_DENY_CAUSES}。
- */
 export const AUTO_MODE_UNAVAILABLE_CAUSES = Object.freeze(['error', 'timeout']);
-/**
- * 逐成因一句人话。**两句**刻意逐字互异 —— 对用户是两条不同的下一步:
- *   · `unavailable` —— 「分类器这一轮**跑不了**」⇒ 可以过一会儿再试同一次调用;
- *   · `parse_error` —— 「分类器**跑了、答了**,只是答在契约之外」⇒ 这是一次为安全起见的拦阻,
- *     重试解决不了,要去看那一轮的裁决散文 / 调分类器。
- * 🔴 两句**不许合并**:合并等于把「稍后重试」与「别重试」渲成同一句。
- */
-// 🔴 0.68.0 / L-245:表型从 `Record<string, string>` 改成 **`Record<ClassifierDenyCause, string>`**。
-//    这一改就是本件真正的「never 分支断言」:core 哪天加第三个词,元组长一员 ⇒ 成员型多一员 ⇒
-//    **这张表少一个键** ⇒ **编译期当场红**,逼人同批补那一句话。修前是 `Record<string,…>`,加词那天
-//    这里一声不响,靠的是运行期那句「a word newer than this client」的兜底 —— 而那句兜底**结构上
-//    走不到**(读器在上一层就按闭集把表外词判成缺席),所以它既拦不住漂移、也从来没说过话。
 const DENY_CAUSE_SENTENCES = Object.freeze({
     unavailable: 'denied because the auto-mode classifier could not run this round (the call may be retried later)',
     parse_error: 'denied because the auto-mode classifier answered outside its contract (its reply could not be parsed, so the call was blocked)',
 });
-/**
- * 一个 deny 成因词 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 🔴 **按自有属性查表**(与本包其余措辞铸点同一条纪律):`Object.freeze` 不移除原型,裸下标会让
- *    一个来自 wire 的 `constructor` / `toString` 命中 `Object.prototype` 上的**函数**并被当成一句话。
- * ── 🔴 0.68.0 / L-245:入参从 `unknown` 收窄成**闭集成员型** ─────────────────────────────────
- * 修前这里留着一句「its reported cause X **is a word newer than this client**」的兜底,而它
- * **结构上走不到**:唯一到达本铸点的路是 {@link classifierDenyCauseOf},那一层已经按闭集把表外词
- * 判成了缺席(理由见该函数:出闭集的 cause 在 core 那边是**记录缺陷**,server 整条不上帧 ⇒ 一个
- * 表外词根本到不了消费端)。一条走不到的兜底有两重坏处:① 它假装这一面是开集,于是没人给这张表
- * 配编译期围栏,core 加词那天这里一声不响;② 它说的那句话是**假的** —— 真有一个「比这一端新」的词
- * 时,它压根不会到这里。
- * ⇒ 入参收窄(表外词现在是**编译期**错误)+ 表型 `Record<ClassifierDenyCause, string>`(加词当天
- *   缺键红)。剩下的运行期兜底只服务一种情形:调用方 cast 绕过型面、或从旧持久态恢复出一个非成员值
- *   —— 那时它说的是「这个词不在本端的闭集里」(一句真话),而**不再**冒充「上游比我新」。
- * 🔴 渲染路径**不许抛**(本仓已定谳的病形),所以 never 分支照样交一句话,不 throw。
- */
 export function classifierDenyCauseDetail(cause) {
-    // 🔴 **按自有属性查表**(与本包其余措辞铸点同一条纪律):`Object.freeze` 不移除原型,一个被
-    //    cast 进来的 `constructor` / `toString` 会命中 `Object.prototype` 上的**函数**并被当成一句话。
     const known = Object.hasOwn(DENY_CAUSE_SENTENCES, cause)
         ? DENY_CAUSE_SENTENCES[cause]
         : undefined;

package/dist/classifierStatus.d.ts

@@ -1,85 +1,13 @@
-/**
- * 分类器的三态(0.65.0:熔断族退役,`breaker_open` 随之删除;同批 `armed` 与 `available` 拆成
- * 两个词)。**「没武装」仍然不在里面** —— 那一问由 `wiring_manifest.autoMode.reason` 那一格
- * 自己回答(六词闭集),在这里再答一遍会长出第二份台账。
- *
- * 🔴 **0.65.0 / B-071:`armed` 与 `available` 拆成两个词**(此前只有后者,`armed===true` 直接
- *    判 `available`)。core 的 `WiringManifest.autoMode` 顶注把这两件事**明确分开**了:
- *      · `armed` ⇔ `reason === "armed"` —— 「**这条腿**铸出了分类器 decider」
- *        (逐字 `the classifier decider was minted for this leg`),一个**装配期**事实;
- *      · 而 `The classifier's availability is a per-CALL fact`(逐字;下一句还写明「an
- *        unavailable round is a deny that says so, and the next round is classified afresh」)。
- *    ⇒ 拿 `armed` 去回答「可用吗」= 用装配期读数回答每次调用的问题。武装了的分类器完全可能在
- *    某一轮跑不了(那一轮是一条 deny),下一轮又好了 —— 这正是 core 说「没有会话级 breaker 面」
- *    的理由(0.65.0 起它连那一格也一并删了)。措辞面跟着分两句:「武装了」与「这一次真的跑了」
- *    对用户是两条不同的下一步。
- *
- * 词序 = 判据强度递增的反向读法:`armed`(装配期)→ `available`(本轮肯定事实)→ 坏消息。
- *
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]`(同
- *    `AUTO_MODE_UNAVAILABLE_CAUSES` 的理由)。
- */
 export declare const CLASSIFIER_STATUS_STATES: readonly string[];
-/**
- * 「本轮那一次观测」的**窄型面**(0.68.0 / L-245 B6)。
- *
- * ── 为什么这个型要有名字 ────────────────────────────────────────────────────────────────────
- * 修前第二参是裸 `unknown`,而端手里常常只有**两格裸串**(`disposition.kind` / `disposition.cause`)——
- * 于是壳把它们**铸回一个假门记录** `{gate:{disposition:{kind,cause}}}` 再喂进来(cli
- * `classifierRoundObservation.ts` 的那一处)。那是一条「为了过读器而伪造上游形状」的路:伪造出来的
- * 那层 `gate` 在 wire 上根本不存在,读者会以为端手里有一整只门记录,而下一次读器换键路时端还得
- * 跟着改自己的伪造件。
- * ⇒ 给它一个名字,并把**三条合法入形**写进型面:
- *   · `{ disposition }` —— 端手里只有处置那一格时**直接给这一格**(不必再铸一层 `gate`);
- *   · `{ gate }`        —— 整只 `tool_end` 帧 / 一条耐久 park 行(键路 `gate.disposition`);
- *   · `{ origin }`      —— 「分类器真的跑过」那条**肯定事实**的载体。
- * 🔴 索引签名是**故意**的:整只 wire 帧(键远不止这三个)照样喂得进来,端零改造;而 `unknown`
- *    类型的变量从此喂不进来 —— 那正是「端先自己判一下手里是什么」的那一步,也是伪造件消失的地方。
- */
 export interface ClassifierRoundObservation {
-    /** 门记录上的处置(`{kind:'denied', cause}`)。端手里只有这一格时直接给它。 */
     readonly disposition?: unknown;
-    /** 整只帧 / 耐久行上的门记录(键路 `gate.disposition`)。 */
     readonly gate?: unknown;
-    /** 这只 ask 的出身词(`askOriginOf` 读它;`CLASSIFIER_RAN_ORIGINS` 的成员 = 分类器真跑过)。 */
     readonly origin?: unknown;
-    /** 整只 wire 帧上的其余键(读器一个都不读;留索引签名是为了端零改造)。 */
     readonly [extra: string]: unknown;
 }
-/** 一次状态读数。 */
 export interface ClassifierStatusView {
-    /** {@link CLASSIFIER_STATUS_STATES} 之一。 */
     state: string;
-    /** `unavailable_this_round` 上在场:本轮没跑成的成因(**开集**:词表属主在 core)。 */
     cause?: string;
 }
-/**
- * 「这个会话上,auto 分类器现在是什么状态」——三态,或 `undefined`(**说不出来**)。
- *
- * @param autoMode `wiring_manifest` 的 `autoMode` 段(投影后的或原始的都吃;本函数自己窄读)
- * @param ask      可选:**本轮那一次观测**({@link ClassifierRoundObservation};0.68.0 / L-245 起
- *   有名字)—— 一只 ask / 一条 durable park 行的 `tool_approval` 载荷 / 一只带 `gate` 的 `tool_end`
- *   帧 / 一条门记录本体 / **只有 `{disposition}` 那一格**。键路同形,同一把读器吃(0.67.0:否定事实
- *   的载体从 ask 上的 `classifierUnavailable` 改成门记录上的 `disposition.cause`)。
- *   🔴 端**不必**为了过这只读器去铸一个假门记录:手里只有两格裸串时,直接交 `{disposition:{kind,cause}}`。
- *
- * 优先序(承重,理由见模块顶注):**本轮事实(否定 + 肯定)> 这条腿的 `armed`**——先看观测座上的
- * 本轮不可用事实,再看那条「分类器真的跑过」的肯定事实,最后才看这条腿武没武装。
- * 观测座带本轮事实时,`autoMode` 段缺席也照样答得出(两条本轮臂都不依赖那一段)。
- *
- * 🔴 **`undefined` 是一个诚实的答案,不是一个坏路径**:
- *    · `autoMode` 段缺席(老 mint / 外部 derive)⇒ 这一端**没有**分类器的健康读数;
- *    · 段在、但没武装,而且没有本轮事实 ⇒ 分类器**压根没参与**这条腿,它的健康无从谈起。
- *    两种情形都**绝不**折成 `available`(那是把「没报」渲成「一切正常」)。
- * ⚠️ 「没武装」本身仍是一条要渲的事实 —— 但它的出处是 `autoMode.reason`,不是本读器。
- */
 export declare function classifierStatusOf(autoMode: unknown, ask?: ClassifierRoundObservation): ClassifierStatusView | undefined;
-/**
- * 一次状态读数 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 三句逐字互异,且与 `classifierDenyCauseDetail` 的两句**零重合**(两张面答两个问题)。
- * 🔴 **表外态不抛**:型面挡不住 wire,也挡不住一份从持久态恢复回来的视图 —— 一个
- *    `{state:'breaker_open'}`(0.65.0 退役掉的那个词,可能来自旧持久态)必须渲出一句诚实的话,
- *    而不是把整屏带崩,也不冒充三句里的任何一句。
- */
 export declare function classifierStatusDetail(view: ClassifierStatusView): string;

package/dist/classifierStatus.js

@@ -1,108 +1,10 @@
-/**
- * src/classifierStatus.ts — auto 分类器的**状态读器**与唯一措辞铸点(0.64.0 件②;
- * **0.65.0 随 core 7.12.0 收掉熔断族**、同批**把 `armed` 与 `available` 拆成两个词**,
- * 见下方「熔断族退役」与「优先序承重」两段)。
- *
- * -- 它答的是哪一问(与卡面那一问**不是同一问**)----------------------------------------------
- * `autoModeUnavailable.ts` 答的是**卡面**那一问:「这一刻**为什么在问我**」——一次性的、就这只 ask。
- * 本模块答的是**状态面**那一问:「这个**会话**上,auto 分类器现在是什么状态」——诊断行、模型设置页、
- * 权限卡的状态栏读的是它。两问的下一步不同,所以句子也不同(门里有一条反向钉守着两张面的句子零重合)。
- *
- * -- 🔴 熔断族退役(0.65.0;core 7.12.0 CHANGELOG「Removed (BREAKING)」)-------------------------
- * core 7.12.0 删掉 `AutoModeBreakerTrip` 与 `WiringManifest.autoMode.breaker`(server 7.70.0 [6927]
- * 读面同批收窄)。⇒ **会话轴的那条腿整只没了**:本模块此前词表里的 `breaker_open` 与它承重的那条
- * 熔断记录一起**干净切**(clean-cut,不留别名、不留兼容读)。留着一个上游再也不会填的状态词,
- * 结果是 /doctor 的 Auto classifier 行**永远出不了那一态**,而它的存在会让读者以为它可能出现 ——
- * 那正是「假 affordance」那一族。
- * ⚠️ **如实登记退役的代价**:0.64.0 的顶注写过「上游若把 breaker 退役,本模块**零改**(缺席臂当天
- *    就是正解)」。那句话对**读数**是对的(读不到就是没有),对**词表与型面**不成立 ——
- *    `CLASSIFIER_STATUS_STATES` 里的那个成员、`ClassifierStatusView.breaker` 这一位与它那两句人话
- *    仍然在公面上承诺着一件上游已经不发的事。本批因此不是「零改」,是**按退役条款把承诺一起收掉**。
- *
- * -- 一处窄读,复用不重铸 --------------------------------------------------------------------
- * **本轮轴**:一条门记录上的 `disposition.cause` —— 复用同批新铸的
- * {@link classifierDenyCauseOf},**不重铸**。本模块因此有一条值级 import(它不进内核闭包,见
- * `run-client-core-portability-test.mjs` 的内核上限记账)。
- *
- * -- 🔴 0.67.0:本轮轴的**事实源改道**(判据句一个字没改)------------------------------------
- * core 7.14.0 把 `classifierUnavailable` 从 ask / park / carry / summary 六个载体上整族退役
- * (其中 ask 那几处**自 #661 起引擎就没写过**),继任者是**拒绝面**的一个结构位
- * `GateDisposition.denied.cause`(`gate-outcome.d.ts:168`)。⇒ 本模块的 `unavailable_this_round`
- * 从「这只 ask 上盖了没跑成的章」改读「**本轮观测到的门记录**上那一格 deny 成因」。
- * 🔴 **公面词表与三句判据零改**(§30f/§30k 的判据句逐字不动):换的是事实**从哪里来**,
- *    不是这一端说什么。
- * 🔴 **turn 边界怎么重置**:本读器是**纯函数**,`observed` 参数就是「本轮那一次观测」——
- *    调用方每一 turn 传本 turn 的观测座(一只 ask / 一条耐久行 / 一只带 `gate` 的 `tool_end` 帧),
- *    上一 turn 的事实**结构上**到不了这一次调用。包内**刻意不持有**跨 turn 的闩:一个会话级闩在
- *    重连 / durable 重放上会把一条陈旧的成因渲成「现在」,而缺席不铸才是这一端唯一说得出口的话。
- *
- * -- 🔴 优先序承重:本轮事实(否定 + 肯定)> 这条腿的 `armed` --------------------------------
- * 判据锚在**真正决定「分类器现在跑不跑」的量**上:
- *   · **本轮事实最先** —— 它说的是眼前这一次观测,最具体也最新。两条:否定事实
- *     (门记录的 `disposition.cause === "unavailable"` ⇒ `unavailable_this_round`)与**肯定**事实
- *     (0.65.0 / B-071:`origin === "denial_limit_fallback"` ⇒ 分类器真的跑过 ⇒ `available`);
- *   · **其次是 `armed`** —— core 顶注逐字:「A decider is minted per run (its latch is a RUN fact)」
- *     ⇒ 同一会话的**后一条腿**完全可以重新武装,`armed === true` 时这条腿上真的有一只新铸的 decider。
- *     🔴 **0.65.0 / B-071 收窄**:`armed === true` 现在判的是新词 **`armed`**,不再是
- *     `available` —— core 顶注把「decider 铸出来了」(装配期)与「这一轮可用」(per-call)
- *     分得很清楚,而本读器此前把前者当成后者答了。
- *
- * -- 🔴 时刻/时区 -----------------------------------------------------------------------------
- * 本模块 0.65.0 起不再渲任何时刻(那是熔断记录带来的唯一时间位,随它一起退役)。
- *
- * -- 退役条款 ---------------------------------------------------------------------------------
- * `armed` 这一位若哪天也换形,本模块的**缺席臂**仍是正解:读不出就答 `undefined`(**说不出来**),
- * 绝不折成 `available` —— 那是把「没报」渲成「一切正常」。
- */
 import { classifierDenyCauseOf } from './autoModeUnavailable.js';
-/**
- * 分类器的三态(0.65.0:熔断族退役,`breaker_open` 随之删除;同批 `armed` 与 `available` 拆成
- * 两个词)。**「没武装」仍然不在里面** —— 那一问由 `wiring_manifest.autoMode.reason` 那一格
- * 自己回答(六词闭集),在这里再答一遍会长出第二份台账。
- *
- * 🔴 **0.65.0 / B-071:`armed` 与 `available` 拆成两个词**(此前只有后者,`armed===true` 直接
- *    判 `available`)。core 的 `WiringManifest.autoMode` 顶注把这两件事**明确分开**了:
- *      · `armed` ⇔ `reason === "armed"` —— 「**这条腿**铸出了分类器 decider」
- *        (逐字 `the classifier decider was minted for this leg`),一个**装配期**事实;
- *      · 而 `The classifier's availability is a per-CALL fact`(逐字;下一句还写明「an
- *        unavailable round is a deny that says so, and the next round is classified afresh」)。
- *    ⇒ 拿 `armed` 去回答「可用吗」= 用装配期读数回答每次调用的问题。武装了的分类器完全可能在
- *    某一轮跑不了(那一轮是一条 deny),下一轮又好了 —— 这正是 core 说「没有会话级 breaker 面」
- *    的理由(0.65.0 起它连那一格也一并删了)。措辞面跟着分两句:「武装了」与「这一次真的跑了」
- *    对用户是两条不同的下一步。
- *
- * 词序 = 判据强度递增的反向读法:`armed`(装配期)→ `available`(本轮肯定事实)→ 坏消息。
- *
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]`(同
- *    `AUTO_MODE_UNAVAILABLE_CAUSES` 的理由)。
- */
 export const CLASSIFIER_STATUS_STATES = Object.freeze([
     'armed',
     'available',
     'unavailable_this_round',
 ]);
-/**
- * B-071 —— 包今天手上**唯一**一条「分类器在这次调用上真的跑过」的**肯定**证据。
- *
- * core `ask-origin.d.ts` 逐字:`denial_limit_fallback` = 「the auto-mode classifier reached its
- * denial bound and handed the call to a person; **the classifier stands BEFORE this ask**」——
- * 这只 ask 的存在本身就证明分类器在这条调用链上跑过并数过它自己的拒绝。
- *
- * 🔴 **别的 origin 一个都不算**,而且不是保守起见:
- *   · `org_*` / `hook` / `ask_rule` / `ancestor_marked` / `content_question` —— core 的
- *     `CLASSIFIER_MAY_ANSWER` 表逐行 `false`,分类器**结构上**就不许碰这些 ask ⇒ 它们的存在
- *     与分类器跑没跑完全无关;
- *   · `policy` / `safety_tighten` / `shell_gate_tighten` —— 分类器**可以**答(表里 `true`),
- *     但一只**存活到卡上的** ask 恰恰说明这一轮它**没有**把它解决掉:可能是没跑,也可能是跑了
- *     判 ask。两种情形在这一格上不可分 ⇒ 拿它判 `available` 就是在猜。
- * ⇒ 判不出来时正解是回落到 `armed`(「武装了,本轮如何不知道」),而不是冒充 `available`。
- */
 const CLASSIFIER_RAN_ORIGINS = new Set(['denial_limit_fallback']);
-/**
- * 一只 ask / 一条 `tool_end.gate` 记录上的 `origin` —— 两条载体同一个词表(core 的
- * `ASK_ORIGINS` 一张表两个面:`ToolApprovalFrame.origin` 与 `GateOutcome.origin`)。
- * 顶层优先(活卡帧 / durable park 行),其次是门记录里的那一格。读不出即缺席。
- */
 function askOriginOf(ask) {
     if (typeof ask !== 'object' || ask === null || Array.isArray(ask))
         return undefined;
@@ -115,52 +17,12 @@ function askOriginOf(ask) {
     const inner = gate.origin;
     return typeof inner === 'string' && inner.length > 0 ? inner : undefined;
 }
-/**
- * 🔴 **有裁决**的那个 deny 成因词 —— 它**不是**「这一轮没跑成」(0.67.0 起是本模块唯一的排除集)。
- *
- * core `gate-outcome.d.ts:162-165` 逐字:`parse_error` = 「The classifier answered outside its verdict
- * contract: blocked for safety, **counted by the denial limit like a ruling**」—— 分类器**跑了并且
- * 答了**。而 `unavailable_this_round` 这一态答的是「这一轮**没跑成**」。两句话互斥,所以这个词
- * 到达本读器时的正解是**落到下一条臂**(回落 `armed` = 「武装了,本轮如何这一端说不出来」),
- * 绝不折成一个「没跑成」的成因。
- *
- * ⚠️ **行为与 0.66.0 逐字节相同**(判据句零改):修前这条排除住在 `autoModeUnavailable.ts` 的
- *    `NEVER_STAMPED_CAUSES` 里,理由是「core 明说它不 stamp 到 `classifierUnavailable` 那一格」;
- *    退役后**那一格没了**,而 `parse_error` 在**拒绝面**是一个合法在场的成因词 ⇒ 排除的归属地
- *    从「铸点不该有它」变成「**状态面**这一问不该收它」,于是这张表搬到本模块。
- *    core 哪天再给拒绝面加一个「答了但不算数」的臂,加员与它的处置同批落在这里,门会先红。
- */
 const NOT_A_ROUND_FAILURE = new Set(['parse_error']);
-/**
- * 「这个会话上,auto 分类器现在是什么状态」——三态,或 `undefined`(**说不出来**)。
- *
- * @param autoMode `wiring_manifest` 的 `autoMode` 段(投影后的或原始的都吃;本函数自己窄读)
- * @param ask      可选:**本轮那一次观测**({@link ClassifierRoundObservation};0.68.0 / L-245 起
- *   有名字)—— 一只 ask / 一条 durable park 行的 `tool_approval` 载荷 / 一只带 `gate` 的 `tool_end`
- *   帧 / 一条门记录本体 / **只有 `{disposition}` 那一格**。键路同形,同一把读器吃(0.67.0:否定事实
- *   的载体从 ask 上的 `classifierUnavailable` 改成门记录上的 `disposition.cause`)。
- *   🔴 端**不必**为了过这只读器去铸一个假门记录:手里只有两格裸串时,直接交 `{disposition:{kind,cause}}`。
- *
- * 优先序(承重,理由见模块顶注):**本轮事实(否定 + 肯定)> 这条腿的 `armed`**——先看观测座上的
- * 本轮不可用事实,再看那条「分类器真的跑过」的肯定事实,最后才看这条腿武没武装。
- * 观测座带本轮事实时,`autoMode` 段缺席也照样答得出(两条本轮臂都不依赖那一段)。
- *
- * 🔴 **`undefined` 是一个诚实的答案,不是一个坏路径**:
- *    · `autoMode` 段缺席(老 mint / 外部 derive)⇒ 这一端**没有**分类器的健康读数;
- *    · 段在、但没武装,而且没有本轮事实 ⇒ 分类器**压根没参与**这条腿,它的健康无从谈起。
- *    两种情形都**绝不**折成 `available`(那是把「没报」渲成「一切正常」)。
- * ⚠️ 「没武装」本身仍是一条要渲的事实 —— 但它的出处是 `autoMode.reason`,不是本读器。
- */
 export function classifierStatusOf(autoMode, ask) {
-    // 🔴 0.67.0 事实源改道:否定事实 = **本轮观测到的门记录**上那一格分类器 deny 成因。
-    //    `parse_error` 按 {@link NOT_A_ROUND_FAILURE} **落到下一条臂**(它是「答了」不是「没跑成」)——
-    //    与 0.66.0 的行为逐字节相同,只是排除的归属地换了(见那张表的头注)。
     const round = ask === undefined ? undefined : classifierDenyCauseOf(ask);
     if (round !== undefined && !NOT_A_ROUND_FAILURE.has(round)) {
         return { state: 'unavailable_this_round', cause: round };
     }
-    // 🔴 B-071:**本轮的肯定事实**(分类器真的跑过)—— 与上面那条否定事实同属 per-call 轴,故同样
-    //    压过 `armed`。它**不依赖** `autoMode` 段在不在场:可用性是这次调用的事实,不是装配的事实。
     const origin = ask === undefined ? undefined : askOriginOf(ask);
     if (origin !== undefined && CLASSIFIER_RAN_ORIGINS.has(origin)) {
         return { state: 'available' };
@@ -168,31 +30,13 @@ export function classifierStatusOf(autoMode, ask) {
     const armed = typeof autoMode === 'object' && autoMode !== null && !Array.isArray(autoMode)
         ? autoMode.armed
         : undefined;
-    // 🔴 `armed` 是**这条腿**的事实 —— 同一会话重新武装之后,那条腿上真的有一只新铸的 decider。
-    //    但它**只答到「武装了」为止**(B-071):本轮跑没跑是 per-call 的事,没有本轮事实时这一端
-    //    说不出来,于是渲 `armed` 而不是 `available`。
     if (armed === true)
         return { state: 'armed' };
     return undefined;
 }
-/**
- * 逐本轮成因一句人话(状态面用;与拒绝面那两句刻意不同 —— 见模块顶注)。
- *
- * 🔴 0.67.0:表内今天**只有 `unavailable` 一词** —— 它就是 {@link classifierDenyCauseOf} 在本读器上
- *    能交出来的全部成因(`parse_error` 被 {@link NOT_A_ROUND_FAILURE} 排除在这一态之外)。
- *    修前那两个词(`error`/`timeout`)是**退役掉的** `classifierUnavailable.cause` 的值域;它们今天
- *    仍是 `AUTO_MODE_UNAVAILABLE_CAUSES` 的成员,但那张表在本包没有到达任何投影臂的路(见
- *    `autoModeUnavailable.ts` 顶注)⇒ 在这里给它们留一句话 = 一条永远走不到的渲染分支(假 affordance)。
- *    一条从旧持久态恢复回来的视图若仍带着那两个词,{@link phraseOf} 的兜底会原样带上那个词。
- */
 const ROUND_CAUSE_PHRASES = Object.freeze({
     unavailable: 'the classifier could not run this round',
 });
-/**
- * 一个成因词 → 一个短语。**按自有属性查表**(`Object.freeze` 不移除原型,裸下标会让一个来自 wire 的
- * `constructor` / `toString` 命中 `Object.prototype` 上的**函数**并被当成一句话)。
- * 表外词 ⇒ 原样带上那个词供运维追问上游,**不冒充**任何一句已知的话。
- */
 function phraseOf(table, cause) {
     if (typeof cause === 'string' && Object.hasOwn(table, cause)) {
         const hit = table[cause];
@@ -202,20 +46,9 @@ function phraseOf(table, cause) {
     const word = typeof cause === 'string' && cause.length > 0 ? cause : '(none)';
     return `it reported ${word}, a cause word newer than this client`;
 }
-/**
- * 一次状态读数 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 三句逐字互异,且与 `classifierDenyCauseDetail` 的两句**零重合**(两张面答两个问题)。
- * 🔴 **表外态不抛**:型面挡不住 wire,也挡不住一份从持久态恢复回来的视图 —— 一个
- *    `{state:'breaker_open'}`(0.65.0 退役掉的那个词,可能来自旧持久态)必须渲出一句诚实的话,
- *    而不是把整屏带崩,也不冒充三句里的任何一句。
- */
 export function classifierStatusDetail(view) {
     const state = typeof view?.state === 'string' ? view.state : '';
     if (state === 'armed') {
-        // 🔴 B-071:这一句**刻意不说「在跑 / 可用」** —— 它答的是「这条腿铸出了分类器」,而「这一轮
-        //    它跑不跑得成」这一端没有证据。说成可用,用户下一步会去查「为什么还在问我」而不是去看
-        //    卡上那条 per-call 事实。两句因此是两条不同的下一步,逐字互异。
         return ('auto mode is armed on this session (a classifier is wired for this leg; whether it answers ' +
             'any given round is a per-call fact)');
     }