@sema-agent/client-core 0.103.0 → 0.104.0

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -287,6 +287,7 @@ function projectEvent(ev, ctx) {
             const sleptMsRaw = guardedRead(() => readOwnDataFiniteNumber(stWait, 'sleptMs'));
             const sleptMs = sleptMsRaw !== undefined && sleptMsRaw >= 0 ? sleptMsRaw : undefined;
             const waitSegment = readFrameStringKey(stWait, 'waitSegment');
+            const seat = readFrameStringKey(ev, 'seat');
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -304,6 +305,7 @@ function projectEvent(ev, ctx) {
                 ...(providerConditionSource !== undefined ? { providerConditionSource } : {}),
                 ...(sleptMs !== undefined ? { sleptMs } : {}),
                 ...(waitSegment !== undefined ? { waitSegment } : {}),
+                ...(seat !== undefined ? { seat } : {}),
                 ...(typeof ev.eventId === 'string' ? { eventId: ev.eventId } : {}),
                 ...(typeof ev.parentToolCallId === 'string' ? { parentToolCallId: ev.parentToolCallId } : {}),
             })));

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -61,7 +61,6 @@ export interface PermissionDenialParts {
 export interface SemaCostBreakdown {
     readonly llmRootMicroUsd?: number;
     readonly nestedSubagentMicroUsd?: number;
-    readonly memoryConsolidationMicroUsd?: number;
     readonly suggestionsMicroUsd?: number;
     readonly compactionMicroUsd?: number;
     readonly [k: string]: number | undefined;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -564,6 +564,8 @@ function printArmReadingOf(input) {
         const stop_reason = printArmStopReasonOf(lastRow);
         if (kind === 'completed')
             return { arm: Object.freeze({ subtype: 'success', is_error: false, stop_reason }) };
+        if (kind === 'paused')
+            return { arm: Object.freeze({ subtype: 'error_during_execution', is_error: true, stop_reason }) };
         if (kind === 'failed') {
             const code = readOwnDataValue(terminal, 'code');
             const limit = typeof code === 'string' ? resultLimitRowOfCode(code) : undefined;
@@ -644,7 +646,6 @@ function errorResult(ctx, parts) {
         ...('limit' in arm && arm.limit !== undefined ? { _sema_limit: arm.limit } : {}),
         ...(parts.wayOut !== undefined ? { _sema_wayOut: wayOutOnFrame(parts.wayOut) } : {}),
         ...(parts.codedDetail !== undefined ? { _sema_coded_detail: parts.codedDetail } : {}),
-        ...(parts.errorCode !== undefined && parts.errorCode.length > 0 && errorsStateCode(errors[0], parts.errorCode) ? { _sema_error_code_in_text: true } : {}),
     };
     if (arm.subtype === 'success') {
         return stamp(ctx, {
@@ -665,6 +666,7 @@ function errorResult(ctx, parts) {
         ...head,
         errors,
         ...tail,
+        ...(parts.errorCode !== undefined && parts.errorCode.length > 0 && errorsStateCode(errors[0], parts.errorCode) ? { _sema_error_code_in_text: true } : {}),
     });
 }
 function errorsStateCode(first, code) {

package/dist/agentSession/engineAgentRegistryRead.js

@@ -2,6 +2,7 @@ import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { engineCapNestedValue } from '../engineCapsCache.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -75,12 +76,14 @@ function readRow(v) {
         return undefined;
     const description = Object.hasOwn(o, 'description') ? o.description : undefined;
     const createdAt = Object.hasOwn(o, 'createdAt') ? o.createdAt : undefined;
+    const childSessionId = type === 'background_agent' ? guardedRead(() => readOwnDataValue(o, 'sessionId')) : undefined;
     return {
         id,
         type,
         status,
         ...(typeof description === 'string' && description.length > 0 ? { description } : {}),
         ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
+        ...(typeof childSessionId === 'string' && childSessionId.length > 0 ? { sessionId: childSessionId } : {}),
     };
 }
 export async function readEngineAgentRegistry(client, sessionId, capsBaseUrl, opts) {

package/dist/coreValuePorts.d.ts

@@ -149,8 +149,9 @@ export interface CoreValuePorts {
     readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
     ANTHROPIC_DEFAULT_BASE_URL: string;
     readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
+    ruleNameCovers: (ruleName: string, toolName: string) => boolean;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -180,3 +181,4 @@ export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'all
 export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;
 export declare function anthropicDefaultBaseUrl(): string | undefined;
 export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;
+export declare function ruleNameCovers(ruleName: string, toolName: string): boolean | undefined;

package/dist/coreValuePorts.js

@@ -19,6 +19,7 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'readMcpToolAxes',
     'ANTHROPIC_DEFAULT_BASE_URL',
     'readToolFaces',
+    'ruleNameCovers',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -118,3 +119,7 @@ export function readToolFaces(declared) {
     const fn = port('readToolFaces');
     return fn === undefined ? undefined : fn(declared);
 }
+export function ruleNameCovers(ruleName, toolName) {
+    const fn = port('ruleNameCovers');
+    return fn === undefined ? undefined : fn(ruleName, toolName);
+}

package/dist/deviceRebind.d.ts

@@ -1,6 +1,11 @@
 import type { AgentClient, DeviceEnrollRequest } from '@sema-agent/sdk';
+import { type ExecutionPlacementRole } from './executionPlacementWords.js';
 export type DeviceListVerb = Pick<AgentClient['devices'], 'list'>;
-export type DeviceSessionBindingVerb = Pick<AgentClient['devices'], 'sessionBinding'>;
+export interface SessionExecutionPlacementVerb {
+    executionPlacement(sessionId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<object>;
+}
 export type DeviceRebindVerb = Pick<AgentClient['devices'], 'rebind'>;
 export type DeviceIssueEnrollTokenVerb = Pick<AgentClient['devices'], 'issueEnrollToken'>;
 export type DeviceEnrollVerb = Pick<AgentClient['devices'], 'enroll'>;
@@ -14,7 +19,6 @@ export interface DeviceRosterRow {
 export interface DeviceBindingReading {
     readonly deviceId: string;
     readonly rev: number;
-    readonly boundAt?: string;
 }
 export interface DeviceRefused {
     readonly kind: 'refused';
@@ -37,6 +41,10 @@ export interface DeviceUnreadable {
 export interface DeviceUnarmed {
     readonly kind: 'unarmed';
 }
+export interface DeviceFaceUnsupported {
+    readonly kind: 'unsupported';
+    readonly reason: 'route' | 'capability';
+}
 export type DeviceListOutcome = {
     readonly kind: 'ok';
     readonly devices: readonly DeviceRosterRow[];
@@ -46,9 +54,12 @@ export type DeviceSessionBindingOutcome = {
     readonly kind: 'ok';
     readonly rootSessionId: string;
     readonly boundDevice: DeviceBindingReading;
+} | {
+    readonly kind: 'unbound';
+    readonly role: ExecutionPlacementRole;
 } | {
     readonly kind: 'not-found';
-} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+} | DeviceFaceUnsupported | DeviceUnreadable | DeviceRefused | DeviceTransport | DeviceUnarmed;
 export interface DeviceRebindInput {
     readonly rootSessionId: string;
     readonly toDeviceId: string;
@@ -69,6 +80,8 @@ export type DeviceRebindOutcome = {
 } | {
     readonly kind: 'active-run';
     readonly activeTaskId?: string;
+    readonly children?: readonly string[];
+    readonly retirePath?: string;
 } | {
     readonly kind: 'rev-conflict';
     readonly currentRev?: number;
@@ -79,7 +92,7 @@ export type DeviceRebindReconcileVerdict = 'landed' | 'already-there' | 'unchang
 export declare function listDevices(devices: DeviceListVerb | null | undefined, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceListOutcome>;
-export declare function readSessionBinding(devices: DeviceSessionBindingVerb | null | undefined, rootSessionId: string, opts?: {
+export declare function readSessionBinding(sessions: SessionExecutionPlacementVerb | null | undefined, rootSessionId: string, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceSessionBindingOutcome>;
 export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {

package/dist/deviceRebind.js

@@ -1,10 +1,14 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
-import { isDisplayableWireCode, readErrorString, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
+import { isDisplayableWireCode, readErrorString, readErrorStrictStringList, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
+import { EXECUTION_PLACEMENT_DEVICE_LANE, EXECUTION_PLACEMENT_ROLES } from './executionPlacementWords.js';
 const LANE_ABSENT = 'capability.device_lane_required';
 const RUN_STORE_ABSENT = 'capability.run_store_required';
 const NOT_FOUND = 'not_found.device';
 const ACTIVE_RUN = 'device.rebind_active_run';
+const SESSION_NOT_FOUND = 'not_found.session';
+const ROUTE_ABSENT = 'not_found.route';
+const SESSION_STORE_ABSENT = 'capability.session_store_required';
 const REV_CONFLICT = 'device.rebind_rev_conflict';
 const SERVICE_TOKEN_REQUIRED = 'auth.service_token_required';
 function own(v, key) {
@@ -123,29 +127,50 @@ function bindingOf(raw) {
     const rev = nonNegInt(own(raw, 'rev'));
     if (deviceId === undefined || rev === undefined)
         return null;
-    const boundAt = nonEmpty(own(raw, 'boundAt'));
-    return { deviceId, rev, ...(boundAt !== undefined ? { boundAt } : {}) };
+    return { deviceId, rev };
 }
-export async function readSessionBinding(devices, rootSessionId, opts) {
-    const verb = verbOf(devices, 'sessionBinding');
+function placementReadFailureOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    if (v.status === 404 && v.code === SESSION_NOT_FOUND)
+        return { kind: 'not-found' };
+    if (v.status === 404 && v.code === ROUTE_ABSENT)
+        return { kind: 'unsupported', reason: 'route' };
+    if (v.status === 501 && v.code === SESSION_STORE_ABSENT)
+        return { kind: 'unsupported', reason: 'capability' };
+    return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
+}
+const isPlacementRole = (v) => typeof v === 'string' && EXECUTION_PLACEMENT_ROLES.includes(v);
+export async function readSessionBinding(sessions, rootSessionId, opts) {
+    if (typeof rootSessionId !== 'string' || rootSessionId === '') {
+        return { kind: 'refused', status: 0, errorCode: 'request.id_invalid', message: 'the session id to read the execution placement of must be a non-empty string — nothing was sent' };
+    }
+    const verb = verbOf(sessions, 'executionPlacement');
     if (verb === undefined)
         return { kind: 'unarmed' };
     let body;
     try {
-        body = await verb.call(devices, rootSessionId, signalOpts(opts));
+        body = await verb.call(sessions, rootSessionId, signalOpts(opts));
     }
     catch (e) {
-        return readFailureOf(e);
+        return placementReadFailureOf(e);
+    }
+    const role = own(body, 'role');
+    if (!isPlacementRole(role)) {
+        return { kind: 'unreadable', why: 'the execution placement it returned names no role this client knows (absent / writer / mirror / forking) — refusing to read it as "not bound"' };
     }
-    const rid = own(body, 'rootSessionId');
-    if (typeof rid !== 'string' || rid !== rootSessionId) {
-        return { kind: 'unreadable', why: "the binding it returned does not echo the session id that was asked for — refusing to use another session's binding as this one's prior state" };
+    if (role !== 'writer')
+        return { kind: 'unbound', role };
+    const lane = own(body, 'lane');
+    if (typeof lane !== 'string' || lane === '') {
+        return { kind: 'unreadable', why: "the writer's execution lane in the execution placement is missing or not a word — refusing to guess whether a device is bound" };
     }
-    const bound = bindingOf(own(body, 'boundDevice'));
+    if (lane !== EXECUTION_PLACEMENT_DEVICE_LANE)
+        return { kind: 'unbound', role };
+    const bound = bindingOf(own(body, 'device'));
     if (bound === null) {
-        return { kind: 'unreadable', why: 'the binding it returned has no usable prior state (deviceId + rev) — refusing to treat it as a binding' };
+        return { kind: 'unreadable', why: 'the session is written on the device lane but the execution placement names no readable device (deviceId + rev) — the device is unknown, not unbound' };
     }
-    return { kind: 'ok', rootSessionId: rid, boundDevice: bound };
+    return { kind: 'ok', rootSessionId, boundDevice: bound };
 }
 function rebindFailureOf(e) {
     const v = atMostOnceVerdictOf(e);
@@ -155,7 +180,11 @@ function rebindFailureOf(e) {
         return common;
     if (status === 409 && code === ACTIVE_RUN) {
         const activeTaskId = nonEmpty(own(e, 'activeTaskId'));
-        return { kind: 'active-run', ...(activeTaskId !== undefined ? { activeTaskId } : {}) };
+        if (activeTaskId !== undefined)
+            return { kind: 'active-run', activeTaskId };
+        const children = e !== null && typeof e === 'object' ? readErrorStrictStringList(e, 'children') : undefined;
+        const retirePath = e !== null && typeof e === 'object' ? nonEmpty(readErrorString(e, 'retirePath')) : undefined;
+        return { kind: 'active-run', ...(children !== undefined && retirePath !== undefined ? { children: Object.freeze([...children]), retirePath } : {}) };
     }
     if (status === 409 && code === REV_CONFLICT) {
         const currentRev = nonNegInt(own(e, 'currentRev'));

package/dist/engineAgentAbsence.d.ts

@@ -55,6 +55,7 @@ export interface EngineAgentRegistryRowView {
     readonly status: string;
     readonly description?: string;
     readonly createdAt?: number;
+    readonly sessionId?: string;
 }
 export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'capability_unknown' | 'route_absent' | 'ownership_required' | 'read_failed';
 export type EngineAgentRegistryListing = {

package/dist/executionPlacementWords.d.ts

@@ -0,0 +1,3 @@
+export declare const EXECUTION_PLACEMENT_ROLES: readonly ["absent", "writer", "mirror", "forking"];
+export type ExecutionPlacementRole = (typeof EXECUTION_PLACEMENT_ROLES)[number];
+export declare const EXECUTION_PLACEMENT_DEVICE_LANE = "device";

package/dist/executionPlacementWords.js

@@ -0,0 +1,2 @@
+export const EXECUTION_PLACEMENT_ROLES = Object.freeze(['absent', 'writer', 'mirror', 'forking']);
+export const EXECUTION_PLACEMENT_DEVICE_LANE = 'device';

package/dist/generated/engineFactTables.d.ts

@@ -23,6 +23,7 @@ export interface CoreModeArbitrationRow {
     readonly hookAskFloor: boolean;
 }
 export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "target_unresolved" | "probe" | "write_protection_on_disk" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const CORE_REAL_APPROVAL_ASK_CLASSES: readonly ["ancestor", "dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "rule_unreadable", "denial_limit_fallback", "classifier_no_ruling", "requires_user_interaction", "cross_boundary", "policy_rra", "artifact_shared_read"];
 export declare const CORE_SKILL_GRANT_ORIGINS: readonly ["model", "user", "inherited"];
 export declare const CORE_ALLOW_ENTRY_INERT_REASONS: readonly ["wildcard_all", "namespace_wildcard", "content_unsupported", "grammar", "tool_name", "near_miss", "earlier_grammar"];
 export declare const CORE_ALLOW_RULE_MEMBERS: readonly ["hook", "deployment", "persisted", "skill", "request"];
@@ -37,7 +38,7 @@ export declare const CORE_TASK_HANDLE_PREFIXES: Readonly<Record<"background_bash
 export declare const CORE_PERMISSION_MODE_CLASSES: readonly ["bypass", "prompting"];
 export declare const CORE_MCP_LIVENESS_STATES: readonly ["reachable", "unreachable", "unknown"];
 export declare const CORE_RULE_BEHAVIORS: readonly ["deny", "ask", "allow"];
-export declare const CORE_MCP_IMAGE_MAX_BASE64: number;
+export declare const CORE_IMAGE_ADMISSION_HARD_IMAGE_BASE64_CHARS: number;
 export declare const CORE_MAX_PENDING_STEER_CHARS: number;
 export declare const CORE_PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];
 export declare const CORE_PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
@@ -48,7 +49,7 @@ export declare const CORE_RESUME_STARTUP_CAUSES: readonly ["environment", "sessi
 export declare const CORE_BUILTIN_SUBAGENT_TYPES: readonly ["Explore", "Plan", "fork", "general-purpose"];
 export declare const CORE_RULE_OFFERS_ABSENCES: readonly ["mandated", "allow_outranked", "ask_rule_matched", "lane_cannot_speak"];
 export declare const CORE_TOOL_APPROVAL_CARDS: readonly ["file-edit", "file-write", "notebook-edit", "shell", "fetch", "skill", "workflow", "plan", "question", "generic"];
-export declare const CORE_MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "unknown"];
+export declare const CORE_MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "unknown"];
 export declare const CORE_MCP_AUTHORIZATION_REASONS: readonly ["rejected", "scope", "none"];
 export declare const CORE_PERSISTED_RULE_MATCHES: readonly ["exact", "prefix", "wildcard", "pattern", "subpath", "path", "name", "name_prefix", "host", "subdomain", "tool"];
 export declare const CORE_APPROVAL_REMEDY_KINDS: readonly ["approver", "permission_mode"];

package/dist/generated/engineFactTables.js

@@ -200,6 +200,21 @@ export const CORE_MODE_ARBITRATION = Object.freeze({
     "unstated": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: true, hookAskFloor: false }),
     "ordinary": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: true, hookAskFloor: false }),
 });
+export const CORE_REAL_APPROVAL_ASK_CLASSES = Object.freeze([
+    "ancestor",
+    "dangerous_delete",
+    "unverifiable_delete",
+    "unverifiable_shell_text",
+    "transcript_write",
+    "org_rule",
+    "rule_unreadable",
+    "denial_limit_fallback",
+    "classifier_no_ruling",
+    "requires_user_interaction",
+    "cross_boundary",
+    "policy_rra",
+    "artifact_shared_read",
+]);
 export const CORE_SKILL_GRANT_ORIGINS = Object.freeze([
     "model",
     "user",
@@ -286,7 +301,7 @@ export const CORE_RULE_BEHAVIORS = Object.freeze([
     "ask",
     "allow",
 ]);
-export const CORE_MCP_IMAGE_MAX_BASE64 = 5242880;
+export const CORE_IMAGE_ADMISSION_HARD_IMAGE_BASE64_CHARS = 5242880;
 export const CORE_MAX_PENDING_STEER_CHARS = 16000;
 export const CORE_PROMPT_BLOCK_CAUSES = Object.freeze([
     "block",
@@ -364,6 +379,7 @@ export const CORE_MCP_FAILURE_KINDS = Object.freeze([
     "protocol",
     "invalid_config",
     "credential_unavailable",
+    "host_refused",
     "unknown",
 ]);
 export const CORE_MCP_AUTHORIZATION_REASONS = Object.freeze([

package/dist/generated/engineNoticeTables.js

@@ -17,6 +17,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "config.write_protection_target_view_absent",
     "config.path_view_unresolved",
     "config.execution_env_capability_invalid",
+    "config.read_deny_floor_unkept",
     "config.tool_card_undeclared",
     "config.tool_face_undeclared",
     "config.tool_face_invalid",
@@ -42,6 +43,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "peer.idle_subscription",
     "classifier.denial_limit",
     "classifier.fallback",
+    "classifier.seat_rate_limited",
     "classifier.role_defaulted",
     "classifier.contract_broken",
     "classifier.unavailable",
@@ -52,6 +54,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "mcp.revocation_probe_failed",
     "mcp.server_redialed",
     "mcp.authorization_required",
+    "mcp.credential_echoed",
     "workflow.governance_key_stripped",
     "workflow.agent_option_ignored",
     "memory.session_polluted",
@@ -100,6 +103,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "agents.listing_truncated",
     "tool_result.offload_put_failed",
     "tool_result.media_refused",
+    "config.image_processor_unavailable",
     "instructions.source_changed",
     "session.records_skipped",
     "memory.layer_locked_legacy",
@@ -125,6 +129,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "config.write_protection_target_view_absent": "operator",
     "config.path_view_unresolved": "operator",
     "config.execution_env_capability_invalid": "operator",
+    "config.read_deny_floor_unkept": "operator",
     "config.tool_card_undeclared": "operator",
     "config.tool_face_undeclared": "operator",
     "config.tool_face_invalid": "operator",
@@ -150,6 +155,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "peer.idle_subscription": "user",
     "classifier.denial_limit": "user",
     "classifier.fallback": "operator",
+    "classifier.seat_rate_limited": "operator",
     "classifier.role_defaulted": "operator",
     "classifier.contract_broken": "operator",
     "classifier.unavailable": "user",
@@ -160,6 +166,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "mcp.revocation_probe_failed": "operator",
     "mcp.server_redialed": "operator",
     "mcp.authorization_required": "user",
+    "mcp.credential_echoed": "operator",
     "workflow.governance_key_stripped": "operator",
     "workflow.agent_option_ignored": "operator",
     "memory.session_polluted": "user",
@@ -208,6 +215,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "agents.listing_truncated": "operator",
     "tool_result.offload_put_failed": "operator",
     "tool_result.media_refused": "operator",
+    "config.image_processor_unavailable": "operator",
     "instructions.source_changed": "user",
     "session.records_skipped": "user",
     "memory.layer_locked_legacy": "operator",
@@ -239,6 +247,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "config.write_protection_target_view_absent": "engine",
     "config.path_view_unresolved": "engine",
     "config.execution_env_capability_invalid": "engine",
+    "config.read_deny_floor_unkept": "engine",
     "config.tool_card_undeclared": "engine",
     "config.tool_face_undeclared": "engine",
     "config.tool_face_invalid": "engine",
@@ -264,6 +273,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "peer.idle_subscription": "engine",
     "classifier.denial_limit": "engine",
     "classifier.fallback": "engine",
+    "classifier.seat_rate_limited": "engine",
     "classifier.role_defaulted": "engine",
     "classifier.contract_broken": "engine",
     "classifier.unavailable": "engine",
@@ -274,6 +284,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "mcp.revocation_probe_failed": "engine",
     "mcp.server_redialed": "engine",
     "mcp.authorization_required": "engine",
+    "mcp.credential_echoed": "engine",
     "workflow.governance_key_stripped": "engine",
     "workflow.agent_option_ignored": "engine",
     "memory.session_polluted": "engine",
@@ -322,6 +333,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "agents.listing_truncated": "engine",
     "tool_result.offload_put_failed": "engine",
     "tool_result.media_refused": "engine",
+    "config.image_processor_unavailable": "engine",
     "instructions.source_changed": "server",
     "session.records_skipped": "server",
     "memory.layer_locked_legacy": "server",

package/dist/hitl/automaticAnswerVerdict.js

@@ -1,4 +1,4 @@
-import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS } from '../generated/engineFactTables.js';
+import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS, CORE_REAL_APPROVAL_ASK_CLASSES } from '../generated/engineFactTables.js';
 import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from '../generated/engineAskFaceTables.js';
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
 import { msg, renderMessage } from '../i18n/translate.js';
@@ -60,12 +60,13 @@ export function foldModeArbitrationRow(classes, askFace) {
         return ORDINARY_ROW;
     return Object.freeze({ bypassImmune, classifierEligible, sandboxAdmission, ruleMayClear, hookAskFloor });
 }
-function rowBlocks(lane, row) {
-    return lane === 'mode_posture' ? row.bypassImmune : !row.ruleMayClear;
-}
+const REAL_APPROVAL_CLASSES = new Set(CORE_REAL_APPROVAL_ASK_CLASSES);
 function classBlocks(lane, c, face) {
-    const row = TABLE[c];
-    return lane === 'mode_posture' ? bypassImmuneOn(c, face) : !row.ruleMayClear;
+    if (lane === 'mode_posture')
+        return bypassImmuneOn(c, face);
+    if (lane === 'standing_rule')
+        return !TABLE[c].ruleMayClear;
+    return REAL_APPROVAL_CLASSES.has(c);
 }
 function mustAsk(road, extra) {
     return Object.freeze({ kind: 'must_ask', road, ...(extra?.askClass !== undefined ? { askClass: extra.askClass } : {}), ...(extra?.origin !== undefined ? { origin: extra.origin } : {}) });
@@ -88,6 +89,42 @@ function evidenceView(card, ...keys) {
     }
     return out;
 }
+const SLOT_ABSENT = Object.freeze({ kind: 'absent' });
+const SLOT_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const EVIDENCE_CHAIN_MAX = 32;
+function evidenceSlotOf(o, key) {
+    let at = o;
+    for (let depth = 0; at !== null; depth++) {
+        if (depth >= EVIDENCE_CHAIN_MAX)
+            return SLOT_UNREADABLE;
+        const d = Object.getOwnPropertyDescriptor(at, key);
+        if (d !== undefined)
+            return Object.hasOwn(d, 'value') ? Object.freeze({ kind: 'data', value: d.value }) : SLOT_UNREADABLE;
+        at = Object.getPrototypeOf(at);
+    }
+    return SLOT_ABSENT;
+}
+const EVIDENCE_BOOLEAN_KEYS = Object.freeze(['requiresRealApproval', 'governanceForced', 'mandated']);
+const EVIDENCE_STRING_KEYS = Object.freeze(['origin', 'ruleOffersAbsence', 'mandate']);
+function evidenceUnreadable(card) {
+    for (const k of EVIDENCE_BOOLEAN_KEYS) {
+        const slot = evidenceSlotOf(card, k);
+        if (slot.kind === 'unreadable' || (slot.kind === 'data' && slot.value !== undefined && typeof slot.value !== 'boolean'))
+            return true;
+    }
+    for (const k of EVIDENCE_STRING_KEYS) {
+        const slot = evidenceSlotOf(card, k);
+        if (slot.kind === 'unreadable' || (slot.kind === 'data' && slot.value !== undefined && (typeof slot.value !== 'string' || slot.value === '')))
+            return true;
+    }
+    const risk = evidenceSlotOf(card, 'risk');
+    if (risk.kind === 'absent' || (risk.kind === 'data' && risk.value === undefined))
+        return false;
+    if (risk.kind === 'unreadable' || typeof risk.value !== 'object' || risk.value === null)
+        return true;
+    const nested = evidenceSlotOf(risk.value, 'requiresRealApproval');
+    return nested.kind !== 'data' || typeof nested.value !== 'boolean';
+}
 function readHostAskRuleMatched(facts) {
     if (typeof facts !== 'object' || facts === null)
         return undefined;
@@ -138,14 +175,14 @@ export function automaticAnswerVerdict(card, lane, facts) {
                     return mustAsk('allow_rule_shadow');
             }
         }
+        if (evidenceUnreadable(card))
+            return UNKNOWN.card_unreadable;
         const pair = readAskClassPairState(card);
         if (pair.state === 'malformed')
             return UNKNOWN.classes_malformed;
         if (pair.state === 'absent')
             return UNKNOWN.classes_absent;
         const classes = pair.classes;
-        const folded = foldModeArbitrationRow(classes, face);
-        let anyKnown = false;
         let firstBlocking;
         let anyUnknown = false;
         for (const c of classes) {
@@ -153,12 +190,11 @@ export function automaticAnswerVerdict(card, lane, facts) {
                 anyUnknown = true;
                 continue;
             }
-            anyKnown = true;
             if (firstBlocking === undefined && classBlocks(lane, c, face))
                 firstBlocking = c;
         }
-        if (anyKnown && rowBlocks(lane, folded))
-            return mustAsk('ask_class', firstBlocking !== undefined ? { askClass: firstBlocking } : undefined);
+        if (firstBlocking !== undefined)
+            return mustAsk('ask_class', { askClass: firstBlocking });
         if (anyUnknown)
             return UNKNOWN.class_not_in_table;
         if (lane !== 'mode_posture')

package/dist/hitl/sessionPolicyDeliverable.js

@@ -2,6 +2,7 @@ import { rosterMountedNames } from '../rosterMountedNames.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { readOwnDataValue } from '../ownKey.js';
 import { denyEntryReading, ruleCompileVerdict } from '../ruleCompileVerdict.js';
+import { hasCoreValuePort, ruleNameCovers } from '../coreValuePorts.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
 import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
@@ -13,7 +14,7 @@ const WITHHELD_NOTICE = {
     wildcard: 'Not written to this session’s rule record: this rule uses a wildcard (*), and an engine that matches that record by exact tool name would block none of the tools it covers.',
     not_a_tool_name: 'Not written to this session’s rule record: this entry is not exactly one tool name — it is empty, not text, has spaces around the name, is not a single tool name in rule syntax (for example it contains a backslash or a parenthesis, or is longer than a rule can be), or spells its server or agent peer part in a way the engine never uses when naming tools (for example with a dot or a space), so no tool would ever match it.',
     legacy_tool_name: `Not written to this session’s rule record: unless a tool by exactly this name is available, the engine refuses it — it is a retired tool name, or it contains "__" but does not start with ${PREFIXES_IN_PROSE} — and with it in that record every later run of this session would fail at startup until that entry is removed from the record. ${REFUSED_NAME_FIX}`,
-    not_in_roster: 'Not written to this session’s rule record: the tool roster supplied for this check has no tool by exactly this name, as a name or an alias, with letter case counted — it may be misspelled, or name a tool this deployment does not provide — so recorded as it is it would block nothing here.',
+    not_in_roster: 'Not written to this session’s rule record: the tool roster supplied for this check has no tool this rule would block — no tool by exactly this name, as a name or an alias, with letter case counted, and, where the engine also reads the name as naming every tool of a server (a server whose own name contains "__"), no tool of that server either — it may be misspelled, or name a tool this deployment does not provide — so recorded as it is it would block nothing here.',
     namespace_covering_unconfirmed: msg('session.policy.withheld.namespaceCoveringUnconfirmed'),
 };
 export const SESSION_POLICY_WITHHELD_WHY = Object.freeze(Object.keys(WITHHELD_NOTICE));
@@ -151,11 +152,14 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
                 why = 'not_a_tool_name';
         }
         let inertReason;
+        let coveringRow = false;
         if (engineAsked) {
             const reading = entryReadingOf(r);
             if (reading === 'unknown')
                 return unreadable();
-            if (reading !== 'row') {
+            if (reading === 'covering')
+                coveringRow = true;
+            else if (reading !== 'row') {
                 inertReason = reading.reason;
                 if (why === undefined)
                     why = reading.why;
@@ -168,8 +172,13 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
             if (grammar === 'refused')
                 why = 'not_a_tool_name';
         }
-        if (why === undefined && mounted !== undefined && !mounted.has(r) && covering === undefined)
-            why = 'not_in_roster';
+        if (why === undefined && mounted !== undefined && !mounted.has(r) && covering === undefined) {
+            const reach = coveringRow ? coveredRosterName(r, mounted) : 'none';
+            if (reach === 'unknown')
+                return unreadable();
+            if (reach === 'none')
+                why = 'not_in_roster';
+        }
         if (why === undefined)
             exact.push(r);
         else {
@@ -189,12 +198,29 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
 function entryReadingOf(rule) {
     const reading = denyEntryReading(rule);
     if (reading.kind === 'row')
-        return 'row';
+        return reading.covering === true ? 'covering' : 'row';
     if (reading.kind === 'unknown')
         return 'unknown';
     const reason = reading.reason;
     return reason === 'grammar' || reason === 'content_unsupported' ? { why: 'not_a_tool_name', reason } : { why: 'wildcard', reason };
 }
+function coveredRosterName(rule, mounted) {
+    if (!hasCoreValuePort('ruleNameCovers'))
+        return 'unknown';
+    try {
+        for (const name of mounted) {
+            const v = ruleNameCovers(rule, name);
+            if (v === true)
+                return 'covers';
+            if (v !== false)
+                return 'unknown';
+        }
+        return 'none';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 export function sessionPolicyWithheldNotice(why, lang) {
     if (typeof why === 'string' && Object.hasOwn(WITHHELD_NOTICE, why)) {
         const sentence = WITHHELD_NOTICE[why];