@sema-agent/client-core 0.12.2 → 0.14.0

package/dist/fleet/fleetLedger.d.ts

@@ -34,10 +34,12 @@
  *   关流封装),壳的 `engineBgProbe.ts:8-9` 自述「引擎 fleet 面只有 SSE,没有一次性口」已过期。
  *   本包出 `fleetSnapshotOptions()`;`engineBgProbe` 的手抄开流即断由壳侧换 verb(见交接报告)。
  *
- * ── 单实例纪律 ────────────────────────────────────────────────────────────────────────────────
- * `liveBgViews` 是 module 级 Set:写者 = 每个 `createFleetLedger()`,读者 = 引擎温切门
- * (`readEngineActiveBgTasks`)与代际让位读面(`isFleetSessionScoped`)。两份实例 = 温切门恒读空
- * ⇒ respawn 会静默杀掉在飞 bg 子代。
+ * ── 单实例纪律(REF-CC-044,fleet2-06:per-sessionKey 化,W1/design/161 同款原语)────────────────
+ * `liveBgViews` 是 module 级 `Map<sessionKey, Set<LiveBgView>>`:写者 = 每个 `createFleetLedger()`
+ * (登记进自己的 `opts.sessionKey`,零参 = `DEFAULT_SESSION_KEY`),读者 = 引擎温切门
+ * (`readEngineActiveBgTasks[For]`)与代际让位读面(`isFleetSessionScoped[For]`)。同一 sessionKey
+ * 两份实例 = 温切门恒读空 ⇒ respawn 会静默杀掉在飞 bg 子代;per-session 化同时堵住了跨会话污染
+ * (A 会话的 `clearAllRetainedFleetRows` 不该清掉 B 会话的池,B 断线也不该把 A 标 fresh)。
  */
 import type { FleetFrame, FleetTaskRow } from '@sema-agent/sdk';
 import { type FleetTaskView, type FleetWorkflowView, type ProjectTasksOptions } from './fleetProjection.js';
@@ -63,14 +65,20 @@ export interface EngineActiveBgReading {
  *    仍广播,fail-closed 是 1.245+)。
  */
 export declare function isFleetSessionScoped(): boolean;
+/** W1 keyed variant:只看**这一个会话**登记的视图(REF-CC-044)。 */
+export declare function isFleetSessionScopedFor(sessionKey: string): boolean;
 /** 引擎侧在飞 bg 子代读数(union 所有未 dispose 的源,按 row.id 去重)。无 live 源 ⇒ `{[], false}`。 */
 export declare function readEngineActiveBgTasks(): EngineActiveBgReading;
+/** W1 keyed variant(REF-CC-044):只 union **这一个会话**登记的视图,不跨会话泄漏。 */
+export declare function readEngineActiveBgTasksFor(sessionKey: string): EngineActiveBgReading;
 /**
- * 清空所有 live 源的终态留存池 —— 会话切换(/clear、REPL 内 resume、fork)信号一到就调。
- * R7:留存池是渲染层宽限窗,快照臂刻意不清它(重连不该抽走行);但换了会话继续渲上一会话的
- * 终态行(名字 = objective 派生)就是跨会话残影。
+ * 清空**这一个会话**的所有 live 源的终态留存池 —— 会话切换(/clear、REPL 内 resume、fork)信号
+ * 一到就调。R7:留存池是渲染层宽限窗,快照臂刻意不清它(重连不该抽走行);但换了会话继续渲上一
+ * 会话的终态行(名字 = objective 派生)就是跨会话残影。
  */
 export declare function clearAllRetainedFleetRows(): void;
+/** W1 keyed variant(REF-CC-044):只清**这一个会话**的池,不广播到别的会话。 */
+export declare function clearAllRetainedFleetRowsFor(sessionKey: string): void;
 /** 测试钩:摘掉所有登记的视图(同进程多组断言之间互不污染)。 */
 export declare function __resetFleetLedgerRegistryForTests(): void;
 /**
@@ -87,12 +95,25 @@ export declare function fleetSnapshotOptions(opts?: {
     session?: string;
     timeoutMs?: number;
 };
+/** REF-CC-047(fleet2-09):hook_notice 具名臂(B2 禁 unknown 出公开面;Extract 同款手法已在
+ *  文件内的 `BgNotificationWire` 示范过)。 */
+export type HookNoticeFrame = Extract<FleetFrame, {
+    type: 'hook_notice';
+}>;
 export interface FleetLedgerHooks {
     /**
      * hook_notice 帧的**写 store** 半场(判定在 `classifyHookNoticeFrame`,本台账只做分发)。
      * 返回值忽略;不给 = 该帧被静默丢弃(端没有承载面时的正确行为)。
      */
-    onHookNotice?(frame: unknown, sessionScoped: boolean): void;
+    onHookNotice?(frame: HookNoticeFrame, sessionScoped: boolean): void;
+}
+/** REF-CC-044(fleet2-06)/REF-CC-039(fleet2-01):`createFleetLedger` 的可选装配位。 */
+export interface CreateFleetLedgerOptions {
+    /** per-session 注册键(W1 同款;多会话宿主每会话一份,零参 = `DEFAULT_SESSION_KEY`)。 */
+    sessionKey?: string;
+    /** 本地接收时钟注入(测试用确定性时钟;默认 `Date.now`)。REF-CC-039:帧到达时刻的**单一铸点**,
+     *  绝不能用 wire 上的 server 时刻(`frame.ts`)顶替 —— 两个不同时钟域的算术是缺陷,不是特性。 */
+    nowFn?: () => number;
 }
 export interface FleetLedgerStatus {
     connected: boolean;
@@ -102,6 +123,8 @@ export interface FleetLedgerStatus {
     bgNotifyFailClosed: boolean;
     taskCount: number;
     workflowCount: number;
+    /** REF-CC-051(fleet2-13):畸形帧/通知早退的留痕计数(C5 静默丢数据零容忍)。 */
+    droppedMalformed: number;
 }
 export interface FleetLedger {
     /** 消费一帧(consumer-side active-set update-in-place / remove)。 */
@@ -129,4 +152,4 @@ export interface FleetLedger {
  * 建一个 fleet 帧台账。**不开流、不构造 client** —— 宿主的 consume 循环把解码后的帧喂进来。
  * (这条切缝就是设计稿 §2.5 给 fleetClient 划的那一刀:帧体归库、连接归端。)
  */
-export declare function createFleetLedger(hooks?: FleetLedgerHooks): FleetLedger;
+export declare function createFleetLedger(hooks?: FleetLedgerHooks, opts?: CreateFleetLedgerOptions): FleetLedger;

package/dist/fleet/fleetLedger.js

@@ -7,10 +7,15 @@ import { enqueueBgChildNotification, isOwnWorkflowRun } from '../notifications.j
 import { isOwnEngineRun, recordBgParentRun, recordBgTerminalFacts, recordOwnEngineRun, } from '../subagentContentStore.js';
 import { rowIdTail } from '../workflow.js';
 import { recordEngineTranscriptId } from '../subagent/engineDelegatedPrompt.js';
-import { TERMINAL_FLEET_TASK_STATUSES, projectTasks, projectWorkflows, } from './fleetProjection.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { TERMINAL_FLEET_TASK_STATUSES, projectTasks, projectWorkflows, wireParentId, } from './fleetProjection.js';
 /** 终态行留存宽限窗(187 的 agents 页把完成会话留在列表;窗过即净,防长会话堆行)。 */
 export const TERMINAL_RETAIN_MS = 60_000;
-const liveBgViews = new Set();
+/** REF-CC-044(fleet2-06):per-sessionKey 注册表(W1 同款 `Map<sessionKey, T>` 形)。 */
+const liveBgViews = new Map();
+function viewsFor(sessionKey) {
+    return liveBgViews.get(sessionKey) ?? new Set();
+}
 /**
  * server 代际证据读面:任一 live fleet 源的 meta 报过 `sessionScoped=true`。
  * true ⇒ 到达本连接的**行帧**已经过 server 会话过滤,端侧行级 own 判别可以让位。
@@ -18,7 +23,11 @@ const liveBgViews = new Set();
  *    仍广播,fail-closed 是 1.245+)。
  */
 export function isFleetSessionScoped() {
-    for (const view of liveBgViews) {
+    return isFleetSessionScopedFor(DEFAULT_SESSION_KEY);
+}
+/** W1 keyed variant:只看**这一个会话**登记的视图(REF-CC-044)。 */
+export function isFleetSessionScopedFor(sessionKey) {
+    for (const view of viewsFor(sessionKey)) {
         try {
             if (view.sessionScoped() === true)
                 return true;
@@ -31,9 +40,13 @@ export function isFleetSessionScoped() {
 }
 /** 引擎侧在飞 bg 子代读数(union 所有未 dispose 的源,按 row.id 去重)。无 live 源 ⇒ `{[], false}`。 */
 export function readEngineActiveBgTasks() {
+    return readEngineActiveBgTasksFor(DEFAULT_SESSION_KEY);
+}
+/** W1 keyed variant(REF-CC-044):只 union **这一个会话**登记的视图,不跨会话泄漏。 */
+export function readEngineActiveBgTasksFor(sessionKey) {
     const byId = new Map();
     let fresh = false;
-    for (const view of liveBgViews) {
+    for (const view of viewsFor(sessionKey)) {
         try {
             const r = view.read();
             if (r.connected)
@@ -48,12 +61,16 @@ export function readEngineActiveBgTasks() {
     return { tasks: [...byId.values()], fresh };
 }
 /**
- * 清空所有 live 源的终态留存池 —— 会话切换(/clear、REPL 内 resume、fork)信号一到就调。
- * R7:留存池是渲染层宽限窗,快照臂刻意不清它(重连不该抽走行);但换了会话继续渲上一会话的
- * 终态行(名字 = objective 派生)就是跨会话残影。
+ * 清空**这一个会话**的所有 live 源的终态留存池 —— 会话切换(/clear、REPL 内 resume、fork)信号
+ * 一到就调。R7:留存池是渲染层宽限窗,快照臂刻意不清它(重连不该抽走行);但换了会话继续渲上一
+ * 会话的终态行(名字 = objective 派生)就是跨会话残影。
  */
 export function clearAllRetainedFleetRows() {
-    for (const view of liveBgViews) {
+    clearAllRetainedFleetRowsFor(DEFAULT_SESSION_KEY);
+}
+/** W1 keyed variant(REF-CC-044):只清**这一个会话**的池,不广播到别的会话。 */
+export function clearAllRetainedFleetRowsFor(sessionKey) {
+    for (const view of viewsFor(sessionKey)) {
         try {
             view.clearRetained();
         }
@@ -86,13 +103,18 @@ export function fleetSnapshotOptions(opts) {
  * 建一个 fleet 帧台账。**不开流、不构造 client** —— 宿主的 consume 循环把解码后的帧喂进来。
  * (这条切缝就是设计稿 §2.5 给 fleetClient 划的那一刀:帧体归库、连接归端。)
  */
-export function createFleetLedger(hooks = {}) {
+export function createFleetLedger(hooks = {}, opts = {}) {
+    const sessionKey = opts.sessionKey ?? DEFAULT_SESSION_KEY;
+    const nowFn = opts.nowFn ?? Date.now;
     const taskMap = new Map();
     const wfMap = new Map();
-    /** [1481]①「elapsed 恒 0s」补偿:记每行最后一帧到达时刻(引擎只在活动边界重发行)。 */
+    /** [1481]①「elapsed 恒 0s」补偿:记每行**本地接收**时刻(引擎只在活动边界重发行)。
+     *  REF-CC-039:字段标域改名 `receivedAtMs` —— 装的是 `nowFn()`,绝不是 wire 上的 `frame.ts`。 */
     const rowMeta = new Map();
-    /** [1481]②「完成即消失」补偿:终态行进留存池,宽限窗内继续投影。 */
+    /** [1481]②「完成即消失」补偿:终态行进留存池,宽限窗内继续投影。`expireAt` 同样锚本地钟。 */
     const retained = new Map();
+    /** REF-CC-051(fleet2-13):畸形帧/通知早退计数(与同文件的策略性丢弃 debug 行对称留痕)。 */
+    let droppedMalformed = 0;
     let connected = false;
     let version = null;
     let scoped = null;
@@ -108,19 +130,35 @@ export function createFleetLedger(hooks = {}) {
             connected,
             rows: [...taskMap.values()]
                 .filter(r => !TERMINAL_FLEET_TASK_STATUSES.has(r.status ?? ''))
-                .map(r => ({
-                id: r.id,
-                name: r.name,
-                status: r.status ?? 'running',
-                ...(r.parentId ? { parentId: r.parentId } : {}),
-            })),
+                .map(r => {
+                const parentId = wireParentId(r);
+                return {
+                    id: r.id,
+                    // REF-CC-046(fleet2-08,含 TYPESHAPE-06):与 parentId 同款条件展开 —— `name` 是三态位
+                    // (server ≥3.5.1 起真的会缺席),无条件落键会让「键在不在」判三态在序列化边界翻面。
+                    ...(typeof r.name === 'string' && r.name.length > 0 ? { name: r.name } : {}),
+                    // REF-CC-052(fleet2-14):`status` 是 SDK 必填闭集,但脏值/缺席仍可能到达 wire —— 不知道
+                    // 就说不知道,`'unknown'` 是自描述哨兵,绝不编造一个具体的、看似活跃的 `'running'`。
+                    status: r.status ?? 'unknown',
+                    // REF-CC-049(fleet2-11):经 wireParentId 单一铸点(悬空父脏值空串按缺席处理)。eopt:
+                    // 局部变量先取一次(两次裸调用之间 TS 不共享窄化,双调用会重新变宽成 string|undefined)。
+                    ...(parentId !== undefined ? { parentId } : {}),
+                };
+            }),
         }),
         sessionScoped: () => sessionScopedMeta,
         clearRetained: () => {
             retained.clear();
         },
     };
-    liveBgViews.add(bgView);
+    {
+        let views = liveBgViews.get(sessionKey);
+        if (!views) {
+            views = new Set();
+            liveBgViews.set(sessionKey, views);
+        }
+        views.add(bgView);
+    }
     function applyFrame(frame) {
         switch (frame.type) {
             case 'meta': {
@@ -143,10 +181,12 @@ export function createFleetLedger(hooks = {}) {
                 taskMap.clear();
                 wfMap.clear();
                 rowMeta.clear();
-                const at = frame.ts;
+                // REF-CC-039(fleet2-01):单一铸点 —— 整批快照行共享**同一次**本地接收时刻,绝不用
+                // wire 上的 `frame.ts`(server 时刻,server 省略该键时兜成 0,与本地钟不同域)。
+                const receivedAtMs = nowFn();
                 for (const row of frame.tasks) {
                     taskMap.set(row.id, row);
-                    rowMeta.set(row.id, { receivedAt: at });
+                    rowMeta.set(row.id, { receivedAtMs });
                 }
                 for (const row of frame.workflows)
                     wfMap.set(row.id, row);
@@ -154,10 +194,15 @@ export function createFleetLedger(hooks = {}) {
             }
             case 'task': {
                 const row = frame.row;
-                if (!row?.id)
+                if (!row?.id) {
+                    droppedMalformed++;
+                    debug('[fleet-frame] MALFORMED task frame dropped(row 或 row.id 缺席)');
                     break;
+                }
+                // REF-CC-039(fleet2-01):同一个字段只有一个铸点 —— 本地接收时刻,不是 `frame.ts`。
+                const receivedAtMs = nowFn();
                 taskMap.set(row.id, row); // POST-MERGE FULL row → replace by id
-                rowMeta.set(row.id, { receivedAt: frame.ts });
+                rowMeta.set(row.id, { receivedAtMs });
                 debug(`[fleet-row] id=${row.id} parent=${row.parentId ?? '-'} agentType=${row.agentType ?? '-'}` +
                     ` agentName=${row.agentName ?? '-'} name=${row.name ?? '-'} status=${row.status ?? '-'}` +
                     ` tokens=${row.tokens ?? 0} parentToolCallId=${row.parentToolCallId ?? '-'}`);
@@ -169,9 +214,10 @@ export function createFleetLedger(hooks = {}) {
                 //     (或无标行)→ 登映射**不登台账**(台账只收硬证据,防无标外来行污染台账后反过来给
                 //     通知臂放行);这也保住「壳重启+resume 接回会话」的终报 hydrate;
                 //   · 两者都不是(老代际广播窗)→ 不登映射(隔离优先)。
-                if (row.parentId) {
+                const parentId = wireParentId(row);
+                if (parentId !== undefined) {
                     const childTid = rowIdTail(row.id);
-                    const parentTid = rowIdTail(row.parentId);
+                    const parentTid = rowIdTail(parentId);
                     const parentOwned = isOwnEngineRun(parentTid);
                     if (parentOwned)
                         recordOwnEngineRun(childTid);
@@ -188,8 +234,14 @@ export function createFleetLedger(hooks = {}) {
                     recordEngineTranscriptId(rowIdTail(row.id), row.transcriptId);
                 }
                 // 终态帧 → 留存池(remove 同毫秒尾随,probe 实证;留存让 completed band 数得到它)。
+                // REF-CC-040(fleet2-02):非终态分支必须显式 delete —— 否则 bg 复活(SendMessage 后
+                // seq+1)时,`project()` 因 `taskMap.has(id)` 恒 continue 而永不清理过期留存条目,belt
+                // 的 `!retained.has()` 前提失守,第二周期的终态被首周期的陈旧快照挡在门外。
                 if (TERMINAL_FLEET_TASK_STATUSES.has(row.status ?? '')) {
-                    retained.set(row.id, { row, expireAt: frame.ts + TERMINAL_RETAIN_MS });
+                    retained.set(row.id, { row, expireAt: receivedAtMs + TERMINAL_RETAIN_MS });
+                }
+                else {
+                    retained.delete(row.id);
                 }
                 break;
             }
@@ -198,8 +250,13 @@ export function createFleetLedger(hooks = {}) {
                 rowMeta.delete(frame.id);
                 break;
             case 'workflow':
-                if (frame.row?.id)
+                if (frame.row?.id) {
                     wfMap.set(frame.row.id, frame.row);
+                }
+                else {
+                    droppedMalformed++;
+                    debug('[fleet-frame] MALFORMED workflow frame dropped(row 或 row.id 缺席)');
+                }
                 break;
             case 'workflow_remove':
                 wfMap.delete(frame.id);
@@ -221,10 +278,16 @@ export function createFleetLedger(hooks = {}) {
                 break;
         }
     }
-    /** bg 子代终态通知帧([446] 帧契约,service 1.119):常开 lane 即时到达 → 转注入链。 */
+    /** bg 子代终态通知帧([446] 帧契约,service 1.119):常开 lane 即时到达 → 转注入链。
+     *  REF-CC-048(fleet2-10):参数类型此前写成 `FleetFrame extends never ? never : BgNotificationWire`
+     *  —— 条件类型只对**裸类型参数**分发,`FleetFrame` 是具体 union,整个表达式恒等于
+     *  `BgNotificationWire`,伪装成了一个从不成立的守卫。直写目标类型,不留误导性的仪式感。 */
     function applyBgNotification(n) {
-        if (typeof n?.taskId !== 'string' || typeof n?.status !== 'string')
+        if (typeof n?.taskId !== 'string' || typeof n?.status !== 'string') {
+            droppedMalformed++;
+            debug('[fleet-frame] MALFORMED bg_notification dropped(taskId 或 status 缺席/非串)');
             return;
+        }
         // 🔴 own/foreign 判别(双开泄漏案帧级防线;[1498]④ 换锚重写):payload `sessionId` 是**子代
         //   自身** session uuid,宿主会话在 ownerSessionId 上且出 wire 前被剥 —— 所以判别锚
         //   `parentTaskId`(spawn 该子代的 leader run id)对 own-run 台账:
@@ -282,11 +345,24 @@ export function createFleetLedger(hooks = {}) {
                     : {}),
             });
             // belt:终态**行帧**丢失(kill 竞态等)时,已知行也随通知转终态进留存池。
+            // REF-CC-040(fleet2-02):无条件覆盖(不再靠 `!retained.has()` 判「池里没有它」)—— 「谁写得
+            // 对」不该依赖清理时序;'task' 非终态分支现在会显式 delete,belt 这里覆盖同样安全。
+            // REF-CC-039:`expireAt` 同一铸点(`nowFn()`),不用 `Date.now()` 另开一个时钟域。
+            //
+            // 🔴 取舍写死(P3 wave2 回炉,复审 advisory①:finding proposal 两种形都允许,本处取的是
+            //    「无条件覆盖」而不是「按 seq 择新」,两个方向的后果各钉了一条常驻断言):
+            //    · **通知晚于终态行帧** ⇒ 覆盖。通知是 settle 权威(下方 `recordBgTerminalFacts` 就是
+            //      无条件按 `n.status` 记的账),留存池若不跟着覆盖,面板行渲 `completed` 而详情页写
+            //      `killed` = 同一帧两写分叉。钉:pure 门「留存池行的 status 与终态事实台账不分叉」。
+            //    · **非终态行帧晚于 belt** ⇒ 抹掉 belt 结果(`case 'task'` 的 `retained.delete`)。这正是
+            //      复活语义:行又活了,首周期的终态快照本就不该继续投影。钉:pure 门「复活(非终态)
+            //      一到就清留存条目 ⇒ 首周期陈旧终态行不得复现为幽灵」。
+            //    要改成 seq 择新形,先把这两条断言的期望值一起改 —— 它们是这个取舍的可执行形。
             const known = taskMap.get(n.taskId);
-            if (known && !retained.has(n.taskId)) {
+            if (known) {
                 retained.set(n.taskId, {
                     row: { ...known, status: n.status },
-                    expireAt: Date.now() + TERMINAL_RETAIN_MS,
+                    expireAt: nowFn() + TERMINAL_RETAIN_MS,
                 });
             }
         }
@@ -313,7 +389,7 @@ export function createFleetLedger(hooks = {}) {
             const meta = rowMeta.get(r.id);
             if (!meta)
                 return r;
-            const idle = Math.max(0, nowMs - meta.receivedAt);
+            const idle = Math.max(0, nowMs - meta.receivedAtMs);
             return idle > 0 ? { ...r, elapsedMs: (r.elapsedMs ?? 0) + idle } : r;
         });
         // ② 终态留存池:live 集没有的行在宽限窗内继续投影;被查看中的行不过期。
@@ -344,15 +420,18 @@ export function createFleetLedger(hooks = {}) {
                 return true;
             // 祖链闭包:孙代行 parentId=直接父(a… handle)而非 spawn run([1502] wire 事实)——
             // 沿 parentId 链上溯,任一环(或环的 parentId)∈ 本端 run 台账即 own。
+            // REF-CC-049(fleet2-11):`wireParentId` 单一铸点(空串按缺席),不再裸读 `cur.parentId`
+            // 做 `!== undefined` 判断 —— 那种写法对空串脏值判「有父」,与 case 'task' 那半支相反。
             const seen = new Set();
             let cur = r;
             while (cur && !seen.has(cur.id)) {
                 seen.add(cur.id);
                 if (isOwnEngineRun(cur.id))
                     return true;
-                if (cur.parentId !== undefined && isOwnEngineRun(cur.parentId))
+                const parentId = wireParentId(cur);
+                if (parentId !== undefined && isOwnEngineRun(parentId))
                     return true;
-                cur = cur.parentId !== undefined ? allRowsById.get(cur.parentId) : undefined;
+                cur = parentId !== undefined ? allRowsById.get(parentId) : undefined;
             }
             return false;
         };
@@ -383,10 +462,16 @@ export function createFleetLedger(hooks = {}) {
             bgNotifyFailClosed: bgNotifyFailClosedMeta,
             taskCount: taskMap.size,
             workflowCount: wfMap.size,
+            droppedMalformed,
         }),
         dispose() {
             disposed = true;
-            liveBgViews.delete(bgView);
+            const views = liveBgViews.get(sessionKey);
+            if (views) {
+                views.delete(bgView);
+                if (views.size === 0)
+                    liveBgViews.delete(sessionKey);
+            }
         },
         __rowsForTest: () => [...taskMap.values()],
     };

package/dist/fleet/fleetProjection.d.ts

@@ -50,9 +50,13 @@ export interface FleetTaskView {
     tokens: number;
     tokenDir: 'down' | 'up';
     queuedCount: number;
-    awaitingPlanApproval?: boolean;
-    descendantCount?: number;
-    viewed?: boolean;
+    /** REF-CC-050(fleet2-12):投影器无条件赋值(`?? false`),门 `ALWAYS_EMITTED_TASK_VIEW_KEYS`
+     *  已把它钉成「恒发」——类型必填而不是留一条测不到的缺席分支。 */
+    awaitingPlanApproval: boolean;
+    /** REF-CC-050:同上,`childCount.get(r.id) ?? 0` 恒赋值。 */
+    descendantCount: number;
+    /** REF-CC-050:同上,`viewingTaskId !== undefined && …` 恒赋值(布尔运算永不产 undefined)。 */
+    viewed: boolean;
     /** 🔴 三态:有键 ⇒ 真值(含真 0);缺键 ⇒ 「不知道」。绝不 `?? 0`。 */
     toolUses?: number;
     transcriptId?: string;
@@ -133,8 +137,15 @@ export declare const TERMINAL_FLEET_TASK_STATUSES: ReadonlySet<string>;
  *    design/153 §7.1),server 只是尚未投影 ⇒ 这不是「猜测层」,是**预挂**。
  *    删的收益 = 一行;删的代价 = server 补上透传那天静默说谎。
  *  ⇒ 保留 + 把「候 server 预挂」的注释换成上面这条可复核的直证。定谳权交回 PM。
+ *
+ * 🔴 REF-CC-043(fleet2-05,P2 裁 GO,宪法三问已过):`default` 分支此前渲 `'running'` ——
+ *  未知未来状态被谎报成「活跃」,后果方向是**伤害型**(用户会以为一个已经僵住/退场的子代还在跑)。
+ *  改渲 `'idle'`(闭集里本就存在的「非活跃」词,187 用它表示「非活跃、非终态、非阻塞」)—— 门
+ *  `ALWAYS_EMITTED_TASK_VIEW_KEYS` 不受影响,只是同一个已知渲染词的语义更诚实。
+ *  `s` 的参数类型同批收窄:`| undefined` 半支从未被真实调用点使用过(唯一生产调用点
+ *  `projectTasks` 传的是 SDK 必填闭集 `FleetTaskRow['status']`),继续留着是死分支。
  */
-export declare function coerceTaskStatus(s: string | undefined): FleetTaskStatus;
+export declare function coerceTaskStatus(s: string): FleetTaskStatus;
 /** 中性 workflow run 状态(running|completed|failed)→ 渲染词汇。 */
 export declare function coerceWorkflowStatus(s: string | undefined): FleetTaskStatus;
 /**
@@ -183,6 +194,13 @@ export declare function wireCurrentTool(r: Pick<FleetTaskRow, 'currentTool'>): {
 export declare function wireStartedCount(r: Pick<FleetWorkflowRow, 'startedCount'>): number | undefined;
 /** `parentToolCallId`(P1-2)—— 归属直读键。空串按缺席处理(引擎不该发,发了也别当真)。 */
 export declare function wireParentToolCallId(r: Pick<FleetTaskRow, 'parentToolCallId'>): string | undefined;
+/**
+ * `parentId` —— 悬空父的存在性判定唯一铸点(REF-CC-049,fleet2-11)。B10 禁真值判定当存在性判定:
+ * 空串是脏值形(SDK 只承诺「悬空不发」,那是 server 当下行为不是类型保证),按缺席处理。
+ * `fleetLedger.ts` 与本文件的 `projectTasks` 都调它 —— 一个谓词一个铸点,防止 `!== undefined`
+ * 与真值判定两种写法在同一字段上判读相反(悬空父脏值 `""` 时曾经真的翻过面)。
+ */
+export declare function wireParentId(r: Pick<FleetTaskRow, 'parentId'>): string | undefined;
 /** 终态四键之 `usage`(数值 verbatim,只挑数字位;全脏 ⇒ 整键缺席,不造空对象)。 */
 export declare function wireRowUsage(r: Pick<FleetTaskRow, 'usage'>): FleetRowUsage | undefined;
 /** 终态四键之 `editedFiles`(bg 子代专属;脏项逐条丢,不整键丢)。 */
@@ -220,6 +238,26 @@ export declare const FLEET_WORKFLOW_VIEW_KEYS: readonly string[];
 export declare const FLEET_TASK_ROW_WIRE_KEYS: readonly string[];
 /** SDK `FleetWorkflowRow` 的入口键名清单(同上)。 */
 export declare const FLEET_WORKFLOW_ROW_WIRE_KEYS: readonly string[];
+/**
+ * 不投影登记表的一条条目(REF-CC-053,fleet2-15,P2 裁 GO)。
+ *
+ * 🔴 表原先只要求「写够 20 字理由」,而一条自认的**已知缺口**(`currentAction`,补它=真行为改动)
+ * 与三条**设计取舍**(折进别的键 / 归属权威在别处)共用同一条放行通道 —— 门只能证明「有人表过态」,
+ * 证明不了这态是「已裁定不做」还是「欠着没人管」。`kind` 把两者拆成两条不同的路:
+ *   · `by-design`:裁定不投影,不需要到期日(它不会自己变成待办)。
+ *   · `known-gap`:真缺口,`dueDate` 到期未清 ⇒ 门红(与规范「具名豁免带属主与到期日,过期即红」
+ *     同款,`run-fleet-view-keys-test.mjs` 的 D 段做校验)。
+ */
+export interface NotProjectedEntry {
+    /** 为什么不投影(≥20 字,原「理由」字段原样保留)。 */
+    reason: string;
+    /** `by-design` = 裁定的架构取舍;`known-gap` = 自认的缺口,不是取舍。 */
+    kind: 'by-design' | 'known-gap';
+    /** 谁负责这条判定 / 谁负责把 known-gap 补上。 */
+    owner: string;
+    /** 仅 `known-gap` 必填:ISO 日期,过期未清 = 门红(禁无期限豁免)。 */
+    dueDate?: string;
+}
 /**
  * **不投影登记表**:wire 上有、`FleetTaskView` 上**故意没有**的键,每条必须写清理由。
  *
@@ -228,7 +266,7 @@ export declare const FLEET_WORKFLOW_ROW_WIRE_KEYS: readonly string[];
  * 每个 wire 键只有两条出路:**要么投影出去,要么在这里写下不投的理由**;新 wire 键在覆盖账那条
  * 腿上当场红,不给「悄悄没人管」留位置。
  */
-export declare const FLEET_TASK_ROW_KEYS_NOT_PROJECTED: Readonly<Record<string, string>>;
+export declare const FLEET_TASK_ROW_KEYS_NOT_PROJECTED: Readonly<Record<string, NotProjectedEntry>>;
 /** workflow 行:wire 十键与视图十键一一同名同义 ⇒ 本表**空**(空不是「忘了填」,是覆盖账那条腿
  *  每跑一次都在证明它该空:少投一个键就红)。 */
-export declare const FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED: Readonly<Record<string, string>>;
+export declare const FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED: Readonly<Record<string, NotProjectedEntry>>;

package/dist/fleet/fleetProjection.js

@@ -24,6 +24,13 @@ export const TERMINAL_FLEET_TASK_STATUSES = new Set([
  *    design/153 §7.1),server 只是尚未投影 ⇒ 这不是「猜测层」,是**预挂**。
  *    删的收益 = 一行;删的代价 = server 补上透传那天静默说谎。
  *  ⇒ 保留 + 把「候 server 预挂」的注释换成上面这条可复核的直证。定谳权交回 PM。
+ *
+ * 🔴 REF-CC-043(fleet2-05,P2 裁 GO,宪法三问已过):`default` 分支此前渲 `'running'` ——
+ *  未知未来状态被谎报成「活跃」,后果方向是**伤害型**(用户会以为一个已经僵住/退场的子代还在跑)。
+ *  改渲 `'idle'`(闭集里本就存在的「非活跃」词,187 用它表示「非活跃、非终态、非阻塞」)—— 门
+ *  `ALWAYS_EMITTED_TASK_VIEW_KEYS` 不受影响,只是同一个已知渲染词的语义更诚实。
+ *  `s` 的参数类型同批收窄:`| undefined` 半支从未被真实调用点使用过(唯一生产调用点
+ *  `projectTasks` 传的是 SDK 必填闭集 `FleetTaskRow['status']`),继续留着是死分支。
  */
 export function coerceTaskStatus(s) {
     switch (s) {
@@ -40,7 +47,8 @@ export function coerceTaskStatus(s) {
         case 'parked':
             return 'awaiting approval';
         default:
-            return 'running'; // unknown future status → render as a generic live row (open-set fallback)
+            // 未知未来状态 → 渲成非活跃中性词(开集回落;绝不谎报活跃,REF-CC-043)。
+            return 'idle';
     }
 }
 /** 中性 workflow run 状态(running|completed|failed)→ 渲染词汇。 */
@@ -145,6 +153,16 @@ export function wireParentToolCallId(r) {
     const v = r.parentToolCallId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+/**
+ * `parentId` —— 悬空父的存在性判定唯一铸点(REF-CC-049,fleet2-11)。B10 禁真值判定当存在性判定:
+ * 空串是脏值形(SDK 只承诺「悬空不发」,那是 server 当下行为不是类型保证),按缺席处理。
+ * `fleetLedger.ts` 与本文件的 `projectTasks` 都调它 —— 一个谓词一个铸点,防止 `!== undefined`
+ * 与真值判定两种写法在同一字段上判读相反(悬空父脏值 `""` 时曾经真的翻过面)。
+ */
+export function wireParentId(r) {
+    const v = r.parentId;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
 /** 终态四键之 `usage`(数值 verbatim,只挑数字位;全脏 ⇒ 整键缺席,不造空对象)。 */
 export function wireRowUsage(r) {
     const u = r.usage;
@@ -211,6 +229,7 @@ export function projectTasks(allRows, opts) {
         const toolUses = wireToolUses(r);
         const transcriptId = wireTranscriptId(r);
         const currentTool = wireCurrentTool(r);
+        const parentId = wireParentId(r);
         const parentToolCallId = wireParentToolCallId(r);
         const stoppedBy = wireStoppedBy(r);
         const usage = wireRowUsage(r);
@@ -222,7 +241,7 @@ export function projectTasks(allRows, opts) {
             // 子行帧无 description → 从 name 复原任务描述(CC 锚:行正文恒显 description,不留空列)。
             description: projectDescription(r.description) || taskDescFromName(r.name, r.agentType, r.agentName),
             depth: depthOf(r),
-            ...(r.parentId !== undefined ? { parentId: r.parentId } : {}),
+            ...(parentId !== undefined ? { parentId } : {}),
             status: coerceTaskStatus(r.status),
             elapsedMs: r.elapsedMs ?? 0,
             tokens: r.tokens ?? 0,
@@ -368,16 +387,39 @@ export const FLEET_WORKFLOW_ROW_WIRE_KEYS = FLEET_WORKFLOW_ROW_WIRE_KEY_TUPLE;
  * 腿上当场红,不给「悄悄没人管」留位置。
  */
 export const FLEET_TASK_ROW_KEYS_NOT_PROJECTED = {
-    sourceLane: 'SDK 3.0.0 新键([2070]① 让位半场:前台 delegation 复合 id 行带 "run-leg" 标)。两仓现零消费面 ——' +
-        '#95 纪律:没人读的键不盲投。已知潜在消费方=壳 wf-panel 的双生行过滤(现走 taskId 台账补偿),' +
-        '若迁到本键判别则届时投影并删本条(那是行为改动,单独批)。',
-    agentType: '折进 `name`(deriveAgentLabel:agentName ?? agentType,都缺才退 objective 派生)——渲染契约只有一个身份列,187 的 tjl 同形。',
-    agentName: '同 agentType:两位在本层合成一个身份 label,分开带出去等于把 187 的 tjl 规则推给每个消费端各写一遍。',
-    workflowRunId: 'workflow 归属**不走行字段**:权威判定在 adapt 的 task_progress 臂(recordWorkflowAgentTaskId,判据④),端按 taskId 尾段查台账过滤双生行。行上再带一份 = 第二真源。',
-    currentAction: '结构化同源体 `currentTool` 已投影(SDK 注:currentAction 是它的**文本回落**)。🔴 诚实记账:旧端(server <1.288)只发 currentAction ⇒ 那一档上本视图今天确实拿不到活动文本,这是**已知缺口**不是设计取舍;补它 = 加 `currentAction?: string` 进本视图 + 端侧回落渲染。',
+    sourceLane: {
+        kind: 'by-design',
+        owner: 'client-core 规范重构轮',
+        reason: 'SDK 3.0.0 新键([2070]① 让位半场:前台 delegation 复合 id 行带 "run-leg" 标)。两仓现零消费面 ——' +
+            '#95 纪律:没人读的键不盲投。已知潜在消费方=壳 wf-panel 的双生行过滤(现走 taskId 台账补偿),' +
+            '若迁到本键判别则届时投影并删本条(那是行为改动,单独批)。',
+    },
+    agentType: {
+        kind: 'by-design',
+        owner: 'client-core 规范重构轮',
+        reason: '折进 `name`(deriveAgentLabel:agentName ?? agentType,都缺才退 objective 派生)——渲染契约只有一个身份列,187 的 tjl 同形。',
+    },
+    agentName: {
+        kind: 'by-design',
+        owner: 'client-core 规范重构轮',
+        reason: '同 agentType:两位在本层合成一个身份 label,分开带出去等于把 187 的 tjl 规则推给每个消费端各写一遍。',
+    },
+    workflowRunId: {
+        kind: 'by-design',
+        owner: 'client-core 规范重构轮',
+        reason: 'workflow 归属**不走行字段**:权威判定在 adapt 的 task_progress 臂(recordWorkflowAgentTaskId,判据④),端按 taskId 尾段查台账过滤双生行。行上再带一份 = 第二真源。',
+    },
+    currentAction: {
+        kind: 'known-gap',
+        owner: 'client-core 规范重构轮',
+        dueDate: '2027-02-01',
+        reason: '结构化同源体 `currentTool` 已投影(SDK 注:currentAction 是它的**文本回落**)。🔴 诚实记账:旧端(server <1.288)只发 currentAction ⇒ 那一档上本视图今天确实拿不到活动文本,这是**已知缺口**不是设计取舍;补它 = 加 `currentAction?: string` 进本视图 + 端侧回落渲染。',
+    },
 };
 /** workflow 行:wire 十键与视图十键一一同名同义 ⇒ 本表**空**(空不是「忘了填」,是覆盖账那条腿
  *  每跑一次都在证明它该空:少投一个键就红)。 */
 export const FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED = {};
-const _fleetViewKeyPins = [true, true, true, true, true, true, true, true];
+// `Covers`(REF-CC-145/dup-12,P3 wave1 卡C-argv)改吃共用叶 ../typePins.js——四份逐字重复钉之一
+// (`Exclude<A,B> extends never` = 「A 的每个成员都在 B 里」;不成立时类型是 `never`,赋 `true` 即编译红)。
+const _fleetViewKeyPins = [true, true, true, true, true, true, true, true, true, true];
 void _fleetViewKeyPins;

package/dist/fleetAgentPanelProjection.d.ts

@@ -39,12 +39,29 @@ export interface FleetAgentRowLike {
 }
 /** 行从投影集消失多久之后按 completed 兜底 settle(重连空窗 / snapshot 清表远小于此)。 */
 export declare const ABSENT_SETTLE_MS = 30000;
-/** 测试钩:清投影台账。 */
+/**
+ * 测试钩:清投影台账 —— **全部 sessionKey**,不是只清 default 桶。
+ *
+ * 🔴 回炉定谳(P3 wave2 复审 blocker④):per-session 化那一批一度把它收窄成
+ * `resetFleetAgentPanelProjectionFor(DEFAULT_SESSION_KEY)`。它的契约是「清投影台账」,不是一个
+ * 会话语义位 —— 收窄等于给多会话宿主的用例之间留一条跨用例串扰通道(用例 A 先
+ * `projectFleetAgentRowsFor('sess-b', …)`,用例间调零参 reset,`sess-b` 桶存活 ⇒ 下个用例首次
+ * 投影同 taskId 时 `prev` 非空且 `settled:true`,`fleet-row`/`end` 被去重门吞掉)。
+ * 对位实现同形:`fleet/fleetLedger.__resetFleetLedgerRegistryForTests()` = `liveBgViews.clear()`;
+ * W1 段五个槽位的现成规约也逐个钉的是「reset 清全部键」。
+ * 要只清一个会话请用 `resetFleetAgentPanelProjectionFor(sessionKey)`。
+ */
 export declare function resetFleetAgentPanelProjection(): void;
+/** W1 keyed variant(REF-CC-045):只清**这一个会话**的桶。 */
+export declare function resetFleetAgentPanelProjectionFor(sessionKey: string): void;
 /** 台账读面(测试/诊断):当前记着的行数。 */
 export declare function fleetAgentProjectionSize(): number;
+/** W1 keyed variant。 */
+export declare function fleetAgentProjectionSizeFor(sessionKey: string): number;
 /**
  * 把一次 fleet 投影(已经过 own 判别 + workflow belt 的 FleetTask[])喂给面板事件流。
  * 幂等、无副作用地重复调用安全 —— 每秒被 footer 调用两次就是常态。
  */
 export declare function projectFleetAgentRows(rows: readonly FleetAgentRowLike[], nowMs?: number): void;
+/** W1 keyed variant(REF-CC-045):多会话宿主每会话一份台账,互不顶盖。 */
+export declare function projectFleetAgentRowsFor(sessionKey: string, rows: readonly FleetAgentRowLike[], nowMs?: number): void;