@sema-agent/server 7.148.0 → 7.150.0

package/dist/task-cwd.d.ts

@@ -1,13 +1,15 @@
 import { type DeploymentShapeInput } from "./deployment-shape.js";
+import type { RunInternals } from "@sema-agent/core";
 /**
  * 词法归一:纯字符串运算,折 `.` / `..` / 重复分隔符,**不碰 fs**。
  * `posix.normalize` 把 `..` 在根部截断(`/../x` → `/x`),与「根之上没有东西」的语义一致;尾部分隔符
  * 统一剥掉(根 `/` 除外),让同一目标只有一个 key —— 前缀判域(见 {@link dirCoversPath})靠的就是
  * key 的唯一性。
  *
- * 🔴 **单点**([ref] 起):此前它的一份私有副本住在 `boot/deferred-sandbox-path-env.ts`(沙箱代理的
- * `absolutePath` 词法臂),而写门豁免域与任务根的判域现在读的是同一条律 —— 两份各自归一就是两个 key
- * 空间,而「豁免域盖没盖住任务根」这种判断在两个 key 空间里可以同时答是和否。
+ * 🔴 **单点**([ref] 起):写门豁免域与任务根的判域读的是同一条律 —— 两份各自归一就是两个 key
+ * 空间,而「豁免域盖没盖住任务根」这种判断在两个 key 空间里可以同时答是和否。它只答**配置座**上的判域
+ * (env-facts 的 cwd / scratchpad 事实、{@link dirCoversPath});执行环境方法读路径不经它 —— 那一面是执行缝路径律
+ * (`plugins/exec-path-law.ts`,只锚不折,沙箱写门代理的 `absolutePath` 也读那一只)。
  * (core 内部有同形的 `normalizeAbsPathLexically`,但未从包根导出;此处是 Node 标准库的等价运算,
  *  不是它的抄本——若日后 core 导出,这里应改为直接复用。)
  */
@@ -85,23 +87,38 @@ export declare function parseAdditionalDirectories(raw: unknown): string[] | und
  * sandbox — "当前工作目录为空"): resolve the HOST lane's effective workspace for a task. Precedence:
  *   1. the session's explicitly-registered `cwd` (the caller's own launch dir, the cwd seam) — an explicit
  *      per-session choice always wins;
- *   2. the TRUSTED `ctx.parentCwd` (core threads the PARENT task's working root via `RunInternals` when this
- *      task is a delegated child — never a TaskSpec field), UNLESS the child asked for `isolation:"worktree"`
- *      (an isolated fan-out child must not share the parent's mutable dir) — then `undefined`;
- *   3. undefined → the factory's ephemeral per-task dir (top-level task with no registered cwd).
+ *   2. the TRUSTED `ctx.parentCwd` — the working root of the run that handed this leg its work, via `RunInternals`
+ *      (never a TaskSpec field): a delegating parent (core threads it to a delegated child) or a composition host (the
+ *      submission whose cascade ladder / verification gate this leg belongs to: those legs run in sessions the engine
+ *      mints, which arm 1 cannot read, so the composition entries hand them the submission's registered cwd —
+ *      {@link compositionLegRoot}) — UNLESS the leg asked for `isolation:"worktree"` (an isolated fan-out child must
+ *      not share the parent's mutable dir) — then `undefined`;
+ *   3. undefined → the factory's ephemeral per-task dir (no registered cwd anywhere up the chain).
  * The `isolation:"worktree"` ⇒ `undefined` rule is this function's own and holds by itself (the child never inherits the
  * parent's dir). It is NOT what answers a worktree ask on the host lane: `boot/execution-env.ts` never reaches here with one —
  * the worktree wrapper (one layer out) mints the tree and does not call the base factory, and without the wrapper the base
  * factory REFUSES (`isolation.unavailable`) instead of minting the empty ephemeral dir rule 3 would give. That refusal arm is
  * revoked when engine 7.61.0 refuses by itself; this function's rule then goes on keeping the child off the parent's dir.
- * CC parity: a Task sub-agent inherits the main session's cwd. Trust: `parentCwd` comes from core's trusted
- * run-internals channel (same posture as `isolation`), so no tenancy gate is needed here — but the HOST lane
- * itself is single-user by deployment shape, and container lanes (k8s/e2b/local-docker) never consult this.
+ * CC parity: a Task sub-agent inherits the main session's cwd. Trust: `parentCwd` comes from the trusted
+ * run-internals channel (same posture as `isolation`) — written by core's delegation callers, or by this service's
+ * composition entries from a cwd the registration gate (`callerCwd`) already admitted — so no tenancy gate is needed
+ * here; the HOST lane itself is single-user by deployment shape, and container lanes (k8s/e2b/local-docker) never consult this.
  */
 export declare function effectiveHostWorkspace(sessionCwd: string | undefined, ctx: {
     isolation?: string;
     parentCwd?: string;
 }): string | undefined;
+/**
+ * 组合入口(`runCascade` / `resumeCascade` / `runWithVerification` / `resumeWithVerification`)交给它驱动的**每一条腿**的那一格:这次提交登记的工作目录,
+ * 作交活方的工作目录(`RunInternals.parentCwd`)—— {@link effectiveHostWorkspace} 的第 2 臂,委派子代用的同一臂(device 车道的 `effectiveDeviceCwd` 同序)。
+ *
+ * 为什么组合腿要它:梯子的每一级是在引擎**现铸的会话**里冷跑(core `runCascade` 剥掉 spec 的 `sessionId`),验证门的验证器腿的 spec 不带会话 ——
+ * 工厂按腿的会话查登记表(第 1 臂)查不到提交登记在根会话上的那一枚,不交就落第 3 臂(临时目录):用户让梯子在项目里改文件,改到了别处;验证器验的是一只空目录。
+ * 跑在根会话上的腿(验证门的实现腿 / 修复腿)第 1 臂先命中,同一个值。
+ * 没登记(`registeredCwd` 缺席:非 host / device 车道、多租户、根会话的提交从没带过 `cwd`、嵌入方装配器没铸事实)⇒ 空对象 —— 每一条腿照旧落临时目录、收场由托管表删。
+ * 登记粘在会话上(`setSessionCwd` 只在请求带 `cwd` 时写):同一会话之前带过、这次不带 ⇒ 交的仍是那一枚 —— 与第 1 臂对同一会话上普通 run 的读法一致。
+ */
+export declare function compositionLegRoot(registeredCwd: string | undefined): Pick<RunInternals, "parentCwd">;
 /** {@link launchWorkspaceOf} 读到的那一格出自哪里(闭集;起服那一行日志与随包文档的 `workspaceFrom` 词)。 */
 export type LaunchWorkspaceFrom = "workspace-flag" | "host-workspace-base" | "process-cwd";
 /** 起服时的「工作区」:目录 + 它读自哪一格。 */

package/dist/task-cwd.js

@@ -46,6 +46,9 @@ export function parseAdditionalDirectories(raw) {
 export function effectiveHostWorkspace(sessionCwd, ctx) {
     return sessionCwd ?? (ctx.isolation !== "worktree" ? ctx.parentCwd : undefined);
 }
+export function compositionLegRoot(registeredCwd) {
+    return registeredCwd !== undefined ? { parentCwd: registeredCwd } : {};
+}
 export function launchWorkspaceOf(config, explicit, cwd = process.cwd) {
     if (explicit !== undefined)
         return { dir: explicit, from: "workspace-flag" };

package/dist/task-mcp.d.ts

@@ -69,9 +69,9 @@ export declare const MAX_REQUEST_MCP_DROP_NAMES = 32;
  */
 export declare const MCP_SERVER_ENTRY_KEYS: readonly ["allowTools", "contentOrigin", "elicitation", "name", "sessionMetaKey", "source", "startupTimeoutMs", "toolAxes", "toolFaces", "transport"];
 /** `transport.kind:"stdio"` 的键闭集 = stdio 臂处置表的键(`env` 是件,其余进声明)。 */
-export declare const STDIO_MCP_TRANSPORT_KEYS: readonly ("env" | "kind" | "args" | "command")[];
+export declare const STDIO_MCP_TRANSPORT_KEYS: readonly ("kind" | "env" | "args" | "command")[];
 /** `transport.kind:"http"` 的键闭集 = http 臂处置表的键(`headers` 是件,`assertionHeader` 承载不发送,其余进声明)。 */
-export declare const HTTP_MCP_TRANSPORT_KEYS: readonly ("url" | "headers" | "kind" | "principalHeader" | "assertionHeader")[];
+export declare const HTTP_MCP_TRANSPORT_KEYS: readonly ("url" | "kind" | "headers" | "principalHeader" | "assertionHeader")[];
 /**
  * Does THIS deployment honor caller-supplied per-request MCP servers? TRUE for a SINGLE-USER deployment
  * (deployment-shape row `multiTenant` does not hold) — the requester is the super-admin of their own worker, so their `.mcp.json` is
@@ -189,7 +189,7 @@ export declare function requestMcpDeclarationRefusal(list: unknown): Declaration
  * 重放腿走读器({@link normalizeServer} / {@link classifyRequestMcp}),处置:整只不是数组 ⇒ 整只忽略 + 运维 warn `mcp_injection_ignored`;条目不是对象 / 坏硬键
  * (`name` / `transport` 硬字段 / `allowTools` / `toolAxes` / `toolFaces`)⇒ 这一条 server 整条不进 + 运维 warn `mcp_injection_dropped` + 用户面通告 `mcp.injection_dropped` 点名 `field`
  * (`toolAxes` 在一次性迁移 M19 的窗开着时先按升级前读法重读一次,过了就挂,见读器的注);超上限的尾项 ⇒ `over_cap` 点名;坏软键(`contentOrigin` / `elicitation` / `source`)
- * 与词表外的键 ⇒ 丢键、server 照挂(`contentOrigin` 另有 `mcp_content_class_dropped` 留声);`transport` 软字段有几处读器不交(`env` / `headers` 不是纯数据的串记录、其中名叫 `__proto__` 的成员、
+ * 与词表外的键 ⇒ 丢键、server 照挂(`contentOrigin` 另有 `mcp_content_class_dropped` 留声);`transport` 软字段有几处读器不交(`env` / `headers` 不是纯数据的串记录、其中名叫保留名(`__proto__` / `constructor` / `prototype`)的成员、
  * `args` / `principalHeader` 坏形)⇒ 这份请求不重放(「请求成员读不出」那一只判据,`unread-request-members.ts`,经 {@link requestMcpTransportUnread} 读这一座;续跑腿折 409)。
  */
 export declare function assertRequestMcpEntries(bodyMcp: unknown): void;

package/dist/task-mcp.js

@@ -5,7 +5,7 @@ import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
 import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 import { MCP_SOURCE_LABEL_MAX, isMcpSourceLabel, readMcpSourceLabel } from "./mcp-source-label.js";
 import { MCP_HTTP_TRANSPORT_DISPOSITION, MCP_STDIO_TRANSPORT_DISPOSITION, describeMcpAssertionHeaderNotAString, describeMcpIdentityHeadersConflict, mcpIdentityHeadersIssue, noteMcpAssertionHeaderIgnored, noteMcpAssertionHeaderNotSent, specWithholdsMcpAssertionHeader, toMcpDraft, } from "./mcp-assertion-header.js";
-import { declarationKeys } from "./plain-string-record.js";
+import { declarationKeys } from "./request-declaration-disposition.js";
 import { mintDeclaration, peerSentence } from "./peer-seat.js";
 import { MAX_KEY_ECHO, echoKeyName, keyClosureClause, scanKeyClosure } from "./request-key-closure.js";
 import { readRequestToolAxes } from "./request-tool-axes.js";

package/dist/task-settings.d.ts

@@ -463,6 +463,19 @@ export declare function taskHooksHonored(config: {
  * 在 `server.ts` prepareSpec 里 400 响亮拒 + 逐字列名。双层姿势与 outputStyle / permissionMode 两处逐字相同。
  */
 export declare function parseTaskSettings(raw: unknown, seats?: ParseTaskSettingsSeats): ParseTaskSettingsResult;
+/** The one reading of `settings.outputStyle`: a non-empty string within {@link MAX_SETTINGS_OUTPUT_STYLE_CHARS} ⇒ it; anything else ⇒ absent.
+ *  Readers: the settings parser above and the system-prompt fold judgment at the head of `resolveSpec` (which runs before the parser's stage). */
+export declare function acceptOutputStyle(v: unknown): string | undefined;
+/**
+ * **系统提示追加折叠的唯一读法**(一个 spec 字段 `TaskSpec.appendSystemPrompt` 里折进几段):段按序、缺席 / 空段不出、`\n\n` 连接;`chars` = 折出来的字符数(含连接符)。
+ * 段序恒为 请求 `appendSystemPrompt` → 项目简报(`project-context.ts`)→ `settings.outputStyle`(字节稳定,前缀缓存靠它);三段共一只上限 16384。
+ * 读者四位,同读这一只:受理口的两段合计判(`http/admission.ts`)、装配器头部的三段判(`boot/resolve-spec.ts`,只在简报在场时)、装配合成(本文件 `applyTaskSettings` 接 style)、
+ * 续跑镜像(`resolve-spec.ts` 阶段⑤:存量体合计超帽 ⇒ 丢 style + warn)。
+ */
+export declare function appendFold(segments: readonly (string | undefined)[]): {
+    readonly text: string | undefined;
+    readonly chars: number;
+};
 /** Defensive acceptance of the `appendSystemPrompt` rider ([ref] R2 + codex F2): the HTTP 400 gate (prepareSpec,
  *  MAX_SYSTEM_PROMPT_CHARS) only covers FRESH submits — every resume family re-enters resolveSpec on a STORED body,
  *  and a pre-1.243 store preserved unknown request keys verbatim (the field was INERT then), so an over-cap legacy

package/dist/task-settings.js

@@ -135,6 +135,7 @@ export function settingsEnvCredentialIssue(reaching, credentialNames) {
         message: `settings.env carries credentials: ${named.join(", ")}${more}. A credential reaches the engine only through the environment its process starts from, never through a request's settings.env — ` +
             "that block comes from a settings file the model can read, and the request hands it to the session's shell and hooks. Move these out of settings.env into the engine's environment " +
             "(a sema shell that keeps credentials in its credentials.env file does this; upgrade a shell that still writes them into settings.json). " +
+            "A settings hook reads a variable from the engine's environment only when the deployment names it in HOOK_ENV_ALLOW; this engine's own credential variables (the entries matched by name) reach no hook at all. " +
             "If an entry is not a credential: rename a variable that matched by name, or keep a value that matched by shape out of settings.env the same way (the shape scan is deliberately coarse)",
         fields: { field: "settings.env", entries },
         keys: hits.map((h) => h.key),
@@ -359,9 +360,9 @@ export function parseTaskSettings(raw, seats = {}) {
     }
     if (typeof s.model === "string" && s.model.length > 0)
         out.model = s.model;
-    if (typeof s.outputStyle === "string" && s.outputStyle.length > 0 && s.outputStyle.length <= MAX_SETTINGS_OUTPUT_STYLE_CHARS) {
-        out.outputStyle = s.outputStyle;
-    }
+    const outputStyle = acceptOutputStyle(s.outputStyle);
+    if (outputStyle !== undefined)
+        out.outputStyle = outputStyle;
     if (shellEnv)
         out.shellEnv = shellEnv;
     if (s.ultracode === true)
@@ -387,6 +388,14 @@ export function parseTaskSettings(raw, seats = {}) {
         out.httpHookAllowlist = httpHookAllowlist;
     return { settings: Object.keys(out).length > 0 ? out : undefined, deferred, ...(hooksReread !== undefined ? { hooksReread } : {}) };
 }
+export function acceptOutputStyle(v) {
+    return typeof v === "string" && v.length > 0 && v.length <= MAX_SETTINGS_OUTPUT_STYLE_CHARS ? v : undefined;
+}
+export function appendFold(segments) {
+    const present = segments.filter((segment) => segment !== undefined && segment.length > 0);
+    const text = present.length > 0 ? present.join("\n\n") : undefined;
+    return { text, chars: text?.length ?? 0 };
+}
 export function acceptAppendSystemPrompt(v, warn) {
     if (v === undefined)
         return undefined;
@@ -592,10 +601,8 @@ export function applyTaskSettings(base, settings, bases) {
     const allow = settings.permissions?.allow;
     if (allow !== undefined)
         next = { ...next, allowedTools: allow.map((entry) => allowMemberOf(entry, bases?.configRoot)) };
-    if (settings.outputStyle) {
-        const appended = next.appendSystemPrompt ? `${next.appendSystemPrompt}\n\n${settings.outputStyle}` : settings.outputStyle;
-        next = { ...next, appendSystemPrompt: appended };
-    }
+    if (settings.outputStyle)
+        next = { ...next, appendSystemPrompt: appendFold([next.appendSystemPrompt, settings.outputStyle]).text };
     return next;
 }
 //# sourceMappingURL=task-settings.js.map

package/dist/terminal.d.ts

@@ -105,6 +105,8 @@ export declare function mapPauseSeats<T>(result: T, f: (seat: SeatObject, keys:
  *  ①摘掉**耐久恢复能力凭据**(`CheckpointToken`)—— 座表 {@link PAUSE_SEATS} 上的每一座;②把**域外的失败码**折成本仓的
  *  `internal.store_error`({@link outwardFailureCode},[ref])—— 码座两只:因由的 `terminal.code` 与 cascade 每一级的 `attempts[].errorCode`(同一类码,见 {@link foldOutwardFailureCodes});
  *  因由上折码时**失败句同时换成对外句**(类别句 + 原码尾注,库驱动原句不上 wire,{@link outwardStoreFailure})。
+ *  同一处还接上本仓对**读拒字节地板不守**的说法(属主 `read-deny-floor-notice.ts`):拒起的失败句是本仓那一句(码不变),照跑的结果按 `runId` 挂 `readDenyFloor`
+ *  ({@link withReadDenyFloorSummary})—— 结果离开引擎的每个出口都经这里,说法一处接上。
  *
  * 🔴 为什么两件事合在一只函数里而不是并列两只(7.92.2 改名 `stripResumeToken` → `sealResultForExit`):
  * 它们是**同一个出口上的同一件事** —— 「这条结果可以见人了吗」。并列两只 = 六个结算点各自要记得调两次,

package/dist/terminal.js

@@ -5,6 +5,7 @@ import { recordFailOpen } from "./observability/fail-open.js";
 import { redactSecrets } from "./trace/redact.js";
 import { seatText } from "./trace/exit-seat.js";
 import { storeFaultSentenceOfCode } from "./plugins/store-fault.js";
+import { readDenyFloorRefusalMessage, readDenyFloorSummaryOf } from "./read-deny-floor-notice.js";
 export function failureCodeOf(terminal) {
     return terminal.kind === "failed" ? terminal.code : undefined;
 }
@@ -59,7 +60,14 @@ export function sealStoredResult(result, seat) {
 function seal(result, at) {
     if (result === null || typeof result !== "object")
         return result;
-    return foldOutwardFailureCodes(mapPauseSeats(result, dropCapability), at);
+    const sealed = foldOutwardFailureCodes(mapPauseSeats(result, dropCapability), at);
+    return at === "exit" ? withReadDenyFloorSummary(sealed) : sealed;
+}
+function withReadDenyFloorSummary(result) {
+    if (result.readDenyFloor !== undefined)
+        return result;
+    const summary = readDenyFloorSummaryOf(result.runId);
+    return summary === undefined ? result : { ...result, readDenyFloor: summary };
 }
 function foldOutwardFailureCodes(result, at) {
     const terminal = foldCauseCode(result.terminal, at);
@@ -75,8 +83,10 @@ function foldCauseCode(terminal, at) {
     const t = failedCauseWithCode(terminal);
     if (t === undefined)
         return terminal;
-    if (outwardFailureCode(t.code) === t.code)
-        return terminal;
+    if (outwardFailureCode(t.code) === t.code) {
+        const presented = at === "exit" ? readDenyFloorRefusalMessage(t.code) : undefined;
+        return presented === undefined || presented === t.message ? terminal : { ...t, message: presented };
+    }
     const folded = outwardStoreFailure(t.code, t.message, at);
     return { ...t, code: folded.code, message: folded.message };
 }
@@ -139,12 +149,17 @@ function failedCauseWithCode(t) {
     return kind === "failed" && typeof code === "string" ? { ...t, kind, code } : undefined;
 }
 export function outwardPlane(terminal) {
+    return outwardProjection(terminal, "exit");
+}
+function outwardProjection(terminal, at) {
     const plane = terminalProjection(terminal);
     if (plane.errorCode === undefined)
         return plane;
     const outward = outwardFailureCode(plane.errorCode);
-    if (outward === plane.errorCode)
-        return plane;
+    if (outward === plane.errorCode) {
+        const presented = at === "exit" && plane.status === "failed" ? readDenyFloorRefusalMessage(plane.errorCode) : undefined;
+        return presented === undefined ? plane : { ...plane, errorMessage: presented };
+    }
     return plane.status === "failed" ? { ...plane, errorCode: outward, errorMessage: outwardStoreMessage(plane.errorCode) } : { ...plane, errorCode: outward };
 }
 export function nestedPauseOf(terminal) {
@@ -166,7 +181,7 @@ export function persistedPlaneOf(result) {
     if (r.terminal !== null && typeof r.terminal === "object") {
         let projected;
         try {
-            projected = outwardPlane(r.terminal);
+            projected = outwardProjection(r.terminal, "stored");
         }
         catch (e) {
             recordFailOpen("server.terminal.persisted-plane-malformed", e instanceof Error ? e.message : String(e));

package/dist/tool-approval.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionLane } from "./execution-lane-caps.js";
+import type { ApprovalLegOrigin } from "./approval-leg-origin.js";
 import { type ApprovalDecider, type HostSettledBy, type HostSource, type RetiredDecisionKeyFacts } from "./host-decision.js";
 import type { IncomingMessage } from "node:http";
 import { type AskClass, type AskRequest, type AskOutcome, type PermissionResult, type CheckpointGate, type PendingAction, type PersistedRuleMandate, type ReadRootGrantCandidate, type RuleOffer, type AutoModeFallbackCause, type BoundGrantAbsence, type BoundSkillGrants, type ToolApprovalCard, type ReopenReason } from "@sema-agent/core";
@@ -26,6 +26,8 @@ interface OpenAskAdoption {
     /** 待决行多于 {@link ADOPT_OPEN_ASKS_MAX}:只接管了最先的那么多只。 */
     readonly capped: boolean;
 }
+/** Bound on the remembered allow-all grants (insertion-order evict — a long-lived worker must not grow unbounded). */
+export declare const MAX_ALLOW_SESSIONS = 4096;
 /**
  * 耐久回决口 `POST /v1/approvals/:sessionId/decide` 的路径串 —— [ref]:迟到回决口 PARKING 臂 202 体的机读指路 `decidePath`。
  * 路由表那一行(`http/routes/approvals-assistant.ts` 的 `approval-decide`)按 pattern 匹配它;两者同形由往返钉守
@@ -298,9 +300,9 @@ export type StandingAnswerHome = "none" | "seat" | "server_store";
 /**
  * 🔴 **[ref] —— 会话级放行的唯一判据:站着的答案能不能退掉这一问,能的话它记在哪({@link StandingAnswerHome})。** 纯函数,读者:
  *  · **读侧**(`askBroadcast` 的会话授权短路 {@link ToolApprovalCoordinator.standingGrantSettles}):`seat` 才可能由既有授权代答,否则往下走真出卡;
- *  · **写侧**(`finishRespond` 的 `grantable` 与 `recordDeploymentListAnswer`):`seat` 把 `allow_session` 铸成进程内授权;`server_store` 落 server 的会话豁免店;
+ *  · **写侧**(`finishRespond` 与 `recordDeploymentListAnswer`,经 {@link liveSessionAnswer}):`seat` 把 `allow_session` 铸成进程内授权;`server_store` 落 server 的会话豁免店;
  *    `none` 只放行这一次、`rememberApplied:false`;
- *  · **卡面提示位**(活卡帧 / 条目 / `livePending` 行的 `rememberRefused`):在场 ⇔ `none`;
+ *  · **卡面提示位**(活卡帧 / 条目 / `livePending` 行的 `rememberRefused`):在场 ⇔ 本函数答 `none` 或这条腿记不下(读的是 {@link liveSessionAnswer},它先问本函数);
  *  · **耐久可记性**({@link standingAnswerDurablyRecordable}:`/decide` 的 remember、运维队列行、策略层两只豁免读面)。
  * 各读者读同一份事实、说同一句话:一问若不许被记住的放行答掉,它的应答也不许变成一条记住的放行 —— 否则
  * 同一只卡「重跑一遍」就被自己上一次的回答代答(test [ref] U1s-off 的真形)。读者侧没有任何按「问的属主」另判的臂:属主只在本函数里读一次。
@@ -467,11 +469,12 @@ export interface ToolApprovalFrame {
     mandated?: true;
     /**
      * **7.116.0(审计修复批 S4;ADDITIVE,`"tool_approval"` only)—— 这张卡上的「本会话放行」只放行这一次、不会被记住。**
-     * 在场 ⇔ 同一只判据 {@link standingAnswerHome} 答 `none`(治理强制 / 必须真人 / 强制 / 应答还授予别的东西 / 类集清不掉),回决侧写授权
-     * (`finishRespond`)读的是同一份事实 ⇒ 帧说不可记 ⇔ 点了 `allow_session` 回执 `rememberApplied:false`。壳读这一位决定渲不渲
+     * 在场 ⇔ 同一只判官 {@link liveSessionAnswer} 答 `none`(问本身记不住:治理强制 / 必须真人 / 强制 / 应答还授予别的东西 / 类集清不掉;或这条腿记不下:
+     * 没有会话 / 读不出会话住客),回决侧写授权(`finishRespond`)读的是同一只 ⇒ 帧说不可记 ⇔ 点了 `allow_session` 回执 `rememberApplied:false`。壳读这一位决定渲不渲
      * 「本会话放行」,不再从 `requiresRealApproval` / `mandated` / `governanceForced` 三位自己推断(那一推断漏掉第四个理由:core 7.41.0
      * 的 `Skill` 卡批准即授予清单,三位全无)。`card_json` 卡面、`livePending` 行、运维队列行同名同义。
-     * 🔴 **真才带,缺席绝不编 `false`**:缺席 = 可记(有会话时)或老服务端。没有会话的腿上点了照样只放行一次(回执说明),本位不管那一形。
+     * 判官是 {@link liveSessionAnswer}(这一问的事实 + 这条腿记不记得下:没有会话的腿、读不出会话住客的腿同样在场),回决写侧读同一只。
+     * 🔴 **真才带,缺席绝不编 `false`**:缺席 = 在这条腿上记得住,或老服务端。
      */
     rememberRefused?: true;
     /**
@@ -526,7 +529,7 @@ export interface ToolApprovalFrame {
      * **[ref] ②(core 7.37.0 [ref];ADDITIVE,`"tool_approval"` only)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
      * `MODE_ARBITRATION` 的行键(权限模式读的就是它 / 它们)。引擎在每一个铸 `origin` 的站盖章(策略自报的值在盖章处被替换),本仓经
      * `approval-card.ts` 的 `readAskClassPair(req)` 窄读(判法 = core 屏 `screenAskClassMembers`,[ref] ⑥ / [ref],本仓零自写对判;屏拒 ⇒ 两键都不投 + 计一次
-     * [ref] 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core KL-1214-a),不是「无类」。
+     * [ref] 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core [ref]),不是「无类」。
      * display:壳按类渲卡(cli 卡面、client-core [ref]),durable 审批席按类答;**本仓不按它裁决**(无人值守腿的按类作答读 core 交来的
      * `AskRequest.classes` 本身)。同一对的其余面:`card_json` 卡面 / `approval_request` 呈卡帧 / 断连重放帧(同一份素材)、运维队列行
      * (`parkRowFacts`,读停车行孪生座 `PendingAction.tool_approval.askClass`);inbox 行不带(core `CheckpointSummary` 不回显)。
@@ -890,12 +893,10 @@ export type ApprovalLegFamily = {
     readonly transport: HitlTransport<ToolApprovalFrame>;
 };
 /** 两族共有的腿身份与腿轴。 */
-interface ToolApprovalRunContextBase {
+interface ToolApprovalRunContextBase extends ApprovalLegOrigin {
     taskId: string;
     sessionId?: string;
     owner: string | null;
-    /** 这条腿的执行车道 —— 装配点写所在边界执行上下文的 `ctx.lane`(`http/execution-context.ts`)。出处带车道:这只席造的问在铸行时记下它。 */
-    executionLane: ExecutionLane;
     abortSignal?: AbortSignal;
     /** [ref]([ref] §3.1 askId 派生的腿轴;车3 刀 3a 换轴:原 `leg?: number` → `legKey?: string`)。
      *  = `sha256(resume checkpoint token)` 的 hex,**首腿缺席折空串**(空串是首腿的真值,不是「未知」)。
@@ -1342,7 +1343,7 @@ export declare class ToolApprovalCoordinator {
     private readonly pendingByAskId;
     /** preamble 呈出的卡的消卡订阅(键 = askId;见 {@link watchPresentedCards})。只订本副本上此刻在等的 ask,落定即清 ⇒ 有界于活登记数。 */
     private readonly presentedCardWatchers;
-    /** Per-capability session grants — keys = sessionAllowKey(owner, sessionId, category, grant binding) (修2; bounded). */
+    /** Per-capability session grants — keys = sessionAllowKey(owner, sessionId, session incarnation, category, grant binding) (修2; bounded). */
     private readonly allowAllSessions;
     /** [ref] HIGH-1(broker)→[ref]四 core 产品裁定「多活集合+广播+首决胜出」:per-(owner, host-session)
      *  的**当前活跃连接集合**——boundAsk 闭包只携身份,emit 时广播给该 key 下**全部**活连接(宿主重连/
@@ -1777,8 +1778,7 @@ export declare class ToolApprovalCoordinator {
         owner: string | null;
         taskId: string;
         sessionId?: string;
-        executionLane: ExecutionLane;
-    }, why: LegUnattended) => ((req: AskRequest) => Promise<AskOutcome>);
+    } & ApprovalLegOrigin, why: LegUnattended) => ((req: AskRequest) => Promise<AskOutcome>);
     /**
      * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据;[ref] / SN-C1 换读口)。
      *
@@ -1966,7 +1966,7 @@ export declare class ToolApprovalCoordinator {
      *  emit 时经 broker 取该 (owner, session) 的「当前」活跃流(宿主重连/续聊的新 SSE 自动接卡;
      *  internalsSnapshot 冻结的闭包因此永不携死流)。查无活流 = "unavailable"(G1 回路:durable 部署
      *  park;inherited plain-ask 的 park 回路 = core [ref]①,落地前该臂 = deny,与 1.257 前行为一致)。 */
-    boundAsk: (identity: {
+    boundAsk: (identity: ApprovalLegOrigin & {
         owner: string | null;
         taskId: string;
         sessionId?: string;
@@ -1974,8 +1974,6 @@ export declare class ToolApprovalCoordinator {
         /** [ref] 车3 刀 3b(§7.3):本腿的 walltime deadline —— 与 `legKey` 同源同理由,随**出处**走
          *  (子代经继承链拿到的是宿主腿的闭包,窗必须按宿主腿的剩余 walltime 算)。 */
         legDeadlineMonotonic?: number;
-        /** 宿主腿的执行车道(装配点写执行上下文的 `ctx.lane`);子代经继承链冻同一闭包 ⇒ 子代的问记宿主腿的车道。 */
-        executionLane: ExecutionLane;
     }) => ((req: AskRequest, signal?: AbortSignal) => Promise<AskOutcome>);
     /** 广播版裁决路径——`ask()`(ALS,恒单元素数组)与 `boundAsk`([ref]四多活集合,可能多元素)共用。
      *  全体 `ctxs` 保证同一 (owner, sessionId)(streamKey 分组不变式;单元素数组平凡成立)。
@@ -2068,10 +2066,10 @@ export declare class ToolApprovalCoordinator {
     /**
      * `GET /v1/tool-approvals/:approvalId` —— **按问读口**:一只 ask 此刻在哪一态({@link TOOL_APPROVAL_READ_STATES})。与 {@link respond} 同根同门
      * (HTTP 层的鉴权 / 属主身份同一只 `gatedSubject`;看不见这只问 —— 属主不过 / 查无 / 行读不出 / 没有问账 —— 与应答口同答 404 `not_found.ask`({@link askNotVisible}),
-     * 无存在性 / 状态谕示),读法与应答口逐条同源:
-     * 本副本上在等它的活登记({@link liveEntryFor})⇒ `pending`(行投影 = 列表面 `livePending[]` 的同一只投影);否则按 id 读行
-     * ({@link askRowFor} + {@link askRowVisibleTo}),行态 → 读态与晚答口的分派同一张表;行仍 `STREAM_PENDING` 而本副本没有在等它的登记 ⇒ 它活在别的副本上,
-     * 与晚答口同答 404 `tool_approval.not_pending` + `unknown_or_other_replica`(那里才有兑现它的闭包;属主看得见的态)。
+     * 无存在性 / 状态谕示)。看不看得见只有一个来源:有行的问 = 店答出的行上当下的属主(按 id 读行,{@link askRowFor} + {@link askRowVisibleTo});
+     * 店答不出 ⇒ 看不见,本副本登记上记下的那一位(行上属主的读缓存)不替店作答。没有行的问(问账没上场 / 旧族腿)= 登记记下的那一位(唯一可读的属主事实)。
+     * 读到的行仍 `STREAM_PENDING`:本副本有在等它的登记 ⇒ `pending`(行投影 = 列表面 `livePending[]` 的同一只投影);没有 ⇒ 它活在别的副本上,
+     * 与晚答口同答 404 `tool_approval.not_pending` + `unknown_or_other_replica`(那里才有兑现它的闭包;属主看得见的态);其余行态 → 读态与晚答口的分派同一张表。
      * 纯读:零写、零结算、不碰本地登记(晚答口的 DECIDED 臂会顺手同步本副本的活登记,读口不做)。
      */
     readApproval(id: string, principal: string | undefined): {
@@ -2082,10 +2080,9 @@ export declare class ToolApprovalCoordinator {
         body: unknown;
     }>;
     /**
-     * [ref]:有行的登记的按问读口 —— 行可见且仍 `STREAM_PENDING` ⇒ `pending`(列表面同一只行投影);否则按行的态答(与读行半场同一张表)。
-     * 🔴 行**读不出**(店抛 / 超时)⇒ 只有**本协调器自己铸的活登记**回落:登记记下的属主认调用方 ⇒ `pending`,否则与未知 id 同答 —— 与同一刻的应答口同答
-     * (活登记的应答拿登记属主当候选、不多读一次店,店抖动不挡真实回决,D5),也与 7.135.x 的读口同答。**接管登记**([ref],起服从问账接管、没有引擎腿在等)的
-     * 属主跟着行走,登记上那一格不是权威 —— 应答口对它恒读行判、读不出 ⇒ 404,读口同样 404(两口同答;7.135.x 两口都 404)。读得出的「没有这一行」不回落(那是行的真相)。
+     * 有行的登记的按问读口 —— 行可见且仍 `STREAM_PENDING` ⇒ `pending`(列表面同一只行投影);否则按行的态答(与读行半场同一张表)。
+     * 行读不出(店抛 / 超时)与查无同答 404 —— 活登记与接管登记一样:登记上那一格只是行上属主的读缓存,店答不出时它不替店说「你看得见」
+     * (应答口同律:属主门那一读读不出 ⇒ 同一句 404;决议写失败之后读不回行 ⇒ 500,那是「不知道落没落」,不是看得见)。
      */
     private readByRow;
     /** {@link readApproval} 的读行半场。 */
@@ -2136,12 +2133,15 @@ export declare class ToolApprovalCoordinator {
     /** {@link respondLate} 的读行:按 id 读出行,交 {@link dispatchRowTruth}。 */
     private dispatchLateByRow;
     /**
-     * 按 wire 身份(= 行的键)读行 —— 三态分开交回({@link AskRowRead}):读到了 / 读得出的「没有这一行」/ 读不出(店抛或超时,记账)。
-     * 「读不出」与「不在」不折成一个值:调用点各自表态 —— 应答口与晚答口按「查无」答(读不出 = **不知道**这只 ask 落在哪一态,而受理臂都在对客户端做承诺,
-     * 不知道 ⇒ 回那句 404,绝不把未知说成受理;D5 的 fail-open 只覆盖「不挡人的真实回决」那一面,这条腿方向相反),按问读口对本协调器自己铸的活登记回落那一份登记
-     * (接管登记不回落,{@link readByRow})。
+     * 按 wire 身份(= 行的键)读行,给属主门用(应答口 / 晚答口 / 按问读口):读到了 ⇒ 那一行;读得出的「没有这一行」与读不出(店抛或超时,记账)同答 `null`。
+     * 读不出 = **不知道**属主是谁、这只 ask 落在哪一态 ⇒ 调用方看不见它(与查无同答 404):属主门 fail-closed,受理臂不把未知说成受理,读口不把未知说成待决。
      */
     private askRowFor;
+    /**
+     * 一只有行的问**此刻的行** —— 应答口 / 按问读口 / 列表面读行的**唯一**入口:{@link askRowFor} 点读(读不出 ⇒ `null` ⇒ 看不见),读到仍待决的行就把这只问在本副本上的登记
+     * 对齐到行上当下的属主([ref];先于各口的门判:门判的是调用方,不是这次对齐)。读序号在**发起读之前**取({@link nextRowReadSeq}):晚回来的旧读盖不掉之后发起的读。
+     */
+    private askRowFollowingOwner;
     /**
      * 一条行(的此刻真相)→ 应答口的答案:属主门 + 受理回执 + 六态穷举分派(闭集:新增 `AskState` 而不在此表态 = **编译错**)。两个入口:本副本没有在等
      * 这只 ask 的登记({@link dispatchLateByRow} 读出行),以及有登记但回决的 CAS 干净地输(行已有终局,`decideAsk` 带回的那条行)—— 一只 ask 的
@@ -2229,20 +2229,10 @@ export declare class ToolApprovalCoordinator {
     /** 回决收尾(D1 现行为逐字不变的那一半)——session allow-all 记账 + settle + 200 响应体。原 `respond()`
      *  方法体的逐字搬运([ref] 车2 拆分,行为零改动)。 */
     private finishRespond;
-    /** [ref]([ref] 案):live pending 的**列表读面**——`GET /v1/approvals` 响应第二顶层键 `livePending`
-     *  的唯一数据源,**同时**是 `/v1/approvals/stream` 的 live 半场 diff 源(推与拉必须同源:feed 收到
-     *  `live_pending` 事件就会去 `list()`,两处各读各的会给出一条列不出来的事件)。纯读投影,零锁/零结算
-     *  语义。
-     *  🔴 **[ref] 起行上带整只活卡帧**(`frame`,见 {@link LivePendingRow.frame}):旧文那句「input/args
-     *  不上列表,详情走流帧」对**悬挂 ask 结构上不成立**(它永远没有流帧),而 `frame` 是 `askBroadcast`
-     *  那一处构造的同一个对象 ⇒ 仍然只有**一个**脱敏属主、零第二投影。`scope` 与 durable 面同一个值(checkpoint scope):`undefined` = operator 全量(含 owner null 的
-     *  条目),`_`(`CHECKPOINT_PUBLIC_SCOPE`)= 匿名那一组 = owner null 的条目(R7:不带主体的调用方列得出它答得了的那几张),
-     *  其余串 = 只见 `owner === scope` 的条目(null-owner 行对具名主体不列,宁少列不超范围)。行的 `approvalId` 就是 `respond()` 收的 id
-     *  (同源可达,[ref] 判据);`expiresAtMs` 照抄登记时单点铸定的窗死线([ref] 三键同一个数)。 */
     /**
      * 🔴 [ref] —— **起服接管**:把问账里仍 `STREAM_PENDING` 的问接进本审批机的活集合,让 `livePending[]`(及 `/v1/approvals/stream` 的 live 半场、
-     * 按问读口、应答口)在重启之后不重开流也看得见、答得了它们。审批机仍是这些读面**唯一**的读源:读问账的只有这里(起服一次),之后列表行由
-     * 同一只 {@link livePendingRowOf} 投影,卡帧 = `buildReplayFrame`(开流 preamble 同一只构造)—— 不是 GET 上加一只读表的第二 reader。
+     * 按问读口、应答口)在重启之后不重开流也看得见、答得了它们。审批机仍是这些读面**唯一**的候选源(哪些问在本副本上有登记):扫问账找待决行的只有这里(起服一次),之后列表行由
+     * 同一只 {@link livePendingRowOf} 投影,卡帧 = `buildReplayFrame`(开流 preamble 同一只构造)—— 不是 GET 上按属主扫表的第二 reader;列表面对候选逐只点读行(见 {@link listLivePending}),候选集之外的问它不认识。
      *
      * 律(设计稿 `design-[ref].md` §2):接管登记**没有引擎腿在等它**(铸它的进程没了,或它活在别的副本上),与活登记同一只状态机 ——
      * 应答 = 同一把 `decideAsk` CAS({@link answerRegistration}),收敛 = 同一条悬挂轮询腿读行({@link pollSuspendedDecisions});它活多久只由行说了算,
@@ -2290,7 +2280,26 @@ export declare class ToolApprovalCoordinator {
     }>;
     /** 这只 askId 在本副本上有几条**有引擎腿在等**的登记(接管登记不算)—— 轮询腿的「被唤醒数」读它。 */
     private waitingRegistrationCount;
-    listLivePending(scope: string | undefined): LivePendingRow[];
+    /**
+     * [ref]([ref] 案):live pending 的**列表读面** —— `GET /v1/approvals` 响应第二顶层键 `livePending` 的唯一数据源,**同时**是 `/v1/approvals/stream` 的 live 半场 diff 源
+     * (推与拉必须同源:feed 收到 `live_pending` 事件就会去 `list()`,两处各读各的会给出一条列不出来的事件)。纯读投影,零锁 / 零结算语义。
+     * 🔴 **[ref] 起行上带整只活卡帧**(`frame`,见 {@link LivePendingRow.frame}):旧文那句「input/args 不上列表,详情走流帧」对**悬挂 ask 结构上不成立**(它永远没有流帧),
+     * 而 `frame` 是 `askBroadcast` 那一处构造的同一个对象 ⇒ 仍然只有**一个**脱敏属主、零第二投影。
+     * `scope` 与 durable 面同一个值(checkpoint scope):`undefined` = operator 全量(含 owner null 的条目),`_`(`CHECKPOINT_PUBLIC_SCOPE`)= 匿名那一组 = owner null 的条目
+     * (R7:不带主体的调用方列得出它答得了的那几张),其余串 = 只见 `owner === scope` 的条目(null-owner 行对具名主体不列,宁少列不超范围)。
+     * 行的 `approvalId` 就是 `respond()` 收的 id(同源可达,[ref] 判据);`expiresAtMs` 照抄登记时单点铸定的窗死线([ref] 三键同一个数)。
+     *
+     * 🔴 **有行的问,列表只列按问读口会答 `pending` 的**(看不看得见只有一个来源,{@link readApproval} 同一条律):本副本此刻的登记只是**候选**(哪些问在本副本上有登记);
+     * 有行的问,列不列它、列给谁只由店答出的行说了算 —— 对每只候选点读行({@link askRowFollowingOwner},与读口 / 应答口同一只 {@link askRowFor}):行读不出(店抛 / 超时)⇒ 看不见 ⇒ 不列
+     * (与读口的 `404 not_found.ask` 同隐;店恢复后下一次列表即回),行已离开 `STREAM_PENDING`(别处答了 / 收走了,本副本的登记还没闻讯)⇒ 不列(读口答的是它此刻的态),
+     * 行上当下的属主不在 `scope` 内 ⇒ 不列(登记上记下的那一位只是行上属主的读缓存,不替店作答)。没有行的问(问账没上场 / 旧族腿)登记记下的属主是唯一可读的属主事实 ⇒ 照登记列。
+     * 读行并发发起、各自带 {@link DURABLE_CONVERGE_READ_TIMEOUT_MS} 的墙钟 ⇒ 一次列表至多等一个期限;行体的投影取在读完之后、对每个列出的 wire 身份重取此刻代表它的那条登记
+     * ({@link liveEntryFor}):读行期间已结算的不列,读行期间被活登记接替的接管登记按活登记的样子列。
+     * 读行的次数 = 本副本此刻**有行的不同 ask 数**(重复登记共用一次读,没有行的问不读),**不按 `scope` 先筛**(登记上的属主只是读缓存,不替店判谁看得见 —— scope 之外的卡也要读一次行才判得出);
+     * 登记数的上界是每个任务 / 每个属主各一个未决帽(`STREAM_APPROVAL_ADMIT_MAX_PER_TASK` / `_PER_OWNER`)加起服接管上限 {@link ADOPT_OPEN_ASKS_MAX},本副本的总数没有全局帽。
+     * 列表行 ⊆ 按问读口对同一调用方答 `pending` 的那些;反过来不然 —— `scope` 比读口窄:具名主体的列表不含无主的卡(宁少列),运维列表按 `?owner=` / 全量列、含读口对运维不放行的卡。
+     */
+    listLivePending(scope: string | undefined): Promise<LivePendingRow[]>;
     /**
      * [ref]:某只委派子代此刻有没有**待决**的活卡 —— fleet 对账腿「子代活性由属主说了算」的属主②读口(另一只是
      * bg registry 账)。子代卡在一张没人答的卡上时当然不出帧,只看「静默」就会把它当孤儿扫下面板(报案的真形)。