@sema-agent/client-core 0.73.4 → 0.74.0

package/dist/fleet/workflowSizeWarning.js

@@ -0,0 +1,155 @@
+/**
+ * src/fleet/workflowSizeWarning.ts —— workflow **规模告警**的判定(0.73.5)。
+ *
+ * 三端 footer / 面板都要回答同一个问题:「这条 workflow 是不是大到该提醒用户了」。判定与 CC 同形
+ * (三个缺省帽、每 agent 用量估算、guideline 表、两个 env 覆盖、三档文案与宽度阶梯),属于客户端公共逻辑,
+ * 由本包单源;端只负责读环境、读设置、量宽度与渲染。
+ *
+ * 🔴 **入参按 fleet 视图的三态键读**(`FleetWorkflowView`:`totalCount` / `startedCount` / `doneCount` /
+ *    `failedCount` / `tokens` 全是可选位,缺席 = wire 没报 = 不知道)。出参三态:
+ *      · `warn`    —— 有**正向证据**证明至少一条轴超帽(别的键缺席不挡它;下界分母算出的上界**不算**证据);
+ *      · `ok`      —— 两条轴都判得出,且都在帽内(或 ultracode 压掉了整条告警);
+ *      · `unknown` —— 没有超帽的正向证据,且至少一条轴判不出。**未知的规模不能被当作规模正常**:
+ *                     `unknown` 绝不折成 `ok`,`missing` 点名缺了哪几键。
+ *
+ * 🔴 **分母口径**(每 agent 用量 `u = tokens / started`):
+ *      · `startedCount` 在场且不小于 `doneCount + failedCount` ⇒ 用引擎真值(含真 0:「一个都还没起」是一条真信息
+ *        ⇒ 用先验);比已完成数还小(帧间竞态)⇒ 这份读数是陈旧的,按下面的下界处置;
+ *      · 缺席 ⇒ 只有 `doneCount` / `failedCount` **两键都在场**才回退成下界,结果标 `startedIsLowerBound`。
+ *        下界偏小 ⇒ `u` 偏大 ⇒ 算出来的是投影的**上界**(`projectedTokensUpperBound`,不是 `projectedTokens`):
+ *        上界在帽内 ⇒ 真的在帽内 ⇒ 可以判 `ok`;上界超帽**不是**超帽的证据(同一份读数补上真 `startedCount`
+ *        可能远在帽内)⇒ 投影轴判不出,`unknown`。想保守一点的端可以自己拿上界去提示,判词不替它撒谎;
+ *      · 下界为 0 ⇒ 每 agent 用量判不出:「0 个完成」不是「一个没起」的证据,先验只在引擎**亲口**报
+ *        `startedCount = 0` 时可用;
+ *      · 只有一键在场 ⇒ 不回退(缺席的那键不读作 0)。
+ */
+/** 缺省 agent 数帽。 */
+export const WORKFLOW_SIZE_WARNING_AGENT_CAP = 25;
+/** 缺省 token 帽(已花 ∨ 投影)。 */
+export const WORKFLOW_SIZE_WARNING_TOKEN_CAP = 1_500_000;
+/** 还没有任何 agent 起跑时的每 agent 用量先验。 */
+export const WORKFLOW_SIZE_WARNING_TOKENS_PER_AGENT = 70_000;
+/** 显式 `workflowSizeGuideline` → agent 数帽。`unrestricted` 与缺省(未配置)**不贡献帽**,故不在表里。 */
+export const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS = Object.freeze({
+    small: 5,
+    medium: 15,
+    large: 50,
+});
+/** 两个 env 覆盖各自的名字,按读取优先级排(品牌名在前,兼容名在后)。本包不读 `process.env`,名字单源在这里。 */
+export const WORKFLOW_SIZE_WARNING_ENV_NAMES = Object.freeze({
+    agents: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_AGENTS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_AGENTS']),
+    tokens: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_TOKENS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_TOKENS']),
+});
+/** 三档文案(宽 → 窄)。 */
+export const WORKFLOW_SIZE_WARNING_TEXT_LONG = '⚠ Large workflow · /workflows to stop';
+export const WORKFLOW_SIZE_WARNING_TEXT_SHORT = '⚠ Large workflow';
+export const WORKFLOW_SIZE_WARNING_TEXT_MIN = '⚠';
+/** 有限非负数,否则缺席(坏形按缺席,不猜)。 */
+function count(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+}
+/** 正有限数,否则缺席。 */
+function positive(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
+}
+function guidelineCap(size) {
+    return size !== undefined && Object.hasOwn(WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS, size)
+        ? WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS[size]
+        : undefined;
+}
+/** 规模判定。纯函数:每个环境量都由调用方注入。 */
+export function evaluateWorkflowSize(input) {
+    const agentCap = positive(input.envAgentCap) ?? guidelineCap(input.guidelineSize) ?? WORKFLOW_SIZE_WARNING_AGENT_CAP;
+    const tokenCap = positive(input.envTokenCap) ?? WORKFLOW_SIZE_WARNING_TOKEN_CAP;
+    const scheduled = count(input.totalCount);
+    const tokens = count(input.tokens);
+    const base = {
+        agentCap,
+        tokenCap,
+        ...(scheduled !== undefined ? { scheduledAgents: scheduled } : {}),
+        ...(tokens !== undefined ? { totalTokens: tokens } : {}),
+    };
+    if (input.ultracodeActive === true)
+        return { kind: 'ok', suppressed: true, ...base };
+    // 分母:真值 / 两键下界 / 判不出。
+    const startedWire = count(input.startedCount);
+    const done = count(input.doneCount);
+    const failed = count(input.failedCount);
+    const bound = done !== undefined && failed !== undefined ? done + failed : undefined;
+    let started;
+    let lowerBound = false;
+    if (startedWire !== undefined && (bound === undefined || startedWire >= bound)) {
+        started = startedWire;
+    }
+    else if (bound !== undefined) {
+        // `startedCount` 缺席,或它比已完成数还小(帧间竞态:已完成的 agent 必然起过 ⇒ 这份 started 是陈旧的)。
+        // 顶上来的 `done + failed` 只是**下界**,不是真值 —— 与缺席同一处置。
+        started = bound;
+        lowerBound = true;
+    }
+    // 投影:分母是真值 ⇒ 投影;分母是下界(> 0)⇒ 只有上界;其余判不出。
+    let projected;
+    let upperBound;
+    if (scheduled !== undefined && tokens !== undefined && started !== undefined) {
+        if (!lowerBound) {
+            projected = Math.max(tokens, Math.round((started > 0 ? tokens / started : WORKFLOW_SIZE_WARNING_TOKENS_PER_AGENT) * scheduled));
+        }
+        else if (started > 0) {
+            upperBound = Math.max(tokens, Math.round((tokens / started) * scheduled));
+        }
+    }
+    const facts = {
+        ...base,
+        ...(projected !== undefined ? { projectedTokens: projected } : {}),
+        ...(upperBound !== undefined ? { projectedTokensUpperBound: upperBound } : {}),
+        ...(lowerBound && scheduled !== undefined && tokens !== undefined ? { startedIsLowerBound: true } : {}),
+    };
+    /** 投影轴在帽内的证据:真投影在帽内,或上界在帽内。 */
+    const projectionWithinCap = (projected !== undefined && projected <= tokenCap) || (upperBound !== undefined && upperBound <= tokenCap);
+    const overAgents = scheduled !== undefined && scheduled > agentCap;
+    const overTokens = (tokens !== undefined && tokens > tokenCap) || (projected !== undefined && projected > tokenCap);
+    if (overAgents || overTokens) {
+        return { kind: 'warn', axis: overAgents && overTokens ? 'both' : overAgents ? 'agents' : 'tokens', ...facts };
+    }
+    const missing = [];
+    if (scheduled === undefined)
+        missing.push('totalCount');
+    if (tokens === undefined)
+        missing.push('tokens');
+    if (scheduled !== undefined && tokens !== undefined && !projectionWithinCap)
+        missing.push('startedCount');
+    if (missing.length > 0)
+        return { kind: 'unknown', missing, ...facts };
+    return { kind: 'ok', ...facts };
+}
+/**
+ * 两个 env 覆盖的读口。`env` 由调用方交(本包不碰 `process.env`)。每组按 {@link WORKFLOW_SIZE_WARNING_ENV_NAMES}
+ * 的顺序取**第一个在场的名字**;那个名字的值不是正有限数 ⇒ 该键不在场,**不回落**到第二个名字
+ * (显式写错不该被悄悄换源)。
+ */
+export function readWorkflowSizeWarningEnvCaps(env) {
+    const pick = (names) => {
+        if (env === undefined || env === null)
+            return undefined;
+        for (const n of names) {
+            const raw = env[n];
+            if (typeof raw !== 'string')
+                continue; // 空串也是「在场」:在场的坏值就地止步,不回落
+            return positive(Number(raw));
+        }
+        return undefined;
+    };
+    const a = pick(WORKFLOW_SIZE_WARNING_ENV_NAMES.agents);
+    const t = pick(WORKFLOW_SIZE_WARNING_ENV_NAMES.tokens);
+    return { ...(a !== undefined ? { envAgentCap: a } : {}), ...(t !== undefined ? { envTokenCap: t } : {}) };
+}
+/** 宽度阶梯:挑放得下的最长一档;连字形都放不下 ⇒ `undefined`(整段不渲)。`width` 由调用方注入(与渲染器同一把尺)。 */
+export function workflowSizeWarningTextForWidth(available, width) {
+    if (available >= width(WORKFLOW_SIZE_WARNING_TEXT_LONG))
+        return WORKFLOW_SIZE_WARNING_TEXT_LONG;
+    if (available >= width(WORKFLOW_SIZE_WARNING_TEXT_SHORT))
+        return WORKFLOW_SIZE_WARNING_TEXT_SHORT;
+    if (available >= width(WORKFLOW_SIZE_WARNING_TEXT_MIN))
+        return WORKFLOW_SIZE_WARNING_TEXT_MIN;
+    return undefined;
+}

package/dist/fleetAgentPanelProjection.d.ts

@@ -36,6 +36,8 @@ export interface FleetAgentRowLike {
     /** server 1.250 起行带的 launch 真锚(epoch ms)。R4(clay 五报 07-31):此前投影载荷丢弃它,
      *  详情页 elapsed 只能锚「壳建行时刻」——遗留行上渲出 1h+ 的假时长。缺席=老引擎,消费端保持现状。 */
     startedAt?: number;
+    /** 0.74.0 —— 行的代际号(fleet 视图 `FleetTaskView.cycleSeq` 原样交)。缺席 = 这一行没有代际概念,不是第一代。 */
+    cycleSeq?: number;
 }
 /** 行从投影集消失多久之后上报 `absent`(0.72.12 起不再 settle;重连空窗 / snapshot 清表远小于此)。名字沿用(公面导出)。 */
 export declare const ABSENT_SETTLE_MS = 30000;

package/dist/fleetAgentPanelProjection.js

@@ -47,7 +47,7 @@
  *    run 发布器双生行的形)——REF-CC-042:与同包 `workflow.rowIdTail` 同一个函数(import,不再
  *    就地维护第二份;该函数出过等价性事故,0.1.1 修,见 `workflow.ts` 头注)。
  */
-import { publishEngineAgentPanelAbsence, publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
+import { isStaleEngineAgentPanelEnd, publishEngineAgentPanelAbsence, publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
 import { rowIdTail } from './workflow.js';
 import { TERMINAL_FLEET_TASK_STATUSES } from './fleet/fleetProjection.js';
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
@@ -142,26 +142,53 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
         const toolUses = typeof row.toolUses === 'number' ? row.toolUses : undefined;
         const transcriptId = row.transcriptId || 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;
         const currentTool = currentToolKeyOf(row.currentTool) !== undefined ? row.currentTool : undefined;
         const currentToolKey = currentToolKeyOf(row.currentTool);
         const prev = seenMap.get(taskId);
+        // 0.74.0(异源对抗复审 R1):行上已是更新的一代,这一帧却是更早的一代 ⇒ 前代迟到帧。整只跳过:不发 fleet-row
+        //   (它会把消费端记的周期身份改写回旧代,让随后的 end{旧代} 过陈旧判据)、不发 end、不动台账(否则台账被标
+        //   settled,新一代的真终态就被去重吞掉)。在场已记 ⇒ 不会因此误报缺席。
+        //   判据与消费端同一条(`isStaleEngineAgentPanelEnd`:cycleSeq 优先,startedAt 回退)—— 只比 cycleSeq 会让只带
+        //   startedAt 的前代帧漏网(异源对抗复审 R2)。
+        const rowIdentity = { ...(cycleSeq !== undefined ? { cycleSeq } : {}), ...(startedAt !== undefined ? { startedAt } : {}) };
+        const prevIdentity = prev !== undefined
+            ? { ...(prev.cycleSeq !== undefined ? { cycleSeq: prev.cycleSeq } : {}), ...(prev.startedAt !== undefined ? { startedAt: prev.startedAt } : {}) }
+            : undefined;
+        if (prev !== undefined && isStaleEngineAgentPanelEnd(rowIdentity, prevIdentity))
+            continue;
+        /** 这一帧的周期身份**可证明**比台账上的新(同一条规则反向)。 */
+        const rowNewerCycle = prev !== undefined && isStaleEngineAgentPanelEnd(prevIdentity, rowIdentity);
         // 🔴 粘性只在**同一周期**内成立:上一条已 settle(同 id 复活 = 新周期)或 launch 锚换了 ⇒ 不继承上一周期的用量
         //    (否则新周期首帧没报 tokens 时会把上一周期的数当成当前读数发布;异源对抗复审)。
         const sameCycle = prev !== undefined &&
             !prev.settled &&
-            (startedAt === undefined || prev.startedAt === undefined || prev.startedAt === startedAt);
+            (startedAt === undefined || prev.startedAt === undefined || prev.startedAt === startedAt) &&
+            // 0.74.0:代际号变了同样是新周期(两条都报了才比;任一条没报 = 这一帧没说)
+            (cycleSeq === undefined || prev.cycleSeq === undefined || prev.cycleSeq === cycleSeq);
         const knownTokens = tokens !== undefined ? tokens : sameCycle ? prev?.tokens : undefined;
         // 本周期已知的 launch 锚:帧上给了用帧上的,没给则同周期沿用。🔴 它随**每一条** fleet-row 发布(不只是变化那一帧)——
         // 事件缓冲靠它判「这两条部分帧是不是同一周期」;缺锚的部分帧会让跨周期合并绕过屏障(异源对抗复审 [high])。
-        const knownStartedAt = startedAt !== undefined ? startedAt : sameCycle ? prev?.startedAt : undefined;
+        // 🔴 身份的沿用与用量的沿用是两回事(异源对抗复审 R3):用量只在**活着的同周期**内粘(`sameCycle` 要求
+        //    !prev.settled);身份只要这一帧**不可证更新**就沿用 —— 同周期重复的终态帧若把记住的 startedAt / cycleSeq
+        //    抹掉,下一代只带另一半身份时就判不出「更新」,被 settled 吞掉。
+        const carryIdentity = prev !== undefined && !rowNewerCycle;
+        const knownStartedAt = startedAt !== undefined ? startedAt : carryIdentity ? prev.startedAt : undefined;
+        const knownCycleSeq = cycleSeq !== undefined ? cycleSeq : carryIdentity ? prev.cycleSeq : undefined;
         if (TERMINAL_FLEET_TASK_STATUSES.has(status)) {
-            // ② 终态一次性 settle(幂等台账;消费端 settle 也幂等)。
-            if (!prev?.settled) {
+            // ② 终态一次性 settle(幂等台账;消费端 settle 也幂等)。0.74.0:去重按**周期** —— 已 settle 的是上一代、这一帧是
+            //    更新的一代(中间没见到 running 帧)⇒ 新周期的终态照发,不被上一代的 settled 吞掉。
+            const settledThisCycle = prev?.settled === true && !rowNewerCycle;
+            if (!settledThisCycle) {
                 // 终态行也把最后一拍的累计工具数/转录锚带上:详情页在行翻终态后仍要显示真计数与
                 // 委派 prompt,而终态帧常常是这一行**唯一**带全 usage 的一帧(bg lane 只在活动边界发行帧)。
                 if (
-                // 最终用量也算(终态帧常是唯一带全 usage 的一帧;消费端不更新非 running 行 ⇒ 必须赶在 end 之前发)
-                (tokens !== undefined && prev?.tokens !== tokens) ||
+                // 0.74.0:周期身份本身推进(或首帧就带身份)也是变化 —— 消费端要先记下身份才能对 end 判陈旧。
+                rowNewerCycle ||
+                    (cycleSeq !== undefined && prev?.cycleSeq !== cycleSeq) || // 含首帧(prev 缺席)就带身份的终态
+                    // 最终用量也算(终态帧常是唯一带全 usage 的一帧;消费端不更新非 running 行 ⇒ 必须赶在 end 之前发)
+                    (tokens !== undefined && prev?.tokens !== tokens) ||
                     (toolUses !== undefined && prev?.toolUses !== toolUses) ||
                     (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
                     (startedAt !== undefined && prev?.startedAt !== startedAt)) {
@@ -174,6 +201,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                         ...(toolUses !== undefined ? { toolUses } : {}),
                         ...(transcriptId !== undefined ? { transcriptId } : {}),
                         ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
+                        ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                     });
                 }
                 publishEngineAgentPanelEvent({
@@ -183,6 +211,9 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                     //    **同一个病形**(内联两词 ⇒ core [6908] 的 `blocked` 漏成「成功」)。两处一次改齐,
                     //    读同一个单铸谓词;只修当格 = 下一次加词又漏一处。
                     isError: isTerminalNotSuccess(status),
+                    // 0.74.0:这条终态属于哪个周期(在场才带)—— 消费端据此挡掉上一周期迟到的 end。
+                    ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
+                    ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
                 });
             }
             seenMap.set(taskId, {
@@ -191,6 +222,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
                 transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
                 startedAt: knownStartedAt,
+                cycleSeq: knownCycleSeq,
                 currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
                 lastSeenAt: nowMs,
                 settled: true,
@@ -212,6 +244,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             (toolUses !== undefined && prev.toolUses !== toolUses) ||
             (transcriptId !== undefined && prev.transcriptId !== transcriptId) ||
             (startedAt !== undefined && prev.startedAt !== startedAt) ||
+            (cycleSeq !== undefined && prev.cycleSeq !== cycleSeq) ||
             (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
             publishEngineAgentPanelEvent({
                 kind: 'fleet-row',
@@ -223,6 +256,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 ...(toolUses !== undefined ? { toolUses } : {}),
                 ...(transcriptId !== undefined ? { transcriptId } : {}),
                 ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
+                ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                 ...(currentTool !== undefined ? { currentTool } : {}),
             });
         }
@@ -233,6 +267,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
             transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
             startedAt: knownStartedAt,
+            cycleSeq: knownCycleSeq,
             currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
             lastSeenAt: nowMs,
             settled: false,

package/dist/hitl/planReviewWire.js

@@ -558,6 +558,16 @@ releaseLatch) {
                         'The plan approval was NOT applied: the engine refused "auto-accept edits" for this task (it was not started read-only in plan mode, so that option does not apply). ' +
                             'Nothing changed engine-side — the plan is still waiting for review. Tell the user plainly, and that approving with "manually approve edits" will go through.';
                 }
+                else if (status === 404 && refusedCode === 'not_found.plan_review') {
+                    // 0.73.5:这道门已经不在了(早先的决断已生效,或已过期)。现场形:用户在一张**陈旧的重开卡**上作答 ⇒ 404;
+                    // 通用句「decision failed: HTTP 404 …」被模型读成「计划被拒 / 计划失败」,于是对用户说计划被拒并重新规划 ——
+                    // 而那份计划其实已批准并跑完。⇒ 明说这不是拒绝也不是失败,只是这次作答没有对象;效果态仍是 not_applied。
+                    hostLog('debug', `planReviewWire: ${decision} → 404 not_found.plan_review (no pending plan review any more — an earlier decision likely settled it)`);
+                    effect = 'not_applied';
+                    outcome =
+                        `This ${decision} was not applied: the engine no longer has a pending plan review for this task — an earlier decision most likely already went through (or the review expired). ` +
+                            'This is NOT a rejection of the plan and NOT a failure of the task; the answer just given simply had nothing left to act on.';
+                }
                 else if (typeof status === 'number') {
                     const msg = e instanceof Error ? e.message : String(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${status} ${msg.slice(0, 200)}`);

package/dist/hitl/toolApprovalWire.d.ts

@@ -1107,11 +1107,17 @@ export interface ToolApprovalFrame {
 }
 /**
  * 根外读 ask 附的「把 `dir` 加为本会话读目录」候选(core 7.19.0 #803;sdk 9.6.0 帧键第 30 员)。
- * 穷举表恰一臂:`clearsThisAsk` 域 = {true}。`dir` 原样(不截、不归一);两键形之外的成员不过境。
+ * 穷举表恰一臂:`clearsThisAsk` 域 = {true}。`dir` 原样(不截、不归一);声明之外的成员不过境。
  */
 export interface ReadRootCandidateView {
     dir: string;
     clearsThisAsk: true;
+    /**
+     * 0.73.6 —— `"exact"`(core ≥7.22.0 / server ≥7.85.0):**`dir` 这一串不是目录**,是命令点名的那条路径本身
+     * (`cat ~/.gitconfig` 的 `~/.gitconfig`)。消费端必须**逐字添加这一串**;展成目录模式(`<dir>/**`)授不到任何东西、
+     * 卡还在。渲染按它分支:在场那格不要说成「授权这个目录」。**缺席 = 目录出路,逐字节同旧;只读在场,永不读缺席。**
+     */
+    covers?: 'exact';
 }
 /** {@link ToolApprovalFrame.delegation} 的形(命名形,不用内联匿名 —— typeshape 门 B4 棘轮口径)。 */
 export interface ToolApprovalDelegation {

package/dist/hitl/toolApprovalWire.js

@@ -522,13 +522,17 @@ parkGatedCallId) {
             }
     }
 }
-/** 帧上 `readRootCandidate` 的窄读(模块内部,不出公面):在场且形对 ⇒ 新铸两键形;缺席 / 坏形 ⇒ undefined(键不置)。 */
+/** 帧上 `readRootCandidate` 的窄读(模块内部,不出公面):在场且形对 ⇒ 新铸两键形(`covers: "exact"` 在场时三键);缺席 / 坏形 ⇒ undefined(键不置)。 */
 function readReadRootCandidate(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
     const o = v;
     if (typeof o.dir !== 'string' || o.dir.length === 0 || o.clearsThisAsk !== true)
         return undefined;
+    // `covers` 域 = {缺席, "exact"}。出闭集(含键在场而值 undefined)⇒ **整只座不过境**,不是「摘掉坏成员、其余照发」:
+    // 两种读法在人那一侧是相反的动作(逐字添加 vs 加目录),发一半会让人按错的那一种回授。与上游同一处置。
+    if ('covers' in o)
+        return o.covers === 'exact' ? { dir: o.dir, clearsThisAsk: true, covers: 'exact' } : undefined;
     return { dir: o.dir, clearsThisAsk: true };
 }
 /**

package/dist/index.d.ts

@@ -227,6 +227,7 @@ export * from './headlessPermissionModeWire.js';
 export * from './headlessReconnectWire.js';
 export * from './fleet/fleetProjection.js';
 export * from './fleet/fleetLedger.js';
+export * from './fleet/workflowSizeWarning.js';
 export * from './subagent/engineDelegatedPrompt.js';
 export * from './subagent/engineRowStopGate.js';
 export * from './subagent/engineSubagentOutput.js';

package/dist/index.js

@@ -364,6 +364,8 @@ export * from './headlessReconnectWire.js';
 //   · `engineWireTarget.ts` 的 `installed` —— 非 Node 宿主的显式 wire 目标。
 export * from './fleet/fleetProjection.js';
 export * from './fleet/fleetLedger.js';
+// 0.73.5(CC-58):workflow 规模告警判定(三态;缺席 = 不知道,未知的规模不当作规模正常)。
+export * from './fleet/workflowSizeWarning.js';
 export * from './subagent/engineDelegatedPrompt.js';
 export * from './subagent/engineRowStopGate.js';
 export * from './subagent/engineSubagentOutput.js';

package/dist/notifications.js

@@ -931,6 +931,9 @@ export function enqueueBgChildNotification(n) {
                 //    后台 run 在面板上被 settle 成**成功**。🔴 `suspended`/`needs_review` 仍不在表里
                 //    (那两词是「等一次人的决定」,判成终局会把一条正等着你的 run 在面板上判死)。
                 isError: isTerminalNotSuccess(n.status),
+                // 0.74.0:周期身份 —— **wire 真给了 seq 才带**。上面的 `cycle` 是去重键用的归一值(缺席归一成首周期),
+                // 那是键不是事实;把它上屏等于对一条没报代际的通知声称「这是第一代」。
+                ...(typeof n.seq === 'number' && Number.isInteger(n.seq) && n.seq >= BG_FIRST_SEQ ? { cycleSeq: n.seq } : {}),
             });
         }
         catch {

package/dist/subagentContentStore.d.ts

@@ -260,6 +260,8 @@ export declare function settleSubagentContent(taskId: string): void;
 export declare function clearSubagentContent(taskId: string): void;
 export interface BgTerminalFacts {
     status: string;
+    /** 0.74.0 —— 这份终局属于哪个周期(通知带 `seq` 时记;缺席 = 通知没报)。洗绿保护只在同周期内生效。 */
+    cycleSeq?: number;
     summary?: string;
     recentSteps?: Array<{
         tool?: string;