@sema-agent/client-core 0.85.2 → 0.87.0

package/dist/engineErrorCodes.js

@@ -1,4 +1,5 @@
 import { frozenSet } from './frozenSet.js';
+import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -9,6 +10,7 @@ export function isLimitsExceededCode(code) {
 }
 export const USAGE_WINDOW_EXHAUSTED = 'usage.window_exhausted';
 export const ENV_LIFETIME_EXPIRED = 'env.lifetime_expired';
+export const FLEET_LEASE_UNAVAILABLE = 'fleet.lease_unavailable';
 export const CONFIG_LIMIT_INVALID = 'config.limit_invalid';
 export const CONFIG_STRATEGY_FIND_LIMIT_INVALID = 'config.strategy_find_limit_invalid';
 export const CONFIG_STRATEGY_MAX_SIZE_INVALID = 'config.strategy_max_size_invalid';
@@ -26,7 +28,13 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
+    ...CORE_TOOL_DECLARATION_CODES,
 ]);
+export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
+const RULES_ERROR_CODE_PREFIX = 'rules.';
+export function isRulesRefusalCode(code) {
+    return typeof code === 'string' && code.startsWith(RULES_ERROR_CODE_PREFIX);
+}
 export const DELEGATION_CONCURRENCY_CAP = 'delegation.concurrency_cap';
 export const DELEGATION_SESSION_CAP = 'delegation.session_cap';
 export const DELEGATION_CAP_CODES = frozenSet([

package/dist/engineNoticeCodes.d.ts

@@ -19,6 +19,7 @@ export interface AskUnresolvableFactsView {
     toolCallId: string;
     cause: string;
     parkLaneExisted?: boolean;
+    remedy?: string;
 }
 export declare function readAskUnresolvable(notice: unknown): AskUnresolvableFactsView | undefined;
 export declare const DURABLE_MANDATE_SOURCES: readonly string[];
@@ -81,6 +82,61 @@ export interface SessionRecordsSkippedFactsView {
 }
 export declare function readSessionRecordsSkipped(notice: unknown): SessionRecordsSkippedFactsView | undefined;
 export declare function sessionRecordsSkippedNote(facts: Pick<SessionRecordsSkippedFactsView, 'entriesKept'>): string | undefined;
+export interface RuleStoreUnavailableFactsView {
+    at: string;
+    sessionId: string;
+    runId: string;
+}
+export declare function readRuleStoreUnavailable(notice: unknown): RuleStoreUnavailableFactsView | undefined;
+declare const CLASSIFIER_UNAVAILABLE_DISPOSITIONS: readonly ["asked", "denied"];
+type ClassifierUnavailableDispositionWord = (typeof CLASSIFIER_UNAVAILABLE_DISPOSITIONS)[number];
+export interface ClassifierUnavailableFactsView {
+    toolName: string;
+    toolCallId: string;
+    cause: string;
+    disposition: ClassifierUnavailableDispositionWord;
+    sessionId?: string;
+    runId?: string;
+}
+export declare function readClassifierUnavailable(notice: unknown): ClassifierUnavailableFactsView | undefined;
+export declare const PERMISSION_MODE_FOLD_REASONS: readonly string[];
+export interface PermissionModeUnavailableFactsView {
+    requested: string;
+    effective: string;
+    by: string;
+    sessionId: string;
+    runId: string;
+    childSessionId?: string;
+}
+export declare function readPermissionModeUnavailable(notice: unknown): PermissionModeUnavailableFactsView | undefined;
+export interface AskReleasedByModeFactsView {
+    mode: string;
+    askClass: string;
+    origin?: string;
+    mandate?: string;
+    count: number;
+    firstToolCallId: string;
+    sessionId?: string;
+    runId?: string;
+}
+export declare function readAskReleasedByMode(notice: unknown): AskReleasedByModeFactsView | undefined;
+export interface ReadDenyUnappliedFactsView {
+    mode: string;
+    toolCallId: string;
+    tiers: readonly string[];
+    rows: readonly string[];
+    rowCount: number;
+    sessionId: string;
+    runId: string;
+}
+export declare function readReadDenyUnapplied(notice: unknown): ReadDenyUnappliedFactsView | undefined;
+export interface LegacyModeSeedMigratedFactsView {
+    permissionMode?: string;
+    droppedKeys: readonly string[];
+    sessionId: string;
+    runId: string;
+}
+export declare function readLegacyModeSeedMigrated(notice: unknown): LegacyModeSeedMigratedFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -91,6 +147,12 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'approval.read_root_granted': typeof readReadRootGrantNotice;
     readonly 'approval.read_root_grant_rejected': typeof readReadRootGrantNotice;
     readonly 'session.records_skipped': typeof readSessionRecordsSkipped;
+    readonly 'permission.rule_store_unavailable': typeof readRuleStoreUnavailable;
+    readonly 'classifier.unavailable': typeof readClassifierUnavailable;
+    readonly 'config.permission_mode_unavailable': typeof readPermissionModeUnavailable;
+    readonly 'permission.ask_released_by_mode': typeof readAskReleasedByMode;
+    readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
+    readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -1,4 +1,6 @@
+import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE } from './generated/engineNoticeTables.js';
+import { CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
 export const SERVER_NOTICE_AUDIENCE = Object.freeze({
@@ -30,20 +32,28 @@ export function readMcpInjectionDrop(notice) {
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
-    const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
-    const server = typeof o.server === 'string' && o.server.length > 0 ? o.server : undefined;
-    const reason = typeof o.reason === 'string' && DROP_REASONS.has(o.reason) ? o.reason : undefined;
+    const sessionIdIn = o.sessionId;
+    const serverIn = o.server;
+    const reasonIn = o.reason;
+    const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
+    const server = typeof serverIn === 'string' && serverIn.length > 0 ? serverIn : undefined;
+    const reason = typeof reasonIn === 'string' && DROP_REASONS.has(reasonIn) ? reasonIn : undefined;
     if (sessionId === undefined || server === undefined || reason === undefined)
         return undefined;
-    const field = typeof o.field === 'string' && o.field.length > 0 ? o.field : undefined;
+    const fieldIn = o.field;
+    const field = typeof fieldIn === 'string' && fieldIn.length > 0 ? fieldIn : undefined;
     return { sessionId, server, reason, ...(field !== undefined ? { field } : {}) };
 }
-export const ASK_UNRESOLVABLE_CAUSES = Object.freeze([
-    'approver_unavailable',
-    'no_approver_wired',
-    'mandate_unreconstructible',
-]);
+export const ASK_UNRESOLVABLE_CAUSES = CORE_ASK_UNRESOLVABLE_CAUSES;
 const ASK_UNRESOLVABLE_CAUSE_SET = new Set(ASK_UNRESOLVABLE_CAUSES);
+function optionalSeat(o, key) {
+    try {
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
 export function readAskUnresolvable(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
@@ -54,25 +64,29 @@ export function readAskUnresolvable(notice) {
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
-    const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
-    const toolName = typeof o.toolName === 'string' && o.toolName.length > 0 ? o.toolName : undefined;
-    const toolCallId = typeof o.toolCallId === 'string' && o.toolCallId.length > 0 ? o.toolCallId : undefined;
-    const cause = typeof o.cause === 'string' && ASK_UNRESOLVABLE_CAUSE_SET.has(o.cause) ? o.cause : undefined;
+    const sessionIdIn = o.sessionId;
+    const toolNameIn = o.toolName;
+    const toolCallIdIn = o.toolCallId;
+    const causeIn = o.cause;
+    const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
+    const toolName = typeof toolNameIn === 'string' && toolNameIn.length > 0 ? toolNameIn : undefined;
+    const toolCallId = typeof toolCallIdIn === 'string' && toolCallIdIn.length > 0 ? toolCallIdIn : undefined;
+    const cause = typeof causeIn === 'string' && ASK_UNRESOLVABLE_CAUSE_SET.has(causeIn) ? causeIn : undefined;
     if (sessionId === undefined || toolName === undefined || toolCallId === undefined || cause === undefined) {
         return undefined;
     }
+    const parkIn = o.parkLaneExisted;
+    const remedyIn = optionalSeat(o, 'remedy');
     return {
         sessionId,
         toolName,
         toolCallId,
         cause,
-        ...(typeof o.parkLaneExisted === 'boolean' ? { parkLaneExisted: o.parkLaneExisted } : {}),
+        ...(typeof parkIn === 'boolean' ? { parkLaneExisted: parkIn } : {}),
+        ...(typeof remedyIn === 'string' && remedyIn.length > 0 ? { remedy: remedyIn } : {}),
     };
 }
-export const DURABLE_MANDATE_SOURCES = Object.freeze([
-    'force_durable_gate',
-    'durable_approval',
-]);
+export const DURABLE_MANDATE_SOURCES = CORE_DURABLE_MANDATE_SOURCES;
 const DURABLE_MANDATE_SOURCE_SET = new Set(DURABLE_MANDATE_SOURCES);
 export function readDurableGateUnavailable(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
@@ -84,26 +98,41 @@ export function readDurableGateUnavailable(notice) {
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
-    const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
-    const runId = typeof o.runId === 'string' && o.runId.length > 0 ? o.runId : undefined;
-    const source = typeof o.source === 'string' && DURABLE_MANDATE_SOURCE_SET.has(o.source) ? o.source : undefined;
-    const cause = typeof o.cause === 'string' && o.cause.length > 0 ? o.cause : undefined;
+    const sessionIdIn = o.sessionId;
+    const runIdIn = o.runId;
+    const sourceIn = o.source;
+    const causeIn = o.cause;
+    const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
+    const runId = typeof runIdIn === 'string' && runIdIn.length > 0 ? runIdIn : undefined;
+    const source = typeof sourceIn === 'string' && DURABLE_MANDATE_SOURCE_SET.has(sourceIn) ? sourceIn : undefined;
+    const cause = typeof causeIn === 'string' && causeIn.length > 0 ? causeIn : undefined;
     if (sessionId === undefined || runId === undefined || source === undefined || cause === undefined) {
         return undefined;
     }
-    const principal = typeof o.principal === 'string' && o.principal.length > 0 ? o.principal : undefined;
+    const principalIn = o.principal;
+    const principal = typeof principalIn === 'string' && principalIn.length > 0 ? principalIn : undefined;
+    const liveApprover = o.liveApprover;
+    const liveQuestionFace = o.liveQuestionFace;
     return {
         sessionId,
         runId,
         ...(principal !== undefined ? { principal } : {}),
         source,
         cause,
-        ...(typeof o.liveApprover === 'boolean' ? { liveApprover: o.liveApprover } : {}),
-        ...(typeof o.liveQuestionFace === 'boolean' ? { liveQuestionFace: o.liveQuestionFace } : {}),
+        ...(typeof liveApprover === 'boolean' ? { liveApprover } : {}),
+        ...(typeof liveQuestionFace === 'boolean' ? { liveQuestionFace } : {}),
     };
 }
 const nonNegInt = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined;
-const nameList = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string' && x.length > 0) ? Object.freeze([...v]) : undefined;
+const nameList = (v) => {
+    if (!Array.isArray(v))
+        return undefined;
+    const n = v.length;
+    const copy = [];
+    for (let i = 0; i < n; i++)
+        copy.push(v[i]);
+    return copy.every((x) => typeof x === 'string' && x.length > 0) ? Object.freeze(copy) : undefined;
+};
 export function readSkillsListingTruncated(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
@@ -123,7 +152,8 @@ export function readSkillsListingTruncated(notice) {
         return undefined;
     }
     const descMaxChars = nonNegInt(o.descMaxChars);
-    const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
+    const sessionIdIn = o.sessionId;
+    const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
     return {
         budgetBytes,
         ...(descMaxChars !== undefined ? { descMaxChars } : {}),
@@ -148,7 +178,8 @@ export function readMcpServerRedialed(notice) {
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const count = (v) => (typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined);
     const server = str(o.server);
-    const outcome = typeof o.outcome === 'string' && MCP_REDIAL_OUTCOMES.includes(o.outcome) ? o.outcome : undefined;
+    const outcomeIn = o.outcome;
+    const outcome = typeof outcomeIn === 'string' && MCP_REDIAL_OUTCOMES.includes(outcomeIn) ? outcomeIn : undefined;
     const added = count(o.added);
     const removed = count(o.removed);
     const sessionId = str(o.sessionId);
@@ -224,7 +255,8 @@ export function readInstructionsSourceChanged(notice) {
         const o = d;
         const previous = ownPathOrNull(o, 'previous');
         const current = ownPathOrNull(o, 'current');
-        const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
+        const sessionIdIn = o.sessionId;
+        const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
         if (previous === undefined || current === undefined || sessionId === undefined)
             return undefined;
         return { previous, current, sessionId };
@@ -271,6 +303,186 @@ export function sessionRecordsSkippedNote(facts) {
     return ("None of this session's earlier entries could be read, so this turn runs with an empty context — the model sees nothing of the earlier conversation. " +
         'If that history matters, whoever operates this engine has to repair the stored log of this session.');
 }
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+function guardedRead(notice, read) {
+    try {
+        return read(notice);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readRuleStoreUnavailable(notice) {
+    return guardedRead(notice, readRuleStoreUnavailableOf);
+}
+function readRuleStoreUnavailableOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'permission.rule_store_unavailable')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const at = nonEmpty(o.at);
+    const sessionId = nonEmpty(o.sessionId);
+    const runId = nonEmpty(o.runId);
+    if (at === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    return { at, sessionId, runId };
+}
+const CLASSIFIER_UNAVAILABLE_DISPOSITIONS = Object.freeze(['asked', 'denied']);
+const _classifierDispositionPin = true;
+void _classifierDispositionPin;
+const AUTO_MODE_UNAVAILABLE_CAUSE_SET = new Set(AUTO_MODE_UNAVAILABLE_CAUSES);
+export function readClassifierUnavailable(notice) {
+    return guardedRead(notice, readClassifierUnavailableOf);
+}
+function readClassifierUnavailableOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'classifier.unavailable')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const toolName = nonEmpty(o.toolName);
+    const toolCallId = nonEmpty(o.toolCallId);
+    const causeIn = o.cause;
+    const dispositionIn = o.disposition;
+    const cause = typeof causeIn === 'string' && AUTO_MODE_UNAVAILABLE_CAUSE_SET.has(causeIn) ? causeIn : undefined;
+    const disposition = CLASSIFIER_UNAVAILABLE_DISPOSITIONS.includes(dispositionIn)
+        ? dispositionIn
+        : undefined;
+    if (toolName === undefined || toolCallId === undefined || cause === undefined || disposition === undefined)
+        return undefined;
+    const sessionId = nonEmpty(optionalSeat(o, 'sessionId'));
+    const runId = nonEmpty(optionalSeat(o, 'runId'));
+    return {
+        toolName,
+        toolCallId,
+        cause,
+        disposition,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(runId !== undefined ? { runId } : {}),
+    };
+}
+export const PERMISSION_MODE_FOLD_REASONS = CORE_PERMISSION_MODE_FOLD_REASONS;
+const PERMISSION_MODE_FOLD_REASON_SET = new Set(PERMISSION_MODE_FOLD_REASONS);
+export function readPermissionModeUnavailable(notice) {
+    return guardedRead(notice, readPermissionModeUnavailableOf);
+}
+function readPermissionModeUnavailableOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'config.permission_mode_unavailable')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const requested = nonEmpty(o.requested);
+    const effective = nonEmpty(o.effective);
+    const byIn = o.by;
+    const by = typeof byIn === 'string' && PERMISSION_MODE_FOLD_REASON_SET.has(byIn) ? byIn : undefined;
+    const sessionId = nonEmpty(o.sessionId);
+    const runId = nonEmpty(o.runId);
+    if (requested === undefined || effective === undefined || by === undefined || sessionId === undefined || runId === undefined) {
+        return undefined;
+    }
+    const childSessionId = nonEmpty(optionalSeat(o, 'childSessionId'));
+    return { requested, effective, by, sessionId, runId, ...(childSessionId !== undefined ? { childSessionId } : {}) };
+}
+export function readAskReleasedByMode(notice) {
+    return guardedRead(notice, readAskReleasedByModeOf);
+}
+function readAskReleasedByModeOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'permission.ask_released_by_mode')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const mode = nonEmpty(o.mode);
+    const askClass = nonEmpty(o.askClass);
+    const count = nonNegInt(o.count);
+    const firstToolCallId = nonEmpty(o.firstToolCallId);
+    if (mode === undefined || askClass === undefined || count === undefined || count < 1 || firstToolCallId === undefined) {
+        return undefined;
+    }
+    const origin = nonEmpty(optionalSeat(o, 'origin'));
+    const mandate = nonEmpty(optionalSeat(o, 'mandate'));
+    const sessionId = nonEmpty(optionalSeat(o, 'sessionId'));
+    const runId = nonEmpty(optionalSeat(o, 'runId'));
+    return {
+        mode,
+        askClass,
+        ...(origin !== undefined ? { origin } : {}),
+        ...(mandate !== undefined ? { mandate } : {}),
+        count,
+        firstToolCallId,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(runId !== undefined ? { runId } : {}),
+    };
+}
+export function readReadDenyUnapplied(notice) {
+    return guardedRead(notice, readReadDenyUnappliedOf);
+}
+function readReadDenyUnappliedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'permission.read_deny_unapplied')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const mode = nonEmpty(o.mode);
+    const toolCallId = nonEmpty(o.toolCallId);
+    const tiers = nameList(o.tiers);
+    const rows = nameList(o.rows);
+    const rowCount = nonNegInt(o.rowCount);
+    const sessionId = nonEmpty(o.sessionId);
+    const runId = nonEmpty(o.runId);
+    if (mode === undefined || toolCallId === undefined || tiers === undefined || rows === undefined ||
+        rowCount === undefined || sessionId === undefined || runId === undefined) {
+        return undefined;
+    }
+    return { mode, toolCallId, tiers, rows, rowCount, sessionId, runId };
+}
+export function readLegacyModeSeedMigrated(notice) {
+    return guardedRead(notice, readLegacyModeSeedMigratedOf);
+}
+function readLegacyModeSeedMigratedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'resume.legacy_mode_seed_migrated')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const m = o.migrated;
+    if (typeof m !== 'object' || m === null || Array.isArray(m))
+        return undefined;
+    const mo = m;
+    const droppedKeys = nameList(mo.droppedKeys);
+    const sessionId = nonEmpty(o.sessionId);
+    const runId = nonEmpty(o.runId);
+    if (droppedKeys === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    const permissionMode = nonEmpty(optionalSeat(mo, 'permissionMode'));
+    return { ...(permissionMode !== undefined ? { permissionMode } : {}), droppedKeys, sessionId, runId };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -281,6 +493,12 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'approval.read_root_granted': readReadRootGrantNotice,
     'approval.read_root_grant_rejected': readReadRootGrantNotice,
     'session.records_skipped': readSessionRecordsSkipped,
+    'permission.rule_store_unavailable': readRuleStoreUnavailable,
+    'classifier.unavailable': readClassifierUnavailable,
+    'config.permission_mode_unavailable': readPermissionModeUnavailable,
+    'permission.ask_released_by_mode': readAskReleasedByMode,
+    'permission.read_deny_unapplied': readReadDenyUnapplied,
+    'resume.legacy_mode_seed_migrated': readLegacyModeSeedMigrated,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/executionLaneCapability.d.ts

@@ -1,6 +1,9 @@
+export type ExecutionLaneIsolatedAbsence = 'no_hands' | 'not_reported' | 'unreadable';
 export interface ExecutionLaneCapabilityView {
     provider: string;
     toolsOnThisHost: boolean;
+    isolated?: boolean;
+    isolatedAbsent?: ExecutionLaneIsolatedAbsence;
 }
 export type ExecutionLaneReading = {
     kind: 'unobserved';
@@ -11,11 +14,14 @@ export type ExecutionLaneReading = {
     view: ExecutionLaneCapabilityView;
 };
 export declare function projectExecutionLaneCapability(caps: unknown): ExecutionLaneReading | undefined;
+export declare function projectExecutionLaneWiring(wiring: unknown): ExecutionLaneReading | undefined;
 export declare function noteEngineCapsForExecutionLane(baseUrl: string, caps: unknown, opts?: {
     generation?: number;
 }): void;
 export declare function observedExecutionLane(baseUrl?: string | undefined): ExecutionLaneReading;
 export declare function toolsRunHereFromExecutionLane(reading: ExecutionLaneReading, legacyInference: boolean): boolean;
+export declare function noOsSandboxOnThisHost(reading: ExecutionLaneReading): 'yes' | 'no' | 'unknown';
+export declare function noOsSandboxContent(): string;
 export declare function executionLaneDoctorDetail(reading: ExecutionLaneReading): string;
 export declare function forgetExecutionLaneReading(baseUrl: string | undefined): void;
 export declare function __resetExecutionLaneReadingsForTests(): void;

package/dist/executionLaneCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
 export function projectExecutionLaneCapability(caps) {
     if (caps === null || typeof caps !== 'object')
         return undefined;
@@ -11,6 +11,9 @@ export function projectExecutionLaneCapability(caps) {
     const lane = caps.executionLane;
     if (lane === undefined)
         return { kind: 'not_reported' };
+    return projectExecutionLaneObject(lane, () => capsGenerationOf(caps).generation === 'new');
+}
+function projectExecutionLaneObject(lane, newGeneration) {
     if (lane === null || typeof lane !== 'object' || Array.isArray(lane))
         return undefined;
     const provider = lane.provider;
@@ -19,7 +22,33 @@ export function projectExecutionLaneCapability(caps) {
         return undefined;
     if (typeof toolsOnThisHost !== 'boolean')
         return undefined;
-    return { kind: 'present', view: { provider, toolsOnThisHost } };
+    let isolated;
+    let isolatedThrew = false;
+    try {
+        isolated = Object.hasOwn(lane, 'isolated') ? lane.isolated : undefined;
+    }
+    catch {
+        isolatedThrew = true;
+    }
+    if (!isolatedThrew && typeof isolated === 'boolean')
+        return { kind: 'present', view: { provider, toolsOnThisHost, isolated } };
+    const isolatedAbsent = isolatedThrew || isolated !== undefined ? 'unreadable' : !newGeneration() ? 'not_reported' : toolsOnThisHost ? 'unreadable' : 'no_hands';
+    return { kind: 'present', view: { provider, toolsOnThisHost, isolatedAbsent } };
+}
+export function projectExecutionLaneWiring(wiring) {
+    try {
+        if (wiring === null || typeof wiring !== 'object' || Array.isArray(wiring))
+            return undefined;
+        if (!Object.hasOwn(wiring, 'executionLane'))
+            return { kind: 'not_reported' };
+        const lane = wiring.executionLane;
+        if (lane === undefined)
+            return { kind: 'not_reported' };
+        return projectExecutionLaneObject(lane, () => true);
+    }
+    catch {
+        return undefined;
+    }
 }
 const reader = createEngineCapReader({
     name: 'executionLane',
@@ -37,6 +66,30 @@ export function toolsRunHereFromExecutionLane(reading, legacyInference) {
         return reading.view.toolsOnThisHost;
     return legacyInference;
 }
+export function noOsSandboxOnThisHost(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return 'unknown';
+    try {
+        if (reading.kind !== 'present')
+            return 'unknown';
+        const view = reading.view;
+        if (typeof view !== 'object' || view === null)
+            return 'unknown';
+        const tools = view.toolsOnThisHost;
+        const isolated = view.isolated;
+        if (tools === false || isolated === true)
+            return 'no';
+        if (tools === true && isolated === false)
+            return 'yes';
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function noOsSandboxContent() {
+    return 'Tools run directly on this machine with no OS sandbox — files and commands they change here are changed for real, so permission rules and approvals are the only guard';
+}
 const LANE_DETAIL_MAX = 40;
 export function executionLaneDoctorDetail(reading) {
     switch (reading.kind) {

package/dist/fleet/fleetProjection.js

@@ -1,6 +1,7 @@
 import { collapseLabel, escapeDisplayControlChars, taskDescFromName } from '../fleetTaskDesc.js';
 import { rowIdTail } from '../workflow.js';
 import { frozenSet } from '../frozenSet.js';
+import { CORE_RESERVED_AGENT_NAMES } from '../generated/engineFactTables.js';
 export const TERMINAL_FLEET_TASK_STATUSES = frozenSet([
     'completed',
     'failed',
@@ -52,15 +53,12 @@ function deriveAgentLabel(agentType, agentName, name, id) {
     const tail = rowIdTail(id).slice(-8);
     return tail ? `agent ${tail}` : 'agent';
 }
+const CONTROL_VERB_LEGACY_NAMES = ['Task', 'Fork'];
+const CONTROL_VERB_GOAL_NAMES = ['DeclareDone'];
 export const CONTROL_TOOL_VERBS = frozenSet([
-    'Agent',
-    'Task',
-    'Fork',
-    'StructuredOutput',
-    'ReportBlocked',
-    'ReadToolResult',
-    'ToolSearch',
-    'DeclareDone',
+    ...CORE_RESERVED_AGENT_NAMES,
+    ...CONTROL_VERB_LEGACY_NAMES,
+    ...CONTROL_VERB_GOAL_NAMES,
 ]);
 export function projectDescription(description) {
     const d = description ?? '';

package/dist/fleet/workflowSizeWarning.js

@@ -1,11 +1,8 @@
+import { CORE_WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS } from '../generated/engineFactTables.js';
 export const WORKFLOW_SIZE_WARNING_AGENT_CAP = 25;
 export const WORKFLOW_SIZE_WARNING_TOKEN_CAP = 1_500_000;
 export const WORKFLOW_SIZE_WARNING_TOKENS_PER_AGENT = 70_000;
-export const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS = Object.freeze({
-    small: 5,
-    medium: 15,
-    large: 50,
-});
+export const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS = CORE_WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS;
 export const WORKFLOW_SIZE_WARNING_ENV_NAMES = Object.freeze({
     agents: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_AGENTS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_AGENTS']),
     tokens: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_TOKENS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_TOKENS']),

package/dist/gateOutcome.d.ts

@@ -3,9 +3,13 @@ import { type CcToolDenialKind } from './gateVocabulary.js';
 export type GateDispositionView = {
     kind: 'allowed';
     classifier?: GateClassifierRoundView;
+    released?: GateModeReleaseView;
 } | {
     kind: 'denied';
     classifier?: GateClassifierRoundView;
+    mode?: string;
+    askClass?: string;
+    classes?: readonly string[];
     deniedBy: DeniedBy | (string & {});
     cause?: string;
 };
@@ -19,6 +23,14 @@ export interface GateClassifierFallbackView {
     to: string;
     cause: string;
 }
+export interface GateModeReleaseView {
+    mode: string;
+    askClass: string;
+    classes: readonly string[];
+    origin?: string;
+    mandate?: string;
+    reason?: string;
+}
 export interface SettlementWhoView {
     party: string;
     approver?: string;
@@ -38,6 +50,7 @@ export interface GateOutcomeView {
 }
 export declare function gateOutcomeOf(frame: unknown): GateOutcomeView | undefined;
 export declare function isGateParkedToolEnd(frame: unknown): boolean;
+export declare function gateModeRelease(g: GateOutcomeView | undefined): GateModeReleaseView | undefined;
 export declare function isDeniedGate(g: GateOutcomeView | undefined): boolean;
 export declare function gateDeniedBy(g: GateOutcomeView | undefined): string | undefined;
 export declare function gateApprover(g: GateOutcomeView | undefined): string | undefined;