@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/runLedgerSnapshot.js

@@ -0,0 +1,272 @@
+import { createStreamDrainingLegs } from './streamDrainingLegs.js';
+import { abortableSleep, settleWithinDeadline } from './abortableSleep.js';
+import { readOwnDataValue } from './ownKey.js';
+const RUN_LEDGER_SNAPSHOT_BUDGET_MS = 8_000;
+const UNNUMBERED_FRAME_CAP = 64;
+const PARK_TRAILER_MAX = 4;
+function frameSeq(ev) {
+    try {
+        const id = ev?.id;
+        if (typeof id !== 'string' || id.length === 0)
+            return undefined;
+        const n = Number(id);
+        return Number.isSafeInteger(n) && n >= 0 ? n : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isParkMarker(ev) {
+    try {
+        const t = ev?.type;
+        return t === 'suspended' || t === 'needs_review';
+    }
+    catch {
+        return false;
+    }
+}
+function isOwnToolStart(ev, callId) {
+    if (callId === undefined || callId.length === 0)
+        return false;
+    try {
+        const e = ev;
+        return e !== null && typeof e === 'object' && e.type === 'tool_start' && e.toolCallId === callId;
+    }
+    catch {
+        return false;
+    }
+}
+function errorNameOf(e) {
+    try {
+        const name = e?.name;
+        return typeof name === 'string' ? name : 'Error';
+    }
+    catch {
+        return 'Error';
+    }
+}
+function budgetMsOf(deps) {
+    try {
+        const raw = readOwnDataValue(deps, 'budgetMs');
+        return typeof raw === 'number' && Number.isFinite(raw) ? Math.max(0, raw) : RUN_LEDGER_SNAPSHOT_BUDGET_MS;
+    }
+    catch {
+        return RUN_LEDGER_SNAPSHOT_BUDGET_MS;
+    }
+}
+export async function readRunLedgerSnapshot(taskId, callId, deps, signal) {
+    const log = (msg) => {
+        try {
+            deps.log?.(msg);
+        }
+        catch {
+        }
+    };
+    if (typeof taskId !== 'string' || taskId.length === 0)
+        return null;
+    const ac = new AbortController();
+    const onOuterAbort = () => ac.abort();
+    let outerWatched = false;
+    try {
+        if (signal?.aborted === true)
+            return null;
+        signal?.addEventListener('abort', onOuterAbort, { once: true });
+        outerWatched = signal !== undefined;
+    }
+    catch (e) {
+        log(`[ledgerSnapshot] signal-unreadable task=${taskId} name=${errorNameOf(e)}`);
+        return null;
+    }
+    const budget = budgetMsOf(deps);
+    let onExpire;
+    const expired = new Promise((resolve) => {
+        onExpire = () => resolve(null);
+        if (ac.signal.aborted)
+            resolve(null);
+        else
+            ac.signal.addEventListener('abort', onExpire, { once: true });
+    });
+    const parkedNow = async () => {
+        try {
+            return (await deps.isParked(taskId, ac.signal)) === true;
+        }
+        catch (e) {
+            log(`[ledgerSnapshot] parked-read-threw task=${taskId} name=${errorNameOf(e)}`);
+            return false;
+        }
+    };
+    const waitAbortable = (ms) => abortableSleep(Math.max(0, ms), ac.signal).then(() => !ac.signal.aborted);
+    const readOnce = async (drainLegs) => {
+        let max;
+        let folded;
+        let numbered = 0;
+        let lastParkAt = -1;
+        let openToolStart;
+        let unnumbered = 0;
+        let preambleLen = 0;
+        let unnumberedRun = 0;
+        let complete = false;
+        let cappedOut = false;
+        let disordered = false;
+        const passAc = new AbortController();
+        const onOuter = () => passAc.abort();
+        if (ac.signal.aborted)
+            passAc.abort();
+        else
+            ac.signal.addEventListener('abort', onOuter, { once: true });
+        try {
+            if (deps.fold !== undefined)
+                folded = deps.fold.init();
+            for await (const ev of deps.frames(taskId, passAc.signal)) {
+                if (ac.signal.aborted)
+                    break;
+                if (drainLegs.see(ev))
+                    continue;
+                const seq = frameSeq(ev);
+                if (seq === undefined && deps.fold?.substantive?.(ev) === true) {
+                    disordered = true;
+                    break;
+                }
+                if (seq === undefined) {
+                    unnumbered += 1;
+                    if (unnumbered > UNNUMBERED_FRAME_CAP + 3 * preambleLen) {
+                        cappedOut = true;
+                        break;
+                    }
+                    if (max === undefined) {
+                        preambleLen += 1;
+                        continue;
+                    }
+                    unnumberedRun += 1;
+                    if (preambleLen > 0 && unnumberedRun >= 2 * preambleLen) {
+                        complete = true;
+                        break;
+                    }
+                    continue;
+                }
+                unnumberedRun = 0;
+                if (deps.fold?.strictOrder === true && max !== undefined && seq <= max) {
+                    disordered = true;
+                    break;
+                }
+                numbered += 1;
+                if (max === undefined || seq > max)
+                    max = seq;
+                if (isParkMarker(ev))
+                    lastParkAt = numbered;
+                if (isOwnToolStart(ev, callId))
+                    openToolStart = ev;
+                if (deps.fold !== undefined)
+                    folded = deps.fold.step(folded, ev);
+            }
+            if (!complete && !cappedOut && !disordered && !ac.signal.aborted) {
+                const drained = drainLegs.legEnded('returned');
+                if (drained !== undefined)
+                    return { kind: 'drained', decision: drained };
+                complete = true;
+            }
+        }
+        catch (e) {
+            drainLegs.legEnded('threw');
+            const name = errorNameOf(e);
+            if (!ac.signal.aborted && name === 'StreamEndedWithoutTerminalError')
+                complete = true;
+            else
+                log(`[ledgerSnapshot] read-ended-unproven task=${taskId} name=${name}`);
+        }
+        finally {
+            passAc.abort();
+            ac.signal.removeEventListener('abort', onOuter);
+        }
+        if (!complete || disordered || max === undefined || ac.signal.aborted) {
+            if (disordered)
+                log(`[ledgerSnapshot] read-unordered task=${taskId}`);
+            return { kind: 'read', result: null };
+        }
+        const nearParkTail = lastParkAt > 0 && numbered - lastParkAt <= PARK_TRAILER_MAX;
+        return {
+            kind: 'read',
+            result: { max, nearParkTail, ...(openToolStart !== undefined ? { openToolStart } : {}), ...(deps.fold !== undefined ? { folded: folded } : {}) },
+        };
+    };
+    const readPass = async () => {
+        const drainLegs = createStreamDrainingLegs();
+        for (;;) {
+            const once = await readOnce(drainLegs);
+            if (once.kind === 'read')
+                return once.result;
+            if (!('reconnectAfterMs' in once.decision)) {
+                log(`[ledgerSnapshot] drained-give-up task=${taskId}`);
+                return null;
+            }
+            log(`[ledgerSnapshot] drained-reread task=${taskId} ms=${String(once.decision.reconnectAfterMs)}`);
+            if (!(await waitAbortable(once.decision.reconnectAfterMs)))
+                return null;
+        }
+    };
+    const body = async () => {
+        try {
+            if (!(await parkedNow())) {
+                log(`[ledgerSnapshot] not-parked-before task=${taskId}`);
+                return null;
+            }
+            const [first, second] = await Promise.all([readPass(), readPass()]);
+            if (first === null) {
+                log(`[ledgerSnapshot] no-proof task=${taskId}`);
+                return null;
+            }
+            if (!first.nearParkTail) {
+                log(`[ledgerSnapshot] tail-not-at-park task=${taskId}`);
+                return null;
+            }
+            if (second === null || second.max !== first.max || !second.nearParkTail) {
+                log(`[ledgerSnapshot] passes-disagree-on-end task=${taskId}`);
+                return null;
+            }
+            const agree = deps.fold?.agree;
+            if (agree !== undefined && !(first.folded !== undefined && second.folded !== undefined && agree(first.folded, second.folded) === true)) {
+                log(`[ledgerSnapshot] passes-disagree-on-fold task=${taskId}`);
+                return null;
+            }
+            const chosen = second.openToolStart !== undefined ? second : first;
+            if (!(await parkedNow())) {
+                log(`[ledgerSnapshot] not-parked-after task=${taskId}`);
+                return null;
+            }
+            if (ac.signal.aborted)
+                return null;
+            return {
+                highWater: String(chosen.max),
+                ...(chosen.openToolStart !== undefined ? { openToolStart: chosen.openToolStart } : {}),
+                ...(deps.fold !== undefined && chosen.folded !== undefined ? { folded: chosen.folded } : {}),
+            };
+        }
+        catch (e) {
+            log(`[ledgerSnapshot] internal-error task=${taskId} name=${errorNameOf(e)}`);
+            return null;
+        }
+    };
+    try {
+        const bounded = settleWithinDeadline(budget, (deadline) => {
+            if (deadline.aborted)
+                ac.abort();
+            else
+                deadline.addEventListener('abort', () => ac.abort(), { once: true });
+            return body();
+        }).then((settled) => (settled.kind === 'value' ? settled.value : null));
+        return await Promise.race([bounded, expired]);
+    }
+    finally {
+        if (outerWatched) {
+            try {
+                signal?.removeEventListener('abort', onOuterAbort);
+            }
+            catch (e) {
+                log(`[ledgerSnapshot] signal-unlisten-threw task=${taskId} name=${errorNameOf(e)}`);
+            }
+        }
+        if (onExpire !== undefined)
+            ac.signal.removeEventListener('abort', onExpire);
+        ac.abort();
+    }
+}

package/dist/runPermissionModeSwitch.d.ts

@@ -0,0 +1,57 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type PermissionModeReceiptView } from './adapter/downstream/wiringManifestView.js';
+import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
+import { type PermissionModeWriteReading } from './permissionModeWriteCapability.js';
+import type { PermissionMode } from './permissionWireCaps.js';
+export type { PermissionModeReceiptView };
+type AdmissionFold = (typeof SDK_PERMISSION_MODE_ADMISSION_FOLDS)[number];
+type PersistMiss = (typeof SDK_PERMISSION_MODE_PERSIST_MISSES)[number];
+export interface PermissionModeAdmissionView {
+    readonly requested: string;
+    readonly admitted: string;
+    readonly foldedBy: AdmissionFold;
+}
+export type RunPermissionModeSwitchOutcome = {
+    readonly kind: 'switched';
+    readonly taskId: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionModeReceiptView;
+    readonly admission?: PermissionModeAdmissionView;
+    readonly persisted: true;
+} | {
+    readonly kind: 'switched';
+    readonly taskId: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionModeReceiptView;
+    readonly admission?: PermissionModeAdmissionView;
+    readonly persisted: false;
+    readonly persistMiss: PersistMiss;
+} | {
+    readonly kind: 'not-running';
+} | {
+    readonly kind: 'not-found';
+} | {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+} | {
+    readonly kind: 'unconfirmed';
+    readonly why: 'transport' | 'server-error' | 'unreadable-answer';
+    readonly status?: number;
+} | {
+    readonly kind: 'unavailable';
+};
+export interface RunPermissionModeSwitchRuns {
+    setPermissionMode(taskId: string, mode: PermissionMode, opts?: {
+        session?: string;
+        signal?: AbortSignal;
+    }): Promise<object>;
+}
+export interface RunPermissionModeSwitchOptions {
+    readonly permissionModeWrite?: PermissionModeWriteReading | undefined;
+    readonly sessionId?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+export declare const PERMISSION_MODE_SWITCH_RESULT_KEYS: readonly ["taskId", "sessionId", "status", "permissionMode", "admission", "persisted", "persistMiss"];
+export declare function setRunPermissionMode(runs: RunPermissionModeSwitchRuns | null | undefined, taskId: string, mode: PermissionMode, opts?: RunPermissionModeSwitchOptions): Promise<RunPermissionModeSwitchOutcome>;
+export declare function runPermissionModeSwitchLine(outcome: RunPermissionModeSwitchOutcome, lang?: UiLanguage): string;

package/dist/runPermissionModeSwitch.js

@@ -0,0 +1,135 @@
+import { atMostOnceVerdictOf } from './atMostOnce.js';
+import { readPermissionModeReceiptSegment } from './adapter/downstream/wiringManifestView.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { ownDataField } from './ownKey.js';
+import { permissionModeWriteAvailable } from './permissionModeWriteCapability.js';
+import { isDisplayableWireCode } from './wireFailureShape.js';
+export const PERMISSION_MODE_SWITCH_RESULT_KEYS = Object.freeze(['taskId', 'sessionId', 'status', 'permissionMode', 'admission', 'persisted', 'persistMiss']);
+const NOT_RUNNING_CODE = 'steering.not_running';
+const PRE_SWITCH_CORRUPT_CODE = 'corrupt';
+function guardedSlot(o, key) {
+    if (o === null || (typeof o !== 'object' && typeof o !== 'function'))
+        return undefined;
+    try {
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+const unavailable = () => Object.freeze({ kind: 'unavailable' });
+const unreadableAnswer = () => Object.freeze({ kind: 'unconfirmed', why: 'unreadable-answer' });
+function admissionOf(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const requested = ownDataField(raw, 'requested');
+    const admitted = ownDataField(raw, 'admitted');
+    const foldedBy = ownDataField(raw, 'foldedBy');
+    if (typeof requested !== 'string' || requested === '' || typeof admitted !== 'string' || admitted === '')
+        return undefined;
+    const fold = SDK_PERMISSION_MODE_ADMISSION_FOLDS.find((w) => w === foldedBy);
+    return fold === undefined ? undefined : Object.freeze({ requested, admitted, foldedBy: fold });
+}
+function switchOutcomeOf(taskId, sent, body) {
+    try {
+        if (body === null || typeof body !== 'object' || Array.isArray(body))
+            return unreadableAnswer();
+        const keys = PERMISSION_MODE_SWITCH_RESULT_KEYS;
+        for (const k of Reflect.ownKeys(body))
+            if (typeof k !== 'string' || !keys.includes(k))
+                return unreadableAnswer();
+        if (ownDataField(body, 'taskId') !== taskId)
+            return unreadableAnswer();
+        const sessionId = ownDataField(body, 'sessionId');
+        if (typeof sessionId !== 'string' || sessionId === '' || ownDataField(body, 'status') !== 'running')
+            return unreadableAnswer();
+        const permissionMode = readPermissionModeReceiptSegment(body, 'permissionMode');
+        if (permissionMode === undefined)
+            return unreadableAnswer();
+        const admissionRaw = ownDataField(body, 'admission');
+        const admission = admissionRaw === undefined ? undefined : admissionOf(admissionRaw);
+        if (admissionRaw !== undefined && admission === undefined)
+            return unreadableAnswer();
+        const asked = admission !== undefined ? admission.requested : permissionMode.requested;
+        if (asked !== undefined && asked !== sent)
+            return unreadableAnswer();
+        if (admission !== undefined && permissionMode.requested !== undefined && permissionMode.requested !== admission.admitted)
+            return unreadableAnswer();
+        const persisted = ownDataField(body, 'persisted');
+        const persistMiss = ownDataField(body, 'persistMiss');
+        const base = { kind: 'switched', taskId, sessionId, permissionMode, ...(admission !== undefined ? { admission } : {}) };
+        if (persisted === true && persistMiss === undefined)
+            return Object.freeze({ ...base, persisted: true });
+        const miss = persisted === false ? SDK_PERMISSION_MODE_PERSIST_MISSES.find((w) => w === persistMiss) : undefined;
+        return miss === undefined ? unreadableAnswer() : Object.freeze({ ...base, persisted: false, persistMiss: miss });
+    }
+    catch {
+        return unreadableAnswer();
+    }
+}
+function failureOutcomeOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    if (v.status === 501)
+        return unavailable();
+    if (v.delivery === 'rejected' && v.status !== undefined) {
+        if (v.status === 404)
+            return Object.freeze({ kind: 'not-found' });
+        if (v.status === 409 && v.code === NOT_RUNNING_CODE)
+            return Object.freeze({ kind: 'not-running' });
+        return Object.freeze({ kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) });
+    }
+    if (v.status === 500 && v.code === PRE_SWITCH_CORRUPT_CODE)
+        return Object.freeze({ kind: 'refused', status: 500, errorCode: v.code });
+    return v.status !== undefined
+        ? Object.freeze({ kind: 'unconfirmed', why: 'server-error', status: v.status })
+        : Object.freeze({ kind: 'unconfirmed', why: 'transport' });
+}
+export async function setRunPermissionMode(runs, taskId, mode, opts = {}) {
+    if (!permissionModeWriteAvailable(guardedSlot(opts, 'permissionModeWrite')))
+        return unavailable();
+    const verb = guardedSlot(runs, 'setPermissionMode');
+    if (typeof verb !== 'function')
+        return unavailable();
+    const sessionId = guardedSlot(opts, 'sessionId');
+    const signal = guardedSlot(opts, 'signal');
+    const callOpts = {
+        ...(typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {}),
+        ...(signal !== undefined && signal !== null ? { signal: signal } : {}),
+    };
+    let body;
+    try {
+        body = await verb.call(runs, taskId, mode, callOpts);
+    }
+    catch (e) {
+        return failureOutcomeOf(e);
+    }
+    return switchOutcomeOf(taskId, mode, body);
+}
+export function runPermissionModeSwitchLine(outcome, lang) {
+    switch (outcome.kind) {
+        case 'switched': {
+            const mode = displayUntrusted(outcome.permissionMode.effective, { max: 64 });
+            const reason = outcome.admission !== undefined
+                ? msg(outcome.admission.foldedBy === 'entry_floor' ? 'session.permissionModeSwitch.reason.entryFloor' : 'session.permissionModeSwitch.reason.disableAutoMode')
+                : outcome.permissionMode.foldedBy !== undefined
+                    ? msg('session.permissionModeSwitch.reason.engine')
+                    : undefined;
+            const line = renderMessage(reason === undefined ? msg('session.permissionModeSwitch.applied', { mode }) : msg('session.permissionModeSwitch.folded', { mode, reason }), lang);
+            return outcome.persisted ? line : renderMessage(msg('session.permissionModeSwitch.notPersisted', { line }), lang);
+        }
+        case 'not-running':
+            return renderMessage(msg('session.permissionModeSwitch.notRunning'), lang);
+        case 'not-found':
+            return renderMessage(msg('session.permissionModeSwitch.notFound'), lang);
+        case 'refused':
+            return outcome.errorCode !== undefined && isDisplayableWireCode(outcome.errorCode)
+                ? renderMessage(msg('session.permissionModeSwitch.refusedWithCode', { status: String(outcome.status), code: outcome.errorCode }), lang)
+                : renderMessage(msg('session.permissionModeSwitch.refused', { status: String(outcome.status) }), lang);
+        case 'unconfirmed':
+            return renderMessage(msg('session.permissionModeSwitch.unconfirmed'), lang);
+        case 'unavailable':
+            return renderMessage(msg('session.permissionModeSwitch.unavailable'), lang);
+    }
+}

package/dist/runReattachPolicy.d.ts

@@ -1,31 +1,42 @@
+import { type RunNotFollowed } from './runFollow.js';
 export declare const REATTACH_MAX_TRIES = 5;
+export declare const STREAM_CAP_CREDIBLE_AFTER_MS = 300000;
 export interface ReattachBudget {
     readonly tries: number;
     readonly drainingStreak: number;
     readonly drainingTotal: number;
 }
 export declare const REATTACH_BUDGET_FRESH: ReattachBudget;
+export declare const REATTACH_BUDGET_NONE: ReattachBudget;
 export type ReattachEvent = {
     readonly cause: 'connection_lost';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
     readonly error?: object;
 } | {
     readonly cause: 'stream_cap';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
+    readonly legElapsedMs?: number;
 } | {
     readonly cause: 'stream_draining';
-    readonly hasRunId: boolean;
+    readonly runId?: string;
     readonly frame: object;
     readonly madeProgress?: boolean;
+} | {
+    readonly cause: 'stream_draining';
+    readonly runId?: string;
+    readonly ladder: 'exhausted';
 };
-export type ReattachGiveUp = 'no_run_id' | 'budget_exhausted' | 'bad_input';
+export type ReattachDrainingEvent = Extract<ReattachEvent, {
+    readonly cause: 'stream_draining';
+}>;
 export type ReattachDecision = {
     readonly action: 'reattach';
     readonly afterMs: number;
+    readonly premature?: true;
     readonly budget: ReattachBudget;
 } | {
     readonly action: 'give_up';
-    readonly reason: ReattachGiveUp;
     readonly budget: ReattachBudget;
+    readonly notFollowed: RunNotFollowed<'reattach_exhausted' | 'no_run_id' | 'bad_input'>;
 };
 export declare function runReattachPolicy(budget: ReattachBudget, event: ReattachEvent): ReattachDecision;

package/dist/runReattachPolicy.js

@@ -1,46 +1,94 @@
 import { STREAM_DRAINING_RECONNECT_MAX, drainingRetryDelayMs, isPreStreamDrainingReject } from './wireErrorTriage.js';
 import { drainingLegStep } from './streamDrainingLegs.js';
+import { mintRunNotFollowed } from './runFollow.js';
 export const REATTACH_MAX_TRIES = 5;
+export const STREAM_CAP_CREDIBLE_AFTER_MS = 300_000;
+const connectionLostBackoffMs = (n) => 1000 * n;
 const DRAINING_TOTAL_MAX = REATTACH_MAX_TRIES * STREAM_DRAINING_RECONNECT_MAX;
 export const REATTACH_BUDGET_FRESH = Object.freeze({ tries: 0, drainingStreak: 0, drainingTotal: 0 });
+export const REATTACH_BUDGET_NONE = Object.freeze({ tries: REATTACH_MAX_TRIES, drainingStreak: 0, drainingTotal: DRAINING_TOTAL_MAX });
 const isCount = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
-const giveUp = (reason, budget) => Object.freeze({ action: 'give_up', reason, budget });
-const reattach = (afterMs, tries, drainingStreak, drainingTotal) => Object.freeze({ action: 'reattach', afterMs, budget: Object.freeze({ tries, drainingStreak, drainingTotal }) });
+const giveUp = (notFollowed, budget) => Object.freeze({ action: 'give_up', budget, notFollowed });
+const reattach = (afterMs, tries, drainingStreak, drainingTotal, premature) => Object.freeze({ action: 'reattach', afterMs, ...(premature === true ? { premature } : {}), budget: Object.freeze({ tries, drainingStreak, drainingTotal }) });
 export function runReattachPolicy(budget, event) {
+    let handle;
     try {
-        if (typeof budget !== 'object' || budget === null || !isCount(budget.tries) || !isCount(budget.drainingStreak) || !isCount(budget.drainingTotal))
-            return giveUp('bad_input', REATTACH_BUDGET_FRESH);
-        if (typeof event !== 'object' || event === null || typeof event.hasRunId !== 'boolean')
-            return giveUp('bad_input', budget);
-        if (!event.hasRunId)
-            return giveUp('no_run_id', budget);
+        const eventOk = typeof event === 'object' && event !== null;
+        const runId = eventOk ? event.runId : undefined;
+        handle = typeof runId === 'string' && runId !== '' ? runId : undefined;
+        const budgetOk = typeof budget === 'object' && budget !== null && isCount(budget.tries) && isCount(budget.drainingStreak) && isCount(budget.drainingTotal);
+        const keep = budgetOk ? budget : REATTACH_BUDGET_FRESH;
+        if (!eventOk)
+            return giveUp(mintRunNotFollowed('bad_input'), keep);
+        const bad = () => giveUp(mintRunNotFollowed('bad_input', handle), keep);
+        if (!budgetOk)
+            return bad();
+        const cause = event.cause;
+        if (cause !== 'connection_lost' && cause !== 'stream_cap' && cause !== 'stream_draining')
+            return bad();
+        let draining;
+        if (cause === 'stream_draining') {
+            const ladder = event.ladder;
+            const frame = event.frame;
+            if ((ladder === undefined) === (frame === undefined))
+                return bad();
+            if (ladder !== undefined) {
+                if (ladder !== 'exhausted')
+                    return bad();
+                draining = { ladder: true };
+            }
+            else {
+                const madeProgress = event.madeProgress;
+                const streak = madeProgress === true ? 0 : budget.drainingStreak;
+                const st = drainingLegStep(streak, frame);
+                if ('giveUp' in st.decision && st.decision.giveUp === 'not_draining_end')
+                    return bad();
+                draining = { step: st };
+            }
+        }
+        let premature = false;
+        if (cause === 'stream_cap') {
+            const legElapsedMs = event.legElapsedMs;
+            if (legElapsedMs !== undefined) {
+                if (typeof legElapsedMs !== 'number' || !Number.isFinite(legElapsedMs) || legElapsedMs < 0)
+                    return bad();
+                premature = legElapsedMs < STREAM_CAP_CREDIBLE_AFTER_MS;
+            }
+        }
+        if (runId === undefined)
+            return giveUp(mintRunNotFollowed('no_run_id'), keep);
+        if (handle === undefined)
+            return bad();
+        const exhausted = (brk) => giveUp(mintRunNotFollowed('reattach_exhausted', handle, brk), budget);
         const { tries, drainingStreak, drainingTotal } = budget;
-        if (event.cause === 'connection_lost') {
+        if (cause === 'connection_lost') {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
+                return exhausted(cause);
+            const error = event.error;
             const next = tries + 1;
-            const afterMs = isPreStreamDrainingReject(event.error) ? drainingRetryDelayMs(event.error, next - 1) : 1000 * next;
+            const afterMs = isPreStreamDrainingReject(error) ? drainingRetryDelayMs(error, next - 1) : connectionLostBackoffMs(next);
             return reattach(afterMs, next, 0, drainingTotal);
         }
-        if (event.cause === 'stream_cap') {
+        if (cause === 'stream_cap') {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
+                return exhausted(cause);
+            if (premature)
+                return reattach(connectionLostBackoffMs(tries + 1), tries + 1, 0, drainingTotal, true);
             return reattach(0, tries + 1, 0, drainingTotal);
         }
-        if (event.cause === 'stream_draining') {
-            const streak = event.madeProgress === true ? 0 : drainingStreak;
-            const { decision, streak: nextStreak } = drainingLegStep(streak, event.frame);
-            if ('reconnectAfterMs' in decision && drainingTotal < DRAINING_TOTAL_MAX)
-                return reattach(decision.reconnectAfterMs, tries, nextStreak, drainingTotal + 1);
-            if ('giveUp' in decision && decision.giveUp === 'not_draining_end')
-                return giveUp('bad_input', budget);
+        if (draining === undefined || 'ladder' in draining) {
             if (tries >= REATTACH_MAX_TRIES)
-                return giveUp('budget_exhausted', budget);
-            return reattach(0, tries + 1, nextStreak, drainingTotal);
+                return exhausted(cause);
+            return reattach(0, tries + 1, drainingStreak, drainingTotal);
         }
-        return giveUp('bad_input', budget);
+        const { decision, streak: nextStreak } = draining.step;
+        if ('reconnectAfterMs' in decision && drainingTotal < DRAINING_TOTAL_MAX)
+            return reattach(decision.reconnectAfterMs, tries, nextStreak, drainingTotal + 1);
+        if (tries >= REATTACH_MAX_TRIES)
+            return exhausted(cause);
+        return reattach(0, tries + 1, nextStreak, drainingTotal);
     }
     catch {
-        return giveUp('bad_input', REATTACH_BUDGET_FRESH);
+        return giveUp(mintRunNotFollowed('bad_input', handle), REATTACH_BUDGET_FRESH);
     }
 }