@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/engineErrorCodes.d.ts

@@ -58,7 +58,6 @@ export declare const STOP_PARK_RESUME_WON = "stop.park_resume_won";
 export declare const STOP_NOT_LANDED = "stop.not_landed";
 export declare const STOP_NOT_LOCAL = "stop.not_local";
 export declare const STOP_PARKED = "stop.parked";
-export declare const STOP_CONFLICT_CODES: readonly ["stop.park_arbiter_unreachable", "stop.park_resume_won", "stop.not_landed", "stop.not_local", "stop.parked"];
 export declare const OUTPUT_INVALID = "output.invalid";
 export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
 export declare const STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
@@ -128,6 +127,8 @@ export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";
 export declare const SCENARIO_NOT_ALLOWED_ERROR_CODE = "scenario_not_allowed";
 export declare const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = "state.scenario_assignment_unknown";
+export declare const USER_ATTACHMENT_INVALID_ERROR_CODE = "config.user_attachment_invalid";
+export declare const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = "config.user_invoked_skill_unknown";
 export declare const STREAM_MAX_DURATION = "STREAM_MAX_DURATION";
 export type ModelFallbackReason = 'inherit_no_tier_binding';
 export declare const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING: ModelFallbackReason;

package/dist/engineErrorCodes.js

@@ -111,13 +111,6 @@ export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
 export const STOP_NOT_LOCAL = 'stop.not_local';
 export const STOP_PARKED = 'stop.parked';
-export const STOP_CONFLICT_CODES = Object.freeze([
-    STOP_PARK_ARBITER_UNREACHABLE,
-    STOP_PARK_RESUME_WON,
-    STOP_NOT_LANDED,
-    STOP_NOT_LOCAL,
-    STOP_PARKED,
-]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
 export const STATUS_DERIVED_COARSE_CODES = SDK_STATUS_DERIVED_COARSE_CODES;
@@ -266,6 +259,8 @@ export function isWorkflowParkRefusalCode(code) {
 export const DRAINING_ERROR_CODE = 'draining';
 export const SCENARIO_NOT_ALLOWED_ERROR_CODE = 'scenario_not_allowed';
 export const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = 'state.scenario_assignment_unknown';
+export const USER_ATTACHMENT_INVALID_ERROR_CODE = 'config.user_attachment_invalid';
+export const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = 'config.user_invoked_skill_unknown';
 export const STREAM_MAX_DURATION = 'STREAM_MAX_DURATION';
 export const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING = 'inherit_no_tier_binding';
 export function asModelFallbackReason(v) {

package/dist/engineRowRef.js

@@ -93,6 +93,9 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_interrupted_never_started',
     '_sema_approval_window_expired',
     '_sema_denial_limit_window_expired',
+    '_sema_api_error_status',
+    '_sema_api_error_code',
+    '_sema_provider_condition',
 ]);
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');

package/dist/engineSessionMessages.d.ts

@@ -32,6 +32,7 @@ export interface EngineHistoryToolResultBlock {
     readonly tool_use_id: string;
     readonly content: readonly EngineHistoryBlock[];
     readonly is_error: boolean;
+    readonly _sema_gate_parked?: true;
 }
 export interface EngineHistoryOpaqueBlock {
     readonly type: string;

package/dist/engineSessionMessages.js

@@ -1,3 +1,4 @@
+import { isGateParkedToolEnd } from './gateOutcome.js';
 import { ownDataField, ownSendableField } from './ownKey.js';
 const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalOwn(o, key) {
@@ -286,7 +287,12 @@ function toolResultBody(row, tally) {
         blocks = mapBlocks(items, tally);
     }
     const isError = ownDataField(row, 'isError') === true;
-    return { kind: 'message', role: 'user', body: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: blocks, is_error: isError }] } };
+    const parked = isGateParkedToolEnd(row);
+    return {
+        kind: 'message',
+        role: 'user',
+        body: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: blocks, is_error: isError, ...(parked ? { _sema_gate_parked: true } : {}) }] },
+    };
 }
 function projectRow(row, tally) {
     if (!isObjectLike(row))

package/dist/engineTargetSeat.d.ts

@@ -0,0 +1,27 @@
+import type { CloudLoginFailure, CloudLoginFailureReading, EipcStoreClient, EngineTargetRefusal, EngineTargetRefused, EngineTargetState, SeatLocalMcpReading } from './seatContract.js';
+import type { McpProbeOutcome } from './mcpProbeWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export interface CloudLoginFailureContext {
+    readonly deadlineReached?: boolean;
+    readonly cancelled?: boolean;
+}
+export declare function cloudLoginFailureOf(err: {} | null | undefined, ctx?: CloudLoginFailureContext): CloudLoginFailureReading;
+export declare function cloudLoginFailureText(failure: CloudLoginFailure | CloudLoginFailureReading, lang?: UiLanguage): string;
+export declare function engineTargetRefusalText(refused: EngineTargetRefusal | EngineTargetRefused, lang?: UiLanguage): string;
+export type EngineTargetReading = {
+    readonly kind: 'state';
+    readonly state: EngineTargetState;
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'malformed';
+};
+export interface EngineTargetWatch {
+    stop(): void;
+    isCurrent(generation: number): boolean;
+}
+export declare function watchEngineTarget(store: EipcStoreClient<EngineTargetState> | undefined, onState: (reading: EngineTargetReading, switched: boolean) => void): EngineTargetWatch;
+export declare function seatMcpReadingOf(outcome: McpProbeOutcome, readAt: string, extra?: {
+    readonly restartRequired?: true;
+    readonly forcedAsk?: Readonly<Record<string, readonly string[]>>;
+}): SeatLocalMcpReading;

package/dist/engineTargetSeat.js

@@ -0,0 +1,199 @@
+import { CLOUD_LOGIN_FAILURES, ENGINE_TARGET_REFUSALS, LOCAL_SESSIONS_SPEC } from './seatContract.js';
+import { ownDataField } from './ownKey.js';
+import { readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const field = (v, key) => {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        return ownDataField(v, key);
+    }
+    catch {
+        return undefined;
+    }
+};
+const OAUTH_WORDS = ['access_denied', 'expired_token', 'invalid_grant'];
+export function cloudLoginFailureOf(err, ctx) {
+    if (field(ctx, 'cancelled') === true)
+        return Object.freeze({ failure: 'cancelled' });
+    if (field(ctx, 'deadlineReached') === true)
+        return Object.freeze({ failure: 'expired_token' });
+    if (err !== null && typeof err === 'object') {
+        const code = readThrownSlot(err, 'code', 'data');
+        if (typeof code === 'string' && code.length > 0) {
+            const word = OAUTH_WORDS.find((w) => w === code);
+            return Object.freeze({ failure: word ?? 'other' });
+        }
+        const status = readThrownStatusSlot(err);
+        if (typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599)
+            return Object.freeze({ failure: 'refused', status });
+    }
+    return Object.freeze({ failure: 'transport' });
+}
+const LOGIN_KEYS = {
+    access_denied: 'config.cloudLogin.accessDenied',
+    expired_token: 'config.cloudLogin.expiredToken',
+    invalid_grant: 'config.cloudLogin.invalidGrant',
+    cancelled: 'config.cloudLogin.cancelled',
+    transport: 'config.cloudLogin.transport',
+    refused: 'config.cloudLogin.refused',
+    no_tokens: 'config.cloudLogin.noTokens',
+    other: 'config.cloudLogin.other',
+};
+export function cloudLoginFailureText(failure, lang) {
+    const word = typeof failure === 'string' ? failure : field(failure, 'failure');
+    const known = CLOUD_LOGIN_FAILURES.find((w) => w === word) ?? 'other';
+    if (known === 'refused') {
+        const status = typeof failure === 'string' ? undefined : field(failure, 'status');
+        if (typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599) {
+            return renderMessage(msg('config.cloudLogin.refusedStatus', { status }), lang);
+        }
+    }
+    return renderMessage(msg(LOGIN_KEYS[known]), lang);
+}
+const REFUSAL_KEYS = {
+    busy: 'config.engineTarget.busy',
+    switching: 'config.engineTarget.switching',
+    not_configured: 'config.engineTarget.notConfigured',
+    not_signed_in: 'config.engineTarget.notSignedIn',
+    probe_failed: 'config.engineTarget.probeFailed',
+    org_policy: 'config.engineTarget.orgPolicy',
+    url_refused: 'config.engineTarget.urlRefused',
+    login_failed: 'config.engineTarget.loginFailed',
+    storage_unavailable: 'config.engineTarget.storageUnavailable',
+    no_local_runtime: 'config.engineTarget.noLocalRuntime',
+    input: 'config.engineTarget.input',
+};
+export function engineTargetRefusalText(refused, lang) {
+    const word = typeof refused === 'string' ? refused : field(refused, 'refusal');
+    const known = ENGINE_TARGET_REFUSALS.find((w) => w === word);
+    if (known === undefined)
+        return renderMessage(msg('config.engineTarget.unknown'), lang);
+    if (known === 'login_failed' && typeof refused !== 'string') {
+        const failure = field(refused, 'failure');
+        if (CLOUD_LOGIN_FAILURES.some((w) => w === failure)) {
+            const status = field(refused, 'status');
+            return cloudLoginFailureText({ failure: failure, ...(typeof status === 'number' ? { status } : {}) }, lang);
+        }
+    }
+    return renderMessage(msg(REFUSAL_KEYS[known]), lang);
+}
+const checkState = (v) => {
+    const check = LOCAL_SESSIONS_SPEC.stores?.['engineTargetState']?.check;
+    return typeof check === 'function' && check(v) === true;
+};
+export function watchEngineTarget(store, onState) {
+    let current;
+    let trusted = false;
+    let active = true;
+    let off;
+    const deliver = (state) => {
+        if (!active)
+            return;
+        let ok = false;
+        try {
+            ok = checkState(state);
+        }
+        catch {
+            ok = false;
+        }
+        if (!ok) {
+            trusted = false;
+            onState(Object.freeze({ kind: 'malformed' }), false);
+            return;
+        }
+        const s = state;
+        const switched = current !== undefined && s.generation !== current;
+        current = s.generation;
+        trusted = true;
+        onState(Object.freeze({ kind: 'state', state: s }), switched);
+    };
+    const handle = {
+        stop: () => {
+            if (!active)
+                return;
+            active = false;
+            try {
+                if (typeof off === 'function')
+                    off();
+            }
+            catch {
+                off = undefined;
+            }
+        },
+        isCurrent: (generation) => active && trusted && current !== undefined && generation === current,
+    };
+    if (store === undefined || store === null) {
+        onState(Object.freeze({ kind: 'not_reported' }), false);
+        active = false;
+        return handle;
+    }
+    try {
+        if (typeof store !== 'object' || typeof store.onStateChange !== 'function' || typeof store.getStateSync !== 'function') {
+            onState(Object.freeze({ kind: 'malformed' }), false);
+            active = false;
+            return handle;
+        }
+        off = store.onStateChange((state) => deliver(state));
+    }
+    catch {
+        onState(Object.freeze({ kind: 'malformed' }), false);
+        active = false;
+        return handle;
+    }
+    let now;
+    try {
+        now = store.getStateSync();
+    }
+    catch {
+        trusted = false;
+        if (active)
+            onState(Object.freeze({ kind: 'malformed' }), false);
+        return handle;
+    }
+    deliver(now);
+    return handle;
+}
+const MCP_DETAIL_MAX = 200;
+export function seatMcpReadingOf(outcome, readAt, extra) {
+    const restart = field(extra, 'restartRequired') === true ? { restartRequired: true } : {};
+    const status = field(outcome, 'status');
+    if (status === 'face') {
+        const face = field(outcome, 'face');
+        const servers = field(face, 'servers');
+        if (Array.isArray(servers)) {
+            const forced = field(extra, 'forcedAsk');
+            const rows = [];
+            for (const row of servers) {
+                const name = field(row, 'name');
+                const st = field(row, 'status');
+                if (typeof name !== 'string' || name.length === 0 || typeof st !== 'string')
+                    continue;
+                const tc = field(row, 'toolCount');
+                const liveness = field(field(row, 'liveness'), 'state');
+                const ec = field(row, 'errorCode');
+                const fa = field(forced, name);
+                const forcedAsk = Array.isArray(fa) ? fa.filter((n) => typeof n === 'string' && n.length > 0) : [];
+                rows.push(Object.freeze({
+                    name,
+                    status: st,
+                    ...(typeof tc === 'number' && Number.isSafeInteger(tc) && tc >= 0 ? { toolCount: tc } : {}),
+                    ...(typeof liveness === 'string' && liveness.length > 0 ? { liveness } : {}),
+                    ...(typeof ec === 'string' && ec.length > 0 ? { errorCode: ec } : {}),
+                    ...(forcedAsk.length > 0 ? { forcedAsk: [...forcedAsk] } : {}),
+                }));
+            }
+            return Object.freeze({ status: 'listed', servers: rows, readAt, ...restart });
+        }
+    }
+    const cause = status === 'refused' ? field(outcome, 'cause') : status === 'unknown' ? field(outcome, 'why') : undefined;
+    const message = field(outcome, 'message');
+    return Object.freeze({
+        status: 'unreadable',
+        cause: typeof cause === 'string' && cause.length > 0 ? cause : 'no_verdict',
+        ...(typeof message === 'string' && message.length > 0 ? { detail: displayUntrusted(message, { max: MCP_DETAIL_MAX }) } : {}),
+        readAt,
+        ...restart,
+    });
+}

package/dist/engineWireFor.js

@@ -1,6 +1,7 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireTargetFor } from './engineWireTarget.js';
+import { readThrownSlot } from './wireFailureShape.js';
 export const INJECTED_WIRE_SETTLE_MS = 60_000;
 export function engineWireFor(wire, sessionKey, usable) {
     if (wire !== undefined) {
@@ -285,15 +286,9 @@ function abortedBeforeSendError() {
     return e;
 }
 function answeredByEngine(e) {
-    try {
-        if (e === null || typeof e !== 'object')
-            return false;
-        const o = e;
-        return typeof o.status === 'number' || typeof o.errorCode === 'string';
-    }
-    catch {
+    if (e === null || typeof e !== 'object')
         return false;
-    }
+    return typeof readThrownSlot(e, 'status', 'data') === 'number' || typeof readThrownSlot(e, 'errorCode', 'data') === 'string';
 }
 const SETTLED_BY_PACKAGE_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-settled');
 function settledByPackage(value) {

package/dist/env/uiLanguage.d.ts

@@ -1,4 +1,5 @@
-export type UiLanguage = 'en' | 'zh';
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export type UiLanguage = (typeof SETTINGS_UI_LANGUAGE_VALUES)[number];
 export declare const UI_LANGUAGES: readonly UiLanguage[];
 export declare const UI_LANGUAGE_ENDONYMS: Record<UiLanguage, string>;
 export declare function isUiLanguage(v: unknown): v is UiLanguage;

package/dist/env/uiLanguage.js

@@ -1,11 +1,12 @@
 import { parseLocaleTag } from './localeTag.js';
-export const UI_LANGUAGES = ['en', 'zh'];
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export const UI_LANGUAGES = SETTINGS_UI_LANGUAGE_VALUES;
 export const UI_LANGUAGE_ENDONYMS = {
     en: 'English',
     zh: '中文',
 };
 export function isUiLanguage(v) {
-    return v === 'en' || v === 'zh';
+    return typeof v === 'string' && UI_LANGUAGES.includes(v);
 }
 export function pickUiLanguage(localeTag) {
     return parseLocaleTag(localeTag).language === 'zh' ? 'zh' : 'en';

package/dist/eventLeg.d.ts

@@ -2,6 +2,7 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
 import { type AskGateWireDeps } from './hitl/askGateWire.js';
 import { type ActiveRunBusySignal } from './adapter/runStream.js';
+import type { ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
 export declare const EVENT_LEG_KINDS: readonly ["live", "durable", "continuation"];
 export type EventLegKind = (typeof EVENT_LEG_KINDS)[number];
 export type EventLegStage = 'bindRun' | 'stampOwner' | 'hitlFrames' | 'askBridge' | 'idleTriage';
@@ -69,6 +70,13 @@ export interface EventLegStreamContext {
     readonly leg: EventLegKind;
     readonly runId: string | undefined;
 }
+export interface ApprovalFrameContext {
+    readonly leg: EventLegKind;
+    readonly windowIsCurrent: boolean;
+    readonly receivedAtMs: number;
+    readonly streamEnded: AbortSignal;
+}
+export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
 export interface EventLegPorts {
     readonly run?: EventLegRunPorts;
     readonly owner?: EventLegOwnerPorts;

package/dist/eventLeg.js

@@ -1,4 +1,4 @@
-import { frameBindingOf, registerFrameBinding } from './frameBinding.js';
+import { approvalFrameContextOfFrame, frameBindingOf, registerApprovalFrameContext, registerFrameBinding } from './frameBinding.js';
 import { bridgeAskUserQuestionGates } from './hitl/askGateWire.js';
 import { diagnoseSseIdleTear } from './sseIdleTriage.js';
 import { recordSubagentOwnerFromProgress } from './subagentContentStore.js';
@@ -6,6 +6,8 @@ import { activeRunBusySignal } from './adapter/runStream.js';
 import { invokeHostCallbackIsolated } from './hostCallbackGuard.js';
 import { hostLog } from './host.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { settleEngineClosedApproval } from './hitl/approvalHolds.js';
+import { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
 export const EVENT_LEG_KINDS = Object.freeze(['live', 'durable', 'continuation']);
 export const EVENT_LEG_TABLE = Object.freeze({
     live: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames', 'askBridge', 'idleTriage']), windowIsCurrent: true }),
@@ -18,7 +20,7 @@ function makeFrameStageDomains(domains) {
 const FRAME_STAGE_DOMAINS = makeFrameStageDomains({
     bindRun: Object.freeze(['meta', 'done', 'failed']),
     stampOwner: Object.freeze(['task_progress']),
-    hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete']),
+    hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete', 'approval_request', 'approval_revoke']),
 });
 const HITL_PORT_OF = Object.freeze({
     question: 'question',
@@ -27,8 +29,14 @@ const HITL_PORT_OF = Object.freeze({
     elicitation_complete: 'elicitation',
     tool_approval: 'toolApproval',
     tool_approval_complete: 'toolApproval',
+    approval_request: 'register',
+    approval_revoke: 'register',
 });
 const inDomain = (stage, frameType) => FRAME_STAGE_DOMAINS[stage].includes(frameType);
+export function approvalFrameContextOf(arm) {
+    const frame = guardedRead(() => readOwnDataValue(arm, 'frame'));
+    return typeof frame === 'object' && frame !== null ? approvalFrameContextOfFrame(frame) : undefined;
+}
 const HOST_PORT_MISSING = 'host_port_missing';
 export function composeEventLeg(source, leg, ports) {
     const kind = leg.kind;
@@ -136,12 +144,18 @@ export function composeEventLeg(source, leg, ports) {
         const boundInfo = Object.freeze({ cause, leg: kind });
         callPort('run.onBound', () => runPorts.onBound?.(binding, boundInfo));
     };
-    const deliverHitl = (ev, env) => {
+    const deliverHitl = (ev, env, streamEnded) => {
         if (!inDomain('hitlFrames', ev.type))
             return false;
         const port = HITL_PORT_OF[ev.type];
+        if (port === 'register') {
+            registerApprovalFrameContext(ev, Object.freeze({ leg: env.leg, windowIsCurrent: env.windowIsCurrent, receivedAtMs: Date.now(), streamEnded }));
+            return false;
+        }
         if (port === 'toolApproval' && hostBridge !== undefined)
             return false;
+        if (ev.type === 'tool_approval_complete')
+            settleEngineClosedApproval(ev, approvalCompleteParked(ev));
         const threw = callPort(`hitl.${port}`, () => hitl?.[port]?.call(hitl, ev, env));
         if (threw)
             hitlUndelivered++;
@@ -153,49 +167,55 @@ export function composeEventLeg(source, leg, ports) {
         let binding;
         let runEvidence = false;
         const env = Object.freeze({ windowIsCurrent: EVENT_LEG_TABLE[streamKind].windowIsCurrent, leg: streamKind });
-        for await (const ev of stream) {
-            if (taskId === undefined && streamKind === 'live')
-                taskId = readHeaderRunId();
-            const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
-            if (!inDomain('bindRun', ev.type))
-                runEvidence = true;
-            if (refusal !== undefined) {
-                if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())
-                    callPort('run.onRefused', () => runPorts.onRefused?.(refusal, info));
-            }
-            else {
-                if (ev.type === 'meta' || ev.type === 'done') {
-                    const carrier = ev.type === 'meta' ? ev : ev.result;
-                    const tid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'taskId')) : undefined;
-                    const sid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId')) : undefined;
-                    const runId = ev.type === 'done' && tid !== undefined && tid === sid ? undefined : tid;
-                    if (streamKind === 'live' && runId !== undefined && runId !== taskId) {
-                        taskId = runId;
-                        sessionId = sid;
+        const ended = new AbortController();
+        try {
+            for await (const ev of stream) {
+                if (taskId === undefined && streamKind === 'live')
+                    taskId = readHeaderRunId();
+                const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
+                if (!inDomain('bindRun', ev.type))
+                    runEvidence = true;
+                if (refusal !== undefined) {
+                    if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())
+                        callPort('run.onRefused', () => runPorts.onRefused?.(refusal, info));
+                }
+                else {
+                    if (ev.type === 'meta' || ev.type === 'done') {
+                        const carrier = ev.type === 'meta' ? ev : ev.result;
+                        const tid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'taskId')) : undefined;
+                        const sid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId')) : undefined;
+                        const runId = ev.type === 'done' && tid !== undefined && tid === sid ? undefined : tid;
+                        if (streamKind === 'live' && runId !== undefined && runId !== taskId) {
+                            taskId = runId;
+                            sessionId = sid;
+                        }
+                        else if (sid !== undefined && taskId !== undefined && (runId === undefined || runId === taskId)) {
+                            sessionId = sid;
+                        }
                     }
-                    else if (sid !== undefined && taskId !== undefined && (runId === undefined || runId === taskId)) {
-                        sessionId = sid;
+                    if (taskId !== undefined) {
+                        if (binding === undefined || binding.taskId !== taskId || binding.sessionId !== sessionId) {
+                            binding = Object.freeze({ taskId, ...(sessionId !== undefined ? { sessionId } : {}) });
+                        }
+                        if (sessionId !== undefined)
+                            runSessions.set(taskId, sessionId);
+                        registerFrameBinding(ev, binding);
+                        noteBound(binding);
                     }
                 }
-                if (taskId !== undefined) {
-                    if (binding === undefined || binding.taskId !== taskId || binding.sessionId !== sessionId) {
-                        binding = Object.freeze({ taskId, ...(sessionId !== undefined ? { sessionId } : {}) });
-                    }
-                    if (sessionId !== undefined)
-                        runSessions.set(taskId, sessionId);
-                    registerFrameBinding(ev, binding);
-                    noteBound(binding);
+                if (inDomain('stampOwner', ev.type)) {
+                    const b = frameBindingOf(ev);
+                    recordSubagentOwnerFromProgress(ev, b?.taskId, b?.sessionId, sessionKey);
                 }
+                if (deliverHitl(ev, env, ended.signal))
+                    continue;
+                for (const tap of taps)
+                    callPort('taps', () => tap(ev));
+                yield ev;
             }
-            if (inDomain('stampOwner', ev.type)) {
-                const b = frameBindingOf(ev);
-                recordSubagentOwnerFromProgress(ev, b?.taskId, b?.sessionId, sessionKey);
-            }
-            if (deliverHitl(ev, env))
-                continue;
-            for (const tap of taps)
-                callPort('taps', () => tap(ev));
-            yield ev;
+        }
+        finally {
+            ended.abort();
         }
     }
     const streamOf = (raw, streamKind, streamRunId) => {

package/dist/fileHistoryCaptureCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type FileHistoryCaptureReading = {
     kind: 'unobserved';
 } | {
@@ -18,7 +19,7 @@ export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureR
 export declare const FILE_HISTORY_TIGHTEN_VERDICTS: readonly ["not_requested", "declare", "already_off", "unjudged"];
 export type FileHistoryTightenVerdict = (typeof FILE_HISTORY_TIGHTEN_VERDICTS)[number];
 export declare function fileHistoryTightenVerdict(reading: FileHistoryCaptureReading, captureOffByUser: boolean): FileHistoryTightenVerdict;
-export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean): string | undefined;
+export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean, lang?: UiLanguage): string | undefined;
 export interface FileHistoryTightenJudgement {
     readonly verdict: FileHistoryTightenVerdict;
     readonly reading: FileHistoryCaptureReading;

package/dist/fileHistoryCaptureCapability.js

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
@@ -60,21 +61,11 @@ export function fileHistoryTightenVerdict(reading, captureOffByUser) {
         return 'already_off';
     return 'unjudged';
 }
-const FILE_HISTORY_REFUSAL_NOT_YET = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's capabilities have not been read " +
-    'yet, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. ' +
-    'Try again in a moment; to send regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_NOT_SAID = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
-    'stop recording file history for a session, so sending now could record it anyway. Trying again will not change that ' +
-    'while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_UNRECOGNIZED = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine reported a file-history capture mode ' +
-    'this client does not recognize, so whether it can stop recording file history for a session is unknown and sending now could ' +
-    'record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be ' +
-    'recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_UNREADABLE = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's report on whether it can stop " +
-    'recording file history for a session could not be read by this client, so sending now could record it anyway. Trying ' +
-    'again will not change that while this engine reports the same; to send and let file history be recorded this time, ' +
-    'turn file checkpointing back on in your settings.';
-function unjudgedRefusalOf(reading) {
+const FILE_HISTORY_REFUSAL_NOT_YET = 'session.fileHistoryRefusal.notYet';
+const FILE_HISTORY_REFUSAL_NOT_SAID = 'session.fileHistoryRefusal.notSaid';
+const FILE_HISTORY_REFUSAL_UNRECOGNIZED = 'session.fileHistoryRefusal.unrecognized';
+const FILE_HISTORY_REFUSAL_UNREADABLE = 'session.fileHistoryRefusal.unreadable';
+function unjudgedRefusalKeyOf(reading) {
     let kind;
     let word;
     try {
@@ -92,8 +83,11 @@ function unjudgedRefusalOf(reading) {
         return FILE_HISTORY_REFUSAL_UNRECOGNIZED;
     return FILE_HISTORY_REFUSAL_NOT_YET;
 }
-export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
-    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading) : undefined;
+function unjudgedRefusalOf(reading, lang) {
+    return renderMessage(msg(unjudgedRefusalKeyOf(reading)), lang);
+}
+export function fileHistoryUnjudgedRefusal(reading, captureOffByUser, lang) {
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading, lang) : undefined;
 }
 const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
 export async function judgeFileHistoryTighten(captureOffByUser, opts) {
@@ -101,7 +95,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
     const failClosed = () => {
         const reading = { kind: 'unobserved' };
         return closed
-            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_REFUSAL_NOT_YET }
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: renderMessage(msg(FILE_HISTORY_REFUSAL_NOT_YET)) }
             : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
     };
     try {

package/dist/fileHistoryLegNotice.d.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
 import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
 export type FileHistoryDeclarationFact = 'sent' | 'not_sent' | 'unknown';
 export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "honored", "not_declared", "unknown"];
@@ -10,7 +11,7 @@ export interface FileHistoryLegNoticeInput {
     readonly legWord: string | undefined;
 }
 export declare function fileHistoryLegNoticeVerdict(input: FileHistoryLegNoticeInput): FileHistoryLegNoticeVerdict;
-export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict): string | null;
+export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict, lang?: UiLanguage): string | null;
 export declare function fileHistoryDeclarationOfBody(body: object | null | undefined): FileHistoryDeclarationFact;
 export type OutboundBodyField = {
     kind: 'absent';

package/dist/fileHistoryLegNotice.js

@@ -1,4 +1,5 @@
 import { fileHistoryCaptureMode } from './fileHistoryCaptureCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { frameProvesDelivery } from './promptDelivery.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export const FILE_HISTORY_LEG_VERDICTS = Object.freeze(['not_honored', 'honored', 'not_declared', 'unknown']);
@@ -35,10 +36,9 @@ export function fileHistoryLegNoticeVerdict(input) {
         return 'not_declared';
     return 'unknown';
 }
-const NOT_HONORED_SENTENCE = 'The engine is still capturing file history for this session, though your settings asked it not to.';
-export function fileHistoryLegNoticeSentence(verdict) {
+export function fileHistoryLegNoticeSentence(verdict, lang) {
     if (verdict === 'not_honored')
-        return NOT_HONORED_SENTENCE;
+        return renderMessage(msg('session.fileHistoryLeg.notHonored'), lang);
     return null;
 }
 export function fileHistoryDeclarationOfBody(body) {