@sema-agent/client-core 0.83.3 → 0.83.5

package/dist/hooksWireCaps.js

@@ -2,7 +2,7 @@ import { engineCapNestedTrue, engineCapState } from './engineCapsCache.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { collapseLabel } from './fleetTaskDesc.js';
 import { hostLog, hostSettings } from './host.js';
-import { decidePluginHooks, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
+import { decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, CC_STOP_SEMANTICS_MIN_SERVER, ccStopSemanticsFromVersion, engineCcStopSemantics, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, getWireSessionStopHookCcSemantics, buildGoalStopHookPrompt, } from './goalStopHook.js';
@@ -37,6 +37,40 @@ function nonManagedDisableAllHooks(settings) {
     }
     return false;
 }
+const HOOKS_STARTUP_MODES = ['safe', 'bare'];
+const _startupModesPin = [true, true];
+void _startupModesPin;
+function describeStartupModeValue(v) {
+    if (v === null)
+        return 'null';
+    if (typeof v === 'string')
+        return JSON.stringify(v.length > 40 ? `${v.slice(0, 40)}…` : v);
+    return typeof v;
+}
+function startupModeWord(settings) {
+    let v;
+    try {
+        const member = settings.hooksStartupMode;
+        if (member === undefined)
+            return undefined;
+        if (typeof member !== 'function') {
+            hostLog('debug', `hooksWireCaps: hooksStartupMode is ${describeStartupModeValue(member)}, not a method — treated as neither safe nor bare mode (settings hooks not narrowed)`);
+            return undefined;
+        }
+        v = member.call(settings);
+    }
+    catch (err) {
+        hostLog('debug', `hooksWireCaps: hooksStartupMode() threw — treated as neither safe nor bare mode (settings hooks not narrowed): ${String(err)}`);
+        return undefined;
+    }
+    if (v === undefined)
+        return undefined;
+    const word = HOOKS_STARTUP_MODES.find((w) => w === v);
+    if (word !== undefined)
+        return word;
+    hostLog('debug', `hooksWireCaps: hooksStartupMode() returned ${describeStartupModeValue(v)}, which is neither 'safe' nor 'bare' — treated as neither mode (settings hooks not narrowed)`);
+    return undefined;
+}
 function hooksOfSource(source) {
     try {
         const s = hostSettings()?.getSettingsForSource(source);
@@ -203,8 +237,27 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (merged, non-managed) — only policySettings hooks projected to the engine');
     }
     const managedOnly = managedByPolicy || disabledByNonManaged;
-    const sources = managedOnly ? ['policySettings'] : ALL_HOOK_SOURCES;
+    const read = withPlugins ? readPluginHooks(settings, true) : undefined;
+    let oldStartupBit;
+    let pluginDataThrew = false;
+    if (read?.reading !== undefined) {
+        const reading = read.reading;
+        const bit = guardPluginTraversal(() => reading.suppressedByStartupMode === true);
+        if (bit === undefined)
+            pluginDataThrew = true;
+        else
+            oldStartupBit = bit;
+    }
+    const startupMode = startupModeWord(settings) ?? (oldStartupBit === true ? 'safe' : undefined);
+    if (startupMode === 'bare') {
+        hostLog('debug', 'hooksWireCaps: bare mode reported by the host — only policySettings hooks projected to the engine (same as safe mode)');
+    }
+    else if (startupMode === 'safe') {
+        hostLog('debug', 'hooksWireCaps: safe mode reported by the host — only policySettings hooks projected to the engine');
+    }
+    const sources = managedOnly || startupMode !== undefined ? ['policySettings'] : ALL_HOOK_SOURCES;
     const merged = {};
+    const sourced = new Map();
     for (const source of sources) {
         const hooks = hooksOfSource(source);
         if (!hooks)
@@ -218,8 +271,20 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
             if (kept.groups.length === 0)
                 continue;
             merged[event] = [...(merged[event] ?? []), ...kept.groups];
+            const tagged = sourced.get(event) ?? [];
+            for (const group of kept.groups)
+                tagged.push({ source, group });
+            sourced.set(event, tagged);
         }
     }
+    let settingsDeduped = 0;
+    for (const [event, groups] of sourced) {
+        const d = dedupeSettingsHookGroups(groups);
+        if (d.removed === 0)
+            continue;
+        merged[event] = d.groups;
+        settingsDeduped += d.removed;
+    }
     const goalMatcher = goalStopHookMatcher(managedOnly);
     if (goalMatcher !== null) {
         merged['Stop'] = [...(merged['Stop'] ?? []), goalMatcher];
@@ -228,6 +293,10 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         hostLog('debug', `hooksWireCaps: ${settingsDropped.length} settings hook entr${settingsDropped.length === 1 ? 'y' : 'ies'} not sent to the engine ` +
             `(${[...new Set(settingsDropped.map((d) => d.reason))].join(', ')}) — see hooksWirePlan().settingsDropped`);
     }
+    if (settingsDeduped > 0) {
+        hostLog('debug', `hooksWireCaps: ${settingsDeduped} settings hook entr${settingsDeduped === 1 ? 'y appears' : 'ies appear'} more than once ` +
+            '(same event, matcher group and hook) — sent once, at the first position, with the fields of the highest-precedence source');
+    }
     if (settingsStripped > 0) {
         hostLog('debug', `hooksWireCaps: ${settingsStripped} settings hook entr${settingsStripped === 1 ? 'y' : 'ies'} carried a plugin key — ` +
             'stripped before sending (plugin context is only minted for entries from the plugin reader)');
@@ -250,18 +319,19 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         }
         return planOf('absent', wireOf());
     }
-    const read = readPluginHooks(settings, true);
-    if (read.reading === undefined)
-        return planOf(read.state, wireOf());
+    if (read?.reading === undefined)
+        return planOf(read?.state ?? 'absent', wireOf());
+    if (pluginDataThrew)
+        return planOf('failed', wireOf());
     const reading = read.reading;
     const occupied = occupancyOf(merged);
     const d = guardPluginTraversal(() => {
         const plugins = reading.plugins;
-        const startupMode = reading.suppressedByStartupMode === true;
-        const managedOnlyPlugins = !startupMode && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || mergedDisable());
+        const startup = startupMode !== undefined;
+        const managedOnlyPlugins = !startup && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || mergedDisable());
         return decidePluginHooks({
             plugins,
-            exclusion: startupMode ? 'startup_mode' : undefined,
+            exclusion: startup ? 'startup_mode' : undefined,
             managedOnly: managedOnlyPlugins,
             engine,
             shellHookEvents: shellEvents,

package/dist/host.d.ts

@@ -7,7 +7,9 @@ export interface SettingsPort {
     shouldSkipHookDueToTrust(hook?: unknown): boolean;
     mergedDisableAllHooks?(): boolean | undefined;
     enabledPluginHooks?(): PluginHooksReading;
+    hooksStartupMode?(): HooksStartupMode | undefined;
 }
+export type HooksStartupMode = 'safe' | 'bare';
 export type PluginHookOptionValue = string | number | boolean;
 export interface PluginHookSensitiveOption {
     readonly sensitive: true;

package/dist/index.d.ts

@@ -57,8 +57,8 @@ export * from './modelCapabilityProbe.js';
 export * from './classifierStatus.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
-export { displayUntrusted } from './displayUntrusted.js';
-export type { DisplayUntrustedOptions, DisplayMark } from './displayUntrusted.js';
+export { displayUntrusted, displayUntrustedMarks } from './displayUntrusted.js';
+export type { DisplayUntrustedOptions, DisplayMark, DisplayMarkSpan, DisplayUntrustedMarked } from './displayUntrusted.js';
 export type * from './types/engineState.js';
 export * from './hostEnv.js';
 export * from './unrefTimer.js';
@@ -66,6 +66,7 @@ export * from './controlRouter.js';
 export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
+export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export * from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -154,7 +155,7 @@ export * from './hitl/editedRuleTextPrecheck.js';
 export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
-export * from './hitl/gateIdentity.js';
+export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
 export * from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';

package/dist/index.js

@@ -57,13 +57,14 @@ export * from './modelCapabilityProbe.js';
 export * from './classifierStatus.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
-export { displayUntrusted } from './displayUntrusted.js';
+export { displayUntrusted, displayUntrustedMarks } from './displayUntrusted.js';
 export * from './hostEnv.js';
 export * from './unrefTimer.js';
 export * from './controlRouter.js';
 export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
+export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export * from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -151,7 +152,7 @@ export * from './hitl/editedRuleTextPrecheck.js';
 export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
-export * from './hitl/gateIdentity.js';
+export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
 export * from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';

package/dist/pluginHooksWire.d.ts

@@ -84,6 +84,15 @@ export interface SettingsHookFilterResult {
     readonly drops: SettingsHookDrop[];
     readonly stripped: number;
 }
+export interface SourcedSettingsHookGroup {
+    readonly source: HookSettingsSource;
+    readonly group: WireHookGroup;
+}
+export declare function dedupeSettingsHookGroups(groups: readonly SourcedSettingsHookGroup[]): SettingsHookDedupResult;
+export interface SettingsHookDedupResult {
+    readonly groups: WireHookGroup[];
+    readonly removed: number;
+}
 export declare function pluginHookVerdictOf(plan: HooksWirePlan, pluginId: string, event: string, groupIndex: number, hookIndex: number): PluginHookVerdict | undefined;
 export declare function pluginHookReasonText(reason: PluginHookReason): string;
 export declare function settingsHookDropText(reason: SettingsHookDropReason): string;

package/dist/pluginHooksWire.js

@@ -305,6 +305,125 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
     });
     return { groups: out, drops, stripped };
 }
+function settingsHookEntryKey(entry) {
+    if (!isRecord(entry) || typeof entry.type !== 'string')
+        return undefined;
+    const cond = entry.if;
+    if (cond !== undefined && typeof cond !== 'string')
+        return undefined;
+    const ifKey = cond ?? '';
+    const str = (v) => typeof v === 'string';
+    const shell = entry.shell;
+    try {
+        switch (entry.type) {
+            case 'command':
+                if (!str(entry.command) || (shell !== undefined && !str(shell)))
+                    return undefined;
+                return JSON.stringify(['command', shell ?? null, entry.command, entry.args ?? null, ifKey]);
+            case 'prompt':
+            case 'agent':
+                return str(entry.prompt) ? JSON.stringify([entry.type, entry.prompt, ifKey]) : undefined;
+            case 'http':
+                return str(entry.url) ? JSON.stringify(['http', entry.url, ifKey]) : undefined;
+            case 'mcp_tool':
+                return str(entry.server) && str(entry.tool)
+                    ? JSON.stringify(['mcp_tool', entry.server, entry.tool, entry.input ?? {}, ifKey])
+                    : undefined;
+            case 'script': {
+                const script = entry.script;
+                const file = entry.file;
+                if ((script !== undefined && !str(script)) || (file !== undefined && !str(file)) || (script === undefined && file === undefined))
+                    return undefined;
+                return JSON.stringify(['script', script ?? null, file ?? null, ifKey]);
+            }
+            default:
+                return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function ccMergeRank(source) {
+    switch (source) {
+        case 'userSettings':
+            return 0;
+        case 'projectSettings':
+            return 1;
+        case 'localSettings':
+            return 2;
+        case 'flagSettings':
+            return 3;
+        case 'policySettings':
+            return 4;
+    }
+}
+export function dedupeSettingsHookGroups(groups) {
+    const keysOf = [];
+    const winner = new Map();
+    for (const { source, group } of groups) {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            keysOf.push([]);
+            continue;
+        }
+        let groupKey;
+        try {
+            const { hooks: _hooks, ...rest } = group;
+            void _hooks;
+            groupKey = JSON.stringify(rest);
+        }
+        catch {
+            groupKey = undefined;
+        }
+        const rank = ccMergeRank(source);
+        const keys = [];
+        for (const entry of group.hooks) {
+            const entryKey = groupKey === undefined ? undefined : settingsHookEntryKey(entry);
+            const key = entryKey === undefined ? undefined : `${groupKey}\u0000${entryKey}`;
+            keys.push(key);
+            if (key === undefined)
+                continue;
+            const prev = winner.get(key);
+            if (prev === undefined || rank >= prev.rank)
+                winner.set(key, { entry, rank });
+        }
+        keysOf.push(keys);
+    }
+    const placed = new Set();
+    const out = [];
+    let removed = 0;
+    groups.forEach(({ group }, gi) => {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            out.push(group);
+            return;
+        }
+        const keys = keysOf[gi] ?? [];
+        const kept = [];
+        let changed = false;
+        group.hooks.forEach((entry, hi) => {
+            const key = keys[hi];
+            if (key === undefined) {
+                kept.push(entry);
+                return;
+            }
+            if (placed.has(key)) {
+                removed++;
+                changed = true;
+                return;
+            }
+            placed.add(key);
+            const win = winner.get(key)?.entry ?? entry;
+            if (win !== entry)
+                changed = true;
+            kept.push(win);
+        });
+        if (!changed)
+            out.push(group);
+        else if (kept.length > 0)
+            out.push({ ...group, hooks: kept });
+    });
+    return { groups: out, removed };
+}
 export function pluginHookVerdictOf(plan, pluginId, event, groupIndex, hookIndex) {
     return plan.verdicts.find((v) => v.pluginId === pluginId && v.event === event && v.groupIndex === groupIndex && v.hookIndex === hookIndex);
 }

package/dist/request/taskRequest.js

@@ -19,7 +19,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'council', lanes: ['interactive', 'print'], live: true, why: 'code-review council 形开关(server 读 `=== true`;非 true 不 stamp=与缺席同义,发小的那个)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'debate', lanes: ['interactive', 'print'], live: true, why: 'council 的 debate 变体开关(server 读 `=== true`)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'rounds', lanes: ['interactive', 'print'], live: true, why: 'debate 轮数(server clamp [1,3],非有限数被 server 归 undefined——本层原样透传不预 clamp)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
-    { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头集(passthrough 同 repo;形状由 server 场景定义,本层不闭集)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
+    { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头数(server 场景按数字读、非数字回 400;本层型面仍按旧形声明为字符串数组 —— 已知不一致,随该族退役处理)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'memoryCapture', lanes: ['interactive', 'print', 'utility'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏', whyUtilityLane: '有座:side-channel 提交是壳自己的一次性问答,**绝不该**进用户的长期记忆 —— 这一位正是那句声明,且它是收紧方向,带上去只会更严' },
     { field: 'memory', lanes: ['interactive', 'print', 'utility'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴', whyUtilityLane: '有座:side-channel 提交不需要挂记忆面(不挂记忆段 / 索引 / 三只记忆工具),省 token 且零记忆写入;与 memoryCapture 不是一个轴,两条都带' },
     { field: 'approverPosture', lanes: ['interactive', 'print'], live: true, why: '宿主对这个 run 的**审批姿态声明**(「这个 run 的审批卡由我自己自动答」;单成员闭集 `"bypass"`)。🔴 它不授权任何东西、也不是一只门:引擎只把这句声明**渲**给模型(它自己的标记块,首个回合),没有任何裁决腿读它 —— 与 `permissionMode` 的 `bypassPermissions`(选门的形状)**不是一回事**,两键在请求体上各自原样过境、**互不派生**:宿主完全可以一边留着缺省权限模式、一边自己自动答这个 run 的审批卡。🔴 **声明它的唯一条件是「宿主确实自己自动答这个 run 的审批卡」,不许据此推导或改动 `permissionMode`** —— 拿这一位当理由去把门放宽,是把一句只渲给模型看的话读成了授权。宿主并不自动答卡却声明了它 ⇒ 那是对模型说了一句与实际不符的话,修法是**别声明**,不是去动门。加座的理由是**一个事实一处铸点**:同样一句话,要么由引擎在它自己的标记块里说,要么由壳把提醒形文本拼进本 turn 的输入 —— 后者在模型眼里是一段**没有引擎标记**的提醒形副本,按标记声明它该当**数据**处理并报出来。所以壳从此停拼,交这一位。两条用户车道都是提交面 ⇒ 都能声明。坏词由引擎响亮拒(单成员闭集,打错字不许被折成缺席),本层同律在构造期就拒(见 `refuseBadApproverPosture`)。⚠️ 上游的**提交体**与**引擎规格**两层都真读这一键,而装着的 sdk 型面尚未镜像它 ⇒ 本层的字面按提交体的形声明,不从 sdk 取型', whyUtilityLane: '无座:审批姿态是**用户**对他自己那条会话的声明,而 side-channel 是壳自己的提交 —— 把用户的 bypass 姿态带进一条他没参与的提交,等于替他重申一句他没说过的话;况且零工具面根本产不出审批卡' },

package/dist/seatContract.d.ts

@@ -2,6 +2,7 @@ import type { ReasoningEffort } from "./effortWire.js";
 import type { LaneProof } from "./seam.js";
 import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
+import type { ApprovalMandateWord } from "./gateVocabulary.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -55,6 +56,10 @@ export interface ToolPermissionRequest {
     createdAtMs?: number;
     governanceForced?: true;
     delegation?: ToolApprovalDelegation;
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+    ruleOffersAbsence?: string;
 }
 declare const SEAT_EVENT_TYPE_TUPLE: readonly ["start", "close", "session_updated", "message", "stream_event", "chrome_event", "error", "tool_permission_resolved"];
 export type SeatEventType = (typeof SEAT_EVENT_TYPE_TUPLE)[number];
@@ -255,7 +260,7 @@ export declare const SEAT_METHOD_NAMES: readonly ["start", "sendMessage", "inter
 export declare const SEAT_STORE_PROPS: readonly ["sessionsStateStore", "focusedSessionStateStore", "settingsStateStore"];
 export declare const SEAT_EVENT_METHOD_NAMES: readonly ["onEvent", "onToolPermissionRequest"];
 export declare const LOCAL_SESSION_EVENT_KEYS: readonly ["type", "sessionId", "message", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "chrome"];
-export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation"];
+export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation", "mandated", "mandate", "origin", "ruleOffersAbsence"];
 export declare const LOCAL_SESSION_RECORD_KEYS: readonly ["sessionId", "engineSessionId", "model", "title", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked"];
 export declare const SEND_MESSAGE_REQUEST_KEYS: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario"];
 export declare const SEAT_SEND_MESSAGE_KEY_ORIGINS: {
@@ -318,6 +323,18 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
         }, {
             readonly key: "delegation";
             readonly why: "展示增强位,权威结构门在 hitl wire 卡口(结构读+仅子代 ask 在场,坏形降缺席);座位门同款理由不设第二判官。消费端坏形降缺席,绝不拒行。";
+        }, {
+            readonly key: "mandated";
+            readonly why: "展示增强位(CC-203),权威窄读在卡口与过境口 toolPermissionRequestAskBits(严格 true 才上座);座位门再裁一次会为一个徽标键拒掉整条 request、把安全 ask 丢给引擎 TTL deny。消费端经 approvalIsMandated 读,其余一律当缺席。";
+        }, {
+            readonly key: "mandate";
+            readonly why: "展示增强位(CC-203),权威窄读在卡口与过境口(闭集六词精确字节,表外不上座);座位门不设第二判官,理由同 mandated。消费端经 readApprovalMandate 读,表外值读成缺席。";
+        }, {
+            readonly key: "origin";
+            readonly why: "喂姿态谓词 askSurvivesPosture 的安全位(CC-203),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口 toolPermissionRequestAskBits,座位门不设第二判官(为一个位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形的两种失效方向:非串 / 空串读成缺席 ⇒ 宿主报了没命中时姿态谓词可答可以放(放宽方向:真出身若是必问词就丢了);表外串读成不认识的词 ⇒ 答 unknown,宿主退回自己的规则(不放宽)。不经过境口自铸座位请求的宿主要自己按同一把窄读。";
+        }, {
+            readonly key: "ruleOffersAbsence";
+            readonly why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。";
         }];
     };
     readonly LocalSessionEvent: {

package/dist/seatContract.js

@@ -489,6 +489,10 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "createdAtMs",
     "governanceForced",
     "delegation",
+    "mandated",
+    "mandate",
+    "origin",
+    "ruleOffersAbsence",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -562,6 +566,22 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "delegation",
                 why: "展示增强位,权威结构门在 hitl wire 卡口(结构读+仅子代 ask 在场,坏形降缺席);座位门同款理由不设第二判官。消费端坏形降缺席,绝不拒行。",
             },
+            {
+                key: "mandated",
+                why: "展示增强位(CC-203),权威窄读在卡口与过境口 toolPermissionRequestAskBits(严格 true 才上座);座位门再裁一次会为一个徽标键拒掉整条 request、把安全 ask 丢给引擎 TTL deny。消费端经 approvalIsMandated 读,其余一律当缺席。",
+            },
+            {
+                key: "mandate",
+                why: "展示增强位(CC-203),权威窄读在卡口与过境口(闭集六词精确字节,表外不上座);座位门不设第二判官,理由同 mandated。消费端经 readApprovalMandate 读,表外值读成缺席。",
+            },
+            {
+                key: "origin",
+                why: "喂姿态谓词 askSurvivesPosture 的安全位(CC-203),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口 toolPermissionRequestAskBits,座位门不设第二判官(为一个位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形的两种失效方向:非串 / 空串读成缺席 ⇒ 宿主报了没命中时姿态谓词可答可以放(放宽方向:真出身若是必问词就丢了);表外串读成不认识的词 ⇒ 答 unknown,宿主退回自己的规则(不放宽)。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "ruleOffersAbsence",
+                why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
         ],
     },
     LocalSessionEvent: {

package/dist/systemReminderTag.js

@@ -1,9 +1,30 @@
 const OPEN_TAG_SOURCE = '<system-reminder(?: mark="[A-Za-z0-9_-]{22}")?>';
-const WRAPPED_RE = new RegExp(`^\\s*${OPEN_TAG_SOURCE}\\s*\\n?([\\s\\S]*?)\\n?\\s*<\\/system-reminder>\\s*$`);
+const CLOSE_TAG = '</system-reminder>';
+const OPEN_TAG_AT_START_RE = new RegExp(`^${OPEN_TAG_SOURCE}`);
 export function unwrapSystemReminder(text) {
-    const m = WRAPPED_RE.exec(text);
-    return m ? m[1] : text;
+    const head = text.trimStart();
+    const open = OPEN_TAG_AT_START_RE.exec(head);
+    if (open === null)
+        return text;
+    const whole = head.trimEnd();
+    if (!whole.endsWith(CLOSE_TAG) || whole.length - CLOSE_TAG.length < open[0].length)
+        return text;
+    return whole.slice(open[0].length, whole.length - CLOSE_TAG.length).trim();
 }
 export function stripSystemReminderBlocks(text) {
-    return text.replace(new RegExp(`${OPEN_TAG_SOURCE}[\\s\\S]*?<\\/system-reminder>`, 'g'), '');
+    const openRe = new RegExp(OPEN_TAG_SOURCE, 'g');
+    let out = '';
+    let pos = 0;
+    for (;;) {
+        openRe.lastIndex = pos;
+        const open = openRe.exec(text);
+        if (open === null)
+            break;
+        const close = text.indexOf(CLOSE_TAG, open.index + open[0].length);
+        if (close === -1)
+            break;
+        out += text.slice(pos, open.index);
+        pos = close + CLOSE_TAG.length;
+    }
+    return pos === 0 ? text : out + text.slice(pos);
 }