@sema-agent/server 7.98.0 → 7.99.0

package/dist/boot/config-center.js

@@ -11,7 +11,8 @@ import { applyCatalogToSource, withPromptArtifactBackfill } from "../capabilitie
 import { validatePromptsDomain, CORE_ENGINE_VERSION } from "../prompts-domain-validate.js";
 import { centerScenarios, centerScenarioDetails } from "../capabilities/scenarios.js";
 import { configLkgEnabled, isRosterGateArmed } from "../config.js";
-import { defaultLkgPath, defaultSkillCacheDir, saveLkg, loadLkg } from "../config-lkg.js";
+import { defaultLkgPath, defaultSkillCacheDir, saveLkg, loadLkg, legacyV1LkgPath, migrateV1Lkg } from "../config-lkg.js";
+import { answerStillCurrent, centerStateBin, credentialIdentityNow } from "../center-credential.js";
 import { centerManagedConfigKeys } from "../config-center/apply-effective.js";
 import { createConfigProvider, raceBootFetch, BOOT_FETCH_DEFERRED } from "../config-provider.js";
 import { executionLaneCaps, executionLaneOf } from "../execution-lane-caps.js";
@@ -53,6 +54,43 @@ export async function createConfigCenterRuntime(ctx) {
     let bootSkillStale = false;
     let pendingRestart;
     const cc = config.configCenter;
+    const bootCredential = cc?.credential.read();
+    if (cc !== undefined && bootCredential !== undefined && !bootCredential.ok) {
+        logger.error("center_credential_unreadable", {
+            key: "SEMA_REGISTRY_TOKEN_FILE",
+            reason: bootCredential.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)",
+        });
+    }
+    const currentIdentity = () => (cc === undefined ? undefined : credentialIdentityNow(cc.credential));
+    const candidateIdentity = new WeakMap();
+    const candidateIdentityOf = (eff) => candidateIdentity.get(eff);
+    const validatorIdentity = new Map();
+    const bindValidator = (etag, identity) => {
+        if (etag === undefined)
+            return;
+        validatorIdentity.delete(etag);
+        validatorIdentity.set(etag, identity);
+        const oldest = validatorIdentity.keys().next();
+        if (validatorIdentity.size > 16 && oldest.done !== true)
+            validatorIdentity.delete(oldest.value);
+    };
+    const pullEffective = async (provider, etag) => {
+        if (provider.kind === "local")
+            return provider.fetchEffective(etag);
+        const before = currentIdentity();
+        const conditional = etag !== undefined && before !== undefined && validatorIdentity.get(etag) === before ? etag : undefined;
+        const r = await provider.fetchEffective(conditional);
+        const used = r === null ? before : r.credentialIdentity;
+        if (cc === undefined || !answerStillCurrent(cc.credential, used)) {
+            throw new Error("center credential identity changed while the effective pull was in flight — response discarded; the next pull runs under the current credential");
+        }
+        if (r !== null) {
+            candidateIdentity.set(r.effective, used);
+            bindValidator(r.etag, used);
+        }
+        return r;
+    };
     let sealedKeys;
     try {
         sealedKeys = await ensureSealedKeyStore(join(config.localDataRoot ?? localRoot, "sealed-key"), logger);
@@ -70,7 +108,7 @@ export async function createConfigCenterRuntime(ctx) {
     const configProvider = cc || config.configProvider === "local"
         ? createConfigProvider({
             ...(config.configProvider ? { provider: config.configProvider } : {}),
-            ...(cc ? { configCenter: { baseUrl: cc.baseUrl, token: cc.token, worker: cc.worker, dryRun: cc.dryRun } } : {}),
+            ...(cc ? { configCenter: { baseUrl: cc.baseUrl, credential: cc.credential, worker: cc.worker, dryRun: cc.dryRun } } : {}),
             ...(config.configProvider === "local" ? { localDir: localRoot } : {}),
         })
         : undefined;
@@ -88,41 +126,106 @@ export async function createConfigCenterRuntime(ctx) {
         if (!pendingCatalogFaces)
             return;
         const { target } = pendingCatalogFaces;
-        if (await applyCatalogToSource(promptSource, target, centerPrompts, logger, phase)) {
+        if (await applyCatalogToSource(catalogSource, target, centerPrompts, logger, phase)) {
             centerPrompts = target;
             pendingCatalogFaces = undefined;
         }
     };
     const promptEpochDir = join(config.localDataRoot ?? localRoot, "prompt-epoch");
-    const promptStateDir = join(promptEpochDir, "state", cc?.worker === undefined ? "global" : `worker-${createHash("sha256").update(cc.worker).digest("hex").slice(0, 16)}`);
-    const withByDigestBackfill = (inner) => cc?.baseUrl ? withPromptArtifactBackfill(inner, (d) => fetchPromptArtifact(cc.baseUrl, cc.token, d), logger) : inner;
+    const promptStateRoot = join(promptEpochDir, "state");
+    let promptStateIdentity = currentIdentity();
+    const promptStateBin = () => (cc === undefined ? "global" : promptStateIdentity === undefined ? undefined : centerStateBin(cc.worker, promptStateIdentity));
+    const storePerBin = (make) => {
+        const stores = new Map();
+        return (bin) => {
+            const hit = stores.get(bin);
+            if (hit !== undefined)
+                return hit;
+            const made = make(bin);
+            stores.set(bin, made);
+            return made;
+        };
+    };
+    const fileStateStoreFor = storePerBin((bin) => new FilePromptSourceStateStore(join(promptStateRoot, bin)));
+    const binnedPromptStateStore = (storeFor) => ({
+        load: async () => {
+            const bin = promptStateBin();
+            return bin === undefined ? undefined : storeFor(bin).load();
+        },
+        save: async (state) => {
+            const bin = promptStateBin();
+            if (bin === undefined)
+                throw new Error("center credential identity unknown (credential unreadable at adoption) — prompt source state not persisted");
+            await storeFor(bin).save(state);
+        },
+    });
+    let promptPersisted;
+    const recordingStateStore = (inner) => ({
+        load: async () => {
+            promptPersisted = await inner.load();
+            return promptPersisted;
+        },
+        save: async (state) => {
+            await inner.save(state);
+            promptPersisted = state;
+        },
+    });
+    const withByDigestBackfill = (inner) => cc?.baseUrl ? withPromptArtifactBackfill(inner, (d) => fetchPromptArtifact(cc, d), logger) : inner;
     const promptSource = (() => {
         try {
+            const bootBin = promptStateBin();
+            if (bootBin !== undefined)
+                fileStateStoreFor(bootBin);
             return new CenterPromptSource({
                 store: withByDigestBackfill(new FilePromptArtifactStore(promptEpochDir)),
-                stateStore: new FilePromptSourceStateStore(promptStateDir),
+                stateStore: recordingStateStore(binnedPromptStateStore(fileStateStoreFor)),
                 engineVersion: CORE_ENGINE_VERSION,
             });
         }
         catch (e) {
             logger.warn("center_prompts_store_unwritable", { dir: promptEpochDir, err: String(e), note: "file-backed prompt-epoch store unavailable — memory fallback (catalog candidate not restart-durable); built-ins/declaration axis unaffected" });
-            return new CenterPromptSource({ store: withByDigestBackfill(new MemoryPromptArtifactStore()), stateStore: new MemoryPromptSourceStateStore(), engineVersion: CORE_ENGINE_VERSION });
+            return new CenterPromptSource({
+                store: withByDigestBackfill(new MemoryPromptArtifactStore()),
+                stateStore: recordingStateStore(binnedPromptStateStore(storePerBin(() => new MemoryPromptSourceStateStore()))),
+                engineVersion: CORE_ENGINE_VERSION,
+            });
         }
     })();
-    if (configProvider && !cc?.dryRun) {
+    const catalogSource = {
+        applySnapshot: (raw) => promptSource.applySnapshot(raw),
+        applyDisabled: (sourceRevision) => promptSource.applyDisabled(sourceRevision),
+        current: () => promptSource.current(),
+        persistedActive: () => promptPersisted?.state === "active",
+    };
+    const rebasePromptState = async (identity, phase) => {
+        promptStateIdentity = identity;
+        centerPrompts = undefined;
+        pendingCatalogFaces = undefined;
+        promptPersisted = undefined;
         try {
             await promptSource.restore();
         }
         catch (e) {
-            logger.warn("center_prompts_catalog_restore_failed", { err: String(e), note: "disk LKG unavailable — catalog candidate absent until the next adopt; declaration axis and built-ins unaffected" });
+            logger.warn("center_prompts_catalog_restore_failed", { phase, err: String(e), note: "the persisted catalog state for this credential identity could not be loaded — catalog candidate absent until the next adopt; declaration axis and built-ins unaffected" });
         }
-    }
+        if (cc !== undefined && identity !== undefined && currentIdentity() !== identity) {
+            promptStateIdentity = undefined;
+            await promptSource.restore();
+            logger.warn("center_prompts_catalog_identity_changed", { phase, note: "the center credential changed while the persisted catalog state was being read — that state is not used; the current identity's next candidate re-establishes it" });
+        }
+    };
+    if (configProvider && !cc?.dryRun)
+        await rebasePromptState(promptStateIdentity, "boot");
     const adoptCenterPrompts = async (eff, phase) => {
+        const adoptedIdentity = candidateIdentityOf(eff);
+        if (adoptedIdentity !== undefined && adoptedIdentity !== promptStateIdentity) {
+            await rebasePromptState(adoptedIdentity, phase);
+        }
         const raw = eff?.prompts;
         if (raw === undefined) {
             if (centerPrompts)
                 logger.info("center_prompts_cleared", { phase, note: "effective carries no prompts key (publish gate off) — built-in providers resume" });
-            const cleared = await applyCatalogToSource(promptSource, undefined, centerPrompts, logger, phase);
+            const cleared = await applyCatalogToSource(catalogSource, undefined, centerPrompts, logger, phase);
             if (cleared) {
                 centerPrompts = undefined;
                 pendingCatalogFaces = undefined;
@@ -148,7 +251,7 @@ export async function createConfigCenterRuntime(ctx) {
                 note: "new tasks assemble the new pack (epoch re-pins at the next task boundary); in-flight sessions stay pinned",
             });
         }
-        const transitioned = await applyCatalogToSource(promptSource, v.value, centerPrompts, logger, phase);
+        const transitioned = await applyCatalogToSource(catalogSource, v.value, centerPrompts, logger, phase);
         if (transitioned) {
             centerPrompts = v.value;
             pendingCatalogFaces = undefined;
@@ -159,7 +262,7 @@ export async function createConfigCenterRuntime(ctx) {
     };
     let bootConfigPending;
     const lkgEnabled = configProvider?.kind === "remote" && configLkgEnabled();
-    const lkgPath = process.env.CONFIG_LKG_PATH ?? defaultLkgPath(cc?.worker);
+    const lkgPathFor = (identity) => process.env.CONFIG_LKG_PATH ?? defaultLkgPath(cc?.worker, identity);
     const lkgSurvivesRestart = lkgEnabled && process.env.CONFIG_LKG_DURABLE === "true";
     let lkgBooted = false;
     let bootLkgCandidate;
@@ -170,9 +273,15 @@ export async function createConfigCenterRuntime(ctx) {
             return true;
         if (!lkgEnabled)
             return false;
+        const identity = candidateIdentityOf(effectiveObj);
+        if (identity === undefined) {
+            logger.warn("config_lkg_save_failed", { err: "candidate carries no credential identity", note: "LKG NOT written (the bin is keyed by the identity that fetched the candidate) — handoff NOT confirmed" });
+            return false;
+        }
+        const lkgPath = lkgPathFor(identity);
         try {
             if (effectiveObj.skills && config.configCenter) {
-                await applyCenterSkills([], effectiveObj.skills, config.configCenter.baseUrl, config.configCenter.token, logger, undefined, defaultSkillCacheDir());
+                await applyCenterSkills([], effectiveObj.skills, config.configCenter, logger, undefined, defaultSkillCacheDir());
             }
             const enabledSkills = (effectiveObj.skills?.skills ?? []).filter((m) => m.enabled !== false);
             const cacheDir = defaultSkillCacheDir();
@@ -193,7 +302,7 @@ export async function createConfigCenterRuntime(ctx) {
                 }
             }
             lastPrewarmBodiesVerified = true;
-            await saveLkg(lkgPath, cc?.worker, effectiveObj, etag);
+            await saveLkg(lkgPath, cc?.worker, identity, effectiveObj, etag);
             return lkgSurvivesRestart;
         }
         catch (err) {
@@ -206,14 +315,40 @@ export async function createConfigCenterRuntime(ctx) {
         const bootFromLkg = async (why) => {
             if (!lkgEnabled || dryRun)
                 return null;
-            const read = await loadLkg(lkgPath, cc?.worker);
+            const identity = currentIdentity();
+            if (identity === undefined) {
+                logger.warn("config_lkg_unusable", { reason: "center credential unreadable — credential identity unknown, no LKG bin is read back", note: "env fallback serves; the live pull retries on the refresh cadence once the credential is readable" });
+                return null;
+            }
+            const lkgPath = lkgPathFor(identity);
+            const legacy = await migrateV1Lkg({ legacyPath: process.env.CONFIG_LKG_PATH ?? legacyV1LkgPath(cc?.worker), binPath: lkgPath, worker: cc?.worker, identity });
+            switch (legacy.outcome) {
+                case "none":
+                    break;
+                case "migrated":
+                    logger.info("config_lkg_migrated", { from: legacy.from, retiredTo: legacy.retiredTo, to: lkgPath, note: "formatVersion 1 LKG (pull-token identity = this worker) migrated once into this credential identity's bin; the old file was renamed, not deleted" });
+                    if (legacy.retireError !== undefined)
+                        logger.warn("config_lkg_legacy_not_retired", { path: legacy.from, reason: legacy.retireError, note: "the bin was written and is used; only the old file's rename / copy failed" });
+                    break;
+                case "not-migrated":
+                    logger.warn("config_lkg_unusable", { path: legacy.path, reason: legacy.reason, note: "env fallback serves; the cache rewrites on the next clean candidate" });
+                    return null;
+            }
+            const read = await loadLkg(lkgPath, cc?.worker, identity);
             if (!read.lkg) {
                 if (read.reason !== "absent")
                     logger.warn("config_lkg_unusable", { path: lkgPath, reason: read.reason, note: "ignoring the on-disk LKG — env fallback serves; the cache rewrites on the next clean candidate" });
                 return null;
             }
+            if (currentIdentity() !== identity) {
+                logger.warn("config_lkg_unusable", { path: lkgPath, reason: "center credential identity changed while the LKG was being read — not used", note: "env fallback serves; the current identity's next pull re-establishes its own LKG" });
+                return null;
+            }
             logger.info("config_loaded_lkg", { path: lkgPath, savedAt: read.lkg.savedAt, why, note: "booting from the persisted last-known-good (all restart-to-apply faces included) — the live pull continues in the background and reconciles on arrival" });
-            return { effective: read.lkg.effective, ...(read.lkg.etag !== undefined ? { etag: read.lkg.etag } : {}) };
+            const lkgEffective = read.lkg.effective;
+            candidateIdentity.set(lkgEffective, identity);
+            bindValidator(read.lkg.etag, identity);
+            return { effective: lkgEffective, ...(read.lkg.etag !== undefined ? { etag: read.lkg.etag } : {}) };
         };
         const bootApplyLkgInline = async (lkgR) => {
             const lkgGen = generationOf(lkgR.effective.version);
@@ -231,7 +366,7 @@ export async function createConfigCenterRuntime(ctx) {
             logger.info("config_loaded", { source: "lkg", version: lkgR.effective.version, worker: cc?.worker ?? "(global)", models: cfgModels });
         };
         try {
-            const bootFetch = configProvider.fetchEffective(undefined);
+            const bootFetch = pullEffective(configProvider, undefined);
             const raced = await raceBootFetch(bootFetch, config.configBootFetchBudgetMs);
             let lkgFallback = null;
             if (raced === BOOT_FETCH_DEFERRED) {
@@ -327,6 +462,8 @@ export async function createConfigCenterRuntime(ctx) {
                 }
             }
         }
+        if (!dryRun && cc !== undefined && currentIdentity() !== promptStateIdentity)
+            await rebasePromptState(currentIdentity(), "boot-end");
     }
     const readFaceBaseline = { ...(config.readFace !== undefined ? { readFace: config.readFace } : {}), readFaceSource: config.readFaceSource };
     const readFaceEnvHeld = applyCenterReadFace(config, effective ?? { version: 0, updatedAt: "", models: { models: [], roles: {} } }, effective ? logger : undefined).envHeld;
@@ -438,7 +575,7 @@ export async function createConfigCenterRuntime(ctx) {
         },
         async applyCenterCapabilities(skills) {
             if (effective?.skills && config.configCenter) {
-                skills = await applyCenterSkills(skills, effective.skills, config.configCenter.baseUrl, config.configCenter.token, logger, undefined, configLkgEnabled() ? defaultSkillCacheDir() : undefined);
+                skills = await applyCenterSkills(skills, effective.skills, config.configCenter, logger, undefined, configLkgEnabled() ? defaultSkillCacheDir() : undefined);
             }
             if (effective?.plugins) {
                 const pluginOut = await applyCenterPlugins(skills, effective, {
@@ -458,7 +595,7 @@ export async function createConfigCenterRuntime(ctx) {
             }
             if (bootLkgCandidate && lkgEnabled) {
                 const bootPublished = await persistLkgDurable(bootLkgCandidate.effective, bootLkgCandidate.etag).catch((err) => {
-                    logger.warn("config_lkg_save_failed", { path: lkgPath, err: String(err), note: "boot LKG persist failed — retained for the per-tick retry" });
+                    logger.warn("config_lkg_save_failed", { err: String(err), note: "boot LKG persist failed — retained for the per-tick retry" });
                     return false;
                 });
                 {
@@ -521,7 +658,7 @@ export async function createConfigCenterRuntime(ctx) {
                             metrics.inc("models_tiers_plane_deferred_stuck_total");
                             logger.warn("models_tiers_deferred_no_handoff", { version: planeDeferredNoHandoff.version, since: planeDeferredNoHandoff.since, note: "candidate still retained without a next-boot handoff — mount restart-surviving LKG storage + CONFIG_LKG_DURABLE=true, or restart manually after ensuring the candidate is re-pulled at boot" });
                         }
-                        const r = arrival !== undefined ? arrival.result : await configProvider.fetchEffective(ccEtag);
+                        const r = arrival !== undefined ? arrival.result : await pullEffective(configProvider, ccEtag);
                         if (r === null && planeDeferredNoHandoff) {
                             const skillsDebt = (planeDeferredNoHandoff.blocked ?? []).includes("skills");
                             const promoted = lkgSurvivesRestart || skillsDebt ? await persistLkgDurable(planeDeferredNoHandoff.candidate, planeDeferredNoHandoff.candidateEtag) : false;
@@ -793,7 +930,15 @@ export async function createConfigCenterRuntime(ctx) {
                 };
                 if (bootConfigPending) {
                     const arrivalGen = reserveArrivalGeneration();
-                    void bootConfigPending.then((r) => void (lkgBooted ? runTick({ result: r, ordinal: arrivalGen }) : deferredBootApply(r, arrivalGen)), () => { });
+                    const continueArrival = (r) => void (lkgBooted ? runTick({ result: r, ordinal: arrivalGen }) : deferredBootApply(r, arrivalGen));
+                    void bootConfigPending.then((r) => {
+                        if (r !== null && configProvider.kind === "remote" && candidateIdentityOf(r.effective) !== currentIdentity()) {
+                            logger.warn("config_boot_arrival_identity_changed", { note: "the late boot pull landed under a center credential that is no longer current — not adopted; re-pulling once under the current credential" });
+                            void pullEffective(configProvider, undefined).then(continueArrival, (err) => logger.warn("config_boot_arrival_repull_failed", { err: String(err), note: "the refresh cadence retries under the current credential" }));
+                            return;
+                        }
+                        continueArrival(r);
+                    }, () => { });
                 }
             }
         },

package/dist/boot/org-memory.d.ts

@@ -54,7 +54,8 @@ export interface OrgMemoryAdmissionWiring {
     /** §7 第二消费者收编:同一个目录实例也喂 memory-policy 面的 `org:` 属主门(`ServiceDeps.orgMemoryDirectory`)。
      *  **同实例**是这条收编的全部意义——「谁属于 org:acme」在一个进程里必须只有一个答案,两面共享同一份
      *  TTL 缓存/退避窗/gen 高水位;各建各的目录会让准入门与策略面在吊销窗内公开分歧。缺席=无目录源
-     *  (单用户/无 center 且无 env 表)⇒ 策略面逐字保持收编前的 operator-only 行为。 */
+     *  (单用户/无 center 且无 env 表)⇒ 策略面逐字保持收编前的 operator-only 行为。
+     *  远程腿的这一个实例内部按中心凭证身份分箱([ref] E-15):两面问到的是同一身份的同一箱。 */
     directory: OrgMemoryDirectory | undefined;
 }
 /** 依赖收窄到真实消费面(warn/inc 各一手)——接口隔离让测试用真形字面量,零铸形([ref] §1)。 */

package/dist/boot/org-memory.js

@@ -1,4 +1,5 @@
 import { fetchPrincipalOrgMemory } from "../config-center/http-client.js";
+import { createIdentityBins } from "../center-credential.js";
 import { createMemoryScopeAdmission, createOrgMemoryDirectory, parseOrgDirectoryStatic } from "../org-memory-admission.js";
 const ORG_PREFIX = "org:";
 function collectDeploymentOrgScopes(config) {
@@ -25,11 +26,14 @@ export function createOrgMemoryAdmissionWiring(opts) {
         });
     }
     const directory = centerLeg !== undefined
-        ? createOrgMemoryDirectory({
-            fetchSection: (principal) => fetchPrincipalOrgMemory(centerLeg.baseUrl, centerLeg.token, principal, fetch, centerLeg.worker),
-            grantTtlMs: config.memoryOrgGrantTtlMs,
-            unavailableBackoffMs: config.memoryOrgUnavailableBackoffMs,
-        })
+        ? (() => {
+            const directoryNow = createIdentityBins(centerLeg.credential, (credential) => createOrgMemoryDirectory({
+                fetchSection: (principal) => fetchPrincipalOrgMemory({ baseUrl: centerLeg.baseUrl, credential }, principal, fetch, centerLeg.worker),
+                grantTtlMs: config.memoryOrgGrantTtlMs,
+                unavailableBackoffMs: config.memoryOrgUnavailableBackoffMs,
+            }));
+            return { lookup: (principal) => directoryNow().lookup(principal) };
+        })()
         : staticJson !== undefined
             ? createOrgMemoryDirectory({
                 staticTable: parseOrgDirectoryStatic(staticJson),

package/dist/boot/runtime-caps.js

@@ -1,4 +1,5 @@
-import { applyGovernedVerdictAbsenceWarning, applyLocalAutoModeDeny, applyMemoryOptOutGrant, applyObserverEnvOptIn, centerEntitlementSourceWired, createPrincipalEntitlementsClient, scopedTokenNeedsWorker, } from "../runtime-caps-resolver.js";
+import { applyGovernedVerdictAbsenceWarning, applyLocalAutoModeDeny, applyMemoryOptOutGrant, applyObserverEnvOptIn, centerEntitlementSourceWired, createPrincipalEntitlementsClient, } from "../runtime-caps-resolver.js";
+import { scopedTokenNeedsWorker } from "../center-credential.js";
 export function assertMemoryCapturePolicyWirable(input) {
     if (input.policy !== "governed")
         return;
@@ -36,15 +37,14 @@ export function createRuntimeCaps(ctx) {
             reason: "MEMORY_CAPTURE_POLICY=governed with NO local memory_optout_grant table: the only verdict source is the config center, and `allowMemoryOptOut` is an OPTIONAL entitlement key — for any principal whose caps omit it the verdict is ABSENT and core refuses that session's memory.capture:\"off\" (memory.capture_optout_denied, fail-closed). ANONYMOUS/system runs are worse off still: the center source is per-principal and is never consulted without an identity, so on this shape a principal-less run can never obtain a verdict at all. Verify the center emits allowMemoryOptOut for every principal, or wire a SQL backend (DB_BACKEND=mysql|pg) so the grant table answers (its deployment-default row also covers anonymous runs).",
         });
     }
-    if (centerEntitlementSourceWired(config) && config.configCenter && scopedTokenNeedsWorker(config.configCenter.token, config.configCenter.worker)) {
+    if (centerEntitlementSourceWired(config) && config.configCenter && scopedTokenNeedsWorker(config.configCenter.credential.read(), config.configCenter.worker)) {
         logger.warn("runtime_caps_scoped_token_no_worker", {
             reason: "SEMA_REGISTRY_TOKEN is a worker-scoped wpt_ token but SEMA_REGISTRY_WORKER is unset → center 403s per-principal caps → ALL workflow self-orchestration will be fail-closed denied. Set SEMA_REGISTRY_WORKER (the orchestrator normally injects it) or use the full SERVICE_PULL_TOKEN.",
         });
     }
     const principalCaps = centerEntitlementSourceWired(config) && config.configCenter
         ? createPrincipalEntitlementsClient({
-            baseUrl: config.configCenter.baseUrl,
-            token: config.configCenter.token,
+            center: config.configCenter,
             ...(config.configCenter.worker ? { worker: config.configCenter.worker } : {}),
             onError: (err, principal) => logger.warn("runtime_caps_resolve_failed", { principal, err: String(err) }),
         })

package/dist/capabilities/center-prompts.d.ts

@@ -55,6 +55,9 @@ export declare function applyCatalogToSource(source: {
     /** codex-2 F2(restart-owed disable):撤下写盘失败后重启,内存 prev 丢了但持久态还 active——
      *  以 source 自身的 live candidate 为准判「欠 disable」,不是只看内存 prev。 */
     current?(): unknown;
+    /** S-651(codex 修复验证轮 V1):本箱**持久记录**是 active —— 即使那份 artifact 此刻加载不出(活候选为空)。
+     *  「欠撤下」的真源是持久记录;活候选只是它能加载时的影子。缺席 = 调用方不掌握持久记录(沿用前两条判据)。 */
+    persistedActive?(): boolean;
 }, next: PromptsDomainFaces | undefined, prev: PromptsDomainFaces | undefined, log: {
     info: (msg: string, meta?: Record<string, unknown>) => void;
     warn: (msg: string, meta?: Record<string, unknown>) => void;

package/dist/capabilities/center-prompts.js

@@ -55,7 +55,7 @@ export async function applyCatalogToSource(source, next, prev, log, phase) {
             log.warn("center_prompts_catalog_apply_failed", { phase, code: r.code, reason: r.reason, note: "validate passed but the source apply failed (disk/state) — declaration axis and built-ins unaffected; candidate unchanged; the transition retries on the next refresh tick" });
             return false;
         }
-        if (prev?.catalog || source.current?.() !== undefined) {
+        if (prev?.catalog || source.current?.() !== undefined || source.persistedActive?.() === true) {
             await source.applyDisabled(`${phase}:catalog-absent`);
             log.info("center_prompts_catalog_disabled", { phase, note: "catalog axis withdrawn — core candidate cleared (does not revive offline)" });
         }

package/dist/center-credential.d.ts

@@ -0,0 +1,112 @@
+/** 凭证种类闭集。新增一个种类 = 本文件与 `config-center/center-request.ts` 的穷举 switch 当场编译红。 */
+export type CenterCredentialKind = "pull-token" | "user-jwt" | "none";
+/** 凭证在哪里声明(env 形带值 —— 只在本模块内流转)。 */
+export type CenterCredentialDeclaration = {
+    readonly from: "env";
+    readonly token: string;
+} | {
+    readonly from: "file";
+    readonly path: string;
+} | {
+    readonly from: "absent";
+};
+/** 声明形的**非秘密**投影(进日志 / 拒因 / 未来的 caps 读面):env 形不带值。 */
+export type CenterCredentialOrigin = {
+    readonly from: "env";
+} | {
+    readonly from: "file";
+    readonly path: string;
+} | {
+    readonly from: "absent";
+};
+/** 一次取值的结果。`ok:false` 只有文件形会出现(env / absent 形的取值恒成功)。 */
+export type CenterCredentialRead = {
+    readonly ok: true;
+    readonly kind: "pull-token";
+    readonly bearer: string;
+    readonly identity: string;
+    readonly workerScoped: boolean;
+} | {
+    readonly ok: true;
+    readonly kind: "user-jwt";
+    readonly bearer: string;
+    readonly identity: string;
+} | {
+    readonly ok: true;
+    readonly kind: "none";
+    readonly identity: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** 健康态:最近一次取值的结果(caps `leaseHealth` 之类的读面读它,不自己再判)。 */
+export type CenterCredentialHealth = {
+    readonly state: "ok";
+} | {
+    readonly state: "unreadable";
+    readonly reason: string;
+    readonly since: number;
+    readonly failures: number;
+};
+export interface CenterCredentialSource {
+    /** 声明形(非秘密):`{from:"file", path}` 进日志与拒因用。 */
+    readonly origin: CenterCredentialOrigin;
+    /** 装配判据:声明了凭证(env 值非空 / 文件路径在场)。**按声明装,不按内容装** —— 文件此刻不可读也算声明了。 */
+    readonly declared: boolean;
+    /** 每次出站请求调用一次;文件形每次都读文件。 */
+    read(): CenterCredentialRead;
+    health(): CenterCredentialHealth;
+}
+/** 凭证文件此刻不可读 / 为空。中心请求装配点(`center-request.ts`)取值失败时抛它,各消费方按自己的
+ *  失败臂处置(拉配置保 LKG、caps fail-closed、租约走「鉴权失败」响亮臂 …),**不发一个空 bearer 出去**。 */
+export declare class CenterCredentialUnavailableError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare const CENTER_TOKEN_ENV = "SEMA_REGISTRY_TOKEN";
+export declare const CENTER_TOKEN_FILE_ENV = "SEMA_REGISTRY_TOKEN_FILE";
+/**
+ * 读两个声明键。两个都非空 ⇒ throw(boot 拒启,拒因点名二选一)。空串 = 未设(与 7.98.0 之前
+ * `SEMA_REGISTRY_TOKEN || ""` 的读法一致)。文件路径在这里解析成绝对路径(之后 cwd 变了也读同一个文件)。
+ */
+export declare function readCenterCredentialDeclaration(env?: NodeJS.ProcessEnv): CenterCredentialDeclaration;
+/** 拉取令牌形的身份 = worker(拉取令牌代表 worker,不是人)。种类判别与 formatVersion 1 LKG 的一次性迁移
+ *  (`config-lkg.ts` `migrateV1Lkg`:v1 信封只记 worker,只有这一形的身份推得出来)共用这一只。 */
+export declare function pullTokenIdentity(worker: string | undefined): string;
+/**
+ * 凭证来源工厂(活对象:文件形每次取值读盘并记健康态)。`worker` = `SEMA_REGISTRY_WORKER`(拉取令牌形的身份)。
+ * `readFile` 只为测试注入。
+ */
+export declare function createCenterCredentialSource(declaration: CenterCredentialDeclaration, worker: string | undefined, deps?: {
+    readFile?: (path: string) => string;
+    now?: () => number;
+}): CenterCredentialSource;
+/** 需要作用域 worker 的拉取令牌(`wpt_<self>`)却没配 `SEMA_REGISTRY_WORKER` ⇒ 中心对 per-principal caps
+ *  逐次 403(caps fail-closed 拒全部 workflow)。boot 期一次性诊断用;判据只读本模块的种类判别。 */
+export declare function scopedTokenNeedsWorker(read: CenterCredentialRead, worker: string | undefined): boolean;
+/**
+ * [ref] E-15 —— 按「worker + 凭证身份」分箱的**唯一键形**(LKG 文件名、prompt 活动状态目录共用)。
+ * 两段都取摘要:worker 名 / 身份任意字节都成单段路径,无 dot-segment,无撞形(codex-5 当年给 prompt 状态
+ * 目录定的姿势,本批推广到 LKG)。
+ */
+export declare function centerStateBin(worker: string | undefined, identity: string): string;
+/** 此刻凭证的身份(每次现读);文件形此刻不可读 ⇒ `undefined`(身份未知)。「我现在是谁」只有这一只读法。 */
+export declare function credentialIdentityNow(source: CenterCredentialSource): string | undefined;
+/**
+ * [ref] E-15 ② —— 一次中心往返的答复**仍属于此刻的凭证**:发出它所用的身份 = 此刻的身份。
+ * 拉配置(`boot/config-center.ts` `pullEffective`)与两条 `?principal=` 视图(`config-center/http-client.ts`)
+ * 都只问这一只;不成立 ⇒ 答复丢弃,当这次拉取失败(各走各的失败臂)。
+ */
+export declare function answerStillCurrent(source: CenterCredentialSource, usedIdentity: string | undefined): usedIdentity is string;
+/**
+ * [ref] E-15 · 内存面 —— 身份绑定的进程内状态(per-principal caps 缓存与在飞表、org 记忆目录)的**唯一分箱规则**,
+ * 与盘上的 {@link centerStateBin} 同一条规则的两面(7.99.0 合并复审 F2:此前两处缓存只按 principal 键)。
+ *  · 箱 = 取箱那一刻的凭证身份(惰建)。凭证此刻不可读 ⇒ 「身份未知」箱。
+ *  · 每个箱只经**钉在它身份上**的凭证来源对中心说话(`make` 拿到的那只):此刻的凭证已换了人 / 不可读 ⇒ 这一箱的
+ *    请求不发(取值失败 ⇒ `CenterCredentialUnavailableError`,消费方走自己的失败臂)。身份未知箱因此从不收任何
+ *    中心答复;缓存 / 在飞 / 条件请求的校验子全在箱里,换了人结构上够不着上一个人的。
+ *  · 请求发出之后才换人:答复到达时由 {@link answerStillCurrent} 判丢弃(请求装配侧,见 http-client.ts)。
+ * 旧身份的箱不淘汰(量级 = 进程生命期内出现过的身份数):换回来的身份在 TTL 内照常命中它自己的缓存。
+ */
+export declare function createIdentityBins<T>(source: CenterCredentialSource, make: (pinned: CenterCredentialSource) => T): () => T;
+//# sourceMappingURL=center-credential.d.ts.map