@sema-agent/server 7.43.0 → 7.44.0

package/dist/trace/redact.js

@@ -1,49 +1,20 @@
-/**
- * Trace thinking-block redaction (service-side). Per core [R57]: the agent's reasoning/CoT is emitted on the
- * live TaskEvent stream but DELIBERATELY kept out of the metadata Tracer because CoT may contain reasoned-about
- * secrets (and is large / ToS-sensitive for some providers). Persisting it for the trace UI is the deployment's
- * call — so when we DO persist it, redact unambiguous secret formats first. Conservative on purpose: only clear
- * key/token shapes are redacted. ⚠️ It is NOT exhaustive: unrecognised secret formats (a free-text password,
- * a JWT) pass through, and the broad `Bearer <20+ chars>` rule can over-match legitimate CoT (false positives
- * tolerated — over-redacting trace text is safe). For sensitive deployments, disable thinking capture entirely
- * via TRACE_THINKING=false. This is a seam — deployments can extend the patterns.
- */
 const SECRET_PATTERNS = [
-    [/-----BEGIN[^-]+PRIVATE KEY(?: BLOCK)?-----[\s\S]{0,8192}?-----END[^-]+PRIVATE KEY(?: BLOCK)?-----/g, "«redacted:private-key»"], // bounded body (council #8: avoid backtracking on fence-heavy input). `( BLOCK)?` covers PGP-armored keys `-----BEGIN PGP PRIVATE KEY BLOCK-----` where 'BLOCK' sits between 'PRIVATE KEY' and the dashes (L5 corpus caught the leak — same class as core's 1.108.1 PGP regression).
-    [/\bsk-[A-Za-z0-9_-]{16,}\b/g, "«redacted:key»"], // OpenAI / DeepSeek-style keys
-    [/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/g, "«redacted:gh-token»"], // GitHub tokens
-    [/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, "«redacted:slack-token»"], // Slack tokens
-    [/\bAKIA[0-9A-Z]{16}\b/g, "«redacted:aws-key»"], // AWS access key id
-    [/\b[Bb]earer\s+[A-Za-z0-9._~+/-]{20,}=*/g, "Bearer «redacted»"], // bearer auth tokens
-    [/\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}/g, "Basic «redacted»"], // HTTP Basic auth (base64 creds)
-    // BL-5: credentials embedded in a clone/push URL (`scheme://user:PASS@host`) — keep scheme+user, drop the
-    // password. Port-only URLs (`host:9999/path`, no `@`) don't match (the userinfo `:pass@` is required).
+    [/-----BEGIN[^-]+PRIVATE KEY(?: BLOCK)?-----[\s\S]{0,8192}?-----END[^-]+PRIVATE KEY(?: BLOCK)?-----/g, "«redacted:private-key»"],
+    [/\bsk-[A-Za-z0-9_-]{16,}\b/g, "«redacted:key»"],
+    [/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/g, "«redacted:gh-token»"],
+    [/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, "«redacted:slack-token»"],
+    [/\bAKIA[0-9A-Z]{16}\b/g, "«redacted:aws-key»"],
+    [/\b[Bb]earer\s+[A-Za-z0-9._~+/-]{20,}=*/g, "Bearer «redacted»"],
+    [/\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}/g, "Basic «redacted»"],
     [/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/[^/@\s:]+):[^/@\s]+@/g, "$1:«redacted»@"],
-    // BL-5: Gitea / PAT `Authorization: token <hex>` scheme (the Bearer/Basic rules don't cover the `token` keyword).
     [/\b[Tt]oken\s+[A-Za-z0-9._~+/-]{20,}/g, "token «redacted»"],
-    [/("(?:private_key|client_secret|password|api[_-]?key|secret|token)"\s*:\s*)"[^"\\]*(?:\\.[^"\\]*)*"/gi, '$1"«redacted»"'], // JSON secret-field VALUES (escaped-quote-safe)
+    [/("(?:private_key|client_secret|password|api[_-]?key|secret|token)"\s*:\s*)"[^"\\]*(?:\\.[^"\\]*)*"/gi, '$1"«redacted»"'],
 ];
-/** Redact unambiguous secret formats from reasoning/CoT before it is persisted to the durable trace log. */
-/** S24 (SILENT-FALLBACK P1): optional redaction observer — rewrites previously had zero fingerprint, so
- *  over-redaction (mangling legit content) and under-redaction (a pattern that never fires) were both
- *  invisible. main.ts wires this to `redactions_applied_total{pattern}`. Hot path: the observer only runs
- *  when a pattern actually matched; the label is derived once per pattern at module load. */
 let onRedaction;
 export function setRedactionObserver(fn) {
     onRedaction = fn;
 }
 const PATTERN_LABELS = SECRET_PATTERNS.map(([, repl]) => repl.replace(/[«»]/g, "").replace(/^redacted:/, ""));
-/**
- * `opts.observe: false` = **照常脱敏,但这一遍不计数**(合并码重扫)。
- *
- * 为什么需要它:本函数对自己的输出**值幂等、计数不幂等** —— URL-userinfo 与 JSON 秘密字段两条 pattern
- * 会命中自己已经替换过的输出并再计一次。于是任何**重扫已脱敏文本**的读路径(耐久待批队列的回读腿,
- * `/v1/approvals/stream` 每 3s 一拍)都会持续给 `redactions_applied_total` 加数,把那个用来识别
- * 「过度脱敏 / pattern 从不触发」的指标灌成不可读。
- *
- * 🔴 关的是**计数**,不是脱敏:重扫这一遍仍是纵深防御(手改过的行、未来某条写路径漏了脱敏,读面照样
- * 兜住)—— 少脱一次的代价是把凭证投上跨租户可见的运维队列,那条永远不能省。
- */
 export function redactSecrets(text, opts) {
     const observe = opts?.observe ?? true;
     let out = text;
@@ -53,10 +24,6 @@ export function redactSecrets(text, opts) {
             out = out.replace(re, repl);
             continue;
         }
-        // Count-then-replace (1.127.0): only the STRING form of `replace` expands `$1` capture refs —
-        // a function replacer returns its result verbatim, so the URL/JSON-field patterns emitted a literal `$1`
-        // instead of the preserved scheme/key prefix. The extra match() scan runs only when an observer is
-        // installed, on text that is already preview-capped.
         const n = out.match(re)?.length ?? 0;
         out = out.replace(re, repl);
         if (n > 0) {
@@ -64,29 +31,12 @@ export function redactSecrets(text, opts) {
                 onRedaction(PATTERN_LABELS[i], n);
             }
             catch {
-                /* observability must never break redaction */
             }
         }
     }
     return out;
 }
-/** Recursively redact secret-shaped strings inside a structured value (e.g. tool-call `args`), preserving shape.
- *  Tool arguments are persisted to the durable trace + replayed to any trace consumer, so a secret passed AS a
- *  tool arg must be stripped too (council: redactSecrets covered only free reasoning text, not tool args). */
-/** 递归上限 —— 与「一条畸形输入不得打死流」这条目标匹配的量级:真实工具输出的嵌套远低于此,
- *  而爆栈发生在数千层。超限的子树替换成一个**标记**,而不是抛错、也不是静默截断成 `{}`。 */
 const REDACT_MAX_DEPTH = 64;
-/**
- * 🔴 环 + 深度预算(2026-07-25 补)。原实现是纯递归、**既不记已访问节点也不限深度**,而它的调用位置是
- * **最不可信的边界**:`toolStart`/`toolEnd` 把工具的 `args`/`output`/`structured` 直接喂进来。后果两条:
- *   · **循环引用** ⇒ 无限递归 ⇒ `RangeError` **抛出构造函数**。在 sync 的 SSE 腿上那个 throw 就落在
- *     `for await (…) res.write(…)` 的循环里 ⇒ **一个畸形工具输出能打死一条正在跑的流**;在 ledger-sink 腿上
- *     则是那一帧 append 直接失败(事件永久不落盘)。
- *   · 超深嵌套 ⇒ 同样爆栈。
- * 同文件的 `redactedPreview` 的文档里早把这条记成"已复审的 MEDIUM"并**绕开** redactDeep ——
- * 也就是说这个洞是知道的,只是没堵。现在堵在 redactDeep 本体:环与超深都换成**可见的标记**,
- * 让下游看到"这里有东西被省略了",而不是丢一个空对象或炸掉整条流。
- */
 export function redactDeep(value) {
     return redactDeepInner(value, 0, new WeakSet());
 }
@@ -95,7 +45,6 @@ function redactDeepInner(value, depth, seen) {
         return redactSecrets(value);
     if (!value || typeof value !== "object")
         return value;
-    // 环:同一个对象在**当前这条路径上**再次出现 ⇒ 标记后停,不再往下走。
     if (seen.has(value))
         return "[circular]";
     if (depth >= REDACT_MAX_DEPTH)
@@ -110,33 +59,16 @@ function redactDeepInner(value, depth, seen) {
         return out;
     }
     finally {
-        // 出栈即移除:`seen` 记的是**当前路径**,不是"整棵树里出现过" —— 否则同一个对象被两个兄弟字段
-        // 各引用一次(DAG,完全合法)会被误标成 circular。
         seen.delete(value);
     }
 }
-/**
- * A REDACTED, length-BOUNDED string preview of a structured value — for surfacing a pending tool call's `args`
- * in the assistant inbox ("what is this ask about") WITHOUT leaking secrets or dumping an unbounded payload (a
- * write_file `content` can be megabytes). {@link redactDeep} scrubs secret-shaped strings first; the result is
- * JSON-stringified and capped (truncation is marked). `null`/`undefined` → `null` (nothing to preview). Defense
- * in depth: the redaction is conservative (NOT exhaustive — see {@link redactSecrets}); the inbox is already
- * owner-scoped, so this preview is only ever shown to the ask's own principal (or an operator inspecting it).
- */
 export function redactedPreview(value, cap = 2000) {
     if (value === null || value === undefined)
         return null;
-    // A bare string arg → preview it directly (not JSON-quoted), redacted.
     if (typeof value === "string") {
         const r = redactSecrets(value);
         return r.length === 0 ? null : r.length > cap ? `${r.slice(0, cap)}…[truncated]` : r;
     }
-    // Structured value → cycle-safe, leaf-bounded JSON, THEN string-level redaction. We do NOT use redactDeep here
-    // (review MEDIUM): redactDeep has no cycle/depth/size budget, so a cyclic arg would recurse to a stack overflow
-    // BEFORE any try/catch, a BigInt would throw, and a huge leaf would be fully copied before truncation. The
-    // replacer below caps long string leaves up front (bounds the buffer), tags cycles, and stringifies BigInt;
-    // redactSecrets on the resulting JSON catches the same secret shapes (the standalone key patterns + the JSON
-    // secret-field rule both operate on the flat string — equivalent-or-better than per-leaf redaction).
     const seen = new WeakSet();
     let s;
     try {
@@ -155,7 +87,7 @@ export function redactedPreview(value, cap = 2000) {
             }) ?? "";
     }
     catch {
-        s = "[unserializable]"; // last-resort (should be unreachable: cycles/BigInt are handled in the replacer)
+        s = "[unserializable]";
     }
     if (s.length === 0)
         return null;

package/dist/turn-activity.js

@@ -1,32 +1,8 @@
-/**
- * #245 S1([3777] 决策卡死墙攻关):进程内 per-task「turn 最后活性时刻」——running 形 409 与
- * GET /v1/runs/:id 读面的判别材料 `msSinceLastActivity` 的唯一数据源。
- *
- * 【为什么需要它】run 行的 `updatedAt` 由 liveness heartbeat(独立 `setInterval`,runs.ts)推进——
- * 它只证明 **server 进程**活着;turn 卡死在某个 await 上时心跳照走([3771] 推理漏洞的公开更正)。
- * 「turn 真在推进」的证据 = ledger sink 的 durable append(text/tool/status/park/done 全族都过那一条
- * 单写串行链)。cli 的 running 形保守臂([3779] C3)缺的就是这一维:没有它,「真忙的后台 run」与
- * 「断连僵局」在 wire 上不可分辨,只能猜。
- *
- * 【语义边界(与消费端约定,勿漂)】
- * - **同副本 best-effort**:记录只活在本进程。跨副本命中(claim 持有者在别的副本)或本副本重启后
- *   ⇒ 读不到 ⇒ wire 键**诚实缺席**——缺席 = 「无法证明」,不是「不活」。绝不铸 0(0 会被读成
- *   「刚刚还活着」,错误方向与 [2255] 「宁缺毋假」纪律同族)。
- * - 不落库、不进 SQL 面:这是分诊提示,不是状态机输入;任何门/CAS/resume 判定都不许读它。
- *
- * 【生命周期】终局**不主动清**——409 只在 `running` 行上消费本记录,终局行不进那个分支,残留无害;
- * 主动清反而制造「done append 已打点、行还没翻终态」窗口里的缺席假象。有界性由插入序近似 LRU 兜底
- * (CAP 条,超限逐最老;每条 ≈ 60B,上限 ≈ 0.5MB,常驻可接受)。
- * 🔴 但**新世代必须清**(codex S1-F2,2026-08-13):session purge 删行后客户端合法复用自带 taskId 重
- * 提交——不清的话新 run 首次打点前会读到旧 run 的时刻 = 假「刚有活性」证据。清点 = 三个 createRun
- * 成功分支(routes/runs.ts + routes/tasks.ts×2,接线锚在 session-active-conflict-materials 测试)。
- */
 const CAP = 8192;
 const lastActivityByTask = new Map();
-/** ledger sink 每次 durable append 时打点(装配点:runs.ts / routes/tasks.ts 的 createLedgerSink)。 */
 export function recordTurnActivity(taskId) {
     if (lastActivityByTask.has(taskId)) {
-        lastActivityByTask.delete(taskId); // 重插保持插入序 = 近似 LRU
+        lastActivityByTask.delete(taskId);
     }
     else if (lastActivityByTask.size >= CAP) {
         const oldest = lastActivityByTask.keys().next().value;
@@ -35,11 +11,9 @@ export function recordTurnActivity(taskId) {
     }
     lastActivityByTask.set(taskId, Date.now());
 }
-/** 最后活性时刻(epoch ms);无记录 ⇒ undefined(缺席语义见顶注)。 */
 export function readTurnActivityMs(taskId) {
     return lastActivityByTask.get(taskId);
 }
-/** 测试隔离用(生产路径不调:终局不清的理由见顶注)。 */
 export function clearTurnActivity(taskId) {
     lastActivityByTask.delete(taskId);
 }

package/dist/usage-analytics.js

@@ -1,30 +1,8 @@
-/**
- * 用量统计查询面(registry AnalyticsSource id="service-usage" 槽位的数据源)。
- *
- * 数据源 = task_run 账本的 result JSON(E8 `stats.modelUsage` per-model echo:inputTokens/outputTokens/
- * cacheReadTokens/cacheWriteTokens/costMicroUsd——costMicroUsd 是 authoritative micro-USD 记账非估算)。
- * 架构 = store 侧薄扫窗(usageScan:SQL 只按时间窗过滤取四列,行内 JSON 提取在 store 完成)+ 本文件的
- * 【纯函数】聚合(三后端同代码,零方言分叉;test 直接喂行)。
- *
- * 口径(回帖契约,2026-07-09):
- *  - tokensIn = Σ(inputTokens + cacheReadTokens + cacheWriteTokens)(即"进模型的上下文 token 总量",
- *    cache 命中也计——计费口径;cache 明细在 breakdown 的 cacheReadTokens 单列可见);
- *  - tokensOut = Σ outputTokens;
- *  - costUsd = Σ costMicroUsd / 1e6(authoritative);
- *  - 旧行/无 modelUsage echo 的行(1.x 早期或非终态)fallback `stats.tokens` 整数计入 tokensOut 并置
- *    `estimated:true` 于该聚合(诚实标注,契约要求"token 数标注估算与否");#59 起 `estimated` 还覆盖
- *    第二种口径不完整:**有 echo 行但缺数值键**(该键按 0 计入 ⇒ 总量偏低)——两臂同义:别把总数当精确值;
- *  - 行内数值键一律走 {@link numOf} 守卫:数据源是 DB 里的 JSON,裸算术遇缺席/非数会 NaN 毒掉整窗(#59);
- *  - 扫窗有行数上限(store 侧 LIMIT)——触顶时结果携带 `truncated:true`(诚实截断,绝不静默)。
- */
-/** JSON 来源的数值键:非 number / 非有限 ⇒ undefined(缺席),**绝不返回 NaN**,也绝不让字符串滑进 `+`。 */
 function numOf(d, key) {
     const v = d[key];
     return typeof v === "number" && Number.isFinite(v) ? v : undefined;
 }
 const emptyTotals = () => ({ tasks: 0, tokensIn: 0, tokensOut: 0, costUsd: 0, estimated: false });
-/** 折入一行 per-model echo(summary/series 的 foldRow 与 breakdown 的 model 维共用——两处写两遍必漂移)。
- *  缺席/非数键按 0 计入并置 `estimated`(诚实标注偏低,绝不静默,也绝不 NaN 毒窗)。 */
 function foldModelEntry(t, d) {
     const input = numOf(d, "inputTokens");
     const output = numOf(d, "outputTokens");
@@ -36,8 +14,6 @@ function foldModelEntry(t, d) {
     t.costUsd += (cost ?? 0) / 1e6;
     if (input === undefined || output === undefined || cacheRead === undefined || cacheWrite === undefined || cost === undefined)
         t.estimated = true;
-    // S10/V2-⑤:上面这条 tokensIn 求和公式只在「分量制」行上正确。缺标记(存量行,某族历史上 inputTokens
-    // 含 cache ⇒ 双算)或本读端不认识的标记值(将来别的口径)⇒ 走既有不精确通道,不显示为精确值。
     if (d.usageBasis !== "uncached-components-v1")
         t.estimated = true;
 }
@@ -49,20 +25,18 @@ function foldRow(t, row) {
             foldModelEntry(t, d);
     }
     else if (row.stats?.tokens) {
-        t.tokensOut += row.stats.tokens; // 旧行 fallback:总数无 in/out 拆分,归 out 侧并标 estimated
+        t.tokensOut += row.stats.tokens;
         t.estimated = true;
     }
 }
 const round6 = (n) => Math.round(n * 1e6) / 1e6;
 const finish = (t) => ({ ...t, costUsd: round6(t.costUsd) });
-/** GET /v1/usage/summary — 窗内总量。 */
 export function usageSummary(rows) {
     const t = emptyTotals();
     for (const r of rows)
         foldRow(t, r);
     return finish(t);
 }
-/** GET /v1/usage/series — 时间序列(UTC 桶;空桶不发行,消费方按需补零)。 */
 export function usageSeries(rows, metric, granularity) {
     const bucketMs = granularity === "hour" ? 3_600_000 : 86_400_000;
     const buckets = new Map();
@@ -77,8 +51,6 @@ export function usageSeries(rows, metric, granularity) {
         .sort((a, b) => a[0] - b[0])
         .map(([b, t]) => ({ t: new Date(b).toISOString(), v: metric === "costUsd" ? round6(t.costUsd) : t[metric] }));
 }
-/** GET /v1/usage/breakdown — 按维度分桶。dimension=model 时按 per-model echo 展开(一行可贡献多个 model 桶;
- *  fallback 行归 "(unattributed)");dimension=principal 时 owner NULL 归 "(anonymous)"。 */
 export function usageBreakdown(rows, dimension) {
     const buckets = new Map();
     const bucket = (key) => {
@@ -96,8 +68,8 @@ export function usageBreakdown(rows, dimension) {
         if (mu && Object.keys(mu).length > 0) {
             for (const [model, d] of Object.entries(mu)) {
                 const t = bucket(model);
-                t.tasks += 1; // 每 (run, model) 计一次 —— 一个 run 用两个模型在两桶各计 1(桶内 tasks=touched-run 数)
-                foldModelEntry(t, d); // #59:与 summary/series 同一守卫(缺席键不毒桶,只标 estimated;桶间不传染)
+                t.tasks += 1;
+                foldModelEntry(t, d);
             }
         }
         else {
@@ -108,7 +80,6 @@ export function usageBreakdown(rows, dimension) {
         .sort((a, b) => b[1].costUsd - a[1].costUsd || b[1].tokensOut - a[1].tokensOut || a[0].localeCompare(b[0]))
         .map(([key, t]) => ({ key, ...finish(t) }));
 }
-/** store 行投影 helper:result JSON(已 parse 或原始字符串)→ UsageRow.stats。所有后端复用(方言只在 SQL)。 */
 export function projectUsageStats(result) {
     try {
         const parsed = typeof result === "string" ? JSON.parse(result) : result;
@@ -124,9 +95,8 @@ export function projectUsageStats(result) {
         return out;
     }
     catch {
-        return undefined; // 坏 JSON:计 tasks 不计 token(诚实降级)
+        return undefined;
     }
 }
-/** usageScan 的统一行数上限(触顶=结果 truncated:true;试点规模远在限内)。 */
 export const USAGE_SCAN_LIMIT = 50_000;
 //# sourceMappingURL=usage-analytics.js.map

package/dist/wall-clock-jump-guard.js

@@ -1,73 +1,13 @@
-/**
- * 墙钟阶跃守卫 —— 给「按墙钟绝对 deadline 做终局判定」的清算腿加一道**单调钟佐证**。
- *
- * 病灶(test [4232] 场景①,libfaketime 真实构造,宿主真钟全程未碰):审批 SLA=45s,把进程内墙钟
- * **前拨 1 小时**,真实只等了约 14 秒审批卡就被 D-D deny-sweep 判超时自动拒绝。链条是清楚的:
- * `checkpoint.deadline` 是 core 在 `put` 时按**当时的墙钟**铸的绝对时刻(必须是墙钟——它要跨进程
- * 重启存活,单调基准一重启就没了),而 sweep 每拍拿 `Date.now()` 去比 `deadline <= cutoff`。墙钟凭空
- * 前跳 J 毫秒 ⇒ 判定钟凭空多走 J 毫秒 ⇒ 人还没走开,窗就没了。
- *
- * [4235] core 半场三定性把判定半场划给本仓:`totalWaitMs` 的墙钟**记账**是设计如此(要跨 durable
- * resume 延续),不改形;**判定**侧可以在进程内用单调钟做窗口佐证,与账面字段互不牵连。本模块就是那道佐证。
- *
- * ## 判据(为什么是「宽限一个完整 SLA」)
- * 直觉修法是把 cutoff 改成 `now - 累计前跳量`。它不成立:core 在跳变**之后**铸的 deadline 用的是**新**
- * 墙钟,拿旧墙钟去比 ⇒ 新卡凭空多活 J 毫秒,而 J 可以是任意大。补偿量若衰减,cutoff 又会以 2 倍速前进。
- * 两条路都把一个有界缺陷换成一个无界缺陷。
- *
- * 本模块改判**宽限**:检出一次前跳后,按**单调钟**静默 `grace = slaMs` 毫秒不做判定。
- *
- * 🔴 **宽限量是一个完整 SLA,不是 `min(J, S)`**(codex 对抗复审 R1 [high] 三,验真后修 —— 第一版正是
- * `min(J, S)`,而那条「J < S 时宽限恰好补平损失」的证明**是错的**)。错在哪:宽限只是**推迟**判定,
- * 它消不掉墙钟从此**永久领先** J 毫秒这件事。反例(逐字复算):S=45s,gate 在真实 t=0 铸出(deadline =
- * W0+45s),真实 t=1s 时前跳 J=10s。`min(J,S)`=10s ⇒ 宽限到真实 t=11s;此后墙钟恒为 `W0+t+10`,
- * 于是 deadline 在 **真实 t=35s** 就被判到期 —— 仍旧少给了整整 10 秒。
- *
- * 取满一个 S 才成立,证明是:宽限结束的时刻 t_g = t_jump + S(单调钟量)。
- *   · 跳变**之前或当时**就在等的 gate:它在 t_g 之前不可能被判,故真实等待 ≥ S ✔
- *   · 跳变**之后**在 t_x 铸出的 gate:deadline 用的是跳变后的钟 ⇒ 它按墙钟到期的时刻恰好对应真实
- *     t_x + S(墙钟与单调钟从跳变后起同速),宽限只可能把它再往后推,绝不会提前 ✔
- * 即**任一审批席都拿得到不少于一个完整 SLA 的真实时间**;单次阶跃下判定最多被推迟一个 S。
- *
- * 🔴 **「有界且一次性自清」只对单次阶跃成立**(codex 对抗复审 R2 [high] 五,验真后修 —— 第一版把这句话
- * 写成了无条件的,那是错的):每次前跳都把窗延到「此刻 + 一个 S」,所以**只要每个 S 内再跳一次**,窗就
- * 永远续下去,deny 腿被静默关停 —— 而它是一条 **fail-closed** 腿,永久不跑比跑早了更坏。
- * 收口 = 一串连续跳变的**累计宽限总上限**(缺省 `2 × S`:一个 S 覆盖有证明的单次阶跃,第二个 S 容一串
- * 短促跳变即 NTP 连续大步修正的真实形);撞上上限就**响亮**恢复判定(`onGraceCapped`),此后宁可按一个
- * 不稳的钟判,也不让 fail-closed 腿永远不跑。绝对兜底始终另有一层:`checkpoint.terminal_at_ms` 由别的
- * reap 腿执行、不经本守卫。
- *
- * ## 方向与响亮度(#157 安全轴)
- * 宽限只会**推迟**一个 fail-closed 动作(deny),绝不会放行任何东西 —— 方向安全。但它必须**响亮**:
- * 检出即 warn(带跳变量与宽限量),宽限期内每拍 info。绝对兜底仍在:`checkpoint.terminal_at_ms`
- * (put 时钉死的绝对上限)由另一条 reap 腿执行,不经本守卫 ⇒ 悬挂不可能无限。
- *
- * 后拨(墙钟相对单调钟**倒退**)不触发宽限:它只会让 deadline 显得更远 ⇒ 判定被推迟,已经是安全方向。
- * 仍然 warn —— 一次没人知道的钟倒退是运维事实,不是可以吞掉的噪声。
- */
-/** 判定为「阶跃」的漂移阈值。低于它的漂移是 tick 抖动 / 事件循环延迟 / NTP 缓变(≤500ppm,60s 拍上仅 30ms),
- *  不是拨表。误判的代价只是**推迟**一次 deny ≤ 宽限量,所以宁可取得低一些。 */
 export const DEFAULT_CLOCK_JUMP_THRESHOLD_MS = 2_000;
-/** `slaMs` 缺省(部署没配 `APPROVAL_TIMEOUT_SEC` 时)—— 与 `tool-approval.ts` 的
- *  `DEFAULT_APPROVAL_TTL_MS` 同值同义:一次审批交互的量级。 */
 export const DEFAULT_CLOCK_JUMP_GRACE_MS = 5 * 60_000;
 export function createWallClockJumpGuard(opts = {}) {
     const monotonic = opts.monotonic ?? (() => performance.now());
     const threshold = opts.jumpThresholdMs ?? DEFAULT_CLOCK_JUMP_THRESHOLD_MS;
     const graceCap = opts.slaMs !== undefined && opts.slaMs > 0 ? opts.slaMs : DEFAULT_CLOCK_JUMP_GRACE_MS;
-    // codex R2 [high] 五(验真后修):首拍锚点**真的**在构造时取(旧形只初始化了单调锚,墙钟锚留 undefined,
-    // 而注释却写着「构造时取」—— 注在撒谎,且后果具体:构造之后、第一次 admit 之前的那次前跳测不出来,
-    // 那正是「进程刚起来、pending gate 已在库里」的真实窗口)。
     let lastWall = (opts.now ?? Date.now)();
     let lastMono = monotonic();
     let graceUntilMono;
-    /** 本串连续跳变的起点(单调钟)。`undefined` = 当前不在宽限中。 */
     let burstStartMono;
-    // 一串跳变累计宽限的总上限。为什么需要它(codex R2 [high] 五的第二半):每次前跳都把窗延到「此刻 +
-    // 一个 SLA」,于是**只要每个 SLA 内再跳一次**,窗就永远续下去 —— deny 腿被静默关停,而它是一条
-    // **fail-closed** 腿,永久不跑比跑早了更坏。旧注「有界且一次性自清」在连续跳变下是假的。
-    // 2×SLA 的取值:一个 SLA 覆盖单次阶跃(那是有证明的那一支),第二个 SLA 容一串短促跳变(NTP 连续
-    // 大步修正的真实形);再往后钟已属病态,此时**宁可按一个不稳的钟判**也不能让 fail-closed 腿永远不跑。
     const maxTotalGrace = opts.maxTotalGraceMs !== undefined && opts.maxTotalGraceMs > 0 ? opts.maxTotalGraceMs : graceCap * 2;
     return {
         admit(wallNowMs) {
@@ -76,29 +16,22 @@ export function createWallClockJumpGuard(opts = {}) {
             const monoDelta = mono - lastMono;
             lastWall = wallNowMs;
             lastMono = mono;
-            // 漂移 = 墙钟走的量 − 单调钟走的量。两者本该逐毫秒并进;差额就是拨表量。
             const driftMs = wallNowMs - prevWall - monoDelta;
             if (driftMs > threshold) {
-                // codex R1 [high] 三:**整一个 SLA**,与跳变量无关(`min(driftMs, graceCap)` 的证明是错的,
-                // 反例逐字见模块头注 —— 宽限推迟不了「墙钟从此永久领先」这件事)。
                 const graceMs = graceCap;
                 if (burstStartMono === undefined)
-                    burstStartMono = mono; // 本串的起点(总上限自它起算)
+                    burstStartMono = mono;
                 const until = mono + graceMs;
-                // 取 max:宽限期内又跳一次 ⇒ 窗延到更晚的那个,不被后一次的小跳缩短。
                 if (graceUntilMono === undefined || until > graceUntilMono)
                     graceUntilMono = until;
                 opts.onJump?.({ jumpMs: Math.round(driftMs), graceMs: Math.round(graceMs) });
             }
             else if (driftMs < -threshold) {
-                // 后拨:判定被推迟=安全方向,不宽限(宽限只会把安全方向再推远)。但要留痕。
                 opts.onJump?.({ jumpMs: Math.round(driftMs), graceMs: 0 });
             }
             if (graceUntilMono !== undefined && burstStartMono !== undefined) {
                 const elapsedInBurst = mono - burstStartMono;
                 if (elapsedInBurst >= maxTotalGrace) {
-                    // 撞上总上限 ⇒ **响亮**恢复判定(不是悄悄放行)。绝对兜底另有一层:`checkpoint.terminal_at_ms`
-                    // 由别的 reap 腿执行、不经本守卫,所以即使这里也失灵,悬挂仍不可能无限。
                     opts.onGraceCapped?.({ totalGraceMs: Math.round(elapsedInBurst) });
                     graceUntilMono = undefined;
                     burstStartMono = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.43.0",
+  "version": "7.44.0",
   "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",
@@ -36,7 +36,7 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
-    "build": "tsc -p tsconfig.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build-js.json && tsc -p tsconfig.build-dts.json",
     "prepublishOnly": "npm run build",
     "start": "node dist/main.js",
     "dev": "tsx src/main.ts",
@@ -54,7 +54,7 @@
     "build:binary:run-local:darwin-arm64": "bun build --compile --target=bun-darwin-arm64 src/run-local.ts --outfile dist/run-local-darwin-arm64"
   },
   "dependencies": {
-    "@sema-agent/core": "^5.55.0",
+    "@sema-agent/core": "^5.56.0",
     "@sema-agent/registry-core": "^0.19.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",

package/dist/capabilities/scenario-alias.d.ts

@@ -1,27 +0,0 @@
-import type { Logger } from "../observability/logger.js";
-export declare const SCENARIO_ALIASES: Readonly<Record<string, string>>;
-/**
- * 把请求/配置里的场景名归一到现役主名。
- *
- *  - `known` 里**真有**这个名字 ⇒ 原样返回(live 定义优先于 alias)。⚠️ 窗内 center **无法**用旧名
- *    另立场景:`centerScenarios` 把 alias 名当**保留名**响亮跳过(理由见那里——否则请求面归影子场景、
- *    而按场景键的配置在 alias 窗里两边都算,MCP/A2A 会静默漏进主名的 roster)。所以这一支今天只是
- *    纵深防御(万一将来有别的路径往表里塞同名场景,它至少不会被别名劫持)。
- *  - 否则命中 alias 表 ⇒ 返回主名 + 响亮 `scenario_alias_deprecated`(每 logger 每旧名一次)。
- *  - 都不命中 ⇒ 原样返回(未知名的处置归调用方:请求面 typed 400,指派面走 unknown→default 回退)。
- */
-export declare function canonicalScenarioName(name: string, known: readonly string[] | undefined, logger?: Logger): string;
-/**
- * 「为场景 `name` 查按场景键的运维配置时,应命中哪些键」= 主名 + 其过渡期旧名。
- *
- * 🔴 **无二义的前提**(codex 对抗复审 [high] 的修法):旧名在窗内是**保留名** —— `centerScenarios` /
- * `centerScenarioDetails` 拒绝任何以 alias 名声明的 center 场景,所以「标了旧名的配置」在本部署里
- * 只可能是冲着(改名前的)主名去的,不存在第二个属主可漏。二义在源头掐掉,而不是在这四个取用口
- * 各塞一份 live 名册判据(那才是「同一语义多个属主」)。
- *
- * 请求面归一之后,运维**已写好的**旧名配置(skill frontmatter 的 `scenarios:`、center mcp/a2a 的
- * `scenarios`、center prompts 的 `scenarioOverrides`)若不再被命中,就会在改名当版**静默失效**
- * —— 静默是这里唯一不可接受的形态,所以窗内两名皆认。窗撤销时随 {@link SCENARIO_ALIASES} 一起塌回单键。
- */
-export declare function scenarioConfigKeys(name: string): readonly string[];
-//# sourceMappingURL=scenario-alias.d.ts.map

package/dist/capabilities/scenario-alias.js

@@ -1,61 +0,0 @@
-// ── #273 / C-R14 场景名 alias 过渡窗(clay 直裁 [4123],server 表态 [4127])──────────────────────
-//
-// 「team」一词全生态只指 agent-teams(持久具名团队);一次性多 agent 讨论一律叫「discuss」。本仓的
-// `team` 场景正中射程 ⇒ 主名改 `discuss`,旧名保**一版**入口别名。
-//
-// 🔴 **单点解析**:归一发生在 {@link canonicalScenarioName},由 {@link gateScenarioRequest}(HTTP lane)
-// 与 run-local 各调**一次**;此后整条下游(`scenarioName` 的每个判据点、trace 字段、skills/mcp/a2a/
-// prompts 的按场景过滤)只见现役主名。**禁**在判据点上一处一处加双名判 —— 改名批最经典的漏改形就是
-// 「改了三处、漏了第四处」,而漏掉的那处会静默按 default 跑(讨论任务被 2400s 墙钟砍腰之类)。
-//
-// ⏳ 窗一版:下一 minor 删本表 + team.ts 的 `run_team` 别名工具(两处同批删,发车帖点名壳/center)。
-export const SCENARIO_ALIASES = Object.freeze({ team: "discuss" });
-/** 一次性 deprecation warn 的去重位:按 logger 实例记已喊过的旧名。部署的 logger 是进程单例 ⇒ 每个
- *  旧名每进程喊一次(不是每请求刷屏);测试各建各的 logger ⇒ 每格都看得见自己的那一声。 */
-const aliasWarned = new WeakMap();
-/**
- * 把请求/配置里的场景名归一到现役主名。
- *
- *  - `known` 里**真有**这个名字 ⇒ 原样返回(live 定义优先于 alias)。⚠️ 窗内 center **无法**用旧名
- *    另立场景:`centerScenarios` 把 alias 名当**保留名**响亮跳过(理由见那里——否则请求面归影子场景、
- *    而按场景键的配置在 alias 窗里两边都算,MCP/A2A 会静默漏进主名的 roster)。所以这一支今天只是
- *    纵深防御(万一将来有别的路径往表里塞同名场景,它至少不会被别名劫持)。
- *  - 否则命中 alias 表 ⇒ 返回主名 + 响亮 `scenario_alias_deprecated`(每 logger 每旧名一次)。
- *  - 都不命中 ⇒ 原样返回(未知名的处置归调用方:请求面 typed 400,指派面走 unknown→default 回退)。
- */
-export function canonicalScenarioName(name, known, logger) {
-    if (known?.includes(name))
-        return name;
-    if (!Object.hasOwn(SCENARIO_ALIASES, name))
-        return name;
-    const resolved = SCENARIO_ALIASES[name];
-    if (resolved === undefined)
-        return name;
-    if (logger) {
-        let seen = aliasWarned.get(logger);
-        if (!seen)
-            aliasWarned.set(logger, (seen = new Set()));
-        if (!seen.has(name)) {
-            seen.add(name);
-            logger.warn("scenario_alias_deprecated", { requested: name, resolved });
-        }
-    }
-    return resolved;
-}
-/**
- * 「为场景 `name` 查按场景键的运维配置时,应命中哪些键」= 主名 + 其过渡期旧名。
- *
- * 🔴 **无二义的前提**(codex 对抗复审 [high] 的修法):旧名在窗内是**保留名** —— `centerScenarios` /
- * `centerScenarioDetails` 拒绝任何以 alias 名声明的 center 场景,所以「标了旧名的配置」在本部署里
- * 只可能是冲着(改名前的)主名去的,不存在第二个属主可漏。二义在源头掐掉,而不是在这四个取用口
- * 各塞一份 live 名册判据(那才是「同一语义多个属主」)。
- *
- * 请求面归一之后,运维**已写好的**旧名配置(skill frontmatter 的 `scenarios:`、center mcp/a2a 的
- * `scenarios`、center prompts 的 `scenarioOverrides`)若不再被命中,就会在改名当版**静默失效**
- * —— 静默是这里唯一不可接受的形态,所以窗内两名皆认。窗撤销时随 {@link SCENARIO_ALIASES} 一起塌回单键。
- */
-export function scenarioConfigKeys(name) {
-    const olds = Object.entries(SCENARIO_ALIASES).filter(([, to]) => to === name).map(([from]) => from);
-    return olds.length > 0 ? [name, ...olds] : [name];
-}
-//# sourceMappingURL=scenario-alias.js.map