@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/pluginHooksWire.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
+import { HOOK_SETTINGS_SOURCE_TEXT, hooksSalvageMaskOf, salvageSettingsHooksEntries, } from './settingsHooksSalvage.js';
 export const ENGINE_FIRED_HOOK_EVENTS = SETTINGS_ENGINE_OWNED_HOOK_EVENTS;
 export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
 export const PLUGIN_HOOK_REASONS = [
@@ -22,6 +23,9 @@ export const PLUGIN_HOOK_REASONS = [
     'engine_llm_limit',
     'engine_unconfirmed',
     'engine_elsewhere',
+    'hooks_module',
+    'scope_unsupported',
+    'source_incomplete',
 ];
 export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'workspace_untrusted',
@@ -32,6 +36,43 @@ export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'prompt_not_user_authored',
 ];
 export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported'];
+export function hooksWirePlanShapeOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return 'not';
+        const o = v;
+        for (const k of PLAN_KEYS)
+            if (!Object.hasOwn(o, k) && !LATER_PLAN_KEYS.has(k))
+                return 'not';
+        const reader = o.pluginReader;
+        const engineFacts = o.engine;
+        const wire = o.wire;
+        const arrayOrAbsent = (k) => !Object.hasOwn(o, k) || Array.isArray(o[k]);
+        return Array.isArray(o.verdicts) &&
+            Array.isArray(o.excluded) &&
+            Array.isArray(o.settingsDropped) &&
+            arrayOrAbsent('settingsVerdicts') &&
+            arrayOrAbsent('settingsExcluded') &&
+            arrayOrAbsent('settingsSalvage') &&
+            arrayOrAbsent('moduleVerdicts') &&
+            arrayOrAbsent('sessionVerdicts') &&
+            (!Object.hasOwn(o, 'sessionReader') || o.sessionReader === 'present' || o.sessionReader === 'absent' || o.sessionReader === 'failed') &&
+            (!Object.hasOwn(o, 'closedBy') || o.closedBy === null || o.closedBy === 'workspace_untrusted' || o.closedBy === 'governance_unreadable' || o.closedBy === 'policy_disable_all') &&
+            (reader === 'present' || reader === 'absent' || reader === 'failed') &&
+            typeof engineFacts === 'object' &&
+            engineFacts !== null &&
+            (wire === undefined || (typeof wire === 'object' && wire !== null && !Array.isArray(wire)))
+            ? 'plan'
+            : 'not';
+    }
+    catch {
+        return 'threw';
+    }
+}
+const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy', 'wire'];
+const LATER_PLAN_KEYS = new Set(['settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy']);
+const _planKeysPin = [true, true];
+void _planKeysPin;
 export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192, maxLlmEntriesPerEvent: 4 };
 const ENGINE_HOOK_TYPE_RUNS = new Set(['command', 'http', 'prompt', 'agent']);
 const COMPACTION_EVENTS = new Set(['PreCompact', 'PostCompact']);
@@ -39,6 +80,8 @@ const judged = (disposition, reason) => ({ kind: 'judged', disposition, reason }
 function hookExecutorOf(x) {
     if (x.event === 'UserPromptSubmit' && !x.promptAuthoredByUser)
         return { kind: 'excluded', reason: 'prompt_not_user_authored' };
+    if (x.source === 'session')
+        return judged(x.shellRuns ? 'shell' : 'not_run', 'scope_unsupported');
     if (x.source === 'settings') {
         const why = x.powershell
             ? { reason: 'engine_type_skipped', certain: true }
@@ -172,15 +215,25 @@ export function occupancyOf(wire) {
 export function decidePluginHooks(input) {
     const verdicts = [];
     const excluded = [];
+    const modules = [];
     const candidates = new Map();
     let unreadable = 0;
     const fallback = (event, type, reason) => input.shellRuns(event, typeof type === 'string' ? type : undefined) ? { disposition: 'shell', reason } : { disposition: 'not_run', reason };
     input.plugins.forEach((p, pluginIndex) => {
-        if (!isRecord(p) || !isRecord(p.hooks)) {
+        if (!isRecord(p)) {
+            unreadable++;
+            return;
+        }
+        if (p.hooksModule === true && input.exclusion === undefined && !(input.managedOnly && p.managed !== true)) {
+            modules.push({ pluginId: typeof p.id === 'string' ? p.id : '', pluginName: typeof p.name === 'string' ? p.name : '', disposition: 'not_run', reason: 'hooks_module' });
+        }
+        if (!isRecord(p.hooks)) {
             unreadable++;
             return;
         }
         const src = p;
+        const sv = salvageSettingsHooksEntries({ hooks: p.hooks });
+        const pieceMask = hooksSalvageMaskOf(sv.outcome === 'loaded-partial' ? sv.dropped : []);
         const sourceOk = nonEmptyString(p.id) && nonEmptyString(p.name) && nonEmptyString(p.root) && nonEmptyString(p.dataDir);
         const pluginId = typeof p.id === 'string' ? p.id : '';
         const pluginName = typeof p.name === 'string' ? p.name : '';
@@ -207,7 +260,15 @@ export function decidePluginHooks(input) {
                         return;
                     }
                     const entryType = isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined;
-                    const shape = sourceOk ? classifyEntry(entry, src.options) : { kind: 'malformed' };
+                    if (!sourceOk) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'source_incomplete' });
+                        return;
+                    }
+                    if (!pieceMask.eventDropped(event) && pieceMask.entryDropped(event, groupIndex, hookIndex)) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        return;
+                    }
+                    const shape = classifyEntry(entry, src.options);
                     if (shape.kind === 'malformed') {
                         verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
                         return;
@@ -299,7 +360,79 @@ export function decidePluginHooks(input) {
         }
         projected.set(event, groupsOut);
     }
-    return { verdicts, excluded, projected, unreadable };
+    const suppressed = input.suppressedLocally;
+    if (suppressed !== undefined && suppressed.size > 0) {
+        for (const v of verdicts) {
+            if (v.disposition !== 'shell' || !suppressed.has(v.pluginId))
+                continue;
+            v.disposition = 'not_run';
+            if (!ENGINE_EVENTS.has(v.event))
+                v.reason = 'no_executor';
+        }
+    }
+    return { verdicts, excluded, modules, projected, unreadable };
+}
+const SESSION_HOOK_ORIGINS = new Set(['skill', 'agent', 'sdk_host']);
+const LOCAL_REGISTRATION_TYPES = new Set(['callback', 'function']);
+const isLocalRegistration = (e) => isRecord(e) && typeof e.type === 'string' && LOCAL_REGISTRATION_TYPES.has(e.type);
+const JUDGE_STAND_IN = Object.freeze({ type: 'command', command: 'true' });
+function sessionHooksForJudge(hooks) {
+    const out = {};
+    for (const [event, groups] of Object.entries(hooks)) {
+        out[event] = Array.isArray(groups)
+            ? groups.map((g) => isRecord(g) && Array.isArray(g.hooks) && g.hooks.some(isLocalRegistration)
+                ? { ...g, hooks: g.hooks.map((e) => (isLocalRegistration(e) ? JUDGE_STAND_IN : e)) }
+                : g)
+            : groups;
+    }
+    return out;
+}
+export function decideSessionHooks(input) {
+    const out = [];
+    let unreadable = 0;
+    for (const src of input.sources) {
+        if (!isRecord(src) || typeof src.origin !== 'string' || !SESSION_HOOK_ORIGINS.has(src.origin) || !isRecord(src.hooks)) {
+            unreadable++;
+            continue;
+        }
+        const origin = src.origin;
+        const name = typeof src.name === 'string' ? src.name : '';
+        const sv = salvageSettingsHooksEntries({ hooks: sessionHooksForJudge(src.hooks) });
+        const rejectedWhole = sv.outcome === 'rejected';
+        const mask = hooksSalvageMaskOf(sv.outcome === 'loaded-partial' ? sv.dropped : []);
+        for (const [event, groups] of Object.entries(src.hooks)) {
+            if (!Array.isArray(groups)) {
+                unreadable++;
+                continue;
+            }
+            ;
+            groups.forEach((group, groupIndex) => {
+                if (!isRecord(group) || !Array.isArray(group.hooks)) {
+                    unreadable++;
+                    return;
+                }
+                ;
+                group.hooks.forEach((entry, hookIndex) => {
+                    const key = { origin, name, event, groupIndex, hookIndex };
+                    const type = isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined;
+                    if (rejectedWhole || (!mask.eventDropped(event) && mask.entryDropped(event, groupIndex, hookIndex)) || type === undefined) {
+                        out.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        return;
+                    }
+                    const shellRuns = input.shellRuns(event, type);
+                    if (!ENGINE_EVENTS.has(event)) {
+                        out.push({ ...key, ...(shellRuns ? { disposition: 'shell', reason: 'shell_event' } : { disposition: 'not_run', reason: 'no_executor' }) });
+                        return;
+                    }
+                    const ex = hookExecutorOf({ source: 'session', event, powershell: false, llmPosition: 0, engine: input.engine, shellRuns, promptAuthoredByUser: input.promptAuthoredByUser });
+                    if (ex.kind === 'excluded')
+                        return;
+                    out.push({ ...key, disposition: ex.disposition, reason: ex.reason });
+                });
+            });
+        }
+    }
+    return { verdicts: out, unreadable };
 }
 const SHELL_INERT_COMMAND = /^[A-Za-z0-9_./:+-]+$/;
 function carriesArgs(entry) {
@@ -312,7 +445,7 @@ function carriesArgs(entry) {
     }
     return true;
 }
-export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, judge) {
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, judge, mask) {
     const drops = [];
     const verdicts = [];
     const excluded = [];
@@ -320,6 +453,8 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
     let stripped = 0;
     const engineEvent = ENGINE_EVENTS.has(event);
     groups.forEach((group, groupIndex) => {
+        if (mask !== undefined && mask.groupDropped(event, groupIndex))
+            return;
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
             out.push(group);
             return;
@@ -327,6 +462,10 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
         const kept = [];
         let changed = false;
         group.hooks.forEach((entry, hookIndex) => {
+            if (mask !== undefined && mask.entryDropped(event, groupIndex, hookIndex)) {
+                changed = true;
+                return;
+            }
             const reason = !isRecord(entry)
                 ? undefined
                 : entry.type === 'mcp_tool'
@@ -665,18 +804,15 @@ const REASON_TEXT = {
     engine_llm_limit: 'the engine may skip prompt or agent hooks after the first four on one event',
     engine_unconfirmed: 'it is sent to the engine, which is expected to run it, but this client cannot confirm that',
     engine_elsewhere: 'it is not confirmed that the engine was started by this client on this machine, so this client runs it itself',
+    hooks_module: 'hooks registered in code by a plugin module run neither in the engine nor in this client',
+    scope_unsupported: 'hooks registered for a skill, an agent or by the host application are not sent to the engine, and this client does not run this event',
+    source_incomplete: 'the plugin was reported without its id, name, root folder or data folder',
 };
 const DROP_TEXT = {
     exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
     mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
 };
-const SOURCE_TEXT = {
-    policySettings: 'Managed settings',
-    userSettings: 'User settings',
-    projectSettings: 'Project settings',
-    localSettings: 'Local settings',
-    flagSettings: 'Flag settings',
-};
+const SOURCE_TEXT = HOOK_SETTINGS_SOURCE_TEXT;
 export function pluginHookReasonText(reason) {
     return REASON_TEXT[reason];
 }
@@ -786,5 +922,75 @@ export function hooksNotRunNotice(plan) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
         lines.push(`${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
     }
+    const moduleRows = plan.moduleVerdicts;
+    for (const raw of Array.isArray(moduleRows) ? moduleRows : []) {
+        if (!isRecord(raw) || ownField(raw, 'disposition') !== 'not_run')
+            continue;
+        const reason = ownField(raw, 'reason');
+        const name = ownField(raw, 'pluginName');
+        if (typeof reason !== 'string' || !REASON_SET.has(reason))
+            continue;
+        lines.push(`Plugin "${noticeLabel(typeof name === 'string' ? name : '') || '(unnamed)'}": hooks module will not run — ${pluginHookReasonText(reason)}.`);
+    }
+    const sessionRows = plan.sessionVerdicts;
+    const bySession = new Map();
+    for (const raw of Array.isArray(sessionRows) ? sessionRows : []) {
+        if (!isRecord(raw) || ownField(raw, 'disposition') !== 'not_run')
+            continue;
+        const origin = ownField(raw, 'origin');
+        const name = ownField(raw, 'name');
+        const reason = ownField(raw, 'reason');
+        const event = ownField(raw, 'event');
+        if (typeof origin !== 'string' || !SESSION_HOOK_ORIGINS.has(origin) || typeof reason !== 'string' || !REASON_SET.has(reason) || typeof event !== 'string')
+            continue;
+        const nm = typeof name === 'string' ? name : '';
+        const k = `${origin}\u0000${nm}\u0000${reason}`;
+        const row = bySession.get(k) ?? { origin: origin, name: nm, reason: reason, events: [], count: 0 };
+        if (!row.events.includes(event))
+            row.events.push(event);
+        row.count++;
+        bySession.set(k, row);
+    }
+    for (const row of bySession.values()) {
+        const events = row.events.map((e) => noticeLabel(e)).join(', ');
+        const who = row.origin === 'sdk_host' ? 'Host application hooks' : `${row.origin === 'skill' ? 'Skill' : 'Agent'} "${noticeLabel(row.name) || '(unnamed)'}"`;
+        lines.push(`${who}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+    }
+    const salvageRows = plan.settingsSalvage;
+    for (const row of Array.isArray(salvageRows) ? salvageRows : []) {
+        const notice = isRecord(row) ? ownField(row, 'notice') : undefined;
+        if (typeof notice === 'string' && notice.length > 0)
+            lines.push(notice);
+    }
     return lines;
 }
+export function userPromptSubmitExecutorOf(plan) {
+    try {
+        const p = plan;
+        if (!isRecord(p))
+            return 'unknown';
+        const verdicts = ownField(p, 'verdicts');
+        if (!Array.isArray(verdicts))
+            return 'unknown';
+        const rows = [...verdicts];
+        for (const k of ['settingsVerdicts', 'sessionVerdicts']) {
+            const v = ownField(p, k);
+            if (v === undefined)
+                continue;
+            if (!Array.isArray(v))
+                return 'unknown';
+            rows.push(...v);
+        }
+        const ups = rows.filter((r) => isRecord(r) && ownField(r, 'event') === 'UserPromptSubmit').map((r) => ownField(r, 'disposition'));
+        if (ups.length === 0)
+            return 'none';
+        if (ups.some((d) => d === 'engine'))
+            return 'engine';
+        if (ups.every((d) => d === 'shell'))
+            return 'shell';
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/printModelStatus.d.ts

@@ -0,0 +1,63 @@
+import type { SDKAssistantMessageError } from '@sema-agent/agent-types';
+import { type RetryStatus, type RetryStatusArmLike, type RetryStatusNotice } from './retryStatus.js';
+export declare const PRINT_MODEL_STATUS_SUBTYPE = "_sema_model_status";
+export declare const PRINT_LAST_MODEL_STATUS_KEY = "_sema_last_model_status";
+export interface PrintModelStatusCtx {
+    readonly sessionId: string;
+    readonly nowMs: number;
+    readonly mintUuid: () => string;
+    readonly model?: string;
+}
+export interface PrintModelStatusPayload {
+    readonly kind: RetryStatus['kind'];
+    readonly terminal?: true;
+    readonly attempt?: number;
+    readonly max_retries?: number;
+    readonly retry_delay_ms?: number;
+    readonly error_status?: number;
+    readonly provider_condition?: string;
+    readonly err_class?: string;
+    readonly elapsed_ms?: number;
+    readonly timeout_ms?: number;
+    readonly model?: string;
+    readonly phase: RetryStatusNotice['phase'];
+    readonly recourse?: NonNullable<RetryStatusNotice['recourse']>;
+    readonly message: string;
+}
+export interface PrintApiRetryFrame {
+    readonly type: 'system';
+    readonly subtype: 'api_retry';
+    readonly attempt: number;
+    readonly max_retries: number;
+    readonly retry_delay_ms: number;
+    readonly error_status: number | null;
+    readonly error: SDKAssistantMessageError;
+    readonly _sema_provider_condition?: string;
+    readonly _sema_model?: string;
+    readonly _sema_message: string;
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export interface PrintModelStatusSupersetFrame {
+    readonly type: 'system';
+    readonly subtype: typeof PRINT_MODEL_STATUS_SUBTYPE;
+    readonly _sema_model_status: PrintModelStatusPayload & {
+        readonly refresh?: true;
+    };
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export type PrintModelStatusFrame = PrintApiRetryFrame | PrintModelStatusSupersetFrame;
+export interface PrintModelStatusResultFields {
+    readonly _sema_last_model_status?: PrintModelStatusPayload;
+}
+export interface PrintLaneArmLike extends RetryStatusArmLike {
+    readonly type?: string;
+    readonly event?: RetryStatusArmLike;
+}
+export interface PrintModelStatusTracker {
+    take(msg: PrintLaneArmLike | null | undefined, ctx: PrintModelStatusCtx): PrintModelStatusFrame | null;
+    beginTurn(): void;
+    resultFields(nowMs: number): PrintModelStatusResultFields;
+}
+export declare function createPrintModelStatusTracker(): PrintModelStatusTracker;

package/dist/printModelStatus.js

@@ -0,0 +1,155 @@
+import { retryStatusFromArm, retryStatusNotice } from './retryStatus.js';
+import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+export const PRINT_MODEL_STATUS_SUBTYPE = '_sema_model_status';
+export const PRINT_LAST_MODEL_STATUS_KEY = '_sema_last_model_status';
+function httpStatusOf(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v > 0 && v <= 999 ? v : undefined;
+}
+function ccRetryErrorCategory(status) {
+    const code = httpStatusOf(status.errorStatus);
+    if (code === 529 || status.providerCondition === 'overloaded')
+        return 'overloaded';
+    if (code === 429)
+        return 'rate_limit';
+    if (code === 401 || code === 403)
+        return 'authentication_failed';
+    if (code !== undefined && code >= 408)
+        return 'server_error';
+    return 'unknown';
+}
+function modelStatusPayload(status, ctx) {
+    const code = httpStatusOf(status.errorStatus);
+    const terminal = 'terminal' in status && status.terminal === true;
+    const sane = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
+    const count = (v) => (typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined);
+    const retryDelayMs = status.kind !== 'waiting' && !terminal ? sane(Math.max(0, status.deadline - ctx.nowMs)) : undefined;
+    const attempt = count(status.attempt);
+    const maxRetries = count(status.maxRetries);
+    const elapsed = sane(status.elapsedMs);
+    const ceiling = sane(status.timeoutMs);
+    const model = ctx.model !== undefined && ctx.model.length > 0 ? ctx.model : undefined;
+    const notice = retryStatusNotice(status, model !== undefined ? { modelName: model } : undefined);
+    return {
+        kind: status.kind,
+        ...(terminal ? { terminal: true } : {}),
+        ...(attempt !== undefined ? { attempt } : {}),
+        ...(maxRetries !== undefined ? { max_retries: maxRetries } : {}),
+        ...(retryDelayMs !== undefined ? { retry_delay_ms: retryDelayMs } : {}),
+        ...(code !== undefined ? { error_status: code } : {}),
+        ...(typeof status.providerCondition === 'string' ? { provider_condition: status.providerCondition } : {}),
+        ...(typeof status.errClass === 'string' ? { err_class: status.errClass } : {}),
+        ...(elapsed !== undefined ? { elapsed_ms: elapsed } : {}),
+        ...(ceiling !== undefined ? { timeout_ms: ceiling } : {}),
+        ...(model !== undefined ? { model } : {}),
+        phase: notice.phase,
+        ...(notice.recourse !== undefined ? { recourse: notice.recourse } : {}),
+        message: notice.line,
+    };
+}
+function apiRetryKeyOf(status) {
+    const terminal = 'terminal' in status && status.terminal === true;
+    const ok = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+    if (status.kind === 'waiting' || terminal || !ok(status.attempt) || !ok(status.maxRetries))
+        return null;
+    return `${String(status.attempt)}/${String(status.maxRetries)}/${String(status.errClass ?? '')}/${String(status.errorStatus ?? '')}`;
+}
+function statusFrameOf(status, ctx, uuid, refresh) {
+    const payload = modelStatusPayload(status, ctx);
+    if (apiRetryKeyOf(status) !== null && !refresh) {
+        return {
+            type: 'system',
+            subtype: 'api_retry',
+            attempt: status.attempt ?? 0,
+            max_retries: status.maxRetries ?? 0,
+            retry_delay_ms: payload.retry_delay_ms ?? 0,
+            error_status: payload.error_status ?? null,
+            error: ccRetryErrorCategory(status),
+            ...(payload.provider_condition !== undefined ? { _sema_provider_condition: payload.provider_condition } : {}),
+            ...(payload.model !== undefined ? { _sema_model: payload.model } : {}),
+            _sema_message: payload.message,
+            uuid,
+            session_id: ctx.sessionId,
+        };
+    }
+    return { type: 'system', subtype: PRINT_MODEL_STATUS_SUBTYPE, _sema_model_status: { ...payload, ...(refresh ? { refresh: true } : {}) }, uuid, session_id: ctx.sessionId };
+}
+function isMainLaneArm(msg) {
+    const tri = (o, key) => {
+        try {
+            const d = Object.getOwnPropertyDescriptor(o, key);
+            if (d !== undefined && !('value' in d))
+                return { ok: false };
+            return { ok: true, v: readOwnDataValue(o, key) };
+        }
+        catch {
+            return { ok: false };
+        }
+    };
+    const top = tri(msg, 'parentToolCallId');
+    if (!top.ok)
+        return false;
+    const event = tri(msg, 'event');
+    if (!event.ok)
+        return false;
+    const nested = typeof event.v === 'object' && event.v !== null ? tri(event.v, 'parentToolCallId') : { ok: true, v: undefined };
+    if (!nested.ok)
+        return false;
+    return typeof top.v !== 'string' && typeof nested.v !== 'string';
+}
+export function createPrintModelStatusTracker() {
+    let last = null;
+    let lastApiRetryKey = null;
+    const clear = () => {
+        last = null;
+        lastApiRetryKey = null;
+    };
+    return {
+        take(msg, ctx) {
+            try {
+                const type = guardedRead(() => readOwnDataValue(msg, 'type'));
+                if (type === 'stream_event' || type === 'tool_end_result') {
+                    if (msg !== null && msg !== undefined && isMainLaneArm(msg))
+                        clear();
+                    return null;
+                }
+                if (type !== 'retry_status')
+                    return null;
+                const sessionId = readOwnDataNonEmptyString(ctx, 'sessionId');
+                const mintUuid = readOwnDataValue(ctx, 'mintUuid');
+                const nowMs = readOwnDataFiniteNumber(ctx, 'nowMs');
+                if (sessionId === undefined || typeof mintUuid !== 'function' || nowMs === undefined)
+                    return null;
+                const status = retryStatusFromArm(msg, nowMs);
+                if (status === undefined)
+                    return null;
+                if (status === null) {
+                    clear();
+                    return null;
+                }
+                const model = readOwnDataNonEmptyString(ctx, 'model');
+                const key = apiRetryKeyOf(status);
+                const refresh = key !== null && key === lastApiRetryKey;
+                const safeCtx = { sessionId, nowMs, mintUuid, ...(model !== undefined ? { model } : {}) };
+                const frame = statusFrameOf(status, safeCtx, mintUuid(), refresh);
+                lastApiRetryKey = key;
+                last = { status, model };
+                return frame;
+            }
+            catch {
+                return null;
+            }
+        },
+        beginTurn: clear,
+        resultFields(nowMs) {
+            try {
+                if (last === null)
+                    return {};
+                const now = typeof nowMs === 'number' && Number.isFinite(nowMs) ? nowMs : 0;
+                return { _sema_last_model_status: modelStatusPayload(last.status, { ...(last.model !== undefined ? { model: last.model } : {}), nowMs: now }) };
+            }
+            catch {
+                return {};
+            }
+        },
+    };
+}

package/dist/request/taskRequest.d.ts

@@ -1,6 +1,7 @@
-import type { TaskRequest } from '@sema-agent/sdk';
+import type { TaskRequest, UserAttachment } from '@sema-agent/sdk';
 import { type OutputStyleSeatReading } from '../outputStyleSeatCapability.js';
 import { type ApprovalReachWord } from '../approvalReachWire.js';
+import { type HostTurnSettings, type HostTurnSettingsInput } from '../hostTurnSettings.js';
 export type RequestLane = 'interactive' | 'print' | 'utility';
 export type TaskRequestLike = Record<string, unknown>;
 export interface RequestFieldSpec {
@@ -22,7 +23,9 @@ export interface TaskRequestInput {
     reasoningEffort?: string;
     model?: string;
     images?: readonly unknown[];
+    userAttachments?: readonly UserAttachment[];
     skills?: unknown;
+    userInvokedSkills?: readonly string[];
     mcpServers?: unknown;
     clientContext?: Record<string, unknown>;
     scratchpadDir?: string;
@@ -58,12 +61,13 @@ export interface TaskRequestInput {
     disableSkills?: TaskRequest['disableSkills'];
     rewind?: Record<string, unknown>;
     repo?: string;
+    hostSettings: HostTurnSettings;
     settings?: {
-        resolved?: Record<string, unknown>;
-        webSearch?: Record<string, unknown>;
+        resolved?: never;
+        webSearch?: never;
         ultracode?: boolean;
-        hooks?: Record<string, unknown>;
-        outputStyle?: string;
+        hooks?: never;
+        outputStyle?: never;
     };
 }
 export declare const TASK_REQUEST_OMISSION_CAUSES: readonly ["upstream_absent", "other_channel", "off_lane", "not_live"];
@@ -78,6 +82,7 @@ export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];
+    readonly host: HostTurnSettings;
 }
 export type TaskRequestSeatReading = {
     readonly seat: 'seated';
@@ -95,6 +100,7 @@ export interface UpstreamAbsentRequestIntent {
 export declare const UPSTREAM_ABSENT_REQUEST_INTENTS: readonly UpstreamAbsentRequestIntent[];
 export declare const REQUEST_LANES: readonly RequestLane[];
 export declare function taskRequestSeatOf(key: string, lane: RequestLane): TaskRequestSeatReading;
+export declare function hostTurnSettings(input: HostTurnSettingsInput): HostTurnSettings;
 export declare const MEMORY_CAPTURE_OFF: "off";
 export declare function memoryCaptureDeclarationField(declared: boolean): {
     memoryCapture: 'off';