@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/adapt/arms.js

@@ -16,7 +16,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, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameEntryIdList, 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';
@@ -926,6 +926,9 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     const errorEnvelope = typeof m.subtype === 'string' && m.subtype.startsWith(ERROR_SUBTYPE_PREFIX);
     const terminalText = salvaged !== undefined ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
     const committed = text.lastCommittedAnswerText;
+    const namedEntryIds = readFrameEntryIdList(m, '_sema_result_entry_ids');
+    const lastTwoOnScreen = text.lastTwoCommittedAnswerText;
+    const twoLinkChainOnScreen = namedEntryIds !== undefined && namedEntryIds.length === 2 && lastTwoOnScreen !== undefined && lastTwoOnScreen.trim() === terminalText.trim();
     const terminalIdentity = messageIdentityOf(m, ctx);
     const emitTerminal = function* (body, tag) {
         yield transcript({
@@ -947,6 +950,8 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     }
     else if (terminalText.length === 0) {
     }
+    else if (twoLinkChainOnScreen) {
+    }
     else if (committed.trim() === terminalText.trim()) {
     }
     else if (prefixOf(terminalText, committed) !== null) {
@@ -965,6 +970,7 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
             resultLength: terminalText.length,
         });
     }
+    text.endRunScope();
     if (isReplayMarked(m))
         yield chrome({ kind: 'result_replayed', laneProof: mainLane(), text: RESULT_REPLAYED_TEXT });
 };

package/dist/adapt/textStream.d.ts

@@ -33,6 +33,8 @@ export interface TextStream {
     readonly emittedAssistantText: boolean;
     readonly committedAnswerText: string;
     readonly lastCommittedAnswerText: string;
+    readonly lastTwoCommittedAnswerText: string | undefined;
+    endRunScope(): void;
     beginAssistantMessage(): void;
     closeSegmentAuthorityWindowOnNextText(): void;
     replaceThinkingSegment(content: string, anchor?: Frame): ThinkingSegmentReplacement;

package/dist/adapt/textStream.js

@@ -28,6 +28,10 @@ export function createTextStream(ctx, idOf) {
     let emittedAssistantText = false;
     let committedText = '';
     let previousCommittedText = '';
+    let olderCommittedText = '';
+    let closedTextMessagesInRun = 0;
+    let runBooksRewritten = false;
+    let currentFromClosedRun = false;
     let committedTextRows = [];
     let messageSerial = 0;
     let textPending = '';
@@ -294,6 +298,8 @@ export function createTextStream(ctx, idOf) {
                     }
                     booksSynced = syncedBook !== null;
                 }
+                if (booksSynced)
+                    runBooksRewritten = true;
                 if (booksSynced && answer.endsWith(liveSegment)) {
                     answer = answer.slice(0, answer.length - liveSegment.length) + content;
                 }
@@ -316,6 +322,7 @@ export function createTextStream(ctx, idOf) {
             if (committedPrefixDiverged) {
                 if (committedText.endsWith(livePrefix)) {
                     committedText = committedText.slice(0, committedText.length - livePrefix.length) + content;
+                    runBooksRewritten = true;
                 }
             }
             else {
@@ -437,8 +444,13 @@ export function createTextStream(ctx, idOf) {
         },
         beginAssistantMessage: () => {
             messageSerial += 1;
-            if (carriesAnswerText(committedText))
+            if (carriesAnswerText(committedText)) {
+                olderCommittedText = previousCommittedText;
                 previousCommittedText = committedText;
+                if (!currentFromClosedRun)
+                    closedTextMessagesInRun += 1;
+            }
+            currentFromClosedRun = false;
             committedText = '';
             previousSegmentCommitted += segmentCommitted;
             segmentCommitted = '';
@@ -452,6 +464,20 @@ export function createTextStream(ctx, idOf) {
         get lastCommittedAnswerText() {
             return carriesAnswerText(committedText) ? committedText : previousCommittedText;
         },
+        get lastTwoCommittedAnswerText() {
+            if (runBooksRewritten || currentFromClosedRun)
+                return undefined;
+            const currentCarries = carriesAnswerText(committedText);
+            if (closedTextMessagesInRun + (currentCarries ? 1 : 0) < 2)
+                return undefined;
+            return currentCarries ? previousCommittedText + committedText : olderCommittedText + previousCommittedText;
+        },
+        endRunScope: () => {
+            closedTextMessagesInRun = 0;
+            olderCommittedText = '';
+            runBooksRewritten = false;
+            currentFromClosedRun = committedText.length > 0;
+        },
         get emittedAssistantText() {
             return emittedAssistantText;
         },

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -54,7 +54,12 @@ export type ReopenCardVerdict = {
     firstSight: boolean;
     presented?: boolean;
 };
-export declare const PLAN_REVIEW_REOPEN_REFUSALS: readonly ["invalid_call", "no_delivery_path", "not_presented", "gate_record_gone", "internal_error"];
+export interface PlanReviewReopenCallOptions {
+    trigger?: PlanReviewReopenTrigger;
+    checkpointId?: string;
+    stillHere?: () => boolean | undefined;
+}
+export declare const PLAN_REVIEW_REOPEN_REFUSALS: readonly ["invalid_call", "no_delivery_path", "not_presented", "gate_record_gone", "internal_error", "conversation_left", "conversation_unconfirmed"];
 export type PlanReviewReopenRefusal = (typeof PLAN_REVIEW_REOPEN_REFUSALS)[number];
 export interface RunningChoiceRequest {
     taskId: string;
@@ -78,10 +83,7 @@ export interface ActiveRunSelfHealDeps {
     listOwnedPendingApprovals?: (opts?: {
         signal?: AbortSignal;
     }) => Promise<number>;
-    reopenPlanReview?: (taskId: string, opts?: {
-        trigger?: PlanReviewReopenTrigger;
-        checkpointId?: string;
-    }) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
+    reopenPlanReview?: (taskId: string, opts?: PlanReviewReopenCallOptions) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
     reopenAskPark?: (taskId: string, opts?: {
         trigger?: PlanReviewReopenTrigger;
     }) => Promise<ReopenCardVerdict>;

package/dist/adapter/activeRunSelfHeal.js

@@ -7,9 +7,10 @@ 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 { endRunClauseOf as endRunClause, gateKindPhraseOf as gateKindPhrase, governanceOriginClauseOf as governanceOriginClause, sessionBusyRowOf } from '../sessionOccupant.js';
 import { readThrownStatusSlot, slotReadOf } from '../wireFailureShape.js';
 import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent } from '../checkpointRowVerdict.js';
-import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
+import { guardedRead, hostPresenceOf, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
@@ -52,7 +53,7 @@ export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
 export const RUNNING_STATES = Object.freeze(['running']);
 export const CLAIM_HELD_STATES = SDK_RUN_LIVE_STATUSES;
-export const PLAN_REVIEW_REOPEN_REFUSALS = Object.freeze(['invalid_call', 'no_delivery_path', 'not_presented', 'gate_record_gone', 'internal_error']);
+export const PLAN_REVIEW_REOPEN_REFUSALS = Object.freeze(['invalid_call', 'no_delivery_path', 'not_presented', 'gate_record_gone', 'internal_error', 'conversation_left', 'conversation_unconfirmed']);
 export function selfHealSubmissionDisposition(outcome) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -642,25 +643,10 @@ async function interruptedShortCircuitUnguarded(signal, runs, deps) {
         return { kind: 'interrupted-still-finishing', taskId, waitedMs: verdict.waitedMs };
     return null;
 }
+const _conversationPresencePin = [true, true];
+void _conversationPresencePin;
 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';
-    }
+    return hostPresenceOf(deps);
 }
 export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     const outcome = await triageActiveRun(signal, runs, deps);
@@ -743,10 +729,20 @@ async function triageActiveRun(signal, runs, deps) {
     }
     return { kind: 'not-parked', taskId, status, ...triageGate };
 }
+function stillHereForwardOf(deps) {
+    let port;
+    try {
+        port = deps?.stillHere;
+    }
+    catch {
+        return { stillHere: () => undefined };
+    }
+    return port === undefined ? {} : { stillHere: port };
+}
 async function planVerdict(taskId, deps, checkpointId) {
     try {
         const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
-        const second = { ...(trigger !== undefined ? { trigger } : {}), ...(checkpointId !== undefined && checkpointId.length > 0 ? { checkpointId } : {}) };
+        const second = { ...(trigger !== undefined ? { trigger } : {}), ...(checkpointId !== undefined && checkpointId.length > 0 ? { checkpointId } : {}), ...stillHereForwardOf(deps) };
         const verdict = Object.keys(second).length === 0 ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, second);
         return snapshotReopenVerdict(await verdict);
     }
@@ -1133,25 +1129,6 @@ async function routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerd
 }
 export const INTERACTIVE_WAY_OUT = EN_MESSAGES['session.selfHeal.wayOut.interactive'];
 const say = (lang, key, params) => renderMessage(msg(key, params), lang);
-function gateKindPhrase(kind, lang) {
-    return kind ? say(lang, 'session.selfHeal.gate.kind', { kind }) : say(lang, 'session.selfHeal.gate.generic');
-}
-function endRunClause(copy, taskId, lang, face = 'headless') {
-    let host;
-    try {
-        host = copy?.endRun;
-    }
-    catch {
-        host = undefined;
-    }
-    const phrase = typeof host === 'string' ? host.trim().replace(/[\s.;。；!！?？]+$/u, '') : '';
-    if (/[\p{L}\p{N}]/u.test(phrase))
-        return phrase;
-    if (face === 'interactive') {
-        return taskId ? say(lang, 'session.selfHeal.endRun.engineInteractive', { taskId }) : say(lang, 'session.selfHeal.endRun.engineInteractive.noId');
-    }
-    return say(lang, 'session.selfHeal.endRun.engine', { cancelPath: `POST /v1/runs/${taskId ? taskId : '<id>'}/cancel` });
-}
 function wakeSessionClause(copy, lang) {
     let host;
     try {
@@ -1172,9 +1149,6 @@ function decidePathClause(signal, lang) {
         return '';
     return say(lang, 'session.selfHeal.decidePathClause', { gate: gateKindPhrase(signal?.pendingGate?.kind, lang), decidePath });
 }
-function governanceOriginClause(signal, lang) {
-    return signal?.pendingGate?.governanceForced === true ? say(lang, 'session.selfHeal.governanceOrigin') : '';
-}
 function lastActivityClause(signal, lang) {
     const ms = signal?.msSinceLastActivity;
     if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0)
@@ -1182,6 +1156,12 @@ function lastActivityClause(signal, lang) {
     const human = ms < 120_000 ? `${String(Math.max(1, Math.round(ms / 1000)))}s` : `${String(Math.round(ms / 60_000))}m`;
     return say(lang, 'session.selfHeal.lastActivity', { ago: human });
 }
+function conversationRefusalOf(outcome) {
+    if (outcome.decisionInFlight === true || outcome.dismissedByUser === true || outcome.noPresentationSurface === true)
+        return undefined;
+    const cause = outcome.reopenRefusal;
+    return cause === 'conversation_left' || cause === 'conversation_unconfirmed' ? cause : undefined;
+}
 export function activeRunSelfHealRow(outcome, signal, copy, origin, follow, lang) {
     const override = copy?.rowFor?.(outcome, signal);
     if (typeof override === 'string')
@@ -1193,7 +1173,8 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow, lang
     const keep = (outcome.kind === 'plan-review-reopen-failed' || outcome.kind === 'ask-reopen-failed') &&
         outcome.decisionInFlight !== true &&
         outcome.pendingRowGone !== true &&
-        (outcome.kind !== 'plan-review-reopen-failed' || outcome.dismissedByUser !== true)
+        (outcome.kind !== 'plan-review-reopen-failed' || outcome.dismissedByUser !== true) &&
+        (outcome.kind !== 'plan-review-reopen-failed' || conversationRefusalOf(outcome) === undefined)
         ? keepSessionWayOutOf(copy)
         : null;
     const base = activeRunSelfHealBaseRow(outcome, copy?.wayOut ?? say(lang, 'session.selfHeal.wayOut.interactive'), following, keep, engineDecide, lang, copy);
@@ -1226,6 +1207,13 @@ function injectedSubmissionRow(outcome, following = false, lang) {
     if (outcome.kind === 'plan-review-reopen-failed' && outcome.dismissedByUser === true) {
         return say(lang, 'session.selfHeal.injected.dismissedPlan', { lead, id, closed: msg('session.selfHeal.userClosedCardNotPutBack') });
     }
+    if (outcome.kind === 'plan-review-reopen-failed') {
+        const gone = conversationRefusalOf(outcome);
+        if (gone === 'conversation_left')
+            return say(lang, 'session.selfHeal.injected.planReopenConversationLeft', { lead, id });
+        if (gone === 'conversation_unconfirmed')
+            return say(lang, 'session.selfHeal.injected.planReopenConversationUnconfirmed', { lead, id });
+    }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'queued') {
         const queuedOn = msg('session.selfHeal.injected.queuedOn', { lead, id });
         const reopened = reopenedOfOutcome(outcome);
@@ -1341,6 +1329,11 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             if (outcome.dismissedByUser === true) {
                 return say(lang, 'session.selfHeal.row.planReopenFailed.dismissed', { taskId: outcome.taskId, closed: msg('session.selfHeal.userClosedCardNotPutBack') });
             }
+            const gone = conversationRefusalOf(outcome);
+            if (gone === 'conversation_left')
+                return say(lang, 'session.selfHeal.row.planReopenFailed.conversationLeft', { taskId: outcome.taskId });
+            if (gone === 'conversation_unconfirmed')
+                return say(lang, 'session.selfHeal.row.planReopenFailed.conversationUnconfirmed', { taskId: outcome.taskId });
             const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';
             const noView = outcome.noPresentationSurface === true ? msg('session.selfHeal.noCardView.afterColon') : '';
             return keepSessionWayOut !== null
@@ -1549,26 +1542,5 @@ export function activeRunBusyHeadlessRow(signal, copy, lang) {
     const override = copy?.headlessRowFor?.(signal);
     if (typeof override === 'string')
         return override;
-    const activeTaskId = signal.activeTaskId;
-    const handle = activeTaskId ? msg('session.selfHeal.handle.run', { taskId: activeTaskId }) : '';
-    const endRun = endRunClause(copy, activeTaskId, lang);
-    const status = signal.activeTaskStatus;
-    const decidePath = signal.pendingGate?.decidePath ?? null;
-    const hostFresh = copy?.freshSession ?? undefined;
-    const freshSession = hostFresh ?? say(lang, 'session.selfHeal.freshSession.default');
-    if (decidePath) {
-        return say(lang, 'session.selfHeal.headless.decide', {
-            handle,
-            status: status ? msg('session.selfHeal.headless.status', { status }) : '',
-            gate: gateKindPhrase(signal.pendingGate?.kind, lang),
-            decidePath,
-            endRun,
-            freshSession,
-            governance: governanceOriginClause(signal, lang),
-        });
-    }
-    if (status)
-        return say(lang, 'session.selfHeal.headless.statusOnly', { handle, status, endRun, freshSession });
-    const startOver = hostFresh !== undefined ? `${hostFresh.charAt(0).toUpperCase()}${hostFresh.slice(1)}` : say(lang, 'session.selfHeal.freshSession.defaultCapitalized');
-    return say(lang, 'session.selfHeal.headless.neverReleased', { handle, startOver, endRun });
+    return sessionBusyRowOf(signal, 'scripted', copy, lang);
 }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -298,6 +298,8 @@ function projectEvent(ev, ctx) {
             const sleptMs = sleptMsRaw !== undefined && sleptMsRaw >= 0 ? sleptMsRaw : undefined;
             const waitSegment = readFrameStringKey(ev, 'waitSegment');
             const seat = readFrameStringKey(ev, 'seat');
+            const providerMessage = readFrameStringKey(ev, 'providerMessage');
+            const judgedToolCallId = readFrameStringKey(ev, 'toolCallId');
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -316,6 +318,8 @@ function projectEvent(ev, ctx) {
                 ...(sleptMs !== undefined ? { sleptMs } : {}),
                 ...(waitSegment !== undefined ? { waitSegment } : {}),
                 ...(seat !== undefined ? { seat } : {}),
+                ...(providerMessage !== undefined ? { providerMessage } : {}),
+                ...(judgedToolCallId !== undefined ? { toolCallId: judgedToolCallId } : {}),
                 ...(typeof ev.eventId === 'string' ? { eventId: ev.eventId } : {}),
                 ...(typeof ev.parentToolCallId === 'string' ? { parentToolCallId: ev.parentToolCallId } : {}),
             })));

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

@@ -91,6 +91,14 @@ export declare function readRunCostFacts(stats: TaskStats | undefined, observed?
     readonly usageMissingObserved?: boolean;
 }): RunCostFacts | undefined;
 export declare function runCostSettlementOf(stats: TaskStats | undefined): Exclude<RunCostSettlement, 'awaiting'>;
+export type ResultIntake = {
+    readonly committed: true;
+    readonly sessionId: string;
+    readonly entryId: string;
+} | {
+    readonly committed: false;
+};
+export declare function resultIntakeOf(frame: object | null | undefined): ResultIntake | undefined;
 export interface ObservedTerminalParts extends PermissionDenialParts {
     readonly _sema_usage_lower_bound?: true;
 }

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,6 +1,6 @@
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
-import { guardedRead, putOwnKey, readFrameStringKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from '../../ownKey.js';
+import { guardedRead, putOwnKey, readFrameEntryIdList, readFrameStringKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalCodedDetail, runTerminalGateToolName, } from '../../runTerminal.js';
@@ -276,14 +276,42 @@ function structuredOutputParts(r) {
     const so = r.structuredOutput;
     return so !== undefined ? { structured_output: so } : {};
 }
+const _intakeCoversCore = true;
+const _intakeCoveredByCore = true;
+void _intakeCoversCore;
+void _intakeCoveredByCore;
+function intakeOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const committed = readOwnDataValue(v, 'committed');
+        if (committed === false)
+            return Object.freeze({ committed: false });
+        if (committed !== true)
+            return undefined;
+        const sessionId = readOwnDataNonEmptyString(v, 'sessionId');
+        const entryId = readOwnDataNonEmptyString(v, 'entryId');
+        return sessionId !== undefined && entryId !== undefined ? Object.freeze({ committed: true, sessionId, entryId }) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resultIntakeOf(frame) {
+    return intakeOf(guardedRead(() => readOwnDataValue(frame, '_sema_intake')));
+}
 function effectiveFactParts(rec) {
     const reasoning = readEffectiveReasoning(rec.effectiveReasoning);
     const scopes = readEffectiveMemoryScopes(rec.effectiveMemoryScopes);
     const responseModel = rec.responseModel;
+    const intake = intakeOf(guardedRead(() => readOwnDataValue(rec, 'intake')));
+    const turnAbortedBy = readFrameStringKey(rec, 'turnAbortedBy');
     return {
         ...(reasoning !== undefined ? { _sema_effective_reasoning: reasoning } : {}),
         ...(scopes !== undefined ? { _sema_effective_memory_scopes: scopes } : {}),
         ...(typeof responseModel === 'string' && responseModel.length > 0 ? { _sema_response_model: responseModel } : {}),
+        ...(intake !== undefined ? { _sema_intake: intake } : {}),
+        ...(turnAbortedBy !== undefined ? { _sema_turn_aborted_by: turnAbortedBy } : {}),
     };
 }
 function reemitEffectiveFacts(f) {
@@ -291,6 +319,8 @@ function reemitEffectiveFacts(f) {
         ...(f?._sema_effective_reasoning !== undefined ? { _sema_effective_reasoning: f._sema_effective_reasoning } : {}),
         ...(f?._sema_effective_memory_scopes !== undefined ? { _sema_effective_memory_scopes: f._sema_effective_memory_scopes } : {}),
         ...(f?._sema_response_model !== undefined ? { _sema_response_model: f._sema_response_model } : {}),
+        ...(f?._sema_intake !== undefined ? { _sema_intake: f._sema_intake } : {}),
+        ...(f?._sema_turn_aborted_by !== undefined ? { _sema_turn_aborted_by: f._sema_turn_aborted_by } : {}),
     };
     const _keySetPin = true;
     void _keySetPin;
@@ -597,6 +627,10 @@ const PRINT_ARM_UNKNOWN_READING = Object.freeze({ arm: PRINT_ARM_UNKNOWN_OUTCOME
 function selectedModelParts(model) {
     return typeof model === 'string' && model.length > 0 ? { _sema_selected_model: model } : {};
 }
+function resultEntryIdsParts(r) {
+    const ids = readFrameEntryIdList(r, 'resultEntryIds');
+    return ids !== undefined ? { _sema_result_entry_ids: ids } : {};
+}
 function salvagedTextOf(r) {
     const salvagedOutput = r.salvagedOutput;
     return typeof r.result === 'string' && r.result.trim().length > 0
@@ -831,6 +865,7 @@ function doneToSdkResultBody(ev, ctx, observed) {
         ...effectiveFactParts(rec),
         ...nestedUsageByTaskParts(stats, observed?.nestedUsageByTask),
         ...selectedModelParts(r.model),
+        ...resultEntryIdsParts(r),
     });
 }
 export function failedToSdkResult(ev, ctx, observed) {

package/dist/adapter/runStream.d.ts

@@ -2,23 +2,13 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import { type SDKMessage, type EmitContext, type ModelUsage } from './types.js';
 import { type EngineTurnUsage } from './downstream/turnUsageToModelUsage.js';
 import type { ObservedTerminalParts } from './downstream/terminalToSdkResult.js';
+import { type ActiveRunBusySignal, type ActiveRunPendingGate } from '../sessionOccupant.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;
-    readonly governanceForced?: true;
-    readonly checkpointId?: string;
-}
+export type { ActiveRunBusySignal, ActiveRunPendingGate };
 export declare function pendingGateIsProvablyDifferent(prev: ActiveRunPendingGate | null | undefined, next: ActiveRunPendingGate | null | undefined): boolean;
-export interface ActiveRunBusySignal {
-    readonly activeTaskId: string | null;
-    readonly activeTaskStatus: string | null;
-    readonly pendingGate: ActiveRunPendingGate | null;
-    readonly msSinceLastActivity?: number;
-}
 export declare function activeRunBusySignal(ev: unknown): ActiveRunBusySignal | null;
 export declare function isGovernanceStopRowText(text: string): boolean;
 export declare function isModelOutputErrorText(text: string): boolean;

package/dist/adapter/runStream.js

@@ -5,6 +5,7 @@ import { terminalPartsOfObserved, readRunCostFacts, terminalToSdkResult, TOOL_IN
 import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
 import { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { sessionBusyRowOf, sessionOccupantOf } from '../sessionOccupant.js';
 import { doneResultView, isReplayedTerminal, terminalLayerOf } from '../replayBody.js';
 import { carriesAnswerText, guardedRead, readFrameStringKey } from '../ownKey.js';
 import { ccErrorOfProviderStatus } from '../providerRejection.js';
@@ -16,7 +17,7 @@ import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
 import { displayUntrusted, washCredentials } from '../displayUntrusted.js';
 import { runBlockedText } from '../promptBlockedCopy.js';
-import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX, SESSION_BUSY_ROW_LEAD, legacyRowKindOfText, } from '../rowKind.js';
+import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX, legacyRowKindOfText, } from '../rowKind.js';
 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';
@@ -75,12 +76,15 @@ export function pendingGateIsProvablyDifferent(prev, next) {
     return a !== b;
 }
 export function activeRunBusySignal(ev) {
-    const read = busyReadOfFrame(ev);
+    const read = busyReadOfFrame(busyFrameSnapshotOf(ev));
     if (read === null || !read.cls.busy)
         return null;
-    const { carrier, cls } = read;
-    const status = carrier.activeTaskStatus;
-    const rawGate = carrier.pendingGate;
+    return busySignalOfRead(read);
+}
+function busySignalOfRead(read) {
+    const { cls } = read;
+    const status = read.status;
+    const rawGate = read.pendingGate;
     let pendingGate = null;
     if (typeof rawGate === 'object' && rawGate !== null) {
         const k = rawGate.kind;
@@ -94,14 +98,24 @@ export function activeRunBusySignal(ev) {
             ...(typeof cp === 'string' && cp.length > 0 ? { checkpointId: cp } : {}),
         };
     }
-    const msIdle = carrier.msSinceLastActivity;
+    const msIdle = read.msSinceLastActivity;
     return {
         activeTaskId: cls.handle,
         activeTaskStatus: typeof status === 'string' && status.length > 0 ? status : null,
         pendingGate,
+        occupancy: read.occupancy,
         ...(typeof msIdle === 'number' && Number.isFinite(msIdle) && msIdle >= 0 ? { msSinceLastActivity: msIdle } : {}),
     };
 }
+function busySignalForRow(read, cls) {
+    const bare = { activeTaskId: cls.handle, activeTaskStatus: null, pendingGate: null, occupancy: 'unreadable' };
+    try {
+        return read !== null ? busySignalOfRead(read) : bare;
+    }
+    catch {
+        return bare;
+    }
+}
 function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
     const carrier = activeRunBusyCarrierOf(ev);
     if (carrier === null)
@@ -111,7 +125,24 @@ function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
     const flatCode = typeof carrier.errorCode === 'string' ? carrier.errorCode : undefined;
     const activeTaskId = preReadActiveTaskId !== undefined ? preReadActiveTaskId.value : carrier.activeTaskId;
     const cls = classifyActiveRunBusy({ errorCode: (isDone ? runTerminalCode(terminal) : undefined) ?? flatCode, activeTaskId });
-    return { carrier, cls };
+    if (!cls.busy)
+        return { cls, occupancy: 'unreadable', status: undefined, pendingGate: undefined, msSinceLastActivity: undefined };
+    const status = ownDataBit(carrier, 'activeTaskStatus');
+    const stale = ownDataBit(carrier, 'stale');
+    return {
+        cls,
+        occupancy: sessionOccupantOf(activeTaskId === null || typeof activeTaskId === 'string' ? activeTaskId : undefined, typeof status === 'string' ? status : undefined, stale === true),
+        status,
+        pendingGate: ownDataBit(carrier, 'pendingGate'),
+        msSinceLastActivity: ownDataBit(carrier, 'msSinceLastActivity'),
+    };
+}
+function busyFrameSnapshotOf(ev) {
+    if (typeof ev !== 'object' || ev === null)
+        return ev;
+    if (ev.type !== 'done')
+        return ev;
+    return { type: 'done', result: ev.result };
 }
 export function isGovernanceStopRowText(text) {
     return legacyRowKindOfText(text) === 'governance_stop';
@@ -236,7 +267,8 @@ function terminalFactOf(ev, doneTerminal) {
     };
 }
 function terminalRowFacts(ev) {
-    const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
+    const result = ev.type === 'done' ? ev.result : undefined;
+    const doneTerminal = ev.type === 'done' ? readRunTerminal(result) : null;
     const errTextRaw = ev.type === 'failed'
         ? (ev.errorMessage ?? ev.errorCode ?? 'run failed')
         : doneTerminal?.kind === 'failed'
@@ -246,15 +278,15 @@ function terminalRowFacts(ev) {
                 : null;
     const errText = errTextRaw === '' ? null : errTextRaw;
     if (errText === null)
-        return { doneTerminal, errText, activeTaskId: undefined, busy: { busy: false, handle: null }, governance: false };
-    const activeTaskId = (ev.type === 'done' ? ev.result?.activeTaskId : undefined) ??
-        (ev.type === 'failed' ? ev.activeTaskId : undefined);
-    const busy = busyReadOfFrame(ev, doneTerminal, { value: activeTaskId })?.cls ?? { busy: false, handle: null };
+        return { doneTerminal, errText, activeTaskId: undefined, busy: { busy: false, handle: null }, busyRead: null, governance: false };
+    const activeTaskId = ev.type === 'done' ? result?.activeTaskId : ev.activeTaskId;
+    const busyRead = busyReadOfFrame(ev.type === 'done' ? { type: 'done', result } : ev, doneTerminal, { value: activeTaskId });
+    const busy = busyRead?.cls ?? { busy: false, handle: null };
     const governance = isGovernanceTerminal({
         status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
         errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
     });
-    return { doneTerminal, errText, activeTaskId, busy, governance };
+    return { doneTerminal, errText, activeTaskId, busy, busyRead, governance };
 }
 const PROVIDER_REJECTED_DETAIL = 'provider_rejected';
 function ownDataBit(o, k) {
@@ -812,14 +844,9 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const maxTokHint = /max_tokens/i.test(errText)
                     ? '\nyour provider caps max_tokens lower — lower it in /model (press m, or M to type a value)'
                     : '';
-                const busyHandle = busy.handle;
                 const arm = terminalRowArmOf(rowFacts);
                 const rowText = arm === 'busy'
-                    ? `${SESSION_BUSY_ROW_LEAD}${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
-                        `has not been released, so this message was NOT sent. Nothing releases it on its own — ` +
-                        (ctx.lane === 'print' || ctx.lane === 'utility'
-                            ? `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
-                            : `end ${busyHandle ? `run ${busyHandle}` : 'that run'} on the engine, or start a new session.`)
+                    ? sessionBusyRowOf(busySignalForRow(rowFacts.busyRead, busy), ctx.lane === 'print' || ctx.lane === 'utility' ? 'scripted' : 'interactive')
                     : arm === 'governance'
                         ?
                             `${isGovernanceStopRowText(errText) ? errText : `${RUN_STOPPED_MESSAGE_PREFIX}: ${errText}`}${maxTokHint}`

package/dist/agentSession/engineAgentRegistryRead.js

@@ -3,6 +3,7 @@ import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { engineCapNestedValue } from '../engineCapsCache.js';
 import { guardedRead, readOwnDataValue } from '../ownKey.js';
+import { ROUTE_NOT_FOUND } from '../engineErrorCodes.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -123,7 +124,7 @@ async function readOnce(client, sessionId, capsBaseUrl, opts) {
     }
     catch (e) {
         const { code, status } = errCodes(e);
-        if (status === 404 && code === 'not_found.route')
+        if (status === 404 && code === ROUTE_NOT_FOUND)
             return unavailable('route_absent');
         if (status === 501 && code === 'capability.session_ownership_required')
             return unavailable('ownership_required');

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -1,5 +1,5 @@
 import { engineCapNestedValue } from '../engineCapsCache.js';
-import { LIMIT_RATE_EXCEEDED, isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
+import { LIMIT_RATE_EXCEEDED, ROUTE_NOT_FOUND, isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
@@ -133,7 +133,7 @@ function refusedWhyOf(rawCode, status) {
             return 'ownership_required';
         if (code === 'not_found.session')
             return 'session_not_found';
-        if (code === 'not_found.route')
+        if (code === ROUTE_NOT_FOUND)
             return 'route_absent';
         if (code === LIMIT_RATE_EXCEEDED)
             return 'rate_limited';