@sema-agent/client-core 0.109.0 → 0.111.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

@@ -1,12 +1,13 @@
 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 { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationRenderKeys } from '../notifications.js';
+import { classifyPeerNotification, renderPeerFrameTranscriptText, sessionBoxNoticeOf } from '../peerFrames.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';
 import { recordEngineToolLabel } from '../engineToolLabelStore.js';
+import { publishEngineInlineTaskModel } from '../engineInlineTaskStats.js';
 import { applySubagentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
@@ -15,7 +16,8 @@ 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, humanInputAuthorKeys, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.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';
@@ -328,6 +330,7 @@ const humanInputArm = function* (m) {
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
         ...humanInputAttachmentsForChrome(m),
         ...humanInputAuthorKeys(m),
+        ...runOriginKeys(m),
     });
 };
 function humanInputAttachmentsForChrome(m) {
@@ -524,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);
@@ -551,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,
@@ -963,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)
@@ -983,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)
@@ -1005,12 +1015,13 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
             ...(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);
         }
     }
-    const peerFrame = classifyPeerNotification(n);
     if (peerFrame === null && n.task_type !== 'external' && isWorkflowCompletionCardEnqueued(taskId))
         return;
     if (peerFrame === null && n.task_type !== 'external')
@@ -1018,6 +1029,13 @@ 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 });
+    const truncated = resupplyTruncatedArmBody(n, 'task_notification', taskId);
+    if (truncated !== undefined)
+        yield chrome({ kind: 'resupply_truncated', laneProof: mainLane(), ...truncated });
     yield transcript({
         type: 'user',
         message: {
@@ -1029,7 +1047,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());
@@ -1041,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',
@@ -1059,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')