@sema-agent/client-core 0.96.0 → 0.97.1

package/dist/storePostureCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { storeSeatOf, createEngineCapReader } from './engineCapReader.js';
+import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
@@ -44,7 +44,6 @@ function projectStorePostureOf(caps) {
 const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
@@ -54,7 +53,7 @@ function presentView(reading) {
         return undefined;
     try {
         const kind = reading.kind;
-        if (kind === 'not_reported' || kind === 'unobserved')
+        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'unreadable')
             return { kind };
         if (kind !== 'present')
             return undefined;
@@ -89,6 +88,8 @@ const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
 export function storePostureDoctorDetail(reading) {
     const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
     const r = presentView(reading);
+    if (r?.kind === 'unreadable')
+        return unreadableReadingDetail('store posture');
     if (r?.kind === 'not_reported') {
         return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
     }

package/dist/toolHistoryBadTurn.js

@@ -1,10 +1,11 @@
-import { displayUntrusted } from './displayUntrusted.js';
+import { displayUntrusted, markerSafeCut } from './displayUntrusted.js';
 const BAD_TURN_PREVIEW_MAX = 60;
 export function toolHistoryBadTurnSentence(promptText) {
     const text = typeof promptText === 'string' ? promptText : '';
     const washed = displayUntrusted(stripDisplayTagBlocks(text), { mark: 'dot' }).replace(/\s+/g, ' ').trim();
     const points = Array.from(washed);
-    const preview = points.length > BAD_TURN_PREVIEW_MAX ? `${points.slice(0, BAD_TURN_PREVIEW_MAX).join('')}...` : washed;
+    const head = points.length > BAD_TURN_PREVIEW_MAX ? points.slice(0, BAD_TURN_PREVIEW_MAX).join('') : undefined;
+    const preview = head === undefined ? washed : `${washed.slice(0, markerSafeCut(washed, head.length))}...`;
     return preview.length > 0
         ? `The broken record is in the turn you started with "${preview}"; /rewind has that prompt preselected, so restore the conversation to before it.`
         : 'The broken record is in the turn /rewind has preselected; restore the conversation to before it.';

package/dist/toolResult.d.ts

@@ -92,6 +92,17 @@ export interface ToolResultBody {
     degraded?: typeof TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT;
 }
 export declare function degradedToolResultBody(isError: boolean): ToolResultBody;
+export type ToolCardDegradedCause = 'not-executed' | 'error-without-detail' | 'no-result' | 'unrecognised';
+export type ToolCardOutcomeReading = {
+    readonly kind: 'normal';
+} | {
+    readonly kind: 'degraded';
+    readonly cause: ToolCardDegradedCause;
+    readonly text: string;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readToolCardOutcome(record: object | null | undefined): ToolCardOutcomeReading;
 export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean): ToolResultBody;
 export declare function structuredToToolUseResult(structured: unknown, modelText?: string, leaderLedger?: boolean): {
     toolUseResult: unknown;

package/dist/toolResult.js

@@ -4,6 +4,7 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
+import { readFrameTrueMark } from './ownKey.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
@@ -276,6 +277,58 @@ export const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT = 'wire_carried_no_output';
 export function degradedToolResultBody(isError) {
     return { content: '', isError, degraded: TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT };
 }
+const TOOL_CARD_DEGRADED_TEXT = {
+    'not-executed': 'This tool call did not run: the engine closed it without executing it.',
+    'error-without-detail': 'This tool call reported an error but returned no details.',
+    'no-result': 'No result was reported for this tool call, so whether it ran and what it did is not shown here — check before running it again.',
+    unrecognised: 'This tool call carries a result marker this client does not recognise, so no result is shown for it.',
+};
+const cardDegraded = (cause) => ({ kind: 'degraded', cause, text: TOOL_CARD_DEGRADED_TEXT[cause] });
+function cardOwnData(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    if (d === undefined)
+        return undefined;
+    if (!Object.hasOwn(d, 'value'))
+        throw new TypeError(`own property "${key}" is an accessor`);
+    return d.value;
+}
+const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function toolResultBlockOf(record) {
+    const message = cardOwnData(record, 'message');
+    if (!isCardRecordObject(message))
+        return undefined;
+    const content = cardOwnData(message, 'content');
+    if (!Array.isArray(content))
+        return undefined;
+    for (let i = 0; i < content.length; i++) {
+        const block = cardOwnData(content, String(i));
+        if (isCardRecordObject(block) && cardOwnData(block, 'type') === 'tool_result')
+            return block;
+    }
+    return undefined;
+}
+export function readToolCardOutcome(record) {
+    try {
+        if (!isCardRecordObject(record))
+            return { kind: 'unreadable' };
+        const block = toolResultBlockOf(record);
+        if (block === undefined)
+            return { kind: 'unreadable' };
+        if (readFrameTrueMark(record, '_sema_not_executed'))
+            return cardDegraded('not-executed');
+        const markerDesc = Object.getOwnPropertyDescriptor(record, '_sema_degraded');
+        if (markerDesc === undefined)
+            return { kind: 'normal' };
+        if (!Object.hasOwn(markerDesc, 'value'))
+            return { kind: 'unreadable' };
+        if (markerDesc.value !== TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT)
+            return cardDegraded('unrecognised');
+        return cardDegraded(cardOwnData(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
 export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true) {
     const text = flatten(output);
     const name = (toolName || '').toLowerCase();

package/dist/userInvokedSkillsCapability.d.ts

@@ -1,5 +1,7 @@
 export type UserInvokedSkillsReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/userInvokedSkillsCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectUserInvokedSkillsCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectUserInvokedSkillsCapability(caps) {
 const reader = createEngineCapReader({
     name: 'userInvokedSkills',
     project: projectUserInvokedSkillsCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function userInvokedSkillsAvailable(reading) {
 }
 export function userInvokedSkillsDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('user-invoked skills');
         case 'unobserved':
             return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':

package/dist/webSearchBackendCapability.d.ts

@@ -4,6 +4,8 @@ export interface WebSearchBackendCapabilityView {
 }
 export type WebSearchBackendReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/webSearchBackendCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export const WEB_SEARCH_BACKEND_NONE = 'none';
 export function projectWebSearchBackendCapability(caps) {
@@ -28,7 +28,6 @@ export function projectWebSearchBackendCapability(caps) {
 const reader = createEngineCapReader({
     name: 'webSearch.backend',
     project: projectWebSearchBackendCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWebSearchBackend(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -40,6 +39,8 @@ const WS_DETAIL_MAX = 40;
 const DEPLOY_ENV = 'WEB_SEARCH_PROVIDER';
 export function webSearchBackendDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('deployment default backend');
         case 'unobserved':
             return ('deployment default backend not observed — the engine reports it on /v1/capabilities; ' +
                 'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');

package/dist/wireErrorTriage.js

@@ -1,27 +1,51 @@
-import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
+import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
-import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
+import { DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|\bterminated\b|\bother side closed\b/i;
-function wireErrorDetail(err) {
-    const e = err;
-    const cause = e?.cause;
-    return ((typeof cause?.message === 'string' && cause.message.length > 0 && cause.message) ||
-        (typeof e?.message === 'string' && e.message.length > 0 && e.message) ||
-        String(err));
+function readTurnErrorSlots(err) {
+    if (err === null || err === undefined)
+        return { status: undefined, errorCode: undefined, message: undefined, cause: undefined, name: undefined };
+    return {
+        status: readThrownSlot(err, 'status', 'data'),
+        errorCode: readThrownSlot(err, 'errorCode', 'data'),
+        message: readThrownSlot(err, 'message'),
+        cause: readThrownSlot(err, 'cause'),
+        name: typeof err === 'object' ? readThrownSlot(err, 'name') : undefined,
+    };
+}
+function renderedText(err) {
+    try {
+        return String(err);
+    }
+    catch {
+        return WIRE_FAILURE_UNRENDERABLE_TEXT;
+    }
+}
+function wireErrorDetailOf(slots, err) {
+    const causeMessage = slots.cause === undefined || slots.cause === THROWN_SLOT_UNREADABLE ? undefined : readThrownSlot(slots.cause, 'message');
+    return ((typeof causeMessage === 'string' && causeMessage.length > 0 && causeMessage) ||
+        (typeof slots.message === 'string' && slots.message.length > 0 && slots.message) ||
+        renderedText(err));
+}
+function isTransportShape(slots, detail) {
+    if (typeof slots.status === 'number' || slots.status === THROWN_SLOT_UNREADABLE)
+        return false;
+    return (slots.cause !== undefined && slots.cause !== THROWN_SLOT_UNREADABLE) || WIRE_NETWORK_ERROR_PATTERN.test(detail());
 }
 export function classifyTurnWireError(err) {
-    const e = err;
-    if (typeof e?.status === 'number') {
-        const errorCode = typeof e.errorCode === 'string' && e.errorCode.length > 0 ? e.errorCode : undefined;
-        const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
-        const storedRowWhere = corruptStoredRowWhere(err);
-        const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
-        const leaseUnavailable = fleetLeaseUnavailableFromError(err) !== null;
+    const slots = readTurnErrorSlots(err);
+    if (typeof slots.status === 'number') {
+        const errorCode = typeof slots.errorCode === 'string' && slots.errorCode.length > 0 ? slots.errorCode : undefined;
+        const message = typeof slots.message === 'string' && slots.message.length > 0 ? slots.message : renderedText(err);
+        const effectiveCode = typeof err === 'object' && err !== null ? foldedWireErrorCode(err, errorCode) : undefined;
+        const storedRowWhere = typeof err === 'object' && err !== null ? storedRowWhereOf(err, effectiveCode) : undefined;
+        const sessionUnreadable = isCorruptSessionCode(effectiveCode);
+        const leaseUnavailable = slots.errorCode === FLEET_LEASE_UNAVAILABLE && fleetLeaseUnavailableFromError(err) !== null;
         return {
             kind: 'http',
-            status: e.status,
+            status: slots.status,
             ...(errorCode !== undefined ? { errorCode } : {}),
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
@@ -29,27 +53,21 @@ export function classifyTurnWireError(err) {
             ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
         };
     }
-    const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'
-        ? err.name
-        : undefined;
-    if (errName === 'StreamEndedWithoutTerminalError') {
+    if (slots.status !== THROWN_SLOT_UNREADABLE && slots.name === 'StreamEndedWithoutTerminalError') {
         return { kind: 'stream-ended-without-terminal' };
     }
-    const detail = wireErrorDetail(err);
-    const isNetwork = e?.cause !== undefined || WIRE_NETWORK_ERROR_PATTERN.test(detail);
-    if (isNetwork)
+    const detail = wireErrorDetailOf(slots, err);
+    if (isTransportShape(slots, () => detail))
         return { kind: 'transport', detail };
-    return { kind: 'internal', name: err instanceof Error ? err.name : typeof err, detail };
+    const name = thrownIsInstanceOf(err, Error) && slots.name !== THROWN_SLOT_UNREADABLE ? slots.name : typeof err;
+    return { kind: 'internal', name, detail };
 }
 export function isWireTransportError(err) {
-    const e = err;
-    if (typeof e?.status === 'number')
-        return false;
-    return e?.cause !== undefined || WIRE_NETWORK_ERROR_PATTERN.test(wireErrorDetail(err));
+    const slots = readTurnErrorSlots(err);
+    return isTransportShape(slots, () => wireErrorDetailOf(slots, err));
 }
 export function isPreStreamDrainingReject(err) {
-    const e = err;
-    return typeof e?.status === 'number' && e.status === 503 && e.errorCode === DRAINING_ERROR_CODE;
+    return readThrownSlot(err, 'status', 'data') === 503 && readThrownSlot(err, 'errorCode', 'data') === DRAINING_ERROR_CODE;
 }
 export function effectiveWireErrorCode(err) {
     if (typeof err !== 'object' || err === null)
@@ -62,13 +80,20 @@ export function effectiveWireErrorCode(err) {
         outerRaw = undefined;
     }
     const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
+    return foldedWireErrorCode(err, outer);
+}
+function foldedWireErrorCode(err, outer) {
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return outer;
     const inner = readBlockedBy(err);
     return inner.kind === 'named' ? inner.code : outer;
 }
 export function corruptStoredRowWhere(err) {
-    if (effectiveWireErrorCode(err) !== 'corrupt')
+    const code = effectiveWireErrorCode(err);
+    return typeof err === 'object' && err !== null ? storedRowWhereOf(err, code) : undefined;
+}
+function storedRowWhereOf(err, effectiveCode) {
+    if (effectiveCode !== 'corrupt')
         return undefined;
     const where = readErrorString(err, 'where');
     return where !== undefined && where.trim().length > 0 ? where : undefined;
@@ -81,7 +106,7 @@ export function isResumeAtRejection(err) {
     return code !== undefined && code.startsWith(RESUME_AT_ERROR_CODE_PREFIX);
 }
 export function drainingRetryDelayMs(err, attempt, opts) {
-    const ra = err?.retryAfterMs;
+    const ra = readThrownSlot(err, 'retryAfterMs', 'data');
     if (typeof ra === 'number' && Number.isFinite(ra) && ra >= 0) {
         return Math.min(ra, opts?.retryAfterCapMs ?? 15_000);
     }
@@ -183,8 +208,7 @@ export function scenarioNotAllowedContent(detail, requestedScenario, surface) {
 export function resumeRetryLaterFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const e = err;
-    const code = e.errorCode;
+    const code = readThrownSlot(err, 'errorCode', 'data');
     if (typeof code !== 'string' || !RESUME_RETRY_LATER_CODES.includes(code))
         return null;
     const sec = readErrorNumber(err, 'retryAfterSec');

package/dist/wireFailureShape.d.ts

@@ -10,7 +10,7 @@ interface WireFailureShape {
     message: string;
 }
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
-export declare function readThrownSlot(o: unknown, key: string, own?: boolean): unknown;
+export declare function readThrownSlot(o: unknown, key: string, own?: boolean | 'data'): unknown;
 export declare function thrownIsInstanceOf<C extends abstract new (...args: never[]) => unknown>(e: unknown, cls: C): e is InstanceType<C>;
 export type ThrownExtraReading = {
     readonly state: 'object';

package/dist/wireFailureShape.js

@@ -1,6 +1,12 @@
+import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function readThrownSlot(o, key, own = false) {
     try {
+        if (own === 'data') {
+            if (o === null || o === undefined)
+                return THROWN_SLOT_UNREADABLE;
+            return typeof o === 'object' || typeof o === 'function' ? ownDataField(o, key) : undefined;
+        }
         if (own && !Object.hasOwn(o, key))
             return undefined;
         return o[key];
@@ -21,12 +27,75 @@ export function thrownIsInstanceOf(e, cls) {
         return false;
     }
 }
+const EXTRA_KEY = 'extra';
+const EXTRA_CHAIN_DEPTH_MAX = 64;
+function extraSlotOf(o) {
+    let node = o;
+    for (let depth = 0; node !== null; depth++) {
+        if (depth > EXTRA_CHAIN_DEPTH_MAX)
+            throw new RangeError('prototype chain too deep to read');
+        const d = Object.getOwnPropertyDescriptor(node, EXTRA_KEY);
+        if (d !== undefined) {
+            const isData = Object.hasOwn(d, 'value');
+            if (node === o)
+                return isData ? { kind: 'own-data', value: d.value } : { kind: 'own-accessor' };
+            return !isData && typeof d.get === 'function' && isSdkErrorClassPrototype(node) ? { kind: 'sdk-class' } : { kind: 'none' };
+        }
+        node = Object.getPrototypeOf(node);
+    }
+    return { kind: 'none' };
+}
+function isSdkErrorClassPrototype(holder) {
+    if (holder === Object.prototype || !isClassPrototype(holder))
+        return false;
+    let node = Object.getPrototypeOf(holder);
+    for (let depth = 0; node !== null; depth++) {
+        if (depth > EXTRA_CHAIN_DEPTH_MAX)
+            throw new RangeError('prototype chain too deep to read');
+        if (isBuiltinErrorPrototype(node))
+            return true;
+        node = Object.getPrototypeOf(node);
+    }
+    return false;
+}
+function classConstructorOf(node) {
+    const ctor = Object.getOwnPropertyDescriptor(node, 'constructor');
+    if (ctor === undefined || !Object.hasOwn(ctor, 'value') || typeof ctor.value !== 'function')
+        return undefined;
+    const fn = ctor.value;
+    const p = Object.getOwnPropertyDescriptor(fn, 'prototype');
+    return p !== undefined && Object.hasOwn(p, 'value') && p.value === node ? fn : undefined;
+}
+function isClassPrototype(node) {
+    return classConstructorOf(node) !== undefined;
+}
+const BUILTIN_ERROR_SOURCE = /^function Error\(\)\s*\{\s*\[native code\]\s*\}$/;
+function isBuiltinErrorPrototype(node) {
+    const fn = classConstructorOf(node);
+    if (fn === undefined)
+        return false;
+    const n = Object.getOwnPropertyDescriptor(fn, 'name');
+    if (n === undefined || !Object.hasOwn(n, 'value') || n.value !== 'Error')
+        return false;
+    if (!BUILTIN_ERROR_SOURCE.test(Function.prototype.toString.call(fn)))
+        return false;
+    return ['message', 'name', 'toString'].every((k) => Object.getOwnPropertyDescriptor(node, k) !== undefined);
+}
 export function readThrownExtra(o) {
-    if (o === null || o === undefined)
+    if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
         return { state: 'absent' };
-    const slot = readThrownSlot(o, 'extra');
-    if (slot === THROWN_SLOT_UNREADABLE)
+    let slot;
+    try {
+        const at = extraSlotOf(o);
+        if (at.kind === 'own-accessor')
+            return { state: 'unreadable' };
+        if (at.kind === 'none')
+            return { state: 'absent' };
+        slot = at.kind === 'own-data' ? at.value : Reflect.get(o, EXTRA_KEY);
+    }
+    catch {
         return { state: 'unreadable' };
+    }
     try {
         if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
             return { state: 'absent' };
@@ -38,27 +107,15 @@ export function readThrownExtra(o) {
 }
 function readErrorSlot(obj, key, accept) {
     try {
-        const o = obj;
-        let top;
-        try {
-            top = o[key];
-        }
-        catch {
-            top = undefined;
-        }
+        const topRaw = readThrownSlot(obj, key, 'data');
+        const top = topRaw === THROWN_SLOT_UNREADABLE ? undefined : topRaw;
         if (accept(top))
             return top;
         const reading = readThrownExtra(obj);
         if (reading.state !== 'object')
             return undefined;
         const extra = reading.value;
-        let fromExtra;
-        try {
-            fromExtra = Object.hasOwn(extra, key) ? extra[key] : undefined;
-        }
-        catch {
-            fromExtra = undefined;
-        }
+        const fromExtra = guardedRead(() => readOwnDataValue(extra, key));
         return accept(fromExtra) ? fromExtra : undefined;
     }
     catch {
@@ -217,13 +274,7 @@ export function readBlockedBy(o) {
 }
 export function readRefusalField(o) {
     const str = (rec) => {
-        let v;
-        try {
-            v = rec.field;
-        }
-        catch {
-            return undefined;
-        }
+        const v = guardedRead(() => readOwnDataValue(rec, 'field'));
         return typeof v === 'string' && v !== '' ? v : undefined;
     };
     const reading = readThrownExtra(o);

package/dist/workflowsJournalCapability.d.ts

@@ -1,5 +1,7 @@
 export type WorkflowsJournalReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/workflowsJournalCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectWorkflowsJournalCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectWorkflowsJournalCapability(caps) {
 const reader = createEngineCapReader({
     name: 'workflowsJournal',
     project: projectWorkflowsJournalCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function workflowsJournalAvailable(reading) {
 }
 export function workflowsJournalDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('workflow journal');
         case 'unobserved':
             return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':

package/dist/writeProtectionCapability.d.ts

@@ -3,6 +3,8 @@ export interface WriteProtectionCapabilityView extends Pick<WriteProtectionCapab
 }
 export type WriteProtectionReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/writeProtectionCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectWriteProtectionCapability(caps) {
     try {
@@ -65,7 +65,6 @@ export function projectWriteProtectionPosture(wiring) {
 const reader = createEngineCapReader({
     name: 'writeProtection',
     project: projectWriteProtectionCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWriteProtection(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -76,6 +75,8 @@ export function observedWriteProtection(baseUrl = engineWireTarget()?.baseUrl) {
 const WP_DETAIL_MAX = 40;
 export function writeProtectionDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail();
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
                 'capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');