@sema-agent/server 7.147.0 → 7.149.0

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,6 +67,10 @@ 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;
@@ -81,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

@@ -9,14 +9,15 @@ 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);
@@ -50,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

package/dist/boot/shutdown.d.ts

@@ -18,11 +18,11 @@
  *     {@link ShutdownHandle} 摘 —— 调用方手写「摘三信号」的收尾会把双钩漏在进程上,而陈旧的那只
  *     rejection 钩仍握着 `process.exit(1)`,会对后续无关的 rejection 把进程打掉。
  */
-import { Runner, type RunnerDeps } from "@sema-agent/core";
+import { Runner, type NodeLspManager } from "@sema-agent/core";
 import type { ServiceConfig } from "../config.js";
 import type { createHttpServer } from "../http/server.js";
 import type { RetentionLaneController } from "./retention-lane.js";
-import type { Logger } from "../observability/logger.js";
+import { type Logger } from "../observability/logger.js";
 import type { startOtlpExporter } from "../observability/otel-exporter.js";
 import type { CostQuota } from "../observability/cost-quota.js";
 import type { RateLimiter } from "../observability/rate-limit.js";
@@ -61,7 +61,8 @@ export interface ShutdownCtx {
     rateLimiter: RateLimiter | RateLimiterStore | undefined;
     runner: Runner;
     subRunner: Runner;
-    lspManager: RunnerDeps["lspManager"];
+    /** 铸点 `createLspManager` 的返回值(本机语言服务器管理器;缺席 = 这台部署不挂)。 */
+    lspManager: NodeLspManager | undefined;
     workflowNotifyJournal: WorkflowNotifyJournalStore | undefined;
     fleetClient: ReturnType<typeof startFleetClientFromConfig>;
     backend: StoreBackend | undefined;
@@ -83,7 +84,7 @@ export interface ShutdownCtx {
     /** [ref]-2:config 60s 刷新环(web-admin startRefreshLoop)——不停的话停机中途还可能热应用
      *  一份新配置。缺席 = 纯 env 部署没起环。 */
     webAdmin: {
-        stopRefreshLoop(): void;
+        stopRefreshLoop(): Promise<void>;
     } | undefined;
     /** [ref]:活体审批协调器(`TOOL_APPROVAL_ENABLED` 关 ⇒ 缺席)。hardShutdown 起点调它的 `drainForShutdown`:本进程握着的活卡
      *  按断连同路收场、审计留有序关停记号 —— 否则下一次 boot 把有序重启读成崩溃(`crashed_before_park`)。 */

package/dist/boot/shutdown.js

@@ -1,4 +1,5 @@
 import { Runner } from "@sema-agent/core";
+import { writeLogText } from "../observability/logger.js";
 import { writeCrashLast, clearCrashLast, readCrashLast } from "./crash-last.js";
 import { createSighupIdleHandler } from "../sighup-idle.js";
 import { createParentWatch } from "../parent-watch.js";
@@ -56,7 +57,7 @@ export function installShutdownHandlers(ctx) {
     const onUncaughtException = (err) => {
         try {
             writeLastWords(err);
-            console.error(err);
+            writeLogText("stderr", err);
         }
         finally {
             process.exit(1);
@@ -74,7 +75,7 @@ export function installShutdownHandlers(ctx) {
         }
         try {
             writeLastWords(err);
-            console.error(err);
+            writeLogText("stderr", err);
         }
         finally {
             process.exit(1);
@@ -136,12 +137,12 @@ export function installShutdownHandlers(ctx) {
         storeLiveProbe?.stop();
         servingLease?.stop();
         void deviceHub?.close().catch((err) => logger.warn("device_hub_close_failed", { err: seatText("operator-log-text", String(err)) }));
-        webAdmin?.stopRefreshLoop();
+        const credentialSettled = webAdmin?.stopRefreshLoop() ?? Promise.resolve();
         otelExporter?.stop();
         breakerState?.stop();
         runner.sessions.dispose();
         subRunner.sessions.dispose();
-        void lspManager?.dispose?.();
+        void lspManager?.dispose();
         void workflowNotifyJournal?.close?.();
         const backgroundSoftStopped = exitBoundary.reapChildProcessesEarly();
         const softStoppedAt = Date.now();
@@ -164,6 +165,7 @@ export function installShutdownHandlers(ctx) {
             void Promise.all([retentionTeardown, ledgerStopped])
                 .then(() => (backend ? backend.close() : Promise.resolve()))
                 .then(() => routingStopped)
+                .finally(() => credentialSettled)
                 .finally(() => backgroundGrace)
                 .finally(() => process.exit(0));
         });

package/dist/boot/stage-01-config.d.ts

@@ -1,5 +1,6 @@
 export declare function runStage01(): {
     config: import("../config-types.js").LoadedConfig;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../observability/logger.js").Logger;
     metrics: import("../observability/metrics.js").Metrics;

package/dist/boot/stage-01-config.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { loadConfig, logConfigDiagnostics, splitLocalRoots } from "../config.js";
 import { configLocalRoot } from "../config-provider.js";
-import { operatorDeclarationRefusal, runStaleHeartbeatRefusal } from "../config-invariants.js";
+import { operatorDeclarationRefusal, operatorSingleUserBoundaryRefusal, runStaleHeartbeatRefusal, singleUserAnonymousBoundaryRefusal } from "../config-invariants.js";
 import { drainNumEnvWarnings } from "../plugins/remote-shell.js";
 import { setWebSearchBadPayloadObserver } from "../plugins/web-search.js";
 import { createLogger } from "../observability/logger.js";
@@ -13,8 +13,9 @@ import { installSecretEnvScrubRecorder } from "../observability/secret-env-scrub
 import { setRunTerminalLogObserver } from "../observability/run-terminal.js";
 import { setRedactionObserver } from "../trace/redact.js";
 import { installOutboundDispatcher } from "../outbound-dispatcher.js";
-import { provisionSemaConfigDir } from "../sema-config-dir.js";
 import { bindOwnCredentialsConfig, declareServerWithheldEnv } from "../server-secret-env.js";
+import { admitLocalDataRoot } from "../plugins/local-data-root-admission.js";
+import { localBackendRootOf } from "../plugins/store-backend.js";
 import { installDefaultEngineNoticeSeat } from "./runner-deps.js";
 export function runStage01() {
     declareServerWithheldEnv();
@@ -28,6 +29,14 @@ export function runStage01() {
     if (operatorDeclarationFailure !== undefined) {
         throw new Error(operatorDeclarationFailure);
     }
+    const anonymousBoundaryFailure = singleUserAnonymousBoundaryRefusal(config);
+    if (anonymousBoundaryFailure !== undefined) {
+        throw new Error(anonymousBoundaryFailure);
+    }
+    const singleUserBoundaryFailure = operatorSingleUserBoundaryRefusal(config);
+    if (singleUserBoundaryFailure !== undefined) {
+        throw new Error(singleUserBoundaryFailure);
+    }
     const logger = createLogger(config.logLevel);
     const metrics = createMetrics();
     installFailOpenRecorder({ logger, metrics, redactDetail: redactSecrets });
@@ -54,7 +63,7 @@ export function runStage01() {
         else
             logger.info("run_failed", fields);
     });
-    provisionSemaConfigDir(config, logger);
+    const localAdmission = config.dbBackend === "local" ? admitLocalDataRoot(localBackendRootOf(config)) : undefined;
     const localRoot = configLocalRoot(config);
     const rootsSplit = splitLocalRoots({
         localDataRoot: config.localDataRoot,
@@ -69,6 +78,6 @@ export function runStage01() {
         });
     }
     installOutboundDispatcher(logger);
-    return { config, localRoot, logger, metrics };
+    return { config, localAdmission, localRoot, logger, metrics };
 }
 //# sourceMappingURL=stage-01-config.js.map

package/dist/boot/stage-02-web-admin-pull.d.ts

@@ -2,7 +2,9 @@ import type { runStage01 } from "./stage-01-config.js";
 export declare function runStage02(ctx: Awaited<ReturnType<typeof runStage01>>): Promise<{
     config: import("../config-types.js").ServiceConfig;
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
+    storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-02-web-admin-pull.js

@@ -2,6 +2,8 @@ import { createUnpricedCeilingVerdict } from "./unpriced-ceiling-verdict.js";
 import { createWebAdminRuntime } from "./web-admin.js";
 import { composeExecutionLane, HTTP_SERVICE_LANE_ENTRY } from "./execution-lane.js";
 import { configSourceKind } from "../config-provider.js";
+import { announceConfigRootEnclosingWorkspace } from "../sema-config-dir.js";
+import { launchWorkspaceOf } from "../task-cwd.js";
 import { buildCandidateRejectionNotes } from "../web-admin-client/candidate-gate.js";
 import { logConfigDirMigration, migrateLocalConfigDirectory } from "../config-d-migration.js";
 import { logEnvModelsMigration, runEnvModelsMigration } from "../config-root-migration.js";
@@ -10,16 +12,26 @@ import { defaultModelRefusal, refusedNameMintedRefusal } from "../model-entry-re
 import { isRosterGateArmed } from "../config.js";
 import { judgeServedModelRoute } from "../model-route-endpoint.js";
 import { servedModelTableLeg } from "../model-select.js";
+import { warnAssumedContextWindows } from "../context-window-notice.js";
+import { captureBootStoreEvidence } from "./store-evidence.js";
+import { admitStoreDurability } from "../store-admission.js";
+import { provisionSemaConfigDir } from "../sema-config-dir.js";
 export async function runStage02(ctx) {
     const { config: loaded, localRoot, logger, metrics } = ctx;
+    const storeEvidence = await captureBootStoreEvidence({ config: loaded, localRoot });
     const configSource = configSourceKind(loaded);
     if (configSource === "local") {
         await assertLocalConfigDirTrusted({ root: localRoot, declaredOwnerUid: loaded.configLocalOwnerUid });
-        const envModelsMigration = { root: localRoot, env: process.env, envTableIsPlaceholder: isRosterGateArmed(loaded.webAdmin) };
-        logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
         logConfigDirMigration(logger, await migrateLocalConfigDirectory(localRoot));
     }
     const config = await composeExecutionLane(loaded, { configSource, localRoot, logger, entry: HTTP_SERVICE_LANE_ENTRY });
+    admitStoreDurability(config, storeEvidence);
+    provisionSemaConfigDir(config, logger);
+    if (configSource === "local") {
+        const envModelsMigration = { root: localRoot, env: process.env, envTableIsPlaceholder: isRosterGateArmed(config.webAdmin) };
+        logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
+    }
+    announceConfigRootEnclosingWorkspace(config, logger, launchWorkspaceOf(config));
     const webAdmin = await createWebAdminRuntime({ config, logger, metrics, localRoot });
     const servedLeg = servedModelTableLeg(config);
     const rejection = webAdmin.candidateRejectionState();
@@ -35,8 +47,9 @@ export async function runStage02(ctx) {
     if (mintedRefused !== undefined) {
         throw new Error(mintedRefused);
     }
+    warnAssumedContextWindows(config, logger, { envTableIsPlaceholder: isRosterGateArmed(config.webAdmin) });
     const ceilingVerdict = createUnpricedCeilingVerdict({ config, logger });
     ceilingVerdict.judge();
-    return { ...ctx, config, ceilingVerdict, webAdmin };
+    return { ...ctx, config, ceilingVerdict, storeEvidence, webAdmin };
 }
 //# sourceMappingURL=stage-02-web-admin-pull.js.map

package/dist/boot/stage-03-store-backend.d.ts

@@ -1,5 +1,7 @@
 import type { runStage02 } from "./stage-02-web-admin-pull.js";
+import type { AdoptionWiring } from "../adoption/plan.js";
 export declare function runStage03(ctx: Awaited<ReturnType<typeof runStage02>>): Promise<{
+    adoptionWiring: AdoptionWiring;
     backend: import("../index.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
@@ -26,7 +28,9 @@ export declare function runStage03(ctx: Awaited<ReturnType<typeof runStage02>>):
     usageWindowStore: import("@sema-agent/core").UsageWindowStore | undefined;
     config: import("../config-types.js").ServiceConfig;
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
+    storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-03-store-backend.js

@@ -1,9 +1,10 @@
 import { uuidv7 } from "@sema-agent/core";
 import { openStores } from "./stores.js";
 export async function runStage03(ctx) {
-    const { config, localRoot, logger, metrics } = ctx;
-    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, sessionCaptureRecords, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportStores, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, storeSweep, } = await openStores({ config, logger, metrics, localRoot });
+    const { config, localAdmission, localRoot, logger, metrics, storeEvidence } = ctx;
+    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, sessionCaptureRecords, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportStores, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, storeSweep, } = await openStores({ config, logger, metrics, localRoot, storeEvidence, localAdmission });
+    const adoptionWiring = { memoryEngine: memoryExportStores !== undefined, taskAttachment: taskAttachmentStore !== undefined };
     const instanceId = uuidv7();
-    return { ...ctx, backend, backgroundAgentStore, breakerState, engineDataRoot, instanceId, mailboxRecipientLifecycle, mailboxStore, memoryEngine, memoryExportStores, memoryPosture, memorySyncCursors, memorySyncRunner, rosterStore, sessionCaptureRecords, sessionStore, sqlEngine, storePosture, storeSweep, taskAttachmentStore, taskListLane, usageWindowStore };
+    return { ...ctx, adoptionWiring, backend, backgroundAgentStore, breakerState, engineDataRoot, instanceId, mailboxRecipientLifecycle, mailboxStore, memoryEngine, memoryExportStores, memoryPosture, memorySyncCursors, memorySyncRunner, rosterStore, sessionCaptureRecords, sessionStore, sqlEngine, storePosture, storeSweep, taskAttachmentStore, taskListLane, usageWindowStore };
 }
 //# sourceMappingURL=stage-03-store-backend.js.map

package/dist/boot/stage-04-stores.d.ts

@@ -30,6 +30,7 @@ export declare function runStage04(ctx: Awaited<ReturnType<typeof runStage03>>):
     sideQueryAccounting: import("../budget.js").SideQueryAccounting;
     toolResultStore: import("@sema-agent/core").ToolResultStore | undefined;
     tracer: import("@sema-agent/core").TracerHook;
+    adoptionWiring: import("../adoption/plan.js").AdoptionWiring;
     backend: import("../index.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
@@ -56,7 +57,9 @@ export declare function runStage04(ctx: Awaited<ReturnType<typeof runStage03>>):
     usageWindowStore: import("@sema-agent/core").UsageWindowStore | undefined;
     config: import("../config-types.js").ServiceConfig;
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
+    storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-04-stores.js

@@ -8,7 +8,7 @@ import { createRuleConsentLane } from "../rules-consent.js";
 import { createConsolidationValve } from "./memory-consolidation.js";
 import { createOperatorFaceIncidentSink } from "../memory-incident-sink.js";
 export async function runStage04(ctx) {
-    const { backend, breakerState, config, logger, memoryEngine, metrics } = ctx;
+    const { adoptionWiring, backend, breakerState, config, logger, memoryEngine, metrics } = ctx;
     const memoryBundleFaces = memoryEngine ? createMemoryBundleFaces(memoryEngine) : undefined;
     const memoryComplianceFaces = memoryEngine
         ? createMemoryComplianceFaces(memoryEngine, {
@@ -24,7 +24,7 @@ export async function runStage04(ctx) {
         ? createSessionMemoryStatusFace(memoryEngine)
         : undefined;
     const { valve: consolidationValve, watch: consolidationSeatWatch } = createConsolidationValve({ config, memoryEngine, logger });
-    const adoptionBoot = await runAdoptionBootScan({ backend, logger });
+    const adoptionBoot = await runAdoptionBootScan({ backend, logger, wiring: adoptionWiring });
     if (adoptionBoot.scanned > 0 || adoptionBoot.error !== undefined) {
         logger.info("adoption_boot_scan", { ...adoptionBoot });
     }

package/dist/boot/stage-05-execution-env.d.ts

@@ -6,13 +6,15 @@ export declare function runStage05(ctx: Awaited<ReturnType<typeof runStage04>>):
     deviceLane: import("./device-lane.js").DeviceLane | undefined;
     peerDesk: import("../peer-seat.js").PeerDesk;
     dropSessionScoped: (sid: string) => void;
+    dropSessionScopedOf: (sid: string, incarnation: string) => boolean;
     executionEnvFactory: import("@sema-agent/core").ExecutionEnvFactory | undefined;
-    fenceSessionOwner: (sid: string, owner: string | null) => void;
+    fenceSessionOwner: (sid: string, owner: string | null, incarnation?: string) => void;
     sessionResidentBackground: () => import("../session-resident-background.js").SessionResidentCounts;
-    lspManager: import("@sema-agent/core").NodeLspManager | import("../lsp/manager.js").E2bLspManager | undefined;
+    lspManager: import("@sema-agent/core").NodeLspManager | undefined;
     spaceReclaimer: import("../workspace-space.js").SpaceReclaimer | undefined;
-    sandboxPodReaper: import("../plugins/k8s-pod-reaper.js").SandboxPodReaper | undefined;
+    sandboxReaper: import("../plugins/sandbox-reaper.js").SandboxReaper | undefined;
     sandboxGitPlane: () => import("../sandbox-git-plane.js").SandboxGitPlane;
+    sandboxCapacity: import("../plugins/local-docker-capacity.js").LocalDockerCapacity | undefined;
     perSessionCwd: Map<string, string>;
     perTaskImage: import("../per-task-image.js").PerTaskImageRegistry;
     sendUserFileTaskEnvs: import("../capabilities/sandbox-file-send.js").TaskEnvRegistry | undefined;
@@ -51,6 +53,7 @@ export declare function runStage05(ctx: Awaited<ReturnType<typeof runStage04>>):
     sideQueryAccounting: import("../budget.js").SideQueryAccounting;
     toolResultStore: import("@sema-agent/core").ToolResultStore | undefined;
     tracer: import("@sema-agent/core").TracerHook;
+    adoptionWiring: import("../adoption/plan.js").AdoptionWiring;
     backend: import("../index.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
@@ -77,7 +80,9 @@ export declare function runStage05(ctx: Awaited<ReturnType<typeof runStage04>>):
     usageWindowStore: import("@sema-agent/core").UsageWindowStore | undefined;
     config: import("../config-types.js").ServiceConfig;
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
+    storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;