@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/printToolResultFrame.js

@@ -1,14 +1,8 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
-import { parseModelFacingBash } from './toolResult.js';
-import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
 import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
-function bashExitCodeFailed(toolName, text, structured) {
-    if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
-        return false;
-    return bashExitReadingFailed(bashExitOf(structured, () => parseModelFacingBash(text)));
-}
+import { readFrameTrueMark } from './ownKey.js';
 export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
@@ -21,6 +15,7 @@ export function toolEndResultToUserFrame(arm) {
         isError: arm.isError === true,
     }, undefined, parent === null ? 'leader' : 'subagent');
     const envelope = toolResultEnvelopeParts(outcome);
+    const content = Array.isArray(outcome.body.content) ? outcome.body.content : arm.truncated === true ? `${text}\n…(truncated)` : text;
     return {
         type: 'user',
         message: {
@@ -29,13 +24,14 @@ export function toolEndResultToUserFrame(arm) {
                 {
                     type: 'tool_result',
                     tool_use_id: arm.toolCallId,
-                    content: arm.truncated === true ? `${text}\n…(truncated)` : text,
-                    is_error: arm.isError === true || bashExitCodeFailed(arm.toolName, text, arm.structured),
+                    content,
+                    is_error: outcome.body.isError,
                 },
             ],
         },
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: arm.uuid,

package/dist/promptBlockedCopy.d.ts

@@ -0,0 +1,5 @@
+import type { RunTerminalRead } from './runTerminal.js';
+export declare const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = "UserPromptSubmit operation blocked by hook";
+export declare function runBlockedText(blocked: Extract<RunTerminalRead, {
+    kind: 'blocked';
+}>): string;

package/dist/promptBlockedCopy.js

@@ -0,0 +1,35 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { stripSystemReminderTagTokens, unwrapSystemReminder } from './systemReminderTag.js';
+export const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = 'UserPromptSubmit operation blocked by hook';
+const RUN_BLOCKED_REASONED = 'Run blocked';
+const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
+const HOOK_WORDS_SHOWN_MAX = 1000;
+const CAUSE_CLAUSE = Object.freeze({
+    crashed: 'the hook failed before it answered; the prompt was not submitted',
+    timeout: 'the hook did not answer in time; the prompt was not submitted',
+    cancelled: 'the run was cancelled while the hook was checking the prompt; the prompt was not submitted',
+});
+function shownHookWords(words) {
+    if (words === undefined)
+        return undefined;
+    const shown = stripSystemReminderTagTokens(displayUntrusted(stripSystemReminderTagTokens(words), { max: HOOK_WORDS_SHOWN_MAX })).trim();
+    return shown === '' ? undefined : shown;
+}
+export function runBlockedText(blocked) {
+    const detail = blocked.detail;
+    if (detail !== undefined && detail.kind === 'prompt_blocked_by_hook') {
+        const clause = detail.cause !== 'unrecognized' && Object.hasOwn(CAUSE_CLAUSE, detail.cause) ? CAUSE_CLAUSE[detail.cause] : undefined;
+        const words = shownHookWords(detail.hookReason);
+        if (clause !== undefined)
+            return `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}: ${clause}${words !== undefined ? `\n${words}` : ''}`;
+        return words !== undefined ? `${PROMPT_BLOCKED_BY_HOOK_ROW_LEAD}:\n${words}` : PROMPT_BLOCKED_BY_HOOK_ROW_LEAD;
+    }
+    const reason = blocked.reason;
+    if (reason === undefined)
+        return RUN_BLOCKED_NO_REASON;
+    const unwrapped = unwrapSystemReminder(reason);
+    if (unwrapped === reason)
+        return `${RUN_BLOCKED_REASONED}: ${reason}`;
+    const body = stripSystemReminderTagTokens(unwrapped).trim();
+    return body === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
+}

package/dist/protocolSegment.d.ts

@@ -1,12 +1,15 @@
-export type ProtocolSegment = {
-    readonly kind: 'ok';
+export type RuleToolNameReading = {
+    readonly kind: 'current';
 } | {
-    readonly kind: 'empty';
+    readonly kind: 'retired';
+    readonly currentName?: string;
 } | {
-    readonly kind: 'unminted';
-    readonly minted?: string;
+    readonly kind: 'unprefixed_namespace';
+} | {
+    readonly kind: 'unmintable_segment';
 } | {
     readonly kind: 'unknown';
 };
-export declare function protocolSegmentOf(name: string): ProtocolSegment;
+export declare function ruleToolNameVerdictOf(name: string): RuleToolNameReading;
+export declare function mintedPrefixOf(name: string): string | undefined;
 export declare function clientOwnedServerPrefix(server: string): string | undefined;

package/dist/protocolSegment.js

@@ -1,33 +1,43 @@
-import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
-import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
-export function protocolSegmentOf(name) {
-    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix) && name.slice(prefix.length).split('__')[0] === ''))
-        return { kind: 'empty' };
-    const ns = protocolOf(name);
-    if (ns === undefined)
-        return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };
-    let parsed;
+import { mcpNamespace, mintNamespacePrefix, protocolOf, ruleToolNameJudgement } from './coreValuePorts.js';
+export function ruleToolNameVerdictOf(name) {
+    let kind;
+    let currentName;
     try {
-        parsed = ns.parse(name);
+        const v = ruleToolNameJudgement(name, new Set());
+        if (v === null || typeof v !== 'object')
+            return { kind: 'unknown' };
+        kind = v.kind;
+        if (kind === 'retired')
+            currentName = v.currentName;
     }
     catch {
         return { kind: 'unknown' };
     }
-    const peer = parsed?.peer;
-    if (typeof peer !== 'string')
-        return { kind: 'ok' };
-    if (peer.includes('*'))
-        return { kind: 'unminted' };
-    let minted;
+    switch (kind) {
+        case 'current':
+        case 'unprefixed_namespace':
+        case 'unmintable_segment':
+            return { kind };
+        case 'retired':
+            return typeof currentName === 'string' && currentName !== '' ? { kind, currentName } : { kind };
+        default:
+            return { kind: 'unknown' };
+    }
+}
+export function mintedPrefixOf(name) {
     try {
-        minted = mintNamespacePrefix(ns, peer);
+        const ns = protocolOf(name);
+        if (ns === undefined)
+            return undefined;
+        const peer = ns.parse(name)?.peer;
+        if (typeof peer !== 'string' || peer.includes('*'))
+            return undefined;
+        const minted = mintNamespacePrefix(ns, peer);
+        return typeof minted === 'string' ? minted : undefined;
     }
     catch {
-        return { kind: 'unknown' };
+        return undefined;
     }
-    if (typeof minted !== 'string')
-        return { kind: 'unknown' };
-    return minted === `${ns.prefix}${peer}__` ? { kind: 'ok' } : { kind: 'unminted', minted };
 }
 export function clientOwnedServerPrefix(server) {
     try {

package/dist/providerRejection.d.ts

@@ -1,8 +1,12 @@
 import { type RunTerminalFailureDetail } from './runTerminal.js';
 import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
+export declare const PROVIDER_REJECTION_KINDS: readonly ["schema_invalid", "auth", "rate_limited", "resend_eligible", "unknown"];
+export type ProviderRejectionKind = (typeof PROVIDER_REJECTION_KINDS)[number];
 export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
+    kind: ProviderRejectionKind;
 }
 export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
 export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;
+export declare function providerRejectionKind(detail: RunTerminalFailureDetail | null | undefined): ProviderRejectionKind;

package/dist/providerRejection.js

@@ -18,6 +18,28 @@ function providerStatusTier(status) {
     return UNTIERED;
 }
 const EDITABLE_TIER = 'invalid_request';
+export const PROVIDER_REJECTION_KINDS = Object.freeze(['schema_invalid', 'auth', 'rate_limited', 'resend_eligible', 'unknown']);
+const SCHEMA_INVALID_CODES = new Set([
+    'invalid_type',
+    'missing_required_parameter',
+    'unknown_parameter',
+    'unsupported_parameter',
+    'invalid_function_parameters',
+    'invalid_json_schema',
+]);
+function schemaTierStatus(status) {
+    return status === 400 || status === 422;
+}
+function kindOfStatus(status, code) {
+    const tier = providerStatusTier(status);
+    if (tier === 'authentication_failed')
+        return 'auth';
+    if (tier === 'rate_limit')
+        return 'rate_limited';
+    if (tier === EDITABLE_TIER)
+        return code !== undefined && schemaTierStatus(status) && SCHEMA_INVALID_CODES.has(code) ? 'schema_invalid' : 'resend_eligible';
+    return 'unknown';
+}
 const NOT_BY_EDITING_TAIL = new Map([
     ['authentication_failed', ': check the provider credentials or access for this account.'],
     ['model_not_found', ': the model is not available from this provider — choose another model.'],
@@ -30,26 +52,40 @@ function toolHistoryMismatchCarrier(carrier) {
 }
 const PROVIDER_REJECTED = 'provider_rejected';
 const RESEND_TEXT_STATUS = /\(HTTP (\d{3})\)/;
+function ownDataOf(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}
 export function readProviderRejectionResendKey(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
             return undefined;
-        const got = v;
-        const resend = got.resend;
-        const text = got.text;
+        const resend = ownDataOf(v, 'resend');
+        const text = ownDataOf(v, 'text');
+        const kind = ownDataOf(v, 'kind');
         if (typeof text !== 'string' || (resend !== 'edit_and_resend' && resend !== 'not_by_editing'))
             return undefined;
         const hit = RESEND_TEXT_STATUS.exec(text);
         if (hit === null || hit[1] === undefined)
             return undefined;
-        const again = providerRejectionResend({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
-        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text } : undefined;
+        const rej = readRejection({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
+        if (rej === undefined)
+            return undefined;
+        let wanted;
+        if (kind === undefined)
+            wanted = kindOfStatus(rej.status, undefined);
+        else if (typeof kind === 'string' && PROVIDER_REJECTION_KINDS.includes(kind))
+            wanted = kind;
+        else
+            return undefined;
+        const again = verdictOf(rej.status, wanted);
+        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text, kind: again.kind } : undefined;
     }
     catch {
         return undefined;
     }
 }
-export function providerRejectionResend(detail, carrier) {
+function readRejection(detail) {
     let read;
     try {
         const r = readRunTerminal({ terminal: { kind: 'failed', detail } });
@@ -63,16 +99,41 @@ export function providerRejectionResend(detail, carrier) {
     const status = Object.hasOwn(read, 'status') ? read.status : undefined;
     if (status === undefined)
         return undefined;
-    if (toolHistoryMismatchCarrier(carrier))
+    return { status, code: Object.hasOwn(read, 'code') ? read.code : undefined };
+}
+function schemaInvalidText(status) {
+    return `The model provider rejected the structure of this request (HTTP ${status}) — rewording the message will not fix this. Check that the configured model and endpoint accept this kind of request, or report the problem to whoever runs the engine.`;
+}
+function verdictOf(status, kind) {
+    if (kind === 'schema_invalid') {
+        if (providerStatusTier(status) !== EDITABLE_TIER || !schemaTierStatus(status))
+            return undefined;
+        return { resend: 'not_by_editing', text: schemaInvalidText(status), kind };
+    }
+    if (kind !== kindOfStatus(status, undefined))
         return undefined;
-    const tier = providerStatusTier(status);
-    return tier === EDITABLE_TIER
-        ? {
+    if (kind === 'resend_eligible') {
+        return {
             resend: 'edit_and_resend',
             text: `The model provider rejected this request as sent (HTTP ${status}). Change it — for example shorten it or remove an attachment — and send it again.`,
-        }
-        : {
-            resend: 'not_by_editing',
-            text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(tier) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+            kind,
         };
+    }
+    return {
+        resend: 'not_by_editing',
+        text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(providerStatusTier(status)) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+        kind,
+    };
+}
+export function providerRejectionResend(detail, carrier) {
+    const r = readRejection(detail);
+    if (r === undefined)
+        return undefined;
+    if (toolHistoryMismatchCarrier(carrier))
+        return undefined;
+    return verdictOf(r.status, kindOfStatus(r.status, r.code));
+}
+export function providerRejectionKind(detail) {
+    const r = readRejection(detail);
+    return r === undefined ? 'unknown' : kindOfStatus(r.status, r.code);
 }

package/dist/replayBody.d.ts

@@ -0,0 +1,12 @@
+export interface ReplayRowView {
+    readonly status?: string;
+    readonly errorCode?: string;
+    readonly error?: string;
+    readonly sessionId?: string;
+}
+export interface DoneResultView {
+    readonly replay: boolean;
+    readonly engine: unknown;
+    readonly row?: ReplayRowView;
+}
+export declare function doneResultView(result: unknown): DoneResultView;

package/dist/replayBody.js

@@ -0,0 +1,25 @@
+function guarded(o, k) {
+    try {
+        return o[k];
+    }
+    catch {
+        return undefined;
+    }
+}
+function guardedString(o, k) {
+    const v = guarded(o, k);
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function doneResultView(result) {
+    if (typeof result !== 'object' || result === null || Array.isArray(result))
+        return { replay: false, engine: result };
+    if (guarded(result, 'replay') !== true)
+        return { replay: false, engine: result };
+    const row = {};
+    for (const k of ['status', 'errorCode', 'error', 'sessionId']) {
+        const v = guardedString(result, k);
+        if (v !== undefined)
+            row[k] = v;
+    }
+    return { replay: true, engine: guarded(result, 'result'), row };
+}

package/dist/resumeRefusalCopy.js

@@ -1,6 +1,6 @@
-import { readErrorNumber, readErrorString } from './wireFailureShape.js';
+import { readBlockedBy, readErrorNumber, readErrorString } from './wireFailureShape.js';
 import { readOwnDataNonEmptyString } from './ownKey.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, isRefusedParkCode, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineVersionTier } from './supportFloor.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
@@ -55,22 +55,7 @@ export function resumePolicyBlockFromError(err) {
     }
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return null;
-    const judge = (v) => ({
-        blockedBy: typeof v === 'string' && v.length > 0 ? { kind: 'named', code: v } : { kind: 'unreadable' },
-    });
-    try {
-        const top = o['blockedBy'];
-        if (top !== undefined)
-            return judge(top);
-        const extra = o['extra'];
-        if (typeof extra === 'object' && extra !== null && !Array.isArray(extra) && Object.hasOwn(extra, 'blockedBy')) {
-            return judge(extra['blockedBy']);
-        }
-        return { blockedBy: { kind: 'absent' } };
-    }
-    catch {
-        return { blockedBy: { kind: 'unreadable' } };
-    }
+    return { blockedBy: readBlockedBy(o) };
 }
 export function resumePolicyBlockContent(detail) {
     const b = detail.blockedBy;
@@ -282,7 +267,6 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
     }
     return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
 }
-const REFUSED_PARK_CODES = new Set([CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED]);
 const REFUSED_PARK_FIELD_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
 export function refusedParkFromError(failure) {
     if (typeof failure !== 'object' || failure === null)
@@ -296,7 +280,7 @@ export function refusedParkFromError(failure) {
     catch {
         return null;
     }
-    if (typeof code !== 'string' || !REFUSED_PARK_CODES.has(code))
+    if (typeof code !== 'string' || !isRefusedParkCode(code))
         return null;
     if (status !== undefined && status !== 409)
         return null;
@@ -305,7 +289,7 @@ export function refusedParkFromError(failure) {
     const rawField = code === CHECKPOINT_CONFIG_REFUSED ? readErrorString(failure, 'field') : undefined;
     const field = rawField !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawField) ? rawField : undefined;
     return Object.freeze({
-        code: code,
+        code,
         ...(field !== undefined ? { field } : {}),
         ...(stillPending !== undefined ? { stillPending } : {}),
     });

package/dist/retryStatus.d.ts

@@ -6,6 +6,8 @@ export type RetryStatus = {
     errClass?: BrainRetryErrClass | (string & {});
     retryAtMs?: number;
     errorStatus?: number;
+    providerCondition?: string;
+    providerConditionSource?: string;
     elapsedMs?: number;
     timeoutMs?: number;
     detail?: string;
@@ -17,6 +19,8 @@ export type RetryStatus = {
     errClass?: BrainRetryErrClass | (string & {});
     retryAtMs?: number;
     errorStatus?: number;
+    providerCondition?: string;
+    providerConditionSource?: string;
     terminal?: true;
     error: RetryStatusErrorPayload;
     elapsedMs?: number;
@@ -29,6 +33,8 @@ export type RetryStatus = {
     errClass?: BrainRetryErrClass | (string & {});
     retryAtMs?: number;
     errorStatus?: number;
+    providerCondition?: string;
+    providerConditionSource?: string;
     elapsedMs?: number;
     timeoutMs?: number;
     terminal?: never;
@@ -60,7 +66,9 @@ export interface BrainStatusPayload {
     errClass?: BrainRetryErrClass | (string & {});
     elapsedMs?: number;
     timeoutMs?: number;
+    providerCondition?: string;
+    providerConditionSource?: string;
 }
-export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs"];
+export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource"];
 export declare function mapBrainStatusToRetry(p: BrainStatusPayload, nowMs: number): RetryStatus | null;
 export {};

package/dist/retryStatus.js

@@ -20,6 +20,8 @@ export const BRAIN_STATUS_PAYLOAD_KEYS = [
     'errorStatus',
     'elapsedMs',
     'timeoutMs',
+    'providerCondition',
+    'providerConditionSource',
 ];
 const _brainStatusKeyPin = [true, true];
 void _brainStatusKeyPin;
@@ -33,6 +35,10 @@ export function mapBrainStatusToRetry(p, nowMs) {
     const cause = typeof p.errClass === 'string' && p.errClass.length > 0 ? { errClass: p.errClass } : {};
     const producerTiming = typeof p.retryAtMs === 'number' ? { retryAtMs: p.retryAtMs } : {};
     const failureStatus = typeof p.errorStatus === 'number' ? { errorStatus: p.errorStatus } : {};
+    const providerJudged = {
+        ...(typeof p.providerCondition === 'string' && p.providerCondition.length > 0 ? { providerCondition: p.providerCondition } : {}),
+        ...(typeof p.providerConditionSource === 'string' && p.providerConditionSource.length > 0 ? { providerConditionSource: p.providerConditionSource } : {}),
+    };
     const saneMs = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
     const elapsedMs = saneMs(p.elapsedMs);
     const timeoutMs = saneMs(p.timeoutMs);
@@ -40,9 +46,10 @@ export function mapBrainStatusToRetry(p, nowMs) {
         ...(elapsedMs !== undefined ? { elapsedMs } : {}),
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
     };
-    const stalledDetail = typeof p.detail === 'string' && p.detail.length > 0 ? { detail: p.detail } : {};
+    const stalledShown = typeof p.detail === 'string' && p.detail.length > 0 ? displayUntrusted(p.detail) : '';
+    const stalledDetail = stalledShown.length > 0 ? { detail: stalledShown } : {};
     const shown = (absent) => (typeof p.detail === 'string' ? displayUntrusted(p.detail) : absent);
-    const extra = { ...counts, ...cause, ...producerTiming, ...failureStatus, ...waitProgress };
+    const extra = { ...counts, ...cause, ...producerTiming, ...failureStatus, ...providerJudged, ...waitProgress };
     switch (p.phase) {
         case 'recovered':
             return null;

package/dist/rewindArchiveCapability.d.ts

@@ -1,24 +1,14 @@
+import { type RewindArchiveReading, type RewindCodeArchive } from './rewindArchiveReading.js';
 import type { RewindMode } from './rewindWireCaps.js';
-export type RewindArchiveBit = 'on' | 'off' | 'not_reported' | 'malformed';
-export type RewindArchiveReading = {
-    kind: 'unobserved';
-} | {
-    kind: 'present';
-    conversationAnchor: RewindArchiveBit;
-    forkRestore: RewindArchiveBit;
-    codeOnly: RewindArchiveBit;
-    restoreFilesEpoch: RewindArchiveBit;
-};
+export { projectRewindArchiveCapability, rewindConversationAvailability } from './rewindArchiveReading.js';
+export type { RewindArchiveBit, RewindArchiveReading, RewindCodeArchive } from './rewindArchiveReading.js';
 export type RewindArchiveMode = 'both' | 'code';
-export type RewindCodeArchive = 'available' | 'unavailable' | 'unknown';
-export declare function projectRewindArchiveCapability(caps: unknown): RewindArchiveReading | undefined;
 export declare function noteEngineCapsForRewindArchive(baseUrl: string, caps: unknown, opts?: {
     generation?: number;
 }): void;
 export declare function observedRewindArchive(baseUrl?: string | undefined): RewindArchiveReading;
 export declare function rewindCodeArchiveAvailability(reading: RewindArchiveReading, mode: RewindArchiveMode): RewindCodeArchive;
 export declare function rewindArchiveDoctorDetail(reading: RewindArchiveReading, mode: RewindArchiveMode): string;
-export declare function rewindConversationAvailability(reading: RewindArchiveReading): RewindCodeArchive;
 export declare function engineRewindRefusedNow(option: RewindMode, reading?: RewindArchiveReading): boolean;
 export declare function rewindConversationDoctorDetail(reading: RewindArchiveReading): string;
 export declare function rewindRestoreFilesEpochDetail(reading: RewindArchiveReading): string;

package/dist/rewindArchiveCapability.js

@@ -1,55 +1,13 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
-import { ownDataField } from './ownKey.js';
-import { _wireConversationRewindJudge } from './toolHistoryMismatch.js';
-const CAPS_KEYS = {
-    conversationAnchor: 'resumeAt',
-    forkRestore: 'rewindFiles',
-    codeOnly: 'rewindFilesTo',
-    restoreFilesEpoch: 'restoreFiles',
-};
-const _capsKeyPin = true;
-void _capsKeyPin;
-function bitOf(caps, key) {
-    const v = ownDataField(caps, key);
-    if (v === undefined)
-        return 'not_reported';
-    if (v === true)
-        return 'on';
-    if (v === false)
-        return 'off';
-    return 'malformed';
-}
-export function projectRewindArchiveCapability(caps) {
-    try {
-        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-            return undefined;
-        return {
-            kind: 'present',
-            conversationAnchor: bitOf(caps, CAPS_KEYS.conversationAnchor),
-            forkRestore: bitOf(caps, CAPS_KEYS.forkRestore),
-            codeOnly: bitOf(caps, CAPS_KEYS.codeOnly),
-            restoreFilesEpoch: bitOf(caps, CAPS_KEYS.restoreFilesEpoch),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-const reader = createEngineCapReader({
-    name: 'rewindArchive',
-    project: projectRewindArchiveCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
-});
+import { resetRewindArchiveReader, rewindArchiveReadingAt, rewindConversationAvailability, } from './rewindArchiveReading.js';
+export { projectRewindArchiveCapability, rewindConversationAvailability } from './rewindArchiveReading.js';
 export function noteEngineCapsForRewindArchive(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
-function conversationRewindJudge(engineBaseUrl) {
-    return rewindConversationAvailability(observedRewindArchive(engineBaseUrl));
+    void baseUrl;
+    void caps;
+    void opts;
 }
-_wireConversationRewindJudge(conversationRewindJudge);
 export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
-    return reader.observed(baseUrl);
+    return rewindArchiveReadingAt(baseUrl);
 }
 export function rewindCodeArchiveAvailability(reading, mode) {
     if (reading.kind !== 'present')
@@ -86,15 +44,6 @@ export function rewindArchiveDoctorDetail(reading, mode) {
             return `${lane} reported in a shape this reader cannot read — the value is neither true nor false, so the answer is unknown, not "no"`;
     }
 }
-export function rewindConversationAvailability(reading) {
-    if (reading.kind !== 'present')
-        return 'unknown';
-    if (reading.conversationAnchor === 'on')
-        return 'available';
-    if (reading.conversationAnchor === 'off')
-        return 'unavailable';
-    return 'unknown';
-}
 export function engineRewindRefusedNow(option, reading = observedRewindArchive()) {
     switch (option) {
         case 'both':
@@ -139,5 +88,5 @@ export function rewindRestoreFilesEpochDetail(reading) {
     }
 }
 export function __resetRewindArchiveReadingsForTests() {
-    reader.__resetForTests();
+    resetRewindArchiveReader();
 }

package/dist/rewindArchiveReading.d.ts

@@ -0,0 +1,15 @@
+export type RewindArchiveBit = 'on' | 'off' | 'not_reported' | 'malformed';
+export type RewindArchiveReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'present';
+    conversationAnchor: RewindArchiveBit;
+    forkRestore: RewindArchiveBit;
+    codeOnly: RewindArchiveBit;
+    restoreFilesEpoch: RewindArchiveBit;
+};
+export type RewindCodeArchive = 'available' | 'unavailable' | 'unknown';
+export declare function projectRewindArchiveCapability(caps: unknown): RewindArchiveReading | undefined;
+export declare function rewindArchiveReadingAt(baseUrl: string | undefined): RewindArchiveReading;
+export declare function resetRewindArchiveReader(): void;
+export declare function rewindConversationAvailability(reading: RewindArchiveReading): RewindCodeArchive;