@sema-agent/server 7.76.2 → 7.78.0

package/dist/trace/model-segment.js

@@ -0,0 +1,58 @@
+import { reasoningEndEventData } from "./project.js";
+const BOUNDARY = new Set([
+    "tool_start", "tool_end", "status", "context_usage", "compacted", "diagnostics",
+    "steering_injected", "compaction_outcome", "workspace_changed", "wiring_manifest",
+    "tool_roster_delta", "human_input", "task_notification", "turn_end", "tool_disclosure",
+]);
+export function isModelSegmentBoundary(type) {
+    return BOUNDARY.has(type);
+}
+export function reasoningStreamOfTask(...ids) {
+    const set = new Set(ids.filter((v) => typeof v === "string" && v !== ""));
+    return (ident) => (ident.sourceTaskId !== undefined && set.has(ident.sourceTaskId)) || (ident.bgAgentId !== undefined && set.has(ident.bgAgentId));
+}
+function streamKeyOf(ident) {
+    return `${ident.parentToolCallId ?? ""}\u0000${ident.sourceTaskId ?? ""}\u0000${ident.bgAgentId ?? ""}`;
+}
+function identOf(ev) {
+    const s = (v) => (typeof v === "string" ? v : undefined);
+    return { parentToolCallId: s(ev.parentToolCallId), sourceTaskId: s(ev.sourceTaskId), bgAgentId: s(ev.bgAgentId) };
+}
+export function createReasoningSegments() {
+    const open = new Map();
+    const cutKey = (key) => {
+        const seg = open.get(key);
+        if (seg === undefined)
+            return [];
+        open.delete(key);
+        const data = reasoningEndEventData({ ...seg.ident, eventId: seg.eventId, content: seg.buf });
+        return data === null ? [] : [{ type: "reasoning_end", ...data }];
+    };
+    return {
+        onEvent: (ev) => {
+            if (ev.type === "reasoning_delta") {
+                if (typeof ev.delta !== "string" || ev.delta === "")
+                    return [];
+                const ident = identOf(ev);
+                const key = streamKeyOf(ident);
+                const seg = open.get(key);
+                if (seg === undefined)
+                    open.set(key, { ident, eventId: ev.eventId, buf: ev.delta });
+                else
+                    seg.buf += ev.delta;
+                return [];
+            }
+            return isModelSegmentBoundary(ev.type ?? "") ? cutKey(streamKeyOf(identOf(ev))) : [];
+        },
+        cut: (match) => {
+            const out = [];
+            for (const [key, seg] of [...open]) {
+                if (match !== undefined && !match(seg.ident))
+                    continue;
+                out.push(...cutKey(key));
+            }
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=model-segment.js.map

package/dist/trace/project.d.ts

@@ -194,6 +194,23 @@ export declare function screenedStoredEventData(type: string, data: unknown): un
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
  *  身份四键零字节变换(live 现状带全四键,消费端可能已依赖)。 */
 export declare function textEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
+/**
+ * `reasoning_end` 段末帧的**唯一**铸点(三条 live 腿共用:top stream / 转发子代腿 / 子代 tail 面)——
+ * `text_end` 的推理面孪生({@link textEndEventData}),形逐字同(共用 {@link segmentEndFields})。
+ *
+ * 🔴 **本帧由 server 自铸,core 不发**(`TaskEvent` 上只有 `reasoning_delta`)。`content` = 该段
+ * `reasoning_delta` 的累积原文,经与 durable 面**同一只** `redactModelText` —— 这正是本帧存在的理由:
+ * 逐 chunk 的 `reasoning_delta` 对**跨 chunk** 的凭据形无能为力(半截 `sk-` 在任何一块里都不成形),
+ * 而账本腿攒到 flush 边界的那一整段早就脱得干净;live 面此前没有这份权威副本,壳无可替换。
+ * 段界与账本腿**同一只谓词**(`trace/model-segment.ts` 的 `isModelSegmentBoundary`),所以同一次运行里
+ * 「账本 `reasoning` 行」与本帧的正文逐字节相等。
+ *
+ * **空段不发**,判据比 `text_end` 宽一格(那边是 core 契约的「空段不发」,只需判空串):本帧的正文由
+ * 本仓攒出,一段**全空白**的思考(模型吐了几个换行就去调工具)没有可替换的权威正文,而消费律是
+ * 「整段替换已攒的 delta」—— 发一枚空白权威段 = 让消费端把已渲染的思考清成空白。坏形(`content` 非串)
+ * 同样丢帧,理由与 `text_end` 逐字同源。
+ */
+export declare function reasoningEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
 /** The durable `tool_end` payload (shared by both append sites). E1: the model-facing `output` is UNTRUSTED RAW
  *  from core (file/shell/API bodies) — core only SIZE-bounds it (`truncated`), REDACTION is ours (same contract as
  *  `tool_start.args`); never re-fed to a model. E2: identity. Absent `output` ⇒ the tool produced no content body.
@@ -219,6 +236,63 @@ export declare function toolEndEventData(ev: {
     eventId?: string;
     parentToolCallId?: string;
 }): Record<string, unknown>;
+/**
+ * `tool_progress` 的白名单投影(core 7.18.0 [ref])—— 一只**仍在跑**的工具调用的存活 tick。
+ *
+ * ## 这一帧只上 live,不落账(判据是 core 的契约,不是本仓的偏好)
+ * core `@contract tool_progress.ephemeral` 逐字:「LIVE ONLY, like `task_progress`/`status`: core never
+ * persists this frame (no session-tree entry, no checkpoint state, no resume replay)」。本仓对
+ * `task_progress` / `status` 正是同一处置(两条 durable 腿零 case),本帧照抄。
+ * 另一条 core 契约把「不落账」从偏好抬成正确性:`@contract tool_progress.cadence` 逐字「A call that
+ * finishes inside one interval emits NO frame at all」⇒ **帧的缺席从来不是证据**;落账会让回放面凭空
+ * 多出一份「这只调用跑了多久」的账,而那件事的真源是 `tool_end`(core 明写 `elapsedTimeSeconds`
+ * **不等于** `tool_end` 的 duration)。
+ *
+ * ## 信任划线
+ *  · `toolCallId` / `toolName` —— 引擎铸的 id 与名册里的工具名(与 `tool_start` 逐字同源)⇒ verbatim。
+ *  · `elapsedTimeSeconds` —— 引擎铸的整秒,单调、一 call 一个原点 ⇒ 有限数才铸键。
+ *  · `output` —— 🔴 **UNTRUSTED RAW**,core 逐字「exactly as `tool_end.output`: process output that may
+ *    carry secrets, paths or PII; core bounds only its SIZE, and a consumer MUST redact before persisting
+ *    or displaying it」⇒ 与 `tool_end.output` **同一只** `redactDeep`,一个字节的例外都不开。
+ *  · `totalLines` / `totalBytes` —— 引擎计数;core 的缺席律逐字:三者**同进同退**(在场=「观察到了输出」,
+ *    缺席=「一个字节都没观察到」,**从不是**「与上一帧相比没变」)。所以本投影按 `output` 的在场判三者:
+ *    `output` 读不出 ⇒ 三键一起缺席,不单独留下两个计数(那会把「没输出」谎报成「有输出但读不出」)。
+ */
+export declare function toolProgressEventData(ev: {
+    toolCallId?: unknown;
+    toolName?: unknown;
+    elapsedTimeSeconds?: unknown;
+    output?: unknown;
+    totalLines?: unknown;
+    totalBytes?: unknown;
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+}): Record<string, unknown> | undefined;
+/**
+ * `tool_disclosure` 的白名单投影(core 7.18.0 [ref])—— 本条腿的**延迟工具普查**:哪些挂载的工具今天只是
+ * 名字占位、模型已经激活了哪些、以及是哪条策略判的。
+ *
+ * ## 三腿对称(与 `tool_roster_delta` 同判、同理由)
+ * 开腿那一刻的快照住在 `wiring_manifest` 之后的**第一帧**,而**之后每一次激活**只活在本帧上。不落账 ⇒
+ * 断线重连 / 后台跑完再回来的耐久面永远停在开腿版本,而壳正是据它判「这只工具现在还是不是占位名」。
+ * 本帧是**整只快照**语义(`deferred` / `activated` 全量,消费端整只替换),所以回放不需要合并。
+ *
+ * ## 缺席语义(core 逐字,别读错)
+ *  · **整帧缺席** = 「这条腿什么都没延迟」,**不是**「这个 build 没有这个面」、也不是「未知」;
+ *  · `thresholdPercent` 缺席 = `always` / `never` 两档下**根本没查过阈值**,不许读成「取了默认百分比」;
+ *  · 一条 resume 腿的**首帧** `activated` 可能非空(引擎重播的),**不许**读成「这条腿激活了它们」。
+ *
+ * 成员全是闭形值(策略闭词 + 数字 + 名册里的工具名)⇒ 零脱敏,与 `tool_roster_delta` 的名册行同待遇。
+ * `policy` **不在本仓枚举**(闭集词表属主在 core;抄一份会把 core 加的新词吞成缺席)。
+ */
+export declare function toolDisclosureEventData(ev: {
+    policy?: unknown;
+    thresholdPercent?: unknown;
+    deferred?: unknown;
+    activated?: unknown;
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+}): Record<string, unknown> | undefined;
 /** The `task_progress` payload (a subagent's live progress tick) — EXPLICIT WHITELIST shared by all
  *  three legs (bg runs.ts + resume append + the sync live SSE frame): taskId/parent linkage/token rollup verbatim,
  *  `name` UNTRUSTED (core sanitizes for rendering, does NOT secret-redact — a taskName can be secret-shaped) →
@@ -662,6 +736,7 @@ export declare function contextUsageEventData(ev: {
     usedTokens?: unknown;
     windowTokens?: unknown;
     compactAtTokens?: unknown;
+    sections?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): Record<string, unknown>;

package/dist/trace/project.js

@@ -110,8 +110,12 @@ function screenedGateOrThrow(v) {
         recordFailOpen("server.trace.gate-outcome-defective", "disposition is not one of the two arms");
         return undefined;
     }
+    const classifierFallbackRaw = d.classifier !== null && typeof d.classifier === "object" ? d.classifier.fallback : undefined;
     const shapeDefect = (d.kind === "denied" && typeof d.deniedBy !== "string" && "disposition.deniedBy is not a string") ||
         (d.kind === "denied" && d.cause !== undefined && typeof d.cause !== "string" && "disposition.cause is not a string") ||
+        (d.classifier !== undefined && (d.classifier === null || typeof d.classifier !== "object") && "disposition.classifier is not an object") ||
+        (classifierFallbackRaw !== undefined && (classifierFallbackRaw === null || typeof classifierFallbackRaw !== "object") && "disposition.classifier.fallback is not an object") ||
+        (classifierFallbackRaw !== undefined && classifierFallbackRaw !== null && typeof classifierFallbackRaw === "object" && typeof classifierFallbackRaw.cause !== "string" && "disposition.classifier.fallback.cause is not a string") ||
         (g.settlement !== undefined && (g.settlement === null || typeof g.settlement !== "object") && "settlement is not an object") ||
         (g.settlement !== undefined && g.settlement !== null && typeof g.settlement.kind !== "string" && "settlement.kind is not a string") ||
         (g.origin !== undefined && typeof g.origin !== "string" && "origin is not a string") ||
@@ -125,6 +129,16 @@ function screenedGateOrThrow(v) {
         recordFailOpen("server.trace.gate-outcome-defective", defects.join("; "));
         return undefined;
     }
+    const attribution = d.classifier;
+    const classifier = attribution === undefined
+        ? undefined
+        : {
+            modelRequested: attribution.modelRequested,
+            modelUsed: attribution.modelUsed,
+            ...(attribution.fallback === undefined
+                ? {}
+                : { fallback: { from: attribution.fallback.from, to: attribution.fallback.to, cause: attribution.fallback.cause } }),
+        };
     const settlement = g.settlement === undefined ? undefined : projectSettlement(g.settlement);
     if (g.settlement !== undefined && settlement === undefined) {
         recordFailOpen("server.trace.gate-outcome-defective", "settlement.who is not an object with a party in the closed set");
@@ -132,8 +146,8 @@ function screenedGateOrThrow(v) {
     }
     return {
         disposition: d.kind === "denied"
-            ? { kind: "denied", deniedBy: d.deniedBy, ...(d.cause === undefined ? {} : { cause: d.cause }) }
-            : { kind: "allowed" },
+            ? { kind: "denied", deniedBy: d.deniedBy, ...(d.cause === undefined ? {} : { cause: d.cause }), ...(classifier === undefined ? {} : { classifier }) }
+            : { kind: "allowed", ...(classifier === undefined ? {} : { classifier }) },
         ...(settlement === undefined ? {} : { settlement }),
         ...(g.origin === undefined ? {} : { origin: g.origin }),
     };
@@ -176,14 +190,22 @@ function projectSettlement(st) {
 export function textEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.length === 0)
         return null;
+    return segmentEndFields(ev.content, ev);
+}
+function segmentEndFields(content, ev) {
     return {
-        content: redactModelText(ev.content),
+        content: redactModelText(content),
         ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
         ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
         ...(ev.sourceTaskId !== undefined ? { sourceTaskId: ev.sourceTaskId } : {}),
         ...(ev.bgAgentId !== undefined ? { bgAgentId: ev.bgAgentId } : {}),
     };
 }
+export function reasoningEndEventData(ev) {
+    if (typeof ev.content !== "string" || ev.content.trim().length === 0)
+        return null;
+    return segmentEndFields(ev.content, ev);
+}
 export function toolEndEventData(ev) {
     const gate = ev.gate === undefined ? undefined : screenedGate(ev.gate);
     return {
@@ -202,6 +224,43 @@ export function toolEndEventData(ev) {
         ...identityFields(ev),
     };
 }
+const dropProjectedFace = (what) => {
+    recordFailOpen("server.trace.projection-input-malformed", what);
+    return undefined;
+};
+export function toolProgressEventData(ev) {
+    const id = typeof ev.toolCallId === "string" && ev.toolCallId !== "" ? ev.toolCallId : undefined;
+    const name = typeof ev.toolName === "string" && ev.toolName !== "" ? ev.toolName : undefined;
+    if (id === undefined || name === undefined)
+        return dropProjectedFace("tool_progress is missing toolCallId/toolName");
+    const n = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
+    const hasOutput = typeof ev.output === "string";
+    return {
+        toolCallId: id,
+        toolName: name,
+        ...(n(ev.elapsedTimeSeconds) !== undefined ? { elapsedTimeSeconds: n(ev.elapsedTimeSeconds) } : {}),
+        ...(hasOutput ? { output: redactDeep(ev.output) } : {}),
+        ...(hasOutput && n(ev.totalLines) !== undefined ? { totalLines: n(ev.totalLines) } : {}),
+        ...(hasOutput && n(ev.totalBytes) !== undefined ? { totalBytes: n(ev.totalBytes) } : {}),
+        ...identityFields(ev),
+    };
+}
+export function toolDisclosureEventData(ev) {
+    const policy = typeof ev.policy === "string" && ev.policy !== "" ? ev.policy : undefined;
+    const names = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : undefined);
+    const deferred = names(ev.deferred);
+    const activated = names(ev.activated);
+    if (policy === undefined || deferred === undefined || activated === undefined)
+        return dropProjectedFace("tool_disclosure is missing policy/deferred/activated");
+    const threshold = typeof ev.thresholdPercent === "number" && Number.isFinite(ev.thresholdPercent) ? ev.thresholdPercent : undefined;
+    return {
+        policy,
+        ...(threshold !== undefined ? { thresholdPercent: threshold } : {}),
+        deferred,
+        activated,
+        ...identityFields(ev),
+    };
+}
 export function taskProgressEventData(ev) {
     return {
         taskId: ev.taskId,
@@ -382,6 +441,41 @@ export function wiringManifestEventData(ev) {
     })();
     const toolsIn = m.tools;
     const tools = toolsIn === undefined ? undefined : Value.Check(ToolRoster, toolsIn) ? toolsIn : (recordFailOpen("server.trace.tool-roster-malformed", "wiring_manifest.tools did not fit core ToolRoster"), undefined);
+    const hooksIn = m.hooks;
+    const hooks = (() => {
+        if (hooksIn === undefined)
+            return undefined;
+        if (!Array.isArray(hooksIn))
+            return dropProjectedFace("wiring_manifest.hooks is not an array");
+        const rows = [];
+        for (const raw of hooksIn) {
+            const e = sec(raw);
+            if (e === undefined) {
+                dropProjectedFace("wiring_manifest.hooks[] row is not an object");
+                continue;
+            }
+            const family = str(e.family);
+            const owner = str(e.owner);
+            if (family === undefined || owner === undefined) {
+                dropProjectedFace("wiring_manifest.hooks[] row is missing family/owner");
+                continue;
+            }
+            rows.push({ family, owner, ...(e.observational === true ? { observational: true } : {}) });
+        }
+        return rows.length > 0 ? rows : undefined;
+    })();
+    const lspIn = sec(m.lsp);
+    const lsp = (() => {
+        if (m.lsp === undefined)
+            return undefined;
+        if (lspIn === undefined)
+            return dropProjectedFace("wiring_manifest.lsp is not an object");
+        const mounted = bool(lspIn.mounted);
+        if (mounted === undefined)
+            return dropProjectedFace("wiring_manifest.lsp.mounted is not a boolean");
+        const lane = str(lspIn.lane);
+        return { mounted, ...(lane === undefined ? {} : { lane }) };
+    })();
     const mcpIn = m.mcp;
     const mcp = (() => {
         if (!Array.isArray(mcpIn))
@@ -422,6 +516,8 @@ export function wiringManifestEventData(ev) {
         ...(autoMode !== undefined ? { autoMode } : {}),
         ...(tools !== undefined ? { tools } : {}),
         ...(mcp !== undefined ? { mcp } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
+        ...(lsp !== undefined ? { lsp } : {}),
         ...identityFields(ev),
     };
 }
@@ -527,9 +623,32 @@ 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) } : {}),
+        ...contextUsageSectionsField(ev.sections),
         ...identityFields(ev),
     };
 }
+function contextUsageSectionsField(sections) {
+    if (sections === undefined)
+        return {};
+    if (!Array.isArray(sections)) {
+        dropProjectedFace("context_usage.sections is not an array");
+        return {};
+    }
+    const out = [];
+    for (const raw of sections) {
+        if (typeof raw !== "object" || raw === null) {
+            dropProjectedFace("context_usage.sections[] element is not an object");
+            continue;
+        }
+        const { id, tokens, kind } = raw;
+        if (typeof id !== "string" || id === "" || typeof tokens !== "number" || !Number.isFinite(tokens)) {
+            dropProjectedFace("context_usage.sections[] element is missing id/tokens");
+            continue;
+        }
+        out.push({ id, tokens, ...(typeof kind === "string" && kind !== "" ? { kind } : {}) });
+    }
+    return out.length > 0 ? { sections: out } : {};
+}
 export function turnEndEventData(ev) {
     return {
         ...(ev.usage ? { usage: ev.usage } : {}),
@@ -703,6 +822,7 @@ function mapTraceEventInner(type, seq, data) {
         case "wiring_manifest":
         case "human_input":
         case "tool_roster_delta":
+        case "tool_disclosure":
             return null;
         default:
             return null;

package/dist/trace/redact.js

@@ -233,12 +233,150 @@ let anyValueArm;
 function anyValueArmRe() {
     return (anyValueArm ??= new RegExp(`(?:${VALUE_ARM_BODIES.join("|")})`, "y"));
 }
-function collectRegexSpans(g, repl, order, text, out) {
+const HEAD_CLASS_ESCAPES = new Set(["d", "D", "w", "W", "s", "S"]);
+const HEAD_LITERAL_ESCAPES = new Set(["\\", "/", "-", ".", "+", "*", "?", "(", ")", "[", "]", "{", "}", "|", "^", "$"]);
+function headOfAtoms(atoms, src) {
+    const tail = atoms[atoms.length - 1];
+    if (tail === undefined || !tail.unbounded || tail.cls === undefined) {
+        throw new Error(`redact: arm-pool pattern /${src}/ must end in a greedy unbounded single-class value run`);
+    }
+    let pos = 0;
+    let head = 0;
+    for (let k = 0; k < atoms.length - 1; k++) {
+        const a = atoms[k];
+        if (a.cls !== tail.cls)
+            head = pos + a.len;
+        pos += a.len;
+    }
+    return head;
+}
+const HEAD_GROUP_OPEN = /^\((\?:|\?=|\?!|\?<=|\?<!)/;
+function parseHeadAlternative(src, from) {
+    let seqs = [[]];
+    let i = from;
+    let closed = false;
+    while (i < src.length) {
+        const c = src[i];
+        if (c === "|" || c === ")")
+            break;
+        if (closed)
+            throw new Error(`redact: arm-pool pattern /${src}/ has trailing syntax after its value run`);
+        let base;
+        if (c === "(") {
+            const open = HEAD_GROUP_OPEN.exec(src.slice(i));
+            if (open === null)
+                throw new Error(`redact: head derivation cannot bound group at ${i} in /${src}/`);
+            const mark = open[1];
+            const inner = parseHeadAlternatives(src, i + 1 + mark.length);
+            if (src[inner.next] !== ")")
+                throw new Error(`redact: unbalanced group at ${i} in /${src}/`);
+            i = inner.next + 1;
+            if (mark !== "?:")
+                continue;
+            if (inner.alts.some((alt) => alt.some((a) => a.unbounded))) {
+                seqs = inner.alts.flatMap((alt) => seqs.map((s) => [...s, ...alt]));
+                closed = true;
+                continue;
+            }
+            base = { len: Math.max(...inner.alts.map((alt) => alt.reduce((n, a) => n + a.len, 0))), cls: undefined };
+        }
+        else if (c === "[") {
+            let k = i + 1;
+            while (k < src.length && src[k] !== "]")
+                k += src[k] === "\\" ? 2 : 1;
+            if (k >= src.length)
+                throw new Error(`redact: unterminated character class at ${i} in /${src}/`);
+            base = { len: 1, cls: src.slice(i, k + 1) };
+            i = k + 1;
+        }
+        else if (c === "\\") {
+            const e = src[i + 1];
+            if (e === undefined)
+                throw new Error(`redact: dangling escape at ${i} in /${src}/`);
+            if (HEAD_CLASS_ESCAPES.has(e))
+                base = { len: 1, cls: `\\${e}` };
+            else if (HEAD_LITERAL_ESCAPES.has(e))
+                base = { len: 1, cls: undefined };
+            else
+                throw new Error(`redact: head derivation cannot bound escape \\${e} at ${i} in /${src}/`);
+            i += 2;
+        }
+        else if (c === "." || c === "^" || c === "$" || c === "*" || c === "+" || c === "?" || c === "{") {
+            throw new Error(`redact: head derivation cannot bound ${JSON.stringify(c)} at ${i} in /${src}/`);
+        }
+        else {
+            base = { len: 1, cls: undefined };
+            i += 1;
+        }
+        let atom = { ...base, unbounded: false };
+        const q = src[i];
+        if (q === "*" || q === "+") {
+            atom = { ...base, unbounded: true };
+            i += 1;
+        }
+        else if (q === "?") {
+            i += 1;
+        }
+        else if (q === "{") {
+            const m = /^\{(\d+)(,(\d*))?\}/.exec(src.slice(i));
+            if (m === null)
+                throw new Error(`redact: head derivation cannot bound quantifier at ${i} in /${src}/`);
+            const lo = Number(m[1]);
+            const hi = m[2] === undefined ? lo : m[3] === "" ? -1 : Number(m[3]);
+            atom = hi < 0 ? { ...base, unbounded: true } : { len: base.len * hi, cls: base.cls, unbounded: false };
+            i += m[0].length;
+        }
+        if (src[i] === "?")
+            throw new Error(`redact: head derivation cannot bound a lazy quantifier at ${i} in /${src}/`);
+        if (atom.unbounded)
+            closed = true;
+        for (const s of seqs)
+            s.push(atom);
+    }
+    return { seqs, next: i };
+}
+function parseHeadAlternatives(src, from) {
+    const alts = [];
+    let i = from;
+    for (;;) {
+        const one = parseHeadAlternative(src, i);
+        alts.push(...one.seqs);
+        i = one.next;
+        if (src[i] !== "|")
+            break;
+        i += 1;
+    }
+    return { alts, next: i };
+}
+function literalHeadLength(re) {
+    if (/[uv]/.test(re.flags))
+        throw new Error(`redact: head derivation does not support the u/v flags on /${re.source}/`);
+    const src = re.source;
+    const parsed = parseHeadAlternatives(src, 0);
+    if (parsed.next !== src.length)
+        throw new Error(`redact: head derivation stopped at ${parsed.next} in /${src}/`);
+    return Math.max(...parsed.alts.map((alt) => headOfAtoms(alt, src)));
+}
+function scanResumeAfterHit(start, end, head) {
+    return Math.max(start + 1, end - Math.max(head - 1, 0));
+}
+function headWindowCandidates(at, maxHead) {
+    const out = [];
+    let last = -1;
+    for (const e of at) {
+        for (let p = Math.max(e - Math.max(maxHead - 1, 0), last + 1, 0); p <= e; p++) {
+            out.push({ p, back: e - p });
+            last = p;
+        }
+    }
+    return out;
+}
+function collectRegexSpans(g, head, repl, order, text, out) {
     g.lastIndex = 0;
     for (let m = g.exec(text); m !== null; m = g.exec(text)) {
         const end = m.index + m[0].length;
         out.push({ start: m.index, end, repl, order });
-        g.lastIndex = end > m.index ? end : m.index + 1;
+        g.lastIndex = scanResumeAfterHit(m.index, end, head);
     }
 }
 function resolveSpanOverlaps(spans) {
@@ -265,10 +403,10 @@ function applySpans(text, spans) {
     parts.push(text.slice(copied));
     return { out: parts.join(""), count: spans.length };
 }
-function collectValueArmSpans(g, y, repl, order, text, out) {
+function collectValueArmSpans(g, y, head, repl, order, text, out) {
     const tails = escapedSeparatorTails(text);
     if (tails === undefined) {
-        collectRegexSpans(g, repl, order, text, out);
+        collectRegexSpans(g, head, repl, order, text, out);
         return;
     }
     let pos = 0;
@@ -314,12 +452,14 @@ function collectValueArmSpans(g, y, repl, order, text, out) {
         else
             break;
         out.push({ start: idx, end, repl, order });
-        pos = end;
+        pos = scanResumeAfterHit(idx, end, head);
     }
 }
-function collectStickySpans(y, repl, order, text, at, out) {
+function collectStickySpans(y, head, repl, order, text, at, out) {
     let pos = 0;
-    for (const p of at) {
+    for (const { p, back } of at) {
+        if (back >= head)
+            continue;
         if (p < pos)
             continue;
         y.lastIndex = p;
@@ -328,7 +468,7 @@ function collectStickySpans(y, repl, order, text, at, out) {
             continue;
         const end = p + m[0].length;
         out.push({ start: p, end, repl, order });
-        pos = end;
+        pos = scanResumeAfterHit(p, end, head);
     }
 }
 const WORD_SEGMENT_CLASS = "[A-Za-z0-9._~+/-]";
@@ -358,7 +498,7 @@ const SHAPE_SECRET_PATTERNS = [
     [new RegExp(String.raw `xapp-\d-${atLeast("[A-Za-z0-9-]", 20)}`, "g"), "«redacted:slack-token»"],
     [valueArm("sk-", "[A-Za-z0-9_-]", 16, "self-evident"), "«redacted:key»"],
 ];
-const FULL_SECRET_PATTERNS = [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS];
+const FULL_ARM_PATTERNS = [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS];
 const PEM_HEADER_IDENT_MAX = 31;
 const PEM_BODY_RUN_MIN = 8;
 const isSepCode = (c) => c === CH_SPACE || c === CH_TAB || c === CH_CR || c === CH_LF;
@@ -743,7 +883,7 @@ const FRAGMENT_SECRET_PATTERNS = [
     [valueArm("(?:gl(?:pat|dt|rt|rtr|cbt|ptt|oas|ft|imt|agent|wt|soat|ffct)-|(?:sk|rk)_(?:live|test|org)_|pypi-)", "[A-Za-z0-9_-]", 8, "needs-left-boundary"), "«redacted:key:partial»"],
     [valueArm("xapp-\\d-", "[A-Za-z0-9-]", 4, "needs-left-boundary"), "«redacted:slack-token:partial»"],
 ];
-const REDACTION_TOKENS = new Set([...FULL_SECRET_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
+const REDACTION_TOKENS = new Set([...FULL_ARM_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
     .flatMap((r) => r.match(/«[^»]*»/g) ?? []));
 const REDACTION_TOKEN_MAX = Math.max(...[...REDACTION_TOKENS].map((t) => t.length));
 {
@@ -802,9 +942,9 @@ const regexRule = ([re, repl]) => {
     return { run: (text, wantCount) => singleHit(label, arm, applyOnce(text, wantCount)) };
 };
 const URL_USERINFO_PATTERN = (() => {
-    const row = FULL_SECRET_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
+    const row = FULL_ARM_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
     if (row === undefined)
-        throw new Error("redact: URL-userinfo rule missing from FULL_SECRET_PATTERNS");
+        throw new Error("redact: URL-userinfo rule missing from FULL_ARM_PATTERNS");
     return row;
 })();
 const isRegexSpace = (c) => c === 32 || (c >= 9 && c <= 13) || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a) || c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;
@@ -1000,17 +1140,22 @@ const armPoolRule = (() => {
     const arms = [...SHAPE_SECRET_PATTERNS, ...FRAGMENT_SECRET_PATTERNS].map(([re, repl], order) => {
         if (/\$./.test(repl))
             throw new Error(`redact: arm-pool replacement ${JSON.stringify(repl)} must not use $N refs`);
-        return { g: re, y: VALUE_ARM_STICKY.get(re), repl, order };
+        const y = VALUE_ARM_STICKY.get(re);
+        const head = literalHeadLength(re);
+        if (y !== undefined && head === 0)
+            throw new Error(`redact: boundary arm /${re.source}/ has a zero-length structural head — the head-window screen would skip every candidate position`);
+        return { g: re, y, head, repl, order };
     });
-    const boundaryArms = arms.flatMap((a) => (a.y === undefined ? [] : [{ y: a.y, repl: a.repl, order: a.order }]));
+    const boundaryArms = arms.flatMap((a) => (a.y === undefined ? [] : [{ y: a.y, head: a.head, repl: a.repl, order: a.order }]));
+    const maxBoundaryHead = Math.max(1, ...boundaryArms.map((a) => a.head));
     return {
         run: (text, wantCount) => {
             const spans = [];
             for (const a of arms) {
                 if (a.y === undefined)
-                    collectRegexSpans(a.g, a.repl, a.order, text, spans);
+                    collectRegexSpans(a.g, a.head, a.repl, a.order, text, spans);
                 else
-                    collectValueArmSpans(a.g, a.y, a.repl, a.order, text, spans);
+                    collectValueArmSpans(a.g, a.y, a.head, a.repl, a.order, text, spans);
             }
             const tried = new Set();
             const freshEnds = (from) => {
@@ -1026,8 +1171,9 @@ const armPoolRule = (() => {
             };
             for (let at = freshEnds(0); at.length > 0;) {
                 const before = spans.length;
+                const cand = headWindowCandidates(at, maxBoundaryHead);
                 for (const a of boundaryArms)
-                    collectStickySpans(a.y, a.repl, a.order, text, at, spans);
+                    collectStickySpans(a.y, a.head, a.repl, a.order, text, cand, spans);
                 at = freshEnds(before);
             }
             const kept = resolveSpanOverlaps(spans);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.76.2",
+  "version": "7.78.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,8 +54,8 @@
     "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.17.7",
-    "@sema-agent/settings-schema": "1.10.0",
+    "@sema-agent/core": "7.18.0",
+    "@sema-agent/settings-schema": "2.1.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
     "mysql2": "^3.22.4",
@@ -69,7 +69,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "9.3.0",
+    "@sema-agent/sdk": "9.4.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",