@sema-agent/server 7.73.1 → 7.75.0

package/dist/trace/project.d.ts

@@ -122,8 +122,9 @@ export declare function toolStartEventData(ev: {
 /**
  * 🔴 **筛子是一只总函数**(S-239,codex 对抗复审 r1 [medium] 亲核复现后修)—— 上面纪律②许诺的
  * 「坏形 ⇒ report + withhold,**不抛**」此前是靠**逐条枚举**坏形兑现的,枚举不到的那些照样抛:
- * `projectSettlement` 对 `note` / `who.approver` 先 `redactSecrets` 再截断,而 `redactSecrets` 在 ≥2^23
- * 的单段上爆回溯栈(`RangeError`,S-102/S-106 登记的既有上界,见 `redact.ts` 该行顶注),两条叶各能抛一次。
+ * `projectSettlement` 对 `note` / `who.approver` 先 `redactSecrets` 再截断,而 `redactSecrets` 会在
+ * 病态输入上爆回溯栈(`RangeError`:≥2^23 单段那一形已由 S-219 的 `atLeast` 铸点闭掉,仍能抛的是 JSON 秘密字段臂的
+ * 转义对循环,S-102/S-106 登记的既有上界,见 `redact.ts` 该行顶注),两条叶各能抛一次。
  *
  * 抛出去的代价按腿算,而且一条比一条重:写腿落账那处的 `.catch` 看不到**同步**投影期的异常;读腿上它
  * 直接逃出 `formatEvent` / 投影函数 —— 账本裸回放腿的那一次会当场断流(那一行不上帧、游标不前进、后面的
@@ -135,41 +136,30 @@ export declare function toolStartEventData(ev: {
  * `note` 一条叶(`approver` 同病)—— 那是给一个类打两个特判,正是本仓要消掉的形。
  */
 export declare function screenedGate(v: unknown): GateOutcome | undefined;
-/**
- * 🔴 **耐久行的**门记录读口(7.72.0;`screenedGate` 的读腿孪生)—— 先把本仓自己写过的**旧拼法**读成它
- * 今天的名字({@link RETIRED_ASK_ORIGIN_SPELLINGS}),再走与写腿**同一只**筛子。
- *
- * 为什么读腿要多这一步而写腿不要:读到的字节可能是**本仓上一个版本**写下的(账本回放、park 行的
- * `resolvedOutcome`),而 core 7.14.0 [ref] C2 把 `ASK_ORIGINS` 的一个词改了名 —— 不认旧拼法,那些行就整条
- * withhold,连 `disposition` / `settlement`(谁拒的、人怎么结的)一起在回放面上消失。写腿面对的则是**当下**
- * 引擎铸的记录,它铸不出退役词,所以那里出现退役词 = producer 契约漂了 = 要 report + withhold 的事。
- *
- * 不改原对象(调用方与账本共享引用):归一时换一只信封,原记录一个字节不动。
- */
-export declare function screenedStoredGate(v: unknown): GateOutcome | undefined;
 /**
  * 🔴 **账本裸回放面的读腿一步**(S-239)—— `GET /v1/runs/:id/events`(`http/routes/runs.ts` 的
- * `formatEvent`)对每一行走这一口,把行上的 `GateOutcome` 交给**同一只** {@link screenedStoredGate}。
+ * `formatEvent`)对每一行走这一口,把行上的 `GateOutcome` 交给**同一只** {@link screenedGate}。
  *
  * ## 它补的是哪一格
  * 7.72.0 把耐久读边界收成一只筛子,但点名的读腿只有两条({@link toolResultFieldsOf} 的投影回放、
  * `/decide` 幂等回放体)。**账本裸回放**是第三条,而它此前只过 `redactLedgerEventData` —— 那只函数
  * 对 `tool_end` 型**逐字不动**(它管的是 `done.result` / `failed.errorMessage` / park 行三族)。
- * 于是同一条账本行在本仓三张读面上有**两种**读法:
- *  · 本仓 7.64.0–7.71.0 自己写下的 `origin:"unresolvable"` —— 投影面读成今天的名字,裸回放面原样
- *    透出一个 core 今天判**非成员**的词(消费端按闭集分派 ⇒ 落进它的 default 臂);
- *  · 第三方 producer / 坏世代写下的集外词与破不变量的记录 —— 投影面整条 withhold + 计数,裸回放面
- *    直接上 wire,而 `gate-outcome-defective` 那一格不涨(运维看不见有 producer 在发坏记录)。
+ * 于是第三方 producer / 坏世代写下的集外词与破不变量的记录在投影面整条 withhold + 计数,裸回放面却
+ * 直接上 wire,而 `gate-outcome-defective` 那一格不涨(运维看不见有 producer 在发坏记录)。
  *
  * ## 为什么是这一形(而不是在路由里加一只筛)
- * 筛子仍然只有一只,归一表仍然只有一张 —— 本函数只是把**第三条读腿**接到它上面,规则因此从
- * 「三条读腿里有两条筛」回到「凡耐久读腿上的 `GateOutcome` 一律过 `screenedStoredGate`,零例外」。
- * 它按**型**分派而不是按调用点,所以将来第二个携带 `GateOutcome` 的账本型只需把
- * {@link GATE_BEARING_LEDGER_EVENT_TYPE} 扩成词表,读腿一行都不用改。
- *
- * ## 与写腿的关系(别再走回头路)
- * 写腿的对偶是 `redactLedgerEventData`(三孪生 store 的 `appendEvent` 落库前),它**不该**长出本函数
- * 这一步:归一只认读腿,写腿保持严格(理由全文见 {@link RETIRED_ASK_ORIGIN_SPELLINGS} 的边界划清二)。
+ * 筛子只有一只 —— 本函数只是把**第三条读腿**接到它上面,规则因此是「凡耐久读腿上的 `GateOutcome`
+ * 一律过 {@link screenedGate},零例外」。它按**型**分派而不是按调用点,所以将来第二个携带
+ * `GateOutcome` 的账本型只需把 {@link GATE_BEARING_LEDGER_EVENT_TYPE} 扩成词表,读腿一行都不用改。
+ *
+ * ## 读腿与写腿现在是**同一只**筛(7.74.0 起,零双读)
+ * 7.72.0–7.73.0 期间读腿多一步「认本服务上一版写下的退役词旧拼法」(`unresolvable` → `ancestor_marked`),
+ * 那是一条**长期双读臂**:同一份字节在写腿与读腿上有两种理解,而且没有到期日。7.74.0 把它换成**一次性
+ * 迁移**(启动期把存量字节原地改名,`plugins/one-time-migrations.ts`,随 7.75.0 删)⇒ 读腿退回写腿那只
+ * 严格筛子,集外词一律整条 withhold + 计数,不再有第二种读法。
+ *
+ * ## 与写腿脱敏汇点的关系(别再走回头路)
+ * 写腿的对偶是 `redactLedgerEventData`(三孪生 store 的 `appendEvent` 落库前),它管的是脱敏、不是判形;
  * 两只函数因此是「共用的脱敏汇点 + 读腿独有的筛」这一层关系,不是同一只函数的两种模式。
  *
  * 不改原对象(调用方与账本共享引用):有变更时换一只信封,原记录一个字节不动。
@@ -616,7 +606,9 @@ export interface TraceTurn {
      *  于是一次 usage 半缺(某些 provider 只回 output 侧)在面板上显示成一个可核对的真数字。
      *  0 是一个数,未知不是 —— 两者同形正是本仓 `boundCallId`/`gateKind`/`contentKind` 一族一直在防的事。
      *  ⚠️ wire 面(`GET /v1/tasks/:id/turns` 与 trace SSE 的 `turn` 事件)因此可能给出**只有一侧**的
-     *  `tokens`;做算术的消费端要按「键可能缺席」读(`tokens` 整只可缺席早就是契约的一部分)。 */
+     *  `tokens`;做算术的消费端要按「键可能缺席」读(`tokens` 整只可缺席早就是契约的一部分)。
+     *  🔴 **7.74.0 / core 7.17.0([ref])**:引擎自陈 `usageMissing` 的一轮(usage 是六个 0 的占位)⇒ 整只缺席 ——
+     *  「未知」在这张脸上只有缺席这一种拼法,不加第二枚座位(见 {@link toContractTokens})。 */
     tokens?: {
         in?: number;
         out?: number;
@@ -673,8 +665,16 @@ export declare function turnEndEventData(ev: {
  *  🔴 S-213⑥:**一条规则管五个子键** —— 源侧在场就铸、缺席就不铸,没有 `?? 0`。此前 `in`/`out` 两座
  *  各带一个默认 0,于是 usage 半缺(provider 只回 output 侧)被投影成 `in:0` = 一个看起来可核对的真
  *  数字;`uncachedIn`/`cacheRead`/`cacheWrite` 三键从第一天起就是缺席制,`in`/`out` 只是漏进了默认值。
- *  早退分支语义不变:输入两键(择一)与 `outputTokens` 全缺 ⇒ 整只 `tokens` 缺席(不铸空对象)。 */
-export declare function toContractTokens(usage: unknown): TraceTurn["tokens"] | undefined;
+ *  早退分支语义不变:输入两键(择一)与 `outputTokens` 全缺 ⇒ 整只 `tokens` 缺席(不铸空对象)。
+ *
+ *  🔴 **7.74.0 / core 7.17.0([ref]):`usageMissing` 是本投影的输入,不只是事件面的一枚标。**引擎自该版起
+ *  在「这一轮 provider 没回 usage 帧」时也**恒发** `turn_end.usage` —— 内容是六个 0 的占位对象,旁边挂
+ *  `usageMissing: true`。只看 usage 会把「未测量」投成一只全 0 对象,与「真的零用量」在
+ *  `GET /v1/tasks/:id/turns` 与 trace SSE 的 `turn` 事件上逐字节同形 —— 正是 S-213⑥「0 是一个数,未知不是」
+ *  要消灭的那一形。契约里「未知 = `tokens` 整只缺席」早就是唯一读法 ⇒ 标在场就**不铸**(与 7.73.1 及以前的
+ *  wire 读数逐字节相同),不按「六个 0」的值形猜、也不给 `TraceTurn.tokens` 加第二枚「未知」座(同一事实两种
+ *  拼法)。标的域是 core 的 `true | 缺席`(永不 `false`)⇒ 严判 `=== true`,别的值不是标。 */
+export declare function toContractTokens(usage: unknown, usageMissing?: unknown): TraceTurn["tokens"] | undefined;
 /** [ref]C-13:tool_start/tool_end 的**共享挑键**——`projectEvents`(turns 面)与 `mapTraceEvent`
  *  (trace SSE 面)对同一账本行的字段选择逐字同构,此前两处独立手写,structured/totalChars/label
  *  三次扩字段各改两遍(见两处对偶注)。收一份:两面各自包装键名皮(id/name/input vs 同名),

package/dist/trace/project.js

@@ -86,21 +86,21 @@ export function toolStartEventData(ev) {
     return { toolCallId: ev.toolCallId, toolName: ev.toolName, ...(ev.label !== undefined ? { label: ev.label } : {}), args: redactDeep(ev.args), ...identityFields(ev) };
 }
 const SETTLEMENT_NOTE_MAX = 500;
-const RETIRED_ASK_ORIGIN_SPELLINGS = {
-    unresolvable: "ancestor_marked",
-};
 export function screenedGate(v) {
     try {
         return screenedGateOrThrow(v);
     }
     catch (e) {
-        recordFailOpen("server.trace.gate-outcome-defective", `projection threw: ${e instanceof Error ? `${e.name}: ${e.message}` : "non-Error throw"}`);
+        recordFailOpen("server.trace.gate-outcome-defective", `projection threw: ${e instanceof Error ? e.name : "non-Error throw"}`);
         return undefined;
     }
 }
 function screenedGateOrThrow(v) {
-    if (v === null || typeof v !== "object")
+    if (v === null || typeof v !== "object") {
+        if (v !== undefined)
+            recordFailOpen("server.trace.gate-outcome-defective", "gate is not an object");
         return undefined;
+    }
     const g = v;
     const d = g.disposition;
     if (d === null || typeof d !== "object" || (d.kind !== "allowed" && d.kind !== "denied")) {
@@ -135,13 +135,6 @@ function screenedGateOrThrow(v) {
         ...(g.origin === undefined ? {} : { origin: g.origin }),
     };
 }
-export function screenedStoredGate(v) {
-    if (v === null || typeof v !== "object")
-        return undefined;
-    const g = v;
-    const renamed = typeof g.origin === "string" ? RETIRED_ASK_ORIGIN_SPELLINGS[g.origin] : undefined;
-    return screenedGate(renamed === undefined ? g : { ...g, origin: renamed });
-}
 const GATE_BEARING_LEDGER_EVENT_TYPE = "tool_end";
 export function screenedStoredEventData(type, data) {
     if (type !== GATE_BEARING_LEDGER_EVENT_TYPE)
@@ -151,7 +144,7 @@ export function screenedStoredEventData(type, data) {
     const d = data;
     if (d.gate === undefined)
         return data;
-    const gate = screenedStoredGate(d.gate);
+    const gate = screenedGate(d.gate);
     if (gate === undefined) {
         const withheld = { ...d };
         delete withheld.gate;
@@ -531,7 +524,9 @@ export function turnEndEventData(ev) {
         ...identityFields(ev),
     };
 }
-export function toContractTokens(usage) {
+export function toContractTokens(usage, usageMissing) {
+    if (usageMissing === true)
+        return undefined;
     if (!usage || typeof usage !== "object")
         return undefined;
     const u = usage;
@@ -556,7 +551,7 @@ export function toolCallFieldsOf(d) {
     };
 }
 export function toolResultFieldsOf(d) {
-    const gate = d.gate === undefined ? undefined : screenedStoredGate(d.gate);
+    const gate = d.gate === undefined ? undefined : screenedGate(d.gate);
     return {
         callId: String(d.toolCallId ?? ""),
         ...(typeof d.label === "string" ? { label: d.label } : {}),
@@ -615,7 +610,7 @@ export function projectEvents(events, opts = {}) {
                 });
                 break;
             case "turn_end":
-                flushTurn(ev.seq, ev.ts, toContractTokens(d.usage));
+                flushTurn(ev.seq, ev.ts, toContractTokens(d.usage, d.usageMissing));
                 break;
         }
     }
@@ -677,7 +672,7 @@ function mapTraceEventInner(type, seq, data) {
         case "tool_end":
             return { event: "tool-result", data: { seq, ...toolResultFieldsOf(data), isError: Boolean(data.isError), ...(data.output !== undefined ? { output: data.output } : {}) } };
         case "turn_end": {
-            const tokens = toContractTokens(data.usage);
+            const tokens = toContractTokens(data.usage, data.usageMissing);
             return { event: "turn", data: { seq, ...(tokens ? { tokens } : {}) } };
         }
         case "prompt_assembled":

package/dist/trace/redact.js

@@ -2,14 +2,292 @@ import { stripFormatCharacters } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 export const normalizeForRedaction = stripFormatCharacters;
 const REDACTION_TOKEN_RE_SRC = String.raw `«redacted(?::[a-z-]{1,16}){0,2}»`;
+const atLeast = (cls, min) => `${cls}{${min}}${cls}*`;
 const ENTROPY_SCAN_MAX = 96;
 const twoStrongAhead = (valueClass) => String.raw `(?=${valueClass}{0,${ENTROPY_SCAN_MAX}}[0-9A-Z]${valueClass}{0,${ENTROPY_SCAN_MAX}}[0-9A-Z])`;
 const IDENT_CONNECTORS = "[_./-]";
 const noConnectorAhead = (valueClass) => String.raw `(?!${valueClass}{0,${ENTROPY_SCAN_MAX}}${IDENT_CONNECTORS}${valueClass})`;
-const valueArm = (prefixSrc, valueClass, min) => new RegExp(`${prefixSrc}${twoStrongAhead(valueClass)}${valueClass}{${min},}`, "g");
+const WORD_INTERIOR_CLASS = "[A-Za-z0-9]";
+const CH_TAB = 9, CH_LF = 10, CH_CR = 13, CH_ESC = 27, CH_SPACE = 32, CH_PLUS = 43, CH_MINUS = 45, CH_SLASH = 47;
+const CH_0 = 48, CH_9 = 57, CH_COLON = 58, CH_EQ = 61, CH_AT = 64, CH_A = 65, CH_Z = 90;
+const CH_LBRACKET = 91, CH_BACKSLASH = 92, CH_UNDERSCORE = 95;
+const CH_a = 97, CH_b = 98, CH_f = 102, CH_n = 110, CH_r = 114, CH_t = 116, CH_u = 117, CH_z = 122, CH_TILDE = 126;
+const CH_QUOTE = 34;
+const CH_CSI8 = 155;
+const CH_LAQUO = 171;
+const ESC_CHAR = String.fromCharCode(CH_ESC);
+const CSI8_CHAR = String.fromCharCode(CH_CSI8);
+const WORD_INTERIOR_BYTES = (() => {
+    const one = new RegExp(`^${WORD_INTERIOR_CLASS}$`);
+    const table = new Uint8Array(256);
+    for (let c = 0; c < table.length; c++)
+        if (one.test(String.fromCharCode(c)))
+            table[c] = 1;
+    return table;
+})();
+function hexDigitValue(c) {
+    if (c >= CH_0 && c <= CH_9)
+        return c - CH_0;
+    if (c >= CH_A && c <= CH_A + 5)
+        return c - CH_A + 10;
+    if (c >= CH_a && c <= CH_a + 5)
+        return c - CH_a + 10;
+    return -1;
+}
+function c1LeadLen(s, i, code) {
+    if (s.charCodeAt(i) === code)
+        return 1;
+    if (s.charCodeAt(i) !== CH_BACKSLASH || s.charCodeAt(i + 1) !== CH_u)
+        return 0;
+    let v = 0;
+    for (let k = i + 2; k < i + 6; k++) {
+        const d = hexDigitValue(s.charCodeAt(k));
+        if (d < 0)
+            return 0;
+        v = v * 16 + d;
+    }
+    return v === code ? 6 : 0;
+}
+const CSI_PARAM_RUN = /[0-?]*/y;
+const INTERMEDIATE_RUN = /[ -/]*/y;
+function skipClassRun(re, s, p) {
+    if (p >= s.length)
+        return p;
+    re.lastIndex = p;
+    return re.exec(s) === null ? p : re.lastIndex;
+}
+function scanIntermediateChain(s, p, termLo, termHi, mark) {
+    const n = s.length;
+    for (;;) {
+        p = skipClassRun(INTERMEDIATE_RUN, s, p);
+        if (p >= n)
+            return p;
+        const c = s.charCodeAt(p);
+        if (c >= termLo && c <= termHi)
+            mark(p + 1);
+        if (c !== CH_BACKSLASH)
+            return p;
+        let k = p;
+        while (k < n && s.charCodeAt(k) === CH_BACKSLASH)
+            k += 1;
+        if (k >= n || s.charCodeAt(k) !== CH_QUOTE)
+            return p;
+        p = k + 1;
+    }
+}
+const ESCAPED_SEPARATOR_UNITS = [
+    {
+        leads: ["\\b", "\\f", "\\n", "\\r", "\\t", "\\u"],
+        scan: (s, i, mark) => {
+            if (s.charCodeAt(i) !== CH_BACKSLASH)
+                return i;
+            const c = s.charCodeAt(i + 1);
+            if (c === CH_b || c === CH_f || c === CH_n || c === CH_r || c === CH_t)
+                mark(i + 2);
+            else if (c === CH_u && hexDigitValue(s.charCodeAt(i + 2)) >= 0 && hexDigitValue(s.charCodeAt(i + 3)) >= 0
+                && hexDigitValue(s.charCodeAt(i + 4)) >= 0 && hexDigitValue(s.charCodeAt(i + 5)) >= 0)
+                mark(i + 6);
+            return i;
+        },
+    },
+    {
+        leads: [ESC_CHAR, CSI8_CHAR, "\\u"],
+        scan: (s, i, mark) => {
+            const esc = c1LeadLen(s, i, CH_ESC);
+            let p;
+            if (esc > 0) {
+                if (s.charCodeAt(i + esc) !== CH_LBRACKET)
+                    return i;
+                p = i + esc + 1;
+            }
+            else {
+                const csi8 = c1LeadLen(s, i, CH_CSI8);
+                if (csi8 === 0)
+                    return i;
+                p = i + csi8;
+            }
+            return scanIntermediateChain(s, skipClassRun(CSI_PARAM_RUN, s, p), CH_AT, CH_TILDE, mark);
+        },
+    },
+    {
+        leads: [ESC_CHAR, "\\u"],
+        scan: (s, i, mark) => {
+            const esc = c1LeadLen(s, i, CH_ESC);
+            return esc === 0 ? i : scanIntermediateChain(s, i + esc, CH_0, CH_TILDE, mark);
+        },
+    },
+];
+const ESCAPED_SEPARATOR_NEEDLES = [...new Set(ESCAPED_SEPARATOR_UNITS.flatMap((u) => u.leads))];
+const NEEDLE_FIRST_CHARS = [...new Set(ESCAPED_SEPARATOR_NEEDLES.map((n) => n.slice(0, 1)))];
+const RUN_SKIPPABLE_BYTES = (() => {
+    const table = new Uint8Array(256);
+    for (const first of NEEDLE_FIRST_CHARS) {
+        const code = first.charCodeAt(0);
+        if (code >= table.length)
+            continue;
+        const single = ESCAPED_SEPARATOR_NEEDLES.some((n) => n.length === 1 && n.charCodeAt(0) === code);
+        const selfPair = ESCAPED_SEPARATOR_NEEDLES.some((n) => n.length > 1 && n.charCodeAt(0) === code && n.charCodeAt(1) === code);
+        if (!single && !selfPair)
+            table[code] = 1;
+    }
+    return table;
+})();
+function markEscapedSeparatorTails(s) {
+    const any = anyValueArmRe();
+    let ends;
+    let ascending = true;
+    const mark = (end) => {
+        if (end > s.length)
+            return;
+        const tail = s.charCodeAt(end - 1);
+        if (tail < WORD_INTERIOR_BYTES.length && WORD_INTERIOR_BYTES[tail] !== 1)
+            return;
+        any.lastIndex = end;
+        if (any.exec(s) === null)
+            return;
+        if (ends === undefined)
+            ends = [end];
+        else {
+            if (end < ends[ends.length - 1])
+                ascending = false;
+            ends.push(end);
+        }
+    };
+    const nextAt = new Array(NEEDLE_FIRST_CHARS.length).fill(-1);
+    const nextLead = (from) => {
+        let best = Number.POSITIVE_INFINITY;
+        for (let k = 0; k < NEEDLE_FIRST_CHARS.length; k++) {
+            if (nextAt[k] < from) {
+                const hit = s.indexOf(NEEDLE_FIRST_CHARS[k], from);
+                nextAt[k] = hit === -1 ? Number.POSITIVE_INFINITY : hit;
+            }
+            if (nextAt[k] < best)
+                best = nextAt[k];
+        }
+        return best === Number.POSITIVE_INFINITY ? -1 : best;
+    };
+    const n = s.length;
+    for (let i = nextLead(0); i >= 0;) {
+        let resume = i;
+        for (const unit of ESCAPED_SEPARATOR_UNITS) {
+            const consumed = unit.scan(s, i, mark);
+            if (consumed > resume)
+                resume = consumed;
+        }
+        if (resume === i) {
+            const code = s.charCodeAt(i);
+            if (code < RUN_SKIPPABLE_BYTES.length && RUN_SKIPPABLE_BYTES[code] === 1) {
+                let j = i + 1;
+                while (j < n && s.charCodeAt(j) === code)
+                    j += 1;
+                if (j > i + 1)
+                    resume = j - 1;
+            }
+        }
+        i = nextLead(resume > i ? resume : i + 1);
+    }
+    if (ends === undefined)
+        return undefined;
+    if (!ascending)
+        ends.sort((x, y) => x - y);
+    return ends;
+}
+let escapedTailsText;
+let escapedTailsValue;
+function escapedSeparatorTails(s) {
+    if (escapedTailsText !== s) {
+        escapedTailsValue = markEscapedSeparatorTails(s);
+        escapedTailsText = s;
+    }
+    return escapedTailsValue;
+}
+function forgetEscapedSeparatorTails() {
+    escapedTailsText = undefined;
+    escapedTailsValue = undefined;
+}
+const VALUE_ARM_STICKY = new Map();
+const VALUE_ARM_BODIES = [];
+const valueArm = (prefixSrc, valueClass, min) => {
+    const body = `${prefixSrc}${twoStrongAhead(valueClass)}${atLeast(valueClass, min)}`;
+    const g = new RegExp(`(?<!${WORD_INTERIOR_CLASS})${body}`, "g");
+    VALUE_ARM_STICKY.set(g, new RegExp(body, "y"));
+    VALUE_ARM_BODIES.push(body);
+    return g;
+};
+let anyValueArm;
+function anyValueArmRe() {
+    return (anyValueArm ??= new RegExp(`(?:${VALUE_ARM_BODIES.join("|")})`, "y"));
+}
+function runValueArm(g, y, repl, text, wantCount) {
+    const tails = escapedSeparatorTails(text);
+    if (tails === undefined) {
+        if (!wantCount)
+            return { out: text.replace(g, repl), count: 0 };
+        let hits = 0;
+        const replaced = text.replace(g, () => {
+            hits += 1;
+            return repl;
+        });
+        return { out: replaced, count: hits };
+    }
+    let out;
+    let copied = 0;
+    let count = 0;
+    let pos = 0;
+    let ti = 0;
+    let bIdx = -1;
+    let bEnd = -1;
+    const nextB = (from) => {
+        while (ti < tails.length) {
+            const p = tails[ti];
+            ti += 1;
+            if (p < from)
+                continue;
+            y.lastIndex = p;
+            const m = y.exec(text);
+            if (m !== null) {
+                bIdx = p;
+                bEnd = p + m[0].length;
+                return;
+            }
+        }
+        bIdx = -1;
+    };
+    nextB(0);
+    g.lastIndex = 0;
+    let a = g.exec(text);
+    for (;;) {
+        if (a !== null && a.index < pos) {
+            g.lastIndex = pos;
+            a = g.exec(text);
+        }
+        if (bIdx >= 0 && bIdx < pos)
+            nextB(pos);
+        let idx;
+        let end;
+        if (a !== null && (bIdx < 0 || a.index <= bIdx)) {
+            idx = a.index;
+            end = a.index + a[0].length;
+        }
+        else if (bIdx >= 0) {
+            idx = bIdx;
+            end = bEnd;
+        }
+        else
+            break;
+        (out ??= []).push(text.slice(copied, idx), repl);
+        copied = end;
+        count += 1;
+        pos = end;
+    }
+    if (out === undefined)
+        return { out: text, count: 0 };
+    out.push(text.slice(copied));
+    return { out: out.join(""), count };
+}
 const WORD_SEGMENT_CLASS = "[A-Za-z0-9._~+/-]";
-const keywordArm = (keywordSrc, valueClass, min, tailSrc = "") => new RegExp(`(?:${keywordSrc}\\s+${valueClass}{${min},}${tailSrc}` +
-    `|(?<!${WORD_SEGMENT_CLASS})${keywordSrc}(?:${twoStrongAhead(valueClass)}|${noConnectorAhead(valueClass)})${valueClass}{${min},}${tailSrc})`, "g");
+const keywordArm = (keywordSrc, valueClass, min, tailSrc = "") => new RegExp(`(?:${keywordSrc}\\s+${atLeast(valueClass, min)}${tailSrc}` +
+    `|(?<!${WORD_SEGMENT_CLASS})${keywordSrc}(?:${twoStrongAhead(valueClass)}|${noConnectorAhead(valueClass)})${atLeast(valueClass, min)}${tailSrc})`, "g");
 const STRUCTURAL_SECRET_PATTERNS = [
     [/-----BEGIN(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----[\s\S]{0,8192}?-----END(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----/g, "«redacted:private-key»"],
     [/---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----[\s\S]{0,8192}?---- END SSH2 ENCRYPTED PRIVATE KEY ----/g, "«redacted:private-key»"],
@@ -26,22 +304,17 @@ const KEYWORD_SECRET_PATTERNS = [
 ];
 const SHAPE_SECRET_PATTERNS = [
     [valueArm("sk-", "[A-Za-z0-9_-]", 16), "«redacted:key»"],
-    [/(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g, "«redacted:gh-token»"],
-    [/github_pat_[A-Za-z0-9]{22}_[A-Za-z0-9]{59,}/g, "«redacted:gh-token»"],
-    [/xox[baprs]-[A-Za-z0-9-]{10,}/g, "«redacted:slack-token»"],
-    [/AKIA[0-9A-Z]{16,}/g, "«redacted:aws-key»"],
-    [/ASIA[0-9A-Z]{16,}/g, "«redacted:aws-key»"],
-    [/(?:gl(?:pat|dt|rt|rtr|cbt|ptt|oas|ft|imt|agent|wt|soat|ffct)-[A-Za-z0-9_-]{20,}|(?:sk|rk)_(?:live|test|org)_[A-Za-z0-9]{24,}|pypi-[A-Za-z0-9_-]{85,})/g, "«redacted:key»"],
-    [/xapp-\d-[A-Za-z0-9-]{20,}/g, "«redacted:slack-token»"],
+    [new RegExp(String.raw `(?:ghp|gho|ghu|ghs|ghr)_${atLeast("[A-Za-z0-9]", 20)}`, "g"), "«redacted:gh-token»"],
+    [new RegExp(String.raw `github_pat_[A-Za-z0-9]{22}_${atLeast("[A-Za-z0-9]", 59)}`, "g"), "«redacted:gh-token»"],
+    [new RegExp(String.raw `xox[baprs]-${atLeast("[A-Za-z0-9-]", 10)}`, "g"), "«redacted:slack-token»"],
+    [new RegExp(String.raw `AKIA${atLeast("[0-9A-Z]", 16)}`, "g"), "«redacted:aws-key»"],
+    [new RegExp(String.raw `ASIA${atLeast("[0-9A-Z]", 16)}`, "g"), "«redacted:aws-key»"],
+    [new RegExp(String.raw `(?:gl(?:pat|dt|rt|rtr|cbt|ptt|oas|ft|imt|agent|wt|soat|ffct)-${atLeast("[A-Za-z0-9_-]", 20)}|(?:sk|rk)_(?:live|test|org)_${atLeast("[A-Za-z0-9]", 24)}|pypi-${atLeast("[A-Za-z0-9_-]", 85)})`, "g"), "«redacted:key»"],
+    [new RegExp(String.raw `xapp-\d-${atLeast("[A-Za-z0-9-]", 20)}`, "g"), "«redacted:slack-token»"],
 ];
 const FULL_SECRET_PATTERNS = [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS];
 const PEM_HEADER_IDENT_MAX = 31;
 const PEM_BODY_RUN_MIN = 8;
-const CH_TAB = 9, CH_LF = 10, CH_CR = 13, CH_SPACE = 32, CH_PLUS = 43, CH_MINUS = 45, CH_SLASH = 47;
-const CH_0 = 48, CH_9 = 57, CH_COLON = 58, CH_EQ = 61, CH_A = 65, CH_Z = 90, CH_BACKSLASH = 92, CH_UNDERSCORE = 95;
-const CH_a = 97, CH_n = 110, CH_r = 114, CH_t = 116, CH_z = 122;
-const CH_QUOTE = 34;
-const CH_LAQUO = 171;
 const isSepCode = (c) => c === CH_SPACE || c === CH_TAB || c === CH_CR || c === CH_LF;
 const isBase64Code = (c) => (c >= CH_A && c <= CH_Z) || (c >= CH_a && c <= CH_z) || (c >= CH_0 && c <= CH_9) || c === CH_PLUS || c === CH_SLASH || c === CH_EQ;
 const isIdentStartCode = (c) => (c >= CH_A && c <= CH_Z) || (c >= CH_a && c <= CH_z);
@@ -417,7 +690,7 @@ function redactHeadlessPpkBodies(text) {
 const FRAGMENT_SECRET_PATTERNS = [
     [valueArm("sk-", "[A-Za-z0-9_-]", 6), "«redacted:key:partial»"],
     [valueArm("(?:ghp|gho|ghu|ghs|ghr)_", "[A-Za-z0-9]", 8), "«redacted:gh-token:partial»"],
-    [/github_pat_[A-Za-z0-9_]{8,}/g, "«redacted:gh-token:partial»"],
+    [new RegExp(String.raw `github_pat_${atLeast("[A-Za-z0-9_]", 8)}`, "g"), "«redacted:gh-token:partial»"],
     [valueArm("xox[baprs]-", "[A-Za-z0-9-]", 4), "«redacted:slack-token:partial»"],
     [valueArm("AKIA", "[0-9A-Z]", 6), "«redacted:aws-key:partial»"],
     [valueArm("ASIA", "[0-9A-Z]", 8), "«redacted:aws-key:partial»"],
@@ -450,10 +723,15 @@ const regexRule = ([re, repl], arm) => {
             throw new Error(`redact: replacement ${JSON.stringify(repl)} uses unsupported ref $${d}`);
     }
     const expand = refs.length === 0 ? undefined : (args) => repl.replace(/\$([1-9])/g, (_, d) => args[Number(d)] ?? "");
+    const sticky = VALUE_ARM_STICKY.get(re);
+    if (sticky !== undefined && refs.length > 0)
+        throw new Error(`redact: value arm replacement ${JSON.stringify(repl)} must not use $N refs`);
     return {
         label: labelOfToken(repl),
         arm,
         run: (text, wantCount, json) => {
+            if (sticky !== undefined)
+                return runValueArm(re, sticky, repl, text, wantCount);
             const rx = re;
             if (!wantCount)
                 return { out: text.replace(rx, repl), count: 0 };
@@ -700,6 +978,7 @@ export function redactSecrets(text, opts) {
     const wantCount = onRedaction !== undefined && (opts?.observe ?? true);
     const json = opts?.json === true;
     const r = applyRules(normalizeForRedaction(text), wantCount, json, opts?.observe ?? true);
+    forgetEscapedSeparatorTails();
     reportHits(r.hits);
     return r.out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.73.1",
+  "version": "7.75.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",
@@ -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": "7.16.0",
+    "@sema-agent/core": "7.17.2",
     "@sema-agent/settings-schema": "1.10.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
@@ -69,7 +69,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "9.1.0",
+    "@sema-agent/sdk": "9.2.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",