@sema-agent/server 7.43.0 → 7.44.0

package/dist/budget.js

@@ -1,14 +1,6 @@
-/**
- * Cost / budget / trace wiring for the Runner (core 5.x) — pure, testable helpers kept out of the
- * auto-running main.ts:
- *   ③ buildPricing   — Model.cost catalog → injected ModelPricing (authoritative costMicroUsd).
- *   ④ 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 { modelCostToPricing } from "@sema-agent/core";
 import { currentPrincipal } from "./observability/principal-context.js";
-import { promptManifestRecordOf, configAssembledRecordOf } from "./observability/prompt-manifest.js"; // design/158 N18: see re-export block below (moved to ./observability/prompt-manifest.js)
-/** ③ Per-model pricing keyed by model id (core falls back to each Model.cost when a model is absent). */
+import { promptManifestRecordOf, configAssembledRecordOf } from "./observability/prompt-manifest.js";
 export function buildPricing(models) {
     const pricing = {};
     for (const m of Object.values(models))
@@ -16,28 +8,9 @@ export function buildPricing(models) {
             pricing[m.id] = modelCostToPricing(m.cost);
     return pricing;
 }
-/**
- * 缝合审 M3:`capabilities.pricingConfigured` 的判据 —— 提成函数放在 pricing 自己的文件里,因为
- * **这个表是热变的**(`boot/config-center.ts` 的 `mutateInPlace(pricing, buildPricing(config.models))`,
- * 那行注释自己写着 `hot: cost/model changes`)。旧码在 `main.ts` 的 capabilities 字面量里把它算成一个
- * **boot 时的布尔快照**,于是运维在 config center 里加上/撤掉价目表之后,`/v1/capabilities` 还报旧值 ——
- * 而这个键的**全部用途**就是给消费端消歧「costMicroUsd=0 是免费跑,还是根本没配价目表」,报错了就是
- * 把消歧信号变成误导信号。main.ts 侧改用 getter(读时求值)。
- *
- * 同一条论证在同一个字面量里**已经执行过一次**:紧邻的 `restartState: () => configCenter.restartState()`
- * 带着注释「A live getter (not a snapshot) so /health always reads current」—— 兄弟键漏了。本仓第 7 例同形。
- */
 export function isPricingConfigured(pricing) {
     return Object.values(pricing).some((p) => Object.values(p).some((v) => typeof v === "number" && v > 0));
 }
-/**
- * Bound the cardinality of a free-form metric label value (BL-11/BL-21). A label fed by untrusted/unbounded
- * input — MCP tool names (a misconfigured/malicious server can emit thousands of dynamic names) or center
- * model ids (a malformed roster) — would otherwise mint an unbounded number of metric series: a slow memory
- * leak in the registry + a /metrics scrape blow-up. We track the DISTINCT values seen; once the cap is hit,
- * further NEW values collapse into one `__other__` bucket (already-seen values still report exactly). The
- * cap is made observable (no silent truncation) via `onOverflow`, fired once when the cap is first crossed.
- */
 export function cardinalityGuard(cap, onOverflow) {
     const seen = new Set();
     let overflowed = false;
@@ -55,27 +28,11 @@ export function cardinalityGuard(cap, onOverflow) {
         return value;
     };
 }
-/**
- * E8 (shell-host contract): per-task × per-model usage accumulator, fed (synchronously) by the `brain.call`
- * tracer. The `TracerHook` contract is SYNC / no-IO, so we cannot persist from the hook; instead we accumulate
- * here in memory and the run lifecycle DRAINS us at each turn boundary, appending the delta to the durable run
- * event log. The **append-only delta** model is what makes it resume-safe: a task that suspends and resumes in a
- * different process appends only its own post-resume deltas; the result echo SUMS all `model_usage` events across
- * the whole (possibly multi-process) run. Memory is bounded — a task's entry is dropped on {@link drain}/{@link clear}.
- */
 export class ModelUsageTracker {
     byTask = new Map();
     active = new Set();
-    /** Mark a TOP-LEVEL run active so its `brain.call` usage is tracked. **Required** — `record` ignores any taskId
-     *  that isn't registered. This is the leak fence: delegated SUB-TASKS (team members,
-     *  adversarial verifiers) run on throwaway core-minted sessionIds that the run lifecycle never registers/drains,
-     *  so without this gate their usage would accumulate under ids nothing ever clears → an unbounded process-lifetime
-     *  leak. Sub-task spend is intentionally NOT in the per-run `modelUsage` echo (it lands in `TaskStats.nested`);
-     *  `modelUsage` is the TOP-LEVEL run's own per-model usage. Call at run start; {@link clear} unregisters. */
     register(taskId) { if (taskId)
         this.active.add(taskId); }
-    /** Accumulate one `brain.call`'s usage — ONLY for a registered top-level run (else a no-op; see {@link register}).
-     *  Sync, never throws (TracerHook contract). */
     record(taskId, model, d) {
         if (!taskId || !model || !this.active.has(taskId))
             return;
@@ -90,22 +47,16 @@ export class ModelUsageTracker {
             cur.outputTokens += d.outputTokens;
             cur.cacheReadTokens += d.cacheReadTokens;
             cur.cacheWriteTokens += d.cacheWriteTokens;
-            // 🔴 RB-368 未知传染:已知 + 未知 = **未知**(和里含一个不知道的项,这个和就不知道)⇒ 删键,不折 0。
-            // 顺序无关(先未知后已知同样保持未知),因为 `cur.costMicroUsd` 已是 undefined 时 `+` 也不成立。
             if (d.costMicroUsd === undefined || cur.costMicroUsd === undefined)
                 delete cur.costMicroUsd;
             else
                 cur.costMicroUsd += d.costMicroUsd;
         }
         else {
-            // 显式重建而非 `{...d}`:调用方可能传 `{costMicroUsd: undefined}`(显式 undefined 键),
-            // 那样 `Object.hasOwn` 为真、JSON.stringify 又把它抹掉 ⇒ 「缺席」在内存与落库两处形状不一致。
             const { costMicroUsd, ...tokens } = d;
             perModel.set(model, { ...tokens, ...(costMicroUsd !== undefined ? { costMicroUsd } : {}) });
         }
     }
-    /** Return the usage accumulated for this task SINCE the last drain (per neutral model id), and RESET it.
-     *  `undefined` when nothing accrued — callers skip the durable append then. */
     drain(taskId) {
         const perModel = this.byTask.get(taskId);
         if (!perModel || perModel.size === 0)
@@ -116,251 +67,70 @@ export class ModelUsageTracker {
         this.byTask.delete(taskId);
         return out;
     }
-    /** Drop a task's pending accumulation AND unregister it (cleanup at run end / on an abandoned/errored leg). After
-     *  this, further `record(taskId,…)` no-ops until a fresh {@link register}. `drain` deliberately does NOT unregister
-     *  (the run continues across turns); only `clear` ends the run's tracking. */
     clear(taskId) { this.byTask.delete(taskId); this.active.delete(taskId); }
 }
-// design/158 N18: PromptManifestRecord / promptManifestRecordOf / configAssembledRecordOf / PromptManifestTracker
-// moved VERBATIM to ./observability/prompt-manifest.js (budget.ts's name says cost/budget; this face is
-// wire-observability projection of prompt.assembled/config.assembled, unrelated). Re-exported here so existing
-// importers (main.ts, runs.ts, http/server.ts, trace/project.ts, tests) keep working untouched — createTracer
-// below still consumes promptManifestRecordOf/configAssembledRecordOf/PromptManifestTracker.
 export { promptManifestRecordOf, configAssembledRecordOf, PromptManifestTracker, } from "./observability/prompt-manifest.js";
-/**
- * ④ Bridge core's fire-and-forget trace events to /metrics (+ the E8 per-task model-usage accumulator). The hook
- * is void / never throws / does no sync IO (in-memory counters only), per the TracerHook contract. `brain.call`
- * fires for EVERY call (top-level + async + council sub-tasks) → `model_cost_micro_usd_total` is the authoritative
- * spend, and (when a {@link ModelUsageTracker} is supplied) the per-task `modelUsage` echo's source.
- */
 export function createTracer(metrics, costQuota, modelUsage, fleetUsage, fleetLease, quotaWeightFor, promptManifests) {
-    // Per-process cardinality guards for the two unbounded-input labels (BL-11/BL-21). 256 is generous for any
-    // real tool/model catalog; overflow bumps a counter so an over-cap deploy is observable, not silent.
     const toolName = cardinalityGuard(256, () => metrics.inc("metric_label_overflow_total", { label: "tool_name" }));
     const modelId = cardinalityGuard(256, () => metrics.inc("metric_label_overflow_total", { label: "model" }));
-    // provider flows from env/registry config (not a bounded enum) — guard it like modelId (1.127.0):
-    // a misconfigured registry entry must not explode Prometheus label cardinality. 64 is generous for real providers.
     const providerName = cardinalityGuard(64, () => metrics.inc("metric_label_overflow_total", { label: "provider" }));
     return (e) => {
         if (e.kind === "brain.call") {
-            // S18 (SILENT-FALLBACK P1): count every call by provider+model. provider is optional on the trace event —
-            // "unknown" = the routing layer fell through without a recognized provider (previously unobservable).
             metrics.inc("brain_calls_total", { provider: providerName(e.provider ?? "unknown"), model: modelId(e.model) });
             if (e.costMicroUsd) {
                 metrics.inc("model_cost_micro_usd_total", { model: modelId(e.model) }, e.costMicroUsd);
-                // ⑤b attribute spend to the originating principal (ALS) — reaches council/team sub-tasks too.
                 const principal = currentPrincipal();
                 if (principal)
                     costQuota?.add(principal, e.costMicroUsd);
             }
             else if (e.costMicroUsd === undefined) {
-                // D5:cost 整键缺席 = 未知(RB-368)——计数供 /metrics/summary 的 costUnknown/unpricedCalls
-                // 信号(costUsd 在 unpriced 部署恒 0,没有这个信号消费端会读成「零花费」)。显式 0 =
-                // declared free,走上面 truthy 为假的静默臂,不计入 unpriced。
                 metrics.inc("brain_calls_unpriced_total", { model: modelId(e.model) });
             }
-            // ┌─ #59 裁定 / RB-368 结案([2052]① cli 报案 → [2073] 立案 → [2076] 工单挂 core → [2083] 到货) ─┐
-            // 病灶报案:下面三处曾是 `e.costMicroUsd ?? 0`(账本 + fleetUsage + fleetLease),把「成本未知」记成
-            // 「免费」,与 `pricingConfigured=false` 的部署组合 ⇒ 全部账目假 0。
-            //
-            // **第一轮裁定(core ≤2.2.0,已被上游修复取代,留档见证判断链)**:亲读上游后纠偏——core 当时在
-            // brain.call 帧上**恒发数字、从不缺席**(`costMicroUsd: turnCostMicroUsd` 是无条件键;无价目表时
-            // `modelCostToPricing(undefined)` 产出全零单价 ⇒ 如实算出 0)。歧义**产生在 core**,server 收到的
-            // 信息里根本不含这个区分 ⇒ 当时改透传治不了根(缺席永不到达),`?? 0` 定性为**类型面守卫**。
-            // 结论是把根因工单挂回 core,而不是在本层做样子。
-            //
-            // 🔴 **第二轮 = 现行(core ≥2.3.0,RB-368 到货)**:core 已在源头消歧——unpriced 部署下
-            // brain.call(`runtask.js:831`)/ task.end(`:2851`)/ `stats.costMicroUsd`+`costBreakdown`
-            // (`assemble-result.js:39,144`)**整键缺席**;显式全零 `cost` = 声明免费 ⇒ 照发 0。于是三处
-            // `?? 0` 全部改为**条件展开透传**:键在 ⇒ 原样传(含真 0);键不在 ⇒ 三路都不带该键。
-            // 事实钉在 test/budget.test.ts(真 Runner 跑一趟取证),floor 已钉 ^2.3.0——装回旧 core 这三条
-            // 透传臂会变成永不到达的死枝而全量照绿,那正是 floor 门存在的理由。
-            //
-            // 三问(第二轮):
-            //  · 谁需要 —— 消费端要区分真零/未知(cli 在 CC 对照里正是靠「诚实缺席不编造」赢的那一点;
-            //    cli #68 的两信号分渲 = 部署级 pricingConfigured + 行级缺席,行级这一半由本改动供给)。
-            //  · 谁受伤 —— (a) 聚合面遇缺席:usage-analytics 与 aggregateModelUsage 此前把 DB JSON 当全必填做裸
-            //    算术,一行缺键就 NaN/字符串毒掉整窗(#59 同批已修,红先复现在
-            //    test/usage-analytics.test.ts + test/model-usage.test.ts);(b) 历史行:已按 0 记账的行无法回溯
-            //    区分,只能靠部署位读回——**本改动不回溯**,分界线 = 升到 core 2.3.0 那一刻。
-            //  · 补偿 —— 第一级 = `capabilities.pricingConfigured`(main.ts,已在):false ⇒ 消费端把任何 0
-            //    渲染成「未知」而非「免费」;第二级 = 行级缺席(本改动),沿账本→durable `model_usage`→
-            //    `aggregateModelUsage`→`TaskStats.modelUsage` 回声→usage-analytics 的 `estimated` 标记,一路
-            //    保持缺席(聚合面的**未知传染**语义见 trace/project.ts)。
-            //  · fleet 批报腿(下面 fleetUsage)自 registry-core 0.11.0/[2103] 起**同样接住了**:wire 有
-            //    缺席位(UsageEntry.costMicroUsd optional),accumulator cell 级传染透传缺席,center 聚合面
-            //    「下界 + costUnknown」——两层语义与本处的关系见 fleet-client.ts 的旁注(3.7.0 前这里曾写
-            //    「wire 表达不了缺席、center 只见低估」,已被该车推翻;doc-rot 修 2026-07-30)。
-            // └──────────────────────────────────────────────────────────────────────────────────────────────┘
-            // [2153]③ 侦察钉(core 2.6.0):`brain.call` 帧新增可选 `turn?: number`(trace.d.ts 确认;此前只有
-            // `turn.end`/`repetition.detected`/`task.degraded` 三帧带 turn)。**刻意不接**——`modelUsage.record`
-            // 喂的是 E8 durable `model_usage` echo,累加键=`taskId → model`(见 `ModelUsageTracker.byTask`,
-            // 上方 class 定义),drain 边界=**per-turn**(run lifecycle 在每个 turn 边界 drain 一次、append 一条
-            // durable 事件行)。也就是说 turn 粒度已经由「何时 drain」这个外层动作表达,一次 drain 窗口内本就
-            // 只可能有一个 turn 的 delta——帧上逐行再带一份 `turn` 是重复信息,对已经 per-turn 聚合的行没有
-            // 增量语义(不是「丢了信息」,是「信息已经在结构里」)。将来若变盘:若聚合粒度改粗(比如攒够 N
-            // turn 才 drain 一次,单行 delta 跨多个 turn),或 usage-analytics 想要「同一 drain 窗口内哪个 turn
-            // 花了多少」的细分,才值得把 `e.turn` 塞进 `ModelUsageDelta`(那时 byTask 需要再加一层 turn 键)。
-            // E8 (shell-host): per-task × per-model usage for the `TaskStats.modelUsage` echo. `record` is a NO-OP unless
-            // e.taskId is a REGISTERED top-level run (the leak fence — sub-task/throwaway taskIds are never registered, so
-            // they neither leak nor enter the echo; their spend is in TaskStats.nested). Drained at turn boundaries into the
-            // durable log (resume-safe); the registered entry is dropped at run end (clear). NOT cardinality-guarded by
-            // model: bounded by a run's model set, and by the active-run set.
-            // core 3.0.0([2296] S1):this lane's `inputTokens` stays `e.promptTokens` — DELIBERATELY zero-changed.
-            // The E8 ledger's semantics are COMPONENT-wise (MISS + cacheRead/cacheWrite listed separately;
-            // usage-analytics' read side SUMS them back into a total), unlike the weightedTokens/fleetUsage lane just
-            // below (which wants the pre-summed normalized total and migrates to `e.totalInputTokens`). Pre-3.0.0 the
-            // gateway family's `promptTokens` already included cache, so this same read-side sum double-counted for
-            // that family — an existing accounting gap in historical rows that this version does not retroactively fix
-            // (declared, not silently carried forward): see CHANGELOG's "存量口径断层" note.
-            modelUsage?.record(e.taskId, e.model, { inputTokens: e.promptTokens, outputTokens: e.completionTokens, cacheReadTokens: e.cacheRead, cacheWriteTokens: e.cacheWrite, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}) }); // RB-368 透传缺席
-            // weight-at-burn:加权 tokens = (prompt+completion)×模型配额倍率,在记账点固化(此后改倍率
-            // 不回算历史,registry ModelEntry.quotaWeight 同句契约)。weight 源=config.modelQuotaWeights(registry
-            // hot-apply;env lane 空表 ⇒ 1 兜底);非法回调值防御性归 1(tracer 契约 never-throws,不让坏表毒记账)。
-            // core 3.0.0([2296] S1):`e.promptTokens` → `e.totalInputTokens`. This axis's contract (line ~365 below)
-            // has always been "normalized total input INCLUDING cache" — pre-3.0.0 that's what `promptTokens` meant for
-            // the gateway family; 3.0.0 flips `promptTokens` to mean cache-MISS-only, so staying on it here would
-            // massively under-count the quota/lease axis for any cache-heavy load (a lease could be walked through by
-            // cache-heavy traffic — the exact same failure class as the side-query R4 finding below).
+            modelUsage?.record(e.taskId, e.model, { inputTokens: e.promptTokens, outputTokens: e.completionTokens, cacheReadTokens: e.cacheRead, cacheWriteTokens: e.cacheWrite, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}) });
             const qwRaw = quotaWeightFor?.(e.model);
             const qw = typeof qwRaw === "number" && Number.isFinite(qwRaw) && qwRaw > 0 ? qwRaw : 1;
             const weightedTokens = Math.round((e.totalInputTokens + e.completionTokens) * qw);
-            // P2 用量批报:principal×model 窗口累计(同 ⑤b 的 ALS 归因点 — 子任务花费也归到发起 principal),
-            // fleet-client 每窗口 drain→POST /api/fleet/usage。未配 fleet(accumulator 缺席)= 零行为。
-            // core 3.0.0:同上迁移理由,inputTokens=归一化总输入含 cache(totalInputTokens),与 weightedTokens 同轴。
-            fleetUsage?.record(currentPrincipal(), e.model, e.taskId, { inputTokens: e.totalInputTokens, outputTokens: e.completionTokens, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}), weightedTokens, quotaWeightAtUse: qw }); // RB-368 透传缺席
-            // lease 消费(D4 AP):同一 ALS 归因点做 lease 本地扣减 —— 只对当前持 lease 的 principal
-            // 生效(FleetLeaseManager 内部判),sync + never throws。双轴=weightedTokens(配额轴)+costMicroUsd($ 轴)。
-            fleetLease?.recordSpend(currentPrincipal(), { weightedTokens, ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}) }); // RB-368 透传缺席
+            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);
         }
         else if (e.kind === "tool.call") {
-            // [2153]③ 侦察钉(core 2.6.0):`tool.call` 帧新增可选 `toolCallId?: string` / `turn?: number`(trace.d.ts
-            // 确认)。**刻意不接进 `tool_calls_total` 的标签**:`toolCallId` 逐调用唯一 → 直接当标签会让这个
-            // 计数器的基数=调用总数(等于没聚合),是本文件 `cardinalityGuard` 存在的理由要防的那类爆炸,
-            // 连 guard 都救不了(不是「用户输入无界」那类可折叠 __other__ 的情形,是键本身设计上就唯一)。
-            // `turn` 本身是低基数(有界于单任务的 turn 数),但作为**跨任务**的 Prometheus 标签会随长任务/
-            // 多任务叠加成事实上无界的序列(同 model/tool_name 已用 guard 的理由,turn 目前没有等价上限)——
-            // 且当前没有「按 turn 分桶看 tool 调用量」的仪表盘/告警消费者在等这个切面,先不加标签。这两个键
-            // 已经在别的通道有名分:`toolCallId` 走 wire 的 `tool_start`/`tool_end` TaskEvent(trace/project.ts
-            // toolStartEventData/toolEndEventData,逐调用可关联、不进 metrics 基数);`turn` 走 `turn.end`/
-            // `task.end.turns`。本臂（createTracer→/metrics）只做计数,不是这两键的合适去处。将来若要接:
-            // (a) 出现「per-turn tool 调用密度」的真实消费者(如异常 turn 侦测),`turn` 分桶价值才成立——
-            //     用有界桶(如 `turn <= 20 ? String(turn) : "20+"`)而非原始整数,避免上面同款无界问题;
-            // (b) `toolCallId` 除非改造成非标签的关联字段(如结构化日志行,不是 Prometheus label),否则永远
-            //     不该进这个计数器。
             metrics.inc("tool_calls_total", { name: toolName(e.name), ok: String(e.ok) });
         }
         else if (e.kind === "task.degraded") {
-            // 1.40: a task was switched to a cheaper model (near-budget / rate_limit / breaker-open). Quality
-            // dropped → alert-worthy operational signal, by reason.
             metrics.inc("degraded_total", { reason: e.reason });
         }
         else if (e.kind === "prompt.assembled") {
-            // core 1.243(提示词主权批): who owned the constitution layer, per task. The
-            // steady state for EVERY service scenario is "core" (structural constitution — our providers all
-            // return role bases only). Anything else is worth eyes: "provider-assembled" = a pre-1.243-shaped
-            // provider tripped the migration guard (upgrade it); "replaced" = an explicit replaceAll opt-out
-            // (none exist in this repo today); "legacy" = a deprecated free-form `system` provider. Alert on
-            // `prompt_constitution_total{mode!="core"} > 0` — the "TOC lost its safety blocks and called it a
-            // config issue" failure class becomes a one-glance dashboard check.
             metrics.inc("prompt_constitution_total", { mode: e.constitution });
-            // [998]② durable half: record the whitelisted manifest for the run lifecycle to drain into a
-            // `prompt_assembled` event (turns/stream). register-gated (top-level runs only), sync, never persists here.
             promptManifests?.record(e.taskId, promptManifestRecordOf(e));
         }
         else if (e.kind === "config.assembled") {
-            // [1301]③:config catalog 观测半场——生效配置逐字段来源(default/spec/derived/host-declared+
-            // overrideReasons)随任务进 durable 事件日志(config_assembled),「谁设的 80」读帧不考古。
             const rec = configAssembledRecordOf(e);
             if (rec)
                 promptManifests?.recordConfig(e.taskId, rec);
         }
         else if (e.kind === "compaction.phase_timings") {
-            // codex F6: core 1.289's `compaction.phase_timings` fires on SUCCESS (per-phase timing telemetry) — it is
-            // NOT an outcome, so counting it into compaction_events_total would add a fake "phase_timings" failure
-            // outcome for every successful compaction (poisoning the "non-success outcomes" dashboard semantics
-            // documented below). Record the total duration on the existing observe face instead (the
-            // brain_call_latency_ms precedent); non-finite values are dropped (tracer never throws, never poisons).
-            // 三路复审修5 核查(workflow W5 报「histogram never」):duration 观测出口就在下一行(F6 起已在),
-            // event 契约(core trace.d.ts)带 `durationMs: number`,budget.test.ts 咬合断言 observe 只进
-            // compaction_duration_ms 不进失败计数器 —— W5 判 STALE,零改。per-phase 明细走 compacted 事件的
-            // phaseDurations(trace/project.ts compactedEventData)上 wire,不在 /metrics 重复开面(有界纪律)。
             const d = e.durationMs;
             if (typeof d === "number" && Number.isFinite(d))
                 metrics.observe("compaction_duration_ms", d);
         }
         else if (e.kind.startsWith("compaction.")) {
-            // core 1.257(压缩健康面): every NON-SUCCESS compaction outcome
-            // now emits a `compaction.*` trace frame (failed / mooted / blocked / noop / disabled / suppressed +
-            // the input_truncated disclosure and announce_dropped). Before these frames the only evidence of a
-            // failing compactor was `onError(phase:"compaction")` log lines — no aggregate, so "3 silent auto
-            // failures opened the breaker and manual verbs drain mooted" (the exact failure fingerprint)
-            // was invisible on a dashboard. Count by outcome+trigger: `compaction_events_total{outcome="failed"}`
-            // rising = the summarizer is failing; sustained `mooted`/`blocked` explains "202 → no compacted
-            // event" without log spelunking. Labels are bounded: 8 kinds × 3 triggers (frames without a trigger
-            // — noop/disabled/mooted/input_truncated/announce_dropped — label "none"). SUCCESS is deliberately
-            // not counted here: `compacted` is a TaskEvent riding the run stream, not a trace frame.
             metrics.inc("compaction_events_total", { outcome: e.kind.slice("compaction.".length), trigger: e.trigger ?? "none" });
         }
         else if (e.kind === "permission.persisted_rule_allowed" || e.kind === "permission.rule_store_unreadable") {
-            // 🔴 [3372] core 5.23.0 提货批,codex 复审 round2 [medium](验真后修)。首版把这两帧登记成
-            // 「丢弃,已有等价信号」——**那条理由是假的**(亲验:`plugins/permission-rule-store-sql.ts` 里既没有
-            // `noteStoreError` 也没有 `onCorruptRead`),而它们又是**真可达**的(#154 车二把规则店接上了)。
-            // 一条假理由比没有理由更坏:台账的全部价值就在于它写的话是真的。
-            //
-            // 两帧各自答一个**别处答不出来**的问题,而且都在安全轴上:
-            //  · `persisted_rule_allowed` —— design/179 明写它是 allow 侧的**归因通道**:「这次为什么没问我?」
-            //    `permission_denied_total` 的补集答不了(它连「有没有走规则」都不知道),`tool_trace` 是默认关
-            //    的诊断旋钮、也不带规则归因。持久规则店是本装配里**唯一的放宽缝**,它每放行一次都该有账。
-            //  · `rule_store_unreadable` —— 规则店读不出 ⇒ 该次调用按**零规则**裁决(诚实地问,而不是假装空店)。
-            //    后果是一场**审批风暴**:运维看到的是「卡突然变多」,而病因在店上。没有这个计数就只能靠猜。
-            // 标签有界:`event` 二取一(闭集,由上面的 `===` 判别式本身封闭)。规则原文/店的错误句**不进标签**
-            // (前者是用户数据、后者无界)——它们该去结构化日志,不是 Prometheus 基数。
             metrics.inc("permission_rule_events_total", { event: e.kind.slice("permission.".length) });
         }
-        // ── 未命中 = 该帧不进 /metrics ────────────────────────────────────────────────────────────────
-        // 这条 if/else 链没有 else:没命中的 `TraceEvent` 就地丢弃。对多数 kind 这是对的(计量面不该给每个
-        // 诊断帧开计数器),但「丢」必须是**裁定**而不是漏接。[3372](core 5.23.0 一次给安全轴加了三个
-        // `permission.*` 帧)之后,该族的逐条处置记在 `trace/core-keyset-guard.ts` 的 ⑦ 面并由 tsc 守着:
-        // core 再加一个 `permission.*` 帧,那里编译期先红,逼人裁「接还是不接」。其余族(compaction/brain/
-        // task/…)仍按本链的显式分支处置,无门。
     };
 }
-/**
- * [1469] side-query 记账 seam(codex R3 high:sideQuery 不走 core tracer——brain.stream 直调不发
- * brain.call——createTracer 的四路 sink(costQuota/model_cost 指标/fleetUsage 批报/fleetLease 本地扣减)
- * 全部旁路)。本 seam 与 createTracer 的 brain.call 臂**同语义**喂同一组 sink:weightedTokens 同式
- * (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 标签/
- * weight 键用**路由身份 r.model**(池配置有界)非 servedModel(provider 上报,无界)。
- */
-export function createSideQueryAccountant(metrics, costQuota, 
-// 依赖面收窄到真消费的方法(§X 同 ModelKeyRef 一式):全形对象照传(结构超集),测试桩零铸型。
-fleetUsage, fleetLease, quotaWeightFor) {
+export function createSideQueryAccountant(metrics, costQuota, fleetUsage, fleetLease, quotaWeightFor) {
     return (principal, r) => {
         const input = typeof r.usage?.input === "number" ? r.usage.input : 0;
         const output = typeof r.usage?.output === "number" ? r.usage.output : 0;
         const cacheRead = typeof r.usage?.cacheRead === "number" ? r.usage.cacheRead : 0;
         const cacheWrite = typeof r.usage?.cacheWrite === "number" ? r.usage.cacheWrite : 0;
-        // #257(codex #256-R3 high 定谳):core 在 side-query 出口已把 `usage.input` **归一为 uncached 量**
-        // ——对每个 provider 族(side-query.d.ts:「`input` NORMALIZED to the uncached prompt quantity …
-        // for EVERY provider family」,与 run loop 的 usage-accounting 同一道门)。所以配额轴折算恒为
-        // input + cacheRead + cacheWrite,**不再按 cache family 分臂**:曾经的
-        // `family === "input-includes-cached" ? input : …` 分支建立在「OpenAI 族 input 仍含 cache」这个
-        // 已被 core 出口归一推翻的前提上,每次 cache 命中都把 OpenAI 族配额/lease 少收 cacheRead+cacheWrite
-        // (红先钉 = budget.test「#257 OpenAI 族 cache 命中不许少计」格)。family 判定链
-        // (cacheFamilyOfMirror + catalog 快照)随本修整体退役——LEDGER 的 cacheFamilyOf/CacheFamily
-        // 两行同步改 skip(消费点消失,理由=core 出口归一)。
         const promptTokens = input + cacheRead + cacheWrite;
-        // RB-368/#59 同判据(createTracer 上方注释同款纪律):`usage.cost.total` 整键缺席 = 未知(unpriced 部署的
-        // side query 真形),不是「花了 $0」——折 0 就是把「不知道」编造成「免费」。已知(哪怕显式 0)才带键。
         const costTotal = typeof r.usage?.cost?.total === "number" ? r.usage.cost.total : undefined;
         const micro = costTotal !== undefined ? Math.round(costTotal * 1_000_000) : undefined;
         if (micro !== undefined && micro > 0) {
@@ -372,20 +142,15 @@ fleetUsage, fleetLease, quotaWeightFor) {
         const qw = typeof qwRaw === "number" && Number.isFinite(qwRaw) && qwRaw > 0 ? qwRaw : 1;
         const weightedTokens = Math.round((promptTokens + output) * qw);
         if (weightedTokens > 0 || (micro !== undefined && micro > 0)) {
-            fleetUsage?.record(principal, r.model, "", { inputTokens: promptTokens, outputTokens: output, ...(micro !== undefined ? { costMicroUsd: micro } : {}), weightedTokens, quotaWeightAtUse: qw }); // taskId ""(无 run 语义;accumulator 对 "" 不计 runsSeen);inputTokens=归一化总输入含 cache(fleet-bus 同口径);RB-368 透传缺席
-            fleetLease?.recordSpend(principal, { weightedTokens, ...(micro !== undefined ? { costMicroUsd: micro } : {}) }); // RB-368 透传缺席
+            fleetUsage?.record(principal, r.model, "", { inputTokens: promptTokens, outputTokens: output, ...(micro !== undefined ? { costMicroUsd: micro } : {}), weightedTokens, quotaWeightAtUse: qw });
+            fleetLease?.recordSpend(principal, { weightedTokens, ...(micro !== undefined ? { costMicroUsd: micro } : {}) });
         }
     };
 }
-/**
- * ⑤ 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 /
- * non-numeric request is ignored (falls back to the ceiling). Returns undefined = "no budget gate".
- */
 export function cappedCeiling(requested, ceiling) {
     const req = typeof requested === "number" && requested > 0 ? requested : undefined;
     if (!ceiling || ceiling <= 0)
-        return req; // no operator ceiling → honor caller (or none)
-    return req === undefined ? ceiling : Math.min(req, ceiling); // cap caller down to the ceiling
+        return req;
+    return req === undefined ? ceiling : Math.min(req, ceiling);
 }
 //# sourceMappingURL=budget.js.map

package/dist/capabilities/builtin-tools.js

@@ -1,7 +1,4 @@
 import { Type } from "typebox";
-/** Current time — the model has no clock; OA/most tasks need it. No side effects. CC-parity tool name `Now`
- *  (PascalCase, core 1.176 first-party rename wrap-up — the SERVICE owns this one; `nowTool` is not a core tool).
- *  effect:"read" so it never suspends → no durable-resume rename strand (no pending-tool checkpoint to canonicalize). */
 export function nowTool() {
     return {
         name: "Now",

package/dist/capabilities/center-plugins.js

@@ -1,41 +1,16 @@
-/**
- * plugins 域 worker 消费半场(契约冻结 board [1361]②/[1362] 四收紧/[1366]①;2026-07-28 开工车)。
- *
- * center 只存"插件从哪来"(PluginSpec 引用,永不承载可执行字节);worker 半场 = 把引用物化成本地
- * 目录并把其中的 **skills** 装进 baseline(v1 装载面;commands 由 cli 壳消费——board [1363] 即 cli
- * 答的命令契约稿,worker 侧本无命令面,这是分工不是降级)。挂 applyCenterSkills 同 reconcile 周期
- * (boot 期,buildScenarios 之前)。
- *
- * 契约条款落点(与 test/center-plugins.test.ts 逐条对应):
- *  - https-only + `PLUGINS_ALLOW_HOSTS`(缺省 github.com):{@link validatePluginDecl}。registry-core
- *    0.10.23 已在 schema 层单真源拒非 https,worker 侧**仍复验**——纵深:wire 可能来自旧 center。
- *  - sha 全 40hex + checkout 强制:{@link gitClonePlan}(有 sha = init+fetch-by-sha+checkout,不信
- *    分支名也不拉全史;无 sha = `--depth 1` HEAD)。
- *  - clone 姿势隔离:GIT_CONFIG_GLOBAL/SYSTEM=/dev/null + GIT_TERMINAL_PROMPT=0(无凭据仓 fail 而非
- *    挂交互 prompt)。私仓凭据走各机自己的 credential helper,永不入声明。
- *  - manifest 路径逃逸(../ /绝对路径/symlink 出根)= 整条拒装:{@link resolvePluginSkillsRoot}
- *    (realpath 后前缀判定)。
- *  - 撞名让位(收紧④):plugin 的 skill 与 baseline(builtin/center 直发)同名 ⇒ **plugin 让位**
- *    (跳过+letGo 留痕)。⚠️ 方向与 applyCenterSkills 的 center-wins 相反——center 直发 skills 过了
- *    publisher RBAC+发布审批,plugin 内容只是 git 仓字节,信任级不同,让位方向因此相反。
- *  - fail-loud 单条不连坐 + LKG(上次成功物化留盘,拉取失败沿用):{@link applyCenterPlugins}。
- */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { promises as fsp, realpathSync, existsSync, readFileSync, lstatSync, statSync } from "node:fs";
 import { join, resolve, isAbsolute, sep } from "node:path";
 import { assertConfined, loadSkills } from "./skills.js";
 const execFileP = promisify(execFile);
-/** 缺省 clone host 白名单(契约条款 1;国内镜像走本名单加 https 镜像域,不开 http 口)。 */
 export const DEFAULT_PLUGIN_ALLOW_HOSTS = ["github.com"];
-/** 条款 1/2/4:https-only、host 全等白名单、sha 40hex。纯函数,worker 侧纵深复验(不信任 wire 已验过)。 */
 export function validatePluginDecl(decl, allowHosts) {
     const name = typeof decl.name === "string" && decl.name !== "" ? decl.name : "(unnamed)";
     if (decl.enabled === false)
         return { ok: false, skip: true, name, reason: "enabled:false" };
     const kind = decl.source?.kind;
     if (kind === "marketplace") {
-        // v1 暂缓:marketplace 物化(add-by-url + install-by-name)是 v2 面;skip 不连坐,warn 留痕。
         return { ok: false, skip: true, name, reason: "marketplace source: not materialized in v1 (skills lane ships git-form first)" };
     }
     if (kind !== "git")
@@ -51,7 +26,6 @@ export function validatePluginDecl(decl, allowHosts) {
     catch {
         return { ok: false, name, reason: "https url does not parse" };
     }
-    // host 全等匹配——evil-github.com / github.com.evil.io 都不隐含放行。
     if (!allowHosts.some((h) => h.toLowerCase() === host)) {
         return { ok: false, name, reason: `host ${host} not in PLUGINS_ALLOW_HOSTS (default github.com; extend with a comma-separated https mirror domain list)` };
     }
@@ -63,17 +37,15 @@ export function validatePluginDecl(decl, allowHosts) {
     }
     return { ok: true, name, url };
 }
-/** 条款 3/5:clone 计划(argv 序列 + 隔离 env)。纯数据,让"姿势"可被钉死。 */
 export function gitClonePlan(o) {
     const env = {
-        GIT_CONFIG_GLOBAL: "/dev/null", // 收紧③:宿主 git 配置(insteadOf/credential/hooks)一概不继承
+        GIT_CONFIG_GLOBAL: "/dev/null",
         GIT_CONFIG_SYSTEM: "/dev/null",
-        GIT_TERMINAL_PROMPT: "0", // 无凭据仓 ⇒ fail-loud,绝不挂在交互 prompt 上
+        GIT_TERMINAL_PROMPT: "0",
     };
     if (o.sha === undefined) {
         return { steps: [["clone", "--depth", "1", "--quiet", o.url, o.dest]], env };
     }
-    // 有 sha:init + fetch-by-sha + checkout —— 不信分支名、不拉全史;fetch 不到该 sha = 该条失败。
     return {
         steps: [
             ["init", "--quiet", o.dest],
@@ -83,25 +55,17 @@ export function gitClonePlan(o) {
         env,
     };
 }
-/** manifest 本体尺寸上限(#97 redesign⑥ V2-⑦:**新的本地输入上限**,非既有格式事实——manifest 只被
- *  消费一个 `skillsPath` 字段,几行 JSON;超界视为畸形输入整条拒装)。 */
 export const PLUGIN_MANIFEST_MAX_BYTES = 64 * 1024;
-/** 条款 5 的 manifest 半场:`.claude-plugin/plugin.json` 的 `skillsPath`(缺省 `skills/`;cli plugin
- *  布局同族)。返回 ok:true+dir:undefined = 插件没有 skills 目录(可以只有 commands——那是 cli 壳的
- *  半场,worker 装 0 个 skill 不算失败);ok:false = 路径逃逸/manifest 本体畸形,整条拒装。
- *  manifest 臂分立(V2-⑦,原 broad-catch 是 fail-open):**不存在**=可选面,缺省 skills/;**存在但**
- *  本体逃逸根外/非普通文件/超界/读失败/JSON 坏 = ok:false 走既有 warning 面。 */
 export function resolvePluginSkillsRoot(cloneRoot) {
     let skillsPath = "skills";
     const rootReal = realpathSync(cloneRoot);
     const manifestPath = join(cloneRoot, ".claude-plugin", "plugin.json");
     let manifestPresent = false;
     try {
-        lstatSync(manifestPath); // 条目在场判定(lstat:悬空 symlink 也算在场——它该走拒绝臂,不是缺席臂)
+        lstatSync(manifestPath);
         manifestPresent = true;
     }
     catch {
-        /* 无 manifest ⇒ 缺省 skills/(manifest 是可选面) */
     }
     if (manifestPresent) {
         try {
@@ -123,21 +87,17 @@ export function resolvePluginSkillsRoot(cloneRoot) {
     if (isAbsolute(skillsPath))
         return { ok: false, reason: `skillsPath must be relative (got ${skillsPath})` };
     const candidate = resolve(rootReal, skillsPath);
-    // 先做词法前缀判定(../ 逃逸在 realpath 之前就拒——目标可能不存在)
     if (candidate !== rootReal && !candidate.startsWith(rootReal + sep)) {
         return { ok: false, reason: `skillsPath escapes the plugin root (${skillsPath})` };
     }
     if (!existsSync(candidate))
         return { ok: true };
-    // symlink 出根:对存在的目标 realpath 再判一次
     const real = realpathSync(candidate);
     if (real !== rootReal && !real.startsWith(rootReal + sep)) {
         return { ok: false, reason: `skillsPath resolves outside the plugin root via symlink (${skillsPath})` };
     }
     return { ok: true, dir: candidate };
 }
-/** 总入口(条款 3/7/8):逐条物化 + 装载 + 让位合并。materialize 盘位 = `<cacheRoot>/<name>/live`
- *  (成功后原子 rename 替换,失败保留旧盘位 = LKG)。 */
 export async function applyCenterPlugins(baseline, eff, opts) {
     const declared = Array.isArray(eff.plugins)
         ? (eff.plugins)
@@ -150,7 +110,7 @@ export async function applyCenterPlugins(baseline, eff, opts) {
     const runGit = opts.runGit ?? (async (args, env) => {
         await execFileP("git", args, { env: { ...process.env, ...env }, timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
     });
-    const taken = new Set(baseline.map((s) => s.spec.name)); // 让位判据:baseline(builtin+center 直发)恒赢
+    const taken = new Set(baseline.map((s) => s.spec.name));
     for (const decl of declared) {
         const v = opts.skipValidate
             ? { ok: true, name: String(decl.name), url: String(decl.source?.url), ...(typeof decl.sha === "string" ? { sha: decl.sha } : {}) }
@@ -165,14 +125,12 @@ export async function applyCenterPlugins(baseline, eff, opts) {
             continue;
         }
         const liveDir = join(opts.cacheRoot, v.name, "live");
-        // ── 物化:clone 到 staging,成功后原子替换 live;失败保留旧 live = LKG ──
         const staging = join(opts.cacheRoot, v.name, `staging-${process.pid}`);
         let materialized = false;
         try {
             await fsp.rm(staging, { recursive: true, force: true });
             await fsp.mkdir(staging, { recursive: true });
             const plan = gitClonePlan({ url: v.url, dest: staging, sha: v.sha });
-            // clone 目标目录已建:单步 clone 允许空目录;init 形对空目录同样成立。
             for (const step of plan.steps)
                 await runGit(step, plan.env);
             await fsp.rm(liveDir, { recursive: true, force: true });
@@ -183,7 +141,6 @@ export async function applyCenterPlugins(baseline, eff, opts) {
         catch (err) {
             await fsp.rm(staging, { recursive: true, force: true }).catch(() => undefined);
             if (existsSync(liveDir)) {
-                // LKG:拉取失败沿用上次成功物化(applyCenterSkills 同款语义)。
                 opts.logger?.warn("center_plugin_fetch_failed_lkg", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
                 out.lkgUsed.push(v.name);
             }
@@ -193,7 +150,6 @@ export async function applyCenterPlugins(baseline, eff, opts) {
                 continue;
             }
         }
-        // ── 装载:skills 目录(路径逃逸=整条拒装;fail-loud 单条不连坐)──
         try {
             const rootCheck = resolvePluginSkillsRoot(liveDir);
             if (!rootCheck.ok) {
@@ -202,11 +158,10 @@ export async function applyCenterPlugins(baseline, eff, opts) {
                 continue;
             }
             if (!rootCheck.dir)
-                continue; // 无 skills 目录:合法(commands-only 插件,cli 壳的半场)
-            const loaded = loadSkills(rootCheck.dir, { confineTo: liveDir }); // 不可信 lane:逐条目约束在 clone root 内(根守卫只守了 skills 根,根下 symlink 可逃逸)
+                continue;
+            const loaded = loadSkills(rootCheck.dir, { confineTo: liveDir });
             for (const skill of loaded) {
                 if (taken.has(skill.spec.name)) {
-                    // 收紧④:plugin 让位(方向与 center-wins 相反,理由见模块顶注)。
                     out.letGo.push({ plugin: v.name, skill: skill.spec.name });
                     opts.logger?.warn("center_plugin_skill_shadowed", { plugin: v.name, skill: skill.spec.name, note: "name taken by builtin/center skill — plugin yields (contract tightening-4)" });
                     continue;