@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/adapt/arms.js

@@ -7,7 +7,7 @@ import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.js';
 import { recordEngineToolLabel } from '../engineToolLabelStore.js';
-import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
+import { applySubagentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
@@ -15,7 +15,7 @@ import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { isMintedRowCcError, readProviderRejectionResendKey } from '../providerRejection.js';
 import { rowKindOf } from '../rowKind.js';
 import { terminalCodedDetailOf } from '../runTerminal.js';
-import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, humanInputAuthorKeys, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
 import { CORE_USER_ATTACHMENT_LABEL_MAX } from '../generated/engineFactTables.js';
 import { ESCAPE_FACE, paintAndCap, washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
@@ -236,7 +236,9 @@ const userArm = function* (m, { ctx, idOf }) {
         return;
     yield transcript({ ...m, uuid: idOf(m), session_id: ctx.sessionId }, ctx.now());
 };
-const systemArm = function* (m, { ctx, idOf }) {
+const systemArm = function* (m, { ctx, idOf, text }) {
+    if (readFrameStringKey(m, 'subtype') === 'compact_boundary')
+        text.noteModelSegmentBoundary();
     yield transcript(m, ctx.now());
     const attachedFiles = m._sema_attached_files;
     if (Array.isArray(attachedFiles)) {
@@ -325,13 +327,20 @@ const humanInputArm = function* (m) {
         ...(str(m.entryId) !== undefined ? { entryId: str(m.entryId) } : {}),
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
         ...humanInputAttachmentsForChrome(m),
+        ...humanInputAuthorKeys(m),
     });
 };
 function humanInputAttachmentsForChrome(m) {
     const rows = humanInputAttachmentsOf(m);
     if (rows === undefined)
         return {};
-    return { attachments: rows.map((r) => (r.label !== undefined ? { ...r, label: paintAndCap(r.label, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } : r)) };
+    return {
+        attachments: rows.map((r) => ({
+            ...r,
+            ...(r.label !== undefined ? { label: paintAndCap(r.label, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } : {}),
+            ...(r.declinedBy !== undefined ? { declinedBy: { kind: r.declinedBy.kind, name: paintAndCap(r.declinedBy.name, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } } : {}),
+        })),
+    };
 }
 const messageCommittedArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
@@ -623,6 +632,7 @@ const textSegmentEndArm = function* (m, { text }) {
     if (content.length === 0)
         return;
     text.anchorWindow(m);
+    yield* text.admitEndOnlyBlock(content, m);
     const r = text.replaceAnswerSegment(content, m);
     yield* text.drainLive();
     yield chrome({
@@ -677,8 +687,9 @@ const toolEndResultArm = function* (m, deps) {
     const structured = ownSnapshotWhenTyped(m.structured, 'task-output');
     if (callId !== undefined) {
         const launched = readAsyncLaunchedAgentReceipt(structured);
-        if (launched !== null)
-            registerSubagentContentAlias(callId, launched.taskId);
+        if (launched !== null && applySubagentAlias(callId, launched.taskId, 'content') !== 'rejected') {
+            yield chrome({ kind: 'subagent_alias', laneProof: { lane: 'subagent', parentToolCallId: callId }, parentToolCallId: callId, taskId: launched.taskId, scope: 'content' });
+        }
     }
     if (callId !== undefined && isUnsettledHeldToolEnd(m)) {
         const held = cards.detach(callId);
@@ -769,8 +780,12 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         }));
         return;
     }
-    if (explicitParent !== undefined)
-        registerSubagentAlias(explicitParent, taskId);
+    if (explicitParent !== undefined) {
+        const aliasSeq = cycleSeqValue(m.seq);
+        if (applySubagentAlias(explicitParent, taskId, 'full', aliasSeq) !== 'rejected') {
+            yield chrome({ kind: 'subagent_alias', laneProof: { lane: 'subagent', parentToolCallId: explicitParent }, parentToolCallId: explicitParent, taskId, scope: 'full', ...(aliasSeq !== undefined ? { seq: aliasSeq } : {}) });
+        }
+    }
     const cardId = panel.bind(taskId, explicitParent);
     const usage = (m.usage ?? {});
     ctx.probe?.('tick', JSON.stringify({

package/dist/adapt/textStream.d.ts

@@ -18,6 +18,8 @@ interface ThinkingSegmentReplacement {
 }
 export interface TextStream {
     feedText(delta: string, frame: Frame): Generator<AdapterOutput>;
+    admitEndOnlyBlock(content: string, frame: Frame): Generator<AdapterOutput>;
+    noteModelSegmentBoundary(): void;
     feedThinking(delta: string, frame: Frame): Generator<AdapterOutput>;
     drainLive(): Generator<AdapterOutput>;
     takeThinking(): Generator<AdapterOutput>;

package/dist/adapt/textStream.js

@@ -39,6 +39,10 @@ export function createTextStream(ctx, idOf) {
     let segmentCommitted = '';
     let previousSegmentCommitted = '';
     let segmentWindowCloseArmed = false;
+    let wholeBlockDelivered = false;
+    const closeWholeBlockMark = () => {
+        wholeBlockDelivered = false;
+    };
     const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
         ? ctx.coalesceIntervalMs
         : FLUSH_INTERVAL_MS;
@@ -122,6 +126,7 @@ export function createTextStream(ctx, idOf) {
     }
     function* takeAnswerSegment() {
         idleFlushUsedInSegment = false;
+        closeWholeBlockMark();
         yield* emitAnswerSegment();
         previousSegmentCommitted += segmentCommitted;
         segmentCommitted = '';
@@ -166,23 +171,37 @@ export function createTextStream(ctx, idOf) {
             textPending = '';
         }
     }
+    function* feedText(delta, frame) {
+        if (delta.length === 0 && segmentWindowCloseArmed && previousSegmentCommitted + segmentCommitted !== '')
+            return;
+        consumeArmedClose();
+        if (thinking.length > 0 || thinkingPending.length > 0) {
+            yield* drainLive();
+            yield* takeThinking();
+        }
+        if (answerSegment.length === 0)
+            segmentAnchor = frame;
+        segmentLast = frame;
+        openSegmentWindow(frame);
+        answer += delta;
+        answerSegment += delta;
+        textPending += delta;
+    }
+    function* admitEndOnlyBlock(content, frame) {
+        if (content.length === 0 || wholeBlockDelivered)
+            return;
+        const verdict = resolveTextSegmentAuthority(content, {
+            committedPrefix: previousSegmentCommitted + segmentCommitted,
+            openSegment: answerSegment,
+        });
+        if (verdict.form !== 'untouched')
+            return;
+        yield* feedText(content, frame);
+    }
     return {
-        *feedText(delta, frame) {
-            if (delta.length === 0 && segmentWindowCloseArmed && previousSegmentCommitted + segmentCommitted !== '')
-                return;
-            consumeArmedClose();
-            if (thinking.length > 0 || thinkingPending.length > 0) {
-                yield* drainLive();
-                yield* takeThinking();
-            }
-            if (answerSegment.length === 0)
-                segmentAnchor = frame;
-            segmentLast = frame;
-            openSegmentWindow(frame);
-            answer += delta;
-            answerSegment += delta;
-            textPending += delta;
-        },
+        feedText,
+        admitEndOnlyBlock,
+        noteModelSegmentBoundary: closeWholeBlockMark,
         *feedThinking(delta, frame) {
             if (thinkingSettled) {
                 if (thinking.length > 0) {
@@ -335,6 +354,8 @@ export function createTextStream(ctx, idOf) {
             emittedAssistantText = true;
             if (typeof committed === 'string')
                 committedText += committed;
+            if (typeof committed === 'string' && committed.length > 0)
+                wholeBlockDelivered = true;
         },
         replaceThinkingSegment: (content, anchor) => {
             const rows = committedThinking;

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -48,6 +48,7 @@ export type ReopenCardVerdict = {
     _sema_rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    _sema_rowDeadline?: number | null;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -154,6 +155,7 @@ export type SelfHealOutcome = {
     rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    rowDeadline?: 'armed' | 'none';
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -5,8 +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 { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.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';
@@ -215,6 +215,7 @@ const REOPEN_VERDICT_KEYS = [
     '_sema_reopenRefusal',
     '_sema_policyBlocked',
     '_sema_rowVerdict',
+    '_sema_rowDeadline',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -338,6 +339,20 @@ function reopenRowVerdictOf(verdict) {
         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)
@@ -722,6 +737,7 @@ async function askParkArm(taskId, signal, runs, carrierVerdict, deps) {
     const noView = reopenRefusedForNoPresentationSurface(verdict);
     const policyBlocked = inFlight || noView ? undefined : reopenPolicyBlockedOf(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',
@@ -733,6 +749,7 @@ async function askParkArm(taskId, signal, runs, carrierVerdict, deps) {
         ...(errorCode !== undefined ? { errorCode } : {}),
         ...(policyBlocked !== undefined ? { policyBlocked } : {}),
         ...(rowVerdict !== undefined ? { rowVerdict } : {}),
+        ...(rowDeadline !== undefined ? { rowDeadline } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -1214,8 +1231,8 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             if (outcome.rowVerdict !== undefined) {
                 return say(lang, 'session.selfHeal.row.askReopenFailed.rowUnresumable', {
                     taskId: outcome.taskId,
-                    sentence: checkpointRowBarSentence(outcome.rowVerdict),
-                    unbound: msg('approval.decide.unboundWayOut'),
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict, lang),
+                    unbound: rowBarWayOutContent(outcome.rowVerdict, outcome.rowDeadline ?? 'unknown', lang),
                 });
             }
             if (outcome.policyBlocked !== undefined)

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,7 +5,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf, toolInputRewriteOf } from '.
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpAuthorization, readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, workflowCompletionExtrasOf } from '../../ownKey.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, humanInputAuthorKeys, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, workflowCompletionExtrasOf } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -954,6 +954,7 @@ function humanInputProjection(ev, ctx) {
         ...(str(ev.eventId) !== undefined ? { eventId: str(ev.eventId) } : {}),
         ...(str(ev.parentToolCallId) !== undefined ? { parentToolCallId: str(ev.parentToolCallId) } : {}),
         ...attachmentsKey(humanInputAttachmentsOf(ev)),
+        ...humanInputAuthorKeys(ev),
     })));
 }
 function attachmentsKey(rows) {

package/dist/agentSession/engineAgentRegistryRead.js

@@ -77,6 +77,7 @@ function readRow(v) {
     const description = Object.hasOwn(o, 'description') ? o.description : undefined;
     const createdAt = Object.hasOwn(o, 'createdAt') ? o.createdAt : undefined;
     const childSessionId = type === 'background_agent' ? guardedRead(() => readOwnDataValue(o, 'sessionId')) : undefined;
+    const retained = guardedRead(() => readOwnDataValue(o, 'retained')) === true;
     return {
         id,
         type,
@@ -84,6 +85,7 @@ function readRow(v) {
         ...(typeof description === 'string' && description.length > 0 ? { description } : {}),
         ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
         ...(typeof childSessionId === 'string' && childSessionId.length > 0 ? { sessionId: childSessionId } : {}),
+        ...(retained ? { retained: true } : {}),
     };
 }
 export async function readEngineAgentRegistry(client, sessionId, capsBaseUrl, opts) {

package/dist/bashExitReading.d.ts

@@ -8,3 +8,15 @@ export interface BashExitReading {
 }
 export declare function bashExitOf(structured: unknown, parseFrame: () => BashFrameExit | null): BashExitReading;
 export declare function bashExitReadingFailed(r: BashExitReading): boolean;
+export type BashCurtailmentKind = 'timedOut' | 'livenessNoOutput' | 'aborted' | 'callbackError';
+export interface BashCurtailment {
+    readonly kind: BashCurtailmentKind;
+    readonly timeoutSec?: number;
+    readonly noOutputSec?: number;
+}
+export declare function bashCurtailmentOf(structured: unknown): BashCurtailment | undefined;
+export declare function bashCurtailmentSentence(c: BashCurtailment): string;
+export declare function bashCurtailedResultPart(stderr: string, c: BashCurtailment | undefined): {
+    stderr: string;
+    _sema_curtailed?: BashCurtailment;
+};

package/dist/bashExitReading.js

@@ -1,3 +1,4 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
 export function bashExitOf(structured, parseFrame) {
     const s = typeof structured === 'object' && structured !== null ? structured : undefined;
     const interp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0 ? s.returnCodeInterpretation : undefined;
@@ -10,3 +11,46 @@ export function bashExitOf(structured, parseFrame) {
 export function bashExitReadingFailed(r) {
     return r.exitCode !== null && r.exitCode !== 0 && r.benignNote === undefined;
 }
+export function bashCurtailmentOf(structured) {
+    if (typeof structured !== 'object' || structured === null)
+        return undefined;
+    const own = (key) => guardedRead(() => readOwnDataValue(structured, key));
+    if (own('type') !== 'bash')
+        return undefined;
+    const secOf = (key) => {
+        const v = own(key);
+        return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? (v === 0 ? 0 : v) : undefined;
+    };
+    if (own('timedOut') === true) {
+        const timeoutSec = secOf('timeoutSec');
+        return timeoutSec === undefined ? { kind: 'timedOut' } : { kind: 'timedOut', timeoutSec };
+    }
+    if (own('livenessNoOutput') === true) {
+        const noOutputSec = secOf('noOutputSec');
+        return noOutputSec === undefined ? { kind: 'livenessNoOutput' } : { kind: 'livenessNoOutput', noOutputSec };
+    }
+    if (own('aborted') === true)
+        return { kind: 'aborted' };
+    if (own('callbackError') === true)
+        return { kind: 'callbackError' };
+    return undefined;
+}
+export function bashCurtailmentSentence(c) {
+    switch (c.kind) {
+        case 'timedOut':
+            return c.timeoutSec === undefined ? 'Command timed out' : `Command timed out after ${c.timeoutSec}s`;
+        case 'livenessNoOutput':
+            return c.noOutputSec === undefined ? 'Command killed: no output' : `Command killed: no output for ${c.noOutputSec}s`;
+        case 'aborted':
+            return 'Command was interrupted';
+        case 'callbackError':
+            return 'Command ended: output stream failed';
+    }
+}
+export function bashCurtailedResultPart(stderr, c) {
+    if (c === undefined)
+        return { stderr };
+    const sentence = bashCurtailmentSentence(c);
+    const alreadyLeads = stderr.startsWith(sentence) && stderr.charAt(sentence.length).trim() === '';
+    return { stderr: stderr.length === 0 ? sentence : alreadyLeads ? stderr : `${sentence} ${stderr}`, _sema_curtailed: { ...c } };
+}

package/dist/checkpointRowVerdict.d.ts

@@ -1,3 +1,4 @@
+import { type UiLanguage } from './env/uiLanguage.js';
 export type CheckpointRowVerdictReading = {
     readonly kind: 'ok';
 } | {
@@ -26,4 +27,8 @@ 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 declare function checkpointRowBarSentence(bar: CheckpointRowBar, lang?: UiLanguage | (string & {})): 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) {
@@ -93,6 +94,33 @@ export function checkpointRowBarOf(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 checkpointRowBarSentence(bar, lang) {
+    return bar.kind !== 'unreadable' && typeof bar.sentence === 'string' && bar.sentence !== ''
+        ? bar.sentence
+        : renderMessage(msg('approval.rowUnresumable.fallback'), isUiLanguage(lang) ? lang : undefined);
+}
+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/compensations.js

@@ -118,7 +118,7 @@ export const MIGRATED_COMPENSATIONS = [
         id: 'T49',
         what: 'subagent alias 只能在 tick 上学 —— content 帧只带 parentToolCallId、没有 taskId',
         disposition: 'in-library',
-        libraryHalf: 'adapt.ts task_progress 臂 registerSubagentAlias(explicitParent, taskId)',
+        libraryHalf: 'adapt.ts task_progress 臂 applySubagentAlias(explicitParent, taskId, \'full\')(与 registerSubagentAlias 同一实现)',
         chromeArm: null,
         hostHalf: null,
         retireOn: 'RL-40',

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/engineAgentAbsence.d.ts

@@ -56,6 +56,7 @@ export interface EngineAgentRegistryRowView {
     readonly description?: string;
     readonly createdAt?: number;
     readonly sessionId?: string;
+    readonly retained?: true;
 }
 export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'capability_unknown' | 'route_absent' | 'ownership_required' | 'read_failed';
 export type EngineAgentRegistryListing = {
@@ -75,6 +76,7 @@ export interface EngineAgentRegistryReadingOptions {
     readonly sessionId?: string;
 }
 export declare function engineAgentRegistryReadingOf(listing: EngineAgentRegistryListing | null | undefined, registryKey: string | null | undefined, opts?: EngineAgentRegistryReadingOptions | null): EngineAgentRegistryReading;
+export declare function localEngineSessionShellsOf(listings: readonly (EngineAgentRegistryListing | null | undefined)[]): number | 'unknown';
 export interface EngineAgentRegistryMissingRow {
     readonly id: string;
     readonly status: string;

package/dist/engineAgentAbsence.js

@@ -214,6 +214,34 @@ function readingFromRecord(rec, registryKey, opts) {
     const single = ownOpt(opts, 'singleReplica');
     return single.given && single.value === true && REGISTRY_AGENT_HANDLE_RE.test(registryKey) ? 'not_listed' : 'unknown';
 }
+const SESSION_SHELL_TYPES = new Set(Object.keys({ background_bash: true, monitor: true }));
+export function localEngineSessionShellsOf(listings) {
+    try {
+        if (!Array.isArray(listings))
+            return 'unknown';
+        let count = 0;
+        for (let i = 0; i < listings.length; i++) {
+            if (!Object.hasOwn(listings, i))
+                return 'unknown';
+            const rec = registryListingProvenanceOf(listings[i]);
+            if (rec === undefined || rec.superseded || rec.rawRowCount >= REGISTRY_LIST_LIMIT)
+                return 'unknown';
+            for (const r of rec.rows) {
+                if (!SESSION_SHELL_TYPES.has(r.type) || r.retained === true)
+                    continue;
+                const reading = registryStatusReading(r.status);
+                if (reading === 'unknown')
+                    return 'unknown';
+                if (reading === 'running')
+                    count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function keySetOf(v) {
     if (v instanceof Set)
         return (k) => v.has(k);