@sema-agent/server 6.2.1 → 6.3.1

package/dist/bench/s1/arms.d.ts

@@ -67,12 +67,13 @@ export interface ProfileDeps {
      */
     runCounterfactualOracle?: () => Promise<OracleVerdicts>;
 }
-/** A leaf impl spec — budget already stamped by the harness (the §3.2 red line). */
+/** A leaf impl spec — budget already stamped by the harness (the §3.2 red line). All three budget keys live in
+ *  `limits` (core ≥5.8 reads them ONLY there — a top-level maxTokens/maxCostUsd would be a silently-dead key). */
 export interface SoloImplSpec {
     objective: string;
-    maxTokens: number;
-    maxCostUsd: number;
     limits: {
+        maxTokens: number;
+        maxCostUsd: number;
         maxTurns: number;
     };
 }

package/dist/bench/s1/live-deps.d.ts

@@ -34,7 +34,8 @@
  *    same anti-reward-hack transfer path SOLO/SUP use). If the integrated tree can't be imported, the cell is
  *    `infraFailed` (EXCLUDED) — NEVER a fabricated uniform delivered=false loss for the whole TEAM column.
  */
-import type { ProfileDeps } from "./arms.js";
+import { type TaskSpec } from "@sema-agent/core";
+import type { ProfileDeps, SoloImplSpec, SupImplSpec } from "./arms.js";
 import type { TrapSpec } from "./tasks.js";
 /** Live runtime config — the SAME base model + budget every arm runs on (the §3.2 fairness root). */
 export interface LiveRuntimeConfig {
@@ -88,4 +89,11 @@ export interface LiveCell {
  * @param cellId a stable id for the cell (used as sandbox metadata for fleet observability).
  */
 export declare function buildLiveDeps(rt: LiveRuntimeConfig, trap: TrapSpec, seed: number | string, cellId: string): LiveCell;
+/** The per-cell base TaskSpec every arm's leaf projects from. EXPORTED so the shape test measures the REAL spec
+ *  handed to the runner (the BUDGET-MATCH anchor is spec.limits, not the harness's own RowBudget echo). */
+export declare function benchBaseSpec(rt: LiveRuntimeConfig, cellId: string): (objective: string) => TaskSpec;
+/** Project a `SoloImplSpec` (budget already stamped by the harness, all keys in `limits`) onto the bench base TaskSpec. */
+export declare function toTaskSpec(base: (objective: string) => TaskSpec, impl: SoloImplSpec): TaskSpec;
+/** Project a `SupImplSpec` onto the bench base TaskSpec PLUS the durable wiring (checkpointStore + ask policy). */
+export declare function toSupTaskSpec(base: (objective: string) => TaskSpec, impl: SupImplSpec, trap: TrapSpec): TaskSpec;
 //# sourceMappingURL=live-deps.d.ts.map

package/dist/bench/s1/live-deps.js

@@ -272,13 +272,7 @@ function graderTransport(grader) {
  */
 export function buildLiveDeps(rt, trap, seed, cellId) {
     const { brain, models, roles, pricing } = buildBrainIngredients(rt);
-    const baseSpec = (objective) => ({
-        objective,
-        sessionId: `s1-${cellId}`,
-        maxTokens: rt.maxTokens ?? 8000,
-        maxCostUsd: rt.maxCostUsd ?? 1.0,
-        limits: { maxTurns: rt.maxTurns ?? 12 },
-    });
+    const baseSpec = benchBaseSpec(rt, cellId);
     // Lazily-provisioned, memoized per-cell sandboxes (so a cell that never runs a seam pays zero VM cost; a seam
     // that throws still leaves them on `state` so dispose() reaps them).
     const state = {};
@@ -458,12 +452,23 @@ export function buildLiveDeps(rt, trap, seed, cellId) {
     };
     return { deps, dispose };
 }
-/** Project a `SoloImplSpec` (budget already stamped by the harness) onto the bench base TaskSpec. */
-function toTaskSpec(base, impl) {
-    return { ...base(impl.objective), maxTokens: impl.maxTokens, maxCostUsd: impl.maxCostUsd, limits: { ...impl.limits } };
+/** The per-cell base TaskSpec every arm's leaf projects from. EXPORTED so the shape test measures the REAL spec
+ *  handed to the runner (the BUDGET-MATCH anchor is spec.limits, not the harness's own RowBudget echo). */
+export function benchBaseSpec(rt, cellId) {
+    // 🔴 core ≥5.8: maxTokens/maxCostUsd are read ONLY from `limits` — a top-level key is silently dead. No `as
+    // TaskSpec` here or in the projections below: the compiler is the guard against re-introducing dead keys.
+    return (objective) => ({
+        objective,
+        sessionId: `s1-${cellId}`,
+        limits: { maxTokens: rt.maxTokens ?? 8000, maxCostUsd: rt.maxCostUsd ?? 1.0, maxTurns: rt.maxTurns ?? 12 },
+    });
+}
+/** Project a `SoloImplSpec` (budget already stamped by the harness, all keys in `limits`) onto the bench base TaskSpec. */
+export function toTaskSpec(base, impl) {
+    return { ...base(impl.objective), limits: { ...impl.limits } };
 }
 /** Project a `SupImplSpec` onto the bench base TaskSpec PLUS the durable wiring (checkpointStore + ask policy). */
-function toSupTaskSpec(base, impl, trap) {
+export function toSupTaskSpec(base, impl, trap) {
     const requireApproval = trap.gatedTools ?? ["Bash"];
     const neverAuto = trap.neverAuto ?? [];
     return {

package/dist/bench/s1/runner-ctx.d.ts

@@ -4,7 +4,8 @@
  * clock that makes C2 (human-review wall-time) reproducible.
  *
  * 🔴 THE §3.2 RED LINE (design/89's #1 confound): every leaf TaskSpec across all 3 arms carries the SAME
- * `{ maxTokens, maxCostUsd, limits.maxTurns }`, and TEAM's per-worker budgets sum to ≤ the solo budget — so no
+ * `limits.{ maxTokens, maxCostUsd, maxTurns }` (core ≥5.8: budget keys live ONLY in `limits` — a top-level
+ * `maxTokens`/`maxCostUsd` is a silently-unread dead key), and TEAM's per-worker budgets sum to ≤ the solo budget — so no
  * arm can win on a bigger pie. `assertBudgetMatch` (below) is the build-time guard the shape test runs.
  *
  * 🔴 BUDGET-MATCH for TEAM is NEW WIRING the live conflict test does NOT do: `leader-conflict-resolver-live.test.ts`
@@ -37,9 +38,9 @@ export declare function budgetDescriptor(budget: BenchBudget, arm: string, teamW
 export interface BenchBudget {
     /** SAME base model all arms (design/89 §3.2 — decorrelation is a separate axis, not the value axis). */
     modelId: string;
-    /** `TaskSpec.maxTokens` — SAME all arms. */
+    /** `TaskSpec.limits.maxTokens` — SAME all arms. */
     maxTokens: number;
-    /** `TaskSpec.maxCostUsd` — SAME all arms (also the per-run spend cap). For TEAM, Σworker ≤ this. */
+    /** `TaskSpec.limits.maxCostUsd` — SAME all arms (also the per-run spend cap). For TEAM, Σworker ≤ this. */
     maxCostUsd: number;
     /** `TaskSpec.limits.maxTurns` — SAME all arms. */
     maxTurns: number;
@@ -89,11 +90,14 @@ export interface RunnerCtx {
  * Returns the budget fields to spread onto the spec — kept as a helper so EVERY leaf is stamped identically
  * (the live tests forget this for TEAM workers — the confound). `maxCostUsd` is overridable for the TEAM
  * per-worker split (Σ ≤ solo, enforced by `assertBudgetMatch`).
+ *
+ * 🔴 ALL THREE keys live under `limits` — core ≥5.8 reads `maxTokens`/`maxCostUsd` ONLY from `TaskSpec.limits`;
+ * a top-level key is DEAD (silently unread — the cost/token gates never bind).
  */
 export declare function leafBudgetFields(budget: BenchBudget, overrideMaxCostUsd?: number): {
-    maxTokens: number;
-    maxCostUsd: number;
     limits: {
+        maxTokens: number;
+        maxCostUsd: number;
         maxTurns: number;
     };
 };

package/dist/bench/s1/runner-ctx.js

@@ -4,7 +4,8 @@
  * clock that makes C2 (human-review wall-time) reproducible.
  *
  * 🔴 THE §3.2 RED LINE (design/89's #1 confound): every leaf TaskSpec across all 3 arms carries the SAME
- * `{ maxTokens, maxCostUsd, limits.maxTurns }`, and TEAM's per-worker budgets sum to ≤ the solo budget — so no
+ * `limits.{ maxTokens, maxCostUsd, maxTurns }` (core ≥5.8: budget keys live ONLY in `limits` — a top-level
+ * `maxTokens`/`maxCostUsd` is a silently-unread dead key), and TEAM's per-worker budgets sum to ≤ the solo budget — so no
  * arm can win on a bigger pie. `assertBudgetMatch` (below) is the build-time guard the shape test runs.
  *
  * 🔴 BUDGET-MATCH for TEAM is NEW WIRING the live conflict test does NOT do: `leader-conflict-resolver-live.test.ts`
@@ -44,12 +45,17 @@ export function makeBenchClock(startEpochMs = Date.now()) {
  * Returns the budget fields to spread onto the spec — kept as a helper so EVERY leaf is stamped identically
  * (the live tests forget this for TEAM workers — the confound). `maxCostUsd` is overridable for the TEAM
  * per-worker split (Σ ≤ solo, enforced by `assertBudgetMatch`).
+ *
+ * 🔴 ALL THREE keys live under `limits` — core ≥5.8 reads `maxTokens`/`maxCostUsd` ONLY from `TaskSpec.limits`;
+ * a top-level key is DEAD (silently unread — the cost/token gates never bind).
  */
 export function leafBudgetFields(budget, overrideMaxCostUsd) {
     return {
-        maxTokens: budget.maxTokens,
-        maxCostUsd: overrideMaxCostUsd ?? budget.maxCostUsd,
-        limits: { maxTurns: budget.maxTurns },
+        limits: {
+            maxTokens: budget.maxTokens,
+            maxCostUsd: overrideMaxCostUsd ?? budget.maxCostUsd,
+            maxTurns: budget.maxTurns,
+        },
     };
 }
 /**

package/dist/boot/resolve-spec.js

@@ -589,21 +589,24 @@ export function createResolveSpec(ctx) {
             // model uses its own upstream key; a model without one falls back to the gateway key. undefined
             // when no per-model keys are configured → unchanged single-key behavior.
             getApiKeyAndHeaders: getKeyResolver(), // A10 搬运改写②:活引用取值(原 `keyResolver`)
-            // [854]④ per-request 配速:body.limits.{timeoutSec,maxOutputTokens,maxTurns} 现在被收下(核对上游
+            // [854]④ per-request 配速:body.limits.{maxWalltimeMs,maxOutputTokens,maxTurns} 现在被收下(核对上游
             // TB2.0 实测诉求;旧姿势「body limits 一律忽略」作废)。合成规则在 resolveTaskLimits(spec-fields.ts):
-            //  - body.timeoutSec 给了就用 body(caller 显式配速,可低于内建墙;已被可选 TASK_TIMEOUT_MAX_SEC 封顶);
+            //  - body.maxWalltimeMs 给了就用 body(caller 显式配速,可低于内建墙;已被可选 TASK_TIMEOUT_MAX_SEC
+            //    封顶——env 保秒义,对毫秒键封顶时 ×1000);
             //  - body 缺席保持既有姿势 = tenancy 墙钟(单用户 turnkey 无墙 / 多租 2400s、大任务 3600s,
             //    clay 2026-07-04 make-real 教训①)+ env TASK_TIMEOUT_SEC 只抬不降(taskWallClockSec 内 Math.max);
             //  - maxOutputTokens/maxTurns 直透传(可选 TASK_MAX_OUTPUT_TOKENS_MAX / TASK_MAX_TURNS_MAX 同款封顶)。
-            // resume 重放持久化 body 不过 HTTP 400 门 → normalizeLimits defensive(0/负/垃圾按键 DROP,不 throw)。
+            // resume 重放持久化 body 不过 HTTP 400 门 → normalizeLimits defensive(0/负/垃圾按键 DROP,不 throw);
+            // 退役键(timeoutSec/deadline 族)DROP 必须留痕:task_limits_legacy_key_dropped 带被丢键与最终生效墙钟
+            // (null=整任务无墙——单用户 turnkey 无 env 墙时的真后果;多租=被延到租户墙)。
             ...(() => {
-                const limits = resolveTaskLimits(body.limits, taskLimitCaps, taskTimeoutSec, config.requirePrincipal, body.council === true || body.debate === true || scenarioName === "team");
+                const limits = resolveTaskLimits(body.limits, taskLimitCaps, taskTimeoutSec, config.requirePrincipal, body.council === true || body.debate === true || scenarioName === "team", (event, fields) => logger.warn(event, { ...fields, sessionId: auth?.sessionId ?? null }));
                 // [1301]③ config catalog server 半场:env 封顶不再是「五层五值互不知情」的暗手——每个真在场
                 // 的运营方旋钮以 configOverrides 声明进 spec(advisory,core 折进 config.assembled 的
                 // overrideReasons;「谁设的顶」变成读帧不考古)。只声明 SET 了的键(缺省不设=不污染帧)。
                 const declarations = [];
                 if (taskLimitCaps.timeoutSec !== undefined)
-                    declarations.push({ key: "server.limits.timeoutSecCap", value: String(taskLimitCaps.timeoutSec), reason: "env TASK_TIMEOUT_MAX_SEC (operator ceiling on caller limits.timeoutSec)" });
+                    declarations.push({ key: "server.limits.timeoutSecCap", value: String(taskLimitCaps.timeoutSec), reason: "env TASK_TIMEOUT_MAX_SEC (seconds; operator ceiling applied to caller limits.maxWalltimeMs as cap×1000)" });
                 if (taskLimitCaps.maxOutputTokens !== undefined)
                     declarations.push({ key: "server.limits.maxOutputTokensCap", value: String(taskLimitCaps.maxOutputTokens), reason: "env TASK_MAX_OUTPUT_TOKENS_MAX (operator ceiling)" });
                 if (taskLimitCaps.maxTurns !== undefined)
@@ -620,9 +623,9 @@ export function createResolveSpec(ctx) {
                 // 「server 设的顶」,声明其来源;single-user 无墙=不声明)。
                 if (config.requirePrincipal === true)
                     declarations.push({ key: "server.limits.wallClockBaseSec", value: "2400/3600", reason: "tenancy wall-clock base (multi-tenant; big tasks 3600) — TASK_TIMEOUT_SEC raises, never shrinks" });
-                // codex F1:core 目录自有键(limits.timeoutSec 等)**绝不重复声明**——core 已按真 provenance 发
+                // codex F1:core 目录自有键(limits.maxWalltimeMs 等)**绝不重复声明**——core 已按真 provenance 发
                 // 该字段,叠一条 host-declared 字符串值=同键双条矛盾帧(by-key 投影抹掉权威来源)。server 只
-                // 声明自己命名空间的键;来源语义(caller vs 墙钟)由 timeoutSec 的 spec provenance + 上面的
+                // 声明自己命名空间的键;来源语义(caller vs 墙钟)由 maxWalltimeMs 的 spec provenance + 上面的
                 // Cap 声明组合可读。
                 // core 5.8.0:预算族(maxCostUsd/maxTokens/degrade)从 TaskSpec 顶层迁入 limits——顶层键已删,
                 // 继续写顶层=经宽类型静默死键(E-HIGH-1 病族)。wire 面不变:body 顶层 maxCostUsd/maxTokens 照收

package/dist/http/server.js

@@ -942,8 +942,9 @@ export function createHttpServer(rawDeps) {
         // [854]④: fresh-submit shape validation for per-request 配速 —— 已知三键必须是正整数,否则 400 fail-loud
         // (body.model silent-drop 同类教训:静默 normalize 成「没配速」正是本件要防的假成功)。0 也拒绝:core 侧
         // `timeoutSec > 0` 才生效(0=不设墙,会绕过 TASK_TIMEOUT_MAX_SEC 封顶),maxTurns/maxOutputTokens 的 0 无意义。
-        // 枚举外键与 resilience/attachments 同口径:容忍(只校验已知键)。resolveSpec 的 normalizeLimits 对 RESUME
-        // 重放路径保持 defensive(按键 DROP,不 throw)。
+        // 枚举外键与 resilience/attachments 同口径:容忍(只校验已知键)——但退役键与预算族错位键**点名 400**
+        // (它们是「caller 有明确意图、本层却不会采纳」的已知键形,容忍=静默吞意图)。resolveSpec 的
+        // normalizeLimits 对 RESUME 重放路径保持 defensive(按键 DROP,不 throw)。
         if (body.limits !== undefined) {
             const l = body.limits;
             if (typeof l !== "object" || l === null || Array.isArray(l)) {
@@ -953,7 +954,8 @@ export function createHttpServer(rawDeps) {
             // core 5.8.0 时限重构:旧键响亮拒并点名替代(core 同姿势 config.limit_unknown_key;「勿自行兼容」是
             // core 的公开指令)。timeoutSec(秒)→ maxWalltimeMs(毫秒,注意单位);deadline 族三 opt-out 随
             // 机制整族退役(nudge/call-cap/graceful-finalize 已从引擎移除),无替代键。fresh fail-loud;resume
-            // 重放不过此门,normalizeLimits 对旧键 defensive DROP(存量 suspended 体降级为默认配速,方向安全)。
+            // 重放不过此门,resolveTaskLimits 对旧键 defensive DROP + 具名留痕(task_limits_legacy_key_dropped:
+            // 存量 suspended 体降级为默认配速——单用户无 env 墙时=整任务无墙,多租=延到租户墙,非「方向安全」)。
             if (l.timeoutSec !== undefined) {
                 sendError(res, 400, "request.field_invalid", "limits.timeoutSec was retired in core 5.8.0 — use limits.maxWalltimeMs (milliseconds; opt-in wall clock)");
                 return null;
@@ -969,6 +971,25 @@ export function createHttpServer(rawDeps) {
                     return null;
                 }
             }
+            // 预算族错位键(core 5.8.0「预算入 limits」的单向缺口):caller 按 core 键形写 limits.maxCostUsd/
+            // maxTokens/degrade/budgetStreamCancel 时,本服务的采纳面在 body **顶层**(resolve-spec.ts
+            // cappedCeiling)/运营方 env(MODEL_DEGRADE_*)/core 默认(budgetStreamCancel=maxCostUsd 在场即
+            // true)——不点名拒则被静默吞掉,方向「更松」(caller 以为封了 0.5 刀,实际无成本上限)。
+            // 退役键同姿势 fail-loud;resume 重放不过此门,normalizeLimits 对这四键维持 defensive DROP。
+            for (const k of ["maxCostUsd", "maxTokens"]) {
+                if (l[k] !== undefined) {
+                    sendError(res, 400, "request.field_invalid", `limits.${k} is not read from limits here — send it at the request body top level (${k}); it is capped by the operator ceiling ${k === "maxCostUsd" ? "MAX_TASK_COST_USD" : "MAX_TASK_TOKENS"}`);
+                    return null;
+                }
+            }
+            if (l.degrade !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.degrade is operator-controlled (env MODEL_DEGRADE_TO / MODEL_DEGRADE_AT_COST_FRACTION), not caller-settable — remove it");
+                return null;
+            }
+            if (l.budgetStreamCancel !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.budgetStreamCancel is not caller-settable here — the engine default applies (armed whenever a cost budget is present); remove it");
+                return null;
+            }
             for (const k of ["maxWalltimeMs", "maxOutputTokens", "maxTurns"]) {
                 const v = l[k];
                 if (v !== undefined && (typeof v !== "number" || !Number.isInteger(v) || v < 1)) {

package/dist/plugins/usage-window-store-sql.js

@@ -14,7 +14,28 @@ function parseRecord(raw, key) {
     if (typeof v !== "object" || v === null || !Array.isArray(r.slots) || !Array.isArray(r.buckets)) {
         throw new Error(`usage_window record for key "${key}" has an invalid shape (expected {slots[],buckets[]}) — refusing to mis-count a governance window`);
     }
-    return v;
+    // 深度对齐 core FileUsageWindowStore(validateSlots/validateBuckets):内层坏形若放过,非数值
+    // tokens 参与累加得 "0oops" ⇒ exhausted:false,超额账户被判未耗尽。逐条校验,任一不合即 fail-loud。
+    const badShape = (detail) => new Error(`usage_window record for key "${key}" has an invalid shape (${detail}) — refusing to mis-count a governance window`);
+    const finite = (x) => typeof x === "number" && Number.isFinite(x);
+    const slots = r.slots.map((s) => {
+        if (s === null || typeof s !== "object")
+            throw badShape("`slots` entry is not an object");
+        const { at, tokens } = s;
+        if (!finite(at) || !finite(tokens))
+            throw badShape("`slots` entry has a non-finite-numeric `at`/`tokens`");
+        return { at, tokens };
+    });
+    const buckets = r.buckets.map((b) => {
+        if (b === null || typeof b !== "object")
+            throw badShape("`buckets` entry is not an object");
+        const { windowMs, openedAt, tokens } = b;
+        if (!finite(windowMs) || windowMs <= 0 || !finite(openedAt) || !finite(tokens)) {
+            throw badShape("`buckets` entry has a non-finite-numeric `windowMs`/`openedAt`/`tokens` (windowMs must be > 0)");
+        }
+        return { windowMs, openedAt, tokens };
+    });
+    return { slots, buckets };
 }
 export async function ensureTiDBUsageWindowSchema(pool) {
     await pool.query(`CREATE TABLE IF NOT EXISTS ${USAGE_WINDOW_TABLE} (

package/dist/spec-fields.d.ts

@@ -93,12 +93,12 @@ export interface TaskLimitCaps {
     /** TASK_MAX_TURNS_MAX */ maxTurns?: number;
 }
 /**
- * [854]④ — normalize `body.limits` → 请求方配速意图 {timeoutSec?, maxOutputTokens?, maxTurns?}。DEFENSIVE
+ * [854]④ — normalize `body.limits` → 请求方配速意图 {maxWalltimeMs?, maxOutputTokens?, maxTurns?}。DEFENSIVE
  * (resume 重放持久化 body 不过 HTTP 400 门):仅正的有限数字存活(floor 取整),0/负/垃圾按键 DROP —— core 侧
- * `timeoutSec > 0` 才生效(0=不设墙,会绕过运营方封顶)、maxTurns/maxOutputTokens 的 0 无意义。每键各自被
+ * 墙钟 > 0 才生效(0=不设墙,会绕过运营方封顶)、maxTurns/maxOutputTokens 的 0 无意义。每键各自被
  * 运营方上限旋钮 clamp(Math.min;旋钮缺省不设=不封顶)。全空 ⇒ undefined。
  */
-export declare function normalizeLimits(v: unknown, caps: TaskLimitCaps): {
+export declare function normalizeLimits(v: unknown, caps: TaskLimitCaps, warn?: (event: string, fields: Record<string, unknown>) => void): {
     maxWalltimeMs?: number;
     maxOutputTokens?: number;
     maxTurns?: number;
@@ -120,5 +120,5 @@ export declare function normalizeApproachNotice(raw: unknown): false | {
  *  - `maxOutputTokens` / `maxTurns`:直透传(各自可选 env 上限已 clamp)。
  * 全空 ⇒ undefined(spec 不挂 limits 键,byte-compat)。
  */
-export declare function resolveTaskLimits(bodyLimits: unknown, caps: TaskLimitCaps, envTimeoutSec: number, requirePrincipal: boolean | undefined, big: boolean): TaskSpec["limits"];
+export declare function resolveTaskLimits(bodyLimits: unknown, caps: TaskLimitCaps, envTimeoutSec: number, requirePrincipal: boolean | undefined, big: boolean, warn?: (event: string, fields: Record<string, unknown>) => void): TaskSpec["limits"];
 //# sourceMappingURL=spec-fields.d.ts.map

package/dist/spec-fields.js

@@ -350,18 +350,32 @@ export function toolNameListFromBody(raw) {
 export function promptProfileFromBody(raw) {
     return raw === "simple" || raw === "classic" ? raw : undefined;
 }
+/** core 5.8.0 时限重构的退役键(fresh-submit 在 HTTP 门 400 点名;resume 重放在 normalize 层 DROP)。 */
+const RETIRED_LIMIT_KEYS = ["timeoutSec", "deadlineNudge", "callCapByDeadline", "gracefulFinalize"];
+/** 在场的退役键(normalizeLimits/resolveTaskLimits 共用判据源:留痕事件的 droppedKeys 字段)。 */
+function retiredLimitKeysPresent(v) {
+    if (v == null || typeof v !== "object" || Array.isArray(v))
+        return [];
+    const o = v;
+    return RETIRED_LIMIT_KEYS.filter((k) => o[k] !== undefined);
+}
 /**
- * [854]④ — normalize `body.limits` → 请求方配速意图 {timeoutSec?, maxOutputTokens?, maxTurns?}。DEFENSIVE
+ * [854]④ — normalize `body.limits` → 请求方配速意图 {maxWalltimeMs?, maxOutputTokens?, maxTurns?}。DEFENSIVE
  * (resume 重放持久化 body 不过 HTTP 400 门):仅正的有限数字存活(floor 取整),0/负/垃圾按键 DROP —— core 侧
- * `timeoutSec > 0` 才生效(0=不设墙,会绕过运营方封顶)、maxTurns/maxOutputTokens 的 0 无意义。每键各自被
+ * 墙钟 > 0 才生效(0=不设墙,会绕过运营方封顶)、maxTurns/maxOutputTokens 的 0 无意义。每键各自被
  * 运营方上限旋钮 clamp(Math.min;旋钮缺省不设=不封顶)。全空 ⇒ undefined。
  */
-export function normalizeLimits(v, caps) {
+export function normalizeLimits(v, caps, warn) {
     if (v == null || typeof v !== "object" || Array.isArray(v))
         return undefined;
     // core 5.8.0:键集换 maxWalltimeMs(毫秒)。旧键(timeoutSec/deadline 族三 opt-out)fresh-submit 已在
-    // HTTP 门响亮 400 点名替代;本层只走 resume 重放的持久化 body——旧键 defensive DROP(存量 suspended
-    // 体降级为默认配速,env 墙钟兜底仍在,方向安全;绝不静默换算=那是「自行兼容」,core 明令禁止)。
+    // HTTP 门响亮 400 点名替代;本层只走 resume 重放的持久化 body——旧键 defensive DROP 但**必须留痕**
+    // (task_limits_legacy_key_dropped):丢 caller 显式时限=收窄契约,存量 suspended 体降级为默认配速时,
+    // 单用户 turnkey 无 env 墙 ⇒ 整任务无墙钟、多租 ⇒ 被延到租户墙(2400/3600s)——两向都可能长于原意图。
+    // 绝不静默换算=那是「自行兼容」,core 明令禁止。
+    const dropped = retiredLimitKeysPresent(v);
+    if (dropped.length > 0)
+        warn?.("task_limits_legacy_key_dropped", { droppedKeys: dropped });
     const o = v;
     const pick = (raw, cap) => {
         if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 1)
@@ -405,12 +419,17 @@ export function normalizeApproachNotice(raw) {
  *  - `maxOutputTokens` / `maxTurns`:直透传(各自可选 env 上限已 clamp)。
  * 全空 ⇒ undefined(spec 不挂 limits 键,byte-compat)。
  */
-export function resolveTaskLimits(bodyLimits, caps, envTimeoutSec, requirePrincipal, big) {
+export function resolveTaskLimits(bodyLimits, caps, envTimeoutSec, requirePrincipal, big, warn) {
+    // 留痕事件在本层发(不透传给 normalizeLimits,免双发):只有装配点知道最终生效墙钟——
+    // effectiveMaxWalltimeMs: null = 整任务无墙(单用户 turnkey 无 env 墙时丢弃旧 timeoutSec 的真后果)。
+    const dropped = retiredLimitKeysPresent(bodyLimits);
     const requested = normalizeLimits(bodyLimits, caps);
     // core 5.8.0:墙钟键=maxWalltimeMs(毫秒)。taskWallClockSec 仍以秒推导(tenancy 基值+env 只抬不降,
     // 语义原样),装配处换算一次;body 显式给了 maxWalltimeMs 则直接生效(caller 意图,可低于 env 墙)。
     const wallSec = taskWallClockSec(envTimeoutSec, requirePrincipal, big);
     const maxWalltimeMs = requested?.maxWalltimeMs ?? (wallSec !== undefined ? wallSec * 1000 : undefined);
+    if (dropped.length > 0)
+        warn?.("task_limits_legacy_key_dropped", { droppedKeys: dropped, effectiveMaxWalltimeMs: maxWalltimeMs ?? null });
     const out = { ...(requested ?? {}), ...(maxWalltimeMs !== undefined ? { maxWalltimeMs } : {}) };
     return Object.keys(out).length > 0 ? out : undefined;
 }

package/dist/trace/core-keyset-guard.d.ts

@@ -25,8 +25,8 @@ type BgNotifExcluded = "kind" | "sessionScoped" | "owner" | "scope" | "descripti
 type _GuardBgNotif = AssertAllKeysHandled<Exclude<keyof BackgroundChildEvent, BgNotifProjected | BgNotifExcluded>>;
 type RosterProjected = "name" | "agentId" | "sessionId" | "toolUseId" | "owner" | "scope" | "sessionScoped" | "rootSessionId" | "model" | "createdAt";
 type _GuardRoster = AssertAllKeysHandled<Exclude<keyof RosterEntry, RosterProjected>>;
-type AskProjected = "toolName" | "args" | "message" | "sourceTaskId" | "fromSubagent" | "sourceAgentName" | "delegation";
-type AskExcluded = "toolCallId" | "preview" | "principal" | "requiresRealApproval";
+type AskProjected = "toolName" | "toolCallId" | "args" | "message" | "sourceTaskId" | "fromSubagent" | "sourceAgentName" | "delegation";
+type AskExcluded = "preview" | "principal" | "requiresRealApproval";
 type _GuardAsk = AssertAllKeysHandled<Exclude<keyof AskRequest, AskProjected | AskExcluded>>;
 type TaskEventHandled = "text_delta" | "reasoning_delta" | "tool_start" | "tool_end" | "turn_end" | "compacted" | "diagnostics" | "message_committed" | "status" | "task_notification" | "task_progress" | "steering_injected" | "workspace_changed" | "done" | "context_usage" | "compaction_outcome";
 type _GuardTaskEvent = AssertAllKeysHandled<Exclude<TaskEvent["type"], TaskEventHandled>>;

package/dist/trace/project.d.ts

@@ -89,6 +89,7 @@ export type TraceBlock = {
     truncated?: boolean;
     totalChars?: number;
     structured?: unknown;
+    errorCode?: string;
     eventId?: string;
     parentToolCallId?: string;
 } | {
@@ -334,6 +335,8 @@ export declare function contextUsageEventData(ev: {
     usedTokens?: unknown;
     windowTokens?: unknown;
     compactAtTokens?: unknown;
+    eventId?: unknown;
+    parentToolCallId?: unknown;
 }): Record<string, unknown>;
 /**
  * `turn_end` 的白名单投影 —— 🔴 2026-07-25 补:`turn_end` 此前是**唯一没有 builder 的内容臂**,两条持久化点
@@ -348,6 +351,8 @@ export declare function turnEndEventData(ev: {
     usage?: unknown;
     usageMissing?: true;
     stopReason?: string;
+    eventId?: unknown;
+    parentToolCallId?: unknown;
 }): Record<string, unknown>;
 /** Map core's `turn_end.usage` (1.76 / core [R59]: inputTokens/outputTokens/cacheReadTokens/cacheWriteTokens/
  *  costMicroUsd; core 3.0.0 adds required `totalInputTokens`) → the contract's `TraceTurn.tokens`.

package/dist/trace/project.js

@@ -156,9 +156,13 @@ export function toolEndEventData(ev) {
         // core 1.442([1898] RB-210):截断诚实体量(各 block 真实大小之和,不含 JSON 包装开销)。
         ...(Number.isFinite(ev.totalChars) ? { totalChars: ev.totalChars } : {}),
         ...(ev.structured !== undefined ? { structured: redactDeep(ev.structured) } : {}),
-        // core 5.9.0 W3([2535]):park/死投影结构化标记(引擎闭词表 `gate.parked`/`tool.not_found`,只在
-        // isError 时在场)——verbatim 透传,壳按它判别 park 毒化帧而不锚 abort 文案字面。
-        ...(typeof ev.errorCode === "string" ? { errorCode: ev.errorCode } : {}),
+        // core 5.9.0 W3([2535];2026-08-04 复审纠偏):errorCode = core 在 isError 时对**任意工具 ToolResult
+        // 的 `details.code`** 的透传 —— 开集,无引擎白名单(runtask 直读 result.details.code,structuredFrom
+        // 的 CC_DETAIL_TYPES 白名单只管 structured 键)。引擎码 `gate.parked`/`tool.not_found` 只是两例,
+        // 工具层现役即有 `path_not_in_root`/`readonly_out_of_root` 等,自注册工具可加新码 —— 消费端必须
+        // 带 default 臂,禁按两值穷举。verbatim 依据:码是机器短串标识符、非用户内容(不脱敏),边界靠
+        // 显式上限而非词表 —— >128 字符=非法形,整键丢弃(不截断:截断会铸出 core 从未发过的码)。
+        ...(typeof ev.errorCode === "string" && ev.errorCode.length <= 128 ? { errorCode: ev.errorCode } : {}),
         ...identityFields(ev),
     };
 }
@@ -425,6 +429,8 @@ export function contextUsageEventData(ev) {
         ...(n(ev.usedTokens) !== undefined ? { usedTokens: n(ev.usedTokens) } : {}),
         ...(n(ev.windowTokens) !== undefined ? { windowTokens: n(ev.windowTokens) } : {}),
         ...(n(ev.compactAtTokens) !== undefined ? { compactAtTokens: n(ev.compactAtTokens) } : {}),
+        // [2557] 2.4:本分支带 TaskEventIdentity 而 builder 曾剥——差集门补进三构造器当场红出(compacted 同病先例)。
+        ...identityFields(ev),
     };
 }
 /**
@@ -441,6 +447,8 @@ export function turnEndEventData(ev) {
         ...(ev.usage ? { usage: ev.usage } : {}),
         ...(ev.usageMissing === true ? { usageMissing: true } : {}),
         ...(typeof ev.stopReason === "string" ? { stopReason: ev.stopReason } : {}),
+        // [2557] 2.4:同 contextUsage——identity 键(eventId/parentToolCallId)曾被剥,差集门红出补齐。
+        ...identityFields(ev),
     };
 }
 /** Map core's `turn_end.usage` (1.76 / core [R59]: inputTokens/outputTokens/cacheReadTokens/cacheWriteTokens/
@@ -486,6 +494,9 @@ export function toolResultFieldsOf(d) {
         ...(d.truncated ? { truncated: true } : {}),
         ...(Number.isFinite(d.totalChars) ? { totalChars: d.totalChars } : {}),
         ...(d.structured !== undefined ? { structured: d.structured } : {}),
+        // core 5.9.0 W3([2535]):机器可判别的 park/死投影码(`gate.parked`/`tool.not_found`)——写侧
+        // toolEndEventData 已带,读腿必须同键 verbatim(absent⇒absent),否则冷回放退回锚 abort 文案字面。
+        ...(typeof d.errorCode === "string" ? { errorCode: d.errorCode } : {}),
         ...identityFields(d),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "6.2.1",
+  "version": "6.3.1",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -68,7 +68,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "^6.1.0",
+    "@sema-agent/sdk": "^6.2.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",