@sema-agent/client-core 0.107.0 → 0.108.0

package/dist/checkpointRowVerdict.d.ts

@@ -1,3 +1,4 @@
+import { type UiLanguage } from './env/uiLanguage.js';
 export type CheckpointRowVerdictReading = {
     readonly kind: 'ok';
 } | {
@@ -27,3 +28,7 @@ export type CheckpointRowBar = Exclude<CheckpointRowVerdictReading, {
 export declare function checkpointRowBarOf(row: object | null | undefined): CheckpointRowBar | undefined;
 export declare const CHECKPOINT_ROW_BAR_SENTENCE: string;
 export declare function checkpointRowBarSentence(bar: CheckpointRowBar): string;
+export type CheckpointDeadlineState = 'armed' | 'none' | 'unknown';
+export declare function checkpointDeadlineStateOf(row: object | null | undefined): CheckpointDeadlineState;
+export declare function unboundWayOutContent(state: CheckpointDeadlineState, lang?: UiLanguage | (string & {})): string;
+export declare function rowBarWayOutContent(bar: CheckpointRowBar, state: CheckpointDeadlineState, lang?: UiLanguage | (string & {})): string;

package/dist/checkpointRowVerdict.js

@@ -1,5 +1,6 @@
 import { readErrorString, slotReadOf } from './wireFailureShape.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { isUiLanguage } from './env/uiLanguage.js';
 const UNREADABLE = Object.freeze({ kind: 'unreadable' });
 const OK = Object.freeze({ kind: 'ok' });
 function ownNonEmptyString(o, key) {
@@ -96,3 +97,28 @@ export const CHECKPOINT_ROW_BAR_SENTENCE = renderMessage(msg('approval.rowUnresu
 export function checkpointRowBarSentence(bar) {
     return bar.kind !== 'unreadable' && typeof bar.sentence === 'string' && bar.sentence !== '' ? bar.sentence : CHECKPOINT_ROW_BAR_SENTENCE;
 }
+export function checkpointDeadlineStateOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return 'unknown';
+        const r = slotReadOf(row, 'deadline');
+        if (r.presence !== 'present')
+            return 'unknown';
+        const v = r.value;
+        if (v === null)
+            return 'none';
+        return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? 'armed' : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function unboundWayOutContent(state, lang) {
+    const key = state === 'armed' ? 'approval.decide.unboundWayOut.armed' : state === 'none' ? 'approval.decide.unboundWayOut.none' : 'approval.decide.unboundWayOut.unknown';
+    return renderMessage(msg(key), isUiLanguage(lang) ? lang : undefined);
+}
+export function rowBarWayOutContent(bar, state, lang) {
+    if (bar.kind === 'lacking')
+        return renderMessage(msg('approval.rowUnresumable.lackingWayOut'), isUiLanguage(lang) ? lang : undefined);
+    return unboundWayOutContent(state, lang);
+}

package/dist/cloudConfigWireCaps.d.ts

@@ -63,6 +63,15 @@ export interface CloudExecutionProjection {
 }
 export declare function cloudExecutionToPolicy(execution: unknown): CloudExecutionProjection;
 export declare function cloudRosterNames(rostersValue: unknown): string[];
+export type CloudA2aReading = {
+    readonly kind: 'present';
+    readonly peerNames: readonly string[];
+    readonly unreadableRows: number;
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unreadable';
+};
 export interface CloudEffectiveWarning {
     readonly kind: string;
     readonly domain?: string;
@@ -137,6 +146,7 @@ export interface CloudProjection {
     budget: CloudBudgetReading;
     runtimeCaps: CloudRuntimeCapsReading;
     modelRefIssues: CloudModelRefIssue[];
+    a2a: CloudA2aReading;
 }
 export declare function projectEffectiveBody(body: unknown, skillBodies: Record<string, string>, env: EnvLike, rostersValue?: unknown, opts?: CloudModelsDocOptions, skills?: CloudSkillsOptions): CloudProjection;
 export interface CloudEffectiveNotice {

package/dist/cloudConfigWireCaps.js

@@ -1,6 +1,7 @@
 import { mcpAllowToolsVerdict, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, mcpToolFacesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { skillToolListsVerdict, toCappedSpec } from './skillsWireCaps.js';
 import { SETTINGS_DESCRIBE_BAD_MCP_SERVER_NAME, SETTINGS_IS_USABLE_MCP_SERVER_NAME, SETTINGS_READ_REQUEST_MCP_TRANSPORT } from './generated/settingsSchemaFns.js';
+import { SETTINGS_IS_USABLE_WIRE_NAME } from './generated/settingsSchemaFns.js';
 import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
@@ -8,6 +9,7 @@ import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
 import { modelsPolicyOf } from './model/modelsPolicy.js';
 import { normalizeEngineBaseUrl } from './engineUrl.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { slotReadOf } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { SETTINGS_BUDGET_NUMBER_KEYS, SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS, SETTINGS_BUDGET_STRING_KEYS, SETTINGS_TIER_GROUP_NAME_RE, } from './generated/settingsSchemaTables.js';
 const asRec = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
@@ -535,6 +537,36 @@ export function cloudRosterNames(rostersValue) {
         .map((e) => asStr(asRec(e)?.name))
         .filter((n) => !!n);
 }
+function cloudA2aOf(body) {
+    const cfg = slotReadOf(body, 'config');
+    const config = cfg.presence === 'present' ? guardedRead(() => asRec(cfg.value)) : undefined;
+    if (config === undefined)
+        return { kind: 'unreadable' };
+    const slot = slotReadOf(config, 'a2a');
+    if (slot.presence === 'absent')
+        return { kind: 'absent' };
+    const domain = slot.presence === 'present' ? guardedRead(() => asRec(slot.value)) : undefined;
+    if (domain === undefined)
+        return { kind: 'unreadable' };
+    const peersSlot = slotReadOf(domain, 'peers');
+    if (peersSlot.presence === 'absent')
+        return { kind: 'present', peerNames: [], unreadableRows: 0 };
+    const peers = peersSlot.presence === 'present' ? guardedRead(() => (Array.isArray(peersSlot.value) ? peersSlot.value : undefined)) : undefined;
+    const count = peers === undefined ? undefined : guardedRead(() => readOwnDataValue(peers, 'length'));
+    if (peers === undefined || typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        return { kind: 'unreadable' };
+    const peerNames = [];
+    let unreadableRows = 0;
+    for (let i = 0; i < count; i++) {
+        const row = guardedRead(() => readOwnDataValue(peers, String(i)));
+        const name = typeof row === 'object' && row !== null ? guardedRead(() => readOwnDataValue(row, 'name')) : undefined;
+        if (typeof name === 'string' && SETTINGS_IS_USABLE_WIRE_NAME(name))
+            peerNames.push(name);
+        else
+            unreadableRows += 1;
+    }
+    return { kind: 'present', peerNames, unreadableRows };
+}
 const BUDGET_NUMBER_KEYS = SETTINGS_BUDGET_NUMBER_KEYS;
 const BUDGET_STRING_KEYS = SETTINGS_BUDGET_STRING_KEYS;
 const PER_MODEL_NUMBER_KEYS = SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS;
@@ -702,6 +734,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts,
         budget: budgetOf(b, view),
         runtimeCaps: runtimeCapsOf(b, view),
         modelRefIssues,
+        a2a: cloudA2aOf(b),
     };
 }
 const quoted = (s, fallback) => (s === undefined ? fallback : `the "${s}" settings`);

package/dist/coreValuePorts.d.ts

@@ -153,6 +153,7 @@ export interface CoreValuePorts {
     IMPORTED_SETTINGS_LAYERS: readonly ['userSettings', 'projectSettings', 'localSettings'];
     runParkedOf(run: WorkflowRunParkedInputView): boolean;
     parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[];
+    modelFaceResolvable(face: object, options?: ModelFaceOptionsView): ModelFaceVerdictView;
 }
 export interface WorkflowAgentStatusView {
     readonly status: string;
@@ -161,7 +162,21 @@ export interface WorkflowRunParkedInputView {
     readonly status: string;
     readonly agents: ReadonlyArray<WorkflowAgentStatusView>;
 }
-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", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf"];
+export interface ModelFaceOptionsView {
+    readonly spec?: {
+        readonly model?: string | object;
+        readonly modelRole?: string;
+    };
+    readonly when?: readonly ('per-task' | 'deployment')[];
+}
+export type ModelFaceVerdictView = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly role: string;
+    readonly code: string;
+};
+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", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf", "modelFaceResolvable"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -195,3 +210,4 @@ export declare function ruleNameCovers(ruleName: string, toolName: string): bool
 export declare function importedSettingsLayers(): CoreValuePorts['IMPORTED_SETTINGS_LAYERS'] | undefined;
 export declare function runParkedOf(run: WorkflowRunParkedInputView): boolean | undefined;
 export declare function parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[] | undefined;
+export declare function modelFaceResolvable(face: object, options?: ModelFaceOptionsView): ModelFaceVerdictView | undefined;

package/dist/coreValuePorts.js

@@ -23,6 +23,7 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'IMPORTED_SETTINGS_LAYERS',
     'runParkedOf',
     'parkedAgentsOf',
+    'modelFaceResolvable',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -137,3 +138,7 @@ export function parkedAgentsOf(agents) {
     const fn = port('parkedAgentsOf');
     return fn === undefined ? undefined : fn(agents);
 }
+export function modelFaceResolvable(face, options) {
+    const fn = port('modelFaceResolvable');
+    return fn === undefined ? undefined : fn(face, options);
+}

package/dist/decideReceipt.js

@@ -9,6 +9,7 @@ import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
 import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
 import { isUiLanguage } from './env/uiLanguage.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { unboundWayOutContent } from './checkpointRowVerdict.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -162,7 +163,7 @@ export function decideRequiresBindingFromError(e) {
     }
 }
 export function decideRequiresBindingContent(_detail, lang) {
-    return renderMessage(msg('approval.decide.requiresBinding', { wayOut: msg('approval.decide.unboundWayOut') }), isUiLanguage(lang) ? lang : undefined);
+    return renderMessage(msg('approval.decide.requiresBinding', { wayOut: unboundWayOutContent('unknown', lang) }), isUiLanguage(lang) ? lang : undefined);
 }
 function askGoneRawCause(e) {
     let top;

package/dist/engineErrorCodes.d.ts

@@ -99,6 +99,11 @@ export declare function refusalSaysStillPending(err: object): boolean;
 export declare function refusalRetriableReading(err: object): boolean | undefined;
 export type StatusDerivedCoarseCode = (typeof SDK_STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
+export declare const RESUME_PRINCIPAL_MISMATCH = "resume.principal_mismatch";
+export declare const RESUME_COMPOSITION_MISMATCH = "resume.composition_mismatch";
+export declare const RESUME_PARENT_CONSTRAINT_MISSING = "resume.parent_constraint_missing";
+export declare const RESUME_PARENT_CONSTRAINT_MISMATCH = "resume.parent_constraint_mismatch";
+export declare const RESUME_CONSTRAINT_UNPROJECTABLE = "resume.constraint_unprojectable";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";
 export declare const RESUME_RETRY_LATER_CODES: readonly string[];
 export declare const RESUME_ENV_FAILED = "resume.env_failed";

package/dist/engineErrorCodes.js

@@ -177,6 +177,11 @@ export function refusalRetriableReading(err) {
     }
 }
 export const RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
+export const RESUME_PRINCIPAL_MISMATCH = 'resume.principal_mismatch';
+export const RESUME_COMPOSITION_MISMATCH = 'resume.composition_mismatch';
+export const RESUME_PARENT_CONSTRAINT_MISSING = 'resume.parent_constraint_missing';
+export const RESUME_PARENT_CONSTRAINT_MISMATCH = 'resume.parent_constraint_mismatch';
+export const RESUME_CONSTRAINT_UNPROJECTABLE = 'resume.constraint_unprojectable';
 export const RESUME_CONTEXT_UNAVAILABLE = 'conflict.resume_context_unavailable';
 export const RESUME_RETRY_LATER_CODES = Object.freeze([
     RESUME_USAGE_WINDOW_EXHAUSTED,

package/dist/engineNoticeCodes.d.ts

@@ -14,9 +14,23 @@ export interface McpInjectionDropFactsView {
     field?: string;
 }
 export declare function readMcpInjectionDrop(notice: unknown): McpInjectionDropFactsView | undefined;
+export type NoticeLegView = {
+    readonly kind: 'self';
+} | {
+    readonly kind: 'delegated';
+    readonly sourceSessionId: string;
+    readonly agentId?: string;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function noticeCallSessionOf(facts: {
+    readonly sessionId?: string | undefined;
+    readonly leg: NoticeLegView;
+}): string | undefined;
 export declare const ASK_UNRESOLVABLE_CAUSES: readonly string[];
 export interface AskUnresolvableFactsView {
     sessionId: string;
+    leg: NoticeLegView;
     toolName: string;
     toolCallId: string;
     cause: string;
@@ -108,6 +122,7 @@ export interface ClassifierUnavailableFactsView {
     disposition: ClassifierUnavailableDispositionWord;
     sessionId?: string;
     runId?: string;
+    leg: NoticeLegView;
 }
 export declare function readClassifierUnavailable(notice: unknown): ClassifierUnavailableFactsView | undefined;
 export declare const PERMISSION_MODE_FOLD_REASONS: readonly string[];
@@ -129,6 +144,7 @@ export interface AskReleasedByModeFactsView {
     firstToolCallId: string;
     sessionId?: string;
     runId?: string;
+    leg: NoticeLegView;
 }
 export declare function readAskReleasedByMode(notice: unknown): AskReleasedByModeFactsView | undefined;
 export interface ReadDenyUnappliedFactsView {
@@ -139,6 +155,7 @@ export interface ReadDenyUnappliedFactsView {
     rowCount: number;
     sessionId: string;
     runId: string;
+    leg: NoticeLegView;
 }
 export declare function readReadDenyUnapplied(notice: unknown): ReadDenyUnappliedFactsView | undefined;
 export interface ToolTurnRepairView {
@@ -198,6 +215,7 @@ export interface UserInputUndrainedFactsView {
     runId?: string;
     childSessionId?: string;
     inputIds?: readonly string[];
+    inputKind?: 'steer' | 'approval_feedback';
 }
 export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
 export interface UndrainedInputsLedger {
@@ -210,7 +228,7 @@ export interface UndrainedInputsVerdict {
     readonly unattributed: number;
 }
 export declare function undrainedInputsVerdict(facts: Pick<UserInputUndrainedFactsView, 'count' | 'cause' | 'inputIds' | 'childSessionId'> | null | undefined, ledger: UndrainedInputsLedger | null | undefined): UndrainedInputsVerdict | undefined;
-export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId'>): string | undefined;
+export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId' | 'inputKind'>, lang?: UiLanguage): string | undefined;
 export interface TurnInterruptedFactsView {
     lane: 'input_now' | 'user_halt' | 'unrecognized';
     inputId?: string;

package/dist/engineNoticeCodes.js

@@ -4,6 +4,7 @@ import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_
 import { CORE_APPROVAL_REMEDY_KINDS, CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
+import { slotReadOf } from './wireFailureShape.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
 function audienceRow(table, code) {
@@ -43,6 +44,46 @@ export function readMcpInjectionDrop(notice) {
     const field = typeof fieldIn === 'string' && fieldIn.length > 0 ? fieldIn : undefined;
     return { sessionId, server, reason, ...(field !== undefined ? { field } : {}) };
 }
+const LEG_SELF = Object.freeze({ kind: 'self' });
+const LEG_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+function readNoticeLeg(detail) {
+    try {
+        const source = slotReadOf(detail, 'sourceSessionId');
+        const agent = slotReadOf(detail, 'agentId');
+        if (source.presence === 'absent')
+            return agent.presence === 'absent' ? LEG_SELF : LEG_UNREADABLE;
+        if (source.presence !== 'present' || typeof source.value !== 'string' || source.value.length === 0)
+            return LEG_UNREADABLE;
+        const agentId = agent.presence === 'present' && typeof agent.value === 'string' && agent.value.length > 0 ? agent.value : undefined;
+        return Object.freeze({ kind: 'delegated', sourceSessionId: source.value, ...(agentId !== undefined ? { agentId } : {}) });
+    }
+    catch {
+        return LEG_UNREADABLE;
+    }
+}
+export function noticeCallSessionOf(facts) {
+    const str = (o, key) => {
+        const s = slotReadOf(o, key);
+        return s.presence === 'present' && typeof s.value === 'string' && s.value.length > 0 ? s.value : undefined;
+    };
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return undefined;
+        const legSlot = slotReadOf(facts, 'leg');
+        const leg = legSlot.presence === 'present' ? legSlot.value : undefined;
+        if (typeof leg !== 'object' || leg === null)
+            return undefined;
+        const kind = str(leg, 'kind');
+        if (kind === 'delegated')
+            return str(leg, 'sourceSessionId');
+        if (kind !== 'self')
+            return undefined;
+        return str(facts, 'sessionId');
+    }
+    catch {
+        return undefined;
+    }
+}
 export const ASK_UNRESOLVABLE_CAUSES = CORE_ASK_UNRESOLVABLE_CAUSES;
 const ASK_UNRESOLVABLE_CAUSE_SET = new Set(ASK_UNRESOLVABLE_CAUSES);
 function optionalSeat(o, key) {
@@ -111,6 +152,9 @@ export function askUnresolvableRemedyContent(remedy, lang) {
     return renderMessage(msg('notice.askUnresolvable.remedy.permissionMode', { mode: displayUntrusted(r.value, { max: 64 }) }), lang);
 }
 export function readAskUnresolvable(notice) {
+    return guardedRead(notice, readAskUnresolvableOf);
+}
+function readAskUnresolvableOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
     const n = notice;
@@ -131,7 +175,7 @@ export function readAskUnresolvable(notice) {
     if (sessionId === undefined || toolName === undefined || toolCallId === undefined || cause === undefined) {
         return undefined;
     }
-    const parkIn = o.parkLaneExisted;
+    const parkIn = optionalSeat(o, 'parkLaneExisted');
     const remedyIn = optionalSeat(o, 'remedy');
     let remedies;
     try {
@@ -148,6 +192,7 @@ export function readAskUnresolvable(notice) {
         ...(typeof parkIn === 'boolean' ? { parkLaneExisted: parkIn } : {}),
         ...(typeof remedyIn === 'string' && remedyIn.length > 0 ? { remedy: remedyIn } : {}),
         ...(remedies !== undefined ? { remedies } : {}),
+        leg: readNoticeLeg(o),
     };
 }
 export const DURABLE_MANDATE_SOURCES = CORE_DURABLE_MANDATE_SOURCES;
@@ -433,6 +478,7 @@ function readClassifierUnavailableOf(notice) {
         disposition,
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(runId !== undefined ? { runId } : {}),
+        leg: readNoticeLeg(o),
     };
 }
 export const PERMISSION_MODE_FOLD_REASONS = CORE_PERMISSION_MODE_FOLD_REASONS;
@@ -495,6 +541,7 @@ function readAskReleasedByModeOf(notice) {
         firstToolCallId,
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(runId !== undefined ? { runId } : {}),
+        leg: readNoticeLeg(o),
     };
 }
 export function readReadDenyUnapplied(notice) {
@@ -521,7 +568,7 @@ function readReadDenyUnappliedOf(notice) {
         rowCount === undefined || sessionId === undefined || runId === undefined) {
         return undefined;
     }
-    return { mode, toolCallId, tiers, rows, rowCount, sessionId, runId };
+    return { mode, toolCallId, tiers, rows, rowCount, sessionId, runId, leg: readNoticeLeg(o) };
 }
 export function readToolTurnRepaired(notice) {
     return guardedRead(notice, readToolTurnRepairedOf);
@@ -695,6 +742,9 @@ function optionalNonEmpty(o, key) {
         return undefined;
     }
 }
+function undrainedInputKindOf(v) {
+    return v === 'steer' || v === 'approval_feedback' ? v : undefined;
+}
 export function readUserInputUndrained(notice) {
     return guardedRead(notice, readUserInputUndrainedOf);
 }
@@ -726,6 +776,7 @@ function readUserInputUndrainedOf(notice) {
     const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
     const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
     const runId = nonEmpty(optionalOwnSeat(o, 'runId'));
+    const inputKind = kind === 'steer' ? undrainedInputKindOf(optionalOwnSeat(o, 'kind')) : undefined;
     const childSeat = ownSeatOrUnreadable(o, 'childSessionId');
     const childSessionId = nonEmpty(childSeat);
     const childSeatProven = childSeat === undefined || childSessionId !== undefined;
@@ -739,6 +790,7 @@ function readUserInputUndrainedOf(notice) {
         ...(runId !== undefined ? { runId } : {}),
         ...(childSessionId !== undefined ? { childSessionId } : {}),
         ...(inputIds !== undefined ? { inputIds } : {}),
+        ...(inputKind !== undefined ? { inputKind } : {}),
     };
 }
 function exactInputIdList(v, count) {
@@ -849,11 +901,12 @@ const subagentFollowUpUndrainedSentence = (n) => `${messagesPhrase(n, 'follow-up
     `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
 const unrecognizedUndrainedSentence = (n, kind) => `${kind === 'followUp' ? `${messagesPhrase(n, 'follow-up message')} you queued` : `${messagesPhrase(n, 'message')} you sent during a run`} may not have been used, ` +
     `and the reason was not reported in a form this version recognizes. Check the run's transcript before sending ${itThem(n)} again.`;
-export function userInputUndrainedNotice(facts) {
+export function userInputUndrainedNotice(facts, lang) {
     let kind;
     let count;
     let cause;
     let child;
+    let inputKind;
     try {
         if (facts === null || typeof facts !== 'object' || Array.isArray(facts))
             return undefined;
@@ -871,6 +924,12 @@ export function userInputUndrainedNotice(facts) {
         child = undefined;
     }
     const fromSubagent = typeof child === 'string' && child.length > 0;
+    try {
+        inputKind = Object.hasOwn(facts, 'inputKind') ? facts.inputKind : undefined;
+    }
+    catch {
+        inputKind = undefined;
+    }
     const n = positiveInt(count);
     if (n === undefined || !isUndrainedLane(kind))
         return undefined;
@@ -879,6 +938,9 @@ export function userInputUndrainedNotice(facts) {
             return fromSubagent ? subagentFollowUpUndrainedSentence(n) : followUpUndrainedSentence(n);
         return unrecognizedUndrainedSentence(n, kind);
     }
+    if (cause === 'leg_end' && inputKind === 'approval_feedback') {
+        return renderMessage(msg(n === 1 ? 'notice.userInputUndrained.approvalFeedback.one' : 'notice.userInputUndrained.approvalFeedback.other', { count: n }), lang);
+    }
     if (cause === 'leg_end' && fromSubagent)
         return subagentSteerUndrainedSentence(n);
     if (typeof cause === 'string' && Object.hasOwn(STEER_UNDRAINED_SENTENCE, cause)) {

package/dist/engineTargetSeat.js

@@ -58,6 +58,7 @@ const REFUSAL_KEYS = {
     not_configured: 'config.engineTarget.notConfigured',
     not_signed_in: 'config.engineTarget.notSignedIn',
     probe_failed: 'config.engineTarget.probeFailed',
+    cloud_unreachable: 'config.engineTarget.cloudUnreachable',
     org_policy: 'config.engineTarget.orgPolicy',
     url_refused: 'config.engineTarget.urlRefused',
     login_failed: 'config.engineTarget.loginFailed',

package/dist/errorSupplementRoles.js

@@ -6,6 +6,7 @@ import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
 import { inheritEnvRefusalContent } from './inheritEnvWire.js';
 import { projectSeedRefusalContent } from './projectSeed.js';
 import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, sessionArchiveStampedContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
+import { catalogDefaultRefusalContent } from './model/catalogDefault.js';
 const ROLE_BY_READER = new Map([
     [corruptSessionContent, 'replacement'],
     [corruptStoredRowContent, 'replacement'],
@@ -23,6 +24,7 @@ const ROLE_BY_READER = new Map([
     [idempotencyPayloadMismatchContent, 'replacement'],
     [unsupportedRuleRefusalContent, 'replacement'],
     [projectSeedRefusalContent, 'replacement'],
+    [catalogDefaultRefusalContent, 'replacement'],
     [admissionWallRefusalContent, 'supplement'],
     [hostPostureRefusalContent, 'supplement'],
     [toolDeclarationRefusalContent, 'supplement'],

package/dist/eventLeg.js

@@ -21,7 +21,7 @@ function makeFrameStageDomains(domains) {
 }
 const FRAME_STAGE_DOMAINS = makeFrameStageDomains({
     bindRun: Object.freeze(['meta', 'done', 'failed']),
-    stampOwner: Object.freeze(['task_progress']),
+    stampOwner: Object.freeze(['task_progress', 'task_started']),
     hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete', 'approval_request', 'approval_complete', 'approval_revoke']),
 });
 const HITL_FRAMES_PROJECTED = Object.freeze(['human_input']);

package/dist/executionLaneWords.js

@@ -1,3 +1,4 @@
+import { SETTINGS_NO_EXECUTION_TARGET_LANES } from './generated/settingsSchemaTables.js';
 export function executionLaneWordIsNone(provider) {
-    return provider === 'none' || provider === 'in-process';
+    return SETTINGS_NO_EXECUTION_TARGET_LANES.some((w) => w === provider) || provider === 'in-process';
 }

package/dist/gateOutcome.d.ts

@@ -1,6 +1,6 @@
 import type { DeniedBy, Settlement } from '@sema-agent/sdk';
 import { type CcToolDenialKind } from './gateVocabulary.js';
-import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
+import { CORE_MODE_RELEASE_REASONS, CORE_REFUSAL_ECHO_KINDS } from './generated/engineFactTables.js';
 export type GateDispositionView = {
     kind: 'allowed';
     classifier?: GateClassifierRoundView;
@@ -14,7 +14,16 @@ export type GateDispositionView = {
     deniedBy: DeniedBy | (string & {});
     cause?: string;
     extension?: string;
+    echoed?: readonly GateRefusalEchoView[];
 };
+export interface GateRefusalEchoView {
+    readonly kind: string;
+    readonly value: string;
+    readonly canonical?: string;
+}
+export declare const GATE_REFUSAL_ECHO_KIND_WORDS: readonly ["path", "command", "pattern"];
+export type GateRefusalEchoKindWord = (typeof CORE_REFUSAL_ECHO_KINDS)[number];
+export declare function isGateRefusalEchoKindWord(v: string): v is GateRefusalEchoKindWord;
 export interface GateClassifierRoundView {
     modelRequested: string;
     modelUsed: string;

package/dist/gateOutcome.js

@@ -1,10 +1,14 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
-import { CORE_MODE_RELEASE_REASONS, CORE_SETTLEMENT_KINDS } from './generated/engineFactTables.js';
+import { CORE_MODE_RELEASE_REASONS, CORE_REFUSAL_ECHO_KINDS, CORE_SETTLEMENT_KINDS } from './generated/engineFactTables.js';
 import { readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+export const GATE_REFUSAL_ECHO_KIND_WORDS = CORE_REFUSAL_ECHO_KINDS;
+export function isGateRefusalEchoKindWord(v) {
+    return typeof v === 'string' && CORE_REFUSAL_ECHO_KINDS.includes(v);
+}
 export const GATE_MODE_RELEASE_REASON_WORDS = CORE_MODE_RELEASE_REASONS;
 export function isGateModeReleaseReasonWord(v) {
     return typeof v === 'string' && CORE_MODE_RELEASE_REASONS.includes(v);
@@ -112,6 +116,46 @@ function nonEmptyStringList(v) {
     }
     return Object.freeze(out);
 }
+function ownDataOf(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d === undefined || !Object.hasOwn(d, 'value') ? { ok: false } : { ok: true, value: d.value };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function readRefusalEchoes(raw) {
+    try {
+        if (!Array.isArray(raw))
+            return undefined;
+        const len = ownDataOf(raw, 'length');
+        if (!len.ok || typeof len.value !== 'number' || !Number.isInteger(len.value) || len.value <= 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < len.value; i += 1) {
+            const slot = ownDataOf(raw, String(i));
+            if (!slot.ok)
+                return undefined;
+            const e = slot.value;
+            if (typeof e !== 'object' || e === null || Array.isArray(e))
+                return undefined;
+            const kind = ownDataOf(e, 'kind');
+            const value = ownDataOf(e, 'value');
+            if (!kind.ok || typeof kind.value !== 'string' || kind.value.length === 0)
+                return undefined;
+            if (!value.ok || typeof value.value !== 'string' || value.value.length === 0)
+                return undefined;
+            const canonical = ownDataOf(e, 'canonical');
+            const canon = canonical.ok && typeof canonical.value === 'string' && canonical.value.length > 0 ? canonical.value : undefined;
+            out.push(Object.freeze({ kind: kind.value, value: value.value, ...(canon !== undefined ? { canonical: canon } : {}) }));
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
 function readModeRelease(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return undefined;
@@ -198,6 +242,8 @@ function readGateRecord(frame) {
         const askClass = str(dr.askClass);
         const classes = nonEmptyStringList(dr.classes);
         const extension = str(dr.extension);
+        const echoedSeat = ownDataOf(dr, 'echoed');
+        const echoed = echoedSeat.ok ? readRefusalEchoes(echoedSeat.value) : undefined;
         disposition = {
             kind: 'denied',
             deniedBy,
@@ -207,6 +253,7 @@ function readGateRecord(frame) {
             ...(askClass !== undefined ? { askClass } : {}),
             ...(classes !== undefined ? { classes } : {}),
             ...(extension !== undefined ? { extension } : {}),
+            ...(echoed !== undefined ? { echoed } : {}),
         };
     }
     else {

package/dist/generated/engineFactTables.d.ts

@@ -73,3 +73,4 @@ export declare const CORE_USER_ATTACHMENTS_MAX: number;
 export declare const CORE_USER_ATTACHMENT_LABEL_MAX: number;
 export declare const CORE_PRESENT_PLAN_TOOL_NAME: "ExitPlanMode";
 export declare const CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE: "workflow.agent_parked";
+export declare const CORE_REFUSAL_ECHO_KINDS: readonly ["path", "command", "pattern"];

package/dist/generated/engineFactTables.js

@@ -466,3 +466,8 @@ export const CORE_USER_ATTACHMENTS_MAX = 20;
 export const CORE_USER_ATTACHMENT_LABEL_MAX = 4096;
 export const CORE_PRESENT_PLAN_TOOL_NAME = "ExitPlanMode";
 export const CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE = "workflow.agent_parked";
+export const CORE_REFUSAL_ECHO_KINDS = Object.freeze([
+    "path",
+    "command",
+    "pattern",
+]);

package/dist/generated/engineNoticeTables.js

@@ -52,6 +52,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "delegation.transcript_integrity",
     "delegation.ask_unresolvable",
     "delegation.resume_lane_missing",
+    "delegation.delivery_discarded",
     "mcp.injection_dropped",
     "mcp.revocation_probe_failed",
     "mcp.server_redialed",
@@ -171,6 +172,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "delegation.transcript_integrity": "operator",
     "delegation.ask_unresolvable": "user",
     "delegation.resume_lane_missing": "operator",
+    "delegation.delivery_discarded": "operator",
     "mcp.injection_dropped": "user",
     "mcp.revocation_probe_failed": "operator",
     "mcp.server_redialed": "operator",
@@ -296,6 +298,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "delegation.transcript_integrity": "engine",
     "delegation.ask_unresolvable": "engine",
     "delegation.resume_lane_missing": "engine",
+    "delegation.delivery_discarded": "engine",
     "mcp.injection_dropped": "engine",
     "mcp.revocation_probe_failed": "engine",
     "mcp.server_redialed": "engine",