@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -1,174 +1,34 @@
 import type { ActiveRunBusySignal } from './runStream.js';
-/** wire gate kind → plan_review 重开臂的 canonical 成员(core CheckpointGate 词表之一)。 */
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
-/**
- * wire gate kind → plan 重开臂的**全表**(#265,2026-08-14 补齐 `dry_run_review`)。
- *
- * server 侧的 kind→决议入口映射(`resumeEntryForGate`)把 `plan_review` 与 `dry_run_review` 送去
- * **同一个**入口 `/v1/assistant/tasks/{taskId}/plan_review`,两者 park 也都落 `needs_review`
- * ⇒ 同臂。此前包内只认 canonical 那一个词,于是一条停在 dry-run 复核门上的 run 走结局④「不动 +
- * 如实说」——话是诚实的,但那张本来可以重开的卡没被重开,会话仍旧锁着。
- *
- * ⚠️ 别把它和 run status 词 `needs_review` 混起来:那是 **status**(两跳间接量),gate kind 叫
- * `dry_run_review`。gate kind `needs_review` 仍是表外词(结局④),这条边界由常驻门逐词钉。
- */
 export declare const PLAN_REVIEW_GATE_KINDS: readonly string[];
-/**
- * wire gate kind → ask 重开臂的成员:`human` / `irreversible_ask` / `policy_ask` 是 core
- * CheckpointGate 的审批/提问族(有 approvals.list pending 行可铸卡);`tool_approval` 是 park 判定
- * (`toolApprovalWire.isToolApprovalGate`)已承认的一等 kind —— 两张表必须同集合
- * ([paired-mechanisms-must-share-premise]:park 认得出、分诊路不进去 = 恒 reopen-failed)。
- * 表外 kind(`resource_limit` / `needs_review` / `task_done` / 未来新词)一律走结局④:不动 +
- * 如实说(wire 带的 decidePath 由文案层原样交给用户)。
- *
- * `policy_ask` 是 #265 补齐的第四个成员(server 全表逐名对读):它与 `human` 同族同入口
- * (`/v1/approvals/{sessionId}/decide`),漏一个词的代价 = 那一类门恒走结局④,卡不重开。
- */
 export declare const ASK_PARK_GATE_KINDS: readonly string[];
-/**
- * 行上在场且**不属 ask 门族**的门种(`plan_review` / `resource_limit` / 未来新词);`null` = 该行可入
- * ask/审批臂。kind 缺席(pre-`gate_kind` 历史行)与空串也归 `null` —— 旧行没有更强信号,各臂维持
- * 自己的原判据(toolName 等),门种闸只拦「明说了自己不归这族」的行。
- * 🔴 单源:`classifyAskParkRows` 的门种闸与 `findPendingForTask` 的行过滤必须共用这一只 ——
- * 各写各的 includes 必漂(P-30:`findPendingForTask` 侧漏了这道闸,同 task 停着 plan_review 行时
- * 「任意行」回落把它递给工具审批 wire,弹 toolName 空的卡、decide 撞 409 gate_not_tool_approval)。
- */
 export declare function askParkForeignGateKind(row: {
     gateKind?: string | null;
 }): string | null;
-/**
- * status 回退表(kind 缺席时的粗粒度代理):plan_review park 的引擎 run status。
- * 🔴 动作**不按状态名硬编码枚举**:两张表之外的一切状态(含今天还不存在的)一律「不动它 +
- * 如实说」,新状态到货时最坏结果是保守。
- */
 export declare const PLAN_REVIEW_STATES: readonly string[];
-/** status 回退表:审批/提问 park(**只有 `suspended`**)。 */
 export declare const ASK_PARK_STATES: readonly string[];
-/**
- * 走三选卡臂的状态 —— **只有 `running`**(引擎 RunStatus 里「正在干活」的那一个词)。
- *
- * 🔴 为什么是白名单而不是「park 词表之外的一切」:三选卡上的两条动作路(steer / cancel)都只对
- * 一条**真在跑**的 run 成立 —— steer 的语义是「注入在跑的那一轮」(非 running 会落 `queued` /
- * `parked_for_wake` / 409),cancel 对 park 态则是替用户否掉待决项(禁区)。今天还不存在的新状态
- * 落在表外 ⇒ 照旧「不动它 + 如实说」:不确定时不给用户递一把语义不明的把手。
- */
 export declare const RUNNING_STATES: readonly string[];
-/**
- * 「引擎确认这条 run **不再占着会话**」的状态词 —— 也就是 cancel 之后允许重发那条消息的**唯一**
- * 判据。
- *
- * 🔴 为什么是白名单而不是「running 之外的一切」:这条会话锁的语义是 **park 态(`suspended` /
- * `needs_review`)保留 claim**。用 `!RUNNING_STATES.includes(status)` 当判据时,一条正在收尾的 run
- * 只要在这一拍被读成 park(cancel 是异步的,run 完全可能先走到一个 checkpoint),就被判成「已释放」
- * ⇒ 上屏说「引擎确认它不再占着这个会话」(假话)+ 立刻重发 ⇒ 那条消息一头撞进还锁着的会话,再吃
- * 一个 409。没想过的新状态词同理落在白名单外:我们不知道那个词是不是「释放了」,就不能替引擎下这个
- * 断言(等到点如实说「还占着」是可收敛的诚实结局,零破坏性)。
- *
- * 词表锚 = SDK `RunStatus`(`running|completed|failed|suspended|needs_review|blocked`)的三个终态
- * + `timeout`。真·404(引擎不认得这条 run 了)另有一条腿,不走这里(见 {@link waitForClaimRelease})。
- */
 export declare const CLAIM_RELEASED_STATES: readonly string[];
-/**
- * 「这条 run **确实还占着**会话」的状态词 —— 也就是文案敢说「that run still held this session」的
- * **唯一**判据(二次评审 R5 [medium])。
- *
- * 🔴 为什么又是白名单:上面那张表管的是「敢不敢重发」,这张表管的是「敢不敢断言它还占着」,两件事
- * **都**只能由正面证据得出,而它们**不是互补的** —— 两张表之外还有一整片「读到了一个我们不认识的
- * 词」的地带(server 加一个新终态 `cancelled` 就是现成的例子)。用「lastStatus 非空」当持锁判据,
- * 那个新词会被读成「还占着」并渲上屏,而会话其实早就释放了。表外非空词 ⇒ 既不算释放也不算持锁,
- * 收口成「确认不了」。
- */
 export declare const CLAIM_HELD_STATES: readonly string[];
-/**
- * durable 控制面的**鸭子类型**视图。live 客户端有 get/cancel,mock 车道没有 —— 两个都是可选,
- * `events` 是必填只为让这个接口不是「全可选属性」(全可选会触发 TS 的弱类型检查,把宽客户端形
- * 判成「无公共属性」而拒绝赋值)。三处 `unknown` 是边界职责形(本包不拥有 run 记录的类型,
- * 消费点 `readStatus` 就是窄化动作本身;typeshape 门 RATCHET 逐条登记)。
- */
-/**
- * `GET /v1/runs/:id` 的行,**只到本层读得到的那几格**(0.68.0 / L-230)。
- *
- * 🔴 具名而不是内联匿名形:三格都是 wire 值(`unknown`),而端要按它们分支 —— 一个有名字的形让
- *    宿主的适配层能声明自己返回什么,也让 typeshape 门的 B4 棘轮不为这一处升一格。
- * 🔴 **三格全可选**:老引擎只发 `status`;`heldBy` / `cancelRequested` 是 server 7.73.0 S-122 P-45
- *    的 additive 读面,缺席一律走既有路(见 `readClaimHolder` / `readCancelRequested` 的三态)。
- * 🔴 行上其余键本层**一个都不读**(它们仍在 wire 上,只是这一层不需要);要读的端自己窄化。
- */
 export interface DurableRunRecordView {
-    /** run 行状态词(开集;本层按 {@link CLAIM_RELEASED_STATES} / {@link CLAIM_HELD_STATES} 白名单判)。 */
     readonly status?: unknown;
-    /** 谁占着这个会话:非空串 = 那条 run 还占着;**`null` = 一句正面事实(交出来了)**;整键缺席 = 老引擎。 */
     readonly heldBy?: unknown;
-    /** 这条 run 上**有没有受理过一次取消请求**(不是「已取消」)。整键缺席 = 老引擎不发。 */
     readonly cancelRequested?: unknown;
 }
 export interface DurableRunVerbs {
     events: unknown;
-    /**
-     * `GET /v1/runs/:id`。
-     * 🔴 0.68.0(L-230;server 7.73.0 S-122 P-45 读面):型面补两个**可选**位 —— `heldBy` 与
-     *    `cancelRequested`。两者都是 **additive**:老引擎不发,读点按缺席走既有路
-     *    ({@link CLAIM_RELEASED_STATES}),所以拓型不是「要求宿主升级」,是「宿主已经透传的那两位
-     *    从此有读点」(L-230 ⑤ 逐字:缺的是读点不是通道)。
-     */
     get?: (taskId: string, opts?: DurableRunCallOpts) => Promise<DurableRunRecordView | null>;
     cancel?: (taskId: string, opts?: DurableRunCallOpts) => Promise<unknown>;
-    /** 三选卡的 steer 腿(`POST /v1/runs/:id/steer`)。🔴 **AT-MOST-ONCE**:steer 非幂等,契约逐字
-     *  「it is NEVER retried」(本包 `controlRouter` 同律)—— 本层调它恰一次,失败如实上屏由人重发。
-     *  live 客户端有,mock 车道恒缺席 ⇒ 三选卡上的 steer 选项整个不渲(假 affordance 禁令)。 */
     steer?: (taskId: string, steer: {
         text: string;
         mode?: 'all' | 'one-at-a-time';
     }, opts?: DurableRunCallOpts) => Promise<unknown>;
 }
-/**
- * durable run 动词的每次调用选项。
- *
- * 🔴 `session` 不是可有可无的礼貌位:SDK 头注逐字 —— 这些 run 面是**会话作用域**的,今天一个
- * **缺席**的 session 只让 server 记一条迁移告警就放行,而「the enforcement train will 404 absence
- * too — so new code should always send it」。等那班车到站,不带 session 的 `get`/`cancel`/`steer`
- * 会**整体** 404:三选卡照样渲着 canSteer/canCancel(动词都在场),用户按下去却必然失败,cancel
- * 之后的释放确认也永远读不到 —— 一张按了没用的卡,正是本文件到处在禁的那一形。所以本层把宿主
- * 注入的 `sessionId` 逐次透传;宿主没给就退化成今天的行为(告警放行),但那是宿主的选择,不是
- * 本层替它省掉的一步。
- */
 export interface DurableRunCallOpts {
     signal?: AbortSignal;
     session?: string;
 }
-/**
- * 重开口的判决形(契约,宿主与包内重开腿共同遵守)。
- *
- * · `reopened: true` 的**成文语义** = 「待决材料已确认到手,且卡已交给一个当时在场的渲染面」
- *   (pending 行/题面先 await 到手 + overlay/卡口在场检查通过)。它**不是**像素级呈现的证明。
- * · `firstSight` = 这张卡的身份键在本进程**从未登记过呈现**(判据 = `armedGateRegistry`;
- *   读写都在重开腿与宿主呈现面,本分诊纯层只经返回值拿判决,不碰台账)。文案据此分形:
- *   首见卡说「呈上了一张卡」,零 closed/reopened 断言;复见卡才说「closed without being
- *   answered, so sema reopened it」—— 对没发生过的历史下断言 = 谎报面。
- * · `presented`(**真呈现回执位**,可选)= 宿主呈现层的回执:`true` = 渲染面确认这张卡真的
- *   呈现了;`false` = 宿主**确知**没呈现(如帧被会话级去重集吃掉);缺席 = 宿主没有回执机制,
- *   按「已交付渲染面、未验证」处理。分诊层的消费规则:`presented === false` 时 reopened 的
- *   断言不成立 —— 按重开失败臂说话(说「已重开」而宿主明知没渲 = 谎报);true/缺席不降级。
- *   回执机制的实现留宿主端,包只成文这个契约位。
- */
-export type ReopenCardVerdict = 
-/** L-80:`decidedWithoutCard` = 重开链**没呈卡但已成功决断**(规则直决 / sync-allow)—— 这是进展,
- *  不是失败;端不许把它渲成「could not reopen … NOT sent」。缺席 = 真失败形(语义零变)。
- *
- *  L-93(0.53.0):`pendingRowGone` = 重开链**在有界窗内向引擎读面问过了、而且得到了回答**,
- *  回答是「这条 run 名下**零属主待决行**」——卡不是「呈不出来」,而是**没有东西可呈**
- *  (引擎重启后 process_local 会话店丢行 / 审批被引擎 reap,而 run 仍停在 park 态)。
- *
- *  🔴 **置位条件是正面证据,fail-closed**(宿主义务,包侧无法代为判定):
- *    · 置 —— 读面(approvals.list 等)在窗内**答了**,且属主过滤后的待决行数**恰 0**;
- *    · **不置** —— 读口缺席 / 网络失败 / 抛错 / 窗尽未答 / 调用方中止 / 只是「没找到能用的那一行」
- *      (归属证不出、问句缺席、行形坏)。这些都是「不知道」,不是「不在」。
- *  为什么这条边界不能松:`pendingRowGone` 是本层**唯一**允许 cancel 一条 park 态 run 的前提
- *  (见 {@link ActiveRunSelfHealDeps.offerStaleParkChoice})。park 态的 cancel 语义 = 替用户否掉
- *  待决项,而「待决项仍在」时那正是已退役的循环病根(cancel = deny ⇒ 模型重试 ⇒ 再 park)。
- *  只有**确已没有任何待决项可被否掉**时,那条循环在结构上不存在。含糊值(`false` / `'true'` /
- *  `1` / 缺席)一律不算 —— 判据只认严格 `true`。 */
-{
+export type ReopenCardVerdict = {
     reopened: false;
     decidedWithoutCard?: true;
     pendingRowGone?: true;
@@ -177,372 +37,126 @@ export type ReopenCardVerdict =
     firstSight: boolean;
     presented?: boolean;
 };
-/**
- * `running` 三选卡的呈现请求。🔴 `canSteer` / `canCancel` 是**供给位**(那条路今天兑现得了吗),
- * 呈现层据此渲选项 —— 渲一个按了没用的选项比没有这个选项更坏。
- */
 export interface RunningChoiceRequest {
     taskId: string;
-    /** 引擎报的状态(如实转述,不加工)。 */
     status: string;
-    /** steer 动词在场 **且** 有正文可送。 */
     canSteer: boolean;
-    /** cancel 动词在场 **且** 有 `get` 可以确认 claim 真的释放。 */
     canCancel: boolean;
 }
-/**
- * 「陈旧 park」两选卡的呈现请求(L-93,0.53.0)—— run 仍停在 park 态,而它在等的那张审批**已经
- * 不在引擎上**(宿主证出 {@link ReopenCardVerdict} 的 `pendingRowGone`)。卡上只有两条路:
- * 停掉这条 run(会话当场释放,消息随后重发)/ 什么都不做。
- *
- * 🔴 这里**没有** steer 选项:steer 的语义是「注入正在跑的那一轮」,对一条 park 住的 run 它落
- * `queued`(排在那个**已经不存在**的 checkpoint 上)—— 递一条注定注入不进去的路 = 假 affordance。
- * 🔴 `canCancel` 是**供给位**(与 {@link RunningChoiceRequest} 同律):cancel 动词在场 **且** 有
- * `get` 能确认 claim 真的释放,两者缺一就兑现不了「停掉它再重发」。
- */
 export interface StaleParkChoiceRequest {
     taskId: string;
-    /** 引擎报的状态(如实转述,不加工)。 */
     status: string;
-    /** 「停掉它」这条路今天兑现得了吗 = cancel 动词在场 **且** 有 `get` 能确认 claim 真的释放
-     *  **且** 有属主待决行读口(`listOwnedPendingApprovals`)能在开枪前把前提再证一次。
-     *  三者缺一,本层就不呈这张卡(所以卡到宿主手上时它恒为 `true`;位仍在场是为了与
-     *  {@link RunningChoiceRequest} 同形,且将来这张卡加第二条路时不必改形)。 */
     canCancel: boolean;
 }
-/** 分诊树的注入口(重开腿/待决卡探询都是宿主生命周期资产,经 deps 进来,本层保持纯)。 */
 export interface ActiveRunSelfHealDeps {
-    /** 屏幕上是否已有一张待决卡(有 ⇒ 结局 = decision-pending,绝不重开第二张)。 */
     hasPendingDecision?: () => boolean;
-    /**
-     * [3892]-[3899] P0 假死锁防御(#244 F1 上收,语义照 cli 现实现):`hasPendingDecision` 的真值
-     * 常来自渲染队列长度的**本地镜像**,它在 `--resume` 后可能卡成脏值(队列里躺着一张从未渲上屏
-     * 的幽灵卡)—— 布尔真 + 屏上零真卡 ⇒ 每条消息被 decision-pending 臂闸死,而引擎侧那个 run 早已
-     * completed。本读口 = **引擎侧属主 pending 行数**(宿主装配点带归属过滤:引擎全局队列可躺着
-     * 别家会话的陈年行,裸计数恒非零 = 防御恒不触发,等于没修)。
-     * 判据:镜像说有卡时复核一次,**属主行数恰 0 = 镜像脏值的正面证据** ⇒ 不 stand down,继续真
-     * 分诊(放行重呈);>0 / 抛错 / 读口缺席 / 窗尽 / 调用方中止 ⇒ 保守维持 stand down(分不出
-     * 真卡与幽灵时,旧行为对真卡是对的;存量装配不注入时行为逐字不变)。
-     * 🔴 `opts.signal` = 本层合流的截止/中止口(4s 有界窗 × `deps.signal`),装配方**必须**把它
-     * 透传进真实读面(approvals.list)—— 只掐调用方的 await 不掐底层请求,「有界」就只是判决面
-     * 的说法(忽略该参的存量实现照常工作,只是失去被掐能力)。
-     */
     listOwnedPendingApprovals?: (opts?: {
         signal?: AbortSignal;
     }) => Promise<number>;
-    /** plan_review park 的重开口(生产 = 包 `hitl/planReviewWire.reopenPlanReviewCard`);
-     *  判决形见 {@link ReopenCardVerdict}。同步/异步两式通吃(端的生产口可能要等呈现回执)。 */
     reopenPlanReview?: (taskId: string) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
-    /** ask park 的重开口(生产 = 宿主 ask 重开编排,纯判据半场在包 `hitl/parkOwnership.ts` 与
-     *  `hitl/askParkRowRouting.ts`)。async:待决行(=卡的内容)必须先到手才有资格说「重开了」。 */
     reopenAskPark?: (taskId: string) => Promise<ReopenCardVerdict>;
-    /**
-     * `running` 三选卡的呈现口(#265 上收件)。**缺席 ⇒ 本臂整个不走**(退回 `not-parked` 现状行)
-     * —— 卡呈不出来时零动作是唯一诚实的收口。
-     * 返回值三态:`steer`(把这条消息排进在跑的那一轮)/ `cancel`(停掉它再重发)/ `wait`(什么都
-     * 不做)。🔴 Esc / 空答 / 读不出的答案一律由呈现层收口成 `wait`。
-     */
     offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait'>;
-    /**
-     * 「陈旧 park」两选卡的呈现口(L-93,0.53.0)。**缺席 ⇒ 本臂整个不走**(退回既有
-     * `ask-reopen-failed`,老宿主逐字节零行为差)—— 卡呈不出来时零动作是唯一诚实的收口。
-     *
-     * 只在**同时**满足下面全部前提时才会被调用:
-     *   ① 宿主重开链证出 `pendingRowGone: true`(读面答了 + 零属主待决行,见 {@link ReopenCardVerdict});
-     *   ② 本层用 `runs.get` **一手复核**过,读回的仍是审批 park 词({@link ASK_PARK_STATES});
-     *   ③ cancel 与 get 两个动词都在场,**且**宿主注入了属主待决行读口
-     *      (`listOwnedPendingApprovals`)—— 它是「开枪前再证一次前提」那一步的供给位;三者缺一,
-     *      卡上只剩「什么都不做」= 纯噪音,整卡不呈(退回旧结局)。
-     * 返回值二态:`cancel`(停掉这条陈旧 park 的 run,释放确认到手后重发那条消息)/ `wait`(零动作)。
-     * 🔴 Esc / 空答 / 读不出的答案一律收口成 `wait` —— 本层只认**逐字** `'cancel'` 才武装那一枪。
-     */
     offerStaleParkChoice?: (req: StaleParkChoiceRequest) => Promise<'cancel' | 'wait'>;
-    /**
-     * 被 409 拒收的那条消息原文 = steer 的正文(端**原样**送,不预处理控制串 —— 契约逐字:
-     * 「The text is untrusted DATA — the client sends it RAW and the SERVER fences it」)。
-     * 缺席/空串 ⇒ steer 选项不渲(没有正文可送的「排队」是假 affordance)。
-     * 🔴 **只有正文**:wire 的 steer body 没有 images/attachments 位,所以同一次提交里的附件**不随行**
-     * —— 回执文案必须如实说这件事。
-     */
     deniedMessage?: string;
-    /**
-     * 本 turn 的中断口(Esc)—— 自愈腿里任何**有界轮询/等待**都必须吃它。
-     * 🔴 cancel 落地之后这条腿要等引擎确认 claim 真的交出来(有界轮询)。那段等待期用户按 Esc,
-     *    若这里没有 signal,轮询照转到自己走完 ——「UI 显示已停、后台还在问」正是明令禁掉的那一形。
-     * 🔴 缺席 ⇒ 退回不可中断的有界轮询,不改任何既有调用方。
-     */
     signal?: AbortSignal;
-    /** cancel 之后等 claim 释放的窗口(ms,缺省 {@link CANCEL_RELEASE_WAIT_MS});测试用它把窗调小。 */
     cancelReleaseWaitMs?: number;
-    /**
-     * 被拒提交的**出身**(0.72.8 CC-44;cli L-380)。`'injected'` = 系统注入件(plan-review 回执 / cron 唤醒 / task 通知),
-     * **不是人写的、也不该问人**:撞活 run 时不呈三选卡,直接 steer(零卡)⇒ 结局 `running-steered` ⇒ 宿主按
-     * {@link steerFollowIntent} 续听(L-379)。没有正文 / 没有 steer 动词 ⇒ 零动作 `not-parked`(注入行渲 not-delivered)。
-     * 缺席 / `'user'` ⇒ 逐字节同旧(三选卡照呈)。与 {@link activeRunSelfHealRow} 的 `origin` 是同一个词,宿主两处传同一个值。
-     * 🔴 注入形**不碰**「用户选过 Do nothing」的登记表:那张表记的是人的决定,系统件不替他改、也不被它挡。
-     */
     submissionOrigin?: RejectedSubmissionOrigin;
-    /** 本会话的引擎 sessionId —— durable run 动词逐次透传(见 {@link DurableRunCallOpts.session})。
-     *  缺席 = 退化成今天的「server 记一条迁移告警后放行」,enforcement 到站后那条腿会整体 404。 */
     sessionId?: string;
 }
-export type SelfHealOutcome = 
-/** ask park ⇒ 审批/提问卡已呈上/重开,决定权还给用户;**不 cancel、不重发**。
- *  `firstSight` 见 {@link ReopenCardVerdict} —— 只影响话怎么说,不影响动作。 */
-{
+export type SelfHealOutcome = {
     kind: 'ask-reopened';
     taskId: string;
     firstSight: boolean;
-}
-/**
- * 🔴 屏幕上正有一张待决的审批/提问卡 ⇒ **绝不**自动取消。
- * park 态的 cancel 语义 = 替用户否掉那个待决项(needs_review 就是 reject 掉整个 plan)。
- * 只要用户手上还有可以按的那张卡,决定权就该留在他那里,本层只负责把话说清楚。
- */
- | {
+} | {
     kind: 'decision-pending';
     taskId: string | null;
-}
-/** plan_review park ⇒ 审批卡已呈上/重开,决定权还给用户;**不 cancel、不重发**。 */
- | {
+} | {
     kind: 'plan-review-reopened';
     taskId: string;
     firstSight: boolean;
-}
-/** plan_review park 但卡重开不了(渲染面缺席 / 宿主回执确认没呈现等)⇒ 仍然不 cancel,
- *  如实说 + 给真出路。`decidePath` 来自 409 体的 `pendingGate`(wire 给的真路由,不自造)。 */
- | {
+} | {
     kind: 'plan-review-reopen-failed';
     taskId: string;
     decidePath: string | null;
-}
-/** 持锁的是**活着的** run(通常是背景化的那一轮),或 wire 指名了两张分诊表之外的 gate
- *  kind(结局④:不动 + 如实说)⇒ 不动它,如实告知。
- *  `alreadyOffered`(Inkglow-1085 P0b①,0.37.0,在场即真):同一 (sessionKey,taskId) 的三选卡
- *  **已呈现过且用户选了「Do nothing」** —— 本次不再整卡重弹,端据此把整卡降级渲成一行提示
- *  (默认文案层已给降级行;登记的清口见 {@link clearRunningChoiceOffer})。缺席 = 首撞或登记
- *  已被 steer/cancel 选择清掉,现状行字节不变。 */
- | {
+} | {
     kind: 'not-parked';
     taskId: string;
     status: string;
     alreadyOffered?: true;
-}
-/**
- * 存活对账腿(Inkglow-1085 P0b②,0.37.0):wire 409 终帧说这条 run `running` 占着会话,而出卡前
- * 的 `runs.get` 真查撞 **404** —— claim 指着一条引擎已不认得的 run(幽灵 running)。三选卡不呈
- * (对不存在的 run 渲 steer/cancel 是假 affordance),也**不自动重发**(该 404 与 non-owner 同码
- * 刻意不可分辨,自动重发可能撞回一个仍锁着的会话)——如实说 + 「再发一次」是真出路。
- */
- | {
+} | {
     kind: 'running-not-found';
     taskId: string;
-}
-/**
- * 存活对账腿(对抗复审 [high] 采纳,2026-08-19):wire 409 说这条 run `running`,而出卡前的
- * `runs.get` 读回**终态词**({@link CLAIM_RELEASED_STATES})—— run 已终结,claim 是陈旧/释放中的
- * 投影([4664] 洞③:409 与 poll 口径短暂相左)。三选卡不呈(steer/cancel 对已终结的 run 全是假
- * affordance),也**不自动重发**(claim 可能尚未真正落地释放)—— 如实说 + 「再发一次」真出路。
- * 修前这一形落 `not-parked`,默认文案对一条已终结的 run 说「wait for it to finish」= 永远等不到。
- */
- | {
+} | {
     kind: 'running-settled';
     taskId: string;
     status: string;
-}
-/** 读不到状态(缺 verb / 404 / 传输错)⇒ 不做破坏性动作,如实告知。 */
- | {
+} | {
     kind: 'state-unknown';
     taskId: string | null;
     detail: string;
-}
-/** ask park 但卡重开不了(无渲染面/待决行缺席/问句缺席/归属证不出)⇒ 仍然不 cancel,
- *  如实说 + 给真出路。 */
- | {
+} | {
     kind: 'ask-reopen-failed';
     taskId: string;
     decidePath: string | null;
-}
-/** L-80:重开链无卡直决成功 ⇒ run 已恢复;消息按 `resending` 处置(端接自动重发,见 disposition)。 */
- | {
+} | {
     kind: 'ask-decided-without-card';
     taskId: string;
     released: true;
-}
-/** L-80:直决成功但 run 释放与否**不知道**(无 `runs.get` / 读不出 status / 窗内没释放):不重发、不谎报失败。 */
- | {
+} | {
     kind: 'ask-decided-release-unknown';
     taskId: string;
     lastStatus: string | null;
-}
-/**
- * 三选卡①:用户选了 steer,消息交给了那条持锁的 run。`delivery` = SDK `SteerReceipt.delivery`
- * (`applied` / `queued` / `parked_for_wake`,读不出即 null)—— 三种投递语义**完全不同**,文案
- * 必须分形(共用一句固定包裹时,`parked_for_wake` 那一格会在同一句里既说 run「is already
- * working」又说它「had already finished」)。
- *
- * `status` = `SteerReceipt.status`(服务端投递那一刻读到的行状态词)。它不是修辞:
- * `delivery:'queued'` 按契约意味着**那条 run 根本不在跑**(durably suspended / needs_review),
- * 即 wire 正在纠正本层的分诊输入(进这一臂的前提是 status 读作 `running`)。
- *
- * `reopened` = queued 臂按 `status` 重开那张门卡的判决(其余 delivery 恒 null)—— 门没被答,
- * 那条 run 就不会 resume,消息也就永远注入不进去。
- */
- | {
+} | {
     kind: 'running-steered';
     taskId: string;
     delivery: string | null;
     status: string | null;
     reopened: ReopenCardVerdict | null;
-}
-/**
- * 三选卡①的失败半场:steer 这一枪没得到成功回执。🔴 **零重试**(非幂等),也**绝不回退到 cancel**。
- *
- * `delivery` 是**两类失败的分界**,不是修辞:
- *   · `'rejected'` = 服务端答了且明确拒(4xx:`steering.invalid_content` 422 /
- *     `steering.not_running` 409 / 404 non-owner / 413 too large …)⇒ 「没送到」是**已证事实**,
- *     可以放心让用户重发。
- *   · `'unknown'`  = 送达未知(5xx,或连接在回执路上断了)⇒ 请求可能**已经被受理并注入**。
- *     对这一类说「你的消息没发出去,再发一遍」= 诱导用户把一条非幂等指令注入第二次,而重复的
- *     副作用客户端全程看不见。诚实做法是说清「无法确认」,让用户先看那条 run 的动向。
- */
- | {
+} | {
     kind: 'running-steer-failed';
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
-}
-/** 三选卡②:用户显式选了 cancel,cancel 已落地且引擎确认那条 run 不再占着会话 ⇒ 调用方把被拒的
- *  这条消息**重发一次**(用户已显式授权;与「零授权自动 cancel 循环」不是一回事)。 */
- | {
+} | {
     kind: 'running-cancelled';
     taskId: string;
-}
-/** 三选卡②的有界收口:cancel 请求发出去了,但等到窗口到点(或用户中止了等待)那条 run 仍占着
- *  会话 ⇒ **不重发**,如实说。`waitedMs` = **真等了多久**(不是预算值:预算是打算等多久,用户
- *  读到的那句话说的是已经发生的事);`aborted` = 收口原因是用户中止而不是窗口到点。 */
- | {
+} | {
     kind: 'running-cancel-timeout';
     taskId: string;
     waitedMs: number;
     aborted: boolean;
-    /** 🔴 最近一次探测**拿到了持锁的正面证据**吗。判据**两条取并**(0.68.0 / L-230):
-     *  ① 引擎直说的 `heldBy`(非空串 = 有一条 run 的名字在锁上);② 回落到状态词白名单
-     *  ({@link CLAIM_HELD_STATES},老引擎不发 `heldBy` 时的既有路)。**不是**「lastStatus 非空」——
-     *  表外的新状态词非空却证明不了持锁。false = 两条都读不出 / 读到一个不认识的词 ⇒ 文案只许说
-     *  「确认不了」,绝不说「它还占着」。 */
     confirmedHeld: boolean;
-}
-/**
- * 三选卡②的失败半场:cancel 那一枪没成,且**有界确认腿也没看到会话被交出来**。
- * `delivery` 与 steer 同义(见 running-steer-failed):`rejected` = 服务端明确拒了那一枪(4xx,
- * 确定没生效);`unknown` = 送达未知(5xx / 连接断)—— 那条 run **可能已经在停了**,文案不许
- * 断言「它还占着会话」。
- */
- | {
+} | {
     kind: 'running-cancel-failed';
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
-}
-/**
- * 宿主证出「零属主待决行」后,本层一手复核 `runs.get` 撞 **404** —— claim 指着一条引擎已不认得的
- * run(幽灵 claim 的 park 半场,与 {@link SelfHealOutcome} 的 `running-not-found` 同律)。
- * 不呈任何卡(对不存在的 run 渲 cancel 是假 affordance),也**不自动重发**:该 404 是
- * `not_found.run` = 「不存在」∪「不是你的」的**刻意不可分辨**并集,拿它当「已解锁」的正面证据,
- * 消息可能一头撞回一个仍锁着的会话。如实说 + 「再发一次」是真出路。
- */
- | {
+} | {
     kind: 'ask-run-not-found';
     taskId: string;
-}
-/** 用户在两选卡上显式选了「停掉它」,cancel 已落地且引擎确认那条 run 不再占着会话 ⇒ 调用方把被拒
- *  的这条消息**重发一次**(与 `running-cancelled` 同一条重发腿、同一个前提:释放已被确认)。 */
- | {
+} | {
     kind: 'stale-park-cancelled';
     taskId: string;
-}
-/** 两选卡 cancel 的有界收口:请求发出去了,但等到窗口到点(或用户中止)那条 run 仍占着会话
- *  ⇒ **不重发**,如实说。三个位与 `running-cancel-timeout` 同义(共用同一条确认腿)。 */
- | {
+} | {
     kind: 'stale-park-cancel-timeout';
     taskId: string;
     waitedMs: number;
     aborted: boolean;
     confirmedHeld: boolean;
-}
-/** 两选卡 cancel 的失败半场:那一枪没成,且有界确认腿也没看到会话被交出来。`delivery` 与
- *  `running-cancel-failed` 同义(`rejected` = 4xx 明确拒;`unknown` = 5xx/连接断,可能已受理)。 */
- | {
+} | {
     kind: 'stale-park-cancel-failed';
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
-}
-/**
- * 两选卡②:用户选了「什么都不做」(或卡上读不出答案)⇒ 零动作,如实说清死结在哪、有哪两条真出路。
- * `alreadyOffered`(与 `not-parked` 同款登记降级):同 (sessionKey,taskId) 的两选卡**已呈现过且
- * 用户选了「什么都不做」** ⇒ 本次不再整卡重弹,端据此渲一行提示;清口同
- * {@link clearRunningChoiceOffer}。
- */
- | {
+} | {
     kind: 'stale-park-wait';
     taskId: string;
     status: string;
     alreadyOffered?: true;
 };
-/**
- * 撞 409 的那条提交是谁写的。
- *
- * `'user'`(缺省)= 用户在输入框里敲的那条 —— 现有全部文案的隐含前提,不传即逐字节不变。
- * `'injected'` = 宿主代模型/排程注入的**系统件**:`<plan-review-outcome>` 回执、cron /
- * ScheduleWakeup 唤醒、task 通知。对这一类说「Your message was NOT sent … send it again」是
- * 两重谎:①那不是用户的消息;②它在队列里不可编辑不可 ↑ 召回(壳侧 `isQueuedCommandEditable`
- * 对 isMeta 恒 false),用户**在结构上就没有**「再发一次」这个动作。
- */
 export type RejectedSubmissionOrigin = 'user' | 'injected';
-/**
- * 结局 → 这条被拒提交**到底怎么了**。文案(本文件)与宿主的重排队判据(壳
- * `queueProcessor`/`handlePromptSubmit`)读的是**同一个**分类函数 —— 两边各写一份必漂,
- * 而漂的后果是「话说会重试、实际没重排队」(或反之),正是本文件头在骂的假承诺形。
- *
- *  · `held-for-decision` —— 没送出去,**而且用户手上此刻真有一张答了就能放行的卡**。
- *    ⇒ 宿主可以安全地把系统注入件按原优先级放回队列,答完卡自然重投。
- *  · `resending`         —— 调用方马上就会重发同一条(cancel 已确认释放)。
- *  · `handed-off`        —— 正文已经交给引擎了(steer),不是「没送出去」。
- *  · `not-delivered`     —— 没送出去,且**没有**一张此刻能答的卡 ⇒ 重排队只会空转,如实告知。
- */
 export type SelfHealSubmissionDisposition = 'held-for-decision' | 'resending' | 'handed-off' | 'not-delivered';
-/**
- * 🔴 判据锚在「**有没有一张现在就能答、答了就放行的卡**」这个决定量上,不是锚在「是不是 park
- * 态」这个前置条件上([anchor-on-the-deciding-quantity])。所以三张 reopen-failed / not-parked /
- * state-unknown 全部落 `not-delivered`:它们同样是 park,但卡没能呈到用户面前,把注入件放回队列
- * 只会在下一拍再撞一次同样的 409。`running-not-found`(幽灵 claim)同落 `not-delivered`:
- * 「已解锁」证不出,自动重投可能撞回仍锁着的会话。
- */
 export declare function selfHealSubmissionDisposition(outcome: SelfHealOutcome): SelfHealSubmissionDisposition;
-/**
- * steer 之后**谁续听那条 run、从哪一拍续听**(0.72.6;cli L-379 包侧半场)。
- *
- * ── 病形 ────────────────────────────────────────────────────────────────────────────────────
- * server 7.81.0 起 local 车道的 bg/resume 腿是活审批目标:plan_review 决断后 run **立刻回 running**、撞到
- * 下一道门时**活着等卡**(不再 park → 新流接管)。壳的跟进提交(系统注入件)撞活 run ⇒ 本文件折成 steer ⇒
- * `running-steered` ⇒ 行文案说「watch that run」⇒ 壳 turn 收尾 —— **没有人 tail 那条 run**。那条 run 的
- * 后续(含它新弹出的决断卡)只出现在它自己的 `GET /v1/runs/:id/events` 上,没人听就没人看见:卡永不上屏,
- * 用户被丢在原地(实测 400 s 零事件零卡;7.80.1 差分 3.3 s 上屏)。
- *
- * ── 为什么是包侧判据 ────────────────────────────────────────────────────────────────────────
- * 「该不该 tail、什么时候 tail」由 `delivery` 决定,三端各自猜必漂。判据锚在 SDK `SteerReceipt` 头注逐字:
- *   · `applied`         —— 注入到活着的 run,下一步就消化 ⇒ **现在就 tail** 至终局 / park。
- *   · `queued`          —— run 停在待决 checkpoint,消息 park 在上面;答卡后 resume 出的那条流才是要听的
- *                          ⇒ 续听挂在 **decide 之后**(reopen 那张卡的路径已在本文件里,decide 是壳的事)。
- *   · `parked_for_wake` —— run 已终局,消息卡在 `task_done` checkpoint;**wake 之前什么都不会发生** ⇒ 现在
- *                          tail 只会空等;续听挂在 wake 之后(本客户端不 wake,如实说)。
- *   · 读不出 / 未知词    —— **保守当活 ⇒ tail**:不 tail 的代价是卡永不上屏,空 tail 的代价只是多一条订阅。
- * `fromEventId` 包侧算不出(回执不带),壳用自己手上的 Last-Event-ID 续;缺席 = 从 live 起听。
- * 🔴 `held-for-decision` 档**刻意不加位**:宿主答卡后按原优先级重投注入件,那次提交要么开新 turn(自己的流),
- *    要么再撞 409 ⇒ 回到这里 ⇒ `running-steered` ⇒ 本函数。谁听 = 重投那次提交的流。
- */
 export type SteerFollowIntent = {
     kind: 'tail';
     taskId: string;
@@ -553,146 +167,39 @@ export type SteerFollowIntent = {
     kind: 'after-wake';
     taskId: string;
 };
-/** 结局 → 续听意图;非 `running-steered` 结局(含非对象入参)⇒ `null`。纯函数,不改 {@link SelfHealOutcome} 型面。 */
 export declare function steerFollowIntent(outcome: SelfHealOutcome | null | undefined): SteerFollowIntent | null;
-/**
- * 宿主对 {@link activeRunSelfHealRow} 的**续听声明**:`following: true` = 「我已经按 {@link steerFollowIntent}
- * 挂上了续听」。只有这时 handed-off 那两句才从「watch that run」换成事实陈述 —— 文案与行为同一前提,没接线的端
- * 不许替用户说「sema 在看着」。缺席 / false ⇒ 逐字节同旧。
- */
 export interface SelfHealFollowDeclaration {
     following?: boolean;
 }
-/**
- * cancel 回执(202 体)/ run 行上的 `cancelRequested`(0.68.0 / L-230;server 7.73.0 S-122 P-45)。
- *
- * 🔴 **三态**同上:`true` / `false` 都是真读数,**读不出 ⇒ `undefined`**(老引擎不发这一位)。
- *    绝不折 `false` —— 「没请求过取消」与「不知道有没有请求过」对下一步的含义不同:前者可以放心
- *    再发一次 cancel,后者再发就可能是第二枪。
- * 🔴 它**不是**「已经取消了」:上游逐字是 *requested*,一次**已受理的请求**,不是终局。
- *    会话有没有交出来仍然只由 {@link readClaimHolder} 与 {@link CLAIM_RELEASED_STATES} 回答。
- */
 export declare function readCancelRequested(body: unknown): boolean | undefined;
-/**
- * 一次**至多一次**(non-idempotent)POST 失败之后:到底是「服务端明确拒了」还是「不知道有没有
- * 落地」。steer 与 cancel 两条腿共用这一把尺 —— 它们同属「这一枪不能盲发第二次」的族,而两类
- * 失败对用户的处置**完全不同**,各写一份必漂。
- *
- * 判据 = HTTP 状态码在不在、是不是 4xx:**4xx = 服务端收到了、解析了、明确拒绝**(steering 族的
- * 拒收码全在 4xx:422 invalid_content / 409 not_running|queue_full|duplicate_input_id / 404 / 413),
- * 那一枪确定没有产生效果;5xx 与「压根没有状态码」(fetch failed / 连接断 / 超时)都是**送达未知**
- * —— 请求可能已经被受理,只是回执没回来。
- * 🔴 方向:不确定时归 `unknown`(保守面在「不对用户断言一件证不出的事」这一侧)。
- */
 export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
-/** SDK `SteerReceipt.delivery`(`applied` / `queued` / `parked_for_wake`)。读不出 = null —— 不编造
- *  一个投递语义:三种 delivery 对用户的意思完全不同,猜错就是假承诺。 */
 export declare function readSteerDelivery(receipt: unknown): string | null;
-/** SDK `SteerReceipt.status` —— 服务端在投递那一刻读到的**行状态词**(`running` /「park 词」/终态)。
- *  `delivery:'queued'` 时它是**唯一**能分出「在等哪一类门」的材料(契约逐字:`"suspended"` OR
- *  `"needs_review"`),读不出即 null(不猜一个门种)。 */
 export declare function readSteerReceiptStatus(receipt: unknown): string | null;
-/** 清掉某条 run 的「Do nothing」登记 —— 宿主「重新打开操作菜单」入口(下一次 409 重新整卡呈现)。
- *  `sessionId` 与当时喂给 {@link ActiveRunSelfHealDeps.sessionId} 的值同源(缺席 = 默认键)。
- *  🔴 三选卡与两选卡(L-93)的登记**一起清**:这个入口的语义是「让我重新对这条 run 表态」,
- *  只清其中一张会让另一张在宿主已经答应「重新问」之后仍旧被压掉(paired-mechanisms 同族)。 */
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;
-/** 测试钩:清空整张登记表(套件各组之间隔离用)。 */
 export declare function __resetRunningChoiceLedgerForTests(): void;
-/** {@link waitForClaimRelease} 的收口:`released` = 那条 run 真交出了会话;`waitedMs` = **真等了
- *  多久**;`aborted` = 收口原因是调用方中止(用户 Esc)而不是窗口到点。 */
 export interface ClaimReleaseVerdict {
     released: boolean;
     waitedMs: number;
     aborted: boolean;
-    /**
-     * **最近一次**探测读到的状态词;那一次读不出来(404 / 传输错 / 奇形记录)⇒ null。
-     *
-     * 🔴 它是文案层分「还占着」与「读不出来」的唯一判据:`released:false` 有两种出身 —— 读到了 park
-     * 词(那句「那条 run 还占着这个会话」是**可证的**)与读不出来(此时说「它还占着」就是替引擎下
-     * 一个证不出的断言)。收口成同一句话 = 又一次把「不知道」渲成事实。
-     * 🔴 **只记最近那一次,不记「窗内曾经读到过」**(二次评审 R2 [medium]):先读到 running、此后到
-     * 窗尽全是 404 的时序里,最新证据是「读不出来」;留着那个陈旧的 running 会让收口行断言一件它
-     * 已经不知道的事,恰好塌回本批要修的那一格。
-     */
     lastStatus: string | null;
-    /**
-     * **最近一次**探测读到的 `heldBy` 三态(0.68.0 / L-230;见 `readClaimHolder`)。
-     *
-     *  · `'held'`     —— 引擎**直说**那条 run 还占着这个会话(比按状态词推断强得多的证据);
-     *  · `'released'` —— 引擎**直说**已经交出来了;
-     *  · `'unknown'`  —— 这一位读不出(老引擎不发 / 本发没有回答)。
-     *
-     * 🔴 与 `lastStatus` 同律:**只记最近那一次有回答的探测**;截止掐断(连回答都没有)不改写它。
-     * 🔴 文案层的用法:`'held'` 是「那条 run 还占着这个会话」这句话的**直接证据**,比
-     *    {@link CLAIM_HELD_STATES} 那条按词推断的路更强;两条都读不出时收口成「确认不了」,
-     *    绝不替引擎下一个证不出的断言。
-     */
     lastHolder: 'held' | 'released' | 'unknown';
 }
-/** {@link waitForClaimRelease} 的注入口(时钟/等待/中止/窗口全部可注入 —— 门要能在零墙钟下判)。 */
 export interface ClaimReleaseWaitDeps {
-    /** run 详情读口(生产 = durable `runs.get`)。 */
     get: NonNullable<DurableRunVerbs['get']>;
-    /** 总窗上限(ms)。 */
     budgetMs: number;
-    /** 时钟(缺省 Date.now)。 */
     now?: () => number;
-    /** 退避等待(缺省 = 可中断 setTimeout)。 */
     sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
-    /** 调用方中止口(Esc)。 */
     signal?: AbortSignal;
-    /** 本会话的引擎 sessionId(逐次透传进 `get`;见 {@link DurableRunCallOpts.session})。 */
     session?: string;
 }
-/**
- * 等到那条 run 不再占着会话 ⇒ `released`;窗口到点仍占着 / 读不到 / 调用方中止 ⇒ 不 released
- * (如实说,**绝不重发**那条被拒的消息)。
- *
- * 🔴 判据锚在**决定量**本身:`runs.get` 读回的 status 在不在 {@link CLAIM_RELEASED_STATES} 白名单里
- * (而不是「cancel 回了 202」那个前置条件,也不是「不是 running」那个更弱的反面)。
- * 🔴 读失败(传输错)**不**当成「释放了」:那是「不知道」,而把不知道当成释放 = 把消息喂进一个可能
- * 还锁着的会话(下一次 409 就是它的代价)。只有 404(引擎不认得这条 run 了)才算释放 —— 那种情况
- * 下它连 claim 都不可能还占着。
- * 🔴 有界性由**每一发都带截止 signal**保证(见 {@link claimProbeSignal}),不是靠循环顶那一次减法。
- */
 export declare function waitForClaimRelease(taskId: string, deps: ClaimReleaseWaitDeps): Promise<ClaimReleaseVerdict>;
-/**
- * 自愈一次:定门(kind 优先 → status 表回退)→ 按门类重开对应的卡 → 回报结局。**绝不抛**
- * (turn 收尾路径)。kind 在场时不再回查 runs.get —— wire 已指名门身份,省一次往返。
- */
 export declare function attemptActiveRunSelfHeal(signal: ActiveRunBusySignal, runs: DurableRunVerbs | undefined, deps?: ActiveRunSelfHealDeps): Promise<SelfHealOutcome>;
-/**
- * 端覆盖口:默认串里的两句「出路」是 cli 的真接线动作(`/clear` / 丢 `--resume`),别的宿主
- * 必须换成自己的真出路;整行覆盖给要完全接管措辞/本地化的端。全部可选,不传 = 默认英文串
- * 逐字节不变。
- */
 export interface ActiveRunSelfHealCopy {
-    /** 交互面结局的「真出路」半句(默认 `run /clear to keep working in a fresh session`)。 */
     wayOut?: string;
-    /** headless 面「换个会话」的说法(默认 `start a new session (drop --resume/--continue)`)。 */
     freshSession?: string;
-    /** 整行覆盖(交互面):按结局返回整行;返回 undefined = 该结局落回默认串。 */
     rowFor?: (outcome: SelfHealOutcome, signal: ActiveRunBusySignal | null | undefined) => string | undefined;
-    /** 整行覆盖(headless 面):返回 undefined = 落回默认串。 */
     headlessRowFor?: (signal: ActiveRunBusySignal) => string | undefined;
 }
-/** cli 的唯一真出路(`/clear` = 新会话 id ⇒ 引擎侧全新 session ⇒ 不受旧 claim 影响)。
- *  导出(#244 F1):宿主的 resume 冷启动对账腿等失败半场要说**同一句**真出路 —— 各写一份必漂
- *  (一句「按某个键」而那个键没注册,正是本文件头在骂的形)。覆盖语义照旧走
- *  {@link ActiveRunSelfHealCopy.wayOut},本常量只是默认串的单源。 */
 export declare const INTERACTIVE_WAY_OUT = "run /clear to keep working in a fresh session";
-/**
- * 每种结局的上屏整行。**每一句出路都真的接了线**;没有真出路的分支就直说「这个会话暂时无法
- * 继续」。重开成功那条也要上屏 —— 卡是替用户重新打开的,他得知道去答哪张、答完做什么。
- * wire 真到得了端的两个 additive 键是 `activeTaskStatus` 与 `pendingGate`,各自有真消费点;
- * 不为「说不定哪天上游会发」的键留悬空分支。
- */
 export declare function activeRunSelfHealRow(outcome: SelfHealOutcome, signal?: ActiveRunBusySignal | null, copy?: ActiveRunSelfHealCopy, origin?: RejectedSubmissionOrigin, follow?: SelfHealFollowDeclaration): string;
-/**
- * 非交互车道(headless `-p` 等)对同一事实的诚实说法:那里没有 `/clear`,默认串指的是「别再
- * `--resume` 到这个会话」和引擎自己的 cancel/decide 端点 —— 都是真的存在、真的能做的动作。
- * 这条车道没有自愈腿,材料被吞的代价是全额的:一个「答一下就解锁」的会话会被一句「去 cancel」
- * 打发走,而 cancel 恰恰是替用户否掉那个待决项 —— 所以 decide 入口在场时它才是首选出路。
- */
 export declare function activeRunBusyHeadlessRow(signal: ActiveRunBusySignal, copy?: ActiveRunSelfHealCopy): string;