@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/controlRouter.js

@@ -1,7 +1,8 @@
 import { cancelConflictContent, cancelConflictFromError } from './wireRefusalCopy.js';
-import { PROTOCOL_ERROR_NAME, protocolErrorNameOf } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { steerPriorityMode } from './steerPriorityCapability.js';
 import { preemptReadingOfAck, preemptReadingOfError } from './preemptWire.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export class ControlSafetyError extends Error {
     code;
     cause;
@@ -156,10 +157,11 @@ export class ControlRouter {
 export function errCodes(e) {
     if (!e || typeof e !== 'object')
         return {};
-    const o = e;
-    const code = typeof o.errorCode === 'string' ? o.errorCode : undefined;
-    const name = typeof o.name === 'string' ? o.name : undefined;
-    const rawStatus = o.status ?? o.statusCode;
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    const code = typeof rawCode === 'string' ? rawCode : undefined;
+    const rawName = readThrownSlot(e, 'name');
+    const name = typeof rawName === 'string' ? rawName : undefined;
+    const rawStatus = readThrownStatusSlot(e);
     const status = typeof rawStatus === 'number' ? rawStatus : undefined;
     return { code, name, status };
 }
@@ -185,48 +187,32 @@ const STEERING_NAME_TO_SAFETY = {
     SteeringError: 'steering_other',
 };
 const STEERING_COPY = {
-    not_running: {
-        happened: 'that run is not accepting messages right now — it has just finished, is running on another server, or is not the active run of its session',
-        nextStep: 'check its current state and send the message to the run that is active',
-    },
-    invalid_content: {
-        happened: 'the message was refused because its text contains control markers the engine does not accept, so nothing was delivered',
-        nextStep: 'rewrite the message and send it again',
-    },
-    queue_full: {
-        happened: 'that run is paused and already holds as many waiting messages as it can, so this one was not accepted',
-        nextStep: 'send it again once the waiting messages have been delivered (when the run resumes or the session is woken)',
-    },
-    duplicate_input_id: {
-        happened: 'a different instruction was already accepted under this idempotency key, and that earlier instruction stands',
-        nextStep: 'if you changed the text, send the new text under a new key; otherwise do not resend it — a new key would deliver the same instruction twice',
-    },
-    ambiguous_target: {
-        happened: 'more than one running agent matches that target, so the message was not delivered',
-        nextStep: 'address a sub-agent by its tool-call id; a workflow agent cannot be singled out while another running agent shares its label, so send it again once only one does',
-    },
-    still_running: {
-        happened: 'that agent is still running, so it cannot be resumed',
-        nextStep: 'send it a message instead, or wait for it to finish',
-    },
-    blocked_by_hook: {
-        happened: "the message was not accepted: a prompt check on this deployment blocked it, so nothing was delivered",
-        nextStep: 'edit the message and send it again — that is not a duplicate submission',
-    },
-    ledger_unavailable: {
-        happened: 'the server could not record the message and refused it before anything reached the engine, so nothing was delivered',
-        nextStep: 'send the same text again later',
-    },
-    steering_other: {
-        happened: 'the message was refused for a reason this version does not recognise, so it did not land',
-        nextStep: 'report its error code if this keeps happening; do not guess what it means',
-    },
+    not_running: { happened: 'session.steerRefusal.notRunning.happened', nextStep: 'session.steerRefusal.notRunning.nextStep' },
+    invalid_content: { happened: 'session.steerRefusal.invalidContent.happened', nextStep: 'session.steerRefusal.invalidContent.nextStep' },
+    queue_full: { happened: 'session.steerRefusal.queueFull.happened', nextStep: 'session.steerRefusal.queueFull.nextStep' },
+    duplicate_input_id: { happened: 'session.steerRefusal.duplicateInputId.happened', nextStep: 'session.steerRefusal.duplicateInputId.nextStep' },
+    ambiguous_target: { happened: 'session.steerRefusal.ambiguousTarget.happened', nextStep: 'session.steerRefusal.ambiguousTarget.nextStep' },
+    still_running: { happened: 'session.steerRefusal.stillRunning.happened', nextStep: 'session.steerRefusal.stillRunning.nextStep' },
+    blocked_by_hook: { happened: 'session.steerRefusal.blockedByHook.happened', nextStep: 'session.steerRefusal.blockedByHook.nextStep' },
+    ledger_unavailable: { happened: 'session.steerRefusal.ledgerUnavailable.happened', nextStep: 'session.steerRefusal.ledgerUnavailable.nextStep' },
+    steering_other: { happened: 'session.steerRefusal.steeringOther.happened', nextStep: 'session.steerRefusal.steeringOther.nextStep' },
 };
-const adviceOfCopy = (c) => `${c.happened} — ${c.nextStep}`;
-const STEERING_ADVICE = Object.freeze(Object.fromEntries(Object.entries(STEERING_COPY).map(([k, c]) => [k, adviceOfCopy(c)])));
+const adviceOfCopy = (c, lang) => renderMessage(msg('session.steerRefusal.advice', { happened: c.happened, nextStep: c.nextStep }), lang);
+function hostQueueFactOf(v) {
+    return v === 'queued_until_turn_end' || v === 'dropped' ? v : 'unknown';
+}
+function renderedCopyOf(keys, lang, hostQueue) {
+    const happened = renderMessage(msg(keys.happened), lang);
+    const tableNextStep = renderMessage(msg(keys.nextStep), lang);
+    if (hostQueue === 'queued_until_turn_end')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.queued'), lang) };
+    if (hostQueue === 'dropped')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.dropped', { nextStep: tableNextStep }), lang) };
+    return { happened, nextStep: tableNextStep };
+}
 const STEERING_OTHER_UNKNOWN_COPY = {
-    happened: 'the message was refused for a reason this version does not recognise, and whether it was delivered is not known',
-    nextStep: 'do not resend it as if it had certainly been dropped — check the run first, and report its error code if this keeps happening',
+    happened: 'session.steerRefusal.steeringOtherUnknown.happened',
+    nextStep: 'session.steerRefusal.steeringOtherUnknown.nextStep',
 };
 const CANCEL_NOT_FOUND_COPY = {
     happened: 'this server has no run with that id for you — it does not exist, or it belongs to someone else',
@@ -262,7 +248,7 @@ function steeringCopyOf(e, safety) {
     return STEERING_COPY[safety];
 }
 const STEERING_REFUSED_BEFORE_ENGINE = new Map([['ledger_unavailable', 503]]);
-export function steeringRefusedBeforeEngine(e) {
+export function steeringRefusedBeforeEngine(e, hostQueue, lang) {
     try {
         const { status } = errCodes(e);
         if (status === undefined)
@@ -270,8 +256,8 @@ export function steeringRefusedBeforeEngine(e) {
         const safety = steeringVerdict(e);
         if (safety === undefined || STEERING_REFUSED_BEFORE_ENGINE.get(safety) !== status)
             return undefined;
-        const copy = STEERING_COPY[safety];
-        return { safety, advice: STEERING_ADVICE[safety], happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(STEERING_COPY[safety], lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;
@@ -288,17 +274,19 @@ function steeringVerdict(e) {
     if (typeof code === 'string' && code.startsWith('steering.')) {
         return STEERING_CODE_TO_SAFETY.get(code) ?? 'steering_other';
     }
+    if (readThrownSlot(e, 'errorCode', 'data') === THROWN_SLOT_UNREADABLE)
+        return undefined;
     const protocolName = protocolErrorNameOf(e);
     return protocolName !== undefined ? STEERING_NAME_TO_SAFETY[protocolName] : undefined;
 }
-export function steerRefusalAdviceOf(e) {
+export function steerRefusalAdviceOf(e, hostQueue, lang) {
     try {
         const verdict = steeringVerdict(e);
         if (verdict === undefined)
             return undefined;
         const safety = steeringSafetyOf(e, verdict);
-        const copy = steeringCopyOf(e, safety);
-        return { safety, advice: adviceOfCopy(copy), happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(steeringCopyOf(e, safety), lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;

package/dist/coreValuePorts.d.ts

@@ -97,6 +97,27 @@ export interface RuleToolNameVerdictView {
     readonly guidance?: string;
     readonly currentName?: string;
 }
+export type RuleEntryReadingView = {
+    readonly kind: 'row';
+    readonly compiled: RuleEntryCompiledView;
+} | {
+    readonly kind: 'inert';
+    readonly reason: string;
+    readonly verdict?: string;
+    readonly guidance?: string;
+    readonly currentName?: string;
+    readonly valueType?: string;
+};
+export interface RuleEntryCompiledView {
+    readonly kind: string;
+}
+export type McpToolAxesReadView = {
+    readonly ok: true;
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -118,8 +139,10 @@ export interface CoreValuePorts {
         adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
     }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
     judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
+    readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView;
+    readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -145,3 +168,5 @@ export declare function adjudicateModelRoute(model: RouteModelView, credential:
 export declare function routePairingStatus(brain: {
     adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
 }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;
+export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView | undefined;
+export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;

package/dist/coreValuePorts.js

@@ -15,6 +15,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'adjudicateModelRoute',
     'routePairingStatus',
     'judgeRuleToolName',
+    'readRuleEntry',
+    'readMcpToolAxes',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -99,3 +101,11 @@ export function routePairingStatus(brain, model, perModelAuth) {
     const fn = port('routePairingStatus');
     return fn === undefined ? undefined : fn(brain, model, perModelAuth);
 }
+export function readRuleEntry(raw, behavior, roster) {
+    const fn = port('readRuleEntry');
+    return fn === undefined ? undefined : fn(raw, behavior, roster);
+}
+export function readMcpToolAxes(declared) {
+    const fn = port('readMcpToolAxes');
+    return fn === undefined ? undefined : fn(declared);
+}

package/dist/corruptSessionCopy.d.ts

@@ -1 +1,2 @@
-export declare function corruptSessionContent(): string;
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare function corruptSessionContent(lang?: UiLanguage): string;

package/dist/corruptSessionCopy.js

@@ -1,4 +1,4 @@
-export function corruptSessionContent() {
-    return ("This session's saved history cannot be read — its stored log is damaged — so the engine cannot open this session. " +
-        'Retrying will not help: whoever operates this engine has to repair or remove that stored log. Until then, continue in a new session.');
+import { msg, renderMessage } from './i18n/translate.js';
+export function corruptSessionContent(lang) {
+    return renderMessage(msg('session.corrupt.content'), lang);
 }

package/dist/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
     server: "7.129.1",
     core: "7.51.2",
-    sdk: "23.0.2",
+    sdk: "23.1.0",
 });

package/dist/detachWire.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
+import { readThrownSlot } from './wireFailureShape.js';
 import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
@@ -13,10 +14,10 @@ export async function resolveHeadlessDetach(env = hostEnv()) {
 }
 export const DETACH_DURABLE_OFF_400_ANCHOR = 'x-detach-on-disconnect requires a durable run';
 export function isDetachDurableOff400(err) {
+    if (readThrownSlot(err, 'status', 'data') !== 400)
+        return false;
     try {
         const e = err;
-        if (e?.status !== 400)
-            return false;
         const msg = e?.message;
         return typeof msg === 'string' && msg.includes(DETACH_DURABLE_OFF_400_ANCHOR);
     }

package/dist/devicesFace.d.ts

@@ -0,0 +1,34 @@
+import { type SeatCapabilityReading } from './seatContract.js';
+import { type DeviceExecutorManagementReading } from './deviceExecutorManagementCapability.js';
+import type { DeviceListOutcome } from './deviceRebind.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export type DevicesFaceUnavailableWhy = 'host_not_wired' | 'host_not_reported' | 'host_report_unreadable' | 'lane_absent' | 'lane_unreported';
+export type DevicesFace = {
+    readonly kind: 'unavailable';
+    readonly why: DevicesFaceUnavailableWhy;
+} | {
+    readonly kind: 'probe_pending';
+} | {
+    readonly kind: 'probe_failed';
+    readonly retryable: true;
+    readonly cause: 'transport' | 'refused' | 'unreadable';
+} | {
+    readonly kind: 'verbs_off';
+} | {
+    readonly kind: 'manage';
+    readonly probe: boolean;
+};
+export interface DevicesFaceInput {
+    readonly host: {
+        readonly kind: 'seat';
+        readonly capability: SeatCapabilityReading;
+    } | {
+        readonly kind: 'direct';
+        readonly sliceArmed: boolean;
+    };
+    readonly engine?: DeviceExecutorManagementReading | undefined;
+    readonly lastList?: DeviceListOutcome | undefined;
+}
+export declare function devicesFaceOf(input: DevicesFaceInput): DevicesFace;
+export declare function devicesWritesAllowed(face: DevicesFace): boolean;
+export declare function devicesFaceDetail(face: DevicesFace, lang?: UiLanguage): string | undefined;

package/dist/devicesFace.js

@@ -0,0 +1,90 @@
+import { seatCapabilityUnavailableDetail } from './seatContract.js';
+import { deviceLaneOpen, deviceManagementVerbsAvailable } from './deviceExecutorManagementCapability.js';
+import { ownDataField } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const freeze = (v) => Object.freeze(v);
+const field = (v, key) => {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        return ownDataField(v, key);
+    }
+    catch {
+        return undefined;
+    }
+};
+function hostProblem(host) {
+    const kind = field(host, 'kind');
+    if (kind === 'direct')
+        return field(host, 'sliceArmed') === true ? undefined : 'host_not_wired';
+    if (kind !== 'seat')
+        return 'host_report_unreadable';
+    const reading = field(host, 'capability');
+    const rk = field(reading, 'kind');
+    if (rk === 'reported')
+        return field(reading, 'available') === true ? undefined : 'host_not_wired';
+    if (rk === 'not_reported')
+        return 'host_not_reported';
+    return 'host_report_unreadable';
+}
+export function devicesFaceOf(input) {
+    const engineRaw = field(input, 'engine');
+    const engine = { kind: field(engineRaw, 'kind'), management: field(engineRaw, 'management') };
+    const lane = deviceLaneOpen(engine);
+    const listKind = field(field(input, 'lastList'), 'kind');
+    if (lane === 'no' || listKind === 'lane-absent')
+        return freeze({ kind: 'unavailable', why: 'lane_absent' });
+    const host = field(input, 'host');
+    const hostWhy = hostProblem(host);
+    if (hostWhy !== undefined)
+        return freeze({ kind: 'unavailable', why: hostWhy });
+    if (listKind === 'unarmed')
+        return freeze({ kind: 'unavailable', why: 'host_not_wired' });
+    if (lane === 'unknown') {
+        if (field(host, 'kind') === 'direct')
+            return freeze({ kind: 'unavailable', why: 'lane_unreported' });
+        if (listKind === undefined)
+            return freeze({ kind: 'probe_pending' });
+        if (listKind === 'ok')
+            return freeze({ kind: 'manage', probe: true });
+        const cause = listKind === 'transport' || listKind === 'refused' ? listKind : 'unreadable';
+        return freeze({ kind: 'probe_failed', retryable: true, cause });
+    }
+    const verbs = deviceManagementVerbsAvailable(engine);
+    if (verbs === 'no')
+        return freeze({ kind: 'verbs_off' });
+    return freeze({ kind: 'manage', probe: verbs === 'unknown' });
+}
+export function devicesWritesAllowed(face) {
+    return field(face, 'kind') === 'manage';
+}
+const UNWIRED = freeze({ kind: 'reported', available: false });
+const NOT_REPORTED = freeze({ kind: 'not_reported' });
+const MALFORMED = freeze({ kind: 'malformed' });
+export function devicesFaceDetail(face, lang) {
+    const kind = field(face, 'kind');
+    if (kind === 'manage')
+        return undefined;
+    if (kind === 'probe_pending')
+        return renderMessage(msg('session.devices.probePending'), lang);
+    if (kind === 'verbs_off')
+        return renderMessage(msg('session.devices.verbsOff'), lang);
+    if (kind === 'probe_failed') {
+        const cause = field(face, 'cause');
+        if (cause === 'transport')
+            return renderMessage(msg('session.devices.probeFailedTransport'), lang);
+        if (cause === 'refused')
+            return renderMessage(msg('session.devices.probeFailedRefused'), lang);
+        return renderMessage(msg('session.devices.probeFailedUnreadable'), lang);
+    }
+    const why = kind === 'unavailable' ? field(face, 'why') : undefined;
+    if (why === 'lane_absent')
+        return renderMessage(msg('session.devices.laneAbsent'), lang);
+    if (why === 'lane_unreported')
+        return renderMessage(msg('session.devices.laneUnreported'), lang);
+    if (why === 'host_not_wired')
+        return seatCapabilityUnavailableDetail('devices', UNWIRED);
+    if (why === 'host_not_reported')
+        return seatCapabilityUnavailableDetail('devices', NOT_REPORTED);
+    return seatCapabilityUnavailableDetail('devices', MALFORMED);
+}

package/dist/displayUntrusted.d.ts

@@ -44,6 +44,7 @@ export declare function credentialWashPasses(text: string, opts?: DisplayUntrust
     capped: boolean;
 };
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function cleanUntrustedScalar(v: string | number | bigint | boolean | null | undefined): string;
 export declare function queryCarriesCredential(query: string): boolean;
 export declare function displayConfiguredUrl(url: string, opts?: DisplayUntrustedOptions): string;
 export declare function quoteUntrustedForSentence(text: string, max: number): string | undefined;

package/dist/displayUntrusted.js

@@ -4663,6 +4663,9 @@ export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
     return typeof out === 'string' ? out : out.text;
 }
+export function cleanUntrustedScalar(v) {
+    return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false });
+}
 const NON_SECRET_FIELD_NAMES = new Set([
     'deployment', 'deploymentname', 'deploymentid', 'name', 'tenant', 'tenantname', 'tenantid', 'region', 'location', 'zone',
     'project', 'projectname', 'projectid', 'workspace', 'workspacename', 'workspaceid', 'resource', 'resourcename', 'resourcegroup',

package/dist/engineAgentPanelStore.d.ts

@@ -46,6 +46,7 @@ export type EngineAgentPanelEvent = {
     report?: string;
     wireTaskId?: string;
     taskIdOrigin?: 'fleet-row' | 'wire';
+    sessionId?: string;
 } | {
     kind: 'sweep';
 };
@@ -58,6 +59,12 @@ export declare function clearEnginePanelTaskResidentByWire(wireTaskId: string, c
 export declare function __resetEngineAgentPanelIdentityForTests(): void;
 export declare function __resetEnginePanelStateForTests(): void;
 export declare function publishEngineAgentPanelEvent(ev: EngineAgentPanelEvent): void;
+export interface EngineAgentPanelStart {
+    taskId: string;
+    startedAt?: number;
+    workflowRunId?: string;
+}
+export declare function publishEngineAgentPanelStart(ev: EngineAgentPanelStart): void;
 export declare function subscribeEnginePanelRows(fn: (delta: PanelDelta) => void): () => void;
 export interface EngineAgentPanelAbsence {
     taskId: string;

package/dist/engineAgentPanelStore.js

@@ -1,4 +1,5 @@
 import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, panelIsResident, panelResolveTaskId, MAX_HELD_WIRE_TICK_BEATS, } from './panelReduce.js';
+import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from './ownKey.js';
 import { clearEnginePanelIdentity, panelStateNow, stepEnginePanel, subscribeRows, resetEnginePanelHolder } from './panelStateHolder.js';
 export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 const _panelToolUsesLanePins = [true, true];
@@ -31,6 +32,19 @@ export function __resetEnginePanelStateForTests() {
 export function publishEngineAgentPanelEvent(ev) {
     stepEnginePanel(ev);
 }
+export function publishEngineAgentPanelStart(ev) {
+    const taskId = guardedRead(() => readOwnDataNonEmptyString(ev, 'taskId'));
+    if (taskId === undefined)
+        return;
+    const startedAt = guardedRead(() => readOwnDataFiniteNumber(ev, 'startedAt'));
+    const workflowRunId = guardedRead(() => readOwnDataNonEmptyString(ev, 'workflowRunId'));
+    stepEnginePanel({
+        kind: 'start',
+        taskId,
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+    });
+}
 export function subscribeEnginePanelRows(fn) {
     return subscribeRows(fn);
 }

package/dist/engineCapReader.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 interface EngineCapReaderSpec<R> {
     name: string;
     project: (caps: unknown) => R | undefined;
@@ -12,7 +13,7 @@ interface EngineCapReader<R> {
     observed(baseUrl: string | undefined): R | ReaderUnobserved | ReaderUnreadable;
 }
 export declare function createEngineCapReader<R>(spec: EngineCapReaderSpec<R>): EngineCapReader<R>;
-export declare function unreadableReadingDetail(subject?: string): string;
+export declare function unreadableReadingDetail(subject?: string, lang?: UiLanguage): string;
 export type StoreSeat = {
     kind: 'object';
     store: object;

package/dist/engineCapReader.js

@@ -1,7 +1,10 @@
 import { engineCapsLandingOf } from './engineCapsCache.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
-const unobserved = () => ({ kind: 'unobserved' });
-const unreadable = () => ({ kind: 'unreadable' });
+const UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const unobserved = () => UNOBSERVED;
+const unreadable = () => UNREADABLE;
 function freezeReading(reading, seen = new Set()) {
     if (reading === null || typeof reading !== 'object' || seen.has(reading))
         return reading;
@@ -49,9 +52,8 @@ export function createEngineCapReader(spec) {
         },
     };
 }
-export function unreadableReadingDetail(subject) {
-    const head = typeof subject === 'string' && subject.length > 0 ? `${subject} could not be read` : 'could not be read';
-    return `${head} — the engine's /v1/capabilities report arrived, but this entry is not in a form this client reads, so it is shown as unknown, not as absent; probing the same engine again will not change it while the engine reports it this way`;
+export function unreadableReadingDetail(subject, lang) {
+    return renderMessage(typeof subject === 'string' && subject.length > 0 ? msg('notice.capability.unreadable.subject', { subject }) : msg('notice.capability.unreadable.bare'), lang);
 }
 export function storeSeatOf(caps) {
     try {

package/dist/engineCapsCache.d.ts

@@ -6,6 +6,11 @@ export type EngineCapsLanding = {
 } | {
     readonly kind: 'unreadable';
 };
+export interface EngineCapsChange {
+    readonly kind: 'landed' | 'invalidated' | 'replaced';
+    readonly baseUrl: string;
+    readonly generation: number;
+}
 export declare function engineCapsGeneration(baseUrl: string): number;
 export declare function engineCapsLandingOf(baseUrl: string | undefined): EngineCapsLanding;
 export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
@@ -42,6 +47,9 @@ export declare function engineCapString(baseUrl: string | undefined, key: string
 export declare function invalidateEngineCaps(baseUrl: string | undefined, probe?: () => Promise<unknown>): void;
 export type EngineCapsProbeRotation = 'started' | 'registered' | 'ignored';
 export declare function rotateEngineCapsProbe(baseUrl: string | undefined, probe: () => Promise<unknown>): EngineCapsProbeRotation;
+export type EngineCapsReprobe = 'reprobed' | 'no_probe' | 'ignored';
+export declare function invalidateEngineCapsAndReprobe(baseUrl: string | undefined): EngineCapsReprobe;
+export declare function registerCapsChangeDelivery(baseUrl: string | undefined, deliver: (change: EngineCapsChange) => void): () => void;
 export declare function refreshEngineCapsOnce(baseUrl: string | undefined, opts?: {
     withinMs?: number;
 }): Promise<'settled' | 'timed_out' | 'no_probe'>;

package/dist/engineCapsCache.js

@@ -4,11 +4,11 @@ const NOT_LANDED = Object.freeze({ kind: 'not_landed' });
 const capsByBase = new Map();
 const inFlight = new Set();
 const settleByBase = new Map();
-const genByBase = new Map();
+const stateByBase = new Map();
 const probeByBase = new Map();
 const refreshByBase = new Map();
 function capsGeneration(baseUrl) {
-    return genByBase.get(baseUrl) ?? 0;
+    return stateByBase.get(baseUrl)?.gen ?? 0;
 }
 export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
@@ -169,6 +169,7 @@ function landCapsSnapshot(baseUrl, gen, caps) {
         ? Object.freeze({ kind: 'unreadable' })
         : Object.freeze({ kind: 'landed', caps: snapshot });
     capsByBase.set(baseUrl, record);
+    publishCapsChange(baseUrl, 'landed');
     return 'landed';
 }
 function snapshotCapsBody(body) {
@@ -355,18 +356,25 @@ export function invalidateEngineCaps(baseUrl, probe) {
         return;
     if (probe === undefined)
         probeByBase.delete(baseUrl);
-    const hadState = capsByBase.has(baseUrl) ||
+    const hadLanding = capsByBase.has(baseUrl);
+    const hadState = hadLanding ||
         inFlight.has(baseUrl) ||
         settleByBase.has(baseUrl) ||
-        genByBase.has(baseUrl);
+        stateByBase.get(baseUrl)?.gen !== undefined;
     if (hadState) {
-        genByBase.set(baseUrl, capsGeneration(baseUrl) + 1);
+        const st = stateByBase.get(baseUrl);
+        if (st === undefined)
+            stateByBase.set(baseUrl, { gen: 1, subscribers: new Set() });
+        else
+            st.gen = capsGeneration(baseUrl) + 1;
         capsByBase.delete(baseUrl);
         inFlight.delete(baseUrl);
         settleByBase.get(baseUrl)?.wake();
     }
     if (probe !== undefined)
         kickEngineCapsProbe(baseUrl, probe);
+    if (hadLanding)
+        publishCapsChange(baseUrl, probe !== undefined ? 'replaced' : 'invalidated');
 }
 export function rotateEngineCapsProbe(baseUrl, probe) {
     try {
@@ -381,6 +389,51 @@ export function rotateEngineCapsProbe(baseUrl, probe) {
         return 'ignored';
     }
 }
+export function invalidateEngineCapsAndReprobe(baseUrl) {
+    try {
+        if (typeof baseUrl !== 'string' || baseUrl === '')
+            return 'ignored';
+        const probe = probeByBase.get(baseUrl);
+        if (probe === undefined)
+            return 'no_probe';
+        invalidateEngineCaps(baseUrl, probe);
+        return 'reprobed';
+    }
+    catch {
+        return 'ignored';
+    }
+}
+export function registerCapsChangeDelivery(baseUrl, deliver) {
+    if (typeof baseUrl !== 'string' || baseUrl === '' || typeof deliver !== 'function')
+        return () => { };
+    let st = stateByBase.get(baseUrl);
+    if (st === undefined) {
+        st = { gen: undefined, subscribers: new Set() };
+        stateByBase.set(baseUrl, st);
+    }
+    const sub = { deliver, live: true };
+    const owner = st;
+    owner.subscribers.add(sub);
+    return () => {
+        if (!sub.live)
+            return;
+        sub.live = false;
+        owner.subscribers.delete(sub);
+        if (owner.subscribers.size === 0 && owner.gen === undefined && stateByBase.get(baseUrl) === owner)
+            stateByBase.delete(baseUrl);
+    };
+}
+function publishCapsChange(baseUrl, kind) {
+    const subs = stateByBase.get(baseUrl)?.subscribers;
+    if (subs === undefined || subs.size === 0)
+        return;
+    const change = Object.freeze({ kind, baseUrl, generation: capsGeneration(baseUrl) });
+    for (const sub of [...subs]) {
+        if (!sub.live)
+            continue;
+        sub.deliver(change);
+    }
+}
 export async function refreshEngineCapsOnce(baseUrl, opts) {
     try {
         if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -454,7 +507,7 @@ export function __resetEngineCapsCacheForTests() {
     capsByBase.clear();
     inFlight.clear();
     settleByBase.clear();
-    genByBase.clear();
+    stateByBase.clear();
     probeByBase.clear();
     refreshByBase.clear();
 }

package/dist/engineCapsChange.d.ts

@@ -0,0 +1,2 @@
+import { type EngineCapsChange } from './engineCapsCache.js';
+export declare function onEngineCapsChange(baseUrl: string | undefined, listener: (change: EngineCapsChange) => void): () => void;

package/dist/engineCapsChange.js

@@ -0,0 +1,9 @@
+import { registerCapsChangeDelivery } from './engineCapsCache.js';
+import { invokeHostCallbackIsolated } from './hostCallbackGuard.js';
+export function onEngineCapsChange(baseUrl, listener) {
+    if (typeof listener !== 'function')
+        return () => { };
+    return registerCapsChangeDelivery(baseUrl, (change) => {
+        invokeHostCallbackIsolated('engineCapsChange: listener', () => listener(change));
+    });
+}