@sema-agent/server 7.147.0 → 7.148.0

package/dist/model-route-endpoint.js

@@ -31,21 +31,43 @@ export function judgeModelRouteEndpoint(view, leg) {
     }
     const routes = routeTableOf(view);
     const entries = Object.entries(view.models ?? {});
+    const laneUnmounted = [];
     const unresolved = [];
-    let laneCredentialMissing = false;
     for (const [name, m] of entries) {
         if (name === DEFAULT_MODEL_REF && entries.some(([k, other]) => k !== name && other === m))
             continue;
-        if (brainLaneFor(m.provider, routes) !== "gateway")
+        const lane = brainLaneFor(m.provider, routes);
+        if (catalogBrainLane(m.provider) !== lane) {
+            laneUnmounted.push(`"${name}"`);
+            continue;
+        }
+        if (lane !== "gateway")
             continue;
         if (openaiRouteBaseUrl(m.baseUrl, gateway) !== undefined)
             continue;
-        laneCredentialMissing ||= catalogBrainLane(m.provider) === "anthropic";
-        unresolved.push(unresolvedRouteLabel(name, m.provider));
+        unresolved.push(`"${name}"`);
+    }
+    const endpointMissing = unresolved.length > 0 ? routeEndpointMissingRefusal(unresolved, leg) : undefined;
+    if (laneUnmounted.length > 0) {
+        const reason = laneUnmountedRefusal(laneUnmounted, leg) + (endpointMissing !== undefined ? ` Also: ${endpointMissing}` : "");
+        return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: "lane_credential_missing", reason };
+    }
+    return endpointMissing === undefined ? undefined : { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: "endpoint_missing", reason: endpointMissing };
+}
+function laneUnmountedRefusal(quotedNames, leg) {
+    const one = quotedNames.length === 1;
+    const head = `${one ? `model ${quotedNames[0]} asks` : `models ${quotedNames.join(", ")} ask`} for the anthropic lane (provider "anthropic"), but no Anthropic route is mounted on this ` +
+        `deployment — ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN are both unset [${MODEL_ROUTE_ENDPOINT_MISSING_CODE}]. ${one ? "It is" : "They are"} not served rather than ` +
+        "handed to the openai-compatible gateway under an anthropic label (that lane would answer with its own key, its own wire format and its own cache accounting). ";
+    switch (leg) {
+        case "env":
+            return (head +
+                "Pick one way out: (1) set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN (plus ANTHROPIC_BASE_URL for a non-default endpoint); " +
+                "(2) set MODEL_PROVIDER=gateway (or vllm) to serve the env model on the openai-compatible gateway; " +
+                "(3) leave MODEL_ID unset and let the default entry of a catalog (config.d/models.json, or the web-admin) serve — a catalog in force replaces the env model table.");
+        case "catalog":
+            return head + `Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN in this service's env, or change ${one ? "the entry's" : "each named entry's"} provider to an OpenAI-compatible route ("gateway" / "vllm") with its own baseUrl.`;
     }
-    if (unresolved.length === 0)
-        return undefined;
-    return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: laneCredentialMissing ? "lane_credential_missing" : "endpoint_missing", reason: routeEndpointMissingRefusal(unresolved, leg) };
 }
 function routeEndpointMissingRefusal(quotedNames, leg) {
     const one = quotedNames.length === 1;

package/dist/model-select.d.ts

@@ -84,6 +84,22 @@ export declare function resolveTaskModel(bodyModel: unknown, objective: string,
     notAllowed?: ModelNotAllowed;
     unavailable?: ModelUnavailable;
 };
+/** 用户选择被判的那一份模型面(`ServiceConfig` 结构上满足):目录、档位绑定、不可用条目、本代 `atMention` —— 四件出自同一份配置。 */
+export interface UserModelPlane<M> {
+    readonly models: Record<string, M>;
+    readonly tiers: Record<string, string> | undefined;
+    readonly modelRefusals: Readonly<Record<string, ModelEntryRefusal>> | undefined;
+    readonly atMention: AtMention;
+}
+/**
+ * 🔴 **用户选择的唯一入口**(请求面 `body.model` / `settings.model`、objective 内联 `@name`,每一条提交腿同调):在**可选目录**({@link selectableCatalog})上解析、
+ * 用本代 `atMention` 判许可({@link resolveTaskModel} → {@link isAtMentionable})。可选目录随结果交回(调用方其余显式选择通道 —— `compactionModel` /
+ * `agents[].model` / 未知模型拒体的 `available` —— 判的是同一张,不另铸)。哪张目录、哪份许可只在这里取,任何一条腿都没有「取契约缺省」的第二读法。
+ */
+export declare function pickUserModel<M>(plane: UserModelPlane<M>, bodyModel: unknown, objective: string): {
+    selectable: Record<string, M>;
+    picked: ReturnType<typeof resolveTaskModel>;
+};
 /**
  * [ref] 判别式拒因:这次**用户选择**点中的是一条已发布、但本部署不可用的目录条目(`config.modelRefusals`)。
  * 与 {@link ModelNotAllowed} 同一种处置口:本函数不 throw,调用点按 leg 分流(fresh 400 `request.model_unavailable` /

package/dist/model-select.js

@@ -57,6 +57,10 @@ export function resolveTaskModel(bodyModel, objective, catalog, atMention, refus
         ...(unavailable ? { unavailable } : {}),
     };
 }
+export function pickUserModel(plane, bodyModel, objective) {
+    const selectable = selectableCatalog(plane.models, plane.tiers, plane.modelRefusals);
+    return { selectable, picked: resolveTaskModel(bodyModel, objective, selectable, plane.atMention, plane.modelRefusals) };
+}
 export function selectableCatalog(models, tiers, refusals) {
     const expanded = (expandTiers(models, tiers ?? {}) ?? models);
     const reserved = Object.keys(refusals ?? {}).filter((n) => Object.hasOwn(expanded, n) && !Object.hasOwn(models, n));

package/dist/mountinfo.d.ts

@@ -0,0 +1,37 @@
+/** mountinfo 的一行里两位消费者要的几格。 */
+export interface MountRow {
+    readonly id: string;
+    readonly parent: string;
+    /** 这只挂载的文件系统(`主:次` 设备号;同一个超级块的挂载同号)。 */
+    readonly dev: string;
+    /** 这只挂载在源文件系统里的根路径(第 4 格;整只文件系统挂上来时是 `/`,绑定挂载一只子目录时是那只子目录)。 */
+    readonly root: string;
+    readonly mountPoint: string;
+    readonly options: readonly string[];
+    /** `-` 之后第 1 格(`ext4` / `overlay` / `tmpfs` / `nfs4` …)。 */
+    readonly fsType: string;
+    /** `-` 之后第 2 格(块设备 `/dev/…`、网络盘的 `主机:/导出`、伪文件系统的名字)。 */
+    readonly source: string;
+}
+/** 一份挂载表的解析结果:成形的行 + 读不懂的行数(非空却缺格的行;`-` 之后三格 —— fs 类型 / 挂载源 / 超级块选项 —— 缺任一格或为空串的行照样进表,同时计一行)。 */
+export interface MountTable {
+    readonly rows: readonly MountRow[];
+    readonly malformed: number;
+}
+/** `ancestor` 是不是 `p` 本身或它的祖先(按路径段比:`/etc/semaX` 不是 `/etc/sema` 的后代)。 */
+export declare const coversPath: (ancestor: string, p: string) => boolean;
+/**
+ * 逐行解析(纯函数)。空行不计;前 6 格缺席或为空、或 `-` 分隔缺席的行不进表、计一行读不懂;`-` 之后三格(内核恒写这三格,没有挂载源时写 `none`)
+ * 缺任一格或为空串的行进表(配置根信任判只看行,行为不变)、同时计一行读不懂 —— 持久性判者见到读不懂就整表不判(看见的那一只可能正是读丢的那一行)。
+ */
+export declare function parseMountinfo(text: string): MountTable;
+/**
+ * 走路径时**真正看见的**那一只挂载(按拓扑,不按行序 —— 挂载被 move 过去时 mountinfo 的行序不变):从这个视图的顶(parent 不在表里的行)起,
+ * 每一层在当前挂载的子挂载里找盖住 `dir` 的、挂载点最短的那一只(沿路径先跨进的那一只;同一挂载点叠挂时上层的 parent 是下层,下一层接着找),直到没有子挂载盖住它。
+ * 同一层里挂载点最短的有两只以上(传播出来的影子挂载:同父同点,内核按自己的哈希链查,mountinfo 判不出谁可见)⇒ `"ambiguous"` —— 判不出就不认,不靠行序猜。
+ * 没有任何一只盖住 `dir`(表里没有视图的顶)⇒ `undefined`。
+ */
+export declare function visibleMountOf(rows: readonly MountRow[], dir: string): MountRow | "ambiguous" | undefined;
+/** 生产的挂载表:Linux 上读本进程的 mountinfo(读不出 ⇒ 抛,调用方各自处置);别的平台没有 procfs 挂载表 ⇒ `null`。 */
+export declare function readProcessMountinfo(): Promise<string | null>;
+//# sourceMappingURL=mountinfo.d.ts.map

package/dist/mountinfo.js

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises";
+import { HOST_PLATFORM } from "./plugins/host-platform.js";
+const unescapeMountinfoPath = (field) => field.replace(/\\([0-7]{3})/g, (_m, oct) => String.fromCharCode(Number.parseInt(oct, 8)));
+export const coversPath = (ancestor, p) => ancestor === p || ancestor === "/" || p.startsWith(`${ancestor}/`);
+export function parseMountinfo(text) {
+    const rows = [];
+    let malformed = 0;
+    for (const line of text.split("\n")) {
+        if (line === "")
+            continue;
+        const f = line.split(" ");
+        const [id, parent, dev, root, mountPoint, options] = f;
+        const sep = f.indexOf("-", 6);
+        if (sep === -1 || !id || !parent || !dev || !root || !mountPoint || !options) {
+            malformed++;
+            continue;
+        }
+        const fsType = f[sep + 1];
+        const source = f[sep + 2];
+        if (!fsType || !source || !f[sep + 3])
+            malformed++;
+        rows.push({ id, parent, dev, root: unescapeMountinfoPath(root), mountPoint: unescapeMountinfoPath(mountPoint), options: options.split(","), fsType: fsType ?? "", source: unescapeMountinfoPath(source ?? "") });
+    }
+    return { rows, malformed };
+}
+export function visibleMountOf(rows, dir) {
+    const ids = new Set(rows.map((r) => r.id));
+    let level = rows.filter((r) => !ids.has(r.parent) || r.parent === r.id);
+    let visible;
+    for (let depth = 0; depth <= rows.length; depth++) {
+        const covering = level.filter((r) => coversPath(r.mountPoint, dir));
+        if (covering.length === 0)
+            break;
+        const shortest = Math.min(...covering.map((r) => r.mountPoint.length));
+        const first = covering.filter((r) => r.mountPoint.length === shortest);
+        if (first.length !== 1)
+            return "ambiguous";
+        const next = first[0];
+        visible = next;
+        level = rows.filter((r) => r.parent === next.id && r.id !== next.id);
+    }
+    return visible;
+}
+export async function readProcessMountinfo() {
+    return HOST_PLATFORM === "linux" ? readFile("/proc/self/mountinfo", "utf8") : null;
+}
+//# sourceMappingURL=mountinfo.js.map

package/dist/namespaced-rule-name.d.ts

@@ -7,8 +7,8 @@
  * (本文件那只判与它在会话规则写口、SQL 店写口、四张条目表上的调用)退役,零双读。
  *
  * **调它的面**(点名,不是「每个面」):运维三张名表(`APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`)与中心下发的同名表、请求
- * `settings.permissions.{ask,deny,neverAuto}`(经 `config.ts` 的 `unmatchableToolNamesRefusal`)。这些面上退役且无后继的名字在**有通告席**的表上不拒、行原样留着(唯一读法 {@link isRetiredWithoutSuccessor};
- * 通告席见 `UnmatchableToolNameJudgment.noticeSeat`),请求体 `neverAuto` 没有通告席、照拒。会话规则写口直接调 core 的 `assertSessionRuleNamesCurrent`
+ * `settings.permissions.{ask,deny,neverAuto}`(经 `config.ts` 的 `unmatchableToolNamesRefusal`)。这些面上退役且无后继的名字在**有通告席**的表上不拒、行原样留着(唯一读法 = 引擎的账 {@link retiredLeftOutAccount};
+ * 通告席见 `UnmatchableToolNameJudgment.noticeSeat`;core 7.66.0 [ref] 起请求体 `neverAuto` 也有席 —— 本服务据同一本账铸通告)。会话规则写口直接调 core 的 `assertSessionRuleNamesCurrent`
  * (同一只判官的店形);引擎 allow 层的条目表(请求 `settings.permissions.allow`、运维 `APPROVAL_GRANT`、技能两只清单)交引擎 `compileAllowList`
  * (名册 = {@link TOOL_NAME_ROSTER};判官判非现役的条目读成 `tool_name`,名册里有的只差大小写读成 `near_miss`)。
  * **不调它的面**:`/v1/rules` 的持久规则写口与 `cc-import` 导入口(`http/routes/rules.ts`、`rules-consent.ts` 与两只持久规则店零判官调用)—— 如实未接,
@@ -19,7 +19,7 @@
  *
  * 规则文本里「工具名那一段」怎么取也只有一种读法:{@link ruleEntryToolName}(配置表读它)。
  */
-import { type PermissionRule, type RuleToolNameVerdict } from "@sema-agent/core";
+import { retiredToolNameAccount, type PermissionRule, type RuleToolNameVerdict } from "@sema-agent/core";
 /**
  * 一条**规则文本**里的工具名那一段(判官与旧名判据的主语)= core 包根 `parsePermissionRule` 的 `toolName`,原样 —— 引擎的技能编译器
  * (`compileSkillGrant`)与规则编译器读条目用的就是这一只:`Bash(npm:*)` ⇒ `Bash`;`mcp__srv(*)` / `mcp__srv()` / 带首尾空格的 `mcp__srv ` ⇒ 光杆名 `mcp__srv`。
@@ -52,19 +52,28 @@ export declare const NAME_TABLE_BEHAVIOR: "deny";
  * (core 7.55.0 [ref]:`mcp__*` 在 deny / ask 里是这一协议的每一只工具、在 allow 里什么也不是),漏传态度的调用点是编译错,不是一条静默的「不带态度」读法。
  */
 export declare function unmatchableRuleNameOf(name: string, behavior: PermissionRule["behavior"]): UnmatchableRuleName | undefined;
+/** core 7.66.0 [ref] `retiredToolNameAccount` 的答形(包根不导出具名型 ⇒ 从返回型取,不手抄)。 */
+export type RetiredToolNameAccount = NonNullable<ReturnType<typeof retiredToolNameAccount>>;
 /**
- * **限制表上跳过的那一行**,唯一一只读法:引擎判官判 `retired`,且判词**不带** 1:1 后继 `currentName`(退役表那一行写的是 `removed` / `folded into`,不是 `renamed`)。
- * 这样一行够不着任何工具,也没有可以改写成的现名 —— 引擎准备期的名字审计用同一位(`retired` ∧ 无 `currentName`)把它排出审计、照跑,并铸一条 `config.legacy_tool_name`。
- * 本服务**有通告席**的前门读这一只:**不拒、不改写表**(行原样留着 —— 与引擎同:引擎只把它排出审计,编出的策略里那一行照在,名册里真有同名工具时它照管);
- * 不拒必须配恰一句话 —— 没有人说话的表(请求体 `settings.permissions.neverAuto`、选择器清单)照拒:选择器 / 技能表候引擎发退役名通告,`neverAuto` 候引擎导出通告句源后由本服务铸。
- * 谁读这张表谁说一句:引擎读的表(请求体 `settings.permissions` 的规则桶)由引擎铸通告;只有本服务读的表(运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、
- * 中心下发的 `approvalRequire`)由读它的那一处按 {@link retiredWithoutSuccessorEntries} 在起服 / 落配日志里点名。本服务的名册看不到嵌入方自挂的工具,
- * 所以「够不着」只对本服务知道的工具成立 —— 去掉这一行会让嵌入方自挂的同名工具失去这条限制(静默放宽),留着它最坏是一条死行。
- * 有后继的改名(`Task` ⇒ `Agent`、`KillShell` ⇒ `TaskStop`)不是这一形:写的人要的那只工具换了名字,照拒并给现名。其它判词不经这里。
+ * **限制表上跳过的那几行**,唯一一只读法 = **引擎的账**(core 7.66.0 [ref] `retiredToolNameAccount`):引擎自己的条目读法(`compileAllowList`)读每一条,
+ * 再问引擎自己的那一问 `isRetiredLeftOut` —— 退役且**无后继**(退役表那一行写 `removed` / `folded into`,不是 `renamed`),且名册里没有它的另一种大小写
+ * (`TEAMCREATE` 旁边挂着 `TeamCreate` ⇒ 那一条是写给那只工具的,照拒)。引擎的工具策略 `deny` / `ask`、任务的工具名清单、技能的 `disallowed-tools` 问的
+ * 就是这一问(core 7.65.0 [ref] / 7.66.0 [ref]);本服务的表问同一本账,不另写判官。7.147.0 及更早本仓按判词自判(`retired` ∧ 无 `currentName`),
+ * 少问名册孪生那一问 —— 同一事实的第二种读法,随 7.66.0 退役(零双读)。
+ * 这样一行够不着任何工具,也没有可以改写成的现名:**不拒、不改写表**(行原样留着 —— 与引擎同:引擎只把它排出拒判,编出的策略里那一行照在,名册里真有同名工具时
+ * 它照管);不拒必须配恰一句话 —— 谁读这张表谁说:引擎读的表(请求体 `settings.permissions` 的规则桶、选择器清单、技能表)由引擎铸 `config.legacy_tool_name`;
+ * 只有本服务读的表(运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、中心下发的 `approvalRequire`)由读它的那一处在起服 / 落配日志里点名;
+ * 请求体 `settings.permissions.neverAuto`(引擎不读、请求面无日志)由本服务按这本账铸那一条通告(`retired-name-host-notice.ts`)。
+ * 本服务的名册看不到嵌入方自挂的工具,所以「够不着」只对本服务知道的工具成立 —— 去掉这一行会让嵌入方自挂的同名工具失去这条限制(静默放宽),留着它最坏是一条死行。
+ * 有后继的改名(`Task` ⇒ `Agent`、`KillShell` ⇒ `TaskStop`)、无前缀短名、铸不出的对端段不在账里:照拒并给现名 / 出路。
+ * 名册 = {@link TOOL_NAME_ROSTER}(引擎拿这一 run 真挂的名册问;受理口只读得到这一张)。`source` = 这张表的名字(进句子与每条的 `source`,非空)。
+ * `deny` / `ask` 读名同(引擎:两者都收紧)。没有这种行 ⇒ `undefined`。账列至多 32 条(`total` 数全部)。
  */
-export declare function isRetiredWithoutSuccessor(v: UnmatchableRuleName | undefined): boolean;
-/** 一张**只有本服务读**的限制名表(条目就是工具名:运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、中心下发的 `approvalRequire`)里按 {@link isRetiredWithoutSuccessor} 读出的那几行(带退役表自己那一行),供读表处点名;表本身不动。 */
-export declare function retiredWithoutSuccessorEntries(names: readonly string[], behavior: PermissionRule["behavior"]): readonly {
+export declare function retiredLeftOutAccount(field: "deny" | "ask", source: string, entries: readonly string[]): RetiredToolNameAccount | undefined;
+/** 一条条目是不是账里那种行(逐条问同一本账;限制表的拒判跳过它)。 */
+export declare function isRetiredLeftOut(entry: string): boolean;
+/** 一张**只有本服务读**的限制名表(运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、中心下发的 `approvalRequire`)里账上的那几行(带退役表自己那一行),供读表处点名;表本身不动。 */
+export declare function retiredLeftOutEntries(source: string, names: readonly string[]): readonly {
     readonly entry: string;
     readonly guidance: string;
 }[];

package/dist/namespaced-rule-name.js

@@ -1,4 +1,4 @@
-import { PROTOCOL_TABLE, catalogToolNames, judgeRuleToolName, parsePermissionRule } from "@sema-agent/core";
+import { PROTOCOL_TABLE, catalogToolNames, judgeRuleToolName, parsePermissionRule, retiredToolNameAccount } from "@sema-agent/core";
 import { HOST_TOOL_NAMES } from "./capabilities/host-tool-names.js";
 import { displayListEntry } from "./list-entry-display.js";
 export function ruleEntryToolName(entry) {
@@ -10,17 +10,14 @@ export function unmatchableRuleNameOf(name, behavior) {
     const verdict = judgeRuleToolName(name, TOOL_NAME_ROSTER, behavior);
     return verdict.kind === "current" ? undefined : verdict;
 }
-export function isRetiredWithoutSuccessor(v) {
-    return v?.kind === "retired" && v.currentName === undefined;
+export function retiredLeftOutAccount(field, source, entries) {
+    return retiredToolNameAccount({ field, source, entries }, TOOL_NAME_ROSTER);
 }
-export function retiredWithoutSuccessorEntries(names, behavior) {
-    const out = [];
-    for (const name of names) {
-        const verdict = unmatchableRuleNameOf(name, behavior);
-        if (verdict?.kind === "retired" && isRetiredWithoutSuccessor(verdict))
-            out.push({ entry: name, guidance: verdict.guidance });
-    }
-    return out;
+export function isRetiredLeftOut(entry) {
+    return retiredLeftOutAccount(NAME_TABLE_BEHAVIOR, "entry", [entry]) !== undefined;
+}
+export function retiredLeftOutEntries(source, names) {
+    return retiredLeftOutAccount(NAME_TABLE_BEHAVIOR, source, names)?.detail.entries.map((e) => ({ entry: e.entry, guidance: e.guidance })) ?? [];
 }
 export function describeUnmatchableRuleName(v, name) {
     switch (v.kind) {

package/dist/net-address.d.ts

@@ -45,7 +45,7 @@ export declare function createCidrSet(cidrs: readonly ParsedCidr[]): CidrSet;
 /** 可信代理名单(已由配置层逐项校验过的文本)⇒ 集合。坏项 = 装配缝(配置层已先拒),当场抛,不跳过。 */
 export declare function createTrustedProxySet(items: readonly string[]): CidrSet;
 /**
- * 地址的规范形(帽键的唯一拼法):IPv4 原样(`isIP` 已保证点分十进制、无前导零);IPv6 取 WHATWG 的压缩小写形;
+ * 地址的规范形(帽键 / 限流键 / 本机判 / 出网回环判的唯一拼法):IPv4 原样(`isIP` 已保证点分十进制、无前导零);IPv6 取 WHATWG 的压缩小写形;
  * IPv4-mapped IPv6(`::ffff:1.2.3.4` / `::ffff:102:304`)⇒ 点分 IPv4 —— 同一台主机经 IPv4 栈与双栈来时是同一个键。
  * 非地址、带 zone id、带端口、带方括号 ⇒ `undefined`(端口 / 方括号由调用方按自己的文法先剥)。
  */

package/dist/observability/corrupt-read-seat.d.ts

@@ -1,6 +1,6 @@
 import { type FileStorageCorruptReadInfo } from "@sema-agent/core";
 import { type FailOpenTag } from "./fail-open.js";
-import type { Logger } from "./logger.js";
+import { type Logger } from "./logger.js";
 /**
  * 铸一只腐读披露座。
  *
@@ -39,10 +39,10 @@ export declare function createCorruptReadFailOpenSeat(tag: FailOpenTag, leg?: (i
  *
  * ## 逐命中响亮不降级
  * 这一座里有安全轴的脸(session-policy),所以每命中一行 warn 保留(降成「每进程一次」是降级,[ref] 的裁定);**在此之上**,认出的脸另记账:
- *  · session-policy 脸 ⇒ `P-DEBT` tag(`server.session-policy.corrupt-read-fail-open`)—— 计数逐次 + 探针行 + 一次性 warn。core 7.39.2 起按键读拒;
+ *  · session-policy 脸 ⇒ R 类 tag(`server.session-policy.corrupt-read-fail-open`)—— 计数逐次 + 探针行 + 一次性 warn。core 7.39.2 起按键读拒;
  *    core 7.41.0 [ref] 起本会话的枚举拒、别的会话的抹除不动它、重绑带走它 —— 但只对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`);
- *    无归属的坏行仍按「无规则」(会话规则只许收紧 ⇒ 丢的恰是收紧);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的)。
- *    抹除扫走无归属坏行那一形 core 是否披露、座上数不数得到,本车未亲核(未闭环,收车档登)。放行是 core 的裁定、本仓不包层(源头修复纪律),所以**只登债、不改放行**;
+ *    无从归属的坏行仍按「无规则」(core 已知限制 KL-1299-a 接受:无从归属 ≠ 本会话);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的)。
+ *    抹除扫走无归属坏行那一形 core 是否披露、座上数不数得到,未亲核。放行是 core 的裁定、本仓不包层(源头修复纪律),所以**只记账、不改放行**(R 类:有界放行,计数长期保留);
  *  · 其余脸 ⇒ 不计(见 {@link DurableAbsenceFace})。
  * 记账**先于** warn:记账是总函数,warn 可能抛(core 的 guard 会吞掉那个抛),一次日志故障不许吃掉计数。
  *

package/dist/observability/corrupt-read-seat.js

@@ -1,6 +1,7 @@
 import { join, sep } from "node:path";
 import { readJsonlRecords, resolveDataRoot } from "@sema-agent/core";
 import { recordFailOpen } from "./fail-open.js";
+import { createLogger } from "./logger.js";
 export function createCorruptReadSeat(warn, event, note) {
     return (info) => {
         return warn(event, {
@@ -180,10 +181,11 @@ export class JsonlStoreGate {
             throw new JsonlStoreCorruptError(this.seat, this.path, this.reason);
     }
 }
-const warnToConsole = (event, fields) => console.warn(event, fields);
+const seamLogger = createLogger();
+const warnToLogSeam = (event, fields) => seamLogger.warn(event, fields);
 const isThenable = (v) => typeof v === "object" && v !== null && typeof v.then === "function";
 function guardDisclosure(disclose, event) {
-    const reportSinkFailure = (info, err) => warnToConsole(`${event}_sink_failed`, { kind: info.kind, path: info.path, reason: info.reason, sinkError: err instanceof Error ? err.name : typeof err });
+    const reportSinkFailure = (info, err) => warnToLogSeam(`${event}_sink_failed`, { kind: info.kind, path: info.path, reason: info.reason, sinkError: err instanceof Error ? err.name : typeof err });
     return (info) => {
         let out;
         try {
@@ -224,7 +226,7 @@ function replayJsonl(path, seat, shape, onSkipped, disclose) {
 export function replayJsonlGuarded(path, seat, shape, warn) {
     const entry = JSONL_REPLAY_SEATS[seat];
     const gate = new JsonlStoreGate(seat, path);
-    const disclose = guardDisclosure(createCorruptReadSeat(warn ?? warnToConsole, entry.event, entry.note), entry.event);
+    const disclose = guardDisclosure(createCorruptReadSeat(warn ?? warnToLogSeam, entry.event, entry.note), entry.event);
     const records = replayJsonl(path, seat, shape, (info) => gate.trip(info.reason), disclose);
     return { records, gate };
 }