@sema-agent/server 7.148.0 → 7.150.0

package/dist/trace/project.js

@@ -2,10 +2,12 @@ import { admitProviderEcho, redactErrorMessage, redactModelText } from "../obser
 import { isInputAuthor, isRunOrigin, MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
+import { errorText } from "../observability/err-text.js";
 import { redactSecrets, redactDeep } from "./redact.js";
 import { seatText } from "./exit-seat.js";
 import { sanitizeWireText } from "./engine-notice-wire.js";
-import { projectToolOutput, projectToolStructured } from "./tool-output-media.js";
+import { projectToolOutput } from "./tool-output-media.js";
+import { projectToolCard } from "./tool-card.js";
 import { injectionTierOrAbsent } from "./injection-tier.js";
 import { semaProvenanceFields } from "./sema-provenance.js";
 import { resupplyFields, sessionBoxCarrierFields, terminalFrameFacetFields } from "./task-notification-facets.js";
@@ -254,7 +256,7 @@ export function toolEndEventData(ev) {
         ...(ev.output !== undefined ? { output: projectToolOutput(ev.output) } : {}),
         ...(ev.truncated ? { truncated: true } : {}),
         ...(Number.isFinite(ev.totalChars) ? { totalChars: ev.totalChars } : {}),
-        ...(ev.structured !== undefined ? { structured: projectToolStructured(ev.structured, redactDeep) } : {}),
+        ...(ev.structured !== undefined ? { structured: projectToolCard(ev.structured, redactDeep) } : {}),
         ...(typeof ev.errorCode === "string" && ev.errorCode.length <= 128 ? { errorCode: ev.errorCode } : {}),
         ...(typeof ev.delivered === "string" && MCP_DELIVERY_VERDICTS.includes(ev.delivered) ? { delivered: ev.delivered } : {}),
         ...(gate !== undefined ? { gate } : {}),
@@ -328,20 +330,20 @@ export function parkEventData(result, reopened) {
     };
 }
 export async function appendParkRow(append, usage, word, result, reopened) {
-    let drainFailed = false;
-    let drainFailure;
     if (usage !== undefined) {
         try {
             await appendModelUsageDelta(append, usage.modelUsage, usage.taskId);
         }
         catch (e) {
-            drainFailed = true;
-            drainFailure = e;
+            recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-usage ${errorText(e)}`);
         }
     }
-    await append(word, parkEventData(result, reopened));
-    if (drainFailed)
-        throw drainFailure;
+    try {
+        await append(word, parkEventData(result, reopened));
+    }
+    catch (e) {
+        recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-row ${errorText(e)}`);
+    }
 }
 export function taskStartedEventData(ev) {
     return {

package/dist/trace/projection-table.d.ts

@@ -15,6 +15,7 @@
  * `nested` 不收各臂键不同的联合(`keyof` 只给交集,某一臂独有的键会悄悄没有处置),core 写成 `unknown` / `any` 的值只能 `strip`;
  * **一格只许一词** —— 类型上把其余词的键写成 `never`(展开也混不进第二个词),运行期再核一次,两词同在 ⇒ 响亮抛。
  * 投影函数是表的解释器 {@link projectByTable};`core-keyset-guard.ts` 读表({@link TableCoreKeys})—— 门与投影只有一个写者。
+ * 解释器的产物型也是表的函数({@link FaceOf}):表翻一格,出门型随之变,出口不另写产物型、不解构挑键。
  *
  * ## 三条读法(所有表同一条)
  *  · **缺席即缺席**:源值 `undefined` ⇒ 键缺席(不补 `[]` / `false` / 默认值);
@@ -91,10 +92,40 @@ export type TableCoreKeys<Tbl> = {
         readonly mint: unknown;
     } ? never : K;
 }[keyof Tbl];
+/** 表的一格在 core 型上的源值型(铸键不在 core 型上 ⇒ 没有源值)。 */
+type SourceOf<T, K> = K extends keyof T ? T[K] : never;
+/** 列表位的元素型。 */
+type RowOf<V> = NonNullable<V> extends readonly (infer E)[] ? E : never;
+/** 一格出门后的型 —— 与解释器 {@link projectNode} 逐臂同读(谓词臂在布尔读法臂之前:谓词也是布尔读法,它多说了值认成什么型)。 */
+type CellFace<V, E> = E extends "forward" ? Exclude<V, undefined> : E extends {
+    readonly mint: (...args: never[]) => infer X;
+} ? Exclude<X, undefined> : E extends {
+    readonly forward: (raw: unknown) => raw is infer G;
+} ? G : E extends {
+    readonly forward: unknown;
+} ? Exclude<V, undefined> : E extends {
+    readonly redact: unknown;
+} ? string : E extends {
+    readonly nested: infer Sub;
+    readonly rows: unknown;
+} ? FaceOf<RowOf<V>, Sub>[] : E extends {
+    readonly nested: infer Sub;
+} ? FaceOf<NonNullable<V>, Sub> : never;
+/**
+ * 一张表的**出门型** = 解释器 {@link projectByTable} 的产物型,逐格由处置词推出(表是唯一写者,型随表走):
+ *  · `"strip"` ⇒ 键不在型里;
+ *  · `"forward"` / `{ forward: 布尔读法 }` ⇒ 源值型去 `undefined`(解释器只把 `undefined` 读作缺席,`null` 原样出门);
+ *  · `{ forward: (raw) => raw is G }` ⇒ `G`(读法认的就是出门的型);
+ *  · `{ redact }` ⇒ `string`;`{ nested }` ⇒ 子表的出门型(写了 `rows` ⇒ 它的数组);`{ mint }` ⇒ 铸函数返回型去 `undefined`。
+ * 每个键都可选(缺席即缺席 / 在场却读不出 ⇒ 丢);不带表字面量的 `readonly`(产物是解释器新建的对象)。
+ */
+export type FaceOf<T, Tbl> = {
+    -readonly [K in keyof Tbl as Tbl[K] extends "strip" ? never : K]?: CellFace<SourceOf<T, K>, Tbl[K]>;
+};
 /**
  * 按表投影一个值。`face` = 计数 / 报错里的面名(`<面>.<键路径>`);`root` = 铸键与 `rows` 读到的根(面的顶层值)。
- * 纯数据进、纯数据出;不改入参。
+ * 纯数据进、纯数据出;不改入参。产物型 = {@link FaceOf}(本函数是表的唯一解释器,型的唯一断言在这里)。
  */
-export declare function projectByTable<T extends object, R>(face: string, table: CoreTable<T, R>, value: T, root: R): Record<string, unknown>;
+export declare function projectByTable<T extends object, R, Tbl extends CoreTable<T, R>>(face: string, table: Tbl, value: T, root: R): FaceOf<T, Tbl>;
 export {};
 //# sourceMappingURL=projection-table.d.ts.map

package/dist/trace/redact.d.ts

@@ -266,6 +266,18 @@ export declare function redactSecrets(text: string, opts?: {
     json?: boolean;
     before?: string;
 }): string;
+/**
+ * **一个孤立的标识符(目录条目名)本身是不是一枚凭据形** —— 与 {@link redactSecretsWithArms} 的强臂读法是**两个问题**:那一个问「这段自由文本里有没有一枚凭据」
+ * (规则素材闸:整条命令),这一个问「这个孤立的值**本身**是不是一枚凭据」。三条律,都不带一条自己的正则,读的是同一个候选池、同一张臂表:
+ *  ① **档 `"bounded-unit"`**([ref],{@link RedactionScope}):标识符不是自由文本,词法关键字臂出局 —— `tokenizer-model-2026-11-08` 里的 `token` 不是「令牌关键字 + 值」
+ *     (自由文本档对它的读数是 `token «redacted»`);值形臂〔前缀 + 值形 + 长度下限〕与结构锚臂留在档里;
+ *  ② **只认强证据臂**(`full` 档;弱证据残片臂是为兜上游截断过的残片而宁多脱的短前缀启发式,被判的是运维写的完整串,它们的前提不成立);
+ *  ③ **凭据形在串首**(**同一条**强认领起点 = 0 —— 串首是弱认领、强认领嵌在后面的不算,如 `ASIAPACIFIC1.mask-rcnn-…`):「名字**就是**一枚凭据」是把密钥误贴进名字位的形;名字里嵌着的 `sk-` + 长体(`mask-rcnn-resnet50-fpn-1x-coco` 里的 `sk-rcnn-…`,
+ *     脱敏器在自由文本里为真钥紧贴普通词字符也遮,宁多脱)不是 —— 拒收一个现实名字的代价(模型不可用)与多遮一截日志的代价不是一个量级。
+ * 只问不出门(`observe: false`,不计「已脱」读数)。实际判别力 = 「值段带已知凭据前缀」({@link unitCarriesCredential} 顶注的 🚧):没有前缀的高熵串不认 ——
+ * 是「认得出的凭据形不收」,不是「名字里不会有秘密」。读者:目录条目名的入口判据(`model-entry-refusal.ts`)。
+ */
+export declare function isCredentialShapedUnit(unit: string): boolean;
 /**
  * 脱敏 + **这一遍命中了哪些档位的臂**({@link RedactionArm} 闭集两词)—— 与 {@link redactSecrets} 同一只
  * 脱敏器、同一张表、同一遍扫描的另一个出口。

package/dist/trace/redact.js

@@ -4792,7 +4792,7 @@ function runRedaction(text, observe, json, wantHits, scope, layout, extent, obse
     if (observe)
         reportHits(observeFrom === 0 ? hits : hitsOfSpans(spans.filter((sp) => sp.end > observeFrom)));
     const groups = mergeRedactionSpans(cover, poolTie, joints);
-    return { text: renderRedactionSpans(text, groups, 0, text.length), hits, spans: groups, crossed: jointsCrossedBy(spans, joints), evidence, lattice, view: viewOpen };
+    return { text: renderRedactionSpans(text, groups, 0, text.length), hits, spans: groups, claims: spans, crossed: jointsCrossedBy(spans, joints), evidence, lattice, view: viewOpen };
 }
 function latticeOpenOf(n, rfold, normalized, open) {
     let at = n;
@@ -4842,6 +4842,10 @@ export function redactSecrets(text, opts) {
     const r = runRedaction(whole, opts?.observe ?? true, opts?.json === true, false, "free-text", "multi-line", WHOLE_EXTENT, before.length, [before.length]);
     return renderRedactionSpans(whole, r.spans, before.length, whole.length);
 }
+export function isCredentialShapedUnit(unit) {
+    const r = runRedaction(unit, false, false, true, "bounded-unit", "multi-line", WHOLE_EXTENT);
+    return r.claims.some((claim) => claim.start === 0 && claim.hit?.arm === "full");
+}
 export function redactSecretsWithArms(text, opts) {
     const r = runRedaction(text, opts?.observe ?? true, opts?.json === true, true, "free-text", "multi-line", WHOLE_EXTENT);
     return { text: r.text, arms: new Set(r.hits.map((h) => h.arm)) };