@sema-agent/client-core 0.77.0 → 0.77.2

package/dist/subagent/engineCompactWire.d.ts

@@ -1,39 +1,5 @@
-/** Test/introspection hook(缺省 = 默认槽,与 0.44.0 逐字同)。 */
 export declare function isEngineCompactPending(sessionKey?: string): boolean;
-/**
- * Test hook: reset the cached capability (fresh engine / respawn)。
- *
- * 🔴 **只清能力面,绝不动 arm 台账**(异源对抗复审第四轮 [medium] 采纳,修回归):本口是**生产口**
- *    (引擎重启 / respawn 的能力失效),不是「取消用户的 /compact」。一度顺手加的 `pendingCompactKeys.clear()`
- *    会让「idle 时 `/compact` 回过 armed → 引擎 respawn → 下一条 run 不再压缩」——用户的命令无声蒸发,
- *    而且那是**默认槽**上的行为改变,与本批「单会话宿主逐字节零变化」的声明直接矛盾。
- *    要清 arm 走 {@link __resetEngineCompactArmForTests}(测试钩,生产面没有这个动作)。
- */
 export declare function resetManualCompactCapability(): void;
-/** 测试钩:清 arm 台账(module 级单例,同进程多组断言必须能清)。生产面**没有**这个动作。 */
 export declare function __resetEngineCompactArmForTests(): void;
-/**
- * The /compact command's live half. Mid-turn: fire now. Idle: arm for the next run bind.
- * Returns what it did (for the command's display line / tests). No-op ('offline') without a live
- * wire; 'unsupported' when the engine's capabilities said manualCompact:false ([488] TOC-local) —
- * the client-side projection compaction still runs, but the ENGINE session context does not shrink.
- *
- * 🔴 design/285 批 3(D7b):本族三处零参 `engineWireTarget()` 全部换成 `engineWireTargetFor(sessionKey)`。
- *    /compact 打的是**这个会话此刻在飞的那条 run**,不是某一行子代 —— owner 台账里没有它,所以槽键
- *    只能由调用方给(多会话宿主每个 REPL 面板一个槽)。缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
- * 📋 **带反证的驳回半场(异源对抗复审第三轮 [high] 的另一半,如实记)**:复审还要求把快照提前到
- *    **request(arm)那一拍**,理由是「arm 与 bind 之间槽可能被重绑,意图属于 A 却在 B 上执行」。
- *    **不采**,反证:arm 那一拍**根本没有 taskId** —— `/compact` 在 idle 下的语义是成文的
- *    「**这个槽的下一条 run**」(见本文件头注的 arm-then-fire 段),槽的身份就是 key 本身。
- *    槽真被重绑到另一台引擎时,「下一条 run」就在那台引擎上,压它才是意图;把 request 那一刻的
- *    target 冻下来反而会去压一台**已经不再跑这条会话**的引擎。⇒ 冻结的正确起点是**拿到 taskId 的
- *    那一拍**(bind),那之后的每一次延迟与重试都必须用同一份 —— 那正是上面这一条。
- *    现状由常驻钉 `B3-P31/R6i` 钉住(arm 之后换槽装配 ⇒ 发射打的是**换后**那台,且带换后的会话)。
- * 🔴 **一条动词的槽键必须一以贯之**(异源对抗复审 [high] 采纳):目标、`?session=`、**run id**
- *    (`activeEngineRunIdFor`)、**能力位**(per-baseUrl 分桶)、**arm 状态**(per-key 分桶)——
- *    五件全按同一个 key。只换其中几件就是**半 keyed 形**:那比换锚之前更坏(之前五件一致地错在同一个
- *    槽上,一眼可见;半 keyed 是「A 的 run id 发到 B 的服务器」「B 的 arm 被 A 的 bind 吃掉」这类只在
- *    多会话下现形的错)。这条正是 plan 决策链本批**豁免**的同一条理由 —— 那边整条链搬不动,这边搬得动。
- */
 export declare function requestEngineCompact(sessionKey?: string): 'fired' | 'armed' | 'offline' | 'unsupported';
 export declare function onEngineTaskBound(taskId: string, sessionKey?: string): void;

package/dist/subagent/engineCompactWire.js

@@ -1,71 +1,12 @@
-/**
- * ⇄ B6 批搬迁(2026-07-27,设计稿 §3 B6):cli `src/sema/engineCompactWire.ts` 整搬。
- *
- * 🔴 搬迁差分:
- *   · `wireConfig()`(六份手抄的**最后一份**,而且这一份已经多长了一行 principal 注释 ——
- *     漂移的活样本)→ `engineWireTarget()`;
- *   · `getActiveEngineTaskId()` → `activeEngineRunId()`(SessionPort);
- *   · `logForDebugging` → `hostLog('debug', …)`;
- *   · `setTimeout(...)+t.unref?.()` → `hostTimers()`(**本文件是 TimersPort 的第一个消费者**)。
- *     🔴 端没装 TimersPort 的后果**说清楚**:两处延迟发射(404 单次重试 / bind 后 1.5s 发射)
- *     会**整个不发生** —— `/compact` 在 idle armed 之后就再也不会真正打到引擎,而命令行显示的
- *     还是 'armed'。这不是「少个定时器」,是一条静默失效的功能腿。所以缺 port 时留 debug 日志,
- *     并且 `hostPortMisses()` 里能看见(端自检恒应为空)。
- *
- * ── 以下为原文件的领域说明(逐字保留)────────────────────────────────────────────────────────
- *
- * engineCompactWire — manual /compact reaches the ENGINE (K-1c), not just the client projection.
- *
- * Problem (clay dogfood 07-03): in live mode `/compact` ran only the CLIENT-side compaction (the local
- * message projection) — the engine session's context was never compacted, so the next turn still paid
- * the full window.
- *
- * Engine contract (service server.ts:1874, core 1.156 `TaskStream.compact()`):
- *   POST /v1/runs/:id/compact → 202; compaction runs at the next SAFE turn boundary and a
- *   `compacted{trigger:"manual"}` event rides the run's OWN stream. The verb only applies to a run LIVE
- *   on the replica — and `/compact` is typed while IDLE, when there is no live run. So the wire is
- *   arm-then-fire:
- *     - `/compact` mid-turn (active engine run bound)  → fire immediately against that run.
- *     - `/compact` idle → arm a pending flag; the host's run_started bind (onEngineTaskBound) fires it
- *       against the NEXT turn's run — the engine compacts at that turn's first safe boundary, exactly
- *       the semantics CC users expect ("everything before this point is summarized").
- *
- * SDK 0.0.52 长出 runs.compact verb(SDK 宪法迁移批)—— raw fetch 退役,改走 AgentClient
- * (engineWireSdk 工厂;baseUrl/token/principal 纪律与 live wire 同源)。Fire-and-forget + fail-soft
- * 语义不变:409/501/网络错都只留 debug 日志,端侧投影压缩仍是可见结果。
- * 迁移差分记账:①原 raw POST 无超时 → SDK 缺省 60s 预算(compact 是 202 即回的 arm verb,本地
- * 口毫秒级,纯上界改善);②404 单次 2s 延迟重试(早 header bind 跑赢 run-row 持久化)逐字保留。
- */
 import { hostLog, hostTimersFor } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
 import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
-/**
- * 🔴 **arm 状态按会话槽分桶**(design/285 批 3,异源对抗复审 [high] 采纳)。
- *
- * 修前是一个**进程级布尔**:`/compact` 在 B 会话上 idle-arm 之后,**先 bind 的那条会话**(可能是 A)
- * 会把它消费掉 —— B 要的压缩发到了 A 的 run 上(动了一条不相干会话的上下文),而 B 自己永远没压缩。
- * 单会话宿主上这两件事是同一件,keyed 化之后才第一次分得开。
- */
 const pendingCompactKeys = new Set();
-/** Test/introspection hook(缺省 = 默认槽,与 0.44.0 逐字同)。 */
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
-/**
- * [488] 定谳(2026-07-07 指纹探针,server 1.130.0):TOC 本地引擎(无 TiDB runStore)的
- * manual-compact verb 是 BY-DESIGN 501(handler 第一道闸 `!deps.runStore → 501`,capabilities
- * 也如实报 `manualCompact:false`)——之前端没消费这个 gate,verb 打过去 501 被 fire-and-forget
- * 吞掉,引擎 session 从未压缩=「静默 no-op」的真机理。这里 lazy 探一次 /v1/capabilities 并缓存;
- * false ⇒ requestEngineCompact 返回 'unsupported'(不再装作 armed/fired)。探测失败 fail-open
- * (null=未知 ⇒ 保持旧行为发 verb,错误面不变)。
- */
-// 🔴 **判定位与在途探测按 baseUrl 分桶**(design/285 批 3,异源对抗复审 [high] 采纳;与
-//    `engineCapsCache` / `engineSubagentOutput.capByBase` 同代)。修前是**进程级单值**:keyed 宿主上
-//    `requestEngineCompact('B')` 会拿**先探到的那台引擎**(可能是 A)的 `manualCompact` 位去决定要不要
-//    给 B 发 verb —— 一条动词的槽键必须一以贯之,目标/会话/run id/能力位缺一个都是半 keyed 形。
-//    ⚠️ 单会话宿主只有一个 baseUrl ⇒ 分桶后与 0.44.0 逐字同(同一个 base 仍是「探一次、缓存住」)。
 const manualCompactCapableByBase = new Map();
 const capabilitiesProbeByBase = new Map();
 function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
@@ -77,9 +18,6 @@ function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
         return;
     capabilitiesProbeByBase.set(base, (async () => {
         try {
-            // SDK 0.0.52 client.capabilities()(typed Capabilities.manualCompact)。5s 预算经 client
-            // timeoutMs(对抗复审 MED 原语义:hung engine 不 pin probe promise);非 2xx/网络错/超时 SDK
-            // 统一抛错 → 与原「non-200 也重试」同归 catch 删记号允许后续重试。
             const client = makeEngineWireClient({
                 baseUrl: base,
                 ...(cfg.token ? { token: cfg.token } : {}),
@@ -94,39 +32,21 @@ function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
             if (typeof caps.manualCompact === 'boolean')
                 manualCompactCapableByBase.set(base, caps.manualCompact);
             else
-                capabilitiesProbeByBase.delete(base); // shape we don't understand — retry later
+                capabilitiesProbeByBase.delete(base);
         }
         catch {
-            capabilitiesProbeByBase.delete(base); // non-2xx/network error/timeout: unknown stays fail-open, next call re-probes
+            capabilitiesProbeByBase.delete(base);
         }
     })());
 }
-/**
- * Test hook: reset the cached capability (fresh engine / respawn)。
- *
- * 🔴 **只清能力面,绝不动 arm 台账**(异源对抗复审第四轮 [medium] 采纳,修回归):本口是**生产口**
- *    (引擎重启 / respawn 的能力失效),不是「取消用户的 /compact」。一度顺手加的 `pendingCompactKeys.clear()`
- *    会让「idle 时 `/compact` 回过 armed → 引擎 respawn → 下一条 run 不再压缩」——用户的命令无声蒸发,
- *    而且那是**默认槽**上的行为改变,与本批「单会话宿主逐字节零变化」的声明直接矛盾。
- *    要清 arm 走 {@link __resetEngineCompactArmForTests}(测试钩,生产面没有这个动作)。
- */
 export function resetManualCompactCapability() {
     manualCompactCapableByBase.clear();
     capabilitiesProbeByBase.clear();
 }
-/** 测试钩:清 arm 台账(module 级单例,同进程多组断言必须能清)。生产面**没有**这个动作。 */
 export function __resetEngineCompactArmForTests() {
     pendingCompactKeys.clear();
 }
-/**
- * 延迟发射(`setTimeout` + `unref` 的 port 形)。缺 TimersPort ⇒ **不发射**并留日志 ——
- * 静默 drop 会让 `/compact` 看起来 armed 了却永不落地(见文件头)。
- */
 function deferFire(ms, fn, why, sessionKey) {
-    // 🔴 定时器也按本槽取(异源对抗复审第四轮 [medium] 采纳):零参 `hostTimers()` 读的是**默认槽** ——
-    //    按接入契约只走 `installHostFor(key, {timers})` 的 keyed-only 宿主在那里恒空 ⇒ 快照有效、arm 已划掉、
-    //    请求永远不发射。一条动词的槽键必须一以贯之,定时器是第六件。
-    //    (默认槽下 `hostTimersFor(DEFAULT_SESSION_KEY)` ≡ `hostTimers()`,逐字节等价。)
     const timers = hostTimersFor(sessionKey);
     if (!timers) {
         hostLog('debug', `engineCompactWire: no TimersPort — ${why} 不会发射(端漏装 port,/compact 这条腿静默失效)`);
@@ -135,7 +55,6 @@ function deferFire(ms, fn, why, sessionKey) {
     timers.setTimer(ms, fn);
     return true;
 }
-/** 按本槽冻一发;`null` = 那一刻没有 wire(与修前的 `!cfg` 早退同语义,只是提前到冻结那一拍)。 */
 function freezeCompactShot(taskId, sessionKey) {
     const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
@@ -151,9 +70,6 @@ function freezeCompactShot(taskId, sessionKey) {
     };
 }
 async function postCompact(shot, retriesLeft = 1) {
-    // SDK runs.compact(0.0.52)——POST /v1/runs/:id/compact body {}(无 instructions 时与原 '{}' 逐字
-    // 同 wire);header 姿势 = Transport buildHeaders(Bearer 仅有 token 时 + x-agent-principal +
-    // content-type),与原手抄同三头。🔴 三头与 `?session=` 全取**冻结的那一份**,绝不现读。
     const client = makeEngineWireClient({
         baseUrl: shot.baseUrl,
         ...(shot.token ? { token: shot.token } : {}),
@@ -170,9 +86,7 @@ async function postCompact(shot, retriesLeft = 1) {
         const status = e?.status;
         if (typeof status === 'number') {
             hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${status}`);
-            // 404 = the early header bind outran the run-row persist — one deferred retry covers it.
             if (status === 404 && retriesLeft > 0) {
-                // 重试用**同一份**冻结快照:重试窗内换了会话/换了引擎,旧 taskId 也绝不配新凭证。
                 deferFire(2000, () => void postCompact(shot, retriesLeft - 1), '404 单次重试', shot.sessionKey);
             }
             return;
@@ -180,39 +94,15 @@ async function postCompact(shot, retriesLeft = 1) {
         hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${String(e)}`);
     }
 }
-/**
- * The /compact command's live half. Mid-turn: fire now. Idle: arm for the next run bind.
- * Returns what it did (for the command's display line / tests). No-op ('offline') without a live
- * wire; 'unsupported' when the engine's capabilities said manualCompact:false ([488] TOC-local) —
- * the client-side projection compaction still runs, but the ENGINE session context does not shrink.
- *
- * 🔴 design/285 批 3(D7b):本族三处零参 `engineWireTarget()` 全部换成 `engineWireTargetFor(sessionKey)`。
- *    /compact 打的是**这个会话此刻在飞的那条 run**,不是某一行子代 —— owner 台账里没有它,所以槽键
- *    只能由调用方给(多会话宿主每个 REPL 面板一个槽)。缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
- * 📋 **带反证的驳回半场(异源对抗复审第三轮 [high] 的另一半,如实记)**:复审还要求把快照提前到
- *    **request(arm)那一拍**,理由是「arm 与 bind 之间槽可能被重绑,意图属于 A 却在 B 上执行」。
- *    **不采**,反证:arm 那一拍**根本没有 taskId** —— `/compact` 在 idle 下的语义是成文的
- *    「**这个槽的下一条 run**」(见本文件头注的 arm-then-fire 段),槽的身份就是 key 本身。
- *    槽真被重绑到另一台引擎时,「下一条 run」就在那台引擎上,压它才是意图;把 request 那一刻的
- *    target 冻下来反而会去压一台**已经不再跑这条会话**的引擎。⇒ 冻结的正确起点是**拿到 taskId 的
- *    那一拍**(bind),那之后的每一次延迟与重试都必须用同一份 —— 那正是上面这一条。
- *    现状由常驻钉 `B3-P31/R6i` 钉住(arm 之后换槽装配 ⇒ 发射打的是**换后**那台,且带换后的会话)。
- * 🔴 **一条动词的槽键必须一以贯之**(异源对抗复审 [high] 采纳):目标、`?session=`、**run id**
- *    (`activeEngineRunIdFor`)、**能力位**(per-baseUrl 分桶)、**arm 状态**(per-key 分桶)——
- *    五件全按同一个 key。只换其中几件就是**半 keyed 形**:那比换锚之前更坏(之前五件一致地错在同一个
- *    槽上,一眼可见;半 keyed 是「A 的 run id 发到 B 的服务器」「B 的 arm 被 A 的 bind 吃掉」这类只在
- *    多会话下现形的错)。这条正是 plan 决策链本批**豁免**的同一条理由 —— 那边整条链搬不动,这边搬得动。
- */
 export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
     const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
         return 'offline';
-    probeManualCompactCapability(sessionKey); // lazy, cached per baseUrl; first call may still ride the old path (fail-open)
+    probeManualCompactCapability(sessionKey);
     if (manualCompactCapableByBase.get(cfg.baseUrl) === false) {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }
-    // 🔴 run id 也按本槽取(异源对抗复审 [high]):写死默认槽 = 把 A 的 run id 发到 B 的服务器上。
     const taskId = activeEngineRunIdFor(sessionKey);
     if (taskId) {
         const shot = freezeCompactShot(taskId, sessionKey);
@@ -223,34 +113,14 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
     pendingCompactKeys.add(sessionKey);
     return 'armed';
 }
-/**
- * host run_started hook: a new engine run just bound. If a manual compact is pending, fire it —
- * the engine compacts at this turn's first safe boundary.
- *
- * Timing: the bind fires off the X-Task-Id RESPONSE HEADER — the earliest possible signal, which can
- * precede the server's run-row persist (a straight POST here raced it to a 404 in the live harness).
- * Compaction runs at the next safe TURN BOUNDARY anyway, so a short defer loses nothing; retry once
- * more for slow persists. Both shots are best-effort (postCompact never throws).
- */
 const BOUND_FIRE_DELAY_MS = 1500;
 export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY) {
-    probeManualCompactCapability(sessionKey); // warm the capability cache off the first turn bind, before any /compact
-    // 🔴 只消费**本槽**的 arm(异源对抗复审 [high]):进程级布尔会让先 bind 的那条会话把别人的 arm 吃掉 ——
-    //    B 要的压缩发到 A 的 run 上,而 B 自己永远没压缩。
+    probeManualCompactCapability(sessionKey);
     if (!pendingCompactKeys.has(sessionKey))
         return;
-    // 🔴 **在 bind 这一拍冻结**(异源对抗复审 [high]):延迟 1.5s 之后再现读 target/session,就会把
-    //    这一拍的 taskId 配上那一拍的引擎与会话。
-    // 🔴 **冻不出快照就不消费这一记 arm**(异源对抗复审第三轮 [high] 的可采半场):那一刻没有 wire
-    //    时,旧形是「先把 arm 划掉、再发现发不出去」= 用户的 `/compact` 无声蒸发,而命令行早就回过
-    //    'armed'。改成**冻出来了才划掉**:这一拍发不出就留着,下一次 bind 再兑现(arm-then-fire 的
-    //    本意就是「下一条 run」,不是「下一条 run 且那一刻恰好有 wire」)。
     const shot = freezeCompactShot(taskId, sessionKey);
     if (shot === null)
         return;
-    // 🔴 **登记上定时器才划掉 arm**(异源对抗复审第四轮 [medium]):端漏装 TimersPort 时 `deferFire`
-    //    只留一行日志就返回,先划掉 arm 就等于把用户的 `/compact` 无声吃掉(与上面那条同一个道理,
-    //    只是这一次挡的是「冻得出快照但排不上队」)。
     if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {
         pendingCompactKeys.delete(sessionKey);
     }

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -1,44 +1,13 @@
-/** 记一个子代行的转录锚(幂等;server <1.278 永不调用 = 台账恒空,取件腿整条静默不动)。 */
 export declare function recordEngineTranscriptId(taskId: string, transcriptId: string): void;
-/** 读面(取件腿 + 测试)。 */
 export declare function getEngineTranscriptId(taskId: string): string | undefined;
-/** 测试钩:清台账 + 在飞记号。 */
 export declare function __resetEngineDelegatedPromptForTests(): void;
-/**
- * content → 纯文本。tool_result 型正文返回 undefined —— 那是子代自己跑工具的回填,**不是**委派
- * prompt(这条判别就是「别把子代自己的消息当委派 prompt」的落点)。
- */
 export declare function delegatedPromptText(content: unknown): string | undefined;
-/**
- * 从转录里挑出委派 prompt = **最后一条非 tool_result 的 user 消息**(倒扫)。
- * 🔴 倒扫不是随手选的:fork 型子代的转录以**父会话历史**开头,正扫会拿到宿主自己的首轮提示
- * (live pty 实测的错答案);全新子会话型只有一条 user 文本消息,倒扫结果与正扫相同。
- */
 export declare function pickDelegatedPrompt(messages: readonly unknown[]): string | undefined;
-/** 读面注入点(离线测试用):替身返回转录窗口条目数组。 */
 type TranscriptWindowReader = (transcriptId: string) => Promise<readonly unknown[] | null>;
 export declare function __setTranscriptWindowReaderForTests(r: TranscriptWindowReader | null): void;
-/** `fetchDelegatedPrompt` 的结果 —— 三态,**端必须分得开**(见下面 outcome 的键注)。 */
 export interface DelegatedPromptFetch {
-    /** 挑到的委派 prompt;`undefined` = 没拿到(看 `outcome` 分清是哪种没拿到)。 */
     prompt?: string;
-    /**
-     * · `'hit'`        —— 拿到了,端可以落状态。
-     * · `'skipped'`    —— 无转录锚 / 已有在飞 ⇒ 端什么都别做(不是失败)。
-     * · `'unreadable'` —— 压根没读到(无 wire / 构造失败 / throw)⇒ **记号已撤**,下次可重试。
-     * · `'absent'`     —— 读成功但转录里挑不出委派 user 消息 ⇒ **定论**,记号保留,不再重复打读面。
-     *
-     * 🔴 `unreadable` 与 `absent` 分开是复审穷举第 5 条:混成一个会把「一次性取件」变成
-     *    「每次进查看态都打一发 `GET /v1/sessions/:id`」。
-     */
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
 }
-/**
- * 取一个后台子代行的**委派 prompt**(判定半场:防抖 + 取锚 + 读转录 + 挑正文)。
- * 幂等、fail-soft、绝不 throw。**不碰任何端状态** —— 落状态是端的事(见文件头拆缝说明)。
- *
- * 端侧用法(壳 `hydrateEngineAgentPrompt` shim):先自己判「这行是不是 local_agent、prompt 是不是
- * 已经有了」,是才调本函数;拿到 `outcome==='hit'` 再 `setState`。
- */
 export declare function fetchDelegatedPrompt(taskId: string): Promise<DelegatedPromptFetch>;
 export {};

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,78 +1,24 @@
-/**
- * ⇄ B6 批搬迁(2026-07-27,设计稿 §3 B6 + §2.5 拆缝表):cli `src/sema/engineDelegatedPrompt.ts` 的
- *    **判定半场** —— 转录锚台账(module 级)+ 委派 prompt 挑选规则 + 转录窗口读面 + 在飞防抖。
- *
- * 留在 TUI(**执行半场**):`hydrateEngineAgentPrompt` 里对 `AppState.tasks[taskId]` 的
- * `isLocalAgentTask` 判别 / `store.setState` 落 `prompt` / 查看态转录补插首条 user 消息 ——
- * 那三件读写的是**端的任务状态形状**(`LocalAgentTaskState`),web/桌面各有各的形。
- * 壳侧 shim 保留原函数名与签名,内部改成「调本包 `fetchDelegatedPrompt()` → 拿到串再 setState」。
- *
- * 🔴 **单实例纪律(这条是本文件搬迁的真正理由,不是顺手)**:`transcriptIdByTask` 是 module 级
- *    Map,**写者 = `fleetLedger` 的行帧/通知帧消费臂**(`recordEngineTranscriptId`),
- *    **读者 = 取件腿**。fleetLedger 已在本包内 ⇒ 台账若留在壳里就是「包写壳读」两份实例,
- *    取件腿恒读空、Prompt 段恒留白,而两边代码看着都对
- *    ([paired-mechanisms-must-share-premise] 同族失败形)。所以台账必须与写者同包。
- *
- * ── 以下为原文件的领域说明(逐字保留,它记着两条踩过的坑)────────────────────────────────────
- *
- * engineDelegatedPrompt — 后台子代**委派 prompt** 的取件腿(server 1.278.0 `transcriptId` 提货)。
- *
- * ── 缺陷形
- *   后台子代行是行帧 lane(fleet stream)投影出来的,行帧上**没有** prompt —— 于是
- *   `AsyncAgentDetailDialog` 的 `Prompt` 段恒空(row.prompt = '')。前台子代的 prompt 由
- *   `task_progress` tick 的绑定臂晚绑,后台子代整跑零 tick(tick lane 根本没通道),所以那条腿
- *   对它无效。
- *
- * ── 修法(不发明:server 1.278.0 在 fleet 行上加了 `transcriptId`)
- *   `transcriptId` = core 铸的**子代 childSessionId**(core subagent.js:`transcriptId: child.sessionId`)。
- *   它是**取件锚不是内容** —— 端凭它去 session 读面(`GET /v1/sessions/:id`,SDK
- *   `sessions.get`)取转录,从里面挑出委派 prompt。
- *
- * 🔴 取哪一条 —— **最后一条非 tool_result 的 user 消息**,不是第一条(live 一手取证订正):
- *   `fork` 型子代的 `child.sessionId` 是**父会话的 fork**(core subagent.js:1749
- *   `forkTranscriptId = child.sessionId ?? forkedId`),转录里先是**父会话的全部历史**,委派
- *   prompt 追加在 fork 点。所以「第一条 user 消息」拿到的是**宿主自己的首轮提示**——第一版就是
- *   这么写的,live pty 实测拉回 6869 字符(委派 prompt 只有 ~330),典型的「看起来很合理的错答案」。
- *   反过来,全新子会话型子代的转录里委派 prompt 是唯一一条 user 文本消息 —— 两种形状都满足
- *   「最后一条非 tool_result 的 user 消息」,所以倒扫是同时正确的那一条规则。
- *   (`tool_result` 型 user 条目 = 子代自己跑工具的回填,必须跳过。)
- *   窗口取 `tail=N`(转录尾部)+ `blobCap`:委派 prompt 在尾部方向,而 `messages` 整段可以非常大。
- *   诚实边界:子代被 steer 过(steerSubagent 注入 user 消息)时倒扫会拿到最新那条指令 —— 已记账,
- *   wire 上没有「哪条是委派」的标,端不猜。
- *
- * 诚实边界:拉不到 / 没有 transcriptId / 读面 501/404 ⇒ **什么都不写**,Prompt 段维持留白。
- * 绝不用「子代的首条输出」或行描述冒充委派 prompt(那是把一个看起来合理的错答案摆上屏)。
- * 一切失败 fail-soft,绝不 throw。
- */
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
-/** 只拉转录**尾部**这么多条(委派 prompt 在尾部方向;见文件头的 fork 形状订正)。 */
 const TAIL_WINDOW = 200;
-/** 单条正文的上限:详情页自己还会截到 300 字符,这里只防拉回一个巨型 blob。 */
 const BLOB_CAP = 8 * 1024;
-// ── 转录锚台账(module-level:footer/REPL 谁重挂都不丢;写者=行帧消费臂)───────────────────────
 const transcriptIdByTask = new Map();
-/** 记一个子代行的转录锚(幂等;server <1.278 永不调用 = 台账恒空,取件腿整条静默不动)。 */
 export function recordEngineTranscriptId(taskId, transcriptId) {
     if (!taskId || !transcriptId)
         return;
     transcriptIdByTask.set(taskId, transcriptId);
 }
-/** 读面(取件腿 + 测试)。 */
 export function getEngineTranscriptId(taskId) {
     return transcriptIdByTask.get(taskId);
 }
-/** 测试钩:清台账 + 在飞记号。 */
 export function __resetEngineDelegatedPromptForTests() {
     transcriptIdByTask.clear();
     promptHydrateInFlight.clear();
 }
-/** 每 task 一次在飞防抖;拉不到即撤记号,下次进入查看态可重试(副本重启/瞬态 404)。 */
 const promptHydrateInFlight = new Set();
-/** 一条转录条目的 role(permissive:`role` 或 CC jsonl 形的 `type`)。 */
 function roleOf(entry) {
     if (typeof entry !== 'object' || entry === null)
         return undefined;
@@ -81,7 +27,6 @@ function roleOf(entry) {
         return e.role;
     if (typeof e.type === 'string')
         return e.type;
-    // CC jsonl 形:{type:'user', message:{role:'user', content}}
     if (typeof e.message === 'object' && e.message !== null) {
         const m = e.message;
         if (typeof m.role === 'string')
@@ -89,7 +34,6 @@ function roleOf(entry) {
     }
     return undefined;
 }
-/** 一条转录条目的正文 content(permissive:直挂 或 嵌在 `message` 里)。 */
 function contentOf(entry) {
     if (typeof entry !== 'object' || entry === null)
         return undefined;
@@ -101,13 +45,7 @@ function contentOf(entry) {
     }
     return undefined;
 }
-/**
- * content → 纯文本。tool_result 型正文返回 undefined —— 那是子代自己跑工具的回填,**不是**委派
- * prompt(这条判别就是「别把子代自己的消息当委派 prompt」的落点)。
- */
 export function delegatedPromptText(content) {
-    // 字符串形也要过信封剥离 —— 这条早退曾经绕过它(自家红测抓到:剥的是数组形,而真转录里
-    // 两种形都出现)。任何「返回 prompt 正文」的出口都必须经同一道剥离,否则就是半修。
     if (typeof content === 'string')
         return stripEnvelopes(content);
     if (!Array.isArray(content))
@@ -122,31 +60,12 @@ export function delegatedPromptText(content) {
             continue;
         const b = block;
         if (b.type === 'tool_result')
-            return undefined; // 子代自己的工具回填,不是委派 prompt
+            return undefined;
         if (b.type === 'text' && typeof b.text === 'string')
             parts.push(b.text);
     }
     return stripEnvelopes(parts.join('\n'));
 }
-/**
- * 剥掉委派 prompt 外面那两层**运行时信封**,再判空。
- *
- * 🔴 为什么必须剥(2026-08-01 真机实测):引擎会话里那条 user 消息的前 ~1330 字符是
- * `<system-reminder>…技能不可用清单…</system-reminder>` 与 `<fork-boilerplate>…worker fork 交代…
- * </fork-boilerplate>` 两层信封,真正的委派 prompt 排在后面。而详情页的 `displayPrompt` 只渲**前 300
- * 字符** ⇒ 用户在「Prompt」标题下看到的是一份技能清单,不是他派下去的那句话。
- *
- * 判空也必须在剥完之后做:只有信封、没有正文的消息应当算**没有委派 prompt**(让取件腿如实留白),
- * 而不是把信封当成 prompt 渲出去 —— 后者是「渲了个东西」冒充「渲对了东西」。
- *
- * 信封是**成对标签**,所以用配对正则整段剥;不配对(被截断等)时保守不动,宁可多渲也不吃掉正文。
- */
-// 🔴 件⑦([4974],2026-08-22):`system-reminder` 的**开标签带属性**(core ≥5.46 恒带
-//    `mark="<22 位 base64url>"`),精确形 `<system-reminder>` 整段剥不掉 ⇒ 上面那条 2026-08-01
-//    修过的 bug 原样复发(详情页 Prompt 又变回技能清单)。剥壳口径收进包内单一闸口
-//    `systemReminderTag`(同根因的另一座位是 `classifierVerdictWire`,见该模块头注)。
-//    `fork-boilerplate` 是 core `agents/subagent.js` 里的**裸**标签(dist 直证),保持精确形 ——
-//    没有属性的标签不需要属性容忍,给它加 = 给伪造面白让一寸。
 const PROMPT_ENVELOPE_EXACT_TAGS = ['fork-boilerplate'];
 function stripEnvelopes(raw) {
     let text = stripSystemReminderBlocks(raw);
@@ -155,11 +74,6 @@ function stripEnvelopes(raw) {
     }
     return text.trim() || undefined;
 }
-/**
- * 从转录里挑出委派 prompt = **最后一条非 tool_result 的 user 消息**(倒扫)。
- * 🔴 倒扫不是随手选的:fork 型子代的转录以**父会话历史**开头,正扫会拿到宿主自己的首轮提示
- * (live pty 实测的错答案);全新子会话型只有一条 user 文本消息,倒扫结果与正扫相同。
- */
 export function pickDelegatedPrompt(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const entry = messages[i];
@@ -178,10 +92,6 @@ export function __setTranscriptWindowReaderForTests(r) {
 async function readTranscriptWindow(transcriptId, sessionKey) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
-    // 🔴 B6:六份手抄 `wireConfig()` 收成 `engineWireTarget()`(env 读经 hostEnv,本包零 process)。
-    // 🔴 design/285 批 3(D7b):零参形写死默认槽 —— 转录取件是**按行**的读面(锚 = 这一行登记的
-    //    transcriptId),所以 baseUrl/token/principal 必须按**这一行所属的槽**取,否则 keyed 宿主上
-    //    会拿 A 槽的凭证去 `GET /v1/sessions/:id` 读 B 槽的转录(404,或更坏:读到同 id 的别人)。
     const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
         return null;
@@ -192,8 +102,6 @@ async function readTranscriptWindow(transcriptId, sessionKey) {
     });
     if (!client)
         return null;
-    // 窗口读:`tail=N` = 转录**尾部** N 条(server ≥1.162)。老引擎忽略 query 返回全量 ——
-    // 倒扫规则对全量同样正确,只是多传了点字节(行为等价)。
     const rec = await client.sessions.get(transcriptId, {
         tail: TAIL_WINDOW,
         blobCap: BLOB_CAP,
@@ -201,13 +109,6 @@ async function readTranscriptWindow(transcriptId, sessionKey) {
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
-/**
- * 取一个后台子代行的**委派 prompt**(判定半场:防抖 + 取锚 + 读转录 + 挑正文)。
- * 幂等、fail-soft、绝不 throw。**不碰任何端状态** —— 落状态是端的事(见文件头拆缝说明)。
- *
- * 端侧用法(壳 `hydrateEngineAgentPrompt` shim):先自己判「这行是不是 local_agent、prompt 是不是
- * 已经有了」,是才调本函数;拿到 `outcome==='hit'` 再 `setState`。
- */
 export async function fetchDelegatedPrompt(taskId) {
     if (promptHydrateInFlight.has(taskId))
         return { outcome: 'skipped' };
@@ -217,7 +118,6 @@ export async function fetchDelegatedPrompt(taskId) {
     promptHydrateInFlight.add(taskId);
     let msgs = null;
     try {
-        // 槽键取自 owner 台账的这一行(缺席 ⇒ DEFAULT_SESSION_KEY ⇒ 与 0.44.0 逐字同)。
         msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key);
     }
     catch (e) {
@@ -232,8 +132,6 @@ export async function fetchDelegatedPrompt(taskId) {
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId}: ${msgs === null ? 'transcript unreadable (retryable)' : 'no delegated user message (final)'}`);
         return { outcome: msgs === null ? 'unreadable' : 'absent' };
     }
-    // 诊断锚(SEMA_DEBUG 才落盘):字符数 + 头 60 字符 —— 「拿到的到底是委派 prompt 还是
-    // fork 转录里宿主自己的首轮提示」只有看得见正文头才分得开(第一版倒在这上面)。
     hostLog('debug', `[delegated-prompt] ${taskId} <- transcript ${transcriptId} (${prompt.length} chars) head=${JSON.stringify(prompt.slice(0, 60))}`);
     return { prompt, outcome: 'hit' };
 }

package/dist/subagent/engineRowStopGate.d.ts

@@ -1,25 +1,5 @@
-/** 引擎 bridge 从 `task_progress` tick / fleet 行帧建的行(module-level:footer 重挂不丢归属)。 */
 export declare const engineOwnedRowIds: Set<string>;
-/** fleet 树 enter 时为「面板无行的 fleet 行」stub 出来的纯查看载体行。 */
 export declare const fleetViewStubRowIds: Set<string>;
-/** 这一行的真身在引擎里(本地 abortController 管不到它)。 */
 export declare function isEngineViewRow(taskId: string): boolean;
-/**
- * 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。
- *
- * 🔴 design/285 批 3(D7b):零参 `engineWireTarget()` 换成 `engineWireTargetFor(sessionKey)`。
- *    caps 缓存按 **baseUrl** 分桶,而 keyed 多会话宿主每槽一个 baseUrl —— 写死默认槽 = 用 A 引擎的
- *    能力位去判 B 引擎能不能停行。本模块是**零依赖叶**(单实例纪律见头注),不许 import 台账,
- *    所以槽键由调用方给;缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
- */
 export declare function engineTaskHandlesCapable(sessionKey?: string): boolean;
-/**
- * 停这一行**必须先拿到引擎回执**吗?
- *
- * true  ⇒ 行的执行者是引擎,端写 `killed` 是一句它没证实过的断言 —— 必须 `POST …/stop` 拿到 200
- *         才翻;409 `stop.not_landed` / `stop.not_local` / `stop.parked` 一律保持原状(引擎里
- *         可能还在跑),下一拍由行帧/`stopped-by` 归因 settle([1754]③)。
- * false ⇒ 行跑在本进程(CC 逐字形态),`abortController.abort()` 就是执行本身,端写 `killed`
- *         按构造恒真 ⇒ 同步翻,与 CC 2.1.220 `UPd`(pretty220.js:507299)一字不差。
- */
 export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string): boolean;

package/dist/subagent/engineRowStopGate.js

@@ -1,63 +1,14 @@
-/**
- * ⇄ B6 批搬迁(2026-07-27,设计稿 §3 B6):cli `src/sema/engineRowStopGate.ts` 整搬。
- *    唯一差分 = `process.env.SEMA_LIVE_BASEURL` → `engineWireTarget()?.baseUrl`
- *    (本包零 `process`;Node 宿主下 `hostEnv()` 返回的就是 `process.env` 同一对象 ⇒ 取值相同。
- *    **超集**:非 Node 宿主可用 `installEngineWireTarget()` 显式装,此前那条腿恒 false)。
- *
- * 🔴 单实例纪律(本文件两个 module 级 Set 都是判据真源):
- *   `engineOwnedRowIds` 写者 = 引擎 bridge 的 `task_progress` tick / fleet 行帧臂;
- *   `fleetViewStubRowIds` 写者 = fleet 树 enter 的 stub 造行处;
- *   读者 = 批量停/单行停的同步分诊。两份实例 ⇒ 分诊恒判「纯本地行」⇒ 引擎侧行被壳直接写
- *   `killed` 而引擎里还在跑 = [1754]③ 那类「壳说了一句它没证实过的话」。
- *
- * ── 以下为原文件的领域说明(逐字保留)────────────────────────────────────────────────────────
- *
- * engineRowStopGate — 「这一行是引擎侧的吗 / 停它要不要等引擎回执」的**同步**判别叶模块(#98)。
- *
- * 为什么单独一个叶模块:批量停(`ctrl+x ctrl+k` → `killAllRunningAgentTasks`)必须在**同步**
- * 那一拍就把行分成两半 —— 纯本地行照 CC 逐字立刻翻 `killed`(CC 的 markNotified→kill 顺序不容
- * 插入一个 await,否则 runner 自己的完成通知会抢在 markNotified 前面发出去),引擎侧行才走
- * 「等 200 再翻」。而原先这两个判据分别住在 `engineAgentView`(拉 React/ink/transcript 全图)和
- * `engineTaskHandleWire`(拉 SDK),`LocalAgentTask` 静态 import 任一都是循环依赖风险 —— 所以此前
- * 只能 `await import(...)`,分类天然异步。把判据本身下沉成零依赖叶(只依赖同样零依赖的
- * `engineCapsCache`),两边改成 re-export,判据单一真源不变,调用方拿到同步口。
- *
- * 🔴 语义与单行 `x`(BackgroundTasksDialog.killEngineAwareAgentTask)必须逐字一致:
- *   引擎视图行 ∧ `capabilities.taskHandles` 在场 → 发真停止动词、**只有 200 才翻行**;
- *   缺任一(老引擎 / 无 wire / 纯本地 AgentTool 行) → 回落旧行为(本地 abort 即真停,立即翻)。
- */
 import { engineCapTrue } from '../engineCapsCache.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
-/** 引擎 bridge 从 `task_progress` tick / fleet 行帧建的行(module-level:footer 重挂不丢归属)。 */
 export const engineOwnedRowIds = new Set();
-/** fleet 树 enter 时为「面板无行的 fleet 行」stub 出来的纯查看载体行。 */
 export const fleetViewStubRowIds = new Set();
-/** 这一行的真身在引擎里(本地 abortController 管不到它)。 */
 export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
-/**
- * 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。
- *
- * 🔴 design/285 批 3(D7b):零参 `engineWireTarget()` 换成 `engineWireTargetFor(sessionKey)`。
- *    caps 缓存按 **baseUrl** 分桶,而 keyed 多会话宿主每槽一个 baseUrl —— 写死默认槽 = 用 A 引擎的
- *    能力位去判 B 引擎能不能停行。本模块是**零依赖叶**(单实例纪律见头注),不许 import 台账,
- *    所以槽键由调用方给;缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
- */
 export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY) {
     return engineCapTrue(engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
 }
-/**
- * 停这一行**必须先拿到引擎回执**吗?
- *
- * true  ⇒ 行的执行者是引擎,端写 `killed` 是一句它没证实过的断言 —— 必须 `POST …/stop` 拿到 200
- *         才翻;409 `stop.not_landed` / `stop.not_local` / `stop.parked` 一律保持原状(引擎里
- *         可能还在跑),下一拍由行帧/`stopped-by` 归因 settle([1754]③)。
- * false ⇒ 行跑在本进程(CC 逐字形态),`abortController.abort()` 就是执行本身,端写 `killed`
- *         按构造恒真 ⇒ 同步翻,与 CC 2.1.220 `UPd`(pretty220.js:507299)一字不差。
- */
 export function engineRowNeedsStopConfirm(taskId, sessionKey) {
-    // `sessionKey` additive(design/285 批 3):keyed 宿主把这一行所属的槽传下来;缺省 = 默认槽。
     return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY);
 }

package/dist/subagent/engineSubagentOutput.d.ts

@@ -1,15 +1,8 @@
-/** 测试钩:清 caps 缓存。 */
 export declare function __resetSubagentOutputCapCacheForTests(): void;
 export interface EngineSubagentReport {
-    /** 子代最终 assistant 正文(server 对 running 态给状态文本——由 status 区分)。 */
     content: string;
-    /** output.status 原样(completed/failed/killed/running…;undefined = wire 未带)。 */
     status?: string;
 }
-/**
- * 拉取一个后台子代的终报正文。null = 读不到(无 wire / caps 缺 / 404 域外或副本重启 / 网错)——
- * 调用方回落 bg 事实渲染。绝不 throw。
- */
 export declare function fetchEngineSubagentReport(taskId: string, opts?: {
     signal?: AbortSignal;
 }): Promise<EngineSubagentReport | null>;