@sema-agent/client-core 0.74.2 → 0.74.4

package/dist/engineAgentPanelStore.js

@@ -88,7 +88,366 @@ 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,
+//     没有这一步它永远归不了一。
+//   · 🔴 **先发布的键为准**(0.74.4 CC-83;test [7702] N-3 证伪「零改」:tick 归不了一而原样发出之后,行帧再按尾段发 = 消费端仍两行):
+//     一条 tick 已按 UUID 原样发出(第二拍 / 拍数耗尽 / 绑卡),这个子代在消费端的键就是 UUID —— 之后到的 fleet-row / fleet 侧 end
+//     改写成 UUID(原词进 wireTaskId,taskIdOrigin:'wire'),不再把尾段当第二把键发出去。消费端从此在任何到达序上都只见一把键;
+//     常态序(行帧先到)仍归一到尾段。
+//   · 🔴 前代 UUID 的迟到 tick **丢弃**(0.74.4 CC-84;test [7702] W2 tick 腿):钥匙上的周期比最近行帧旧 ⇒ 这条 progress 属已结束的
+//     周期,归一发出去会把前代的累计数写进复活行;end 有陈旧判据(消费端按周期挡),tick 没有 ⇒ 在漏斗里挡。
+/** 钥匙表上限(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();
+/**
+ * 已按 UUID 原样发出过 tick 的子代(先发布的键为准,CC-83):transcriptId(= UUID)与 parentToolCallId 两把钥匙都记。
+ * 🔴 所有权表**按生命周期退役、不按容量改写**(异源复审 0.74.4 R1 [medium]):一把已发布的键在消费端就是一行,容量到了把它忘掉 =
+ * 同一子代重新长成两行。所以 `retired`(收到 end)的条目先让位;都没退役时才让最旧的(上限 MAX_OWNERSHIP_KEYS,远大于同时在飞的子代数)。
+ */
+const MAX_OWNERSHIP_KEYS = 8192;
+const publishedWireIds = new Map();
+const publishedWireByParent = new Map();
+/** 尾段 → 已发布的 UUID(CC-83):fleet 侧的 fleet-row / end / 缺席 到时改写成 UUID;带登记时行帧的周期,复活的新周期不继承。 */
+const wireIdByFleetId = new Map();
+function bounded(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    if (map.size > MAX_IDENTITY_KEYS) {
+        const oldest = map.keys().next().value;
+        if (oldest !== undefined)
+            map.delete(oldest);
+    }
+}
+/** 所有权表的有界:退役的先让位,都没退役才让最旧的。 */
+function boundedOwnership(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    if (map.size <= MAX_OWNERSHIP_KEYS)
+        return;
+    for (const [k, v] of map) {
+        if (v.retired) {
+            map.delete(k);
+            return;
+        }
+    }
+    const oldest = map.keys().next().value;
+    if (oldest !== undefined)
+        map.delete(oldest);
+}
+/** 一条 tick 按 UUID 原样发出去了:从此这个子代的键 = UUID。 */
+function notePublishedWire(ev) {
+    // 已退役的键不因一条迟到 tick 复活(异源复审 R3 [high]):退役 = 它的行已结,迟到帧落在它自己的行上,所有权不回来
+    boundedOwnership(publishedWireIds, ev.taskId, { retired: publishedWireIds.get(ev.taskId)?.retired ?? false });
+    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
+        bounded(publishedWireByParent, ev.parentToolCallId, ev.taskId);
+}
+/** 这把 UUID 的子代收到了终态:所有权可退役(容量满时先让位;不删 —— 迟到的同周期行帧 / end 仍要改写到它)。 */
+function retireWire(wireId) {
+    const w = publishedWireIds.get(wireId);
+    if (w !== undefined)
+        w.retired = true;
+    for (const o of wireIdByFleetId.values())
+        if (o.wireId === wireId)
+            o.retired = true;
+}
+/** fleet-row 对应的子代是否已经按 UUID 发布过;transcriptId 命中不看退役(同一子代的迟到行帧),parentToolCallId 只认未退役(复活会沿用同一张卡)。 */
+function publishedWireFor(ev) {
+    if (ev.transcriptId !== undefined && publishedWireIds.has(ev.transcriptId))
+        return ev.transcriptId;
+    if (ev.parentToolCallId !== undefined) {
+        const u = publishedWireByParent.get(ev.parentToolCallId);
+        if (u !== undefined && publishedWireIds.get(u)?.retired === false)
+            return u;
+    }
+    return undefined;
+}
+/** 尾段今天归哪把 UUID(在场 = 这个子代已按 UUID 上屏;复活的新周期不算)。 */
+function wireOwnerOf(fleetId, current) {
+    const o = wireIdByFleetId.get(fleetId);
+    if (o === undefined)
+        return undefined;
+    if (current !== undefined && isStaleEngineAgentPanelEnd(o, current)) {
+        wireIdByFleetId.delete(fleetId); // 行帧已是更新的周期:旧 UUID 的所有权到此为止,新周期按常态登记
+        retireWire(o.wireId); // 旧周期已过:那把 UUID 退役,退路键(同一张卡)不再把新周期的行帧拉回它(异源复审 R2 [high])
+        return undefined;
+    }
+    return o.wireId;
+}
+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;
+    notePublishedWire(ev);
+    return { ...rest, taskIdOrigin: 'wire' };
+}
+/** 钥匙上的周期比最近行帧旧 = 这条 tick 属已结束的周期(CC-84);判不出 ⇒ 不算陈旧。 */
+function staleWireTick(id) {
+    return isStaleEngineAgentPanelEnd(id, latestCycleByFleetId.get(id.taskId));
+}
+function flushHeld(wireTaskId) {
+    const held = heldWireTicks.get(wireTaskId);
+    if (held === undefined)
+        return;
+    heldWireTicks.delete(wireTaskId);
+    if (publishedWireIds.has(held.ev.taskId)) {
+        deliverEngineAgentPanelEvent(asIsTick(held.ev));
+        return;
+    }
+    const id = resolveEnginePanelTaskId(held.ev.taskId, held.ev.parentToolCallId);
+    if (id.origin === 'fleet-row') {
+        if (staleWireTick(id))
+            return; // 前代周期的 progress:丢
+        rememberResolvedWire(held.ev.taskId, id);
+        deliverEngineAgentPanelEvent(normalizedTick(held.ev, id.taskId));
+        return;
+    }
+    deliverEngineAgentPanelEvent(asIsTick(held.ev));
+}
+/**
+ * 0.74.3 CC-70(异源复审 R3 [high]):按 wire 上的子代 id 清常驻标 —— 原键照清;归一到 fleet 尾段的那把键**只在这条终态属当代时**才清:
+ * 复活后迟到的前代终态(旧 UUID 的流内 close / 终态 tick)归一后带旧代际,清了尾段键 = 撤掉复活行的 sweep 保护 ⇒ 下一次 sweep 假结它。
+ * 判据与 `end` 的陈旧判据同一只(`isStaleEngineAgentPanelEnd`,拿钥匙上的周期对最近一条行帧的周期);判不出 ⇒ 照清(不因缺席留下永久常驻)。
+ * `cycle`(0.74.4):调用方(通知车道)带得出这条终态的周期时传进来 —— 尾段归某把 UUID 所有而通知比所有权旧 ⇒ 不清那把 UUID 的常驻标。
+ */
+export function clearEnginePanelTaskResidentByWire(wireTaskId, cycle) {
+    residentTaskIds.delete(wireTaskId);
+    const owner = wireIdByFleetId.get(wireTaskId); // 传进来的是尾段而尾段归某把 UUID 所有(通知车道)⇒ 那把键下的常驻标一起清
+    // 通知带周期(seq)且比所有权登记时的周期旧 = 前代的终态 ⇒ 不清当代 UUID 的常驻标(异源复审 R3 [high])
+    if (owner !== undefined && !(cycle !== undefined && isStaleEngineAgentPanelEnd(cycle, owner)))
+        residentTaskIds.delete(owner.wireId);
+    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();
+    publishedWireIds.clear();
+    publishedWireByParent.clear();
+    wireIdByFleetId.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': {
+            // 先发布的键为准(CC-83):这个子代已经按 UUID 上过屏 ⇒ 行帧改写成 UUID 发,并记 尾段 → UUID 供 fleet 侧 end 改写;不登记尾段钥匙。
+            const rowCycle = { ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}), ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}) };
+            const published = wireOwnerOf(ev.taskId, rowCycle) ?? publishedWireFor(ev);
+            if (published !== undefined && published !== ev.taskId) {
+                const prev = wireIdByFleetId.get(ev.taskId);
+                boundedOwnership(wireIdByFleetId, ev.taskId, { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...rowCycle });
+                deliverEngineAgentPanelEvent({ ...ev, taskId: published, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
+                ageHeld(undefined);
+                return;
+            }
+            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': {
+            // 先发布的键为准也管 tick 自己(异源复审 R2 [high]):这把 UUID 已经是消费端的键,之后的 tick 不再经退路键归一到尾段
+            //(否则复活后同一张卡的退路键把前代 UUID 的迟到 tick 拉进新周期的行)。
+            if (publishedWireIds.has(ev.taskId)) {
+                heldWireTicks.delete(ev.taskId);
+                deliverEngineAgentPanelEvent(asIsTick(ev));
+                return;
+            }
+            const id = resolveEnginePanelTaskId(ev.taskId, ev.parentToolCallId);
+            if (id.origin === 'fleet-row') {
+                heldWireTicks.delete(ev.taskId);
+                if (staleWireTick(id))
+                    return; // CC-84:前代 UUID 的迟到 tick 不进复活行
+                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': {
+            // 先发布的键为准(CC-83):尾段已被改写成 UUID 的子代,fleet 侧(投影 / 通知)的 end{尾段} 也改写成 UUID
+            const wireOwner = wireOwnerOf(ev.taskId, ev);
+            if (wireOwner !== undefined) {
+                const ownerRec = wireIdByFleetId.get(ev.taskId);
+                deliverEngineAgentPanelEvent({ ...ev, taskId: wireOwner, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
+                // 前代迟到的 end(比所有权登记时的周期旧)只过境让消费端判陈旧,不退役当代所有权(异源复审 R3)
+                if (!isStaleEngineAgentPanelEnd(ev, ownerRec))
+                    retireWire(wireOwner);
+                return;
+            }
+            if (publishedWireIds.has(ev.taskId)) {
+                // 这把 UUID 是先发布的键 ⇒ 它的 end 落在它自己的行上(不归一;一把已发布的键永远不改写)
+                flushHeld(ev.taskId);
+                deliverEngineAgentPanelEvent(ev);
+                retireWire(ev.taskId);
+                return;
+            }
+            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);
+            retireWire(ev.taskId); // 这把 UUID 若是先发布的键,所有权退役(容量满时先让位)
+            return;
+        }
+        default:
+            // sweep:缓着的 tick 不放(见头注)—— 原样进主通道。
+            deliverEngineAgentPanelEvent(ev);
+    }
+}
+function deliverEngineAgentPanelEvent(ev) {
     // 同 taskId 的任何主通道事实(tick / fleet-row = 行在场;end = 真终态)都让**缓冲里**那条缺席过期 —— 迟订阅的消费者
     // 不许先恢复了行、再被一条旧缺席标成 unknown(已递达订阅者的缺席由订阅者按契约在这些事件上撤标)。
     if (ev.kind !== 'sweep')
@@ -239,6 +598,10 @@ let absenceListener = null;
 const absenceBuffer = new Map();
 /** 发布一条缺席上报(由 `projectFleetAgentRows` 的缺席路径调;消费者抛错不反噬投影)。 */
 export function publishEngineAgentPanelAbsence(ev) {
+    // 0.74.4 CC-83(异源复审 R1 [medium]):尾段已归先发布的 UUID 所有 ⇒ 缺席也按那把键发(主通道与侧信道同一把键),原尾段进 wireTaskId
+    const owner = wireOwnerOf(ev.taskId);
+    if (owner !== undefined)
+        ev = { ...ev, taskId: owner, wireTaskId: ev.taskId };
     if (absenceListener) {
         try {
             absenceListener(ev);

package/dist/executionLaneCapability.js

@@ -111,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

@@ -161,6 +161,8 @@ 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';
@@ -253,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';