@sema-agent/server 7.131.0 → 7.133.0

package/dist/brain.js

@@ -4,11 +4,12 @@ import { buildDefaultResilience } from "./config-types.js";
 import { resolveModelApiKey } from "./key-resolver.js";
 import { createHash } from "node:crypto";
 import { isModelKeyPoison, modelKeyPoisonIdentity } from "./key-resolver.js";
-import { dispatchBrainLane } from "./model-provider.js";
+import { anthropicRouteRoot, brainLaneFor, mountRoutes, routeTableOf } from "./model-provider.js";
 import { openaiRouteBaseUrl } from "./model-route-endpoint.js";
 import { catalogEntryFingerprint } from "./web-admin-client/restart-signal.js";
 import { buildDisplaySafeRefusal, buildDisplaySafeUrl } from "./trace/redact.js";
 import { createModelReachBrain } from "./model-unreachable-notice.js";
+import { breakerKeyOf, routeDigestOf } from "./breaker-key.js";
 function isOffDeploymentRoot(baseUrl, config) {
     if (!baseUrl)
         return false;
@@ -20,6 +21,9 @@ function isOffDeploymentRoot(baseUrl, config) {
 function deploymentGatewayRoots(config) {
     return config.gatewayBaseUrl !== undefined ? [config.gatewayBaseUrl, ...config.gatewayFallbackUrls] : [];
 }
+function breakerRoutesOf(config, r) {
+    return r.circuitBreaker ? deploymentGatewayRoots(config).slice(0, -1) : [];
+}
 function deploymentGatewayKey(config) {
     return config.gatewayBaseUrl !== undefined ? config.gatewayApiKey : undefined;
 }
@@ -53,6 +57,7 @@ export function createBrainAssembly(config, deps = {}) {
             ? { maxRetries: FAST_FAIL_MAX_RETRIES }
             : {};
     const routes = deploymentGatewayRoots(config);
+    const breakerRoutes = breakerRoutesOf(config, r);
     const openaiBrains = routes.map((baseUrl, i) => {
         const gatewayKey = deploymentGatewayKey(config);
         const brain = constructRouteBrain(i === 0 ? "gateway route" : `gateway fallback route[${i - 1}]`, [baseUrl], () => createOpenAIBrain({
@@ -62,13 +67,12 @@ export function createBrainAssembly(config, deps = {}) {
             fetchImpl,
             ...timeouts,
         }));
-        const isLast = i === routes.length - 1;
-        return r.circuitBreaker && !isLast
+        return i < breakerRoutes.length
             ? createCircuitBreakerBrain(brain, {
                 failureThreshold: r.failureThreshold,
                 cooldownMs: r.cooldownMs,
                 state: breakerState,
-                key: (m) => `${m.provider ?? "openai"}:${m.id}@${baseUrl}`,
+                key: (m) => breakerKeyOf(m, baseUrl),
             })
             : brain;
     });
@@ -77,23 +81,18 @@ export function createBrainAssembly(config, deps = {}) {
         : openaiBrains.length > 1
             ? createFailoverBrain(openaiBrains)
             : openaiBrains[0];
-    const anthropicCfg = config.anthropic;
-    const anthropicBrain = anthropicCfg
-        ? constructRouteBrain("anthropic route", [anthropicCfg.baseUrl], () => createAnthropicBrain({
-            ...(anthropicCfg.authToken
-                ? { headers: { Authorization: `Bearer ${anthropicCfg.authToken}` } }
-                : { apiKey: anthropicCfg.apiKey }),
-            baseUrl: anthropicCfg.baseUrl ?? "https://api.anthropic.com",
-            version: anthropicCfg.version,
-            cacheBreakpoints: anthropicCfg.cacheBreakpoints,
-            ...(anthropicCfg.maxRetries !== undefined ? { maxRetries: anthropicCfg.maxRetries } : {}),
-            fetchImpl,
-            ...timeouts,
-        }))
-        : undefined;
-    let brain = anthropicBrain
-        ? createRoutingBrain({ anthropic: anthropicBrain }, { fallback: gatewayBrain })
-        : gatewayBrain;
+    const brainRoutes = mountRoutes(config, (anthropicCfg) => constructRouteBrain("anthropic route", [anthropicCfg.baseUrl], () => createAnthropicBrain({
+        ...(anthropicCfg.authToken
+            ? { headers: { Authorization: `Bearer ${anthropicCfg.authToken}` } }
+            : { apiKey: anthropicCfg.apiKey }),
+        baseUrl: anthropicRouteRoot(anthropicCfg),
+        version: anthropicCfg.version,
+        cacheBreakpoints: anthropicCfg.cacheBreakpoints,
+        ...(anthropicCfg.maxRetries !== undefined ? { maxRetries: anthropicCfg.maxRetries } : {}),
+        fetchImpl,
+        ...timeouts,
+    })));
+    let brain = Object.keys(brainRoutes).length > 0 ? createRoutingBrain(brainRoutes, { fallback: gatewayBrain }) : gatewayBrain;
     let degradeBaked = null;
     if (config.degrade?.reactive) {
         const degradeTo = config.degrade.to;
@@ -104,12 +103,12 @@ export function createBrainAssembly(config, deps = {}) {
             const ownEnvRef = credential.apiKeyEnv !== undefined ? { [fallbackModel.name]: credential.apiKeyEnv } : {};
             const ownSealed = credential.sealed !== undefined ? { [fallbackModel.name]: credential.sealed } : {};
             const fbOwnApiKey = () => resolveModelApiKey(fallbackModel.name, ownEnvRef, process.env, ownSealed);
-            const anthropicLaneHop = dispatchBrainLane(fallbackModel.provider, anthropicBrain !== undefined) === "anthropic";
+            const anthropicLaneHop = brainLaneFor(fallbackModel.provider, brainRoutes) === "anthropic";
             const fbDeclaredRoot = degradeDeclaredRoot(fallbackModel.baseUrl, config);
             const fbDeploymentKey = deploymentGatewayKey(config);
-            const fallback = anthropicLaneHop && anthropicBrain
+            const fallback = anthropicLaneHop
                 ?
-                    anthropicBrain
+                    brainRoutes.anthropic
                 : constructRouteBrain(`degrade target "${degradeTo}"`, [fallbackModel.baseUrl, config.gatewayBaseUrl], () => createOpenAIBrain({
                     ...(fbDeclaredRoot !== undefined ? { baseUrl: fbDeclaredRoot } : {}),
                     ...(fbDeploymentKey ? { apiKey: fbDeploymentKey } : {}),
@@ -211,6 +210,7 @@ export function brainSummary(config) {
         idleTimeoutMs: r.idleTimeoutMs,
         circuitBreaker: breakerActive,
         circuitBreakerRequested: r.circuitBreaker,
+        circuitBreakerRoutes: breakerRoutesOf(config, r).map((u) => ({ route: buildDisplaySafeUrl(u), digest: routeDigestOf(u) })),
         gatewayRetryCap: config.gatewayMaxRetries !== undefined
             ? `env:${config.gatewayMaxRetries}`
             : hasFailover || r.circuitBreaker || config.degrade?.reactive
@@ -223,7 +223,7 @@ export function brainSummary(config) {
             const target = degradeTarget;
             if (!target)
                 return { reactiveDegradeRoutePairing: null, reactiveDegradeRouteRefusal: null };
-            if (dispatchBrainLane(target.provider, config.anthropic !== undefined) === "anthropic") {
+            if (brainLaneFor(target.provider, routeTableOf(config)) === "anthropic") {
                 return { reactiveDegradeRoutePairing: "anthropic-lane", reactiveDegradeRouteRefusal: null };
             }
             const credential = degradeCredentialIdentityOf(config, target);

package/dist/breaker-key.d.ts

@@ -0,0 +1,6 @@
+import { type Model } from "@sema-agent/core";
+/** 一条路由的身份摘要(键的路由段;启动日志把它与该路由的展示串并排印出,运维据此把错误文本 / 表行对回路由)。 */
+export declare function routeDigestOf(baseUrl: string): string;
+/** 断路器键:`<头段>@<路由摘要>`,头段 = `<provider>:<model id>`(放不下列宽预算时见 {@link boundedHead})。provider 缺席按 `openai`(与 core 默认键同一个前半)。恒 ≤ 190 字节。 */
+export declare function breakerKeyOf(model: Pick<Model, "provider" | "id">, baseUrl: string): string;
+//# sourceMappingURL=breaker-key.d.ts.map

package/dist/breaker-key.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { routeKeyOf } from "@sema-agent/core";
+const ROUTE_DIGEST_HEX = 24;
+const BREAKER_KEY_MAX_BYTES = 190;
+const HEAD_MAX_BYTES = BREAKER_KEY_MAX_BYTES - 1 - ROUTE_DIGEST_HEX;
+const HEAD_DIGEST_HEX = 16;
+const sha256Hex = (text) => createHash("sha256").update(text, "utf8").digest("hex");
+export function routeDigestOf(baseUrl) {
+    return sha256Hex(routeKeyOf(baseUrl)).slice(0, ROUTE_DIGEST_HEX);
+}
+export function breakerKeyOf(model, baseUrl) {
+    return `${boundedHead(`${model.provider ?? "openai"}:${model.id}`)}@${routeDigestOf(baseUrl)}`;
+}
+function boundedHead(head) {
+    if (Buffer.byteLength(head, "utf8") <= HEAD_MAX_BYTES)
+        return head;
+    const tail = `~${sha256Hex(head).slice(0, HEAD_DIGEST_HEX)}`;
+    let prefix = "";
+    let used = 0;
+    for (const ch of head) {
+        const n = Buffer.byteLength(ch, "utf8");
+        if (used + n > HEAD_MAX_BYTES - tail.length)
+            break;
+        prefix += ch;
+        used += n;
+    }
+    return `${prefix}${tail}`;
+}
+//# sourceMappingURL=breaker-key.js.map

package/dist/budget.js

@@ -93,9 +93,11 @@ export function createTracer(metrics, costQuota, modelUsage, fleetUsage, fleetLe
             const weightedTokens = Math.round((e.totalInputTokens + e.completionTokens) * qw);
             fleetUsage?.record(currentPrincipal(), e.model, e.taskId, { inputTokens: e.totalInputTokens, outputTokens: e.completionTokens, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}), weightedTokens, quotaWeightAtUse: qw });
             fleetLease?.recordSpend(currentPrincipal(), { weightedTokens, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}) });
-            if (e.firstTokenMs !== undefined)
-                metrics.observe("brain_first_token_ms", e.firstTokenMs);
-            metrics.observe("brain_call_latency_ms", e.latencyMs);
+            if (e.turn !== undefined) {
+                if (e.firstTokenMs !== undefined)
+                    metrics.observe("brain_first_token_ms", e.firstTokenMs);
+                metrics.observe("brain_call_latency_ms", e.latencyMs);
+            }
         }
         else if (e.kind === "tool.call") {
             metrics.inc("tool_calls_total", { name: toolName(e.name), ok: String(e.ok) });
@@ -107,7 +109,6 @@ export function createTracer(metrics, costQuota, modelUsage, fleetUsage, fleetLe
             metrics.inc("degraded_total", { reason: e.reason });
         }
         else if (e.kind === "prompt.assembled") {
-            metrics.inc("prompt_constitution_total", { mode: e.constitution });
             promptManifests?.record(e.taskId, promptManifestRecordOf(e));
         }
         else if (e.kind === "config.assembled") {

package/dist/caller-text-echo.d.ts

@@ -0,0 +1,23 @@
+/** 回显的字符上限(剥完控制与双向字符之后数)。 */
+export declare const CALLER_TEXT_ECHO_MAX_CHARS = 64;
+/** 站点给的回显选项。 */
+export interface EchoCallerTextOptions {
+    /** 回显的字符上限(剥完控制与双向字符之后数);不给 = {@link CALLER_TEXT_ECHO_MAX_CHARS}。必须是正整数,否则抛 `RangeError`(编程错误,不静默落成某个长度)。 */
+    readonly maxChars?: number;
+}
+/** 调用方写的串的回显形(不带引号):剥控制与双向字符 → 截到 `maxChars`(缺省 {@link CALLER_TEXT_ECHO_MAX_CHARS})字 + 「…」。 */
+export declare function echoCallerText(text: string, opts?: EchoCallerTextOptions): string;
+/** 句子里点名一个值的写法:{@link echoCallerText} 外加一对双引号。 */
+export declare function quotedCallerText(text: string): string;
+/**
+ * 数据截断(**不是**回显):前 `max` 字 + `…(总长)`;不超则原样。给喂回模型 / 交给 hook 的**数据**用 —— 读的一方(模型、hook 作者)看得出被截、截掉多少。
+ * 不剥控制与双向字符:数据要原样(exit 2 的多行 stderr 保行)。写进日志字段 / 回到人面前的串**不用**它,用 {@link echoCallerText}。
+ */
+export declare function clipDataText(s: string, max: number): string;
+/**
+ * 硬帽:前 `max` 字,什么也不加;不超则原样,缺席(`undefined`)透传。给带 schema `.max()` 的 wire 字段用(审批卡:整只 ask 不能因为一个 200 KB 的字段落不了库)——
+ * 截断记号会让串超过 schema 的上限,所以这里没有记号;也不剥控制与双向字符(卡上的串是要被人审的那一串,清洗会让「看到的」与「将执行的」不是同一个东西)。
+ */
+export declare function capText(s: string, max: number): string;
+export declare function capText(s: string | undefined, max: number): string | undefined;
+//# sourceMappingURL=caller-text-echo.d.ts.map

package/dist/caller-text-echo.js

@@ -0,0 +1,21 @@
+import { stripControlAndBidi } from "@sema-agent/settings-schema";
+export const CALLER_TEXT_ECHO_MAX_CHARS = 64;
+export function echoCallerText(text, opts) {
+    const max = opts?.maxChars ?? CALLER_TEXT_ECHO_MAX_CHARS;
+    if (!Number.isInteger(max) || max < 1)
+        throw new RangeError(`echoCallerText: maxChars must be a positive integer, got ${String(max)}`);
+    const clean = stripControlAndBidi(text);
+    return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+export function quotedCallerText(text) {
+    return `"${echoCallerText(text)}"`;
+}
+export function clipDataText(s, max) {
+    return s.length > max ? `${s.slice(0, max)}…(${s.length})` : s;
+}
+export function capText(s, max) {
+    if (s === undefined)
+        return undefined;
+    return s.length > max ? s.slice(0, max) : s;
+}
+//# sourceMappingURL=caller-text-echo.js.map

package/dist/capabilities/brand-identity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 品牌行(`SEMA_IDENTITY`)—— 品牌部署(local / TOC:`CONFIG_PROVIDER=local`、`run-local`)的 `default` / `code` 两场景,模型的 role 层以它开头。
+ *
+ * 律:品牌行是**部署类的一条 overlay**,不是每请求的分叉。部署座(`RunnerDeps.mods`)上一张 `prompt.compose` 注册,恒答同一条 overlay ——
+ * `add` 到 `role` 档(部署类的 add rank 99,排在目录的角色基底 `core/role.base` rank 100 之前),带 `when`:
+ *  · `binding.anyOf: ["default", "code"]` —— 场景名由 `buildPromptSeats` 写进 `TaskSpec.promptBinding`(恒写);`code-review` / `scan` 与中心声明的场景
+ *    不在表里 ⇒ 不挂(它们与 `default` 同为 `general` 角色,`host.role` 分不开,只有 binding 分得开);
+ *  · `facts.isSubagent: false` —— 委派子代(Agent 工具 / workflow 腿)经父 spec 座继承 binding,但它拿的是子代角色(引擎 sub-agent persona 或定义的
+ *    systemPrompt),品牌行只属于与用户对话的那一腿(与 7.131.0 同:场景的提示从来不进子代)。
+ * 判它挂不挂的只有引擎一处(`whenHolds`,每一类 overlay 同一只);本服务不读 `e.selectors`,不写任何每请求的分支。
+ * 文本只在 `prompts/identity.ts` 一处(本模块不复述);「这台部署是不是品牌部署」只有一只判官 {@link isBrandedDeployment} —— HTTP 服务的三个读者
+ * (部署座的品牌行 `createDeploymentMods`、commit 尾注署名、场景详情读面的 `promptSummary`)同调它;本地 CLI(`run-local`)恒是品牌形,直接表态 `true`。
+ */
+import type { EngineDollar, ModRegistration, PromptOverlay } from "@sema-agent/core";
+import type { ServiceConfig } from "../config-types.js";
+/** 🔴 **品牌部署的唯一判官**:local 配置源(`CONFIG_PROVIDER=local`,TOC / Sema 产品线)⇒ 品牌部署。读者见本模块头注;再多一个读者也调它,不各写一遍。 */
+export declare function isBrandedDeployment(config: Pick<ServiceConfig, "configProvider">): boolean;
+/** 注册名(admission / 清单 / `superseded` 归因里的那个名字)。 */
+export declare const BRAND_IDENTITY_REGISTRATION = "server.brand-identity";
+/** 品牌行挂的场景(binding 表)。 */
+export declare const BRAND_IDENTITY_SCENARIOS: readonly ["default", "code"];
+/** 那一条 overlay(数据;注册恒答它)。 */
+export declare const BRAND_IDENTITY_OVERLAY: PromptOverlay;
+/** 品牌行的部署注册:`prompt.compose` 是收集型站点 —— 先 `await next(e)`,原样保留它交回的 overlays,再接上自己的一条。 */
+export declare function createBrandIdentityRegistration(): ModRegistration<EngineDollar>;
+//# sourceMappingURL=brand-identity.d.ts.map

package/dist/capabilities/brand-identity.js

@@ -0,0 +1,27 @@
+import { SEMA_IDENTITY } from "./prompts/identity.js";
+export function isBrandedDeployment(config) {
+    return config.configProvider === "local";
+}
+export const BRAND_IDENTITY_REGISTRATION = "server.brand-identity";
+export const BRAND_IDENTITY_SCENARIOS = ["default", "code"];
+export const BRAND_IDENTITY_OVERLAY = {
+    id: "sema/identity",
+    op: "add",
+    target: "role",
+    text: SEMA_IDENTITY,
+    when: { binding: { anyOf: [...BRAND_IDENTITY_SCENARIOS] }, facts: { isSubagent: false } },
+};
+export function createBrandIdentityRegistration() {
+    return {
+        name: BRAND_IDENTITY_REGISTRATION,
+        tier: "prepend",
+        uses: { events: ["prompt.compose"], calls: [] },
+        register(on) {
+            on("prompt.compose", async (_$, e, next) => {
+                const lower = (await next(e))?.overlays;
+                return { overlays: [...(Array.isArray(lower) ? lower : []), BRAND_IDENTITY_OVERLAY] };
+            });
+        },
+    };
+}
+//# sourceMappingURL=brand-identity.js.map

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

@@ -104,6 +104,13 @@ export declare function applyCenterPlugins(baseline: LoadedSkill[], eff: {
 }, opts: {
     cacheRoot: string;
     allowHosts: readonly string[];
+    /**
+     * S-379 —— 「**工具跑的那台机器**的盘就是本进程这台盘吗」,由**组合根**算好传入(`boot/web-admin.ts` 传 `toolsRunOnThisHost(config)`,与出厂自扫
+     * `loadDeploymentSkills` 读的是同一只函数 —— 判据属主在 `task-cwd.ts`,这里不第二次判车道、不 import 车道词)。真 ⇒ 目录形 plugin 技能带上自己的
+     * 目录(`SkillSpec.baseDir`:`Skill` 结果首行 + `${SKILL_ROOT}` 替换);假 ⇒ 不带(fail-closed:沙箱 / 远端车道上这条路径在工具那边不存在)。
+     * 🔴 **必填,不给缺省**:修前这个调用点手上根本没有这一事实,fail-closed 默认把 host 车道也一并挡成「永不带」而没有任何红 —— 必填让「漏传」是编译错。
+     */
+    toolsShareThisFilesystem: boolean;
     logger?: Logger;
     /** 测试口:跳过 validate(materialize 只接受已验声明;真 git 腿用本地 bare repo,validate 层的
      *  https-only 单独测——两层分开,谁也不掩护谁)。生产恒 false/缺席。 */

package/dist/capabilities/center-plugins.js

@@ -196,7 +196,7 @@ export async function applyCenterPlugins(baseline, eff, opts) {
             }
             if (!rootCheck.dir)
                 continue;
-            const loaded = loadSkills(rootCheck.dir, { confineTo: liveDir });
+            const loaded = loadSkills(rootCheck.dir, { confineTo: liveDir, toolsShareThisFilesystem: opts.toolsShareThisFilesystem, ...(opts.logger !== undefined ? { logger: opts.logger } : {}) });
             for (const skill of loaded) {
                 if (taken.has(skill.spec.name)) {
                     out.letGo.push({ plugin: v.name, skill: skill.spec.name });

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

@@ -1,48 +1,24 @@
 /**
- * center prompts 消费投影腿([ref]④/[ref]③ 分工:web 承存储+covering 解析+下发,server 承本模块;
- * [ref] 下发形定稿 / [ref] registry-core 0.10.16 schema / [ref]⑤「server 零新义务=逐字透传」)。
+ * 中心提示层的采纳腿:判官(`prompts-domain-validate.ts` 的 `judgePromptsWire`,经候选判官)收下的那份 artifact → 引擎的中心源
+ * (`CenterPromptSource`,经 `RunnerDeps.promptSource` 由引擎采用)。
  *
- * 链路:center(sema-web-admin,2026-08-26 由 sema-web 改名)把 covering 走完的**基线终形**经 `GET /api/config/effective` 的 additive
- * `prompts` key 下发 → 本模块按任务 scenario 选包(`scenarioOverrides[s] ?? sections`,整包替换非增量,
- * [ref]①c)→ 声明数组**逐字**(含 opt-in `contentHash`,core 1.315 校验+manifest 透传)喂 core 既有
- * typed `stableBlocks` 钩子。守卫全在 core(id 规范/slot 闭集/core/ 命名空间拒绝/identity 三锚
- * pass-through/锁定槽不可写)——server 不做语义复检([ref]①f:identity 完整角色层由 center 编辑面把关)。
- *
- * 仅有的一层「形校验」不是语义复检,是**防炸底线**(详见其现居所 `src/prompts-domain-validate.ts`——
- * 判形半场已下沉到该中立叶子,本文件 re-export 保兼容;[ref] S6,lens2 §G):core 对坏形声明的
- * 守卫是 THROW(assemble 期),server 在采用前做结构判形,坏形=拒绝采用该候选的 prompts 面。
- *
- * 生效语义(两段史):1.222 时 core 1.315 的 epoch 是 bundled-only(声明不进 descriptor),热换=resume
- * 三失真,故临时 restart-to-apply;core 1.316([ref] 裁 a/[ref]d)把声明以 (id,slot,chars,contentHash?)
- * 纳入 artifactDigest——声明变=digest 变=**下任务边界自动重 pin**(既有 legacy_migration 机制接手),
- * 进行中会话 epoch pin 保稳。自此恢复**热采用**(main.ts boot+refresh 双点 adopt),与 center
- * 「发布=新任务生效」产品语义对齐([ref]②b)。字节级检测只认 opt-in contentHash(文本不进 digest,
- * 防会话可导出面字典预映)——center 链路恒逐 section 铸([ref]),本投影逐字透传即全强度。
+ * 律:中心层只有一种形(引擎当期 schema 的发布形 artifact),只有一个座(`RunnerDeps.promptSource`)。本服务不展开、不选包、不按场景挑段:
+ * 「哪个场景用哪段」在 artifact 的 `when.binding` 里,由引擎按每个请求的 `TaskSpec.promptBinding`(场景名,`buildPromptSeats` 一处写)判。
+ * 本模块只管三件事:① 把判官交出的值推进中心源的两态过渡({@link applyCenterArtifact});② 按 digest 补拉一份本副本没有的 artifact
+ * ({@link withPromptArtifactBackfill},钉着它的会话续跑时用);③ 中心源自己的运维句(启动恢复读到一份引擎拒的 / 读不出的副本)
+ * 落进本服务的日志({@link centerSourceOnError})。
  */
-import { type PromptProvider, type PublishedPromptArtifactEnvelope } from "@sema-agent/core";
-import { type EffectiveCenterPrompts, type PromptsDomainFaces } from "../prompts-domain-validate.js";
-/** 判形半场(validateCenterPrompts/validatePromptsDomain/CORE_ENGINE_VERSION 及两 interface)已下沉到
- *  中立叶子 `src/prompts-domain-validate.ts`([ref] S6);消费者直引真源([ref] 兼容面全清,
- *  此处兼容 re-export 已删)。 */
-/** [ref]b / [ref] — §9.4 by-digest 补拉组合店:local miss ⇒ fetchRaw(digest) 从 center 拉 envelope ⇒
- *  core verifyPromptArtifact 全管线 + **回验「拿到的=要的」digest 逐位**(center 答非所问=丢弃)⇒
- *  best-effort 回写 inner(下次直命中)。任何失败=undefined(诚实缺席,fail-loud 归 core 的
- *  prompt_snapshot_unavailable——绝不拼杂交)。 */
-export declare function withPromptArtifactBackfill(inner: {
-    get(d: string, o: {
-        engineVersion: string;
-    }): Promise<PublishedPromptArtifactEnvelope | undefined>;
-    put(e: PublishedPromptArtifactEnvelope): Promise<void>;
-}, fetchRaw: (artifactDigest: string) => Promise<unknown>, log: {
+import { type PromptArtifactStore, type PublishedPromptArtifact, type RunnerDeps } from "@sema-agent/core";
+type Log = {
     info: (msg: string, meta?: Record<string, unknown>) => void;
     warn: (msg: string, meta?: Record<string, unknown>) => void;
-}): typeof inner;
-/** e/b 接线([ref]① seam/[ref]e):catalog 轴的两态过渡推进 core 的 CenterPromptSource——
- *  present(且身份变)⇒ applySnapshot(core 重验+落盘+原子换 candidate;validate 已过 core verify,
- *  此处失败=磁盘/状态写问题,warn 不挡 declaration 轴);absent-after-present / prompts 键整体消失
- *  ⇒ applyDisabled(闸关=显式撤下语义的 catalog 轴半场,离线重启不复活)。幂等安全:同 envelope
- *  重放=同 digest 覆盖写。 */
-export declare function applyCatalogToSource(source: {
+};
+/** §9.4 按 digest 补拉的组合店:本地 miss ⇒ `fetchRaw(digest)` 从中心拉 ⇒ 引擎 `verifyPromptArtifact` 全管线 + **回验「拿到的 = 要的」digest 逐位**
+ *  (中心答非所问 = 丢弃)⇒ best-effort 回写本地店(下次直命中)。任何失败 = undefined(诚实缺席;响亮归引擎的 `prompt.snapshot_unavailable` —— 绝不拼杂交)。
+ *  本地店的 `onRefused`(一份副本在、却用不了:引擎拒 / 读不出)原样交给本地店报,不吞:那是「为什么缺」的那一句。 */
+export declare function withPromptArtifactBackfill(inner: PromptArtifactStore, fetchRaw: (artifactDigest: string) => Promise<unknown>, log: Log): PromptArtifactStore;
+/** 中心源的推进面(引擎 `CenterPromptSource` 的两只写口 + 两只「欠不欠撤下」的读口)。 */
+export interface CenterSourceTransitions {
     applySnapshot(raw: unknown): Promise<{
         ok: true;
         artifactDigest: string;
@@ -52,27 +28,24 @@ export declare function applyCatalogToSource(source: {
         reason: string;
     }>;
     applyDisabled(sourceRevision: string): Promise<void>;
-    /** codex-2 F2(restart-owed disable):撤下写盘失败后重启,内存 prev 丢了但持久态还 active——
-     *  以 source 自身的 live candidate 为准判「欠 disable」,不是只看内存 prev。 */
+    /** codex-2 F2(restart-owed disable):撤下写盘失败后重启,内存 prev 丢了但持久态还 active —— 以中心源自身的活候选为准判「欠撤下」,不是只看内存 prev。 */
     current?(): unknown;
-    /** S-651(codex 修复验证轮 V1):本箱**持久记录**是 active —— 即使那份 artifact 此刻加载不出(活候选为空)。
-     *  「欠撤下」的真源是持久记录;活候选只是它能加载时的影子。缺席 = 调用方不掌握持久记录(沿用前两条判据)。 */
+    /** 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;
-}, phase: string): Promise<boolean>;
+}
+/**
+ * 判官交出的值推进中心源的两态过渡:`next` 在场(且 digest 变)⇒ `applySnapshot`(引擎重验 + 落盘 + 原子换候选);`next` 缺席
+ * (候选不带 prompts 键 = 闸关 / 没发布)而中心层此前在(内存 prev / 活候选 / 持久 active 任一)⇒ `applyDisabled`(显式撤下,离线重启不复活)。
+ * 去重键是 artifact 的内容身份(digest;发布出处 `sourceRevision` 不进身份)。返回过渡是否落地 —— false ⇒ 调用方**不推进**已采纳的值,
+ * 下一拍同一过渡自动重试(codex-2 F2:吞错推进曾让失败的采纳 / 撤下永久静默)。
+ */
+export declare function applyCenterArtifact(source: CenterSourceTransitions, next: PublishedPromptArtifact | undefined, prev: PublishedPromptArtifact | undefined, log: Log, phase: string): Promise<boolean>;
 /**
- * 选包+投影:该 scenario 的终形声明数组(`scenarioOverrides[s] ?? sections`)→ typed `stableBlocks`
- * 钩子(声明**逐字**透传,含 contentHash——core 1.315 校验后进 manifest)。空数组在 validate 已拒
- * (F4:空替换集非 v1 语义),所以这里恒有非空声明——恒返回 provider(center-wins 无死分支)。
+ * 中心源自己的运维句(`CenterPromptSource` 的 `onError` 选项,引擎的 `RunnerDeps.onError` 形)落进本服务的日志:启动恢复读到持久记录指着的那份 artifact
+ * 被引擎拒(退役 schema 的拒句点名重发写法)/ 读不出 / 根本没有副本 —— 中心源无状态起服并说一句。行名与 Runner 的 `prompt-constitution` 阶段同一个
+ * (`prompt_composition_warning`):那一阶段的句子都在说「交给组装的东西没有照写的那样生效」。不传 = 这几句静默(引擎的缺省),所以每个起中心源的入口都传它。
  */
-export declare function centerPromptProvider(prompts: EffectiveCenterPrompts, scenarioName: string): PromptProvider;
-/** codex R3(appendSystemPrompt 案):该 scenario 的终形 center 声明里是否有「已组装 identity」——core 的
- *  M9 迁移卫在 provider.stableBlocks 的 identity 声明上探同三锚,命中即走 pass-through 臂(其保留集无
- *  `core/role.append`,任何 append rider/outputStyle 会被静默丢)。选包与 {@link centerPromptProvider}
- *  同式(`overrides[s] ?? sections`);锚谓词由调用方注入(task-settings `hasConstitutionAnchors` 单真源)。
- *  [ref]①f 的「server 不做语义复检」不动:这不是复检语义,是为 capabilities.appendSystemPrompt 的诚实面
- *  探 core 会走哪条臂。 */
-export declare function centerIdentityAssembled(prompts: EffectiveCenterPrompts, scenarioName: string, isAssembled: (text: unknown) => boolean): boolean;
+export declare function centerSourceOnError(log: Pick<Log, "warn">): NonNullable<RunnerDeps["onError"]>;
+export {};
 //# sourceMappingURL=center-prompts.d.ts.map

package/dist/capabilities/center-prompts.js

@@ -1,17 +1,16 @@
 import { verifyPromptArtifact } from "@sema-agent/core";
-import { CORE_ENGINE_VERSION } from "../prompts-domain-validate.js";
 import { SHA256_HEX_RE } from "../digest-form.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 export function withPromptArtifactBackfill(inner, fetchRaw, log) {
     const inFlight = new Map();
     return {
-        put: (e) => inner.put(e),
-        get: async (digest, opts) => {
+        put: (artifact) => inner.put(artifact),
+        get: async (digest, onRefused) => {
             const hex = digest.replace(/^sha256:/i, "").toLowerCase();
             if (!SHA256_HEX_RE.test(hex))
                 return undefined;
             const canonical = `sha256:${hex}`;
-            const local = await inner.get(canonical, opts);
+            const local = await inner.get(canonical, onRefused);
             if (local)
                 return local;
             const pending = inFlight.get(canonical);
@@ -20,14 +19,14 @@ export function withPromptArtifactBackfill(inner, fetchRaw, log) {
             const run = (async () => {
                 try {
                     const raw = await fetchRaw(canonical);
-                    const v = verifyPromptArtifact(raw, { engineVersion: CORE_ENGINE_VERSION });
+                    const v = verifyPromptArtifact(raw);
                     if (!v.ok || v.artifact.artifactDigest.replace(/^sha256:/, "").toLowerCase() !== hex) {
                         log.warn("center_prompts_backfill_rejected", { digest: canonical, ...(v.ok ? { got: v.artifact.artifactDigest, code: "digest_mismatch" } : { code: v.code, reason: v.reason }) });
                         return undefined;
                     }
-                    await inner.put(raw).catch(() => recordFailOpen("server.prompts.artifact-cache-write-failed", `digest=${canonical}`));
+                    await inner.put(v.artifact).catch(() => recordFailOpen("server.prompts.artifact-cache-write-failed", `digest=${canonical}`));
                     log.info("center_prompts_backfilled", { digest: canonical });
-                    return raw;
+                    return v.artifact;
                 }
                 catch (e) {
                     log.warn("center_prompts_backfill_failed", { digest: canonical, err: String(e) });
@@ -42,22 +41,22 @@ export function withPromptArtifactBackfill(inner, fetchRaw, log) {
         },
     };
 }
-export async function applyCatalogToSource(source, next, prev, log, phase) {
+export async function applyCenterArtifact(source, next, prev, log, phase) {
     try {
-        if (next?.catalog) {
-            if (prev?.identity === next.identity)
+        if (next !== undefined) {
+            if (prev?.artifactDigest === next.artifactDigest)
                 return true;
-            const r = await source.applySnapshot(next.catalog);
+            const r = await source.applySnapshot(next);
             if (r.ok) {
                 log.info("center_prompts_catalog_applied", { phase, artifactDigest: r.artifactDigest });
                 return true;
             }
-            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" });
+            log.warn("center_prompts_catalog_apply_failed", { phase, code: r.code, reason: r.reason, note: "the candidate passed the judge but the source apply failed (disk/state) — built-ins unaffected; candidate unchanged; the transition retries on the next refresh tick" });
             return false;
         }
-        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)" });
+        if (prev !== undefined || source.current?.() !== undefined || source.persistedActive?.() === true) {
+            await source.applyDisabled(`${phase}:prompts-absent`);
+            log.info("center_prompts_catalog_disabled", { phase, note: "center layer withdrawn — the engine's candidate is cleared (does not revive offline)" });
         }
         return true;
     }
@@ -66,22 +65,9 @@ export async function applyCatalogToSource(source, next, prev, log, phase) {
         return false;
     }
 }
-export function centerPromptProvider(prompts, scenarioName) {
-    const decls = scenarioDecls(prompts, scenarioName);
-    return { stableBlocks: () => decls };
-}
-export function centerIdentityAssembled(prompts, scenarioName, isAssembled) {
-    return scenarioDecls(prompts, scenarioName).some((d) => d.slot === "identity" && isAssembled(d.text));
-}
-function scenarioDecls(prompts, scenarioName) {
-    const overrides = prompts.scenarioOverrides;
-    if (overrides) {
-        if (Object.hasOwn(overrides, scenarioName)) {
-            const hit = overrides[scenarioName];
-            if (hit)
-                return hit;
-        }
-    }
-    return prompts.sections;
+export function centerSourceOnError(log) {
+    return (err, ctx) => {
+        log.warn("prompt_composition_warning", { sessionId: ctx.sessionId, ...(ctx.classification !== undefined ? { classification: ctx.classification } : {}), info: err instanceof Error ? err.message : String(err) });
+    };
 }
 //# sourceMappingURL=center-prompts.js.map

package/dist/capabilities/composite-members.d.ts

@@ -45,7 +45,7 @@ export declare const COMPOSITE_CAPABILITY_MEMBERS: {
     readonly centerWiring: readonly ["effectivePull", "effectiveRevision", "lease", "leaseHealth", "failMode", "usageReport", "issuer", "worker", "caller"];
     readonly webSearch: readonly ["backend"];
     readonly background: readonly ["listFace", "exitFaces"];
-    readonly taskSettings: readonly ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks"];
+    readonly taskSettings: readonly ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats"];
     readonly settings: readonly ["permissions"];
     readonly permissionModeAuto: readonly ["accepted", "classifierSeat", "entitlementSource", "armed", "reason", "model"];
     readonly writeProtection: readonly ["armed", "rows", "replaced"];

package/dist/capabilities/composite-members.js

@@ -6,7 +6,7 @@ export const COMPOSITE_CAPABILITY_MEMBERS = {
     centerWiring: ["effectivePull", "effectiveRevision", "lease", "leaseHealth", "failMode", "usageReport", "issuer", "worker", "caller"],
     webSearch: ["backend"],
     background: ["listFace", "exitFaces"],
-    taskSettings: ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks"],
+    taskSettings: ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats"],
     settings: ["permissions"],
     permissionModeAuto: ["accepted", "classifierSeat", "entitlementSource", "armed", "reason", "model"],
     writeProtection: ["armed", "rows", "replaced"],

package/dist/capabilities/engine-capabilities.js

@@ -1,7 +1,8 @@
 import { ENGINE_CAPABILITIES } from "@sema-agent/core";
-import { ownCredentialsWithheld } from "../server-secret-env.js";
+import { ownCredentialsWithheld, ownCredentialValuesWithheld } from "../server-secret-env.js";
 const ENGINE_CAPABILITY_FACTS = {
     "inherit_env.own_credentials_withheld": ownCredentialsWithheld,
+    "inherit_env.own_credential_values_withheld": ownCredentialValuesWithheld,
 };
 export function engineCapabilityBits() {
     const out = {};

package/dist/capabilities/execution-lane.js

@@ -1,8 +1,8 @@
 import { toolsRunOnThisHost } from "../task-cwd.js";
-import { executionLaneCaps, executionLaneOf, laneIsolated } from "../execution-lane-caps.js";
+import { executionLaneOf, laneIsolated, laneWiresExecutionEnv } from "../execution-lane-caps.js";
 export function projectExecutionLaneCapability(config) {
     const lane = executionLaneOf(config.remoteExec?.provider);
-    const handsWired = executionLaneCaps(lane).coreRemoteExecutionEnv === "supported";
+    const handsWired = laneWiresExecutionEnv(lane);
     return {
         provider: lane,
         toolsOnThisHost: toolsRunOnThisHost(config),