@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/adapter/activeRunSelfHeal.js

@@ -1,6 +1,7 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage } from '../i18n/translate.js';
+import { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent } from '../hitl/askParkAutoReopenBlock.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
 import { readThrownStatusSlot } from '../wireFailureShape.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
@@ -8,6 +9,7 @@ import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
 import { resumeAttachReplayDisclosure, runningAttachOffered } from '../hitl/resumeRunningCard.js';
 import { isSdkRunParked, isSdkRunTerminal, SDK_RUN_LIVE_STATUSES } from '../terminalStatuses.js';
+import { awaitInterruptedRunSettle, interruptedRunSettleRow } from '../terminationIntent.js';
 import { SDK_APPROVAL_DECIDE_GATE_KINDS, SDK_PLAN_REVIEW_GATE_KINDS } from '../generated/sdkFactTables.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 const APPROVAL_LEG_GATE_KINDS = SDK_APPROVAL_DECIDE_GATE_KINDS;
@@ -60,6 +62,10 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'not-delivered';
         case 'running-steered':
             return 'handed-off';
+        case 'interrupted-settled':
+            return 'resending';
+        case 'interrupted-still-finishing':
+            return 'not-delivered';
         case 'running-attach':
             return 'not-delivered';
         default:
@@ -136,6 +142,8 @@ const REOPEN_VERDICT_KEYS = [
     'dismissedByUser',
     '_sema_noPresentationSurface',
     '_sema_errorCode',
+    '_sema_reopenRefusal',
+    '_sema_policyBlocked',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -238,6 +246,28 @@ function reopenErrorCodeOf(verdict) {
         return undefined;
     }
 }
+function reopenPolicyBlockedOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        const v = verdict._sema_policyBlocked;
+        return typeof v === 'string' && ASK_PARK_AUTO_REOPEN_BLOCKS.includes(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function reopenRefusalOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        const v = verdict._sema_reopenRefusal;
+        return typeof v === 'string' && PLAN_REVIEW_REOPEN_REFUSALS.includes(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function failureWireCode(e) {
     try {
         return effectiveWireErrorCode(e);
@@ -415,7 +445,58 @@ async function readOwnedPendingCount(read, deps) {
         recheckCtl.abort(new Error('owned-pending recheck settled'));
     }
 }
+async function interruptedShortCircuit(signal, runs, deps) {
+    try {
+        return await interruptedShortCircuitUnguarded(signal, runs, deps);
+    }
+    catch {
+        return null;
+    }
+}
+async function interruptedShortCircuitUnguarded(signal, runs, deps) {
+    const taskId = signal.activeTaskId;
+    if (typeof taskId !== 'string' || taskId === '')
+        return null;
+    const callerAborted = () => deps?.signal?.aborted === true;
+    if (callerAborted())
+        return null;
+    const port = deps?.wasRecentlyTerminatedByUs;
+    if (deps === undefined || typeof port !== 'function')
+        return null;
+    let ours = false;
+    try {
+        ours = port.call(deps, taskId) === true;
+    }
+    catch {
+        ours = false;
+    }
+    if (!ours)
+        return null;
+    const verbs = runs;
+    if (verbs === undefined || typeof verbs.get !== 'function')
+        return null;
+    const callerSignal = deps.signal;
+    const settleDeps = {
+        getRun: async (id, o) => {
+            const row = await verbs.get(id, { ...sessionOpts(deps), ...(o?.signal !== undefined ? { signal: o.signal } : {}) });
+            return row === null ? null : { status: readStatusGuarded(row) };
+        },
+        ...(callerSignal !== undefined ? { signal: callerSignal } : {}),
+        ...(deps.interruptedSettle ?? {}),
+    };
+    const verdict = await awaitInterruptedRunSettle(taskId, settleDeps);
+    if (callerAborted())
+        return null;
+    if (verdict.kind === 'settled')
+        return { kind: 'interrupted-settled', taskId, status: verdict.status };
+    if (verdict.kind === 'still-running')
+        return { kind: 'interrupted-still-finishing', taskId, waitedMs: verdict.waitedMs };
+    return null;
+}
 export async function attemptActiveRunSelfHeal(signal, runs, deps) {
+    const interrupted = await interruptedShortCircuit(signal, runs, deps);
+    if (interrupted !== null)
+        return interrupted;
     let pending = false;
     try {
         pending = deps?.hasPendingDecision?.() === true;
@@ -491,7 +572,8 @@ async function planVerdict(taskId, deps) {
 }
 async function askVerdict(taskId, deps) {
     try {
-        return snapshotReopenVerdict(await deps?.reopenAskPark?.(taskId));
+        const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
+        return snapshotReopenVerdict(await (trigger === undefined ? deps?.reopenAskPark?.(taskId) : deps?.reopenAskPark?.(taskId, { trigger })));
     }
     catch (e) {
         if (deps?.signal?.aborted === true)
@@ -507,6 +589,7 @@ async function planReviewArm(taskId, signal, deps) {
     const dismissed = reopenRefusedForUserDismissal(verdict);
     const noView = reopenRefusedForNoPresentationSurface(verdict);
     const errorCode = inFlight || dismissed || noView ? undefined : reopenErrorCodeOf(verdict);
+    const reopenRefusal = inFlight || dismissed || noView ? undefined : reopenRefusalOf(verdict);
     return {
         kind: 'plan-review-reopen-failed',
         taskId,
@@ -516,6 +599,7 @@ async function planReviewArm(taskId, signal, deps) {
         ...(dismissed ? { dismissedByUser: true } : {}),
         ...(noView ? { noPresentationSurface: true } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(reopenRefusal !== undefined ? { reopenRefusal } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -551,7 +635,8 @@ async function askParkArm(taskId, signal, runs, deps) {
         return staleParkArm(taskId, signal, runs, deps);
     }
     const noView = reopenRefusedForNoPresentationSurface(verdict);
-    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) ? undefined : reopenErrorCodeOf(verdict);
+    const policyBlocked = inFlight || noView ? undefined : reopenPolicyBlockedOf(verdict);
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
@@ -560,6 +645,7 @@ async function askParkArm(taskId, signal, runs, deps) {
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
         ...(noView ? { noPresentationSurface: true } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(policyBlocked !== undefined ? { policyBlocked } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -855,7 +941,7 @@ 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) {
+function endRunClause(copy, taskId, lang, face = 'headless') {
     let host;
     try {
         host = copy?.endRun;
@@ -866,6 +952,9 @@ function endRunClause(copy, taskId, lang) {
     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) {
@@ -937,6 +1026,9 @@ function injectedSubmissionRow(outcome, following = false, lang) {
     if ((outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.decisionInFlight === true) {
         return say(lang, 'session.selfHeal.injected.decisionInFlight', { lead, id });
     }
+    if (outcome.kind === 'ask-reopen-failed' && outcome.policyBlocked !== undefined) {
+        return askParkAutoReopenBlockedContent(outcome.policyBlocked, outcome.taskId, 'interactive', 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') });
     }
@@ -961,6 +1053,8 @@ function injectedSubmissionRow(outcome, following = false, lang) {
             ? say(lang, 'session.selfHeal.injected.unknownDeliveryFollowing', { unknown })
             : say(lang, 'session.selfHeal.injected.unknownDeliveryWatch', { unknown });
     }
+    if (outcome.kind === 'interrupted-still-finishing')
+        return say(lang, 'session.selfHeal.injected.interruptedFinishing', { lead, id });
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
             return say(lang, 'session.selfHeal.injected.heldForDecision', { lead, id });
@@ -1021,6 +1115,8 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
         case 'ask-reopen-failed': {
             if (outcome.decisionInFlight === true)
                 return decisionInFlightRow('ask', outcome.taskId, lang);
+            if (outcome.policyBlocked !== undefined)
+                return askParkAutoReopenBlockedContent(outcome.policyBlocked, outcome.taskId, 'interactive', lang);
             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
@@ -1125,15 +1221,21 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             return say(lang, 'session.selfHeal.row.cancelFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail, wayOut });
         case 'stale-park-wait':
             return outcome.alreadyOffered === true
-                ? say(lang, 'session.selfHeal.row.stale.wait.offered', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang) })
-                : say(lang, 'session.selfHeal.row.stale.wait.first', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang) });
+                ? say(lang, 'session.selfHeal.row.stale.wait.offered', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang, 'interactive') })
+                : say(lang, 'session.selfHeal.row.stale.wait.first', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang, 'interactive') });
         case 'running-not-found':
             return say(lang, 'session.selfHeal.row.runNotFound', { taskId: outcome.taskId, wayOut });
+        case 'interrupted-settled':
+            return interruptedRunSettleRow(outcome.taskId, { kind: 'settled', status: outcome.status }, lang) ?? '';
+        case 'interrupted-still-finishing': {
+            const waited = `${String(Math.max(1, Math.round(outcome.waitedMs / 1000)))}s`;
+            return say(lang, 'session.selfHeal.row.interrupted.stillFinishing', { taskId: outcome.taskId, waited });
+        }
         case 'running-settled':
             return say(lang, 'session.selfHeal.row.runSettled', { taskId: outcome.taskId, status: outcome.status, wayOut });
         case 'not-parked':
             if (outcome.alreadyOffered === true) {
-                return say(lang, 'session.selfHeal.row.notParked.offered', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang) });
+                return say(lang, 'session.selfHeal.row.notParked.offered', { taskId: outcome.taskId, status: outcome.status, wayOut, endRun: endRunClause(copy, outcome.taskId, lang, 'interactive') });
             }
             const parkedOn = outcome.pendingGateKind !== undefined
                 ? gateKindPhrase(outcome.pendingGateKind, lang)

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -1,11 +1,11 @@
-import { readFleetSegment, readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
+import { modRowsOf, readFleetSegment, readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
 import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
 import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js';
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, markMcpSectionDroppedNamedRows, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameTrueMark } from '../../ownKey.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataNonEmptyString } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -76,12 +76,27 @@ function isCompactionStartedFrame(ev) {
 function assertNeverArm(_ev) {
 }
 export function eventToSdkMessage(ev, ctx) {
-    return withEngineIdentity(projectEvent(ev, ctx), ev, ctx);
-}
-function withEngineIdentity(p, ev, ctx) {
+    const entry = sampleNotificationEntry(ev);
+    if (entry.dropped !== undefined)
+        return entry.dropped;
+    return withEngineIdentity(projectEvent(entry.frame, ctx), ev, ctx, entry.frame);
+}
+function sampleNotificationEntry(ev) {
+    const word = guardedRead(() => readOwnDataNonEmptyString(ev, 'type'));
+    if (word !== 'task_notification' && word !== 'workflow_complete')
+        return { frame: ev };
+    const sampled = ownSnapshotTyped(ev);
+    if (sampled === undefined)
+        return { dropped: dropped('malformed', word) };
+    return { frame: sampled };
+}
+function noticeSnapshotOf(ev) {
+    return ownSnapshotTyped(ev);
+}
+function withEngineIdentity(p, ev, ctx, identityFrame = ev) {
     if (p.kind !== 'message')
         return p;
-    const eventId = wireEventIdOf(ev);
+    const eventId = wireEventIdOf(identityFrame);
     if (eventId === undefined)
         return p;
     const env = p.message;
@@ -128,17 +143,20 @@ function projectEvent(ev, ctx) {
             })));
         }
         case 'workflow_complete': {
-            if (typeof ev.runId !== 'string' || ev.runId.length === 0) {
+            const wf = noticeSnapshotOf(ev);
+            if (wf === undefined)
+                return dropped('malformed', 'workflow_complete');
+            if (typeof wf.runId !== 'string' || wf.runId.length === 0) {
                 return dropped('malformed', 'workflow_complete');
             }
-            if (!isCoreWorkflowRunTerminal(ev.status)) {
+            if (!isCoreWorkflowRunTerminal(wf.status)) {
                 return dropped('malformed', 'workflow_complete');
             }
             return projected(stamp(ctx, armBody({
                 type: 'workflow_complete',
-                runId: ev.runId,
-                status: ev.status,
-                summary: typeof ev.summary === 'string' ? ev.summary : '',
+                runId: wf.runId,
+                status: wf.status,
+                summary: typeof wf.summary === 'string' ? wf.summary : '',
             })));
         }
         case 'text':
@@ -211,6 +229,7 @@ function projectEvent(ev, ctx) {
             const collateralAbort = ev._sema_collateral_abort;
             const denialKind = ccToolDenialKindForToolEnd(ev);
             const toolEndNotExecuted = readFrameTrueMark(ev, 'notExecuted');
+            const toolEndAnsweredBy = readFrameStringKey(ev, 'answeredBy');
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -233,6 +252,7 @@ function projectEvent(ev, ctx) {
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
                 ...(toolEndNotExecuted ? { notExecuted: true } : {}),
+                ...(toolEndAnsweredBy !== undefined ? { answeredBy: toolEndAnsweredBy } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }
@@ -313,8 +333,11 @@ function projectEvent(ev, ctx) {
             return projected(stamp(ctx, armBody({ type: 'wiring_manifest', ...body, ...identity })));
         }
         case 'task_notification': {
-            const nested = ev.notification;
-            const n = (nested ?? ev);
+            const notice = noticeSnapshotOf(ev);
+            if (notice === undefined)
+                return dropped('malformed', 'task_notification');
+            const nested = notice.notification;
+            const n = (nested ?? notice);
             if (typeof n.task_id !== 'string')
                 return dropped('malformed', 'task_notification');
             return projected(stamp(ctx, armBody({
@@ -660,72 +683,8 @@ function projectModsSection(holder) {
     try {
         if (!Object.hasOwn(holder, 'mods'))
             return undefined;
-        const raw = holder.mods;
-        if (!Array.isArray(raw))
-            return undefined;
-        const rows = [];
-        for (const r of raw) {
-            const row = modRowOf(r);
-            if (row !== undefined)
-                rows.push(row);
-        }
-        if (raw.length > 0 && rows.length === 0)
-            return undefined;
-        return rows;
-    }
-    catch {
-        return undefined;
-    }
-}
-function modRowOf(r) {
-    try {
-        if (typeof r !== 'object' || r === null || Array.isArray(r))
-            return undefined;
-        const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
-        const strList = (v) => (Array.isArray(v) && v.every((x) => typeof x === 'string') ? [...v] : undefined);
-        const o = r;
-        const name = str(o.name);
-        const seat = str(o.seat);
-        const tier = str(o.tier);
-        if (name === undefined || seat === undefined || tier === undefined)
-            return undefined;
-        const eventsRaw = o.events;
-        const observeRaw = o.observe;
-        const skippedRaw = o.skipped;
-        const refusedByRaw = o.refusedBy;
-        const reasonRaw = o.reason;
-        const hasMountedKey = eventsRaw !== undefined || observeRaw !== undefined || skippedRaw !== undefined;
-        const hasRefusedKey = refusedByRaw !== undefined || reasonRaw !== undefined;
-        if (hasMountedKey && hasRefusedKey)
-            return undefined;
-        if (hasRefusedKey) {
-            const refusedBy = str(refusedByRaw);
-            const reason = str(reasonRaw);
-            return refusedBy === undefined || reason === undefined ? undefined : { name, seat, tier, refusedBy, reason };
-        }
-        const events = strList(eventsRaw);
-        if (events === undefined)
-            return undefined;
-        const observe = observeRaw === undefined ? undefined : strList(observeRaw);
-        const skipped = Array.isArray(skippedRaw)
-            ? skippedRaw.flatMap((x) => {
-                if (typeof x !== 'object' || x === null || Array.isArray(x))
-                    return [];
-                const k = x;
-                const registration = str(k.registration);
-                const cause = str(k.cause);
-                const why = str(k.reason);
-                return registration === undefined || cause === undefined || why === undefined ? [] : [{ registration, cause, reason: why }];
-            })
-            : undefined;
-        return {
-            name,
-            seat,
-            tier,
-            events,
-            ...(observe !== undefined ? { observe } : {}),
-            ...(skipped !== undefined && skipped.length > 0 ? { skipped } : {}),
-        };
+        const rows = modRowsOf(holder.mods);
+        return rows === undefined ? undefined : rows.slice();
     }
     catch {
         return undefined;

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

@@ -1,8 +1,11 @@
 import type { AgentEvent, TaskStats } from '@sema-agent/sdk';
 import { type CcToolDenialKind, type GateDeniedByWord } from '../../gateVocabulary.js';
 import { type SDKMessage, type EmitContext } from '../types.js';
-import type { TerminalReason } from '@sema-agent/agent-types';
+import type { SDKPermissionDenial, SDKResultError, SDKResultSuccess, TerminalReason } from '@sema-agent/agent-types';
+import { type RunTerminalCodedDetail, type RunTerminalRead } from '../../runTerminal.js';
 import { type SemaModelUsage } from './turnUsageToModelUsage.js';
+import { type ResultLimitWord } from '../../engineErrorCodes.js';
+import { type ResultWayOutFacts } from '../../providerRejection.js';
 export interface SemaFlatUsage {
     readonly inputTokens: number;
     readonly outputTokens: number;
@@ -23,6 +26,9 @@ export interface TerminalStreamObserved {
     readonly streamSawRunOpen?: boolean;
     readonly deniedToolNameByCallId?: ReadonlyMap<string, string | undefined>;
     readonly deniedCallsOverflowed?: boolean;
+    readonly wayOutFacts?: ResultWayOutFacts | undefined;
+    readonly codedDetail?: RunTerminalCodedDetail | undefined;
+    readonly lastRow?: PrintResultLastRow | null;
 }
 export declare const TOOL_INPUT_JOIN_MAX_CALLS = 4096;
 export interface SemaPermissionDenial {
@@ -36,6 +42,22 @@ export interface SemaPermissionDenial {
     readonly _sema_denied_by_source?: 'tool_end';
     readonly toolDenialKind?: CcToolDenialKind;
 }
+export interface CcPermissionDenial {
+    readonly tool_name: string;
+    readonly tool_use_id: string;
+    readonly tool_input: SDKPermissionDenial['tool_input'];
+    readonly _sema_tool_arg?: string;
+    readonly _sema_tool_input_redacted?: true;
+    readonly deniedBy?: GateDeniedByWord;
+    readonly _sema_denied_by_source?: 'tool_end';
+    readonly toolDenialKind?: CcToolDenialKind;
+}
+export interface PermissionDenialParts {
+    readonly permission_denials: readonly CcPermissionDenial[];
+    readonly _sema_permission_denials?: readonly SemaPermissionDenial[];
+    readonly _sema_permission_denials_absent?: true;
+    readonly _sema_zero_output_denied?: true;
+}
 export interface SemaCostBreakdown {
     readonly llmRootMicroUsd?: number;
     readonly nestedSubagentMicroUsd?: number;
@@ -68,6 +90,10 @@ export interface RunCostFacts {
 export declare function readRunCostFacts(stats: TaskStats | undefined, observed?: {
     readonly usageMissingObserved?: boolean;
 }): RunCostFacts | undefined;
+export interface ObservedTerminalParts extends PermissionDenialParts {
+    readonly _sema_usage_lower_bound?: true;
+}
+export declare function terminalPartsOfObserved(observed: TerminalStreamObserved | undefined): ObservedTerminalParts;
 export interface SemaSubagentUsageRow {
     readonly turns: number;
     readonly inputTokens: number;
@@ -98,6 +124,39 @@ export interface SemaTerminalModelUsage extends SemaModelUsage {
     readonly _sema_cache_write_tokens_long?: number;
 }
 export declare function terminalReasonForResult(msg: SDKMessage): TerminalReason | undefined;
+export type { ResultLimitWord };
+export declare function resultLimitOf(frame: object | null | undefined): ResultLimitWord | undefined;
+export interface PrintResultLastRowBlock {
+    readonly type?: string;
+    readonly text?: string;
+}
+export interface PrintResultLastRowMessage {
+    readonly content?: string | readonly PrintResultLastRowBlock[];
+    readonly stop_reason?: string | null;
+}
+export interface PrintResultLastRow {
+    readonly type?: string;
+    readonly _sema_api_error_message?: boolean;
+    readonly message?: PrintResultLastRowMessage;
+    readonly salvagedText?: string;
+}
+export interface PrintResultArmInput {
+    readonly terminal: RunTerminalRead | null;
+    readonly lastRow?: PrintResultLastRow | null;
+}
+export interface PrintResultSuccessArm {
+    readonly subtype: SDKResultSuccess['subtype'];
+    readonly is_error: boolean;
+    readonly stop_reason: SDKResultSuccess['stop_reason'];
+}
+export interface PrintResultErrorArm {
+    readonly subtype: SDKResultError['subtype'];
+    readonly is_error: true;
+    readonly stop_reason: SDKResultError['stop_reason'];
+    readonly limit?: ResultLimitWord;
+}
+export type PrintResultArm = PrintResultSuccessArm | PrintResultErrorArm;
+export declare function printResultArmOf(input: PrintResultArmInput | null | undefined): PrintResultArm;
 export declare function doneToSdkResult(ev: Extract<AgentEvent, {
     type: 'done';
 }>, ctx: EmitContext, observed?: TerminalStreamObserved): SDKMessage;