@sema-agent/client-core 0.102.0 → 0.104.0

package/dist/adapt/toolCards.d.ts

@@ -2,7 +2,7 @@ import type { AdapterContext, AdapterOutput } from '../seam.js';
 import { structuredToToolUseResult, type ToolKillCause, type ToolResultBody } from '../toolResult.js';
 import { type Frame, type IdOf } from './ids.js';
 import type { EngineRowRef } from '../engineRowRef.js';
-import { type GateOutcomeView } from '../gateOutcome.js';
+import { type GateOutcomeView, type ToolInputRewriteView } from '../gateOutcome.js';
 type RichToolUseResult = NonNullable<ReturnType<typeof structuredToToolUseResult>>;
 export interface ToolResultOutcome {
     readonly body: ToolResultBody;
@@ -38,6 +38,7 @@ export interface ToolResultRowFlagParts {
     readonly _sema_approval_window_expired?: true;
     readonly _sema_denial_limit_window_expired?: true;
     readonly _sema_answered_by?: string;
+    readonly _sema_rewrite?: ToolInputRewriteView;
 }
 export declare function toolResultRowFlagParts(arm: object | null | undefined, gate: GateOutcomeView | undefined): ToolResultRowFlagParts;
 interface ToolEndPayload {

package/dist/adapt/toolCards.js

@@ -6,7 +6,7 @@ import { toolResultBlocksOf } from '../toolResultContent.js';
 import { bashExitOf, bashExitReadingFailed } from '../bashExitReading.js';
 import { isCcToolDenialKind } from '../gateVocabulary.js';
 import { guardedRead, ownSnapshotWhenTyped, readFrameStringKey, readFrameTrueMark, readOwnDataValue } from '../ownKey.js';
-import { gateDeniedBy, isApprovalWindowExpiredGate, isDeniedGate, isDenialLimitAutoDeniedGate } from '../gateOutcome.js';
+import { gateDeniedBy, isApprovalWindowExpiredGate, isDeniedGate, isDenialLimitAutoDeniedGate, toolInputRewriteOf } from '../gateOutcome.js';
 import { TOOL_END_INTERRUPTED_NEVER_STARTED } from '../engineErrorCodes.js';
 function toolUseResultParts(v) {
     return v !== undefined ? { tool_use_result: v } : {};
@@ -58,6 +58,7 @@ export function toolResultRowFlagParts(arm, gate) {
         return {};
     const notExecuted = readFrameTrueMark(arm, 'notExecuted');
     const answeredBy = modAnsweredByOf(arm, notExecuted, gate);
+    const rewrite = toolInputRewriteOf(arm);
     return {
         ...(notExecuted ? { _sema_not_executed: true } : {}),
         ...(readFrameTrueMark(arm, '_sema_collateral_abort') ? { _sema_collateral_abort: true } : {}),
@@ -65,6 +66,7 @@ export function toolResultRowFlagParts(arm, gate) {
         ...(isApprovalWindowExpiredGate(gate) ? { _sema_approval_window_expired: true } : {}),
         ...(isDenialLimitAutoDeniedGate(gate) ? { _sema_denial_limit_window_expired: true } : {}),
         ...(answeredBy !== undefined ? { _sema_answered_by: answeredBy } : {}),
+        ...(rewrite !== undefined ? { _sema_rewrite: rewrite } : {}),
     };
 }
 const MOD_ENGINE_ORIGIN = 'engine';

package/dist/adapter/downstream/eventToSdkMessage.d.ts

@@ -1,7 +1,7 @@
 import type { AgentEvent, CheckpointGate, TaskResult } from '@sema-agent/sdk';
 import { type WiringManifestView } from './wiringManifestView.js';
 import { type SDKMessage, type EmitContext, type ModelUsage } from '../types.js';
-import { type McpLivenessView } from '../../mcpLiveness.js';
+import { type McpAuthorizationView, type McpLivenessView } from '../../mcpLiveness.js';
 import { type ContextUsageSectionRow, type PromptIdentityLayersRow, type PromptManifestIdentityRow, type PromptManifestSectionRow } from '../../ownKey.js';
 export declare const INTERNAL_SDK_ARM_TYPES: ReadonlySet<string>;
 export type EventProjectionNoneReason = 'usage_only' | 'terminal_delegated' | 'hitl_out_of_slice' | 'not_in_slice' | 'empty_payload';
@@ -38,6 +38,8 @@ export interface WiringManifestMcpEntryView {
     httpStatus?: number;
     liveness?: McpLivenessView;
     livenessUnreadable?: true;
+    authorization?: McpAuthorizationView;
+    authorizationUnreadable?: true;
 }
 export declare function projectMcpSection(raw: unknown): WiringManifestMcpEntryView[] | undefined;
 export type SubmitWiringManifestReading = {
@@ -76,6 +78,7 @@ export interface WiringManifestModMountedView {
     readonly name: string;
     readonly seat: string;
     readonly tier: string;
+    readonly provenance?: string;
     readonly events: readonly string[];
     readonly observe?: readonly string[];
     readonly skipped?: readonly WiringManifestModSkipView[];
@@ -84,6 +87,7 @@ export interface WiringManifestModRefusedView {
     readonly name: string;
     readonly seat: string;
     readonly tier: string;
+    readonly provenance?: string;
     readonly refusedBy: string;
     readonly reason: string;
 }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -1,11 +1,11 @@
 import { modRowsOf, readFleetSegment, readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
 import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
-import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js';
+import { ccToolDenialKindForToolEnd, gateOutcomeOf, toolInputRewriteOf } from '../../gateOutcome.js';
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
-import { readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataNonEmptyString } from '../../ownKey.js';
+import { readMcpAuthorization, readMcpLiveness } from '../../mcpLiveness.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -73,6 +73,11 @@ const dropped = (why, type) => ({ kind: 'dropped', why, type });
 function isCompactionStartedFrame(ev) {
     return ev.type === 'compaction_started';
 }
+const BEYOND_FLOOR_ARMS = Object.freeze(['cross_boundary_taint', 'approval_complete', 'session_titled']);
+function isBeyondFloorArm(ev) {
+    const word = ev.type;
+    return typeof word === 'string' && BEYOND_FLOOR_ARMS.includes(word);
+}
 function assertNeverArm(_ev) {
 }
 export function eventToSdkMessage(ev, ctx) {
@@ -106,6 +111,10 @@ function withEngineIdentity(p, ev, ctx, identityFrame = ev) {
 function projectEvent(ev, ctx) {
     if (isCompactionStartedFrame(ev))
         return compactionStartedProjection(ev, ctx);
+    if (isBeyondFloorArm(ev)) {
+        const word = ev.type;
+        return word === 'cross_boundary_taint' ? nothing('not_in_slice') : dropped('unsupported_arm', word);
+    }
     switch (ev.type) {
         case 'task_started':
             return taskStartedProjection(ev, ctx);
@@ -230,6 +239,7 @@ function projectEvent(ev, ctx) {
             const denialKind = ccToolDenialKindForToolEnd(ev);
             const toolEndNotExecuted = readFrameTrueMark(ev, 'notExecuted');
             const toolEndAnsweredBy = readFrameStringKey(ev, 'answeredBy');
+            const toolEndRewrite = toolInputRewriteOf(ev);
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -253,6 +263,7 @@ function projectEvent(ev, ctx) {
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
                 ...(toolEndNotExecuted ? { notExecuted: true } : {}),
                 ...(toolEndAnsweredBy !== undefined ? { answeredBy: toolEndAnsweredBy } : {}),
+                ...(toolEndRewrite !== undefined ? { rewrite: toolEndRewrite } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }
@@ -272,6 +283,11 @@ function projectEvent(ev, ctx) {
             const nonEmptyStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
             const providerCondition = nonEmptyStr(ev.providerCondition);
             const providerConditionSource = nonEmptyStr(ev.providerConditionSource);
+            const stWait = ev;
+            const sleptMsRaw = guardedRead(() => readOwnDataFiniteNumber(stWait, 'sleptMs'));
+            const sleptMs = sleptMsRaw !== undefined && sleptMsRaw >= 0 ? sleptMsRaw : undefined;
+            const waitSegment = readFrameStringKey(stWait, 'waitSegment');
+            const seat = readFrameStringKey(ev, 'seat');
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -287,6 +303,9 @@ function projectEvent(ev, ctx) {
                 ...(timeoutMs !== undefined ? { timeoutMs } : {}),
                 ...(providerCondition !== undefined ? { providerCondition } : {}),
                 ...(providerConditionSource !== undefined ? { providerConditionSource } : {}),
+                ...(sleptMs !== undefined ? { sleptMs } : {}),
+                ...(waitSegment !== undefined ? { waitSegment } : {}),
+                ...(seat !== undefined ? { seat } : {}),
                 ...(typeof ev.eventId === 'string' ? { eventId: ev.eventId } : {}),
                 ...(typeof ev.parentToolCallId === 'string' ? { parentToolCallId: ev.parentToolCallId } : {}),
             })));
@@ -555,6 +574,7 @@ export function projectMcpSection(raw) {
             ...(typeof r.delivered === 'string' && r.delivered.length > 0 ? { delivered: r.delivered } : {}),
             ...(typeof r.httpStatus === 'number' && Number.isFinite(r.httpStatus) ? { httpStatus: r.httpStatus } : {}),
             ...((cell) => cell.kind === 'observation' ? { liveness: cell.liveness } : cell.kind === 'unreadable' ? { livenessUnreadable: true } : {})(readMcpLiveness(r)),
+            ...((cell) => cell.kind === 'record' ? { authorization: cell.authorization } : cell.kind === 'unreadable' ? { authorizationUnreadable: true } : {})(readMcpAuthorization(r)),
         });
     }
     if (raw.length > 0 && rows.length === 0)

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -61,7 +61,6 @@ export interface PermissionDenialParts {
 export interface SemaCostBreakdown {
     readonly llmRootMicroUsd?: number;
     readonly nestedSubagentMicroUsd?: number;
-    readonly memoryConsolidationMicroUsd?: number;
     readonly suggestionsMicroUsd?: number;
     readonly compactionMicroUsd?: number;
     readonly [k: string]: number | undefined;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -564,6 +564,8 @@ function printArmReadingOf(input) {
         const stop_reason = printArmStopReasonOf(lastRow);
         if (kind === 'completed')
             return { arm: Object.freeze({ subtype: 'success', is_error: false, stop_reason }) };
+        if (kind === 'paused')
+            return { arm: Object.freeze({ subtype: 'error_during_execution', is_error: true, stop_reason }) };
         if (kind === 'failed') {
             const code = readOwnDataValue(terminal, 'code');
             const limit = typeof code === 'string' ? resultLimitRowOfCode(code) : undefined;
@@ -644,7 +646,6 @@ function errorResult(ctx, parts) {
         ...('limit' in arm && arm.limit !== undefined ? { _sema_limit: arm.limit } : {}),
         ...(parts.wayOut !== undefined ? { _sema_wayOut: wayOutOnFrame(parts.wayOut) } : {}),
         ...(parts.codedDetail !== undefined ? { _sema_coded_detail: parts.codedDetail } : {}),
-        ...(parts.errorCode !== undefined && parts.errorCode.length > 0 && errorsStateCode(errors[0], parts.errorCode) ? { _sema_error_code_in_text: true } : {}),
     };
     if (arm.subtype === 'success') {
         return stamp(ctx, {
@@ -654,7 +655,6 @@ function errorResult(ctx, parts) {
             subtype: 'success',
             ...head,
             result,
-            errors,
             ...tail,
         });
     }
@@ -666,6 +666,7 @@ function errorResult(ctx, parts) {
         ...head,
         errors,
         ...tail,
+        ...(parts.errorCode !== undefined && parts.errorCode.length > 0 && errorsStateCode(errors[0], parts.errorCode) ? { _sema_error_code_in_text: true } : {}),
     });
 }
 function errorsStateCode(first, code) {

package/dist/adapter/downstream/wiringManifestView.js

@@ -127,6 +127,8 @@ function modRowOf(r) {
         const name = nonEmpty(ownSlot(r, 'name'));
         const seat = nonEmpty(ownSlot(r, 'seat'));
         const tier = nonEmpty(ownSlot(r, 'tier'));
+        const provenance = nonEmpty(ownSlot(r, 'provenance'));
+        const provenancePart = provenance !== undefined ? { provenance } : {};
         if (name === undefined || seat === undefined || tier === undefined)
             return undefined;
         const events = ownSlot(r, 'events');
@@ -143,7 +145,7 @@ function modRowOf(r) {
             const why = nonEmpty(reason);
             if (by === undefined || why === undefined)
                 return undefined;
-            const refused = { name, seat, tier, refusedBy: by, reason: why };
+            const refused = { name, seat, tier, ...provenancePart, refusedBy: by, reason: why };
             return refused;
         }
         const eventList = events.state === 'value' ? ownStringList(events.value) : undefined;
@@ -155,6 +157,7 @@ function modRowOf(r) {
             name,
             seat,
             tier,
+            ...provenancePart,
             events: eventList,
             ...(observeList !== undefined ? { observe: observeList } : {}),
             ...(skipList !== undefined && skipList.length > 0 ? { skipped: skipList } : {}),

package/dist/agentSession/engineAgentRegistryRead.js

@@ -2,6 +2,7 @@ import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { engineCapNestedValue } from '../engineCapsCache.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -75,12 +76,14 @@ function readRow(v) {
         return undefined;
     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;
     return {
         id,
         type,
         status,
         ...(typeof description === 'string' && description.length > 0 ? { description } : {}),
         ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
+        ...(typeof childSessionId === 'string' && childSessionId.length > 0 ? { sessionId: childSessionId } : {}),
     };
 }
 export async function readEngineAgentRegistry(client, sessionId, capsBaseUrl, opts) {

package/dist/cloudConfigWireCaps.js

@@ -1,6 +1,6 @@
 import { mcpAllowToolsVerdict, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, mcpToolFacesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { skillToolListsVerdict, toCappedSpec } from './skillsWireCaps.js';
-import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_REQUEST_MCP_TRANSPORT } from './generated/settingsSchemaFns.js';
+import { SETTINGS_DESCRIBE_BAD_MCP_SERVER_NAME, SETTINGS_IS_USABLE_MCP_SERVER_NAME, SETTINGS_READ_REQUEST_MCP_TRANSPORT } from './generated/settingsSchemaFns.js';
 import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
@@ -66,7 +66,7 @@ export function cloudMcpToSpecs(servers, env) {
             recordDrop(name, 'missing-field');
             continue;
         }
-        if (!SETTINGS_IS_USABLE_WIRE_NAME(name)) {
+        if (!SETTINGS_IS_USABLE_MCP_SERVER_NAME(name)) {
             recordDrop(name, 'name-unusable');
             continue;
         }
@@ -148,10 +148,12 @@ export function cloudMcpToSpecs(servers, env) {
         let axesDeclared;
         let elicitationDeclared;
         let allowDeclared;
+        let startupDeclared;
         try {
             axesDeclared = s.toolAxes;
             elicitationDeclared = s.elicitation;
             allowDeclared = s.allowTools;
+            startupDeclared = s.startupTimeoutMs;
         }
         catch {
             recordDrop(name, 'entry-unreadable');
@@ -199,6 +201,7 @@ export function cloudMcpToSpecs(servers, env) {
             ...(elVerdict.elicitation !== undefined ? { elicitation: elVerdict.elicitation } : {}),
             ...(facesShipped !== undefined ? { toolFaces: facesShipped } : {}),
             ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
+            ...(startupDeclared !== undefined ? { startupTimeoutMs: startupDeclared } : {}),
         });
     }
     return { specs, missingEnv: [...new Set(missingEnv)], droppedServers, degradedServers };
@@ -859,7 +862,7 @@ function droppedMcpNotices(carrier) {
         const label = name === undefined
             ? undefined
             : reason === 'name-unusable'
-                ? SETTINGS_DESCRIBE_BAD_WIRE_NAME(name)
+                ? SETTINGS_DESCRIBE_BAD_MCP_SERVER_NAME(name)
                 : reason === 'transport-invalid' || reason === 'allow-tools-invalid' || reason === 'entry-unreadable'
                     ? `"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${pathLabel}`
                     : `"${name}"${pathLabel}`;

package/dist/coreValuePorts.d.ts

@@ -149,8 +149,9 @@ export interface CoreValuePorts {
     readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
     ANTHROPIC_DEFAULT_BASE_URL: string;
     readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
+    ruleNameCovers: (ruleName: string, toolName: string) => boolean;
 }
-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", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces"];
+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", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -180,3 +181,4 @@ export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'all
 export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;
 export declare function anthropicDefaultBaseUrl(): string | undefined;
 export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;
+export declare function ruleNameCovers(ruleName: string, toolName: string): boolean | undefined;

package/dist/coreValuePorts.js

@@ -19,6 +19,7 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'readMcpToolAxes',
     'ANTHROPIC_DEFAULT_BASE_URL',
     'readToolFaces',
+    'ruleNameCovers',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -118,3 +119,7 @@ export function readToolFaces(declared) {
     const fn = port('readToolFaces');
     return fn === undefined ? undefined : fn(declared);
 }
+export function ruleNameCovers(ruleName, toolName) {
+    const fn = port('ruleNameCovers');
+    return fn === undefined ? undefined : fn(ruleName, toolName);
+}

package/dist/credentialPlaneCapability.d.ts

@@ -0,0 +1,22 @@
+export type SandboxGitCredentialOriginView = {
+    readonly origin: string;
+    readonly delivers: true;
+} | {
+    readonly origin: string;
+    readonly delivers: false;
+    readonly reason: string;
+};
+export type SandboxGitCredentialPlaneReading = {
+    readonly kind: 'unobserved';
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'off';
+    readonly reason: string;
+} | {
+    readonly kind: 'on';
+    readonly origins: readonly SandboxGitCredentialOriginView[];
+};
+export declare function observedSandboxGitCredentialPlane(baseUrl?: string | undefined): SandboxGitCredentialPlaneReading;

package/dist/credentialPlaneCapability.js

@@ -0,0 +1,75 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { ownDataField } from './ownKey.js';
+const UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+const NOT_REPORTED = Object.freeze({ kind: 'not_reported' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+function readOrigin(v) {
+    if (!isRecord(v))
+        return undefined;
+    const origin = ownDataField(v, 'origin');
+    const delivers = ownDataField(v, 'delivers');
+    if (!nonEmpty(origin))
+        return undefined;
+    if (delivers === true)
+        return Object.freeze({ origin, delivers: true });
+    if (delivers !== false)
+        return undefined;
+    const reason = ownDataField(v, 'reason');
+    return nonEmpty(reason) ? Object.freeze({ origin, delivers: false, reason }) : undefined;
+}
+function projectSandboxGit(plane) {
+    try {
+        if (!isRecord(plane))
+            return UNREADABLE;
+        const sg = ownDataField(plane, 'sandboxGit');
+        if (sg === undefined)
+            return NOT_REPORTED;
+        if (!isRecord(sg))
+            return UNREADABLE;
+        const state = ownDataField(sg, 'state');
+        if (state === 'off') {
+            const reason = ownDataField(sg, 'reason');
+            return nonEmpty(reason) ? Object.freeze({ kind: 'off', reason }) : UNREADABLE;
+        }
+        if (state !== 'on')
+            return UNREADABLE;
+        const list = ownDataField(sg, 'origins');
+        if (!Array.isArray(list))
+            return UNREADABLE;
+        const n = ownDataField(list, 'length');
+        if (typeof n !== 'number' || !Number.isInteger(n) || n < 0)
+            return UNREADABLE;
+        const origins = [];
+        for (let i = 0; i < n; i += 1) {
+            const row = readOrigin(ownDataField(list, String(i)));
+            if (row === undefined)
+                return UNREADABLE;
+            origins.push(row);
+        }
+        return Object.freeze({ kind: 'on', origins: Object.freeze(origins) });
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+export function observedSandboxGitCredentialPlane(baseUrl = engineWireTargetBaseUrl()) {
+    try {
+        const slot = engineCapValue(typeof baseUrl === 'string' && baseUrl.length > 0 ? baseUrl : undefined, 'credentialPlane');
+        switch (slot.kind) {
+            case 'unobserved':
+                return UNOBSERVED;
+            case 'not_reported':
+                return NOT_REPORTED;
+            case 'value':
+                return projectSandboxGit(slot.value);
+            default:
+                return UNREADABLE;
+        }
+    }
+    catch {
+        return UNOBSERVED;
+    }
+}

package/dist/deviceExecutorManagementCapability.d.ts

@@ -13,6 +13,7 @@ export type DeviceExecutorManagementReading = {
     protocolVersion?: number;
     maxInflightPerDevice?: number;
     wsPath?: string;
+    relayUrl?: string;
 };
 export declare function projectDeviceExecutorManagementCapability(caps: unknown): DeviceExecutorManagementReading | undefined;
 export declare function observedDeviceExecutorManagement(baseUrl?: string | undefined): DeviceExecutorManagementReading;

package/dist/deviceExecutorManagementCapability.js

@@ -1,6 +1,6 @@
 import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
-import { ownDataField } from './ownKey.js';
+import { guardedRead, ownDataField } from './ownKey.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 export function projectDeviceExecutorManagementCapability(caps) {
     try {
@@ -28,12 +28,14 @@ export function projectDeviceExecutorManagementCapability(caps) {
         const pv = ownDataField(d, 'protocolVersion');
         const mi = ownDataField(d, 'maxInflightPerDevice');
         const ws = ownDataField(d, 'wsPath');
+        const relay = guardedRead(() => ownDataField(d, 'relayUrl'));
         return {
             kind: 'present',
             management,
             ...(typeof pv === 'number' && Number.isFinite(pv) ? { protocolVersion: pv } : {}),
             ...(typeof mi === 'number' && Number.isFinite(mi) && mi >= 0 ? { maxInflightPerDevice: mi } : {}),
             ...(typeof ws === 'string' && ws.length > 0 ? { wsPath: ws } : {}),
+            ...(typeof relay === 'string' && relay.length > 0 ? { relayUrl: relay } : {}),
         };
     }
     catch {

package/dist/deviceRebind.d.ts

@@ -1,6 +1,11 @@
 import type { AgentClient, DeviceEnrollRequest } from '@sema-agent/sdk';
+import { type ExecutionPlacementRole } from './executionPlacementWords.js';
 export type DeviceListVerb = Pick<AgentClient['devices'], 'list'>;
-export type DeviceSessionBindingVerb = Pick<AgentClient['devices'], 'sessionBinding'>;
+export interface SessionExecutionPlacementVerb {
+    executionPlacement(sessionId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<object>;
+}
 export type DeviceRebindVerb = Pick<AgentClient['devices'], 'rebind'>;
 export type DeviceIssueEnrollTokenVerb = Pick<AgentClient['devices'], 'issueEnrollToken'>;
 export type DeviceEnrollVerb = Pick<AgentClient['devices'], 'enroll'>;
@@ -14,7 +19,6 @@ export interface DeviceRosterRow {
 export interface DeviceBindingReading {
     readonly deviceId: string;
     readonly rev: number;
-    readonly boundAt?: string;
 }
 export interface DeviceRefused {
     readonly kind: 'refused';
@@ -37,6 +41,10 @@ export interface DeviceUnreadable {
 export interface DeviceUnarmed {
     readonly kind: 'unarmed';
 }
+export interface DeviceFaceUnsupported {
+    readonly kind: 'unsupported';
+    readonly reason: 'route' | 'capability';
+}
 export type DeviceListOutcome = {
     readonly kind: 'ok';
     readonly devices: readonly DeviceRosterRow[];
@@ -46,9 +54,12 @@ export type DeviceSessionBindingOutcome = {
     readonly kind: 'ok';
     readonly rootSessionId: string;
     readonly boundDevice: DeviceBindingReading;
+} | {
+    readonly kind: 'unbound';
+    readonly role: ExecutionPlacementRole;
 } | {
     readonly kind: 'not-found';
-} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+} | DeviceFaceUnsupported | DeviceUnreadable | DeviceRefused | DeviceTransport | DeviceUnarmed;
 export interface DeviceRebindInput {
     readonly rootSessionId: string;
     readonly toDeviceId: string;
@@ -69,6 +80,8 @@ export type DeviceRebindOutcome = {
 } | {
     readonly kind: 'active-run';
     readonly activeTaskId?: string;
+    readonly children?: readonly string[];
+    readonly retirePath?: string;
 } | {
     readonly kind: 'rev-conflict';
     readonly currentRev?: number;
@@ -79,7 +92,7 @@ export type DeviceRebindReconcileVerdict = 'landed' | 'already-there' | 'unchang
 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?: {
+export declare function readSessionBinding(sessions: SessionExecutionPlacementVerb | null | undefined, rootSessionId: string, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceSessionBindingOutcome>;
 export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {

package/dist/deviceRebind.js

@@ -1,10 +1,14 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
-import { isDisplayableWireCode, readErrorString, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
+import { isDisplayableWireCode, readErrorString, readErrorStrictStringList, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
+import { EXECUTION_PLACEMENT_DEVICE_LANE, EXECUTION_PLACEMENT_ROLES } from './executionPlacementWords.js';
 const LANE_ABSENT = 'capability.device_lane_required';
 const RUN_STORE_ABSENT = 'capability.run_store_required';
 const NOT_FOUND = 'not_found.device';
 const ACTIVE_RUN = 'device.rebind_active_run';
+const SESSION_NOT_FOUND = 'not_found.session';
+const ROUTE_ABSENT = 'not_found.route';
+const SESSION_STORE_ABSENT = 'capability.session_store_required';
 const REV_CONFLICT = 'device.rebind_rev_conflict';
 const SERVICE_TOKEN_REQUIRED = 'auth.service_token_required';
 function own(v, key) {
@@ -123,29 +127,50 @@ function bindingOf(raw) {
     const rev = nonNegInt(own(raw, 'rev'));
     if (deviceId === undefined || rev === undefined)
         return null;
-    const boundAt = nonEmpty(own(raw, 'boundAt'));
-    return { deviceId, rev, ...(boundAt !== undefined ? { boundAt } : {}) };
+    return { deviceId, rev };
 }
-export async function readSessionBinding(devices, rootSessionId, opts) {
-    const verb = verbOf(devices, 'sessionBinding');
+function placementReadFailureOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    if (v.status === 404 && v.code === SESSION_NOT_FOUND)
+        return { kind: 'not-found' };
+    if (v.status === 404 && v.code === ROUTE_ABSENT)
+        return { kind: 'unsupported', reason: 'route' };
+    if (v.status === 501 && v.code === SESSION_STORE_ABSENT)
+        return { kind: 'unsupported', reason: 'capability' };
+    return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
+}
+const isPlacementRole = (v) => typeof v === 'string' && EXECUTION_PLACEMENT_ROLES.includes(v);
+export async function readSessionBinding(sessions, rootSessionId, opts) {
+    if (typeof rootSessionId !== 'string' || rootSessionId === '') {
+        return { kind: 'refused', status: 0, errorCode: 'request.id_invalid', message: 'the session id to read the execution placement of must be a non-empty string — nothing was sent' };
+    }
+    const verb = verbOf(sessions, 'executionPlacement');
     if (verb === undefined)
         return { kind: 'unarmed' };
     let body;
     try {
-        body = await verb.call(devices, rootSessionId, signalOpts(opts));
+        body = await verb.call(sessions, rootSessionId, signalOpts(opts));
     }
     catch (e) {
-        return readFailureOf(e);
+        return placementReadFailureOf(e);
+    }
+    const role = own(body, 'role');
+    if (!isPlacementRole(role)) {
+        return { kind: 'unreadable', why: 'the execution placement it returned names no role this client knows (absent / writer / mirror / forking) — refusing to read it as "not bound"' };
     }
-    const rid = own(body, 'rootSessionId');
-    if (typeof rid !== 'string' || rid !== rootSessionId) {
-        return { kind: 'unreadable', why: "the binding it returned does not echo the session id that was asked for — refusing to use another session's binding as this one's prior state" };
+    if (role !== 'writer')
+        return { kind: 'unbound', role };
+    const lane = own(body, 'lane');
+    if (typeof lane !== 'string' || lane === '') {
+        return { kind: 'unreadable', why: "the writer's execution lane in the execution placement is missing or not a word — refusing to guess whether a device is bound" };
     }
-    const bound = bindingOf(own(body, 'boundDevice'));
+    if (lane !== EXECUTION_PLACEMENT_DEVICE_LANE)
+        return { kind: 'unbound', role };
+    const bound = bindingOf(own(body, 'device'));
     if (bound === null) {
-        return { kind: 'unreadable', why: 'the binding it returned has no usable prior state (deviceId + rev) — refusing to treat it as a binding' };
+        return { kind: 'unreadable', why: 'the session is written on the device lane but the execution placement names no readable device (deviceId + rev) — the device is unknown, not unbound' };
     }
-    return { kind: 'ok', rootSessionId: rid, boundDevice: bound };
+    return { kind: 'ok', rootSessionId, boundDevice: bound };
 }
 function rebindFailureOf(e) {
     const v = atMostOnceVerdictOf(e);
@@ -155,7 +180,11 @@ function rebindFailureOf(e) {
         return common;
     if (status === 409 && code === ACTIVE_RUN) {
         const activeTaskId = nonEmpty(own(e, 'activeTaskId'));
-        return { kind: 'active-run', ...(activeTaskId !== undefined ? { activeTaskId } : {}) };
+        if (activeTaskId !== undefined)
+            return { kind: 'active-run', activeTaskId };
+        const children = e !== null && typeof e === 'object' ? readErrorStrictStringList(e, 'children') : undefined;
+        const retirePath = e !== null && typeof e === 'object' ? nonEmpty(readErrorString(e, 'retirePath')) : undefined;
+        return { kind: 'active-run', ...(children !== undefined && retirePath !== undefined ? { children: Object.freeze([...children]), retirePath } : {}) };
     }
     if (status === 409 && code === REV_CONFLICT) {
         const currentRev = nonNegInt(own(e, 'currentRev'));

package/dist/engineAgentAbsence.d.ts

@@ -55,6 +55,7 @@ export interface EngineAgentRegistryRowView {
     readonly status: string;
     readonly description?: string;
     readonly createdAt?: number;
+    readonly sessionId?: string;
 }
 export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'capability_unknown' | 'route_absent' | 'ownership_required' | 'read_failed';
 export type EngineAgentRegistryListing = {

package/dist/engineErrorCodes.d.ts

@@ -59,6 +59,7 @@ export declare function activeRunBusyCarrierOf(ev: unknown): Record<string, unkn
 export declare const CORRUPT_SESSION_ERROR_CODE = "corrupt_session";
 export declare const CORRUPT_ROW_ERROR_CODE = "corrupt";
 export declare const MEMORY_CONTROL_PLANE_CORRUPT = "internal.memory_control_plane_corrupt";
+export declare const RESUME_CONSTRAINT_REJECTED = "resume.constraint_rejected";
 export declare function isCorruptSessionCode(code: string | null | undefined): boolean;
 export declare const STOP_PARK_ARBITER_UNREACHABLE = "stop.park_arbiter_unreachable";
 export declare const STOP_PARK_RESUME_WON = "stop.park_resume_won";