@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/ownKey.d.ts

@@ -32,6 +32,11 @@ export interface HumanInputAttachmentView {
     kind?: string;
     outcome: string;
     label?: string;
+    declinedBy?: HumanInputAttachmentDeclinedByView;
+}
+export interface HumanInputAttachmentDeclinedByView {
+    kind: 'extension';
+    name: string;
 }
 export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | undefined;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;

package/dist/ownKey.js

@@ -175,7 +175,14 @@ export function humanInputAttachmentsOf(frame) {
                     return undefined;
                 const kind = readOwnDataNonEmptyString(r, 'kind');
                 const label = readOwnDataNonEmptyString(r, 'label');
-                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}) };
+                const declinedBy = guardedRead(() => {
+                    const d = readOwnDataValue(r, 'declinedBy');
+                    if (typeof d !== 'object' || d === null || Array.isArray(d))
+                        return undefined;
+                    const name = readOwnDataNonEmptyString(d, 'name');
+                    return readOwnDataValue(d, 'kind') === 'extension' && name !== undefined ? { kind: 'extension', name } : undefined;
+                });
+                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}), ...(declinedBy !== undefined ? { declinedBy } : {}) };
             });
             if (row !== undefined)
                 appendOwnElement(rows, row);

package/dist/peerFrames.d.ts

@@ -1,6 +1,7 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const AGENT_MESSAGE_TAG = "agent-message";
 export declare const CROSS_SESSION_MESSAGE_TAG = "cross-session-message";
-export declare const PEER_FRAME_LANES: readonly ["agent_message", "cross_session_message", "cross_session_notice"];
+export declare const PEER_FRAME_LANES: readonly ["agent_message", "cross_session_message", "cross_session_notice", "inbox_notice"];
 export declare const CROSS_SESSION_NOTICE_KINDS: readonly ["delivery_notice", "idle_notice"];
 export type CrossSessionNoticeKind = (typeof CROSS_SESSION_NOTICE_KINDS)[number];
 export declare const PEER_MODE_CLASSES: readonly ["bypass", "prompting"];
@@ -22,13 +23,50 @@ export type CrossSessionMessageFrame = {
     fromScope?: string;
     seq?: number;
 };
+export type PeerNoticeFacts = {
+    state: string;
+    recipient?: string;
+    target?: string;
+    detail?: string;
+    dropReason?: string;
+    refSeq?: number;
+    finishedAt?: number;
+};
 export type CrossSessionNoticeFrame = {
     lane: 'cross_session_notice';
     kind: CrossSessionNoticeKind;
     text: string;
+    notice?: PeerNoticeFacts;
+};
+export type InboxNoticeFrame = {
+    lane: 'inbox_notice';
+    pending: number;
+    delivered: number;
+    urgent?: number;
+    resupplied?: number;
 };
-export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame;
+export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame | InboxNoticeFrame;
 export declare function classifyPeerNotification(raw: Record<string, unknown>): PeerFrameProjection | null;
+export type SessionBoxNoticeFacts = {
+    noticeKind: 'inbox';
+    pending: number;
+    delivered: number;
+    urgent?: number;
+    resupplied?: number;
+} | {
+    noticeKind: 'delivery' | 'idle';
+    state: string;
+    peerLabel?: string;
+    detail?: string;
+    dropReason?: string;
+    refSeq?: number;
+    finishedAt?: number;
+};
+export type SessionBoxNoticeBody = SessionBoxNoticeFacts & {
+    text: string;
+};
+export declare function sessionBoxNoticeSentence(facts: SessionBoxNoticeFacts, lang?: UiLanguage): string | undefined;
+export declare function sessionBoxNoticeOf(p: PeerFrameProjection): SessionBoxNoticeBody | undefined;
 export declare function renderPeerFrameTranscriptText(p: PeerFrameProjection): string;
 export declare function parsePeerFrameText(text: string): AgentMessageFrame | CrossSessionMessageFrame | null;
 export declare function peerFrameDisplayName(p: AgentMessageFrame | CrossSessionMessageFrame): string;

package/dist/peerFrames.js

@@ -1,4 +1,5 @@
-import { applyDisplayFace, PEER_NAME_FACE } from './displayUntrusted.js';
+import { applyDisplayFace, displayUntrusted, PEER_NAME_FACE } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownSnapshotRecord } from './ownKey.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS, CORE_PERMISSION_MODE_CLASSES } from './generated/engineFactTables.js';
 const WIRE_KEY_FROM = 'from';
@@ -12,6 +13,20 @@ const WIRE_KEY_AGENT_TYPE = 'agentType';
 const WIRE_KEY_AGENT_MESSAGE = 'agentMessage';
 const WIRE_KEY_CROSS_SESSION_MESSAGE = 'crossSessionMessage';
 const WIRE_KEY_CROSS_SESSION_NOTICE = 'crossSessionNotice';
+const WIRE_KEY_INBOX_NOTICE = 'inboxNotice';
+const WIRE_KEY_PENDING = 'pending';
+const WIRE_KEY_DELIVERED = 'delivered';
+const WIRE_KEY_URGENT = 'urgent';
+const WIRE_KEY_RESUPPLIED = 'resupplied';
+const WIRE_KEY_PEER_META = 'peerMeta';
+const WIRE_KEY_NOTICE = 'notice';
+const WIRE_KEY_STATE = 'state';
+const WIRE_KEY_REF_SEQ = 'refSeq';
+const WIRE_KEY_RECIPIENT = 'recipient';
+const WIRE_KEY_TARGET = 'target';
+const WIRE_KEY_DETAIL = 'detail';
+const WIRE_KEY_DROP_REASON = 'dropReason';
+const WIRE_KEY_FINISHED_AT = 'finishedAt';
 const WIRE_KEY_PROVENANCE = '_sema_provenance';
 const WIRE_KEY_FROM_SESSION = 'fromSession';
 const WIRE_KEY_FROM_NAME = 'fromName';
@@ -20,7 +35,7 @@ const WIRE_KEY_FROM_SCOPE = 'fromScope';
 const FROM_ATTR = WIRE_KEY_FROM;
 export const AGENT_MESSAGE_TAG = 'agent-message';
 export const CROSS_SESSION_MESSAGE_TAG = 'cross-session-message';
-export const PEER_FRAME_LANES = Object.freeze(['agent_message', 'cross_session_message', 'cross_session_notice']);
+export const PEER_FRAME_LANES = Object.freeze(['agent_message', 'cross_session_message', 'cross_session_notice', 'inbox_notice']);
 export const CROSS_SESSION_NOTICE_KINDS = Object.freeze(['delivery_notice', 'idle_notice']);
 export const PEER_MODE_CLASSES = CORE_PERMISSION_MODE_CLASSES;
 function dataProp(o, key) {
@@ -43,6 +58,40 @@ function nonEmptyString(v) {
 function finiteNumber(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
+function countOf(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined;
+}
+function shownLabel(v, max) {
+    if (typeof v !== 'string')
+        return undefined;
+    const s = displayUntrusted(v, { blanks: true, max });
+    return s.length > 0 ? s : undefined;
+}
+const NOTICE_LABEL_MAX = 64;
+const NOTICE_TEXT_MAX = 200;
+function peerNoticeOf(n) {
+    const notice = dataProp(dataProp(dataProp(n, WIRE_KEY_PROVENANCE), WIRE_KEY_PEER_META), WIRE_KEY_NOTICE);
+    if (notice === null || typeof notice !== 'object')
+        return undefined;
+    const state = nonEmptyString(dataProp(notice, WIRE_KEY_STATE));
+    if (state === undefined)
+        return undefined;
+    const recipient = shownLabel(dataProp(notice, WIRE_KEY_RECIPIENT), NOTICE_LABEL_MAX);
+    const target = shownLabel(dataProp(notice, WIRE_KEY_TARGET), NOTICE_LABEL_MAX);
+    const detail = shownLabel(dataProp(notice, WIRE_KEY_DETAIL), NOTICE_TEXT_MAX);
+    const dropReason = shownLabel(dataProp(notice, WIRE_KEY_DROP_REASON), NOTICE_TEXT_MAX);
+    const refSeq = countOf(dataProp(notice, WIRE_KEY_REF_SEQ));
+    const finishedAt = countOf(dataProp(notice, WIRE_KEY_FINISHED_AT));
+    return {
+        state,
+        ...(recipient !== undefined ? { recipient } : {}),
+        ...(target !== undefined ? { target } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+        ...(dropReason !== undefined ? { dropReason } : {}),
+        ...(refSeq !== undefined ? { refSeq } : {}),
+        ...(finishedAt !== undefined ? { finishedAt } : {}),
+    };
+}
 function provenanceAgrees(n, lane, carrierFromRaw) {
     const prov = dataProp(n, WIRE_KEY_PROVENANCE);
     if (prov === null || typeof prov !== 'object')
@@ -112,7 +161,24 @@ export function classifyPeerNotification(raw) {
         const text = nonEmptyString(dataProp(crossSessionNotice, WIRE_KEY_TEXT));
         if (kind === undefined || text === undefined || !provenanceAgrees(n, 'cross_session_notice'))
             return null;
-        return { lane: 'cross_session_notice', kind, text };
+        const notice = peerNoticeOf(n);
+        return { lane: 'cross_session_notice', kind, text, ...(notice !== undefined ? { notice } : {}) };
+    }
+    const inboxNotice = dataProp(n, WIRE_KEY_INBOX_NOTICE);
+    if (inboxNotice !== undefined) {
+        const pending = countOf(dataProp(inboxNotice, WIRE_KEY_PENDING));
+        const delivered = countOf(dataProp(inboxNotice, WIRE_KEY_DELIVERED));
+        if (pending === undefined || delivered === undefined || !provenanceAgrees(n, 'inbox_notice'))
+            return null;
+        const urgent = countOf(dataProp(inboxNotice, WIRE_KEY_URGENT));
+        const resupplied = countOf(dataProp(inboxNotice, WIRE_KEY_RESUPPLIED));
+        return {
+            lane: 'inbox_notice',
+            pending,
+            delivered,
+            ...(urgent !== undefined ? { urgent } : {}),
+            ...(resupplied !== undefined ? { resupplied } : {}),
+        };
     }
     return null;
 }
@@ -140,9 +206,98 @@ function attr(v) {
 function unattr(v) {
     return v.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
 }
+const DELIVERY_SENTENCE_KEYS = Object.freeze({
+    delivered: 'notice.sessionBox.delivery.delivered',
+    held: 'notice.sessionBox.delivery.held',
+    held_by_policy: 'notice.sessionBox.delivery.heldByPolicy',
+    denied: 'notice.sessionBox.delivery.denied',
+    refused: 'notice.sessionBox.delivery.refused',
+    expired: 'notice.sessionBox.delivery.expired',
+});
+const IDLE_SENTENCE_KEYS = Object.freeze({
+    exited: 'notice.sessionBox.idle.exited',
+    unavailable: 'notice.sessionBox.idle.unavailable',
+    expired: 'notice.sessionBox.idle.expired',
+});
+function sentenceKeyOf(table, word) {
+    return Object.hasOwn(table, word) ? table[word] : undefined;
+}
+function joinParts(parts, lang) {
+    return parts.join(lang === 'zh' ? '' : ' ');
+}
+function inboxLine(pending, urgent, resupplied, lang) {
+    const parts = [renderMessage(pending === 1 ? msg('notice.sessionBox.inbox.one') : msg('notice.sessionBox.inbox.many', { pending }), lang)];
+    if (urgent !== undefined)
+        parts.push(renderMessage(msg('notice.sessionBox.inbox.urgent', { urgent }), lang));
+    if (resupplied !== undefined)
+        parts.push(renderMessage(msg('notice.sessionBox.inbox.resupplied', { resupplied }), lang));
+    return joinParts(parts, lang);
+}
+export function sessionBoxNoticeSentence(facts, lang) {
+    try {
+        const noticeKind = dataProp(facts, 'noticeKind');
+        if (noticeKind === 'inbox') {
+            const pending = countOf(dataProp(facts, WIRE_KEY_PENDING));
+            if (pending === undefined)
+                return undefined;
+            return inboxLine(pending, countOf(dataProp(facts, WIRE_KEY_URGENT)), countOf(dataProp(facts, WIRE_KEY_RESUPPLIED)), lang);
+        }
+        if (noticeKind !== 'delivery' && noticeKind !== 'idle')
+            return undefined;
+        const state = nonEmptyString(dataProp(facts, WIRE_KEY_STATE));
+        if (state === undefined)
+            return undefined;
+        const label = shownLabel(dataProp(facts, 'peerLabel'), NOTICE_LABEL_MAX);
+        const detail = shownLabel(dataProp(facts, WIRE_KEY_DETAIL), NOTICE_TEXT_MAX);
+        const dropReason = shownLabel(dataProp(facts, WIRE_KEY_DROP_REASON), NOTICE_TEXT_MAX);
+        if (noticeKind === 'delivery') {
+            const peer = label ?? renderMessage(msg('notice.sessionBox.peer.another'), lang);
+            if (state === 'dropped')
+                return renderMessage(dropReason !== undefined ? msg('notice.sessionBox.delivery.dropped', { peer, reason: dropReason }) : msg('notice.sessionBox.delivery.droppedPlain', { peer }), lang);
+            return renderMessage(msg(sentenceKeyOf(DELIVERY_SENTENCE_KEYS, state) ?? 'notice.sessionBox.delivery.other', { peer }), lang);
+        }
+        const peer = label ?? renderMessage(msg('notice.sessionBox.peer.anotherStart'), lang);
+        if (state === 'idle')
+            return renderMessage(detail !== undefined ? msg('notice.sessionBox.idle.finishedDetail', { peer, detail }) : msg('notice.sessionBox.idle.finished', { peer }), lang);
+        return renderMessage(msg(sentenceKeyOf(IDLE_SENTENCE_KEYS, state) ?? 'notice.sessionBox.idle.other', { peer }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sessionBoxNoticeOf(p) {
+    if (p.lane === 'inbox_notice') {
+        const facts = {
+            noticeKind: 'inbox',
+            pending: p.pending,
+            delivered: p.delivered,
+            ...(p.urgent !== undefined ? { urgent: p.urgent } : {}),
+            ...(p.resupplied !== undefined ? { resupplied: p.resupplied } : {}),
+        };
+        const text = sessionBoxNoticeSentence(facts);
+        return text === undefined ? undefined : { ...facts, text };
+    }
+    if (p.lane !== 'cross_session_notice' || p.notice === undefined)
+        return undefined;
+    const delivery = p.kind === 'delivery_notice';
+    const peerLabel = delivery ? (p.notice.recipient ?? p.notice.target) : (p.notice.target ?? p.notice.recipient);
+    const facts = {
+        noticeKind: delivery ? 'delivery' : 'idle',
+        state: p.notice.state,
+        ...(peerLabel !== undefined ? { peerLabel } : {}),
+        ...(p.notice.detail !== undefined ? { detail: p.notice.detail } : {}),
+        ...(p.notice.dropReason !== undefined ? { dropReason: p.notice.dropReason } : {}),
+        ...(p.notice.refSeq !== undefined ? { refSeq: p.notice.refSeq } : {}),
+        ...(p.notice.finishedAt !== undefined ? { finishedAt: p.notice.finishedAt } : {}),
+    };
+    const text = sessionBoxNoticeSentence(facts);
+    return text === undefined ? undefined : { ...facts, text };
+}
 export function renderPeerFrameTranscriptText(p) {
     if (p.lane === 'cross_session_notice')
         return escapeEnvelopeTag(CROSS_SESSION_MESSAGE_TAG, escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.text)));
+    if (p.lane === 'inbox_notice')
+        return inboxLine(p.pending, p.urgent, p.resupplied, undefined);
     if (p.lane === 'agent_message') {
         const body = escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.body));
         return `<${AGENT_MESSAGE_TAG} ${FROM_ATTR}="${attr(p.from)}">\n${body}\n</${AGENT_MESSAGE_TAG}>`;

package/dist/pluginHooksWire.d.ts

@@ -12,7 +12,7 @@ export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event",
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
-export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored"];
+export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored", "workspace_untrusted", "governance_unreadable", "policy_disable_all"];
 export type SettingsHookDropReason = (typeof SETTINGS_HOOK_DROP_REASONS)[number];
 export type HookSettingsSource = 'policySettings' | 'userSettings' | 'projectSettings' | 'localSettings' | 'flagSettings';
 export interface PluginHookKey {
@@ -196,6 +196,7 @@ export interface SettingsHooksLocalGroup<T> {
 export declare function settingsHooksKeptLocally<T>(plan: HooksWirePlan, event: string, group: SettingsHooksLocalGroup<T>, opts?: {
     readonly engineCompaction?: 'performed' | 'not_performed';
 }): readonly T[];
+export declare function pluginHooksKeptLocally<T>(plan: HooksWirePlan, pluginId: string, event: string, groupIndex: number, hooks: readonly T[]): readonly T[];
 export declare function pluginHookReasonText(reason: PluginHookReason): string;
 export declare function settingsHookDropText(reason: SettingsHookDropReason): string;
 export declare function pluginHookExecutorLabel(v: PluginHookVerdict): string;

package/dist/pluginHooksWire.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { appendOwnElement, readOwnDataValue } from './ownKey.js';
+import { inSlotReadOf } from './wireFailureShape.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
 import { HOOK_SETTINGS_SOURCE_TEXT, hooksEntryUnreadKeys, hooksGroupAuthoredSource, hooksGroupUnreadKeys, hooksKeyCoordinateText, hooksSalvageMaskOf, salvageSettingsHooksEntries, } from './settingsHooksSalvage.js';
@@ -40,7 +41,15 @@ export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'managed_plugins_only',
     'prompt_not_user_authored',
 ];
-export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported', 'key_not_read', 'source_not_authored'];
+export const SETTINGS_HOOK_DROP_REASONS = [
+    'exec_form_unsupported',
+    'mcp_tool_unsupported',
+    'key_not_read',
+    'source_not_authored',
+    'workspace_untrusted',
+    'governance_unreadable',
+    'policy_disable_all',
+];
 export function hooksWirePlanShapeOf(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -729,6 +738,8 @@ function skipMatcherKey(matcher) {
     return matcher === undefined || matcher === null || matcher === '' || matcher === '*' ? 'null' : JSON.stringify(matcher);
 }
 export function settingsHooksKeptLocally(plan, event, group, opts) {
+    if (planClosedLocally(plan))
+        return [];
     let raw;
     try {
         raw = group?.hooks;
@@ -802,6 +813,42 @@ export function settingsHooksKeptLocally(plan, event, group, opts) {
         return hooks;
     }
 }
+function planClosedLocally(plan) {
+    if (typeof plan !== 'object' || plan === null)
+        return false;
+    let slot;
+    try {
+        slot = inSlotReadOf(plan, 'closedBy');
+    }
+    catch {
+        return true;
+    }
+    if (slot.state === 'absent')
+        return false;
+    if (slot.state !== 'present')
+        return true;
+    return slot.value !== null && slot.value !== undefined;
+}
+export function pluginHooksKeptLocally(plan, pluginId, event, groupIndex, hooks) {
+    if (planClosedLocally(plan))
+        return [];
+    if (!Array.isArray(hooks))
+        return hooks;
+    try {
+        let kept = null;
+        hooks.forEach((h, i) => {
+            const engineRuns = pluginHookVerdictOf(plan, pluginId, event, groupIndex, i)?.disposition === 'engine';
+            if (engineRuns)
+                kept ??= hooks.slice(0, i);
+            else if (kept !== null)
+                appendOwnElement(kept, h);
+        });
+        return kept ?? hooks;
+    }
+    catch {
+        return hooks;
+    }
+}
 function settingsRowBaseOf(v) {
     if (!isRecord(v))
         return undefined;
@@ -881,6 +928,9 @@ const DROP_TEXT = {
     mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
     key_not_read: REASON_TEXT.key_not_read,
     source_not_authored: REASON_TEXT.source_not_authored,
+    workspace_untrusted: renderMessage(msg('config.hooks.plan.reason.closedUntrusted')),
+    governance_unreadable: renderMessage(msg('config.hooks.plan.reason.closedGovernanceUnreadable')),
+    policy_disable_all: renderMessage(msg('config.hooks.plan.reason.closedDisableAll')),
 };
 const SOURCE_TEXT = HOOK_SETTINGS_SOURCE_TEXT;
 export function pluginHookReasonText(reason) {
@@ -958,6 +1008,9 @@ function namedPathsOfRow(d) {
             return typeof d.event === 'string' && Number.isInteger(d.groupIndex) && d.groupIndex >= 0 ? [['hooks', d.event, d.groupIndex, 'source']] : [];
         case 'exec_form_unsupported':
         case 'mcp_tool_unsupported':
+        case 'workspace_untrusted':
+        case 'governance_unreadable':
+        case 'policy_disable_all':
             return [];
     }
 }
@@ -1009,6 +1062,8 @@ export function hooksNotRunNotice(plan) {
     for (const d of plan.settingsDropped) {
         if (!d.notRun)
             continue;
+        if (d.reason === 'workspace_untrusted' || d.reason === 'policy_disable_all')
+            continue;
         const named = d.reason === 'key_not_read' || d.reason === 'source_not_authored' ? namedPathsOfRow(d) : [];
         if (named.length > 0 && (d.reason === 'key_not_read' || d.reason === 'source_not_authored')) {
             const nk = `${d.source}\u0000${d.reason}`;

package/dist/replayBody.js

@@ -62,8 +62,16 @@ export function runRowSentenceOf(carrier) {
         return undefined;
     }
 }
+function isPlainObjectLike(v) {
+    try {
+        return typeof v === 'object' && v !== null && !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
 export function doneResultView(result) {
-    if (typeof result !== 'object' || result === null || Array.isArray(result))
+    if (!isPlainObjectLike(result))
         return { replay: false, receipt: false, body: result };
     const replay = guarded(result, 'replay') === true;
     const engine = engineResultLayerOf(result);
@@ -80,7 +88,7 @@ export function doneResultView(result) {
     return { replay, receipt: true, body: Object.freeze(view) };
 }
 export function isReplayedTerminal(frame) {
-    if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+    if (!isPlainObjectLike(frame))
         return false;
     if (guarded(frame, 'type') !== 'done')
         return false;

package/dist/request/taskRequest.d.ts

@@ -179,5 +179,10 @@ export interface LiveDefaultsInput {
     mockScenarioKeys?: ReadonlySet<string>;
 }
 export declare function applyLiveRequestDefaults(req: TaskRequestLike, host: LiveDefaultsInput): TaskRequestLike;
+export interface LiveRequestDefaultsResult {
+    readonly request: TaskRequestLike;
+    readonly notices: readonly HostSettingNotice[];
+}
+export declare function applyLiveRequestDefaultsWithNotices(req: TaskRequestLike, host: LiveDefaultsInput): LiveRequestDefaultsResult;
 export type BuiltTaskRequest = TaskRequest;
 export declare function unregisteredRequestKeys(req: TaskRequestLike, lane: RequestLane): string[];