@sema-agent/client-core 0.64.2 → 0.65.1

package/dist/autoModeUnavailable.js

@@ -1,6 +1,6 @@
 /**
  * src/autoModeUnavailable.ts — 「这只 ask 是因为**分类器跑不了**才问人」的事实读器 + 唯一措辞铸点
- * (0.63.0 件⑧;core 7.10.0 #616)。
+ * (0.63.0 件⑧;core 7.10.0 #616 —— **0.65.0 随 core 7.12.0 收窄,见下方「熔断族退役」段**)。
  *
  * -- 它答的是哪一问 ---------------------------------------------------------------------------
  * auto 模式下,门会就一只 ask 去咨询分类器。分类器**没跑成**时,引擎在这只 ask 上盖一格
@@ -10,77 +10,64 @@
  * 🔴 **缺席 ≠「分类器跑成了」**:绝大多数 ask 根本没咨询过分类器(部署没武装 auto、或这只 ask 走的
  *    是别的门)。缺席只意味着「这只 ask 上没有这条事实」。
  *
- * -- 🔴 两条 cause 轴,不是一张表 --------------------------------------------------------------
- *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout` / `breaker_open`)—— 「这一轮分类
- *     **为什么没跑成**」。这是 `classifierUnavailable.cause` 的值域。
- *   · {@link AUTO_MODE_BREAKER_CAUSES}(`error` / `timeout` / `parse_error`)—— 「**熔断闩为什么合上**」。
- *   两集交于 `error` / `timeout`,各有一个独占成员。合成一张表就把两条轴的差别扔了。
- * 🔴 **`parse_error` 只在熔断轴上**:core 顶注逐字 ——「`parse_error` stamps nothing」:分类器
- *    **跑了并且答了**,只是答在契约之外,那是**另一句话**。所以它**一个字节都不 stamp** 到
- *    `classifierUnavailable` 上;本读器把**熔断轴独占的词**({@link BREAKER_ONLY},今天 = `parse_error`)
- *    判**缺席** —— 把它读成一个「没跑成」的成因就是替引擎编一件它明说没发生的事。
- * ⚠️ **0.64.2 订正(行为面)**:修前这只读器按 unavailable **闭集**收窄,于是一台比本端新的引擎发一个
- *    **合法的新成因词**时,卡上那一行整段消失(而 {@link classifierUnavailableDetail} 的兜底句因此
- *    **永远不可达**)。现改为「非空串即收 + 排除熔断轴独占词」——「表外」与「另一条轴上的词」是两件事,
- *    修前把它们判成了同一件。`parse_error` 的行为一字未变(黑盒判据 G-19 照旧成立)。
+ * -- 🔴 熔断族退役(0.65.0;core 7.12.0 CHANGELOG「Removed (BREAKING)」)--------------------------
+ * core 7.12.0 把 `AUTO_MODE_BREAKER_CAUSES` 与 `WiringManifest.autoMode.breaker` 整族删掉,
+ * `AUTO_MODE_UNAVAILABLE_CAUSES` 同批收成 `["error","timeout"]`(`dist/core/auto-mode.d.ts:9` 真字节);
+ * server 7.70.0([6927])读面同批收窄,`classifierUnavailable.cause` 不再发 `breaker_open`。
+ * ⇒ 本模块把 `AUTO_MODE_BREAKER_CAUSES` / `ClassifierBreakerView` / `classifierBreakerOf` 与
+ *   `breaker_open` 这个词**干净切**(clean-cut,不留别名、不留兼容读):留一个读不到的读器只会让
+ *   三端继续为一件上游已经不发的事实写渲染分支,而那正是「校旧物」的门自己要拦的形。
+ * 🔴 **`cause` 的开集读一个字节不动**:一台比本端**新**的引擎发一个新成因词时照收(见
+ *    {@link classifierUnavailableOf});退役掉的只是本端**认得**的那张表里的一个成员 —— 旧引擎真发
+ *    `breaker_open` 时它照旧过境,只是走 {@link classifierUnavailableDetail} 的兜底句
+ *    (「这个词比这一端新/旧」那一类),不再冒充一句本端自铸的解释。
+ *
+ * -- 🔴 判据轴与成因轴不是一张表 --------------------------------------------------------------
+ *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout`)—— 「这一轮分类**为什么没跑成**」。
+ *     这是 `classifierUnavailable.cause` 的值域(词表属主 = core)。
+ *   · core `AutoModeVerdict` 的**判据轴**另有一个 `parse_error` 臂 —— 分类器**跑了并且答了**,
+ *     只是答在契约之外(`dist/core/auto-mode.d.ts:29-32` 逐字:「The model responded but not in the
+ *     `<block>…` contract shape. Handled as a BLOCK …」)。它**一个字节都不 stamp** 到
+ *     `classifierUnavailable` 上,那是**另一句话**。
+ * 🔴 本读器因此把 {@link NEVER_STAMPED_CAUSES}(今天 = `{parse_error}`)判**缺席** —— 把一个判据词
+ *    读成「没跑成」的成因,就是替引擎编一件它明说没发生的事。0.63.0 起的黑盒判据 G-19 钉的正是这
+ *    一条,退役熔断族**没有改动它的行为**(修前这一格由「熔断轴 − 不可用轴」的差集派生,而差集的
+ *    右操作数随熔断表一起没了;排除的**理由**从来就不在熔断轴上,现按理由的真出处直写)。
  *
  * -- 为什么是镜像而不是 import ---------------------------------------------------------------
- * 这两张表与 `classifierUnavailable` 的型面在 sdk 8.8.0 与 agent-types 上**都还没有**(亲验:两棵树
- * 全树零命中),唯一的出处是 `@sema-agent/core` 的 `dist/core/auto-mode.js` / `tool-policy.d.ts` /
- * `checkpoint-store.d.ts`。而 core **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的
- * `.d.ts` 一旦引用它,装了本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` /
- * `toolResult.ts` / `retryStatus.ts` 同一条处置:**按真字节镜像,把代价交给门** ——
+ * 这张表与 `classifierUnavailable` 的型面在 sdk 8.8.0 与 agent-types 上**都还没有**(亲验:两棵树
+ * 全树零命中),唯一的出处是 `@sema-agent/core` 的 `dist/core/auto-mode.js` / `tool-policy.d.ts`。
+ * 而 core **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的 `.d.ts` 一旦引用它,装了
+ * 本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` / `toolResult.ts` /
+ * `retryStatus.ts` 同一条处置:**按真字节镜像,把代价交给门** ——
  * `run-auto-mode-unavailable-test.mjs` 对**实装 devDep core** 的产物逐词双向对账,core 一动这里就先红。
- * 🔴 **候上游导出即换**:sdk 哪天镜像了这两张表与那一格,本模块的表应当整只退役改成从 sdk 取。
- *
- * -- 0.64.0 件② 加员:**会话轴**的窄读 --------------------------------------------------------
- * {@link classifierBreakerOf} 读的是同一条熔断轴的**另一端**:不是「这一轮为什么没跑成」,而是
- * 「这个**会话**的闩什么时候合上的、因为什么、连着失败了几次」(core 7.10.0 `AutoModeBreakerTrip`,
- * 挂在 `WiringManifest.autoMode.breaker` 上;**server ≥7.69.0 才投**)。
- * 🔴 **它是历史,不是当前闩状态**:core 顶注逐字「a trip names one leg … the ledger carries the most
- *    recent one forward per session」—— 同一会话的后一条腿完全可以重新武装。判「分类器现在跑不跑」
- *    的量是那条腿的 `armed`,不是这条记录在不在(判定在 `classifierStatus.ts`)。
- * 🔴 **缺席有四种成因,不可分辨**:从没熔断过 / 账本(有界 FIFO)把它淘汰了 / 这一次是 standalone
- *    prepare(账本没接上)/ 老引擎不投。所以缺席只能读成「**没有可用的熔断记录**」——
- *    既不是「没熔断过」,也不是「一定是老引擎」。
- * 它落在本文件是因为
- * {@link AUTO_MODE_BREAKER_CAUSES} 本来就在这里 —— 表与读它的窄读同居,而不是隔一个文件遥指。
- * 🔴 它同时是那一处的**唯一**窄读:`wiring_manifest` 的投影臂与 `classifierStatus.ts` 的状态读器
- *    共用它。本文件是**零 import 的纯叶**,所以投影臂那条内核闭包只多一件叶子(见
- *    `run-client-core-portability-test.mjs` 的内核上限记账)。
- * 🔴 **退役条款**:上游若改采 CC 形而把 `breaker` 这一键整只退役(它是 sema 在 CC 之外自己加的
- *    一格),本读器**零改** —— 它的**缺席臂**当天就是正解:读不到就是没有,状态面自然回落到
- *    本轮轴与「可用」。退役一个 additive 键不该逼三端各改一次。
+ * 🔴 **候上游导出即换**:sdk 哪天镜像了这张表与那一格,本模块的表应当整只退役改成从 sdk 取。
  */
 /**
- * 一轮分类**为什么没跑成**(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像)。
+ * 一轮分类**为什么没跑成**(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像,core 7.12.0 起两词)。
  *   · `error` —— 模型那条腿抛了/被拒(分类时的路由失败也读在这里:派生路由的前置在任何 decide
  *     之前就回落了,所以没有单独的词);
- *   · `timeout` —— 往返上限到了;
- *   · `breaker_open` —— 本会话的熔断闩**已经**合上,这一轮被短路,压根没发出去。
-
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
-export const AUTO_MODE_UNAVAILABLE_CAUSES = Object.freeze(['error', 'timeout', 'breaker_open']);
-/**
- * **熔断闩为什么合上**(core `AUTO_MODE_BREAKER_CAUSES`;逐词逐序镜像)——**另一条轴**,
- * 与上面那张表刻意不合并(见模块顶注)。`parse_error` 是它的独占成员。
+ *   · `timeout` —— 往返上限到了。
 
  * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
  *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
  */
-export const AUTO_MODE_BREAKER_CAUSES = Object.freeze(['error', 'timeout', 'parse_error']);
+export const AUTO_MODE_UNAVAILABLE_CAUSES = Object.freeze(['error', 'timeout']);
 /**
- * **熔断轴独占的成因词**(0.64.2 起是本文件唯一的排除集)——
- * `AUTO_MODE_BREAKER_CAUSES` 减去 `AUTO_MODE_UNAVAILABLE_CAUSES`,今天恰是 `{parse_error}`。
+ * **判据轴独占、且 core 明说「不 stamp」的成因词**(0.65.0 起是本文件唯一的排除集)——今天恰是
+ * `{parse_error}`。
  *
- * 🔴 **派生而不是手抄**:排除的理由不是「它不在我的表里」,而是 core 逐字说过**它不 stamp 到这一格**
- *    (分类器跑了并且答了,只是答在契约之外)。这条理由天然属于「只在熔断轴上的那些词」,所以判据
- *    就按两张镜像表的**差集**算 —— core 哪天再给熔断轴加一个独占词,这里自动跟上,而不需要有人记得
- *    回来改第三处。
+ * 🔴 **它的出处是理由,不是另一张表**:core `AutoModeVerdict` 的 `parse_error` 臂逐字说的是
+ *    「分类器跑了并且答了,只是答在契约之外,按 BLOCK 处置」——一个**有裁决**的回合,而
+ *    `classifierUnavailable` 这一格答的是「这一轮**没跑成**」。两句话互斥,所以这个词到达这一格
+ *    时只能是坏数据,读它就是替引擎编事实。
+ * ⚠️ **形制变更的如实登记**(0.65.0):修前这只集合是 `AUTO_MODE_BREAKER_CAUSES` 减
+ *    `AUTO_MODE_UNAVAILABLE_CAUSES` 的**差集**。core 7.12.0 删掉熔断表之后那条派生的右操作数不存在
+ *    了 —— 而排除的理由从头到尾都不是「它在熔断轴上」,是上面那一条。所以这里按理由的真出处直写
+ *    一张单员表,而不是为了保住「派生」的形去挽留一张上游已经删掉的表。core 哪天再给判据轴加一个
+ *    「答了但不算数」的臂,加员与它的一句人话同批落在本文件,门会先红。
  */
-const BREAKER_ONLY = new Set(AUTO_MODE_BREAKER_CAUSES.filter((c) => !AUTO_MODE_UNAVAILABLE_CAUSES.includes(c)));
+const NEVER_STAMPED_CAUSES = new Set(['parse_error']);
 /**
  * 一只 ask(或一条 durable park 行的 `tool_approval` 载荷)→ 「分类器跑不了」的事实;
  * 没有这条事实 / 形坏 ⇒ `undefined`,绝不抛出。
@@ -88,7 +75,7 @@ const BREAKER_ONLY = new Set(AUTO_MODE_BREAKER_CAUSES.filter((c) => !AUTO_MODE_U
  * 🔴 **两处同一只读器**:`AskRequest.classifierUnavailable` 与
  *    `PendingAction.tool_approval.classifierUnavailable`(durable park 行的孪生位)**键路同形**,
  *    所以一只读器吃两处 —— 各写一份就是两份台账各漂各的,本包一贯要根治的形。
- * 🔴 **`cause` 按开集读 + 一条派生的排除**(**0.64.2 订正,行为面**;修前是「unavailable 闭集」):
+ * 🔴 **`cause` 按开集读 + 一条有出处的排除**(**0.64.2 订正,行为面**;修前是「unavailable 闭集」):
  *    · **非空串即收** —— 词表的属主是 core,而 server 侧除了「非空串」之外**不做词表校验**
  *      (engine fixture `approval-card.js:240` 的 `z.string().min(1)`)。在这里抄一份闭集表,只会在
  *      core 加词那天把一个**合法**值判没,而丢掉的正是「这次不可用是**新出现的那一类**」这条信息
@@ -96,8 +83,10 @@ const BREAKER_ONLY = new Set(AUTO_MODE_BREAKER_CAUSES.filter((c) => !AUTO_MODE_U
  *      修前那条路是可复现的:一台比本端新的引擎发一个新成因词 ⇒ 卡上那一行**整段消失**,而
  *      {@link classifierUnavailableDetail} 早就为这一形备好了兜底句(「a word newer than this client」)
  *      —— 那句话在修前**永远不可达**,这本身就是判据写错了的证据。
- *    · **{@link BREAKER_ONLY} 里的词仍判缺席** —— 今天只有 `parse_error`。这不是「表外词一律拒」,
- *      而是一条**有出处的排除**:core 顶注逐字「`parse_error` stamps nothing」,读它就是替引擎编一件
+ *      ⚠️ 0.65.0 起 `breaker_open` 也走这一条(core 7.12.0 已删该词)—— **旧引擎的合法帧照旧过境**,
+ *        只是本端不再为它自铸一句解释。
+ *    · **{@link NEVER_STAMPED_CAUSES} 里的词仍判缺席** —— 今天只有 `parse_error`。这不是「表外词一律拒」,
+ *      而是一条**有出处的排除**:core 的判据轴逐字说它「跑了并且答了」,读它就是替引擎编一件
  *      它明说没发生的事。0.63.0 起的黑盒判据 G-19 钉的正是这一条,行为**一字未变**。
  * 🔴 **只交 `cause` 一格**:顺手把整只 ask 的别的键带出来会长成第二份 ask 读面。
  * 🔴 **端不许在自己那一侧再补一张闭集表**:未知词的正解是渲兜底句(措辞铸点已经有),不是不渲。
@@ -111,20 +100,22 @@ export function classifierUnavailableOf(ask) {
     const cause = raw.cause;
     if (typeof cause !== 'string' || cause === '')
         return undefined;
-    if (BREAKER_ONLY.has(cause))
+    if (NEVER_STAMPED_CAUSES.has(cause))
         return undefined;
     return { cause };
 }
 /**
- * 逐成因一句人话。**四句**(两轴的并集)刻意逐字互异 —— 对用户是四条不同的下一步。
- * 🔴 `parse_error` 那一句说的是「分类器**跑了、答了**,只是答在契约之外」,与另外三句的
+ * 逐成因一句人话。**三句**刻意逐字互异 —— 对用户是三条不同的下一步。
+ * 🔴 `parse_error` 那一句说的是「分类器**跑了、答了**,只是答在契约之外」,与另外两句的
  *    「没跑成」是两回事;它**永远不会**从 {@link classifierUnavailableOf} 出来(那一格按
- *    unavailable 轴收窄),放在这里是给**渲熔断面**的消费端用同一个铸点。
+ *    {@link NEVER_STAMPED_CAUSES} 排除),放在这里是给**渲判据面**的消费端用同一个铸点。
+ * 🔴 **`breaker_open` 那一句 0.65.0 随熔断族退役**(core 7.12.0 已删该词):旧引擎发来的
+ *    `breaker_open` 从此走下面的兜底句,原样带上那个词 —— 编一句本端自铸的熔断解释,就是在描述
+ *    一个这一代引擎里已经不存在的机制。
  */
 const CAUSE_SENTENCES = Object.freeze({
     error: 'asked because the auto-mode classifier could not run (it errored)',
     timeout: 'asked because the auto-mode classifier could not run (it timed out)',
-    breaker_open: 'asked because the auto-mode classifier is latched off for this session (its breaker tripped), so this round was never sent',
     parse_error: 'the auto-mode classifier answered outside its contract (its reply could not be parsed)',
 });
 /**
@@ -133,7 +124,7 @@ const CAUSE_SENTENCES = Object.freeze({
  * 🔴 **按自有属性查表**(与本包其余措辞铸点同一条纪律):`Object.freeze` 不移除原型,裸下标会让
  *    一个来自 wire 的 `constructor` / `toString` 命中 `Object.prototype` 上的**函数**并被当成一句话。
  * 🔴 表外词 / 坏值 ⇒ 一句**兜底**:仍然告诉用户「这只 ask 是分类器那条腿引出来的」,但**不冒充**
- *    四句里的任何一句(成因读不懂 ≠ 成因是别的什么);原样带上那个词供运维追问上游。
+ *    三句里的任何一句(成因读不懂 ≠ 成因是别的什么);原样带上那个词供运维追问上游。
  */
 export function classifierUnavailableDetail(cause) {
     const known = typeof cause === 'string' && Object.hasOwn(CAUSE_SENTENCES, cause) ? CAUSE_SENTENCES[cause] : undefined;
@@ -142,47 +133,3 @@ export function classifierUnavailableDetail(cause) {
     const word = typeof cause === 'string' && cause.length > 0 ? cause : '(none)';
     return `asked because of the auto-mode classifier; its reported cause ${word} is a word newer than this client`;
 }
-/** JS `Date` 能表示的绝对值上限(±8.64e15 ms);越界的数会让 `toISOString()` 抛 `RangeError`。 */
-const MAX_EPOCH_MS = 8.64e15;
-/**
- * `wiring_manifest.autoMode` → 熔断记录;没有这条事实 / 形坏 ⇒ `undefined`,绝不抛。
- *
- * 🔴 **三键承重、一键可缺**:`openedAtMs` / `lastCause` / `failures` 是那句话的承重物
- *    (「什么时候、因为什么、几次」),缺任一 ⇒ **整段缺席**(半句没有出口的话不如不渲);
- *    `runId` 不进那句话 ⇒ 缺席只丢它自己。这与本包 `projectMcpSection` 的「必需两座 + 其余可缺」
- *    同一条判据。
- * 🔴 **`lastCause` 开集读**:表外词照收 —— 词的属主在 core,抄一张表在这里只会把 core 加的新词
- *    吞成缺席(与 `WiringManifestMcpEntry.errorCode` 同规)。消费端按具名词写的 `switch` 必须带
- *    `default` 臂;本模块的措辞铸点自带兜底句。
- * 🔴 **按自有属性读**:一只来自 wire 的对象可以带原型;`Object.create({openedAtMs:1,…})` 上那些
- *    值不是这条帧带来的事实。
- */
-export function classifierBreakerOf(autoMode) {
-    if (typeof autoMode !== 'object' || autoMode === null || Array.isArray(autoMode))
-        return undefined;
-    if (!Object.hasOwn(autoMode, 'breaker'))
-        return undefined;
-    const raw = autoMode.breaker;
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
-        return undefined;
-    const r = raw;
-    const openedAtMs = Object.hasOwn(r, 'openedAtMs') ? r.openedAtMs : undefined;
-    if (typeof openedAtMs !== 'number' || !Number.isFinite(openedAtMs))
-        return undefined;
-    // 🔴 见模块顶注:越界的数会让渲染路径当场抛 `RangeError`;负数不是一个「闩合上了」的读数。
-    if (openedAtMs < 0 || openedAtMs > MAX_EPOCH_MS)
-        return undefined;
-    const lastCause = Object.hasOwn(r, 'lastCause') ? r.lastCause : undefined;
-    if (typeof lastCause !== 'string' || lastCause.length === 0)
-        return undefined;
-    const failures = Object.hasOwn(r, 'failures') ? r.failures : undefined;
-    if (typeof failures !== 'number' || !Number.isInteger(failures) || failures < 1)
-        return undefined;
-    const runId = Object.hasOwn(r, 'runId') ? r.runId : undefined;
-    return {
-        openedAtMs,
-        lastCause,
-        failures,
-        ...(typeof runId === 'string' && runId.length > 0 ? { runId } : {}),
-    };
-}

package/dist/classifierStatus.d.ts

@@ -1,63 +1,21 @@
 /**
- * src/classifierStatus.ts — auto 分类器的**状态读器**与唯一措辞铸点(0.64.0 件②;
- * core 7.10.0 `AutoModeBreakerTrip` / `WiringManifest.autoMode.breaker`)。
+ * 分类器的三态(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`(本轮肯定事实)→ 坏消息。
  *
- * -- 它答的是哪一问(与卡面那一问**不是同一问**)----------------------------------------------
- * `autoModeUnavailable.ts` 答的是**卡面**那一问:「这一刻**为什么在问我**」——一次性的、就这只 ask。
- * 本模块答的是**状态面**那一问:「这个**会话**上,auto 分类器现在是什么状态」——诊断行、模型设置页、
- * 权限卡的状态栏读的是它。两问的下一步不同,所以句子也不同(门里有一条反向钉守着两张面的句子零重合)。
- *
- * -- 两处窄读,一只读器 ----------------------------------------------------------------------
- *   · **会话轴**:`wiring_manifest.autoMode.breaker`(core `AutoModeBreakerTrip`;server ≥7.69.0 才投)
- *     —— 「这个会话的闩**已经**合上了,是什么时候、因为什么、连着失败了几次」。
- *   · **本轮轴**:一只 ask 上的 `classifierUnavailable.cause` —— 复用 0.63.0 已有的
- *     {@link classifierUnavailableOf},**不重铸**。
- * `classifierBreakerOf` 是会话轴那一处的**唯一**窄读:`wiring_manifest` 的投影臂与本模块的
- * 状态读器共用它。各写一份就是两份台账各漂各的(本包一贯要根治的形)。
- * 🔴 **它的物理位置在 `autoModeUnavailable.ts` 而不是这里**,理由是**门**:`wiring_manifest` 的
- *    投影臂在**内核闭包**里,而那道闭包的棘轮判据逐字是「新进来的这一件自己有没有 import ——
- *    有,就说明它不是叶子,那种 +1 正是本棘轮要拦的东西」。本模块有值级 import(它复用本轮轴的
- *    读器,刻意不另铸第二只),所以**本模块自己不该进内核**;而那只窄读是零 import 的纯判据,
- *    放进已经在闭包里的那张**熔断轴表**的同一个文件里,内核只多一件叶子。归属上也更顺:
- *    `AUTO_MODE_BREAKER_CAUSES` 本来就在那里,窄读读的正是那条轴。
- *
- * -- 🔴 「有熔断记录」与 `armed`/`reason` 之间**没有**互证关系,别去补一条 ---------------------
- * 直觉会想写「有 breaker ⇒ reason 应当是 `latch_open`」。那条互证是**错的**,而且会把真读数整段判没:
- * core 的 arm 词表头注逐字写着 —— 闩合上之后,**被闩住的那条腿不再把 auto 意图传给后续腿**,于是
- * 后续腿的 arm 判读走的是 `no_intent`;`latch_open` 那个词留在词表里只是为了让「中途重读」的消费者
- * 在闭集上完备,而**今天没有任何东西铸它**。所以一份 `{armed:false, reason:"no_intent", breaker:{…}}`
- * 是**最常见**的合法形,不是矛盾。
- *
- * -- 🔴 优先序承重:本轮事实 > 这条腿的 `armed` > 历史熔断记录 -------------------------------
- * 判据锚在**真正决定「分类器现在跑不跑」的量**上,而那个量是**这条腿的 `armed`**,不是账本里有没有
- * 一条旧记录:
- *   · **本轮事实最先**(`classifierUnavailable`)—— 它说的是眼前这一只 ask,最具体也最新;
- *   · **其次是 `armed`** —— core 顶注逐字:「A decider is minted per run (its latch is a RUN fact),
- *     so a trip names one leg; the ledger below carries the most recent one forward per session」。
- *     ⇒ 同一会话的**后一条腿**完全可以重新武装(新 decider 的闩由构造关着),而账本仍把那次旧 trip
- *     带着。`armed === true` 时判 `breaker_open`,就是把一个**正在放行**的分类器显示成已经关掉了
- *     (异源对抗复审 r2 抓出的真病);
- *   · **最后才是历史记录** —— 没武装、而账本里有一条 trip,那条 trip 就是「为什么没武装」的最好解释。
- * 🔴 **历史记录不因为被压下去就丢掉**:任何一态上 {@link ClassifierStatusView.breaker} 都照带,
- *    端可以在「在跑」那一行后面补一句「这个会话上曾经熔断过」——那是**两条不同的下一步**,所以
- *    措辞铸点为它单出一句。
- *
- * -- 🔴 时刻一律 UTC ISO,不猜用户时区 --------------------------------------------------------
- * 时区是宿主的事(它知道用户的 locale,本包不知道)。一个猜错的本地时刻比一个明确的 UTC 时刻更难
- * 排查 —— 运维拿着它去对引擎日志,而引擎日志也是 UTC。
- * 🔴 `openedAtMs` 是 **wire 来的数**:一个 `1e20` 会让 `toISOString()` 当场抛 `RangeError`,那是
- *    **整屏崩**不是一行渲不出([render-path-must-not-throw])。窄读因此按 Date 的真实值域收。
- *
- * -- 退役条款 ---------------------------------------------------------------------------------
- * 上游若改采 CC 形而把 `breaker` 这一键退役(它今天是 sema 在 CC 之外自己加的一格),本模块**零改**:
- * {@link classifierBreakerOf} 的**缺席臂**当天就是正解 —— 读不到就是没有,状态面自然回落到本轮轴
- * 与 `available`。这条设计是刻意的:退役一个 additive 键不该逼三端各改一次。
- */
-import { type ClassifierBreakerView } from './autoModeUnavailable.js';
-/**
- * 分类器的三态。**刻意只有三个** —— 「没武装」不是分类器的健康状态,那一问由
- * `wiring_manifest.autoMode.reason` 那一格自己回答(六词闭集),在这里再答一遍会长出第二份台账。
-
  * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]`(同
  *    `AUTO_MODE_UNAVAILABLE_CAUSES` 的理由)。
  */
@@ -66,9 +24,7 @@ export declare const CLASSIFIER_STATUS_STATES: readonly string[];
 export interface ClassifierStatusView {
     /** {@link CLASSIFIER_STATUS_STATES} 之一。 */
     state: string;
-    /** `breaker_open` 上在场:合闩记录(渲那句话要的三件都在里面)。 */
-    breaker?: ClassifierBreakerView;
-    /** `unavailable_this_round` 上在场:本轮没跑成的成因(`AUTO_MODE_UNAVAILABLE_CAUSES` 之一)。 */
+    /** `unavailable_this_round` 上在场:本轮没跑成的成因(**开集**:词表属主在 core)。 */
     cause?: string;
 }
 /**
@@ -77,14 +33,13 @@ export interface ClassifierStatusView {
  * @param autoMode `wiring_manifest` 的 `autoMode` 段(投影后的或原始的都吃;本函数自己窄读)
  * @param ask      可选:**本轮**那只 ask(或 durable park 行的 `tool_approval` 载荷)
  *
- * 优先序(承重,理由见模块顶注):**本轮事实 > 这条腿的 `armed` > 历史熔断记录**——先看 `ask` 上的本轮
- * 不可用事实,再看这条腿武没武装(武装了 = 分类器真的在跑,压过账本里的历史记录),最后才拿历史
- * 熔断记录说话。`ask` 带本轮事实时,`autoMode` 段缺席也照样答 `unavailable_this_round`。
+ * 优先序(承重,理由见模块顶注):**本轮事实(否定 + 肯定)> 这条腿的 `armed`**——先看 `ask` 上的
+ * 本轮不可用事实,再看 `ask` 上那条「分类器真的跑过」的肯定事实,最后才看这条腿武没武装。
+ * `ask` 带本轮事实时,`autoMode` 段缺席也照样答得出(两条本轮臂都不依赖那一段)。
  *
  * 🔴 **`undefined` 是一个诚实的答案,不是一个坏路径**:
  *    · `autoMode` 段缺席(老 mint / 外部 derive)⇒ 这一端**没有**分类器的健康读数;
- *    · 段在、但没武装,而且既没有本轮失败事实、账本里也没有一条 trip ⇒ 分类器**压根没参与**这条腿,
- *      它的健康无从谈起。
+ *    · 段在、但没武装,而且没有本轮事实 ⇒ 分类器**压根没参与**这条腿,它的健康无从谈起。
  *    两种情形都**绝不**折成 `available`(那是把「没报」渲成「一切正常」)。
  * ⚠️ 「没武装」本身仍是一条要渲的事实 —— 但它的出处是 `autoMode.reason`,不是本读器。
  */
@@ -92,10 +47,9 @@ export declare function classifierStatusOf(autoMode: unknown, ask?: unknown): Cl
 /**
  * 一次状态读数 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
  *
- * 三句逐字互异,且与 `classifierUnavailableDetail` 的四句**零重合**(两张面答两个问题)。
- * 🔴 **表外态 / 熔断态记录读不出来都不抛**:型面挡不住 wire,也挡不住一份从持久态恢复回来的视图
- *    —— `{state:'breaker_open'}`(没有 `breaker`)、`breaker: null`、`openedAtMs: 1e20`(会让
- *    `toISOString()` 抛 `RangeError`)都必须渲出一句诚实的话,而不是把整屏带崩。本函数因此**自己
- *    复核**那只记录(走同一只窄读),读不出就走「没被告知何时因何」那一句,绝不半渲一个假读数。
+ * 三句逐字互异,且与 `classifierUnavailableDetail` 的三句**零重合**(两张面答两个问题)。
+ * 🔴 **表外态不抛**:型面挡不住 wire,也挡不住一份从持久态恢复回来的视图 —— 一个
+ *    `{state:'breaker_open'}`(0.65.0 退役掉的那个词,可能来自旧持久态)必须渲出一句诚实的话,
+ *    而不是把整屏带崩,也不冒充三句里的任何一句。
  */
 export declare function classifierStatusDetail(view: ClassifierStatusView): string;