@sema-agent/server 7.145.0 → 7.147.0

package/dist/config.js

@@ -3,7 +3,7 @@ import { DEFAULT_AT_MENTION, DEFAULT_MODEL_REF, mintCapabilityKeys } from "./mod
 import { homedir } from "node:os";
 import { isAbsolute, join, posix as posixPath } from "node:path";
 import { fileURLToPath } from "node:url";
-import { compileAllowList, inheritEnvPolicyProblem, BUILTIN_COMPLIANCE_DENIES, COMPLIANCE_CAPABILITIES, CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES, compileReadDeny, resolveReadDenyBuiltins, isModelPriced, PROTOCOL_TABLE, RECOMMENDED_SENSITIVE_PATTERNS, judgeRuleToolName, resolveFileHistoryRetention, resolveLockedKeys, validatePermissionRules, WRITE_PROTECTED_DEFAULT_TABLE, resolveWriteProtectedTable, principalInboxConsumerOf, carriesCredential } from "@sema-agent/core";
+import { compileAllowList, inheritEnvPolicyProblem, BUILTIN_COMPLIANCE_DENIES, COMPLIANCE_CAPABILITIES, CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES, compileReadDeny, resolveReadDenyBuiltins, isModelPriced, PROTOCOL_TABLE, RECOMMENDED_SENSITIVE_PATTERNS, judgeRuleToolName, resolveFileHistoryRetention, resolveLockedKeys, validatePermissionRules, WRITE_PROTECTED_DEFAULT_TABLE, resolveWriteProtectedTable, principalInboxConsumerOf, carriesCredential, isReplicableScope, resolveBashTimeoutCaps } from "@sema-agent/core";
 import { ROSTER_PRIMARY_ROLES, ROSTER_CHEAP_ROLES, WEB_ADMIN_ENV, retiredEnvRefusal, stripControlAndBidi } from "@sema-agent/settings-schema";
 import { parseApprovalHmacKeys, parsePrincipalJwks } from "./auth-keys.js";
 import { DEFAULT_ELICITATION_THROTTLE } from "./elicitation.js";
@@ -11,11 +11,13 @@ import { buildRuleListJudgeOptions } from "./permission-rule-list.js";
 import { isV2ScopeKey, memoryReplicationCoverage, replicatesProjectLayersOf } from "./memory-scope.js";
 import { memorySyncPeerOf } from "./memory-sync-client.js";
 import { buildMemorySyncIdentityBootRefusal, declaredMemorySyncIdentityFlaw } from "./memory-sync-identity.js";
+import { formatEmbedderIdentityToken, formatReembedAssignment, parseEmbedderIdentityToken } from "./memory-embedder-reembed.js";
 import { assertProjectLayerOwnable } from "./project-identity.js";
 import { projectLayerOwnerOf } from "./project-layer-key.js";
 import { DEFAULT_QUESTION_THROTTLE } from "./question.js";
 import { GIT_API_KINDS, isGitApiKind } from "./git-api-kind.js";
 import { CONFIG_PROVIDER_WORDS, RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC, RESILIENCE_DEFAULTS, TASK_WRITE_FACE_ESCALATIONS, MAX_TIMER_DELAY_MS, AUTO_MODE_CLASSIFIER_TIMEOUT_BOUNDS, DRAIN_GRACE_FLOOR_MS, DRAIN_SECOND_SIGNAL_MIN_GAP_BOUNDS, DRAIN_SECOND_SIGNAL_MIN_GAP_DEFAULT_MS, FIRST_BYTE_TIMEOUT_BOUNDS, FLEET_LEASE_OUTAGE_MAX_DEFAULT_MS, fleetScopeOf, DEVICE_DELIVERY_TIMEOUT_BOUNDS, DEVICE_EXEC_TIMEOUT_BOUNDS, inWholeNumberBounds, wholeNumberBoundsRule } from "./config-types.js";
+import { parseTrustedProxyCidr } from "./net-address.js";
 import { DEVICE_HELLO_ACK_BOUNDS } from "./device-ws-protocol.js";
 import { FLEET_ADVERTISE_ADDRESS_ENV, FLEET_GENERATION_ENV, FLEET_SCOPE_ENV, SERVING_LEASE_TTL_FLOOR_MS, isCanonicalGeneration } from "@sema-agent/settings-schema/fleet";
 import { ScopeId } from "@sema-agent/settings-schema/api/scopes";
@@ -23,11 +25,10 @@ import { centerLaneConfigured, pathBaseUrlRefusal } from "./web-admin-client/cen
 import { resolveLocalDataRoot } from "./local-data-root.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { normalizeSshFingerprint } from "./ssh-host-key.js";
-import { buildReadFacePostureNotice, settleDerivedReadFace } from "./read-face-posture.js";
 import { THINKING_LEVELS, THINKING_FORMATS, buildModelCompat, isThinkingFormat, isThinkingTier } from "./model-compat.js";
 import {} from "./posture-source.js";
 import { COST_QUOTA_WINDOW_SEC_RANGE, costQuotaWindowSecInRange } from "./observability/cost-quota.js";
-import { NAME_TABLE_BEHAVIOR, TOOL_NAME_ROSTER, describeUnmatchableRuleName, ruleEntryToolName, unmatchableRuleNameOf } from "./namespaced-rule-name.js";
+import { NAME_TABLE_BEHAVIOR, TOOL_NAME_ROSTER, describeUnmatchableRuleName, isRetiredWithoutSuccessor, retiredWithoutSuccessorEntries, ruleEntryToolName, unmatchableRuleNameOf } from "./namespaced-rule-name.js";
 import { bakeOperatorPrincipalsRefusal, bakeRunnerCredentialRefusal, centerIdentityRefusal, halfOpenDirectDoorRefusal, leaderDurableStoreRefusal, operatorPrincipalsRequiredRefusal, operatorSingleUserRefusal, remoteConfigProviderUrlRefusal, retentionLaneRefusal, workflowParkDecisionDomainRefusal } from "./config-invariants.js";
 import { declaredSemaConfigDir } from "./sema-config-dir.js";
 import { lkgPathOverrideOf } from "./config-lkg.js";
@@ -38,7 +39,7 @@ import { SANDBOX_IPV6_DEFAULT, SANDBOX_IPV6_WORDS } from "./sandbox-egress-polic
 import { WORKSPACE_CACHE_DEFAULT, WORKSPACE_CACHE_MOUNT_DEFAULT, WORKSPACE_CACHE_MOUNT_RESERVED, WORKSPACE_CACHE_SIZE_DEFAULT, WORKSPACE_CACHE_WORDS, isK8sQuantity, mountsOverlap, reservedMountCollision } from "./workspace-cache.js";
 import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 import { sandboxForwardedEnvOf } from "./execution-config-root.js";
-import { SANDBOX_READ_FLOOR_DEFAULT, SANDBOX_READ_FLOOR_WORDS, executionLaneOf, executionLaneRequiredRefusal, laneMissingEnv, readDeclaredLaneTable } from "./execution-lane-caps.js";
+import { SANDBOX_READ_FLOOR_DEFAULT, SANDBOX_READ_FLOOR_WORDS, laneMissingEnv, readDeclaredLaneTable } from "./execution-lane-caps.js";
 import { MEMORY_ENGINE_BACKENDS, SESSION_BACKENDS, STORE_BACKENDS } from "@sema-agent/settings-schema/execution-lanes";
 import { AUTONOMY_MODES } from "./runtime-governance.js";
 import { MAX_NAMED_INERT_ENTRIES, allowLayerEntryCountIssue, describeInertRuleEntries, inertRuleEntriesOf, inertRuleEntryGuidance, ruleEntryListShapeOk } from "./rule-entry-list.js";
@@ -59,6 +60,7 @@ import { allowlistedEnv } from "./server-secret-env.js";
 import { ENV_NAME_ALLOWLIST_KNOBS, ENV_NAME_ALLOWLIST_KNOB_NAMES, describeAllowlistPostures } from "./env-name-allowlist-knobs.js";
 import { APPROVAL_ASK_RETENTION_DEFAULT_MS, APPROVAL_ASK_RETENTION_FLOOR_MS } from "./approval-ask-retention.js";
 import { parseModsDeclaration } from "./mods-declaration.js";
+import { ADOPTION_IMPORT_MAX_SESSIONS_DEFAULT, ADOPTION_IMPORT_MAX_SESSIONS_FLOOR, ADOPTION_IMPORT_MAX_SESSION_BYTES_CEILING, ADOPTION_IMPORT_MAX_SESSION_BYTES_DEFAULT, ADOPTION_IMPORT_MAX_SESSION_BYTES_FLOOR } from "./adoption/import-limits.js";
 import { buildDeclaredEngineWithoutCoordinatesRefusal, missingSqlCoordinateKeys } from "./sql-engine-coordinates.js";
 export { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC } from "./config-types.js";
 function csv(name) {
@@ -190,14 +192,6 @@ const CONFIG_NOTICES = [];
 export function drainConfigNotices() {
     return CONFIG_NOTICES.splice(0, CONFIG_NOTICES.length);
 }
-let EXEC_LANE_NOTICE;
-function buildExecLaneNotice(remoteExec) {
-    const lane = executionLaneOf(remoteExec?.provider);
-    return {
-        lane,
-        source: lane === "in-process" ? "default-unset" : DEPLOYMENT_SHAPE_PREDICATES.singleMachineDefaultLane.holds({ remoteExec }) ? "default-local-provider" : "explicit-env",
-    };
-}
 const ENV_VALUE_ECHO_CHARS = 120;
 export function parseConfigProvider() {
     const raw = process.env.CONFIG_PROVIDER;
@@ -206,7 +200,7 @@ export function parseConfigProvider() {
     const word = CONFIG_PROVIDER_WORDS.find((w) => w === raw);
     if (word === undefined) {
         throw new Error(`env CONFIG_PROVIDER="${echoCallerText(raw, { maxChars: ENV_VALUE_ECHO_CHARS })}" must be one of: ${CONFIG_PROVIDER_WORDS.join(", ")} — or leave it unset (then ${WEB_ADMIN_ENV.url}, if set, selects the center as the config source; otherwise this worker is env-only). ` +
-            `The word is matched exactly (no trimming, no case folding). Refusing to boot rather than guessing: the config source, the execution-lane default and the local config root all key on this one word.`);
+            `The word is matched exactly (no trimming, no case folding). Refusing to boot rather than guessing: the config source and the local config root both key on this one word.`);
     }
     return word;
 }
@@ -252,10 +246,6 @@ export function logConfigDiagnostics(logger) {
             }
         }
     }
-    const laneNotice = EXEC_LANE_NOTICE;
-    EXEC_LANE_NOTICE = undefined;
-    if (laneNotice && logger.info)
-        logger.info("exec_lane_selected", { lane: laneNotice.lane, source: laneNotice.source });
     if (logger.debug) {
         for (const k of configKnobTable()) {
             logger.debug("config_knob_polarity", {
@@ -274,6 +264,11 @@ function clampEnvWithWarn(name, fallback, min, max = Number.POSITIVE_INFINITY) {
         CONFIG_WARNINGS.push({ env: name, raw: env(name, fallback), used: String(used), kind: "clamped" });
     return used;
 }
+function countEnvClamped(name, fallback, min, max = Number.POSITIVE_INFINITY) {
+    if (!Number.isInteger(numEnv(name, String(fallback))))
+        throw new Error(`env ${name}=${env(name, String(fallback))} must be a whole number (it is a count)`);
+    return clampEnvWithWarn(name, String(fallback), min, max);
+}
 function numEnvOr(name, fallback) {
     const raw = process.env[name];
     if (raw === undefined || raw === "")
@@ -400,8 +395,21 @@ function parseDeviceRelayUrlEnv(raw) {
     }
     return { kind: "url", url: raw };
 }
+export function entryDeclarableRemoteExec(lane) {
+    switch (lane) {
+        case "host":
+            return {
+                provider: "host",
+                ...(process.env.HOST_WORKSPACE_BASE ? { workspaceBase: process.env.HOST_WORKSPACE_BASE } : {}),
+                ...((n) => (n !== undefined ? { commandTimeoutMs: n } : {}))(optNumEnvStrict("HOST_COMMAND_TIMEOUT_MS")),
+            };
+        case "none":
+            return { provider: "none" };
+    }
+}
+const envNamesNoLane = (raw) => raw === undefined || raw === "";
 function declaredExecutionLane(raw) {
-    if (raw === undefined || raw === "")
+    if (envNamesNoLane(raw))
         return undefined;
     const table = readDeclaredLaneTable(raw);
     if ("refusal" in table)
@@ -415,7 +423,7 @@ function declaredExecutionLane(raw) {
     const missing = laneMissingEnv(lane, process.env);
     if (missing.length > 0) {
         throw new Error(`REMOTE_EXEC=${lane} but required env ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} unset, empty or whitespace-only — it counts as absent: ` +
-            `refusing to start rather than silently downgrading to the host/in-process lane (#157; set ${missing.length === 1 ? "it" : "them"}, or unset REMOTE_EXEC if you meant no sandbox lane).`);
+            `refusing to start rather than silently running on another lane (#157; set ${missing.length === 1 ? "it" : "them"}, or declare REMOTE_EXEC=none if the agent's tools need no execution environment).`);
     }
     return lane;
 }
@@ -439,6 +447,19 @@ function parseDevicePreAuthPerRemoteEnv() {
     }
     return n;
 }
+function parseDeviceTrustedProxyCidrsEnv(raw) {
+    if (raw === undefined || raw === "")
+        return undefined;
+    const items = raw.split(",").map((item) => item.replace(/^[ \t]+|[ \t]+$/g, ""));
+    return items.map((item, i) => {
+        const r = parseTrustedProxyCidr(item);
+        if (r.ok)
+            return r.text;
+        throw new Error(`env DEVICE_TRUSTED_PROXY_CIDRS item ${i + 1} of ${items.length} (${JSON.stringify(item)}) ${r.flaw}. ` +
+            `This list names the reverse proxies whose X-Forwarded-For the device pre-auth cap trusts — list only your own proxies, comma-separated ` +
+            `(e.g. 10.0.0.0/8,fd00::/8); unset it to read no proxy header at all (the cap is then keyed on the socket peer).`);
+    });
+}
 function parseFileHistoryRetention() {
     const raw = process.env.FILE_HISTORY_RETENTION_KEEP;
     if (raw === undefined || raw === "")
@@ -543,9 +564,9 @@ function ownCredentialNameProblem(name, channel) {
 }
 const NAMES_IN_FORCE = {
     LSP_ENV_ALLOW: (c) => c.lspEnvAllow,
-    E2B_SANDBOX_ENV: (c) => (c.remoteExec?.provider === "e2b" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
-    K8S_SANDBOX_ENV: (c) => (c.remoteExec?.provider === "k8s" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
-    DOCKER_SANDBOX_ENV: (c) => (c.remoteExec?.provider === "local-docker" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
+    E2B_SANDBOX_ENV: (c) => (c.remoteExec.provider === "e2b" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
+    K8S_SANDBOX_ENV: (c) => (c.remoteExec.provider === "k8s" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
+    DOCKER_SANDBOX_ENV: (c) => (c.remoteExec.provider === "local-docker" ? Object.keys(sandboxForwardedEnvOf(c)) : []),
 };
 const SERVER_ENV_NAME_ALLOWLIST_KNOBS = Object.keys(NAMES_IN_FORCE);
 export function sandboxEnvNamesInForce(seats) {
@@ -1040,16 +1061,17 @@ function parseModelDomain() {
     }
     const extraBody = buildExtraBody();
     const thinkingDefault = parseDefaultThinking(process.env.MODEL_DEFAULT_THINKING);
-    const envCompatDeclared = buildModelCompat({
+    const envApi = provider === "anthropic" ? "anthropic-messages" : "openai-completions";
+    const envCompatDeclared = buildModelCompat("openai-completions", {
         reasoningEffortLevels: parseReasoningEffortLevels(csv("MODEL_REASONING_EFFORT_LEVELS")),
         thinkingFormat: parseThinkingFormat(process.env.MODEL_THINKING_FORMAT),
     });
-    const envCompat = provider === "anthropic" ? undefined : envCompatDeclared;
+    const envCompat = envApi === "openai-completions" ? envCompatDeclared : undefined;
     const modelCapability = { reasoning: parseBoolWord("MODEL_REASONING", process.env.MODEL_REASONING), vision: parseBoolWord("MODEL_VISION", process.env.MODEL_VISION) };
     const model = {
         id: modelId,
         name: modelId,
-        api: provider === "anthropic" ? "anthropic-messages" : "openai-completions",
+        api: envApi,
         provider,
         baseUrl: "",
         ...mintCapabilityKeys(modelCapability),
@@ -1292,7 +1314,8 @@ function findUnmatchableToolNames(names, opts) {
             }
         }
         const subject = opts.consumer === "tool-name-table" ? name : ruleEntryToolName(name);
-        const verdict = unmatchableRuleNameOf(subject, opts.behavior);
+        const judged = unmatchableRuleNameOf(subject, opts.behavior);
+        const verdict = opts.noticeSeat !== undefined && isRetiredWithoutSuccessor(judged) ? undefined : judged;
         if (verdict?.kind === "retired") {
             out.push({ name, guidance: describeUnmatchableRuleName(verdict, subject), reason: verdict.kind });
             continue;
@@ -1405,9 +1428,21 @@ function parseApprovalDomain(ctx) {
     const dgHmacKeys = parseApprovalHmacKeys(process.env.APPROVAL_HMAC_KEYS, announceKeySetRejection("APPROVAL_HMAC_KEYS"));
     const durableApproval = postureOn("DURABLE_APPROVAL", infraReady);
     const rejectUnmatchableToolNames = (envName, names) => {
-        const unmatchable = unmatchableToolNamesRefusal(envName, names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR });
+        const unmatchable = unmatchableToolNamesRefusal(envName, names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR, noticeSeat: "server" });
         if (unmatchable !== undefined)
             throw new Error(unmatchable.message);
+        const skipped = retiredWithoutSuccessorEntries(names, NAME_TABLE_BEHAVIOR);
+        if (skipped.length > 0) {
+            CONFIG_NOTICES.push({
+                level: "warn",
+                event: "approval_list_legacy_tool_name",
+                fields: {
+                    env: envName,
+                    entries: JSON.stringify(skipped.map((s) => s.entry)),
+                    note: `${skipped.map((s) => `${displayListEntry(s.entry)} (${s.guidance})`).join("; ")} — ${skipped.length === 1 ? "a tool name" : "tool names"} the engine retired with no successor: ${skipped.length === 1 ? "it reaches" : "they reach"} no tool this server knows, so ${skipped.length === 1 ? "the entry guards" : "the entries guard"} nothing (kept as written: a tool of that exact name mounted by an embedder is still matched) and the server starts. Remove ${skipped.length === 1 ? "it" : "them"} from ${envName} if written for the retired tool.`,
+                },
+            });
+        }
         return names;
     };
     return {
@@ -1590,19 +1625,30 @@ function parentPidEnv() {
     return { parentPid: n };
 }
 const ENGINE_LINGER_FLOOR_MS = 1_000;
+const ENGINE_HANDOVER_LINGER_FLOOR_MS = 60_000;
 const ENGINE_LINGER_CEIL_MS = 24 * 60 * 60 * 1_000;
-function lingerMsEnv(name, raw, defaultMs, disableHint) {
+function engineWindowZeroSentence(zero) {
+    switch (zero.kind) {
+        case "refused":
+            return `There is no "disable" value here — ${zero.disableHint}`;
+        case "noGrace":
+            return `the literal "0" is the one value below the floor accepted here — ${zero.offHint}`;
+    }
+}
+function lingerMsEnv(name, raw, defaultMs, floorMs, zero) {
     if (raw === undefined || raw.trim() === "")
         return defaultMs;
+    if (zero.kind === "noGrace" && raw.trim() === "0")
+        return 0;
     const n = parseNumOrFail(name, raw);
-    if (!Number.isSafeInteger(n) || n < ENGINE_LINGER_FLOOR_MS || n > ENGINE_LINGER_CEIL_MS) {
+    if (!Number.isSafeInteger(n) || n < floorMs || n > ENGINE_LINGER_CEIL_MS) {
         throw new Error(`env ${name}="${raw}" must be an INTEGER number of MILLISECONDS in ` +
-            `[${ENGINE_LINGER_FLOOR_MS}, ${ENGINE_LINGER_CEIL_MS}] (1s … 24h) — it is how long ` +
+            `[${floorMs}, ${ENGINE_LINGER_CEIL_MS}] (${floorMs / 1_000}s … 24h) — it is how long ` +
             `"nobody attached, no run in flight, no HTTP touch" must hold CONTINUOUSLY before the engine self-exits. ` +
             `A value like "60" is the seconds-for-milliseconds slip: a 60ms window kills the engine inside a shell's own ` +
             `restart gap. A value like "1e100" passes a naive "is it a positive integer" check but the elapsed clock can ` +
             `NEVER reach it, which silently turns self-exit off while looking configured. ` +
-            `There is no "disable" value here — ${disableHint}`);
+            engineWindowZeroSentence(zero));
     }
     return n;
 }
@@ -1628,6 +1674,7 @@ function parseMemoryEmbedder(ctx) {
     const dimRaw = process.env.MEMORY_EMBEDDER_DIM || undefined;
     const apiKey = process.env.MEMORY_EMBEDDER_API_KEY || undefined;
     const timeoutRaw = process.env.MEMORY_EMBEDDER_TIMEOUT_MS || undefined;
+    const reembedRaw = process.env.MEMORY_EMBEDDER_REEMBED || undefined;
     const trio = [
         ["MEMORY_EMBEDDER_ENDPOINT", endpoint],
         ["MEMORY_EMBEDDER_MODEL", model],
@@ -1635,8 +1682,11 @@ function parseMemoryEmbedder(ctx) {
     ];
     const missing = trio.filter(([, v]) => v === undefined).map(([name]) => name);
     if (missing.length === 3) {
-        if (timeoutRaw !== undefined || apiKey !== undefined) {
-            throw new Error(`MEMORY_EMBEDDER_TIMEOUT_MS/MEMORY_EMBEDDER_API_KEY are set but the embedder itself is not configured — refusing to start half-configured (set MEMORY_EMBEDDER_ENDPOINT, MEMORY_EMBEDDER_MODEL and MEMORY_EMBEDDER_DIM to enable the memory vector plane, or unset the other MEMORY_EMBEDDER_* keys)`);
+        const dependents = [["MEMORY_EMBEDDER_TIMEOUT_MS", timeoutRaw], ["MEMORY_EMBEDDER_API_KEY", apiKey], ["MEMORY_EMBEDDER_REEMBED", reembedRaw]]
+            .filter(([, v]) => v !== undefined)
+            .map(([name]) => name);
+        if (dependents.length > 0) {
+            throw new Error(`${dependents.join("/")} ${dependents.length === 1 ? "is" : "are"} set but the embedder itself is not configured — refusing to start half-configured (set MEMORY_EMBEDDER_ENDPOINT, MEMORY_EMBEDDER_MODEL and MEMORY_EMBEDDER_DIM to enable the memory vector plane, or unset the other MEMORY_EMBEDDER_* keys)`);
         }
         return undefined;
     }
@@ -1659,12 +1709,26 @@ function parseMemoryEmbedder(ctx) {
     if (!ctx.memoryEngineEnabled) {
         throw new Error("MEMORY_EMBEDDER_* is set but MEMORY_ENGINE=off — the memory engine is not wired at all, so the embedder would never be called; unset one of the two (#228)");
     }
+    if (reembedRaw !== undefined) {
+        const configured = formatEmbedderIdentityToken({ model, dimensions });
+        const confirmed = parseEmbedderIdentityToken(reembedRaw);
+        if (confirmed === undefined) {
+            throw new Error(`MEMORY_EMBEDDER_REEMBED=${JSON.stringify(reembedRaw.length > 200 ? `${reembedRaw.slice(0, 200)}…` : reembedRaw)} is not a re-embed confirmation — the value must name the embedder identity being confirmed as <model>/<dimensions> ` +
+                `(for this configuration: ${formatReembedAssignment({ model, dimensions })}). It confirms that the memory vector column may be cleared and re-embedded into that identity when the recorded identity does not match; ` +
+                "an on/off value is refused because it would also confirm the NEXT model change. Fix the value or unset it.");
+        }
+        if (confirmed.model !== model || confirmed.dimensions !== dimensions) {
+            throw new Error(`MEMORY_EMBEDDER_REEMBED=${formatEmbedderIdentityToken(confirmed)} confirms re-embedding into a different identity than the configured embedder ${configured} ` +
+                `(MEMORY_EMBEDDER_MODEL / MEMORY_EMBEDDER_DIM) — a stale confirmation never clears vectors for another model. Set ${formatReembedAssignment({ model, dimensions })} to confirm this change, or unset it.`);
+        }
+    }
     return {
         endpoint,
         model,
         dimensions,
         timeoutMs: numEnvBounded("MEMORY_EMBEDDER_TIMEOUT_MS", "30000", 1000, 300_000),
         ...(apiKey !== undefined ? { apiKey } : {}),
+        ...(reembedRaw !== undefined ? { reembedConfirmed: true } : {}),
     };
 }
 function parseMemoryConsolidationDriver() {
@@ -1757,6 +1821,10 @@ function parseMemoryDomain(ctx) {
         if (scope === undefined) {
             throw new Error("MEMORY_SYNC_URL is set but no sync scope is derivable (memory engine off or multi-tenant without an explicit scope) — set MEMORY_SYNC_SCOPE, or run the single-user file memory engine with a typed MEMORY_SCOPE (e.g. user:<tenant>) so it provides one");
         }
+        if (!isReplicableScope(scope)) {
+            throw new Error(`${memorySyncScopeRaw !== undefined ? "MEMORY_SYNC_SCOPE" : "MEMORY_SCOPE"} names a userlocal: memory layer as the sync layer — that layer family never leaves the store it is written in ` +
+                "(the engine refuses to sync it before any read or request), so this sync leg would fail every round. Set MEMORY_SYNC_SCOPE to a layer that may be replicated, or unset MEMORY_SYNC_URL.");
+        }
         if (carriesCredential(scope)) {
             throw new Error(`${memorySyncScopeRaw !== undefined ? "MEMORY_SYNC_SCOPE" : "MEMORY_SCOPE"} (the memory sync layer's name) holds a credential-shaped part — the layer name travels verbatim in every sync request path and report, so it is refused, never cleaned: rename the layer`);
         }
@@ -1915,6 +1983,7 @@ function parseAuthDomain(ctx) {
         ...parseGovernanceDeclarations(),
         operatorPrincipals: csv("OPERATOR_PRINCIPALS"),
         operatorSingleUser: boolEnv("OPERATOR_SINGLE_USER", false),
+        serviceTokenActsForDeployment: boolEnv("SERVICE_TOKEN_ACTS_FOR_DEPLOYMENT", true),
         configCatalogEnabled: boolEnv("CONFIG_CATALOG_ENABLED", true),
         principalJwtPubkeys,
         principalJwtIss,
@@ -1923,8 +1992,14 @@ function parseAuthDomain(ctx) {
         principalJwtMaxTtlSec,
     };
 }
+export const BG_AGENT_SILENCE_FLOOR_MS = 10 * 60_000;
+export function backgroundAgentStallFloorMs(f) {
+    const personWaitMs = Math.max(f.streamApproval.windowMs, f.streamApproval.unreachedTtlMs, (f.questionThrottle ?? DEFAULT_QUESTION_THROTTLE).ttlMs, f.mcpElicitation.throttle.ttlMs);
+    return Math.max(BG_AGENT_SILENCE_FLOOR_MS, personWaitMs + f.commandCeilingMs);
+}
 function parseOrchestrationDomain(ctx) {
     const { postureOn, singleUserTurnkey } = ctx;
+    const backgroundAgentStallFloor = backgroundAgentStallFloorMs({ ...ctx.personGates, commandCeilingMs: resolveBashTimeoutCaps().maxMs });
     const workflowSizeGuidelineRaw = process.env.WORKFLOW_SIZE_GUIDELINE;
     if (workflowSizeGuidelineRaw !== undefined && !["small", "medium", "large", "unrestricted"].includes(workflowSizeGuidelineRaw)) {
         throw new Error(`WORKFLOW_SIZE_GUIDELINE must be small|medium|large|unrestricted, got "${workflowSizeGuidelineRaw}"`);
@@ -1947,7 +2022,6 @@ function parseOrchestrationDomain(ctx) {
         ? { readFace: enumEnv("READ_FACE", "roots", ["open", "roots"]), readFaceSource: "env" }
         : { readFaceSource: "engine-default" };
     return {
-        requireExecutionLane: boolEnv("REQUIRE_EXECUTION_LANE", false),
         ...readFaceFacts,
         ...optionalEnumKey("taskWriteFaceEscalation", "TASK_WRITE_FACE_ESCALATION", process.env.TASK_WRITE_FACE_ESCALATION, TASK_WRITE_FACE_ESCALATIONS),
         ...(process.env.READ_DENY_PATTERNS !== undefined ? { readDenyPatterns: parseReadDenyPatternsEnv(process.env.READ_DENY_PATTERNS) } : {}),
@@ -2028,12 +2102,8 @@ function parseOrchestrationDomain(ctx) {
                                         ...(process.env.ADB_MOUNT_PATH ? { mountPath: process.env.ADB_MOUNT_PATH } : {}),
                                     }
                                     :
-                                        declaredLane === "host"
-                                            ? {
-                                                provider: "host",
-                                                ...(process.env.HOST_WORKSPACE_BASE ? { workspaceBase: process.env.HOST_WORKSPACE_BASE } : {}),
-                                                ...((n) => (n !== undefined ? { commandTimeoutMs: n } : {}))(optNumEnvStrict("HOST_COMMAND_TIMEOUT_MS")),
-                                            }
+                                        declaredLane === "host" || declaredLane === "none"
+                                            ? entryDeclarableRemoteExec(declaredLane)
                                             :
                                                 declaredLane === "local-docker" && process.env.DOCKER_IMAGE
                                                     ? {
@@ -2062,13 +2132,12 @@ function parseOrchestrationDomain(ctx) {
                                                                 ...((n) => (n !== undefined ? { maxInflightPerDevice: n } : {}))(parseDeviceBoundedIntEnv("DEVICE_MAX_INFLIGHT_PER_DEVICE", process.env.DEVICE_MAX_INFLIGHT_PER_DEVICE, DEVICE_HELLO_ACK_BOUNDS.maxInflight)),
                                                                 ...((n) => (n !== undefined ? { maxPreAuthPerRemote: n } : {}))(parseDevicePreAuthPerRemoteEnv()),
                                                                 ...((n) => (n !== undefined ? { enrollTokenTtlSec: n } : {}))(parseDeviceEnrollTokenTtlEnv()),
+                                                                ...((n) => (n !== undefined ? { trustedProxyCidrs: n } : {}))(parseDeviceTrustedProxyCidrsEnv(process.env.DEVICE_TRUSTED_PROXY_CIDRS)),
                                                                 relay: parseDeviceRelayUrlEnv(process.env.DEVICE_RELAY_URL),
                                                                 ...(process.env.DEVICE_SUPERSEDE ? { supersede: enumEnv("DEVICE_SUPERSEDE", "stale_only", ["stale_only", "deny"]) } : {}),
                                                             }
                                                             :
-                                                                ctx.configProvider === "local"
-                                                                    ? { provider: "host", singleMachineDefault: true }
-                                                                    : undefined,
+                                                                undefined,
         worktreeIsolation: boolEnv("WORKTREE_ISOLATION_ENABLED", false) && process.env.WORKTREE_REPO_ROOT
             ? {
                 repoRoot: process.env.WORKTREE_REPO_ROOT,
@@ -2099,7 +2168,8 @@ function parseOrchestrationDomain(ctx) {
         workflowRunRetentionMs: clampEnvWithWarn("WORKFLOW_RUN_RETENTION_MS", String(30 * 24 * 60 * 60 * 1000), 60_000),
         ...(usageWindows ? { usageWindows } : {}),
         backgroundAgentRetentionMs: clampEnvWithWarn("BG_AGENT_RETENTION_MS", String(7 * 24 * 60 * 60 * 1000), 60_000),
-        backgroundAgentStaleRunningMs: clampEnvWithWarn("BG_AGENT_STALE_RUNNING_MS", String(15 * 60_000), 10 * 60_000),
+        backgroundAgentStaleRunningMs: clampEnvWithWarn("BG_AGENT_STALE_RUNNING_MS", String(15 * 60_000), BG_AGENT_SILENCE_FLOOR_MS),
+        backgroundAgentStallMs: clampEnvWithWarn("BG_AGENT_STALL_MS", String(backgroundAgentStallFloor), backgroundAgentStallFloor),
         backgroundAgentParkClaimStaleMs: clampEnvWithWarn("BG_AGENT_PARK_CLAIM_STALE_MS", String(60 * 60_000), 60_000),
         rosterRetentionMs: clampEnvWithWarn("ROSTER_RETENTION_MS", String(30 * 24 * 60 * 60 * 1000), 60_000),
         leaderRunStaleMs: clampEnvWithWarn("LEADER_RUN_STALE_MS", String(26 * 60 * 60 * 1000), 60_000),
@@ -2158,6 +2228,8 @@ function parseLimitsHttpDomain() {
             ? { attachmentMimeAllowlist: csv("ATTACHMENT_MIME_ALLOWLIST").map((s) => s.toLowerCase()) }
             : {}),
         attachmentUnboundTtlMs: clampEnvWithWarn("ATTACHMENT_UNBOUND_TTL_MS", String(24 * 3600 * 1000), LIMITS_HTTP_FLOORS.attachmentUnboundTtlMs),
+        adoptionImportMaxSessions: countEnvClamped("ADOPTION_IMPORT_MAX_SESSIONS", ADOPTION_IMPORT_MAX_SESSIONS_DEFAULT, ADOPTION_IMPORT_MAX_SESSIONS_FLOOR),
+        adoptionImportMaxSessionBytes: countEnvClamped("ADOPTION_IMPORT_MAX_SESSION_BYTES", ADOPTION_IMPORT_MAX_SESSION_BYTES_DEFAULT, ADOPTION_IMPORT_MAX_SESSION_BYTES_FLOOR, ADOPTION_IMPORT_MAX_SESSION_BYTES_CEILING),
         infraCostRates: {
             toolCallMicroUsd: clampEnvWithWarn("INFRA_COST_TOOL_CALL", "0", 0),
             sandboxSecMicroUsd: clampEnvWithWarn("INFRA_COST_SANDBOX_SEC", "0", 0),
@@ -2173,9 +2245,23 @@ function parseLimitsHttpDomain() {
         sighupIdleGraceMs: clampEnvWithWarn("SIGHUP_IDLE_GRACE_MS", String(120_000), 5_000),
         ...parentPidEnv(),
         engineAutoExit: boolEnv("ENGINE_AUTO_EXIT", false),
-        engineLingerMs: lingerMsEnv("ENGINE_LINGER_MS", process.env.ENGINE_LINGER_MS, 60_000, "set ENGINE_AUTO_EXIT=false to turn self-exit off entirely."),
-        engineOrphanLingerMs: lingerMsEnv("ENGINE_ORPHAN_LINGER_MS", process.env.ENGINE_ORPHAN_LINGER_MS, 2_000, "this window only applies once the SEMA_PARENT_PID process is gone — unset SEMA_PARENT_PID to stop watching the parent at all."),
+        engineLingerMs: lingerMsEnv("ENGINE_LINGER_MS", process.env.ENGINE_LINGER_MS, 60_000, ENGINE_LINGER_FLOOR_MS, { kind: "refused", disableHint: "set ENGINE_AUTO_EXIT=false to turn self-exit off entirely." }),
+        engineOrphanLingerMs: lingerMsEnv("ENGINE_ORPHAN_LINGER_MS", process.env.ENGINE_ORPHAN_LINGER_MS, 2_000, ENGINE_LINGER_FLOOR_MS, {
+            kind: "refused",
+            disableHint: "this window only applies once the SEMA_PARENT_PID process is gone — unset SEMA_PARENT_PID to stop watching the parent at all.",
+        }),
+        engineFirstAttachMs: lingerMsEnv("ENGINE_FIRST_ATTACH_MS", process.env.ENGINE_FIRST_ATTACH_MS, 180_000, ENGINE_LINGER_FLOOR_MS, {
+            kind: "noGrace",
+            offHint: "it means no extra grace before the first non-probe request (the window is then ENGINE_LINGER_MS, as before this knob existed); " +
+                "set ENGINE_AUTO_EXIT=false to turn self-exit off entirely.",
+        }),
+        engineHandoverLingerMs: lingerMsEnv("ENGINE_HANDOVER_LINGER_MS", process.env.ENGINE_HANDOVER_LINGER_MS, 1_800_000, ENGINE_HANDOVER_LINGER_FLOOR_MS, {
+            kind: "refused",
+            disableHint: "this window only applies after a shell hands the engine over (POST /v1/engine/handover) — a shell that never does so never uses it; set ENGINE_AUTO_EXIT=false and unset SEMA_PARENT_PID to turn self-exit off entirely.",
+        }),
         rateLimitPerMin: numEnv("RATE_LIMIT_RPM", "0"),
+        runMaxConcurrent: nonNegativeIntEnv("RUN_MAX_CONCURRENT", "在飞 run 全局并发帽"),
+        runMaxConcurrentPerPrincipal: nonNegativeIntEnv("RUN_MAX_CONCURRENT_PER_PRINCIPAL", "按主体在飞 run 并发帽"),
         maxTaskCostUsd: numEnv("MAX_TASK_COST_USD", "0"),
         maxTaskTokens: numEnv("MAX_TASK_TOKENS", "0"),
         maxPrincipalCostUsd: numEnv("MAX_PRINCIPAL_COST_USD", "0"),
@@ -2484,15 +2570,15 @@ const MEMORY_GROUP_KEYS = [
 const AUTH_GROUP_KEYS = [
     "authToken", "authTokens", "allowUnauthedWrites", "corsOrigins", "principalHeader", "requirePrincipal", "autonomy",
     "commandPolicy", "compliancePosture", "lockedConfigKeys", "retentionPolicy", "retentionSweep",
-    "operatorPrincipals", "operatorSingleUser", "configCatalogEnabled", "principalJwtPubkeys", "principalJwtIss", "principalJwtAud",
+    "operatorPrincipals", "operatorSingleUser", "serviceTokenActsForDeployment", "configCatalogEnabled", "principalJwtPubkeys", "principalJwtIss", "principalJwtAud",
     "principalJwtMaxTtlSec", "authBridgeIssuer", "bindHost", "bindHostSource",
 ];
 const ORCHESTRATION_GROUP_KEYS = [
-    "sandboxGit", "remoteExec", "remoteExecHomeDir", "requireExecutionLane", "worktreeIsolation", "leaderEnabled", "leaderFanoutEnabled", "routerEnabled", "selfOrchestrationEnabled",
+    "sandboxGit", "remoteExec", "remoteExecHomeDir", "worktreeIsolation", "leaderEnabled", "leaderFanoutEnabled", "routerEnabled", "selfOrchestrationEnabled",
     "selfOrchestrationModels", "selfOrchestrationWorkerIsolation", "forkEnabled", "experimentalObserverAgents",
     "schedulerEnabled", "schedulerSessionWakeup", "schedulerSessionLifetime", "schedulerStorePath", "planModeEnabled", "hooksTimeoutMs", "workflowRunStoreBackend",
     "workflowOrphanGraceMs", "workflowJournalRetentionMs", "workflowRunRetentionMs", "usageWindows", "workflowAgentsReadOnly",
-    "workflowSizeGuideline", "backgroundAgentRetentionMs", "backgroundAgentStaleRunningMs",
+    "workflowSizeGuideline", "backgroundAgentRetentionMs", "backgroundAgentStaleRunningMs", "backgroundAgentStallMs",
     "backgroundAgentParkClaimStaleMs", "delegationEntryCaps", "rosterRetentionMs", "leaderRunStaleMs", "scratchpadSweepTtlMs", "sandboxPkgSource", "sandboxPkgSourceCustom",
     "sessionAutoTitle", "sessionAutoTitleSource", "selectEnvironmentTool", "envFactsEnabled", "toolDeferLongtail", "lspEnabled", "lspHostEnabled", "lspEnvAllow",
     "imageBakes", "readFace", "readFaceSource", "taskWriteFaceEscalation", "readDenyPatterns", "readDenyBuiltinTiers", "readDenyBuiltinExclude", "readDenyFloorRequired", "sandboxReadFloor",
@@ -2501,8 +2587,9 @@ const ORCHESTRATION_GROUP_KEYS = [
 const LIMITS_HTTP_GROUP_KEYS = [
     "port", "attachmentOrphanGraceMs", "workspaceFileMaxBytes", "attachmentMaxBytes", "attachmentMimeAllowlist",
     "attachmentUnboundTtlMs", "infraCostRates", "drainGraceMs", "drainSecondSignalMinGapMs", "sighupIdleGraceMs", "parentPid",
-    "engineAutoExit", "engineLingerMs", "engineOrphanLingerMs",
-    "rateLimitPerMin", "maxTaskCostUsd",
+    "engineAutoExit", "engineLingerMs", "engineOrphanLingerMs", "engineFirstAttachMs", "engineHandoverLingerMs",
+    "rateLimitPerMin", "runMaxConcurrent", "runMaxConcurrentPerPrincipal", "maxTaskCostUsd",
+    "adoptionImportMaxSessions", "adoptionImportMaxSessionBytes",
     "maxTaskTokens", "maxPrincipalCostUsd", "costQuotaWindowSec", "reapIntervalSec", "runStaleSec", "toolResultTtlSec",
 ];
 const OBSERVABILITY_GROUP_KEYS = ["metricsToken", "traceToken", "toolTrace", "traceThinking", "logLevel", "otel"];
@@ -2545,6 +2632,9 @@ export function attachConfigGroups(flat) {
     }
     return flat;
 }
+function attachLoadedConfigGroups(flat) {
+    return attachConfigGroups(flat);
+}
 function k8sWorkspaceStore() {
     const workspacePersist = enumEnv("WORKSPACE_PERSIST", WORKSPACE_PERSIST_DEFAULT, WORKSPACE_PERSIST_WORDS);
     const workspaceSnapshotKeep = numEnvBounded("WORKSPACE_SNAPSHOT_KEEP", String(WORKSPACE_SNAPSHOT_KEEP_DEFAULT), WORKSPACE_SNAPSHOT_KEEP_RANGE.min, WORKSPACE_SNAPSHOT_KEEP_RANGE.max);
@@ -2615,7 +2705,6 @@ function k8sWorkspaceCache() {
     return { mount, size };
 }
 export function loadConfig() {
-    EXEC_LANE_NOTICE = undefined;
     rejectRetiredEnvs();
     CONFIG_WARNINGS.length = 0;
     CONFIG_NOTICES.length = 0;
@@ -2635,11 +2724,7 @@ export function loadConfig() {
     const approval = parseApprovalDomain({ postureOn, singleUserTurnkey, infraReady: durableStoreReady });
     const memory = parseMemoryDomain({ requirePrincipal });
     const auth = parseAuthDomain({ requirePrincipal });
-    const orchestration = parseOrchestrationDomain({ postureOn, singleUserTurnkey, configProvider });
-    settleDerivedReadFace(orchestration, singleUserTurnkey);
-    const readFaceNotice = buildReadFacePostureNotice(orchestration);
-    if (readFaceNotice !== undefined)
-        CONFIG_NOTICES.push({ level: "info", ...readFaceNotice });
+    const orchestration = parseOrchestrationDomain({ postureOn, singleUserTurnkey, personGates: approval });
     const limitsHttp = parseLimitsHttpDomain();
     const observability = parseObservabilityDomain();
     const integrations = parseIntegrationsDomain({ requirePrincipal, configProvider });
@@ -2701,12 +2786,7 @@ export function loadConfig() {
     if (parkDecisionDomainRefusal !== undefined) {
         throw new Error(parkDecisionDomainRefusal);
     }
-    const laneRequiredRefusal = executionLaneRequiredRefusal(orchestration);
-    if (laneRequiredRefusal !== undefined) {
-        throw new Error(laneRequiredRefusal);
-    }
-    EXEC_LANE_NOTICE = buildExecLaneNotice(orchestration.remoteExec);
-    return attachConfigGroups({
+    return attachLoadedConfigGroups({
         ...store,
         ...modelPlane,
         ...approval,
@@ -2729,7 +2809,9 @@ export function parseCapEnv(name, raw) {
     return { value: n };
 }
 export function splitLocalRoots(a) {
-    const configRoot = a.configLocalDir ?? a.agentDataDir ?? join(a.home, ".ai-agent");
+    if (a.configLocalDir !== undefined)
+        return undefined;
+    const configRoot = a.agentDataDir ?? join(a.home, ".ai-agent");
     if (!a.localDataRoot || a.localDataRoot === configRoot)
         return undefined;
     return { dataRoot: a.localDataRoot, configRoot };

package/dist/degenerate-instrument.js

@@ -1,6 +1,6 @@
 import { failureCodeOf } from "./terminal.js";
 import { StoredSession } from "@sema-agent/core";
-import { TiDBSessionStorage } from "./plugins/tidb-session-storage.js";
+import { TiDBSessionStorage } from "./stores-sql/tidb-session-storage.js";
 const SUBSTANTIVE_CHARS = 200;
 const REP_WINDOW = 8192;
 const MIN_REPEATS = 3;

package/dist/deleted-session-ids.d.ts

@@ -0,0 +1,19 @@
+import type { DeploymentShapeInput } from "./deployment-shape.js";
+/** 表的条数上限(一条约百字节量级)。引擎的会话暂存自己按会话数有上限(超了整会话驱逐最旧);本表的上限比它宽得多。 */
+export declare const DELETED_SESSION_ID_CAP = 50000;
+/**
+ * **铸点**(唯一):本进程的在线删除协调器在删除会话本体之前记一笔 —— 围栏先立,id 才空出来。删除随后失败也无害:
+ * 这一笔只拒「别的属主」,而会话还在时别的属主本来就用不了它。
+ * 同一只 id 再删一次:这一次的删前属主对已记的每一位都等价(同一只等价律判)⇒ 收进集合(前几位一位不丢 —— 等价律有方向、不传递,只记最新一位会让
+ * 「哨兵删 → 无主重登再删 → `default` 用」绕过「哨兵 ≢ `default`」);对某一位不等价 ⇒ 记成「谁都不是」。后一次删除从不覆盖前一位(前一位的暂存仍可能在本进程)。
+ * `deployment` = 部署形(等价律的窄互认臂读它;调用方递 `ServiceConfig` 整份)。
+ */
+export declare function retireSessionId(sessionId: string, owner: string | null, deployment: DeploymentShapeInput<"principal">): void;
+/**
+ * **读点**(唯一;执行上下文解析器 `http/execution-context.ts` 步 ① 调):这只 id 在本进程被删过、而删前的属主不是 `owner` ⇒ `true`(解析器拒)。
+ * `owner` = 这条执行要服务的属主(根会话行上那一读的住客);`undefined` = 判不出 ⇒ 删过就为真(fail-closed)。
+ * 同一位 = 对**每一位**删前属主,会话属主等价律 `sameSessionOwner(deployment, 删前属主, owner)` 都成立(删前属主是行上记下的那一格,本次住客是这一次的调用方);
+ * 被互不等价的属主各删过一次的 id 对谁都为真。
+ */
+export declare function sessionIdRetiredFor(sessionId: string, owner: string | null | undefined, deployment: DeploymentShapeInput<"principal">): boolean;
+//# sourceMappingURL=deleted-session-ids.d.ts.map

package/dist/deleted-session-ids.js

@@ -0,0 +1,26 @@
+import { recordFailOpen } from "./observability/fail-open.js";
+import { sameSessionOwner } from "./security.js";
+export const DELETED_SESSION_ID_CAP = 50_000;
+const DELETED_UNDER_SEVERAL = Symbol("deleted under several owners");
+const formerOwners = new Map();
+export function retireSessionId(sessionId, owner, deployment) {
+    const prior = formerOwners.get(sessionId);
+    const recorded = prior === undefined ? [owner] : sessionIdRetiredFor(sessionId, owner, deployment) ? DELETED_UNDER_SEVERAL : prior === DELETED_UNDER_SEVERAL || prior.includes(owner) ? prior : [...prior, owner];
+    formerOwners.delete(sessionId);
+    formerOwners.set(sessionId, recorded);
+    if (formerOwners.size <= DELETED_SESSION_ID_CAP)
+        return;
+    const oldest = formerOwners.keys().next().value;
+    if (oldest !== undefined)
+        formerOwners.delete(oldest);
+    recordFailOpen("server.session-id-tombstone.evicted", `cap=${DELETED_SESSION_ID_CAP}`);
+}
+export function sessionIdRetiredFor(sessionId, owner, deployment) {
+    const former = formerOwners.get(sessionId);
+    if (former === undefined)
+        return false;
+    if (owner === undefined || former === DELETED_UNDER_SEVERAL)
+        return true;
+    return !former.every((f) => sameSessionOwner(deployment, f, owner));
+}
+//# sourceMappingURL=deleted-session-ids.js.map