@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/abortableSleep.d.ts

@@ -9,3 +9,10 @@ export type DeadlineSettled<T> = {
     kind: 'deadline';
 };
 export declare function settleWithinDeadline<T>(ms: number, run: (signal: AbortSignal) => Promise<T>): Promise<DeadlineSettled<T>>;
+export interface RequestDeadline {
+    readonly signal: AbortSignal;
+    readonly expired: () => boolean;
+    readonly abort: () => void;
+    readonly race: <T>(p: Promise<T>) => Promise<T>;
+}
+export declare function requestDeadline(ms: number, cancel: AbortSignal | undefined): RequestDeadline;

package/dist/abortableSleep.js

@@ -50,3 +50,40 @@ export function settleWithinDeadline(ms, run) {
         pending.then((value) => finish({ kind: 'value', value }), (error) => finish({ kind: 'error', detail: errorDetail(error) }));
     });
 }
+const MAX_TIMER_MS = 2_147_483_647;
+export function requestDeadline(ms, cancel) {
+    const ctl = new AbortController();
+    const stop = new AbortController();
+    let expired = false;
+    const gone = new Promise((_resolve, reject) => {
+        const fire = () => reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+        if (ctl.signal.aborted)
+            fire();
+        else
+            ctl.signal.addEventListener('abort', fire, { once: true });
+    });
+    gone.catch(() => undefined);
+    void abortableSleep(Math.min(ms, MAX_TIMER_MS), stop.signal).then(() => {
+        if (stop.signal.aborted)
+            return;
+        expired = true;
+        ctl.abort();
+    });
+    const onCancel = () => ctl.abort();
+    if (cancel !== undefined) {
+        if (cancel.aborted)
+            ctl.abort();
+        else
+            cancel.addEventListener('abort', onCancel, { once: true });
+    }
+    return {
+        signal: ctl.signal,
+        expired: () => expired,
+        abort: () => {
+            stop.abort();
+            cancel?.removeEventListener('abort', onCancel);
+            ctl.abort();
+        },
+        race: (p) => Promise.race([p, gone]),
+    };
+}

package/dist/adapt/arms.js

@@ -2,7 +2,7 @@ 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, sessionBoxNoticeOf } from '../peerFrames.js';
-import { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationRenderKeys } from '../notifications.js';
+import { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, resupplyTruncatedArmBody, settleWorkflowPointerOwed, takeWorkflowPointerSupplement, taskNotificationRenderKeys } from '../notifications.js';
 import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.js';
@@ -1015,6 +1015,8 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst, pass }) {
             ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
         });
         dropQueuedNotificationsForRun(taskId);
+        if (peerFrame === null && n.task_type === 'workflow')
+            settleWorkflowPointerOwed(taskId);
         if (n.task_type !== 'background_bash' && n.task_type !== 'monitor') {
             const bgSessionId = n.task_type === 'background_agent' && typeof n.sessionId === 'string' && n.sessionId.length > 0 ? n.sessionId : undefined;
             yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus), bgSessionId);
@@ -1031,6 +1033,9 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst, pass }) {
     const boxNotice = peerFrame === null ? undefined : sessionBoxNoticeOf(peerFrame);
     if (boxNotice !== undefined)
         yield chrome({ kind: 'session_box_notice', laneProof: mainLane(), ...boxNotice, rowUuid });
+    const truncated = resupplyTruncatedArmBody(n, 'task_notification', taskId);
+    if (truncated !== undefined)
+        yield chrome({ kind: 'resupply_truncated', laneProof: mainLane(), ...truncated });
     yield transcript({
         type: 'user',
         message: {
@@ -1054,13 +1059,26 @@ const workflowCompleteArm = function* (frame) {
     const runId = typeof m.runId === 'string' ? m.runId : undefined;
     if (runId === undefined)
         return;
-    if (isEngineWorkflowNotified(runId))
+    const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
+    const extras = workflowCompletionExtrasOf(m);
+    if (isEngineWorkflowNotified(runId)) {
+        const supplement = takeWorkflowPointerSupplement(runId, wfStatus, extras.diagnostics, extras.completionId);
+        if (supplement === undefined)
+            return;
+        yield chrome({
+            kind: 'workflow_notification_enqueue',
+            laneProof: mainLane(),
+            runId,
+            status: wfStatus,
+            summary: supplement.summary,
+            message: renderTaskNotificationXml(supplement),
+            notification: supplement,
+        });
         return;
+    }
     markEngineWorkflowNotified(runId);
-    const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
     const wfSummary = typeof m.summary === 'string' ? m.summary : '';
     noteWorkflowCompletionCardEnqueued(runId);
-    const extras = workflowCompletionExtrasOf(m);
     const notification = freezeTaskNotificationFields({ taskId: runId, taskType: 'workflow', status: wfStatus, summary: wfSummary, ...(extras.completionId !== undefined ? { completionId: extras.completionId } : {}) });
     yield chrome({
         kind: 'workflow_notification_enqueue',
@@ -1072,6 +1090,9 @@ const workflowCompleteArm = function* (frame) {
         notification,
         ...(extras.diagnostics !== undefined ? { diagnostics: extras.diagnostics } : {}),
     });
+    const truncated = resupplyTruncatedArmBody(m, 'workflow_complete', runId);
+    if (truncated !== undefined)
+        yield chrome({ kind: 'resupply_truncated', laneProof: mainLane(), ...truncated });
 };
 const retryStatusArm = function* (m, { ctx, flags }) {
     const status = retryStatusFromArm(m, ctx.now());

package/dist/adapt/toolCards.d.ts

@@ -2,6 +2,7 @@ import type { AdapterContext, AdapterOutput } from '../seam.js';
 import { structuredToToolUseResult, type ToolKillCause, type ToolResultBody } from '../toolResult.js';
 import { type Frame, type IdOf } from './ids.js';
 import type { EngineRowRef } from '../engineRowRef.js';
+import { SEMA_REFUSAL_NOTED_KEY } from '../engineRowRef.js';
 import { type GateOutcomeView, type ToolInputRewriteView } from '../gateOutcome.js';
 type RichToolUseResult = NonNullable<ReturnType<typeof structuredToToolUseResult>>;
 export interface ToolResultOutcome {
@@ -37,10 +38,11 @@ export interface ToolResultRowFlagParts {
     readonly _sema_interrupted_never_started?: true;
     readonly _sema_approval_window_expired?: true;
     readonly _sema_denial_limit_window_expired?: true;
+    readonly [SEMA_REFUSAL_NOTED_KEY]?: true;
     readonly _sema_answered_by?: string;
     readonly _sema_rewrite?: ToolInputRewriteView;
 }
-export declare function toolResultRowFlagParts(arm: object | null | undefined, gate: GateOutcomeView | undefined): ToolResultRowFlagParts;
+export declare function toolResultRowFlagParts(arm: object | null | undefined, gate: GateOutcomeView | undefined, denialKind: string | undefined): ToolResultRowFlagParts;
 interface ToolEndPayload {
     output?: unknown;
     structured?: unknown;

package/dist/adapt/toolCards.js

@@ -1,6 +1,7 @@
 import { deriveTranscriptId } from '../seam.js';
 import { degradedToolResultBody, detectEngineBgShellDetach, detectEngineBgShellReceipt, reportFindingsToolUseResult, structuredToToolUseResult, todoWriteToolUseResult, wireOutputToBody, } from '../toolResult.js';
 import { chrome, mainLane, transcript } from './ids.js';
+import { refusalNotedOf, SEMA_REFUSAL_NOTED_KEY } from '../engineRowRef.js';
 import { flattenWireOutput } from './wireShapes.js';
 import { toolResultBlocksOf } from '../toolResultContent.js';
 import { bashExitOf, bashExitReadingFailed } from '../bashExitReading.js';
@@ -53,7 +54,7 @@ export function toolResultRowIdentity(sources, toolCallId, ctx) {
     }
     return { uuid: deriveTranscriptId({ toolCallId }, ctx) };
 }
-export function toolResultRowFlagParts(arm, gate) {
+export function toolResultRowFlagParts(arm, gate, denialKind) {
     if (arm === null || arm === undefined)
         return {};
     const notExecuted = readFrameTrueMark(arm, 'notExecuted');
@@ -65,6 +66,7 @@ export function toolResultRowFlagParts(arm, gate) {
         ...(readFrameStringKey(arm, 'errorCode') === TOOL_END_INTERRUPTED_NEVER_STARTED ? { _sema_interrupted_never_started: true } : {}),
         ...(isApprovalWindowExpiredGate(gate) ? { _sema_approval_window_expired: true } : {}),
         ...(isDenialLimitAutoDeniedGate(gate) ? { _sema_denial_limit_window_expired: true } : {}),
+        ...(refusalNotedOf(denialKind, gate) ? { [SEMA_REFUSAL_NOTED_KEY]: true } : {}),
         ...(answeredBy !== undefined ? { _sema_answered_by: answeredBy } : {}),
         ...(rewrite !== undefined ? { _sema_rewrite: rewrite } : {}),
     };
@@ -126,7 +128,7 @@ export function createToolCardLedger(ctx, idOf) {
             ...toolResultEnvelopeParts(outcome),
             ...(isCcToolDenialKind(end?.denialKind) ? { _sema_denial_kind: end.denialKind } : {}),
             ...(end?.gate !== undefined ? { _sema_gate: end.gate } : {}),
-            ...toolResultRowFlagParts(end?.closeArm, end?.gate),
+            ...toolResultRowFlagParts(end?.closeArm, end?.gate, end?.denialKind),
         }, ctx.now());
     }
     function* closeCard(p, end) {

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -94,6 +94,7 @@ export interface ActiveRunSelfHealDeps {
     submissionOrigin?: RejectedSubmissionOrigin;
     injectedCarriers?: readonly object[];
     sessionId?: string;
+    stillHere?: () => boolean | undefined;
     wasRecentlyTerminatedByUs?: (taskId: string) => boolean;
     interruptedSettle?: InterruptedSettleWindow;
 }
@@ -135,6 +136,14 @@ export type SelfHealOutcome = {
     kind: 'interrupted-settled';
     taskId: string;
     status: string;
+} | {
+    kind: 'resend-withheld-left';
+    taskId: string;
+    releaseConfirmedByEngine?: true;
+} | {
+    kind: 'resend-withheld-unconfirmed';
+    taskId: string;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'interrupted-still-finishing';
     taskId: string;
@@ -252,6 +261,14 @@ export interface SelfHealFollowDeclaration {
     following?: boolean;
 }
 export declare function injectedResubmitAfter(outcome: SelfHealOutcome | null | undefined, runStatus: string | null | undefined): boolean;
+export type InjectedResubmitWaitVerdict = 'resubmit' | 'gave-up' | 'left' | 'unconfirmed';
+export interface InjectedResubmitWaitDeps extends Pick<ActiveRunSelfHealDeps, 'sessionId' | 'stillHere'> {
+    runs: () => DurableRunVerbs | undefined;
+    budgetMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+export declare function waitForInjectedResubmit(outcome: SelfHealOutcome | null | undefined, deps: InjectedResubmitWaitDeps): Promise<InjectedResubmitWaitVerdict>;
 export declare function readCancelRequested(body: unknown): boolean | undefined;
 export { atMostOnceFailureClass };
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;
@@ -272,6 +289,10 @@ export interface ClaimReleaseWaitDeps {
     session?: string;
 }
 export declare function waitForClaimRelease(taskId: string, deps: ClaimReleaseWaitDeps): Promise<ClaimReleaseVerdict>;
+export type ConversationPresence = 'here' | 'left' | 'unconfirmed';
+export declare function conversationLeftOf(deps: {
+    readonly stillHere?: () => boolean | undefined;
+} | null | undefined): ConversationPresence;
 export declare function attemptActiveRunSelfHeal(signal: ActiveRunBusySignal, runs: DurableRunVerbs | undefined, deps?: ActiveRunSelfHealDeps): Promise<SelfHealOutcome>;
 export interface ActiveRunSelfHealCopy {
     wayOut?: string;
@@ -285,4 +306,22 @@ export interface ActiveRunSelfHealCopy {
 }
 export declare const INTERACTIVE_WAY_OUT: string;
 export declare function activeRunSelfHealRow(outcome: SelfHealOutcome, signal?: ActiveRunBusySignal | null, copy?: ActiveRunSelfHealCopy, origin?: RejectedSubmissionOrigin, follow?: SelfHealFollowDeclaration, lang?: UiLanguage): string;
+export type ConversationLeftStopResult = {
+    kind: 'untouched';
+} | {
+    kind: 'waiting';
+    certain: boolean;
+} | {
+    kind: 'ended';
+    confirmedByEngine: boolean;
+} | {
+    kind: 'nothing-to-end';
+} | {
+    kind: 'refused';
+    detail: string;
+} | {
+    kind: 'not-confirmed';
+};
+export declare function conversationLeftStopResultOf(outcome: SelfHealOutcome | null | undefined): ConversationLeftStopResult;
+export declare function conversationLeftStopRow(result: ConversationLeftStopResult, taskId: string, copy?: ActiveRunSelfHealCopy, lang?: UiLanguage): string;
 export declare function activeRunBusyHeadlessRow(signal: ActiveRunBusySignal, copy?: ActiveRunSelfHealCopy, lang?: UiLanguage): string;

package/dist/adapter/activeRunSelfHeal.js

@@ -1,10 +1,12 @@
 import { abortableSleep } from '../abortableSleep.js';
+import { unrefTimer } from '../unrefTimer.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 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 { STEERING_NOT_RUNNING } from '../engineErrorCodes.js';
 import { readThrownStatusSlot, slotReadOf } from '../wireFailureShape.js';
 import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent } from '../checkpointRowVerdict.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
@@ -76,6 +78,9 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'superseded';
         case 'injected-deferred':
             return 'deferred';
+        case 'resend-withheld-left':
+        case 'resend-withheld-unconfirmed':
+            return 'not-delivered';
         default:
             return 'not-delivered';
     }
@@ -110,6 +115,54 @@ export function injectedResubmitAfter(outcome, runStatus) {
         return false;
     }
 }
+const INJECTED_RESUBMIT_WAIT_BUDGET_MS = 30 * 60_000;
+const INJECTED_RESUBMIT_READ_STEPS_MS = Object.freeze([500, 1_000, 2_000, 4_000, 8_000]);
+function injectedResubmitSleep(ms) {
+    return new Promise((resolve) => {
+        unrefTimer(setTimeout(resolve, ms));
+    });
+}
+async function readDeferredRunStatus(deps, taskId) {
+    try {
+        const verbs = deps.runs();
+        const get = verbs?.get;
+        if (typeof get !== 'function')
+            return null;
+        return readStatusGuarded(await get.call(verbs, taskId, sessionOpts(deps)));
+    }
+    catch {
+        return null;
+    }
+}
+export async function waitForInjectedResubmit(outcome, deps) {
+    try {
+        if (typeof outcome !== 'object' || outcome === null || outcome.kind !== 'injected-deferred')
+            return 'gave-up';
+        if (typeof deps?.runs !== 'function' || typeof deps.runs()?.get !== 'function')
+            return 'gave-up';
+        const now = typeof deps.now === 'function' ? deps.now : () => Date.now();
+        const sleep = typeof deps.sleep === 'function' ? deps.sleep : injectedResubmitSleep;
+        const budgetMs = typeof deps.budgetMs === 'number' && Number.isFinite(deps.budgetMs) && deps.budgetMs >= 0 ? deps.budgetMs : INJECTED_RESUBMIT_WAIT_BUDGET_MS;
+        const startedAt = now();
+        for (let attempt = 0;; attempt++) {
+            const before = conversationLeftOf(deps);
+            if (before !== 'here')
+                return before;
+            const status = await readDeferredRunStatus(deps, outcome.taskId);
+            const after = conversationLeftOf(deps);
+            if (after !== 'here')
+                return after;
+            if (injectedResubmitAfter(outcome, status))
+                return 'resubmit';
+            if (now() - startedAt >= budgetMs)
+                return 'gave-up';
+            await sleep(INJECTED_RESUBMIT_READ_STEPS_MS[Math.min(attempt, INJECTED_RESUBMIT_READ_STEPS_MS.length - 1)] ?? 8_000);
+        }
+    }
+    catch {
+        return 'gave-up';
+    }
+}
 const PLAN_REVIEW_CARRIER_KEY = '_sema_planReviewOutcome';
 function planReviewCarrierOf(item) {
     const meta = guardedRead(() => (typeof item === 'object' && item !== null && !Array.isArray(item) ? readOwnDataValue(item, PLAN_REVIEW_CARRIER_KEY) : undefined));
@@ -589,7 +642,40 @@ async function interruptedShortCircuitUnguarded(signal, runs, deps) {
         return { kind: 'interrupted-still-finishing', taskId, waitedMs: verdict.waitedMs };
     return null;
 }
+export function conversationLeftOf(deps) {
+    if (typeof deps !== 'object' || deps === null)
+        return 'here';
+    let port;
+    try {
+        port = deps.stillHere;
+    }
+    catch {
+        return 'unconfirmed';
+    }
+    if (typeof port !== 'function')
+        return 'here';
+    try {
+        const answer = port.call(deps);
+        return answer === true ? 'here' : answer === false ? 'left' : 'unconfirmed';
+    }
+    catch {
+        return 'unconfirmed';
+    }
+}
 export async function attemptActiveRunSelfHeal(signal, runs, deps) {
+    const outcome = await triageActiveRun(signal, runs, deps);
+    if (selfHealSubmissionDisposition(outcome) !== 'resending' || typeof outcome.taskId !== 'string')
+        return outcome;
+    const presence = conversationLeftOf(deps);
+    if (presence === 'here')
+        return outcome;
+    return {
+        kind: presence === 'left' ? 'resend-withheld-left' : 'resend-withheld-unconfirmed',
+        taskId: outcome.taskId,
+        ...('releaseConfirmedByEngine' in outcome && outcome.releaseConfirmedByEngine === true ? { releaseConfirmedByEngine: true } : {}),
+    };
+}
+async function triageActiveRun(signal, runs, deps) {
     const interrupted = await interruptedShortCircuit(signal, runs, deps);
     if (interrupted !== null)
         return interrupted;
@@ -989,7 +1075,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, carr
             const delivery = atMostOnceFailureClass(e);
             const errorCode = failureWireCode(e);
             let runStatus;
-            if (delivery === 'rejected' && errorCode === STEER_NOT_RUNNING_CODE && typeof runs.get === 'function' && !probeCallerAborted()) {
+            if (delivery === 'rejected' && errorCode === STEERING_NOT_RUNNING && typeof runs.get === 'function' && !probeCallerAborted()) {
                 const probe = await probeRunStatusOnce(taskId, runs, runs.get, deps);
                 if (probe.status !== null)
                     runStatus = probe.status;
@@ -1080,7 +1166,6 @@ function wakeSessionClause(copy, lang) {
         return say(lang, 'session.selfHeal.wakeOn.host', { where: host.trim() });
     return say(lang, 'session.selfHeal.wakeOn.engine');
 }
-const STEER_NOT_RUNNING_CODE = 'steering.not_running';
 function decidePathClause(signal, lang) {
     const decidePath = signal?.pendingGate?.decidePath;
     if (!decidePath)
@@ -1164,6 +1249,13 @@ function injectedSubmissionRow(outcome, following = false, lang) {
     }
     if (outcome.kind === 'interrupted-still-finishing')
         return say(lang, 'session.selfHeal.injected.interruptedFinishing', { lead, id });
+    if (outcome.kind === 'resend-withheld-left') {
+        return outcome.releaseConfirmedByEngine === true
+            ? say(lang, 'session.selfHeal.injected.resendWithheldLeftConfirmed', { lead, id })
+            : say(lang, 'session.selfHeal.injected.resendWithheldLeftInferred', { lead, id });
+    }
+    if (outcome.kind === 'resend-withheld-unconfirmed')
+        return say(lang, 'session.selfHeal.injected.resendWithheldUnconfirmed', { lead });
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
             return say(lang, 'session.selfHeal.injected.heldForDecision', { lead, id });
@@ -1291,7 +1383,7 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             });
         }
         case 'running-steer-failed':
-            if (outcome.delivery === 'rejected' && outcome.errorCode === STEER_NOT_RUNNING_CODE && outcome.runStatus !== undefined && isSdkRunTerminal(outcome.runStatus)) {
+            if (outcome.delivery === 'rejected' && outcome.errorCode === STEERING_NOT_RUNNING && outcome.runStatus !== undefined && isSdkRunTerminal(outcome.runStatus)) {
                 return say(lang, 'session.selfHeal.row.steerFailed.runEnded', { taskId: outcome.taskId, status: outcome.runStatus });
             }
             return outcome.delivery === 'rejected'
@@ -1306,6 +1398,12 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             return outcome.releaseConfirmedByEngine === true
                 ? say(lang, 'session.selfHeal.row.cancelled.confirmed', { taskId: outcome.taskId })
                 : say(lang, 'session.selfHeal.row.cancelled.reported', { taskId: outcome.taskId });
+        case 'resend-withheld-left':
+            return outcome.releaseConfirmedByEngine === true
+                ? say(lang, 'session.selfHeal.row.resendWithheldLeft.confirmed', { taskId: outcome.taskId })
+                : say(lang, 'session.selfHeal.row.resendWithheldLeft.reported', { taskId: outcome.taskId });
+        case 'resend-withheld-unconfirmed':
+            return say(lang, 'session.selfHeal.row.resendWithheldUnconfirmed');
         case 'running-cancel-timeout': {
             const waited = `${String(Math.max(1, Math.round(outcome.waitedMs / 1000)))}s`;
             if (outcome.aborted)
@@ -1377,6 +1475,76 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             });
     }
 }
+export function conversationLeftStopResultOf(outcome) {
+    if (typeof outcome !== 'object' || outcome === null)
+        return { kind: 'untouched' };
+    switch (outcome.kind) {
+        case 'running-cancelled':
+        case 'stale-park-cancelled':
+        case 'ask-decided-without-card':
+        case 'resend-withheld-left':
+        case 'resend-withheld-unconfirmed':
+            return { kind: 'ended', confirmedByEngine: outcome.releaseConfirmedByEngine === true };
+        case 'running-cancel-timeout':
+        case 'stale-park-cancel-timeout':
+        case 'ask-decided-release-unknown':
+        case 'interrupted-still-finishing':
+            return { kind: 'not-confirmed' };
+        case 'running-cancel-failed':
+        case 'stale-park-cancel-failed':
+            return outcome.delivery === 'rejected' ? { kind: 'refused', detail: outcome.detail } : { kind: 'not-confirmed' };
+        case 'running-settled':
+        case 'running-not-found':
+        case 'ask-run-not-found':
+        case 'ask-run-settled':
+        case 'interrupted-settled':
+            return { kind: 'nothing-to-end' };
+        case 'not-parked':
+            return isSdkRunTerminal(outcome.status) ? { kind: 'nothing-to-end' } : { kind: 'untouched' };
+        case 'ask-reopened':
+        case 'plan-review-reopened':
+        case 'decision-pending':
+            return { kind: 'waiting', certain: true };
+        case 'ask-reopen-failed':
+        case 'plan-review-reopen-failed':
+            return { kind: 'waiting', certain: false };
+        case 'state-unknown':
+        case 'stale-park-wait':
+        case 'running-steered':
+        case 'running-steer-failed':
+        case 'running-attach':
+        case 'injected-redundant':
+        case 'injected-deferred':
+            return { kind: 'untouched' };
+    }
+}
+export function conversationLeftStopRow(result, taskId, copy, lang) {
+    const endRun = endRunClause(copy, taskId, lang, 'interactive');
+    try {
+        switch (result.kind) {
+            case 'untouched':
+                break;
+            case 'waiting':
+                return result.certain === true
+                    ? say(lang, 'session.selfHeal.stopLeft.waiting.certain', { taskId })
+                    : say(lang, 'session.selfHeal.stopLeft.waiting.uncertain', { taskId, endRun });
+            case 'ended':
+                return result.confirmedByEngine === true
+                    ? say(lang, 'session.selfHeal.stopLeft.ended.confirmed', { taskId })
+                    : say(lang, 'session.selfHeal.stopLeft.ended.reported', { taskId });
+            case 'nothing-to-end':
+                return say(lang, 'session.selfHeal.stopLeft.nothingToEnd', { taskId });
+            case 'refused':
+                return say(lang, 'session.selfHeal.stopLeft.refused', { taskId, detail: typeof result.detail === 'string' ? result.detail : '', endRun });
+            case 'not-confirmed':
+                return say(lang, 'session.selfHeal.stopLeft.notConfirmed', { taskId, endRun });
+        }
+    }
+    catch {
+        return say(lang, 'session.selfHeal.stopLeft.untouched', { taskId, endRun });
+    }
+    return say(lang, 'session.selfHeal.stopLeft.untouched', { taskId, endRun });
+}
 export function activeRunBusyHeadlessRow(signal, copy, lang) {
     const override = copy?.headlessRowFor?.(signal);
     if (typeof override === 'string')

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,17 +5,16 @@ 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, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, resupplyTruncatedOf, workflowCompletionExtrasOf } from '../../ownKey.js';
 import { humanInputAuthorKeys, runOriginKeys } from '../../inputAuthor.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
+import { promptSuggestionBatchOf } from '../../promptSuggestionBatch.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
 import { envelopeUuidOf, mintEngineRowRef, readBoundRun, wireEventIdOf } from '../../engineRowRef.js';
 function armBody(body) {
     return body;
 }
-const SUGGESTION_BATCH_CAP = 8;
-const SUGGESTION_CHARS_CAP = 200;
 export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'tool_disclosure',
     'tool_progress',
@@ -174,6 +173,10 @@ function projectEvent(ev, ctx) {
                 status: wf.status,
                 summary: typeof wf.summary === 'string' ? wf.summary : '',
                 ...workflowCompletionExtrasOf(wf),
+                ...(() => {
+                    const t = resupplyTruncatedOf(wf);
+                    return t === undefined ? {} : { payloadTruncated: { bytes: t.bytes, droppedKeys: [...t.droppedKeys] } };
+                })(),
             })));
         }
         case 'text':
@@ -403,16 +406,13 @@ function projectEvent(ev, ctx) {
             })));
         }
         case 'suggestions': {
-            const filtered = (Array.isArray(ev.suggestions) ? ev.suggestions : []).filter((s) => typeof s === 'string' && s.trim().length > 0);
-            const list = filtered
-                .slice(0, SUGGESTION_BATCH_CAP)
-                .map((s) => (s.length > SUGGESTION_CHARS_CAP ? `${s.slice(0, SUGGESTION_CHARS_CAP)}…` : s));
-            if (list.length === 0)
+            const batch = promptSuggestionBatchOf(ev.suggestions);
+            if (batch === undefined)
                 return nothing('empty_payload');
             return projected(stamp(ctx, armBody({
                 type: 'prompt_suggestions',
-                suggestions: list,
-                ...(filtered.length > list.length ? { truncatedCount: filtered.length - list.length } : {}),
+                suggestions: [...batch.list],
+                ...(batch.truncatedCount !== undefined ? { truncatedCount: batch.truncatedCount } : {}),
             })));
         }
         case 'turn_end':

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -5,6 +5,7 @@ import type { SDKPermissionDenial, SDKResultError, SDKResultSuccess, TerminalRea
 import { type RunTerminalCodedDetail, type RunTerminalRead } from '../../runTerminal.js';
 import { type SemaModelUsage } from './turnUsageToModelUsage.js';
 import { type ResultLimitWord } from '../../engineErrorCodes.js';
+import type { RunCostSettlement } from '../../sessionCostReading.js';
 import { type ResultWayOutFacts } from '../../providerRejection.js';
 export interface SemaFlatUsage {
     readonly inputTokens: number;
@@ -89,6 +90,7 @@ export interface RunCostFacts {
 export declare function readRunCostFacts(stats: TaskStats | undefined, observed?: {
     readonly usageMissingObserved?: boolean;
 }): RunCostFacts | undefined;
+export declare function runCostSettlementOf(stats: TaskStats | undefined): Exclude<RunCostSettlement, 'awaiting'>;
 export interface ObservedTerminalParts extends PermissionDenialParts {
     readonly _sema_usage_lower_bound?: true;
 }

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -261,6 +261,17 @@ export function readRunCostFacts(stats, observed) {
         reconcile,
     };
 }
+export function runCostSettlementOf(stats) {
+    try {
+        const facts = readRunCostFacts(stats);
+        if (facts === undefined)
+            return 'lost';
+        return facts.reconcile.ownMicroUsd !== undefined ? 'priced' : 'unpriced';
+    }
+    catch {
+        return 'lost';
+    }
+}
 function structuredOutputParts(r) {
     const so = r.structuredOutput;
     return so !== undefined ? { structured_output: so } : {};

package/dist/adapter/runStream.d.ts

@@ -5,6 +5,7 @@ import type { ObservedTerminalParts } from './downstream/terminalToSdkResult.js'
 import { type ToolHistoryErrorCarrier } from '../toolHistoryMismatch.js';
 import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX } from '../rowKind.js';
 export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
+import { type PlanReviewCardFacts } from '../planReviewCardFacts.js';
 export interface ActiveRunPendingGate {
     readonly kind: string | null;
     readonly decidePath: string | null;
@@ -37,5 +38,9 @@ export interface RunStreamHandle {
     latestUsageMissing?: true;
     observedTerminalParts?: () => ObservedTerminalParts;
 }
+export interface PlanReviewFrameClaim {
+    feed(frame: {} | null | undefined): PlanReviewCardFacts | undefined;
+}
+export declare function openPlanReviewFrameClaim(): PlanReviewFrameClaim;
 export declare function isRunStreamActive(): boolean;
 export declare function runStream(events: AsyncIterable<AgentEvent>, ctx: EmitContext, handle?: RunStreamHandle): AsyncGenerator<SDKMessage>;

package/dist/adapter/runStream.js

@@ -20,7 +20,7 @@ import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESS
 export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
-import { openPlanBodyClaimLeg, planReviewParkFacts, stepPlanBodyClaim } from '../planReviewCardFacts.js';
+import { openPlanBodyClaimLeg, planReviewClaimStep } from '../planReviewCardFacts.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
 const ENGINE_TURN_USAGE_KEYS = Object.freeze(['inputTokens', 'totalInputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'costMicroUsd']);
 const _engineTurnUsageKeysPin = true;
@@ -454,6 +454,18 @@ function wireFrameIsSubFlow(ev) {
     });
     return snap === undefined || snapshotIsSubFlow(snap);
 }
+export function openPlanReviewFrameClaim() {
+    const leg = openPlanBodyClaimLeg();
+    return Object.freeze({
+        feed(frame) {
+            if (typeof frame !== 'object' || frame === null)
+                return undefined;
+            const subFlow = wireFrameIsSubFlow(frame);
+            const seq = guardedRead(() => eventSeq(frame));
+            return planReviewClaimStep(leg, frame, subFlow, seq);
+        },
+    });
+}
 function withStringFailureFields(ev) {
     if (ev.type !== 'failed')
         return ev;
@@ -592,7 +604,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             seen.add(seq);
         }
-        stepPlanBodyClaim(planLeg, ev, wireSubFlow);
+        const planReviewAtTerminal = planReviewClaimStep(planLeg, ev, wireSubFlow, seq);
         if (ev.type === 'tool_start') {
             const callId = ev.toolCallId;
             if (typeof callId === 'string' && callId.length > 0 && !toolInputAmbiguous.has(callId)) {
@@ -855,7 +867,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     accepted: ev.type === 'done' && (doneTerminal?.kind === 'completed' || doneTerminal?.kind === 'paused'),
                 }).acceptedSinceMismatch;
             }
-            const planReview = ev.type === 'done' ? planReviewParkFacts(planLeg, engineResultOf(ev.result)) : undefined;
+            const planReview = planReviewAtTerminal;
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
                     await ctx.emitChrome({ kind: 'plan_review_park', laneProof: mainLane(), result: ev.result, ...(planReview !== undefined ? { planReview } : {}) });