@sema-agent/client-core 0.103.0 → 0.104.1

package/dist/index.d.ts

@@ -361,13 +361,16 @@ export { BACKGROUND_HANDOFF_ABORT_REASON, handoffInteractiveRun, handedOffRunsOf
 export type { BackgroundHandoffRequest, BackgroundHandoffOutcome, BackgroundRun, BackgroundRunSettlement, HandedOffRunRow, HandedOffRunsReading, } from './sessionBackgroundHandoff.js';
 export { listDevices, readSessionBinding, rebindSession, reconcileRebindOutcome, rebindProvesRequestNotApplied } from './deviceRebind.js';
 export { issueEnrollToken, enrollDevice, revokeDevice, deviceIdentityMismatchOf, deviceIdentityMismatchLine, deviceRegistrationOutcomeLine } from './deviceRebind.js';
-export type { DeviceSummary, DeviceListResult, DeviceBinding, DeviceSessionBinding, DeviceRebindRequest, DeviceRevokeRequest, DeviceRebindResult, DeviceEnrollToken, DeviceEnrollRequest, DeviceEnrollResult, DeviceRevokeResult, } from '@sema-agent/sdk';
-export type { DeviceListVerb, DeviceSessionBindingVerb, DeviceRebindVerb, DeviceRosterRow, DeviceBindingReading, DeviceRefused, DeviceLaneAbsent, DeviceTransport, DeviceUnreadable, DeviceUnarmed, DeviceListOutcome, DeviceSessionBindingOutcome, DeviceRebindInput, DeviceRebindUnconfirmed, DeviceRebindOutcome, DeviceRebindReconcileVerdict, DeviceIssueEnrollTokenVerb, DeviceEnrollVerb, DeviceRevokeVerb, DeviceEnrollOptions, DeviceRateLimited, DeviceEnrollTokenOutcome, DeviceEnrollOutcome, DeviceRevokeOutcome, DeviceRegistrationVerb, DeviceIdentityMismatch, } from './deviceRebind.js';
+export type { DeviceSummary, DeviceListResult, DeviceRebindRequest, DeviceRevokeRequest, DeviceRebindResult, DeviceEnrollToken, DeviceEnrollRequest, DeviceEnrollResult, DeviceRevokeResult, } from '@sema-agent/sdk';
+export type { ExecutionPlacementRole } from './executionPlacementWords.js';
+export type { DeviceListVerb, SessionExecutionPlacementVerb, DeviceFaceUnsupported, DeviceRebindVerb, DeviceRosterRow, DeviceBindingReading, DeviceRefused, DeviceLaneAbsent, DeviceTransport, DeviceUnreadable, DeviceUnarmed, DeviceListOutcome, DeviceSessionBindingOutcome, DeviceRebindInput, DeviceRebindUnconfirmed, DeviceRebindOutcome, DeviceRebindReconcileVerdict, DeviceIssueEnrollTokenVerb, DeviceEnrollVerb, DeviceRevokeVerb, DeviceEnrollOptions, DeviceRateLimited, DeviceEnrollTokenOutcome, DeviceEnrollOutcome, DeviceRevokeOutcome, DeviceRegistrationVerb, DeviceIdentityMismatch, } from './deviceRebind.js';
 export { resolveEngineEnvSourcing, engineEnvView } from './engineEnvSourcing.js';
 export type { EngineEnvView, EngineEnvGroupDecl, EngineEnvSourcingInput, EngineEnvTouchedKey, EngineEnvGroupReading, EngineEnvKeyReason, EngineEnvSourcingVerdict, } from './engineEnvSourcing.js';
 export * from './compensations.js';
 export * from './request/printNotification.js';
 export * from './seatContract.js';
+export { sessionRowTagOf, sessionRowPatchRefusalOf } from './sessionRowTag.js';
+export type { SessionRowCurrentReading, SessionRowPatchRefusal } from './sessionRowTag.js';
 export { mcpToolTogglesToExcludeTools } from './mcpToolToggles.js';
 export type { McpToolToggleKey, McpMountedServers } from './mcpToolToggles.js';
 export { readThinkingLatch, writeThinkingLatch, thinkingLatchView, thinkingLatchSentence, thinkingLatchRowWordOf, readSeatThinkingLatch } from './thinkingLatch.js';

package/dist/index.js

@@ -299,6 +299,7 @@ export { resolveEngineEnvSourcing, engineEnvView } from './engineEnvSourcing.js'
 export * from './compensations.js';
 export * from './request/printNotification.js';
 export * from './seatContract.js';
+export { sessionRowTagOf, sessionRowPatchRefusalOf } from './sessionRowTag.js';
 export { mcpToolTogglesToExcludeTools } from './mcpToolToggles.js';
 export { readThinkingLatch, writeThinkingLatch, thinkingLatchView, thinkingLatchSentence, thinkingLatchRowWordOf, readSeatThinkingLatch } from './thinkingLatch.js';
 export { devicesFaceOf, devicesWritesAllowed, devicesFaceDetail } from './devicesFace.js';

package/dist/jsonFaithful.js

@@ -19,14 +19,16 @@ export const isPlainRecord = (v) => {
         return true;
     if (typeof proto !== 'object')
         return false;
-    if (!Object.prototype.hasOwnProperty.call(proto, 'constructor'))
+    const ctorDesc = Object.getOwnPropertyDescriptor(proto, 'constructor');
+    if (ctorDesc === undefined || !Object.hasOwn(ctorDesc, 'value'))
         return false;
-    const ctor = proto.constructor;
+    const ctor = ctorDesc.value;
     if (typeof ctor !== 'function')
         return false;
     if (Function.prototype.toString.call(ctor) !== Function.prototype.toString.call(Object))
         return false;
-    return ctor.prototype === proto;
+    const protoDesc = Object.getOwnPropertyDescriptor(ctor, 'prototype');
+    return protoDesc !== undefined && Object.hasOwn(protoDesc, 'value') && protoDesc.value === proto;
 };
 export const materializeJsonFaithful = (v, path, seen = new Set(), opts = {}) => {
     const guard = opts.guard;

package/dist/mcpLiveness.d.ts

@@ -29,7 +29,7 @@ export interface McpEngineLegHealth {
 }
 export declare function mcpLivenessRollupOf(rows: readonly McpLivenessBearingRow[] | undefined): McpEngineLegHealth;
 export declare function mcpEngineLegHealthDetail(health: McpEngineLegHealth | undefined): string;
-export declare const MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "unknown"];
+export declare const MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "unknown"];
 export declare const MCP_AUTHORIZATION_REASONS: readonly ["rejected", "scope", "none"];
 export declare const MCP_FAILURE_UNAUTHORIZED: Extract<(typeof CORE_MCP_FAILURE_KINDS)[number], 'unauthorized'>;
 export interface McpAuthorizationView {

package/dist/mcpWireCaps.js

@@ -437,6 +437,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.134.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.139.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/printModelStatus.d.ts

@@ -20,6 +20,7 @@ export interface PrintModelStatusPayload {
     readonly elapsed_ms?: number;
     readonly timeout_ms?: number;
     readonly model?: string;
+    readonly seat?: string;
     readonly phase: RetryStatusNotice['phase'];
     readonly recourse?: NonNullable<RetryStatusNotice['recourse']>;
     readonly message: string;

package/dist/printModelStatus.js

@@ -41,6 +41,7 @@ function modelStatusPayload(status, ctx) {
         ...(elapsed !== undefined ? { elapsed_ms: elapsed } : {}),
         ...(ceiling !== undefined ? { timeout_ms: ceiling } : {}),
         ...(model !== undefined ? { model } : {}),
+        ...(typeof status.seat === 'string' ? { seat: status.seat } : {}),
         phase: notice.phase,
         ...(notice.recourse !== undefined ? { recourse: notice.recourse } : {}),
         message: notice.line,
@@ -49,6 +50,8 @@ function modelStatusPayload(status, ctx) {
 function apiRetryKeyOf(status) {
     const terminal = 'terminal' in status && status.terminal === true;
     const ok = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+    if (status.seat !== undefined)
+        return null;
     if (status.kind === 'waiting' || terminal || !ok(status.attempt) || !ok(status.maxRetries))
         return null;
     return `${String(status.attempt)}/${String(status.maxRetries)}/${String(status.errClass ?? '')}/${String(status.errorStatus ?? '')}`;
@@ -126,12 +129,13 @@ export function createPrintModelStatusTracker() {
                     clear();
                     return null;
                 }
-                const model = readOwnDataNonEmptyString(ctx, 'model');
+                const model = status.seat === undefined ? readOwnDataNonEmptyString(ctx, 'model') : undefined;
                 const key = apiRetryKeyOf(status);
                 const refresh = key !== null && key === lastApiRetryKey;
                 const safeCtx = { sessionId, nowMs, mintUuid, ...(model !== undefined ? { model } : {}) };
                 const frame = statusFrameOf(status, safeCtx, mintUuid(), refresh);
-                lastApiRetryKey = key;
+                if (status.seat === undefined)
+                    lastApiRetryKey = key;
                 last = { status, model };
                 return frame;
             }

package/dist/retryStatus.d.ts

@@ -13,6 +13,7 @@ export type RetryStatus = {
     timeoutMs?: number;
     sleptMs?: number;
     waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
     detail?: string;
 } | {
     kind: 'error';
@@ -30,6 +31,7 @@ export type RetryStatus = {
     timeoutMs?: number;
     sleptMs?: number;
     waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
 } | {
     kind: 'waiting';
     deadline: number;
@@ -44,6 +46,7 @@ export type RetryStatus = {
     timeoutMs?: number;
     sleptMs?: number;
     waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
     terminal?: never;
     error: RetryStatusErrorPayload;
 };
@@ -77,10 +80,13 @@ export interface BrainStatusPayload {
     providerConditionSource?: string;
     sleptMs?: number;
     waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
 }
 export declare const BRAIN_STATUS_WAIT_SEGMENTS: readonly ["response_headers", "first_token"];
 export type BrainStatusWaitSegment = (typeof BRAIN_STATUS_WAIT_SEGMENTS)[number];
-export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource", "sleptMs", "waitSegment"];
+export declare const BRAIN_STATUS_SEATS: readonly ["classifier"];
+type BrainStatusSeat = (typeof BRAIN_STATUS_SEATS)[number];
+export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource", "sleptMs", "waitSegment", "seat"];
 export declare function mapBrainStatusToRetry(p: BrainStatusPayload, nowMs: number): RetryStatus | null;
 export interface RetryStatusArmLike {
     readonly phase?: string;
@@ -98,6 +104,7 @@ export interface RetryStatusArmLike {
     readonly providerConditionSource?: string;
     readonly sleptMs?: number;
     readonly waitSegment?: string;
+    readonly seat?: string;
     readonly parentToolCallId?: string;
 }
 export declare function retryStatusFromArm(arm: RetryStatusArmLike | null | undefined, nowMs: number): RetryStatus | null | undefined;

package/dist/retryStatus.js

@@ -14,6 +14,9 @@ export const BRAIN_STATUS_PHASES = [
 export const BRAIN_STATUS_WAIT_SEGMENTS = Object.freeze(['response_headers', 'first_token']);
 void true;
 void true;
+export const BRAIN_STATUS_SEATS = Object.freeze(['classifier']);
+void true;
+void true;
 export const BRAIN_STATUS_PAYLOAD_KEYS = [
     'phase',
     'detail',
@@ -30,6 +33,7 @@ export const BRAIN_STATUS_PAYLOAD_KEYS = [
     'providerConditionSource',
     'sleptMs',
     'waitSegment',
+    'seat',
 ];
 const _brainStatusKeyPin = [true, true];
 void _brainStatusKeyPin;
@@ -61,9 +65,11 @@ export function mapBrainStatusToRetry(p, nowMs) {
     };
     const sleptMs = saneMs(p.sleptMs);
     const waitSegment = p.waitSegment;
+    const seat = p.seat;
     const waitFacts = {
         ...(sleptMs !== undefined ? { sleptMs } : {}),
         ...(typeof waitSegment === 'string' && waitSegment.length > 0 ? { waitSegment } : {}),
+        ...(typeof seat === 'string' && seat.length > 0 ? { seat } : {}),
     };
     const stalledShown = typeof p.detail === 'string' && p.detail.length > 0 ? displayUntrusted(p.detail) : '';
     const stalledDetail = stalledShown.length > 0 ? { detail: stalledShown } : {};
@@ -112,8 +118,8 @@ export function retryStatusFromArm(arm, nowMs) {
         const v = str(key);
         return v !== undefined && v.length > 0 ? v : undefined;
     };
-    const [detail, retryInSec, retryInMs, attempt, maxRetries, errClass, retryAtMs, errorStatus, elapsedMs, timeoutMs, providerCondition, providerConditionSource, sleptMs, waitSegment] = [
-        str('detail'), num('retryInSec'), num('retryInMs'), num('attempt'), num('maxRetries'), str('errClass'), num('retryAtMs'), num('errorStatus'), num('elapsedMs'), num('timeoutMs'), word('providerCondition'), word('providerConditionSource'), num('sleptMs'), word('waitSegment'),
+    const [detail, retryInSec, retryInMs, attempt, maxRetries, errClass, retryAtMs, errorStatus, elapsedMs, timeoutMs, providerCondition, providerConditionSource, sleptMs, waitSegment, seat] = [
+        str('detail'), num('retryInSec'), num('retryInMs'), num('attempt'), num('maxRetries'), str('errClass'), num('retryAtMs'), num('errorStatus'), num('elapsedMs'), num('timeoutMs'), word('providerCondition'), word('providerConditionSource'), num('sleptMs'), word('waitSegment'), word('seat'),
     ];
     const phase = str('phase');
     if (phase === undefined)
@@ -134,6 +140,7 @@ export function retryStatusFromArm(arm, nowMs) {
         ...(providerConditionSource !== undefined ? { providerConditionSource } : {}),
         ...(sleptMs !== undefined ? { sleptMs } : {}),
         ...(waitSegment !== undefined ? { waitSegment } : {}),
+        ...(seat !== undefined ? { seat } : {}),
     }, nowMs);
 }
 const WAIT_SWITCH_FRACTION = 0.5;
@@ -218,7 +225,8 @@ function sealParts(p) {
 }
 export function retryStatusParts(status, ctx) {
     const modelName = washedText(noticeText(ctx, 'modelName'))?.trim();
-    const model = modelName === undefined || modelName === '' ? undefined : modelName;
+    const otherSeat = status !== null && noticeText(status, 'seat') !== undefined;
+    const model = otherSeat || modelName === undefined || modelName === '' ? undefined : modelName;
     if (status === null)
         return sealParts({ phase: 'cleared' });
     const armWord = noticeText(status, 'kind');
@@ -243,7 +251,7 @@ export function retryStatusParts(status, ctx) {
     const condition = reading === undefined ? undefined : `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}`;
     const serviceSide = http !== undefined && isServiceSideStatus(http);
     const knownArm = armWord === 'stalled' || armWord === 'error';
-    const recourse = !knownArm
+    const recourseOfArm = !knownArm
         ? undefined
         : reading !== undefined
             ? conditionRecourseOf(conditionWord)
@@ -252,6 +260,7 @@ export function retryStatusParts(status, ctx) {
                 : !terminal
                     ? 'wait'
                     : undefined;
+    const recourse = otherSeat && recourseOfArm === 'switch_model' ? (terminal ? undefined : 'wait') : recourseOfArm;
     const deadlineRaw = knownArm && !terminal && noticeNumber(status, 'retryAtMs') !== undefined ? noticeNumber(status, 'deadline') : undefined;
     const retryAtMs = deadlineRaw !== undefined && deadlineRaw > 0 ? deadlineRaw : undefined;
     return sealParts({

package/dist/ruleCompileVerdict.d.ts

@@ -17,6 +17,7 @@ export declare function ruleCompileVerdictUnder(rule: string, behavior: 'deny' |
 export type DenyEntryInertReason = 'grammar' | 'content_unsupported' | 'wildcard_all' | 'namespace_wildcard';
 export type DenyEntryReading = {
     readonly kind: 'row';
+    readonly covering?: true;
 } | {
     readonly kind: 'inert';
     readonly reason: DenyEntryInertReason;

package/dist/ruleCompileVerdict.js

@@ -58,7 +58,9 @@ export function denyEntryReading(rule) {
         const kind = readOwnDataValue(reading, 'kind');
         if (kind === 'row') {
             const compiled = readOwnDataValue(reading, 'compiled');
-            return typeof compiled === 'object' && compiled !== null ? { kind: 'row' } : { kind: 'unknown' };
+            if (typeof compiled !== 'object' || compiled === null)
+                return { kind: 'unknown' };
+            return readOwnDataValue(compiled, 'kind') === 'covering' ? { kind: 'row', covering: true } : { kind: 'row' };
         }
         if (kind !== 'inert')
             return { kind: 'unknown' };

package/dist/seatContract.d.ts

@@ -14,6 +14,7 @@ import type { DeviceEnrollTokenOutcome, DeviceListOutcome, DeviceRebindOutcome,
 import type { McpPanelView } from "./mcpPanel.js";
 import type { McpToolToggleKey } from "./mcpToolToggles.js";
 import { type ThinkingLatchEvent, type ThinkingLatchRowWord } from "./thinkingLatchWords.js";
+import type { SessionRowPatchFields } from "./sessionRowTag.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -48,6 +49,7 @@ export interface LocalSessionRecord {
     }>;
     parked?: boolean;
     pinned?: boolean;
+    rowTag?: string;
     thinkingLatch?: ThinkingLatchRowWord;
 }
 export declare const TOOL_PERMISSION_REQUEST_ID_DOMAINS: readonly ["live:", "durable:", "question:", "elicit:", "plan:"];
@@ -301,12 +303,10 @@ export declare const ATTACHMENT_UPLOAD_REQUEST_KEYS: readonly ["name", "mimeType
 export interface SessionScopedRequest {
     sessionId: string;
 }
-export interface SessionRowPatchRequest {
+export interface SessionRowPatchRequest extends SessionRowPatchFields {
     sessionId: string;
-    title?: string | null;
-    pinned?: boolean;
 }
-export declare const SESSION_ROW_PATCH_REQUEST_KEYS: readonly ["sessionId", "title", "pinned"];
+export declare const SESSION_ROW_PATCH_REQUEST_KEYS: readonly ["sessionId", "title", "pinned", "expectedRowTag"];
 export interface SetThinkingLatchRequest {
     readonly sessionId: string;
     readonly event: ThinkingLatchEvent;
@@ -688,7 +688,7 @@ export declare const SEAT_STORE_PROPS: readonly ["sessionsStateStore", "focusedS
 export declare const SEAT_EVENT_METHOD_NAMES: readonly ["onEvent", "onToolPermissionRequest"];
 export declare const LOCAL_SESSION_EVENT_KEYS: readonly ["type", "sessionId", "message", "error", "errorCategory", "code", "session", "userMessageUuid", "requestId", "outcome", "parked", "chrome", "_sema_turnFailure", "subagentContent"];
 export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation", "mandated", "mandate", "origin", "ruleOffersAbsence", "askClass", "classes", "sessionRow"];
-export declare const LOCAL_SESSION_RECORD_KEYS: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "thinkingLatch"];
+export declare const LOCAL_SESSION_RECORD_KEYS: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "thinkingLatch"];
 export declare const SEND_MESSAGE_REQUEST_KEYS: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario", "rewind"];
 export declare const SEAT_SEND_MESSAGE_KEY_ORIGINS: {
     readonly sessionId: {
@@ -738,7 +738,7 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
     readonly LocalSessionRecord: {
         readonly guard: "isLocalSessionRecord";
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "thinkingLatch"];
+        readonly validated: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "thinkingLatch"];
         readonly unchecked: readonly [];
     };
     readonly ToolPermissionRequest: {
@@ -815,7 +815,7 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
     readonly SessionRowPatchRequest: {
         readonly guard: "isSessionRowPatchRequest";
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["sessionId", "title", "pinned"];
+        readonly validated: readonly ["sessionId", "title", "pinned", "expectedRowTag"];
         readonly unchecked: readonly [];
     };
     readonly SetThinkingLatchRequest: {

package/dist/seatContract.js

@@ -6,6 +6,7 @@ import { PROBE_VERDICTS } from "./modelCapabilityProbe.js";
 import { guardedRead, ownDataField, ownDataRefusalKeyOf, ownSendableField, readOwnDataValue } from "./ownKey.js";
 import { MCP_LIVENESS_STATES } from "./mcpLiveness.js";
 import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatchWords.js";
+import { EXECUTION_PLACEMENT_ROLES } from "./executionPlacementWords.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -122,7 +123,22 @@ function shapeVerdict(spec, v, path, disc) {
     return true;
 }
 const shapeRule = (label, spec) => ({ label, test: (v, path) => shapeVerdict(spec, v, path) });
-const armsRule = (label, disc, arms) => ({
+function keyGroupsVerdict(groups, v, path) {
+    let seen;
+    for (const g of groups) {
+        const present = g.filter((k) => !isAbsent(own(v, k)));
+        if (present.length === 0)
+            continue;
+        const missing = g.find((k) => !present.includes(k));
+        if (missing !== undefined)
+            return bad("missing key", pathAt(path, missing));
+        if (seen !== undefined)
+            return bad(`bad value (${seen.join("+")} | ${g.join("+")})`, pathAt(path, g[0]));
+        seen = g;
+    }
+    return true;
+}
+const armsRule = (label, disc, arms, groups = {}) => ({
     label,
     test: (v, path) => {
         if (!isPlainRecord(v))
@@ -130,7 +146,10 @@ const armsRule = (label, disc, arms) => ({
         const d = own(v, disc);
         if (typeof d !== "string" || !Object.hasOwn(arms, d))
             return bad("unknown arm", pathAt(path, disc));
-        return shapeVerdict(arms[d], v, path, disc);
+        const verdict = shapeVerdict(arms[d], v, path, disc);
+        if (verdict !== true || !Object.hasOwn(groups, d))
+            return verdict;
+        return keyGroupsVerdict(groups[d], v, path);
     },
 });
 const isArraySlotKey = (k, n) => k === "length" || (/^(0|[1-9][0-9]*)$/.test(k) && Number(k) < n);
@@ -559,7 +578,7 @@ export const SEAT_TURN_SETTINGS_ORIGINS = Object.freeze({
 });
 export const SEAT_REWIND_INTENT_KEYS = ["mode", "targetMessageUuid"];
 export const ATTACHMENT_UPLOAD_REQUEST_KEYS = ["name", "mimeType", "bytes"];
-export const SESSION_ROW_PATCH_REQUEST_KEYS = Object.freeze(["sessionId", "title", "pinned"]);
+export const SESSION_ROW_PATCH_REQUEST_KEYS = Object.freeze(["sessionId", "title", "pinned", "expectedRowTag"]);
 const SET_THINKING_LATCH_REQUEST_KEYS = Object.freeze(["sessionId", "event"]);
 export const SESSION_SEARCH_RESULT_KEYS = ["sessionId", "title", "matches"];
 export const GET_TRANSCRIPT_RESULT_KEYS = ["sessionId", "messages"];
@@ -582,7 +601,6 @@ const DEVICE_ROSTER_ROW = shapeRule("device row", {
 const DEVICE_BINDING = shapeRule("device binding", {
     deviceId: reqF(R_NONEMPTY),
     rev: reqF(R_INT0),
-    boundAt: optF(R_STR),
 });
 const checkDeviceListOutcome = seatShapeCheck(armsRule("listDevices outcome", "kind", {
     ok: { devices: reqF(arrayRule(DEVICE_ROSTER_ROW)), dropped: reqF(R_INT0) },
@@ -594,23 +612,24 @@ const checkDeviceListOutcome = seatShapeCheck(armsRule("listDevices outcome", "k
 }));
 const checkDeviceSessionBindingOutcome = seatShapeCheck(armsRule("readSessionBinding outcome", "kind", {
     ok: { rootSessionId: reqF(R_NONEMPTY), boundDevice: reqF(DEVICE_BINDING) },
+    unbound: { role: reqF(oneOfRule("placement role", EXECUTION_PLACEMENT_ROLES)) },
     "not-found": {},
+    unsupported: { reason: reqF(oneOfRule("unsupported reason", ["route", "capability"])) },
     unreadable: DEVICE_UNREADABLE_SPEC,
-    "lane-absent": DEVICE_LANE_ABSENT_SPEC,
     refused: DEVICE_REFUSED_SPEC,
     transport: DEVICE_TRANSPORT_SPEC,
     unarmed: {},
 }));
 const checkDeviceRebindOutcome = seatShapeCheck(armsRule("rebindSession outcome", "kind", {
     ok: { deviceId: reqF(R_NONEMPTY), rev: reqF(R_INT0), workspaceCarryover: optF(oneOfRule("carryover", ["none"])) },
-    "active-run": { activeTaskId: optF(R_STR) },
+    "active-run": { activeTaskId: optF(R_STR), children: optF(arrayRule(R_STR)), retirePath: optF(R_NONEMPTY) },
     "rev-conflict": { currentRev: optF(R_INT0) },
     "not-found": {},
     unconfirmed: DEVICE_UNCONFIRMED_SPEC,
     "lane-absent": DEVICE_LANE_ABSENT_SPEC,
     refused: DEVICE_REFUSED_SPEC,
     unarmed: {},
-}));
+}, { "active-run": [["activeTaskId"], ["children", "retirePath"]] }));
 const ENROLL_TOKEN_ALLOW = new Set(["token"]);
 const checkDeviceEnrollTokenOutcome = seatShapeCheck(armsRule("issueEnrollToken outcome", "kind", {
     ok: { token: reqF(R_NONEMPTY), expiresAt: optF(R_STR), ttlSec: optF(R_INT1) },
@@ -983,6 +1002,10 @@ const checkLocalSessionRecord = seatCheck((s) => {
     if (!isAbsent(pinned) && typeof pinned !== "boolean") {
         return bad("pinned must be a boolean when present (absent = not pinned or unknown)", "pinned");
     }
+    const rowTag = own(s, "rowTag");
+    if (!isAbsent(rowTag) && (typeof rowTag !== "string" || rowTag.length === 0)) {
+        return bad("rowTag must be a non-empty string when present (absent = this row cannot be written conditionally)", "rowTag");
+    }
     const latch = own(s, "thinkingLatch");
     if (!isAbsent(latch)) {
         const verdict = R_THINKING_LATCH_ROW.test(latch, "thinkingLatch");
@@ -1079,6 +1102,7 @@ const RETRY_COMMON_SPEC = {
     timeoutMs: optF(R_NUM),
     sleptMs: optF(R_NUM0),
     waitSegment: optF(R_NONEMPTY),
+    seat: optF(R_NONEMPTY),
 };
 const RETRY_STATUS = armsRule("retry status", "kind", {
     stalled: { ...RETRY_COMMON_SPEC, detail: optF(R_STR) },
@@ -1451,8 +1475,12 @@ export const checkSessionRowPatchRequest = seatCheck((v) => {
     }
     if (!isAbsent(pinned) && typeof pinned !== "boolean")
         return bad("pinned must be a boolean when present", "pinned");
+    const expectedRowTag = body.expectedRowTag;
+    if (!isAbsent(expectedRowTag) && (typeof expectedRowTag !== "string" || expectedRowTag.length === 0)) {
+        return bad("expectedRowTag must be the non-empty rowTag read from the same session row when present", "expectedRowTag");
+    }
     if (isAbsent(title) && isAbsent(pinned))
-        return bad("nothing to change: carry at least one of title / pinned");
+        return bad("nothing to change: carry at least one of title / pinned (expectedRowTag is a precondition, not a change)");
     return true;
 });
 export function isSessionRowPatchRequest(v) {
@@ -1744,6 +1772,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "queuedMessages",
     "parked",
     "pinned",
+    "rowTag",
     "thinkingLatch",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
@@ -1789,7 +1818,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     LocalSessionRecord: {
         guard: "isLocalSessionRecord",
         check: checkLocalSessionRecord,
-        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "thinkingLatch"],
+        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "thinkingLatch"],
         unchecked: [],
     },
     ToolPermissionRequest: {
@@ -1910,7 +1939,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     SessionRowPatchRequest: {
         guard: "isSessionRowPatchRequest",
         check: checkSessionRowPatchRequest,
-        validated: ["sessionId", "title", "pinned"],
+        validated: ["sessionId", "title", "pinned", "expectedRowTag"],
         unchecked: [],
     },
     SetThinkingLatchRequest: {

package/dist/sessionRowTag.d.ts

@@ -0,0 +1,24 @@
+export interface SessionRowPatchFields {
+    title?: string | null;
+    pinned?: boolean;
+    expectedRowTag?: string;
+}
+export interface SessionRowCurrentReading {
+    readonly rowTag?: string;
+    readonly title?: string;
+    readonly pinned?: boolean;
+}
+export type SessionRowPatchRefusal = {
+    readonly kind: 'already-applied';
+    readonly current: SessionRowCurrentReading;
+} | {
+    readonly kind: 'row-changed';
+    readonly current?: SessionRowCurrentReading;
+} | {
+    readonly kind: 'mirror';
+    readonly forkPath?: string;
+} | {
+    readonly kind: 'tag-unsupported';
+};
+export declare function sessionRowTagOf(row: object | null | undefined): string | undefined;
+export declare function sessionRowPatchRefusalOf(error: {} | null | undefined, sent: Readonly<SessionRowPatchFields> | null | undefined): SessionRowPatchRefusal | null;

package/dist/sessionRowTag.js

@@ -0,0 +1,77 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { isSlotCarrier, readErrorRecord, readErrorString, readThrownSlot, slotReadOf } from './wireFailureShape.js';
+const ROW_CHANGED = 'conflict.session_row_changed';
+const SESSION_MIRROR = 'conflict.session_mirror';
+const BODY_SHAPE = 'request.body_shape';
+function ownData(v, key) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    return guardedRead(() => readOwnDataValue(v, key));
+}
+export function sessionRowTagOf(row) {
+    const v = ownData(row, 'rowTag');
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function currentRowOf(e) {
+    const row = guardedRead(() => readErrorRecord(e, 'currentRow'));
+    if (row === undefined)
+        return undefined;
+    const rowTag = sessionRowTagOf(row);
+    const title = ownData(row, 'title');
+    const pinned = ownData(row, 'pinned');
+    return Object.freeze({
+        ...(rowTag !== undefined ? { rowTag } : {}),
+        ...(typeof title === 'string' ? { title } : {}),
+        ...(typeof pinned === 'boolean' ? { pinned } : {}),
+    });
+}
+function pendingSlotOf(sent, key) {
+    if (sent === null || typeof sent !== 'object')
+        return { state: 'absent' };
+    const read = slotReadOf(sent, key);
+    if (read.presence === 'absent')
+        return { state: 'absent' };
+    if (read.presence !== 'present')
+        return { state: 'unreadable' };
+    return read.value === undefined ? { state: 'absent' } : { state: 'value', value: read.value };
+}
+function alreadyApplied(sent, current) {
+    const title = pendingSlotOf(sent, 'title');
+    const pinned = pendingSlotOf(sent, 'pinned');
+    if (title.state === 'unreadable' || pinned.state === 'unreadable')
+        return false;
+    let compared = 0;
+    if (title.state === 'value') {
+        if (typeof title.value !== 'string' || current.title !== title.value)
+            return false;
+        compared++;
+    }
+    if (pinned.state === 'value') {
+        if (typeof pinned.value !== 'boolean' || current.pinned !== pinned.value)
+            return false;
+        compared++;
+    }
+    return compared > 0;
+}
+export function sessionRowPatchRefusalOf(error, sent) {
+    if (!isSlotCarrier(error))
+        return null;
+    const status = readThrownSlot(error, 'status', 'data');
+    const code = readThrownSlot(error, 'errorCode', 'data');
+    if (status === 409 && code === ROW_CHANGED) {
+        const current = currentRowOf(error);
+        if (current !== undefined && alreadyApplied(sent, current))
+            return { kind: 'already-applied', current };
+        return { kind: 'row-changed', ...(current !== undefined ? { current } : {}) };
+    }
+    if (status === 409 && code === SESSION_MIRROR) {
+        const forkPath = guardedRead(() => readErrorString(error, 'forkPath'));
+        return { kind: 'mirror', ...(typeof forkPath === 'string' && forkPath.length > 0 ? { forkPath } : {}) };
+    }
+    if (status === 400 && code === BODY_SHAPE) {
+        const tag = ownData(sent, 'expectedRowTag');
+        if (typeof tag === 'string' && tag.length > 0)
+            return { kind: 'tag-unsupported' };
+    }
+    return null;
+}

package/dist/steering.d.ts

@@ -11,6 +11,7 @@ export interface EngineTaskStatusAttachment {
     status: 'pending' | 'running' | 'completed' | 'failed' | 'killed' | 'parked';
     description: string;
     deltaSummary: null;
+    read?: string;
 }
 export type SteeringRenderable = SteeringInjectedAttachment | EngineTaskStatusAttachment;
 export declare function steeringLabel(source: string): string;