@sema-agent/client-core 0.88.0 → 0.89.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/providerRejection.d.ts

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

package/dist/providerRejection.js

@@ -0,0 +1,52 @@
+import { readRunTerminal } from './runTerminal.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.'],
+]);
+const PROVIDER_REJECTED = 'provider_rejected';
+export function providerRejectionResend(detail) {
+    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;
+    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[];

package/dist/request/taskRequest.js

@@ -1,3 +1,4 @@
+import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.js';
 export const REQUEST_FIELD_MATRIX = [
     { field: 'objective', lanes: ['interactive', 'print', 'utility'], live: false, why: '本 turn 的真实输入,每条车道都必需', whyUtilityLane: '恒座:三条车道都必须带上本次提交的模型面输入' },
     { field: 'sessionId', lanes: ['interactive', 'print', 'utility'], live: false, why: '单命名空间(TP-A Step 2):壳 id 即引擎 session id;print 在非 live 下保留 mock 常量', whyUtilityLane: '恒座:side-channel 提交走**独立**会话 id(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -25,6 +26,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'fileHistory', lanes: ['interactive', 'print'], live: true, why: '「这一次运行别捕获文件历史」的**请求级声明**(server 7.104.0 提交体键,单成员闭集 "disabled";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,子代继承)。两条用户车道都是提交面、都跑在用户的文件上 ⇒ 都能声明;「本会话不捕获」= 每个提交都带(续跑腿重放同一个体)。🔴 只在能力读数 `on-optional` 时发(老 server 对表外键 400),值由片段口 `fileHistoryDeclarationField` 唯一铸出。与 rewind 还原键同交 ⇒ 上游 400 `request.field_conflict`', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),不会改任何文件 ⇒ 没有可捕获的东西;带上它只会在不认识这一键的老 server 上给这条提交多一种 400' },
     { field: 'inheritEnv', lanes: ['interactive', 'print'], live: true, why: '模型驱动的宿主 shell「继承多少用户环境」的**请求级声明**(server 7.106.0 提交体键,两词闭集 "all" / "scrub";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,续跑腿重放同判)。两条用户车道都是提交面、都可能在用户机器上跑 shell ⇒ 都能声明。本层两词原样透传、不按车道 / 部署预判(非 host 车道 × "all" 400、托管 × "all" 422 归上游判)。🔴 缺席 = 缺省清洗且清掉本会话上一条声明 ⇒ 要「本会话整份继承」就每个提交都带。🔴 只在服务端版本 ≥ 7.106.0 时发(老 server 对表外键整条 400),值由片段口 `inheritEnvDeclaration` 唯一铸出', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),没有模型驱动的 shell 去继承环境;带上它只会在不认这一键的老服务端上给这条提交多一种 400' },
     { field: 'requireExistingSession', lanes: ['interactive', 'print'], live: true, why: '「只续已有会话」的**请求级断言**(sdk `TaskRequest.requireExistingSession`):`true` 且会话不在 ⇒ 服务端在任何东西跑起来之前拒(会话不在 / 没给会话 id 两形),而**不是**静默新开一个同 id 的空会话;缺席 / `false` = 历史的「找不到就新开」。两条用户车道都有「续某个会话」的入口 ⇒ 都能声明。本层只认字面 `true`(`false` 与缺席同义、不发);非布尔坏值响亮拒(上游对它 400);`true` 而入参没有可续的会话 id ⇒ 装配期按名响亮拒,不留给上游。上游两形的拒绝经 `requireExistingSessionRefusalFromError` 归成一句', whyUtilityLane: '无座:side-channel 每一次提交都走壳另铸的**独立**会话 id(见 sessionId 那一行),从不续任何已有会话 ⇒「必须已存在」对它没有意义,带上去只会让每一次提交都被拒' },
+    { field: 'disableSkills', lanes: ['interactive', 'print'], live: true, why: '「这一发一只技能都不装」的**请求级声明**(出厂技能、调用方给的技能、子代定义里的技能一个都不进引擎;其余工具照挂 —— 与 excludeAllTools 是两件事,两键同带各自生效)。两条用户车道都是提交面 ⇒ 都能声明。本层只认字面 true(false 与缺席同义、不发);非布尔坏值响亮拒(上游对它 400);与非空 skills 或任一非空 agents[].skills 同在 ⇒ 装配期按名响亮拒(上游对这一组合 400),兜底层落 agents 之后同判。🔴 只在能力位读数为真时发(老服务端对表外键整条 400),值由片段口 disableSkillsDeclaration 唯一铸出', whyUtilityLane: '无座:同 skills 一行 —— side-channel 是零工具面,装不装技能都无从谈起' },
     { field: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。#106 裁 B(让位+告知)后交互面默认关', whyUtilityLane: '无座:终验让引擎再跑一轮自证,而 side-channel 要的是一次小提交的即时答案;「无人值守才需要引擎自证」这条理由在本车道上让位给「小预算优先」' },
     { field: 'limits', lanes: ['print', 'utility'], live: true, why: 'P2-3-b:`-p` 的预算护栏(--max-* flag 族),交互 REPL 由人随时 Esc', whyUtilityLane: '有座:side-channel 必须带预算护栏(墙钟 / 输出 token / 轮数)—— 它同样没有人看着,而且没有后续回合可以中断' },
     { field: 'interactiveTools', lanes: ['print', 'utility'], live: true, why: '[909]B 件3:无人值守 stamp false,从 roster 源头灭掉 AskUserQuestion/plan 门。交互车道 stamp false 等于自废武功', whyUtilityLane: '有座:side-channel 绝不该弹交互问答 / plan 门(没有人在看这条提交)。它与 excludeAllTools 是**两条独立**的收紧声明、在这条车道上**并存**(本车道强制带卸载声明,见 `refuseUtilityWithoutToolUnload`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
@@ -76,18 +78,40 @@ export function taskRequestOmissionCauseDetail(cause) {
     const word = typeof cause === 'string' && cause.length > 0 ? cause : '(none)';
     return `a cause this build does not know (${word}) — this build does not know this cause: receipt causes come from this build's own frozen vocabulary, so a word outside it was not produced here; check whatever supplied it`;
 }
-export const TASK_REQUEST_OMISSION_CAUSE_NOTICES = Object.freeze({
-    upstream_absent: 'Not sent with this request: this version has no way to send this setting in any request, so giving it or leaving it out makes no difference to what is sent.',
-    other_channel: 'Not sent from here: that part of the request belongs to a separate step, so what goes out for it, if anything, is decided there rather than by the value given here.',
-    off_lane: 'Not sent with this request: this kind of request does not carry this setting, so giving it or leaving it out makes no difference to what this request sends.',
-    not_live: 'Not sent with this request: the request was marked as not going to a live engine (for example an offline or test run), and this setting is only sent on requests that go to one.',
+const TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS = Object.freeze({
+    upstream_absent: {
+        lead: 'Not sent with this request',
+        reason: 'this version has no way to send this setting in any request, so giving it or leaving it out makes no difference to what is sent',
+    },
+    other_channel: {
+        lead: 'Not sent from here',
+        reason: 'that part of the request belongs to a separate step, so what goes out for it, if anything, is decided there rather than by the value given here',
+    },
+    off_lane: {
+        lead: 'Not sent with this request',
+        reason: 'this kind of request does not carry this setting, so giving it or leaving it out makes no difference to what this request sends',
+    },
+    not_live: {
+        lead: 'Not sent with this request',
+        reason: 'the request was marked as not going to a live engine (for example an offline or test run), and this setting is only sent on requests that go to one',
+    },
 });
-const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE = 'Not sent with this request, for a reason this version does not recognize.';
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_LEAD = 'Not sent with this request';
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON = 'for a reason this version does not recognize';
+const wholeOmissionNotice = (p) => `${p.lead}: ${p.reason}.`;
+export const TASK_REQUEST_OMISSION_CAUSE_NOTICES = Object.freeze(Object.fromEntries(TASK_REQUEST_OMISSION_CAUSES.map((cause) => [cause, wholeOmissionNotice(TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS[cause])])));
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE = `${TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_LEAD}, ${TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON}.`;
+const omissionNoticePartsOf = (cause) => typeof cause === 'string' && Object.hasOwn(TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS, cause)
+    ? TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS[cause]
+    : undefined;
 export function taskRequestOmissionCauseNotice(cause) {
-    return typeof cause === 'string' && Object.hasOwn(TASK_REQUEST_OMISSION_CAUSE_NOTICES, cause)
+    return omissionNoticePartsOf(cause) !== undefined
         ? TASK_REQUEST_OMISSION_CAUSE_NOTICES[cause]
         : TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE;
 }
+export function taskRequestOmissionCausePhrase(cause) {
+    return omissionNoticePartsOf(cause)?.reason ?? TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON;
+}
 const row = (field) => ({ via: 'matrix', field });
 const INPUT_KEY_ROUTES = {
     objective: { via: 'always' },
@@ -141,6 +165,7 @@ const INPUT_KEY_ROUTES = {
     fileHistory: row('fileHistory'),
     inheritEnv: row('inheritEnv'),
     requireExistingSession: row('requireExistingSession'),
+    disableSkills: row('disableSkills'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     council: row('council'),
@@ -214,6 +239,7 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     memory: (v) => v === 'off',
     fileHistory: (v) => v === FILE_HISTORY_DISABLED,
     requireExistingSession: (v) => v === true,
+    disableSkills: (v) => v === true,
     rewind: (v) => typeof v === 'object' && v !== null && rewindSubKeys().some((k) => hasOwn(v, k) && present(v[k])),
 });
 const inPlay = (key, v) => present(v) && (VALUE_LEVEL_IN_PLAY[key]?.(v) ?? true);
@@ -542,7 +568,7 @@ export function parseMaxCostUsd(text) {
         return { ok: false, why: 'not_positive' };
     return { ok: true, value };
 }
-const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv', 'requireExistingSession'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv', 'requireExistingSession', 'disableSkills'];
 function dataFirstSnapshot(input, afterData) {
     let descs;
     try {
@@ -612,6 +638,7 @@ export function assembleTaskRequest(input, lane) {
     const fileHistoryIn = src.fileHistory;
     const inheritEnvIn = src.inheritEnv;
     const requireExistingSessionIn = src.requireExistingSession;
+    const disableSkillsIn = src.disableSkills;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -624,6 +651,7 @@ export function assembleTaskRequest(input, lane) {
         fileHistory: fileHistoryIn,
         inheritEnv: inheritEnvIn,
         requireExistingSession: requireExistingSessionIn,
+        disableSkills: disableSkillsIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
@@ -637,6 +665,7 @@ export function assembleTaskRequest(input, lane) {
     refuseBadFileHistory(fileHistoryIn);
     refuseBadInheritEnv(inheritEnvIn);
     refuseBadRequireExistingSession(requireExistingSessionIn);
+    refuseBadDisableSkills(disableSkillsIn, 'buildTaskRequest');
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
@@ -721,6 +750,7 @@ export function assembleTaskRequest(input, lane) {
             '错误文本只报键名,不回显值。');
     }
     refuseRequireExistingWithoutSession(requireExistingSessionIn, i.sessionId);
+    refuseDisableSkillsConflict(disableSkillsIn, i.skills, Reflect.get(src, 'agents'), 'buildTaskRequest');
     refuseUtilityWithoutToolUnload(lane, excludeAllToolsIn);
     const carries = (route, value, key) => {
         if (route.via === 'always')
@@ -796,6 +826,7 @@ export function assembleTaskRequest(input, lane) {
         ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
         ...(on('inheritEnv') ? { inheritEnv: inheritEnvIn } : {}),
         ...(on('requireExistingSession') ? { requireExistingSession: true } : {}),
+        ...(on('disableSkills') ? { disableSkills: true } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });
@@ -819,6 +850,7 @@ export function applyLiveRequestDefaults(req, host) {
         out.retainSubagentSessions = true;
     if (out.agents === undefined && host.agents !== undefined)
         out.agents = host.agents;
+    refuseDisableSkillsConflict(out.disableSkills, out.skills, out.agents, 'applyLiveRequestDefaults');
     if (typeof out.scenario === 'string' && host.mockScenarioKeys?.has(out.scenario)) {
         delete out.scenario;
     }

package/dist/runTerminal.d.ts

@@ -11,6 +11,11 @@ export interface RunTerminalPausedRead extends RunTerminalPause {
     code?: string;
     flatStatus?: string;
 }
+export interface RunTerminalFailureDetail {
+    kind: string;
+    status?: number;
+    code?: string;
+}
 export type RunTerminalRead = {
     kind: 'completed';
     plane: RunTerminalPlane;
@@ -20,6 +25,7 @@ export type RunTerminalRead = {
     code?: string;
     message?: string;
     nestedPause?: RunTerminalPause;
+    detail?: RunTerminalFailureDetail;
 } | {
     kind: 'blocked';
     plane: RunTerminalPlane;