@sema-agent/server 7.147.0 → 7.149.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`,今天 131072 token)下阈值 = 39 321 字符,一个中小 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,22 @@ 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` 是同一个值,
+ * 这个值的**唯一**答者是部署形行 `DEPLOYMENT_SHAPE_PREDICATES.backgroundShell`(读能力表那一位:k8s / e2b 任何租户,host 只单主)—— 适配器与本事实读同一行,
+ * 本事实不再自己读能力表的三档。host 另有一个全局关停开关(`HOST_BG_ENABLED`),是旋钮不是部署形,所以只在 host 车道上、在行之上合取:
+ * 开关是第二参 `hostBackgroundShellOn`,调用方交 `hostBackgroundShellEnabled()`(host 适配器的能力位读同一只;本模块零 I/O,不自己读 env)。
+ * 同读钉 `test/auto-background-on-timeout.test.ts` ③ 逐车道 × 单主 / 多租拿装配出的真执行环境的 `supported` / `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,7 +7,7 @@ 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 { deletionHeadReadOf, headReadOf } from "./session-incarnation.js";
 import { 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)",
@@ -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,26 @@ 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 laneCanAdopt = DEPLOYMENT_SHAPE_PREDICATES.backgroundShell.holds(c) && (c.remoteExec.provider !== "host" || hostBackgroundShellOn);
+    return laneCanAdopt ? YES : no("lane_cannot_adopt_running_command");
+}
+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-settle-stored-scope.d.ts

@@ -0,0 +1,56 @@
+/**
+ * **按令牌把一张 pending 卡 CAS expire —— 全仓唯一的读法**(状态读 `get` 交出的行状态,属主格读店的列,CAS 吃那一格)。六个读者同读这一只,没有第二份:
+ *  · `POST /v1/runs/:id/cancel` 的停驻取消腿(`routes/runs.ts` 的 `cancelSuspended`);
+ *  · 一条续跑腿被取消之后结算它续的那张卡(`resume-legs.ts` 的 `settleCardForCancel`);
+ *  · 审批 SLA 拒扫腿对「准入策略挡住」的续跑当场过期该卡(`http/approval-sweeps.ts` 的 `expirePolicyBlockedCard`);
+ *  · 会话删除 / 显式结清口带走停驻子代时作废它的卡(`session-children-retire.ts` 的 `expireParkedCard`);
+ *  · 停驻写没落定就以失败收场时作废手里那张卡(`card-void.ts` 的 `voidPendingCard`);
+ *  · 复活不了的停驻子代被 deny 时作废它的卡(`parked-decide.ts` 的 `voidUnrevivableCard`)。
+ *
+ * ## 规则一条:顺序恒为「先读状态、(要求归属就)再核归属、最后按存储列 expire」,不读行体里的属主格
+ * 一张停驻卡的事实在店里有两份:列(令牌、归属 run 的会话、门型、属主格 `scope` —— 引擎停驻时盖下,身份迁移时与行体里那一份一起迁)与行体(`checkpoint` 里的 JSON 快照)。
+ * `expire` 的 CAS 谓词吃的是列;拿行体里自带的那一份去配,行体与列不一致(手改 / 外来写者 / 迁移两腿之间)时只会把「列好体坏」说成「被并发决议了」,行体读不成检查点时更是读行体就抛。
+ *  1. **状态**:卡已不在待决面(已结 / 已不在)⇒ 不写 —— 已结的卡上 CAS 恒输,写一次只是多一次店写(店写口故障时那一次还会抛,把「本来什么都不用做」的收场变成失败)。
+ *     状态读 `get` 交出的行状态(状态列权威,不是行体快照里那一份);**读不成检查点的行体**({@link UnreadableCheckpointRowError})读不出状态 ⇒ 不替 CAS 判(「不知道」不当作「已结」),
+ *     下一步吃列的 CAS 自己判;其余读故障(连库 / 超时 / 程序错)原样上抛,店的故障不是答案。
+ *  2. **归属**(调用方要求时):卡的归属会话(`hostSessionOfCard`,列)必须就是调用方说的那只 —— 只作废**这一张**;读不出 / 对不上 ⇒ `host_mismatch`,不写。状态在归属之前:已结的卡不因归属对不上而报警。
+ *  3. **属主格**:`peekScopeByToken`(SQL = `scope` 列,local = 账本行),`null` 是店契约里的匿名值,按契约换成公共哨兵(两只真店的属主列非空,到不了这一臂)。
+ * 找「取消动词会结算哪一张卡」是取消口自己的事(`run-cancel-card.ts`);本模块只管拿到令牌之后怎么结算。
+ */
+import type { CheckpointToken } from "@sema-agent/core";
+import type { CheckpointStoreFull } from "./plugins/store-backend.js";
+/** 「这张卡此刻的状态」那一问要的店口(只读 `get` 交出的行状态;结构型 —— 真店的 `get` 直接对上)。 */
+export interface CardStatusPort {
+    get(token: CheckpointToken): Promise<{
+        readonly status?: string;
+    } | null>;
+}
+/** 结算一张卡要的店口:状态 + 属主格(店的列)+ CAS expire。六个读者的依赖型都从这一份取,不各自另写一份 `Pick`。 */
+export type CardSettlePort = CardStatusPort & Pick<CheckpointStoreFull, "peekScopeByToken" | "expire">;
+/** 要求归属时多要的一口:卡归在哪只会话上(归属列)。 */
+export type CardHostPort = Pick<CheckpointStoreFull, "hostSessionOfCard">;
+/**
+ * 结算的结局(店的事实,不嗅文案):
+ *  · `expired` —— 本调用亲手把一张 pending 的卡 expire 了;
+ *  · `not_pending` —— 卡已不在待决面(已结 / 已不在),没写;
+ *  · `lost` —— 读状态时还 pending、CAS 输给了并发的结算(决定 / 收割 / 别的作废者);
+ *  · `host_mismatch` —— 调用方要求的归属对不上(或说不出),没写。
+ */
+export declare const CARD_EXPIRE_OUTCOME: {
+    readonly expired: "expired";
+    readonly notPending: "not_pending";
+    readonly lost: "lost";
+    readonly hostMismatch: "host_mismatch";
+};
+export type CardExpireOutcome = (typeof CARD_EXPIRE_OUTCOME)[keyof typeof CARD_EXPIRE_OUTCOME];
+/** 调用方要求:这张卡必须归在 `hostSession` 这只会话上(`undefined` = 调用方说不出自己的会话 ⇒ 恒对不上)。 */
+export interface CardHostGuard {
+    readonly hostSession: string | undefined;
+}
+/**
+ * 按店里的属主格把 `token` 那张卡 CAS expire(≈ deny 的 reaper 终局;不是 resolve —— 取消意味着 run 死掉,deny-RESUME 会把拒绝喂回模型烧 token),次序见模块头注。
+ * 要求归属就给 `guard`(店口多带 {@link CardHostPort});不给 ⇒ 不核归属(令牌是调用方按列找来的,如取消口的 `runCancelCardOf`)。
+ */
+export declare function expireCardUnderStoredScope(cs: CardSettlePort, token: CheckpointToken): Promise<CardExpireOutcome>;
+export declare function expireCardUnderStoredScope(cs: CardSettlePort & CardHostPort, token: CheckpointToken, guard: CardHostGuard): Promise<CardExpireOutcome>;
+//# sourceMappingURL=card-settle-stored-scope.d.ts.map

package/dist/card-settle-stored-scope.js

@@ -0,0 +1,27 @@
+import { UnreadableCheckpointRowError } from "./plugins/checkpoint-store-face.js";
+import { CHECKPOINT_PUBLIC_SCOPE } from "./security.js";
+export const CARD_EXPIRE_OUTCOME = { expired: "expired", notPending: "not_pending", lost: "lost", hostMismatch: "host_mismatch" };
+async function cardLeftPending(cs, token) {
+    try {
+        const live = await cs.get(token);
+        return live === null || live.status !== "pending";
+    }
+    catch (e) {
+        if (e instanceof UnreadableCheckpointRowError)
+            return false;
+        throw e;
+    }
+}
+export async function expireCardUnderStoredScope(cs, token, guard) {
+    if (await cardLeftPending(cs, token))
+        return CARD_EXPIRE_OUTCOME.notPending;
+    if (guard !== undefined) {
+        if (guard.hostSession === undefined || cs.hostSessionOfCard === undefined || (await cs.hostSessionOfCard(token)) !== guard.hostSession)
+            return CARD_EXPIRE_OUTCOME.hostMismatch;
+    }
+    const scope = await cs.peekScopeByToken(token);
+    if (scope === undefined)
+        return CARD_EXPIRE_OUTCOME.notPending;
+    return (await cs.expire(token, scope ?? CHECKPOINT_PUBLIC_SCOPE)) ? CARD_EXPIRE_OUTCOME.expired : CARD_EXPIRE_OUTCOME.lost;
+}
+//# sourceMappingURL=card-settle-stored-scope.js.map