@sema-agent/client-core 0.108.0 → 0.109.0

package/dist/adapt/arms.js

@@ -7,7 +7,7 @@ import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.js';
 import { recordEngineToolLabel } from '../engineToolLabelStore.js';
-import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
+import { applySubagentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
@@ -15,7 +15,7 @@ import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { isMintedRowCcError, readProviderRejectionResendKey } from '../providerRejection.js';
 import { rowKindOf } from '../rowKind.js';
 import { terminalCodedDetailOf } from '../runTerminal.js';
-import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, humanInputAuthorKeys, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
 import { CORE_USER_ATTACHMENT_LABEL_MAX } from '../generated/engineFactTables.js';
 import { ESCAPE_FACE, paintAndCap, washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
@@ -236,7 +236,9 @@ const userArm = function* (m, { ctx, idOf }) {
         return;
     yield transcript({ ...m, uuid: idOf(m), session_id: ctx.sessionId }, ctx.now());
 };
-const systemArm = function* (m, { ctx, idOf }) {
+const systemArm = function* (m, { ctx, idOf, text }) {
+    if (readFrameStringKey(m, 'subtype') === 'compact_boundary')
+        text.noteModelSegmentBoundary();
     yield transcript(m, ctx.now());
     const attachedFiles = m._sema_attached_files;
     if (Array.isArray(attachedFiles)) {
@@ -325,13 +327,20 @@ const humanInputArm = function* (m) {
         ...(str(m.entryId) !== undefined ? { entryId: str(m.entryId) } : {}),
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
         ...humanInputAttachmentsForChrome(m),
+        ...humanInputAuthorKeys(m),
     });
 };
 function humanInputAttachmentsForChrome(m) {
     const rows = humanInputAttachmentsOf(m);
     if (rows === undefined)
         return {};
-    return { attachments: rows.map((r) => (r.label !== undefined ? { ...r, label: paintAndCap(r.label, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } : r)) };
+    return {
+        attachments: rows.map((r) => ({
+            ...r,
+            ...(r.label !== undefined ? { label: paintAndCap(r.label, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } : {}),
+            ...(r.declinedBy !== undefined ? { declinedBy: { kind: r.declinedBy.kind, name: paintAndCap(r.declinedBy.name, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } } : {}),
+        })),
+    };
 }
 const messageCommittedArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
@@ -623,6 +632,7 @@ const textSegmentEndArm = function* (m, { text }) {
     if (content.length === 0)
         return;
     text.anchorWindow(m);
+    yield* text.admitEndOnlyBlock(content, m);
     const r = text.replaceAnswerSegment(content, m);
     yield* text.drainLive();
     yield chrome({
@@ -677,8 +687,9 @@ const toolEndResultArm = function* (m, deps) {
     const structured = ownSnapshotWhenTyped(m.structured, 'task-output');
     if (callId !== undefined) {
         const launched = readAsyncLaunchedAgentReceipt(structured);
-        if (launched !== null)
-            registerSubagentContentAlias(callId, launched.taskId);
+        if (launched !== null && applySubagentAlias(callId, launched.taskId, 'content') !== 'rejected') {
+            yield chrome({ kind: 'subagent_alias', laneProof: { lane: 'subagent', parentToolCallId: callId }, parentToolCallId: callId, taskId: launched.taskId, scope: 'content' });
+        }
     }
     if (callId !== undefined && isUnsettledHeldToolEnd(m)) {
         const held = cards.detach(callId);
@@ -769,8 +780,12 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         }));
         return;
     }
-    if (explicitParent !== undefined)
-        registerSubagentAlias(explicitParent, taskId);
+    if (explicitParent !== undefined) {
+        const aliasSeq = cycleSeqValue(m.seq);
+        if (applySubagentAlias(explicitParent, taskId, 'full', aliasSeq) !== 'rejected') {
+            yield chrome({ kind: 'subagent_alias', laneProof: { lane: 'subagent', parentToolCallId: explicitParent }, parentToolCallId: explicitParent, taskId, scope: 'full', ...(aliasSeq !== undefined ? { seq: aliasSeq } : {}) });
+        }
+    }
     const cardId = panel.bind(taskId, explicitParent);
     const usage = (m.usage ?? {});
     ctx.probe?.('tick', JSON.stringify({

package/dist/adapt/textStream.d.ts

@@ -18,6 +18,8 @@ interface ThinkingSegmentReplacement {
 }
 export interface TextStream {
     feedText(delta: string, frame: Frame): Generator<AdapterOutput>;
+    admitEndOnlyBlock(content: string, frame: Frame): Generator<AdapterOutput>;
+    noteModelSegmentBoundary(): void;
     feedThinking(delta: string, frame: Frame): Generator<AdapterOutput>;
     drainLive(): Generator<AdapterOutput>;
     takeThinking(): Generator<AdapterOutput>;

package/dist/adapt/textStream.js

@@ -39,6 +39,10 @@ export function createTextStream(ctx, idOf) {
     let segmentCommitted = '';
     let previousSegmentCommitted = '';
     let segmentWindowCloseArmed = false;
+    let wholeBlockDelivered = false;
+    const closeWholeBlockMark = () => {
+        wholeBlockDelivered = false;
+    };
     const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
         ? ctx.coalesceIntervalMs
         : FLUSH_INTERVAL_MS;
@@ -122,6 +126,7 @@ export function createTextStream(ctx, idOf) {
     }
     function* takeAnswerSegment() {
         idleFlushUsedInSegment = false;
+        closeWholeBlockMark();
         yield* emitAnswerSegment();
         previousSegmentCommitted += segmentCommitted;
         segmentCommitted = '';
@@ -166,23 +171,37 @@ export function createTextStream(ctx, idOf) {
             textPending = '';
         }
     }
+    function* feedText(delta, frame) {
+        if (delta.length === 0 && segmentWindowCloseArmed && previousSegmentCommitted + segmentCommitted !== '')
+            return;
+        consumeArmedClose();
+        if (thinking.length > 0 || thinkingPending.length > 0) {
+            yield* drainLive();
+            yield* takeThinking();
+        }
+        if (answerSegment.length === 0)
+            segmentAnchor = frame;
+        segmentLast = frame;
+        openSegmentWindow(frame);
+        answer += delta;
+        answerSegment += delta;
+        textPending += delta;
+    }
+    function* admitEndOnlyBlock(content, frame) {
+        if (content.length === 0 || wholeBlockDelivered)
+            return;
+        const verdict = resolveTextSegmentAuthority(content, {
+            committedPrefix: previousSegmentCommitted + segmentCommitted,
+            openSegment: answerSegment,
+        });
+        if (verdict.form !== 'untouched')
+            return;
+        yield* feedText(content, frame);
+    }
     return {
-        *feedText(delta, frame) {
-            if (delta.length === 0 && segmentWindowCloseArmed && previousSegmentCommitted + segmentCommitted !== '')
-                return;
-            consumeArmedClose();
-            if (thinking.length > 0 || thinkingPending.length > 0) {
-                yield* drainLive();
-                yield* takeThinking();
-            }
-            if (answerSegment.length === 0)
-                segmentAnchor = frame;
-            segmentLast = frame;
-            openSegmentWindow(frame);
-            answer += delta;
-            answerSegment += delta;
-            textPending += delta;
-        },
+        feedText,
+        admitEndOnlyBlock,
+        noteModelSegmentBoundary: closeWholeBlockMark,
         *feedThinking(delta, frame) {
             if (thinkingSettled) {
                 if (thinking.length > 0) {
@@ -335,6 +354,8 @@ export function createTextStream(ctx, idOf) {
             emittedAssistantText = true;
             if (typeof committed === 'string')
                 committedText += committed;
+            if (typeof committed === 'string' && committed.length > 0)
+                wholeBlockDelivered = true;
         },
         replaceThinkingSegment: (content, anchor) => {
             const rows = committedThinking;

package/dist/adapter/activeRunSelfHeal.js

@@ -1231,7 +1231,7 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             if (outcome.rowVerdict !== undefined) {
                 return say(lang, 'session.selfHeal.row.askReopenFailed.rowUnresumable', {
                     taskId: outcome.taskId,
-                    sentence: checkpointRowBarSentence(outcome.rowVerdict),
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict, lang),
                     unbound: rowBarWayOutContent(outcome.rowVerdict, outcome.rowDeadline ?? 'unknown', lang),
                 });
             }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,7 +5,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf, toolInputRewriteOf } from '.
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpAuthorization, readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, workflowCompletionExtrasOf } from '../../ownKey.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, humanInputAuthorKeys, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, workflowCompletionExtrasOf } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -954,6 +954,7 @@ function humanInputProjection(ev, ctx) {
         ...(str(ev.eventId) !== undefined ? { eventId: str(ev.eventId) } : {}),
         ...(str(ev.parentToolCallId) !== undefined ? { parentToolCallId: str(ev.parentToolCallId) } : {}),
         ...attachmentsKey(humanInputAttachmentsOf(ev)),
+        ...humanInputAuthorKeys(ev),
     })));
 }
 function attachmentsKey(rows) {

package/dist/agentSession/engineAgentRegistryRead.js

@@ -77,6 +77,7 @@ function readRow(v) {
     const description = Object.hasOwn(o, 'description') ? o.description : undefined;
     const createdAt = Object.hasOwn(o, 'createdAt') ? o.createdAt : undefined;
     const childSessionId = type === 'background_agent' ? guardedRead(() => readOwnDataValue(o, 'sessionId')) : undefined;
+    const retained = guardedRead(() => readOwnDataValue(o, 'retained')) === true;
     return {
         id,
         type,
@@ -84,6 +85,7 @@ function readRow(v) {
         ...(typeof description === 'string' && description.length > 0 ? { description } : {}),
         ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
         ...(typeof childSessionId === 'string' && childSessionId.length > 0 ? { sessionId: childSessionId } : {}),
+        ...(retained ? { retained: true } : {}),
     };
 }
 export async function readEngineAgentRegistry(client, sessionId, capsBaseUrl, opts) {

package/dist/bashExitReading.d.ts

@@ -8,3 +8,15 @@ export interface BashExitReading {
 }
 export declare function bashExitOf(structured: unknown, parseFrame: () => BashFrameExit | null): BashExitReading;
 export declare function bashExitReadingFailed(r: BashExitReading): boolean;
+export type BashCurtailmentKind = 'timedOut' | 'livenessNoOutput' | 'aborted' | 'callbackError';
+export interface BashCurtailment {
+    readonly kind: BashCurtailmentKind;
+    readonly timeoutSec?: number;
+    readonly noOutputSec?: number;
+}
+export declare function bashCurtailmentOf(structured: unknown): BashCurtailment | undefined;
+export declare function bashCurtailmentSentence(c: BashCurtailment): string;
+export declare function bashCurtailedResultPart(stderr: string, c: BashCurtailment | undefined): {
+    stderr: string;
+    _sema_curtailed?: BashCurtailment;
+};

package/dist/bashExitReading.js

@@ -1,3 +1,4 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
 export function bashExitOf(structured, parseFrame) {
     const s = typeof structured === 'object' && structured !== null ? structured : undefined;
     const interp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0 ? s.returnCodeInterpretation : undefined;
@@ -10,3 +11,46 @@ export function bashExitOf(structured, parseFrame) {
 export function bashExitReadingFailed(r) {
     return r.exitCode !== null && r.exitCode !== 0 && r.benignNote === undefined;
 }
+export function bashCurtailmentOf(structured) {
+    if (typeof structured !== 'object' || structured === null)
+        return undefined;
+    const own = (key) => guardedRead(() => readOwnDataValue(structured, key));
+    if (own('type') !== 'bash')
+        return undefined;
+    const secOf = (key) => {
+        const v = own(key);
+        return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? (v === 0 ? 0 : v) : undefined;
+    };
+    if (own('timedOut') === true) {
+        const timeoutSec = secOf('timeoutSec');
+        return timeoutSec === undefined ? { kind: 'timedOut' } : { kind: 'timedOut', timeoutSec };
+    }
+    if (own('livenessNoOutput') === true) {
+        const noOutputSec = secOf('noOutputSec');
+        return noOutputSec === undefined ? { kind: 'livenessNoOutput' } : { kind: 'livenessNoOutput', noOutputSec };
+    }
+    if (own('aborted') === true)
+        return { kind: 'aborted' };
+    if (own('callbackError') === true)
+        return { kind: 'callbackError' };
+    return undefined;
+}
+export function bashCurtailmentSentence(c) {
+    switch (c.kind) {
+        case 'timedOut':
+            return c.timeoutSec === undefined ? 'Command timed out' : `Command timed out after ${c.timeoutSec}s`;
+        case 'livenessNoOutput':
+            return c.noOutputSec === undefined ? 'Command killed: no output' : `Command killed: no output for ${c.noOutputSec}s`;
+        case 'aborted':
+            return 'Command was interrupted';
+        case 'callbackError':
+            return 'Command ended: output stream failed';
+    }
+}
+export function bashCurtailedResultPart(stderr, c) {
+    if (c === undefined)
+        return { stderr };
+    const sentence = bashCurtailmentSentence(c);
+    const alreadyLeads = stderr.startsWith(sentence) && stderr.charAt(sentence.length).trim() === '';
+    return { stderr: stderr.length === 0 ? sentence : alreadyLeads ? stderr : `${sentence} ${stderr}`, _sema_curtailed: { ...c } };
+}

package/dist/checkpointRowVerdict.d.ts

@@ -27,7 +27,7 @@ export type CheckpointRowBar = Exclude<CheckpointRowVerdictReading, {
 }>;
 export declare function checkpointRowBarOf(row: object | null | undefined): CheckpointRowBar | undefined;
 export declare const CHECKPOINT_ROW_BAR_SENTENCE: string;
-export declare function checkpointRowBarSentence(bar: CheckpointRowBar): string;
+export declare function checkpointRowBarSentence(bar: CheckpointRowBar, lang?: UiLanguage | (string & {})): string;
 export type CheckpointDeadlineState = 'armed' | 'none' | 'unknown';
 export declare function checkpointDeadlineStateOf(row: object | null | undefined): CheckpointDeadlineState;
 export declare function unboundWayOutContent(state: CheckpointDeadlineState, lang?: UiLanguage | (string & {})): string;

package/dist/checkpointRowVerdict.js

@@ -94,8 +94,10 @@ export function checkpointRowBarOf(row) {
     return v === undefined || v.kind === 'ok' ? undefined : v;
 }
 export const CHECKPOINT_ROW_BAR_SENTENCE = renderMessage(msg('approval.rowUnresumable.fallback'));
-export function checkpointRowBarSentence(bar) {
-    return bar.kind !== 'unreadable' && typeof bar.sentence === 'string' && bar.sentence !== '' ? bar.sentence : CHECKPOINT_ROW_BAR_SENTENCE;
+export function checkpointRowBarSentence(bar, lang) {
+    return bar.kind !== 'unreadable' && typeof bar.sentence === 'string' && bar.sentence !== ''
+        ? bar.sentence
+        : renderMessage(msg('approval.rowUnresumable.fallback'), isUiLanguage(lang) ? lang : undefined);
 }
 export function checkpointDeadlineStateOf(row) {
     try {

package/dist/compensations.js

@@ -118,7 +118,7 @@ export const MIGRATED_COMPENSATIONS = [
         id: 'T49',
         what: 'subagent alias 只能在 tick 上学 —— content 帧只带 parentToolCallId、没有 taskId',
         disposition: 'in-library',
-        libraryHalf: 'adapt.ts task_progress 臂 registerSubagentAlias(explicitParent, taskId)',
+        libraryHalf: 'adapt.ts task_progress 臂 applySubagentAlias(explicitParent, taskId, \'full\')(与 registerSubagentAlias 同一实现)',
         chromeArm: null,
         hostHalf: null,
         retireOn: 'RL-40',

package/dist/engineAgentAbsence.d.ts

@@ -56,6 +56,7 @@ export interface EngineAgentRegistryRowView {
     readonly description?: string;
     readonly createdAt?: number;
     readonly sessionId?: string;
+    readonly retained?: true;
 }
 export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'capability_unknown' | 'route_absent' | 'ownership_required' | 'read_failed';
 export type EngineAgentRegistryListing = {
@@ -75,6 +76,7 @@ export interface EngineAgentRegistryReadingOptions {
     readonly sessionId?: string;
 }
 export declare function engineAgentRegistryReadingOf(listing: EngineAgentRegistryListing | null | undefined, registryKey: string | null | undefined, opts?: EngineAgentRegistryReadingOptions | null): EngineAgentRegistryReading;
+export declare function localEngineSessionShellsOf(listings: readonly (EngineAgentRegistryListing | null | undefined)[]): number | 'unknown';
 export interface EngineAgentRegistryMissingRow {
     readonly id: string;
     readonly status: string;

package/dist/engineAgentAbsence.js

@@ -214,6 +214,34 @@ function readingFromRecord(rec, registryKey, opts) {
     const single = ownOpt(opts, 'singleReplica');
     return single.given && single.value === true && REGISTRY_AGENT_HANDLE_RE.test(registryKey) ? 'not_listed' : 'unknown';
 }
+const SESSION_SHELL_TYPES = new Set(Object.keys({ background_bash: true, monitor: true }));
+export function localEngineSessionShellsOf(listings) {
+    try {
+        if (!Array.isArray(listings))
+            return 'unknown';
+        let count = 0;
+        for (let i = 0; i < listings.length; i++) {
+            if (!Object.hasOwn(listings, i))
+                return 'unknown';
+            const rec = registryListingProvenanceOf(listings[i]);
+            if (rec === undefined || rec.superseded || rec.rawRowCount >= REGISTRY_LIST_LIMIT)
+                return 'unknown';
+            for (const r of rec.rows) {
+                if (!SESSION_SHELL_TYPES.has(r.type) || r.retained === true)
+                    continue;
+                const reading = registryStatusReading(r.status);
+                if (reading === 'unknown')
+                    return 'unknown';
+                if (reading === 'running')
+                    count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function keySetOf(v) {
     if (v instanceof Set)
         return (k) => v.has(k);

package/dist/engineErrorCodes.d.ts

@@ -49,6 +49,10 @@ export declare const ATTACHMENT_BUNDLE_SEED_FIXED = "attachment.bundle_seed_fixe
 export declare const ATTACHMENT_BOUND_ELSEWHERE = "attachment.bound_elsewhere";
 export declare const CONFLICT_SESSION_MEMORY_UNOBSERVED = "conflict.session_memory_unobserved";
 export declare const CONFLICT_SESSION_ARCHIVE_STAMPED = "conflict.session_archive_stamped";
+export declare const REQUEST_ENV_CREDENTIAL_REFUSED = "request.env_credential_refused";
+export declare const CONFLICT_SESSION_ID_RETIRED = "conflict.session_id_retired";
+export declare const LIMIT_RATE_EXCEEDED = "limit.rate_exceeded";
+export declare const RATE_EXCEEDED_RUN_CONCURRENCY_CAP = "run_concurrency_cap";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";

package/dist/engineErrorCodes.js

@@ -73,6 +73,10 @@ export const ATTACHMENT_BUNDLE_SEED_FIXED = 'attachment.bundle_seed_fixed';
 export const ATTACHMENT_BOUND_ELSEWHERE = 'attachment.bound_elsewhere';
 export const CONFLICT_SESSION_MEMORY_UNOBSERVED = 'conflict.session_memory_unobserved';
 export const CONFLICT_SESSION_ARCHIVE_STAMPED = 'conflict.session_archive_stamped';
+export const REQUEST_ENV_CREDENTIAL_REFUSED = 'request.env_credential_refused';
+export const CONFLICT_SESSION_ID_RETIRED = 'conflict.session_id_retired';
+export const LIMIT_RATE_EXCEEDED = 'limit.rate_exceeded';
+export const RATE_EXCEEDED_RUN_CONCURRENCY_CAP = 'run_concurrency_cap';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';

package/dist/engineHealthFacts.d.ts

@@ -8,6 +8,7 @@ export interface EngineHealthAuthFacts {
     readonly required: boolean;
     readonly kinds: readonly (HealthAuthKind | (string & {}))[];
     readonly identityAttach: 'available' | 'unavailable';
+    readonly serviceTokenActsForDeployment?: boolean;
 }
 export interface EngineHealthDrainingFacts {
     readonly actionId: string;
@@ -17,6 +18,19 @@ export interface EngineHealthDrainingFacts {
 export interface EngineHealthLeaseFacts {
     readonly lingerMs: number;
     readonly tickMs: number;
+    readonly firstAttach?: EngineHealthFirstAttachFacts;
+}
+export interface EngineHealthFirstAttachFacts {
+    readonly windowMs: number;
+    readonly since: number;
+    readonly attachedAt: number | null;
+}
+export interface EngineHealthInflightFacts {
+    readonly total: number;
+    readonly http?: number;
+    readonly leader?: number;
+    readonly sessionResident?: number;
+    readonly backgroundAgents?: number;
 }
 export interface EngineHealthFacts {
     readonly center?: EngineHealthCenterFacts;
@@ -24,5 +38,8 @@ export interface EngineHealthFacts {
     readonly operator?: 'present' | 'absent';
     readonly draining?: EngineHealthDrainingFacts;
     readonly engineLease?: EngineHealthLeaseFacts;
+    readonly inflight?: EngineHealthInflightFacts;
+    readonly version?: string;
+    readonly dataRoot?: string;
 }
 export declare function readEngineHealthFacts(health: object | null | undefined): EngineHealthFacts;

package/dist/engineHealthFacts.js

@@ -1,5 +1,5 @@
 import { readOwnDataValue } from './ownKey.js';
-const _healthFactsMatchSdk = [true, true, true, true, true, true];
+const _healthFactsMatchSdk = [true, true, true, true, true, true, true, true, true, true];
 void _healthFactsMatchSdk;
 const ENGINE_SIGNAL_KEY = 'engineSignal';
 function isObject(v) {
@@ -51,7 +51,10 @@ function authOf(raw) {
             return undefined;
         kinds.push(word);
     }
-    return Object.freeze({ required, kinds: Object.freeze(kinds), identityAttach });
+    const actsRaw = readOwnDataValue(raw, 'serviceTokenActsForDeployment');
+    if (actsRaw !== undefined && typeof actsRaw !== 'boolean')
+        return undefined;
+    return Object.freeze({ required, kinds: Object.freeze(kinds), identityAttach, ...(typeof actsRaw === 'boolean' ? { serviceTokenActsForDeployment: actsRaw } : {}) });
 }
 function drainingOf(health) {
     const signal = readOwnDataValue(health, ENGINE_SIGNAL_KEY);
@@ -67,6 +70,17 @@ function drainingOf(health) {
         return undefined;
     return Object.freeze({ actionId, since, deadlineAt });
 }
+function firstAttachOf(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const windowMs = epochMs(readOwnDataValue(raw, 'windowMs'));
+    const since = epochMs(readOwnDataValue(raw, 'since'));
+    const attachedRaw = readOwnDataValue(raw, 'attachedAt');
+    const attachedAt = attachedRaw === null ? null : epochMs(attachedRaw);
+    if (windowMs === undefined || since === undefined || attachedAt === undefined)
+        return undefined;
+    return Object.freeze({ windowMs, since, attachedAt });
+}
 function leaseOf(raw) {
     if (!isObject(raw))
         return undefined;
@@ -74,7 +88,26 @@ function leaseOf(raw) {
     const tickMs = epochMs(readOwnDataValue(raw, 'tickMs'));
     if (lingerMs === undefined || tickMs === undefined)
         return undefined;
-    return Object.freeze({ lingerMs, tickMs });
+    const firstRaw = readOwnDataValue(raw, 'firstAttach');
+    const firstAttach = firstRaw === undefined ? undefined : firstAttachOf(firstRaw);
+    if (firstRaw !== undefined && firstAttach === undefined)
+        return undefined;
+    return Object.freeze({ lingerMs, tickMs, ...(firstAttach !== undefined ? { firstAttach } : {}) });
+}
+function inflightOf(health) {
+    const total = epochMs(readOwnDataValue(health, 'inflight'));
+    if (total === undefined)
+        return undefined;
+    const raw = guarded(() => readOwnDataValue(health, 'inflightBreakdown'));
+    const parts = {};
+    if (isObject(raw)) {
+        for (const key of ['http', 'leader', 'sessionResident', 'backgroundAgents']) {
+            const v = guarded(() => epochMs(readOwnDataValue(raw, key)));
+            if (v !== undefined)
+                parts[key] = v;
+        }
+    }
+    return Object.freeze({ total, ...parts });
 }
 function guarded(read) {
     try {
@@ -93,11 +126,17 @@ export function readEngineHealthFacts(health) {
     const operator = operatorRaw === 'present' || operatorRaw === 'absent' ? operatorRaw : undefined;
     const draining = guarded(() => drainingOf(health));
     const engineLease = guarded(() => leaseOf(readOwnDataValue(health, 'engineLease')));
+    const inflight = guarded(() => inflightOf(health));
+    const version = guarded(() => nonEmptyString(readOwnDataValue(health, 'version')));
+    const dataRoot = guarded(() => nonEmptyString(readOwnDataValue(health, 'dataRoot')));
     return Object.freeze({
         ...(center !== undefined ? { center } : {}),
         ...(auth !== undefined ? { auth } : {}),
         ...(operator !== undefined ? { operator } : {}),
         ...(draining !== undefined ? { draining } : {}),
         ...(engineLease !== undefined ? { engineLease } : {}),
+        ...(inflight !== undefined ? { inflight } : {}),
+        ...(version !== undefined ? { version } : {}),
+        ...(dataRoot !== undefined ? { dataRoot } : {}),
     });
 }