@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/credentialProvenance.js

@@ -0,0 +1,76 @@
+export const CREDENTIAL_ATTACH_WORDS = Object.freeze(['local-sidecar', 'service-token', 'registry', 'none']);
+const TARGET_KIND_WORDS = ['local-managed', 'loopback-pin', 'remote', 'unresolved'];
+const TARGET_PROVENANCE_WORDS = ['managed', 'connect-pin', 'manual', 'none'];
+const CONSENT_WORDS = ['granted', 'absent', 'n/a'];
+const SIDECAR_OWNERSHIP_WORDS = ['verified', 'mismatch'];
+function said(word) {
+    const r = { kind: 'word', word };
+    return Object.freeze(r);
+}
+function unreadable(reason) {
+    const r = { kind: 'unreadable', reason };
+    return Object.freeze(r);
+}
+function ownData(holder, key) {
+    try {
+        if (typeof holder !== 'object' || holder === null)
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(holder, key);
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownBool(holder, key) {
+    const v = ownData(holder, key);
+    return typeof v === 'boolean' ? v : undefined;
+}
+function ownWord(holder, key, closed) {
+    const v = ownData(holder, key);
+    return typeof v === 'string' ? closed.find((w) => w === v) : undefined;
+}
+function decide(facts) {
+    if (typeof facts !== 'object' || facts === null || Array.isArray(facts))
+        return unreadable('facts');
+    const kind = ownWord(facts, 'kind', TARGET_KIND_WORDS);
+    if (kind === undefined)
+        return unreadable('kind');
+    if (kind === 'unresolved')
+        return said('none');
+    if (kind === 'local-managed') {
+        const owned = ownWord(facts, 'sidecarOwnership', SIDECAR_OWNERSHIP_WORDS);
+        if (owned === undefined)
+            return unreadable('sidecarOwnership');
+        return said(owned === 'verified' ? 'local-sidecar' : 'none');
+    }
+    const tokenAtFirstWrite = ownBool(facts, 'serviceTokenAtFirstWrite');
+    if (tokenAtFirstWrite === undefined)
+        return unreadable('serviceTokenAtFirstWrite');
+    if (tokenAtFirstWrite)
+        return said('service-token');
+    const loggedIn = ownBool(facts, 'loggedIn');
+    if (loggedIn === undefined)
+        return unreadable('loggedIn');
+    if (!loggedIn)
+        return said('none');
+    const provenance = ownWord(facts, 'provenance', TARGET_PROVENANCE_WORDS);
+    if (provenance === undefined)
+        return unreadable('provenance');
+    if (provenance !== 'connect-pin')
+        return said('none');
+    if (kind === 'remote')
+        return said('registry');
+    const consent = ownWord(facts, 'consent', CONSENT_WORDS);
+    if (consent === undefined || consent === 'n/a')
+        return unreadable('consent');
+    return said(consent === 'granted' ? 'registry' : 'none');
+}
+export function credentialProvenance(facts) {
+    try {
+        return decide(facts);
+    }
+    catch {
+        return unreadable('facts');
+    }
+}

package/dist/cycleOrder.d.ts

@@ -0,0 +1,15 @@
+export interface EngineAgentPanelCycleIdentity {
+    readonly cycleSeq?: number;
+    readonly startedAt?: number;
+}
+export type CycleOrder = 'before' | 'after' | 'same' | 'unknown';
+export declare function cycleSeqValue(v: unknown): number | undefined;
+export declare function cycleSeqOf(v: EngineAgentPanelCycleIdentity | null | undefined): number | undefined;
+export declare function startedAtOf(v: EngineAgentPanelCycleIdentity | null | undefined): number | undefined;
+export declare function cycleOrder(a: EngineAgentPanelCycleIdentity | null | undefined, b: EngineAgentPanelCycleIdentity | null | undefined): CycleOrder;
+export declare function cycleSeqOrder(a: number | undefined, b: number | undefined): CycleOrder;
+export declare function cycleOf(v: EngineAgentPanelCycleIdentity | null | undefined): EngineAgentPanelCycleIdentity;
+export declare function cycleEmpty(v: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+export declare function cycleKeysChanged(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+export declare function carryCycle(frame: EngineAgentPanelCycleIdentity, prev: EngineAgentPanelCycleIdentity | undefined, carry: boolean): EngineAgentPanelCycleIdentity;
+export declare function mergeCycle(prefer: EngineAgentPanelCycleIdentity, fallback: EngineAgentPanelCycleIdentity | undefined): EngineAgentPanelCycleIdentity;

package/dist/cycleOrder.js

@@ -0,0 +1,45 @@
+export function cycleSeqValue(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 1 ? v : undefined;
+}
+export function cycleSeqOf(v) {
+    return cycleSeqValue(v?.cycleSeq);
+}
+export function startedAtOf(v) {
+    const n = v?.startedAt;
+    return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
+}
+export function cycleOrder(a, b) {
+    const ac = cycleSeqOf(a);
+    const bc = cycleSeqOf(b);
+    if (ac !== undefined && bc !== undefined)
+        return ac < bc ? 'before' : ac > bc ? 'after' : 'same';
+    const as = startedAtOf(a);
+    const bs = startedAtOf(b);
+    if (as !== undefined && bs !== undefined)
+        return as < bs ? 'before' : as > bs ? 'after' : 'same';
+    return 'unknown';
+}
+export function cycleSeqOrder(a, b) {
+    return cycleOrder(a === undefined ? undefined : { cycleSeq: a }, b === undefined ? undefined : { cycleSeq: b });
+}
+export function cycleOf(v) {
+    const c = cycleSeqOf(v);
+    const s = startedAtOf(v);
+    return { ...(c !== undefined ? { cycleSeq: c } : {}), ...(s !== undefined ? { startedAt: s } : {}) };
+}
+export function cycleEmpty(v) {
+    return cycleSeqOf(v) === undefined && startedAtOf(v) === undefined;
+}
+export function cycleKeysChanged(prev, next) {
+    const nc = cycleSeqOf(next);
+    const ns = startedAtOf(next);
+    return (nc !== undefined && nc !== cycleSeqOf(prev)) || (ns !== undefined && ns !== startedAtOf(prev));
+}
+export function carryCycle(frame, prev, carry) {
+    const c = cycleSeqOf(frame) ?? (carry ? cycleSeqOf(prev) : undefined);
+    const s = startedAtOf(frame) ?? (carry ? startedAtOf(prev) : undefined);
+    return { ...(c !== undefined ? { cycleSeq: c } : {}), ...(s !== undefined ? { startedAt: s } : {}) };
+}
+export function mergeCycle(prefer, fallback) {
+    return carryCycle(prefer, fallback, true);
+}

package/dist/decideFailureNote.js

@@ -1,20 +1,25 @@
-import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
+import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
 import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
+import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
     const bucket = settingsPermissionBucketRefusalFromError(err);
+    const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
+    const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
         (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
+        (scenario === null ? '' : ` — ${scenarioNotAllowedContent(scenario, undefined, 'resumed_work')}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
-        (gone === null ? '' : ` — ${askGoneContent(gone)}`));
+        (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
+        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : ''));
 }

package/dist/decideReceipt.d.ts

@@ -1,6 +1,7 @@
 import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
 import { type CrashConvergedRow } from './hitl/crashConverged.js';
+import type { AskRowEndingCause } from '@sema-agent/sdk';
 export interface DecideReceiptView {
     status?: string;
     taskId?: string;
@@ -33,7 +34,7 @@ export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetai
 export interface AskGoneDetail {
     code: 'gone.ask';
     state?: 'VOID' | 'DENIED';
-    deniedReason?: string;
+    endingCause?: AskRowEndingCause;
     holderGone?: CrashConvergedRow['cause'];
 }
 export declare function askGoneFromError(e: unknown): AskGoneDetail | null;

package/dist/decideReceipt.js

@@ -1,9 +1,10 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
-import { ASK_GONE, ASK_GONE_DENIED_WORD, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { ASK_GONE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
-import { readErrorString, readErrorStrictStringList } from './wireFailureShape.js';
+import { readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
+import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -132,6 +133,35 @@ export function decideParkMovedContent(detail) {
     const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
     return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
 }
+function askGoneRawCause(e) {
+    let top;
+    try {
+        top = e.endingCause;
+    }
+    catch {
+        top = undefined;
+    }
+    if (typeof top === 'string')
+        return top;
+    const reading = readThrownExtra(e);
+    if (reading.state === 'unreadable')
+        return undefined;
+    if (reading.state === 'object') {
+        const extra = reading.value;
+        let hasCause = false;
+        let word;
+        try {
+            hasCause = Object.hasOwn(extra, 'cause');
+            word = hasCause ? extra.cause : undefined;
+        }
+        catch {
+            return undefined;
+        }
+        if (hasCause)
+            return word;
+    }
+    return undefined;
+}
 export function askGoneFromError(e) {
     if (typeof e !== 'object' || e === null)
         return null;
@@ -139,37 +169,32 @@ export function askGoneFromError(e) {
         return null;
     const rawState = readErrorString(e, 'state');
     const state = rawState === 'VOID' || rawState === 'DENIED' ? rawState : undefined;
-    const rawReason = readErrorString(e, 'deniedReason');
-    const deniedReason = rawReason === undefined || rawReason.length === 0
-        ? undefined
-        : state === 'DENIED'
-            ? rawReason === ASK_GONE_DENIED_WORD ? rawReason : undefined
-            : state === 'VOID' ? rawReason : undefined;
-    const holderGone = state === 'VOID' && isCrashConvergedCause(deniedReason) ? deniedReason : undefined;
+    const endingCause = askRowEndingCauseFor(state, askGoneRawCause(e));
+    const holderGone = state === 'VOID' && isCrashConvergedCause(endingCause) ? endingCause : undefined;
     return {
         code: ASK_GONE,
         ...(state !== undefined ? { state } : {}),
-        ...(deniedReason !== undefined ? { deniedReason } : {}),
+        ...(endingCause !== undefined ? { endingCause } : {}),
         ...(holderGone !== undefined ? { holderGone } : {}),
     };
 }
 export function askGoneContent(detail) {
     let state;
-    let deniedReason;
+    let endingCause;
     let holderGone;
     try {
         state = detail.state;
-        deniedReason = detail.deniedReason;
+        endingCause = detail.endingCause;
         holderGone = detail.holderGone;
     }
     catch {
         state = undefined;
-        deniedReason = undefined;
+        endingCause = undefined;
         holderGone = undefined;
     }
     const st = state === 'VOID' || state === 'DENIED' ? state : undefined;
     const safety = 'Your answer was not applied and nothing was run on it';
-    if (st === 'VOID' && (isCrashConvergedCause(holderGone) || isCrashConvergedCause(deniedReason))) {
+    if (st === 'VOID' && (isCrashConvergedCause(holderGone) || isCrashConvergedCause(endingCause))) {
         return [
             'The engine run that was waiting for this answer ended before the answer arrived',
             safety,

package/dist/declared/supportFloorDeclared.d.ts

@@ -0,0 +1 @@
+export declare const DECLARED_SUPPORT_FLOOR: Readonly<Record<"server" | "core" | "sdk", string>>;

package/dist/declared/supportFloorDeclared.js

@@ -0,0 +1,5 @@
+export const DECLARED_SUPPORT_FLOOR = Object.freeze({
+    server: "7.125.0",
+    core: "7.48.0",
+    sdk: "20.0.0",
+});

package/dist/deviceExecutorManagementCapability.d.ts

@@ -20,5 +20,4 @@ export declare function observedDeviceExecutorManagement(baseUrl?: string | unde
 export declare function deviceManagementVerbsAvailable(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceLaneOpen(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceExecutorManagementDoctorDetail(reading: DeviceExecutorManagementReading): string;
-export declare function forgetDeviceExecutorManagementReading(baseUrl: string | undefined): void;
 export declare function __resetDeviceExecutorManagementReadingsForTests(): void;

package/dist/deviceExecutorManagementCapability.js

@@ -1,27 +1,21 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-function ownRead(o, key) {
-    return Object.hasOwn(o, key) ? o[key] : undefined;
-}
 export function projectDeviceExecutorManagementCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        const c = caps;
-        if (!Object.hasOwn(c, 'deviceExecutor'))
-            return { kind: 'not_reported', why: 'capability_absent' };
-        const d = c.deviceExecutor;
+        const d = ownDataField(caps, 'deviceExecutor');
         if (d === undefined)
             return { kind: 'not_reported', why: 'capability_absent' };
         if (d === false)
             return { kind: 'lane_absent' };
         if (d === null || typeof d !== 'object' || Array.isArray(d))
             return undefined;
-        const o = d;
-        if (ownRead(o, 'enabled') !== true)
+        if (ownDataField(d, 'enabled') !== true)
             return undefined;
-        const mgmt = ownRead(o, 'management');
+        const mgmt = ownDataField(d, 'management');
         let management;
         if (mgmt === undefined)
             management = 'absent';
@@ -31,9 +25,9 @@ export function projectDeviceExecutorManagementCapability(caps) {
             management = 'present-false';
         else
             return undefined;
-        const pv = ownRead(o, 'protocolVersion');
-        const mi = ownRead(o, 'maxInflightPerDevice');
-        const ws = ownRead(o, 'wsPath');
+        const pv = ownDataField(d, 'protocolVersion');
+        const mi = ownDataField(d, 'maxInflightPerDevice');
+        const ws = ownDataField(d, 'wsPath');
         return {
             kind: 'present',
             management,
@@ -108,9 +102,6 @@ export function deviceExecutorManagementDoctorDetail(reading) {
         }
     }
 }
-export function forgetDeviceExecutorManagementReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetDeviceExecutorManagementReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/deviceRebind.d.ts

@@ -0,0 +1,88 @@
+import type { AgentClient } from '@sema-agent/sdk';
+export type DeviceListVerb = Pick<AgentClient['devices'], 'list'>;
+export type DeviceSessionBindingVerb = Pick<AgentClient['devices'], 'sessionBinding'>;
+export type DeviceRebindVerb = Pick<AgentClient['devices'], 'rebind'>;
+export interface DeviceRosterRow {
+    readonly deviceId: string;
+    readonly name?: string;
+    readonly status: 'online' | 'offline' | 'unknown';
+    readonly lastSeenAt?: string;
+}
+export interface DeviceBindingReading {
+    readonly deviceId: string;
+    readonly rev: number;
+    readonly boundAt?: string;
+}
+export interface DeviceRefused {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+    readonly message?: string;
+}
+export interface DeviceLaneAbsent {
+    readonly kind: 'lane-absent';
+    readonly runStoreOnly?: true;
+}
+export interface DeviceTransport {
+    readonly kind: 'transport';
+    readonly detail?: string;
+}
+export interface DeviceUnreadable {
+    readonly kind: 'unreadable';
+    readonly why: string;
+}
+export interface DeviceUnarmed {
+    readonly kind: 'unarmed';
+}
+export type DeviceListOutcome = {
+    readonly kind: 'ok';
+    readonly devices: readonly DeviceRosterRow[];
+    readonly dropped: number;
+} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+export type DeviceSessionBindingOutcome = {
+    readonly kind: 'ok';
+    readonly rootSessionId: string;
+    readonly boundDevice: DeviceBindingReading;
+} | {
+    readonly kind: 'not-found';
+} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+export interface DeviceRebindInput {
+    readonly rootSessionId: string;
+    readonly toDeviceId: string;
+    readonly expectedRev: number;
+    readonly fromDeviceId: string;
+}
+export interface DeviceRebindUnconfirmed {
+    readonly kind: 'unconfirmed';
+    readonly why: 'accepted-unreadable' | 'transport' | 'server-error';
+    readonly detail?: string;
+    readonly mayStillBeRunning: boolean;
+}
+export type DeviceRebindOutcome = {
+    readonly kind: 'ok';
+    readonly deviceId: string;
+    readonly rev: number;
+    readonly workspaceCarryover?: 'none';
+} | {
+    readonly kind: 'active-run';
+    readonly activeTaskId?: string;
+} | {
+    readonly kind: 'rev-conflict';
+    readonly currentRev?: number;
+} | {
+    readonly kind: 'not-found';
+} | DeviceRebindUnconfirmed | DeviceLaneAbsent | DeviceRefused | DeviceUnarmed;
+export type DeviceRebindReconcileVerdict = 'landed' | 'already-there' | 'unchanged' | 'unknown';
+export declare function listDevices(devices: DeviceListVerb | null | undefined, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceListOutcome>;
+export declare function readSessionBinding(devices: DeviceSessionBindingVerb | null | undefined, rootSessionId: string, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceSessionBindingOutcome>;
+export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceRebindOutcome>;
+export declare function reconcileRebindOutcome(before: DeviceBindingReading, toDeviceId: string, after: DeviceBindingReading | null, opts: {
+    readonly serverMayStillBeRunning: boolean;
+}): DeviceRebindReconcileVerdict;
+export declare function rebindProvesRequestNotApplied(outcome: DeviceRebindOutcome): boolean;