@sema-agent/client-core 0.44.0 → 0.46.0

package/dist/subagent/engineSubagentResume.js

@@ -1,14 +1,22 @@
 import { hostLog } from '../host.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
-import { activeEngineRunId, engineSessionParamSpread } from '../engineSessionParam.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { activeEngineRunId, engineSessionParamFor } from '../engineSessionParam.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { getBgParentRunOwner, parentToolCallIdOf, } from '../subagentContentStore.js';
 /** 能力位键(server `routes/capabilities.ts` 的 `subagentResume`;SDK `Capabilities.subagentResume`)。 */
 export const SUBAGENT_RESUME_CAP = 'subagentResume';
-/** 复活口在不在。未判/缺键 = false = 详情面不渲「继续」腿。 */
-export function subagentResumeAvailable(baseUrl = engineWireTarget()?.baseUrl) {
-    return engineCapTrue(baseUrl, SUBAGENT_RESUME_CAP);
+/**
+ * 复活口在不在。未判/缺键 = false = 详情面不渲「继续」腿。
+ *
+ * 🔴 design/285 批 3(D7b):`baseUrl` 缺席时的派生从零参 `engineWireTarget()`(写死默认槽)换成
+ *    `engineWireTargetFor(sessionKey)`。**本腿没有行上下文**(它答的是「这台引擎有没有这个口」,
+ *    不是「这一行该打到哪」)⇒ 槽键只能由调用方给,缺省 `DEFAULT_SESSION_KEY` = 与 0.44.0 逐字同。
+ *    显式 `baseUrl` 恒赢(既有注入缝不动;空串仍原样保留 —— `??` 只对 `undefined` 让位,与默认参形同)。
+ */
+export function subagentResumeAvailable(baseUrl, sessionKey = DEFAULT_SESSION_KEY) {
+    return engineCapTrue(baseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, SUBAGENT_RESUME_CAP);
 }
 /**
  * 「继续」腿的 resume 取址(1.0.74 终扫 P2-11)。
@@ -90,13 +98,35 @@ export function classifySubagentResumeFailure(e) {
  *
  * @param activeRunId 注入缝(缺省 = `activeEngineRunId()`)—— 判据要能在没有 SessionPort 的纯层里验。
  */
-export function resolveOwnerRunId(childTaskId, activeRunId = activeEngineRunId() ?? undefined) {
+export function resolveOwnerRunId(childTaskId, activeRunId) {
     const owner = getBgParentRunOwner(childTaskId);
     if (owner !== undefined)
         return owner.runId;
     if (childTaskId !== undefined && childTaskId !== '')
         return undefined;
-    return activeRunId;
+    // 🔴 **惰性求值**(design/285 批 3,异源对抗复审 [medium] 采纳):此前 `activeRunId` 是**默认参**,
+    //    于是**每一次**调用都先读一遍**默认槽**的 `SessionPort` —— 哪怕台账里明明有这一行、第三态根本
+    //    走不到。批 3 之后 keyed 宿主是成文支持的路径,那次白读会给 keyed-only 宿主(默认槽本就没装)
+    //    刷 `hostPortMisses()`,而接入档要求宿主的自检**恒空**:一个恒响的假警报会把真漏装淹掉。
+    //    注入语义一字未变(传值即用;传 `undefined` 与不传都落到这条真读)。
+    return activeRunId ?? activeEngineRunId();
+}
+/**
+ * 「这一行子代属于哪个会话槽」—— design/285 批 3(D6+D7b)读侧的**一次读**。
+ *
+ * 五个读点(tail / output / taskHandle 两口 / delegatedPrompt)此前各自读一次台账,而 wire target
+ * 一律走零参 `engineWireTarget()`(= 默认槽)。keyed 多会话宿主上那意味着「会话对了、打的服务器与
+ * 凭证可能还是别人的」(D7b)。本函数把「取哪一行的记录 + 它属于哪个槽」收成一处;
+ * `key` 缺席回落默认槽 ⇒ `engineWireTargetFor(DEFAULT_SESSION_KEY)` ≡ `engineWireTarget()`,
+ * 单会话宿主逐字同。
+ *
+ * 🔴 **会话策略刻意留在各腿**(不在这里合并):steer/tail/output 是二态(行的会话优先,缺则退现势),
+ *    resume 是三态(指名了行却没有会话 ⇒ 干脆不带,AT-MOST-ONCE 不许猜)。收成一份就必然要加一个
+ *    「模式」参数,那等于把两条**有意不同**的口径伪装成同一个函数的两种配置。
+ */
+export function resolveOwnerContext(childTaskId) {
+    const record = getBgParentRunOwner(childTaskId);
+    return { record, runId: record?.runId, key: record?.sessionKey ?? DEFAULT_SESSION_KEY };
 }
 /**
  * 产品 facade + 运行定位。**逐字复用 `steerEngineSubagent` 的三步**(engineWireTarget → 无则 no-wire;
@@ -111,10 +141,20 @@ export function resolveOwnerRunId(childTaskId, activeRunId = activeEngineRunId()
  *      猜错会话可能落到**另一个会话的同名子代**上,那是不可回收的伤害;不带参数的失败只是 server
  *      fail-closed 的干净 404,已有 `not-found` 出路文案接。与本模块「错值比缺席更坏」同一条口径。
  *    · 调用方**完全没指名行**(无行上下文的通用调用)⇒ 才退当前会话(既有口径不变)。
- *    ⚠️ 供给面欠账:fleet/通知两腿手里没有流会话,补上之后第二态自然变成第一态,判据无需再改。
+ *    ⚠️ 供给面欠账(**已由 design/285 批 2 补上**):fleet/通知两腿此前手里没有流会话;ingress 落地后
+ *    它们按 `{runId, sessionId, sessionKey}` 三值原子写,第二态自然变成第一态,判据一字未改 ——
+ *    这正是本注 0.30.x 时预告过的那一步。
+ *
+ * 🔴 design/285 批 3(D7b):wire target 从零参 `engineWireTarget()`(默认槽)换成
+ *    `engineWireTargetFor(owner.sessionKey ?? DEFAULT_SESSION_KEY)`。会话对了而 baseUrl/token/
+ *    principal 还是别人的,等于把 resume 这条 AT-MOST-ONCE 的动作发到另一台引擎上。
+ *    第三态(没指名行)的现势会话回落**同样按 key**(`engineSessionParamFor(key)`)—— 没指名行时
+ *    key 恒是默认槽,与 0.44.0 逐字同。
  */
 export function resolveSubagentResumeContext(childTaskId) {
-    const cfg = engineWireTarget();
+    // 记录先取(纯台账读):`key` 决定 wire target 取哪个槽,所以它必须排在 cfg 之前。
+    const { record: owner, key } = resolveOwnerContext(childTaskId);
+    const cfg = engineWireTargetFor(key);
     if (!cfg)
         return { facade: null, runId: undefined, session: {} };
     const client = makeEngineWireClient({
@@ -125,13 +165,16 @@ export function resolveSubagentResumeContext(childTaskId) {
     if (!client)
         return { facade: null, runId: undefined, session: {} };
     const named = childTaskId !== undefined && childTaskId !== '';
-    const owner = getBgParentRunOwner(childTaskId);
     const sessionFromRow = owner?.sessionId;
+    // 第三态(没指名行)的现势会话回落**也按 key** —— 没指名行时 key 恒是默认槽,与 0.44.0 逐字同。
+    const fallback = named ? undefined : engineSessionParamFor(key);
     const session = sessionFromRow !== undefined
         ? { session: sessionFromRow }
-        : named
-            ? {} // 指名了行却没有它的会话 ⇒ 诚实缺席,绝不用当前会话冒充
-            : engineSessionParamSpread();
+        : fallback !== undefined
+            ? { session: fallback } // 没指名行 ⇒ 退当前会话(既有第三态口径不变)
+            : {}; // 指名了行却没有它的会话 ⇒ 诚实缺席,绝不用当前会话冒充
+    // 取址三态的唯一判据(含「没指名行才回落在飞 run」那一态);刻意排在 wire 两道闸**之后**,
+    // 与 0.44.0 求值序逐字同 —— 无 wire 时一次 SessionPort 都不读。
     return { facade: client.runs, runId: resolveOwnerRunId(childTaskId), session };
 }
 /** UNTRUSTED 串的呈前消毒。 */
@@ -193,7 +236,7 @@ const warnedRetainWithoutWake = new Set();
  * @param retainRequested 本端 run 请求里的 `retainSubagentSessions`(缺省 true = 包内 taskRequest 的缺省)。
  */
 export function auditRetainWithoutWake(input) {
-    const baseUrl = input.baseUrl ?? engineWireTarget()?.baseUrl;
+    const baseUrl = input.baseUrl ?? engineWireTargetFor(input.sessionKey ?? DEFAULT_SESSION_KEY)?.baseUrl;
     if (!engineCapTrue(baseUrl, SUBAGENT_RESUME_CAP))
         return undefined;
     if (input.retainRequested === false)

package/dist/subagent/engineSubagentSteer.js

@@ -26,10 +26,9 @@
  */
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
-import { engineSessionParamSpread } from '../engineSessionParam.js';
-import { getBgParentRunOwner } from '../subagentContentStore.js';
-import { resolveOwnerRunId } from './engineSubagentResume.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineSessionParamFor } from '../engineSessionParam.js';
+import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 /**
  * Steer a running engine subagent (target = its parentToolCallId, or agentName).
@@ -58,12 +57,16 @@ import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
  * @param childTaskId 这一行子代的 taskId(fleet 行 id 尾段;端有行上下文时**应当**传)。
  */
 export async function steerEngineSubagent(target, text, childTaskId) {
-    const cfg = engineWireTarget();
-    if (!cfg)
-        return { ok: false, reason: 'no-wire' };
     // 空串/非串按「没指名行」处理(与 resolveOwnerRunId 的 named 判据同口径);窄成 string|undefined
     // 而不是 boolean —— 布尔位不给 TS 窄化,留痕那一行会被迫 cast。
     const named = typeof childTaskId === 'string' && childTaskId !== '' ? childTaskId : undefined;
+    // 🔴 design/285 批 3(D7b):台账记录**先取**(纯读)—— wire target 按**这一行的会话槽**取,
+    //    零参 `engineWireTarget()` 写死默认槽(会话对了而 baseUrl/token/principal 是别人的)。
+    //    这也顺带把本腿原有的「同一张表读两次」收成一次读(取址判据仍在 resolveOwnerRunId 一处)。
+    const { record: owner, key } = resolveOwnerContext(named);
+    const cfg = engineWireTargetFor(key);
+    if (!cfg)
+        return { ok: false, reason: 'no-wire' };
     const runId = resolveOwnerRunId(named);
     if (!runId) {
         // 指名了行才算「台账缺席」——不指名的通用调用只是没有在飞 run,不是宿主映射缺席(两者出路
@@ -79,10 +82,16 @@ export async function steerEngineSubagent(target, text, childTaskId) {
     });
     if (!client)
         return { ok: false, reason: 'no-wire' };
-    // 会话二态(见头注):行登记的会话优先,缺则退现势会话。这里是同一张表的第二次同步读
-    // (与上面 `resolveOwnerRunId` 之间无 await ⇒ 同一拍),取址判据本身仍只有那一处,不另铸。
-    const rowSession = named !== undefined ? getBgParentRunOwner(named)?.sessionId : undefined;
-    const session = rowSession !== undefined ? { session: rowSession } : engineSessionParamSpread();
+    // 会话二态(见头注):行登记的会话优先,缺则退现势会话。记录来自上面那一次读(`resolveOwnerContext`),
+    // 不再第二次查表;取址判据本身仍只有 `resolveOwnerRunId` 那一处,不另铸。
+    // 🔴 design/285 批 3:现势会话回落也按 `key` 取(没指名行时 key 恒是默认槽 ⇒ 与 0.44.0 逐字同)。
+    const rowSession = owner?.sessionId;
+    const fallbackSession = rowSession === undefined ? engineSessionParamFor(key) : undefined;
+    const session = rowSession !== undefined
+        ? { session: rowSession }
+        : fallbackSession !== undefined
+            ? { session: fallbackSession }
+            : {};
     try {
         // service 1.89 receipt shape: { note: "Message queued for delivery to <name> …", delivery, … }
         const body = await client.runs.steerSubagent(runId, target, { content: text }, session);

package/dist/subagent/engineSubagentTail.js

@@ -49,9 +49,10 @@
  */
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
-import { engineSessionParam } from '../engineSessionParam.js';
-import { coerceOutput, getBgParentRun, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineSessionParamFor } from '../engineSessionParam.js';
+import { resolveOwnerContext } from './engineSubagentResume.js';
+import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 // ── caps 探测(true 固化 / false TTL / 失败不缓存)────────────────────────────────────────────
 const capByBase = new Map();
@@ -113,7 +114,12 @@ export function isEngineSubagentTailActive(taskId) {
 export function tailEngineSubagent(taskId) {
     if (activeTails.has(taskId))
         return;
-    const cfg = engineWireTarget();
+    // 🔴 design/285 批 3(D7b):台账记录**先取**(纯读),因为 wire target 要按**这一行的会话槽**取 ——
+    //    零参 `engineWireTarget()` 写死默认槽,keyed 宿主上会拿 A 槽的 baseUrl/token/principal 去
+    //    读 B 槽的子代。`sessionKey` 缺席 ⇒ 回落默认槽 ⇒ 与 0.44.0 逐字同。
+    //    ⚠️ 两道闸的**次序一字未动**(无 wire 仍先于「台账缺席」返回,缺席留痕不会在离线宿主上刷屏)。
+    const { record: owner, runId, key } = resolveOwnerContext(taskId);
+    const cfg = engineWireTargetFor(key);
     if (!cfg)
         return;
     // 🔴 #242 批 3([4000] Q3=B 裁定执行,行为翻面):台账缺席即**诚实缺席,绝不回落**
@@ -122,7 +128,6 @@ export function tailEngineSubagent(taskId) {
     //    供给面:本表由 fleet 行帧 parentId / bg 通知 parentTaskId / task_progress tick 三腿喂
     //    (fleetLedger.ts:394/:496 + recordSubagentOwnerFromProgress),正常 bg 子代出生帧即有值;
     //    缺席 = 真不知道宿主(壳重启且行帧未重播等),此时连「当前活跃 run」纯属赌。
-    const runId = getBgParentRun(taskId);
     if (!runId) {
         noteBgOwnerAbsence('subagent-tail', taskId);
         return;
@@ -146,7 +151,14 @@ export function tailEngineSubagent(taskId) {
         try {
             if (!(await subagentStreamCapable(client, cfg.baseUrl, ac.signal)))
                 return;
-            const session = engineSessionParam();
+            // 🔴 design/285 批 3(D6,会话二态;与 steer 腿 `:88-91` 同一口径):
+            //   · 行登记时**捕到了会话** ⇒ 用**行的**会话(与行的 runId 同源同拍,唯一自洽的组合);
+            //   · 行没有随行会话 ⇒ 退**本槽的现势会话**(遵 [1498]③ 无条件带 session 的双版本兼容纪律;
+            //     runId 已由台账钉死,配错的组合在 session-bound run 上是 server 干净的 404,落既有静默出路)。
+            //   🔴 **BEHAVIOR CHANGE(默认槽也变)**:tick 腿今天就在默认槽写 `sessionId`,所以「会话轮换后
+            //   对旧行开 tail」此前用**现势**会话打一条 session-bound 的旧 run = 确定性 404;现在用行登记的
+            //   那一个,与 steer/resume 已成立的口径统一。现势会话回落也按 `key` 取,不再写死默认槽。
+            const session = owner?.sessionId ?? engineSessionParamFor(key);
             // SDK 0.0.77 起 runs.subagentStream 有真型([1547]① 候发版即消费兑现)——宽形 cast 已撤。
             const stream = client.runs.subagentStream(runId, taskId, {
                 signal: ac.signal,

package/dist/subagent/engineTaskHandleWire.js

@@ -40,9 +40,9 @@
 import { TaskStopConflictError } from '@sema-agent/sdk';
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireDebugEnabled, engineWireTarget } from '../engineWireTarget.js';
-import { engineSessionParamSpread } from '../engineSessionParam.js';
-import { getBgParentRun } from '../subagentContentStore.js';
+import { engineWireDebugEnabled, engineWireTargetFor } from '../engineWireTarget.js';
+import { engineSessionParamFor } from '../engineSessionParam.js';
+import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 // REF-CC-域词表-06 提单源:spool 全量/增量判读的单一真源现在在 toolResult.ts(它也消费同一份
@@ -63,13 +63,30 @@ import { STOP_CONFLICT_CODES, STOP_NOT_LANDED, STOP_NOT_LOCAL, STOP_PARKED, STOP
  *  缺席不静默(noteBgOwnerAbsence warn 留痕);两个消费口各自 fail-soft(output→null 回落
  *  receipt/outputFile 渲染,stop→unavailable + detail,UI 不翻行)。 */
 function resolveHostRun(handle) {
-    const runId = getBgParentRun(handle);
+    const runId = resolveOwnerContext(handle).runId;
     if (!runId) {
         noteBgOwnerAbsence('task-handle', handle);
         return null;
     }
     return runId;
 }
+/**
+ * 🔴 会话**二态**(design/285 批 3,与 tail / output / steer 三腿同一口径):
+ *   · 句柄登记时**捕到了会话**(批 2 起 fleet 行帧腿经 ingress 三值同写)⇒ 用**行登记的**会话 ——
+ *     它与本腿寻址用的 `runId` 同源同拍,是唯一自洽的组合;
+ *   · 没有随行会话 ⇒ 退**本槽的**现势会话(遵 [1498]③ 无条件带 session 的双版本兼容纪律)。
+ *
+ * 🔴 **为什么本腿也改**(设计稿 D6 原本只点名 tail/output,施工轮扩到本腿,同形存量族扫):
+ *    病形 = 「台账取的 runId 配现势 session」—— 两面出生即强制带 `?session=`(见文件头注),
+ *    对 session-bound 的旧 run 是确定性 404。批 2 落地之前本腿的行**没有**随行会话,这一格不可达;
+ *    批 2 让 fleet 行帧腿开始写 session 之后,它与 tail/output 变成同一个形。只修 tail/output 而
+ *    留下本腿 = 同一根因只修当格。停行(`stopEngineTask`)尤其不能留:它是有副作用的动作。
+ *    空串归一仍只在 `engineSessionParamFor` 一处,本函数不重铸。
+ */
+function sessionOf(ctx) {
+    const s = ctx.record?.sessionId ?? engineSessionParamFor(ctx.key);
+    return s !== undefined ? { session: s } : {};
+}
 // 游标累积(按 handle;进程内存态,与查看态生命周期同级——端重启即空,重读从引擎再取)
 const accumulated = new Map();
 /** 测试钩:清累积缓存。 */
@@ -81,8 +98,10 @@ export function __resetTaskHandleWireForTests() {
  * 域外或已 reap / 网错)——调用方回落既有渲染(receipt/outputFile tail)。绝不 throw。
  */
 export async function fetchEngineTaskOutput(handle, opts) {
-    const cfg = engineWireTarget();
-    if (!cfg || !engineTaskHandlesCapable())
+    // design/285 批 3(D7b):wire target 与 caps 门都按**这条句柄所属的槽**取,不再写死默认槽。
+    const owner = resolveOwnerContext(handle);
+    const cfg = engineWireTargetFor(owner.key);
+    if (!cfg || !engineTaskHandlesCapable(owner.key))
         return null;
     const runId = resolveHostRun(handle);
     if (!runId)
@@ -97,7 +116,8 @@ export async function fetchEngineTaskOutput(handle, opts) {
     try {
         const r = await client.runs.taskOutput(runId, handle, {
             ...(opts?.signal ? { signal: opts.signal } : {}),
-            ...engineSessionParamSpread(),
+            // design/285 批 3:会话二态(行登记的优先,缺则退本槽现势)——判据本体见 sessionOf 头注。
+            ...(sessionOf(owner)),
         });
         const fresh = typeof r?.content === 'string' ? r.content : '';
         const prev = accumulated.get(handle) ?? '';
@@ -195,8 +215,10 @@ export function classifyTaskStopConflict(e) {
  * 已随 G1 去字面化搬到 `engineErrorCodes.ts` 的 `STOP_CONFLICT_CODES` —— 顺序即语义那条注也在那边。 */
 /** 停一个引擎侧任务句柄(新面 B)。只有 ok:true(=HTTP 200)算停了。绝不 throw。 */
 export async function stopEngineTask(handle, opts) {
-    const cfg = engineWireTarget();
-    if (!cfg || !engineTaskHandlesCapable())
+    // design/285 批 3(D7b):同 `fetchEngineTaskOutput` —— 停行是有副作用的动作,打错引擎更坏。
+    const owner = resolveOwnerContext(handle);
+    const cfg = engineWireTargetFor(owner.key);
+    if (!cfg || !engineTaskHandlesCapable(owner.key))
         return { ok: false, reason: 'unavailable' };
     const runId = resolveHostRun(handle);
     if (!runId)
@@ -211,7 +233,8 @@ export async function stopEngineTask(handle, opts) {
     try {
         const r = await client.runs.taskStop(runId, handle, {
             ...(opts?.signal ? { signal: opts.signal } : {}),
-            ...engineSessionParamSpread(),
+            // design/285 批 3:会话二态(行登记的优先,缺则退本槽现势)——判据本体见 sessionOf 头注。
+            ...(sessionOf(owner)),
         });
         const out = r?.output ?? {};
         if (engineWireDebugEnabled()) {

package/dist/subagentContentStore.d.ts

@@ -203,12 +203,58 @@ export interface SubagentOwnerRecord {
     runId: string;
     /** 登记时的会话 id;缺席即不带 `?session=`(空串按「带了且不匹配」处理 = 404,恒不铸空串)。 */
     sessionId?: string;
+    /**
+     * 🔴 design/285 批 2(D7a):登记时那条流所属的**会话槽键**(`installHostFor(key, …)` 的 key)。
+     *
+     * 为什么记它而不是只记 `sessionId`:读侧要的不只是 `?session=`,还有**打哪台服务器、用谁的
+     * token 与 principal** —— 那三件在 `engineWireTargetFor(sessionKey)` 上,按槽装配。只记会话
+     * 而 wire target 仍走默认槽 = 「会话对了、凭证是别人的」(D7b),per-key 会话锚只做完一半。
+     *
+     * 缺席 ⇒ 读侧回落 `DEFAULT_SESSION_KEY`,与 0.44.0 逐字同(见 `resolveOwnerContext`)。
+     * 🔴 缺席的**唯一**合法来源是「这一写没有通道证据」:兼容入口 `ledger.applyFrame` 每帧现读槽
+     * 会话、库里不留锚,它写进来的行归属不可知,所以两个新位一律不写(与 0.44.0 逐字同)。
+     */
+    sessionKey?: string;
 }
+/**
+ * 🔴 R6(design/285 §7):同一个 `runId` 上先后被喂进**两个不同**会话时的留痕。
+ *
+ * 为什么要有:合表后 tick 腿(壳 liveClient 开流时捕获)与 fleet 两腿(ingress 捕获)会写同一条
+ * 记录。口径仍是「带值的写照常赢」(last-write-wins),但那不能是**静默**的 —— 两条腿对同一个宿主
+ * run 给出不同会话,要么是宿主把两条流的帧喂进了同一本账,要么是某一腿的捕获点写错了,两种都是
+ * 承重缺陷。**判据是计数而不是日志**:本 store 是零 import 的内核闭包(见文件头注),而且
+ * 「只落日志的告警在测试里等于不存在」(本仓既有裁定,见 `auditRetainWithoutWake` 头注)。
+ */
+export interface SubagentOwnerSessionConflict {
+    taskId: string;
+    runId: string;
+    /** 冲突前记录上的**出身对**(整对记,不是只记会话 —— 换槽键与换会话同样是换出身)。 */
+    prior: {
+        sessionId?: string;
+        sessionKey?: string;
+    };
+    /** 这一写带来的出身对(它整对赢)。 */
+    next: {
+        sessionId?: string;
+        sessionKey?: string;
+    };
+}
+/** R6 读口:`count` = 累计冲突次数(恒应为 0);`last` = 最后一次的四元组(诚实缺席用 undefined)。 */
+export declare function subagentOwnerSessionConflicts(): {
+    count: number;
+    last?: SubagentOwnerSessionConflict;
+};
 /**
  * fleet 行帧 / bg 通知腿的登记口(既有两写点)。
  * `sessionId` 是 #242 批 2 additive 补位:缺席则不落键(读面据此判「不带 `?session=`」)。
+ * `sessionKey` 是 design/285 批 2 additive 补位,同款「缺席则不落键」。
+ *
+ * 🔴 **两个新位的值必须来自 ingress 的不可变捕获**(`ledger.issueStream()` 那一刻解析一次),
+ *    **不是**每帧现读某个可变槽 —— 逐帧现读会让重连后旧流的迟到帧被登记成 `{旧 runId, 新会话}`,
+ *    正是本文件 `recordSubagentOwnerFromProgress` 头注明令禁止的错组合。ingress 的 epoch 闸让旧代际
+ *    的帧根本进不来,这才是「原子」的落点。
  */
-export declare function recordBgParentRun(taskId: string, runId: string, sessionId?: string): void;
+export declare function recordBgParentRun(taskId: string, runId: string, sessionId?: string, sessionKey?: string): void;
 /**
  * 「这一行子代的宿主 run」统一登记口(**显式传值**,零推断,见本段头注)。
  * `runId` 缺席/空串 ⇒ 什么都不记(宁可「不知道」也不记一个错的宿主);`taskId === runId`
@@ -221,8 +267,15 @@ export declare function recordBgParentRun(taskId: string, runId: string, session
  *    session-bound run 上 fail-closed 404)。
  *    口径:**同一 `runId` 上缺席不覆盖在场**(带值的写照常赢);`runId` 真变了 ⇒ 旧 session 必须丢
  *    (那是另一条宿主 run 的会话,留着就是错组合)。
+ *
+ * 🔴 **`sessionId` 与 `sessionKey` 是一个「出身对」,整对进出**(design/285 批 2,异源对抗复审
+ *    [high] 收紧):**这一写带了任一位就整对赢**;**两位都缺席**才走上面那条「缺席不覆盖在场」。
+ *    分开 merge(各留各的)会合成一条从来没被同一次捕获产生过的元组 —— 而读侧正是拿这一对去挑
+ *    服务器 / 凭证 / 会话,详见函数体里那段头注的两条可达路径。`runId` 变了 ⇒ 整对丢。
+ * 🔴 **同 runId 上换出身不静默**(R6):出身对(会话**或**槽键)变了就计 `ownerSessionConflictCount`
+ *    并留下两对(读口 {@link subagentOwnerSessionConflicts})。值仍按「带出身的写赢」,变的是它不再无声。
  */
-export declare function recordSubagentOwner(taskId: string, runId?: string, sessionId?: string): void;
+export declare function recordSubagentOwner(taskId: string, runId?: string, sessionId?: string, sessionKey?: string): void;
 /**
  * `task_progress` 腿的登记口(#242 批 2 ①:收编前本表**零 task_progress 腿**,已直证)。
  *
@@ -238,14 +291,14 @@ export declare function recordSubagentOwner(taskId: string, runId?: string, sess
  *    会话切换之后晚到的旧流 tick 被登记成 `{旧 runId, 新 sessionId}`,这对组合去 resume 会带着
  *    错 session 打旧 run,fail-closed 404。
  */
-export declare function recordSubagentOwnerFromProgress(ev: unknown, ownerRunId?: string, ownerSessionId?: string): void;
+export declare function recordSubagentOwnerFromProgress(ev: unknown, ownerRunId?: string, ownerSessionId?: string, ownerSessionKey?: string): void;
 export declare function getBgParentRun(taskId: string): string | undefined;
 /**
  * 整条宿主记录(runId + 登记时会话)。undefined = **诚实不知道**,调用方渲 no-run 出路 /
  * 不渲入口 —— 绝不在这里回落成「此刻在飞的那条 run」([anchor-on-the-deciding-quantity])。
  */
 export declare function getBgParentRunOwner(taskId: string | undefined): SubagentOwnerRecord | undefined;
-/** 测试钩:清宿主台账(module 级单例,同进程多组断言必须能清)。 */
+/** 测试钩:清宿主台账(module 级单例,同进程多组断言必须能清)。R6 冲突台账一并清。 */
 export declare function __resetSubagentOwnerLedgerForTests(): void;
 export declare function recordOwnEngineRun(runId: string): void;
 export declare function isOwnEngineRun(runId: string): boolean;

package/dist/subagentContentStore.js

@@ -396,12 +396,52 @@ export function getBgTerminalFacts(taskId) {
 //   满了按 LRU 淘汰,淘汰后果只是那一行退回「不知道宿主 run」= 诚实缺席,不是错值。
 const MAX_BG_PARENT_RUNS = 320;
 const bgParentRun = new Map();
+/**
+ * 缺席 `sessionKey` 的**有效槽身份**。
+ *
+ * 🔴 值必须与 `sessionSlot.DEFAULT_SESSION_KEY` 逐字相同,但**刻意不 import**:本 store 是
+ * `runStream.ts` 可移植闭包里的零 import 件(文件头三处以此立身),拉一条边就破了那道门。
+ * 两处同值由 pure 门的 `B3-P31/R6h` 钉住(读侧 `resolveOwnerContext` 的回落键必须 === 本常量),
+ * 任一侧改字面当场红 —— 手抄一个常量而没有对账钉,才是真正会漂的形。
+ */
+const DEFAULT_OWNER_SLOT = '__default__';
+let ownerSessionConflictCount = 0;
+let lastOwnerSessionConflict;
+/**
+ * 🔴 **跨槽冲突的隔离台账**(异源对抗复审第六轮 [high] 采纳):`taskId` → 出事的那个 `runId`。
+ *
+ * 为什么光删记录不够(复审的可证伪点,实测成立):删完之后 `prior` 为空 ⇒ **任一条**后续帧都会
+ * 立刻把记录重建出来 —— 序列 `A 写 → B 写(冲突删)→ A 再写` 当场恢复 `{sessionKey:'A'}`,反向亦然。
+ * 两个来源**持续产帧**时,这条行会在两个槽之间来回翻,每翻一次就开一个错误出站窗;而读侧拿它做的
+ * 是 stop / resume 这类**有副作用**的动作。「后一帧自愈」只是**假设**另一条流已经停了,那不是证据。
+ *
+ * 隔离的**解除规则**(与复审给的口径一致,取其中不需要代际管道的那一条):
+ *   · `runId` **变了** ⇒ 那是另一条宿主 run,与出事的那一条无关,隔离随之作废;
+ *   · 测试钩 `__resetSubagentOwnerLedgerForTests()`。
+ * 🔴 隔离期间**记录保持缺席** ⇒ 五个读点走成文的诚实缺席(`noteBgOwnerAbsence` + null / no-run),
+ *   零读侧改动、零出站。⚠️ 计数恒应为 0 ⇒ 对接线正确的宿主本机制逐字节不可达。
+ * 有界:与 `bgParentRun` 同上限、同 LRU 淘汰口径(键同样来自 wire,不许无界)。
+ */
+const conflictQuarantine = new Map();
+/** R6 读口:`count` = 累计冲突次数(恒应为 0);`last` = 最后一次的四元组(诚实缺席用 undefined)。 */
+export function subagentOwnerSessionConflicts() {
+    return {
+        count: ownerSessionConflictCount,
+        ...(lastOwnerSessionConflict !== undefined ? { last: lastOwnerSessionConflict } : {}),
+    };
+}
 /**
  * fleet 行帧 / bg 通知腿的登记口(既有两写点)。
  * `sessionId` 是 #242 批 2 additive 补位:缺席则不落键(读面据此判「不带 `?session=`」)。
+ * `sessionKey` 是 design/285 批 2 additive 补位,同款「缺席则不落键」。
+ *
+ * 🔴 **两个新位的值必须来自 ingress 的不可变捕获**(`ledger.issueStream()` 那一刻解析一次),
+ *    **不是**每帧现读某个可变槽 —— 逐帧现读会让重连后旧流的迟到帧被登记成 `{旧 runId, 新会话}`,
+ *    正是本文件 `recordSubagentOwnerFromProgress` 头注明令禁止的错组合。ingress 的 epoch 闸让旧代际
+ *    的帧根本进不来,这才是「原子」的落点。
  */
-export function recordBgParentRun(taskId, runId, sessionId) {
-    recordSubagentOwner(taskId, runId, sessionId);
+export function recordBgParentRun(taskId, runId, sessionId, sessionKey) {
+    recordSubagentOwner(taskId, runId, sessionId, sessionKey);
 }
 /**
  * 「这一行子代的宿主 run」统一登记口(**显式传值**,零推断,见本段头注)。
@@ -415,8 +455,15 @@ export function recordBgParentRun(taskId, runId, sessionId) {
  *    session-bound run 上 fail-closed 404)。
  *    口径:**同一 `runId` 上缺席不覆盖在场**(带值的写照常赢);`runId` 真变了 ⇒ 旧 session 必须丢
  *    (那是另一条宿主 run 的会话,留着就是错组合)。
+ *
+ * 🔴 **`sessionId` 与 `sessionKey` 是一个「出身对」,整对进出**(design/285 批 2,异源对抗复审
+ *    [high] 收紧):**这一写带了任一位就整对赢**;**两位都缺席**才走上面那条「缺席不覆盖在场」。
+ *    分开 merge(各留各的)会合成一条从来没被同一次捕获产生过的元组 —— 而读侧正是拿这一对去挑
+ *    服务器 / 凭证 / 会话,详见函数体里那段头注的两条可达路径。`runId` 变了 ⇒ 整对丢。
+ * 🔴 **同 runId 上换出身不静默**(R6):出身对(会话**或**槽键)变了就计 `ownerSessionConflictCount`
+ *    并留下两对(读口 {@link subagentOwnerSessionConflicts})。值仍按「带出身的写赢」,变的是它不再无声。
  */
-export function recordSubagentOwner(taskId, runId, sessionId) {
+export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
     if (!taskId || typeof runId !== 'string' || runId === '' || taskId === runId)
         return;
     if (bgParentRun.size >= MAX_BG_PARENT_RUNS && !bgParentRun.has(taskId)) {
@@ -424,15 +471,104 @@ export function recordSubagentOwner(taskId, runId, sessionId) {
         if (oldest !== undefined)
             bgParentRun.delete(oldest);
     }
+    // 🔴 隔离闸(异源对抗复审第六轮):这条 `(taskId, runId)` 已被判过「两个槽同时认领」⇒ 记录保持
+    //    缺席,任何后续帧都不许把它重建出来(「后一帧自愈」是假设不是证据)。`runId` 变了即解除。
+    const quarantinedRun = conflictQuarantine.get(taskId);
+    // 🔴 **墓碑,不是可解除的锁**(异源对抗复审第七轮 [high] 采纳,推翻前一版的「runId 变了就删条目」):
+    //    `runId` 是**无序字符串**,「不相等」证明不了前进方向。前一版的序列可复现:`(C,R)` 冲突 ⇒ 隔离;
+    //    `(C,R2)` 把条目**删掉**并登记 R2;此时原冲突源**迟到**的 `(C,R)` 因为条目已删、`sameRun` 又为假,
+    //    直接把映射覆盖回旧 R 与旧槽 —— 跨会话误路由窗当场重开。
+    //    ⇒ 条目**留着不删**:别的 `runId` 照常放行(另一条宿主 run 与出事的那条无关),而**那一条**
+    //    出事的 run 从此不许再回来。有界性不变(与 owner 表同上限、同 LRU 淘汰)。
+    if (quarantinedRun !== undefined && quarantinedRun === runId)
+        return;
     const prior = bgParentRun.get(taskId);
-    const kept = typeof sessionId === 'string' && sessionId !== ''
-        ? sessionId
-        : (prior?.runId === runId ? prior.sessionId : undefined);
+    const sameRun = prior?.runId === runId;
+    const incoming = typeof sessionId === 'string' && sessionId !== '' ? sessionId : undefined;
+    const incomingKey = typeof sessionKey === 'string' && sessionKey !== '' ? sessionKey : undefined;
+    // 🔴 **出身对整对进出**(异源对抗复审 [high] 采纳):`sessionId` 与 `sessionKey` **不许各merge各的**。
+    //    分开 merge 会合成一条**从来没有被同一次捕获产生过**的元组,而读侧拿它挑服务器/凭证/会话:
+    //      · ingress 写 `{S1,'A'}` 之后,另一本 keyed 到 `'B'` 的 ledger(其 SessionPort 无 id)经 ingress
+    //        写 `{undefined,'B'}` ⇒ 分开 merge 得 `{S1,'B'}` = 拿 A 的会话去打 B 的服务器;
+    //      · ingress 写 `{S1,'A'}` 之后,tick 腿(只带会话、不带槽键)写 `{S2,undefined}` ⇒ 得 `{S2,'A'}`
+    //        = 拿默认槽捕获的会话去打 A 的服务器。两条都是本设计要结构性堵死的错组合。
+    //    规矩:**这一写带了任一位就整对赢**(带的那一对就是它的出身,另一位缺席就是「这条出身上没有」);
+    //    **两位都缺席**才走「缺席不覆盖在场」(= 兼容入口/无出身的写,它没有资格改出身)。
+    const carriesProvenance = incoming !== undefined || incomingKey !== undefined;
+    const nextPair = carriesProvenance
+        ? {
+            ...(incoming !== undefined ? { sessionId: incoming } : {}),
+            ...(incomingKey !== undefined ? { sessionKey: incomingKey } : {}),
+        }
+        : sameRun
+            ? {
+                ...(prior?.sessionId !== undefined ? { sessionId: prior.sessionId } : {}),
+                ...(prior?.sessionKey !== undefined ? { sessionKey: prior.sessionKey } : {}),
+            }
+            : {};
+    // R6:同一条宿主 run 上**换出身**(会话变了、或槽键变了)—— 留痕在前(赢家仍是带出身的这一写),
+    // 绝不静默 last-write-wins。🔴 槽键变化同样计:换槽键 = 换服务器与凭证,比换会话更严重。
+    const priorHasProvenance = prior?.sessionId !== undefined || prior?.sessionKey !== undefined;
+    if (sameRun &&
+        carriesProvenance &&
+        priorHasProvenance &&
+        (prior?.sessionId !== nextPair.sessionId || prior?.sessionKey !== nextPair.sessionKey)) {
+        ownerSessionConflictCount++;
+        lastOwnerSessionConflict = {
+            taskId,
+            runId,
+            prior: {
+                ...(prior?.sessionId !== undefined ? { sessionId: prior.sessionId } : {}),
+                ...(prior?.sessionKey !== undefined ? { sessionKey: prior.sessionKey } : {}),
+            },
+            next: { ...nextPair },
+        };
+        // 🔴 **两个槽同时认领同一条 run ⇒ 出身对整对作废**(异源对抗复审第二轮 [high] 的**可采半场**)。
+        //
+        //    复审的原议是「任何出身冲突都 fail-closed」,**只采窄的那一格**,理由是两条判据不同命:
+        //    · **只换会话、槽键不变**(或两边都没有槽键)= #242 批 2 **已裁并钉死**的一格
+        //      (常驻钉 `#242-R3c3`「带 session 的写照常覆盖,新值赢」)—— 那是 tick 腿重新捕获的正常形,
+        //      本批无权在施工轮把一条别的批次的裁定翻面;它的信号面是下面那个计数(R6 的原意)。
+        //    · **两边都带槽键且不相等** = 本批**新引入**的一格,没有任何既有裁定,而且它不可能有合法读法:
+        //      两个不同的槽(= 两台引擎、两份凭证)同时声称同一条宿主 run 是谁的。此时「哪一份对」
+        //      **不可知**,而读侧拿它挑的正是**服务器 / 凭证 / 会话** —— 留痕在库内零消费者,
+        //      拿后到的那份继续路由就是把不可知说成已知。按「错值比缺席更坏」整对丢:读侧回落到
+        //      「无通道证据」那条**成文的**降级路径,而不是一个编出来的元组。
+        //    🔴 **整条记录删掉,`runId` 也不留**(异源对抗复审第五轮 [high] 采纳,推翻了本批前一版的
+        //    「留 runId」)。前一版的理由是「`runId` 那一位没有争议」,**那条理由不成立**:`runId`
+        //    要能用,读侧必须给它配一个槽,而读侧对缺席的 `sessionKey` 的解释是 `DEFAULT_SESSION_KEY`
+        //    —— 于是「留 runId、清出身」实际等于**断言这条 run 属于默认槽**,而冲突恰恰是「有一个 keyed
+        //    槽也认领了它」的正面证据。⇒ 那不是「不知道」,是一个已经被证否的猜测。
+        //    与兼容入口的无槽记录**不同命**:对纯兼容宿主来说默认槽就是它唯一的槽(那条记录是对的);
+        //    在冲突这一格上默认槽是**被证否**的候选之一。
+        //    🔴 删记录**不需要任何读侧改动**:五个读点对「台账缺席」早已是成文的诚实缺席
+        //    (`noteBgOwnerAbsence` 留痕 + null / no-run,#242 批 3 [4000] Q3=B 裁定),本分支直接复用它。
+        //    🔴 **不设粘性 quarantine**:删完之后 `prior` 为空 ⇒ 下一条带出身的帧照常重建记录 —— 那正是
+        //    复审要的「唯一槽证据」恢复规则:真正还活着的那条流会继续写,停掉的那条不再写。粘性会把一条
+        //    本可自愈的行永久钉死;而「冲突到下一帧之间的窗」与「冲突帧就是终帧」两种情形下,记录不在
+        //    = 读面诚实缺席,**没有错误出站**,那正是 fail-closed 要的结局。
+        //    ⚠️ 冲突计数**恒应为 0** ⇒ 对任何接线正确的宿主,本分支逐字节不可达。
+        //    🔴 **按「有效槽」比,不按「键在不在」比**(异源对抗复审第三轮 [high] 采纳):读侧的
+        //    `resolveOwnerContext` 把**缺席的 sessionKey 读成 `DEFAULT_SESSION_KEY`** —— 所以「不带键的
+        //    带出身写」不是「没有槽」,它就是**默认槽**在认领这条 run。只比显式值会漏掉最常见的那一格:
+        //    keyed ingress 写 `{S1,'A'}` 之后,一个仍按三参老签名调用的 tick(`{S2, 无键}`)会把记录改成
+        //    `{sessionId:S2}` ⇒ 读侧拿 **A 的 runId** 去打**默认槽**的服务器与凭证。两向都要挡。
+        //    ⚠️ 单会话宿主上两边的有效槽都是 `DEFAULT_SESSION_KEY` ⇒ 恒不触发,#242-R3c3 那条钉一字未动。
+        const priorSlot = prior?.sessionKey ?? DEFAULT_OWNER_SLOT;
+        const nextSlot = nextPair.sessionKey ?? DEFAULT_OWNER_SLOT;
+        if (priorSlot !== nextSlot) {
+            bgParentRun.delete(taskId);
+            if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(taskId)) {
+                const oldestQ = conflictQuarantine.keys().next().value;
+                if (oldestQ !== undefined)
+                    conflictQuarantine.delete(oldestQ);
+            }
+            conflictQuarantine.set(taskId, runId);
+            return;
+        }
+    }
     bgParentRun.delete(taskId); // LRU touch(F11):活跃映射不被容量淘汰挤掉 → 读面退错 runId
-    bgParentRun.set(taskId, {
-        runId,
-        ...(kept !== undefined && kept !== '' ? { sessionId: kept } : {}),
-    });
+    bgParentRun.set(taskId, { runId, ...nextPair });
 }
 /**
  * `task_progress` 腿的登记口(#242 批 2 ①:收编前本表**零 task_progress 腿**,已直证)。
@@ -449,7 +585,7 @@ export function recordSubagentOwner(taskId, runId, sessionId) {
  *    会话切换之后晚到的旧流 tick 被登记成 `{旧 runId, 新 sessionId}`,这对组合去 resume 会带着
  *    错 session 打旧 run,fail-closed 404。
  */
-export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId) {
+export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId, ownerSessionKey) {
     if (typeof ev !== 'object' || ev === null)
         return;
     const o = ev;
@@ -459,7 +595,7 @@ export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId)
         return;
     if (typeof ownerRunId !== 'string' || ownerRunId === '')
         return;
-    recordSubagentOwner(o.taskId, ownerRunId, ownerSessionId);
+    recordSubagentOwner(o.taskId, ownerRunId, ownerSessionId, ownerSessionKey);
 }
 export function getBgParentRun(taskId) {
     touchLru(bgParentRun, taskId);
@@ -475,9 +611,12 @@ export function getBgParentRunOwner(taskId) {
     touchLru(bgParentRun, taskId);
     return bgParentRun.get(taskId);
 }
-/** 测试钩:清宿主台账(module 级单例,同进程多组断言必须能清)。 */
+/** 测试钩:清宿主台账(module 级单例,同进程多组断言必须能清)。R6 冲突台账一并清。 */
 export function __resetSubagentOwnerLedgerForTests() {
     bgParentRun.clear();
+    conflictQuarantine.clear();
+    ownerSessionConflictCount = 0;
+    lastOwnerSessionConflict = undefined;
 }
 // ── 本壳自己发起过的引擎 run 台账([1498]④ 帧级校验换锚)────────────────────────────────────
 // 喂给:engineToolDetach.setActiveEngineTaskId(liveClient 从 run_started 帧绑定,本壳每个交互