@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/request/taskRequest.js

@@ -4,7 +4,7 @@ import { retiredAttachmentsKeyOf } from '../taskRequestWords.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { outputStyleSeatAdmitted } from '../outputStyleSeatCapability.js';
 import { refuseBadApprovalReach } from '../approvalReachWire.js';
-import { HOST_SUPPLIED_KEYS, HostSettingsRefused, buildHostTurnSettings, hostTurnSettingsOf, rethrowHostResolvedDeferred, } from '../hostTurnSettings.js';
+import { HOST_SUPPLIED_KEYS, HostSettingsRefused, UNWIRED_HOST_TURN_SETTINGS, buildHostTurnSettings, hostIntakeSnapshotOf, hostProjectionNotice, hostTurnSettingsOf, intersectHostHooks, rethrowHostResolvedDeferred, } from '../hostTurnSettings.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(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -168,8 +168,6 @@ const INPUT_KEY_ROUTES = {
         why: '思考 token 数上限:sdk `TaskRequest` 上思考强度只有档位词(`reasoningEffort` 七词闭集),没有 token 数这一位;把数字折成档位词 = 替用户编一个他没说过的档位',
     },
     memoryCapture: row('memoryCapture'),
-    memory: row('memory'),
-    fileHistory: row('fileHistory'),
     inheritEnv: row('inheritEnv'),
     requireExistingSession: row('requireExistingSession'),
     disableSkills: row('disableSkills'),
@@ -179,8 +177,16 @@ const INPUT_KEY_ROUTES = {
     hostSettings: { via: 'control' },
     settings: { via: 'settings' },
 };
+const HOST_TOP_KEY_ROUTES = {
+    memory: row('memory'),
+    fileHistory: row('fileHistory'),
+};
+const HOST_TOP_KEYS = Object.freeze(Object.keys(HOST_TOP_KEY_ROUTES));
+const _hostTopKeysPin = [true];
+void _hostTopKeysPin;
+const HOST_TOP_ASK_AFTER = 'memoryCapture';
 const HOST_SETTINGS_SUBKEYS = Object.freeze(HOST_SUPPLIED_KEYS.filter((k) => k.startsWith('settings.')).map((k) => k.slice('settings.'.length)));
-const _hostSubkeysPin = [true, true, true, true];
+const _hostSubkeysPin = [true, true, true];
 void _hostSubkeysPin;
 const SETTINGS_KEY_ROUTES = {
     resolved: row('settings.<resolved>'),
@@ -195,6 +201,8 @@ const liveDefaultKeyNames = () => new Set(LIVE_DEFAULT_FIELDS.flatMap(item => it
 const routeOfTopLevelKey = (key) => {
     if (hasOwn(INPUT_KEY_ROUTES, key))
         return INPUT_KEY_ROUTES[key];
+    if (hasOwn(HOST_TOP_KEY_ROUTES, key))
+        return HOST_TOP_KEY_ROUTES[key];
     if (!key.includes('.') && liveDefaultKeyNames().has(key))
         return { via: 'fixed', cause: 'other_channel' };
     return undefined;
@@ -221,15 +229,16 @@ const OMISSION_JUDGES = {
     not_live: (s, _lane, live) => s.via === 'matrix' && s.spec.live && !live,
 };
 const omissionCauseOf = (s, lane, live) => TASK_REQUEST_OMISSION_CAUSES.find(cause => OMISSION_JUDGES[cause](s, lane, live));
-const hostRefusalNoticeOf = (host, lane, live, verdictNotice) => {
+const hostRefusalNoticeOf = (intake, lane, live) => {
+    const verdictNotice = intake.notice ?? hostProjectionNotice();
     try {
-        const refusing = host.rows.filter((row) => row.disposition === 'refuse_turn');
+        const refusing = intake.refusingKeys;
         if (refusing.length === 0)
             return verdictNotice;
-        const turnNotices = host.notices.filter((n) => n.plane === 'turn');
-        const aligned = turnNotices.length === refusing.length;
-        for (const [i, row] of refusing.entries()) {
-            if (!hostRefuseRowSeated(row.key, lane, live))
+        const turnNotices = intake.turnNotices;
+        const aligned = turnNotices !== undefined && turnNotices.length === refusing.length;
+        for (const [i, key] of refusing.entries()) {
+            if (!hostRefuseRowSeated(key, lane, live))
                 continue;
             return aligned ? (turnNotices[i] ?? verdictNotice) : verdictNotice;
         }
@@ -240,6 +249,12 @@ const hostRefusalNoticeOf = (host, lane, live, verdictNotice) => {
     }
 };
 const hostRefuseRowSeated = (key, lane, live) => {
+    if (hasOwn(HOST_TOP_KEY_ROUTES, key)) {
+        const top = HOST_TOP_KEY_ROUTES[key];
+        return top === undefined || (top.via !== 'matrix' && top.via !== 'fixed') || omissionCauseOf(standingOf(top), lane, live) === undefined;
+    }
+    if (!key.startsWith('settings.'))
+        return true;
     const sub = key.slice('settings.'.length);
     if (!hasOwn(SETTINGS_KEY_ROUTES, sub))
         return true;
@@ -444,16 +459,49 @@ const resolvedSnapshotForWire = (resolved) => {
     return out;
 };
 export function hostTurnSettings(input) {
-    return buildHostTurnSettings(input, (snapshot) => resolvedSnapshotForWire(snapshot));
+    return buildHostTurnSettings(input, { materialize: (snapshot) => resolvedSnapshotForWire(snapshot), memoryOffDeclared });
+}
+export function refilterHostSettings(request, fresh, lane) {
+    refuseBadLane(lane);
+    const host = hostTurnSettingsOf(fresh);
+    const intake = host === undefined || host === UNWIRED_HOST_TURN_SETTINGS ? undefined : hostIntakeSnapshotOf(host);
+    if (host === undefined || intake === undefined) {
+        throw new TypeError(renderMessage(msg('config.taskRequest.hostSettingsMalformed', { shape: coarseShape(fresh) })));
+    }
+    const refuseNotice = () => intake.notice ?? hostProjectionNotice();
+    if (intake.refuses) {
+        const refusing = hostRefusalNoticeOf(intake, lane, true);
+        if (refusing !== undefined)
+            return Object.freeze({ kind: 'refuse', notice: refusing });
+    }
+    const settings = request.settings;
+    if (!isPlainRecord(settings) || !Object.hasOwn(settings, 'hooks'))
+        return Object.freeze({ kind: 'send', request, hooksDropped: 0 });
+    const disposition = intake.dispositions['settings.hooks'];
+    if (disposition === 'unwired')
+        return Object.freeze({ kind: 'send', request, hooksDropped: 0 });
+    const now = intake.carried.hooks;
+    const sentHooks = settings.hooks;
+    if (!isPlainRecord(sentHooks))
+        return Object.freeze({ kind: 'refuse', notice: refuseNotice() });
+    const cut = intersectHostHooks(sentHooks, now);
+    if (!cut.judged)
+        return Object.freeze({ kind: 'refuse', notice: refuseNotice() });
+    if (cut.dropped === 0)
+        return Object.freeze({ kind: 'send', request, hooksDropped: 0 });
+    const { hooks: _sentHooks, ...restSettings } = settings;
+    void _sentHooks;
+    const nextSettings = cut.hooks === undefined ? restSettings : { ...restSettings, hooks: cut.hooks };
+    const { settings: _sentSettings, ...restRequest } = request;
+    void _sentSettings;
+    const next = Object.keys(nextSettings).length > 0 ? { ...restRequest, settings: nextSettings } : restRequest;
+    return Object.freeze({ kind: 'send', request: next, hooksDropped: cut.dropped });
 }
 export const MEMORY_CAPTURE_OFF = 'off';
 export function memoryCaptureDeclarationField(declared) {
     return declared ? { memoryCapture: MEMORY_CAPTURE_OFF } : {};
 }
 export const MEMORY_OFF = 'off';
-export function memoryOffDeclarationField(declared) {
-    return declared ? { memory: MEMORY_OFF } : {};
-}
 export const FILE_HISTORY_DISABLED = 'disabled';
 export const INHERIT_ENV_WORDS = Object.freeze(['all', 'scrub']);
 export function isInheritEnvWord(v) {
@@ -481,16 +529,6 @@ export function memoryOffDeclared(input) {
     }
     return flag === MEMORY_OFF || fromSettings;
 }
-const refuseBadMemoryOff = (v) => {
-    if (v === undefined || v === null)
-        return;
-    if (v === 'off')
-        return;
-    throw new TypeError('buildTaskRequest: memory 只接受字面量 `\'off\'` 或缺席(undefined/null)—— ' +
-        `收到 ${coarseShape(v)}。这一位是**请求级整面开关**(「这一次别给我记忆」),上游是**单成员闭集**(没有 ` +
-        '`"on"`,`{ enabled: false }` 对象形也不是 wire 拼法)且对坏拼写**响亮拒**(server 400 `request.field_invalid`)。' +
-        '本层若静默删键,这一次运行会照常挂上记忆面而声明人不会知道 —— 与 memoryCapture 同一条纪律。错误文本只报形状,不回显值。');
-};
 const withoutRetiredAttachmentsKeys = (v) => {
     if (typeof v !== 'object' || v === null)
         return v;
@@ -598,15 +636,6 @@ const refuseBadExcludeAllTools = (v) => {
         `收到 ${coarseShape(v)}。这一位是**整只工具面卸载**的收紧声明:本层若把坏值静默删键,这一次运行会挂上声明人以为已经卸掉的全部工具。` +
         '错误文本只报形状,不回显值。');
 };
-const refuseBadFileHistory = (v) => {
-    if (v === undefined || v === null)
-        return;
-    if (v === FILE_HISTORY_DISABLED)
-        return;
-    throw new TypeError('buildTaskRequest: fileHistory 只接受字面量 `\'disabled\'` 或缺席(undefined/null)—— ' +
-        `收到 ${coarseShape(v)}。这一位是「这一次运行别捕获文件历史」的收紧声明,上游是**单成员闭集**(没有第二个词)且对坏值` +
-        '**响亮拒**。本层若静默删键,这一次运行照常捕获而声明人不会知道。错误文本只报形状,不回显值。');
-};
 const refuseBadInheritEnv = (v) => {
     if (v === undefined || v === null)
         return;
@@ -704,7 +733,7 @@ export function parseMaxCostUsd(text) {
         return { ok: false, why: 'not_positive' };
     return { ok: true, value };
 }
-const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'hostSettings', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv', 'requireExistingSession', 'disableSkills', 'approvalReach', 'allowTools', 'userInvokedSkills'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'hostSettings', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'inheritEnv', 'requireExistingSession', 'disableSkills', 'approvalReach', 'allowTools', 'userInvokedSkills'];
 const MATERIALIZE_AT_READ = Object.freeze({ allowTools: (v) => allowToolsSnapshot(v), userInvokedSkills: (v) => allowToolsSnapshot(v) });
 function dataFirstSnapshot(input, afterData) {
     let descs;
@@ -742,25 +771,28 @@ export function assembleTaskRequest(input, lane) {
     let resolvedMaterialized;
     let resolvedMaterializeError;
     let resolvedHookRan = false;
+    let intakeEarly;
+    const materializeAtRead = (product) => (raw) => {
+        resolvedInEarly = raw;
+        try {
+            rethrowHostResolvedDeferred(product);
+            resolvedMaterialized = resolvedSnapshotForWire(resolvedInEarly);
+        }
+        catch (e) {
+            resolvedMaterializeError = e;
+        }
+    };
     const src = dataFirstSnapshot(input, (bag) => {
         if (!Object.hasOwn(bag, 'hostSettings'))
             return;
         const product = hostTurnSettingsOf(bag['hostSettings'], 'shape');
         if (product !== undefined) {
             resolvedHookRan = true;
-            resolvedInEarly = product.carried.resolved;
-            try {
-                rethrowHostResolvedDeferred(product);
-                resolvedMaterialized = resolvedSnapshotForWire(resolvedInEarly);
-            }
-            catch (e) {
-                resolvedMaterializeError = e;
-            }
+            intakeEarly = hostIntakeSnapshotOf(product, materializeAtRead(product));
         }
     });
     const live = src.live;
     const memoryCaptureIn = src.memoryCapture;
-    const memoryIn = src.memory;
     const settingsIn = src.settings;
     if (present(settingsIn) && (typeof settingsIn !== 'object' || Array.isArray(settingsIn))) {
         throw new TypeError(`buildTaskRequest: settings 只接受对象或缺席(undefined/null)—— 收到 ${coarseShape(settingsIn)}。` +
@@ -772,19 +804,19 @@ export function assembleTaskRequest(input, lane) {
     if (host === undefined) {
         throw new TypeError(renderMessage(msg('config.taskRequest.hostSettingsMalformed', { shape: coarseShape(hostIn) })));
     }
-    const resolvedIn = resolvedHookRan ? resolvedInEarly : host.carried.resolved;
+    const intake = resolvedHookRan ? intakeEarly : hostIntakeSnapshotOf(host, materializeAtRead(host));
+    if (intake === undefined)
+        throw new TypeError(renderMessage(msg('config.taskRequest.hostSettingsMalformed', { shape: coarseShape(hostIn) })));
+    const resolvedIn = resolvedInEarly;
     const resolvedRoute = SETTINGS_KEY_ROUTES.resolved;
     const resolvedOpen = resolvedRoute.via === 'matrix' && omissionCauseOf(standingOf(resolvedRoute), lane, live) === undefined;
-    if (resolvedOpen && resolvedHookRan && resolvedMaterializeError !== undefined)
+    if (resolvedOpen && resolvedMaterializeError !== undefined)
         throw resolvedMaterializeError;
-    if (resolvedOpen && !resolvedHookRan)
-        rethrowHostResolvedDeferred(host);
     const resolvedWire = resolvedOpen ? (resolvedMaterialized ?? resolvedSnapshotForWire(resolvedIn)) : {};
     const maxCostUsdIn = src.maxCostUsd;
     const excludeAllToolsIn = src.excludeAllTools;
     const maxTokensIn = src.maxTokens;
     const outputRetriesIn = src.outputRetries;
-    const fileHistoryIn = src.fileHistory;
     const inheritEnvIn = src.inheritEnv;
     const requireExistingSessionIn = src.requireExistingSession;
     const disableSkillsIn = src.disableSkills;
@@ -794,12 +826,10 @@ export function assembleTaskRequest(input, lane) {
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
         memoryCapture: memoryCaptureIn,
-        memory: memoryIn,
         maxCostUsd: maxCostUsdIn,
         maxTokens: maxTokensIn,
         excludeAllTools: excludeAllToolsIn,
         outputRetries: outputRetriesIn,
-        fileHistory: fileHistoryIn,
         inheritEnv: inheritEnvIn,
         requireExistingSession: requireExistingSessionIn,
         disableSkills: disableSkillsIn,
@@ -809,20 +839,19 @@ export function assembleTaskRequest(input, lane) {
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
     const hostSettingsKeysIn = HOST_SETTINGS_SUBKEYS.filter((k) => hasOwn(settingsObj, k) && present(Reflect.get(settingsObj, k)));
+    const hostTopKeysIn = HOST_TOP_KEYS.filter((k) => hasOwn(src, k) && present(Reflect.get(src, k)));
     const s = {
         resolved: resolvedIn,
-        webSearch: host.carried.webSearch,
+        webSearch: intake.carried.webSearch,
         ultracode: snapshotByName(settingsObj, ['ultracode']).ultracode,
-        hooks: host.carried.hooks,
-        outputStyle: host.carried.outputStyle,
+        hooks: intake.carried.hooks,
+        outputStyle: intake.carried.outputStyle,
     };
     refuseBadMemoryCapture(memoryCaptureIn);
-    refuseBadMemoryOff(memoryIn);
     refuseBadMaxCostUsd(maxCostUsdIn);
     refuseBadExcludeAllTools(excludeAllToolsIn);
     refuseBadMaxTokens(maxTokensIn);
     refuseBadOutputRetries(outputRetriesIn);
-    refuseBadFileHistory(fileHistoryIn);
     refuseBadInheritEnv(inheritEnvIn);
     refuseBadRequireExistingSession(requireExistingSessionIn);
     refuseBadDisableSkills(disableSkillsIn, 'buildTaskRequest');
@@ -856,6 +885,8 @@ export function assembleTaskRequest(input, lane) {
     for (const key of Object.keys(src)) {
         if (hasOwn(INPUT_KEY_ROUTES, key))
             continue;
+        if (hasOwn(HOST_TOP_KEY_ROUTES, key))
+            continue;
         const stray = Reflect.get(src, key);
         if (!present(stray))
             continue;
@@ -895,10 +926,10 @@ export function assembleTaskRequest(input, lane) {
             '处置:删掉这个键;要在回退会话时一并还原文件,改交 ' +
             'rewind.restoreFiles: true(必须与 rewind.resumeAt 同交);只还原文件、不动会话,交 rewind.rewindFilesTo。错误文本只报键名,不回显值。');
     }
-    if (hostSettingsKeysIn.length > 0) {
+    if (hostSettingsKeysIn.length > 0 || hostTopKeysIn.length > 0) {
         throw new TypeError(renderMessage(msg('config.taskRequest.hostSuppliedKeysByHand', {
-            keys: hostSettingsKeysIn.map((k) => `settings.${k}`).join(', '),
-            fields: hostSettingsKeysIn.map((k) => `${k}: …`).join(', '),
+            keys: [...hostSettingsKeysIn.map((k) => `settings.${k}`), ...hostTopKeysIn].join(', '),
+            fields: [...hostSettingsKeysIn, ...hostTopKeysIn].map((k) => `${k}: …`).join(', '),
         })));
     }
     if (unknownKeys.length > 0) {
@@ -914,8 +945,8 @@ export function assembleTaskRequest(input, lane) {
     refuseRequireExistingWithoutSession(requireExistingSessionIn, i.sessionId);
     refuseDisableSkillsConflict(disableSkillsIn, i.skills, Reflect.get(src, 'agents'), 'buildTaskRequest');
     refuseUtilityWithoutToolUnload(lane, excludeAllToolsIn);
-    if (host.verdict.kind === 'refuse') {
-        const refusing = hostRefusalNoticeOf(host, lane, live, host.verdict.notice);
+    if (intake.refuses) {
+        const refusing = hostRefusalNoticeOf(intake, lane, live);
         if (refusing !== undefined)
             throw new HostSettingsRefused(refusing);
     }
@@ -933,15 +964,25 @@ export function assembleTaskRequest(input, lane) {
         return false;
     };
     const gate = Object.create(null);
-    for (const key of INPUT_KEYS) {
+    const askInput = (key) => {
         const route = INPUT_KEY_ROUTES[key];
         if (route.via === 'settings') {
             for (const sub of SETTINGS_KEYS)
                 gate[`settings.${sub}`] = carries(SETTINGS_KEY_ROUTES[sub], s[sub], `settings.${sub}`);
-            continue;
+            return;
         }
         gate[key] = carries(route, key === 'rewind' ? rewindForGate : i[key], key);
-    }
+    };
+    const anchorAt = INPUT_KEYS.indexOf(HOST_TOP_ASK_AFTER);
+    const hostTopAt = anchorAt < 0 ? INPUT_KEYS.length : anchorAt + 1;
+    for (const key of INPUT_KEYS.slice(0, hostTopAt))
+        askInput(key);
+    const hostTopGate = {
+        memory: carries(HOST_TOP_KEY_ROUTES.memory, intake.carried.memory, 'memory'),
+        fileHistory: carries(HOST_TOP_KEY_ROUTES.fileHistory, intake.carried.fileHistory, 'fileHistory'),
+    };
+    for (const key of INPUT_KEYS.slice(hostTopAt))
+        askInput(key);
     const on = (key) => gate[key] === true;
     const onSetting = (sub) => gate[`settings.${sub}`] === true;
     const settingsOut = {
@@ -989,8 +1030,8 @@ export function assembleTaskRequest(input, lane) {
         ...(on('maxCostUsd') ? { maxCostUsd: maxCostUsdIn } : {}),
         ...(on('maxTokens') ? { maxTokens: i.maxTokens } : {}),
         ...(on('memoryCapture') ? { memoryCapture: 'off' } : {}),
-        ...(on('memory') ? { memory: 'off' } : {}),
-        ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
+        ...(hostTopGate.memory ? { memory: 'off' } : {}),
+        ...(hostTopGate.fileHistory ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
         ...(on('inheritEnv') ? { inheritEnv: inheritEnvIn } : {}),
         ...(on('requireExistingSession') ? { requireExistingSession: true } : {}),
         ...(on('disableSkills') ? { disableSkills: true } : {}),

package/dist/resumeRefusalCopy.d.ts

@@ -48,7 +48,7 @@ export interface ParkedResumeStartupDetail {
     denyStaysOpen: true;
 }
 declare const RESUME_CAUSE_CORE_AHEAD: readonly ["transcript_corrupt"];
-type ResumeCauseCoreAhead = (typeof RESUME_CAUSE_CORE_AHEAD)[number];
+type ResumeCauseCoreAhead = Exclude<(typeof RESUME_CAUSE_CORE_AHEAD)[number], ResumeStartupCause>;
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail, lang?: UiLanguage): string;
 export interface CheckpointUnsupportedVersionDetail {
@@ -69,6 +69,8 @@ export interface RefusedParkFacts {
     readonly code: RefusedParkCode;
     readonly field?: string;
     readonly stillPending?: boolean;
+    readonly blockedBy?: string;
+    readonly reason?: string;
 }
 export declare function refusedParkFromError(failure: unknown): RefusedParkFacts | null;
 export interface RefusedParkContentInput {

package/dist/resumeRefusalCopy.js

@@ -238,6 +238,7 @@ export function checkpointUnsupportedVersionContent(detail, ctx, lang) {
     return renderMessage(msg('resume.refusal.checkpoint.content', { outlet }), lang);
 }
 const REFUSED_PARK_FIELD_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+const REFUSED_PARK_CODE_TOKEN = /^(?=.{1,128}$)[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*$/;
 export function refusedParkFromError(failure) {
     if (typeof failure !== 'object' || failure === null)
         return null;
@@ -258,10 +259,22 @@ export function refusedParkFromError(failure) {
     const stillPending = reading === true ? true : status === 409 && reading === false ? false : undefined;
     const rawField = code === CHECKPOINT_CONFIG_REFUSED ? readErrorString(failure, 'field') : undefined;
     const field = rawField !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawField) ? rawField : undefined;
+    let blockedBy;
+    try {
+        const b = readBlockedBy(failure);
+        blockedBy = b.kind === 'named' && REFUSED_PARK_CODE_TOKEN.test(b.code) ? b.code : undefined;
+    }
+    catch {
+        blockedBy = undefined;
+    }
+    const rawReason = readErrorString(failure, 'reason');
+    const reason = rawReason !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawReason) ? rawReason : undefined;
     return Object.freeze({
         code,
         ...(field !== undefined ? { field } : {}),
         ...(stillPending !== undefined ? { stillPending } : {}),
+        ...(blockedBy !== undefined ? { blockedBy } : {}),
+        ...(reason !== undefined ? { reason } : {}),
     });
 }
 function refusedParkShownRunId(runId) {
@@ -272,6 +285,8 @@ function refusedParkWhy(code, field) {
         case CHECKPOINT_WALLTIME_AXIS_RETIRED:
             return msg('resume.refusal.park.whyWalltime');
         case CHECKPOINT_CONFIG_REFUSED:
+            if (field === 'deps')
+                return msg('resume.refusal.park.whyDeps');
             return msg(field === 'inheritedGate' ? 'resume.refusal.park.whyInheritedGate' : 'resume.refusal.park.whyConfigRefused');
         default:
             return msg('resume.refusal.park.whyUnsupported');
@@ -284,6 +299,7 @@ export function refusedParkContent(input, lang) {
     let rawCode;
     let field;
     let stillPending;
+    let blockedBy;
     try {
         what = input.what;
         lane = input.lane;
@@ -297,21 +313,23 @@ export function refusedParkContent(input, lang) {
         rawCode = facts.code;
         field = facts.field;
         stillPending = facts.stillPending;
+        blockedBy = facts.blockedBy;
     }
     catch {
-        rawCode = field = stillPending = undefined;
+        rawCode = field = stillPending = blockedBy = undefined;
     }
     const code = rawCode === CHECKPOINT_WALLTIME_AXIS_RETIRED || rawCode === CHECKPOINT_CONFIG_REFUSED ? rawCode : CHECKPOINT_UNSUPPORTED_VERSION;
     const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : msg('resume.refusal.park.whatDefault');
     const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined);
     const shownRun = refusedParkShownRunId(runId);
     const head = msg('resume.refusal.park.head', { what: shownWhat, why });
-    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg('resume.refusal.park.configMayReturn') : '';
+    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg(field === 'deps' ? 'resume.refusal.park.depsMayReturn' : 'resume.refusal.park.configMayReturn') : '';
     if (lane === 'print') {
+        const blocked = typeof blockedBy === 'string' && REFUSED_PARK_CODE_TOKEN.test(blockedBy) ? msg('resume.refusal.park.blockedByTail', { blockedBy }) : '';
         if (stillPending === false)
-            return renderMessage(msg('resume.refusal.park.printEnded', { head, code }), lang);
+            return renderMessage(msg('resume.refusal.park.printEnded', { head, code, blocked }), lang);
         const cancel = `POST /v1/runs/${shownRun ?? '<run id>'}/cancel`;
-        return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel }), lang);
+        return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel, blocked }), lang);
     }
     if (stillPending === false)
         return renderMessage(msg('resume.refusal.park.interactiveEnded', { head }), lang);

package/dist/retryStatus.d.ts

@@ -93,6 +93,24 @@ export interface RetryStatusNotice {
     readonly recourse?: 'switch_model' | 'wait' | 'fix_request';
     readonly phase: 'retrying' | 'reconnecting' | 'waiting_first_token' | 'gave_up' | 'cleared';
 }
+export interface RetryStatusParts {
+    readonly phase: RetryStatusNotice['phase'];
+    readonly model?: string;
+    readonly condition?: string;
+    readonly resendNote?: string;
+    readonly httpStatus?: number;
+    readonly source?: string;
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
+    readonly elapsedMs?: number;
+    readonly timeoutMs?: number;
+    readonly retryAtMs?: number;
+    readonly detail?: string;
+    readonly recourse?: RetryStatusNotice['recourse'];
+}
+export declare function retryStatusParts(status: RetryStatus | null, ctx?: {
+    readonly modelName?: string;
+}): RetryStatusParts;
 export declare function retryStatusNotice(status: RetryStatus | null, ctx?: {
     readonly modelName?: string;
 }): RetryStatusNotice;

package/dist/retryStatus.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const BRAIN_STATUS_PHASES = [
     'rate_limited',
     'retrying',
@@ -172,11 +173,38 @@ function noticeAttemptTail(attempt, maxRetries) {
 function sealNotice(line, phase, recourse) {
     return Object.freeze(recourse === undefined ? { line, phase } : { line, recourse, phase });
 }
-export function retryStatusNotice(status, ctx) {
+const SOURCE_PHRASES = Object.freeze({
+    unified_header: 'notice.retry.source.unifiedHeader',
+    provider_code: 'notice.retry.source.providerCode',
+    status: 'notice.retry.source.status',
+});
+function sourcePhraseOf(word) {
+    if (word === undefined || !Object.hasOwn(SOURCE_PHRASES, word))
+        return undefined;
+    return renderMessage(msg(SOURCE_PHRASES[word]));
+}
+function sealParts(p) {
+    return Object.freeze({
+        phase: p.phase,
+        ...(p.model !== undefined ? { model: p.model } : {}),
+        ...(p.condition !== undefined ? { condition: p.condition } : {}),
+        ...(p.resendNote !== undefined ? { resendNote: p.resendNote } : {}),
+        ...(p.httpStatus !== undefined ? { httpStatus: p.httpStatus } : {}),
+        ...(p.source !== undefined ? { source: p.source } : {}),
+        ...(p.attempt !== undefined ? { attempt: p.attempt } : {}),
+        ...(p.maxAttempts !== undefined ? { maxAttempts: p.maxAttempts } : {}),
+        ...(p.elapsedMs !== undefined ? { elapsedMs: p.elapsedMs } : {}),
+        ...(p.timeoutMs !== undefined ? { timeoutMs: p.timeoutMs } : {}),
+        ...(p.retryAtMs !== undefined ? { retryAtMs: p.retryAtMs } : {}),
+        ...(p.detail !== undefined ? { detail: p.detail } : {}),
+        ...(p.recourse !== undefined ? { recourse: p.recourse } : {}),
+    });
+}
+export function retryStatusParts(status, ctx) {
     const modelName = washedText(noticeText(ctx, 'modelName'))?.trim();
-    const prefix = modelName === undefined || modelName === '' ? '' : `${modelName}: `;
+    const model = modelName === undefined || modelName === '' ? undefined : modelName;
     if (status === null)
-        return sealNotice('', 'cleared', undefined);
+        return sealParts({ phase: 'cleared' });
     const armWord = noticeText(status, 'kind');
     const kind = armWord === 'stalled' || armWord === 'waiting' ? armWord : 'error';
     if (kind === 'waiting') {
@@ -184,10 +212,8 @@ export function retryStatusNotice(status, ctx) {
         const timeoutRaw = noticeNumber(status, 'timeoutMs');
         const elapsed = elapsedRaw !== undefined && elapsedRaw >= 0 && elapsedRaw <= Number.MAX_SAFE_INTEGER ? elapsedRaw : undefined;
         const ceiling = timeoutRaw !== undefined && timeoutRaw > 0 && timeoutRaw <= Number.MAX_SAFE_INTEGER ? timeoutRaw : undefined;
-        const progress = [...(elapsed === undefined ? [] : [`${spanText(elapsed)} so far`]), ...(ceiling === undefined ? [] : [`limit ${spanText(ceiling)}`])];
-        const offerSwitch = prefix !== '' && elapsed !== undefined && ceiling !== undefined && elapsed >= ceiling * WAIT_SWITCH_FRACTION;
-        const text = `${prefix}Waiting for the model's first token${progress.length === 0 ? '' : ` — ${progress.join(', ')}`}${offerSwitch ? '; keep waiting or switch model' : ''}`;
-        return sealNotice(text, 'waiting_first_token', offerSwitch ? 'switch_model' : 'wait');
+        const offerSwitch = model !== undefined && elapsed !== undefined && ceiling !== undefined && elapsed >= ceiling * WAIT_SWITCH_FRACTION;
+        return sealParts({ phase: 'waiting_first_token', model, elapsedMs: elapsed, timeoutMs: ceiling, recourse: offerSwitch ? 'switch_model' : 'wait' });
     }
     const terminal = kind === 'error' && noticeValue(status, 'terminal') === true;
     const reading = conditionReadingOf(noticeText(status, 'providerCondition'));
@@ -195,18 +221,9 @@ export function retryStatusNotice(status, ctx) {
     const attempt = noticeCount(noticeNumber(status, 'attempt'));
     const maxRetries = noticeCount(noticeNumber(status, 'maxRetries'));
     const engineWords = kind === 'stalled' ? noticeText(status, 'detail') : noticeText(noticeValue(status, 'error'), 'formatted');
-    const httpPart = http === undefined ? '' : ` (HTTP ${http})`;
-    let first;
-    if (terminal) {
-        const after = attempt === undefined ? '' : ` after ${attempt} attempt${attempt === 1 ? '' : 's'}`;
-        const why = reading === undefined ? '' : `: ${reading.clause}${reading.resendNote === undefined ? '' : `, and ${reading.resendNote}`}`;
-        first = `Stopped${after}${why}${httpPart}`;
-    }
-    else {
-        const head = reading !== undefined ? `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}` : http !== undefined || kind === 'error' ? 'Request failed' : 'Waiting for the API response';
-        first = `${head}${httpPart} — ${kind === 'stalled' ? 'will retry' : 'retrying'}${noticeAttemptTail(attempt, maxRetries)}`;
-    }
     const note = washedText(engineWords);
+    const source = reading === undefined ? undefined : sourcePhraseOf(noticeText(status, 'providerConditionSource'));
+    const condition = reading === undefined ? undefined : `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}`;
     const serviceSide = http !== undefined && (http === 429 || (http >= 500 && http <= 599));
     const knownArm = armWord === 'stalled' || armWord === 'error';
     const recourse = !knownArm
@@ -218,7 +235,47 @@ export function retryStatusNotice(status, ctx) {
                 : !terminal
                     ? 'wait'
                     : undefined;
-    return sealNotice(`${prefix}${first}${note === undefined ? '' : ` · ${note}`}`, kind === 'stalled' ? 'reconnecting' : terminal ? 'gave_up' : 'retrying', recourse);
+    const deadlineRaw = knownArm && !terminal && noticeNumber(status, 'retryAtMs') !== undefined ? noticeNumber(status, 'deadline') : undefined;
+    const retryAtMs = deadlineRaw !== undefined && deadlineRaw > 0 ? deadlineRaw : undefined;
+    return sealParts({
+        phase: kind === 'stalled' ? 'reconnecting' : terminal ? 'gave_up' : 'retrying',
+        model,
+        condition,
+        resendNote: terminal ? reading?.resendNote : undefined,
+        httpStatus: http,
+        source,
+        attempt,
+        maxAttempts: maxRetries,
+        retryAtMs,
+        detail: note,
+        recourse,
+    });
+}
+function retryLineOfParts(parts) {
+    if (parts.phase === 'cleared')
+        return '';
+    const prefix = parts.model === undefined ? '' : `${parts.model}: `;
+    if (parts.phase === 'waiting_first_token') {
+        const progress = [...(parts.elapsedMs === undefined ? [] : [`${spanText(parts.elapsedMs)} so far`]), ...(parts.timeoutMs === undefined ? [] : [`limit ${spanText(parts.timeoutMs)}`])];
+        const offerSwitch = parts.recourse === 'switch_model';
+        return `${prefix}Waiting for the model's first token${progress.length === 0 ? '' : ` — ${progress.join(', ')}`}${offerSwitch ? '; keep waiting or switch model' : ''}`;
+    }
+    const httpPart = parts.httpStatus === undefined ? '' : ` (HTTP ${parts.httpStatus})`;
+    let first;
+    if (parts.phase === 'gave_up') {
+        const after = parts.attempt === undefined ? '' : ` after ${parts.attempt} attempt${parts.attempt === 1 ? '' : 's'}`;
+        const why = parts.condition === undefined ? '' : `: ${parts.condition.charAt(0).toLowerCase()}${parts.condition.slice(1)}${parts.resendNote === undefined ? '' : `, and ${parts.resendNote}`}`;
+        first = `Stopped${after}${why}${httpPart}`;
+    }
+    else {
+        const head = parts.condition !== undefined ? parts.condition : parts.httpStatus !== undefined || parts.phase === 'retrying' ? 'Request failed' : 'Waiting for the API response';
+        first = `${head}${httpPart} — ${parts.phase === 'reconnecting' ? 'will retry' : 'retrying'}${noticeAttemptTail(parts.attempt, parts.maxAttempts)}`;
+    }
+    return `${prefix}${first}${parts.detail === undefined ? '' : ` · ${parts.detail}`}`;
+}
+export function retryStatusNotice(status, ctx) {
+    const parts = retryStatusParts(status, ctx);
+    return sealNotice(retryLineOfParts(parts), parts.phase, parts.recourse);
 }
 const API_ERROR_PROVIDER_TEXT_MAX = 200;
 function isRecordObject(v) {

package/dist/ruleRefusalSentence.d.ts

@@ -0,0 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import type { PermissionsKeptRule } from './permissionsDeclaration.js';
+export type RuleRefusalRow = Pick<PermissionsKeptRule, 'rule' | 'reason' | 'code' | 'message'>;
+export declare function ruleRefusalSentence(rows: readonly RuleRefusalRow[], lang?: UiLanguage): string | undefined;