@sema-agent/server 7.146.0 → 7.148.0

package/dist/config.js

@@ -1,9 +1,10 @@
+import { writeLogText } from "./observability/logger.js";
 import { readFileSync } from "node:fs";
 import { DEFAULT_AT_MENTION, DEFAULT_MODEL_REF, mintCapabilityKeys } from "./model-select.js";
 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, isReplicableScope } from "@sema-agent/core";
+import { hostOfUrl, HOST_UNREADABLE_SENTENCE, 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,6 +12,7 @@ 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";
@@ -23,12 +25,13 @@ import { ScopeId } from "@sema-agent/settings-schema/api/scopes";
 import { centerLaneConfigured, pathBaseUrlRefusal } from "./web-admin-client/center-request.js";
 import { resolveLocalDataRoot } from "./local-data-root.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
+import { RUN_STALE_SEC_DEFAULT } from "./run-stale-default.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 { ASSUMED_CONTEXT_WINDOW } from "./model-context-window.js";
+import { MODEL_THINKING_LEVELS, THINKING_LEVELS, THINKING_FORMATS, buildModelCompat, isModelThinkingLevel, 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, isRetiredLeftOut, retiredLeftOutEntries, 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";
@@ -39,14 +42,15 @@ 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 { deploymentRuleRefusal } from "./rule-issue-reading.js";
 import { MAX_NAMED_INERT_ENTRIES, allowLayerEntryCountIssue, describeInertRuleEntries, inertRuleEntriesOf, inertRuleEntryGuidance, ruleEntryListShapeOk } from "./rule-entry-list.js";
 import { readReadDenyEntry } from "./read-deny-entry.js";
 import { createCenterCredentialSource, readCenterCredentialDeclaration } from "./center-credential.js";
 import { parseCenterCredentialRenewLeadMs } from "./center-credential-renewer.js";
-import { modelProviderRefusal } from "./model-provider.js";
+import { catalogBrainLane, modelProviderRefusal } from "./model-provider.js";
 import { modelRouteUrlRefusal } from "./model-route-url.js";
 import { DEVICE_RELAY_NONE, DEVICE_RELAY_RULE, deviceRelayFlaws, httpUrlFlaws } from "@sema-agent/settings-schema";
 import { buildHttpUrlRefusal, buildRefusalShownUrl } from "./url-refusal.js";
@@ -54,9 +58,10 @@ import { customPkgSourceFromEnv } from "./sandbox-pkg-source.js";
 import { anthropicCredentialRefusal, csvOf, declaredCredential, envLaneTable, mintedCheapId, readModelRouteEnv } from "./model-route-gap.js";
 import { displayListEntry } from "./list-entry-display.js";
 import { echoCallerText } from "./caller-text-echo.js";
+import { PRINCIPAL_MAX_BYTES, principalShapeProblem } from "./principal-shape.js";
 import { buildDisplaySafeUrl, redactSecrets } from "./trace/redact.js";
 import { parseConfigLocalOwnerUid } from "./config-dir-trust.js";
-import { allowlistedEnv } from "./server-secret-env.js";
+import { allowlistedEnv, ownCredentialDeclarationRefusal } 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";
@@ -170,6 +175,10 @@ function nonNegativeIntEnv(name, role, fallback = "0") {
         throw new Error(`env ${name}=${n} must be an integer(${role};计数轴不接受小数——单位写漏了?)`);
     return n;
 }
+function parseLocalDockerCapacityEnv() {
+    const maxContainers = nonNegativeIntEnv("DOCKER_MAX_CONTAINERS", "local-docker 车道同时在跑的容器数上限");
+    return maxContainers > 0 ? { maxContainers } : undefined;
+}
 function numEnvBounded(name, fallback, min, max) {
     const n = numEnv(name, fallback);
     if (n < min || n > max)
@@ -192,14 +201,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;
@@ -208,7 +209,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;
 }
@@ -254,10 +255,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", {
@@ -407,8 +404,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)
@@ -422,7 +432,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;
 }
@@ -563,9 +573,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) {
@@ -1060,16 +1070,26 @@ function parseModelDomain() {
     }
     const extraBody = buildExtraBody();
     const thinkingDefault = parseDefaultThinking(process.env.MODEL_DEFAULT_THINKING);
-    const envCompatDeclared = buildModelCompat({
+    const envLaneWire = ((lane) => {
+        switch (lane) {
+            case "anthropic":
+                return { api: "anthropic-messages", promptCacheFamily: "input-excludes-cached" };
+            case "gateway":
+                return { api: "openai-completions", promptCacheFamily: "input-includes-cached" };
+        }
+    })(catalogBrainLane(provider));
+    const envApi = envLaneWire.api;
+    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 contextWindow = numEnv("MODEL_CONTEXT_WINDOW", String(ASSUMED_CONTEXT_WINDOW));
     const model = {
         id: modelId,
         name: modelId,
-        api: provider === "anthropic" ? "anthropic-messages" : "openai-completions",
+        api: envApi,
         provider,
         baseUrl: "",
         ...mintCapabilityKeys(modelCapability),
@@ -1079,12 +1099,12 @@ function parseModelDomain() {
             cacheRead: costEnv("MODEL_COST_CACHE_READ", "unset"),
             cacheWrite: costEnv("MODEL_COST_CACHE_WRITE", "unset"),
         }, undefined)),
-        contextWindow: numEnv("MODEL_CONTEXT_WINDOW", "262144"),
+        contextWindow,
         maxTokens: process.env.MODEL_MAX_TOKENS !== undefined && process.env.MODEL_MAX_TOKENS !== ""
             ? parseNumOrFail("MODEL_MAX_TOKENS", process.env.MODEL_MAX_TOKENS)
-            : Math.min(32000, numEnv("MODEL_CONTEXT_WINDOW", "262144")),
+            : Math.min(32000, contextWindow),
         ...(optFinitePositiveEnv("MODEL_CHARS_PER_TOKEN") !== undefined ? { charsPerToken: optFinitePositiveEnv("MODEL_CHARS_PER_TOKEN") } : {}),
-        params: { promptCacheFamily: provider === "anthropic" ? "input-excludes-cached" : "input-includes-cached" },
+        params: { promptCacheFamily: envLaneWire.promptCacheFamily },
         ...(thinkingDefault ? { defaultThinking: thinkingDefault } : {}),
         ...(envCompat ? { compat: envCompat } : {}),
         ...(extraBody ? { extraBody } : {}),
@@ -1247,11 +1267,9 @@ function parseDefaultThinking(raw) {
     const v = raw?.trim();
     if (v === undefined || v === "")
         return undefined;
-    if (v === "off")
-        return undefined;
-    if (!isThinkingTier(v)) {
-        throw new Error(`env MODEL_DEFAULT_THINKING="${v}" is not a thinking tier — valid: ${THINKING_LEVELS.join(" | ")} | off ` +
-            `("off" = no model-level default). A typo used to be dropped SILENTLY, leaving the deployment on no default at all (#210 A 档).`);
+    if (!isModelThinkingLevel(v)) {
+        throw new Error(`env MODEL_DEFAULT_THINKING="${v}" is not a model thinking tier — valid: ${MODEL_THINKING_LEVELS.join(" | ")} ` +
+            `("off" = the model's requests default to thinking off; leave it unset for no model-level default). A typo used to be dropped SILENTLY, leaving the deployment on no default at all (#210 A 档).`);
     }
     return v;
 }
@@ -1261,7 +1279,7 @@ function parseReasoningEffortLevels(words) {
     const bad = words.filter((w) => !isThinkingTier(w));
     if (bad.length > 0) {
         throw new Error(`env MODEL_REASONING_EFFORT_LEVELS has unknown tier(s): ${bad.join(", ")} (valid: ${THINKING_LEVELS.join(" | ")})` +
-            `${bad.includes("off") ? ' — "off" belongs to MODEL_DEFAULT_THINKING (no model-level default), it is not an effort tier an endpoint can accept' : ""}. ` +
+            `${bad.includes("off") ? ' — "off" belongs to MODEL_DEFAULT_THINKING (the model default tier), it is not an effort tier an endpoint can accept' : ""}. ` +
             `Bad words used to be dropped SILENTLY, narrowing the declared ladder without a word (#210 A 档).`);
     }
     return words.filter(isThinkingTier);
@@ -1299,7 +1317,7 @@ function uncompilableRuleGuidance(name, behavior, pathBases) {
     const issue = issues[0];
     if (issue === undefined)
         return undefined;
-    return { code: issue.code, guidance: `${issue.code} — core's rule grammar cannot compile this entry: ${issue.message}` };
+    return deploymentRuleRefusal(issue);
 }
 function findUnmatchableToolNames(names, opts) {
     const out = [];
@@ -1312,7 +1330,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 && isRetiredLeftOut(name) ? undefined : judged;
         if (verdict?.kind === "retired") {
             out.push({ name, guidance: describeUnmatchableRuleName(verdict, subject), reason: verdict.kind });
             continue;
@@ -1418,16 +1437,28 @@ function parseApprovalDomain(ctx) {
         windowMsSource: streamAskWindowMsSource,
         onPostureYield: (facts) => {
             streamAskWindowMsEffectiveSource = "engine-default";
-            process.stderr.write(`[config] stream_ask_window_posture_yielded: the single-user posture default STREAM_ASK_WINDOW_MS=${facts.windowMs} would violate the explicit STREAM_APPROVAL_ORPHAN_TTL_MS=${facts.orphanTtlMs} (window + ADHOC_GRACE ${facts.adhocGraceMs} must be strictly less) — falling back to 300000; set STREAM_ASK_WINDOW_MS explicitly to choose\n`);
+            writeLogText("stderr", `[config] stream_ask_window_posture_yielded: the single-user posture default STREAM_ASK_WINDOW_MS=${facts.windowMs} would violate the explicit STREAM_APPROVAL_ORPHAN_TTL_MS=${facts.orphanTtlMs} (window + ADHOC_GRACE ${facts.adhocGraceMs} must be strictly less) — falling back to 300000; set STREAM_ASK_WINDOW_MS explicitly to choose`);
         },
     });
     const directApprovalDoor = boolEnv("DIRECT_APPROVAL_DOOR", false);
     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 = retiredLeftOutEntries(envName, names);
+        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 {
@@ -1659,6 +1690,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],
@@ -1666,8 +1698,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;
     }
@@ -1690,12 +1725,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() {
@@ -1959,8 +2008,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}"`);
@@ -1970,20 +2025,14 @@ function parseOrchestrationDomain(ctx) {
     const bakeRunnerPrincipal = env("BAKE_RUNNER_PRINCIPAL", "system:bake-runner");
     hostBackgroundShellEnabled();
     hostExecSpoolEnabled();
-    const lspHostEnabled = (() => {
-        if (process.env.LSP_ENABLED === "false") {
-            throw new Error("LSP_ENABLED=false no longer drives the HOST lane (removed in server 3.0.0) — set LSP_HOST_ENABLED=false " +
-                "for the host lane; LSP_ENABLED remains the SANDBOX-lane opt-in only (migration table in USAGE.md)");
-        }
-        return boolEnv("LSP_HOST_ENABLED", true);
-    })();
+    const lspHostEnabled = boolEnv("LSP_HOST_ENABLED", true);
+    const autoBackgroundOnTimeout = boolEnv("AUTO_BACKGROUND_ON_TIMEOUT", true);
     const lspEnvAllow = parseEnvNameAllowlist("LSP_ENV_ALLOW", singleUserTurnkey) ?? [];
     const declaredLane = declaredExecutionLane(process.env.REMOTE_EXEC);
     const readFaceFacts = process.env.READ_FACE !== undefined
         ? { 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) } : {}),
@@ -2064,12 +2113,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
                                                     ? {
@@ -2087,6 +2132,7 @@ function parseOrchestrationDomain(ctx) {
                                                             : {}),
                                                         ...((n) => (n !== undefined ? { commandTimeoutMs: n } : {}))(optNumEnvStrict("DOCKER_COMMAND_TIMEOUT_MS")),
                                                         ...((names) => (names !== undefined ? { env: allowlistedEnv(names, process.env) } : {}))(parseEnvNameAllowlist("DOCKER_SANDBOX_ENV", singleUserTurnkey)),
+                                                        ...((capacity) => (capacity !== undefined ? { capacity } : {}))(parseLocalDockerCapacityEnv()),
                                                     }
                                                     :
                                                         declaredLane === "device"
@@ -2103,9 +2149,7 @@ function parseOrchestrationDomain(ctx) {
                                                                 ...(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,
@@ -2136,7 +2180,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),
@@ -2155,8 +2200,8 @@ function parseOrchestrationDomain(ctx) {
         selectEnvironmentTool: boolEnv("SELECT_ENVIRONMENT_TOOL", true),
         envFactsEnabled: boolEnv("SANDBOX_ENV_FACTS", true),
         toolDeferLongtail: boolEnv("TOOL_DEFER_LONGTAIL", false),
-        lspEnabled: boolEnv("LSP_ENABLED", false),
         lspHostEnabled,
+        autoBackgroundOnTimeout,
         lspEnvAllow,
         workflowAgentsReadOnly: boolEnv("WORKFLOW_AGENTS_READONLY", false),
         imageBakes: {
@@ -2241,7 +2286,7 @@ function parseLimitsHttpDomain() {
             return sec;
         })(),
         reapIntervalSec: numEnv("REAP_INTERVAL_SEC", "60"),
-        runStaleSec: numEnv("REAP_RUN_STALE_SEC", "120"),
+        runStaleSec: numEnv("REAP_RUN_STALE_SEC", String(RUN_STALE_SEC_DEFAULT)),
         toolResultTtlSec: (() => {
             const ttl = numEnv("TOOL_RESULT_TTL_SEC", "86400");
             if (ttl <= 0) {
@@ -2282,7 +2327,11 @@ function parseGitApiKind(raw, baseUrl) {
         throw new Error(`GIT_API_BASEURL="${buildDisplaySafeUrl(baseUrl)}" is not a valid URL (expected e.g. https://git.example.com)`);
     }
     const u = new URL(baseUrl);
-    const host = u.hostname.replace(/\.$/, "").toLowerCase();
+    const reading = hostOfUrl(baseUrl);
+    if ("unreadable" in reading) {
+        throw new Error(`GIT_API_BASEURL names no host — ${HOST_UNREADABLE_SENTENCE[reading.unreadable]} (expected e.g. https://git.example.com; the token goes in GIT_API_TOKEN)`);
+    }
+    const host = reading.host;
     const githubFamily = host === "github.com" || host === "api.github.com" || host.endsWith(".github.com");
     if (kind === "gitea" && githubFamily) {
         throw new Error(`GIT_API_BASEURL points at ${host} but GIT_API_KIND is "gitea" — the Gitea API shapes 404 on GitHub. Set GIT_API_KIND=github (base url should be https://api.github.com, or your GHE /api/v3 root).`);
@@ -2471,6 +2520,11 @@ function parseA2aServe() {
         blockingWaitMs: numEnvBounded("A2A_SERVE_BLOCKING_WAIT_MS", "45000", 0, 300_000),
     };
 }
+const A2A_SERVE_SKILLS_VERSION = 2;
+const A2A_SERVE_SKILL_KEYS = ["id", "name", "description", "scenario", "audience"];
+const A2A_SERVE_SKILL_ENTRY_SHAPE = "{id, name?, description?, scenario, audience?}";
+const A2A_SERVE_SKILLS_SHAPE = `{"version":${A2A_SERVE_SKILLS_VERSION},"skills":[${A2A_SERVE_SKILL_ENTRY_SHAPE}, …]}`;
+const A2A_SERVE_MAX_AUDIENCE = 64;
 function parseA2aServeSkills(raw) {
     if (raw === undefined || raw.trim() === "")
         return [];
@@ -2479,18 +2533,38 @@ function parseA2aServeSkills(raw) {
         parsed = JSON.parse(raw);
     }
     catch (e) {
-        throw new Error(`A2A_SERVE_SKILLS must be a JSON array of {id, name?, description?, scenario} objects — it did not parse as JSON (${e.message})`);
-    }
-    if (!Array.isArray(parsed))
-        throw new Error(`A2A_SERVE_SKILLS must be a JSON ARRAY of {id, name?, description?, scenario} objects; got ${typeof parsed}`);
-    if (parsed.length > A2A_SERVE_MAX_SKILLS)
-        throw new Error(`A2A_SERVE_SKILLS declares ${parsed.length} skills — at most ${A2A_SERVE_MAX_SKILLS} are accepted (the card is a public document fetched by anonymous callers)`);
+        throw new Error(`A2A_SERVE_SKILLS must be a JSON object ${A2A_SERVE_SKILLS_SHAPE} — it did not parse as JSON (${e.message})`);
+    }
+    if (Array.isArray(parsed)) {
+        throw new Error(`A2A_SERVE_SKILLS is a bare JSON array — that form is retired: the value is now a versioned envelope ${A2A_SERVE_SKILLS_SHAPE}. ` +
+            `Migrate by wrapping the old value unchanged: {"version":${A2A_SERVE_SKILLS_VERSION},"skills":<the old array>} (an \`audience\` member is only read inside the envelope).`);
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        throw new Error(`A2A_SERVE_SKILLS must be a JSON object ${A2A_SERVE_SKILLS_SHAPE}; got ${parsed === null ? "null" : typeof parsed}`);
+    const envelope = parsed;
+    for (const key of Object.keys(envelope)) {
+        if (key !== "version" && key !== "skills")
+            throw new Error(`A2A_SERVE_SKILLS carries an unknown key ${JSON.stringify(key.slice(0, 64))} — the envelope's keys are exactly "version" and "skills"`);
+    }
+    if (envelope.version !== A2A_SERVE_SKILLS_VERSION) {
+        throw new Error(`A2A_SERVE_SKILLS.version must be the number ${A2A_SERVE_SKILLS_VERSION} — this build reads exactly that envelope version (a different or missing version is refused rather than guessed: the version is what keeps a build from misreading a shape it does not know)`);
+    }
+    const skills = envelope.skills;
+    if (!Array.isArray(skills))
+        throw new Error(`A2A_SERVE_SKILLS.skills must be a JSON array of ${A2A_SERVE_SKILL_ENTRY_SHAPE} objects`);
+    if (skills.length > A2A_SERVE_MAX_SKILLS)
+        throw new Error(`A2A_SERVE_SKILLS declares ${skills.length} skills — at most ${A2A_SERVE_MAX_SKILLS} are accepted (the card is a public document fetched by anonymous callers)`);
     const seen = new Set();
-    return parsed.map((entry, i) => {
-        const at = `A2A_SERVE_SKILLS[${i}]`;
+    return skills.map((entry, i) => {
+        const at = `A2A_SERVE_SKILLS.skills[${i}]`;
         if (typeof entry !== "object" || entry === null || Array.isArray(entry))
-            throw new Error(`${at} must be an object {id, name?, description?, scenario}`);
+            throw new Error(`${at} must be an object ${A2A_SERVE_SKILL_ENTRY_SHAPE}`);
         const e = entry;
+        for (const key of Object.keys(e)) {
+            if (!A2A_SERVE_SKILL_KEYS.includes(key)) {
+                throw new Error(`${at} carries an unknown key ${JSON.stringify(key.slice(0, 64))} — an entry's keys are exactly ${A2A_SERVE_SKILL_KEYS.map((k) => JSON.stringify(k)).join(", ")} (an unknown key is refused, never dropped: a misspelt "audience" would otherwise publish the skill to everyone)`);
+            }
+        }
         const str = (key, required, max) => {
             const v = e[key];
             if (v === undefined) {
@@ -2511,7 +2585,36 @@ function parseA2aServeSkills(raw) {
         const name = str("name", false, A2A_SERVE_MAX_TEXT_CHARS);
         const description = str("description", false, A2A_SERVE_MAX_TEXT_CHARS);
         const scenario = str("scenario", true, A2A_SERVE_MAX_ID_CHARS);
-        return { id, ...(name !== undefined ? { name } : {}), ...(description !== undefined ? { description } : {}), scenario };
+        const audience = parseA2aServeAudience(e.audience, at);
+        return { id, ...(name !== undefined ? { name } : {}), ...(description !== undefined ? { description } : {}), scenario, ...(audience !== undefined ? { audience } : {}) };
+    });
+}
+function parseA2aServeAudience(v, at) {
+    if (v === undefined)
+        return undefined;
+    const rule = `must be a non-empty JSON array of at most ${A2A_SERVE_MAX_AUDIENCE} principal names (omit the key to publish the skill to every caller)`;
+    if (!Array.isArray(v) || v.length === 0)
+        throw new Error(`${at}.audience ${rule}`);
+    if (v.length > A2A_SERVE_MAX_AUDIENCE)
+        throw new Error(`${at}.audience lists ${v.length} principals — it ${rule}`);
+    return v.map((item, j) => {
+        if (typeof item !== "string")
+            throw new Error(`${at}.audience[${j}] must be a string (a principal name)`);
+        const problem = principalShapeProblem(item);
+        switch (problem) {
+            case undefined:
+                return item;
+            case "not_a_name":
+                throw new Error(`${at}.audience[${j}] is not a principal name (empty, or carries characters no verified identity can have) — list the exact principal names this skill is published to`);
+            case "reserved":
+                throw new Error(`${at}.audience[${j}] is a reserved internal identifier (an internal scope sentinel or a reserved prefix), which no caller can authenticate as — list real principal names`);
+            case "too_long":
+                throw new Error(`${at}.audience[${j}] exceeds ${PRINCIPAL_MAX_BYTES} UTF-8 bytes, longer than any principal a caller can authenticate as`);
+            default: {
+                const unknownProblem = problem;
+                throw new Error(`${at}.audience[${j}]: unknown principal-shape verdict ${String(unknownProblem)}`);
+            }
+        }
     });
 }
 const STORE_GROUP_KEYS = [
@@ -2541,13 +2644,13 @@ const AUTH_GROUP_KEYS = [
     "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",
+    "sessionAutoTitle", "sessionAutoTitleSource", "selectEnvironmentTool", "envFactsEnabled", "toolDeferLongtail", "lspHostEnabled", "lspEnvAllow", "autoBackgroundOnTimeout",
     "imageBakes", "readFace", "readFaceSource", "taskWriteFaceEscalation", "readDenyPatterns", "readDenyBuiltinTiers", "readDenyBuiltinExclude", "readDenyFloorRequired", "sandboxReadFloor",
     "agentConfigDir", "configLkgPath", "configLkgEnabled",
 ];
@@ -2599,6 +2702,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);
@@ -2669,7 +2775,9 @@ function k8sWorkspaceCache() {
     return { mount, size };
 }
 export function loadConfig() {
-    EXEC_LANE_NOTICE = undefined;
+    const undeclared = ownCredentialDeclarationRefusal();
+    if (undeclared !== undefined)
+        throw new Error(undeclared);
     rejectRetiredEnvs();
     CONFIG_WARNINGS.length = 0;
     CONFIG_NOTICES.length = 0;
@@ -2689,11 +2797,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 });
@@ -2755,12 +2859,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,
@@ -2790,11 +2889,4 @@ export function splitLocalRoots(a) {
         return undefined;
     return { dataRoot: a.localDataRoot, configRoot };
 }
-export function resolveBindHost(config) {
-    const anyServiceAuth = Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
-    const mustNarrow = Boolean(config.allowUnauthedWrites) && !anyServiceAuth;
-    if (config.bindHost && !(mustNarrow && config.bindHostSource === "HOST"))
-        return config.bindHost;
-    return mustNarrow ? "127.0.0.1" : undefined;
-}
 //# sourceMappingURL=config.js.map

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/delegated-session-owner.d.ts

@@ -29,7 +29,7 @@
 import type { SessionPlacement } from "@sema-agent/core";
 import type { SessionFace } from "./session-incarnation.js";
 import type { SqlDialect } from "./plugins/sql-driver.js";
-/** 孤行哨兵属主的前缀(保留主体前缀:`security.ts` 的 `RESERVED_PRINCIPAL_PREFIXES` 登记它,任何身份来源报出带它的主体都在鉴权边界被拒)。 */
+/** 孤行哨兵属主的前缀(保留主体前缀:`principal-shape.ts` 的 `RESERVED_PRINCIPAL_PREFIXES` 登记它,任何身份来源报出带它的主体都在鉴权边界被拒)。 */
 export declare const ORPHAN_SESSION_OWNER_PREFIX = "_orphan:";
 /** 一只推不出属主的子代会话的哨兵属主(每只会话一个值:即便哪天有谁误配出这个串,也只够得着这一只)。 */
 export declare function orphanSessionOwner(sessionId: string): string;