@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/adapt/arms.js

@@ -1,13 +1,14 @@
 import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../gateOutcome.js';
 import { terminalOwnerOf } from '../seam.js';
 import { isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotSegmentIdentity, snapshotIsSubFlow } from '../adapter/types.js';
-import { classifyPeerNotification, renderPeerFrameTranscriptText } from '../peerFrames.js';
+import { classifyPeerNotification, renderPeerFrameTranscriptText, sessionBoxNoticeOf } from '../peerFrames.js';
 import { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationRenderKeys } from '../notifications.js';
 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 { publishEngineInlineTaskModel } from '../engineInlineTaskStats.js';
+import { applySubagentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
@@ -16,6 +17,7 @@ import { isMintedRowCcError, readProviderRejectionResendKey } from '../providerR
 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 { humanInputAuthorKeys, runOriginKeys } from '../inputAuthor.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 +238,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 +329,21 @@ const humanInputArm = function* (m) {
         ...(str(m.entryId) !== undefined ? { entryId: str(m.entryId) } : {}),
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
         ...humanInputAttachmentsForChrome(m),
+        ...humanInputAuthorKeys(m),
+        ...runOriginKeys(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')
@@ -515,7 +527,7 @@ const compactionStartedArm = function* (m) {
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
-const taskStartedArm = function* (m) {
+const taskStartedArm = function* (m, { cards }) {
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
     const taskId = str(m.taskId);
@@ -542,6 +554,8 @@ const taskStartedArm = function* (m) {
     const eventId = str(idSnap.eventId);
     if (agentType !== undefined && workflowRunId === undefined)
         recordFleetRowAgentType(taskId, agentType);
+    if (model !== undefined && parent !== undefined && workflowRunId === undefined && !cards.has(parent))
+        publishEngineInlineTaskModel(parent, model);
     yield chrome({
         kind: 'subagent_started',
         laneProof,
@@ -623,6 +637,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 +692,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 +785,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({
@@ -948,7 +968,7 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     if (isReplayMarked(m))
         yield chrome({ kind: 'result_replayed', laneProof: mainLane(), text: RESULT_REPLAYED_TEXT });
 };
-const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
+const taskNotificationArm = function* (m, { ctx, idOf, panel, inst, pass }) {
     const n = ownSnapshotRecord(guardedRead(() => readOwnDataValue(m, 'notification'))) ?? {};
     const fields = normalizeTaskNotification(n);
     if (fields === null)
@@ -968,13 +988,18 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
                 : {}),
         });
     }
-    const dedupKeys = taskNotificationRenderKeys({
+    const peerFrame = classifyPeerNotification(n);
+    const baseKeys = taskNotificationRenderKeys({
         taskId,
         status: rawStatus,
         ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
         ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
         ...(fields.completionId !== undefined ? { completionId: fields.completionId } : {}),
     });
+    const inboxRunId = peerFrame !== null && peerFrame.lane === 'inbox_notice' ? readFrameStringKey(n, 'eventId') : undefined;
+    const dedupKeys = peerFrame !== null && peerFrame.lane === 'inbox_notice'
+        ? [`${baseKeys[0]}@${inboxRunId !== undefined ? `e:${inboxRunId}` : `p:${pass}`}`, ...baseKeys.slice(1)]
+        : baseKeys;
     const sameFrameSeen = inst.hasRenderedNotification(dedupKeys[0]);
     const sameCompletionSeen = !sameFrameSeen && dedupKeys.slice(1).some((k) => inst.hasRenderedNotification(k));
     for (const k of dedupKeys)
@@ -995,7 +1020,6 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
             yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus), bgSessionId);
         }
     }
-    const peerFrame = classifyPeerNotification(n);
     if (peerFrame === null && n.task_type !== 'external' && isWorkflowCompletionCardEnqueued(taskId))
         return;
     if (peerFrame === null && n.task_type !== 'external')
@@ -1003,6 +1027,10 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     const fact = peerFrame === null ? freezeTaskNotificationFields(fields) : undefined;
     if (sameCompletionSeen)
         return;
+    const rowUuid = idOf(m);
+    const boxNotice = peerFrame === null ? undefined : sessionBoxNoticeOf(peerFrame);
+    if (boxNotice !== undefined)
+        yield chrome({ kind: 'session_box_notice', laneProof: mainLane(), ...boxNotice, rowUuid });
     yield transcript({
         type: 'user',
         message: {
@@ -1014,7 +1042,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
                 },
             ],
         },
-        uuid: idOf(m),
+        uuid: rowUuid,
         session_id: ctx.sessionId,
         ...(fact !== undefined ? { _sema_task_notification: fact } : {}),
     }, ctx.now());

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.js

@@ -1231,7 +1231,7 @@ 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),
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict, lang),
                     unbound: rowBarWayOutContent(outcome.rowVerdict, outcome.rowDeadline ?? 'unknown', lang),
                 });
             }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -6,6 +6,7 @@ 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 { humanInputAuthorKeys, runOriginKeys } from '../../inputAuthor.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -72,9 +73,6 @@ function streamEventArm(ctx, event) {
 const projected = (message) => ({ kind: 'message', message });
 const nothing = (why) => ({ kind: 'none', why });
 const dropped = (why, type) => ({ kind: 'dropped', why, type });
-function isCompactionStartedFrame(ev) {
-    return ev.type === 'compaction_started';
-}
 const BEYOND_FLOOR_ARMS = Object.freeze(['cross_boundary_taint', 'approval_complete', 'session_titled']);
 function isBeyondFloorArm(ev) {
     const word = ev.type;
@@ -111,8 +109,6 @@ function withEngineIdentity(p, ev, ctx, identityFrame = ev) {
     return projected(Object.assign({}, env, { uuid: envelopeUuidOf(eventId, env.type), _sema_engine_ref: ref }));
 }
 function projectEvent(ev, ctx) {
-    if (isCompactionStartedFrame(ev))
-        return compactionStartedProjection(ev, ctx);
     if (isBeyondFloorArm(ev)) {
         const word = ev.type;
         if (word === 'cross_boundary_taint')
@@ -127,6 +123,8 @@ function projectEvent(ev, ctx) {
     switch (ev.type) {
         case 'task_started':
             return taskStartedProjection(ev, ctx);
+        case 'compaction_started':
+            return compactionStartedProjection(ev, ctx);
         case 'text_end':
             return textEndProjection(ev, ctx);
         case 'reasoning_end':
@@ -954,6 +952,8 @@ 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),
+        ...runOriginKeys(ev),
     })));
 }
 function attachmentsKey(rows) {
@@ -973,3 +973,9 @@ export function turnEndUsage(ev) {
 export function gateKind(gate) {
     return gate?.kind ?? 'human';
 }
+const _pinCompaction = [true, true, true, true, true, true, true, true, true, true, true];
+void _pinCompaction;
+const _pinMods = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true];
+void _pinMods;
+const _pinPrompt = [true, true, true, true, true, true, true, true, true, true];
+void _pinPrompt;

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

@@ -27,7 +27,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 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;

package/dist/checkpointRowVerdict.js

@@ -94,8 +94,10 @@ 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 {

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/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
     server: "7.139.0",
     core: "7.60.0",
-    sdk: "23.1.0",
+    sdk: "25.0.0",
 });