@sema-agent/server 7.136.0 → 7.138.0

package/dist/broker/main.js

@@ -0,0 +1,20 @@
+import { BROKER_HOST, BROKER_LEASE_PATH, BROKER_LEASE_POLL_MS, BROKER_PORT, BROKER_PROBE_ARG } from "./constants.js";
+import { probeBroker, runBroker } from "./broker.js";
+const PROBE_TIMEOUT_MS = 2_000;
+async function main() {
+    if (process.argv.includes(BROKER_PROBE_ARG)) {
+        process.exit((await probeBroker(BROKER_HOST, BROKER_PORT, PROBE_TIMEOUT_MS)) ? 0 : 1);
+    }
+    await runBroker({
+        leasePath: BROKER_LEASE_PATH,
+        host: BROKER_HOST,
+        port: BROKER_PORT,
+        pollMs: BROKER_LEASE_POLL_MS,
+        log: (e) => void process.stdout.write(`${JSON.stringify(e)}\n`),
+    });
+}
+main().catch((e) => {
+    process.stderr.write(`${JSON.stringify({ event: "broker_failed", error: e instanceof Error ? e.message : String(e) })}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/budget.d.ts

@@ -5,7 +5,7 @@
  *   ④ createTracer    — core's content-free TraceEvents → /metrics (spend, first-token, tool calls).
  *   ⑤ cappedCeiling  — clamp a caller's requested per-task budget DOWN to the operator ceiling.
  */
-import { type Model, type ModelPricing, type TracerHook } from "@sema-agent/core";
+import { type AccountRow, type Model, type ModelPricing, type TracerHook } from "@sema-agent/core";
 import type { Metrics } from "./observability/metrics.js";
 import type { QuotaTracker } from "./observability/cost-quota.js";
 import type { FleetUsageBins } from "./fleet-client.js";
@@ -116,23 +116,25 @@ export declare function createTracer(metrics: Pick<Metrics, "inc" | "observe">,
  * (tokens×quotaWeight,weight-at-burn 固化)、micro-USD 同轴。装配点与 createTracer 同一处(main.ts),
  * 传同一组实例——两臂永不分家。
  *
- * 已知残差(codex R3 medium,记档):cost 源=core SideQueryResult.usage.cost.total(brain 层计价),
- * OpenAI cache-heavy 输入按全价入账(tracer 的 e.costMicroUsd 是 cache-family-aware 价)——方向=多收
- * (保守,绝不少收);根修=core 在 SideQueryResult 上回权威 costMicroUsd(已提货 core)。model 标签/
+ * 金额源 = 引擎定价的账行 `SideQueryResult.account.costMicroUsd`(core 7.59.0:与 run 的旁路调用同一只定价函数、
+ * 按部署价表、按实际作答的模型)—— 与 tracer 的 `e.costMicroUsd` 同一口径;缺席 = 那只模型没有价表 = **未知**(不编 0)。
+ * 适配器自报的 `usage.cost.total`(cache 命中按全价)不是金额源(7.58.x 及更早读它,cache-heavy 时多收)。model 标签 /
  * weight 键用**路由身份 r.model**(池配置有界)非 servedModel(provider 上报,无界)。
  */
-export declare function createSideQueryAccountant(metrics: Pick<Metrics, "inc">, costQuota?: QuotaTracker, fleetUsage?: Pick<FleetUsageBins, "record">, fleetLease?: Pick<FleetLeaseManager, "recordSpend">, quotaWeightFor?: (model: string) => number): (principal: string | undefined, r: {
-    model: string;
-    usage?: {
-        input?: number;
-        output?: number;
-        cacheRead?: number;
-        cacheWrite?: number;
-        cost?: {
-            total?: number;
-        };
+export interface SideQueryAccountingInput {
+    readonly model: string;
+    /** 引擎归一的计数(`input` 已是 uncached 量,见函数体 [ref] 注)。 */
+    readonly usage?: {
+        readonly input?: number;
+        readonly output?: number;
+        readonly cacheRead?: number;
+        readonly cacheWrite?: number;
     };
-}) => void;
+    /** 引擎定价的账行(`origin: "side_query"`);只读它的 `costMicroUsd`。 */
+    readonly account?: AccountRow;
+}
+export type SideQueryAccounting = (principal: string | undefined, r: SideQueryAccountingInput) => void;
+export declare function createSideQueryAccountant(metrics: Pick<Metrics, "inc">, costQuota?: QuotaTracker, fleetUsage?: Pick<FleetUsageBins, "record">, fleetLease?: Pick<FleetLeaseManager, "recordSpend">, quotaWeightFor?: (model: string) => number): SideQueryAccounting;
 /**
  * ⑤ Resolve a per-task budget: honor the caller's requested value but never let it EXCEED the operator
  * ceiling. `0`/unset ceiling = no limit (returns the caller's value, or undefined). A non-positive /

package/dist/budget.js

@@ -144,8 +144,8 @@ export function createSideQueryAccountant(metrics, costQuota, fleetUsage, fleetL
         const cacheRead = typeof r.usage?.cacheRead === "number" ? r.usage.cacheRead : 0;
         const cacheWrite = typeof r.usage?.cacheWrite === "number" ? r.usage.cacheWrite : 0;
         const promptTokens = input + cacheRead + cacheWrite;
-        const costTotal = typeof r.usage?.cost?.total === "number" ? r.usage.cost.total : undefined;
-        const micro = costTotal !== undefined ? Math.round(costTotal * 1_000_000) : undefined;
+        const costMicro = r.account?.costMicroUsd;
+        const micro = typeof costMicro === "number" && Number.isFinite(costMicro) ? Math.round(costMicro) : undefined;
         if (micro !== undefined && micro > 0) {
             metrics.inc("model_cost_micro_usd_total", { model: r.model }, micro);
             if (principal)

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

@@ -38,7 +38,7 @@ import type { NamedKeysOf } from "../request-key-closure.js";
  * B.2b)与 CHANGELOG。present-iff 的位与成员照样登记(在场律写在附录的「在场律」列)。
  */
 export declare const COMPOSITE_CAPABILITY_MEMBERS: {
-    readonly deviceExecutor: readonly ["enabled", "protocolVersion", "maxInflightPerDevice", "wsPath", "management"];
+    readonly deviceExecutor: readonly ["enabled", "protocolVersion", "maxInflightPerDevice", "wsPath", "management", "relayUrl"];
     readonly fleet: readonly ["stream", "sessionScope", "observe", "resume", "bgNotifyFailClosed", "steerPriority", "hookFailureNotice", "leaseClient", "generationEcho"];
     readonly memoryEngine: readonly ["backend", "vectorMode"];
     readonly store: readonly ["declared", "backend", "durable", "degradedReason", "sql"];
@@ -55,6 +55,7 @@ export declare const COMPOSITE_CAPABILITY_MEMBERS: {
     readonly sealedKey: readonly ["alg", "publicKeyId", "publicKey"];
     readonly workspaceSync: readonly ["persist", "keep", "timeoutMs", "cache"];
     readonly userAttachments: readonly ["entries", "kinds", "supplies", "limits"];
+    readonly credentialPlane: readonly ["sandboxGit"];
 };
 type CompositeTable = typeof COMPOSITE_CAPABILITY_MEMBERS;
 /** 值的**具名成员对象臂**(标量 / 字面词 / `false` / `null` / `undefined` / 数组 / 函数臂剥掉)。 */

package/dist/capabilities/composite-members.js

@@ -1,5 +1,5 @@
 export const COMPOSITE_CAPABILITY_MEMBERS = {
-    deviceExecutor: ["enabled", "protocolVersion", "maxInflightPerDevice", "wsPath", "management"],
+    deviceExecutor: ["enabled", "protocolVersion", "maxInflightPerDevice", "wsPath", "management", "relayUrl"],
     fleet: ["stream", "sessionScope", "observe", "resume", "bgNotifyFailClosed", "steerPriority", "hookFailureNotice", "leaseClient", "generationEcho"],
     memoryEngine: ["backend", "vectorMode"],
     store: ["declared", "backend", "durable", "degradedReason", "sql"],
@@ -16,6 +16,7 @@ export const COMPOSITE_CAPABILITY_MEMBERS = {
     sealedKey: ["alg", "publicKeyId", "publicKey"],
     workspaceSync: ["persist", "keep", "timeoutMs", "cache"],
     userAttachments: ["entries", "kinds", "supplies", "limits"],
+    credentialPlane: ["sandboxGit"],
 };
 export function gateCompositeMembers(body) {
     return body;

package/dist/capabilities/engine-capabilities.js

@@ -3,6 +3,7 @@ import { ownCredentialsWithheld, ownCredentialValuesWithheld } from "../server-s
 const ENGINE_CAPABILITY_FACTS = {
     "inherit_env.own_credentials_withheld": ownCredentialsWithheld,
     "inherit_env.own_credential_values_withheld": ownCredentialValuesWithheld,
+    "mods.skill_seat": () => false,
 };
 export function engineCapabilityBits() {
     const out = {};

package/dist/capabilities/mcp-probe.d.ts

@@ -34,6 +34,7 @@
  */
 import { type McpServerSpec } from "@sema-agent/core";
 import type { DeclarationRefusal } from "../request-declaration-refusal.js";
+import { type McpDraft, type PeerDesk } from "../peer-seat.js";
 /**
  * 本面的**拒码闭集**(设计稿 §2 的四枚)。闭集写成型,是为了让 {@link MCP_PROBE_HTTP_STATUS} 那张表
  * 「漏一枚 = 编译红」—— [ref] 的安全轴纪律:词表是闭集,未处置的成员必须是编译错误而不是运行期惊喜。
@@ -163,25 +164,29 @@ export interface McpProbeRefusal {
     readonly facts?: DeclarationRefusal["facts"];
 }
 /**
- * `POST …/probe` 的体读器:闭形、逐条点名、零静默丢。成功 ⇒ 交给 core 的 `specs`(**原样**转发被读出来的
- * 条目,`McpServerSpec` 的可选键一个都不重写 —— 重写就是在 core 的型上做第二次投影)。
+ * `POST …/probe` 的体读器:闭形、逐条点名、零静默丢。成功 ⇒ 每条申报的**草稿**(被读出来的条目经 `toMcpDraft` 拆成声明 + 件,
+ * 声明里 `McpServerSpec` 的可选键一个都不重写 —— 重写就是在 core 的型上做第二次投影)。
  *
  * ## 申报「能不能原样用」:问提交腿 fresh 门**同一只**回答者,不另判
  * 本面只判自己那一层(体是对象、顶层只受理 `mcpServers`、这个键必填);`mcpServers` 本身 —— 列表的形、上限、每条的键名与键值 —— 全部交给
  * `task-mcp.ts` 的 `requestMcpDeclarationRefusal`,拒(码 + 句 + `unknownKeys` + 撞帽 / url 带凭据两形的机读位)原样转述:同一份申报在两扇门上只有一个答案,零拨号之前就给。
- * 回答者受理的申报由**同一只**读器(`validateRequestMcp`)交回,读器的产物就是申报本身(只差判官自己的合法归一),经 `toCoreMcpServerSpec`
- * 得到的就是一条任务提交会交给引擎的那一份 —— 本面拨的正是它。读器只在回答者受理之后才跑,所以它对重放存量 body 才有的降级留痕
- * (`source` 写坏的 F 类丢弃)不会在一次被拒的探测上虚记。
+ * 回答者受理的申报由**同一只**读器(`validateRequestMcp`)交回,读器的产物就是申报本身(只差判官自己的合法归一),经 `toMcpDraft`
+ * 拆出的草稿就是一条任务提交会交给铸点的那一份 —— 走查在自己的租约下铸它(见 {@link createMcpProbeWalk}),本面拨的正是铸出的声明。读器只在回答者受理之后才跑,
+ * 所以它对重放存量 body 才有的降级留痕(`source` 写坏的 F 类丢弃)不会在一次被拒的探测上虚记。
  *
- * ## 唯一一处按门分的后果:声明了 `assertionHeader`(引擎尚无断言头座)
+ * ## 唯一一处按门分的后果:声明了 `assertionHeader`(本部署的对端座对断言一种引用恒拒、没有断言来源)
  * 事实只有一个、读它的谓词只有一只(`specWithholdsMcpAssertionHeader`,读发送开关 `MCP_ASSERTION_HEADER_SENT`):这台 server 声明的断言头本版**承载、不发送**,交给引擎的规格里没有它。
  * 新提交照挂并给运维一行 info(`mcp_assertion_header_not_sent`;settings 面同读法);本面**整条拒** —— 拨出去的不是申报的那一份,一台握手放行、
  * 调用才要断言的对端会被答成 connected,而它的调用会被拒。判据同一只、后果按门分(与重放腿对同一组身份头「降级到升级前读法」同一个姿势);
- * 引擎长出同名座的那天,开关翻真,`toCoreMcpServerSpec` 的剥键与这一拒一起退役(`mcp-assertion-header.ts` 的退役门编译红)。
+ * 开关与它的退役门在 `mcp-assertion-header.ts`(押在对端座上)。
+ *
+ * ## 带件的申报(`transport.headers` / `transport.env`):与任务提交同一条路
+ * 件进草稿、不进声明;走查在自己的宿主租约下把件登记进部署的对端座,交给引擎的声明只带一只引用,引擎在起子进程 / 发请求时向同一只座要 ——
+ * 拨出去的就是申报的那一份,件形的判(多行值、协议自有头名 …)也是任务那一份判。
  */
 export declare function readMcpProbeBody(raw: unknown): {
     ok: true;
-    specs: McpServerSpec[];
+    drafts: McpDraft[];
 } | {
     ok: false;
     refusal: McpProbeRefusal;
@@ -194,8 +199,28 @@ export declare function readMcpProbeBody(raw: unknown): {
  * 无 principal(单用户部署上恒如此)折成 `local`:那台机器上只有一个人。
  */
 export declare function buildMcpProbeIdentity(principal: string | undefined): string;
-/** 缓存键 = `(身份, sha256(规范化 specs))`。**纯数据** ⇒ `build*`。 */
-export declare function buildMcpProbeCacheKey(principal: string | undefined, specs: readonly McpServerSpec[]): string;
+/**
+ * 一次探测问的是什么 —— 两条口各一臂,**谁写的申报**就是判别位:
+ *  · `deployment`(`GET /v1/capabilities/mcp`)= 本部署名册里这个场景挂的声明。它们起服时已在名册租约下铸过(件在对端座里、声明只带引用),
+ *    走查直接拨、不开租约、不再登记;
+ *  · `caller`(`POST …/probe`)= 调用方自带申报的草稿(声明 + 件)。走查在自己的宿主租约下经唯一铸点登记件,见 {@link createMcpProbeWalk}。
+ * 两臂的声明都由同一只座作答。缓存键、走查、失败归属(谁写的申报谁的错)都读这一只输入。
+ */
+export type McpProbeInput = {
+    readonly declaredBy: "deployment";
+    readonly specs: readonly McpServerSpec[];
+} | {
+    readonly declaredBy: "caller";
+    readonly drafts: readonly McpDraft[];
+};
+/** 这次探测申报了几台(零台 ⇒ 诚实空面,不进缓存、不占限速、不开租约)。 */
+export declare function countMcpProbeDeclarations(input: McpProbeInput): number;
+/**
+ * 缓存键 = `(身份, sha256(规范化的整份输入))`。**对输入算**:键在缓存命中 / 在途帽 / 限速三道前置拒里就要用,那时还没有登记任何件(登记在走查里),
+ * 所以只能对问的那一份算 —— 调用方臂的件在键内(只差凭据的两份申报是两次走查,与件写在声明里时同义),申报方也在键内(同一份声明在两臂上是两件事)。
+ * 部署臂的声明带的是引用,同一进程同内容同 id,换了名册的件就换了 id。键只在进程内的表里用,不出门。**纯数据** ⇒ `build*`。
+ */
+export declare function buildMcpProbeCacheKey(principal: string | undefined, input: McpProbeInput): string;
 /** 限速键(设计稿 §3:`mcp-probe:<身份>`)。**纯数据** ⇒ `build*`。 */
 export declare function buildMcpProbeRateKey(principal: string | undefined): string;
 /** 本域独占的运行期状态(每 server 实例一份 —— 模块级会把缓存与限速窗跨实例串味)。 */
@@ -281,7 +306,7 @@ export interface McpProbeWalk {
     readonly answer: Promise<McpProbeFaceBody>;
     readonly dials: Promise<unknown>;
 }
-export declare function createMcpProbeWalk(specs: readonly McpServerSpec[], principal: string | undefined, now?: () => number): McpProbeWalk;
+export declare function createMcpProbeWalk(input: McpProbeInput, principal: string | undefined, desk: PeerDesk, now?: () => number): McpProbeWalk;
 /**
  * 下标对齐的**内部断言**没过(行数 ≠ 申报数,或读数条数 ≠ 行数):core 的 `@contract mcp.probe.index_aligned` 在今天结构上保证它不发生,
  * 所以它一旦发生,是**这台服务内部的读数违约**,不是调用方的申报写错 —— 修申报修不好它。**具名型**而不是按文案或按「非 Incomplete 的 reject」分诊:

package/dist/capabilities/mcp-probe.js

@@ -4,7 +4,8 @@ import { createFixedWindowRateLimiter } from "../device-enrollment.js";
 import { canonicalJsonStringify } from "@sema-agent/core";
 import { keyClosureClause, scanKeyClosure } from "../request-key-closure.js";
 import { requestMcpDeclarationRefusal, validateRequestMcp } from "../task-mcp.js";
-import { specWithholdsMcpAssertionHeader, toCoreMcpServerSpec } from "../mcp-assertion-header.js";
+import { specWithholdsMcpAssertionHeader, toMcpDraft } from "../mcp-assertion-header.js";
+import { mintDeclaration } from "../peer-seat.js";
 import { projectWiringManifestMcpRows } from "../trace/project.js";
 import { buildBoundedToolNames } from "../panel-tool-names.js";
 export const MCP_PROBE_REFUSAL_CODES = [
@@ -80,13 +81,26 @@ export function readMcpProbeBody(raw) {
                 "Probe the entry without the key to see how the server answers without it"),
         };
     }
-    return { ok: true, specs: validated.ok.map(toCoreMcpServerSpec) };
+    return { ok: true, drafts: validated.ok.map(toMcpDraft) };
 }
 export function buildMcpProbeIdentity(principal) {
     return principal !== undefined && principal.length > 0 ? principal : "local";
 }
-export function buildMcpProbeCacheKey(principal, specs) {
-    return `${buildMcpProbeIdentity(principal)}::${createHash("sha256").update(canonicalJsonStringify(specs), "utf8").digest("hex")}`;
+export function countMcpProbeDeclarations(input) {
+    switch (input.declaredBy) {
+        case "deployment":
+            return input.specs.length;
+        case "caller":
+            return input.drafts.length;
+        default: {
+            const unknownArm = input;
+            void unknownArm;
+            throw new Error("mcp probe: an input arm this module does not know (the arm set is closed: deployment / caller)");
+        }
+    }
+}
+export function buildMcpProbeCacheKey(principal, input) {
+    return `${buildMcpProbeIdentity(principal)}::${createHash("sha256").update(canonicalJsonStringify(input), "utf8").digest("hex")}`;
 }
 export function buildMcpProbeRateKey(principal) {
     return `mcp-probe:${buildMcpProbeIdentity(principal)}`;
@@ -155,7 +169,8 @@ export function buildMcpProbeFaceRows(rows, readings) {
 function isStringList(v) {
     return Array.isArray(v) && Array.from(v).every((t) => typeof t === "string");
 }
-export function createMcpProbeWalk(specs, principal, now = Date.now) {
+export function createMcpProbeWalk(input, principal, desk, now = Date.now) {
+    const { specs, lease } = probeDeclarations(input, desk);
     const bound = buildMcpProbeWalkTimeoutMs(specs.length);
     const controller = new AbortController();
     const dials = probeMcpServers(specs, {
@@ -163,7 +178,10 @@ export function createMcpProbeWalk(specs, principal, now = Date.now) {
         timeoutMs: MCP_PROBE_VERDICT_TIMEOUT_MS,
         concurrency: MCP_PROBE_CONCURRENCY,
         signal: controller.signal,
+        peerSeat: desk.seat.answer,
     });
+    if (lease !== undefined)
+        void dials.then(() => lease.release(), () => lease.release());
     dials.catch(() => undefined);
     let timer;
     const deadline = new Promise((_resolve, reject) => {
@@ -189,6 +207,27 @@ export function createMcpProbeWalk(specs, principal, now = Date.now) {
     answer.catch(() => undefined);
     return { answer, dials };
 }
+function probeDeclarations(input, desk) {
+    switch (input.declaredBy) {
+        case "deployment":
+            return { specs: input.specs };
+        case "caller": {
+            const lease = desk.lease("probe");
+            try {
+                return { specs: input.drafts.map((draft) => mintDeclaration(desk, draft, lease)), lease };
+            }
+            catch (err) {
+                lease.release();
+                throw err;
+            }
+        }
+        default: {
+            const unknownArm = input;
+            void unknownArm;
+            throw new Error("mcp probe: an input arm this module does not know (the arm set is closed: deployment / caller)");
+        }
+    }
+}
 export class McpProbeMisaligned extends Error {
     constructor(message) {
         super(message);

package/dist/capabilities/scenarios.d.ts

@@ -2,7 +2,7 @@ import { type WebFetchConfig, type BackgroundAgentStore, type CheckpointStore, t
 import type { Logger } from "../observability/logger.js";
 import { type SubagentExtraToolSet } from "./builtin-tools.js";
 import { type RepoReadClient } from "./repo-tools.js";
-import { type LoadedSkill, type ScenarioSkillEntry } from "./skills.js";
+import { type LoadedSkill, type RunSkillEntry, type ScenarioSkillEntry, type SkillSource } from "./skills.js";
 import { type ScenarioHands } from "./hands-lane.js";
 import type { DelegationRootWitness } from "../delegated-session-owner.js";
 /**
@@ -315,14 +315,29 @@ export declare function centerScenarios(deps: ScenarioDeps, specs: CenterScenari
     shadows: string[];
 };
 /**
- * Personalization seam: merge the caller's own skills AFTER the scenario's, with
- * SCENARIO-WINS on a name clash — the scenario / center skills own the name (they are the deployment's baseline
- * wording, not an enforcement face: permissions / write gates / hooks do not ride on skills, and a caller may
- * unload the whole set with `disableSkills`, [ref]); user content never shadows them. Duplicate names within the user list keep the first. Clashes are logged for audit
- * (silent drops would make "my skill didn't fire" undebuggable). Input is already shape/size-validated
- * by the HTTP layer (validateUserSkills); this stays pure merge policy.
+ * 一条 run 的技能(交给引擎的 `TaskSpec.skills`)与它的名册(`wiring_manifest.skills`)—— **同一次合并的两个投影**,铸点只有 {@link buildRunSkills}。
+ *  · `specs`  —— 交给引擎的那一份(`undefined` = 一只都没有且没被关;`disable` ⇒ 显式 `[]`,引擎对空表零 `<skills>` 块、不挂 `Skill`);
+ *  · `roster` —— 同一组、同一个序,逐条带来处;零技能 ⇒ `[]`(零技能是一句陈述,不是缺席)。
  */
-export declare function mergeUserSkills(scenarioSkills: SkillSpec[] | undefined, userSkills: SkillSpec[] | undefined, logger?: Logger): SkillSpec[] | undefined;
+export interface RunSkills {
+    readonly specs: SkillSpec[] | undefined;
+    readonly roster: RunSkillEntry[];
+}
+/**
+ * Personalization seam + run 名册的**唯一铸点**:调用方自带的技能接在场景的之后,**同名场景赢**(场景 / 中心的技能拥有那个名字 —— 它们是部署的基线措辞,
+ * 不是执法面:权限 / 写门 / hook 都不骑在技能上,调用方要整组卸掉用 `disableSkills`,[ref]);用户内容永不遮住它们。用户表内重名留第一个。
+ * 被丢的名字落审计行(静默丢会让「我的技能没生效」查不出来)。形已由 HTTP 门判过(`validateUserSkills`);本函数只做合并政策与来处。
+ *
+ * 来处(`roster[].source`):场景那一半按**部署装载簿**的来处标(`deploymentSources`:装载腿写下的 `LoadedSkill.source`,名字在装载簿里唯一 ——
+ * 装载器同名即抛、配置源按名覆盖);场景里有、装载簿里没有的技能是嵌入方场景代码自带的 ⇒ `factory`(本部署自带,不是配置源交来的、也不是这次请求带的)。
+ * 请求那一半恒 `request`。`disable` ⇒ 两个投影都空(`specs: []`、`roster: []`)。
+ */
+export declare function buildRunSkills(args: {
+    readonly scenario: SkillSpec[] | undefined;
+    readonly request: readonly SkillSpec[] | undefined;
+    readonly disable: boolean;
+    readonly deploymentSources: ReadonlyMap<string, SkillSource>;
+}, logger?: Logger): RunSkills;
 /** center caps view 的解析结果两键(形状锚定)。`scenario` null = 三层皆未配。 */
 export interface ScenarioRuling {
     scenario: string | null;

package/dist/capabilities/scenarios.js

@@ -262,23 +262,28 @@ const REVIEWER_ROLE_TEXT = "You are a senior code reviewer. Call repo_tree to ma
     "the files in scope, then review them yourself. " +
     "Produce ONE prioritized review: a short summary, then findings grouped by severity " +
     "(blocker / major / minor), each with `path:line`, the problem, and a concrete fix. Cite real code — never invent files or symbols.";
-export function mergeUserSkills(scenarioSkills, userSkills, logger) {
-    if (!userSkills || userSkills.length === 0)
-        return scenarioSkills;
-    const reserved = new Set((scenarioSkills ?? []).map((s) => s.name));
-    const out = [...(scenarioSkills ?? [])];
+export function buildRunSkills(args, logger) {
+    if (args.disable)
+        return { specs: [], roster: [] };
+    const scenario = args.scenario ?? [];
+    const roster = scenario.map((s) => ({ name: s.name, description: s.description, source: args.deploymentSources.get(s.name) ?? "factory" }));
+    if (!args.request || args.request.length === 0)
+        return { specs: args.scenario, roster };
+    const reserved = new Set(scenario.map((s) => s.name));
+    const specs = [...scenario];
     const dropped = [];
-    for (const s of userSkills) {
+    for (const s of args.request) {
         if (reserved.has(s.name)) {
             dropped.push(s.name);
             continue;
         }
         reserved.add(s.name);
-        out.push(s);
+        specs.push(s);
+        roster.push({ name: s.name, description: s.description, source: "request" });
     }
     if (dropped.length > 0)
         logger?.warn("user_skills_dropped", { reason: "name reserved by scenario (or duplicate)", names: dropped });
-    return out;
+    return { specs, roster };
 }
 function registeredScenariosClause(known) {
     return `this deployment's scenarios are: ${known.join(", ")}`;

package/dist/capabilities/skills.d.ts

@@ -1,4 +1,4 @@
-import type { SkillSpec } from "@sema-agent/core";
+import type { SkillSpec, TaskSpec } from "@sema-agent/core";
 import type { RemoteExecProvider } from "../execution-lane-caps.js";
 import { type Logger } from "../observability/logger.js";
 /**
@@ -90,14 +90,37 @@ export declare function loadDeploymentSkills(config: {
 /** 一个技能范围交进 `TaskSpec` 的技能(场景工厂的 `skills`)。范围从哪来见 `scenarios.ts` 的 `BUILTIN_SCENARIO_SKILL_SCOPE`(center 场景 = 它自己的名字)。 */
 export declare function skillsForScenario(loaded: readonly LoadedSkill[], scope: string): SkillSpec[];
 /**
- * [ref] —— 场景卡技能清单的一条(`GET /v1/capabilities/scenarios/:name` 的 `skills[]`):名字 / 描述 / 来处,**不带正文**,也不带技能上的两只工具清单
- * (`allowedTools` / `disallowedTools`)。名字就是提交体 `userInvokedSkills` 点名时用的那个串。
+ * 技能清单的一条 —— **一张形,两个面**:场景卡(`GET /v1/capabilities/scenarios/:name` 的 `skills[]`,[ref])与 run 级名册
+ * (`wiring_manifest.skills[]`)。名字 / 描述 / 来处,**不带正文**,也不带技能上的两只工具清单(`allowedTools` / `disallowedTools`)。
+ * 名字就是提交体 `userInvokedSkills` 点名时用的那个串。两个面只差来处的值域(`S`):场景卡上只有部署两处,run 名册上多一个 `request`。
  */
-export interface ScenarioSkillEntry {
+export interface SkillListEntry<S extends string> {
     readonly name: string;
     readonly description: string;
-    readonly source: SkillSource;
+    readonly source: S;
 }
+/** 场景卡技能清单的一条(来处 = 部署两处)。 */
+export type ScenarioSkillEntry = SkillListEntry<SkillSource>;
+/** run 级技能来处的闭集 = 部署两处({@link SkillSource})∪ 本请求体 `skills`。 */
+export type RunSkillSource = SkillSource | "request";
+/** run 级名册的一条(`wiring_manifest.skills[]`)。铸点唯一:`capabilities/scenarios.ts` 的 `buildRunSkills`。 */
+export type RunSkillEntry = SkillListEntry<RunSkillSource>;
+/**
+ * run 级技能名册在 TaskSpec 上的**显式字段键** —— 与执行车道字段(`hands-lane.ts` 的 `HANDS_LANE_FIELD`,[ref])同一形:symbol 键随
+ * spread / rest 解构走(续跑腿的 `taskConfig` 就是 rest 解构出来的),对上游 core 的键面不可见(JSON / 结构化克隆跳过 symbol 键)。
+ * 铸点唯一 = `boot/resolve-spec.ts` 的 resolveSpec 出口({@link stampRunSkills});读点唯一 = {@link runSkillsOf}(每条投 `wiring_manifest` 的腿)。
+ */
+export declare const RUN_SKILLS_FIELD: unique symbol;
+/**
+ * 铸名册(**单一属主**:只许 resolveSpec 的出口调用)。字段 `enumerable`(复制得走)、`writable:false` + `configurable:false`(同一只 spec 被第二次铸 ⇒
+ * 当场 TypeError,两个写者是漂移的成因)。名册冻结一份拷贝(spec 与腿不共享可变引用)。
+ */
+export declare function stampRunSkills<T extends TaskSpec>(spec: T, roster: readonly RunSkillEntry[]): T;
+/**
+ * 读名册。`undefined` = 这只 spec 不是本仓装配出口产的(嵌入方自写 `resolveSpec` / 测试桩)⇒ 腿上没有关于技能的陈述(段缺席)。
+ * 不是保护型量(缺席只少一段披露,不放宽任何东西)⇒ 缺席照常跑,与车道字段的「缺席即拒」不同。入参收 `object`:续跑腿手里是 rest 解构出来的 taskConfig。
+ */
+export declare function runSkillsOf(spec: object): readonly RunSkillEntry[] | undefined;
 /** 一个技能范围的卡上清单 —— 与 {@link skillsForScenario} 同一只过滤、同一个序,只是投影不同。 */
 export declare function scenarioSkillEntries(loaded: readonly LoadedSkill[], scope: string): ScenarioSkillEntry[];
 /** {@link parseFrontmatter} 的三种读数(闭集):`absent` = 第一行不是围栏,没有 frontmatter(正当的全局技能)· `block` = 围栏收好了的块 · `unclosed` = 第一行是围栏而块没收好(读不了 —— 调用方拒载)。 */

package/dist/capabilities/skills.js

@@ -127,6 +127,14 @@ function skillsInScope(loaded, scope) {
 export function skillsForScenario(loaded, scope) {
     return skillsInScope(loaded, scope).map((k) => k.spec);
 }
+export const RUN_SKILLS_FIELD = Symbol("sema-server.runSkills");
+export function stampRunSkills(spec, roster) {
+    Object.defineProperty(spec, RUN_SKILLS_FIELD, { value: Object.freeze(roster.map((e) => Object.freeze({ ...e }))), enumerable: true, writable: false, configurable: false });
+    return spec;
+}
+export function runSkillsOf(spec) {
+    return spec[RUN_SKILLS_FIELD];
+}
 export function scenarioSkillEntries(loaded, scope) {
     return skillsInScope(loaded, scope).map((k) => ({ name: k.spec.name, description: k.spec.description, source: k.source }));
 }

package/dist/capability-facts.d.ts

@@ -87,6 +87,7 @@ export declare const CAPABILITY_FACT_WHY: {
     readonly not_k8s_lane: "the execution lane is not the k8s pod sandbox (REMOTE_EXEC=k8s)";
     readonly workspace_snapshot_store_absent: "no workspace snapshot store is configured (MINIO_ENDPOINT / MINIO_ACCESS_KEY / MINIO_SECRET_KEY)";
     readonly workspace_cache_off: "the build-cache volume per workspace space is off (WORKSPACE_CACHE=off, the default)";
+    readonly deployment_mod_packages_absent: "no operator-declared mod package was loaded at boot (MODS_ROOT / MODS_PACKAGES)";
 };
 export type CapabilityFactWhy = keyof typeof CAPABILITY_FACT_WHY;
 /** 不可用臂。 */
@@ -355,6 +356,11 @@ export declare function workspaceSpace(c: Pick<ServiceConfig, "remoteExec">): Fa
 export declare function workspaceCache(c: Pick<ServiceConfig, "remoteExec">): Fact<"not_k8s_lane" | "workspace_cache_off", {
     cache: WorkspaceCacheCapability;
 }>;
+/** 运维声明的 mod 包:本进程起服装上了几只(部署座装配口 `assembleDeploymentMods` 的读数;本服务自铸的部署注册不算)。
+ *  `/health.mods.deploymentPackages`(投 `count`)与 caps `modsDeploymentPackages`(投 `.available`,false ⇒ 键缺席)同调这一只。 */
+export declare function deploymentModPackages(d: Pick<Deps, "deploymentModPackages">): Fact<"deployment_mod_packages_absent", {
+    count: number;
+}>;
 /** 自唤醒调度器挂在宿主 env 上:`SCHEDULER_ENABLED` ∧ 单用户 ∧ host 车道。装配(`boot/execution-env.ts`)与能力位同调。 */
 export declare function hostScheduler(c: Pick<ServiceConfig, "schedulerEnabled" | "requirePrincipal" | "remoteExec">): Fact<"scheduler_disabled" | "multi_tenant_deployment" | "not_host_lane">;
 /** 引擎能力词的事实(core `ENGINE_CAPABILITIES` 每词一只谓词,值 = 本进程的事实;`/v1/capabilities` 以顶层布尔键展开它们)—— 住在

package/dist/capability-facts.js

@@ -67,6 +67,7 @@ export const CAPABILITY_FACT_WHY = {
     not_k8s_lane: "the execution lane is not the k8s pod sandbox (REMOTE_EXEC=k8s)",
     workspace_snapshot_store_absent: "no workspace snapshot store is configured (MINIO_ENDPOINT / MINIO_ACCESS_KEY / MINIO_SECRET_KEY)",
     workspace_cache_off: "the build-cache volume per workspace space is off (WORKSPACE_CACHE=off, the default)",
+    deployment_mod_packages_absent: "no operator-declared mod package was loaded at boot (MODS_ROOT / MODS_PACKAGES)",
 };
 const no = (why) => ({ available: false, why });
 const yes = (w) => ({ available: true, ...w });
@@ -391,6 +392,10 @@ export function workspaceCache(c) {
         return no("workspace_cache_off");
     return yes({ cache: { mount: rx.workspaceCache.mount, size: rx.workspaceCache.size } });
 }
+export function deploymentModPackages(d) {
+    const n = d.deploymentModPackages;
+    return n !== undefined && n > 0 ? yes({ count: n }) : no("deployment_mod_packages_absent");
+}
 export function hostScheduler(c) {
     if (c.schedulerEnabled !== true)
         return no("scheduler_disabled");

package/dist/center-credential-renewer.js

@@ -3,7 +3,7 @@ import { closeSync, fchmodSync, fsyncSync, openSync, readdirSync, readFileSync,
 import { basename, dirname, join } from "node:path";
 import { WEB_ADMIN_ENV, WebAdminCredentialEnvelope, parseWebAdminCredentialFile } from "@sema-agent/settings-schema";
 import { ACCESS_TOKEN_TTL_SECONDS, OAuthErrorResponse, TokenGrantResponse } from "@sema-agent/settings-schema/api/auth";
-import { CENTER_PULL_TIMEOUT_MS, centerTokenRefresh } from "./web-admin-client/center-request.js";
+import { CENTER_PULL_TIMEOUT_MS, CenterRedirectRefusedError, centerTokenRefresh } from "./web-admin-client/center-request.js";
 export const CENTER_CREDENTIAL_RENEW_LEAD_KEY = "CENTER_CREDENTIAL_RENEW_LEAD_MS";
 export const CENTER_CREDENTIAL_RENEW_LEAD_DEFAULT_MS = 5 * 60_000;
 export const CENTER_CREDENTIAL_RENEW_LEAD_MIN_MS = CENTER_PULL_TIMEOUT_MS;
@@ -277,6 +277,10 @@ export function createCenterCredentialRenewer(deps) {
             res = await centerTokenRefresh(envelope.issuer, envelope.refreshToken, { timeoutMs: CENTER_PULL_TIMEOUT_MS, ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}) });
         }
         catch (err) {
+            if (err instanceof CenterRedirectRefusedError) {
+                judgeRefusal(usedDigest, "rejected", { status: err.status });
+                return;
+            }
             settleRetrying("center_unavailable", usedDigest, { error: err instanceof Error ? err.name : "fetch error" });
             return;
         }

package/dist/checkpoint-ctx-seal-m28.d.ts

@@ -12,16 +12,9 @@
  * 本条在起服第 6 段 checkpoint 店建成、封签器的装配判(`CHECKPOINT_CTX_SEALING_REQUIRED`)过了之后调一次,早于任何路由装配(与 M10 / M19 / M25
  * 同为在迁移段之外跑的条目)。读数一行 info `checkpoint_ctx_credentials_sealed`,不进 `OneTimeMigrationReport`(登记行 `reportKeys` 空)。
  */
-import { type CheckpointCtxSealer, type SealedCheckpointCtx } from "./http/checkpoint-ctx.js";
+import { type CheckpointCtxSealer } from "./http/checkpoint-ctx.js";
 import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
-import type { CtxRowsRewriteM28 } from "./plugins/checkpoint-store-sql.js";
-/** 两孪生的店腿(`SqlCheckpointStore` / `LocalCheckpointStore` 的 `rewriteCtxRowsM28`)。 */
-export interface CheckpointCtxRowsRewriterM28 {
-    rewriteCtxRowsM28(rewrite: (sessionId: string, ctx: object) => {
-        readonly ctx: SealedCheckpointCtx;
-        readonly values: number;
-    } | undefined): Promise<CtxRowsRewriteM28>;
-}
+import type { CheckpointCtxRowsRewriter } from "./plugins/checkpoint-store-sql.js";
 /** M28 一次起服的读数(起服 info 行逐键打出;测试按它断言)。`window: "closed"` ⇒ 一行都没读(其余全 0)。 */
 export interface CheckpointCtxSealM28Report {
     readonly window: "open" | "closed";
@@ -35,7 +28,7 @@ export interface CheckpointCtxSealM28Report {
  * 跑一次 M28(`today` = UTC 日历日 YYYY-MM-DD;`window` 缺省 = 登记表 M28 那一行 —— 只有测试递别的窗)。窗关 ⇒ 不扫。
  * 店腿的每一行:`sealStoredCheckpointCtxM28` 交回新体(凭据位上的明文封好)⇒ 回写;交回 `undefined`(没有明文)⇒ 不写。
  */
-export declare function sealCheckpointCtxCredentialsM28(store: CheckpointCtxRowsRewriterM28, sealer: CheckpointCtxSealer, opts: {
+export declare function sealCheckpointCtxCredentialsM28(store: CheckpointCtxRowsRewriter, sealer: CheckpointCtxSealer, opts: {
     readonly today: string;
     readonly window?: Pick<OneTimeMigrationWindow, "removableAfter">;
 }): Promise<CheckpointCtxSealM28Report>;

package/dist/checkpoint-ctx-seal-m28.js

@@ -10,7 +10,7 @@ export async function sealCheckpointCtxCredentialsM28(store, sealer, opts) {
     if (!migrationWindowOpen(opts.window ?? m28Window(), opts.today)) {
         return { window: "closed", rowsScanned: 0, rowsSealed: 0, valuesSealed: 0, rowsUnreadable: 0, rowsTooLarge: 0 };
     }
-    const r = await store.rewriteCtxRowsM28((sessionId, ctx) => {
+    const r = await store.rewriteCtxRows((sessionId, ctx) => {
         const out = sealStoredCheckpointCtxM28(ctx, sealer, sessionId);
         return out === undefined ? undefined : { ctx: out.ctx, values: out.valuesSealed };
     });

package/dist/checkpoint-identity.d.ts

@@ -7,15 +7,22 @@ export declare const MAX_CHECKPOINT_ID_CHARS = 128;
 export declare function withoutCheckpointToken(text: string, token: unknown): string;
 /** 持久层读出的 `checkpointId` 过信任边界:是串、非空、不超长、不含 token(大小写不敏感)⇒ 原值;否则 `undefined`。判据全文见本文件头注。 */
 export declare function trustedCheckpointId(raw: unknown, token: unknown): string | undefined;
-/** 带 `checkpointId` 当 join 键的两类 durable 读面(计数 detail 的 `face`)。 */
-export type DurableCheckpointFace = "approvals-queue" | "assistant-inbox";
+/**
+ * 带 `checkpointId` 当 join 键的面(计数 detail 的 `face`):运维队列行、停驻收件行、park 账本行(`GET /v1/runs/:id/events` 的 `suspended` /
+ * `needs_review`,写时判一次),与回决门族的 200 体(`decision-receipt`:`/decide` / `/resume` / `/plan_review` 执行**前**从选中的那一行捕获一次,
+ * 结清证据带它 —— 语义属主 = `gate-settlement.ts`)。四面同一只读法、同一个计数。
+ */
+export type DurableCheckpointFace = "approvals-queue" | "assistant-inbox" | "run-events-park" | "decision-receipt";
+/** 一行的身份片段:读得出可信值 ⇒ `{ checkpointId }`;读不出 ⇒ `{}`(键缺席)。由调用方原样展开进行投影 / 结清证据。 */
+export type GateIdentity = {
+    readonly checkpointId?: string;
+};
 /**
  * durable 读面的一行 → 它的身份片段,**由调用方原样展开进行投影**(`...durableRowIdentity(face, raw, token)`):读得出可信值 ⇒ `{ checkpointId }`;
  * 读不出 ⇒ `{}`(这一行**照列**,键缺席)+ 计一次(见本文件头注「durable 面的 join 键」)。
  * `raw === undefined` = 行上没有这一格(`why=absent`,老行);在场却没过信任边界(非串 / 空串 / 超长 / 含 token / 读不出)= `why=untrusted`。
- * 三处读面(两只店的 `listPending` + 收件 handler)只经这一只 —— 读法、计数、缺席形各只有一份。
+ * 三处读面(两只店的 `listPending` + 收件 handler)、park 账本行的唯一构造器(`trace/project.ts` 的 `parkEventData`)与回决门族三条续跑腿的执行前捕获点
+ * (`http/resume-legs.ts`:`/decide` 在分流之前一次、`/resume`、`/plan_review`)只经这一只 —— 读法、计数、缺席形各只有一份。
  */
-export declare function durableRowIdentity(face: DurableCheckpointFace, raw: unknown, token: unknown): {
-    readonly checkpointId?: string;
-};
+export declare function durableRowIdentity(face: DurableCheckpointFace, raw: unknown, token: unknown): GateIdentity;
 //# sourceMappingURL=checkpoint-identity.d.ts.map