@sema-agent/client-core 0.106.0 → 0.108.0

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -3,6 +3,7 @@ import type { ActiveRunBusySignal } from './runStream.js';
 import type { RejectedSubmissionOrigin } from '../request/submissionIdentity.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { type AskParkAutoReopenBlock } from '../hitl/askParkAutoReopenBlock.js';
+import { type CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
 export type DurableDecideLeg = 'approval' | 'plan_review' | 'other_gate' | 'unreadable';
@@ -44,6 +45,10 @@ export type ReopenCardVerdict = {
     _sema_errorCode?: string;
     _sema_reopenRefusal?: PlanReviewReopenRefusal;
     _sema_policyBlocked?: AskParkAutoReopenBlock;
+    _sema_rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
+    _sema_rowDeadline?: number | null;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -147,6 +152,10 @@ export type SelfHealOutcome = {
     noPresentationSurface?: true;
     errorCode?: string;
     policyBlocked?: AskParkAutoReopenBlock;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
+    rowDeadline?: 'armed' | 'none';
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;
@@ -162,6 +171,7 @@ export type SelfHealOutcome = {
     delivery: string | null;
     status: string | null;
     reopened: ReopenCardVerdict | null;
+    messageId?: string;
 } | {
     kind: 'running-steer-failed';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -5,7 +5,8 @@ import { registeredPlanReviewCardFacts } from '../planReviewCardFacts.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent } from '../hitl/askParkAutoReopenBlock.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
-import { readThrownStatusSlot } from '../wireFailureShape.js';
+import { readThrownStatusSlot, slotReadOf } from '../wireFailureShape.js';
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent } from '../checkpointRowVerdict.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
@@ -145,6 +146,12 @@ function injectedCarrierVerdict(items, busyTaskId) {
         return null;
     return allNameBusyRun && present === length ? 'redundant' : 'deferred';
 }
+function injectedCarrierVerdictOf(deps, busyTaskId) {
+    return deps?.submissionOrigin === 'injected' ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), busyTaskId) : null;
+}
+function runSettledOutcome(carrierVerdict, settled) {
+    return carrierVerdict === 'redundant' ? { kind: 'injected-redundant', taskId: settled.taskId } : settled;
+}
 function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
@@ -207,6 +214,8 @@ const REOPEN_VERDICT_KEYS = [
     '_sema_errorCode',
     '_sema_reopenRefusal',
     '_sema_policyBlocked',
+    '_sema_rowVerdict',
+    '_sema_rowDeadline',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -320,6 +329,30 @@ function reopenPolicyBlockedOf(verdict) {
         return undefined;
     }
 }
+function reopenRowVerdictOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        return checkpointRowBarOf({ rowVerdict: verdict._sema_rowVerdict });
+    }
+    catch {
+        return undefined;
+    }
+}
+function reopenRowDeadlineStateOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        const slot = slotReadOf(verdict, '_sema_rowDeadline');
+        if (slot.presence !== 'present')
+            return undefined;
+        const state = checkpointDeadlineStateOf({ deadline: slot.value });
+        return state === 'unknown' ? undefined : state;
+    }
+    catch {
+        return undefined;
+    }
+}
 function reopenRefusalOf(verdict) {
     try {
         if (verdict.reopened !== false)
@@ -583,6 +616,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
             detail: 'the engine did not name the run that holds this session',
         };
     }
+    const carrierVerdict = injectedCarrierVerdictOf(deps, taskId);
     const gateKind = signal.pendingGate?.kind ?? null;
     const gateLeg = durableDecideLegOf({ gateKind });
     const pendingCp = signal.pendingGate?.checkpointId;
@@ -590,7 +624,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (gateLeg === 'plan_review')
         return planReviewArm(taskId, signal, deps, sameTaskCp);
     if (gateLeg === 'approval')
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     let status = signal.activeTaskStatus;
     const statusFresh = status === null;
     if (status === null) {
@@ -610,16 +644,16 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
     }
     if (isSdkRunTerminal(status))
-        return { kind: 'running-settled', taskId, status };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status });
     const triageGate = signal.pendingGate && !statusFresh ? { pendingGateKind: signal.pendingGate.kind ?? null } : {};
     if (gateKind !== null)
         return { kind: 'not-parked', taskId, status, ...triageGate };
     if (PLAN_REVIEW_STATES.includes(status))
         return planReviewArm(taskId, signal, deps);
     if (ASK_PARK_STATES.includes(status))
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     if (RUNNING_STATES.includes(status)) {
-        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, deps);
+        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, carrierVerdict, deps);
     }
     return { kind: 'not-parked', taskId, status, ...triageGate };
 }
@@ -668,7 +702,7 @@ async function planReviewArm(taskId, signal, deps, checkpointId) {
         ...(reopenRefusal !== undefined ? { reopenRefusal } : {}),
     };
 }
-async function askParkArm(taskId, signal, runs, deps) {
+async function askParkArm(taskId, signal, runs, carrierVerdict, deps) {
     const verdict = await askVerdict(taskId, deps);
     if (reopenDelivered(verdict))
         return { kind: 'ask-reopened', taskId, firstSight: verdict.firstSight === true };
@@ -692,17 +726,19 @@ async function askParkArm(taskId, signal, runs, deps) {
             };
         }
         if (release.lastStatus !== null && RUNNING_STATES.includes(release.lastStatus)) {
-            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, deps);
+            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, carrierVerdict, deps);
         }
         return { kind: 'ask-decided-release-unknown', taskId, lastStatus: release.lastStatus };
     }
     const inFlight = reopenRefusedForDecisionInFlight(verdict);
     if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
-        return staleParkArm(taskId, signal, runs, deps);
+        return staleParkArm(taskId, signal, runs, carrierVerdict, deps);
     }
     const noView = reopenRefusedForNoPresentationSurface(verdict);
     const policyBlocked = inFlight || noView ? undefined : reopenPolicyBlockedOf(verdict);
-    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined ? undefined : reopenErrorCodeOf(verdict);
+    const rowVerdict = inFlight ? undefined : reopenRowVerdictOf(verdict);
+    const rowDeadline = rowVerdict !== undefined ? reopenRowDeadlineStateOf(verdict) : undefined;
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined || rowVerdict !== undefined ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
@@ -712,6 +748,8 @@ async function askParkArm(taskId, signal, runs, deps) {
         ...(noView ? { noPresentationSurface: true } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
         ...(policyBlocked !== undefined ? { policyBlocked } : {}),
+        ...(rowVerdict !== undefined ? { rowVerdict } : {}),
+        ...(rowDeadline !== undefined ? { rowDeadline } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -738,7 +776,7 @@ async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
         status = readStatusGuarded(record);
     return errorCode !== undefined ? { status, ghost, errorCode } : { status, ghost };
 }
-async function staleParkArm(taskId, busy, runs, deps) {
+async function staleParkArm(taskId, busy, runs, carrierVerdict, deps) {
     const reopenFailed = {
         kind: 'ask-reopen-failed',
         taskId,
@@ -766,11 +804,11 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (fresh === null)
         return withFailureCode(reopenFailed, first.errorCode);
     if (RUNNING_STATES.includes(fresh))
-        return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
+        return runningChoiceArm(taskId, fresh, busy, false, runs, carrierVerdict, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'ask-run-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: fresh });
     if (!ASK_PARK_STATES.includes(fresh))
         return reopenFailed;
     const offer = deps?.offerStaleParkChoice;
@@ -809,7 +847,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
     if (!ASK_PARK_STATES.includes(afterCard.status)) {
         if (isSdkRunTerminal(afterCard.status))
-            return { kind: 'ask-run-settled', taskId, status: afterCard.status };
+            return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: afterCard.status });
         if (RUNNING_STATES.includes(afterCard.status))
             return { kind: 'not-parked', taskId, status: afterCard.status };
         return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
@@ -871,11 +909,10 @@ async function cancelAndConfirmRelease(taskId, durable, durableGet, deps) {
             (verdict.lastStatus !== null && CLAIM_HELD_STATES.includes(verdict.lastStatus)),
     };
 }
-async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps) {
+async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, carrierVerdict, deps) {
     const notParked = { kind: 'not-parked', taskId, status };
     const offer = deps?.offerRunningChoice;
     const injected = deps?.submissionOrigin === 'injected';
-    const carrierVerdict = injected ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), taskId) : null;
     if (typeof offer !== 'function' && !injected)
         return notParked;
     const text = typeof deps?.deniedMessage === 'string' ? deps.deniedMessage : '';
@@ -895,7 +932,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         if (probeCallerAborted())
             return notParked;
         if (fresh !== null) {
-            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps);
+            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict);
             if (routed !== undefined)
                 return routed;
         }
@@ -936,16 +973,17 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     if (choice === 'steer' && canSteer && runs?.steer !== undefined) {
         try {
             const receipt = await runs.steer(taskId, steerBodyOf({ text }, UNOBSERVED_STEER_PRIORITY), sessionOpts(deps));
-            const { delivery, status: receiptStatus } = readSteerReceipt(receipt);
+            const { delivery, status: receiptStatus, messageId } = readSteerReceipt(receipt);
+            const handedId = messageId !== undefined ? { messageId } : {};
             if (delivery === 'queued') {
                 const verdict = receiptStatus !== null && PLAN_REVIEW_STATES.includes(receiptStatus)
                     ? await planVerdict(taskId, deps)
                     : receiptStatus !== null && ASK_PARK_STATES.includes(receiptStatus)
                         ? await askVerdict(taskId, deps)
                         : null;
-                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict };
+                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict, ...handedId };
             }
-            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null };
+            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null, ...handedId };
         }
         catch (e) {
             const delivery = atMostOnceFailureClass(e);
@@ -974,7 +1012,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             return { kind: 'running-not-found', taskId };
         if (probeCallerAborted() || preFire.status === null)
             return notParked;
-        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps);
+        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps, carrierVerdict);
         if (rerouted !== undefined)
             return rerouted;
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
@@ -996,15 +1034,15 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         return { kind: 'running-attach', taskId };
     return notParked;
 }
-async function routeFreshNonRunning(fresh, taskId, busy, runs, deps) {
+async function routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict) {
     if (RUNNING_STATES.includes(fresh))
         return undefined;
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (ASK_PARK_STATES.includes(fresh))
-        return askParkArm(taskId, busy, runs, deps);
+        return askParkArm(taskId, busy, runs, carrierVerdict, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'running-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status: fresh });
     return { kind: 'not-parked', taskId, status: fresh };
 }
 export const INTERACTIVE_WAY_OUT = EN_MESSAGES['session.selfHeal.wayOut.interactive'];
@@ -1190,6 +1228,13 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
         case 'ask-reopen-failed': {
             if (outcome.decisionInFlight === true)
                 return decisionInFlightRow('ask', outcome.taskId, lang);
+            if (outcome.rowVerdict !== undefined) {
+                return say(lang, 'session.selfHeal.row.askReopenFailed.rowUnresumable', {
+                    taskId: outcome.taskId,
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict),
+                    unbound: rowBarWayOutContent(outcome.rowVerdict, outcome.rowDeadline ?? 'unknown', lang),
+                });
+            }
             if (outcome.policyBlocked !== undefined)
                 return askParkAutoReopenBlockedContent(outcome.policyBlocked, outcome.taskId, 'interactive', lang);
             const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';

package/dist/checkpointRowVerdict.d.ts

@@ -1,3 +1,4 @@
+import { type UiLanguage } from './env/uiLanguage.js';
 export type CheckpointRowVerdictReading = {
     readonly kind: 'ok';
 } | {
@@ -21,3 +22,13 @@ export type CheckpointRequirementsDamagedReading = {
     readonly kind: 'row_mismatch';
 };
 export declare function checkpointRequirementsDamagedOf(failure: object | null | undefined): CheckpointRequirementsDamagedReading | undefined;
+export type CheckpointRowBar = Exclude<CheckpointRowVerdictReading, {
+    readonly kind: 'ok';
+}>;
+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,4 +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) {
@@ -87,3 +89,36 @@ export function checkpointRequirementsDamagedOf(failure) {
         return undefined;
     }
 }
+export function checkpointRowBarOf(row) {
+    const v = checkpointRowVerdictOf(row);
+    return v === undefined || v.kind === 'ok' ? undefined : v;
+}
+export const CHECKPOINT_ROW_BAR_SENTENCE = renderMessage(msg('approval.rowUnresumable.fallback'));
+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'), 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/displayUntrusted.d.ts

@@ -2,6 +2,7 @@ export declare const REDACTION_MARKER_PREFIX = "\u00ABredacted";
 export declare function looksLikeKnownSecret(s: string): boolean;
 export declare function isDiagnosticValueWord(value: string): boolean;
 export declare function percentBoundaryReadingOf(text: string): string;
+type BlankNet = 0 | 1 | 2;
 interface WashStats {
     passes: number;
     capped: boolean;
@@ -13,7 +14,7 @@ export interface DisplayFace {
     readonly unsafe: RegExp | null;
     readonly fold: boolean;
     readonly mark: DisplayMark;
-    readonly keepBlanks?: boolean;
+    readonly blanks?: BlankNet;
     readonly keepCrlf?: boolean;
 }
 export declare function applyDisplayFace(text: string, face: DisplayFace): string;
@@ -26,8 +27,8 @@ export interface DisplayUntrustedOptions {
     readonly keepLayout?: boolean | 'crlf';
     readonly mark?: DisplayMark;
     readonly max?: number;
-    readonly escapeBackslashes?: boolean;
-    readonly blanks?: boolean | 'fillers';
+    readonly escapeBackslashes?: boolean | 'auto';
+    readonly blanks?: boolean | 'except-ideographic';
 }
 export interface DisplayMarkSpan {
     readonly start: number;
@@ -37,6 +38,7 @@ export interface DisplayMarkSpan {
 export interface DisplayUntrustedMarked {
     readonly text: string;
     readonly marks: readonly DisplayMarkSpan[];
+    readonly exact: boolean;
 }
 export declare const DISPLAY_DECISION_BODY: Readonly<DisplayUntrustedOptions>;
 export declare const ESCAPE_FACE: DisplayFace;