@sema-agent/server 7.101.1 → 7.102.0

package/dist/http/server.d.ts

@@ -3,7 +3,8 @@ import type { IncomingMessage } from "node:http";
 import { type Runner, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type EntryProvenanceAccount, type MemoryErasureAttestation, type MemoryEntryOrigin, type OriginClearanceRow, type SessionMemoryStatus, type ConsolidationRunReceipt, type ConsolidationDriverRunRow, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
 import type { TaskRequestBody } from "./wire-types.js";
 import type { ServiceConfig } from "../config-types.js";
-import { type RestartSignal, type SessionMirrorRuling } from "../config-center/facade.js";
+import { type SessionMirrorRuling } from "../config-center/facade.js";
+import type { RestartSignal } from "@sema-agent/settings-schema/fleet";
 import { type OwnerAwareSessionStore } from "../security.js";
 import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchorStore, ApprovalExemptionStore, ApprovalNonceStore, ServiceSessionPolicyStore, ServiceFileHistoryStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
 import type { RuleConsentLane } from "../rules-consent.js";
@@ -549,7 +550,9 @@ export interface ServiceSeamDeps {
             };
         };
     }) => void;
-    parkedReviveTool?: import("@sema-agent/core").ToolSpec;
+    /** #1110(core 7.32.0):parked 赎回面工厂(按行解析驱动哪只 Agent 工具 + 同出一张列表的继承座;属主 `parked-revive-surface.ts`)。
+     *  缺席 = 这台部署没有 park 底座(checkpointStore / backgroundAgentStore 任一缺席),bg 赎回臂不接线。 */
+    parkedReviveSurface?: import("../parked-revive-surface.js").ParkedReviveSurfaceFactory;
     /** 可选第三件:revive args 的 `subagent_type` roster 成员集([ref] Q1 成员性规则)。当前生产装配
      *  **恒缺席**(boot 内建 default 无自定义 agents roster,per-request 的 spec.agents 不进 boot 工具)
      *  = 恒省略 subagent_type,typed 子代按 general-purpose 形复活(保真度 caveat 已报 core,[ref]
@@ -562,7 +565,7 @@ export interface ServiceSeamDeps {
      *  `rebuildInheritedGate` 头注。 */
     parkedReviveInheritedGate?: (row: import("@sema-agent/core").BackgroundAgentRecord, identity: {
         principal: string | undefined;
-    }) => Promise<unknown>;
+    }) => Promise<import("../boot/parked-revive-gate.js").RebuiltInheritedGate | undefined>;
 }
 /** **可观测面**:日志/指标/累加器。全体 fail-open——观测失败绝不改变业务面行为。 */
 export interface ServiceObservabilityDeps {
@@ -640,7 +643,8 @@ export interface ServiceDeploymentDeps {
      *    respond/subagent) stay open so the runs we are waiting on can still finish/interact.
      *  • `inflight` is ASSIGNED BY createServer (a live union of this replica's in-flight legs: durable bg/resume
      *    `inflightRuns` + live sync/resume streams `steerableRuns`) — main.ts polls it to know when drain is done.
-     *  • /health carries `draining:true` (k8s readiness 摘流信号) + `version` (build self-description).
+     *  • /health carries `draining:true` + `version` (build self-description); draining is a readiness reason
+     *    (`http/readiness.ts`) ⇒ `/readyz` 503 + `/health` `ready:false` (the k8s readiness 摘流信号).
      *  • [ref]:`attachedStreams` 同样 ASSIGNED BY createServer —— 本副本当前打开着的 SSE 流条数
      *    (= 引擎附着租约集的大小)。消费方是 `boot/engine-lease.ts` 的自退判据;与 `inflight` 同族,
      *    同一个共享盒子,不另开第二条 main↔server 的通道。
@@ -654,21 +658,28 @@ export interface ServiceDeploymentDeps {
         attachedStreams?: () => number;
         lastAttachEndedAt?: () => number;
     };
-    /** boot ready 门(b):false = registry 部署无显式 env 模型且首次 effective pull 尚未落 roster
-     *  (worker 只有占位模型)。计费提交 503 + /health 加性 `ready:false`。absent = 恒 ready(env 模型在/非
-     *  registry 部署),现有部署零影响。main.ts 在 applyEffective 落模型后翻 true(one-way latch)。 */
+    /** boot ready 门(b):false = 布防(`CONFIG_REQUIRE_ROSTER=true`)且首次 effective pull 尚未落 roster
+     *  (worker 只有占位模型)。就绪原因 `model_roster_pending`(`http/readiness.ts`):计费提交 503 + `/readyz` 503 +
+     *  /health 加性 `ready:false`。absent = 恒 ready(未布防 / 非 registry 部署),现有部署零影响。config-center 的
+     *  markRosterLanded 在落模型后翻 true(one-way latch)。 */
     modelReady?: () => boolean;
     /** Sema-registry restart signal: the refresh loop sets this when a pull carries restart-to-apply
      *  changes (skills/mcp/a2a/scenarios/… baked at boot — the `RestartSlice` closed set) that DIFFER from this process's boot config.
      *  Surfaced at GET /health as `restartRequired` + `restart{reasons,version,since}` so the orchestrator can
      *  auto rolling-restart the worker. Change-detected (not presence) — absent when nothing baked-at-boot
-     *  changed, so polling it never causes a restart loop. */
+     *  changed, so polling it never causes a restart loop. S-741:the fleet heartbeat reads THIS getter too
+     *  (`boot/stage-10-http-server.ts` → `restart: () => deployment.restartState?.()`), so `/health.restart` and the
+     *  announcement's `restart` are the same object — one mint point, two exits. */
     restartState?: () => RestartSignal | undefined;
     /** [ref] 世代账([ref] §2):本副本的配置收敛状态 —— `/health` 取三键
      *  (configTargetVersion / configAppliedVersion / configApplyStaleMs),`GET /v1/diagnostics/wiring` 取整份
      *  (按组的 appliedVersion / deferredKeys+铸因 / lastRejected 消毒形)。缺席 = 这个进程没有配置管道
      *  (纯 env 部署 / 测试夹具)⇒ 两个面的形状逐字不变(additive)。 */
     configApplyState?: () => import("../config-center/apply-ledger.js").ConfigApplyLedgerView | undefined;
+    /** S-698:中心凭证健康位(`/health.centerCredential`)—— 凭证来源的健康态 + 续签器状态(`center-credential-renewer.ts`
+     *  `buildCenterCredentialHealthView` 铸形,只有闭集词 / 时刻 / 计数,不带路径与令牌)。缺席 / 返回 undefined = 健康或没有中心
+     *  ⇒ `/health` 形状逐字不变(additive)。 */
+    centerCredentialState?: () => import("../center-credential-renewer.js").CenterCredentialHealthView | undefined;
     /** [ref] 追加件:`POST /v1/admin/config/refresh` 的实现面 —— 触发**一次既有**的 refresh 拍(在飞则 join)。
      *  缺席 / 回 `"not-wired"` = 本部署没有配置管道 ⇒ 该口诚实 4xx(绝不吞成 200)。 */
     configRefreshNow?: () => Promise<"triggered" | "not-wired" | "failed">;
@@ -798,6 +809,8 @@ export declare function flattenServiceDeps(deps: ServiceDeps): FlatServiceDeps;
 /**
  * Managed-Agents-style HTTP/SSE service surface.
  *   GET  /health
+ *   GET  /readyz              → readiness probe: 200 {ready:true} / 503 {ready:false, reasons} (S-739; same predicate
+ *                               as /health.ready, the billable-submit 503s and the fleet heartbeat — http/readiness.ts)
  *   POST /v1/tasks            → run to completion, TaskResult JSON (synchronous)
  *   POST /v1/tasks/stream     → SSE of TaskEvent, live tokens (synchronous, same instance)
  *   POST /v1/runs             → async: 202 {taskId, sessionId, status}, runs in background (S1)

package/dist/http/server.js

@@ -24,7 +24,7 @@ import { createRequestGuards } from "./request-guards.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
 import { createDispatch, hasServiceAuth } from "./dispatch.js";
-import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath } from "./route-table.js";
+import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, isProbePath } from "./route-table.js";
 import { createApprovalSweeps } from "./approval-sweeps.js";
 export { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, hasServiceAuth };
 export { MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills };
@@ -49,7 +49,7 @@ export function createHttpServer(rawDeps) {
         deps.drainState.inflight = () => new Set([...inflightRuns.keys(), ...steerableRuns.keys()]).size + counters.uncountedBillableInflight + counters.admittedInflight + (deps.leaderEndpoint?.inflight?.() ?? 0);
     let lastBillableActivityAt = performance.now();
     const noteActivity = (url) => {
-        if (url === "/health" || url.startsWith("/metrics"))
+        if (isProbePath(url))
             return;
         lastBillableActivityAt = performance.now();
     };

package/dist/model-entry-refusal.d.ts

@@ -8,7 +8,7 @@ export declare const MODEL_ENTRY_REFUSAL_CODES: {
 export type ModelEntryRefusalCode = (typeof MODEL_ENTRY_REFUSAL_CODES)[ModelEntryRefusalReason];
 /** 「这张表没有缺省模型」的机读码(S-705;boot 拒启与热路径模型面组拒同一个码)。 */
 export declare const DEFAULT_MODEL_MISSING_CODE = "config.default_model_missing";
-/** 🔴 S-712「被拒的名字被档位 / 别名增广铸到了别的条目上(或读不出被丢条目的名字,无从证明没有)」的机读码
+/** 🔴 S-712「被拒的名字被档位 / 别名增广铸到了别的条目上(或被丢身份载体形不对、读不出名字,无从证明没有)」的机读码
  *  (不变量 `refused-names-not-minted`;热路径 / boot 首次 apply / dry-run 同一个码)。 */
 export declare const REFUSED_NAME_MINTED_CODE = "config.model_refused_name_minted";
 /**
@@ -47,20 +47,21 @@ export interface CatalogEntryLike {
  * 坐标,不取它的输出(输出会补缺省、剥扩展键,那是读腿的事)。
  */
 export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): ModelEntryRefusal | undefined;
-/** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、以及身份证明不了的被丢条目(坐标)。 */
+/** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、以及形不对的被丢身份载体行(坐标)。 */
 export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
     readonly usable: readonly M[];
     readonly refused: Readonly<Record<string, ModelEntryRefusal>>;
-    /** S-712:读腿逐条丢掉、而身份证明不了的条目坐标(`models.3`;载体上不带 `name` 的那些 —— 读腿只在原文档对不上本次解析时
-     *  这样交出,见 `read-warnings.ts` `DroppedModelIdentity`)。非空 ⇒ 不变量 `refused-names-not-minted` 无从成立 ⇒ 模型面组拒。 */
-    readonly unreadable: readonly string[];
+    /** S-712:被丢身份**载体形不对**的行坐标(`models.3`;载体不是列表时是一个固定标记)。读腿只为有名的被丢条目铸载体行
+     *  (`read-warnings.ts` `DroppedModelIdentity`,`name` 必在),所以这一形只来自绕过读腿的输入被改过(盘上 LKG 被手改 / 手写
+     *  effective)。非空 ⇒ 读不出的名字无从证明它不被增广铸出 ⇒ 不变量 `refused-names-not-minted` 不成立 ⇒ 模型面组拒(fail-closed)。 */
+    readonly malformed: readonly string[];
 }
 /**
  * 批量形(模型面 stage 与 dry-run 共用这一只 —— 报数与真 apply 永不撕裂)。
  * S-712:`dropped` = 读腿交出的被丢条目身份(`EffectiveConfig.models.droppedIdentities`)—— 它们与逐条判据判出的 `entry_invalid`
- * 是**同一件事**(条目不合 `ModelEntry` 形),只是在第一道边界就被丢了;带名字的铸墓碑,不带名字的(读腿证明不了身份)进
- * `unreadable`。没有字符串名的坏行读腿已按停用处置、根本不进载体(7.101.0 验修轮 V-2:没有名字就没有可保留的名字)。
- * 入参按 `unknown` 判形:载体可能来自盘上 LKG(本仓写的,但文件可被改),形不对的一律按证明不了处置(fail-closed)。
+ * 是**同一件事**(条目不合 `ModelEntry` 形),只是在第一道边界就被丢了;每一行铸一块墓碑(拒因 provider 词空:告警身份不带它)。
+ * 入参按 `unknown` 判形:载体可能来自盘上 LKG(本仓写的,但文件可被改)。**规则一条**:载体要么缺席,要么是一列带字符串 `name`
+ * 的行;其余一律「载体形不对」进 `malformed`(fail-closed)—— 读腿自己从不铸这种形。
  * 与一条可用 / 已判不可用条目同名时不覆盖(可用条目仍可用;同名撞车由不变量 `refused-names-not-minted` 响亮拒)。
  */
 export declare function judgeCatalogEntries<M extends CatalogEntryLike>(enabled: readonly M[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict<M>;
@@ -125,6 +126,6 @@ export interface RefusedNameView {
 export declare function mintedRefusedNames(view: RefusedNameView): MintedRefusedName[];
 /** 不变量 `refused-names-not-minted` 的拒因句(`undefined` = 成立)。warn 与世代账 / 拒因同一句;逐对明细另走 {@link mintedRefusedNames}。 */
 export declare function refusedNameMintedRefusal(view: RefusedNameView): string | undefined;
-/** 身份证明不了的被丢条目的拒因句(同一不变量同一个码:证明不了的名字无从证明它不被增广铸出)。 */
-export declare function unreadableDroppedRefusal(entries: readonly string[]): string;
+/** 被丢身份载体形不对的拒因句(同一不变量同一个码:读不出的名字无从证明它不被增广铸出)。 */
+export declare function malformedDroppedCarrierRefusal(entries: readonly string[]): string;
 //# sourceMappingURL=model-entry-refusal.d.ts.map

package/dist/model-entry-refusal.js

@@ -50,6 +50,7 @@ function entryInvalidRefusal(id, provider, fields, issues) {
             "deployment's catalog on its own (the other entries keep serving) instead of being served with a value nothing validated; fix the entry to bring it back",
     };
 }
+const MALFORMED_CARRIER_NOT_A_LIST = "(droppedIdentities is not a list)";
 export function judgeCatalogEntries(enabled, ctx, dropped) {
     const usable = [];
     const refused = {};
@@ -60,20 +61,22 @@ export function judgeCatalogEntries(enabled, ctx, dropped) {
         else
             refused[String(m.name)] = r;
     }
-    const unreadable = [];
-    for (const d of Array.isArray(dropped) ? dropped : []) {
+    const rows = dropped === undefined ? [] : Array.isArray(dropped) ? dropped : undefined;
+    if (rows === undefined)
+        return { usable, refused, malformed: [MALFORMED_CARRIER_NOT_A_LIST] };
+    const malformed = [];
+    for (const d of rows) {
         const e = (typeof d === "object" && d !== null ? d : {});
-        const where = typeof e.entry === "string" ? e.entry : "(unknown coordinate)";
         if (typeof e.name !== "string") {
-            unreadable.push(where);
+            malformed.push(typeof e.entry === "string" ? e.entry : "(unknown coordinate)");
             continue;
         }
         if (Object.hasOwn(refused, e.name))
             continue;
         const fields = Array.isArray(e.fields) ? e.fields.filter((f) => typeof f === "string") : [];
-        refused[e.name] = entryInvalidRefusal(typeof e.id === "string" ? e.id : "", typeof e.provider === "string" ? e.provider : "", fields, typeof e.issues === "string" ? e.issues : fields.join(", "));
+        refused[e.name] = entryInvalidRefusal(typeof e.id === "string" ? e.id : "", "", fields, typeof e.issues === "string" ? e.issues : fields.join(", "));
     }
-    return { usable, refused, unreadable };
+    return { usable, refused, malformed };
 }
 export function refusalEventOf(reason) {
     switch (reason) {
@@ -149,9 +152,9 @@ export function refusedNameMintedRefusal(view) {
         "an explicit pick of that name (or a role bound to it) would silently run on the other entry's endpoint and account; " +
         "rename the unavailable entry, fix it (see its own warn), or rebind / drop the tier binding that mints the name.");
 }
-export function unreadableDroppedRefusal(entries) {
-    return (`catalog entries dropped by the settings-schema read could not be identified [${REFUSED_NAME_MINTED_CODE}]: ${entries.join(", ")} — ` +
-        "the raw document could not be matched to the snapshot that was parsed (e.g. the local file changed between two reads), so the candidate cannot prove the tier/alias expansion does not re-mint their names; " +
-        "the next read re-judges (fix the named entries if this persists).");
+export function malformedDroppedCarrierRefusal(entries) {
+    return (`the dropped-entry identity carrier of this candidate is malformed [${REFUSED_NAME_MINTED_CODE}]: ${entries.join(", ")} — ` +
+        "every row the settings-schema read writes there carries a string name, so this carrier was edited outside the read legs (e.g. a hand-edited last-known-good file); " +
+        "the candidate cannot prove the tier/alias expansion does not re-mint the unnamed entries, so its model plane is refused — restore or delete that carrier (a fresh read of the source re-mints it).");
 }
 //# sourceMappingURL=model-entry-refusal.js.map

package/dist/observability/fail-open.d.ts

@@ -123,7 +123,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approvals.park-row-blob-unreadable": {
         readonly cls: "F";
-        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。";
+        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。";
     };
     readonly "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         readonly cls: "F";
@@ -287,7 +287,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approval-card.closed-word-out-of-set": {
         readonly cls: "F";
-        readonly note: "S-249(`approval-card.ts` 的边界窄读族;今天的唯一成员是 `readRuleOffersAbsence`):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。";
+        readonly note: "S-249(`approval-card.ts` 的边界窄读族;今天两个成员:`readRuleOffersAbsence`,与 S-721 起的 `readClosedWordSeat` —— 一座一只 core 成员筛,座是参数:`mandate`(core 7.32.0 #1092,活卡帧 / 活挂起行 / 运维队列行同一只,闭集筛 = core `isPersistedRuleMandate`)与 S-755 起的 `origin`(运维队列行读 park 行孪生座,闭集筛 = core `isAskOrigin`,与 inbox 行 core 投影处同一只筛);detail 前缀 `ruleOffersAbsence=` / `mandate=` / `origin=` 判别是哪一座):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。";
     };
     readonly "server.pg-pool.idle-client-error": {
         readonly cls: "F";

package/dist/observability/fail-open.js

@@ -114,7 +114,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
-        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。",
+        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。",
     },
     "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         cls: "F",
@@ -260,7 +260,7 @@ export const FAIL_OPEN_TAGS = {
     "server.redact.ppk-eat-to-end": { cls: "F", note: "S-107 第三十二轮重扫:PuTTY .ppk 容器扫描器(redact.ts redactPpkContainers)在「无合格终止 / 收口后同容器范围再见私钥字段 / 收口后到下一版本头之间夹非空白」三形下从头**吃到输入末尾**(fail-closed 取证丢弃)——终态 errorMessage 座上=整条错误文案变成 «redacted:private-key»,与 redactions_applied_total{private-key} 的诚实替换同形不可分,故要有自己的计数/探针;影子扫不计;计数=多少次整段吃尾。" },
     "server.approval-card.closed-word-out-of-set": {
         cls: "F",
-        note: "S-249(`approval-card.ts` 的边界窄读族;今天的唯一成员是 `readRuleOffersAbsence`):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。",
+        note: "S-249(`approval-card.ts` 的边界窄读族;今天两个成员:`readRuleOffersAbsence`,与 S-721 起的 `readClosedWordSeat` —— 一座一只 core 成员筛,座是参数:`mandate`(core 7.32.0 #1092,活卡帧 / 活挂起行 / 运维队列行同一只,闭集筛 = core `isPersistedRuleMandate`)与 S-755 起的 `origin`(运维队列行读 park 行孪生座,闭集筛 = core `isAskOrigin`,与 inbox 行 core 投影处同一只筛);detail 前缀 `ruleOffersAbsence=` / `mandate=` / `origin=` 判别是哪一座):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。",
     },
     "server.pg-pool.idle-client-error": {
         cls: "F",

package/dist/parked-decide.d.ts

@@ -9,7 +9,9 @@
  * 行永 parked、生命周期分叉)。
  */
 import type { HostDecision } from "./host-decision.js";
-import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, ResumeOutcome, TaskRegistry, ToolSpec, WorkflowRun, WorkflowRunStore } from "@sema-agent/core";
+import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, ResumeOutcome, TaskRegistry, WorkflowRun, WorkflowRunStore } from "@sema-agent/core";
+import type { ParkedReviveSurfaceFactory } from "./parked-revive-surface.js";
+import type { RebuiltInheritedGate } from "./boot/parked-revive-gate.js";
 import { type WorkflowRunParkKey, type WorkflowAgentSessionIndex } from "./orchestration/workflow-agent-session-index.js";
 export interface ParkedAgentMatch {
     handle: string;
@@ -112,9 +114,13 @@ export interface ParkedDecideDeps {
     checkpointStore: Pick<CheckpointStore, "get">;
     /** 与 reaper/scenarios 同一个 registry(claim/rollback 的 CAS 与 in-memory handle 收敛在同处)。 */
     registry: Pick<TaskRegistry, "claimParkedAgent" | "rollbackParkedClaim">;
-    /** boot 期从生产装配(buildScenarios)取的裸 Agent ToolSpec——与 spawn 用同一装配路径,
-     *  subRunner/bg opts/checkpointStore 同实例天然成立([ref] 设计稿 §4)。 */
-    reviveTool: ToolSpec;
+    /** #1110(core 7.32.0):按**行**解析赎回面 —— 驱动哪一只 Agent 工具(生产装配,与 spawn 同源:subRunner / bg opts /
+     *  checkpointStore 同实例,[ref] 设计稿 §4),以及与它同出一张列表的继承座 `mountsCallerTool`(一层行才有;属主与全部判据
+     *  在 `parked-revive-surface.ts`)。修前是 boot 期的一只裸 Agent 工具、从不交座 ⇒ 7.32.0 起停在继承工具上的 allow 恒 422。 */
+    reviveSurface: ParkedReviveSurfaceFactory;
+    /** #1110 codex r1 [high]:会话属主面(`sessionStorage.ownerOf`)—— 赎回腿在 claim 前读**根会话现在**的属主交给赎回面(属主换人 / 会话
+     *  已不在 ⇒ 不交座)。缺席 = 本部署无属主面 ⇒ 读数缺席 ⇒ 不交座(fail-closed)。读抛 ⇒ 原样上抛(claim 之前,没有东西要回滚)。 */
+    sessionOwnerOf?: (sessionId: string) => Promise<string | null | undefined>;
     /** revive args 的 `subagent_type` 成员性判定集([ref] Q1 修正:非 roster 成员必须省略,否则
      *  unknown subagent_type 拒;字面比对 general-purpose 在 roster 撞名时会错省)。缺省空集=恒省略。 */
     knownAgentTypes?: ReadonlySet<string>;
@@ -130,7 +136,7 @@ export interface ParkedDecideDeps {
      *  「席位必须同步」是那个文件此前自设的约束、不是结构事实。 */
     rebuildInheritedGate?: (row: BackgroundAgentRecord, identity: {
         principal: string | undefined;
-    }) => Promise<unknown>;
+    }) => Promise<RebuiltInheritedGate | undefined>;
     warn?: (event: string, fields: Record<string, unknown>) => void;
 }
 export interface ParkedDecideRequest {

package/dist/parked-decide.js

@@ -149,6 +149,8 @@ export async function decideParkedAgent(deps, req, match) {
         return { status: 409, body: { error: "parked row carries no agent name — the revive path requires a named agent (row damaged?)", errorCode: "decide.row_unrevivable", taskId: match.handle } };
     }
     const inheritedGate = deps.rebuildInheritedGate ? await deps.rebuildInheritedGate(row, { principal: decodeCheckpointScope(req.scope) }) : undefined;
+    const rootOwner = row.rootSessionId !== undefined && deps.sessionOwnerOf ? await deps.sessionOwnerOf(row.rootSessionId) : undefined;
+    const surface = deps.reviveSurface(row, { principal: decodeCheckpointScope(req.scope), ...(rootOwner !== undefined ? { rootOwner } : {}) });
     const stores = { agentStore: deps.agentStore, checkpointStore: deps.checkpointStore };
     const claim = await deps.registry.claimParkedAgent(stores, match.handle, { scope: row.scope, owner: row.owner });
     if (!claim.ok) {
@@ -180,6 +182,7 @@ export async function decideParkedAgent(deps, req, match) {
     const outcome = buildParkedResumeOutcome(req);
     const ctx = {
         toolCallId: `drv-${ticket.claimId}`,
+        ...(surface.mountsCallerTool !== undefined ? { mountsCallerTool: surface.mountsCallerTool } : {}),
         reviveClaim: {
             row: { ...ticket.row, parkClaimId: ticket.claimId },
             rev: ticket.reservedRev,
@@ -211,7 +214,7 @@ export async function decideParkedAgent(deps, req, match) {
     defaultSubagentTailBus.forgetHandle(match.handle);
     let receipt;
     try {
-        receipt = await deps.reviveTool.execute(mintReviveArgs(row, deps.knownAgentTypes ?? new Set()), ctx);
+        receipt = await surface.reviveTool.execute(mintReviveArgs(row, deps.knownAgentTypes ?? new Set()), ctx);
     }
     catch (e) {
         const disp = await rollback("execute_threw");

package/dist/parked-revive-surface.d.ts

@@ -0,0 +1,47 @@
+/**
+ * #1110(core 7.32.0)—— `/decide` parked 赎回腿的**赎回面**:驱动哪一只 Agent 工具,以及交不交继承座
+ * `ToolExecuteContext.mountsCallerTool`。
+ *
+ * core 7.32.0 起 Agent 子代按**身份**继承场景层工具(bundle 交给 Agent 的 `inheritedTools` ∩ 父 run 的 `spec.tools`),由宿主
+ * **自己**驱动 `execute` 的一方(本腿)必须交座,否则 fail-closed:复活的子代什么都不继承,而停在一只**继承工具**上的 `allow` 在消费
+ * 审批之前被拒(`parked_resume.startup_failed` ⇒ `parked-decide.ts` 的 422 臂,审批留 pending;`deny` 照常结)。
+ *
+ * 规则(core [ref] / unreleased-1110 原话,一条):**座建在那条行的根会话解析出来的同一张列表上,赎回工具取自同一张列表**。
+ *  · 列表 = 内建 default 场景工厂按行的根会话重解一次(`defaultScenario({}, principal, { sessionId: root })`)—— 与生产 resolve-spec
+ *    给那个会话的 run 组 `spec.tools` 的同一只工厂、同一个会话分区(任务清单店 `taskListStoreFor(root)` 与领队那一张是同一张;
+ *    多租户的 WebFetch 过滤同样生效 ⇒ 子代同样拿不到)。座 = `(t) => tools.includes(t)`(身份判:同名副本不算)。
+ *  · **禁**用 boot 期单例填座:那只 bundle 没有会话,它的任务清单是一张私有表 —— 填了座,每个会话 / 租户的复活队友都会共用它。
+ *  · **根会话现在还属于这张卡的租户**才填座(codex r1 [high]):任务清单店只按会话 id 分区,而会话 id 由调用方自选、删后可被别人重领 ——
+ *    根会话删了(或换了主人)之后赎回一张旧卡,按 id 重解出来的是**新主人**的清单。属主读数由赎回腿在 claim 前读(`identity.rootOwner`,
+ *    读自会话属主面;缺席 = 会话已不在 / 读不出),与卡的权威 principal 逐字相等才填;否则不交座(fail-closed:子代不继承,继承工具上的
+ *    allow 回 422、审批待决,deny 照结)。根删除时把子孙的 parked 卡一并围栏 / 过期 = 另车(会话化身轴,[ref] 同族)。
+ *  · 只对**一层**行填座(`rootSessionId` 在场且 = `parentSessionId`:派它的 run 就是根会话的 run,列表正是那个 run 的挂载)。更深的行
+ *    (孙代:派它的是一个子代,它的挂载是继承裁剪后的子集,行上读不出来)不填 —— 用 boot 期那只裸 Agent、无座 = core 的 fail-closed 臂;
+ *    行上带继承组成是 core #1112(7.32.x)的半场,到货再改读行。
+ * 近似如实记:重解的列表是**部署缺省**那一份,读不回那一 run 的逐请求差异(`settings.webSearch` 后端、center overlay 场景)——
+ * 座只判 bundle 实例的成员性,继承面是 `[...web, ...scaffolds]`,那两项差异不改变谁在面内。
+ */
+import { type BackgroundAgentRecord, type ToolSpec } from "@sema-agent/core";
+import type { Scenario } from "./capabilities/scenarios.js";
+/** 一次赎回用的面:驱动的 Agent 工具 + (一层行时)与它同出一张列表的继承座。 */
+export interface ParkedReviveSurface {
+    readonly reviveTool: ToolSpec;
+    /** 缺席 = 不交座(core fail-closed:复活的子代不继承任何场景层工具)。 */
+    readonly mountsCallerTool?: (tool: ToolSpec) => boolean;
+}
+/**
+ * 按行解析赎回面的入参身份:`principal` = 权威 principal(取 checkpoint 的 scope 列,不取行上有损的 `row.scope`);`rootOwner` = 行的根会话
+ * **现在**的属主(赎回腿在 claim 前读会话属主面;`null` = 匿名会话,缺席 = 会话已不在 / 读不出 / 本部署无属主面)。
+ */
+export interface ParkedReviveSurfaceIdentity {
+    readonly principal: string | undefined;
+    readonly rootOwner?: string | null;
+}
+/** 按行解析赎回面。 */
+export type ParkedReviveSurfaceFactory = (row: BackgroundAgentRecord, identity: ParkedReviveSurfaceIdentity) => ParkedReviveSurface;
+/**
+ * 赎回面工厂。入参 = **内建** default 场景工厂(stage-07 在 center overlay 盖名之前取的那一只;赎回要的是与 spawn 同源的生产装配)。
+ * 内建 bundle 里没有 Agent 工具 ⇒ `undefined`(park 本就不可达,赎回腿不接线)。
+ */
+export declare function createParkedReviveSurface(defaultScenario: Scenario): ParkedReviveSurfaceFactory | undefined;
+//# sourceMappingURL=parked-revive-surface.d.ts.map

package/dist/parked-revive-surface.js

@@ -0,0 +1,20 @@
+import { DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
+const agentOf = (tools) => tools.find((t) => t.name === DEFAULT_SUBAGENT_TOOL_NAME);
+export function createParkedReviveSurface(defaultScenario) {
+    const bootTool = agentOf(defaultScenario({}).tools);
+    if (bootTool === undefined)
+        return undefined;
+    return (row, identity) => {
+        const root = row.rootSessionId;
+        if (root === undefined || row.parentSessionId !== root)
+            return { reviveTool: bootTool };
+        if (identity.rootOwner === undefined || (identity.rootOwner ?? undefined) !== identity.principal)
+            return { reviveTool: bootTool };
+        const tools = defaultScenario({}, identity.principal, { sessionId: root }).tools;
+        const reviveTool = agentOf(tools);
+        if (reviveTool === undefined)
+            return { reviveTool: bootTool };
+        return { reviveTool, mountsCallerTool: (t) => tools.includes(t) };
+    };
+}
+//# sourceMappingURL=parked-revive-surface.js.map

package/dist/plugins/background-shell-support.d.ts

@@ -21,7 +21,7 @@
  * re-read by byte cursor on each poll (path ①). Both are expressed through {@link BackgroundShellDriver}.
  */
 import { BackgroundShellError } from "@sema-agent/core";
-import type { BackgroundShellId, BackgroundPoll, BackgroundSpawnOptions, Result } from "@sema-agent/core";
+import type { BackgroundHardKillOutcome, BackgroundShellId, BackgroundPoll, BackgroundSpawnOptions, Result } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
 /** Per-端 background capability bounds, surfaced as `backgroundCapabilities` on the env ([ref] §3.1/§3.6).
  *
@@ -105,6 +105,13 @@ export interface BackgroundShellDriver<S> {
     kill(state: S): Promise<void>;
     /** Best-effort cleanup of ONE shell's transport resources (kill + remove temp dirs/handles). Should not throw. */
     disposeOne(state: S): Promise<void>;
+    /**
+     * S-745(core 7.32.0 #1107)—— **可选**的同步硬收一枪(`BackgroundShellCapability.killBackgroundNow` 的 driver 半场)。
+     * 只有**本机有进程组可发**的 driver 实现它(今天只有 host 车道);远端 / 沙箱车道留空 ⇒ 座位根本不挂出来,core 对那些行
+     * 答 `no_pgid` 并派普通 kill。契约(core `docs/background-process-lifetime.md`):同步(无 TERM、无定时器、无 await)、
+     * 幂等、永不抛、只对**证明得了还是自己的** pid 发信号(观察到退出 ⇒ `already_gone`,一枪都不发)。
+     */
+    killNow?(state: S): BackgroundHardKillOutcome;
 }
 export declare class BackgroundShellManager<S> {
     private readonly driver;
@@ -154,6 +161,18 @@ export declare class BackgroundShellManager<S> {
     private register;
     poll(shellId: BackgroundShellId): Promise<Result<BackgroundPoll, BackgroundShellError>>;
     kill(shellId: BackgroundShellId): Promise<Result<void, BackgroundShellError>>;
+    /**
+     * S-745 —— 座位 `killBackgroundNow(shellId)` 的 manager 半场:**同步**、永不抛。
+     *  · 不是本 env 的 shell(未知 / 伪造 / 已被驱逐的终态行)⇒ `already_gone`(core 契约「or not its shell」);
+     *  · driver 不实现 {@link BackgroundShellDriver.killNow} ⇒ `no_pgid`(没有同步硬收可落;实现座位的 env 才会走到这里);
+     *  · driver 答出三词之外 ⇒ `no_pgid`(没有落地,可重试)。driver 的座位按契约**永不抛**(host 的那只由构造保证:只读子进程句柄
+     *    + `hardKillGroupNow` 自己吞 `kill` 的拒因);万一抛了,本函数**不吞** —— 异常原样上抛给 core 的注册表,由它读成 `no_pgid` 并记
+     *    `SEMA_DEBUG_SHUTDOWN` 取证行(core 契约:「A seat that throws … reads no_pgid」),不在这里再写一只静默兜底;
+     *  · 落地 `killed` 且条目还在 `running` ⇒ 条目结算 `killed` + 清 BG 超时墙(与 {@link kill} 的记账同一形:这一枪是**我们**
+     *    打的,之后迟到的 `close` 不再把它改判成 `exited`)。条目状态**不参与**判「该不该发」:软梯子会先把条目翻成 `killed`
+     *    再等宽限(屏蔽 TERM 的组此刻还活着),所以「该不该发」只由 driver 读子进程句柄判。
+     */
+    killNow(shellId: BackgroundShellId): BackgroundHardKillOutcome;
     /** Kill + clean up EVERY shell. Best-effort, MUST NOT throw, idempotent ([ref] §3.7).
      *
      *  core `except` 契约(background-shell.d.ts:core runtask 尾调 `{except: keepAlive}`):

package/dist/plugins/background-shell-support.js

@@ -216,6 +216,32 @@ export class BackgroundShellManager {
         }
         return ok(undefined);
     }
+    killNow(shellId) {
+        const entry = this.shells.get(shellId);
+        if (!entry)
+            return "already_gone";
+        const seat = this.driver.killNow;
+        if (seat === undefined)
+            return "no_pgid";
+        const outcome = seat.call(this.driver, entry.state);
+        switch (outcome) {
+            case "killed":
+                if (entry.status === "running") {
+                    entry.status = "killed";
+                    if (entry.timer)
+                        clearTimeout(entry.timer);
+                }
+                return "killed";
+            case "already_gone":
+            case "no_pgid":
+                return outcome;
+            default: {
+                const unreachable = outcome;
+                void unreachable;
+                return "no_pgid";
+            }
+        }
+    }
     async dispose(opts) {
         const keep = opts?.except?.length ? new Set(opts.except) : undefined;
         const doomed = [];

package/dist/plugins/host-platform.d.ts

@@ -23,7 +23,7 @@
  * structural tests only on mac/Linux; behavior-level bite happens on the first Windows-runner green.
  */
 import type { ChildProcess } from "node:child_process";
-import { killProcessTree } from "@sema-agent/core";
+import { killProcessTree, type BackgroundHardKillOutcome } from "@sema-agent/core";
 export declare const IS_WIN32: boolean;
 export interface HostShell {
     shell: string;
@@ -61,6 +61,16 @@ export declare function spawnGroupOptions(): {
  * win32 = core `signalProcessTree(pid,"SIGKILL")` → `taskkill /F /T` (never throws — fire-and-forget spawn).
  */
 export declare function killTreeHard(pid: number): void;
+/**
+ * S-745(core 7.32.0 #1107)—— **同步组硬收的一枪**:后台 driver 的 `killBackgroundNow` 座位用它(梯子的「组 SIGKILL」那一级,
+ * 不经 TERM、不挂定时器)。读数是 core 座位闭集里的三词,判据只看 `kill` 系统调用自己的结局:
+ *  · POSIX:`kill(-pid, SIGKILL)` 落地 ⇒ `killed`;`ESRCH`(这个组已经没有进程)⇒ `already_gone`;其余拒因(`EPERM` 一族)⇒
+ *    `no_pgid`(没有落地,调用方可重试;core 随即派普通 kill);
+ *  · win32 ⇒ 恒 `no_pgid`(core 契约:win32 无同步硬收 —— 没有进程组,树杀要一个延后的发现步,同步 `taskkill` 会杀掉启动器而
+ *    留下 Git Bash 的作业组、却自称 `killed`)。
+ * 「这个 pid 还是不是我的」由**调用方**先判(观察到退出 ⇒ 不许再发,pid 可能已经是别人的):本函数只管打出去的那一枪。永不抛。
+ */
+export declare function hardKillGroupNow(pid: number): BackgroundHardKillOutcome;
 /**
  * SOFT kill (design D2 — the bg KillShell/timeout-wall first rung; the caller owns the grace→hard escalation
  * timer, unchanged). POSIX = `process.kill(-pid, "SIGTERM")` byte-identical (throws on dead group — the caller

package/dist/plugins/host-platform.js

@@ -46,6 +46,17 @@ export function killTreeHard(pid) {
     }
     process.kill(-pid, "SIGKILL");
 }
+export function hardKillGroupNow(pid) {
+    if (IS_WIN32)
+        return "no_pgid";
+    try {
+        process.kill(-pid, "SIGKILL");
+        return "killed";
+    }
+    catch (err) {
+        return err.code === "ESRCH" ? "already_gone" : "no_pgid";
+    }
+}
 export function killTreeSoft(pid) {
     if (IS_WIN32) {
         signalProcessTree(pid, "SIGTERM");

package/dist/plugins/remote-env-host.d.ts

@@ -1,6 +1,10 @@
-import { FileError, ExecutionError, RemoteExecutionError, SchedulerError, type SchedulerCapability, type ScheduledIntent, type SchedulerContext, type ScheduledTaskId, type ScheduledTaskSummary, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, BackgroundShellError, type BackgroundShellCapability, type BackgroundShellId, type BackgroundPoll, type BackgroundSpawnOptions } from "@sema-agent/core";
+import { FileError, ExecutionError, RemoteExecutionError, SchedulerError, type SchedulerCapability, type ScheduledIntent, type SchedulerContext, type ScheduledTaskId, type ScheduledTaskSummary, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, BackgroundShellError, type BackgroundShellCapability, type BackgroundShellId, type BackgroundHardKillOutcome, type BackgroundPoll, type BackgroundSpawnOptions } from "@sema-agent/core";
 /** Options accepted by `ExecutionEnv.exec` (core does not re-export the type; derive it from the seam). */
 type ExecOpts = Parameters<ExecutionEnv["exec"]>[1];
+/** SIGTERM → grace → SIGKILL (no host isolation). 🔴 宽限的**唯一属主**:本 driver 的 `kill` 梯子用它排升级定时器;会话级收敛
+ *  (`background-session-reap.ts#reapSessionBackgroundHard`,DELETE 与停止口)在软面之后、硬面之前**等同一只**(车OL O1 —— 硬面不许把
+ *  这把梯子的用户面宽限取消),不另抄数。启动期读一次;`0` 被 `numEnvOr` 读作缺席(回落 1000),要几乎不等写 `1`。 */
+export declare const HOST_BG_KILL_GRACE_MS: number;
 /** Construction config for {@link RemoteHostExecutionEnv}. */
 export interface HostEnvConfig {
     /**
@@ -242,6 +246,15 @@ export declare class RemoteHostExecutionEnv implements RemoteExecutionEnv, Sched
     private adoptRunningExec;
     pollBackground(shellId: BackgroundShellId): Promise<Result<BackgroundPoll, BackgroundShellError>>;
     killBackground(shellId: BackgroundShellId): Promise<Result<void, BackgroundShellError>>;
+    /**
+     * S-745(core 7.32.0 #1107)—— `BackgroundShellCapability.killBackgroundNow` 座位:退出边界 / 会话收敛的**同步硬收**面经它对
+     * 本 env 的一行发**一枪组 SIGKILL**(pid 不出 env,调用方只握不透明的 shellId)。同步、永不抛、幂等;答 `killed` /
+     * `already_gone` / `no_pgid`(win32 恒 `no_pgid`)。从没起过 shell 的 env(`_bgManager` 未建)⇒ 这个 id 不是本 env 的 ⇒
+     * `already_gone`;**不**顺手新建 manager(拆除路径上不造东西,与 `disposeBackgroundShells` 同一条)。
+     * 本仓只有 host 车道实现它:e2b / k8s·kata / local-docker / ssh / device / adb 没有本机进程组可发,留空 ⇒ core 每行 `no_pgid`
+     * 并派普通 kill(车道矩阵钉:`test/background-hard-kill-s745.test.ts`)。
+     */
+    killBackgroundNow(shellId: BackgroundShellId): BackgroundHardKillOutcome;
     disposeBackgroundShells(opts?: {
         except?: readonly BackgroundShellId[];
     }): Promise<void>;