@sema-agent/server 7.147.0 → 7.148.0

package/dist/capabilities/repo-tools.d.ts

@@ -27,6 +27,7 @@ export declare function createRepoClient(kind: GitApiKind, baseUrl: string, toke
 export declare class GiteaClient implements RepoReadClient {
     private readonly baseUrl;
     private readonly token?;
+    /** 出站出口:Git host 回重定向 ⇒ 拒(`token` 凭据头只去被判过的那个根),不是静默跟随。 */
     private readonly fetchImpl;
     constructor(baseUrl: string, token?: string | undefined, fetchImpl?: typeof fetch);
     private api;
@@ -51,6 +52,7 @@ export declare class GiteaClient implements RepoReadClient {
 export declare class GitHubClient implements RepoReadClient {
     private readonly baseUrl;
     private readonly token?;
+    /** 出站出口:Git host 回重定向 ⇒ 拒(Bearer 凭据只去被判过的那个根),不是静默跟随。 */
     private readonly fetchImpl;
     constructor(baseUrl: string, token?: string | undefined, fetchImpl?: typeof fetch);
     private api;

package/dist/capabilities/repo-tools.js

@@ -13,6 +13,8 @@ export function parseRepo(input) {
 const MAX_FILE_BYTES = 96 * 1024;
 const MAX_TREE_ENTRIES = 2000;
 const REQUEST_TIMEOUT_MS = 15_000;
+import { createEgressFetch } from "../egress-redirect.js";
+import { readUpstreamJson } from "../upstream-body.js";
 export { GIT_API_KINDS, isGitApiKind } from "../git-api-kind.js";
 const RepoInfoWire = z.looseObject({ default_branch: z.string().optional() });
 const TreeWire = z.looseObject({
@@ -32,7 +34,7 @@ function pathSegmentsRejectingTraversal(path) {
     }
     return segments;
 }
-export function createRepoClient(kind, baseUrl, token, fetchImpl = fetch) {
+export function createRepoClient(kind, baseUrl, token, fetchImpl) {
     switch (kind) {
         case "gitea":
             return new GiteaClient(baseUrl, token, fetchImpl);
@@ -48,10 +50,10 @@ export class GiteaClient {
     baseUrl;
     token;
     fetchImpl;
-    constructor(baseUrl, token, fetchImpl = fetch) {
+    constructor(baseUrl, token, fetchImpl) {
         this.baseUrl = baseUrl;
         this.token = token;
-        this.fetchImpl = fetchImpl;
+        this.fetchImpl = createEgressFetch("declare the final address as GIT_API_BASEURL", fetchImpl);
     }
     async api(path, accept = "application/json") {
         const headers = { accept };
@@ -66,12 +68,12 @@ export class GiteaClient {
         return res;
     }
     async defaultBranch({ owner, repo }) {
-        const info = RepoInfoWire.parse(await (await this.api(`/repos/${owner}/${repo}`)).json());
+        const info = RepoInfoWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}`)));
         return info.default_branch || "main";
     }
     async tree(coords, ref) {
         const { owner, repo } = coords;
-        const body = TreeWire.parse(await (await this.api(`/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=true&per_page=${MAX_TREE_ENTRIES}`)).json());
+        const body = TreeWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=true&per_page=${MAX_TREE_ENTRIES}`)));
         const paths = (body.tree ?? []).filter((e) => e.type === "blob").map((e) => e.path);
         return body.truncated
             ? [...paths, `…[truncated, tree has more than ${MAX_TREE_ENTRIES} entries]`]
@@ -80,7 +82,7 @@ export class GiteaClient {
     async readFile(coords, path, ref) {
         const { owner, repo } = coords;
         const segments = pathSegmentsRejectingTraversal(path);
-        const body = ContentsWire.parse(await (await this.api(`/repos/${owner}/${repo}/contents/${segments.map(encodeURIComponent).join("/")}?ref=${encodeURIComponent(ref)}`)).json());
+        const body = ContentsWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}/contents/${segments.map(encodeURIComponent).join("/")}?ref=${encodeURIComponent(ref)}`)));
         if (body.type !== "file" || body.content == null)
             throw new Error(`not a file: ${path}`);
         const text = body.encoding === "base64" ? Buffer.from(body.content, "base64").toString("utf8") : body.content;
@@ -99,10 +101,10 @@ export class GitHubClient {
     baseUrl;
     token;
     fetchImpl;
-    constructor(baseUrl, token, fetchImpl = fetch) {
+    constructor(baseUrl, token, fetchImpl) {
         this.baseUrl = baseUrl;
         this.token = token;
-        this.fetchImpl = fetchImpl;
+        this.fetchImpl = createEgressFetch("declare the final address as GIT_API_BASEURL", fetchImpl);
     }
     async api(path, accept = "application/vnd.github+json") {
         const headers = { accept, "x-github-api-version": "2022-11-28" };
@@ -117,12 +119,12 @@ export class GitHubClient {
         return res;
     }
     async defaultBranch({ owner, repo }) {
-        const info = RepoInfoWire.parse(await (await this.api(`/repos/${owner}/${repo}`)).json());
+        const info = RepoInfoWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}`)));
         return info.default_branch || "main";
     }
     async tree(coords, ref) {
         const { owner, repo } = coords;
-        const body = TreeWire.parse(await (await this.api(`/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`)).json());
+        const body = TreeWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`)));
         const paths = (body.tree ?? []).filter((e) => e.type === "blob").map((e) => e.path);
         if (paths.length > MAX_TREE_ENTRIES) {
             return [...paths.slice(0, MAX_TREE_ENTRIES), `…[truncated, tree has more than ${MAX_TREE_ENTRIES} entries]`];
@@ -134,7 +136,7 @@ export class GitHubClient {
     async readFile(coords, path, ref) {
         const { owner, repo } = coords;
         const segments = pathSegmentsRejectingTraversal(path);
-        const body = ContentsWire.parse(await (await this.api(`/repos/${owner}/${repo}/contents/${segments.map(encodeURIComponent).join("/")}?ref=${encodeURIComponent(ref)}`)).json());
+        const body = ContentsWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}/contents/${segments.map(encodeURIComponent).join("/")}?ref=${encodeURIComponent(ref)}`)));
         if (body.type !== "file" || body.content == null)
             throw new Error(`not a file: ${path}`);
         if (body.encoding === "none") {
@@ -147,7 +149,7 @@ export class GitHubClient {
     }
     async pullDiff(coords, index) {
         const { owner, repo } = coords;
-        const meta = PullMetaWire.parse(await (await this.api(`/repos/${owner}/${repo}/pulls/${index}`)).json());
+        const meta = PullMetaWire.parse(await readUpstreamJson(await this.api(`/repos/${owner}/${repo}/pulls/${index}`)));
         const res = await this.api(`/repos/${owner}/${repo}/pulls/${index}`, "application/vnd.github.v3.diff");
         let text = await res.text();
         const filesInDiff = (text.match(/^diff --git /gm) ?? []).length;

package/dist/capabilities/scenarios.d.ts

@@ -260,18 +260,6 @@ export declare const BUILTIN_SCENARIO_HANDS: {
     readonly scan: "none";
     readonly cowork: "full";
 };
-/**
- * [ref]:内建场景的**技能范围**(技能 `scenarios` 标签按哪个名字匹配)—— **全仓唯一声明处**:各场景工厂交进 `TaskSpec` 的技能与场景卡上的技能清单都按这张表取范围,
- * 再过同一只过滤(`skills.ts` 的 `skillsInScope`),两边因此恒为同一组技能。按 {@link BuiltinScenarioName} 键控 ⇒ 加 / 删一个内建场景而这里没跟 = 编译红。
- * `code` 的范围是 `default`:它与 default 共用一只工厂(工具 / 技能面恒等由构造保证),打了 `scenarios: code` 的技能不进 code 的 run。center 场景的范围是它自己的名字。
- */
-export declare const BUILTIN_SCENARIO_SKILL_SCOPE: {
-    readonly code: "default";
-    readonly default: "default";
-    readonly "code-review": "code-review";
-    readonly scan: "scan";
-    readonly cowork: "cowork";
-};
 /**
  * `branded` = 这台部署是不是品牌部署 —— 部署座挂品牌行读的同一只判官(`brand-identity.ts` `isBrandedDeployment`)交进来;没有默认值:每个调用点说出这件事实。
  * 品牌部署上,品牌行 `when.binding` 那张表里的场景(`BRAND_IDENTITY_SCENARIOS`)的 `promptSummary` 点名 Sema 产品身份 —— 读面说的就是模型收到的。
@@ -309,7 +297,6 @@ export type ScenarioAvailability = {
 export declare function scenarioAvailability(deps: Pick<ScenarioDeps, "repoClient">, toolset: string): ScenarioAvailability;
 /** 拒绝文案的唯一属主:闭集穷举 switch(新增原因词不在这里表态即编译红)。 */
 export declare function scenarioUnavailableMessage(reason: ScenarioUnavailableReason, scenarioLabel: string): string;
-export declare const SCENARIO_NAME_RE: RegExp;
 /**
  * Build the center-declared scenario overlay. Invalid specs are SKIPPED with a warning (never fail
  * boot — same posture as skills/teams); valid ones become scenarios keyed by name, ready to be merged
@@ -423,9 +410,13 @@ export interface ScenarioGateSources {
     } | undefined;
     readonly logger?: Logger;
 }
-export type ScenarioGate = (principal: string | undefined, requested: unknown) => Promise<string>;
+export interface ScenarioGate {
+    (principal: string | undefined, requested: unknown): Promise<string>;
+    /** 在册词表 —— 门判「在不在册」读的**同一张**场景表的自有键(活读,不抄快照)。请求的场景头在分派层判在册读它(读面没有体,不过整只门)。 */
+    readonly known: () => readonly string[];
+}
 /**
- * 门问中心裁定走哪条腿(闭集;新增一词 ⇒ 下面的穷尽 `switch` 编译红)—— 与 `resolveRuntimeCaps` / `peekRuntimeCaps` 是同一对:
+ * 门问中心裁定走哪条腿(闭集;新增一词 ⇒ 下面的穷尽 `switch` 编译红)—— 与 `resolveRuntimeCaps` / `peekRuntimeCapsReading` 是同一对:
  *  · `enforce` —— 任务提交腿:中心裁定走执法腿,center 硬失败铸下的 fail-closed 降级项两腿都认;
  *  · `peek` —— 读面(`GET /v1/capabilities/mcp` 状态面、`GET /v1/sessions/:id/mcp` / `…/a2a` 两张会话面板):只读腿,同一只缓存 / 同一条抓取 / 同一份读数(中心答不出 ⇒ 读面同拒),但硬失败铸的降级项只对读面自己算数,
  *    不替这个主体的真提交留下 `{allowWorkflows:false, allowFork:false, autoMode:false}` 的短窗 deny(读面不许成为别人被拒的原因)。

package/dist/capabilities/scenarios.js

@@ -7,6 +7,7 @@ import { createWebSearchBackend, judgeRequestWebSearch } from "../plugins/web-se
 import { scenarioSkillEntries, skillsForScenario } from "./skills.js";
 import { OFFICE_EXCLUDED_TOOL_NAMES, runHasWorkspace } from "./hands-lane.js";
 import { BRAND_IDENTITY_SCENARIOS } from "./brand-identity.js";
+import { SCENARIO_NAME_RE } from "../owner-brands.js";
 export function buildPromptSeats(scenarioName, prompt, callerSystemPrompt) {
     const parts = [prompt?.roleText, callerSystemPrompt].filter((t) => typeof t === "string" && t.length > 0);
     const systemPrompt = parts.length > 0 ? parts.join("\n\n") : callerSystemPrompt;
@@ -69,7 +70,7 @@ export function buildScenarios(deps) {
                 }).filter((t) => t.name !== WEB_FETCH_TOOL_NAME || deps.requirePrincipal !== true),
             ],
             hands: BUILTIN_SCENARIO_HANDS.default,
-            skills: skillsForScenario(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE.default),
+            skills: skillsForScenario(deps.skills, "default"),
         };
     };
     return {
@@ -77,7 +78,7 @@ export function buildScenarios(deps) {
         code: (req, principal, ctx) => ({
             ...defaultScenario(req, principal, ctx),
             hands: BUILTIN_SCENARIO_HANDS.code,
-            skills: skillsForScenario(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE.code),
+            skills: skillsForScenario(deps.skills, "code"),
             prompt: { role: "code" },
         }),
         "code-review": (req) => codeReview(deps, req),
@@ -89,13 +90,13 @@ export function buildScenarios(deps) {
             return {
                 tools: [...repoToolsFor(repoClient, parseRepo(req.repo)), nowTool()],
                 hands: BUILTIN_SCENARIO_HANDS.scan,
-                skills: skillsForScenario(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE.scan),
+                skills: skillsForScenario(deps.skills, "scan"),
             };
         },
         cowork: (req, principal, ctx) => ({
             ...defaultScenario(req, principal, ctx),
             hands: BUILTIN_SCENARIO_HANDS.cowork,
-            skills: skillsForScenario(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE.cowork),
+            skills: skillsForScenario(deps.skills, "cowork"),
             excludeTools: OFFICE_EXCLUDED_TOOL_NAMES,
             prompt: { role: "cowork" },
         }),
@@ -125,13 +126,6 @@ export const BUILTIN_SCENARIO_HANDS = {
     scan: "none",
     cowork: "full",
 };
-export const BUILTIN_SCENARIO_SKILL_SCOPE = {
-    code: "default",
-    default: "default",
-    "code-review": "code-review",
-    scan: "scan",
-    cowork: "cowork",
-};
 export function builtinScenarioDetails(scenarios, deps, branded) {
     const probe = (name, req, principal, fallback) => {
         try {
@@ -146,7 +140,7 @@ export function builtinScenarioDetails(scenarios, deps, branded) {
         name, source: "builtin", builtin: true, summary, toolset, tools, promptSummary, enabled: true,
         ...availabilityFields(deps, toolset),
         attachmentSupplies: attachmentSuppliesFor(BUILTIN_SCENARIO_HANDS[name], deps.handsLane === true),
-        skills: scenarioSkillEntries(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE[name]),
+        skills: scenarioSkillEntries(deps.skills, name),
     });
     const brandedScenario = (name) => branded && BRAND_IDENTITY_SCENARIOS.includes(name);
     const details = {
@@ -220,7 +214,6 @@ function requireRepoClient(deps, scenarioLabel) {
         ? `${scenarioLabel} scenario has no repo client although the availability owner reports it available (wiring defect)`
         : scenarioUnavailableMessage(verdict.reason, scenarioLabel));
 }
-export const SCENARIO_NAME_RE = /^[a-z][a-z0-9-]{1,31}$/;
 export function centerScenarios(deps, specs, builtinNames, logger) {
     const overlay = {};
     const shadows = [];
@@ -254,7 +247,7 @@ function codeReview(deps, req) {
     }
     const coords = parseRepo(req.repo);
     const repoTools = repoToolsFor(repoClient, coords);
-    const skills = skillsForScenario(deps.skills, BUILTIN_SCENARIO_SKILL_SCOPE["code-review"]);
+    const skills = skillsForScenario(deps.skills, "code-review");
     const hands = BUILTIN_SCENARIO_HANDS["code-review"];
     return { tools: [...repoTools, nowTool()], hands, skills, prompt: { roleText: REVIEWER_ROLE_TEXT } };
 }
@@ -328,7 +321,7 @@ export function gateScenarioRequest(ruling, bodyScenario, defaultScenario, known
     const refusal = danglingScenarioRefusal(name, source, known);
     if (refusal !== undefined) {
         logger?.warn("scenario_assignment_unknown", { scenario: name, source, ...(principal !== undefined ? { principal } : {}) });
-        throw createCodedHttpError(503, "state.scenario_assignment_unknown", refusal, { detail: { scenario: name, source } });
+        throw createCodedHttpError(503, "state.scenario_assignment_unknown", refusal, { scenario: name, source });
     }
     return name;
 }
@@ -345,6 +338,8 @@ export function createScenarioGate(sources, leg) {
             }
         }
     };
-    return async (principal, requested) => gateScenarioRequest(await rulingOf(principal), requested, sources.config.defaultScenario, Object.keys(sources.scenarios), sources.logger, principal);
+    const known = () => Object.keys(sources.scenarios);
+    const gate = async (principal, requested) => gateScenarioRequest(await rulingOf(principal), requested, sources.config.defaultScenario, known(), sources.logger, principal);
+    return Object.assign(gate, { known });
 }
 //# sourceMappingURL=scenarios.js.map

package/dist/capabilities/skills.d.ts

@@ -87,7 +87,7 @@ export declare function loadDeploymentSkills(config: {
         readonly provider: ExecutionLane;
     };
 }, logger?: Logger): LoadedSkill[];
-/** 一个技能范围交进 `TaskSpec` 的技能(场景工厂的 `skills`)。范围从哪来见 `scenarios.ts` 的 `BUILTIN_SCENARIO_SKILL_SCOPE`(center 场景 = 它自己的名字)。 */
+/** 一个技能范围交进 `TaskSpec` 的技能(场景工厂的 `skills`)。**技能范围 = 场景名**,内建与 center 声明的场景一律如此、一处读法(没有范围表):各工厂与场景卡直传自己的场景名。 */
 export declare function skillsForScenario(loaded: readonly LoadedSkill[], scope: string): SkillSpec[];
 /**
  * 技能清单的一条 —— **一张形,两个面**:场景卡(`GET /v1/capabilities/scenarios/:name` 的 `skills[]`,[ref])与 run 级名册

package/dist/capabilities/tool-defer.d.ts

@@ -12,7 +12,7 @@
  *  - 🔴 **候选 ≠ 延迟**(core 7.15.0 [ref] 的行为面收窄,本仓两条真后果见下):候选集整体受**一道**
  *    阈值门,全或无 —— 候选的内联字节(name+description+schema)≥ `floor(上下文 token × 10%) × 3`
  *    才延迟,否则**全内联且不挂 `ToolSearch`**。远端协议铸名因此**不再无条件占位**:本仓缺省窗
- *    (`MODEL_CONTEXT_WINDOW=262144`)下阈值 = 78 642 字符,一个中小 MCP 名册够不着 ⇒ 首请求带全 schema。
+ *    (`ASSUMED_CONTEXT_WINDOW`,今天 262144 token)下阈值 = 78 642 字符,一个中小 MCP 名册够不着 ⇒ 首请求带全 schema。
  *    唯一不受门的是调用方的 `TaskSpec.deferTools` 字面名单(按字面恒延迟、不计量)。
  *  - `RunnerDeps.deferMode:"auto"` 不是第二道门,而是把候选集**拓宽**到全部 caller spec 后走同一道门 ——
  *    在本仓缺省场景下那会连 Agent 与 Task 四件一起卷进候选(与 CC 姿态相反),所以我们**刻意不开**;

package/dist/capability-facts.d.ts

@@ -25,7 +25,8 @@ import type { ServiceBlobExchange, ServiceFileHistoryStore } from "./plugins/sto
 import { resolveStreamApprovalGate, type ApprovalFrameFamily } from "./tool-approval.js";
 import { type WorkspaceSyncCapability } from "./workspace-space.js";
 import type { WorkspaceCacheCapability } from "./workspace-cache.js";
-import type { ResumeAnchorStore } from "./plugins/store-backend.js";
+import { type HeadRead } from "./session-incarnation.js";
+import type { HistoryAnchorReaders } from "./history-anchor.js";
 import type { EngineHandoverDoor } from "./boot/engine-lease.js";
 /** why 闭集:词 → 给运维看的一句义(诊断 / 测试读它;wire 上的拒句由各门自写)。 */
 export declare const CAPABILITY_FACT_WHY: {
@@ -38,14 +39,14 @@ export declare const CAPABILITY_FACT_WHY: {
     readonly checkpoint_store_absent: "no durable checkpoint store is wired (DURABLE_APPROVAL)";
     readonly session_audit_absent: "no session audit view is wired (needs a durable session store)";
     readonly session_watch_absent: "the session watch registry is not wired";
-    readonly session_lister_absent: "no session enumerator is wired (session store or run store listSessions)";
+    readonly session_lister_absent: "no session enumerator is wired (the session store has no listSessions)";
     readonly session_fork_face_absent: "the session store has no fork face";
     readonly session_row_faces_absent: "the session store has no session-row faces (headOf / sessionSummaryOf / writeSessionRowCells)";
     readonly session_purge_absent: "no session purge coordinator is wired";
     readonly session_policy_store_absent: "no session policy store is wired";
     readonly store_backend_absent: "no store backend is wired (DB_BACKEND=memory, multi-tenant bare boot, or half-configured SQL)";
     readonly file_history_store_absent: "no file-history store is wired";
-    readonly resume_anchor_store_absent: "no rewind anchor map is wired (the handle → session-entry map a rewind target is read through)";
+    readonly resume_anchor_store_absent: "no rewind anchor map is wired (the handle → session-entry map a rewind target is read through, with the run store an unknown handle is checked against — both come from the store backend)";
     readonly execution_lane_handless: "the execution lane mounts no execution environment (REMOTE_EXEC=none), so a session has no working tree to rewind";
     readonly workspace_rebuilt_per_task: "each task's workspace is rebuilt when the task starts on this deployment (a fresh directory, container or sandbox, or a restore from the workspace snapshot store that a rewind cannot yet take part in), so a rewind would not land in the tree the next task starts from";
     readonly session_store_shared: "the session store is shared by several server instances (DB_BACKEND=mysql|pg) and no durable claim spans an out-of-run rewind yet, so a rewind could interleave with a run or another rewind started on another instance";
@@ -101,6 +102,8 @@ export declare const CAPABILITY_FACT_WHY: {
     readonly deployment_mod_packages_absent: "no operator-declared mod package was loaded at boot (MODS_ROOT / MODS_PACKAGES)";
     readonly engine_handover_lane_absent: "the attachment lease has no handover lane here: the lease is not armed (neither ENGINE_AUTO_EXIT nor SEMA_PARENT_PID), or the deployment is multi-tenant (REQUIRE_PRINCIPAL=true)";
     readonly engine_lease_stopped: "the attachment lease has stopped observing (this engine is shutting down)";
+    readonly auto_background_off: "AUTO_BACKGROUND_ON_TIMEOUT=false: a foreground command that outruns its own timeout is killed";
+    readonly lane_cannot_adopt_running_command: "the execution lane's environment cannot move a running command to the background (only the single-user host lane with HOST_BG_ENABLED on, k8s and e2b can), so a command that outruns its timeout is killed whatever AUTO_BACKGROUND_ON_TIMEOUT says";
 };
 export type CapabilityFactWhy = keyof typeof CAPABILITY_FACT_WHY;
 /** 不可用臂。 */
@@ -170,8 +173,8 @@ export declare function sessionEventStream(d: Pick<Deps, "sessionWatch" | "sessi
     sessionStorage: HeadReadingSessionStore;
 }>;
 type SessionLister = NonNullable<OwnerAwareSessionStore["listSessions"]>;
-/** 会话枚举面:session 店的 `listSessions`,否则老形 run 店聚合。见证 = 已绑好宿主的那一只。 */
-export declare function sessionList(d: Pick<Deps, "sessionStorage" | "runStore">): Fact<"session_lister_absent", {
+/** 会话枚举面:会话店的 `listSessions` —— 唯一的会话 lister(run 店不列会话:只有 run 行、没有会话行的面答不了「有哪些会话」)。见证 = 已绑好宿主的那一只。 */
+export declare function sessionList(d: Pick<Deps, "sessionStorage">): Fact<"session_lister_absent", {
     lister: SessionLister;
 }>;
 export declare function sessionFork(d: Pick<Deps, "sessionStorage">): Fact<"session_fork_face_absent" | "session_head_face_absent", {
@@ -183,9 +186,17 @@ export declare function sessionFork(d: Pick<Deps, "sessionStorage">): Fact<"sess
 export declare function sessionPatch(d: Pick<Deps, "sessionStorage">): Fact<"session_row_faces_absent", {
     sessionStorage: WithMethods<OwnerAwareSessionStore, "headOf" | "writeSessionRowCells">;
 }>;
+/** 删除门读的会话店视图:按 id 读 = 删除门那一只头读,行格的 placement 问询 = 店自己的那一只。门照旧由属主存取器读头(`admitSessionById`),读的就是这一只。 */
+type DeletionGateStore = Pick<OwnerAwareSessionStore, "placementOf"> & {
+    readonly headOf: HeadRead;
+};
+/**
+ * 会话删除面(purge 协调器 ∧ 删除门的头读)。见证 = 协调器 + 删除门的店视图 {@link DeletionGateStore}:按 id 读是 `deletionHeadReadOf`(local 店删到一半的行也答得出属主,
+ * 开始删它的那位重发收得完;别的店 = `headOf`)—— 与协调器围栏读同一只。
+ */
 export declare function sessionDelete(d: Pick<Deps, "purgeSession" | "sessionStorage">): Fact<"session_purge_absent" | "session_head_face_absent", {
     purge: Store<"purgeSession">;
-    sessionStorage: HeadReadingSessionStore;
+    gateStore: DeletionGateStore;
 }>;
 export declare function sessionPolicy(d: Pick<Deps, "sessionPolicyStore" | "sessionStorage">): Fact<"session_policy_store_absent" | "session_head_face_absent", {
     policyStore: Store<"sessionPolicyStore">;
@@ -212,16 +223,17 @@ type RewindFilesWhy = "file_history_store_absent" | "session_head_face_absent" |
 /**
  * run 外的「只恢复代码」口(`POST /v1/sessions/:id/rewind-files`,[ref])这台部署**解不解得出** —— 能力位 `sessionRewindFiles` 与该口的 501 读这一只。
  * 四格缺一不可,每格都是那一口真要用的设施:文件历史店(引擎 `Runner.rewindFiles` 读的同一只;旋钮 `FILE_HISTORY_CAPTURE` 只关捕获、不摘店,
- * 所以与它无关 —— 已存边界照常可回退)∧ 会话头读(属主门 + 坏档判据)∧ 锚店(`to` 手柄经它翻成 entry id,`history-anchor.ts`)∧ 执行车道有手
+ * 所以与它无关 —— 已存边界照常可回退)∧ 会话头读(属主门 + 坏档判据)∧ 锚店与 run 店(`to` 手柄经锚店翻成 entry id,未知手柄的 404 成因半句读 run 店,
+ * `history-anchor.ts`;两只同出存储后端,所以是同一格)∧ 执行车道有手
  * (无手车道上引擎恒拒 `rewind.files_env_unsupported`:没有工作区可回退 —— 位说有而口恒拒不许发生)∧ 即时回退的工作区活过一次执行(部署形表行 `rewindableWorkspace`;
  * 否则恢复的结果到不了下一次执行)∧ 会话店由本进程独占(local 后端:数据根被一个活进程锁住 ⇒ 引擎的进程内会话锁就是全局互斥;
  * SQL 后端被多副本共用,而 run 外回退还没有一只跨副本的持久认领 —— 「先查认领再交引擎」只是检查不是互斥,所以在共享店上位为假、口 501,不留「检查即放行」)。
  * 动词本身是引擎 `Runner` 的必有成员(型上必在),不是一格。
- * 见证 = 判过在场的三只设施;路由在拒臂之后只读见证。
+ * 见证 = 判过在场的设施(历史店 · 手柄翻译的两只读店 · 会话店);路由在拒臂之后只读见证。
  */
-export declare function sessionRewindFiles(d: Pick<Deps, "fileHistoryStore" | "resumeAnchorStore" | "sessionStorage" | "config" | "backend">): Fact<RewindFilesWhy, {
+export declare function sessionRewindFiles(d: Pick<Deps, "fileHistoryStore" | "resumeAnchorStore" | "runStore" | "sessionStorage" | "config" | "backend">): Fact<RewindFilesWhy, {
     historyStore: ServiceFileHistoryStore;
-    anchors: ResumeAnchorStore;
+    anchors: HistoryAnchorReaders;
     sessionStorage: HeadReadingSessionStore;
 }>;
 /**
@@ -230,7 +242,7 @@ export declare function sessionRewindFiles(d: Pick<Deps, "fileHistoryStore" | "r
  * `previewFileDelta` 不在 core 包根导出面上,本仓不另写一份 —— 等 core 导出它,SQL 店补这一座、本位随之转真,路由零改)。本位为假**不是**口不收 `dryRun`:口照收,答 `preview: null`
  * (「这台给不出统计」≠「什么都不会变」);所以本事实没有 501 拒点,只有能力位读它。
  */
-export declare function sessionRewindFilesPreview(d: Pick<Deps, "fileHistoryStore" | "resumeAnchorStore" | "sessionStorage" | "config" | "backend">): Fact<RewindFilesWhy | "file_history_preview_absent">;
+export declare function sessionRewindFilesPreview(d: Pick<Deps, "fileHistoryStore" | "resumeAnchorStore" | "runStore" | "sessionStorage" | "config" | "backend">): Fact<RewindFilesWhy | "file_history_preview_absent">;
 /** 持久审批底座(checkpoint 店)在场 —— `/v1/approvals/*` 与 `/v1/assistant/*` 整条车道、会话 wake 都站在它上面。 */
 export declare function checkpointPark(d: Pick<Deps, "checkpointStore">): Fact<"checkpoint_store_absent", {
     checkpointStore: Store<"checkpointStore">;
@@ -459,6 +471,21 @@ export declare function deploymentModPackages(d: Pick<Deps, "deploymentModPackag
 }>;
 /** 自唤醒调度器挂在宿主 env 上:`SCHEDULER_ENABLED` ∧ 单用户 ∧ host 车道。装配(`boot/execution-env.ts`)与能力位同调。 */
 export declare function hostScheduler(c: Pick<ServiceConfig, "schedulerEnabled" | "requirePrincipal" | "remoteExec">): Fact<"scheduler_disabled" | "multi_tenant_deployment" | "not_host_lane">;
+/**
+ * 前台命令超时转后台(`AUTO_BACKGROUND_ON_TIMEOUT`)在这台部署上生不生效:旋钮开 ∧ 本车道的执行环境能把**运行中的**命令领养成后台任务。
+ * 「能领养」就是执行环境的 `backgroundCapabilities.supportsDetach`,三只声明它的适配器(host / k8s / e2b)上它与后台 shell 的 `supported` 是同一个值 ——
+ * 所以按能力表的 `backgroundShell` 一位读:`supported`(k8s / e2b)⇒ 能;`single-user-only`(只有 host 一行)⇒ 单用户且 host 后台 shell 开关开着才能 ——
+ * 开关是第二参 `hostBackgroundShellOn`,调用方交 `hostBackgroundShellEnabled()`(`HOST_BG_ENABLED`;host 适配器的能力位读同一只;本模块零 I/O,不自己读 env)。
+ * 对账钉 `test/auto-background-on-timeout.test.ts` 逐车道拿装配出的真执行环境的 `supportsDetach` 与本事实对拍。
+ * 旋钮先判:关着的部署不论车道都答 `auto_background_off`(运维旋钮无条件,不支持的车道不拒启,只如实报)。
+ * `/health.autoBackgroundOnTimeout` 投它的三词({@link autoBackgroundOnTimeoutWord})。
+ */
+export declare function autoBackgroundOnTimeout(c: Pick<ServiceConfig, "autoBackgroundOnTimeout" | "requirePrincipal" | "remoteExec">, hostBackgroundShellOn: boolean): Fact<"auto_background_off" | "lane_cannot_adopt_running_command">;
+/** `/health.autoBackgroundOnTimeout` 的三词闭集(顺序无语义):`armed` = 生效 · `off` = 部署关了 · `unsupported` = 旋钮开着,但本车道不能把运行中的命令转后台。 */
+export declare const AUTO_BACKGROUND_ON_TIMEOUT_WORDS: readonly ["armed", "off", "unsupported"];
+export type AutoBackgroundOnTimeoutWord = (typeof AUTO_BACKGROUND_ON_TIMEOUT_WORDS)[number];
+/** 事实 → 三词(穷举:事实多一个 why 而这里不接 = 编译红)。 */
+export declare function autoBackgroundOnTimeoutWord(f: ReturnType<typeof autoBackgroundOnTimeout>): AutoBackgroundOnTimeoutWord;
 /** 引擎能力词的事实(core `ENGINE_CAPABILITIES` 每词一只谓词,值 = 本进程的事实;`/v1/capabilities` 以顶层布尔键展开它们)—— 住在
  *  `capabilities/engine-capabilities.ts`,这里只是把它纳入「能力位只投影事实」的同一张读面,静态门认 `facts.engineCapabilityBits()` 这一只展开。 */
 export { engineCapabilityBits } from "./capabilities/engine-capabilities.js";

package/dist/capability-facts.js

@@ -7,8 +7,8 @@ import { centerEntitlementSourceWired } from "./runtime-caps-resolver.js";
 import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 import { blobExchangeOf, overwriteWipeIncapable } from "./session-sync.js";
 import { WORKSPACE_PERSIST_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_DEFAULT, workspaceSnapshotTimeoutOf } from "./workspace-space.js";
-import { headReadOf } from "./session-incarnation.js";
-import { laneWiresExecutionEnv } from "./execution-lane-caps.js";
+import { deletionHeadReadOf, headReadOf } from "./session-incarnation.js";
+import { executionLaneCaps, laneWiresExecutionEnv } from "./execution-lane-caps.js";
 export const CAPABILITY_FACT_WHY = {
     run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)",
     subagent_registry_absent: "the sub-agent steer registry is not wired",
@@ -19,14 +19,14 @@ export const CAPABILITY_FACT_WHY = {
     checkpoint_store_absent: "no durable checkpoint store is wired (DURABLE_APPROVAL)",
     session_audit_absent: "no session audit view is wired (needs a durable session store)",
     session_watch_absent: "the session watch registry is not wired",
-    session_lister_absent: "no session enumerator is wired (session store or run store listSessions)",
+    session_lister_absent: "no session enumerator is wired (the session store has no listSessions)",
     session_fork_face_absent: "the session store has no fork face",
     session_row_faces_absent: "the session store has no session-row faces (headOf / sessionSummaryOf / writeSessionRowCells)",
     session_purge_absent: "no session purge coordinator is wired",
     session_policy_store_absent: "no session policy store is wired",
     store_backend_absent: "no store backend is wired (DB_BACKEND=memory, multi-tenant bare boot, or half-configured SQL)",
     file_history_store_absent: "no file-history store is wired",
-    resume_anchor_store_absent: "no rewind anchor map is wired (the handle → session-entry map a rewind target is read through)",
+    resume_anchor_store_absent: "no rewind anchor map is wired (the handle → session-entry map a rewind target is read through, with the run store an unknown handle is checked against — both come from the store backend)",
     execution_lane_handless: "the execution lane mounts no execution environment (REMOTE_EXEC=none), so a session has no working tree to rewind",
     workspace_rebuilt_per_task: "each task's workspace is rebuilt when the task starts on this deployment (a fresh directory, container or sandbox, or a restore from the workspace snapshot store that a rewind cannot yet take part in), so a rewind would not land in the tree the next task starts from",
     session_store_shared: "the session store is shared by several server instances (DB_BACKEND=mysql|pg) and no durable claim spans an out-of-run rewind yet, so a rewind could interleave with a run or another rewind started on another instance",
@@ -82,6 +82,8 @@ export const CAPABILITY_FACT_WHY = {
     deployment_mod_packages_absent: "no operator-declared mod package was loaded at boot (MODS_ROOT / MODS_PACKAGES)",
     engine_handover_lane_absent: "the attachment lease has no handover lane here: the lease is not armed (neither ENGINE_AUTO_EXIT nor SEMA_PARENT_PID), or the deployment is multi-tenant (REQUIRE_PRINCIPAL=true)",
     engine_lease_stopped: "the attachment lease has stopped observing (this engine is shutting down)",
+    auto_background_off: "AUTO_BACKGROUND_ON_TIMEOUT=false: a foreground command that outruns its own timeout is killed",
+    lane_cannot_adopt_running_command: "the execution lane's environment cannot move a running command to the background (only the single-user host lane with HOST_BG_ENABLED on, k8s and e2b can), so a command that outruns its timeout is killed whatever AUTO_BACKGROUND_ON_TIMEOUT says",
 };
 const no = (why) => ({ available: false, why });
 const yes = (w) => ({ available: true, ...w });
@@ -147,7 +149,7 @@ export function sessionEventStream(d) {
     return yes({ watch: d.sessionWatch, sessionStorage: owned.sessionStorage });
 }
 export function sessionList(d) {
-    const lister = d.sessionStorage?.listSessions?.bind(d.sessionStorage) ?? d.runStore?.listSessions?.bind(d.runStore);
+    const lister = d.sessionStorage?.listSessions?.bind(d.sessionStorage);
     return lister !== undefined ? yes({ lister }) : no("session_lister_absent");
 }
 export function sessionFork(d) {
@@ -170,7 +172,12 @@ export function sessionDelete(d) {
     const owned = sessionOwnership(d);
     if (!owned.available)
         return owned;
-    return yes({ purge: d.purgeSession, sessionStorage: owned.sessionStorage });
+    const store = owned.sessionStorage;
+    const headOf = deletionHeadReadOf(store);
+    if (headOf === undefined)
+        return no("session_head_face_absent");
+    const placementOf = store.placementOf?.bind(store);
+    return yes({ purge: d.purgeSession, gateStore: { headOf, ...(placementOf !== undefined ? { placementOf } : {}) } });
 }
 export function sessionPolicy(d) {
     if (d.sessionPolicyStore === undefined)
@@ -209,7 +216,7 @@ export function sessionRewindFiles(d) {
     const owned = sessionOwnership(d);
     if (!owned.available)
         return owned;
-    if (d.resumeAnchorStore === undefined)
+    if (d.resumeAnchorStore === undefined || d.runStore === undefined)
         return no("resume_anchor_store_absent");
     if (!laneWiresExecutionEnv(d.config.remoteExec.provider))
         return no("execution_lane_handless");
@@ -217,7 +224,7 @@ export function sessionRewindFiles(d) {
         return no("workspace_rebuilt_per_task");
     if (d.backend?.kind !== "local")
         return no("session_store_shared");
-    return yes({ historyStore: d.fileHistoryStore, anchors: d.resumeAnchorStore, sessionStorage: owned.sessionStorage });
+    return yes({ historyStore: d.fileHistoryStore, anchors: { anchors: d.resumeAnchorStore, runs: d.runStore }, sessionStorage: owned.sessionStorage });
 }
 export function sessionRewindFilesPreview(d) {
     const rewind = sessionRewindFiles(d);
@@ -493,5 +500,37 @@ export function hostScheduler(c) {
         return no("not_host_lane");
     return YES;
 }
+export function autoBackgroundOnTimeout(c, hostBackgroundShellOn) {
+    if (c.autoBackgroundOnTimeout !== true)
+        return no("auto_background_off");
+    const cap = executionLaneCaps(c.remoteExec.provider).backgroundShell;
+    switch (cap) {
+        case "unsupported":
+            return no("lane_cannot_adopt_running_command");
+        case "supported":
+            return YES;
+        case "single-user-only":
+            return c.requirePrincipal !== true && hostBackgroundShellOn ? YES : no("lane_cannot_adopt_running_command");
+        default: {
+            const unknownCap = cap;
+            throw new Error(`auto-background fact: unknown lane capability ${String(unknownCap)}`);
+        }
+    }
+}
+export const AUTO_BACKGROUND_ON_TIMEOUT_WORDS = ["armed", "off", "unsupported"];
+export function autoBackgroundOnTimeoutWord(f) {
+    if (f.available)
+        return "armed";
+    switch (f.why) {
+        case "auto_background_off":
+            return "off";
+        case "lane_cannot_adopt_running_command":
+            return "unsupported";
+        default: {
+            const unknownWhy = f.why;
+            throw new Error(`auto-background word: unknown why ${String(unknownWhy)}`);
+        }
+    }
+}
 export { engineCapabilityBits } from "./capabilities/engine-capabilities.js";
 //# sourceMappingURL=capability-facts.js.map

package/dist/card-void.d.ts

@@ -1,5 +1,5 @@
 /**
- * **结算时作废一张本 run 自己会话上的、本服务兑现不了的卡** —— 读卡 → 卡仍 pending ∧ 卡在调用方说的那只会话上 ⇒
+ * **结算时作废一张归本 run 会话的、本服务兑现不了的卡** —— 读卡 → 卡仍 pending ∧ 卡归调用方说的那只会话(归属列,`hostSessionOf`)⇒
  * 按卡**自己的** scope 走 checkpoint 店的 `expire`(与引擎的本进程仲裁器、续跑的 resolve 同一只 CAS,恰一个赢家)。不新增任何持久态。
  *
  * 规则只有一条:**本服务兑现不了的卡不留在待决面上**。产地 = 停驻没落定就以失败收场的腿(`runs.ts` 的 `voidHeldParkCard`:后台腿与
@@ -13,16 +13,16 @@
  */
 import type { CheckpointToken } from "@sema-agent/core";
 import { type FailOpenTag } from "./observability/fail-open.js";
-/** 结算点手里那只 checkpoint 店的两个动词:读卡(取它自己的 scope / 会话 / 状态)→ 按卡自己的 scope CAS 作废。 */
+/** 结算点手里那只 checkpoint 店的三个动词:读卡(取它自己的 scope / 状态)、读它归在哪只会话上 → 按卡自己的 scope CAS 作废。 */
 export interface CardVoidPort {
     get(token: CheckpointToken): Promise<{
         readonly scope?: string;
-        readonly sessionId?: string;
         readonly status?: string;
     } | null>;
+    hostSessionOfCard(token: CheckpointToken): Promise<string | null | undefined>;
     expire(token: CheckpointToken, scope: string): Promise<boolean>;
 }
-/** 要作废的那一张:停驻带回的凭据 + 它应在的会话(对不上就不动它 —— 只作废**这一张**)。 */
+/** 要作废的那一张:停驻带回的凭据 + 它应归的会话(本 run 的会话;对不上就不动它 —— 只作废**这一张**)。 */
 export interface CardRef {
     readonly token: CheckpointToken;
     readonly sessionId: string | undefined;

package/dist/card-void.js

@@ -10,7 +10,7 @@ export async function voidPendingCard(card, cards, tag, at) {
         const live = await cards.get(card.token);
         if (live === null || live.status !== "pending")
             return;
-        if (card.sessionId === undefined || live.sessionId !== card.sessionId || typeof live.scope !== "string") {
+        if (card.sessionId === undefined || (await cards.hostSessionOfCard(card.token)) !== card.sessionId || typeof live.scope !== "string") {
             miss("card_mismatch");
             return;
         }

package/dist/center-credential-renewer.d.ts

@@ -38,8 +38,12 @@ export interface CenterCredentialRenewer {
     renewal(): CenterCredentialRenewal;
     /** 最近一次读到的信封的访问令牌到期时刻(epoch ms;最近一次取值不是信封 ⇒ undefined)。 */
     sessionExpiresAt(): number | undefined;
-    /** 退订 + 停定时器(幂等;在飞的那一次照常落地 —— 它的结果对壳同样有用)。 */
-    stop(): void;
+    /**
+     * 退订 + 停定时器(幂等),此后不再发起续签;返回的 promise 在**已经发出**的那一次续签落定之后才 settle(新信封落盘,或按失败落定 —— 从不 reject;
+     * 没有在飞的 ⇒ 立即 settle)。进程出口(起服前探针、停机)等它:中心一旦答应了续签,旧 refresh token 就作废了,换来的新信封没落盘就退出 ⇒
+     * 下一次起服手里只剩一只被消费的令牌。续签请求本身有界(`CENTER_PULL_TIMEOUT_MS`),所以这一等有界。
+     */
+    stop(): Promise<void>;
 }
 /** `/health.centerCredential` 的 wire 形(免鉴权面:只有闭集词、时刻与计数 —— 不带路径、不带 reason 原句、不带令牌)。 */
 export interface CenterCredentialHealthView {

package/dist/center-credential-renewer.js

@@ -5,6 +5,7 @@ import { WEB_ADMIN_ENV, WebAdminCredentialEnvelope, parseWebAdminCredentialFile
 import { ACCESS_TOKEN_TTL_SECONDS, OAuthErrorResponse, TokenGrantResponse } from "@sema-agent/settings-schema/api/auth";
 import { CENTER_PULL_TIMEOUT_MS, CenterRedirectRefusedError, centerTokenRefresh } from "./web-admin-client/center-request.js";
 import { OWNER_ONLY_FILE_MODE } from "./plugins/owner-only-file-mode.js";
+import { readUpstreamJson } from "./upstream-body.js";
 export const CENTER_CREDENTIAL_RENEW_LEAD_KEY = "CENTER_CREDENTIAL_RENEW_LEAD_MS";
 export const CENTER_CREDENTIAL_RENEW_LEAD_DEFAULT_MS = 5 * 60_000;
 export const CENTER_CREDENTIAL_RENEW_LEAD_MIN_MS = CENTER_PULL_TIMEOUT_MS;
@@ -92,6 +93,7 @@ export function createCenterCredentialRenewer(deps) {
     let subject;
     let held;
     let inFlight = false;
+    let current;
     let stopped = false;
     const stranded = new Set();
     let cleanupWarned = false;
@@ -291,13 +293,13 @@ export function createCenterCredentialRenewer(deps) {
             return;
         }
         if (res.status !== 200) {
-            const oauth = OAuthErrorResponse.safeParse(await res.json().catch(() => undefined));
+            const oauth = OAuthErrorResponse.safeParse(await readUpstreamJson(res).catch(() => undefined));
             const oauthError = oauth.success ? oauth.data.error : undefined;
             judgeRefusal(usedDigest, res.status === 400 && oauthError === "invalid_grant" ? "invalid_grant" : "rejected", { status: res.status, ...(oauthError !== undefined ? { oauthError } : {}) });
             return;
         }
         const issuedAt = now();
-        const grant = TokenGrantResponse.safeParse(await res.json().catch(() => undefined));
+        const grant = TokenGrantResponse.safeParse(await readUpstreamJson(res).catch(() => undefined));
         if (!grant.success || !Number.isFinite(grant.data.expires_in) || grant.data.expires_in <= 0) {
             judgeRefusal(usedDigest, "malformed_grant", { status: res.status });
             return;
@@ -324,7 +326,7 @@ export function createCenterCredentialRenewer(deps) {
         if (held === undefined && (expiresAt - t > leadMs || t < quietUntil))
             return;
         inFlight = true;
-        void renewOnce()
+        current = renewOnce()
             .catch((err) => {
             const error = { error: err instanceof Error ? err.message : String(err) };
             if (held !== undefined && subject !== undefined) {
@@ -336,6 +338,7 @@ export function createCenterCredentialRenewer(deps) {
         })
             .finally(() => {
             inFlight = false;
+            current = undefined;
         });
     };
     const unsubscribe = source.onRead((read) => {
@@ -358,6 +361,7 @@ export function createCenterCredentialRenewer(deps) {
             if (timer !== undefined)
                 clearInterval(timer);
             unsubscribe();
+            return current ?? Promise.resolve();
         },
     };
 }