@sema-agent/client-core 0.88.0 → 0.90.0

package/dist/pluginHooksWire.js

@@ -25,6 +25,12 @@ export const PLUGIN_HOOK_REASONS = [
     'shell_form_user_config',
     'user_config_unset',
     'malformed_entry',
+    'engine_hooks_off',
+    'engine_hooks_unknown',
+    'engine_type_skipped',
+    'engine_llm_limit',
+    'engine_unconfirmed',
+    'engine_elsewhere',
 ];
 export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'workspace_untrusted',
@@ -32,15 +38,69 @@ export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'policy_disable_all',
     'startup_mode',
     'managed_plugins_only',
+    'prompt_not_user_authored',
 ];
 export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported'];
-export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192 };
+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']);
+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 === 'settings') {
+        const why = x.powershell
+            ? { reason: 'engine_type_skipped', certain: true }
+            : x.engine.hooksCapable === false
+                ? { reason: 'engine_hooks_off', certain: true }
+                : x.engine.hooksCapable === null
+                    ? { reason: 'engine_hooks_unknown', certain: false }
+                    : x.llmPosition > ENGINE_HOOK_LIMITS.maxLlmEntriesPerEvent
+                        ? { reason: 'engine_llm_limit', certain: false }
+                        : undefined;
+        const compaction = COMPACTION_EVENTS.has(x.event);
+        if (why === undefined) {
+            if (!x.shellRuns || x.engine.ownedByThisShell === true)
+                return judged('engine', 'projected');
+            return compaction ? judged('engine', 'engine_unconfirmed') : judged('shell', 'engine_elsewhere');
+        }
+        if (x.shellRuns && (why.certain || !compaction || why.reason === 'engine_llm_limit'))
+            return judged('shell', why.reason);
+        return why.certain ? judged('not_run', why.reason) : judged('engine', 'engine_unconfirmed');
+    }
+    const why = x.engine.ownedByThisShell === null
+        ? 'engine_locality_unknown'
+        : !x.engine.ownedByThisShell
+            ? 'engine_not_local'
+            : x.engine.pluginHooksCapable === null
+                ? 'engine_capability_unknown'
+                : !x.engine.pluginHooksCapable
+                    ? 'engine_capability_absent'
+                    : x.engine.hooksCapable === false
+                        ? 'engine_hooks_off'
+                        : x.engine.hooksCapable === null
+                            ? 'engine_hooks_unknown'
+                            : x.pluginBlock === 'not_command'
+                                ? 'not_command'
+                                : x.powershell
+                                    ? 'engine_type_skipped'
+                                    : x.pluginBlock;
+    if (why === undefined)
+        return judged('engine', 'projected');
+    return judged(x.shellRuns ? 'shell' : 'not_run', why);
+}
 const ENGINE_EVENTS = new Set(ENGINE_FIRED_HOOK_EVENTS);
 const USER_CONFIG_REF_ONE = /\$\{user_config\.[^}]+\}/;
 const USER_CONFIG_REF_ALL = /\$\{user_config\.([^}]+)\}/g;
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
+function ownField(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function ownView(v) {
+    return isRecord(v) ? Object.assign(Object.create(null), Object.fromEntries(Object.entries(v))) : v;
+}
 function nonEmptyString(v) {
     return typeof v === 'string' && v.length > 0;
 }
@@ -123,7 +183,7 @@ export function decidePluginHooks(input) {
     const excluded = [];
     const candidates = new Map();
     let unreadable = 0;
-    const fallback = (event, reason) => input.shellHookEvents.has(event) ? { disposition: 'shell', reason } : { disposition: 'not_run', reason };
+    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)) {
             unreadable++;
@@ -155,6 +215,7 @@ export function decidePluginHooks(input) {
                         excluded.push({ ...key, reason: 'managed_plugins_only' });
                         return;
                     }
+                    const entryType = isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined;
                     const shape = sourceOk ? classifyEntry(entry, src.options) : { kind: 'malformed' };
                     if (shape.kind === 'malformed') {
                         verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
@@ -171,27 +232,28 @@ export function decidePluginHooks(input) {
                     if (!ENGINE_EVENTS.has(event)) {
                         verdicts.push({
                             ...key,
-                            ...(input.shellHookEvents.has(event)
+                            ...(input.shellRuns(event, entryType)
                                 ? { disposition: 'shell', reason: 'shell_event' }
                                 : { disposition: 'not_run', reason: 'no_executor' }),
                         });
                         return;
                     }
-                    const blocked = input.engine.ownedByThisShell === null
-                        ? 'engine_locality_unknown'
-                        : !input.engine.ownedByThisShell
-                            ? 'engine_not_local'
-                            : input.engine.pluginHooksCapable === null
-                                ? 'engine_capability_unknown'
-                                : !input.engine.pluginHooksCapable
-                                    ? 'engine_capability_absent'
-                                    : shape.kind === 'other'
-                                        ? 'not_command'
-                                        : declaresSensitive(src.options)
-                                            ? 'sensitive_options'
-                                            : undefined;
-                    if (blocked !== undefined) {
-                        verdicts.push({ ...key, ...fallback(event, blocked) });
+                    const ex = hookExecutorOf({
+                        source: 'plugin',
+                        event,
+                        powershell: shape.kind !== 'other' && isRecord(entry) && entry.shell === 'powershell',
+                        llmPosition: 0,
+                        engine: input.engine,
+                        shellRuns: input.shellRuns(event, entryType),
+                        promptAuthoredByUser: input.promptAuthoredByUser,
+                        ...(shape.kind === 'other' ? { pluginBlock: 'not_command' } : declaresSensitive(src.options) ? { pluginBlock: 'sensitive_options' } : {}),
+                    });
+                    if (ex.kind === 'excluded') {
+                        excluded.push({ ...key, reason: ex.reason });
+                        return;
+                    }
+                    if (ex.disposition !== 'engine') {
+                        verdicts.push({ ...key, disposition: ex.disposition, reason: ex.reason });
                         return;
                     }
                     const plugin = { name: src.name, root: src.root, dataDir: src.dataDir };
@@ -218,7 +280,7 @@ export function decidePluginHooks(input) {
             const cmd = c.wireEntry.command;
             if (typeof cmd === 'string' && cmd.length <= ENGINE_HOOK_LIMITS.maxCommandChars)
                 return true;
-            Object.assign(c.verdict, fallback(event, 'engine_limit'));
+            Object.assign(c.verdict, fallback(event, c.wireEntry.type, 'engine_limit'));
             return false;
         });
         if (fits.length === 0)
@@ -233,7 +295,7 @@ export function decidePluginHooks(input) {
         if (occ.groups + groupKeys.length > ENGINE_HOOK_LIMITS.maxGroupsPerEvent ||
             occ.entries + fits.length > ENGINE_HOOK_LIMITS.maxEntriesPerEvent) {
             for (const c of fits)
-                Object.assign(c.verdict, fallback(event, 'engine_limit'));
+                Object.assign(c.verdict, fallback(event, c.wireEntry.type, 'engine_limit'));
             continue;
         }
         const groupsOut = [];
@@ -259,12 +321,13 @@ function carriesArgs(entry) {
     }
     return true;
 }
-export function filterSettingsHookGroups(source, event, groups, execFormCapable, hostFires, failLoudMcpTool) {
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, failLoudMcpTool, judge) {
     const drops = [];
+    const verdicts = [];
+    const excluded = [];
     const out = [];
     let stripped = 0;
     const engineEvent = ENGINE_EVENTS.has(event);
-    const notRun = engineEvent && !hostFires;
     const keepMcpTool = failLoudMcpTool && engineEvent;
     groups.forEach((group, groupIndex) => {
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
@@ -284,10 +347,23 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
                         ? 'exec_form_unsupported'
                         : undefined;
             if (reason !== undefined) {
-                drops.push({ source, event, groupIndex, hookIndex, reason, notRun });
+                drops.push({ source, event, groupIndex, hookIndex, reason, notRun: engineEvent && !shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined) });
                 changed = true;
                 return;
             }
+            if (judge !== undefined && engineEvent && isRecord(entry) && judgeableSettingsEntry(entry)) {
+                const ex = judge(event, group, entry);
+                if (ex.kind === 'excluded') {
+                    excluded.push({ source, event, groupIndex, hookIndex, reason: ex.reason });
+                    changed = true;
+                    return;
+                }
+                verdicts.push({ source, event, groupIndex, hookIndex, disposition: ex.disposition, reason: ex.reason });
+                if (ex.disposition === 'shell') {
+                    changed = true;
+                    return;
+                }
+            }
             if (isRecord(entry) && Object.hasOwn(entry, 'plugin')) {
                 const copy = { ...entry };
                 delete copy.plugin;
@@ -303,7 +379,51 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
         else if (kept.length > 0)
             out.push({ ...group, hooks: kept });
     });
-    return { groups: out, drops, stripped };
+    return { groups: out, drops, stripped, verdicts, excluded };
+}
+function judgeableSettingsEntry(entry) {
+    const type = entry.type;
+    if (typeof type !== 'string' || !ENGINE_HOOK_TYPE_RUNS.has(type))
+        return false;
+    const field = type === 'command' ? entry.command : type === 'http' ? entry.url : entry.prompt;
+    return nonEmptyString(field) && !field.includes('\u0000');
+}
+export function createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser) {
+    const llm = new Map();
+    const seen = new Map();
+    return (event, group, entry) => {
+        let dk;
+        const entryKey = settingsHookEntryKey(entry);
+        if (entryKey !== undefined && isRecord(group)) {
+            try {
+                const { hooks: _hooks, ...rest } = group;
+                void _hooks;
+                dk = `${event}\u0000${JSON.stringify(rest)}\u0000${entryKey}`;
+            }
+            catch {
+                dk = undefined;
+            }
+        }
+        const prior = dk === undefined ? undefined : seen.get(dk);
+        if (prior !== undefined)
+            return prior;
+        const type = entry.type;
+        const isLlm = type === 'prompt' || type === 'agent';
+        const ex = hookExecutorOf({
+            source: 'settings',
+            event,
+            powershell: type === 'command' && entry.shell === 'powershell',
+            llmPosition: isLlm ? (llm.get(event) ?? 0) + 1 : 0,
+            engine,
+            shellRuns: shellRuns(event, typeof type === 'string' ? type : undefined),
+            promptAuthoredByUser,
+        });
+        if (isLlm && ex.kind === 'judged' && ex.disposition !== 'shell')
+            llm.set(event, (llm.get(event) ?? 0) + 1);
+        if (dk !== undefined)
+            seen.set(dk, ex);
+        return ex;
+    };
 }
 function settingsHookEntryKey(entry) {
     if (!isRecord(entry) || typeof entry.type !== 'string')
@@ -427,6 +547,116 @@ export function dedupeSettingsHookGroups(groups) {
 export function pluginHookVerdictOf(plan, pluginId, event, groupIndex, hookIndex) {
     return plan.verdicts.find((v) => v.pluginId === pluginId && v.event === event && v.groupIndex === groupIndex && v.hookIndex === hookIndex);
 }
+function skipMatcherKey(matcher) {
+    return matcher === undefined || matcher === null || matcher === '' || matcher === '*' ? 'null' : JSON.stringify(matcher);
+}
+export function settingsHooksKeptLocally(plan, event, group, opts) {
+    let raw;
+    try {
+        raw = group?.hooks;
+    }
+    catch {
+        raw = undefined;
+    }
+    const hooks = raw;
+    if (!Array.isArray(hooks) || hooks.length === 0 || !ENGINE_EVENTS.has(event))
+        return hooks;
+    try {
+        if (COMPACTION_EVENTS.has(event) && opts?.engineCompaction === 'not_performed')
+            return hooks;
+        const planRec = plan;
+        if (!isRecord(planRec))
+            return hooks;
+        const excludedList = Object.hasOwn(planRec, 'settingsExcluded') ? planRec.settingsExcluded : [];
+        const wire = ownField(planRec, 'wire');
+        if (!Array.isArray(excludedList) || (wire !== undefined && !isRecord(wire)))
+            return hooks;
+        if (excludedList.some((e) => settingsExclusionRowOf(e)?.event === event))
+            return [];
+        const sent = new Set();
+        const groups = isRecord(wire) ? ownField(wire, event) : undefined;
+        if (Array.isArray(groups)) {
+            for (const g of groups) {
+                if (!isRecord(g))
+                    continue;
+                const gh = ownField(g, 'hooks');
+                if (!Array.isArray(gh))
+                    continue;
+                const mk = skipMatcherKey(ownField(g, 'matcher'));
+                for (const h of gh) {
+                    if (isRecord(h) && Object.hasOwn(h, 'plugin'))
+                        continue;
+                    const k = settingsHookEntryKey(ownView(h));
+                    if (k !== undefined)
+                        sent.add(`${mk}\u0000${k}`);
+                }
+            }
+        }
+        if (sent.size === 0)
+            return hooks;
+        const mk = skipMatcherKey(isRecord(group) ? group.matcher : undefined);
+        let kept = null;
+        hooks.forEach((h, i) => {
+            const k = settingsHookEntryKey(h);
+            const skip = k !== undefined && sent.has(`${mk}\u0000${k}`);
+            if (skip)
+                kept ??= hooks.slice(0, i);
+            else if (kept !== null)
+                kept.push(h);
+        });
+        return kept ?? hooks;
+    }
+    catch {
+        return hooks;
+    }
+}
+function settingsRowBaseOf(v) {
+    if (!isRecord(v))
+        return undefined;
+    const source = ownField(v, 'source');
+    const event = ownField(v, 'event');
+    const groupIndex = ownField(v, 'groupIndex');
+    const hookIndex = ownField(v, 'hookIndex');
+    if (typeof source !== 'string' || !Object.hasOwn(SOURCE_TEXT, source))
+        return undefined;
+    if (typeof event !== 'string' || !ENGINE_EVENTS.has(event))
+        return undefined;
+    if (!Number.isInteger(groupIndex) || groupIndex < 0 || !Number.isInteger(hookIndex) || hookIndex < 0)
+        return undefined;
+    return { source: source, event, groupIndex: groupIndex, hookIndex: hookIndex, o: v };
+}
+const DISPOSITION_SET = new Set(PLUGIN_HOOK_DISPOSITIONS);
+const REASON_SET = new Set(PLUGIN_HOOK_REASONS);
+const EXCLUSION_REASON_SET = new Set(PLUGIN_HOOK_EXCLUSION_REASONS);
+function settingsVerdictRowOf(v) {
+    try {
+        const b = settingsRowBaseOf(v);
+        if (b === undefined)
+            return undefined;
+        const disposition = ownField(b.o, 'disposition');
+        const reason = ownField(b.o, 'reason');
+        if (typeof disposition !== 'string' || !DISPOSITION_SET.has(disposition) || typeof reason !== 'string' || !REASON_SET.has(reason))
+            return undefined;
+        return { source: b.source, event: b.event, groupIndex: b.groupIndex, hookIndex: b.hookIndex, disposition: disposition, reason: reason };
+    }
+    catch {
+        return undefined;
+    }
+}
+function settingsExclusionRowOf(v) {
+    try {
+        const b = settingsRowBaseOf(v);
+        if (b === undefined)
+            return undefined;
+        const reason = ownField(b.o, 'reason');
+        if (typeof reason !== 'string' || !EXCLUSION_REASON_SET.has(reason))
+            return undefined;
+        return { source: b.source, event: b.event, groupIndex: b.groupIndex, hookIndex: b.hookIndex, reason: reason };
+    }
+    catch {
+        return undefined;
+    }
+}
 const REASON_TEXT = {
     projected: 'it is sent to the engine',
     shell_event: 'this client runs this event itself',
@@ -441,6 +671,12 @@ const REASON_TEXT = {
     shell_form_user_config: 'its command uses ${user_config.…} in shell form, which is refused (use exec form with "args", or read $CLAUDE_PLUGIN_OPTION_<KEY>)',
     user_config_unset: 'its command uses a plugin option that has not been set',
     malformed_entry: 'the hook entry is malformed',
+    engine_hooks_off: 'the connected engine ignores hooks sent with requests',
+    engine_hooks_unknown: 'it is not known whether the connected engine runs hooks sent with requests',
+    engine_type_skipped: 'the engine does not run PowerShell command hooks',
+    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',
 };
 const DROP_TEXT = {
     exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
@@ -545,5 +781,22 @@ 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 — ${settingsHookDropText(row.reason)}.`);
     }
+    const settingsVerdicts = plan.settingsVerdicts;
+    const byVerdict = new Map();
+    for (const raw of Array.isArray(settingsVerdicts) ? settingsVerdicts : []) {
+        const v = settingsVerdictRowOf(raw);
+        if (v === undefined || v.disposition !== 'not_run')
+            continue;
+        const k = `${v.source}\u0000${v.reason}`;
+        const row = byVerdict.get(k) ?? { source: v.source, reason: v.reason, events: [], count: 0 };
+        if (!row.events.includes(v.event))
+            row.events.push(v.event);
+        row.count++;
+        byVerdict.set(k, row);
+    }
+    for (const row of byVerdict.values()) {
+        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)}.`);
+    }
     return lines;
 }

package/dist/promptDelivery.d.ts

@@ -14,7 +14,10 @@ export interface PromptDeliveryLedger {
     batchOf(uuid: string): readonly string[] | undefined;
     toRecords(): readonly PromptDeliveryRecord[];
     fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];
+    knownUndeliveredMessage(message: object | null | undefined): boolean;
+    withoutUndelivered<T>(messages: readonly T[]): T[];
 }
+export declare function frameProvesDelivery(event: object | null | undefined): boolean;
 export declare function createPromptDeliveryLedger(): PromptDeliveryLedger;
-export declare function promptKnownUndelivered(ledger: PromptDeliveryLedger, message: object | null | undefined): boolean;
-export declare function withoutUndeliveredPrompts<T>(ledger: PromptDeliveryLedger, messages: readonly T[]): T[];
+export declare function promptKnownUndelivered(ledger: Pick<PromptDeliveryLedger, 'knownUndelivered'>, message: object | null | undefined): boolean;
+export declare function withoutUndeliveredPrompts<T>(ledger: Pick<PromptDeliveryLedger, 'knownUndelivered'>, messages: readonly T[]): T[];

package/dist/promptDelivery.js

@@ -32,10 +32,12 @@ function readRecord(rec) {
     }
 }
 const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
-function frameProvesDelivery(event) {
-    if (typeof event !== 'object' || event === null || Array.isArray(event))
+export function frameProvesDelivery(event) {
+    if (typeof event !== 'object' || event === null)
         return false;
     try {
+        if (Array.isArray(event))
+            return false;
         const type = event.type;
         if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
             return false;
@@ -83,7 +85,7 @@ export function createPromptDeliveryLedger() {
             add(u, 'd', added);
         return Object.freeze(added);
     };
-    return Object.freeze({
+    const ledger = Object.freeze({
         attempted(batchUuids) {
             const batch = Object.freeze(cleanBatch(batchUuids));
             const added = [];
@@ -122,7 +124,10 @@ export function createPromptDeliveryLedger() {
             }
             return Object.freeze(added);
         },
+        knownUndeliveredMessage: (message) => promptKnownUndelivered(ledger, message),
+        withoutUndelivered: (messages) => withoutUndeliveredPrompts(ledger, messages),
     });
+    return ledger;
 }
 function uuidOfMessage(m) {
     if (typeof m !== 'object' || m === null)

package/dist/providerRejection.d.ts

@@ -0,0 +1,7 @@
+import { type RunTerminalFailureDetail } from './runTerminal.js';
+import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
+export interface ProviderRejectionResend {
+    resend: 'edit_and_resend' | 'not_by_editing';
+    text: string;
+}
+export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;

package/dist/providerRejection.js

@@ -0,0 +1,58 @@
+import { readRunTerminal } from './runTerminal.js';
+import { classifyToolHistoryMismatch } from './toolHistoryMismatch.js';
+const PROVIDER_STATUS_TIERS = Object.freeze([
+    Object.freeze([400, 400, 'invalid_request']),
+    Object.freeze([401, 401, 'authentication_failed']),
+    Object.freeze([403, 403, 'authentication_failed']),
+    Object.freeze([404, 404, 'model_not_found']),
+    Object.freeze([413, 413, 'invalid_request']),
+    Object.freeze([422, 422, 'invalid_request']),
+    Object.freeze([429, 429, 'rate_limit']),
+    Object.freeze([500, 599, 'server_error']),
+]);
+const UNTIERED = 'unknown';
+function providerStatusTier(status) {
+    for (const [lo, hi, tier] of PROVIDER_STATUS_TIERS)
+        if (status >= lo && status <= hi)
+            return tier;
+    return UNTIERED;
+}
+const EDITABLE_TIER = 'invalid_request';
+const NOT_BY_EDITING_TAIL = new Map([
+    ['authentication_failed', ': check the provider credentials or access for this account.'],
+    ['model_not_found', ': the model is not available from this provider — choose another model.'],
+    ['rate_limit', ': the provider is rate-limiting this account — wait and try again.'],
+    ['server_error', ': the provider reported an internal error — try again later.'],
+    [UNTIERED, ' for a reason that editing it will not fix — check the provider account or try again later.'],
+]);
+function toolHistoryMismatchCarrier(carrier) {
+    return carrier !== undefined && carrier !== null && classifyToolHistoryMismatch(carrier) !== null;
+}
+const PROVIDER_REJECTED = 'provider_rejected';
+export function providerRejectionResend(detail, carrier) {
+    let read;
+    try {
+        const r = readRunTerminal({ terminal: { kind: 'failed', detail } });
+        read = r !== null && r.kind === 'failed' && Object.hasOwn(r, 'detail') ? r.detail : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (read === undefined || !Object.hasOwn(read, 'kind') || read.kind !== PROVIDER_REJECTED)
+        return undefined;
+    const status = Object.hasOwn(read, 'status') ? read.status : undefined;
+    if (status === undefined)
+        return undefined;
+    if (toolHistoryMismatchCarrier(carrier))
+        return undefined;
+    const tier = providerStatusTier(status);
+    return tier === EDITABLE_TIER
+        ? {
+            resend: 'edit_and_resend',
+            text: `The model provider rejected this request as sent (HTTP ${status}). Change it — for example shorten it or remove an attachment — and send it again.`,
+        }
+        : {
+            resend: 'not_by_editing',
+            text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(tier) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+        };
+}

package/dist/request/taskRequest.d.ts

@@ -51,6 +51,7 @@ export interface TaskRequestInput {
     fileHistory?: 'disabled';
     inheritEnv?: InheritEnvWord;
     requireExistingSession?: TaskRequest['requireExistingSession'];
+    disableSkills?: true;
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;
@@ -74,6 +75,7 @@ export interface TaskRequestOmission {
 export declare function taskRequestOmissionCauseDetail(cause: unknown): string;
 export declare const TASK_REQUEST_OMISSION_CAUSE_NOTICES: Readonly<Record<TaskRequestOmissionCause, string>>;
 export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
+export declare function taskRequestOmissionCausePhrase(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];