@sema-agent/client-core 0.77.0 → 0.77.2

package/dist/hitl/livePendingAsk.js

@@ -1,23 +1,3 @@
-/**
- * livePendingAsk — 「悬挂的流内 ask」的三端共用读面与决断口(0.72.14)。
- *
- * ── 这个模块补的是哪一个缺口 ────────────────────────────────────────────────────────────────
- * 流内 ask 在铸造那一刻若没有活着的宿主流可投,引擎把它转成**悬挂**(窗约一小时,不补发、不重算),此后只在
- * `GET /v1/approvals` 回体的第二顶层键 `livePending` 里可发现。后台 workflow 的子代恒落这一形:宿主 turn 先结束,
- * 子代稍后才撞上审批门 ⇒ 用户面零帧零卡,代理静默卡到窗尽。本模块让端从 {@link startApprovalsFeed} 的快照里
- * 读到这些行、出带子代身份的卡、并经**与流内帧腿同一条链**决断。
- *
- * ── 🔴 四条读法 ────────────────────────────────────────────────────────────────────────────
- *  ① **键缺席 ≠ 没有悬挂 ask**:老引擎不发这个键 ⇒ `not_reported`;快照上键缺席,计数读 `null`(不知道),绝不铸 `[]` / `0`。
- *     🔴 CC-98 同一条纪律的第三态:feed 发的「这次取不到」臂(`kind:'unknown'`)喂进本模块三个口时,
- *     计数读 `null`、视图读空、跟踪器**零 delta**(绝不把「取不到」当成「行都消失了」去撤卡)。
- *  ② **数组名即路由判据**:`livePending` 行的决议口是 `POST /v1/tool-approvals/{approvalId}/respond`(流内审批那个口),
- *     **不是** durable 行的 decide 口;两数组不混编。幂等键 = `approvalId`(与流内帧同一个 id)。
- *  ③ **可选旗标 only-if-true**:`fromSubagent` / `governanceForced` / `requiresRealApproval` 缺席绝不编码成 `false`。
- *  ④ **行上没有工具入参**(引擎刻意不在这个读面开第二道脱敏面)⇒ 卡必须明说「看不到入参」,不许渲一个空命令冒充全貌。
- *
- * sdk 的 barrel 没有导出这一行的类型 ⇒ 按**结构**窄读(与 `capabilities.executionLane` 同一姿势),多余成员不过境。
- */
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 function nonEmptyString(v) {
     return typeof v === 'string' && v !== '';
@@ -25,10 +5,6 @@ function nonEmptyString(v) {
 function nonNegativeFinite(v) {
     return typeof v === 'number' && Number.isFinite(v) && v >= 0;
 }
-/**
- * `GET /v1/approvals` 回体 → `livePending` 段读数。四必填位坏形的行丢弃并计数;同 `approvalId` 重复行留第一条。
- * 🔴 CC-98:**非空数组却一行都读不出** ⇒ `malformed`(不是 `present` + 空列表)——分界与理由见函数末那段注。
- */
 export function readLivePendingRows(body) {
     if (body === null || typeof body !== 'object' || Array.isArray(body))
         return { kind: 'malformed' };
@@ -67,24 +43,14 @@ export function readLivePendingRows(body) {
             ...(o.governanceForced === true ? { governanceForced: true } : {}),
             ...(o.fromSubagent === true ? { fromSubagent: true } : {}),
             ...(nonEmptyString(o.originTaskId) ? { originTaskId: o.originTaskId } : {}),
-            // 三道闸:审批帧判别器 ∧ **type 恰是 tool_approval**(判别器也放行 tool_approval_complete —— 完成帧会以空入参出一张可编辑的卡)∧ approvalId 相等
             ...(isToolApprovalFrame(o.frame) && o.frame.type === 'tool_approval' && o.frame.approvalId === o.approvalId ? { frame: o.frame } : {}),
         });
     }
-    // 🔴 CC-98 **分界**(主会话裁定):**非空数组、却一行都读不出来** ⇒ 判 `malformed`(= 这一眼没看成)。
-    // 不许答 `present` + 空列表 —— 那是把「取不到」冒充「一条都没有」,与 `list()` 抛是同一个病形,
-    // 只是换了个入口(端照着它渲「0 条在等你」,而引擎明明报了 N 行)。
-    // 分界的另一半照旧:**部分**坏行逐条丢 + `present`(与 server 的逐行律同形 —— 读得出来的行是真的,
-    // 丢掉那几条由 `dropped` 如实交代,不因为一条坏行就把整段作废)。
-    // 🔴 空数组**不在**本条射程:`[]` 是引擎明说「一条都没有」,恒 `present`(这正是要守住的那一态)。
     if (raw.length > 0 && rows.length === 0)
         return { kind: 'malformed' };
     return { kind: 'present', rows, dropped };
 }
-/** 快照里**出自子代**的悬挂 ask(宿主自己的流内 ask 走流内帧腿,不在这里出卡)。未报 / 没有快照 ⇒ `[]`。 */
 export function suspendedSubagentAsks(snapshot, filter) {
-    // CC-98:「这次取不到」⇒ 手上没有行,出不了卡。但这**不是**「一条都没有」——
-    // 计数口答 `null`、跟踪器零 delta(见下面两处),端别拿本函数的空数组当「没有悬挂 ask」的证据。
     if (snapshot?.kind === 'unknown')
         return [];
     const rows = snapshot?.livePending;
@@ -95,27 +61,17 @@ export function suspendedSubagentAsks(snapshot, filter) {
 export function countApprovalsAwaitingDecision(snapshot, filter) {
     if (snapshot === null || snapshot === undefined)
         return { durable: null, live: null, suspendedSubagent: null };
-    // 🔴 CC-98:「这次取不到」与「没有快照」同一档 —— 三格全 `null`(不知道),绝不折成 0。
-    // 底栏 / 页脚据此渲破折号;渲 0 = 告诉用户「没人在等你」,而真相是这一眼没看成。
     if (snapshot.kind === 'unknown')
         return { durable: null, live: null, suspendedSubagent: null };
     const bySession = (rows) => filter?.sessionId === undefined ? [...rows] : rows.filter(r => r.sessionId === filter.sessionId);
-    // 🔴 CC-98:`pending` 段有读不出来的行(`pendingDropped > 0`)⇒ durable 格答 `null`(不知道确切数)。
     const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? bySession(snapshot.pending).length : null;
     if (!Array.isArray(snapshot.livePending))
         return { durable, live: null, suspendedSubagent: null };
-    // 🔴 CC-98(异源复审 R1 [high] 采修):这一段有**读不出来的行** ⇒ 流内两格答 `null`(不知道确切数)。
-    // 引擎照旧在报那几行,只是这一拍读不懂 —— 拿读得懂的那几条报精确数 = 「0 条在等你」而其实有人在等
-    // (与「取不到渲成没有」同一个病形,只是小一号)。durable 段不受影响,它自己读得出来。
     if ((snapshot.livePendingDropped ?? 0) > 0)
         return { durable, live: null, suspendedSubagent: null };
     const live = bySession(snapshot.livePending);
     return { durable, live: live.length, suspendedSubagent: live.filter(r => r.fromSubagent === true).length };
 }
-/**
- * 悬挂行 → 流内帧腿的输入。只带行上**真有**的位:窗三键不带(行上只有绝对死线,没有出帧时刻,凑不出可校偏的窗),
- * `args` 不带(行上没有)。`sourceTaskId` = `originTaskId`(卡头子代身份徽章的来源)。
- */
 export function livePendingRowToApprovalFrame(row) {
     return {
         type: 'tool_approval',
@@ -127,15 +83,7 @@ export function livePendingRowToApprovalFrame(row) {
         ...(row.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
     };
 }
-/**
- * 出卡并决断一条悬挂 ask —— **与流内帧腿同一条链**({@link surfaceToolApprovalFrameAndRespond}):同一个卡口、
- * 同一个身份键铸口(`approvalId`)、同一套回执 / 拒绝读法。差别只有一处:行上没有入参 ⇒ 卡上明说
- * (`argsUnavailable`),且这张卡上收到「编辑后批准」时**整次不发**(结局 `editRefused`;没有原文可编,丢掉改写再批准 =
- * 批准了人没看到的原始入参)。
- */
 export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {
-    // 0.73.2:行上带 `frame`(server ≥7.87.0)⇒ 全卡,与流内帧腿收到同一只帧时**逐字同一条路**(入参可见、改写可转发、窗三键由 lane 决定);
-    // 缺席 ⇒ 盲卡形不变。两形的身份键都是行的 `approvalId`(读器已钉 frame.approvalId 与之相等)。
     if (row.frame !== undefined) {
         return surfaceToolApprovalFrameAndRespond(row.frame, respond, undefined, signal, lane);
     }
@@ -144,21 +92,9 @@ export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {
         argsUnavailable: true,
     });
 }
-/** 「认领了但还没在任何一张快照里见过」的条目上界(见 {@link createSuspendedAskTracker} 的账目说明)。 */
 const TRACKER_UNSEEN_CLAIMS_MAX = 512;
-/**
- * 快照 → 出卡 / 撤卡的去重账(每个宿主会话一只;不是模块级单例)。同一 `approvalId` 只 `appeared` 一次;
- * `livePending` 键缺席按「现在一条都看不到」处理已出的卡(引擎换代后旧卡没有决断口可用)。
- *
- * 两本账,**都不按条数淘汰活跃条目**(异源对抗复审:无差别的「满了删最旧」会让仍挂着的卡重出、漏撤):
- *   · `shown` = 从快照出过卡、且仍在列表里的 ask。条目随「从列表消失」离账 ⇒ 大小恒 ≤ 列表长度,不设上界。
- *   · `claimed` = 被流内帧腿认领 / 已在本端决断的 ask,值 = 是否已在某张快照里见过。见过之后从列表消失 ⇒ 这只 ask
- *     的一生结束,离账(同 id 日后再出现是新的一只)。**从未见过**的认领才受上界管(帧先到、快照一直没列到它的那一小段),
- *     满了只淘汰这一类里最旧的。
- */
 export function createSuspendedAskTracker(filter) {
     const shown = new Set();
-    /** 已出卡的行当时有没有 `frame`(先盲后全 ⇒ upgraded)。 */
     const shownWithFrame = new Set();
     const claimed = new Map();
     const claim = (id) => {
@@ -180,9 +116,6 @@ export function createSuspendedAskTracker(filter) {
     };
     return {
         ingest(snapshot) {
-            // 🔴 CC-98:「这次取不到」是**零信息**,不是「行都消失了」⇒ 零 delta。
-            // 走下面那条路的后果:`rows` 空 ⇒ 全部 shown 行进 `gone` ⇒ 屏上还在等人的卡被撤掉,
-            // 而那只 ask 在引擎上照旧挂着、照旧没人答 —— 「取不到当成没有」最坏的一形。
             if (snapshot?.kind === 'unknown')
                 return { appeared: [], gone: [], upgraded: [] };
             const rows = suspendedSubagentAsks(snapshot, filter);
@@ -206,11 +139,6 @@ export function createSuspendedAskTracker(filter) {
                     shownWithFrame.add(r.approvalId);
                 appeared.push(r);
             }
-            // 🔴 CC-98(异源复审 R1 [high] 采修):这一张快照里有**读不出来的行**(`livePendingDropped > 0`)⇒
-            // **禁止缺席对账**:一行「不在列表里」可能只是这一拍读不懂,引擎照旧在报它。据此撤卡 =
-            // 把一张还在等人的卡撤掉,而 ask 在引擎上照旧挂着没人答(「取不到当成没有」最坏的一形)。
-            // 新出现的可读行照旧出卡(`appeared`)、补帧照旧升级(`upgraded`)—— 只有「消失」这一句话不许说。
-            // 账**不清**:那几行还留在 `shown` 里,等下一张**完整**的快照再判 gone(撤卡延后,不是丢掉)。
             const incomplete = snapshot !== null && snapshot !== undefined && (snapshot.livePendingDropped ?? 0) > 0;
             const gone = [];
             if (!incomplete) {
@@ -221,7 +149,6 @@ export function createSuspendedAskTracker(filter) {
                     shownWithFrame.delete(id);
                     gone.push(id);
                 }
-                // 见过、现在不在列表里的认领 = 这只 ask 已结算 ⇒ 离账
                 for (const [id, seen] of [...claimed])
                     if (seen && !present.has(id))
                         claimed.delete(id);
@@ -239,7 +166,6 @@ export function createSuspendedAskTracker(filter) {
         noteDecided(approvalId) {
             if (typeof approvalId !== 'string' || approvalId === '')
                 return;
-            // 从快照出过卡的 ask 已在列表里见过 ⇒ 认领直接记「见过」,结算后随列表消失离账
             shownWithFrame.delete(approvalId);
             const wasShown = shown.delete(approvalId);
             if (wasShown)

package/dist/hitl/localAllowRule.d.ts

@@ -1,54 +1,5 @@
-/**
- * hitl/localAllowRule.ts — durable park 腿「不再询问」第三态的**本地落规则判定骨架**
- * (#244 F2 上收件,clay 硬排期;源形 = cli `src/sema/localAllowRuleWrite.ts` 的
- * `parseLocalAllowRule` + 窄化五步。settings 写入、内存权限态、托管策略读口全部留宿主)。
- *
- * ── 为什么这半场是三端公共的 ────────────────────────────────────────────────────────────────
- * durable park 腿的候选走行上的 `PendingCheckpoint.ruleSuggestions` → 卡入参**只读键**
- * `ruleSuggestionsReadOnly`,而 `/decide` 的体(SDK `AskDecisionBody`)是**闭集、无规则位**——
- * 兑付口只能是**客户端本地** settings。哪些候选可本地兑付、写下去的 canonical 字节是什么,
- * 是纯**形**判定:desktop/web 接到同一份行供给时要的正是同一把窄化(各写各的必漂,而漏一步
- * 就是跨会话任意代码放行 —— [3925] P0 解释器族绕过案的教训)。
- *
- * ── 🔴 五道窄化(本地写入独有;wire 兑付腿没有,那条只搬字节给 server)────────────────────────
- * 1. **整工具规则不写**。`Bash` / `Bash(*)` 解析后退化成整工具 allow,比这只 ask 的动词宽得多
- *    (CC `suppressAlwaysAllowRule` 同理;durable 行上没有这一位过境,按**收紧方向**自守)。
- * 2. **规则得是给这只 ask 的那个工具的**(`expectedToolName`)。规则文本是**引擎**铸的,可能用
- *    引擎侧 wire 工具名(`file_write(/tmp/x)` 解析得干干净净,写进 settings 后**永远匹配不上**)
- *    —— 落盘不报错、也不生效的死规则,比拒绝更坏。
- * 3. **没有字面锚的规则不写**。`Bash( * )` / `Bash(**)` 等拼法 ruleContent **非空**却与被禁的
- *    `Bash(*)` 完全等效(宿主匹配器先 trim 再把未转义 `*` 展成 `.*`)。判据锚在「这条规则还有
- *    没有约束力」:去掉全部**未转义**通配符后必须还剩字面字符(转义星 `\*` 是字面星号,照留)。
- * 5. **解释器/包装器裸前缀不写**(`Bash(bash:*)` / `Bash(sudo:*)` …):过得了窄化③(有字面锚)
- *    却等于放行任意命令(`bash -c "任何东西"`)。谓词经 {@link LocalAllowRuleDeps} 注入 ——
- *    策略表本体(BARE_SHELL_PREFIXES / dangerousPatterns)留宿主,绝不在包内自建第二份名单。
- * 5b. **canonical 危险规则谓词叠加**([3925] P0 跟修):⑤ 只覆盖 shell/wrapper,而
- *    python/node/npx/eval/exec/ssh 等**解释器族**的规则形同样等于任意代码放行(`python -c`)。
- *    同经 deps 注入宿主的 `isDangerous{Bash,PowerShell}Permission`(auto-mode 入口同一把谓词)。
- *    ⑤ 不撤:它做 basename/.exe 路径归一(`/bin/bash`),canonical 谓词是纯字面形不做归一 ——
- *    两把互补,各管一族拼法。
- * (④ 托管策略是**可变量**,刻意不在本骨架里 —— 解析必须纯:同一串输入永远同一个结论,否则
- *  已上屏的 option value 会反查不到,用户的选择被丢掉。策略由宿主在渲染面与写入面各自查。)
- *
- * 🔴 **纯函数 / 只看形**:不读 settings、不读宿主状态、不读策略;deps 注入的谓词也必须是
- * 纯函数(pattern 表 + 启动期常量),否则「渲档位」与「按 value 反查候选」两处调用会漂。
- * 🔴 **错误文案是契约面**:cli 常驻套(localRuleSuggestionsCard,128+ 断言)对拒绝集逐字锚 ——
- * 上收前后拒绝集必须逐字相等,改一处文案就是改三端的可观察行为。
- * 🔴 UNTRUSTED:`rule` 是 wire 串(core `inlineUntrusted` + server `redactSecrets` 之后)。它只被
- * 喂给宿主自己的规则解析器与 settings 写口,不回喂模型、不进工具入参、不当代码执行。
- */
 import type { PermissionRuleValue } from '@sema-agent/agent-types';
 export type { PermissionRuleValue };
-/**
- * 宿主注入面(parkOwnership deps 同形:缺一不可的**纯函数**切片,策略表本体留宿主)。
- *  · `parseRule` / `formatRule`:宿主的规则语法(CC `Tool(content)` 形 + 转义 + legacy 工具名
- *    归一)。解析失败**抛**(骨架把它折成 `ok:false`);`formatRule` 的产物 = canonical 字节
- *    (真正会被写进 settings 的那串,渲染面必须渲它而不是 wire 原文)。
- *  · `bashRuleContentHasDangerousBarePrefix`:窄化⑤ 的谓词(宿主 BARE_SHELL_PREFIXES 表,
- *    含 basename/.exe 路径归一)。
- *  · `isDangerousBashPermission` / `isDangerousPowerShellPermission`:窄化⑤b 的 canonical 危险
- *    规则谓词(宿主 dangerousPatterns 表;谓词自己按 toolName 分派,非 Bash/PowerShell 恒 false)。
- */
 export interface LocalAllowRuleDeps {
     parseRule(rule: string): PermissionRuleValue;
     formatRule(value: PermissionRuleValue): string;
@@ -56,12 +7,6 @@ export interface LocalAllowRuleDeps {
     isDangerousBashPermission(toolName: string, ruleContent: string): boolean;
     isDangerousPowerShellPermission(toolName: string, ruleContent: string): boolean;
 }
-/**
- * 解析结局。`ok:false` = 这条候选**不可本地兑付**(渲染面据此不渲该档)。
- * `canonical` = 真正会被写进 settings 的那串字节(`deps.formatRule` 的产物)——
- * 🔴 渲染面**必须渲它**而不是 wire 原文:两者在带括号的命令上会差一层转义,渲原文就等于
- * 「展示的规则和落地的规则不是同一串」。
- */
 export type LocalAllowRuleParse = {
     ok: true;
     value: PermissionRuleValue;
@@ -70,11 +15,4 @@ export type LocalAllowRuleParse = {
     ok: false;
     error: string;
 };
-/**
- * 规则原文 → 宿主规则空间的 `PermissionRuleValue`,带文件头注的**形**类窄化(①②③⑤⑤b)。
- *
- * @param expectedToolName 这只 ask 自己的工具名(卡的 `tool.name`)。给了就必须相等 —— 见头注
- *   窄化②:引擎侧 wire 工具名(`file_write` 之类)解析得干净但在宿主的规则空间里是死规则。
- *   **缺省不校**:纵深第二道(写口)不知道也不该猜「这只 ask 是哪个工具」,那是卡面的知识。
- */
 export declare function parseLocalAllowRule(rule: string, expectedToolName: string | undefined, deps: LocalAllowRuleDeps): LocalAllowRuleParse;

package/dist/hitl/localAllowRule.js

@@ -1,12 +1,4 @@
-/** 规则空间里 Bash 工具的名字(窄化⑤ 只对这一族适用;⑤b canonical 谓词管 PS 族)。 */
 const BASH_TOOL_NAME_FOR_RULES = 'Bash';
-/**
- * 规则原文 → 宿主规则空间的 `PermissionRuleValue`,带文件头注的**形**类窄化(①②③⑤⑤b)。
- *
- * @param expectedToolName 这只 ask 自己的工具名(卡的 `tool.name`)。给了就必须相等 —— 见头注
- *   窄化②:引擎侧 wire 工具名(`file_write` 之类)解析得干净但在宿主的规则空间里是死规则。
- *   **缺省不校**:纵深第二道(写口)不知道也不该猜「这只 ask 是哪个工具」,那是卡面的知识。
- */
 export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof rule !== 'string' || rule === '') {
         return { ok: false, error: 'rule text is empty' };
@@ -21,30 +13,24 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof value.toolName !== 'string' || value.toolName === '') {
         return { ok: false, error: 'rule text carries no tool name' };
     }
-    // 窄化①:整工具 allow 比这只 ask 的动词宽得多(CC suppressAlwaysAllowRule 同理)。
-    // `Bash(*)` 也走这里 —— 解析器把它归一成整工具形,所以判据只有一条「有没有 ruleContent」。
     if (value.ruleContent === undefined || value.ruleContent === '') {
         return {
             ok: false,
             error: 'candidate is a whole-tool allow rule (broader than this ask) — not offered locally',
         };
     }
-    // 窄化②:规则得是给**这只 ask 的那个工具**的(否则是一条落盘不报错、也永远不生效的死规则)。
     if (expectedToolName !== undefined && value.toolName !== expectedToolName) {
         return {
             ok: false,
             error: `candidate names tool "${value.toolName}" but this ask is for "${expectedToolName}" — a rule for another tool would never match`,
         };
     }
-    // 窄化③:去掉未转义通配符后必须还剩字面字符,否则这条规则与整工具放行等效(见头注 3)。
     if (!hasLiteralAnchor(value.ruleContent)) {
         return {
             ok: false,
             error: 'candidate is all wildcard (matches every command for this tool) — equivalent to a whole-tool allow, not offered locally',
         };
     }
-    // 窄化⑤:解释器/包装器裸前缀(`bash:*` / `env:*` / `sudo:*` …)——有字面锚但等于任意命令放行。
-    // 谓词表属主在宿主(bashPermissions 的 BARE_SHELL_PREFIXES),经 deps 注入,绝不自建第二份名单。
     if (value.toolName === BASH_TOOL_NAME_FOR_RULES &&
         deps.bashRuleContentHasDangerousBarePrefix(value.ruleContent)) {
         return {
@@ -52,9 +38,6 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
             error: 'candidate is a bare interpreter/wrapper prefix (bash/sh/env/sudo/…) — persisting it would authorize arbitrary commands, not offered locally',
         };
     }
-    // 窄化⑤b([3925] P0 跟修):canonical 危险规则谓词叠加 —— python/node/npx/eval/exec/ssh 等
-    // 解释器族的五种规则形同样等于任意代码放行(`python -c`)。谓词自己按 toolName 分派
-    // (非 Bash/PowerShell 恒 false),纯函数,不破坏本函数「同输入恒同结论」的承重性质。
     if (deps.isDangerousBashPermission(value.toolName, value.ruleContent) ||
         deps.isDangerousPowerShellPermission(value.toolName, value.ruleContent)) {
         return {
@@ -64,32 +47,17 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
     }
     return { ok: true, value, canonical: deps.formatRule(value) };
 }
-/**
- * 规则内容里还有没有**字面**约束(窄化③ 的判据)。
- *
- * 只剥**未转义**的 `*`:转义星 `\*` 是字面星号(与宿主匹配器 `hasWildcards` 的判据同源),
- * 剥掉它会把「命令就叫 `*`」这条有约束力的规则误判成通配。剥完 **trim**,空 ⇒ 这条规则对该工具的
- * 任何命令都成立。
- *
- * 末尾的 `trim()` 是承重的,不是顺手:宿主匹配器自己入口也先 `pattern.trim()`,所以「只剩空白」
- * 与「什么都不剩」在匹配语义上是同一件事 —— `Bash(* *)` / `Bash( ** )` 这类「看起来有字符」的
- * 拼法因此同样被拦下(cli 常驻套 ①-17 五种拼法全红)。
- * ⚠️ 仍是**收紧方向**的近似:带一个字面非空白字符的极宽规则(如 `Bash(*a*)`)有字面锚、会放行。
- * 真正按匹配器语义算「这条规则有多宽」要把 per-form 的判定搬过来,记为 follow-up;当前判据不漏
- * 「等效于 `Bash(*)`」的那一族,而那一族才是题面。
- */
 function hasLiteralAnchor(ruleContent) {
     let out = '';
     for (let i = 0; i < ruleContent.length; i++) {
         const ch = ruleContent[i];
         if (ch === '\\' && i + 1 < ruleContent.length) {
-            // 转义序列整段保留(`\*` 的星号是字面量,`\\` 是字面反斜杠)。
             out += ruleContent[i + 1];
             i++;
             continue;
         }
         if (ch === '*')
-            continue; // 未转义通配符:剥掉
+            continue;
         out += ch;
     }
     return out.trim() !== '';

package/dist/hitl/parkOwnership.d.ts

@@ -1,66 +1,10 @@
-/**
- * parkOwnership.ts — ask park 重开腿的**纯判据**三件(A-028.2,#244 族A 包半场,2026-08-12;
- * 源形 = cli `src/sema/askParkReopen.ts` 的发现面判据半场;`approvals.list` 编排与 stderr
- * 留宿主 —— 本文件零网络、零渲染,只回答判决)。
- *
- * ── A-024.1:「队列恰一行」不是归属证明 ────────────────────────────────────────────────────
- * `/v1/approvals` 是 **scope 级**单队列:恰一行只说明「此刻没有别的行在排队」,而孤儿 park、
- * 行可见性延迟、另一会话独占队列三种形都能让**别人的**行落单。把这一行直接展示并代为决断,
- * 是 REF-CC-029(`?? pending[0]`)那个病的换形复发 —— 后果不是渲染错,是**把别人的审批递到
- * 这个用户手上并替他按了钮**。
- *
- * 宿主能拿出的归属硬证据只有两条(缺一不可地互补,不是二选一):
- *   ① 行的 `taskId` ∈ own-run 台账(`isOwnEngineRun`,只记本进程亲手驱动的 run + fleet 行帧
- *      闭包进来的自家子代)⇒ 本宿主起的 run/子代。child 委派行走这条 —— 子代 park 行的
- *      `sessionId` 是子代自己的 session,天生 ≠ 本会话,只按 ② 判会把发现面拆掉。
- *   ② 行自带 `sessionId` === 本宿主当前引擎会话 ⇒ 本会话自己的 park。
- *
- * 🔴 判据是 **fail-CLOSED 的正向证明**:两条腿任一成立才采信,**都不成立就不采信** —— 包括
- * 「本会话 id 还没有」「行没带 sessionId」这两种**判不出**的形。把「证明不了」当「是我的」,
- * 在一个会替用户按钮的面上正好反了。判不出的代价只是一句诚实的 reopen-failed(用户重发消息
- * 即重走本链),而放行的代价是替别人决断,不对等。
- */
 import type { PendingCheckpoint } from '@sema-agent/sdk';
 import type { AskQuestion } from '../liveQuestionStore.js';
-/** 归属判据的两条腿的注入口(缺席走包内既有真源:SessionPort + own-run 台账)。 */
 export interface ParkOwnershipDeps {
-    /**
-     * 多会话宿主的会话键(缺省 = DEFAULT_SESSION_KEY,单会话宿主零参装配)。
-     * 🔴 传了**非默认键**而没有注入 `isOwnRun` 时,own-run 缺省腿**整条跳过**(复审 [high] 收紧):
-     * 包内 own-run 台账是**进程级**的(记「本进程驱动过的 run」),在一个跑着 A/B 两个会话的宿主
-     * 进程里,它答不了「这行是 A 的还是 B 的」—— 拿进程级证据放行会把 A 的审批递到 B 手上。
-     * 多会话宿主要么注入自己会话粒度的 `isOwnRun`,要么只靠会话腿(fail-closed:少一条腿的代价
-     * 只是多一次诚实 reopen-failed)。
-     */
     sessionKey?: string;
-    /** 会话腿真源(缺省 = `hostSessionFor(sessionKey).currentSessionId()`;空串按缺席归一,
-     *  判不出 ≠ 命中)。 */
     currentSessionId?: () => string | undefined;
-    /** own-run 台账腿(**并联**:默认会话键下注入腿与包 `isOwnEngineRun` 缺省腿任一命中即 owned
-     *  —— 注入是**补腿不是换腿**,cli 1.0.76 扫码 P1 跟修;非默认键下缺省腿整条跳过,见 sessionKey 注)。
-     *  🔴 键域 = `rowIdTail(行 taskId)`(fleet 台账登记时就过 rowIdTail,本判据同域取键后才调本口)。
-     *  🔴 成文局限(复审二轮裁定,不改行为):默认键下的缺省腿是**进程级**证据,不区分同一宿主
-     *  进程内的会话代际 —— `/clear` 前登记的 run 在新会话语境下仍判 owned。这是单会话宿主的
-     *  出货语义(owner = 本进程的这一位用户;child 委派行的 sessionId 天生 ≠ 本会话,发现面恰恰
-     *  依赖跨会话 id 的进程级证据),最坏形 = 用户看到**自己**旧会话的审批卡(卡面标注行归属)。
-     *  要会话代际粒度就注入自己的 `isOwnRun` —— 台账本体改代际级属 own-run 域独立议题。 */
     isOwnRun?: (taskIdTail: string) => boolean;
 }
-/**
- * 这行 pending 能不能**正向证明**属于本宿主会话(fail-closed;两腿语义见文件头)。
- * 腿序:own-run 先问(child 委派行不依赖会话 id),会话腿后问。
- */
 export declare function pendingRowIsOwnedByThisSession(row: PendingCheckpoint, deps?: ParkOwnershipDeps): boolean;
-/**
- * questions payload 从 pending.input 读 —— **结构判定**收窄到 AskQuestion 必需键(question
- * 非 string / questions 非数组 / 空数组 ⇒ null,不 cast 硬塞;缺 header 的行照 CC 形容忍,
- * overlay 自兜)。铸空卡 = 假 affordance,拿不到题就诚实返 null。
- */
 export declare function askQuestionsFromPending(pending: PendingCheckpoint): AskQuestion[] | null;
-/**
- * HitlSafetyError 判型的 duck-check(按 `name`,不按 instanceof —— 宿主 bundle 里存在第二份包
- * 实例时 instanceof 会分叉,sseIdleTriage 同款纪律)。安全信号(binding_mismatch 族)契约禁
- * 盲重试,重开腿据此把「可重试的瞬时故障」与「必须交还人重决的安全停」分开。
- * 入参是任意抛出值,本函数就是窄化动作本身(unknown 出境登记见 typeshape 门 RATCHET 注)。
- */
 export declare function isHitlSafetyErrorLike(e: unknown): boolean;

package/dist/hitl/parkOwnership.js

@@ -2,19 +2,9 @@ import { isOwnEngineRun } from '../subagentContentStore.js';
 import { rowIdTail } from '../workflow.js';
 import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
-/**
- * 这行 pending 能不能**正向证明**属于本宿主会话(fail-closed;两腿语义见文件头)。
- * 腿序:own-run 先问(child 委派行不依赖会话 id),会话腿后问。
- */
 export function pendingRowIsOwnedByThisSession(row, deps) {
     const sessionKey = deps?.sessionKey ?? DEFAULT_SESSION_KEY;
-    // ① 本宿主亲手驱动的 run / 由它闭包进来的自家子代 —— 不依赖会话 id。
-    //    进程级缺省腿只在默认会话键下启用(多会话宿主必须注入会话粒度的口,见 deps.sessionKey 注)。
     const rowTaskId = typeof row.taskId === 'string' ? row.taskId : '';
-    // 🔴 注入腿与缺省台账腿是**并联**不是顶替(cli 1.0.76 扫码 P1 的包 API 半场,主板 [3925]):
-    //    此前 `deps?.isOwnRun ?? isOwnEngineRun` 让「端为补一条自己的正向腿」变成「顺手关掉进程内
-    //    台账腿」——补一条断一条,消费端得记得自 OR 才不踩(cli 复核读口实翻)。并联只多不少地
-    //    要求正向证明,fail-closed 方向不变;非默认键下缺省腿照旧整条跳过(sessionKey 注)。
     if (rowTaskId.length > 0) {
         const tail = rowIdTail(rowTaskId);
         if (deps?.isOwnRun !== undefined && deps.isOwnRun(tail))
@@ -22,7 +12,6 @@ export function pendingRowIsOwnedByThisSession(row, deps) {
         if (sessionKey === DEFAULT_SESSION_KEY && isOwnEngineRun(tail))
             return true;
     }
-    // ② 行自带 sessionId === 本会话当前引擎会话。任一侧缺席/空串 = 判不出,不是命中。
     const currentSessionId = deps?.currentSessionId ?? (() => hostSessionFor(sessionKey)?.currentSessionId());
     const sessionId = currentSessionId();
     const rowSessionId = typeof row.sessionId === 'string' ? row.sessionId : '';
@@ -31,11 +20,6 @@ export function pendingRowIsOwnedByThisSession(row, deps) {
         rowSessionId.length > 0 &&
         rowSessionId === sessionId);
 }
-/**
- * questions payload 从 pending.input 读 —— **结构判定**收窄到 AskQuestion 必需键(question
- * 非 string / questions 非数组 / 空数组 ⇒ null,不 cast 硬塞;缺 header 的行照 CC 形容忍,
- * overlay 自兜)。铸空卡 = 假 affordance,拿不到题就诚实返 null。
- */
 export function askQuestionsFromPending(pending) {
     const input = pending.input;
     if (typeof input !== 'object' || input === null)
@@ -46,12 +30,6 @@ export function askQuestionsFromPending(pending) {
     const ok = qs.every(q => typeof q === 'object' && q !== null && typeof q.question === 'string');
     return ok ? qs : null;
 }
-/**
- * HitlSafetyError 判型的 duck-check(按 `name`,不按 instanceof —— 宿主 bundle 里存在第二份包
- * 实例时 instanceof 会分叉,sseIdleTriage 同款纪律)。安全信号(binding_mismatch 族)契约禁
- * 盲重试,重开腿据此把「可重试的瞬时故障」与「必须交还人重决的安全停」分开。
- * 入参是任意抛出值,本函数就是窄化动作本身(unknown 出境登记见 typeshape 门 RATCHET 注)。
- */
 export function isHitlSafetyErrorLike(e) {
     return typeof e === 'object' && e !== null && e.name === 'HitlSafetyError';
 }

package/dist/hitl/parkResolver.d.ts

@@ -4,54 +4,17 @@ import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { AskAnsweredOutput, GateLedger } from './gateLedger.js';
 import { type AskGateWireDeps, type GatePark } from './frameRouter.js';
 import { type DecideReceiptView } from '../decideReceipt.js';
-/**
- * L-80(2026-09-03,[6215];#357 复发):**连续非进展轮**上限 —— 数的是「壳再附着之后那段流里一个
- * host 推进帧都没有」的轮次,**不是** park 次数。修前这里是 `24` 且按每次 park 递增
- * (askGateWire `hops++` 无条件),于是一个 turn 里模型对同一失败 Edit 重试 24 次、每次真被门真被决,
- * 也会在第 25 次撞成 `gate hop limit (24) exceeded`——一句与真因无关的预算话术。CC 没有这条预算:
- * 模型问 N 次就答 N 次。本闸只留作最后防线:连续 N 轮零进展(坐标失配空转 / reopen 类 re-park /
- * decide 出站恒断)才收场,收场前再呈一次收场卡、终帧带真因与出路。
- */
 export declare const MAX_GATE_HOPS = 2;
-/** 一轮 park 的进展判决(驱动侧按 `isHostProgressFrame` 观察,见 askGateWire)。 */
 export type HopRound = 'progress' | 'stalled';
-/** hop 预算状态:`stalled` = 连续非进展轮数(进展即清零);`total` = 本 turn park 总数(只用于日志)。 */
 export interface HopBudget {
     readonly stalled: number;
     readonly total: number;
 }
-/** 纯函数:上一轮预算 + 本轮判决 ⇒ 新预算(不就地改入参;`undefined` = 本 turn 第一轮)。 */
 export declare function nextHopBudget(prev: HopBudget | undefined, round: HopRound): HopBudget;
-/**
- * 硬兜底(对抗复审 r1 [high]①,r6 [high] 收窄):一 turn 内**解析不出身份**的 park 数上限。连续非进展计数靠
- * 「解析到的 pending 行身份 + host 推进帧」判进展;解析不到行(tool-less park / approvals 恒空)时身份判不出 ⇒
- * 只能靠推进帧,一个每轮先吐一帧文本再原样 park 的病态引擎在那一形下仍可能无限。**只数这一类**:每轮都解析到
- * 新 call 且真推进的门(模型重试同一失败调用 N 次)不吃这格 —— CC 没有此闸,问 65 次就答 65 次。
- * 命中即收场、终帧如实说「本 turn 有 N 次 park 解析不出身份」。
- */
 export declare const MAX_TOTAL_PARKS = 64;
-/**
- * REF-CC-033:`GateOutcome` 的 `failed` 分支闭集判别码。来源两处:①本文件自己的
- * 「pending 行取不到」早退(`surfaceGateAndDecide` 里 `!pending` 那条);②`HitlBridge` 抛出的
- * `HitlSafetyError.code`(hitlBridge.ts 契约:`binding_mismatch|no_pending|wrong_gate|bad_plan_edit`
- * ——该属性今天仍是开集 `string`,TYPESHAPE-07/REF-CC-036 候后续车锁死;这里落地前用
- * `isGateFailureCode` 按闭集白名单过滤,不认得的值一律降级成 `undefined`,退回文案兜底,不让
- * 开集腐蚀这个新判别位)。消费点只认 `'no_pending'` 为「已解决」,其余码(binding_mismatch 等)
- * 是真需要重新呈现给人的失败,不能走「继续读流」这条路。
- */
-/**
- * 白名单的**运行期真源**(FIX② 2026-08-07 由三处散落的 `===` 收成一份元组)。
- * 🔴 与 `hitlBridge.HitlSafetyError.code` 的联合是**同一个闭集的两半**:下方 `_gateFailureCodePins`
- * 双向钉住,任何一边加员而另一边不跟 ⇒ 编译红。此前两边靠人肉同步,而不同步的可观测后果是
- * 「新码被 `isGateFailureCode` 降成 undefined 后静默走文案兜底臂」—— 门里长得跟正常一模一样。
- */
 export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "bad_plan_mode", "empty_answer"];
 export type GateFailureCode = (typeof GATE_FAILURE_CODES)[number];
-export type GateOutcome = 
-/** `receipt`(B-070 / L-200,0.65.0):这次 decide 的 **200 回执读数** —— 与 fs 腿的
- *  `FsApprovalOutcome.receipt` **同形同源**(同形存量清剿:两条决断腿一次改齐)。语义与缺席纪律
- *  逐字见 `decideReceipt.ts` 顶注;🔴 它**不是**「门已解决」的证据(200 只是投递受理)。 */
-{
+export type GateOutcome = {
     kind: 'decided';
     gatedCallId?: string | undefined;
     answered?: AskAnsweredOutput | undefined;
@@ -69,42 +32,9 @@ export type GateOutcome =
     retryExhausted?: true;
     currentPending?: GateCurrentPending | undefined;
 };
-/**
- * decide 的 `failed` 原因是不是「这个 gate 早就被解决了」(#110 缺陷② c 的判据)。
- *
- * REF-CC-033:此前判据**只**锚在文案词(`no pending checkpoint` / `resolved` / `already` 三者
- * 任一在场)——server 原文改一个字,整条命中当场失效(FIX-13 / 域词表-01)。现在消费点(见下方
- * `isAlreadyResolvedFailure`)优先判 `GateOutcome.code`(闭集判别位,见 `GateFailureCode`);
- * 这个函数降级为**文案兜底臂**,只在 outcome 没带 code 的时候才被调用(典型:`FsApprovalOutcome`
- * 来自 `toolApprovalWire.ts`,那份类型今天没有 code 字段——C-bridge 卡的文件域,本卡不改)。
- * 🔴 方向没变:这条判**错**的后果不对称 —— 误判成「已解决」最多让流多读一轮(hop 预算兜底),
- * 误判成「真失败」会把一个已经 completed 的 run 谎报成失败并烧掉整条会话转录。所以宁可宽。
- */
-/** #114/[C68] 单源化提升:desktop 照抄件(durable 双实现审计 P0-1 修)到货换包导入删抄件。
- *  [C106] 收编 `not found` 形(2026-08-05):引擎对已批门的 deny 回 `approval not found`
- *  (desktop 实测——parked 刚批完、decide 未返回的竞态窗内 Stop 走 parked-deny 路),旧词表
- *  判不中 ⇒ 按真失败 log-only 放弃 ⇒ runs.cancel 永不发出=Stop 哑弹。按上方「宁可宽」方向收编。 */
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
-/** 把 wire 答案({answers:[{header,selected,note?}]})折回 CC 卡片的 Record<question,string> 形状
- *  (multiSelect 与对话框同款 ", " lossy join;note → annotations.notes)。 */
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
-/** 外环决断的两种出路(见文件头注)。 */
-/** resolvePark 的续流判决:`progress` 位 = 这一轮决断真落地了一次(驱动侧不据此复位计数 —— 复位只看
- *  下一段流有没有 host 推进帧);非进展轮携 `reason`(收场文案用)。 */
-export type ParkResolution = 
-/**
- * `handoffTaskId`(B-070 / L-200,0.65.0):🔴 **这一轮之后该盯哪条 run**。
- *
- * sdk README §9.0.0 的 workflow 车道逐字:受理形 200 上的 `taskId` 是「**宿主新铸**的 run id
- * (poll 它,**不要盯那张卡**)」。修前重挂腿恒用**原** taskId 重挂 `runs.events` —— 而那条 run
- * 已经把续跑交给了另一条,于是旧流上再也不会有推进帧,预算一路烧到 hop 上限,终帧还是一句
- * 与真因无关的话。
- * 🔴 **缺席 = 没有换挂**(终局形 / 幂等回放形 / 老 server / 这一轮压根没 decide 成功):调用方
- *    **照旧用原 taskId**;绝不把缺席折成任何别的意思。
- * 🔴 **换挂时 `lastEventId` 必须丢掉**:durable seq 是 **per-run** 的,拿旧 run 的序号去续读新
- *    run 是跨命名空间取数([same-name-different-meaning-crosses-layers])。调用点有断言。
- */
-{
+export type ParkResolution = {
     kind: 'reattach';
     progress: true;
     presented: boolean;
@@ -124,28 +54,13 @@ export type ParkResolution =
 export interface ParkResolveCtx {
     deps: AskGateWireDeps;
     led: GateLedger;
-    /** sync leg 捕获的真 run handle(内环 `TaskIdRef` 的当前值)。 */
     taskId: string;
-    /** 本 turn park 总数(日志用;**不再**是预算计量,见 {@link MAX_GATE_HOPS})。 */
     hops: number;
-    /** 本 turn 内**解析不出身份**的 park 数(驱动侧累计;超过 {@link MAX_TOTAL_PARKS} 即硬兜底收场)。 */
     unverifiableParks?: number;
-    /** 连续非进展轮数(驱动侧 {@link nextHopBudget} 算出;超过 {@link MAX_GATE_HOPS} 即收场)。 */
     stalledRounds?: number;
-    /** 上一轮非进展的真因 token(收场文案用)。 */
     lastStallReason?: string | undefined;
-    /** 上一轮有没有真呈过卡(收场卡只在**没呈过**时才呈 —— 呈过再呈 = 把同一张失效卡再问一遍,F15-e② 禁)。 */
     lastRoundPresentedCard?: boolean | undefined;
     signal?: AbortSignal | undefined;
 }
 export declare function resolvePark(park: GatePark, ctx: ParkResolveCtx): Promise<ParkResolution>;
-/**
- * 驱动侧在**预算提交之后**判定触顶时的收场(对抗复审 r4 [high]①:有推进帧的轮次触顶必须等权威身份解析完 ——
- * 先呈 B、决 B,提交后仍是同一只 call 才收场;这一轮已经呈过卡,不再呈收场卡)。
- */
-export declare function stalledTerminal(park: GatePark, ctx: ParkResolveCtx, stalledRounds: number, lastStallReason: string | undefined, 
-/** 这一轮的决断有没有落地(r5 [medium]③):落地了就**不许**说「could not be answered」「still parked」—— 那是谎报。 */
-decidedThisRound: boolean, 
-/** 这一轮决断落在哪只 call(解析到的行身份):收场排水前先把**它**的扣留帧摘掉(r6 [medium]:两只同族 call 都在
- *  扣留、park 帧无可信身份时,决断臂刻意保守不摘,排水会把刚批准的那只当 abort 吐出)。 */
-decidedGatedCallId?: string | undefined): ParkResolution;
+export declare function stalledTerminal(park: GatePark, ctx: ParkResolveCtx, stalledRounds: number, lastStallReason: string | undefined, decidedThisRound: boolean, decidedGatedCallId?: string | undefined): ParkResolution;