@sema-agent/client-core 0.108.0 → 0.109.0

package/dist/subagentContentStore.js

@@ -1,5 +1,6 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-import { readFrameTrueMark } from './ownKey.js';
+import { readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { cycleSeqValue } from './cycleOrder.js';
 import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     return toolEndOutputText(v);
@@ -398,7 +399,7 @@ function scheduleNotify(taskId) {
     }, NOTIFY_COALESCE_MS);
 }
 export function registerSubagentContentAlias(parentToolCallId, taskId) {
-    aliasContentKey(parentToolCallId, taskId);
+    applySubagentAlias(parentToolCallId, taskId, 'content');
 }
 function aliasContentKey(parentToolCallId, taskId) {
     if (!parentToolCallId || !taskId || parentToolCallId === taskId)
@@ -415,10 +416,72 @@ function aliasContentKey(parentToolCallId, taskId) {
     return true;
 }
 export function registerSubagentAlias(parentToolCallId, taskId) {
+    applySubagentAlias(parentToolCallId, taskId, 'full');
+}
+export const SUBAGENT_ALIAS_SCOPES = ['content', 'full'];
+export function applySubagentAlias(parentToolCallId, taskId, scope, seq) {
+    const hadContent = parentToTask.get(parentToolCallId) === taskId;
     if (!aliasContentKey(parentToolCallId, taskId))
-        return;
-    if (taskToParent.get(taskId)?.card !== parentToolCallId)
-        taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq });
+        return 'rejected';
+    let changed = !hadContent;
+    if (scope === 'full') {
+        const cycle = cycleSeqValue(seq);
+        const cur = taskToParent.get(taskId);
+        if (cur?.card !== parentToolCallId) {
+            const stale = cur !== undefined && cycle !== undefined && cur.seq !== undefined && cycle < cur.seq;
+            if (!stale) {
+                taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq, ...(cycle !== undefined ? { seq: cycle } : {}) });
+                changed = true;
+            }
+        }
+        else if (cycle !== undefined && (cur.seq === undefined || cycle > cur.seq)) {
+            taskToParent.set(taskId, { card: cur.card, stamp: cur.stamp, seq: cycle });
+        }
+    }
+    return changed ? 'new' : 'unchanged';
+}
+export function readSeatSubagentAlias(ev) {
+    try {
+        if (typeof ev !== 'object' || ev === null)
+            return undefined;
+        if (readOwnDataValue(ev, 'kind') !== 'subagent_alias')
+            return undefined;
+        const parentToolCallId = readOwnDataNonEmptyString(ev, 'parentToolCallId');
+        const taskId = readOwnDataNonEmptyString(ev, 'taskId');
+        const scope = readOwnDataNonEmptyString(ev, 'scope');
+        if (parentToolCallId === undefined || taskId === undefined || scope === undefined)
+            return undefined;
+        if (!SUBAGENT_ALIAS_SCOPES.includes(scope))
+            return undefined;
+        const proof = readOwnDataValue(ev, 'laneProof');
+        if (typeof proof !== 'object' || proof === null)
+            return undefined;
+        if (readOwnDataValue(proof, 'lane') !== 'subagent')
+            return undefined;
+        if (readOwnDataNonEmptyString(proof, 'parentToolCallId') !== parentToolCallId)
+            return undefined;
+        const seqDesc = Object.getOwnPropertyDescriptor(ev, 'seq');
+        let seq;
+        if (seqDesc !== undefined) {
+            if (!Object.hasOwn(seqDesc, 'value'))
+                return undefined;
+            if (seqDesc.value !== undefined) {
+                seq = cycleSeqValue(seqDesc.value);
+                if (seq === undefined)
+                    return undefined;
+            }
+        }
+        return { parentToolCallId, taskId, scope: scope, ...(seq !== undefined ? { seq } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function noteSeatSubagentAlias(ev) {
+    const alias = readSeatSubagentAlias(ev);
+    if (alias === undefined)
+        return 'ignored';
+    return applySubagentAlias(alias.parentToolCallId, alias.taskId, alias.scope, alias.seq) === 'new' ? 'registered' : 'ignored';
 }
 function replaySeen(s, ev) {
     const id = ev.eventId;
@@ -661,18 +724,16 @@ export function planSubagentViewSlots(taskId) {
 export function parentToolCallIdOf(taskId) {
     const ids = sameSubagentIds(taskId);
     let stated;
-    let statedStamp = -1;
     for (const id of ids) {
         const hit = taskToParent.get(id);
         if (hit === undefined)
             continue;
-        if (stated === undefined || hit.stamp > statedStamp) {
-            stated = hit.card;
-            statedStamp = hit.stamp;
-        }
+        const newer = hit.seq !== undefined && stated?.seq !== undefined && hit.seq !== stated.seq ? hit.seq > stated.seq : hit.stamp > (stated?.stamp ?? -1);
+        if (stated === undefined || newer)
+            stated = hit;
     }
     if (stated !== undefined)
-        return stated;
+        return stated.card;
     for (const id of ids) {
         const fromContent = tasks.get(id)?.parentToolCallId;
         if (fromContent !== undefined)

package/dist/toolResult.js

@@ -3,7 +3,7 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
-import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
+import { bashCurtailedResultPart, bashCurtailmentOf, bashCurtailmentSentence, bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
 import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf, } from './ownKey.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
@@ -370,6 +370,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
         let parsedMemo;
         const parseOnce = () => (parsedMemo === undefined ? (parsedMemo = parseModelFacingBash(text)) : parsedMemo);
         const exit = bashExitOf(structured, parseOnce);
+        const cut = bashCurtailmentOf(structured);
         const structuredSlots = sType === 'bash' && (typeof s?.stdout === 'string' || typeof s?.stderr === 'string');
         const textSlots = structuredSlots ? null : parseOnce();
         const slots = structuredSlots
@@ -392,26 +393,37 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
                 }
                 if (body.trim() === '' && text.trim() !== '')
                     body = text;
+                else if (cut !== undefined) {
+                    if (body.trim() === '')
+                        body = bashCurtailmentSentence(cut);
+                    else if (reason.trim() !== '')
+                        body = `${bashCurtailmentSentence(cut)}\n${body}`;
+                }
                 return { content: truncated ? `${body}\n…(truncated)` : body, isError: true };
             }
             const stdout = truncated ? `${slots.stdout}\n…(truncated)` : slots.stdout;
             const processedStdout = stdout.replace(/^(\s*\n)+/, '').trimEnd();
             return {
-                content: [processedStdout, slots.stderr.trim()].filter(Boolean).join('\n'),
+                content: [cut !== undefined ? bashCurtailmentSentence(cut) : '', processedStdout, slots.stderr.trim()].filter(Boolean).join('\n'),
                 isError: false,
                 toolUseResult: {
                     stdout,
-                    stderr: slots.stderr,
+                    ...bashCurtailedResultPart(slots.stderr, cut),
                     interrupted: false,
                     ...(benignInterp !== undefined ? { returnCodeInterpretation: benignInterp } : {}),
                 },
             };
         }
         const stdout = truncated ? `${text}\n…(truncated)` : text;
+        const cutSentence = cut !== undefined ? bashCurtailmentSentence(cut) : undefined;
         if (isError || bashExitReadingFailed(exit)) {
+            if (cutSentence !== undefined && text.trim() === '' && exit.exitCode !== 137) {
+                return { content: truncated ? `${cutSentence}\n…(truncated)` : cutSentence, isError: true };
+            }
             return { content: exit.exitCode === 137 ? `${stdout}\n${killedBySignalSentence(killCauseOf)}` : stdout, isError: true };
         }
-        return { content: stdout, isError, toolUseResult: { stdout, stderr: '', interrupted: false } };
+        const okContent = cutSentence === undefined ? stdout : text.trim() === '' ? (truncated ? `${cutSentence}\n…(truncated)` : cutSentence) : `${cutSentence}\n${stdout}`;
+        return { content: okContent, isError, toolUseResult: { stdout, ...bashCurtailedResultPart('', cut), interrupted: false } };
     }
     if (name === 'taskoutput' || name === 'task_output') {
         const body = truncated ? `${text}\n…(truncated)` : text;
@@ -498,10 +510,11 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                 return null;
             const exit = bashExitOf(structured, () => null);
             const benignInterp = exit.benignNote;
+            const cut = bashCurtailmentOf(structured);
             return {
                 toolUseResult: {
                     stdout: typeof s.stdout === 'string' ? s.stdout : '',
-                    stderr: typeof s.stderr === 'string' ? s.stderr : '',
+                    ...bashCurtailedResultPart(typeof s.stderr === 'string' ? s.stderr : '', cut),
                     interrupted: false,
                     ...(benignInterp !== undefined ? { returnCodeInterpretation: benignInterp } : {}),
                 },

package/dist/wireFailureShape.d.ts

@@ -69,6 +69,26 @@ export interface OwnSlotRead {
 }
 export declare function slotPresenceOf(o: object, key: string): SlotPresence;
 export declare function slotReadOf(o: object, key: string): OwnSlotRead;
+export type InSlotRead = {
+    readonly state: 'absent';
+} | {
+    readonly state: 'present';
+    readonly value: {} | null | undefined;
+} | {
+    readonly state: 'present_unreadable';
+} | {
+    readonly state: 'unproven';
+};
+export declare function inSlotReadOf(o: object, key: string): InSlotRead;
+export type InValueRead = {
+    readonly state: 'absent';
+} | {
+    readonly state: 'present';
+    readonly value: {} | null | undefined;
+} | {
+    readonly state: 'unproven';
+};
+export declare function inValueOf(o: object, key: string): InValueRead;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
 export declare function readErrorPresent(o: object, key: string): {} | null | undefined;

package/dist/wireFailureShape.js

@@ -181,31 +181,62 @@ export function readThrownStatusSlot(o, notePresence) {
         return undefined;
     return typeof raw === 'number' ? raw : THROWN_SLOT_UNREADABLE;
 }
-function readOwnSlot(o, key, withPresence) {
+function observeOwnSlot(o, key, withPresence) {
     let d;
     try {
         d = Object.getOwnPropertyDescriptor(o, key);
     }
     catch {
-        return { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+        return { kind: 'thrown' };
     }
     if (d !== undefined)
-        return Object.hasOwn(d, 'value') ? { value: d.value, presence: 'present' } : { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+        return Object.hasOwn(d, 'value') ? { kind: 'data', value: d.value } : { kind: 'accessor' };
     if (!withPresence)
-        return { value: undefined, presence: 'unreadable' };
+        return { kind: 'not-own', inChain: 'unasked' };
     try {
-        return { value: undefined, presence: key in o ? 'unreadable' : 'absent' };
+        return { kind: 'not-own', inChain: key in o ? 'inherited' : 'none' };
     }
     catch {
-        return { value: undefined, presence: 'unreadable' };
+        return { kind: 'not-own', inChain: 'in-thrown' };
     }
 }
+function readOwnSlot(o, key, withPresence) {
+    const ob = observeOwnSlot(o, key, withPresence);
+    if (ob.kind === 'data')
+        return { value: ob.value, presence: 'present' };
+    if (ob.kind === 'thrown' || ob.kind === 'accessor')
+        return { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+    return { value: undefined, presence: ob.inChain === 'none' ? 'absent' : 'unreadable' };
+}
 export function slotPresenceOf(o, key) {
     return slotReadOf(o, key).presence;
 }
 export function slotReadOf(o, key) {
     return readOwnSlot(o, key, true);
 }
+export function inSlotReadOf(o, key) {
+    const claimed = key in o;
+    const ob = observeOwnSlot(o, key, true);
+    if (ob.kind === 'thrown')
+        return { state: 'unproven' };
+    if (ob.kind === 'data' || ob.kind === 'accessor') {
+        if (!claimed)
+            return { state: 'unproven' };
+        return ob.kind === 'data' ? { state: 'present', value: ob.value } : { state: 'present_unreadable' };
+    }
+    if (ob.inChain === 'in-thrown' || ob.inChain === 'unasked')
+        return { state: 'unproven' };
+    const again = ob.inChain === 'inherited';
+    if (!claimed)
+        return again ? { state: 'unproven' } : { state: 'absent' };
+    return again ? { state: 'present_unreadable' } : { state: 'unproven' };
+}
+export function inValueOf(o, key) {
+    const s = inSlotReadOf(o, key);
+    if (s.state === 'present_unreadable')
+        return { state: 'present', value: o[key] };
+    return s;
+}
 function readErrorSlot(obj, key, accept) {
     try {
         const topRaw = readThrownSlot(obj, key, 'data');

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { CONFLICT_SESSION_ARCHIVE_STAMPED, CONFLICT_SESSION_ID_RETIRED, FLEET_LEASE_UNAVAILABLE, LIMIT_RATE_EXCEEDED, RATE_EXCEEDED_RUN_CONCURRENCY_CAP, REQUEST_ENV_CREDENTIAL_REFUSED, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
@@ -145,6 +145,26 @@ export interface SessionArchiveStampedDetail {
 export declare function sessionArchiveStampedFromError(err: {} | null | undefined): SessionArchiveStampedDetail | null;
 export type SessionArchiveStampedScenario = 'fork' | 'push';
 export declare function sessionArchiveStampedContent(lang?: UiLanguage, scenario?: SessionArchiveStampedScenario): string;
+export interface EnvCredentialRefusalDetail {
+    readonly code: typeof REQUEST_ENV_CREDENTIAL_REFUSED;
+    readonly names?: readonly string[];
+    readonly folded?: true;
+}
+export declare function envCredentialRefusalFromError(err: {} | null | undefined): EnvCredentialRefusalDetail | null;
+export declare function envCredentialRefusalContent(detail: Pick<EnvCredentialRefusalDetail, 'names' | 'folded'>, lang?: UiLanguage): string;
+export interface SessionIdRetiredDetail {
+    readonly code: typeof CONFLICT_SESSION_ID_RETIRED;
+    readonly folded?: true;
+}
+export declare function sessionIdRetiredFromError(err: {} | null | undefined): SessionIdRetiredDetail | null;
+export declare function sessionIdRetiredContent(detail: Pick<SessionIdRetiredDetail, 'folded'>, lang?: UiLanguage): string;
+export interface RunConcurrencyCapDetail {
+    readonly code: typeof LIMIT_RATE_EXCEEDED;
+    readonly reason: typeof RATE_EXCEEDED_RUN_CONCURRENCY_CAP;
+    readonly retryAfterSec?: number;
+}
+export declare function runConcurrencyCapFromError(err: {} | null | undefined): RunConcurrencyCapDetail | null;
+export declare function runConcurrencyCapContent(detail: Pick<RunConcurrencyCapDetail, 'retryAfterSec'>, lang?: UiLanguage): string;
 export interface UnsupportedRuleRefusalProblem {
     readonly code: string;
     readonly field?: string;

package/dist/wireRefusalCopy.js

@@ -1,7 +1,8 @@
-import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorPresent, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readRefusalSlots, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { appendOwnElement, guardedRead, readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, CONFLICT_SESSION_ID_RETIRED, FLEET_LEASE_UNAVAILABLE, LIMIT_RATE_EXCEEDED, RATE_EXCEEDED_RUN_CONCURRENCY_CAP, REQUEST_ENV_CREDENTIAL_REFUSED, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 import { SETTINGS_ECHO_CALLER_TEXT } from './generated/settingsSchemaFns.js';
@@ -815,6 +816,94 @@ export function sessionArchiveStampedFromError(err) {
 export function sessionArchiveStampedContent(lang, scenario) {
     return renderMessage(msg(scenario === 'fork' ? 'notice.wireRefusal.sessionArchiveStamped.fork' : 'notice.wireRefusal.sessionArchiveStamped'), lang);
 }
+const ENV_CREDENTIAL_NAME_SHOWN_MAX = 80;
+const ENV_CREDENTIAL_NAMES_SHOWN = 8;
+export function envCredentialRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== REQUEST_ENV_CREDENTIAL_REFUSED)
+            return null;
+        const names = guardedRead(() => envCredentialNamesOf(readErrorPresent(err, 'entries')));
+        return Object.freeze({
+            code: REQUEST_ENV_CREDENTIAL_REFUSED,
+            ...(names !== undefined ? { names } : {}),
+            ...(effective.folded ? { folded: true } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function envCredentialNamesOf(list) {
+    if (!Array.isArray(list))
+        return undefined;
+    const out = [];
+    const len = Math.min(list.length, REFUSAL_PROBLEMS_READ_MAX);
+    for (let i = 0; i < len; i++) {
+        const key = guardedRead(() => {
+            const item = readOwnDataValue(list, String(i));
+            if (typeof item !== 'object' || item === null)
+                return undefined;
+            const k = readOwnDataValue(item, 'key');
+            return typeof k === 'string' && k !== '' ? k : undefined;
+        });
+        if (key !== undefined && !out.includes(key))
+            appendOwnElement(out, key);
+    }
+    return out.length === 0 ? undefined : Object.freeze(out);
+}
+export function envCredentialRefusalContent(detail, lang) {
+    const head = renderMessage(msg(detail.folded === true ? 'notice.wireRefusal.envCredential.folded' : 'notice.wireRefusal.envCredential'), lang);
+    const quoted = (detail.names ?? []).slice(0, ENV_CREDENTIAL_NAMES_SHOWN).map((n) => quoteUntrustedForSentence(n, ENV_CREDENTIAL_NAME_SHOWN_MAX)).filter((q) => q !== undefined);
+    const more = (detail.names?.length ?? 0) > ENV_CREDENTIAL_NAMES_SHOWN ? ', …' : '';
+    const named = quoted.length > 0 ? ` · ${renderMessage(msg('notice.wireRefusal.envCredential.names', { names: quoted.join(', ') + more }), lang)}` : '';
+    return `${head}${named} · ${renderMessage(msg('notice.wireRefusal.envCredential.remedy'), lang)}`;
+}
+export function sessionIdRetiredFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== CONFLICT_SESSION_ID_RETIRED)
+            return null;
+        return Object.freeze({ code: CONFLICT_SESSION_ID_RETIRED, ...(effective.folded ? { folded: true } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function sessionIdRetiredContent(detail, lang) {
+    return renderMessage(msg(detail.folded === true ? 'notice.wireRefusal.sessionIdRetired.folded' : 'notice.wireRefusal.sessionIdRetired'), lang);
+}
+export function runConcurrencyCapFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        if (effectiveWireCodeReading(err).code !== LIMIT_RATE_EXCEEDED)
+            return null;
+        if (readRefusalSlots(err, ['reason']).reason.word !== RATE_EXCEEDED_RUN_CONCURRENCY_CAP)
+            return null;
+        const rawSec = readErrorNumber(err, 'retryAfterSec');
+        const sec = nonNegativeFinite(rawSec)
+            ? Math.ceil(rawSec)
+            : (() => {
+                const rawMs = readThrownSlot(err, 'retryAfterMs', 'data');
+                return nonNegativeFinite(rawMs) ? Math.ceil(rawMs / 1000) : undefined;
+            })();
+        return Object.freeze({ code: LIMIT_RATE_EXCEEDED, reason: RATE_EXCEEDED_RUN_CONCURRENCY_CAP, ...(sec !== undefined ? { retryAfterSec: sec } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function runConcurrencyCapContent(detail, lang) {
+    const head = renderMessage(msg('notice.wireRefusal.runConcurrencyCap.head'), lang);
+    return detail.retryAfterSec !== undefined
+        ? `${head} · ${renderMessage(msg('notice.wireRefusal.sendAgainAbout', { wait: humanWait(detail.retryAfterSec) }), lang)}`
+        : `${head} · ${renderMessage(msg('notice.wireRefusal.runConcurrencyCap.unknownWait'), lang)}`;
+}
 const REQUEST_UNPROCESSABLE = 'request.unprocessable';
 const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;
 const nonEmptyString = (v) => (typeof v === 'string' && v !== '' ? v : undefined);