@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/turnFailurePresentation.js

@@ -1,14 +1,15 @@
 import { msg, renderMessage } from './i18n/translate.js';
-import { classifyTurnWireError, effectiveWireErrorCode, isPreStreamDrainingReject } from './wireErrorTriage.js';
+import { classifyTurnWireError, isPreStreamDrainingReject } from './wireErrorTriage.js';
 import { isSseIdleError } from './sseIdleTriage.js';
 import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
 import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
-import { bodyShapeRefusalFromError, bodyShapeRefusalTouchesSettings, fleetLeaseUnavailableContent, fleetLeaseUnavailableFromError, hostPostureRefusalContent, hostPostureRefusalFromError, settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError, toolDeclarationRefusalContent, toolDeclarationRefusalFromError, usageWindowExhaustedContent, usageWindowExhaustedFromError, } from './wireRefusalCopy.js';
+import { admissionWallRefusalContent, admissionWallRefusalFromError, bodyShapeRefusalFromError, bodyShapeRefusalTouchesSettings, fleetLeaseUnavailableContent, fleetLeaseUnavailableFromError, hostPostureRefusalContent, hostPostureRefusalFromError, fieldLimitRefusalContent, fieldLimitRefusalFromError, toolDeclarationRefusalContent, toolDeclarationRefusalFromError, usageWindowExhaustedContent, usageWindowExhaustedFromError, quotaExhaustedContent, quotaExhaustedFromError, userAttachmentRefusalFromError, } from './wireRefusalCopy.js';
 import { THROWN_SLOT_UNREADABLE, readErrorNumber, readThrownSlot, wireFailureTextsOf } from './wireFailureShape.js';
-import { provablyNotSent } from './engineWireFor.js';
+import { effectiveCodeOf, ownReadingSlot, provablyNotSent, triageReadingOf } from './engineWireFor.js';
 import { corruptStoredRowContent, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, requireExistingSessionRefusalContent, requireExistingSessionRefusalFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError, resumePolicyBlockContent, resumePolicyBlockFromError, resumeRefusalContent, resumeRefusalFromError, } from './resumeRefusalCopy.js';
 import { resumeReopenContent, resumeReopenFromError } from './hitl/suspendedReopen.js';
+import { prepareRefusalCodeOf, prepareRefusalNoteOf } from './prepareRefusal.js';
 import { isCorruptSessionError } from './corruptSession.js';
 import { corruptSessionContent } from './corruptSessionCopy.js';
 import { inheritEnvRefusalContent, inheritEnvRefusalFromError } from './inheritEnvWire.js';
@@ -32,6 +33,7 @@ const TURN_FAILURE_HEADLINE_KEYS = Object.freeze({
     timeout: 'notice.failure.headline.timeout',
     parked: 'notice.failure.headline.parked',
     internal: 'notice.failure.headline.internal',
+    cause_unreadable: 'notice.failure.headline.causeUnreadable',
 });
 function waitSecOf(err) {
     const ms = readThrownSlot(err, 'retryAfterMs', 'data');
@@ -60,12 +62,12 @@ function isIdleWatchdog(err) {
 }
 const DETERMINISTIC_SERVER_CODES = new Set([CORRUPT_SESSION_ERROR_CODE, CORRUPT_ROW_ERROR_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT]);
 const BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
-function httpShapeOf(err, verdict) {
+function httpShapeOf(verdict, code) {
     const status = verdict.status;
-    const code = effectiveWireErrorCode(err) ?? verdict.errorCode;
     if (verdict.sessionUnreadable === true || verdict.storedRowWhere !== undefined)
         return { category: 'server_error', offer: false };
-    if (toolDeclarationRefusalFromError(err) !== null)
+    const facts = { status: verdict.status, ...(verdict.errorCode !== undefined ? { errorCode: verdict.errorCode } : {}) };
+    if (toolDeclarationRefusalFromError(facts) !== null)
         return { category: 'invalid_request', offer: false };
     if (code !== undefined && DETERMINISTIC_SERVER_CODES.has(code))
         return { category: 'server_error', offer: false };
@@ -73,7 +75,7 @@ function httpShapeOf(err, verdict) {
         return { category: 'rate_limited', offer: false };
     if (code === 'budget.precall' || code === 'budget.exceeded')
         return { category: 'billing', offer: false };
-    if (code === 'draining' || verdict.leaseUnavailable === true || isPreStreamDrainingReject(err))
+    if (code === 'draining' || verdict.leaseUnavailable === true || isPreStreamDrainingReject(facts))
         return { category: 'server_error', offer: true };
     if (status === 501 || (code !== undefined && code.startsWith('capability.')))
         return { category: 'capability_unavailable', offer: false };
@@ -91,6 +93,13 @@ function httpShapeOf(err, verdict) {
         return { category: 'invalid_request', offer: false };
     return { category: 'internal', offer: false };
 }
+function answeringSubjectOf(err, verdict) {
+    if (verdict.kind !== 'http')
+        return { subject: err, code: undefined };
+    const answered = triageReadingOf(verdict);
+    const a = ownReadingSlot(answered, 'answer');
+    return a !== undefined && a !== THROWN_SLOT_UNREADABLE ? { subject: a.layer, code: effectiveCodeOf(a.code) ?? verdict.errorCode } : { subject: err, code: verdict.errorCode };
+}
 function connectionLostBeforeSend(err, evidence) {
     if (readThrownSlot(evidence, 'bound', 'data') === true || readThrownSlot(evidence, 'reopened', 'data') === true)
         return false;
@@ -98,12 +107,13 @@ function connectionLostBeforeSend(err, evidence) {
 }
 export function turnFailurePresentation(err, evidence, notesCtx, lang) {
     const verdict = classifyTurnWireError(err);
+    const { subject, code: httpCode } = answeringSubjectOf(err, verdict);
     let shape;
     let headlineKey;
     let detail;
     let name;
     if (verdict.kind === 'http') {
-        shape = httpShapeOf(err, verdict);
+        shape = httpShapeOf(verdict, httpCode);
         detail = verdict.message;
         if (shape.category === 'internal')
             headlineKey = TURN_FAILURE_HEADLINE_KEYS.internal;
@@ -131,17 +141,19 @@ export function turnFailurePresentation(err, evidence, notesCtx, lang) {
         detail = verdict.detail;
     }
     else {
-        shape = { category: 'internal', offer: false };
-        headlineKey = TURN_FAILURE_HEADLINE_KEYS.internal;
+        const triaged = triageReadingOf(verdict);
+        const causeUnreadable = ownReadingSlot(triaged, 'answer') === THROWN_SLOT_UNREADABLE || ownReadingSlot(triaged, 'chainEnd') === 'unreadable';
+        shape = { category: 'internal', offer: causeUnreadable };
+        headlineKey = causeUnreadable ? TURN_FAILURE_HEADLINE_KEYS.cause_unreadable : TURN_FAILURE_HEADLINE_KEYS.internal;
         detail = verdict.detail;
         name = verdict.name;
     }
     const status = verdict.kind === 'http' ? verdict.status : undefined;
-    const errorCode = verdict.kind === 'http' ? (effectiveWireErrorCode(err) ?? verdict.errorCode) : undefined;
-    const wireRetriable = readThrownSlot(err, 'retriable', 'data') === true && !isCodeClassifiedGateFailure(errorCode, true);
+    const errorCode = verdict.kind === 'http' ? httpCode : undefined;
+    const wireRetriable = readThrownSlot(subject, 'retriable', 'data') === true && !isCodeClassifiedGateFailure(errorCode, true);
     const retry = wireRetriable && shape.category !== 'parked' ? { offer: true, basis: 'wire' } : { offer: shape.offer, basis: 'category' };
-    const waitSec = waitSecOf(err);
-    const chain = turnFailureNotesOf(err, verdict, notesCtx, waitSec, lang);
+    const waitSec = waitSecOf(subject);
+    const chain = turnFailureNotesOf(subject, verdict, notesCtx, waitSec, lang);
     const headline = headlineKey !== undefined ? renderMessage(msg(headlineKey), lang) : undefined;
     return Object.freeze({
         category: shape.category,
@@ -157,80 +169,6 @@ export function turnFailurePresentation(err, evidence, notesCtx, lang) {
         ...(chain.waitNote !== undefined ? { waitNote: chain.waitNote } : {}),
     });
 }
-function quotaDetailOf(err) {
-    if (readThrownSlot(err, 'status', 'data') !== 429 || readThrownSlot(err, 'errorCode', 'data') !== 'quota_exhausted')
-        return null;
-    const detail = readThrownSlot(err, 'detail', 'data');
-    const slot = (key) => (typeof detail === 'object' && detail !== null ? readThrownSlot(detail, key, 'data') : undefined);
-    const windowType = slot('windowType');
-    const remaining = slot('remaining');
-    const resetAt = slot('resetAt');
-    const isEstimate = slot('isEstimate');
-    const pool = slot('pool');
-    return {
-        ...(windowType === 'fiveHour' || windowType === 'weekly' || windowType === 'budget' ? { windowType } : {}),
-        ...(typeof remaining === 'number' && Number.isFinite(remaining) ? { remaining } : {}),
-        ...(typeof resetAt === 'string' || resetAt === null ? { resetAt } : {}),
-        ...(typeof isEstimate === 'boolean' ? { isEstimate } : {}),
-        ...(typeof pool === 'string' && pool.length > 0 ? { pool } : {}),
-    };
-}
-const MONTH_KEYS = [
-    'notice.failure.month.jan',
-    'notice.failure.month.feb',
-    'notice.failure.month.mar',
-    'notice.failure.month.apr',
-    'notice.failure.month.may',
-    'notice.failure.month.jun',
-    'notice.failure.month.jul',
-    'notice.failure.month.aug',
-    'notice.failure.month.sep',
-    'notice.failure.month.oct',
-    'notice.failure.month.nov',
-    'notice.failure.month.dec',
-];
-function quotaResetInstant(resetAtIso, nowMs, lang) {
-    const t = Date.parse(resetAtIso);
-    if (!Number.isFinite(t))
-        return undefined;
-    const d = new Date(t);
-    const now = new Date(nowMs);
-    const hm = `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-    const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
-    if (sameDay)
-        return hm;
-    const monthKey = MONTH_KEYS[d.getMonth()];
-    return renderMessage(msg('notice.failure.quota.instantOtherDay', { month: monthKey === undefined ? '' : msg(monthKey), day: d.getDate(), time: hm }), lang);
-}
-function quotaExhaustedLine(detail, nowMs, lang) {
-    const part = (key, params) => renderMessage(msg(key, params), lang);
-    const parts = [];
-    if (detail.windowType === 'fiveHour')
-        parts.push(part('notice.failure.quota.fiveHour'));
-    else if (detail.windowType === 'weekly')
-        parts.push(part('notice.failure.quota.weekly'));
-    else if (detail.windowType === 'budget') {
-        if (detail.pool === 'personal')
-            parts.push(part('notice.failure.quota.budgetPersonal'));
-        else if (detail.pool)
-            parts.push(part('notice.failure.quota.budgetPool', { pool: detail.pool }));
-        else
-            parts.push(part('notice.failure.quota.budget'));
-    }
-    else
-        parts.push(part('notice.failure.quota.usage'));
-    if (typeof detail.remaining === 'number' && Number.isFinite(detail.remaining)) {
-        parts.push(detail.windowType === 'budget'
-            ? part('notice.failure.quota.remainingBudget', { amount: `$${(detail.remaining / 1_000_000).toFixed(2)}` })
-            : part('notice.failure.quota.remainingTokens', { count: detail.remaining.toLocaleString('en-US') }));
-    }
-    const resetText = typeof detail.resetAt === 'string' ? quotaResetInstant(detail.resetAt, nowMs, lang) : undefined;
-    if (resetText)
-        parts.push(detail.isEstimate === false ? part('notice.failure.quota.resetAt', { time: resetText }) : part('notice.failure.quota.resetAround', { time: resetText }));
-    parts.push(part('notice.failure.quota.refresh'));
-    parts.push(part('notice.failure.quota.noBypass'));
-    return parts.join(part('notice.failure.quota.join'));
-}
 function protectiveSettingsAtRisk(sent, lang) {
     const out = [];
     const permsRaw = sent.permissions;
@@ -281,9 +219,9 @@ function turnFailureNotesOf(err, verdict, ctx, waitSec, lang) {
     try {
         const sentRequest = ctx === undefined ? undefined : ctx.sentRequest;
         const nowMs = ctx !== undefined && typeof ctx.nowMs === 'number' && Number.isFinite(ctx.nowMs) ? ctx.nowMs : Date.now();
-        const quota = quotaDetailOf(err);
+        const quota = quotaExhaustedFromError(err);
         if (quota)
-            lines.push(quotaExhaustedLine(quota, nowMs, lang));
+            lines.push(quotaExhaustedContent(quota, nowMs, lang));
         const scenarioDeny = quota ? null : scenarioDenyFromError(err);
         if (scenarioDeny)
             lines.push(scenarioNotAllowedContent(scenarioDeny, ctx?.requestedScenario));
@@ -309,25 +247,32 @@ function turnFailureNotesOf(err, verdict, ctx, waitSec, lang) {
             lines.push(corruptSessionContent(lang));
         const usageWindow = quota || scenarioDeny || resumeRefusal || resumeReopen || resumeGone ? null : usageWindowExhaustedFromError(err);
         if (usageWindow)
-            lines.push(usageWindowExhaustedContent(usageWindow));
+            lines.push(usageWindowExhaustedContent(usageWindow, lang));
         const hostPosture = quota || scenarioDeny || resumeRefusal || resumeReopen || resumeGone || storedRowWhere !== undefined ? null : hostPostureRefusalFromError(err, sentRequest);
         if (hostPosture)
-            lines.push(hostPostureRefusalContent(hostPosture));
+            lines.push(hostPostureRefusalContent(hostPosture, lang));
         const inheritEnv = hostPosture ? null : inheritEnvRefusalFromError(err, sentRequest);
         if (inheritEnv)
             lines.push(inheritEnvRefusalContent(inheritEnv, lang));
-        const bucket = inheritEnv ? null : settingsPermissionBucketRefusalFromError(err);
+        const bucket = inheritEnv ? null : fieldLimitRefusalFromError(err);
         const toolDecl = toolDeclarationRefusalFromError(err);
         if (toolDecl)
-            lines.push(toolDeclarationRefusalContent(toolDecl));
+            lines.push(toolDeclarationRefusalContent(toolDecl, lang));
+        const prepareCode = toolDecl ? undefined : prepareRefusalCodeOf(err);
+        const prepareNote = prepareCode === undefined ? undefined : prepareRefusalNoteOf(prepareCode, userAttachmentRefusalFromError(err) ?? undefined);
+        if (prepareNote !== undefined)
+            lines.push(prepareNote);
+        const wall = admissionWallRefusalFromError(err);
+        if (wall)
+            lines.push(admissionWallRefusalContent(wall));
         const lease = fleetLeaseUnavailableFromError(err);
         if (lease)
-            lines.push(fleetLeaseUnavailableContent(lease));
+            lines.push(fleetLeaseUnavailableContent(lease, lang));
         const policyBlock = quota || scenarioDeny || resumeRefusal || resumeReopen || resumeGone || usageWindow || hostPosture ? null : resumePolicyBlockFromError(err);
         if (policyBlock)
             lines.push(resumePolicyBlockContent(policyBlock, lang));
         if (bucket)
-            lines.push(settingsPermissionBucketRefusalContent(bucket));
+            lines.push(fieldLimitRefusalContent(bucket, lang));
         const settingsRefusal = settingsBodyShapeNote(err, sentRequest, lang);
         if (settingsRefusal !== undefined)
             lines.push(settingsRefusal);

package/dist/usageLimitAutoResume.d.ts

@@ -0,0 +1,74 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type QuotaExhaustedView } from './wireRefusalCopy.js';
+export declare const AUTO_RESUME_HORIZON_MS: number;
+export declare const AUTO_RESUME_REPEAT_BREAKER_HITS = 2;
+export declare const AUTO_RESUME_IMMINENT_MS = 60000;
+export type AutoResumePhase = 'idle' | 'offered' | 'armed' | 'fired' | 'stale' | 'disabled' | 'horizon';
+export type AutoResumeReason = 'context-changed' | 'not-replayable' | 'user-escaped' | 'user-chose-wait' | 'user-cancelled-auto' | 'repeated-usage-limit-hits' | 'no-reset-instant' | 'reset-horizon-exceeded' | 'prompt-superseded' | 'reset-without-auto-resume';
+export interface AutoResumeState {
+    readonly phase: AutoResumePhase;
+    readonly prompt: string | null;
+    readonly resumeAtMs: number | null;
+    readonly windowType: 'fiveHour' | 'weekly' | 'budget' | null;
+    readonly consecutiveHits: number;
+    readonly reason: AutoResumeReason | null;
+    readonly contextId: string | null;
+}
+export type RateLimitOption = 'cancel' | 'auto-resume' | 'cancel-auto-resume';
+export type AutoResumeEvent = {
+    readonly type: 'usage-limit-hit';
+    readonly detail: QuotaExhaustedView;
+    readonly prompt: string;
+    readonly contextId?: string;
+    readonly replayable?: boolean;
+} | {
+    readonly type: 'menu-choice';
+    readonly option: RateLimitOption;
+    readonly contextId?: string;
+} | {
+    readonly type: 'escape';
+} | {
+    readonly type: 'tick';
+    readonly contextId?: string;
+} | {
+    readonly type: 'user-submitted';
+} | {
+    readonly type: 'context-changed';
+} | {
+    readonly type: 'turn-completed';
+};
+export declare const AUTO_RESUME_COPY_WORDS: readonly ["fired", "reset", "breaker", "superseded", "not-replayable", "context-changed", "escaped"];
+export type AutoResumeCopyWord = (typeof AUTO_RESUME_COPY_WORDS)[number];
+export type AutoResumeAction = {
+    readonly type: 'schedule';
+    readonly atMs: number;
+} | {
+    readonly type: 'clear-schedule';
+} | {
+    readonly type: 'resubmit';
+    readonly prompt: string;
+} | {
+    readonly type: 'revoke-resubmit';
+} | {
+    readonly type: 'notify';
+    readonly kind: 'fired' | 'stale' | 'disabled';
+    readonly copy: AutoResumeCopyWord;
+    readonly message: string;
+};
+export interface AutoResumeStep {
+    readonly state: AutoResumeState;
+    readonly actions: readonly AutoResumeAction[];
+}
+export declare function autoResumeCopy(word: AutoResumeCopyWord, lang?: UiLanguage): string;
+export declare function autoResumeAtMs(resetAt: string | null | undefined): number | null;
+export declare function initialAutoResumeState(): AutoResumeState;
+export declare function autoResumeTransition(state: AutoResumeState, event: AutoResumeEvent, nowMs: number): AutoResumeStep;
+export declare function autoResumeArmedRow(state: AutoResumeState, nowMs: number, lang?: UiLanguage): string | undefined;
+export declare function autoResumeNoticeRow(state: AutoResumeState, lang?: UiLanguage): string | undefined;
+export interface RateLimitOptionRow {
+    readonly value: RateLimitOption;
+    readonly label: string;
+    readonly disabled: boolean;
+    readonly disabledReason?: string;
+}
+export declare function rateLimitOptionRows(state: AutoResumeState, lang?: UiLanguage): readonly RateLimitOptionRow[];

package/dist/usageLimitAutoResume.js

@@ -0,0 +1,227 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { usableClockMs } from './clockReading.js';
+import { quotaResetInstantText } from './wireRefusalCopy.js';
+export const AUTO_RESUME_HORIZON_MS = 24 * 60 * 60 * 1000;
+export const AUTO_RESUME_REPEAT_BREAKER_HITS = 2;
+export const AUTO_RESUME_IMMINENT_MS = 60_000;
+export const AUTO_RESUME_COPY_WORDS = Object.freeze(['fired', 'reset', 'breaker', 'superseded', 'not-replayable', 'context-changed', 'escaped']);
+const COPY_KEYS = {
+    fired: 'notice.usageLimit.autoResume.fired',
+    reset: 'notice.usageLimit.autoResume.reset',
+    breaker: 'notice.usageLimit.autoResume.breaker',
+    superseded: 'notice.usageLimit.autoResume.superseded',
+    'not-replayable': 'notice.usageLimit.autoResume.notReplayable',
+    'context-changed': 'notice.usageLimit.autoResume.contextChanged',
+    escaped: 'notice.usageLimit.autoResume.escaped',
+};
+export function autoResumeCopy(word, lang) {
+    return Object.hasOwn(COPY_KEYS, word) ? renderMessage(msg(COPY_KEYS[word]), lang) : '';
+}
+const notifyAction = (kind, copy) => ({ type: 'notify', kind, copy, message: autoResumeCopy(copy) });
+export function autoResumeAtMs(resetAt) {
+    if (typeof resetAt !== 'string')
+        return null;
+    const t = Date.parse(resetAt);
+    return Number.isFinite(t) ? t : null;
+}
+export function initialAutoResumeState() {
+    return Object.freeze({ phase: 'idle', prompt: null, resumeAtMs: null, windowType: null, consecutiveHits: 0, reason: null, contextId: null });
+}
+function noticeSchedule(resumeAtMs, nowMs) {
+    if (resumeAtMs === null || usableClockMs(nowMs) === null || resumeAtMs - nowMs > AUTO_RESUME_HORIZON_MS)
+        return [{ type: 'clear-schedule' }];
+    return [{ type: 'schedule', atMs: resumeAtMs }];
+}
+function freezeActions(actions) {
+    return Object.freeze(actions.map((a) => Object.freeze({ ...a })));
+}
+function settle(state, patch, actions = []) {
+    return Object.freeze({ state: Object.freeze({ ...state, ...patch }), actions: freezeActions(actions) });
+}
+const withActions = (state, actions) => Object.freeze({ state, actions: freezeActions(actions) });
+const NO_ACTIONS = Object.freeze([]);
+const NO_CHANGE = (state) => Object.freeze({ state, actions: NO_ACTIONS });
+const ctxOf = (v) => (typeof v === 'string' ? v : undefined);
+function snapshotDetail(d) {
+    if (typeof d !== 'object' || d === null)
+        return {};
+    const raw = d;
+    const resetAt = raw.resetAt;
+    const windowType = raw.windowType;
+    return {
+        ...(typeof resetAt === 'string' ? { resetAt } : {}),
+        ...(windowType === 'fiveHour' || windowType === 'weekly' || windowType === 'budget' ? { windowType } : {}),
+    };
+}
+export function autoResumeTransition(state, event, nowMs) {
+    try {
+        if (typeof event !== 'object' || event === null)
+            return NO_CHANGE(state);
+        const raw = event;
+        const facts = { type: raw.type, detail: raw.detail, prompt: raw.prompt, contextId: raw.contextId, replayable: raw.replayable, option: raw.option };
+        return transition(state, facts, nowMs);
+    }
+    catch {
+        return NO_CHANGE(state);
+    }
+}
+function transition(state, event, nowMs) {
+    const clockOk = usableClockMs(nowMs) !== null;
+    switch (event.type) {
+        case 'usage-limit-hit': {
+            if (!clockOk)
+                return NO_CHANGE(state);
+            const detail = snapshotDetail(event.detail);
+            const hits = state.consecutiveHits + 1;
+            const resumeAtMs = autoResumeAtMs(detail.resetAt);
+            const windowType = detail.windowType ?? null;
+            const contextId = ctxOf(event.contextId) ?? null;
+            const base = { consecutiveHits: hits, resumeAtMs, windowType, contextId };
+            const prompt = typeof event.prompt === 'string' ? event.prompt : null;
+            const isOurs = state.prompt !== null && prompt === state.prompt;
+            if (state.phase === 'armed')
+                return settle(state, { consecutiveHits: hits }, []);
+            if (state.phase === 'fired' && !isOurs)
+                return settle(state, { consecutiveHits: hits }, []);
+            if (state.phase === 'fired' && hits >= AUTO_RESUME_REPEAT_BREAKER_HITS) {
+                return settle(state, { ...base, phase: 'disabled', reason: 'repeated-usage-limit-hits', prompt: null }, [{ type: 'clear-schedule' }, notifyAction('disabled', 'breaker')]);
+            }
+            if (event.replayable === false || prompt === null) {
+                return settle(state, { ...base, phase: 'disabled', reason: 'not-replayable', prompt: null }, noticeSchedule(resumeAtMs, nowMs));
+            }
+            if (resumeAtMs === null) {
+                return settle(state, { ...base, phase: 'disabled', reason: 'no-reset-instant', prompt: null }, [{ type: 'clear-schedule' }]);
+            }
+            if (resumeAtMs - nowMs > AUTO_RESUME_HORIZON_MS) {
+                return settle(state, { ...base, phase: 'horizon', reason: 'reset-horizon-exceeded', prompt }, [{ type: 'clear-schedule' }]);
+            }
+            return settle(state, { ...base, phase: 'offered', reason: null, prompt }, noticeSchedule(resumeAtMs, nowMs));
+        }
+        case 'menu-choice': {
+            const revokeIfFired = state.phase === 'fired' ? [{ type: 'revoke-resubmit' }] : [];
+            if (event.option === 'cancel') {
+                return settle(state, { phase: 'disabled', reason: 'user-chose-wait', prompt: null }, [...revokeIfFired, ...noticeSchedule(state.resumeAtMs, nowMs)]);
+            }
+            if (event.option === 'cancel-auto-resume') {
+                if (state.phase !== 'armed' && state.phase !== 'fired')
+                    return NO_CHANGE(state);
+                return settle(state, { phase: 'disabled', reason: 'user-cancelled-auto', prompt: null }, [{ type: 'clear-schedule' }, ...revokeIfFired]);
+            }
+            if (event.option !== 'auto-resume')
+                return NO_CHANGE(state);
+            if (state.phase === 'armed')
+                return NO_CHANGE(state);
+            if (state.phase !== 'offered' && state.phase !== 'horizon')
+                return NO_CHANGE(state);
+            if (state.resumeAtMs === null || state.prompt === null)
+                return NO_CHANGE(state);
+            if (!clockOk)
+                return NO_CHANGE(state);
+            const authorizedIn = ctxOf(event.contextId);
+            return settle(state, { phase: 'armed', reason: null, ...(authorizedIn !== undefined ? { contextId: authorizedIn } : {}) }, [{ type: 'schedule', atMs: state.resumeAtMs }]);
+        }
+        case 'escape': {
+            if (state.phase === 'fired')
+                return settle(state, { phase: 'disabled', reason: 'user-escaped', prompt: null }, [{ type: 'clear-schedule' }, { type: 'revoke-resubmit' }]);
+            if (state.phase !== 'armed')
+                return NO_CHANGE(state);
+            return settle(state, { phase: 'disabled', reason: 'user-escaped', prompt: null }, [{ type: 'clear-schedule' }]);
+        }
+        case 'tick': {
+            if (state.resumeAtMs === null)
+                return NO_CHANGE(state);
+            if (!clockOk)
+                return NO_CHANGE(state);
+            if (nowMs < state.resumeAtMs) {
+                if (state.phase === 'armed' || state.phase === 'offered' || state.phase === 'horizon' || state.phase === 'disabled') {
+                    return withActions(state, [{ type: 'schedule', atMs: state.resumeAtMs }]);
+                }
+                return NO_CHANGE(state);
+            }
+            if (state.contextId !== null && ctxOf(event.contextId) !== state.contextId) {
+                return settle(state, { phase: 'stale', reason: 'context-changed', prompt: null }, state.phase === 'armed' ? [{ type: 'clear-schedule' }, notifyAction('stale', 'context-changed')] : [{ type: 'clear-schedule' }]);
+            }
+            if (state.phase === 'armed') {
+                if (state.prompt === null) {
+                    return settle(state, { phase: 'stale', reason: 'reset-without-auto-resume' }, [{ type: 'clear-schedule' }, notifyAction('stale', 'reset')]);
+                }
+                return settle(state, { phase: 'fired', reason: null }, [{ type: 'clear-schedule' }, { type: 'resubmit', prompt: state.prompt }, notifyAction('fired', 'fired')]);
+            }
+            if (state.phase === 'offered' || state.phase === 'horizon' || state.phase === 'disabled') {
+                return settle(state, { phase: 'stale', reason: 'reset-without-auto-resume', prompt: null }, [{ type: 'clear-schedule' }, notifyAction('stale', 'reset')]);
+            }
+            return NO_CHANGE(state);
+        }
+        case 'user-submitted': {
+            if (state.phase !== 'armed' && state.phase !== 'fired')
+                return NO_CHANGE(state);
+            return settle(state, { phase: 'stale', reason: 'prompt-superseded', prompt: null }, state.phase === 'fired' ? [{ type: 'clear-schedule' }, { type: 'revoke-resubmit' }] : [{ type: 'clear-schedule' }]);
+        }
+        case 'context-changed': {
+            if (state.phase !== 'armed' && state.phase !== 'fired' && state.phase !== 'offered' && state.phase !== 'horizon')
+                return NO_CHANGE(state);
+            return settle(state, { phase: 'stale', reason: 'context-changed', prompt: null }, [
+                { type: 'clear-schedule' },
+                ...(state.phase === 'fired' ? [{ type: 'revoke-resubmit' }] : []),
+                notifyAction('stale', 'context-changed'),
+            ]);
+        }
+        case 'turn-completed': {
+            if (state.phase === 'fired')
+                return settle(state, { ...initialAutoResumeState() });
+            if (state.phase === 'stale' || state.phase === 'disabled' || state.phase === 'horizon')
+                return settle(state, { ...initialAutoResumeState() });
+            return settle(state, { consecutiveHits: 0 });
+        }
+        default:
+            return NO_CHANGE(state);
+    }
+}
+export function autoResumeArmedRow(state, nowMs, lang) {
+    if (state.phase !== 'armed' || state.resumeAtMs === null)
+        return undefined;
+    const remaining = state.resumeAtMs - nowMs;
+    const at = remaining > AUTO_RESUME_IMMINENT_MS ? quotaResetInstantText(new Date(state.resumeAtMs).toISOString(), nowMs, lang) : undefined;
+    return at !== undefined ? renderMessage(msg('notice.usageLimit.autoResume.armed.at', { time: at }), lang) : renderMessage(msg('notice.usageLimit.autoResume.armed.shortly'), lang);
+}
+export function autoResumeNoticeRow(state, lang) {
+    if (state.phase === 'stale') {
+        if (state.reason === 'prompt-superseded')
+            return autoResumeCopy('superseded', lang);
+        if (state.reason === 'context-changed')
+            return autoResumeCopy('context-changed', lang);
+        return autoResumeCopy('reset', lang);
+    }
+    if (state.phase === 'disabled' && state.reason === 'repeated-usage-limit-hits')
+        return autoResumeCopy('breaker', lang);
+    if (state.phase === 'disabled' && state.reason === 'not-replayable')
+        return autoResumeCopy('not-replayable', lang);
+    if (state.phase === 'disabled' && state.reason === 'user-escaped')
+        return autoResumeCopy('escaped', lang);
+    if (state.phase === 'horizon')
+        return renderMessage(msg('notice.usageLimit.autoResume.horizon'), lang);
+    return undefined;
+}
+export function rateLimitOptionRows(state, lang) {
+    const t = (key) => renderMessage(msg(key), lang);
+    const rows = [{ value: 'cancel', label: t('notice.usageLimit.autoResume.option.cancel'), disabled: false }];
+    if (state.phase === 'armed' || state.phase === 'fired') {
+        rows.push({ value: 'cancel-auto-resume', label: t('notice.usageLimit.autoResume.option.cancelAuto'), disabled: false });
+        return rows;
+    }
+    const armable = state.phase === 'offered' || state.phase === 'horizon';
+    let disabledReason;
+    if (state.reason === 'repeated-usage-limit-hits')
+        disabledReason = t('notice.usageLimit.autoResume.disabled.breaker');
+    else if (state.reason === 'not-replayable')
+        disabledReason = t('notice.usageLimit.autoResume.disabled.notReplayable');
+    else if (state.reason === 'context-changed')
+        disabledReason = t('notice.usageLimit.autoResume.disabled.contextChanged');
+    else if (state.resumeAtMs === null)
+        disabledReason = t('notice.usageLimit.autoResume.disabled.noResetInstant');
+    else if (!armable)
+        disabledReason = t('notice.usageLimit.autoResume.disabled.nothingWaiting');
+    const label = state.phase === 'horizon' ? t('notice.usageLimit.autoResume.option.autoHorizon') : t('notice.usageLimit.autoResume.option.auto');
+    rows.push({ value: 'auto-resume', label, disabled: disabledReason !== undefined, ...(disabledReason !== undefined ? { disabledReason } : {}) });
+    return rows;
+}

package/dist/userAttachmentEnvelope.js

@@ -165,7 +165,7 @@ const NOT_INCLUDED_REASON = Object.freeze({
     'too-large': "it is larger than the client's size limit for attaching files",
     unreadable: 'the client could not read it',
     'read-denied': "the user's permission rules do not allow reading it",
-    'approval-required': "this deployment's rules require approval before it is read, so the client did not attach it without asking",
+    'approval-required': 'a read-approval rule applies to it, so the client did not attach it without asking',
     'server-not-connected': 'the MCP server it comes from is not connected',
     'resource-not-listed': 'the MCP server does not list that resource',
     'read-failed': 'reading it from the MCP server failed',

package/dist/userAttachmentSeat.js

@@ -1,6 +1,6 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { ownDataField, readOwnDataValue } from './ownKey.js';
+import { appendOwnElement, ownDataField, readOwnDataValue } from './ownKey.js';
 const _seatPin = [true, true];
 void _seatPin;
 function stringList(v) {
@@ -12,9 +12,9 @@ function stringList(v) {
     const out = [];
     for (let i = 0; i < n; i += 1) {
         const d = Object.getOwnPropertyDescriptor(v, i);
-        if (d === undefined || !('value' in d) || typeof d.value !== 'string')
+        if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string')
             return undefined;
-        out.push(d.value);
+        appendOwnElement(out, d.value);
     }
     return out;
 }
@@ -46,7 +46,7 @@ export function projectUserAttachmentSeatCapability(caps) {
     }
 }
 const reader = createEngineCapReader({ name: 'userAttachments', project: projectUserAttachmentSeatCapability });
-export function observedUserAttachmentSeat(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedUserAttachmentSeat(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function userAttachmentSeatAdmits(reading) {

package/dist/userInvokedSkillsCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
@@ -21,7 +21,7 @@ const reader = createEngineCapReader({
     name: 'userInvokedSkills',
     project: projectUserInvokedSkillsCapability,
 });
-export function observedUserInvokedSkills(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedUserInvokedSkills(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function userInvokedSkillsAvailable(reading) {

package/dist/webSearchBackendCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export const WEB_SEARCH_BACKEND_NONE = 'none';
@@ -29,7 +29,7 @@ const reader = createEngineCapReader({
     name: 'webSearch.backend',
     project: projectWebSearchBackendCapability,
 });
-export function observedWebSearchBackend(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedWebSearchBackend(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 const WS_DETAIL_MAX = 40;