@sema-agent/client-core 0.44.0 → 0.46.0

package/dist/subagent/engineCompactWire.d.ts

@@ -1,12 +1,39 @@
-/** Test/introspection hook. */
-export declare function isEngineCompactPending(): boolean;
-/** Test hook: reset the cached capability (fresh engine / respawn). */
+/** Test/introspection hook(缺省 = 默认槽,与 0.44.0 逐字同)。 */
+export declare function isEngineCompactPending(sessionKey?: string): boolean;
+/**
+ * Test hook: reset the cached capability (fresh engine / respawn)。
+ *
+ * 🔴 **只清能力面,绝不动 arm 台账**(异源对抗复审第四轮 [medium] 采纳,修回归):本口是**生产口**
+ *    (引擎重启 / respawn 的能力失效),不是「取消用户的 /compact」。一度顺手加的 `pendingCompactKeys.clear()`
+ *    会让「idle 时 `/compact` 回过 armed → 引擎 respawn → 下一条 run 不再压缩」——用户的命令无声蒸发,
+ *    而且那是**默认槽**上的行为改变,与本批「单会话宿主逐字节零变化」的声明直接矛盾。
+ *    要清 arm 走 {@link __resetEngineCompactArmForTests}(测试钩,生产面没有这个动作)。
+ */
 export declare function resetManualCompactCapability(): void;
+/** 测试钩:清 arm 台账(module 级单例,同进程多组断言必须能清)。生产面**没有**这个动作。 */
+export declare function __resetEngineCompactArmForTests(): void;
 /**
  * The /compact command's live half. Mid-turn: fire now. Idle: arm for the next run bind.
  * Returns what it did (for the command's display line / tests). No-op ('offline') without a live
  * wire; 'unsupported' when the engine's capabilities said manualCompact:false ([488] TOC-local) —
  * the client-side projection compaction still runs, but the ENGINE session context does not shrink.
+ *
+ * 🔴 design/285 批 3(D7b):本族三处零参 `engineWireTarget()` 全部换成 `engineWireTargetFor(sessionKey)`。
+ *    /compact 打的是**这个会话此刻在飞的那条 run**,不是某一行子代 —— owner 台账里没有它,所以槽键
+ *    只能由调用方给(多会话宿主每个 REPL 面板一个槽)。缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
+ * 📋 **带反证的驳回半场(异源对抗复审第三轮 [high] 的另一半,如实记)**:复审还要求把快照提前到
+ *    **request(arm)那一拍**,理由是「arm 与 bind 之间槽可能被重绑,意图属于 A 却在 B 上执行」。
+ *    **不采**,反证:arm 那一拍**根本没有 taskId** —— `/compact` 在 idle 下的语义是成文的
+ *    「**这个槽的下一条 run**」(见本文件头注的 arm-then-fire 段),槽的身份就是 key 本身。
+ *    槽真被重绑到另一台引擎时,「下一条 run」就在那台引擎上,压它才是意图;把 request 那一刻的
+ *    target 冻下来反而会去压一台**已经不再跑这条会话**的引擎。⇒ 冻结的正确起点是**拿到 taskId 的
+ *    那一拍**(bind),那之后的每一次延迟与重试都必须用同一份 —— 那正是上面这一条。
+ *    现状由常驻钉 `B3-P31/R6i` 钉住(arm 之后换槽装配 ⇒ 发射打的是**换后**那台,且带换后的会话)。
+ * 🔴 **一条动词的槽键必须一以贯之**(异源对抗复审 [high] 采纳):目标、`?session=`、**run id**
+ *    (`activeEngineRunIdFor`)、**能力位**(per-baseUrl 分桶)、**arm 状态**(per-key 分桶)——
+ *    五件全按同一个 key。只换其中几件就是**半 keyed 形**:那比换锚之前更坏(之前五件一致地错在同一个
+ *    槽上,一眼可见;半 keyed 是「A 的 run id 发到 B 的服务器」「B 的 arm 被 A 的 bind 吃掉」这类只在
+ *    多会话下现形的错)。这条正是 plan 决策链本批**豁免**的同一条理由 —— 那边整条链搬不动,这边搬得动。
  */
-export declare function requestEngineCompact(): 'fired' | 'armed' | 'offline' | 'unsupported';
-export declare function onEngineTaskBound(taskId: string): void;
+export declare function requestEngineCompact(sessionKey?: string): 'fired' | 'armed' | 'offline' | 'unsupported';
+export declare function onEngineTaskBound(taskId: string, sessionKey?: string): void;

package/dist/subagent/engineCompactWire.js

@@ -36,14 +36,22 @@
  * 迁移差分记账:①原 raw POST 无超时 → SDK 缺省 60s 预算(compact 是 202 即回的 arm verb,本地
  * 口毫秒级,纯上界改善);②404 单次 2s 延迟重试(早 header bind 跑赢 run-row 持久化)逐字保留。
  */
-import { hostLog, hostTimers } from '../host.js';
+import { hostLog, hostTimersFor } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
-import { activeEngineRunId, engineSessionParamSpread } from '../engineSessionParam.js';
-let pendingEngineCompact = false;
-/** Test/introspection hook. */
-export function isEngineCompactPending() {
-    return pendingEngineCompact;
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+/**
+ * 🔴 **arm 状态按会话槽分桶**(design/285 批 3,异源对抗复审 [high] 采纳)。
+ *
+ * 修前是一个**进程级布尔**:`/compact` 在 B 会话上 idle-arm 之后,**先 bind 的那条会话**(可能是 A)
+ * 会把它消费掉 —— B 要的压缩发到了 A 的 run 上(动了一条不相干会话的上下文),而 B 自己永远没压缩。
+ * 单会话宿主上这两件事是同一件,keyed 化之后才第一次分得开。
+ */
+const pendingCompactKeys = new Set();
+/** Test/introspection hook(缺省 = 默认槽,与 0.44.0 逐字同)。 */
+export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
+    return pendingCompactKeys.has(sessionKey);
 }
 /**
  * [488] 定谳(2026-07-07 指纹探针,server 1.130.0):TOC 本地引擎(无 TiDB runStore)的
@@ -53,73 +61,109 @@ export function isEngineCompactPending() {
  * false ⇒ requestEngineCompact 返回 'unsupported'(不再装作 armed/fired)。探测失败 fail-open
  * (null=未知 ⇒ 保持旧行为发 verb,错误面不变)。
  */
-let manualCompactCapable = null;
-let capabilitiesProbe = null;
-function probeManualCompactCapability() {
-    if (capabilitiesProbe)
-        return;
-    const cfg = engineWireTarget();
+// 🔴 **判定位与在途探测按 baseUrl 分桶**(design/285 批 3,异源对抗复审 [high] 采纳;与
+//    `engineCapsCache` / `engineSubagentOutput.capByBase` 同代)。修前是**进程级单值**:keyed 宿主上
+//    `requestEngineCompact('B')` 会拿**先探到的那台引擎**(可能是 A)的 `manualCompact` 位去决定要不要
+//    给 B 发 verb —— 一条动词的槽键必须一以贯之,目标/会话/run id/能力位缺一个都是半 keyed 形。
+//    ⚠️ 单会话宿主只有一个 baseUrl ⇒ 分桶后与 0.44.0 逐字同(同一个 base 仍是「探一次、缓存住」)。
+const manualCompactCapableByBase = new Map();
+const capabilitiesProbeByBase = new Map();
+function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
+    const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
         return;
-    capabilitiesProbe = (async () => {
+    const base = cfg.baseUrl;
+    if (capabilitiesProbeByBase.has(base))
+        return;
+    capabilitiesProbeByBase.set(base, (async () => {
         try {
             // SDK 0.0.52 client.capabilities()(typed Capabilities.manualCompact)。5s 预算经 client
             // timeoutMs(对抗复审 MED 原语义:hung engine 不 pin probe promise);非 2xx/网络错/超时 SDK
-            // 统一抛错 → 与原「non-200 也重试」同归 catch 置 null 允许后续重试。
+            // 统一抛错 → 与原「non-200 也重试」同归 catch 删记号允许后续重试。
             const client = makeEngineWireClient({
-                baseUrl: cfg.baseUrl,
+                baseUrl: base,
                 ...(cfg.token ? { token: cfg.token } : {}),
                 principal: cfg.principal,
                 timeoutMs: 5000,
             });
             if (!client) {
-                capabilitiesProbe = null;
+                capabilitiesProbeByBase.delete(base);
                 return;
             }
             const caps = await client.capabilities();
             if (typeof caps.manualCompact === 'boolean')
-                manualCompactCapable = caps.manualCompact;
+                manualCompactCapableByBase.set(base, caps.manualCompact);
             else
-                capabilitiesProbe = null; // shape we don't understand — retry later
+                capabilitiesProbeByBase.delete(base); // shape we don't understand — retry later
         }
         catch {
-            capabilitiesProbe = null; // non-2xx/network error/timeout: unknown stays fail-open, next call re-probes
+            capabilitiesProbeByBase.delete(base); // non-2xx/network error/timeout: unknown stays fail-open, next call re-probes
         }
-    })();
+    })());
 }
-/** Test hook: reset the cached capability (fresh engine / respawn). */
+/**
+ * Test hook: reset the cached capability (fresh engine / respawn)。
+ *
+ * 🔴 **只清能力面,绝不动 arm 台账**(异源对抗复审第四轮 [medium] 采纳,修回归):本口是**生产口**
+ *    (引擎重启 / respawn 的能力失效),不是「取消用户的 /compact」。一度顺手加的 `pendingCompactKeys.clear()`
+ *    会让「idle 时 `/compact` 回过 armed → 引擎 respawn → 下一条 run 不再压缩」——用户的命令无声蒸发,
+ *    而且那是**默认槽**上的行为改变,与本批「单会话宿主逐字节零变化」的声明直接矛盾。
+ *    要清 arm 走 {@link __resetEngineCompactArmForTests}(测试钩,生产面没有这个动作)。
+ */
 export function resetManualCompactCapability() {
-    manualCompactCapable = null;
-    capabilitiesProbe = null;
+    manualCompactCapableByBase.clear();
+    capabilitiesProbeByBase.clear();
+}
+/** 测试钩:清 arm 台账(module 级单例,同进程多组断言必须能清)。生产面**没有**这个动作。 */
+export function __resetEngineCompactArmForTests() {
+    pendingCompactKeys.clear();
 }
 /**
  * 延迟发射(`setTimeout` + `unref` 的 port 形)。缺 TimersPort ⇒ **不发射**并留日志 ——
  * 静默 drop 会让 `/compact` 看起来 armed 了却永不落地(见文件头)。
  */
-function deferFire(ms, fn, why) {
-    const timers = hostTimers();
+function deferFire(ms, fn, why, sessionKey) {
+    // 🔴 定时器也按本槽取(异源对抗复审第四轮 [medium] 采纳):零参 `hostTimers()` 读的是**默认槽** ——
+    //    按接入契约只走 `installHostFor(key, {timers})` 的 keyed-only 宿主在那里恒空 ⇒ 快照有效、arm 已划掉、
+    //    请求永远不发射。一条动词的槽键必须一以贯之,定时器是第六件。
+    //    (默认槽下 `hostTimersFor(DEFAULT_SESSION_KEY)` ≡ `hostTimers()`,逐字节等价。)
+    const timers = hostTimersFor(sessionKey);
     if (!timers) {
         hostLog('debug', `engineCompactWire: no TimersPort — ${why} 不会发射(端漏装 port,/compact 这条腿静默失效)`);
-        return;
+        return false;
     }
     timers.setTimer(ms, fn);
+    return true;
 }
-async function postCompact(taskId, retriesLeft = 1) {
-    const cfg = engineWireTarget();
+/** 按本槽冻一发;`null` = 那一刻没有 wire(与修前的 `!cfg` 早退同语义,只是提前到冻结那一拍)。 */
+function freezeCompactShot(taskId, sessionKey) {
+    const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
-        return;
+        return null;
+    const sid = engineSessionParamFor(sessionKey);
+    return {
+        taskId,
+        sessionKey,
+        baseUrl: cfg.baseUrl,
+        ...(cfg.token !== undefined ? { token: cfg.token } : {}),
+        ...(cfg.principal !== undefined ? { principal: cfg.principal } : {}),
+        ...(sid !== undefined ? { session: sid } : {}),
+    };
+}
+async function postCompact(shot, retriesLeft = 1) {
     // SDK runs.compact(0.0.52)——POST /v1/runs/:id/compact body {}(无 instructions 时与原 '{}' 逐字
     // 同 wire);header 姿势 = Transport buildHeaders(Bearer 仅有 token 时 + x-agent-principal +
-    // content-type),与原手抄同三头。
+    // content-type),与原手抄同三头。🔴 三头与 `?session=` 全取**冻结的那一份**,绝不现读。
     const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
+        baseUrl: shot.baseUrl,
+        ...(shot.token ? { token: shot.token } : {}),
+        principal: shot.principal,
     });
     if (!client)
         return;
+    const taskId = shot.taskId;
     try {
-        const ack = await client.runs.compact(taskId, engineSessionParamSpread());
+        const ack = await client.runs.compact(taskId, shot.session !== undefined ? { session: shot.session } : {});
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
     }
     catch (e) {
@@ -128,7 +172,8 @@ async function postCompact(taskId, retriesLeft = 1) {
             hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${status}`);
             // 404 = the early header bind outran the run-row persist — one deferred retry covers it.
             if (status === 404 && retriesLeft > 0) {
-                deferFire(2000, () => void postCompact(taskId, retriesLeft - 1), '404 单次重试');
+                // 重试用**同一份**冻结快照:重试窗内换了会话/换了引擎,旧 taskId 也绝不配新凭证。
+                deferFire(2000, () => void postCompact(shot, retriesLeft - 1), '404 单次重试', shot.sessionKey);
             }
             return;
         }
@@ -140,21 +185,42 @@ async function postCompact(taskId, retriesLeft = 1) {
  * Returns what it did (for the command's display line / tests). No-op ('offline') without a live
  * wire; 'unsupported' when the engine's capabilities said manualCompact:false ([488] TOC-local) —
  * the client-side projection compaction still runs, but the ENGINE session context does not shrink.
+ *
+ * 🔴 design/285 批 3(D7b):本族三处零参 `engineWireTarget()` 全部换成 `engineWireTargetFor(sessionKey)`。
+ *    /compact 打的是**这个会话此刻在飞的那条 run**,不是某一行子代 —— owner 台账里没有它,所以槽键
+ *    只能由调用方给(多会话宿主每个 REPL 面板一个槽)。缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
+ * 📋 **带反证的驳回半场(异源对抗复审第三轮 [high] 的另一半,如实记)**:复审还要求把快照提前到
+ *    **request(arm)那一拍**,理由是「arm 与 bind 之间槽可能被重绑,意图属于 A 却在 B 上执行」。
+ *    **不采**,反证:arm 那一拍**根本没有 taskId** —— `/compact` 在 idle 下的语义是成文的
+ *    「**这个槽的下一条 run**」(见本文件头注的 arm-then-fire 段),槽的身份就是 key 本身。
+ *    槽真被重绑到另一台引擎时,「下一条 run」就在那台引擎上,压它才是意图;把 request 那一刻的
+ *    target 冻下来反而会去压一台**已经不再跑这条会话**的引擎。⇒ 冻结的正确起点是**拿到 taskId 的
+ *    那一拍**(bind),那之后的每一次延迟与重试都必须用同一份 —— 那正是上面这一条。
+ *    现状由常驻钉 `B3-P31/R6i` 钉住(arm 之后换槽装配 ⇒ 发射打的是**换后**那台,且带换后的会话)。
+ * 🔴 **一条动词的槽键必须一以贯之**(异源对抗复审 [high] 采纳):目标、`?session=`、**run id**
+ *    (`activeEngineRunIdFor`)、**能力位**(per-baseUrl 分桶)、**arm 状态**(per-key 分桶)——
+ *    五件全按同一个 key。只换其中几件就是**半 keyed 形**:那比换锚之前更坏(之前五件一致地错在同一个
+ *    槽上,一眼可见;半 keyed 是「A 的 run id 发到 B 的服务器」「B 的 arm 被 A 的 bind 吃掉」这类只在
+ *    多会话下现形的错)。这条正是 plan 决策链本批**豁免**的同一条理由 —— 那边整条链搬不动,这边搬得动。
  */
-export function requestEngineCompact() {
-    if (!engineWireTarget())
+export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
+    const cfg = engineWireTargetFor(sessionKey);
+    if (!cfg)
         return 'offline';
-    probeManualCompactCapability(); // lazy, cached; first call may still ride the old path (fail-open)
-    if (manualCompactCapable === false) {
+    probeManualCompactCapability(sessionKey); // lazy, cached per baseUrl; first call may still ride the old path (fail-open)
+    if (manualCompactCapableByBase.get(cfg.baseUrl) === false) {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }
-    const taskId = activeEngineRunId();
+    // 🔴 run id 也按本槽取(异源对抗复审 [high]):写死默认槽 = 把 A 的 run id 发到 B 的服务器上。
+    const taskId = activeEngineRunIdFor(sessionKey);
     if (taskId) {
-        void postCompact(taskId);
+        const shot = freezeCompactShot(taskId, sessionKey);
+        if (shot !== null)
+            void postCompact(shot);
         return 'fired';
     }
-    pendingEngineCompact = true;
+    pendingCompactKeys.add(sessionKey);
     return 'armed';
 }
 /**
@@ -167,10 +233,25 @@ export function requestEngineCompact() {
  * more for slow persists. Both shots are best-effort (postCompact never throws).
  */
 const BOUND_FIRE_DELAY_MS = 1500;
-export function onEngineTaskBound(taskId) {
-    probeManualCompactCapability(); // warm the capability cache off the first turn bind, before any /compact
-    if (!pendingEngineCompact)
+export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY) {
+    probeManualCompactCapability(sessionKey); // warm the capability cache off the first turn bind, before any /compact
+    // 🔴 只消费**本槽**的 arm(异源对抗复审 [high]):进程级布尔会让先 bind 的那条会话把别人的 arm 吃掉 ——
+    //    B 要的压缩发到 A 的 run 上,而 B 自己永远没压缩。
+    if (!pendingCompactKeys.has(sessionKey))
         return;
-    pendingEngineCompact = false;
-    deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(taskId), 'bind 后发射');
+    // 🔴 **在 bind 这一拍冻结**(异源对抗复审 [high]):延迟 1.5s 之后再现读 target/session,就会把
+    //    这一拍的 taskId 配上那一拍的引擎与会话。
+    // 🔴 **冻不出快照就不消费这一记 arm**(异源对抗复审第三轮 [high] 的可采半场):那一刻没有 wire
+    //    时,旧形是「先把 arm 划掉、再发现发不出去」= 用户的 `/compact` 无声蒸发,而命令行早就回过
+    //    'armed'。改成**冻出来了才划掉**:这一拍发不出就留着,下一次 bind 再兑现(arm-then-fire 的
+    //    本意就是「下一条 run」,不是「下一条 run 且那一刻恰好有 wire」)。
+    const shot = freezeCompactShot(taskId, sessionKey);
+    if (shot === null)
+        return;
+    // 🔴 **登记上定时器才划掉 arm**(异源对抗复审第四轮 [medium]):端漏装 TimersPort 时 `deferFire`
+    //    只留一行日志就返回,先划掉 arm 就等于把用户的 `/compact` 无声吃掉(与上面那条同一个道理,
+    //    只是这一次挡的是「冻得出快照但排不上队」)。
+    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {
+        pendingCompactKeys.delete(sessionKey);
+    }
 }

package/dist/subagent/engineDelegatedPrompt.js

@@ -47,7 +47,8 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { resolveOwnerContext } from './engineSubagentResume.js';
 /** 只拉转录**尾部**这么多条(委派 prompt 在尾部方向;见文件头的 fork 形状订正)。 */
 const TAIL_WINDOW = 200;
 /** 单条正文的上限:详情页自己还会截到 300 字符,这里只防拉回一个巨型 blob。 */
@@ -174,11 +175,14 @@ let transcriptWindowReader = null;
 export function __setTranscriptWindowReaderForTests(r) {
     transcriptWindowReader = r;
 }
-async function readTranscriptWindow(transcriptId) {
+async function readTranscriptWindow(transcriptId, sessionKey) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
     // 🔴 B6:六份手抄 `wireConfig()` 收成 `engineWireTarget()`(env 读经 hostEnv,本包零 process)。
-    const cfg = engineWireTarget();
+    // 🔴 design/285 批 3(D7b):零参形写死默认槽 —— 转录取件是**按行**的读面(锚 = 这一行登记的
+    //    transcriptId),所以 baseUrl/token/principal 必须按**这一行所属的槽**取,否则 keyed 宿主上
+    //    会拿 A 槽的凭证去 `GET /v1/sessions/:id` 读 B 槽的转录(404,或更坏:读到同 id 的别人)。
+    const cfg = engineWireTargetFor(sessionKey);
     if (!cfg)
         return null;
     const client = makeEngineWireClient({
@@ -213,7 +217,8 @@ export async function fetchDelegatedPrompt(taskId) {
     promptHydrateInFlight.add(taskId);
     let msgs = null;
     try {
-        msgs = await readTranscriptWindow(transcriptId);
+        // 槽键取自 owner 台账的这一行(缺席 ⇒ DEFAULT_SESSION_KEY ⇒ 与 0.44.0 逐字同)。
+        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key);
     }
     catch (e) {
         promptHydrateInFlight.delete(taskId);

package/dist/subagent/engineRowStopGate.d.ts

@@ -4,8 +4,15 @@ export declare const engineOwnedRowIds: Set<string>;
 export declare const fleetViewStubRowIds: Set<string>;
 /** 这一行的真身在引擎里(本地 abortController 管不到它)。 */
 export declare function isEngineViewRow(taskId: string): boolean;
-/** 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。 */
-export declare function engineTaskHandlesCapable(): boolean;
+/**
+ * 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。
+ *
+ * 🔴 design/285 批 3(D7b):零参 `engineWireTarget()` 换成 `engineWireTargetFor(sessionKey)`。
+ *    caps 缓存按 **baseUrl** 分桶,而 keyed 多会话宿主每槽一个 baseUrl —— 写死默认槽 = 用 A 引擎的
+ *    能力位去判 B 引擎能不能停行。本模块是**零依赖叶**(单实例纪律见头注),不许 import 台账,
+ *    所以槽键由调用方给;缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
+ */
+export declare function engineTaskHandlesCapable(sessionKey?: string): boolean;
 /**
  * 停这一行**必须先拿到引擎回执**吗?
  *
@@ -15,4 +22,4 @@ export declare function engineTaskHandlesCapable(): boolean;
  * false ⇒ 行跑在本进程(CC 逐字形态),`abortController.abort()` 就是执行本身,端写 `killed`
  *         按构造恒真 ⇒ 同步翻,与 CC 2.1.220 `UPd`(pretty220.js:507299)一字不差。
  */
-export declare function engineRowNeedsStopConfirm(taskId: string): boolean;
+export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string): boolean;

package/dist/subagent/engineRowStopGate.js

@@ -27,7 +27,8 @@
  *   缺任一(老引擎 / 无 wire / 纯本地 AgentTool 行) → 回落旧行为(本地 abort 即真停,立即翻)。
  */
 import { engineCapTrue } from '../engineCapsCache.js';
-import { engineWireTarget } from '../engineWireTarget.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 /** 引擎 bridge 从 `task_progress` tick / fleet 行帧建的行(module-level:footer 重挂不丢归属)。 */
 export const engineOwnedRowIds = new Set();
 /** fleet 树 enter 时为「面板无行的 fleet 行」stub 出来的纯查看载体行。 */
@@ -36,9 +37,16 @@ export const fleetViewStubRowIds = new Set();
 export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
-/** 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。 */
-export function engineTaskHandlesCapable() {
-    return engineCapTrue(engineWireTarget()?.baseUrl, 'taskHandles');
+/**
+ * 能力门同步读口(liveClient 构造期已 kick /v1/capabilities 进 engineCapsCache)。
+ *
+ * 🔴 design/285 批 3(D7b):零参 `engineWireTarget()` 换成 `engineWireTargetFor(sessionKey)`。
+ *    caps 缓存按 **baseUrl** 分桶,而 keyed 多会话宿主每槽一个 baseUrl —— 写死默认槽 = 用 A 引擎的
+ *    能力位去判 B 引擎能不能停行。本模块是**零依赖叶**(单实例纪律见头注),不许 import 台账,
+ *    所以槽键由调用方给;缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
+ */
+export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY) {
+    return engineCapTrue(engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
 }
 /**
  * 停这一行**必须先拿到引擎回执**吗?
@@ -49,6 +57,7 @@ export function engineTaskHandlesCapable() {
  * false ⇒ 行跑在本进程(CC 逐字形态),`abortController.abort()` 就是执行本身,端写 `killed`
  *         按构造恒真 ⇒ 同步翻,与 CC 2.1.220 `UPd`(pretty220.js:507299)一字不差。
  */
-export function engineRowNeedsStopConfirm(taskId) {
-    return isEngineViewRow(taskId) && engineTaskHandlesCapable();
+export function engineRowNeedsStopConfirm(taskId, sessionKey) {
+    // `sessionKey` additive(design/285 批 3):keyed 宿主把这一行所属的槽传下来;缺省 = 默认槽。
+    return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY);
 }

package/dist/subagent/engineSubagentOutput.js

@@ -31,9 +31,9 @@
  */
 import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTarget } from '../engineWireTarget.js';
-import { getBgParentRun } from '../subagentContentStore.js';
-import { engineSessionParam } from '../engineSessionParam.js';
+import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineSessionParamFor } from '../engineSessionParam.js';
+import { resolveOwnerContext } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 // ── caps 探测(true 固化 / false TTL / 失败不缓存)────────────────────────────────────────────
 const capByBase = new Map();
@@ -62,14 +62,17 @@ export function __resetSubagentOutputCapCacheForTests() {
  * 调用方回落 bg 事实渲染。绝不 throw。
  */
 export async function fetchEngineSubagentReport(taskId, opts) {
-    const cfg = engineWireTarget();
+    // 🔴 design/285 批 3(D7b):台账记录**先取**(纯读)—— wire target 按**这一行的会话槽**取,
+    //    零参 `engineWireTarget()` 写死默认槽。`sessionKey` 缺席 ⇒ 回落默认槽 ⇒ 与 0.44.0 逐字同。
+    //    ⚠️ 两道闸的**次序一字未动**(无 wire 仍先于「台账缺席」返回)。
+    const { record: owner, runId, key } = resolveOwnerContext(taskId);
+    const cfg = engineWireTargetFor(key);
     if (!cfg)
         return null;
     // 🔴 #242 批 3([4000] Q3=B 裁定执行,行为翻面):台账缺席即**诚实缺席,绝不回落**
     //    `activeEngineRunId()` —— 与 resume 腿 `resolveOwnerRunId` 同口径(错值比缺席更坏:回落
     //    到「此刻在飞的 run」对 session-bound 旧 run 是 404 撞墙,对同名子代是读错人)。缺席不
     //    静默(noteBgOwnerAbsence warn 留痕);调用方按既有 null 回落 bg 事实渲染,fail-soft。
-    const runId = getBgParentRun(taskId);
     if (!runId) {
         noteBgOwnerAbsence('subagent-output', taskId);
         return null;
@@ -86,7 +89,10 @@ export async function fetchEngineSubagentReport(taskId, opts) {
     try {
         // [1498]③:无条件带 session(1.244 忽略/1.245 必需,双版本兼容);缺席时(端未装 SessionPort /
         // 端自己还没有值)不带——1.245 对 session-bound run 会 404,按既有 null 回落,下次重试自然带上。
-        const session = engineSessionParam();
+        // 🔴 design/285 批 3(D6,会话二态;与 steer/tail 同一口径):行登记的会话优先,缺则退**本槽**现势会话。
+        //    🔴 BEHAVIOR CHANGE(默认槽也变):tick 腿今天就在默认槽写 `sessionId` ⇒ 会话轮换后读旧行的终报,
+        //    此前拿**现势**会话打一条 session-bound 的旧 run = 确定性 404;现在用行登记的那一个。
+        const session = owner?.sessionId ?? engineSessionParamFor(key);
         const r = await client.runs.subagentOutput(runId, taskId, {
             ...(opts?.signal ? { signal: opts.signal } : {}),
             ...(session ? { session } : {}),

package/dist/subagent/engineSubagentResume.d.ts

@@ -48,10 +48,18 @@
  * 呈前消毒 + 截长,只渲染。
  */
 import type { SubagentSteerReceipt } from '@sema-agent/sdk';
+import { type SubagentOwnerRecord } from '../subagentContentStore.js';
 /** 能力位键(server `routes/capabilities.ts` 的 `subagentResume`;SDK `Capabilities.subagentResume`)。 */
 export declare const SUBAGENT_RESUME_CAP = "subagentResume";
-/** 复活口在不在。未判/缺键 = false = 详情面不渲「继续」腿。 */
-export declare function subagentResumeAvailable(baseUrl?: string | undefined): boolean;
+/**
+ * 复活口在不在。未判/缺键 = false = 详情面不渲「继续」腿。
+ *
+ * 🔴 design/285 批 3(D7b):`baseUrl` 缺席时的派生从零参 `engineWireTarget()`(写死默认槽)换成
+ *    `engineWireTargetFor(sessionKey)`。**本腿没有行上下文**(它答的是「这台引擎有没有这个口」,
+ *    不是「这一行该打到哪」)⇒ 槽键只能由调用方给,缺省 `DEFAULT_SESSION_KEY` = 与 0.44.0 逐字同。
+ *    显式 `baseUrl` 恒赢(既有注入缝不动;空串仍原样保留 —— `??` 只对 `undefined` 让位,与默认参形同)。
+ */
+export declare function subagentResumeAvailable(baseUrl?: string, sessionKey?: string): boolean;
 /**
  * 「继续」腿的 resume 取址(1.0.74 终扫 P2-11)。
  *
@@ -138,6 +146,34 @@ export declare function classifySubagentResumeFailure(e: unknown): {
  * @param activeRunId 注入缝(缺省 = `activeEngineRunId()`)—— 判据要能在没有 SessionPort 的纯层里验。
  */
 export declare function resolveOwnerRunId(childTaskId?: string, activeRunId?: string | undefined): string | undefined;
+/** {@link resolveOwnerContext} 的返回三件。 */
+export interface SubagentOwnerContext {
+    /** 整条台账记录;`undefined` = **诚实不知道**,调用方走各自既有的缺席出路(绝不在这里回落)。 */
+    record: SubagentOwnerRecord | undefined;
+    /**
+     * `= record?.runId`,与既有 `getBgParentRun()` 逐字同。
+     * 🔴 **不含**「没指名行就回落到在飞 run」那一态 —— 那一态的判据住在 {@link resolveOwnerRunId},
+     *    本函数既不复制它,也**不读 SessionPort**(读了就会给 tail/output/taskHandle 三条
+     *    「台账缺席即诚实缺席」的腿凭空添一次 `activeEngineRunId()` 端口读)。
+     */
+    runId: string | undefined;
+    /** 读侧要用的会话槽键 = `record.sessionKey ?? DEFAULT_SESSION_KEY`。 */
+    key: string;
+}
+/**
+ * 「这一行子代属于哪个会话槽」—— 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 declare function resolveOwnerContext(childTaskId?: string): SubagentOwnerContext;
 /** 一次 resume 调用需要的三件:facade(null = 无 wire)、宿主 run(undefined = 诚实缺席)、会话参数。 */
 export interface SubagentResumeContext {
     facade: SubagentResumeFacade | null;
@@ -157,7 +193,15 @@ export interface SubagentResumeContext {
  *      猜错会话可能落到**另一个会话的同名子代**上,那是不可回收的伤害;不带参数的失败只是 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 declare function resolveSubagentResumeContext(childTaskId?: string): SubagentResumeContext;
 /**
@@ -200,6 +244,12 @@ export interface RetainWithoutWakeInput {
         }) => Promise<void>) | undefined;
     } | null | undefined;
     retainRequested?: boolean | undefined;
+    /**
+     * 🔴 design/285 批 3(D7b):`baseUrl` 缺席时按哪个会话槽派生。缺省 `DEFAULT_SESSION_KEY`
+     * ⇒ 与 0.44.0 逐字同(零参 `engineWireTarget()` 就是默认槽)。本告警是**per-baseUrl once**
+     * 的,keyed 宿主不点名槽就会让两个槽共用一条 once 记录(先响的那个把另一个吞掉)。
+     */
+    sessionKey?: string | undefined;
 }
 /**
  * 「引擎有复活口 + 本端在付留存成本 + 本端没有 wake 实现」⇒ 响亮一条(每 baseUrl 至多一次)。