@sema-agent/server 7.101.0 → 7.102.0

package/dist/center-credential.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { resolve as resolvePath } from "node:path";
 import { looksLikeJwt } from "@sema-agent/settings-schema/api/auth-bridge";
+import { CENTER_CREDENTIAL_ENV, judgeCenterCredentialDeclaration, parseCenterCredentialFile } from "@sema-agent/settings-schema";
 export class CenterCredentialUnavailableError extends Error {
     reason;
     constructor(reason) {
@@ -10,20 +11,9 @@ export class CenterCredentialUnavailableError extends Error {
         this.name = "CenterCredentialUnavailableError";
     }
 }
-export const CENTER_TOKEN_ENV = "SEMA_REGISTRY_TOKEN";
-export const CENTER_TOKEN_FILE_ENV = "SEMA_REGISTRY_TOKEN_FILE";
 export function readCenterCredentialDeclaration(env = process.env) {
-    const token = env.SEMA_REGISTRY_TOKEN ?? "";
-    const file = env.SEMA_REGISTRY_TOKEN_FILE ?? "";
-    if (token !== "" && file !== "") {
-        throw new Error(`${CENTER_TOKEN_ENV} and ${CENTER_TOKEN_FILE_ENV} are both set — pick exactly one: ${CENTER_TOKEN_ENV} carries the credential value, ` +
-            `${CENTER_TOKEN_FILE_ENV} names a file re-read on every request (rotation without restart). Two writers on one credential is a guess, not a config.`);
-    }
-    if (file !== "")
-        return { from: "file", path: resolvePath(file) };
-    if (token !== "")
-        return { from: "env", token };
-    return { from: "absent" };
+    const declared = judgeCenterCredentialDeclaration(env);
+    return declared.from === "file" ? { from: "file", path: resolvePath(declared.path) } : declared;
 }
 const digest16 = (s) => createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
 function jwtSubject(bearer) {
@@ -38,56 +28,142 @@ function jwtSubject(bearer) {
         return { missing: "no sub claim" };
     return typeof parsed.sub === "string" && parsed.sub !== "" ? { sub: parsed.sub } : { missing: "sub is not a non-empty string" };
 }
+function userTokenIdentity(bearer) {
+    const s = jwtSubject(bearer);
+    return "sub" in s ? `user-jwt:${digest16(s.sub)}` : `user-jwt-opaque:${digest16(bearer)}`;
+}
 function classify(bearer, worker) {
-    if (looksLikeJwt(bearer)) {
-        const s = jwtSubject(bearer);
-        return { ok: true, kind: "user-jwt", bearer, identity: "sub" in s ? `user-jwt:${digest16(s.sub)}` : `user-jwt-opaque:${digest16(bearer)}` };
-    }
+    if (looksLikeJwt(bearer))
+        return { ok: true, kind: "user-jwt", bearer, identity: userTokenIdentity(bearer) };
     return { ok: true, kind: "pull-token", bearer, identity: pullTokenIdentity(worker), workerScoped: bearer.startsWith("wpt_") };
 }
 export function pullTokenIdentity(worker) {
     return `pull-token:${worker ?? "global"}`;
 }
 const NONE = { ok: true, kind: "none", identity: "none" };
-export function createCenterCredentialSource(declaration, worker, deps = {}) {
-    switch (declaration.from) {
+const PARSER_EMPTY_REASON = "empty";
+function readCredentialText(text, spec, worker, now) {
+    const where = `${CENTER_CREDENTIAL_ENV.tokenFile} ${spec.path}`;
+    const file = parseCenterCredentialFile(text);
+    switch (file.kind) {
+        case "bare":
+            return classify(file.bearer, worker);
+        case "unreadable":
+            return file.reason === PARSER_EMPTY_REASON
+                ? { ok: false, failure: "missing", reason: `${where} is empty` }
+                : { ok: false, failure: "malformed", reason: `${where} does not hold a center credential (${file.reason})` };
+        case "envelope":
+            return readSession(file.envelope, where, spec.multiTenant, now);
+    }
+}
+function readSession(envelope, where, multiTenant, now) {
+    if (multiTenant) {
+        return {
+            ok: false,
+            failure: "multi_tenant_session",
+            reason: `${where} holds a personal sign-in session (a "user-session" envelope) and this deployment is multi-tenant (REQUIRE_PRINCIPAL=true) — a multi-tenant service never acts as one person's session; give it the worker pull token (one bare line) instead`,
+        };
+    }
+    const expiresAt = Date.parse(envelope.expiresAt);
+    if (!Number.isFinite(expiresAt)) {
+        return { ok: false, failure: "malformed", reason: `${where} holds an envelope whose expiresAt is not a readable instant` };
+    }
+    const identity = userTokenIdentity(envelope.accessToken);
+    if (expiresAt <= now) {
+        return { ok: false, failure: "expired", reason: `${where} holds a sign-in session whose access token expired at ${envelope.expiresAt} — not sent (the renewer re-mints it; sign in again if renewal keeps failing)`, identity, expiresAt };
+    }
+    return { ok: true, kind: "user-session", bearer: envelope.accessToken, identity, expiresAt };
+}
+export function createCenterCredentialSource(spec, worker, deps = {}) {
+    const listeners = new Set();
+    const onRead = (listener) => {
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    };
+    const observed = (r) => {
+        for (const listener of listeners)
+            listener(r);
+        return r;
+    };
+    switch (spec.from) {
         case "absent":
-            return { origin: declaration, declared: false, read: () => NONE, health: () => ({ state: "ok" }) };
+            return { origin: spec, declared: false, read: () => observed(NONE), health: () => ({ state: "ok" }), onRead };
         case "env": {
-            const fixed = classify(declaration.token, worker);
-            return { origin: { from: "env" }, declared: true, read: () => fixed, health: () => ({ state: "ok" }) };
+            const fixed = classify(spec.token, worker);
+            return { origin: { from: "env" }, declared: true, read: () => observed(fixed), health: () => ({ state: "ok" }), onRead };
         }
         case "file": {
             const readFile = deps.readFile ?? ((p) => readFileSync(p, "utf8"));
             const now = deps.now ?? Date.now;
             let health = { state: "ok" };
-            const fail = (reason) => {
-                health = health.state === "unreadable" ? { ...health, reason, failures: health.failures + 1 } : { state: "unreadable", reason, since: now(), failures: 1 };
-                return { ok: false, reason };
+            const readOnce = () => {
+                let text;
+                try {
+                    text = readFile(spec.path);
+                }
+                catch (err) {
+                    const code = err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : "read error";
+                    return { ok: false, failure: "missing", reason: `${CENTER_CREDENTIAL_ENV.tokenFile} ${spec.path} is unreadable (${code})` };
+                }
+                return readCredentialText(text, spec, worker, now());
             };
             return {
-                origin: declaration,
+                origin: { from: "file", path: spec.path },
                 declared: true,
                 read() {
-                    let text;
-                    try {
-                        text = readFile(declaration.path);
-                    }
-                    catch (err) {
-                        const code = err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : "read error";
-                        return fail(`${CENTER_TOKEN_FILE_ENV} ${declaration.path} is unreadable (${code})`);
-                    }
-                    const bearer = text.trim();
-                    if (bearer === "")
-                        return fail(`${CENTER_TOKEN_FILE_ENV} ${declaration.path} is empty`);
-                    health = { state: "ok" };
-                    return classify(bearer, worker);
+                    const r = readOnce();
+                    if (r.ok)
+                        health = { state: "ok" };
+                    else if (health.state === "unreadable")
+                        health = { ...health, failure: r.failure, reason: r.reason, failures: health.failures + 1 };
+                    else
+                        health = { state: "unreadable", failure: r.failure, reason: r.reason, since: now(), failures: 1 };
+                    return observed(r);
                 },
                 health: () => health,
+                onRead,
             };
         }
     }
 }
+export const CENTER_CREDENTIAL_REFUSAL_CODES = {
+    malformed: "config.center_credential_malformed",
+    multi_tenant_session: "config.center_credential_user_session_multi_tenant",
+};
+export function judgeCenterCredentialAtBoot(read) {
+    if (read.ok)
+        return { verdict: "serve" };
+    switch (read.failure) {
+        case "missing":
+            return {
+                verdict: "loud",
+                failure: read.failure,
+                reason: read.reason,
+                effect: "every center request fails its own failure arm until the file is readable (config pull keeps env/LKG-less boot, caps fail-closed, lease takes the loud auth-error arm); no on-disk LKG / prompt state is read back (credential identity unknown)",
+            };
+        case "expired":
+            return {
+                verdict: "loud",
+                failure: read.failure,
+                reason: read.reason,
+                effect: "no center request carries the expired token; the renewer re-mints it now when renewal is on (CENTER_CREDENTIAL_RENEW_LEAD_MS > 0), otherwise requests fail their own failure arms until the shell rewrites the file; the on-disk LKG / prompt state of this identity is read back as usual",
+            };
+        case "malformed": {
+            const code = CENTER_CREDENTIAL_REFUSAL_CODES.malformed;
+            return {
+                verdict: "refuse",
+                code,
+                sentence: `center credential refused at boot [${code}]: ${read.reason}. The file must hold one bare token line, or the sign-in envelope the shell writes (a CenterCredentialEnvelope JSON object); sign in again so the shell rewrites it, or fix the file — its content is never echoed.`,
+            };
+        }
+        case "multi_tenant_session": {
+            const code = CENTER_CREDENTIAL_REFUSAL_CODES.multi_tenant_session;
+            return { verdict: "refuse", code, sentence: `center credential refused at boot [${code}]: ${read.reason}.` };
+        }
+    }
+}
 export function scopedTokenNeedsWorker(read, worker) {
     return read.ok && read.kind === "pull-token" && read.workerScoped && !worker;
 }
@@ -95,8 +171,7 @@ export function centerStateBin(worker, identity) {
     return `${worker === undefined ? "global" : `worker-${digest16(worker)}`}.id-${digest16(identity)}`;
 }
 export function credentialIdentityNow(source) {
-    const r = source.read();
-    return r.ok ? r.identity : undefined;
+    return source.read().identity;
 }
 export function answerStillCurrent(source, usedIdentity) {
     return usedIdentity !== undefined && credentialIdentityNow(source) === usedIdentity;
@@ -121,11 +196,12 @@ function pinCredential(source, identity) {
             if (!r.ok)
                 return r;
             if (identity === undefined) {
-                return { ok: false, reason: "this state bin was opened while the center credential was unreadable (identity unknown) — it never talks to the center; the next call runs in the current identity's bin" };
+                return { ok: false, failure: "missing", reason: "this state bin was opened while the center credential was unreadable (identity unknown) — it never talks to the center; the next call runs in the current identity's bin" };
             }
-            return r.identity === identity ? r : { ok: false, reason: "center credential identity changed — this request belongs to the previous identity's state bin and is not sent" };
+            return r.identity === identity ? r : { ok: false, failure: "missing", reason: "center credential identity changed — this request belongs to the previous identity's state bin and is not sent" };
         },
         health: () => source.health(),
+        onRead: (listener) => source.onRead(listener),
     };
 }
 //# sourceMappingURL=center-credential.js.map

package/dist/config-catalog.js

@@ -1,6 +1,8 @@
 import { CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES } from "@sema-agent/core";
+import { CENTER_CREDENTIAL_ENV } from "@sema-agent/settings-schema";
+import { CENTER_CREDENTIAL_RENEW_LEAD_DEFAULT_MS, CENTER_CREDENTIAL_RENEW_LEAD_MAX_MS, CENTER_CREDENTIAL_RENEW_LEAD_MIN_MS } from "./center-credential-renewer.js";
 import { THINKING_FORMATS } from "./model-compat.js";
-import { RESILIENCE_DEFAULTS, TASK_WRITE_FACE_ESCALATIONS } from "./config-types.js";
+import { AUTO_MODE_CLASSIFIER_TIMEOUT_BOUNDS, DRAIN_SECOND_SIGNAL_MIN_GAP_BOUNDS, DRAIN_SECOND_SIGNAL_MIN_GAP_DEFAULT_MS, RESILIENCE_DEFAULTS, TASK_WRITE_FACE_ESCALATIONS } from "./config-types.js";
 import { webSearchProviderFromEnv, WEB_SEARCH_PROVIDERS } from "./plugins/web-search.js";
 import { AUTONOMY_MODES } from "./runtime-governance.js";
 import { REMOTE_EXEC_PROVIDER_WORDS } from "./execution-lane-caps.js";
@@ -78,6 +80,7 @@ export const CONFIG_CATALOG = [
     r("AUTH_BRIDGE_JWKS_URL", "auth", "url", "registry SSO-JWT 的 JWKS 地址(缺省从 issuer 派生)", { danger: SEC }),
     r("AUTONOMY", "auth", "enum", "运维 autonomy 模式,tighten-only 叠到每个 TaskSpec(read-only/plan ⇒ 只读手,ask ⇒ 恒 shellGate);center 腿热且 non-sticky", { danger: SEC, enumValues: AUTONOMY_MODES, configKey: "autonomy", center: cGov("autonomy") }),
     r("AUTO_MODE_CLASSIFIER_FALLBACK", "approval", "enum", "auto 分类器席答不出裁决时的梯子(main=主模型代判 / none=只留分类器那一级,整条拒)", { enumValues: ["main", "none"], danger: SEC, derivedDefaultNote: "未设/空串 ⇒ 不铸键,跟随引擎缺省 main(core 7.18.0 起;空串按未设,与其余词表旋钮同判);none = 7.77.0 及以前的行为逐字;词表外的值启动期拒启。权限轴放宽,升级须知见 DEPLOY-PREREQS", configKey: "autoModeClassifierFallback" }),
+    r("AUTO_MODE_CLASSIFIER_TIMEOUT_MS", "approval", "number", `auto 分类器单级判决上限(ms;缺席 = core 缺省;自托管慢网关按排队 + prefill 留足;一级到点没裁 ⇒ 走下一级,走完仍没裁 ⇒ 这次门控调用整条拒;须为 [${AUTO_MODE_CLASSIFIER_TIMEOUT_BOUNDS.minMs}, ${AUTO_MODE_CLASSIFIER_TIMEOUT_BOUNDS.maxMs}] 内十进制整数,0 / 小数 / 越界拒启)`, { derivedDefaultNote: "未设/空串 ⇒ 不铸键,跟随 core 缺省(本仓不复制上游数字;core 改缺省本旋钮照映不改)", configKey: "autoModeClassifierTimeoutMs" }),
     r("BAKE_CACHE_BASE", "orchestration", "url", "烤镜像 fetch-once 缓存源 base(注入 --cache-base;绝不受调用方控制)"),
     r("BAKE_IMAGE_REGISTRY", "orchestration", "string", "烤镜像自动登记的 registry host 前缀(repo=registry/profile)"),
     r("BAKE_LEASE_MS", "orchestration", "number", "bake 租约窗(ms;runner 心跳推进,过期被 reaper 抢)", { staticDefault: "90000" }),
@@ -89,6 +92,7 @@ export const CONFIG_CATALOG = [
     r("BG_AGENT_RETENTION_MS", "orchestration", "number", "TERMINAL 后台 agent 行保留期(ms,reaper 按 scope 清)", { staticDefault: String(7 * 24 * 60 * 60 * 1000), danger: DATA, configKey: "backgroundAgentRetentionMs" }),
     r("BG_AGENT_STALE_RUNNING_MS", "orchestration", "number", "running 后台 agent 行写者心跳断更超此值翻 failed(ms;下限 10min 硬钳)", { staticDefault: String(15 * 60_000), configKey: "backgroundAgentStaleRunningMs" }),
     r("BIND_HOST", "auth", "string", "监听绑址(显式值恒生效)", { danger: SEC, derivedDefaultNote: "缺席:无鉴权写面(allowUnauthedWrites ∧ 零凭证)自动收窄 127.0.0.1,其余全接口", resolve: (c) => c.bindHost ?? null }),
+    r("CENTER_CREDENTIAL_RENEW_LEAD_MS", "integrations", "number", `center 凭证续签提前量(ms;${CENTER_CREDENTIAL_ENV.tokenFile} 指向人的登录会话信封时,访问令牌离到期 ≤ 本值即由引擎续签并原子改写同一文件;0 = 关续签只读信封;其余须为 [${CENTER_CREDENTIAL_RENEW_LEAD_MIN_MS}, ${CENTER_CREDENTIAL_RENEW_LEAD_MAX_MS}] 内整数,坏值拒启;裸行 / 值形凭证不续签)`, { staticDefault: String(CENTER_CREDENTIAL_RENEW_LEAD_DEFAULT_MS), danger: SEC, configKey: "centerCredentialRenewLeadMs" }),
     r("COMPLIANCE_ADDITIONAL_DENIES", "auth", "csv", "合规档位之上额外拒绝的能力名(只能收紧;词表=core 闭集,拼错拒启)", { danger: SEC }),
     r("COMPLIANCE_PROFILE", "auth", "enum", "本部署合规档位(core compliancePostureResolver 供数;拼错拒启)", { danger: SEC, enumValues: ["hipaa", "zdr"], resolve: (c) => c.compliancePosture?.profile ?? null }),
     r("CONFIG_BOOT_FETCH_BUDGET_MS", "integrations", "number", "boot 首拉配置的抢答窗(ms;过窗以 env/兜底起服,拉取转后台热应用)", { staticDefault: "1500", configKey: "configBootFetchBudgetMs" }),
@@ -128,6 +132,7 @@ export const CONFIG_CATALOG = [
     r("DOCKER_PIDS_LIMIT", "orchestration", "number", "local-docker fork-bomb 背栓(--pids-limit;非法值回 adapter 默认 512+warn)", { danger: SEC, derivedDefaultNote: "缺席 ⇒ adapter 默认 512" }),
     r("DOCKER_SANDBOX_ENV", "orchestration", "secret", "local-docker 车道每条 docker exec 以 -e 注入的本进程 env 点名表(NAME,NAME;点到的键从 worker env 原样取,值不进 spec/center/日志;与 LSP_ENV_ALLOW / E2B_SANDBOX_ENV 同一只解析器与「点名放行」谓词:形错 / 点名名单型旋钮拒启且不回显值;本进程环境里没有的名按序号 warn、不转发;只在本车道被选中时求值;原文按凭据类对待:只回在场位、不进任何子进程)", { danger: SEC }),
     r("DRAIN_GRACE_MS", "limitsHttp", "number", "SIGTERM 优雅排空窗(ms;期间新计费提交 503+Retry-After)。出厂默认是**服务器部署**的取值;壳自 spawn 的引擎会被壳注入更短的窗 ⇒ 排壳形关机预算时以本行的 effectiveValue(= 本进程实际生效值)为准,不照抄 staticDefault", { staticDefault: String(10 * 60 * 1000), configKey: "drainGraceMs", center: cLimits("drainGraceMs") }),
+    r("DRAIN_SECOND_SIGNAL_MIN_GAP_MS", "limitsHttp", "number", `排空期「第二发信号 = 硬停」的最小间隔(ms;锚 = 排空起点。SIGTERM / SIGINT 与起点相隔不足 ⇒ 同一拍的重复投递,一行 drain_duplicate_signal_ignored 后忽略、排空继续;0 = 关,恒按第二发硬停;须为 [${DRAIN_SECOND_SIGNAL_MIN_GAP_BOUNDS.minMs}, ${DRAIN_SECOND_SIGNAL_MIN_GAP_BOUNDS.maxMs}] 内十进制整数(上界 = DRAIN_GRACE_MS 地板),小数 / 负数 / 越界拒启)`, { staticDefault: String(DRAIN_SECOND_SIGNAL_MIN_GAP_DEFAULT_MS), configKey: "drainSecondSignalMinGapMs" }),
     r("DURABLE_APPROVAL", "approval", "boolean", "durable suspend/resume HITL(需 SQL 店;决定 checkpointStore 与 /v1/approvals 面的存在性)", { danger: SEC, derivedDefaultNote: "posture 三态(S-178):显式词恒赢,缺席 = 单用户(REQUIRE_PRINCIPAL≠true)且有耐久店 ⇒ on / 多租户或无耐久店 ⇒ off;生效来源见 GET /v1/diagnostics/wiring 的 serverGates.durableApproval.source", configKey: "durableApproval" }),
     r("E2B_ALLOW_NET", "orchestration", "boolean", "e2b 沙箱出网许可", { danger: SEC, derivedDefaultNote: "缺席 ⇒ 不铸键(adapter 默认允许)" }),
     r("E2B_API_KEY", "orchestration", "secret", "E2B 车道 API 凭据(REMOTE_EXEC=e2b 必需件)", { danger: [...SEC, ...BILL] }),
@@ -157,7 +162,7 @@ export const CONFIG_CATALOG = [
     r("HOST_BG_DEFAULT_TIMEOUT_SEC", "orchestration", "number", "host 后台 shell 缺省超时(秒)", { staticDefault: "300" }),
     r("HOST_BG_ENABLED", "orchestration", "boolean", "host 车道后台 shell 开关", { staticDefault: "true" }),
     r("HOST_BG_FILE_CAP", "orchestration", "number", "host 后台 shell 磁盘护栏(字节;失控输出被 reap)", { staticDefault: String(64 * 1024 * 1024) }),
-    r("HOST_BG_KILL_GRACE_MS", "orchestration", "number", "host 后台 shell SIGTERM→SIGKILL 宽限(ms)", { staticDefault: "1000" }),
+    r("HOST_BG_KILL_GRACE_MS", "orchestration", "number", "host 后台 shell SIGTERM→SIGKILL 宽限(ms);会话删除 / 会话停止口在软停与硬收之间等同一只", { staticDefault: "1000" }),
     r("HOST_BG_MAX_CONCURRENT", "orchestration", "number", "host 后台 shell 并发帽", { staticDefault: "8" }),
     r("HOST_BG_MAX_TIMEOUT_SEC", "orchestration", "number", "host 后台 shell 超时上限(秒)", { staticDefault: "1800" }),
     r("HOST_BG_MEM_CAP", "orchestration", "number", "host 后台 shell 内存流护栏(字节)", { staticDefault: String(8 * 1024 * 1024) }),
@@ -395,8 +400,8 @@ export const CONFIG_CATALOG = [
     r("SEMA_PIP_INDEX", "orchestration", "url", "SANDBOX_PKG_SOURCE=custom 的显式 pip index 地址"),
     r("SEMA_REGISTRY_ADMIN_TOKEN", "integrations", "secret", "写 center 的管理凭证(仅 boot 上报执行公钥用;刻意不入 ServiceConfig —— 不进 configHash/日志面)", { danger: SEC, scope: "bootstrap-only" }),
     r("SEMA_REGISTRY_DRY_RUN", "integrations", "boolean", "center 腿 dry-run(拉而不应用)", { staticDefault: "false" }),
-    r("SEMA_REGISTRY_TOKEN", "integrations", "secret", "center 拉取凭据(值形;与 SEMA_REGISTRY_TOKEN_FILE 二选一,都设=拒启)", { danger: SEC }),
-    r("SEMA_REGISTRY_TOKEN_FILE", "integrations", "path", "center 拉取凭据文件(每条中心请求都重读 ⇒ 轮换 / 换账号不重启;与 SEMA_REGISTRY_TOKEN 二选一,都设=拒启;文件不可读=响亮 + 健康态 unreadable,不当作无凭证)", { danger: SEC }),
+    r(CENTER_CREDENTIAL_ENV.token, "integrations", "secret", `center 拉取凭据(值形;与 ${CENTER_CREDENTIAL_ENV.tokenFile} 二选一,都设=拒启)`, { danger: SEC }),
+    r(CENTER_CREDENTIAL_ENV.tokenFile, "integrations", "path", `center 拉取凭据文件(每条中心请求都重读 ⇒ 轮换 / 换账号不重启;与 ${CENTER_CREDENTIAL_ENV.token} 二选一,都设=拒启;内容两种类:裸行 = 静态 bearer / JSON 信封 user-session = 人的登录会话(可续签,S-698);文件不可读 / 为空 = 响亮 + 健康态 unreadable,不当作无凭证;内容读不成 / 多租户读到信封 = 拒启)`, { danger: SEC }),
     r("SEMA_REGISTRY_URL", "integrations", "url", "sema-registry 地址(设了=remote 配置源开关)"),
     r("SEMA_REGISTRY_WORKER", "integrations", "string", "本 worker 在 center 的名字(per-worker effective)"),
     r("SEMA_UV_INDEX", "orchestration", "url", "SANDBOX_PKG_SOURCE=custom 的显式 uv index 地址"),

package/dist/config-center/apply-effective.js

@@ -8,7 +8,7 @@ import { stageLimits } from "./stage-limits.js";
 import { APPROVAL_GROUP_KEYS, BATCH1_LIMIT_KEYS } from "./hot-keys-registry.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
 import { crossInvariant } from "../config-invariants.js";
-import { judgeCatalogEntries, mintedRefusedNames, refusalEventOf, refusalWarnFields, REFUSED_NAME_MINTED_CODE, unreadableDroppedRefusal } from "../model-entry-refusal.js";
+import { judgeCatalogEntries, mintedRefusedNames, refusalEventOf, refusalWarnFields, malformedDroppedCarrierRefusal } from "../model-entry-refusal.js";
 import { gateIntentUnserviceableReason } from "../approval.js";
 import { refusedGroups } from "./apply-ledger.js";
 const charsPerTokenOf = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
@@ -215,11 +215,10 @@ function modelPlaneGroupReport(group) {
 const ROLE_BINDING_UNAVAILABLE_HINT = "tasks resolving this role fail: alias/tier expansion cannot mint this name; the engine refuses it loud — bind the role to a usable model, or make the entry usable (see the entry's own warn)";
 function stageModelPlane(config, eff, logger, sealedKeys) {
     const enabled = (eff.models?.models ?? []).filter((m) => m.enabled !== false);
-    const droppedEnabled = eff.models?.droppedIdentities;
-    if (enabled.length === 0 && !(Array.isArray(droppedEnabled) && droppedEnabled.length > 0))
+    const verdict = judgeCatalogEntries(enabled, { anthropicRouteMounted: config.anthropic !== undefined }, eff.models?.droppedIdentities);
+    if (enabled.length === 0 && Object.keys(verdict.refused).length === 0 && verdict.malformed.length === 0)
         return { stages: { collab: stageCollabDomain(eff) } };
     {
-        const verdict = judgeCatalogEntries(enabled, { anthropicRouteMounted: config.anthropic !== undefined }, eff.models.droppedIdentities);
         for (const [name, r] of Object.entries(verdict.refused))
             logger?.warn(refusalEventOf(r.reason), refusalWarnFields(name, r));
         const refuse = (invariant, reason, detail = {}) => {
@@ -232,14 +231,8 @@ function stageModelPlane(config, eff, logger, sealedKeys) {
             });
             return { stages: {}, rejected: { keys: MODEL_PLANE_GROUP_KEYS, reason, invariant }, refused: verdict.refused };
         };
-        if (verdict.unreadable.length > 0) {
-            logger?.warn("sema_registry_model_entry_dropped_unproven", {
-                entries: [...verdict.unreadable],
-                code: REFUSED_NAME_MINTED_CODE,
-                hint: "these catalog entries were dropped by the settings-schema read and the raw document could not be matched to the snapshot that was parsed (e.g. the local file changed between two reads) — their names cannot be proven, so no tombstone can be minted and the candidate's model plane is refused (a name nobody can prove cannot be shown not to be re-minted by the tier/alias expansion); the next read re-judges",
-            });
-            return refuse("refused-names-not-minted", unreadableDroppedRefusal(verdict.unreadable));
-        }
+        if (verdict.malformed.length > 0)
+            return refuse("refused-names-not-minted", malformedDroppedCarrierRefusal(verdict.malformed), { entries: [...verdict.malformed] });
         const usable = verdict.usable;
         const models = {};
         const modelApiKeyEnv = {};

package/dist/config-center/center-request.d.ts

@@ -1,5 +1,7 @@
 import { type CenterCredentialSource } from "../center-credential.js";
 export declare const SCHEMA_MAJOR_HEADER = "x-sema-schema-major";
+/** 8s:对中心请求 / 响应式调用的传输上界(拉配置 / 两条 principal 视图 / 内容拉取 / 凭证续签同一值)。 */
+export declare const CENTER_PULL_TIMEOUT_MS = 8000;
 /** 已装 settings-schema 的 major(机器派生)。版本号不成形 ⇒ 模块装载即抛(装坏了的包不该带着一个猜出来的
  *  major 去跟中心协商 wire 形)。 */
 export declare const SETTINGS_SCHEMA_MAJOR: string;
@@ -49,6 +51,17 @@ export interface CenterRequestInit {
     readonly timeoutMs: number;
     readonly fetchImpl?: typeof fetch;
 }
+/**
+ * S-698 —— 凭证续签:`POST {issuer}/api/v1/auth/token/refresh`,form `refresh_token=…`(settings-schema `AUTH_V1_PATHS.tokenRefresh`)。
+ *  · 以 `issuer` 为根(可带路径前缀;同源与否由续签器先判,本函数只装配);query / fragment 不带过去。
+ *  · **不带 Authorization**:这条端点凭 refresh token 认人,手里的 access token 可能已经过期。
+ *  · `redirect: "manual"`:3xx 不跟 —— POST 307/308 会把体(= refresh token)原样带去 `Location`,同源判据在重定向面前失效。
+ *    3xx 原样交回,续签器按「被拒」处置。
+ */
+export declare function centerTokenRefresh(issuer: string, refreshToken: string, init: {
+    readonly timeoutMs: number;
+    readonly fetchImpl?: typeof fetch;
+}): Promise<Response>;
 /**
  * 对中心发一条请求。返回响应与**这次请求所用凭证的身份**(调用方据此给拿回来的候选打分箱标记,
  * 见 `boot/config-center.ts` 的 LKG / prompt 状态分箱)。

package/dist/config-center/center-request.js

@@ -1,6 +1,8 @@
 import settingsSchemaPackage from "@sema-agent/settings-schema/package.json" with { type: "json" };
+import { AUTH_V1_PATHS } from "@sema-agent/settings-schema/api/auth";
 import { CenterCredentialUnavailableError } from "../center-credential.js";
 export const SCHEMA_MAJOR_HEADER = "x-sema-schema-major";
+export const CENTER_PULL_TIMEOUT_MS = 8000;
 export const SETTINGS_SCHEMA_MAJOR = (() => {
     const version = settingsSchemaPackage.version;
     const m = /^(\d+)\.\d+\.\d+/.exec(version);
@@ -19,6 +21,7 @@ export function pullViewQuery(view) {
 function contentRoot(kind) {
     switch (kind) {
         case "user-jwt":
+        case "user-session":
             return "/api/v1/me";
         case "pull-token":
         case "none":
@@ -45,10 +48,27 @@ function routePath(route, kind) {
             return "/api/config/execution-keys";
     }
 }
-export async function centerFetch(center, route, init) {
-    const scheme = new URL(center.baseUrl).protocol;
+function assertHttpScheme(url, what) {
+    const scheme = url.protocol;
     if (scheme !== "http:" && scheme !== "https:")
-        throw new Error(`SEMA_REGISTRY_URL must be http(s), got "${scheme}"`);
+        throw new Error(`${what} must be http(s), got "${scheme}"`);
+}
+export async function centerTokenRefresh(issuer, refreshToken, init) {
+    const url = new URL(issuer);
+    assertHttpScheme(url, "center credential issuer");
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}${AUTH_V1_PATHS.tokenRefresh}`;
+    url.search = "";
+    url.hash = "";
+    return (init.fetchImpl ?? fetch)(url, {
+        method: "POST",
+        headers: { [SCHEMA_MAJOR_HEADER]: SETTINGS_SCHEMA_MAJOR, "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ refresh_token: refreshToken }).toString(),
+        redirect: "manual",
+        signal: AbortSignal.timeout(init.timeoutMs),
+    });
+}
+export async function centerFetch(center, route, init) {
+    assertHttpScheme(new URL(center.baseUrl), "SEMA_REGISTRY_URL");
     const cred = center.credential.read();
     if (!cred.ok)
         throw new CenterCredentialUnavailableError(cred.reason);

package/dist/config-center/facade.d.ts

@@ -49,7 +49,7 @@
  */
 export { fetchEffective, fetchPrincipalCaps, fetchPrincipalOrgMemory, ConfigCenterHttpError, fetchSkillContent, fetchPromptArtifact, fetchPromptBlob, } from "./http-client.js";
 export { mutateInPlace, applyEffective, type ApplyReport, applyRuntimeGates, applyRuntimeHot, resolveDefaultModelName, logEffectiveDiff, MODEL_PLANE_DOMAINS, type ModelPlaneDomain, type ModelPlaneOf, withModelPlaneOf, buildEnvOnlyModelPlane, } from "./apply-effective.js";
-export { restartReasons, modelPlaneChanged, type RestartSlice, type RestartSliceCtx, type RestartSignal, } from "./restart-signal.js";
+export { restartReasons, modelPlaneChanged, type RestartSlice, type RestartSliceCtx, type EngineRestartSignal, } from "./restart-signal.js";
 export { applyCenterSkills, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./skills-mcp.js";
 export { applyCenterReadFace, CENTER_READ_FACE_LIVE_KEYS, type CenterReadFaceApply, type CenterReadFaceReport, type ReadFaceBaseline } from "./read-face.js";
 export type { CenterSkillManifest, CenterMcpServer, CenterA2aPeer, CenterModel, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";

package/dist/config-center/http-client.js

@@ -2,9 +2,8 @@ import { createHash } from "node:crypto";
 import { readEffectiveWire, PrincipalCapsWire } from "@sema-agent/settings-schema";
 import { centerPromptsFromEffective } from "../prompts-domain-validate.js";
 import { splitFoldedReadWarnings, withDroppedIdentities } from "./read-warnings.js";
-import { centerFetch } from "./center-request.js";
+import { CENTER_PULL_TIMEOUT_MS, centerFetch } from "./center-request.js";
 import { answerStillCurrent } from "../center-credential.js";
-const CENTER_PULL_TIMEOUT_MS = 8000;
 export async function fetchEffective(center, etag, fetchImpl = fetch, worker) {
     const { res, identity } = await centerFetch(center, { kind: "effective", worker }, { etag, timeoutMs: CENTER_PULL_TIMEOUT_MS, fetchImpl });
     if (res.status === 304)
@@ -19,9 +18,7 @@ export async function fetchEffective(center, etag, fetchImpl = fetch, worker) {
         delete wire.prompts;
     else
         wire.prompts = centerPrompts;
-    const rawModels = typeof body === "object" && body !== null && !Array.isArray(body) ? body.models : undefined;
-    const parsedModels = wire.models?.models;
-    const { domainErrors, droppedEntries, droppedIdentities } = splitFoldedReadWarnings(warnings, { raw: rawModels, parsed: Array.isArray(parsedModels) ? parsedModels : undefined });
+    const { domainErrors, droppedEntries, droppedIdentities } = splitFoldedReadWarnings(warnings);
     const effective = withDroppedIdentities(wire, droppedIdentities);
     return {
         effective,

package/dist/config-center/read-warnings.d.ts

@@ -25,7 +25,7 @@
  * 候选门整拒,而它在 1.10.0 上零告警零 domainErrors(亲验读数)。兼容臂的关窗观测归属主(settings-schema 的
  * `onWarning` 流),不借候选门这条带副作用的通道传信息。
  */
-import { type ConfigPath, type EffectiveReadWarning } from "@sema-agent/settings-schema";
+import { type EffectiveReadWarning } from "@sema-agent/settings-schema";
 /** 折叠产物:`scope` 决定消费方做什么 —— `"domain"` 进候选门(`domainErrors`),`"entry"` 进逐条丢弃面(`droppedEntries`)。 */
 export type FoldedReadWarning = {
     readonly scope: "domain";
@@ -58,72 +58,43 @@ export declare function describeSchemaIssueFields(error: unknown): string[];
 /** null = 不入诊断面(`hosts-grandfathered` / `legacy-governance-lifted`:值已被收编接受,与本地店同口径)。 */
 export declare function foldEffectiveReadWarning(w: EffectiveReadWarning): FoldedReadWarning | null;
 /**
- * 🔴 S-712 —— 一条被 schema 逐条丢掉的**启用**目录条目的身份(模型面墓碑的来源;载体 = `EffectiveConfig.models.droppedIdentities`,
+ * 🔴 S-712 —— 一条被 schema 逐条丢掉的**启用**、**有名**目录条目的身份(模型面墓碑的来源;载体 = `EffectiveConfig.models.droppedIdentities`,
  * 随 effective 走 —— 盘上 LKG 从同一个对象落盘,重启从 LKG 起服墓碑不丢)。
  *
  * 为什么要交出身份:条目被丢之后它的名字从目录里消失,而档位增广(core `expandTiers`)会把一个**空出来的**档位词 / CC 别名
  * (条目恰好叫 `sonnet` / `pro` …)重新铸到另一条条目上 —— 显式点它的请求与点名它的角色绑定就这样被静默换了目的地
  * (gpt-6 腿 F2 / F3,真复现)。身份进 `modelRefusals` 之后,不变量 `refused-names-not-minted` 才判得到它。
  *
- * 🔐 纯身份,不含值:`name` / `id` / `provider` 只取**字符串**(条目自己写的词,本就进日志与拒因句),`fields` 是坏字段的
- * **键路径**,`issues` 是 {@link describeSchemaIssues} 的一行(键名 + 类型词)—— 被丢条目的原值(可能是一段贴错位置的凭据)
- * 绝不进载体、日志、LKG 与 400 拒因句。
+ * 🔐 纯身份,不含值:`name` / `id` 取自告警的 `identity`(settings-schema 6.1.0:只取被丢条目原文里的字符串形,脱敏器会改动的串
+ * 整键扣下),`fields` 是坏字段的**键路径**,`issues` 是 {@link describeSchemaIssues} 的一行(键名 + 类型词)—— 被丢条目的原值
+ * (可能是一段贴错位置的凭据)绝不进载体、日志、LKG 与 400 拒因句。
  */
 export interface DroppedModelIdentity {
     /** 出门形坐标(`models.1`),与同一次读的 `droppedEntries[].entry` 同一串。 */
     readonly entry: string;
-    /** 条目写的 `name`。**缺席 = 身份证明不了**(只剩一形:原文档与本次解析对不上 / 坐标在原文档里不存在,见 {@link droppedEntryIdentity})
-     *  ⇒ 模型面整组拒:证明不了的名字无从证明它不被增广铸出。原文档那一格读到了却没有字符串名的行**不进**载体(没有可保留的名字,
-     *  与停用同处置 —— 7.101.0 验修轮 V-2)。 */
-    readonly name?: string;
+    /** 条目写的 `name`(读腿只为有名的行铸载体)。载体上缺了它 = 载体形不对(LKG 载体被改 / 手写 effective)⇒ 模型面整组拒,
+     *  判在 `model-entry-refusal.ts` `judgeCatalogEntries`。 */
+    readonly name: string;
     readonly id?: string;
-    readonly provider?: string;
     readonly fields: readonly string[];
     readonly issues: string;
 }
-/** 本次读的模型域**原文**与**解析产物**(两腿各自手里都有这两件:远端 = 响应体与 `readEffectiveWire` 输出;本地 = 盘上
- *  `config.d/models.json` 与 `FileConfigStore` 输出)。 */
-export interface ModelsDomainSource {
-    /** 模型域的原始文档(`{ models: [...], roles, … }`);读不到 ⇒ `undefined`(身份一律证明不了)。 */
-    readonly raw: unknown;
-    /** 同一次读解析后幸存的条目(schema 逐条丢弃之后的 `models.models`)。 */
-    readonly parsed: readonly unknown[] | undefined;
-}
-/**
- * 一条被丢行在原文档里那一格的读数 —— **三态**(7.101.0 验修轮 V-2,规则变小:「读不出」只剩一种含义):
- *  · `named`:格读到了、`name` 是字符串 ⇒ 身份已定(启用的铸墓碑,停用的不是);
- *  · `nameless`:格读到了、没有字符串 `name`(`null` / 数 / 整格不是对象)⇒ 身份**也**已定:**没有可保留的名字** —— 请求、
- *    `@`-mention、角色绑定都点不到一个非字符串名,档位增广也铸不出它 ⇒ 与 `enabled:false` 同处置(不是墓碑、不拒组);
- *  · `undefined`(由 {@link droppedEntryIdentity} 答):格读不到 —— 坐标在原文档里不存在;调用方在原文档与本次解析对不上
- *    (`sameRead` 假)时根本不来读 ⇒ 两者同是「身份证明不了」,交一条不带 `name` 的载体(模型面据此整组拒)。
- * 此前 `nameless` 被折进「读不出」⇒ 一行 `{ name: null }` 的坏行(哪怕是停用的)就让整个模型面被拒(codex 验修腿 V-2,boot 腿对
- * v7.100.0 的窄回归:那时 boot 对同一文档宽容采纳幸存条目)。
- */
-export type DroppedEntryCell = {
-    readonly kind: "named";
-    readonly name: string;
-    readonly id?: string;
-    readonly provider?: string;
-    readonly enabled: boolean;
-} | {
-    readonly kind: "nameless";
-};
-/**
- * 🔴 S-712 **唯一**的身份读法:按告警坐标(`path`,模型域文档内的段坐标 —— settings-schema 已把它回写成原文档坐标)回读
- * 原文档那一格,答 {@link DroppedEntryCell} 三态之一;坐标在原文档里走不通 ⇒ `undefined`(格读不到)。字符串才算
- * (`name` / `id` / `provider`),`enabled` 只认字面 `false` 为停用。
- * settings-schema 6.1.0 的 `entry-dropped` 自带 `name` / `id` 到货后,本函数改读告警(同一只函数,换数据源),原文档入参随之删除。
- */
-export declare function droppedEntryIdentity(rawDoc: unknown, path: ConfigPath): DroppedEntryCell | undefined;
 /**
  * 两条读腿(远端 `http-client.ts` / 本地 `config-provider.ts`)共用的**分面单点**:折叠产物按 `scope` 分进候选门
  * (`domainErrors`)与逐条丢弃面(`droppedEntries`)。`switch` 穷举 —— 加一种 scope 不补臂 = 编译红,两腿不会各分各的。
  * 文案**未脱敏**:进日志流之前各腿在自己的产出边界上过 `redactConfigError`(与 `domainErrors` 同一道)。
- * S-712:同一次折叠把被丢**模型目录条目**的身份交出(`droppedIdentities`,见 {@link DroppedModelIdentity}),按 {@link DroppedEntryCell}
- * 三态分流:有名且启用 ⇒ 墓碑;停用的、没有字符串名的 ⇒ 不进载体(停用 = 不在目录,与 7.100.0 同义;无名 = 没有可保留的名字);
- * 格读不到 / 原文档对不上 ⇒ 不带 `name` 的载体(证明不了)。坏行本身照样走 `droppedEntries`(坐标 + 字段,不带值)。
+ *
+ * 🔴 S-712 身份规则(一条,数据源 = 告警自带的 `identity`,settings-schema 6.1.0 在**同一次解析**里从被丢条目原文取 —— 本仓不再回读原文档):
+ * **`identity.name` 是字符串 ⇒ 有名;有名且 `identity.enabled !== false` ⇒ 墓碑(进载体);其余一律不进载体。**
+ *  · 有名而停用 ⇒ 停用 = 不在目录(与 7.100.0 同义);
+ *  · 没有字符串名 —— `identity` 在场而无 `name`,或 `identity` 整个缺席 ⇒ **无名可留**,与停用同处置。按 settings-schema 6.1.0 的铸点
+ *    (`config-fns.ts` `readEntryIdentity`),「没有名」有两个成因、刻意不分:原文 `name` 不是字符串(`null` / 数 / 整行不是对象),
+ *    或是字符串但脱敏器会改动它(秘密形 —— 扣下不出门)。后者对本判据同样安全:档位增广只铸闭集词(`ultra` / `max` / `pro` /
+ *    `flash` / `lite`、CC 别名、`best`),没有一个是秘密形,一个被扣下的名字无从被铸出;它的代价只是显式点它的请求拿到「未知模型」
+ *    而不是 `request.model_unavailable`(那个名字本来也不许进日志与拒因句)。
+ * 坏行本身照样走 `droppedEntries`(坐标 + 字段,不带值)。
  */
-export declare function splitFoldedReadWarnings(warnings: readonly EffectiveReadWarning[], models: ModelsDomainSource): {
+export declare function splitFoldedReadWarnings(warnings: readonly EffectiveReadWarning[]): {
     domainErrors: Array<{
         domain: string;
         error: string;

package/dist/config-center/read-warnings.js

@@ -68,38 +68,10 @@ export function foldEffectiveReadWarning(w) {
         }
     }
 }
-const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-export function droppedEntryIdentity(rawDoc, path) {
-    let at = rawDoc;
-    for (const seg of path) {
-        if (typeof seg === "number") {
-            if (!Array.isArray(at) || !Number.isInteger(seg) || seg < 0 || seg >= at.length)
-                return undefined;
-            at = at[seg];
-        }
-        else {
-            if (!isRecord(at) || !Object.hasOwn(at, seg))
-                return undefined;
-            at = at[seg];
-        }
-    }
-    if (!isRecord(at) || typeof at.name !== "string")
-        return { kind: "nameless" };
-    return { kind: "named", name: at.name, ...(typeof at.id === "string" ? { id: at.id } : {}), ...(typeof at.provider === "string" ? { provider: at.provider } : {}), enabled: at.enabled !== false };
-}
 function isModelEntryDrop(w) {
     return w.kind === "entry-dropped" && w.domain === "models" && w.path.length === 2 && w.path[0] === "models" && typeof w.path[1] === "number";
 }
-function sameRead(source, dropped) {
-    const rawModels = isRecord(source.raw) ? source.raw.models : undefined;
-    if (!Array.isArray(rawModels) || source.parsed === undefined)
-        return false;
-    if ([...dropped].some((i) => i >= rawModels.length))
-        return false;
-    const survivors = rawModels.filter((_, i) => !dropped.has(i));
-    return survivors.length === source.parsed.length && survivors.every((s, k) => isRecord(s) && isRecord(source.parsed[k]) && s.name === source.parsed[k].name);
-}
-export function splitFoldedReadWarnings(warnings, models) {
+export function splitFoldedReadWarnings(warnings) {
     const domainErrors = [];
     const droppedEntries = [];
     for (const w of warnings) {
@@ -119,28 +91,14 @@ export function splitFoldedReadWarnings(warnings, models) {
             }
         }
     }
-    const modelDrops = warnings.filter(isModelEntryDrop);
-    const readable = sameRead(models, new Set(modelDrops.map((w) => w.path[1])));
     const droppedIdentities = [];
-    for (const w of modelDrops) {
-        const unproven = { entry: formatConfigPath(w.path), fields: describeSchemaIssueFields(w.error), issues: describeSchemaIssues(w.error) ?? "(schema issues unreadable)" };
-        const cell = readable ? droppedEntryIdentity(models.raw, w.path) : undefined;
-        if (cell === undefined) {
-            droppedIdentities.push(unproven);
+    for (const w of warnings) {
+        if (!isModelEntryDrop(w))
             continue;
-        }
-        switch (cell.kind) {
-            case "nameless":
-                break;
-            case "named":
-                if (cell.enabled)
-                    droppedIdentities.push({ ...unproven, name: cell.name, ...(cell.id !== undefined ? { id: cell.id } : {}), ...(cell.provider !== undefined ? { provider: cell.provider } : {}) });
-                break;
-            default: {
-                const never = cell;
-                throw new Error(`unhandled dropped-entry cell: ${JSON.stringify(never)}`);
-            }
-        }
+        const identity = w.identity;
+        if (identity?.name === undefined || identity.enabled === false)
+            continue;
+        droppedIdentities.push({ entry: formatConfigPath(w.path), name: identity.name, ...(identity.id !== undefined ? { id: identity.id } : {}), fields: describeSchemaIssueFields(w.error), issues: describeSchemaIssues(w.error) ?? "(schema issues unreadable)" });
     }
     return { domainErrors, droppedEntries, droppedIdentities };
 }