@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/selfOrchestrationDenial.js

@@ -1,30 +1,18 @@
 import { CAPABILITY_SELF_ORCHESTRATION_REQUIRED } from './engineErrorCodes.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 const ENTITLEMENT_RESOLVER_ABSENT = 'entitlement_resolver_absent';
 export const SELF_ORCHESTRATION_RETRY_WITHOUT = Object.freeze(['selfOrchestration', 'settings.ultracode']);
 export function classifySelfOrchestrationRefusal(e) {
-    let status;
-    let code;
-    try {
-        const o = e;
-        const rawStatus = o?.status;
-        const rawCode = o?.errorCode;
-        status = typeof rawStatus === 'number' ? rawStatus : undefined;
-        code = typeof rawCode === 'string' ? rawCode : undefined;
-    }
-    catch {
-        return null;
-    }
+    const rawStatus = readThrownSlot(e, 'status', 'data');
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    const status = typeof rawStatus === 'number' ? rawStatus : undefined;
+    const code = typeof rawCode === 'string' ? rawCode : undefined;
     if (status !== 501)
         return null;
     if (code !== CAPABILITY_SELF_ORCHESTRATION_REQUIRED)
         return null;
-    let denial;
-    try {
-        denial = e?.denial;
-    }
-    catch {
-        denial = undefined;
-    }
+    const rawDenial = readThrownSlot(e, 'denial', 'data');
+    const denial = rawDenial === THROWN_SLOT_UNREADABLE ? undefined : rawDenial;
     return {
         kind: 'self-orchestration-denied',
         retryWithout: SELF_ORCHESTRATION_RETRY_WITHOUT,

package/dist/sessionIdSegment.d.ts

@@ -1 +1,7 @@
 export declare function isSessionIdPathSegment(id: unknown): id is string;
+export type SessionIdRefusalWhy = 'not_string' | 'bad_shape' | 'bad_version' | 'bad_variant';
+export interface SessionIdRefusal {
+    readonly why: SessionIdRefusalWhy;
+}
+export declare function canonicalSessionIdOf(raw: {} | null | undefined): string | null;
+export declare function sessionIdRefusalOf(raw: {} | null | undefined): SessionIdRefusal | null;

package/dist/sessionIdSegment.js

@@ -9,3 +9,27 @@ export function isSessionIdPathSegment(id) {
         return false;
     }
 }
+const UUID_ANY_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function sessionIdReadingOf(raw) {
+    if (typeof raw !== 'string')
+        return { id: null, why: 'not_string' };
+    const folded = raw.replace(/[A-F]/g, (c) => c.toLowerCase());
+    if (UUID_ANY_RE.test(folded))
+        return { id: folded, why: null };
+    const version = folded.charAt(14);
+    const variant = folded.charAt(19);
+    const hex = '0123456789abcdef';
+    if (folded.length !== 36 || !hex.includes(version) || !hex.includes(variant))
+        return { id: null, why: 'bad_shape' };
+    const probe = `${folded.slice(0, 14)}4${folded.slice(15, 19)}8${folded.slice(20)}`;
+    if (!UUID_ANY_RE.test(probe))
+        return { id: null, why: 'bad_shape' };
+    return { id: null, why: '12345678'.includes(version) ? 'bad_variant' : 'bad_version' };
+}
+export function canonicalSessionIdOf(raw) {
+    return sessionIdReadingOf(raw).id;
+}
+export function sessionIdRefusalOf(raw) {
+    const r = sessionIdReadingOf(raw);
+    return r.why === null ? null : Object.freeze({ why: r.why });
+}

package/dist/sessionMemoryStatus.js

@@ -1,17 +1,12 @@
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 export function classifyMemoryStatusFailure(e) {
-    let code;
-    let status;
-    try {
-        const o = e;
-        const rawCode = o?.errorCode;
-        const rawStatus = o?.status;
-        code = typeof rawCode === 'string' ? rawCode : undefined;
-        status = typeof rawStatus === 'number' ? rawStatus : undefined;
-    }
-    catch {
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    const rawStatus = readThrownSlot(e, 'status', 'data');
+    if (rawCode === THROWN_SLOT_UNREADABLE || rawStatus === THROWN_SLOT_UNREADABLE)
         return { kind: 'failed', error: e };
-    }
+    const code = typeof rawCode === 'string' ? rawCode : undefined;
+    const status = typeof rawStatus === 'number' ? rawStatus : undefined;
     if (code !== undefined) {
         if (code.startsWith('capability.'))
             return { kind: 'unsupported', reason: 'capability' };

package/dist/sessionPolicyCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type SessionPolicyReading = {
     kind: 'unobserved';
 } | {
@@ -12,4 +13,4 @@ export type SessionPolicyReading = {
 export declare function projectSessionPolicyCapability(caps: unknown): SessionPolicyReading | undefined;
 export declare function observedSessionPolicy(baseUrl?: string | undefined): SessionPolicyReading;
 export declare function sessionPolicyFaceAvailable(reading: SessionPolicyReading): 'yes' | 'no' | 'unknown';
-export declare function sessionPolicyDoctorDetail(reading: SessionPolicyReading): string;
+export declare function sessionPolicyDoctorDetail(reading: SessionPolicyReading, lang?: UiLanguage): string;

package/dist/sessionPolicyCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectSessionPolicyCapability(caps) {
     try {
@@ -31,17 +32,18 @@ export function sessionPolicyFaceAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function sessionPolicyDoctorDetail(reading) {
+export function sessionPolicyDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.sessionPolicy');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('per-session rule face');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'per-session rule face not observed — the engine reports it on /v1/capabilities (sessionPolicy); 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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'sessionPolicy' }), lang);
         case 'not_reported':
-            return 'per-session rule face not reported by this engine — this binary predates the position itself; it says nothing about whether the face exists, so read the rules rather than writing them blind';
+            return renderMessage(msg('notice.capability.sessionPolicy.notReported'), lang);
         case 'absent':
-            return 'no per-session rule store on this deployment — reading and writing this session’s tool rules is unavailable here';
+            return renderMessage(msg('notice.capability.sessionPolicy.absent'), lang);
         case 'present':
-            return 'per-session rule face on — this session’s tool rules can be read, and a tightening write is accepted or refused by the engine call by call';
+            return renderMessage(msg('notice.capability.sessionPolicy.present'), lang);
     }
 }

package/dist/settingsHooksSalvage.d.ts

@@ -0,0 +1,44 @@
+import type { WireHooksConfig } from './finalVerifyWire.js';
+import type { SettingsDocument } from './host.js';
+import type { HookSettingsSource } from './pluginHooksWire.js';
+export type HooksSalvageOutcome = 'loaded' | 'loaded-partial' | 'rejected';
+export type HooksSalvageDropCode = 'hooks-not-object' | 'unknown-event' | 'event-not-array' | 'matcher-invalid' | 'entry-invalid';
+export type HooksSalvageRejectionCode = 'guard-outside-hooks' | 'hooks-is-matcher' | 'guard-under-unknown-event' | 'guard-event-not-array' | 'guard-matcher-invalid' | 'guard-entry-invalid';
+export interface HooksSalvageDrop {
+    readonly code: HooksSalvageDropCode;
+    readonly path: readonly (string | number)[];
+    readonly field?: string;
+}
+export interface HooksSalvageRejection {
+    readonly code: HooksSalvageRejectionCode;
+    readonly path: readonly (string | number)[];
+    readonly field?: string;
+}
+export type HooksSalvage = {
+    readonly outcome: 'loaded';
+    readonly hooks: WireHooksConfig | undefined;
+    readonly dropped: readonly [];
+    readonly rejections: readonly [];
+} | {
+    readonly outcome: 'loaded-partial';
+    readonly hooks: WireHooksConfig | undefined;
+    readonly dropped: readonly HooksSalvageDrop[];
+    readonly rejections: readonly [];
+} | {
+    readonly outcome: 'rejected';
+    readonly hooks: undefined;
+    readonly dropped: readonly [];
+    readonly rejections: readonly HooksSalvageRejection[];
+};
+export interface HooksSalvageMask {
+    readonly hooksDropped: boolean;
+    eventDropped(event: string): boolean;
+    groupDropped(event: string, groupIndex: number): boolean;
+    entryDropped(event: string, groupIndex: number, hookIndex: number): boolean;
+}
+export declare function hooksSalvageMaskOf(dropped: readonly {
+    readonly path: readonly (string | number)[];
+}[]): HooksSalvageMask;
+export declare function salvageSettingsHooksEntries(doc: SettingsDocument | null | undefined): HooksSalvage;
+export declare const HOOK_SETTINGS_SOURCE_TEXT: Readonly<Record<HookSettingsSource, string>>;
+export declare function settingsHooksSalvageNotice(salvage: HooksSalvage, source: HookSettingsSource, doc?: SettingsDocument | null): string | undefined;

package/dist/settingsHooksSalvage.js

@@ -0,0 +1,211 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
+const _tuplePins = [true, true, true, true, true, true];
+void _tuplePins;
+const _classifierPins = [true, true, true, true, true, true];
+void _classifierPins;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const own = (o, k) => (Object.hasOwn(o, k) ? o[k] : undefined);
+const freezeRow = (row) => Object.freeze(row);
+function pieceOf(p) {
+    return freezeRow({ code: p.code, path: Object.freeze([...p.path]), ...(typeof p.field === 'string' ? { field: p.field } : {}) });
+}
+const EMPTY_MASK = Object.freeze({
+    hooksDropped: false,
+    eventDropped: () => false,
+    groupDropped: () => false,
+    entryDropped: () => false,
+});
+export function hooksSalvageMaskOf(dropped) {
+    if (dropped.length === 0)
+        return EMPTY_MASK;
+    let all = false;
+    const events = new Set();
+    const groups = new Set();
+    const entries = new Set();
+    for (const d of dropped) {
+        const p = d.path;
+        if (p[0] !== 'hooks') {
+            all = true;
+            continue;
+        }
+        if (p.length === 1)
+            all = true;
+        else if (p.length === 2 && typeof p[1] === 'string')
+            events.add(p[1]);
+        else if (p.length === 3 && typeof p[1] === 'string' && typeof p[2] === 'number')
+            groups.add(`${p[1]}\u0000${p[2]}`);
+        else if (p.length === 5 && typeof p[1] === 'string' && typeof p[2] === 'number' && p[3] === 'hooks' && typeof p[4] === 'number')
+            entries.add(`${p[1]}\u0000${p[2]}\u0000${p[4]}`);
+        else
+            all = true;
+    }
+    return Object.freeze({
+        hooksDropped: all,
+        eventDropped: (event) => all || events.has(event),
+        groupDropped: (event, gi) => all || events.has(event) || groups.has(`${event}\u0000${gi}`),
+        entryDropped: (event, gi, hi) => all || events.has(event) || groups.has(`${event}\u0000${gi}`) || entries.has(`${event}\u0000${gi}\u0000${hi}`),
+    });
+}
+function pruneHooks(hooks, mask) {
+    if (mask.hooksDropped || !isRecord(hooks))
+        return undefined;
+    const out = [];
+    for (const event of Object.keys(hooks)) {
+        if (mask.eventDropped(event))
+            continue;
+        const groups = own(hooks, event);
+        if (!Array.isArray(groups)) {
+            out.push([event, groups]);
+            continue;
+        }
+        const keptGroups = [];
+        let changed = false;
+        groups.forEach((group, gi) => {
+            if (mask.groupDropped(event, gi)) {
+                changed = true;
+                return;
+            }
+            const entries = isRecord(group) ? own(group, 'hooks') : undefined;
+            if (!isRecord(group) || !Array.isArray(entries)) {
+                keptGroups.push(group);
+                return;
+            }
+            const keptEntries = entries.filter((_e, hi) => !mask.entryDropped(event, gi, hi));
+            if (keptEntries.length === entries.length) {
+                keptGroups.push(group);
+                return;
+            }
+            changed = true;
+            if (keptEntries.length > 0)
+                keptGroups.push({ ...group, hooks: keptEntries });
+        });
+        if (!changed)
+            out.push([event, groups]);
+        else if (keptGroups.length > 0)
+            out.push([event, keptGroups]);
+    }
+    return out.length > 0 ? Object.fromEntries(out) : undefined;
+}
+export function salvageSettingsHooksEntries(doc) {
+    const r = SETTINGS_CLASSIFY_HOOKS_CONFIG(doc);
+    if (r.outcome === 'rejected') {
+        return Object.freeze({ outcome: 'rejected', hooks: undefined, dropped: Object.freeze([]), rejections: Object.freeze(r.rejections.map(pieceOf)) });
+    }
+    const original = isRecord(doc) ? own(doc, 'hooks') : undefined;
+    if (r.outcome === 'loaded') {
+        return Object.freeze({
+            outcome: 'loaded',
+            hooks: isRecord(original) ? original : undefined,
+            dropped: Object.freeze([]),
+            rejections: Object.freeze([]),
+        });
+    }
+    const dropped = Object.freeze(r.dropped.map(pieceOf));
+    return Object.freeze({
+        outcome: 'loaded-partial',
+        hooks: pruneHooks(original, hooksSalvageMaskOf(dropped)),
+        dropped,
+        rejections: Object.freeze([]),
+    });
+}
+export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
+    policySettings: 'Managed settings',
+    userSettings: 'User settings',
+    projectSettings: 'Project settings',
+    localSettings: 'Local settings',
+    flagSettings: 'Flag settings',
+});
+const SALVAGE_LABEL_MAX = 80;
+const SALVAGE_PIECES_SHOWN = 3;
+const labelOf = (s) => (typeof s === 'number' ? String(s) : displayUntrusted(s, { max: SALVAGE_LABEL_MAX }));
+function receivedOf(v) {
+    if (v === null)
+        return 'null';
+    if (Array.isArray(v))
+        return 'array';
+    return typeof v === 'object' ? 'object' : typeof v;
+}
+function valueAt(doc, path) {
+    let cur = doc;
+    for (const seg of path) {
+        if (typeof seg === 'number')
+            cur = Array.isArray(cur) ? cur[seg] : undefined;
+        else
+            cur = isRecord(cur) ? own(cur, seg) : undefined;
+    }
+    return cur;
+}
+function whereOf(path) {
+    const ev = path[1];
+    const gi = path[2];
+    const hi = path[4];
+    const evText = ev === undefined ? '' : `"${labelOf(ev)}"`;
+    if (typeof gi !== 'number')
+        return evText;
+    return typeof hi === 'number' ? `${evText} (matcher ${gi + 1}, hook ${hi + 1})` : `${evText} (matcher ${gi + 1})`;
+}
+const fieldTail = (field) => (field !== undefined ? ` (field "${labelOf(field)}")` : '');
+function dropPhrase(d, doc) {
+    switch (d.code) {
+        case 'hooks-not-object':
+            return `"hooks" must be an object mapping event names to matcher arrays; received ${receivedOf(valueAt(doc, d.path))}. This field was ignored`;
+        case 'unknown-event':
+            return `Unknown hook event ${whereOf(d.path)} was ignored`;
+        case 'event-not-array':
+            return `Hook event ${whereOf(d.path)} must be an array of matchers; received ${receivedOf(valueAt(doc, d.path))}. This entry was ignored`;
+        case 'matcher-invalid':
+            return `an invalid matcher under hook event ${whereOf(d.path)}${fieldTail(d.field)} was ignored`;
+        case 'entry-invalid':
+            return `an invalid hook under hook event ${whereOf(d.path)}${fieldTail(d.field)} was ignored`;
+    }
+}
+function rejectionPhrase(r) {
+    switch (r.code) {
+        case 'guard-outside-hooks':
+            return `a PreToolUse or PermissionRequest hook is written outside "hooks" (at ${r.path.map(labelOf).join('.') || 'the top level'})`;
+        case 'hooks-is-matcher':
+            return '"hooks" is written as a matcher or a single hook instead of an object of hook events';
+        case 'guard-under-unknown-event':
+            return `${whereOf(r.path)} is not a hook event, but it holds PreToolUse or PermissionRequest hooks`;
+        case 'guard-event-not-array':
+            return `hook event ${whereOf(r.path)} is not an array of matchers`;
+        case 'guard-matcher-invalid':
+            return `a matcher under hook event ${whereOf(r.path)}${fieldTail(r.field)} is invalid or holds a misplaced hook`;
+        case 'guard-entry-invalid':
+            return `a hook under hook event ${whereOf(r.path)}${fieldTail(r.field)} is invalid or holds a misplaced hook`;
+    }
+}
+function joinPhrases(phrases) {
+    const seen = new Set();
+    const uniq = [];
+    for (const p of phrases) {
+        if (seen.has(p.key))
+            continue;
+        seen.add(p.key);
+        uniq.push(p.text);
+    }
+    const shown = uniq.slice(0, SALVAGE_PIECES_SHOWN).join('; ');
+    return uniq.length > SALVAGE_PIECES_SHOWN ? `${shown}; and ${uniq.length - SALVAGE_PIECES_SHOWN} more` : shown;
+}
+const GUARD_RISK_TAIL = 'a PreToolUse or PermissionRequest hook that cannot be loaded may be what guards the permissions declared beside it, so none of the hooks in this file are applied until it is fixed';
+export function settingsHooksSalvageNotice(salvage, source, doc) {
+    const layer = HOOK_SETTINGS_SOURCE_TEXT[source] ?? 'Settings';
+    try {
+        if (salvage.outcome === 'loaded-partial') {
+            const what = joinPhrases(salvage.dropped.map((d) => ({ key: d.path.join('\u0000'), text: dropPhrase(d, doc) })));
+            return `${layer}: ${what}. The rest of this file's hooks are applied.`;
+        }
+        if (salvage.outcome === 'rejected') {
+            const why = joinPhrases(salvage.rejections.map((r) => ({ key: r.path.join('\u0000'), text: rejectionPhrase(r) })));
+            if (source === 'policySettings') {
+                return `${layer}: hooks could not be loaded — ${why}. Requests are not sent while the managed hooks cannot be applied; ask your administrator to fix the managed settings.`;
+            }
+            return `${layer}: hooks were not loaded — ${why}; ${GUARD_RISK_TAIL}.`;
+        }
+        return undefined;
+    }
+    catch {
+        return salvage.outcome === 'loaded' ? undefined : `${layer}: some hooks in this file could not be loaded.`;
+    }
+}

package/dist/skillToolListsCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type SkillToolListsReading = {
     kind: 'unobserved';
 } | {
@@ -12,4 +13,4 @@ export type SkillToolListsReading = {
 export declare function projectSkillToolListsCapability(caps: unknown): SkillToolListsReading | undefined;
 export declare function observedSkillToolLists(baseUrl?: string | undefined): SkillToolListsReading;
 export declare function skillToolListsAvailable(reading: SkillToolListsReading): 'yes' | 'no' | 'unknown';
-export declare function skillToolListsDoctorDetail(reading: SkillToolListsReading): string;
+export declare function skillToolListsDoctorDetail(reading: SkillToolListsReading, lang?: UiLanguage): string;

package/dist/skillToolListsCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
@@ -30,17 +31,18 @@ export function skillToolListsAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function skillToolListsDoctorDetail(reading) {
+export function skillToolListsDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.skillToolLists');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('skill tool lists');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'skill tool lists not observed — the engine reports it on /v1/capabilities (skillToolLists); 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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'skillToolLists' }), lang);
         case 'not_reported':
-            return 'skill tool lists not reported by this engine — the engine predates them: tool lists on request skills are not read, so they do not limit any tool';
+            return renderMessage(msg('notice.capability.skillToolLists.notReported'), lang);
         case 'absent':
-            return 'skill tool lists off on this deployment — tool lists on request skills are not read';
+            return renderMessage(msg('notice.capability.skillToolLists.absent'), lang);
         case 'present':
-            return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
+            return renderMessage(msg('notice.capability.skillToolLists.present'), lang);
     }
 }

package/dist/sseIdleTriage.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
+import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
 export const SSE_HEARTBEAT_GRACE_ENV = 'SEMA_SSE_HEARTBEAT_GRACE_MS';
 export const SSE_GRACE_MIN_MS = 5_000;
 export const SSE_GRACE_MAX_MS = 600_000;
@@ -27,9 +28,9 @@ export function engineAliveIdleElapsedMs(err) {
     return typeof e.elapsedMs === 'number' && Number.isFinite(e.elapsedMs) ? e.elapsedMs : 0;
 }
 export function isSseIdleError(err) {
-    if (err instanceof SseIdleError)
+    if (thrownIsInstanceOf(err, SseIdleError))
         return true;
-    return err?.name === 'SseIdleError';
+    return readThrownSlot(err, 'name', 'data') === 'SseIdleError';
 }
 export async function probeEngineAlive(baseUrl, timeoutMs = 2_000) {
     return (await sdkProbeHealth(baseUrl, timeoutMs)).alive;

package/dist/subagent/engineSubagentResume.js

@@ -1,5 +1,6 @@
 import { hostLog } from '../host.js';
-import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { isNotFoundFailure, resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
 import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
@@ -25,15 +26,22 @@ const RETENTION_LAPSED_CODES = new Set([
     RESUME_SESSION_NOT_FOUND,
 ]);
 function shapeOf(e) {
-    const o = (e ?? {});
+    const status = readThrownSlot(e ?? {}, 'status', 'data');
+    const errorCode = readThrownSlot(e ?? {}, 'errorCode', 'data');
+    const message = readThrownSlot(e ?? {}, 'message');
+    if (status === THROWN_SLOT_UNREADABLE || errorCode === THROWN_SLOT_UNREADABLE) {
+        return { message: typeof message === 'string' && message !== '' ? message : String(e), unreadable: true };
+    }
     return {
-        ...(typeof o.status === 'number' ? { status: o.status } : {}),
-        ...(typeof o.errorCode === 'string' ? { errorCode: o.errorCode } : {}),
-        message: typeof o.message === 'string' && o.message !== '' ? o.message : String(e),
+        ...(typeof status === 'number' ? { status } : {}),
+        ...(typeof errorCode === 'string' ? { errorCode } : {}),
+        message: typeof message === 'string' && message !== '' ? message : String(e),
     };
 }
 export function classifySubagentResumeFailure(e) {
-    const { status, errorCode, message } = shapeOf(e);
+    const { status, errorCode, message, unreadable } = shapeOf(e);
+    if (unreadable === true)
+        return { reason: 'error', detail: message };
     if (status === undefined && errorCode === undefined) {
         const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
         if (noAnswer !== null)
@@ -63,12 +71,10 @@ export function classifySubagentResumeFailure(e) {
         return { reason: 'row-contended', detail: message };
     if (errorCode === 'resume.row_gone')
         return { reason: 'row-gone', detail: message };
-    if (errorCode === undefined && status === 404)
+    if (isNotFoundFailure(e) !== false)
         return { reason: 'not-found', detail: message };
     if (errorCode === undefined && status === 400)
         return { reason: 'bad-request', detail: message };
-    if (errorCode?.startsWith('not_found.') === true)
-        return { reason: 'not-found', detail: message };
     return { reason: 'error', detail: message };
 }
 export function resolveOwnerRunId(childTaskId, activeRunId) {

package/dist/subagentContentStore.d.ts

@@ -33,6 +33,9 @@ export interface SubagentContentEvent {
     isError?: boolean | undefined;
 }
 export declare function coerceOutput(v: unknown): string | undefined;
+export declare function subagentContentEventOf(ev: {
+    readonly type: string;
+}): SubagentContentEvent | undefined;
 export interface SubagentContentStoreConfig {
     maxBytesPerTask: number;
     maxBytesTotal: number;

package/dist/subagentContentStore.js

@@ -3,6 +3,28 @@ import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     return toolEndOutputText(v);
 }
+export function subagentContentEventOf(ev) {
+    const t = ev.type;
+    if (t !== 'text_delta' && t !== 'reasoning_delta' && t !== 'text' && t !== 'reasoning' && t !== 'tool_start' && t !== 'tool_end')
+        return undefined;
+    const sub = ev;
+    const parent = sub.parentToolCallId;
+    if (typeof parent !== 'string')
+        return undefined;
+    return {
+        type: sub.type,
+        taskId: sub.taskId ?? parent,
+        parentToolCallId: parent,
+        delta: sub.delta,
+        text: sub.text,
+        eventId: sub.eventId,
+        toolCallId: sub.toolCallId,
+        toolName: sub.toolName,
+        args: sub.args,
+        output: coerceOutput(sub.output),
+        isError: sub.isError,
+    };
+}
 const MAX_ITEMS_PER_TASK = 200;
 const MAX_TASKS = 32;
 const NOTIFY_COALESCE_MS = 250;

package/dist/toolHistoryMismatch.js

@@ -1,4 +1,5 @@
 import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
+import { ownDataField } from './ownKey.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -191,8 +192,8 @@ export function classifyToolHistoryMismatch(err) {
     let status;
     let rawMessage;
     try {
-        code = err.code;
-        status = err.status;
+        code = ownDataField(err, 'code');
+        status = ownDataField(err, 'status');
         rawMessage = err.message;
     }
     catch {

package/dist/toolRoster.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface ToolRosterPathTargetView {
     param: string;
     access: string;
@@ -77,8 +78,8 @@ export type HandsSeamReading = {
 export declare function handsSeamReadingOf(view: {
     readonly hands?: WiringManifestHandsView;
 } | null | undefined): HandsSeamReading;
-export declare function handsSeamDetail(reading: HandsSeamReading): string;
-export declare function handsMountedDetail(reading: HandsMountedReading): string;
+export declare function handsSeamDetail(reading: HandsSeamReading, lang?: UiLanguage): string;
+export declare function handsMountedDetail(reading: HandsMountedReading, lang?: UiLanguage): string;
 export declare function toolRosterNames(roster: ToolRosterView | undefined): readonly string[];
 export interface ToolShim {
     name: string;