@sema-agent/client-core 0.74.1 → 0.74.3

package/dist/engineAgentPanelStore.js

@@ -88,7 +88,227 @@ export function isStaleEngineAgentPanelEnd(end, current) {
         return es < cs;
     return false;
 }
+// ── 0.74.3 CC-70:子代身份归一(所有 lane 的唯一漏斗)────────────────────────────────────────
+//
+// 病(cli L-407 / test 定谳,三端同撞):同一个后台子代在 wire 上有**两把身份** —— fleet 行 id 尾段(17 位,= 注册表 task_id
+// = 壳本地 agentId,core #948 按构造)与主流 `task_progress.taskId`(引擎 UUIDv7 = transcriptId = childSessionId)。本包的
+// `fleet-row` / 通知 `end` 用前者,tick / 流内 close 臂的 `end` 用后者 ⇒ 壳面板按 `ev.taskId` 落 Map 长成两行;包内常驻标也是
+// 「UUID 记、17 位清」永不清。修法 = 在这一只漏斗里把 tick / end 的 `taskId` 归一到 fleet 尾段(消费端零改):
+//   · 钥匙两把,fleet-row 一到就登记:`transcriptId → 尾段`(主)、`parentToolCallId → 尾段`(退路);
+//   · 查得到 ⇒ 改写 `taskId`,原词进 `wireTaskId`,`taskIdOrigin:'fleet-row'`;常驻标若记在 UUID 下随之迁移;
+//   · 查不到:绑卡的 tick(同步委派,`cardBound`)直发;未绑的 tick **缓一拍**等 fleet-row(常态 fleet-row 先到几十秒,但非保证)——
+//     触发 = 同 UUID 的 fleet-row 到(归一发)/ 同 UUID 第二条 tick(新的原样发,旧的丢)/ 同 UUID `end`(先 tick 后 end 原样发)/
+//     缓冲满(最旧的原样发);原样发的带 `taskIdOrigin:'wire'`。🔴 `sweep` **不放**缓着的 tick:那条 tick 还没有行,sweep 没有东西可结;
+//     在「tick 先到、父 turn 先结、行帧后到」的窗里放出去反而把 UUID 行造出来、接着行帧再造第二行 —— 正是要修的病。
+//   · 两张钥匙表与缓一拍都有界(常量),溢出先进先出 —— 上限是内存约束不是语义,超出只退化成「原样发」;
+//   · 缓一拍还按**节拍**有界(异源复审 R1 [medium]):别的 fleet-row / end / sweep 每过一条算一拍(别的 tick 不算 —— 它说明不了行帧车道
+//     活不活,一阵子代同时起步时也不该互相挤),过 MAX_HELD_WIRE_TICK_BEATS 拍还没等到自己的行帧 ⇒ 原样放(store 无计时器,拍是唯一可数的时间);
+//   · 钥匙带**周期身份**(复审 R1 [high]):行帧登记时连 cycleSeq / startedAt 一起记,归一后的 end 若自己不带周期就借钥匙上的
+//     (流内 close 臂的 end 恒不带)—— 复活后旧 transcriptId 的钥匙仍在,迟到的 end{旧 UUID} 归一后带着旧代际,
+//     isStaleEngineAgentPanelEnd 才判得出它是前代;
+//   · tick 经退路键(parentToolCallId)归一时,顺手把 UUID → 尾段 记进主表(复审 R1 [high]):随后的 end{UUID} 不带 parentToolCallId,
+//     没有这一步它永远归不了一。
+/** 钥匙表上限(LRU:命中即续命,真在飞的子代不会被一阵新登记挤掉;超出只退化成「原样发」)。 */
+const MAX_IDENTITY_KEYS = 2048;
+const MAX_HELD_WIRE_TICKS = 64;
+/** 缓一拍的节拍上限:别的 fleet-row / end / sweep 每过一条算一拍(别的 tick 不算)。 */
+export const MAX_HELD_WIRE_TICK_BEATS = 16;
+const fleetIdByTranscriptId = new Map();
+const fleetIdByParentToolCallId = new Map();
+const heldWireTicks = new Map();
+/** 每个 fleet 尾段最近一条行帧带的周期身份(在场才记):清常驻标时用它判「这条终态是不是前代的」(异源复审 R3 [high])。 */
+const latestCycleByFleetId = new Map();
+function remember(map, key, alias) {
+    map.delete(key);
+    map.set(key, alias);
+    if (map.size > MAX_IDENTITY_KEYS) {
+        const oldest = map.keys().next().value;
+        if (oldest !== undefined)
+            map.delete(oldest);
+    }
+}
+/**
+ * 0.74.3 CC-70:把 wire 上的子代 id(task_progress 的 UUID)反查成 fleet 行 id 尾段;`transcriptId` 表优先,退 `parentToolCallId` 表;
+ * 都查不到 ⇒ 原样(`origin:'wire'`)。fleet 尾段本身传进来也原样(它就是目标键)。
+ */
+export function resolveEnginePanelTaskId(wireTaskId, parentToolCallId) {
+    const byTranscript = fleetIdByTranscriptId.get(wireTaskId);
+    if (byTranscript !== undefined) {
+        remember(fleetIdByTranscriptId, wireTaskId, byTranscript); // LRU 续命(异源复审 R2 [high]:FIFO 会把仍在飞的子代挤掉)
+        return identityOf(byTranscript);
+    }
+    const byParent = parentToolCallId !== undefined ? fleetIdByParentToolCallId.get(parentToolCallId) : undefined;
+    if (byParent !== undefined) {
+        remember(fleetIdByParentToolCallId, parentToolCallId, byParent);
+        return identityOf(byParent);
+    }
+    return { taskId: wireTaskId, origin: 'wire' };
+}
+function identityOf(alias) {
+    return {
+        taskId: alias.fleetId,
+        origin: 'fleet-row',
+        ...(alias.cycleSeq !== undefined ? { cycleSeq: alias.cycleSeq } : {}),
+        ...(alias.startedAt !== undefined ? { startedAt: alias.startedAt } : {}),
+    };
+}
+/** 经退路键归一的 tick:把 UUID → 尾段 记进主表,随后不带 parentToolCallId 的 end{UUID} 才归得了一。 */
+function rememberResolvedWire(wireTaskId, id) {
+    if (fleetIdByTranscriptId.has(wireTaskId))
+        return;
+    remember(fleetIdByTranscriptId, wireTaskId, {
+        fleetId: id.taskId,
+        ...(id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
+        ...(id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
+    });
+}
+/** 别的事件过了一拍:缓着的 tick 各记一拍,过上限的原样放出(先进先出)。 */
+function ageHeld(except) {
+    for (const [wireId, held] of [...heldWireTicks]) {
+        if (wireId === except)
+            continue;
+        held.beats += 1;
+        if (held.beats >= MAX_HELD_WIRE_TICK_BEATS) {
+            heldWireTicks.delete(wireId);
+            deliverEngineAgentPanelEvent(asIsTick(held.ev));
+        }
+    }
+}
+function migrateResidency(wireTaskId, fleetId) {
+    if (wireTaskId !== fleetId && residentTaskIds.has(wireTaskId)) {
+        residentTaskIds.delete(wireTaskId);
+        residentTaskIds.add(fleetId);
+    }
+}
+function normalizedTick(ev, fleetId) {
+    const { cardBound: _cardBound, ...rest } = ev;
+    void _cardBound;
+    migrateResidency(ev.taskId, fleetId);
+    return { ...rest, taskId: fleetId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row' };
+}
+function asIsTick(ev) {
+    const { cardBound: _cardBound, ...rest } = ev;
+    void _cardBound;
+    return { ...rest, taskIdOrigin: 'wire' };
+}
+function flushHeld(wireTaskId) {
+    const held = heldWireTicks.get(wireTaskId);
+    if (held === undefined)
+        return;
+    heldWireTicks.delete(wireTaskId);
+    const id = resolveEnginePanelTaskId(held.ev.taskId, held.ev.parentToolCallId);
+    if (id.origin === 'fleet-row')
+        rememberResolvedWire(held.ev.taskId, id);
+    deliverEngineAgentPanelEvent(id.origin === 'fleet-row' ? normalizedTick(held.ev, id.taskId) : asIsTick(held.ev));
+}
+/**
+ * 0.74.3 CC-70(异源复审 R3 [high]):按 wire 上的子代 id 清常驻标 —— 原键照清;归一到 fleet 尾段的那把键**只在这条终态属当代时**才清:
+ * 复活后迟到的前代终态(旧 UUID 的流内 close / 终态 tick)归一后带旧代际,清了尾段键 = 撤掉复活行的 sweep 保护 ⇒ 下一次 sweep 假结它。
+ * 判据与 `end` 的陈旧判据同一只(`isStaleEngineAgentPanelEnd`,拿钥匙上的周期对最近一条行帧的周期);判不出 ⇒ 照清(不因缺席留下永久常驻)。
+ */
+export function clearEnginePanelTaskResidentByWire(wireTaskId) {
+    residentTaskIds.delete(wireTaskId);
+    const id = resolveEnginePanelTaskId(wireTaskId);
+    if (id.taskId === wireTaskId)
+        return;
+    if (isStaleEngineAgentPanelEnd(id, latestCycleByFleetId.get(id.taskId)))
+        return;
+    residentTaskIds.delete(id.taskId);
+}
+/** 测试钩:清两张钥匙表、缓一拍与周期水位。 */
+export function __resetEngineAgentPanelIdentityForTests() {
+    fleetIdByTranscriptId.clear();
+    fleetIdByParentToolCallId.clear();
+    heldWireTicks.clear();
+    latestCycleByFleetId.clear();
+}
+/** 宿主的唯一发布口(三条 lane 都经这里):先归一身份,再进主通道(订阅者 / 缓冲)。 */
 export function publishEngineAgentPanelEvent(ev) {
+    // 行帧先登记、先放自己匹配的 tick,再给别的缓着的 tick 记拍(异源复审 R2 [high]:先记拍会让第 16 拍那条正好是自己行帧的 tick 过期);
+    // end / sweep 没有「自己的」匹配 ⇒ 先记拍。
+    if (ev.kind === 'end' || ev.kind === 'sweep')
+        ageHeld(ev.kind === 'sweep' ? undefined : ev.taskId);
+    switch (ev.kind) {
+        case 'fleet-row': {
+            const alias = {
+                fleetId: ev.taskId,
+                ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}),
+                ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}),
+            };
+            if (alias.cycleSeq !== undefined || alias.startedAt !== undefined) {
+                latestCycleByFleetId.delete(ev.taskId);
+                latestCycleByFleetId.set(ev.taskId, { ...(alias.cycleSeq !== undefined ? { cycleSeq: alias.cycleSeq } : {}), ...(alias.startedAt !== undefined ? { startedAt: alias.startedAt } : {}) });
+                if (latestCycleByFleetId.size > MAX_IDENTITY_KEYS) {
+                    const oldest = latestCycleByFleetId.keys().next().value;
+                    if (oldest !== undefined)
+                        latestCycleByFleetId.delete(oldest);
+                }
+            }
+            if (ev.transcriptId !== undefined && ev.transcriptId.length > 0)
+                remember(fleetIdByTranscriptId, ev.transcriptId, alias);
+            if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
+                remember(fleetIdByParentToolCallId, ev.parentToolCallId, alias);
+            // 先发行帧再放缓着的 tick:tick 一到 fleet lane 就永久让位,行帧说的话(transcriptId / startedAt)得先落在行上。
+            deliverEngineAgentPanelEvent(ev);
+            for (const [wireId, held] of [...heldWireTicks]) {
+                if (wireId === ev.transcriptId || (held.ev.parentToolCallId !== undefined && held.ev.parentToolCallId === ev.parentToolCallId))
+                    flushHeld(wireId);
+            }
+            ageHeld(undefined);
+            return;
+        }
+        case 'tick': {
+            const id = resolveEnginePanelTaskId(ev.taskId, ev.parentToolCallId);
+            if (id.origin === 'fleet-row') {
+                heldWireTicks.delete(ev.taskId);
+                rememberResolvedWire(ev.taskId, id);
+                deliverEngineAgentPanelEvent(normalizedTick(ev, id.taskId));
+                return;
+            }
+            if (ev.cardBound === true) {
+                deliverEngineAgentPanelEvent(asIsTick(ev));
+                return;
+            }
+            if (heldWireTicks.has(ev.taskId)) {
+                // 第二拍还没等到 fleet-row ⇒ 不再等:新的原样发,旧的丢(progress 合并语义,旧拍没有信息)。
+                heldWireTicks.delete(ev.taskId);
+                deliverEngineAgentPanelEvent(asIsTick(ev));
+                return;
+            }
+            if (heldWireTicks.size >= MAX_HELD_WIRE_TICKS) {
+                const oldest = heldWireTicks.keys().next().value;
+                if (oldest !== undefined)
+                    flushHeld(oldest);
+            }
+            heldWireTicks.set(ev.taskId, { ev, beats: 0 });
+            return;
+        }
+        case 'end': {
+            const id = resolveEnginePanelTaskId(ev.taskId);
+            if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
+                flushHeld(ev.taskId); // 同 UUID 还缓着一条 tick ⇒ 先归一放出(行先有最后一拍的数字与名字),再结
+                migrateResidency(ev.taskId, id.taskId);
+                deliverEngineAgentPanelEvent({
+                    ...ev,
+                    taskId: id.taskId,
+                    wireTaskId: ev.taskId,
+                    taskIdOrigin: 'fleet-row',
+                    // end 自己不带周期身份(流内 close 臂恒不带)⇒ 借钥匙上的:复活后迟到的 end{旧 UUID} 由此带着旧代际,消费端按 isStaleEngineAgentPanelEnd 挡掉
+                    ...(ev.cycleSeq === undefined && id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
+                    ...(ev.startedAt === undefined && id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
+                });
+                return;
+            }
+            flushHeld(ev.taskId); // 缓着的 tick 先落行,终态才有行可结
+            deliverEngineAgentPanelEvent(ev);
+            return;
+        }
+        default:
+            // sweep:缓着的 tick 不放(见头注)—— 原样进主通道。
+            deliverEngineAgentPanelEvent(ev);
+    }
+}
+function deliverEngineAgentPanelEvent(ev) {
     // 同 taskId 的任何主通道事实(tick / fleet-row = 行在场;end = 真终态)都让**缓冲里**那条缺席过期 —— 迟订阅的消费者
     // 不许先恢复了行、再被一条旧缺席标成 unknown(已递达订阅者的缺席由订阅者按契约在这些事件上撤标)。
     if (ev.kind !== 'sweep')

package/dist/engineCapsGenerationGuard.d.ts

@@ -0,0 +1,6 @@
+/** 调用方 `opts.generation` 的一次性快照;`null` = 读不出(供给坏了)。 */
+export declare function snapshotCapsGeneration(opts: {
+    generation?: number;
+} | undefined): number | undefined | null;
+/** 入口快照的代际是否仍是当代;`gen` 缺席 = 调用方没供代际 = 恒当代;读代际抛出 = 不是。 */
+export declare function capsGenerationStillCurrent(baseUrl: string, gen: number | undefined): boolean;

package/dist/engineCapsGenerationGuard.js

@@ -0,0 +1,30 @@
+/**
+ * engineCapsGenerationGuard — 六只能力位读器 tee 共用的**代际两问**(0.74.2;不出公面,只供包内 import)。
+ *
+ *  · {@link snapshotCapsGeneration}:从调用方 `opts` 上**一次性**读代际。`opts` 是调用方的对象,回体上的 getter 能在投影中途改它、
+ *    也能让这一次读抛出 ⇒ 读不出答 `null`(tee 按「不动格」处置),别把调用方对象再读第二次。
+ *  · {@link capsGenerationStillCurrent}:入口快照的代际现在还是不是当代。读代际抛出 ⇒ `false`(不动格,与陈旧代际同一处置)。
+ *
+ * 两只都**带值返回**而不是吞掉:tee 里因此没有一处「只求不抛」的空 catch(failloud 门 §C1)。
+ */
+import { engineCapsGeneration } from './engineCapsCache.js';
+/** 调用方 `opts.generation` 的一次性快照;`null` = 读不出(供给坏了)。 */
+export function snapshotCapsGeneration(opts) {
+    try {
+        return opts?.generation;
+    }
+    catch {
+        return null;
+    }
+}
+/** 入口快照的代际是否仍是当代;`gen` 缺席 = 调用方没供代际 = 恒当代;读代际抛出 = 不是。 */
+export function capsGenerationStillCurrent(baseUrl, gen) {
+    if (gen === undefined)
+        return true;
+    try {
+        return gen === engineCapsGeneration(baseUrl);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/executionLaneCapability.js

@@ -25,7 +25,7 @@
  */
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { engineCapsGeneration } from './engineCapsCache.js';
+import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
 /**
  * caps 回体 → 本格读数;**畸形一律 `undefined`**(= 这一格不写 ⇒ 读口答 `unobserved`)。
  * 键不在 / `undefined` ⇒ `not_reported`(老 server);`null` / 数组 / 非对象 / 缺任一座 / 座坏形 ⇒ 畸形。
@@ -54,21 +54,32 @@ const readingByBase = new Map();
  * 投影 `undefined`(畸形)⇒ 这一格**被删**而不是留着上一台引擎的旧值;`opts.generation` 关掉「旧探测覆盖新读数」竞态。
  */
 export function noteEngineCapsForExecutionLane(baseUrl, caps, opts) {
+    if (typeof baseUrl !== 'string' || baseUrl === '')
+        return;
+    // 🔴 代际只在入口**快照一次**(异源对抗复审 R3):opts 是调用方的对象,回体上的 getter 能在投影中途改它;首末两次核对都用这份快照,
+    //    读 opts / 读代际抛出 ⇒ 不动格(与陈旧代际同一处置)。
+    const gen = snapshotCapsGeneration(opts);
+    if (gen === null)
+        return; // 调用方 opts 的 getter 抛出 = 供给坏了 ⇒ 不动格
+    if (!capsGenerationStillCurrent(baseUrl, gen))
+        return;
+    let reading;
     try {
-        if (typeof baseUrl !== 'string' || baseUrl === '')
-            return;
-        if (opts?.generation !== undefined && opts.generation !== engineCapsGeneration(baseUrl))
-            return;
-        const reading = projectExecutionLaneCapability(caps);
-        if (reading === undefined) {
-            readingByBase.delete(baseUrl);
-            return;
-        }
-        readingByBase.set(baseUrl, reading);
+        reading = projectExecutionLaneCapability(caps);
     }
     catch {
-        /* fail-soft:本 tee 任何分支都不许打断 caps 探测链 */
+        // 🔴 0.74.2 同形存量(CC-69 复审 R1 族扫):抛 getter / Proxy 的回体 = 畸形,与「投影答 undefined」同一处置 —— 删格,不许留着上一台的读数。
+        reading = undefined;
+    }
+    // 🔴 投影之后**再核一次代际**(异源对抗复审 R2):投影会执行回体上不可信的 getter,它可以在中途让这一格换代
+    //    (invalidate + 新代际的 tee 已写入);此时无论投影返回还是抛出,都不许动新代际的格。
+    if (!capsGenerationStillCurrent(baseUrl, gen))
+        return;
+    if (reading === undefined) {
+        readingByBase.delete(baseUrl);
+        return;
     }
+    readingByBase.set(baseUrl, reading);
 }
 /** 本进程观测到的执行车道;这一格空缺 ⇒ `{kind:'unobserved'}`(**绝不**编一条车道)。 */
 export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
@@ -100,7 +111,7 @@ export function executionLaneDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('execution lane not observed — the engine reports it on /v1/capabilities; ' +
-                'this process has not received a capabilities response from the engine yet');
+                'this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)');
         case 'not_reported':
             return ('execution lane not reported by this engine — only newer engines advertise it; ' +
                 'this does not say where tools run, so the client keeps inferring it the way it did before');

package/dist/fleet/fleetProjection.d.ts

@@ -140,6 +140,11 @@ export interface FleetWorkflowView {
     failedCount?: number;
     /** 🔴 缺席 ≠ 0:0 = 引擎说「一个都没起」,undefined = 老引擎「不知道」(退 done+failed 下界)。 */
     startedCount?: number;
+    /**
+     * 0.74.3 CC-72(core 7.23.5 #932;cli L-235 ②):run 级 errorCode **原词逐字**(开集,不枚举)。缺席 = 无码 ——
+     * **不是成功也不是失败**,终态仍看 `status`;server 透传 / sdk 声明之前按结构读(sdk 9.7.1 `FleetWorkflowRow` 未声明)。
+     */
+    errorCode?: string;
 }
 /**
  * SDK `FleetTaskStatus` 的终态词汇 —— 非终态即在飞(未知未来值按在飞算,保守)。

package/dist/fleet/fleetProjection.js

@@ -373,6 +373,7 @@ function wireNumberKey(key, v) {
 export function projectWorkflows(rows) {
     return rows.map(r => {
         const startedCount = wireStartedCount(r);
+        const errorCode = wireErrorCode(r);
         return {
             id: r.id,
             // 187 workflow label = `e.summary ?? e.description`(短 label);折成单行,空 → 187 占位符。
@@ -385,9 +386,15 @@ export function projectWorkflows(rows) {
             ...wireNumberKey('tokens', wireCount(r.tokens)),
             ...wireNumberKey('failedCount', wireCount(r.failedCount)),
             ...(startedCount !== undefined ? { startedCount } : {}),
+            ...(errorCode !== undefined ? { errorCode } : {}),
         };
     });
 }
+/** CC-72:sdk 未声明的 run 级码,按结构读 —— 非空串才算在场;空串 / 非串 / null 一律缺席(不折串)。 */
+function wireErrorCode(r) {
+    const v = r.errorCode;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
 // ── 键集契约(`run-fleet-view-keys-test.mjs` 的运行期锚)─────────────────────────────────────
 //
 // 两跳链条,一跳都断不了(形与 `seatContract.ts` 的座位门同款):
@@ -436,6 +443,7 @@ const FLEET_WORKFLOW_VIEW_KEY_TUPLE = [
     'tokens',
     'failedCount',
     'startedCount',
+    'errorCode',
 ];
 /** `FleetWorkflowView` 的键名清单(同上)。 */
 export const FLEET_WORKFLOW_VIEW_KEYS = FLEET_WORKFLOW_VIEW_KEY_TUPLE;

package/dist/fleetAgentPanelProjection.d.ts

@@ -38,6 +38,8 @@ export interface FleetAgentRowLike {
     startedAt?: number;
     /** 0.74.0 —— 行的代际号(fleet 视图 `FleetTaskView.cycleSeq` 原样交)。缺席 = 这一行没有代际概念,不是第一代。 */
     cycleSeq?: number;
+    /** 0.74.3 CC-70:行帧上的委派卡 id(sdk `FleetTaskRow.parentToolCallId`);身份归一的退路键,在场才投影。 */
+    parentToolCallId?: string;
 }
 /** 行从投影集消失多久之后上报 `absent`(0.72.12 起不再 settle;重连空窗 / snapshot 清表远小于此)。名字沿用(公面导出)。 */
 export declare const ABSENT_SETTLE_MS = 30000;

package/dist/fleetAgentPanelProjection.js

@@ -141,6 +141,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
         // 🔴 三态直取:`row.toolUses` 缺席就是 undefined,这里**不许**兜 0(见 FleetAgentRowLike 注)。
         const toolUses = typeof row.toolUses === 'number' ? row.toolUses : undefined;
         const transcriptId = row.transcriptId || undefined;
+        const parentToolCallId = typeof row.parentToolCallId === 'string' && row.parentToolCallId.length > 0 ? row.parentToolCallId : undefined;
         const startedAt = typeof row.startedAt === 'number' && row.startedAt > 0 ? row.startedAt : undefined;
         // 0.74.0:代际号(正整数才算;坏形 / 缺席 ⇒ undefined,绝不补 1)。
         const cycleSeq = typeof row.cycleSeq === 'number' && Number.isInteger(row.cycleSeq) && row.cycleSeq >= 1 ? row.cycleSeq : undefined;
@@ -191,6 +192,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                     (tokens !== undefined && prev?.tokens !== tokens) ||
                     (toolUses !== undefined && prev?.toolUses !== toolUses) ||
                     (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
+                    (parentToolCallId !== undefined && prev?.parentToolCallId !== parentToolCallId) ||
                     (startedAt !== undefined && prev?.startedAt !== startedAt)) {
                     publishEngineAgentPanelEvent({
                         kind: 'fleet-row',
@@ -200,6 +202,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                         ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
                         ...(toolUses !== undefined ? { toolUses } : {}),
                         ...(transcriptId !== undefined ? { transcriptId } : {}),
+                        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
                         ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
                         ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                     });
@@ -221,6 +224,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 tokens: knownTokens,
                 toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
                 transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
+                parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
                 startedAt: knownStartedAt,
                 cycleSeq: knownCycleSeq,
                 currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
@@ -243,6 +247,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             prev.tokens !== knownTokens ||
             (toolUses !== undefined && prev.toolUses !== toolUses) ||
             (transcriptId !== undefined && prev.transcriptId !== transcriptId) ||
+            (parentToolCallId !== undefined && prev.parentToolCallId !== parentToolCallId) ||
             (startedAt !== undefined && prev.startedAt !== startedAt) ||
             (cycleSeq !== undefined && prev.cycleSeq !== cycleSeq) ||
             (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
@@ -255,6 +260,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 // 🔴 缺席即不落键(消费端据「键在不在」判三态)。
                 ...(toolUses !== undefined ? { toolUses } : {}),
                 ...(transcriptId !== undefined ? { transcriptId } : {}),
+                ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
                 ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
                 ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                 ...(currentTool !== undefined ? { currentTool } : {}),
@@ -266,6 +272,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             tokens: knownTokens,
             toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
             transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
+            parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
             startedAt: knownStartedAt,
             cycleSeq: knownCycleSeq,
             currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,

package/dist/hitl/hitlBridge.d.ts

@@ -67,6 +67,7 @@
  */
 import type { AgentEvent, ApprovalDecision, ApprovalStaleError, PendingCheckpoint, CheckpointGate, PlanReviewRequest, AssistantTaskStatus } from '@sema-agent/sdk';
 import type { ApprovalsListEnvelope } from './crashConverged.js';
+import { type SuspendedReopenReading } from './suspendedReopen.js';
 /** durable `/decide` 腿的既有缺省拒因(不带归因时逐字不变 —— 0.27.0 及之前的 wire 字节)。 */
 export declare const DEFAULT_DENY_REASON = "The user rejected this tool use";
 /**
@@ -300,6 +301,8 @@ export interface ActiveGate {
     gate: CheckpointGate;
     /** The durable seq of the `suspended` event, for rewind/dedup correlation (types.ts:48 eventSeq). */
     seq?: string | undefined;
+    /** 0.74.3 CC-73:这条挂起是不是一次 reopen(`suspended.reopened` 三态,见 {@link suspendedReopenOf});每条 suspended 重读,不粘上一条。 */
+    reopened: SuspendedReopenReading;
 }
 /** Outcome of {@link findPendingForTask}. */
 export type FindPendingOutcome = {
@@ -394,6 +397,12 @@ export declare class HitlBridge {
     observe(ev: AgentEvent): void;
     /** The gate currently awaiting a human, if any. The shell branches on `gate.kind` to pick the chrome. */
     currentGate(): CheckpointGate | null;
+    /**
+     * 0.74.3 CC-73:当前挂起是不是一次 reopen(`suspended.reopened` 三态);没挂起 ⇒ `null`。
+     * 消费方据此把「真 reopen 成功、重试会重放」那半句说出来:`reopened` 在场码 ⇒ 卡仍 pending、决定没被消费、可再决;
+     * `not_reopened` / `unstated` ⇒ 普通挂起,一个字都不多说。
+     */
+    currentGateReopen(): SuspendedReopenReading | null;
     /**
      * Fetch the `PendingCheckpoint` this decide/answer is about to resolve, for the callers that do NOT
      * already have one in hand (see `decideTool`/`answerQuestion`'s `preResolvedPending` param — the wire

package/dist/hitl/hitlBridge.js

@@ -2,6 +2,7 @@ import { askParkForeignGateKind } from '../adapter/activeRunSelfHeal.js';
 import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
 import { abortableSleep } from '../abortableSleep.js';
+import { suspendedReopenOf } from './suspendedReopen.js';
 // ── deny/plan-review 归因的 wire 窄化(0.28.0 发版扫描 F1/F2/F3 收编;单源,三条腿共用)──────
 //
 // server 对 `/decide` 与 plan-review 两条腿的 `reason` 同限 `MAX_APPROVAL_REASON_CHARS`(4096 字符,
@@ -417,10 +418,10 @@ export class HitlBridge {
             case 'suspended':
                 // gate may be null (Event_suspended 'null' arm) → a generic "needs you" pause (contract/08 CS-9).
                 if (ev.gate) {
-                    this.active = { gate: ev.gate, seq: eventSeq(ev) };
+                    this.active = { gate: ev.gate, seq: eventSeq(ev), reopened: suspendedReopenOf(ev) };
                 }
                 else {
-                    this.active = { gate: { kind: 'human' }, seq: eventSeq(ev) };
+                    this.active = { gate: { kind: 'human' }, seq: eventSeq(ev), reopened: suspendedReopenOf(ev) };
                 }
                 break;
             case 'done':
@@ -439,6 +440,14 @@ export class HitlBridge {
     currentGate() {
         return this.active?.gate ?? null;
     }
+    /**
+     * 0.74.3 CC-73:当前挂起是不是一次 reopen(`suspended.reopened` 三态);没挂起 ⇒ `null`。
+     * 消费方据此把「真 reopen 成功、重试会重放」那半句说出来:`reopened` 在场码 ⇒ 卡仍 pending、决定没被消费、可再决;
+     * `not_reopened` / `unstated` ⇒ 普通挂起,一个字都不多说。
+     */
+    currentGateReopen() {
+        return this.active?.reopened ?? null;
+    }
     /**
      * Fetch the `PendingCheckpoint` this decide/answer is about to resolve, for the callers that do NOT
      * already have one in hand (see `decideTool`/`answerQuestion`'s `preResolvedPending` param — the wire

package/dist/hitl/suspendedReopen.d.ts

@@ -0,0 +1,30 @@
+/**
+ * suspendedReopen — durable `suspended` 事件上 server 的**重开侧记键** `reopened` 的三态读口(0.74.3 CC-73;
+ * 契约 reopen 族段:`GET /v1/runs/{taskId}/events` 的 `suspended` 事件带 `reopened: <errorCode>`,「缺席 / null =
+ * 这次 park 不是重开」;sdk `events.d.ts` `reopened?: string | null`,普通挂起帧不带此键)。
+ *
+ * ── 🔴 为什么是三态而不是「是 / 不是」两态 ─────────────────────────────────────────────────
+ * 契约把「缺席」和「null」判成同一句话,但两者的**说话人不同**:`null` 是新 server 明说「不是重开」;键缺席既可能是
+ * 新 server 的普通挂起帧,也可能是根本没有这个键的老 server。把两者折成一个值,消费方就再也分不出「server 说了不是」
+ * 与「server 什么都没说」。读口把它们分开带出,消费方按契约把 `unstated` **当作**不是重开即可,但不替 server 说那句话。
+ *
+ * 码是**开集原词**(词表属主在 server:今天三员 `resume.env_failed` / `resume.tool_unavailable` /
+ * `resume.tool_contract_mismatch`,见 `engineErrorCodes.ts` `RESUME_REOPEN_CODES`),本读口不过滤;要文案的消费方拿码去查表。
+ */
+/** `suspended.reopened` 的读数。 */
+export type SuspendedReopenReading = 
+/** 键在场且是非空串:这条挂起是一次**重开**,`code` = server 给的 errorCode 原词。 */
+{
+    readonly kind: 'reopened';
+    readonly code: string;
+}
+/** 键在场且显式 `null`:server 明说这次 park 不是重开。 */
+ | {
+    readonly kind: 'not_reopened';
+}
+/** 键缺席(或值读不出):server 没说;按契约当作不是重开,但不冒充 `null`。 */
+ | {
+    readonly kind: 'unstated';
+};
+/** 任意事件体 → 三态读数;非对象 / 坏形一律 `unstated`,永不抛。 */
+export declare function suspendedReopenOf(ev: unknown): SuspendedReopenReading;

package/dist/hitl/suspendedReopen.js

@@ -0,0 +1,27 @@
+/**
+ * suspendedReopen — durable `suspended` 事件上 server 的**重开侧记键** `reopened` 的三态读口(0.74.3 CC-73;
+ * 契约 reopen 族段:`GET /v1/runs/{taskId}/events` 的 `suspended` 事件带 `reopened: <errorCode>`,「缺席 / null =
+ * 这次 park 不是重开」;sdk `events.d.ts` `reopened?: string | null`,普通挂起帧不带此键)。
+ *
+ * ── 🔴 为什么是三态而不是「是 / 不是」两态 ─────────────────────────────────────────────────
+ * 契约把「缺席」和「null」判成同一句话,但两者的**说话人不同**:`null` 是新 server 明说「不是重开」;键缺席既可能是
+ * 新 server 的普通挂起帧,也可能是根本没有这个键的老 server。把两者折成一个值,消费方就再也分不出「server 说了不是」
+ * 与「server 什么都没说」。读口把它们分开带出,消费方按契约把 `unstated` **当作**不是重开即可,但不替 server 说那句话。
+ *
+ * 码是**开集原词**(词表属主在 server:今天三员 `resume.env_failed` / `resume.tool_unavailable` /
+ * `resume.tool_contract_mismatch`,见 `engineErrorCodes.ts` `RESUME_REOPEN_CODES`),本读口不过滤;要文案的消费方拿码去查表。
+ */
+const UNSTATED = Object.freeze({ kind: 'unstated' });
+const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
+/** 任意事件体 → 三态读数;非对象 / 坏形一律 `unstated`,永不抛。 */
+export function suspendedReopenOf(ev) {
+    if (ev === null || typeof ev !== 'object' || Array.isArray(ev))
+        return UNSTATED;
+    const o = ev;
+    if (!Object.hasOwn(o, 'reopened'))
+        return UNSTATED;
+    const v = o.reopened;
+    if (v === null)
+        return NOT_REOPENED;
+    return typeof v === 'string' && v.length > 0 ? { kind: 'reopened', code: v } : UNSTATED;
+}

package/dist/index.d.ts

@@ -157,9 +157,12 @@ export * from './writeProtectionCapability.js';
 export * from './webSearchBackendCapability.js';
 export * from './executionLaneCapability.js';
 export * from './approvalsStreamLiveCapability.js';
+export * from './deviceExecutorManagementCapability.js';
 export * from './mcpReconnect.js';
 export * from './leaderConflict.js';
 export * from './runTerminal.js';
+export * from './runCancelContext.js';
+export * from './argvFlagValue.js';
 export * from './readFacePosture.js';
 export * from './mcpPanel.js';
 export * from './effectiveFacts.js';
@@ -252,6 +255,7 @@ export * from './hooksWireCaps.js';
 export * from './liveInitToolFace.js';
 export * from './model/providerPresets.js';
 export * from './hitl/hitlBridge.js';
+export * from './hitl/suspendedReopen.js';
 export { toolEndOutputText, ENGINE_ABORT_TOOL_RESULT } from './hitl/frameRouter.js';
 export { isAskTool } from './hitl/frameRouter.js';
 export * from './hitl/hitlHostSurface.js';

package/dist/index.js

@@ -192,6 +192,8 @@ export * from './webSearchBackendCapability.js';
 export * from './executionLaneCapability.js';
 // · approvalsStreamLiveCapability(0.73.3 CC-61):capabilities.approvalsStreamLive 四态读面 + feed 消费方「要不要靠对账拉」的判据单源。
 export * from './approvalsStreamLiveCapability.js';
+// · deviceExecutorManagementCapability(0.74.2 CC-69):capabilities.deviceExecutor.management 四态读面 + 管理动词可用性判据单源。
+export * from './deviceExecutorManagementCapability.js';
 // S-381 / core 7.22.0 #857(0.72.9 CC-30;server ≥7.85.0,sdk 尚未声明):会话内 MCP re-dial 的消费口 —— 200 三态按 outcome 分形读、
 // unsupported 恒五键、名册按 toolNames 在场性、失败按 errorCode 分诊、「重连 = 一次交易」措辞单源;能力位 mcpReconnect 三态读。
 export * from './mcpReconnect.js';
@@ -200,6 +202,10 @@ export * from './mcpReconnect.js';
 export * from './leaderConflict.js';
 // 0.60.0(engine ≥7.64.0 / sdk 8.4.0):终局因由与门记录两只**判定归包**的读器。
 export * from './runTerminal.js';
+// 0.74.3 CC-71:run 记录 cancelContext 读口 + turn_aborted{engine_error} 后的成因闭集四词(cli L-212 (a) 消费半场归包)
+export * from './runCancelContext.js';
+// 0.74.3 CC-80(core 交叉扫 X-5 / cli L-R1):argv 末次旗值扫描原语上公面 —— 包内四消费者早已收编,端还在造第 N 份手写循环
+export * from './argvFlagValue.js';
 // 0.61.0(engine ≥7.65.0 / sdk 8.5.0 / S-167):READ 容纳面档位 + 来源的 operator 面窄读器
 // (`WiringDiagnostics.readFace`)。与 `writeProtectionCapability` / `gateOutcome` 同构同纪律
 // (防御读 / 唯一措辞铸点 / UNTRUSTED-for-display);与租户面 `capabilities.readFace` 刻意不合流,
@@ -436,6 +442,8 @@ export * from './model/providerPresets.js';
 //    共享宿主通知面 + cancel-by-deny 有界观察 —— `askGateWire.ts` 已 import `toolApprovalWire.ts`,
 //    反向 import 会成环,所以两条腿共用的那一组挪进一个两边都能到达的独立模块。
 export * from './hitl/hitlBridge.js';
+// 0.74.3 CC-73:durable suspended.reopened 三态读口(cli L-56 ②)
+export * from './hitl/suspendedReopen.js';
 // [C93] P0 直讨(0.17.1):toolEndOutputText 单一真源导出——web/desktop 被点名「两端务必接」的
 // 6.0.0 output content-block 归一,此前 frameRouter 内私有,两端手抄=漂移温床。frameRouter 只
 // 挑名导出这一件(整星导出会把路由内部面全泄进公面)。