@sema-agent/server 7.146.0 → 7.148.0

package/dist/boot/retention-lane.d.ts

@@ -29,47 +29,16 @@
  * (车1 已实现)。lane **不补记**它们 —— 补记 = 「删了但审计没落地」的窗口重新打开。receipt 在本文件里
  * 只做两件事:二次确认(日志/指标)与「本轮到底动了多少」的读数。
  */
-import type { RetentionPolicy, RetentionReceipt } from "@sema-agent/core";
+import type { RetentionPolicy } from "@sema-agent/core";
 import type { RetentionMode } from "../config-types.js";
-import type { EndedSpace, SpaceReclaimer } from "../workspace-space.js";
+import type { SessionEraseSettler } from "../session-erase.js";
+import type { RetentionExecutor } from "../plugins/retention-deployment.js";
 /** 同 domain 连续失败多少次算「卡住了」(fail-loud 的阈值)。`5` 与 reaper 家族的
  *  `REAPER_FAILURE_WARN_THRESHOLD` 同值同理由:一次抖动(一次重连、一次超时)正是容错要吸收的,
  *  只有**连败**才越过「可诊断」这条线。 */
 export declare const RETENTION_SWEEP_STUCK_THRESHOLD = 5;
 /** 租约 TTL = 本倍数 × sweep 间隔(设计稿 §3)。`2` = 允许一轮跑满一个完整间隔还有余量,再多就该让位。 */
 export declare const RETENTION_LEASE_TTL_FACTOR = 2;
-/**
- * lane 消费的**执行器**面 —— core `ManagedRetentionCapability` 的三方法 + 车1 的非契约窄读口
- * `previewRetention`(audit-only 档的读数源;core 契约无 count 面)+ 声明位。
- *
- * 🔴 三方法的入参是 core 契约形的**超集**(多一个 `audit`):车1 的店在运行期对缺席的审计上下文
- * fail-closed 抛错,所以这里把它写进类型 —— 让「忘了传」变成编译错,而不是一次运行期的破坏性调用被拒。
- */
-export interface RetentionExecutor {
-    readonly retention?: "managed" | "none";
-    listRetentionDomains(): Promise<readonly string[]>;
-    previewRetention(input: {
-        domain: string;
-        cutoffMs: number;
-    }): Promise<{
-        checkpoints: number;
-        sessions: number;
-        toolResults: number;
-    }>;
-    expireCheckpoints(input: RetentionDestructiveInput): Promise<RetentionReceipt>;
-    deleteExpiredSessions(input: RetentionDestructiveInput): Promise<RetentionSessionsReceipt>;
-    deleteOrphanToolResults(input: RetentionDestructiveInput): Promise<RetentionReceipt>;
-}
-/** 破坏性调用的入参(判定时点的三格随行 —— 理由逐字见车1 `RetentionAuditContext` 的头注)。 */
-export interface RetentionDestructiveInput {
-    domain: string;
-    cutoffMs: number;
-    audit: {
-        mode: RetentionMode;
-        policyDays: number;
-        fencingToken: number | null;
-    };
-}
 /** 非破坏性审计行的写口(lane 侧属主的那五个词)。 */
 export interface RetentionAuditSink {
     append(row: {
@@ -128,17 +97,10 @@ export interface RetentionSweepCtx {
      * `createThrottledReaperCatch` 必须建在 `setInterval` 之外是同一条理由。
      */
     streaks?: Map<string, number>;
-    /** 结束的空间的回收座(k8s 车道 ∧ 配了缓存卷或快照存储时在场;与会话删除协调器同一只):enforce 删掉会话树之后,把回执里结束了的空间交给它
-     *  (缓存卷、`space/` 快照、该会话停驻车道的快照一并回收)。它从不抛(失败 = 一行 + fail-open 计数);缺席 = 本部署没有可回收的东西。 */
-    spaceReclaimer?: SpaceReclaimer;
+    /** 删后收尾(`session-erase.ts`,与会话删除协调器同一只):enforce 删掉会话树之后,把回执里的 `erased` 交给它 —— 附件字节、完成信箱围栏、会话信箱清仓、
+     *  住客空间回收、无出处卸载结果的如实告知。每一步失败只记一行(行已删,不再有重试路)。 */
+    settle: SessionEraseSettler;
 }
-/**
- * 会话树 sweep 的回执 = core 契约的 `RetentionReceipt` + 本仓一位:`endedSpaces` = 本次删掉的会话树里**结束了的空间**(会话 id + 住客空间键 = 会话化身;
- * 读不出住客的空化身不算),present-iff 非空。lane 把它交给空间的回收座(与会话删除协调器同一只),缓存卷与快照随空间的终结回收。
- */
-export type RetentionSessionsReceipt = RetentionReceipt & {
-    readonly endedSpaces?: readonly EndedSpace[];
-};
 /** 一轮的读数(给日志与判据用;lane 自己不做任何决策依赖它)。 */
 export interface RetentionSweepOutcome {
     /** 本轮真正处理完的 domain 数(丢租中止时 = 中止之前那些)。 */
@@ -168,7 +130,7 @@ export interface RetentionSweepOutcome {
  * 为什么本道必须存在:引擎的门不拦
  *  · 没锁时,执行器在场 × 一只 `"none"` 的店 —— 部署于是**广告了一个不执行的留存面**:能力位说
  *     `{mode,maxAgeDays}`、审计表也在长,而那只店的行谁都没在删。
- *     本仓的 SQL 后端按同一个事实(扫车道开不开,`plugins/retention-store-sql.ts` 的 `retentionSweepRuns`)给它铸的三只店声明词,所以 lane 开着时
+ *     本仓的 SQL 后端按同一个事实(扫车道开不开,`plugins/retention-declaration.ts` 的 `retentionSweepRuns`)给它铸的三只店声明词,所以 lane 开着时
  *     这三只店在这一格上恒是 `managed`;这一格防的是声明与 lane 脱钩的店(别的后端、替身)。
  * 这些都在**启动期**拒(安全控件不得半开),不是让运维从一台"启动成功、什么也没删"的机器上猜。
  *

package/dist/boot/retention-lane.js

@@ -94,8 +94,8 @@ async function sweepDomainEnforce(ctx, d) {
     };
     const checkpoints = await ctx.executor.expireCheckpoints(input);
     const sessions = await ctx.executor.deleteExpiredSessions(input);
-    if (sessions.endedSpaces !== undefined && ctx.spaceReclaimer !== undefined)
-        await ctx.spaceReclaimer.reclaim(sessions.endedSpaces);
+    if (sessions.erased !== undefined)
+        await (await ctx.settle(sessions.erased)).spaces;
     const toolResults = await ctx.executor.deleteOrphanToolResults(input);
     const touched = checkpoints.deleted + sessions.deleted + toolResults.deleted;
     if (touched > 0) {

package/dist/boot/runner-deps.d.ts

@@ -28,6 +28,7 @@ import type { ToolApprovalCoordinator } from "../tool-approval.js";
 import type { MemoryBackend } from "@sema-agent/core";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { MailboxRecipientLifecycle } from "../plugins/mailbox-recipient-lifecycle.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import type { PeerDesk } from "../peer-seat.js";
 /**
  * `RunnerDeps.onAsk` 的装配([ref] 件4:从内联闭包提为具名导出,**纯 testability 重构、零行为变化**)。
@@ -219,19 +220,20 @@ export interface RunnerDepsCtx {
      *  缺席=undefined=pre-338 语义(纯 env 部署无中心撤销面)。 */
     mcpRevocations: RunnerDeps["mcpRevocations"];
     /**
-     * 交接件⑤ —— commit 尾注的署名座(`RunnerDeps.hands.commitCoAuthor`)。
+     * 交接件⑤ —— commit 尾注的署名(`RunnerDeps.hands.commitCoAuthor`;缺席 = 不署)。手带(`hands`)本身由共享基座铸,调用方只交这一格。
      *
-     * 🔴 为什么它属于**共享基座**而不是主 runner 的差异键:署名是**部署身份**([ref]① clay 拍:
+     * 🔴 为什么手带属于**共享基座**而不是主 runner 的差异键:署名是**部署身份**([ref]① clay 拍:
      * 「署名 = 产品身份资产,归部署」),不是「哪一只 Runner 在跑」的属性。一个被委派出去的子代
      * 提交进的是**同一个仓**、代表的是**同一个部署** —— 它的 commit 少一行 trailer 没有任何理由。
      * 修前两条腿都漏:`main.ts` 与 `run-local.ts` 的 subRunner 都只在主 runner 上写了这一键,而两处
      * 的「差异键」注释块逐条列了 sessionStore / checkpointStore / 四个座位,**都没提 hands**
      * —— 也就是说它不是一次有理由的分歧,是漏配(与本函数头注记的 [ref]§三族A 同一个病族)。
-     * 由**调用方**给值(而不是在基座里按 `config` 现算):两条腿的判据本就不同(HTTP 腿按
+     * 署名由**调用方**给值(而不是在基座里按 `config` 现算):两条腿的判据本就不同(HTTP 腿按
      * 品牌判官 `isBrandedDeployment`(`capabilities/brand-identity.ts`)分 branded/非 branded,run-local 恒是 Sema 本地形),
-     * 各自算一次、传进来一次,两只 Runner 自动同源。
+     * 各自算一次、传进来一次。手带的另一格 `autoBackgroundOnTimeout` 两条腿判据相同(部署旋钮 `AUTO_BACKGROUND_ON_TIMEOUT`),
+     * 所以由手带的唯一铸点 {@link buildHandsBand} 按 `config` 读 —— 读点只有一处,两只 Runner 自动同源。
      */
-    hands: RunnerDeps["hands"];
+    commitCoAuthor: NonNullable<RunnerDeps["hands"]>["commitCoAuthor"];
     executionEnvFactory: RunnerDeps["executionEnvFactory"];
     lspManager: RunnerDeps["lspManager"];
     fleetBus: FleetEventBus;
@@ -246,7 +248,7 @@ export interface RunnerDepsCtx {
 }
 /** [ref] A10 留档发现②:main runner `RunnerDeps` 与 main.ts subRunner 字面量之间此前手工重复
  * 的 ~15 个键,类型标注见 {@link createSharedRunnerDeps} 头注。 */
-export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "readDenyFloorRequired" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations" | "peerSeat">;
+export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "readDenyFloorRequired" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "fileHistoryStore" | "fileHistoryCapture" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations" | "peerSeat">;
 /**
  * [ref] A10 留档发现②(review 2026-07-29,[ref]§三族A 同源修补的延续):main runner 的
  * `RunnerDeps` 字面量(下方 `createRunnerDeps`)与 `main.ts` 里 subRunner 的 `new Runner({...})`
@@ -273,7 +275,7 @@ export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDeny
  *    属性,比再抽一层共享基座更强的同源保证),不重复收纳进这里。
  */
 /** 基座真实消费的窄面(Pick)——subRunner 调用点(main.ts)只需凑这 13 个字段,不必造全量 ctx。 */
-export type SharedRunnerDepsCtx = Pick<RunnerDepsCtx, "config" | "brain" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "deploymentMods" | "toolResultStore" | "checkpointStore" | "sessionPolicyStore" | "hands" | "usageWindowStore" | "orgMemoryAdmission" | "sharedMemoryStores" | "logger" | "governanceSeams" | "mcpRevocations" | "metrics" | "engineDataRoot" | "peerDesk">;
+export type SharedRunnerDepsCtx = Pick<RunnerDepsCtx, "config" | "brain" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "deploymentMods" | "toolResultStore" | "checkpointStore" | "fileHistoryStore" | "sessionPolicyStore" | "commitCoAuthor" | "usageWindowStore" | "orgMemoryAdmission" | "sharedMemoryStores" | "logger" | "governanceSeams" | "mcpRevocations" | "metrics" | "engineDataRoot" | "peerDesk">;
 /** 转发席只需要 `inc` —— 刻意窄到这一个动词,免得把整只 Metrics 拖进这条纯转发腿。 */
 export interface EngineNoticeMetricsSeat {
     inc: (name: string, labels?: Record<string, string>) => void;
@@ -347,6 +349,13 @@ export declare const CROSS_BOUNDARY_POSTURE_REQUIRES_PRINCIPAL: {
     readonly single_user: false;
 };
 export declare function crossBoundaryPostureOf(requirePrincipal: boolean): CrossBoundaryPosture;
+/**
+ * 手带(`RunnerDeps.hands`)的**唯一**铸点(纯数据 ⇒ `build*`)。两格两个来源:署名由腿给(两条腿判据不同,见 {@link RunnerDepsCtx.commitCoAuthor};
+ * leader 车道今天不署名,显式交 `undefined`),前台命令超时转后台读部署旋钮 `AUTO_BACKGROUND_ON_TIMEOUT` —— 旋钮的读点只有这里。
+ * 共享基座(主 / 无手 / hook 代理 / 子代,HTTP 与 run-local 两条腿)与 leader 车道(`boot/leader.ts` → `LeaderWireConfig.hands`)同调这一只:
+ * 有手的每一只 Runner 都拿到它,`/health.autoBackgroundOnTimeout` 说「生效」时没有哪只 Runner 例外。
+ */
+export declare function buildHandsBand(config: Pick<ServiceConfig, "autoBackgroundOnTimeout">, commitCoAuthor: RunnerDepsCtx["commitCoAuthor"]): NonNullable<RunnerDeps["hands"]>;
 export declare function buildDeploymentPostureSeats(config: DeploymentPostureConfig): DeploymentPostureSeats;
 /**
  * 部署读拒行**进场**的唯一告知点(非锚定行一行 `read_deny_unanchored_rows`;判据与行形在 `read-deny-anchor-audit.ts`)。律:**一份读拒行的值第一次装进 Runner 席时点名一次** ——
@@ -356,5 +365,17 @@ export declare function buildDeploymentPostureSeats(config: DeploymentPostureCon
  */
 export declare function announceReadDenyRows(config: Pick<ServiceConfig, "readDenyPatterns">, logger: Pick<Logger, "warn">): void;
 export declare function createSharedRunnerDeps(ctx: SharedRunnerDepsCtx): SharedRunnerDeps;
+/**
+ * 这台部署**声明本机属主的规则桶**吗(core `RunnerDeps.localOwnerRules`:不带主体的 run 经规则店的 `forLocalOwner()` 读持久规则,而不是读零规则)。
+ * 声明 ⟺ 单用户形(部署形表 `multiTenant` 不成立 —— `REQUIRE_PRINCIPAL` 未开)∧ 规则店装配了。
+ *
+ * 规则店缺席时不声明:core 把「声明了却没有可存规则的桶」当配置矛盾、在每次 prepare 整轮拒(连带主体的 run 一起),而「没有规则店」本来就是
+ * 「没有持久规则」—— 声明与店同生同灭。多租形不声明:不带主体的调用方在那里不是任何人的代表,零规则地板是对的。
+ * 单用户形上不带主体的调用方就是这台部署的那一个人(身份边界由跨键不变量 `single-user-anonymous-boundary` 守:无凭据 ∧ 写面无鉴权 ∧ 监听不只在回环 ⇒ 拒启)。
+ * 收编(adoption)把本机属主桶整桶改键到一个主体名下,收编计划同时要求 `REQUIRE_PRINCIPAL=true` ⇒ 声明随之撤回(计划表的 `core-decl` 行)。
+ *
+ * 读者两处、同读这一只:Runner 装配({@link createRunnerDeps})与运维整理阀门的写判官(`boot/stage-06-runners.ts`)。
+ */
+export declare function localOwnerRulesDeclared(config: Parameters<typeof DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds>[0], permissionRuleStore: RunnerDeps["permissionRuleStore"]): boolean;
 export declare function createRunnerDeps(ctx: RunnerDepsCtx): RunnerDeps;
 //# sourceMappingURL=runner-deps.d.ts.map

package/dist/boot/runner-deps.js

@@ -75,6 +75,9 @@ export function crossBoundaryPostureOf(requirePrincipal) {
     }
     throw new Error(`cross-boundary posture table has no word for requirePrincipal=${requirePrincipal} (the table must map both values)`);
 }
+export function buildHandsBand(config, commitCoAuthor) {
+    return { commitCoAuthor, autoBackgroundOnTimeout: config.autoBackgroundOnTimeout };
+}
 export function buildDeploymentPostureSeats(config) {
     const crossSessionLayers = buildCrossSessionInboundLayers(config);
     const lkgRows = lkgReadDenyRows(config.configLkgPath);
@@ -124,9 +127,11 @@ export function createSharedRunnerDeps(ctx) {
         mailboxStore: ctx.mailboxStore ? ctx.mailboxStore : undefined,
         rosterStore: ctx.rosterStore ? ctx.rosterStore : undefined,
         mods: ctx.deploymentMods,
-        hands: ctx.hands,
+        hands: buildHandsBand(ctx.config, ctx.commitCoAuthor),
         toolResultStore: ctx.toolResultStore,
         checkpointStore: ctx.checkpointStore ? ctx.checkpointStore : undefined,
+        fileHistoryStore: ctx.fileHistoryStore ? ctx.fileHistoryStore : undefined,
+        fileHistoryCapture: coreFileHistoryCaptureSeat(ctx.fileHistoryStore, ctx.config.fileHistoryCapture),
         sessionPolicyStore: ctx.sessionPolicyStore ? ctx.sessionPolicyStore : undefined,
         memoryScopeAdmission: ctx.orgMemoryAdmission.memoryScopeAdmission ? ctx.orgMemoryAdmission.memoryScopeAdmission : undefined,
         deploymentMemoryScopes: ctx.orgMemoryAdmission.deploymentMemoryScopes && ctx.orgMemoryAdmission.deploymentMemoryScopes.length > 0 ? ctx.orgMemoryAdmission.deploymentMemoryScopes : undefined,
@@ -142,8 +147,11 @@ export function createSharedRunnerDeps(ctx) {
     };
     return shared;
 }
+export function localOwnerRulesDeclared(config, permissionRuleStore) {
+    return permissionRuleStore !== undefined && !DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(config);
+}
 export function createRunnerDeps(ctx) {
-    const { config, logger, metrics, localRoot, outcomeSink, elicitation, question, toolApproval, sessionStore, memoryEngine, sessionCaptureRecords, memorySyncRunner, runtimeCapsResolver, fileHistoryStore, permissionRuleStore, fleetBus, workflowRunStore, workflowJournalStore, workflowAgentRegistry, workflowNotifyGate, deliverWorkflowCompletion, } = ctx;
+    const { config, logger, metrics, localRoot, outcomeSink, elicitation, question, toolApproval, sessionStore, memoryEngine, sessionCaptureRecords, memorySyncRunner, runtimeCapsResolver, permissionRuleStore, fleetBus, workflowRunStore, workflowJournalStore, workflowAgentRegistry, workflowNotifyGate, deliverWorkflowCompletion, } = ctx;
     const peerSessionLister = sessionStore.listSessionRows?.bind(sessionStore);
     const memoryEngineIncident = createMemoryEngineIncidentSink({ logger, metrics });
     const sharedRunnerDeps = createSharedRunnerDeps(ctx);
@@ -228,9 +236,8 @@ export function createRunnerDeps(ctx) {
             }
             : undefined,
         runtimeCapsResolver: runtimeCapsResolver ? runtimeCapsResolver : undefined,
-        fileHistoryStore: fileHistoryStore ? fileHistoryStore : undefined,
-        fileHistoryCapture: coreFileHistoryCaptureSeat(fileHistoryStore, config.fileHistoryCapture),
         permissionRuleStore: permissionRuleStore ? permissionRuleStore : undefined,
+        localOwnerRules: localOwnerRulesDeclared(config, permissionRuleStore),
         onBackgroundChildEvent: fleetBackgroundChildPublisher(fleetBus, (msg, fields) => logger.info(msg, fields)),
         loadProjectMemory: !DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(config) && config.projectMemoryEnabled
             ? makeLoadProjectMemory({ logger, instructionSource: createInstructionSourceSeat(sessionStore, sharedRunnerDeps.onNotice) })

package/dist/boot/runtime-caps.d.ts

@@ -9,7 +9,7 @@
  */
 import type { ServiceConfig } from "../config.js";
 import type { Logger } from "../observability/logger.js";
-import { type EntitlementsResolverFn, type MemoryOptOutVerdictSource } from "../runtime-caps-resolver.js";
+import { type EntitlementsResolverFn, type MemoryOptOutVerdictSource, type RuntimeCapsReading } from "../runtime-caps-resolver.js";
 export interface RuntimeCapsCtx {
     config: ServiceConfig;
     logger: Logger;
@@ -50,6 +50,6 @@ export declare function createRuntimeCaps(ctx: RuntimeCapsCtx): {
     principalCaps: import("../runtime-caps-resolver.js").PrincipalEntitlementsClient | undefined;
     centerRuntimeCapsResolver: ((principal: string | undefined) => Promise<import("@sema-agent/core").RuntimeCaps | undefined>) | undefined;
     runtimeCapsResolver: EntitlementsResolverFn | undefined;
-    runtimeCapsPeekResolver: EntitlementsResolverFn | undefined;
+    runtimeCapsPeekReading: ((principal: string | undefined) => Promise<RuntimeCapsReading>) | undefined;
 };
 //# sourceMappingURL=runtime-caps.d.ts.map

package/dist/boot/runtime-caps.js

@@ -73,7 +73,21 @@ export function createRuntimeCaps(ctx) {
         });
     };
     const runtimeCapsResolver = compose(centerRuntimeCapsResolver, true);
-    const runtimeCapsPeekResolver = compose(principalCaps?.peekRuntimeCaps, false);
-    return { principalCaps, centerRuntimeCapsResolver, runtimeCapsResolver, runtimeCapsPeekResolver };
+    const peekOver = (base) => compose(base, false);
+    const runtimeCapsPeekReading = peekOver(principalCaps === undefined ? undefined : async () => undefined) === undefined
+        ? undefined
+        : async (principal) => {
+            let refusedBy;
+            const base = principalCaps === undefined
+                ? undefined
+                : async (p) => {
+                    const reading = await principalCaps.peekRuntimeCapsReading(p);
+                    refusedBy = reading.autoModeRefusedBy;
+                    return reading.caps;
+                };
+            const caps = await peekOver(base)?.(principal);
+            return { caps, ...(refusedBy !== undefined ? { autoModeRefusedBy: refusedBy } : {}) };
+        };
+    return { principalCaps, centerRuntimeCapsResolver, runtimeCapsResolver, runtimeCapsPeekReading };
 }
 //# sourceMappingURL=runtime-caps.js.map

package/dist/boot/session-faces.d.ts

@@ -25,6 +25,8 @@ import { SessionWatchRegistry } from "../session-watch.js";
 import type { TaskListLane } from "./task-list-lane.js";
 import { type RunnerDeps } from "@sema-agent/core";
 import type { MailboxRecipientLifecycle } from "../plugins/mailbox-recipient-lifecycle.js";
+import { type SessionPurgeOutcome } from "../session-deletion.js";
+import { type SessionEraser, type SessionEraseSettler } from "../session-erase.js";
 import type { UserInputLedgerStore } from "../user-input-ledger.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
 export interface SessionFacesCtx {
@@ -39,6 +41,9 @@ export interface SessionFacesCtx {
     toolResultStore: ToolResultStoreFull | undefined;
     resumeAnchorStore: ReturnType<StoreBackend["resumeAnchor"]> | undefined;
     approvalExemptionStore: ReturnType<StoreBackend["approvalExemption"]> | undefined;
+    /** 审批问账(E21 级联的一条腿:挂靠被删会话的问行与它们的批随会话删)。读后端的问账本身(`backend.approvalAsk()`),**不看流内审批开关** ——
+     *  前世开着协议留下的行,今世关着也照删(与留存律 / 起服收敛同一读法)。缺席 = 本部署没有后端(纯内存 dev)⇒ 无账可删。 */
+    approvalAskStore: ReturnType<StoreBackend["approvalAsk"]> | undefined;
     sessionPolicyStore: ReturnType<StoreBackend["sessionPolicy"]> | undefined;
     taskAttachmentStore: TaskAttachmentStore | undefined;
     /** [ref]:文件历史的**擦除脸**(后端在即在,与 `FILE_HISTORY_CAPTURE` 无关;只有删除类动词)。E21 删除读它,
@@ -62,10 +67,15 @@ export interface SessionFacesCtx {
     /** k8s 车道工作区空间的回收座(配了构建缓存卷或快照存储时在场;与托管留存 sweep 同一只)—— E21 级联的一条腿:会话删了 =
      *  这位住客的空间结束了,它的缓存卷、`space/` 快照、该会话停驻车道的快照随之回收。缺席 = 本部署没有可回收的东西。 */
     spaceReclaimer?: SpaceReclaimer;
+    /** 删净会话的 **SQL 执行体**(后端的 `sessionEraser`,与留存执行器同一份选项;stage-06 铸)。缺席 = 非 SQL 后端 ⇒ 用会话店的删除锁节 + 上面各店组 local 执行体。 */
+    sessionEraser?: SessionEraser;
+    /** 删后收尾(stage-06 铸的那一只,留存 lane 同用)。缺席(测试走廊 / 嵌入形)⇒ 用本 ctx 的同几只座铸一只(同一只工厂)。 */
+    settleErasedSessions?: SessionEraseSettler;
 }
 export declare function createSessionFaces(ctx: SessionFacesCtx): {
     ownerAware: OwnerAwareSessionStore;
     sessionAudit: ((sessionId: string, opts?: SessionAuditReadOpts) => Promise<{
+        projectId?: string | undefined;
         agent?: import("../session-agent.js").SessionAgent | undefined;
         owner: string | null;
         sessionId: string;
@@ -80,13 +90,13 @@ export declare function createSessionFaces(ctx: SessionFacesCtx): {
         promptEpoch?: import("@sema-agent/core").StoredPromptEpoch;
     } | undefined>) | undefined;
     sessionWatchRegistry: SessionWatchRegistry | undefined;
-    purgeSession: ((sessionId: string, owner: string | null) => Promise<{
-        deleted: boolean;
-    } | {
-        active: string;
-    } | {
-        childrenAlive: readonly string[];
-    }>) | undefined;
+    purgeSession: ((sessionId: string, owner: string | null) => Promise<SessionPurgeOutcome>) | undefined;
+    recoverPendingDeletions: (() => Promise<ReadonlyArray<{
+        readonly sessionId: string;
+        readonly outcome: SessionPurgeOutcome | {
+            readonly failed: string;
+        };
+    }>>) | undefined;
     instrumentDegenerate: ((result: import("@sema-agent/core").TaskResult) => void) | undefined;
     planCacheProbe: PlanCacheProbe;
 };

package/dist/boot/session-faces.js

@@ -1,5 +1,6 @@
 import { buildRewindHandles, buildSessionAudit, buildSessionAuditLocal, buildSessionAuditPg } from "../audit.js";
 import { readSessionAgent } from "../session-agent.js";
+import { readSessionProjectId, sessionWorkspaceStoreOf } from "../session-workspace.js";
 import { makeDegenerateInstrument } from "../degenerate-instrument.js";
 import { PlanCacheProbe } from "../plan-cache-probe.js";
 import { purgeScratchpadDir } from "../env-facts.js";
@@ -8,19 +9,21 @@ import { setLeafAdvanceListener } from "../session-leaf-bus.js";
 import { SessionWatchRegistry, posIntEnv } from "../session-watch.js";
 import { defaultTaskRegistry, peerSessionBoxHandle } from "@sema-agent/core";
 import { reapSessionBackgroundHard } from "../background-session-reap.js";
-import { probeSessionChildren, retireSessionChildren, sessionChildrenScope, SessionChildrenStopIncompleteError } from "../session-children-retire.js";
-import { SessionActiveRunError } from "../execution-placement.js";
-import { headReadOf, redactIncarnations } from "../session-incarnation.js";
-import { recordFailOpen } from "../observability/fail-open.js";
+import { probeSessionChildren, retireSessionChildren, sessionTenantScope, SessionChildrenStopIncompleteError } from "../session-children-retire.js";
+import { SessionActiveRunError, SessionDeletionSupersededError } from "../execution-placement.js";
+import { CROSS_PROCESS_TAKEOVER_AFTER_MS, deletionTokenMintedAt } from "../session-deletion.js";
+import { createLocalSessionEraser, createSessionEraseSettler } from "../session-erase.js";
+import { headReadOf } from "../session-incarnation.js";
 import { retireSessionId } from "../deleted-session-ids.js";
 import { seatText } from "../trace/exit-seat.js";
 export function createSessionFaces(ctx) {
-    const { config, logger, metrics, localRoot, backend, sessionStore, runStore, checkpointStore, toolResultStore, resumeAnchorStore, approvalExemptionStore, sessionPolicyStore, taskAttachmentStore, fileHistoryErasure, workflowCompletionInbox, taskListLane, dropSessionScoped, mailboxStore, mailboxRecipientLifecycle, backgroundAgentStore, userInputLedgerStore, spaceReclaimer, } = ctx;
+    const { config, logger, metrics, localRoot, backend, sessionStore, runStore, checkpointStore, toolResultStore, resumeAnchorStore, approvalExemptionStore, approvalAskStore, sessionPolicyStore, taskAttachmentStore, fileHistoryErasure, workflowCompletionInbox, taskListLane, dropSessionScoped, mailboxStore, mailboxRecipientLifecycle, backgroundAgentStore, userInputLedgerStore, spaceReclaimer, } = ctx;
     const mysqlPool = backend?.mysqlPool();
     const auditPgPool = backend?.pgPool();
     const auditLocalRows = localSessionRowsOf(backend);
     const ownerAware = sessionStore;
     const headOf = headReadOf(sessionStore);
+    const workspaceStore = sessionWorkspaceStoreOf(sessionStore);
     const sessionAudit = mysqlPool || auditPgPool || auditLocalRows
         ? async (sessionId, opts) => {
             const handles = opts !== undefined && resumeAnchorStore !== undefined ? buildRewindHandles(await resumeAnchorStore.listBySession(sessionId), opts.reader) : undefined;
@@ -31,9 +34,13 @@ export function createSessionFaces(ctx) {
                     : await buildSessionAuditLocal(auditLocalRows, sessionId, handles);
             if (!audit)
                 return undefined;
-            const [head, agent] = await Promise.all([headOf?.(sessionId), opts !== undefined ? readSessionAgent(ownerAware, sessionId) : undefined]);
+            const [head, agent, projectId] = await Promise.all([
+                headOf?.(sessionId),
+                opts !== undefined ? readSessionAgent(ownerAware, sessionId) : undefined,
+                opts !== undefined ? readSessionProjectId(workspaceStore, sessionId) : undefined,
+            ]);
             const owner = head?.owner;
-            return { ...audit, owner: owner ?? null, ...(agent !== undefined ? { agent } : {}) };
+            return { ...audit, owner: owner ?? null, ...(agent !== undefined ? { agent } : {}), ...(projectId !== undefined ? { projectId } : {}) };
         }
         : undefined;
     const sessionWatchRegistry = headOf
@@ -44,113 +51,132 @@ export function createSessionFaces(ctx) {
         })
         : undefined;
     setLeafAdvanceListener(sessionWatchRegistry ? (sid, leaf, owner, seq) => sessionWatchRegistry.notifyLocal(sid, leaf, owner, seq) : undefined);
-    const purgeSession = ownerAware.deleteSession
-        ? async (sessionId, owner) => {
-            let spaceKey;
-            if (headOf) {
-                const head = await headOf(sessionId);
-                if (head?.owner !== owner)
-                    return { deleted: false };
-                spaceKey = spaceReclaimer !== undefined ? head.incarnation : undefined;
-            }
-            const childScope = sessionChildrenScope(owner);
-            const reach = await probeSessionChildren({ agentStore: backgroundAgentStore, checkpointStore, registry: defaultTaskRegistry }, sessionId, childScope);
+    const localDeletion = ownerAware.deleteSession;
+    const eraser = ctx.sessionEraser ??
+        (localDeletion !== undefined
+            ? createLocalSessionEraser((sid, owner, token, legs) => localDeletion.call(ownerAware, sid, owner, token, legs), {
+                runStore, approvalAskStore, checkpointStore, resumeAnchorStore, approvalExemptionStore, taskAttachmentStore, userInputLedgerStore, taskListLane,
+                workflowCompletionInbox, mailboxStore, toolResultStore, sessionPolicyStore, fileHistoryErasure,
+            }, logger)
+            : undefined);
+    const settle = ctx.settleErasedSessions ?? createSessionEraseSettler({ attachments: taskAttachmentStore, spaceReclaimer, logger });
+    const deletion = ownerAware.sessionDeletion;
+    const attempts = new Map();
+    const holder = (token) => attempts.get(token) ?? "elsewhere";
+    const purge = eraser !== undefined && deletion !== undefined
+        ? async (sessionId, owner, expect) => {
+            const tenantScope = sessionTenantScope(owner);
+            const reach = await probeSessionChildren({ agentStore: backgroundAgentStore, checkpointStore, registry: defaultTaskRegistry }, sessionId, tenantScope);
             if (!reach.reachable) {
                 logger.warn("session_delete_children_still_alive", { sessionId, remaining: reach.unreachableHandles.length, handles: reach.unreachableHandles });
                 return { childrenAlive: reach.unreachableHandles };
             }
-            const runs = runStore ? await runStore.deleteBySession(sessionId, owner) : { removed: 0 };
-            if ("active" in runs)
-                return { active: runs.active };
-            {
-                const children = await retireSessionChildren({ agentStore: backgroundAgentStore, checkpointStore, registry: defaultTaskRegistry }, sessionId, childScope);
-                if (children.observed.length > 0)
-                    logger.info("session_children_retired", { sessionId, found: children.observed.length, stopped: children.stopped, rounds: children.rounds });
-                if (children.stopped === "incomplete") {
-                    logger.warn("session_delete_children_stop_incomplete", { sessionId, remaining: children.remainingHandles.length, handles: children.remainingHandles });
-                    throw new SessionChildrenStopIncompleteError(sessionId, children.remainingHandles.length);
-                }
-            }
-            if (checkpointStore)
-                await checkpointStore.deleteBySession(sessionId, owner);
-            if (toolResultStore) {
-                const report = await toolResultStore.deleteBySession?.(sessionId);
-                if (report !== undefined && report.unattributable > 0) {
-                    logger.warn("tool_result_unattributable_rows_survive_session_delete", {
-                        sessionId,
-                        deleted: report.deleted,
-                        unattributable: report.unattributable,
-                    });
-                }
-            }
-            if (resumeAnchorStore)
-                await resumeAnchorStore.deleteBySession(sessionId);
-            if (approvalExemptionStore)
-                await approvalExemptionStore.deleteBySession(sessionId);
-            if (sessionPolicyStore?.deleteBySession)
-                await sessionPolicyStore.deleteBySession(sessionId);
-            if (taskAttachmentStore)
-                await taskAttachmentStore.deleteBySession(sessionId);
-            if (userInputLedgerStore)
-                await userInputLedgerStore.deleteBySession(sessionId);
-            if (taskListLane)
-                await taskListLane.deleteBySession(sessionId);
-            dropSessionScoped?.(sessionId);
-            if (fileHistoryErasure) {
-                if (typeof fileHistoryErasure.deleteBySession === "function")
-                    await fileHistoryErasure.deleteBySession(sessionId);
-                else {
-                    await fileHistoryErasure.reap(sessionId, []);
-                    logger.warn("session_file_history_baselines_retained", {
-                        sessionId,
-                        note: "this file-history store has no whole-scope erase verb (deleteBySession); boundaries were reaped but v1 baselines (original file bytes) remain in the store until it implements that verb — an open deletion-rights gap, not silent",
-                    });
-                }
-            }
-            if (workflowCompletionInbox)
-                await workflowCompletionInbox.purge(sessionId, owner ?? null).catch((err) => logger.warn("workflow_completion_inbox_purge_failed", { sessionId, err: seatText("operator-log-text", String(err)) }));
-            const peerBox = mailboxStore !== undefined && mailboxRecipientLifecycle !== undefined
-                ? { store: mailboxStore, lifecycle: mailboxRecipientLifecycle, scope: owner ?? "default", handle: peerSessionBoxHandle(sessionId) }
-                : undefined;
-            if (peerBox !== undefined) {
-                await peerBox.lifecycle.retireRecipient(peerBox.scope, peerBox.handle, Date.now());
-            }
-            await purgeScratchpadDir(config.localDataRoot ?? localRoot, sessionId);
+            let fence;
             try {
-                await reapSessionBackgroundHard(sessionId, owner ?? "default", { includeRetained: false, reason: "session_deleted" }, logger);
+                fence = await deletion.fence(sessionId, owner, expect === undefined ? { holder } : { holder, expect });
             }
             catch (err) {
-                logger.warn("session_background_reap_failed", { sessionId, err: seatText("operator-log-text", String(err)) });
+                if (err instanceof SessionActiveRunError)
+                    return { active: err.activeTaskId };
+                throw err;
             }
-            if (peerBox !== undefined)
-                await peerBox.store.drop(peerBox.scope, peerBox.handle);
-            retireSessionId(sessionId, owner, config);
-            let historyDeleted;
+            if (fence === undefined)
+                return { deleted: false };
+            if ("inProgress" in fence)
+                return { inProgress: true };
+            const { token, incarnation: spaceKey } = fence;
+            attempts.set(token, "running");
+            const step = async (leg) => {
+                if (!(await deletion.holds(sessionId, token)))
+                    throw new SessionDeletionSupersededError(sessionId);
+                return leg();
+            };
+            let trees;
             try {
-                historyDeleted = await ownerAware.deleteSession(sessionId, owner);
+                if (mailboxStore !== undefined && mailboxRecipientLifecycle !== undefined)
+                    await step(() => mailboxRecipientLifecycle.retireRecipient(tenantScope, peerSessionBoxHandle(sessionId), Date.now()));
+                await step(async () => {
+                    const children = await retireSessionChildren({ agentStore: backgroundAgentStore, checkpointStore, registry: defaultTaskRegistry }, sessionId, tenantScope);
+                    if (children.observed.length > 0)
+                        logger.info("session_children_retired", { sessionId, found: children.observed.length, stopped: children.stopped, rounds: children.rounds });
+                    if (children.stopped === "incomplete") {
+                        logger.warn("session_delete_children_stop_incomplete", { sessionId, remaining: children.remainingHandles.length, handles: children.remainingHandles });
+                        throw new SessionChildrenStopIncompleteError(sessionId, children.remainingHandles.length);
+                    }
+                });
+                await step(() => purgeScratchpadDir(config.localDataRoot ?? localRoot, sessionId));
+                await step(async () => {
+                    try {
+                        await reapSessionBackgroundHard(sessionId, tenantScope, { includeRetained: false, reason: "session_deleted" }, logger);
+                    }
+                    catch (err) {
+                        logger.warn("session_background_reap_failed", { sessionId, err: seatText("operator-log-text", String(err)) });
+                    }
+                });
+                await step(() => retireSessionId(sessionId, owner, config));
+                const receipt = await eraser.erase({ sessionId, owner, token });
+                switch (receipt.outcome) {
+                    case "superseded":
+                        throw new SessionDeletionSupersededError(sessionId);
+                    case "erased":
+                        trees = receipt.trees;
+                        break;
+                    default: {
+                        const unknownOutcome = receipt;
+                        throw new Error(`session delete: no arm for erase outcome ${JSON.stringify(unknownOutcome)}`);
+                    }
+                }
             }
             catch (err) {
-                if (err instanceof SessionActiveRunError)
-                    return { active: err.activeTaskId };
+                attempts.set(token, "ended");
+                if (err instanceof SessionDeletionSupersededError) {
+                    logger.info("session_delete_superseded", { sessionId });
+                    return { inProgress: true };
+                }
                 throw err;
             }
+            attempts.delete(token);
+            await sessionStore.forget?.(sessionId);
             sessionWatchRegistry?.dropSession(sessionId);
-            if (historyDeleted && spaceReclaimer !== undefined && spaceKey !== undefined) {
-                void spaceReclaimer.reclaim([{ sessionId, spaceKey }]).catch((err) => {
-                    recordFailOpen("server.workspace-space.reclaim-failed", "stage=seat_threw");
-                    logger.warn("workspace_space_reclaim_failed", {
-                        sessionId,
-                        stage: "seat_threw",
-                        error: seatText("operator-log-text", redactIncarnations(String(err))),
-                        effect: "the ended space's cache volume and snapshot objects may stay (the reclaim seat threw, which its contract forbids; the session delete went ahead) — the bucket's lifecycle rule is the fallback for objects, the volume is deleted by label sema.space",
-                    });
-                });
+            dropSessionScoped?.(sessionId);
+            await settle({ ...trees, sessions: [{ sessionId, owner, incarnation: spaceKey }] });
+            return { deleted: true };
+        }
+        : undefined;
+    const purgeSession = purge !== undefined ? (sessionId, owner) => purge(sessionId, owner) : undefined;
+    const recoverOne = async (sessionId, owner, token) => {
+        const unfinished = "the session stays in the deleting state (it reads as gone everywhere); the next start or a repeated DELETE by its owner finishes it";
+        try {
+            const outcome = await purge(sessionId, owner, token);
+            if ("deleted" in outcome && outcome.deleted)
+                logger.info("session_delete_recovered", { sessionId });
+            else if (!("inProgress" in outcome))
+                logger.warn("session_delete_recovery_unfinished", { sessionId, outcome: Object.keys(outcome)[0], effect: unfinished });
+            return outcome;
+        }
+        catch (err) {
+            logger.warn("session_delete_recovery_unfinished", { sessionId, outcome: "failed", err: seatText("operator-log-text", String(err)), effect: unfinished });
+            return { failed: seatText("operator-log-text", String(err)) };
+        }
+    };
+    const recoverPendingDeletions = purge !== undefined && deletion !== undefined
+        ? async () => {
+            const out = [];
+            for (const { sessionId, owner, token } of await deletion.pending()) {
+                const outcome = await recoverOne(sessionId, owner, token);
+                out.push({ sessionId, outcome });
+                if ("inProgress" in outcome) {
+                    const minted = deletionTokenMintedAt(token) ?? Date.now();
+                    const delayMs = Math.max(1_000, minted + CROSS_PROCESS_TAKEOVER_AFTER_MS - Date.now() + 1_000);
+                    logger.info("session_delete_recovery_deferred", { sessionId, delayMs, note: "another attempt may still be running this delete; it is taken over once the takeover window has passed" });
+                    setTimeout(() => void recoverOne(sessionId, owner, token), delayMs).unref?.();
+                }
             }
-            return { deleted: historyDeleted || runs.removed > 0 };
+            return out;
         }
         : undefined;
     const instrumentDegenerate = mysqlPool ? makeDegenerateInstrument(mysqlPool, metrics, logger) : undefined;
     const planCacheProbe = new PlanCacheProbe(metrics, logger);
-    return { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, instrumentDegenerate, planCacheProbe };
+    return { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, recoverPendingDeletions, instrumentDegenerate, planCacheProbe };
 }
 //# sourceMappingURL=session-faces.js.map