@sema-agent/client-core 0.83.2 → 0.83.4

package/dist/modelIdentityResolvability.js

@@ -19,11 +19,12 @@ function laneState(lanes, lane) {
     if (hit === undefined)
         return 'not_reported';
     const v = hit.v;
-    const _catalogPin = true;
-    void _catalogPin;
-    if (v === 'complete')
-        return lane === 'modelCatalogFile' ? 'unusable' : v;
-    return v === 'partial' || v === 'absent' || v === 'unreadable' ? v : 'unusable';
+    return v === 'complete' || v === 'partial' || v === 'absent' || v === 'unreadable' ? v : 'unusable';
+}
+function catalogDefaultEvidence(catalog, accepts) {
+    const _evidencePin = true;
+    void _evidencePin;
+    return catalog === 'complete' && accepts === true ? { catalog, engineAccepts: accepts } : undefined;
 }
 function analyse(reading) {
     try {
@@ -40,16 +41,36 @@ function analyse(reading) {
             return malformed();
         const lanesHit = own(reading, 'lanes')?.v;
         const order = laneOrder();
-        if (!isPlainObject(lanesHit))
-            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [] };
+        if (!isPlainObject(lanesHit)) {
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: false };
+        }
         const partial = [];
         const unreadable = [];
         const unreported = [];
         const unusable = [];
+        let catalogRefused = false;
+        let catalogUnconfirmed = null;
         for (const lane of order) {
             const s = laneState(lanesHit, lane);
-            if (s === 'complete')
+            if (lane === 'modelCatalogFile') {
+                if (s === 'complete') {
+                    const bit = own(reading, 'engineAcceptsCatalogDefault');
+                    const evidence = catalogDefaultEvidence(s, bit?.v);
+                    if (evidence !== undefined)
+                        return { verdict: 'resolvable', why: 'catalog_default', evidence };
+                    if (bit !== undefined && bit.v === false) {
+                        partial.push(lane);
+                        catalogRefused = true;
+                    }
+                    else {
+                        catalogUnconfirmed = bit === undefined || bit.v === undefined ? 'not_reported' : 'unusable';
+                    }
+                    continue;
+                }
+            }
+            else if (s === 'complete') {
                 return { verdict: 'resolvable', why: 'lane', lane };
+            }
             if (s === 'partial')
                 partial.push(lane);
             else if (s === 'unreadable')
@@ -59,10 +80,10 @@ function analyse(reading) {
             else if (s === 'unusable')
                 unusable.push(lane);
         }
-        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0) {
-            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable };
+        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0 || catalogUnconfirmed !== null) {
+            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable, catalogUnconfirmed, catalogRefused };
         }
-        return { verdict: 'not_resolvable', partial };
+        return { verdict: 'not_resolvable', partial, catalogRefused };
     }
     catch {
         return malformed();
@@ -97,13 +118,25 @@ export function modelIdentityDetail(reading) {
             if (a.why === 'engine_answered') {
                 return 'the engine is up and answering, and it does not start without a model name, so it has one — whether its gateway accepts that name is a separate check';
             }
+            if (a.why === 'catalog_default') {
+                return `${laneLabel('modelCatalogFile')} supplies a model name as its default, and the local engine accepts a catalog default in place of a startup model name, so it can start with it — whether its gateway accepts that name is a separate check`;
+            }
             return `${laneLabel(a.lane)} supplies a model name, so the local engine can start with it — whether its gateway accepts that name is a separate check`;
-        case 'not_resolvable':
-            if (a.partial.length > 0) {
-                const labels = joinPhrases(a.partial.map(laneLabel));
-                return `no model name is configured for the local engine — ${labels} ${a.partial.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name, and the engine does not start without one`;
+        case 'not_resolvable': {
+            const others = a.catalogRefused ? a.partial.filter((l) => l !== 'modelCatalogFile') : a.partial;
+            const partialClause = others.length > 0
+                ? `${joinPhrases(others.map(laneLabel))} ${others.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name`
+                : '';
+            if (a.catalogRefused) {
+                return (`no model name is configured for the local engine to start with — ${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name` +
+                    (partialClause !== '' ? `, and ${partialClause}` : '') +
+                    ', and the engine does not start without one');
+            }
+            if (others.length > 0) {
+                return `no model name is configured for the local engine — ${partialClause}, and the engine does not start without one`;
             }
             return 'no model name is configured for the local engine — none of the places this client reads supplies one, and the engine does not start without it';
+        }
         case 'unknown':
             if (a.why === 'remote') {
                 return a.answer === 'unreachable'
@@ -116,6 +149,15 @@ export function modelIdentityDetail(reading) {
                     ...a.unreported.map((l) => `${laneLabel(l)} was not reported`),
                     ...a.unusable.map((l) => `${laneLabel(l)} gave no usable reading`),
                 ];
+                if (a.catalogUnconfirmed === 'not_reported') {
+                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but whether the local engine accepts a catalog default in place of a startup model name was not reported`);
+                }
+                else if (a.catalogUnconfirmed === 'unusable') {
+                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the report of whether the local engine accepts a catalog default in place of a startup model name gave no usable reading`);
+                }
+                else if (a.catalogRefused) {
+                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name`);
+                }
                 return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;
             }
             return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";

package/dist/pluginHooksWire.d.ts

@@ -10,7 +10,7 @@ export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrust
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
 export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported"];
 export type SettingsHookDropReason = (typeof SETTINGS_HOOK_DROP_REASONS)[number];
-export type HookSettingsSource = 'policySettings' | 'userSettings' | 'projectSettings' | 'localSettings';
+export type HookSettingsSource = 'policySettings' | 'userSettings' | 'projectSettings' | 'localSettings' | 'flagSettings';
 export interface PluginHookKey {
     readonly pluginId: string;
     readonly pluginName: string;

package/dist/pluginHooksWire.js

@@ -332,6 +332,7 @@ const SOURCE_TEXT = {
     userSettings: 'User settings',
     projectSettings: 'Project settings',
     localSettings: 'Local settings',
+    flagSettings: 'Flag settings',
 };
 export function pluginHookReasonText(reason) {
     return REASON_TEXT[reason];

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);
 }