@sema-agent/client-core 0.103.0 → 0.104.0

package/dist/hitl/toolApprovalWire.d.ts

@@ -97,6 +97,7 @@ export interface ApprovalCardRequest {
     };
     wireNote?: string;
     argsUnavailable?: true;
+    argsRewritten?: true;
     governanceForced?: true;
     delegation?: ToolApprovalDelegation;
     ruleOffers?: RuleOfferReading[];
@@ -178,7 +179,7 @@ export interface ReadRootCandidateView {
     covers?: 'exact';
 }
 export type ToolApprovalDelegation = ApprovalCardDelegation;
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "approvalCard", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrantAbsence", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "approvalCard", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrantAbsence", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause", "requestedBy"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;
@@ -276,7 +277,7 @@ export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOfferReading[] | undefined;
 export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
-export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
+export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
 export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;
     readonly argsUnavailable?: true;

package/dist/hitl/toolApprovalWire.js

@@ -28,6 +28,7 @@ import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { isPlainRecord } from '../jsonFaithful.js';
 import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, } from '@sema-agent/sdk';
@@ -193,6 +194,11 @@ const PARK_ROW_ARGS_ABSENT_NOTE = "this request's tool arguments are not availab
 const PARK_ROW_ARGS_TRUNCATED_NOTE = "this request's tool arguments were too large to keep on the pending approval record and were replaced by a size marker, " +
     'so you are deciding without seeing them; deny it if you are not sure what it will do. ' +
     'Edits are not accepted on this card: there is no original input to edit';
+const ARGS_REWRITTEN_NOTE = "this request's tool arguments were changed after the model made the call (for example by a hook) — " +
+    'the arguments shown here are the changed ones recorded for this approval, and they differ from the call shown in the conversation';
+const ARGS_FROM_MODEL_CALL_NOTE = 'this approval request did not carry usable tool arguments (for example because they were too large to include), ' +
+    "so the arguments shown are the model's original call from the conversation — " +
+    'if they were changed after that call (for example by a hook), what runs differs from what is shown';
 const PARK_EDIT_REFUSED_REASON = "the card returned an edited approval, but this request's tool arguments are not available on this surface " +
     '(missing, or replaced by a size marker on the pending approval record), so the edit cannot be applied — nothing was sent; ' +
     'approve or deny it as it is';
@@ -205,6 +211,139 @@ function isParkRowInputSizeMarker(v) {
     const o = v;
     return o.truncated === true && typeof o.bytes === 'number' && Number.isFinite(o.bytes) && o.bytes >= 0;
 }
+function recordedInputShapeOf(v) {
+    if (v === undefined || v === null)
+        return 'absent';
+    try {
+        if (typeof v !== 'object' || !isPlainRecord(v))
+            return 'other';
+        return isParkRowInputSizeMarker(v) ? 'size_marker' : 'input';
+    }
+    catch {
+        return 'other';
+    }
+}
+function argsProvablyDiffer(recorded, streamArgs) {
+    try {
+        if (typeof streamArgs !== 'object' || streamArgs === null || Array.isArray(streamArgs))
+            return false;
+        return jsonValuesDiffer(recorded, streamArgs, 0, { nodes: 0 }) === true;
+    }
+    catch {
+        return false;
+    }
+}
+function cardInputOf(recorded, stream) {
+    const shape = recordedInputShapeOf(recorded);
+    const streamPresent = stream !== undefined && stream !== null;
+    if (shape === 'input')
+        return { from: 'recorded', args: recorded, rewritten: streamPresent && argsProvablyDiffer(recorded, stream) };
+    if (streamPresent)
+        return { from: 'stream', args: stream, shape };
+    return { from: 'none', shape, recorded };
+}
+const CARD_ARGS_COMPARE_MAX_NODES = 20_000;
+const CARD_ARGS_COMPARE_MAX_DEPTH = 256;
+const NOT_COMPARABLE = Symbol('not comparable');
+function ownDataForCompare(o, k) {
+    const d = Object.getOwnPropertyDescriptor(o, k);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : NOT_COMPARABLE;
+}
+const TO_JSON_CHAIN_MAX = 32;
+function hasToJsonHook(o) {
+    let at = o;
+    for (let depth = 0; at !== null; depth++) {
+        if (depth >= TO_JSON_CHAIN_MAX)
+            return true;
+        const d = Object.getOwnPropertyDescriptor(at, 'toJSON');
+        if (d !== undefined)
+            return !Object.hasOwn(d, 'value') || typeof d.value === 'function';
+        at = Object.getPrototypeOf(at);
+    }
+    return false;
+}
+function jsonValueKindOf(v) {
+    if (v === null)
+        return 'null';
+    switch (typeof v) {
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        case 'number':
+            return Number.isFinite(v) ? 'number' : undefined;
+        case 'object':
+            if (Array.isArray(v))
+                return hasToJsonHook(v) ? undefined : 'array';
+            return isPlainRecord(v) && !hasToJsonHook(v) ? 'object' : undefined;
+        default:
+            return undefined;
+    }
+}
+function jsonValuesDiffer(a, b, depth, budget) {
+    if (++budget.nodes > CARD_ARGS_COMPARE_MAX_NODES || depth > CARD_ARGS_COMPARE_MAX_DEPTH)
+        return undefined;
+    const ka = jsonValueKindOf(a);
+    const kb = jsonValueKindOf(b);
+    if (ka === undefined || kb === undefined)
+        return undefined;
+    if (ka !== kb)
+        return true;
+    if (ka === 'array') {
+        const xa = a;
+        const xb = b;
+        const la = ownDataForCompare(xa, 'length');
+        const lb = ownDataForCompare(xb, 'length');
+        if (typeof la !== 'number' || typeof lb !== 'number')
+            return undefined;
+        if (la !== lb)
+            return true;
+        for (let i = 0; i < la; i++) {
+            const va = ownDataForCompare(xa, String(i));
+            const vb = ownDataForCompare(xb, String(i));
+            if (va === NOT_COMPARABLE || vb === NOT_COMPARABLE)
+                return undefined;
+            const d = jsonValuesDiffer(va, vb, depth + 1, budget);
+            if (d !== false)
+                return d;
+        }
+        return false;
+    }
+    if (ka === 'object') {
+        const ra = a;
+        const rb = b;
+        const keysA = Object.keys(ra);
+        const keysB = Object.keys(rb);
+        budget.nodes += keysA.length + keysB.length;
+        if (budget.nodes > CARD_ARGS_COMPARE_MAX_NODES)
+            return undefined;
+        const inA = new Set(keysA);
+        const inB = new Set(keysB);
+        for (const k of keysA) {
+            const va = ownDataForCompare(ra, k);
+            if (va === NOT_COMPARABLE)
+                return undefined;
+            if (!inB.has(k))
+                return jsonValueKindOf(va) === undefined ? undefined : true;
+            const vb = ownDataForCompare(rb, k);
+            if (vb === NOT_COMPARABLE)
+                return undefined;
+            const d = jsonValuesDiffer(va, vb, depth + 1, budget);
+            if (d !== false)
+                return d;
+        }
+        for (const k of keysB) {
+            if (inA.has(k))
+                continue;
+            const vb = ownDataForCompare(rb, k);
+            if (vb === NOT_COMPARABLE)
+                return undefined;
+            return jsonValueKindOf(vb) === undefined ? undefined : true;
+        }
+        return false;
+    }
+    return a === b ? false : true;
+}
 function durableHoldKey(row, callKey) {
     const createdAt = typeof row.createdAt === 'number' && Number.isFinite(row.createdAt) ? row.createdAt : null;
     return JSON.stringify([typeof row.sessionId === 'string' ? row.sessionId : null, typeof row.taskId === 'string' ? row.taskId : null, callKey, createdAt]);
@@ -344,15 +483,10 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const at = { lane: 'decide', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
     const streamArgs = gatedCallId !== undefined ? argsByCall.get(gatedCallId) : undefined;
-    const rowInput = pending.input;
-    const rowArgsGap = streamArgs !== undefined && streamArgs !== null
-        ? undefined
-        : rowInput === undefined || rowInput === null
-            ? 'absent'
-            : isParkRowInputSizeMarker(rowInput)
-                ? 'truncated'
-                : undefined;
-    const args = streamArgs !== undefined && streamArgs !== null ? streamArgs : rowArgsGap !== undefined ? {} : rowInput;
+    const reading = cardInputOf(pending.input, streamArgs);
+    const rowArgsGap = reading.from !== 'none' ? undefined : reading.shape === 'absent' ? 'absent' : reading.shape === 'size_marker' ? 'truncated' : undefined;
+    const args = reading.from !== 'none' ? reading.args : rowArgsGap !== undefined ? {} : reading.recorded;
+    const argsRewritten = reading.from === 'recorded' && reading.rewritten;
     if (typeof args !== 'object' || args === null) {
         return { kind: 'not_sent', ...at, cause: 'no_input', detail: 'gate has no tool input payload' };
     }
@@ -375,6 +509,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 wireNote: rowArgsGap === 'truncated' ? PARK_ROW_ARGS_TRUNCATED_NOTE : PARK_ROW_ARGS_ABSENT_NOTE,
             }
             : {}),
+        ...(argsRewritten ? { argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : {}),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(pending) ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(pending, 'mandated') ? { mandated: true } : {}),
@@ -583,6 +718,7 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'delegation',
     'outcome',
     'cause',
+    'requestedBy',
 ];
 const _mirrorPin = [true];
 void _mirrorPin;
@@ -1088,7 +1224,7 @@ const UNREADABLE_EVIDENCE_KEYS = Object.freeze({
     ]),
     generic: Object.freeze([['ruleOffersAbsence', 'ruleOffersAbsence'], ['askClass', 'askClass'], ['classes', 'classes']]),
 });
-function v1RiskUnreadable(card) {
+function riskSubtreeUnreadable(card) {
     if (slotPresenceOf(card, 'risk') === 'absent')
         return false;
     try {
@@ -1115,7 +1251,7 @@ function withUnreadableEvidence(carrier, leg, req, reported = []) {
         if (retiredAllowRuleShadowKeyPresent(carrier, shadowLeg))
             keys.add(RETIRED_SHADOW_EVIDENCE_LABEL[shadowLeg]);
     }
-    if (leg === 'v1' && v1RiskUnreadable(carrier))
+    if ((leg === 'v1' || leg === 'frame') && riskSubtreeUnreadable(carrier))
         keys.add('risk');
     return keys.size === 0 ? req : { ...req, unreadableEvidence: Object.freeze([...keys].sort()) };
 }
@@ -1509,10 +1645,19 @@ function cardFactsOf(carrier, leg, opts) {
                 stream = opts.streamArgs;
                 blind = opts.argsUnavailable === true;
             }
-            const raw = stream !== undefined && stream !== null ? stream : c.args !== undefined && c.args !== null ? c.args : undefined;
-            if (typeof raw === 'object' && raw !== null)
-                return blind ? { args: raw, argsUnavailable: true } : { args: raw };
-            const fallback = argsFallbackOf(c.message, c.argsOmitted);
+            const reading = cardInputOf(c.args, stream);
+            if (reading.from === 'recorded') {
+                if (blind)
+                    return { args: reading.args, argsUnavailable: true };
+                return reading.rewritten ? { args: reading.args, argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : { args: reading.args };
+            }
+            if (reading.from === 'stream' && typeof reading.args === 'object' && reading.args !== null) {
+                if (blind)
+                    return { args: reading.args, argsUnavailable: true };
+                return { args: reading.args, wireNote: ARGS_FROM_MODEL_CALL_NOTE };
+            }
+            const omitted = c.argsOmitted === true || reading.shape === 'size_marker';
+            const fallback = argsFallbackOf(c.message, omitted);
             const note = blind ? SUSPENDED_ASK_ARGS_NOTE : fallback.omittedNote;
             return { args: fallback.args, argsUnavailable: true, ...(note !== undefined ? { wireNote: note } : {}) };
         }
@@ -1538,6 +1683,8 @@ function cardFactsOf(carrier, leg, opts) {
         out.wireNote = argsPart.wireNote;
     if (argsPart.argsUnavailable === true)
         out.argsUnavailable = true;
+    if (argsPart.argsRewritten === true)
+        out.argsRewritten = true;
     if (full) {
         v1Bit(() => {
             if (c.governanceForced === true)

package/dist/host.d.ts

@@ -3,9 +3,6 @@ import type { WireHooksConfig } from './finalVerifyWire.js';
 import { type NotificationQueuePort } from './notifications.js';
 export type SettingsDocument = Record<string, unknown>;
 export type ManagedPolicyState = 'absent' | 'in-effect' | 'in-effect-pieces' | 'unreadable-covered' | 'unreadable-uncovered' | 'remote-unknown';
-export interface ManagedPolicyReading {
-    readonly state: ManagedPolicyState;
-}
 export type HooksStartupMode = 'safe' | 'bare';
 export type PluginHookOptionValue = string | number | boolean;
 export interface PluginHookSensitiveOption {

package/dist/hostTurnSettings.js

@@ -454,8 +454,10 @@ function permissionsArm(src, side, adoption) {
             appendOwnElement(buckets[bucket], rule);
             origins[bucket].set(rule, origin);
         }
-        else if (rank(origin) < rank(prev))
+        else if (rank(origin) < rank(prev)) {
+            origins[bucket].delete(rule);
             origins[bucket].set(rule, origin);
+        }
     };
     let projectionError;
     const portsProjection = newRulePortsProjection();

package/dist/humanTurn.js

@@ -1,4 +1,4 @@
-import { CORE_MAX_PENDING_STEER_CHARS, CORE_MCP_IMAGE_MAX_BASE64, CORE_USER_ATTACHMENT_LABEL_MAX } from './generated/engineFactTables.js';
+import { CORE_IMAGE_ADMISSION_HARD_IMAGE_BASE64_CHARS, CORE_MAX_PENDING_STEER_CHARS, CORE_USER_ATTACHMENT_LABEL_MAX } from './generated/engineFactTables.js';
 import { mintEnvelopeOf, mintReferenceOf, seatTextOf } from './userAttachmentEnvelope.js';
 import { readEncodingShares, readHumanTurnInput } from './humanTurnRead.js';
 import { putOwnKey } from './ownKey.js';
@@ -224,7 +224,7 @@ function encodeObjective(v) {
     let count = 0;
     let total = 0;
     const seat = (len) => {
-        if (len > CORE_MCP_IMAGE_MAX_BASE64)
+        if (len > CORE_IMAGE_ADMISSION_HARD_IMAGE_BASE64_CHARS)
             return 'image_too_large';
         if (count + 1 > IMAGE_SEAT_MAX_COUNT)
             return 'seat_count';

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: {