@sema-agent/client-core 0.103.0 → 0.104.0

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/systemReminderTag.js

@@ -39,11 +39,21 @@ export function stripSystemReminderBlocks(text) {
     }
     return pos === 0 ? text : out + text.slice(pos);
 }
-const SYSTEM_REMINDER_TAG_TOKEN = /<[^A-Za-z0-9>]{0,12}system-reminder(?:[^>]{0,200}>)?/gi;
-const SYSTEM_REMINDER_TAG_HEAD = /<[^A-Za-z0-9>]{0,12}system-reminder/i;
+const ENGINE_DEFUSAL_ENTITY = /&(lt|gt);/g;
+const ENVELOPE_TAG_TOKEN = /<[^A-Za-z0-9>]{0,12}(?:system-reminder|task-notification)(?:[^>]{0,200}>)?/gi;
+const CUT_TAG_HEAD = /<[^A-Za-z0-9>]{0,12}([A-Za-z-]{1,16})…/g;
+const ENVELOPE_TAG_HEAD_BRACKET = /<(?=[^A-Za-z0-9>]{0,12}(?:system-reminder|task-notification|([A-Za-z-]{1,16})…))/gi;
+const ENVELOPE_TAG_NAMES = Object.freeze(['system-reminder', 'task-notification']);
+function isCutTagName(head) {
+    if (head === undefined || head === '')
+        return false;
+    const h = head.toLowerCase();
+    return ENVELOPE_TAG_NAMES.some((name) => name.length > h.length && name.startsWith(h));
+}
 export function stripSystemReminderTagTokens(text) {
     if (typeof text !== 'string')
         return text;
-    const once = text.replace(SYSTEM_REMINDER_TAG_TOKEN, ' ');
-    return SYSTEM_REMINDER_TAG_HEAD.test(once) ? once.replace(/</g, '&lt;') : once;
+    const restored = text.replace(ENGINE_DEFUSAL_ENTITY, (_entity, name) => (name === 'lt' ? '<' : '>'));
+    const once = restored.replace(ENVELOPE_TAG_TOKEN, ' ').replace(CUT_TAG_HEAD, (head, name) => (isCutTagName(name) ? ' …' : head));
+    return once.replace(ENVELOPE_TAG_HEAD_BRACKET, (bracket, cutName) => (cutName === undefined || isCutTagName(cutName) ? ' ' : bracket));
 }