@sema-agent/server 1.221.0 → 1.223.0

package/dist/main.js

@@ -70,6 +70,8 @@ import { ToolApprovalCoordinator } from "./tool-approval.js";
 import { applyEffective, mutateInPlace, logEffectiveDiff, applyCenterSkills, resolveMcpServers, mcpForScenario, restartReasons } from "./sema-registry.js";
 import { ensureSealedKeyStore, reportExecutionPublicKey } from "./sealed-key.js";
 import { createConfigProvider, raceBootFetch, BOOT_FETCH_DEFERRED } from "./config-provider.js";
+import { validateCenterPrompts, centerPromptProvider } from "./capabilities/center-prompts.js";
+import { defaultLkgPath, defaultSkillCacheDir, saveLkg, loadLkg } from "./config-lkg.js";
 import { createPrincipalCapsClient, gateExecutionLane, scopedTokenNeedsWorker, applyObserverEnvOptIn } from "./runtime-caps-resolver.js";
 import { applyRuntimeGovernance, stripDelegationTools } from "./runtime-governance.js";
 import { parseTaskSettings, applyTaskSettings, coercePermissionMode, withPermissionMode, effectiveThinking } from "./task-settings.js";
@@ -154,24 +156,100 @@ async function main() {
             logger.info("model_roster_landed", { note: "ready gate open — billable submissions accepted" });
         }
     };
+    let centerPrompts;
+    const adoptCenterPrompts = (eff, 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" });
+            centerPrompts = undefined;
+            return;
+        }
+        const v = validateCenterPrompts(raw);
+        if (!v.ok) {
+            logger.warn("center_prompts_invalid", { phase, error: v.error, kept: centerPrompts?.packId ?? "(builtin)", note: "malformed prompts face rejected (core assemble would THROW per task) — keeping the previous pack/built-ins; fix the center payload" });
+            return;
+        }
+        if (centerPrompts?.contentDigest !== v.value.contentDigest) {
+            logger.info("center_prompts_adopted", { phase, packId: v.value.packId, contentDigest: v.value.contentDigest, sections: v.value.sections.length, scenarioOverrides: Object.keys(v.value.scenarioOverrides ?? {}).length, note: "new tasks assemble the new pack (epoch re-pins at the next task boundary); in-flight sessions stay pinned" });
+        }
+        centerPrompts = v.value;
+    };
     let bootConfigPending;
+    const lkgEnabled = configProvider?.kind === "remote" && process.env.CONFIG_LKG_DISABLED !== "true";
+    const lkgPath = process.env.CONFIG_LKG_PATH ?? defaultLkgPath(cc?.worker);
+    let lkgBooted = false;
+    let bootLkgCandidate;
+    const persistLkgDurable = async (effectiveObj, etag) => {
+        if (!lkgEnabled)
+            return;
+        try {
+            if (effectiveObj.skills && config.configCenter) {
+                await applyCenterSkills([], effectiveObj.skills, config.configCenter.baseUrl, config.configCenter.token, logger, undefined, defaultSkillCacheDir());
+            }
+            await saveLkg(lkgPath, cc?.worker, effectiveObj, etag);
+        }
+        catch (err) {
+            logger.warn("config_lkg_save_failed", { path: lkgPath, err: String(err), note: "durable persist failed — restart signal proceeds anyway (a dead disk + dead center double-fault can re-loop; fix the disk)" });
+        }
+    };
     if (configProvider) {
         const dryRun = cc?.dryRun ?? false;
+        const bootFromLkg = async (why) => {
+            if (!lkgEnabled || dryRun)
+                return null;
+            const read = await loadLkg(lkgPath, cc?.worker);
+            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;
+            }
+            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 bootApplyLkgInline = (lkgR) => {
+            applyEffective(config, lkgR.effective, logger, { sealedKeys });
+            adoptCenterPrompts(lkgR.effective, "boot-lkg");
+            markRosterLanded(lkgR.effective);
+            effective = lkgR.effective;
+            latestEffective = lkgR.effective;
+            if (lkgR.etag !== undefined)
+                ccEtag = lkgR.etag;
+            const cfgModels = (lkgR.effective.models?.models ?? []).filter((m) => m.enabled !== false).length;
+            logger.info("config_loaded", { source: "lkg", version: lkgR.effective.version, worker: cc?.worker ?? "(global)", models: cfgModels });
+        };
         try {
             const bootFetch = configProvider.fetchEffective(undefined);
             const raced = await raceBootFetch(bootFetch, config.configBootFetchBudgetMs);
+            let lkgFallback = null;
             if (raced === BOOT_FETCH_DEFERRED) {
                 bootConfigPending = bootFetch;
                 bootFetch.catch(() => { });
+                lkgFallback = await bootFromLkg("boot fetch deferred (budget exceeded)");
+                lkgBooted = lkgFallback !== null;
                 logger.warn("config_boot_fetch_deferred", {
                     source: configProvider.kind,
                     budgetMs: config.configBootFetchBudgetMs,
-                    note: "center slow/unreachable — serving on the env fallback now; the pull continues in the background and hot-applies on arrival (roster gate opens then). Raise CONFIG_BOOT_FETCH_BUDGET_MS to block boot instead.",
+                    lkg: lkgBooted,
+                    note: lkgBooted
+                        ? "center slow — booting from the persisted LKG; the pull continues in the background and reconciles via the refresh path on arrival"
+                        : "center slow/unreachable and no usable LKG — serving on the env fallback; the pull continues in the background (late-boot adoption on arrival). Raise CONFIG_BOOT_FETCH_BUDGET_MS to block boot instead.",
                 });
             }
+            if (raced === BOOT_FETCH_DEFERRED && lkgFallback) {
+                try {
+                    bootApplyLkgInline(lkgFallback);
+                }
+                catch (applyErr) {
+                    lkgBooted = false;
+                    logger.warn("config_lkg_apply_failed", { err: String(applyErr), note: "persisted LKG failed to apply — env fallback serves; the cache rewrites on the next clean candidate" });
+                }
+            }
             const r = raced === BOOT_FETCH_DEFERRED ? null : raced;
             if (r) {
-                const bootClean = (r.domainErrors ?? []).length === 0;
+                const bootPromptsRaw = r.effective.prompts;
+                const bootPromptsOk = bootPromptsRaw === undefined || validateCenterPrompts(bootPromptsRaw).ok;
+                const bootClean = (r.domainErrors ?? []).length === 0 && bootPromptsOk;
                 if (bootClean)
                     ccEtag = r.etag;
                 for (const de of r.domainErrors ?? [])
@@ -181,10 +259,13 @@ async function main() {
                 }
                 else {
                     applyEffective(config, r.effective, logger, { sealedKeys });
+                    adoptCenterPrompts(r.effective, "boot");
                     markRosterLanded(r.effective);
                     effective = r.effective;
                     if (bootClean)
                         latestEffective = r.effective;
+                    if (bootClean && !lkgBooted)
+                        bootLkgCandidate = { effective: r.effective, etag: r.etag };
                     const cfgModels = (r.effective.models?.models ?? []).filter((m) => m.enabled !== false).length;
                     const cfgDir = configProvider.kind === "local" ? { dir: configProvider.root } : {};
                     logger.info("config_loaded", { source: configProvider.kind, version: r.effective.version, worker: cc?.worker ?? "(global)", models: cfgModels, ...cfgDir });
@@ -195,6 +276,17 @@ async function main() {
         }
         catch (err) {
             logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, err: String(err) });
+            const lkgFallback = await bootFromLkg(`boot fetch failed: ${String(err).slice(0, 120)}`);
+            if (lkgFallback) {
+                lkgBooted = true;
+                try {
+                    bootApplyLkgInline(lkgFallback);
+                }
+                catch (applyErr) {
+                    lkgBooted = false;
+                    logger.warn("config_lkg_apply_failed", { err: String(applyErr), note: "persisted LKG failed to apply — env fallback serves" });
+                }
+            }
         }
     }
     if (!modelReadyState.ready)
@@ -948,7 +1040,10 @@ async function main() {
         : undefined;
     let skills = loadSkills(config.skillsDir);
     if (effective?.skills && config.configCenter) {
-        skills = await applyCenterSkills(skills, effective.skills, config.configCenter.baseUrl, config.configCenter.token, logger);
+        skills = await applyCenterSkills(skills, effective.skills, config.configCenter.baseUrl, config.configCenter.token, logger, undefined, process.env.CONFIG_LKG_DISABLED !== "true" ? defaultSkillCacheDir() : undefined);
+    }
+    if (bootLkgCandidate && lkgEnabled) {
+        await saveLkg(lkgPath, cc?.worker, bootLkgCandidate.effective, bootLkgCandidate.etag).catch((err) => logger.warn("config_lkg_save_failed", { path: lkgPath, err: String(err), note: "boot LKG persist failed — next clean candidate rewrites" }));
     }
     if (effective?.mcp)
         config.mcpServers = resolveMcpServers(effective.mcp, logger);
@@ -1054,21 +1149,30 @@ async function main() {
     if (configProvider) {
         const ccRef = config.configCenter;
         let refreshInFlight = false;
-        const refreshTick = async () => {
+        const refreshTick = async (prefetched) => {
             if (refreshInFlight)
                 return;
             refreshInFlight = true;
             try {
-                const r = await configProvider.fetchEffective(ccEtag);
+                const r = prefetched !== undefined ? prefetched : await configProvider.fetchEffective(ccEtag);
                 if (r) {
-                    const badDomains = [...new Set((r.domainErrors ?? []).map((de) => de.domain))].sort().join(",");
+                    const promptsRaw = r.effective.prompts;
+                    const promptsGate = promptsRaw !== undefined ? validateCenterPrompts(promptsRaw) : { ok: true };
+                    const badDomains = [
+                        ...new Set([...(r.domainErrors ?? []).map((de) => de.domain), ...(promptsGate.ok ? [] : ["prompts"])]),
+                    ]
+                        .sort()
+                        .join(",");
                     if (badDomains) {
                         if (lastRejectedCandidate?.version !== r.effective.version || lastRejectedCandidate.domains !== badDomains) {
                             lastRejectedCandidate = { version: r.effective.version, domains: badDomains, at: Date.now() };
                             logger.warn("config_candidate_rejected", {
                                 version: r.effective.version,
                                 domains: badDomains,
-                                errors: (r.domainErrors ?? []).map((de) => ({ domain: de.domain, error: de.error })),
+                                errors: [
+                                    ...(r.domainErrors ?? []).map((de) => ({ domain: de.domain, error: de.error })),
+                                    ...(promptsGate.ok ? [] : [{ domain: "prompts", error: promptsGate.error }]),
+                                ],
                                 lkgVersion: latestEffective?.version ?? "(env)",
                                 note: "candidate rejected whole (§9.5-5) — live config keeps the last-known-good; fix the named files to unblock",
                             });
@@ -1085,6 +1189,7 @@ async function main() {
                         markRosterLanded(r.effective);
                         mutateInPlace(pricing, buildPricing(config.models));
                         keyResolver = buildKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
+                        await persistLkgDurable(r.effective, r.etag);
                         const reasons = restartReasons(effective, r.effective);
                         if (reasons.length === 0) {
                             pendingRestart = undefined;
@@ -1114,8 +1219,51 @@ async function main() {
         };
         const ccTimer = setInterval(() => void refreshTick(), 60_000);
         ccTimer.unref?.();
+        const deferredBootApply = async (r) => {
+            if (!r)
+                return;
+            if (refreshInFlight)
+                return;
+            refreshInFlight = true;
+            try {
+                await deferredBootApplyInner(r);
+            }
+            finally {
+                refreshInFlight = false;
+            }
+        };
+        const deferredBootApplyInner = async (r) => {
+            const promptsRaw = r.effective.prompts;
+            const promptsGate = promptsRaw !== undefined ? validateCenterPrompts(promptsRaw) : { ok: true };
+            if ((r.domainErrors ?? []).length > 0 || !promptsGate.ok) {
+                logger.warn("config_boot_deferred_candidate_rejected", {
+                    version: r.effective.version,
+                    errors: [...(r.domainErrors ?? []).map((de) => ({ domain: de.domain, error: de.error })), ...(promptsGate.ok ? [] : [{ domain: "prompts", error: promptsGate.error }])],
+                    note: "late boot pull carried an invalid candidate — env fallback keeps serving; the refresh cadence re-judges the same tree (etag not advanced)",
+                });
+                return;
+            }
+            if (ccRef?.dryRun) {
+                logEffectiveDiff(config, r.effective, logger);
+                ccEtag = r.etag;
+                return;
+            }
+            applyEffective(config, r.effective, logger, { teamsOnly: true, sealedKeys });
+            adoptCenterPrompts(r.effective, "boot-deferred");
+            markRosterLanded(r.effective);
+            mutateInPlace(pricing, buildPricing(config.models));
+            keyResolver = buildKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
+            effective = r.effective;
+            latestEffective = r.effective;
+            ccEtag = r.etag;
+            await persistLkgDurable(r.effective, r.etag);
+            const reasons = restartReasons(undefined, r.effective).filter((sl) => sl !== "prompts");
+            if (reasons.length > 0)
+                pendingRestart = { restartRequired: true, reasons, version: r.effective.version, since: Date.now() };
+            logger.info("config_loaded_deferred", { source: configProvider.kind, version: r.effective.version, models: (r.effective.models?.models ?? []).filter((m) => m.enabled !== false).length, ...(reasons.length > 0 ? { restartRequired: true, restartReasons: reasons } : {}) });
+        };
         if (bootConfigPending)
-            void bootConfigPending.then(() => refreshTick(), () => { });
+            void bootConfigPending.then((r) => (lkgBooted ? refreshTick(r) : deferredBootApply(r)), () => { });
     }
     let keyResolver = buildKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
     const mysqlPool = backend?.mysqlPool();
@@ -1447,7 +1595,7 @@ async function main() {
                 })(cap.tools),
                 skills: mergeUserSkills(cap.skills, body.skills, logger),
                 mcp: resolveRequestMcp(mcpForScenario(config.mcpServers, scenarioName), body.mcpServers, config, logger),
-                promptProvider: cap.promptProvider,
+                promptProvider: centerPrompts ? centerPromptProvider(centerPrompts, scenarioName) : cap.promptProvider,
                 toolPolicy: durableEnabled
                     ? combinePolicies(createDurableQuestionPolicy(), createDurableAskPolicy({
                         requireApproval: config.approvalRequire, deny: config.approvalDeny, autoBudget: config.approvalAutoBudget, neverAuto: config.approvalNeverAuto,