@sema-agent/client-core 0.102.0 → 0.104.0

package/dist/request/taskRequest.js

@@ -21,7 +21,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'selfOrchestration', lanes: ['interactive', 'print'], live: true, why: 'SEMA_SELF_ORCHESTRATION opt-in → core 挂 run_workflow', whyUtilityLane: '无座:它挂的是编排工具,与零工具面直接矛盾' },
     { field: 'deferTools', lanes: ['interactive', 'print'], live: true, why: '[1052]① Workflow 延迟披露;selfOrchestration 前置门', whyUtilityLane: '无座:工具延迟披露是工具面的位,零工具面上没有对象' },
     { field: 'retainBackgroundProcesses', lanes: ['interactive', 'print'], live: true, why: '缺省 ON(2026-07-26 起翻转);SEMA_RETAIN_BACKGROUND=0 逃生', whyUtilityLane: '无座:后台进程是工具面的产物,零工具面产不出' },
-    { field: 'promptProfile', lanes: ['interactive', 'print'], live: true, why: 'core 1.328 呈现轴 A/B 口,缺省不 stamp = 引擎缺省 simple', whyUtilityLane: '无座:呈现轴是用户会话的偏好;side-channel 的系统提示由壳整段给出(见 systemPrompt 那一行),不再借呈现轴调形' },
+    { field: 'promptLean', lanes: ['interactive', 'print'], live: true, why: '提示词形轴(0.103.0 起布尔,取代退役的两词形轴键;sdk 28 / 服务端 7.137.0):缺省不 stamp = 目录缺省;映射单铸点 promptLeanFromEnv', whyUtilityLane: '无座:提示词形是用户会话的偏好;side-channel 的系统提示由壳整段给出(见 systemPrompt 那一行),不再借形轴调形' },
     { field: 'enableFork', lanes: ['interactive', 'print'], live: true, why: '显式布尔才 stamp([503]② fail-OPEN 教训:off 必须显式)', whyUtilityLane: '无座:分叉是会话面的动作,而 side-channel 提交是一次性的独立会话' },
     { field: 'attachments', lanes: ['interactive', 'print'], live: true, why: 'design/133 + G1 缺省开的 turn 边界 attachment', whyUtilityLane: '无座:turn 边界的附件配置属用户会话;side-channel 提交不带附件' },
     { field: 'skills', lanes: ['interactive', 'print'], live: true, why: '本地技能目录投影(布局取 CC 同款);两条车道都由 launchRepl 载入面注入', whyUtilityLane: '无座:技能挂的是工具,与零工具面矛盾' },
@@ -152,7 +152,7 @@ const INPUT_KEY_ROUTES = {
     selfOrchestration: row('selfOrchestration'),
     deferTools: row('deferTools'),
     retainBackgroundProcesses: row('retainBackgroundProcesses'),
-    promptProfile: row('promptProfile'),
+    promptLean: row('promptLean'),
     enableFork: row('enableFork'),
     attachments: row('attachments'),
     attachmentIds: row('attachmentIds'),
@@ -1103,7 +1103,7 @@ export function assembleTaskRequest(input, laneOrIdentity) {
         ...(on('selfOrchestration') ? { selfOrchestration: i.selfOrchestration } : {}),
         ...(on('deferTools') ? { deferTools: i.deferTools } : {}),
         ...(on('retainBackgroundProcesses') ? { retainBackgroundProcesses: i.retainBackgroundProcesses } : {}),
-        ...(on('promptProfile') ? { promptProfile: i.promptProfile } : {}),
+        ...(on('promptLean') ? { promptLean: i.promptLean } : {}),
         ...(on('enableFork') ? { enableFork: i.enableFork } : {}),
         ...(on('attachments') ? { attachments: attachmentsForWire } : {}),
         ...(on('repo') ? { repo: i.repo } : {}),

package/dist/retryStatus.d.ts

@@ -11,6 +11,9 @@ export type RetryStatus = {
     providerConditionSource?: string;
     elapsedMs?: number;
     timeoutMs?: number;
+    sleptMs?: number;
+    waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
     detail?: string;
 } | {
     kind: 'error';
@@ -26,6 +29,9 @@ export type RetryStatus = {
     error: RetryStatusErrorPayload;
     elapsedMs?: number;
     timeoutMs?: number;
+    sleptMs?: number;
+    waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
 } | {
     kind: 'waiting';
     deadline: number;
@@ -38,6 +44,9 @@ export type RetryStatus = {
     providerConditionSource?: string;
     elapsedMs?: number;
     timeoutMs?: number;
+    sleptMs?: number;
+    waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
     terminal?: never;
     error: RetryStatusErrorPayload;
 };
@@ -69,8 +78,15 @@ export interface BrainStatusPayload {
     timeoutMs?: number;
     providerCondition?: string;
     providerConditionSource?: string;
+    sleptMs?: number;
+    waitSegment?: BrainStatusWaitSegment | (string & {});
+    seat?: BrainStatusSeat | (string & {});
 }
-export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource"];
+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_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;
@@ -86,6 +102,9 @@ export interface RetryStatusArmLike {
     readonly timeoutMs?: number;
     readonly providerCondition?: string;
     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

@@ -11,6 +11,12 @@ export const BRAIN_STATUS_PHASES = [
     'gave_up',
     'waiting_first_token',
 ];
+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',
@@ -25,6 +31,9 @@ export const BRAIN_STATUS_PAYLOAD_KEYS = [
     'timeoutMs',
     'providerCondition',
     'providerConditionSource',
+    'sleptMs',
+    'waitSegment',
+    'seat',
 ];
 const _brainStatusKeyPin = [true, true];
 void _brainStatusKeyPin;
@@ -41,9 +50,11 @@ export function mapBrainStatusToRetry(p, nowMs) {
     const cause = typeof p.errClass === 'string' && p.errClass.length > 0 ? { errClass: p.errClass } : {};
     const producerTiming = typeof p.retryAtMs === 'number' ? { retryAtMs: p.retryAtMs } : {};
     const failureStatus = typeof p.errorStatus === 'number' ? { errorStatus: p.errorStatus } : {};
+    const providerCondition = p.providerCondition;
+    const providerConditionSource = p.providerConditionSource;
     const providerJudged = {
-        ...(typeof p.providerCondition === 'string' && p.providerCondition.length > 0 ? { providerCondition: p.providerCondition } : {}),
-        ...(typeof p.providerConditionSource === 'string' && p.providerConditionSource.length > 0 ? { providerConditionSource: p.providerConditionSource } : {}),
+        ...(typeof providerCondition === 'string' && providerCondition.length > 0 ? { providerCondition } : {}),
+        ...(typeof providerConditionSource === 'string' && providerConditionSource.length > 0 ? { providerConditionSource } : {}),
     };
     const saneMs = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
     const elapsedMs = saneMs(p.elapsedMs);
@@ -52,10 +63,18 @@ export function mapBrainStatusToRetry(p, nowMs) {
         ...(elapsedMs !== undefined ? { elapsedMs } : {}),
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
     };
+    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 } : {};
     const shown = (absent) => (typeof p.detail === 'string' ? displayUntrusted(p.detail) : absent);
-    const extra = { ...counts, ...cause, ...producerTiming, ...failureStatus, ...providerJudged, ...waitProgress };
+    const extra = { ...counts, ...cause, ...producerTiming, ...failureStatus, ...providerJudged, ...waitProgress, ...waitFacts };
     switch (p.phase) {
         case 'recovered':
             return null;
@@ -99,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] = [
-        str('detail'), num('retryInSec'), num('retryInMs'), num('attempt'), num('maxRetries'), str('errClass'), num('retryAtMs'), num('errorStatus'), num('elapsedMs'), num('timeoutMs'), word('providerCondition'), word('providerConditionSource'),
+    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)
@@ -119,6 +138,9 @@ export function retryStatusFromArm(arm, nowMs) {
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         ...(providerCondition !== undefined ? { providerCondition } : {}),
         ...(providerConditionSource !== undefined ? { providerConditionSource } : {}),
+        ...(sleptMs !== undefined ? { sleptMs } : {}),
+        ...(waitSegment !== undefined ? { waitSegment } : {}),
+        ...(seat !== undefined ? { seat } : {}),
     }, nowMs);
 }
 const WAIT_SWITCH_FRACTION = 0.5;
@@ -203,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');
@@ -228,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)
@@ -237,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);
@@ -162,6 +181,7 @@ const R_BOOL = ruleOf("boolean", (v) => typeof v === "boolean");
 const R_THINKING_LATCH_ROW = oneOfRule("latch word", THINKING_LATCH_ROW_WORDS);
 const R_TRUE = ruleOf("true", (v) => v === true);
 const R_NUM = ruleOf("finite number", (v) => typeof v === "number" && Number.isFinite(v));
+const R_NUM0 = ruleOf("finite non-negative number", (v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
 const R_INT0 = ruleOf("non-negative integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0);
 const R_INT1 = ruleOf("positive integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v > 0);
 const keyWords = (k) => k
@@ -558,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"];
@@ -581,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) },
@@ -593,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) },
@@ -882,6 +902,11 @@ function mcpPanelLivenessArms() {
     return arms;
 }
 const MCP_PANEL_LIVENESS_VIEW = armsRule("mcp liveness", "state", mcpPanelLivenessArms());
+const MCP_PANEL_AUTHORIZATION = shapeRule("mcp authorization", {
+    reason: reqF(R_NONEMPTY),
+    authorizeUrl: optF(R_NONEMPTY),
+    resourceMetadataUrl: optF(R_NONEMPTY),
+});
 const MCP_PANEL_LEG_ENTRY = shapeRule("leg entry", {
     name: reqF(R_NONEMPTY),
     status: reqF(R_NONEMPTY),
@@ -892,6 +917,8 @@ const MCP_PANEL_LEG_ENTRY = shapeRule("leg entry", {
     httpStatus: optF(R_NUM),
     liveness: optF(MCP_PANEL_LIVENESS_VIEW),
     livenessUnreadable: optF(R_TRUE),
+    authorization: optF(MCP_PANEL_AUTHORIZATION),
+    authorizationUnreadable: optF(R_TRUE),
 });
 const MCP_PANEL_LAST_LEG = shapeRule("last leg", {
     runId: reqF(R_NONEMPTY),
@@ -975,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");
@@ -1069,6 +1100,9 @@ const RETRY_COMMON_SPEC = {
     providerConditionSource: optF(R_STR),
     elapsedMs: optF(R_NUM),
     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) },
@@ -1441,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) {
@@ -1734,6 +1772,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "queuedMessages",
     "parked",
     "pinned",
+    "rowTag",
     "thinkingLatch",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
@@ -1779,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: {
@@ -1900,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/sessionMemoryErase.js

@@ -245,7 +245,29 @@ const UNCONFIRMED_TEXT = {
     unreadable: 'Not confirmed: the result of this erase could not be read.',
 };
 const ERASED_TEXT = 'Erased: every memory entry recorded as coming from this session was erased or was already gone.';
-const PARTIAL_TEXT = 'Partly erased: some memory entries from this session were not erased yet.';
+const PARTIAL_ENTRIES_TEXT = 'Partly erased: some memory entries from this session were not erased yet.';
+const PARTIAL_UNKNOWN_TEXT = 'Partly erased: the engine reports this erase as not complete, and its receipt does not show whether memory entries or other stored records of them remain.';
+function partialCarriersText(kinds) {
+    return kinds === 1
+        ? 'Partly erased: every memory entry recorded as coming from this session was erased or was already gone, but 1 kind of stored record that refers to them was not confirmed removed, and trying again may not remove it.'
+        : `Partly erased: every memory entry recorded as coming from this session was erased or was already gone, but ${kinds} kinds of stored records that refer to them were not confirmed removed, and trying again may not remove them.`;
+}
+function partialTextOf(cause) {
+    if (cause === null)
+        return PARTIAL_UNKNOWN_TEXT;
+    switch (cause.kind) {
+        case 'entries_pending':
+            return PARTIAL_ENTRIES_TEXT;
+        case 'carriers_residual':
+            return partialCarriersText(cause.carriers.length);
+        case 'unknown':
+            return PARTIAL_UNKNOWN_TEXT;
+        default: {
+            const unreachable = cause;
+            return unreachable;
+        }
+    }
+}
 const RETRY_TEXT = {
     not_needed: 'Nothing more to do.',
     same_request_id: 'It is safe to try again with the same request id.',
@@ -414,7 +436,7 @@ export function sessionMemoryEraseOutcome(answer) {
             return { kind: 'erased', receipt: reading, text: ERASED_TEXT, retry: 'not_needed', retryText: RETRY_TEXT.not_needed };
         }
         const retry = memoryEraseReplayPosture(reading) === 'idempotent' ? 'same_request_id' : 'human_decision';
-        return { kind: 'partial', receipt: reading, text: PARTIAL_TEXT, retry, retryText: RETRY_TEXT[retry] };
+        return { kind: 'partial', receipt: reading, text: partialTextOf(reading.partialCause), retry, retryText: RETRY_TEXT[retry] };
     }
     if (status < 400)
         return unconfirmedBy('unclassified', signed, { status });

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));
 }

package/dist/turnFailurePresentation.js

@@ -60,7 +60,14 @@ function isIdleWatchdog(err) {
         return false;
     }
 }
-const DETERMINISTIC_SERVER_CODES = new Set([CORRUPT_SESSION_ERROR_CODE, CORRUPT_ROW_ERROR_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT]);
+const DETERMINISTIC_SERVER_CODES = new Set([
+    CORRUPT_SESSION_ERROR_CODE,
+    CORRUPT_ROW_ERROR_CODE,
+    SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
+    MEMORY_CONTROL_PLANE_CORRUPT,
+    'approvals.read_corrupt',
+    'workflow.journal_incompatible',
+]);
 const BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
 function httpShapeOf(verdict, code) {
     const status = verdict.status;