@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/settingsHooksSalvage.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement } from './ownKey.js';
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
 const _tuplePins = [true, true, true, true, true, true];
 void _tuplePins;
@@ -110,6 +111,59 @@ export function salvageSettingsHooksEntries(doc) {
         rejections: Object.freeze([]),
     });
 }
+const READER_GROUP_WIRE_KEYS = ['source'];
+const READER_COMMAND_WIRE_KEYS = ['plugin', 'args'];
+function unreadOf(raw, carried, wireKeys, notRead) {
+    const out = [];
+    for (const k of Object.keys(raw)) {
+        if (own(raw, k) === undefined || wireKeys.includes(k))
+            continue;
+        if (Object.hasOwn(carried, k) && !notRead.includes(k))
+            continue;
+        appendOwnElement(out, k);
+    }
+    return Object.freeze(out);
+}
+function carriedGroupOf(event, group) {
+    const r = SETTINGS_CLASSIFY_HOOKS_CONFIG({ hooks: { [event]: [group] } });
+    if (r.outcome !== 'loaded' || !isRecord(r.hooks))
+        return undefined;
+    const groups = own(r.hooks, event);
+    const g = Array.isArray(groups) ? groups[0] : undefined;
+    return isRecord(g) ? g : undefined;
+}
+export function hooksGroupUnreadKeys(event, group) {
+    const raw = group;
+    const carried = carriedGroupOf(event, { ...raw, hooks: [] });
+    return carried === undefined ? undefined : unreadOf(raw, carried, READER_GROUP_WIRE_KEYS, []);
+}
+export function hooksGroupAuthoredSource(group) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(group, READER_GROUP_WIRE_KEYS[0]);
+        if (d === undefined)
+            return 'absent';
+        if (!Object.hasOwn(d, 'value'))
+            return 'unreadable';
+        if (d.value !== undefined)
+            return 'present';
+        return Reflect.get(group, READER_GROUP_WIRE_KEYS[0]) === undefined ? 'absent' : 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function hooksEntryUnreadKeys(event, entry, notRead) {
+    const raw = entry;
+    const g = carriedGroupOf(event, { hooks: [raw] });
+    const entries = g === undefined ? undefined : own(g, 'hooks');
+    const carried = Array.isArray(entries) ? entries[0] : undefined;
+    if (!isRecord(carried))
+        return undefined;
+    return unreadOf(raw, carried, own(carried, 'type') === 'command' ? READER_COMMAND_WIRE_KEYS : [], notRead);
+}
+export function hooksKeyCoordinateText(path) {
+    return `settings.${path.map(labelOf).join('.')}`;
+}
 export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
     policySettings: 'Managed settings',
     userSettings: 'User settings',

package/dist/subagentContentStore.d.ts

@@ -49,6 +49,18 @@ export declare function __resetSubagentContentStoreConfigForTests(): void;
 export declare function bindSubagentIdentityReader(fn: (id: string) => readonly string[] | undefined): void;
 export declare function registerSubagentContentAlias(parentToolCallId: string, taskId: string): void;
 export declare function registerSubagentAlias(parentToolCallId: string, taskId: string): void;
+export declare const SUBAGENT_ALIAS_SCOPES: readonly ["content", "full"];
+export type SubagentAliasScope = (typeof SUBAGENT_ALIAS_SCOPES)[number];
+export type SubagentAliasOutcome = 'new' | 'unchanged' | 'rejected';
+export declare function applySubagentAlias(parentToolCallId: string, taskId: string, scope: SubagentAliasScope, seq?: number): SubagentAliasOutcome;
+export interface SeatSubagentAlias {
+    readonly parentToolCallId: string;
+    readonly taskId: string;
+    readonly scope: SubagentAliasScope;
+    readonly seq?: number;
+}
+export declare function readSeatSubagentAlias(ev: object | null | undefined): SeatSubagentAlias | undefined;
+export declare function noteSeatSubagentAlias(ev: object | null | undefined): 'registered' | 'ignored';
 export declare function publishSubagentContentEvent(ev: SubagentContentEvent): void;
 export declare function pushSubagentLocalEcho(taskId: string, text: string): void;
 export interface SubagentContentSnapshot {

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)
@@ -812,7 +873,7 @@ export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId,
     if (typeof ev !== 'object' || ev === null)
         return;
     const o = ev;
-    if (o.type !== 'task_progress')
+    if (o.type !== 'task_progress' && o.type !== 'task_started')
         return;
     if (typeof o.taskId !== 'string' || o.taskId === '')
         return;

package/dist/supportFloor.js

@@ -40,6 +40,8 @@ function judgeAgainst(version, base, floor, caller) {
     const got = releaseTriple(version);
     if (got === undefined)
         return { need: need.text, tier: 'unknown' };
+    if (got[0] === 0)
+        return { need: need.text, tier: 'unknown' };
     return { need: need.text, tier: compareTriple(got, need.triple) >= 0 ? 'engine' : 'legacy' };
 }
 export function engineVersionTier(version, floor) {

package/dist/taskNotificationAdmission.d.ts

@@ -0,0 +1,19 @@
+import type { RunRecord } from '@sema-agent/sdk';
+export type TaskNotificationAdmissionVerdict = 'admitted' | 'pending' | 'not_found' | 'unreadable';
+export type TaskNotificationAdmissionWhy = 'admitted_at' | 'turns_positive' | 'zero_turns' | 'no_turn_count' | 'key_unbound' | 'read_error' | 'record_malformed' | 'input_unrecognized';
+export type TaskNotificationRunRecordView = RunRecord & {
+    readonly admittedAt?: string | null;
+};
+export type TaskNotificationReadResult = {
+    readonly kind: 'record';
+    readonly record: TaskNotificationRunRecordView;
+} | {
+    readonly kind: 'not_found';
+} | {
+    readonly kind: 'error';
+};
+export interface TaskNotificationAdmission {
+    readonly verdict: TaskNotificationAdmissionVerdict;
+    readonly why: TaskNotificationAdmissionWhy;
+}
+export declare function taskNotificationAdmissionOf(readResult: TaskNotificationReadResult): TaskNotificationAdmission;

package/dist/taskNotificationAdmission.js

@@ -0,0 +1,84 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+function verdictOfWhy(why) {
+    switch (why) {
+        case 'admitted_at':
+        case 'turns_positive':
+            return 'admitted';
+        case 'zero_turns':
+        case 'no_turn_count':
+            return 'pending';
+        case 'key_unbound':
+            return 'not_found';
+        case 'read_error':
+        case 'record_malformed':
+        case 'input_unrecognized':
+            return 'unreadable';
+        default: {
+            const unreachable = why;
+            return unreachable;
+        }
+    }
+}
+function ownData(o, key) {
+    return guardedRead(() => readOwnDataValue(o, key));
+}
+function isJsonObject(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function admittedAtProves(v) {
+    if (typeof v !== 'string')
+        return false;
+    const m = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/.exec(v);
+    if (m === null)
+        return false;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    const daysInMonth = month === 2 ? (leap ? 29 : 28) : month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+    return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth && Number.isFinite(Date.parse(v));
+}
+function recordWhy(record) {
+    if (admittedAtProves(ownData(record, 'admittedAt')))
+        return 'admitted_at';
+    const result = ownData(record, 'result');
+    const stats = isJsonObject(result) ? ownData(result, 'stats') : undefined;
+    const turns = isJsonObject(stats) ? ownData(stats, 'turns') : undefined;
+    if (typeof turns === 'number' && Number.isInteger(turns)) {
+        if (turns > 0)
+            return 'turns_positive';
+        if (turns === 0)
+            return 'zero_turns';
+    }
+    return 'no_turn_count';
+}
+function readWhy(readResult) {
+    if (typeof readResult !== 'object' || readResult === null)
+        return 'input_unrecognized';
+    const kind = ownData(readResult, 'kind');
+    if (kind === 'not_found')
+        return 'key_unbound';
+    if (kind === 'error')
+        return 'read_error';
+    if (kind !== 'record')
+        return 'input_unrecognized';
+    const record = ownData(readResult, 'record');
+    return isJsonObject(record) ? recordWhy(record) : 'record_malformed';
+}
+export function taskNotificationAdmissionOf(readResult) {
+    let why;
+    try {
+        why = readWhy(readResult);
+    }
+    catch {
+        why = 'input_unrecognized';
+    }
+    return Object.freeze({ verdict: verdictOfWhy(why), why });
+}

package/dist/toolResult.js

@@ -3,17 +3,18 @@ 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';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
+const LEGACY_STRUCTURED_DETAIL_TYPE = 'task-output';
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;
     const t = structured.type;
-    return typeof t === 'string' && STRUCTURED_DETAIL_TYPES.has(t) ? t : undefined;
+    return typeof t === 'string' && (STRUCTURED_DETAIL_TYPES.has(t) || t === LEGACY_STRUCTURED_DETAIL_TYPE) ? t : undefined;
 }
 const MAX_STRUCTURED_FIELD_CHARS = 1_000_000;
 export const PROTOCOL_MARKERS = {
@@ -369,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
@@ -391,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;
@@ -497,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/webSearchWireCaps.js

@@ -1,5 +1,6 @@
 import { SETTINGS_IS_HIERARCHICAL_URL } from './generated/settingsSchemaFns.js';
 import { hostEnv } from './hostEnv.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const WEBSEARCH_ENV = {
     provider: 'SEMA_WEBSEARCH_PROVIDER',
     endpoint: 'SEMA_WEBSEARCH_ENDPOINT',
@@ -49,6 +50,9 @@ function apiKeyHeaderValue(provider, key) {
             return `Bearer ${key}`;
     }
 }
+function apiKeyWayOutSentence() {
+    return renderMessage(msg('config.webSearch.apiKeyWayOut'));
+}
 function judgeApiKey(provider, raw) {
     const text = judgeText(raw);
     if (!text.ok || text.value === undefined)
@@ -215,17 +219,18 @@ function envNameOfField(field) {
 export function webSearchVerdictMessage(verdict, context = 'submit') {
     if (verdict.kind !== 'malformed')
         return undefined;
+    const wayOut = verdict.field === 'apiKey' && verdict.issue === API_KEY_ISSUE ? ` ${apiKeyWayOutSentence()}` : '';
     if (verdict.source === 'host') {
         const head = `Web search is misconfigured: the API key your host supplied for webSearch is malformed; it ${verdict.issue}.`;
         return context === 'submit'
-            ? `${head} The request was not sent — the key needs replacing where your host keeps it.`
-            : `${head} Requests will be refused until the key is replaced where your host keeps it.`;
+            ? `${head} The request was not sent — the key needs replacing where your host keeps it.${wayOut}`
+            : `${head} Requests will be refused until the key is replaced where your host keeps it.${wayOut}`;
     }
     const where = verdict.source === 'env' ? envNameOfField(verdict.field) : verdict.field === 'section' ? 'the webSearch section in settings' : `webSearch.${verdict.field} in settings`;
     const fix = verdict.source === 'env' ? 'fix it or unset the SEMA_WEBSEARCH_* variables' : 'fix it or remove the webSearch section';
     return context === 'submit'
-        ? `Web search is misconfigured: ${where} ${verdict.issue}. The request was not sent — ${fix}.`
-        : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.`;
+        ? `Web search is misconfigured: ${where} ${verdict.issue}. The request was not sent — ${fix}.${wayOut}`
+        : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.${wayOut}`;
 }
 export function webSearchEndpointForDisplay(raw) {
     if (typeof raw !== 'string' || !SETTINGS_IS_HIERARCHICAL_URL(raw))

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";
@@ -143,7 +143,28 @@ export interface SessionArchiveStampedDetail {
     readonly code: typeof CONFLICT_SESSION_ARCHIVE_STAMPED;
 }
 export declare function sessionArchiveStampedFromError(err: {} | null | undefined): SessionArchiveStampedDetail | null;
-export declare function sessionArchiveStampedContent(lang?: UiLanguage): string;
+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;