@sema-agent/client-core 0.109.0 → 0.110.0

package/dist/seatContract.js

@@ -310,6 +310,7 @@ const CHROME_ARM_SEAT_ROUTE = {
     compaction_outcome: "seat",
     engine_notice: "seat",
     subagent_alias: "seat",
+    session_box_notice: "seat",
     workflow_notification_enqueue: "host",
     plan_review_park: "host",
     approval_request: "host",
@@ -398,7 +399,7 @@ export function readSeatStreamDelta(message) {
         return Object.freeze({ kind: "malformed" });
     }
 }
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -478,6 +479,8 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     computerUseSwitch: Object.freeze({ action: "Computer use", ability: "be switched", support: "switch support" }),
     engineModeDefaultOnly: Object.freeze({ action: "Default-only engine switching", ability: "keep existing sessions on their engine", support: "default-only engine switching" }),
     seatActions: Object.freeze({ action: "App menu actions", ability: "send actions to this window", support: "app action support" }),
+    notificationLevels: Object.freeze({ action: "Choosing notification levels", ability: "keep notification levels", support: "notification-level support" }),
+    modsView: Object.freeze({ action: "Showing mods", ability: "show mods", support: "mods support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -600,6 +603,7 @@ export const SEAT_TURN_SETTINGS_ORIGINS = Object.freeze({
     hooks: Object.freeze({ hostSupplied: "settings.hooks" }),
     resolved: Object.freeze({ hostSupplied: "settings.resolved" }),
     outputStyle: Object.freeze({ hostSupplied: "settings.outputStyle" }),
+    env: Object.freeze({ hostSupplied: "settings.env" }),
 });
 export const SEAT_REWIND_INTENT_KEYS = ["mode", "targetMessageUuid"];
 export const ATTACHMENT_UPLOAD_REQUEST_KEYS = ["name", "mimeType", "bytes"];
@@ -845,7 +849,7 @@ const R_UNANSWERED_ONLY = ruleOf("unanswered-only", () => false);
 const ENGINE_TARGET_LOCAL_SPEC = {
     lastBootError: optF(R_STR),
     mcp: optF(SEAT_LOCAL_MCP_READING),
-    lifecycle: optF(LOCAL_ENGINE_SEAT_READING),
+    lifecycle: reqF(LOCAL_ENGINE_SEAT_READING),
 };
 const ENGINE_TARGET_LOCAL = {
     label: "local",
@@ -855,8 +859,6 @@ const ENGINE_TARGET_LOCAL = {
             return verdict;
         const rec = v;
         const lifecycle = own(rec, "lifecycle");
-        if (isAbsent(lifecycle))
-            return true;
         const phase = own(lifecycle, "phase");
         const bootError = !isAbsent(own(rec, "lastBootError"));
         if (bootError !== (phase === "down"))
@@ -1074,6 +1076,46 @@ const checkSessionMcpPanelResult = seatCheck((v) => {
         return checkSessionMcpPanelFailure(v);
     return Object.hasOwn(v, "scenarioRefusal") ? checkSessionMcpPanelRefusalView(v) : checkSessionMcpPanelServersView(v);
 });
+const MOD_ROW_SKIP = shapeRule("mod skip", {
+    registration: reqF(R_NONEMPTY),
+    cause: reqF(R_NONEMPTY),
+    reason: reqF(R_NONEMPTY),
+});
+const MOD_ROW_MOUNTED_SPEC = {
+    name: reqF(R_NONEMPTY),
+    seat: reqF(R_NONEMPTY),
+    tier: reqF(R_NONEMPTY),
+    provenance: optF(R_NONEMPTY),
+    events: reqF(arrayRule(R_STR)),
+    observe: optF(arrayRule(R_STR)),
+    skipped: optF(arrayRule(MOD_ROW_SKIP, true)),
+};
+const MOD_ROW_REFUSED_SPEC = {
+    name: reqF(R_NONEMPTY),
+    seat: reqF(R_NONEMPTY),
+    tier: reqF(R_NONEMPTY),
+    provenance: optF(R_NONEMPTY),
+    refusedBy: reqF(R_NONEMPTY),
+    reason: reqF(R_NONEMPTY),
+};
+const MOD_ROW = {
+    label: "mod row",
+    test: (v, path) => {
+        if (!isPlainRecord(v))
+            return bad("not object", path);
+        return Object.hasOwn(v, "refusedBy") || Object.hasOwn(v, "reason") ? shapeVerdict(MOD_ROW_REFUSED_SPEC, v, path) : shapeVerdict(MOD_ROW_MOUNTED_SPEC, v, path);
+    },
+};
+const checkSessionModsFailure = seatShapeCheck(armsRule("readSessionMods failure", "kind", {
+    unreadable: DEVICE_UNREADABLE_SPEC,
+    unarmed: {},
+}));
+const checkSessionModsView = seatShapeCheck(shapeRule("mods view", { rows: reqF(arrayRule(MOD_ROW)) }));
+const checkSessionModsResult = seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("not object");
+    return Object.hasOwn(v, "kind") ? checkSessionModsFailure(v) : checkSessionModsView(v);
+});
 const MCP_TOOL_TOGGLE_KEY = shapeRule("toggle key", {
     server: reqF(R_NONEMPTY),
     tool: reqF(R_NONEMPTY),
@@ -1169,6 +1211,75 @@ export function planSetComputerUse(request, lockedByEnv) {
         return Object.freeze({ kind: "refused", reason: "confirmation-required" });
     return Object.freeze({ kind: "apply", enabled: intent.kind === "enable" });
 }
+export const NOTIFICATION_LEVEL_TYPES = Object.freeze(["permission", "question", "idle"]);
+export const NOTIFICATION_LEVELS = Object.freeze(["off", "badge", "banner"]);
+export const NOTIFICATION_LEVEL_REFUSAL_REASONS = Object.freeze(["invalid-request", "unsupported-level", "write-failed"]);
+const R_NOTIFICATION_LEVEL = oneOfRule("notification level", NOTIFICATION_LEVELS);
+const NOTIFICATION_SUPPORTED_ITEMS = arrayRule(R_NOTIFICATION_LEVEL, true);
+const NOTIFICATION_SUPPORTED_ORDER = "bad value (supported levels: off first, closed-set order, no repeats)";
+const R_NOTIFICATION_SUPPORTED = {
+    label: "supported levels",
+    test: (v, path) => {
+        const verdict = NOTIFICATION_SUPPORTED_ITEMS.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rank = (x) => NOTIFICATION_LEVELS.indexOf(x);
+        const rows = ownItems(v);
+        if (rows[0] !== "off")
+            return bad(NOTIFICATION_SUPPORTED_ORDER, path);
+        for (let i = 1; i < rows.length; i += 1)
+            if (rank(rows[i]) <= rank(rows[i - 1]))
+                return bad(NOTIFICATION_SUPPORTED_ORDER, `${path}[${i}]`);
+        return true;
+    },
+};
+const NOTIFICATION_LEVELS_STATE_SHAPE = shapeRule("notification levels state", {
+    levels: reqF(shapeRule("notification levels", {
+        permission: reqF(R_NOTIFICATION_LEVEL),
+        question: reqF(R_NOTIFICATION_LEVEL),
+        idle: reqF(R_NOTIFICATION_LEVEL),
+    })),
+    supported: reqF(R_NOTIFICATION_SUPPORTED),
+});
+const NOTIFICATION_LEVELS_STATE = {
+    label: NOTIFICATION_LEVELS_STATE_SHAPE.label,
+    test: (v, path) => {
+        const verdict = NOTIFICATION_LEVELS_STATE_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        const levels = own(rec, "levels");
+        const supported = ownItems(own(rec, "supported"));
+        for (const t of NOTIFICATION_LEVEL_TYPES)
+            if (!supported.includes(own(levels, t)))
+                return bad("unsupported level", pathAt(path, `levels.${t}`));
+        return true;
+    },
+};
+const checkNotificationLevelsState = seatShapeCheck(NOTIFICATION_LEVELS_STATE);
+const checkSetNotificationLevelResult = seatShapeCheck(okArmsRule("setNotificationLevel result", { state: reqF(NOTIFICATION_LEVELS_STATE) }, {
+    reason: reqF(oneOfRule("notification level refusal", NOTIFICATION_LEVEL_REFUSAL_REASONS)),
+    state: reqF(NOTIFICATION_LEVELS_STATE),
+}));
+export function planSetNotificationLevel(type, level, supported) {
+    if (typeof type !== "string" || !inTuple(NOTIFICATION_LEVEL_TYPES, type) || typeof level !== "string" || !inTuple(NOTIFICATION_LEVELS, level)) {
+        return Object.freeze({ kind: "refused", reason: "invalid-request" });
+    }
+    let delivers = false;
+    try {
+        const n = Array.isArray(supported) ? ownDataField(supported, "length") : undefined;
+        if (typeof n === "number" && Number.isSafeInteger(n) && n <= NOTIFICATION_LEVELS.length) {
+            for (let i = 0; i < n && !delivers; i += 1)
+                delivers = own(supported, String(i)) === level;
+        }
+    }
+    catch {
+        delivers = false;
+    }
+    if (!delivers)
+        return Object.freeze({ kind: "refused", reason: "unsupported-level" });
+    return Object.freeze({ kind: "apply", type, level });
+}
 export const SEAT_ACTION_NAMES = Object.freeze(["new-project", "prefill-composer"]);
 const SEAT_PREFILL_TEXT_MAX = 14336;
 const SEAT_PREFILL_CWD_MAX = 4096;
@@ -1919,7 +2030,37 @@ export function isSendMessageAck(v) {
 }
 const checkInterruptAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "interrupted") === "boolean" ? true : bad("interrupt ack needs a plain object with boolean `interrupted`", "interrupted"));
 const checkStopAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "stopped") === "boolean" ? true : bad("stop ack needs a plain object with boolean `stopped`", "stopped"));
-const checkOkAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "ok") === "boolean" ? true : bad("ack needs a plain object with boolean `ok`", "ok"));
+const okAckVerdict = (v) => isPlainRecord(v) && typeof own(v, "ok") === "boolean" ? true : bad("ack needs a plain object with boolean `ok`", "ok");
+const checkOkAck = seatCheck(okAckVerdict);
+const TOOL_PERMISSION_SETTLED_WORDS = Object.freeze(["allow", "deny"]);
+const R_SETTLED_ELSEWHERE = shapeRule("settled elsewhere", {
+    firstDecision: reqF(oneOfRule("decision word", TOOL_PERMISSION_SETTLED_WORDS)),
+    contrary: reqF(R_BOOL),
+});
+const checkToolPermissionAck = seatCheck((v) => {
+    const base = okAckVerdict(v);
+    if (base !== true)
+        return base;
+    const slot = own(v, "settledElsewhere");
+    return isAbsent(slot) ? true : R_SETTLED_ELSEWHERE.test(slot, "settledElsewhere");
+});
+const checkSettledElsewhereSlot = seatCheck((v) => R_SETTLED_ELSEWHERE.test(v, "settledElsewhere"));
+export function readToolPermissionSettledElsewhere(ack) {
+    try {
+        if (typeof ack !== "object" || ack === null)
+            return undefined;
+        const slot = own(ack, "settledElsewhere");
+        if (isAbsent(slot))
+            return undefined;
+        if (checkSettledElsewhereSlot(slot) !== true)
+            return undefined;
+        const first = own(slot, "firstDecision");
+        return Object.freeze({ firstDecision: first === "allow" ? "allow" : "deny", contrary: own(slot, "contrary") === true });
+    }
+    catch {
+        return undefined;
+    }
+}
 const checkBooleanAck = (v) => typeof v === "boolean" ? true : bad("expected a bare boolean result");
 const checkGetTranscriptResult = seatCheck((v) => {
     if (!isPlainRecord(v))
@@ -2042,7 +2183,7 @@ export const LOCAL_SESSIONS_SPEC = {
         sendMessage: { kind: "invoke", check: checkSendMessageAck },
         interrupt: { kind: "invoke", check: checkInterruptAck },
         stop: { kind: "invoke", check: checkStopAck },
-        respondToToolPermission: { kind: "invoke", check: checkOkAck },
+        respondToToolPermission: { kind: "invoke", check: checkToolPermissionAck },
         cancelQueuedMessage: { kind: "invoke", check: checkBooleanAck },
         reorderQueuedMessage: { kind: "invoke", check: checkBooleanAck },
         promoteQueuedMessage: { kind: "invoke", check: checkBooleanAck },
@@ -2078,7 +2219,10 @@ export const LOCAL_SESSIONS_SPEC = {
         setThinkingLatch: { kind: "invoke", check: checkOkAck },
         getComputerUse: { kind: "invoke", check: checkComputerUseState },
         setComputerUse: { kind: "invoke", check: checkSetComputerUseResult },
+        getNotificationLevels: { kind: "invoke", check: checkNotificationLevelsState },
+        setNotificationLevel: { kind: "invoke", check: checkSetNotificationLevelResult },
         claimSeatActions: { kind: "invoke", check: checkOkAck },
+        readSessionMods: { kind: "invoke", check: checkSessionModsResult },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
         onSeatAction: { kind: "event", check: checkSeatAction },
@@ -2132,7 +2276,10 @@ export const SEAT_METHOD_NAMES = [
     "setThinkingLatch",
     "getComputerUse",
     "setComputerUse",
+    "getNotificationLevels",
+    "setNotificationLevel",
     "claimSeatActions",
+    "readSessionMods",
     "onEvent",
     "onToolPermissionRequest",
     "onSeatAction",
@@ -2179,6 +2326,12 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "askClass",
     "classes",
     "sessionRow",
+    "probeReason",
+    "probeCause",
+    "feedbackCapable",
+    "requestedBy",
+    "frameReading",
+    "inputSource",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -2236,6 +2389,7 @@ export const TOOL_PERMISSION_DECISION_KEYS = [
     "answer",
     "updatedInput",
     "remember",
+    "feedback",
 ];
 export const START_SESSION_OPTION_KEYS = ["model", "title", "cwd", "excludeTools", "engine"];
 export const SEAT_VALIDATOR_KEY_COVERAGE = {
@@ -2286,10 +2440,34 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "sessionRow",
                 why: "放宽方向的展示位(CC-699),判官在过境口 toolPermissionRequestAskBits(card, requestId):卡上「本会话放行」判官 standingRowsOf 的会话行同一前提 ∧ 本请求 requestId 的域带得走(live: / durable:),严格 true 才上座、永不铸 false;座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。消费端 `=== true` 才渲「本会话放行」,其余(缺席 / 坏形)一律不渲 —— 缺席是闭合失败,不是「没说就照渲」。不经过境口自铸座位请求的宿主拿不到这一位,座位卡就不给那一档。",
             },
+            {
+                key: "feedbackCapable",
+                why: "放宽方向的展示位(CC-585),判官在过境口 toolPermissionRequestAskBits(card, requestId):卡判官 answerCarriage(card) 答 model(卡带耐久待决行腿的正向事实 parkRow)∧ 本请求 requestId 的域恰是 durable:(只有 /decide 收放行反馈位),严格 true 才上座、永不铸 false;座位门不设第二判官,理由同 sessionRow(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。消费端 `=== true` 才渲「Yes + 告诉 agent 下一步」那一格输入,其余(缺席 / 坏形)一律不渲 —— 缺席是闭合失败。不经过境口自铸座位请求的宿主拿不到这一位,座位卡就不给那一格。",
+            },
             {
                 key: "ruleOffersAbsence",
                 why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
             },
+            {
+                key: "probeReason",
+                why: "展示位(CC-1316),权威窄读在过境口 toolPermissionRequestAskBits,与「为什么问」那一句的读口 askProbeReasonDetail 同一个读点(自有数据属性、取值器不执行;串且去两端空白后非空才在场,原文字节);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形读成缺席 ⇒ 卡上不显示这一句,不改决断;缺席不是「没有原因」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "probeCause",
+                why: "展示位(CC-1316),与 probeReason 同一对、同一个读点;载体层判(自有数据属性、非 null 非数组对象)才在场,同一引用原样搬运,内部成员不校(成员的窄读归 askProbeReasonDetail / probeCauseRowsOf);座位门不设第二判官,理由同 probeReason。坏形读成缺席 ⇒ 不显示因由行,不改决断。两位按键隔离:一位读不出不连坐另一位。",
+            },
+            {
+                key: "requestedBy",
+                why: "展示位(CC-1341),权威窄读在过境口 toolPermissionRequestAskBits,读点是卡口的唯一载体级读口 approvalRequestedByOf(载体顶层的自有数据属性、取值器不执行;kind 恰 extension 且 name 非空串才在场,出冻结的新铸副本);原始耐久待决行不读(上游不在行上铸这一位);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形读成缺席 ⇒ 卡上不显示发起者行,不改决断;缺席不是「模型发起」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "frameReading",
+                why: "展示位(CC-1345),权威窄读在过境口 toolPermissionRequestAskBits,读点是包内唯一读口 cardPayloadReadingOf(卡上 cardPayloadUnreadable 严格 true ∧ cardPayloadUnreadableWhy 是判因闭集三词之一才在场;卡面通用卡第一行按因选句同读它);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。表外词 / 游离判因词 / 判因未知读成缺席 ⇒ 卡上回落不分因的原句,不改决断;缺席不是「帧读得出」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "inputSource",
+                why: "展示位(CC-1366),权威窄读在过境口 toolPermissionRequestAskBits,读点是包内唯一窄读 approvalInputSourceOf(载体顶层的自有数据属性、取值器不执行;闭集 record / stream 两词精确字节才在场);来源位本身只有一个铸点(卡入参读法的读数 → 位),过境口只抄卡上已铸的位、不拿 input 重判来源,原始帧 / 原始耐久待决行直交恒缺席;座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。表外词 / 近义词 / 非串读成缺席 ⇒ 壳按来源不明处置,不改决断;缺席不是 record。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
         ],
     },
     LocalSessionEvent: {
@@ -2421,6 +2599,11 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["ok"],
         unchecked: [],
     },
+    ToolPermissionAck: {
+        check: checkToolPermissionAck,
+        validated: ["ok", "settledElsewhere"],
+        unchecked: [],
+    },
     GetTranscriptResult: {
         check: checkGetTranscriptResult,
         validated: ["sessionId", "messages"],
@@ -2448,7 +2631,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2514,9 +2697,12 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["ComputerUseState", checkComputerUseState],
         ["SetComputerUseResult", checkSetComputerUseResult],
         ["SetComputerUseRequest", checkSetComputerUseRequest],
+        ["NotificationLevelsState", checkNotificationLevelsState],
+        ["SetNotificationLevelResult", checkSetNotificationLevelResult],
         ["SeatAction", checkSeatAction],
         ["EngineSwapAnswerOutcome", checkEngineSwapAnswerOutcome],
         ["SelfUpgradeOutcome", checkSelfUpgradeOutcome],
+        ["SessionModsResult", checkSessionModsResult],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2581,5 +2767,8 @@ const _seatContractPins = [
     true, true,
     true, true, true, true, true, true, true,
     true, true, true, true, true, true, true, true,
+    true, true, true, true, true,
+    true, true, true,
+    true, true, true, true,
 ];
 void _seatContractPins;

package/dist/sessionBackground.js

@@ -6,6 +6,7 @@ import { isLoopbackWireUrl } from './engineWireSdk.js';
 import { hostEnv } from './hostEnv.js';
 import { approvalDecisionHolds } from './hitl/approvalHolds.js';
 import { readRunTerminal } from './runTerminal.js';
+import { isReplayedTerminal } from './replayBody.js';
 import { appendOwnElement, ownDataField, putOwnKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export function projectSessionBackgroundable(caps) {
@@ -418,7 +419,7 @@ function observeFrame(rec, ev) {
         }
         else {
             rec.phase = 'ended-unstarted';
-            rec.replay = type === 'done' && frameSlot(ev, 'replay') === true;
+            rec.replay = type === 'done' && isReplayedTerminal(ev);
         }
         return;
     }

package/dist/sessionBackgroundHandoff.js

@@ -4,6 +4,7 @@ import { REATTACH_WINDOW_MS, reattachBackoffMs } from './reattachWindow.js';
 import { terminalEventFromRunRow } from './headlessReconnectWire.js';
 import { RUN_CANCELLED_CODE } from './runCancelContext.js';
 import { readRunTerminal } from './runTerminal.js';
+import { isReplayedTerminal } from './replayBody.js';
 import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { backgroundHandoffSentence, judgeHandoff, ownSlotOf, wireStateOf, } from './sessionBackground.js';
 export const BACKGROUND_HANDOFF_ABORT_REASON = 'background';
@@ -34,7 +35,7 @@ function executionSettlementOf(ev) {
                 return { runEnded: true, kind: 'cancelled', status: 'failed' };
             return { runEnded: true, kind: 'failed', status: 'failed', ...(code !== undefined ? { errorCode: code } : {}) };
         }
-        if (type !== 'done' || slot(ev, 'replay') === true)
+        if (type !== 'done' || isReplayedTerminal(ev))
             return undefined;
         const read = readRunTerminal(slot(ev, 'result'));
         if (read === null)

package/dist/sessionEngine.d.ts

@@ -153,5 +153,7 @@ export declare function sessionEngineBindingFor(input: SessionEngineBindingInput
 export declare function isSessionEngineView(v: {} | null | undefined): boolean;
 export declare function readSessionEngine(record: SessionMapRecord | undefined): SessionEngineReading;
 export declare function commitSessionEngine(store: SessionMapStorePort, session: SessionEngineSessionRef, request: SessionEngineCommitRequest): SessionEngineCommitResult;
+export type SessionEngineRepointResult = 'moved' | 'unaffected' | 'conflict' | 'unreadable' | 'store-failed' | 'request-invalid';
+export declare function repointSessionEngine(store: SessionMapStorePort, from: string, to: string): SessionEngineRepointResult;
 export declare function sessionDispatchRefusedFor(refusal: SessionDispatchRefusal): SessionDispatchRefused;
 export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;

package/dist/sessionEngine.js

@@ -377,6 +377,117 @@ function methodOf(o, key) {
         return undefined;
     }
 }
+function addressBindingOf(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const b = addressBinding(raw);
+    return b.ok && b.identityKind === 'address' ? b : undefined;
+}
+function enginesTableOf(record) {
+    const slot = slotReadOf(record, 'engines');
+    if (slot.presence === 'absent' || (slot.presence === 'present' && slot.value === undefined))
+        return 'absent';
+    return slot.presence === 'present' && isObj(slot.value) ? slot.value : 'unreadable';
+}
+function movedEngines(table, dropKey, putKey, entry) {
+    const out = {};
+    for (const k of Object.keys(table)) {
+        if (k === dropKey)
+            continue;
+        const slot = slotReadOf(table, k);
+        if (slot.presence !== 'present')
+            return undefined;
+        Object.defineProperty(out, k, { value: slot.value, writable: true, enumerable: true, configurable: true });
+    }
+    Object.defineProperty(out, putKey, { value: entry, writable: true, enumerable: true, configurable: true });
+    return out;
+}
+function repointStep(prior, from, to, fromNs, toNs, now) {
+    try {
+        const reading = readSessionEngine(prior);
+        if (reading.kind === 'none')
+            return { result: 'unaffected' };
+        if (reading.kind === 'unresolved' || prior === undefined)
+            return { result: 'unreadable' };
+        const table = enginesTableOf(prior);
+        if (reading.kind === 'bound') {
+            const id = reading.binding.identity;
+            if (id.identityKind !== 'address' || id.key !== from.key)
+                return { result: 'unaffected' };
+            if (table === 'absent' || table === 'unreadable')
+                return { result: 'unreadable' };
+            if (Object.hasOwn(table, to.key))
+                return { result: 'conflict' };
+            const entry = slotReadOf(table, from.key);
+            if (entry.presence !== 'present' || !isObj(entry.value))
+                return { result: 'unreadable' };
+            const engines = movedEngines(table, from.key, to.key, entry.value);
+            if (engines === undefined)
+                return { result: 'unreadable' };
+            return {
+                result: 'moved',
+                next: { ...prior, boundEngine: snapshotOf({ kind: reading.binding.kind, identity: to }), engines, updatedAt: now },
+            };
+        }
+        if (table === 'absent')
+            return { result: 'unaffected' };
+        if (table === 'unreadable')
+            return { result: 'unreadable' };
+        if (!Object.hasOwn(table, fromNs))
+            return { result: 'unaffected' };
+        if (Object.hasOwn(table, toNs))
+            return { result: 'conflict' };
+        const entry = slotReadOf(table, fromNs);
+        if (entry.presence !== 'present' || !isObj(entry.value))
+            return { result: 'unreadable' };
+        const engines = movedEngines(table, fromNs, toNs, entry.value);
+        if (engines === undefined)
+            return { result: 'unreadable' };
+        return { result: 'moved', next: { ...prior, engines, updatedAt: now } };
+    }
+    catch {
+        return { result: 'unreadable' };
+    }
+}
+export function repointSessionEngine(store, from, to) {
+    let readMergeWrite;
+    let fromB;
+    let toB;
+    try {
+        if (!isObj(store))
+            return 'request-invalid';
+        const rmw = methodOf(store, 'readMergeWrite');
+        if (rmw === undefined)
+            return 'request-invalid';
+        readMergeWrite = (build) => rmw.call(store, build);
+        const f = addressBindingOf(from);
+        const t = addressBindingOf(to);
+        if (f === undefined || t === undefined || f.key === t.key)
+            return 'request-invalid';
+        fromB = f;
+        toB = t;
+    }
+    catch {
+        return 'request-invalid';
+    }
+    const fromNs = engineNamespaceKeyFor(from);
+    const toNs = engineNamespaceKeyFor(to);
+    let step;
+    try {
+        const returned = readMergeWrite((prior) => {
+            step = repointStep(prior, fromB, toB, fromNs, toNs, new Date().toISOString());
+            return Object.hasOwn(step, 'next') ? step.next : undefined;
+        });
+        if (step === undefined)
+            return 'store-failed';
+        if (Object.hasOwn(step, 'next') && !isObj(returned))
+            return 'store-failed';
+        return step.result;
+    }
+    catch {
+        return 'store-failed';
+    }
+}
 const REFUSAL_KEYS = {
     'not-wired': 'session.engine.dispatch.notWired',
     'scope-mismatch': 'session.engine.dispatch.scopeMismatch',

package/dist/sessionMemoryStatus.d.ts

@@ -9,7 +9,8 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
-export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId' | 'memorySync'> & {
+export type MemoryStatusFacts = SessionMemoryStatus & {
+    autoConsolidationArmed?: SessionMemoryStatusResponse['autoConsolidationArmed'];
     readonly memorySync?: MemorySyncFacts;
 };
 export interface MemorySyncFacts {

package/dist/sessionSyncFileHistory.d.ts

@@ -1,4 +1,8 @@
+import type { RowBitsOutcome } from '@sema-agent/sdk';
+import { type UiLanguage } from './env/uiLanguage.js';
 export declare const FILE_HISTORY_SKIPPED_NOTICE: string;
 export declare function fileHistorySyncNotice(result: unknown): string | undefined;
 export declare function fileHistorySyncNoticeIdentity(result: unknown): string | undefined;
 export declare function isFileHistoryBlobMissing(err: unknown): boolean;
+export type PushRowBitsWord = RowBitsOutcome | 'writer_side';
+export declare function sessionPushRowBitsNotice(result: {} | null | undefined, lang?: UiLanguage | (string & {})): string | undefined;

package/dist/sessionSyncFileHistory.js

@@ -1,6 +1,8 @@
 import { NOT_FOUND_BLOB } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { readThrownSlot } from './wireFailureShape.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const FILE_HISTORY_SKIPPED_NOTICE = 'File history was not copied: only the conversation was synced, because one of the two engines does not confirm that it can ' +
     'transfer file history (the record /rewind uses to restore files). Syncing this session again will not add it until ' +
     'the conversation has new turns and both engines can transfer file history.';
@@ -64,3 +66,29 @@ export function isFileHistoryBlobMissing(err) {
         return false;
     }
 }
+function pushRowBitsSpeaks(word) {
+    switch (word) {
+        case 'writer_side':
+            return true;
+        case 'mirrored':
+        case 'unsupported':
+        case 'absent':
+            return false;
+    }
+}
+function isPushRowBitsWord(v) {
+    return v === 'mirrored' || v === 'unsupported' || v === 'absent' || v === 'writer_side';
+}
+export function sessionPushRowBitsNotice(result, lang) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    try {
+        const word = getOwn(result, 'rowBits');
+        if (typeof word !== 'string' || !isPushRowBitsWord(word) || !pushRowBitsSpeaks(word))
+            return undefined;
+        return renderMessage(msg('session.sync.pushRowBitsWriterSide'), isUiLanguage(lang) ? lang : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sseIdleTriage.d.ts

@@ -1,4 +1,5 @@
 import { type EnvLike } from './hostEnv.js';
+import { SDK_STREAM_ENDED_REASONS } from './generated/sdkFactTables.js';
 import { type RunNotFollowed } from './runFollow.js';
 export declare const SSE_HEARTBEAT_GRACE_ENV = "SEMA_SSE_HEARTBEAT_GRACE_MS";
 export declare const SSE_GRACE_MIN_MS = 5000;
@@ -8,8 +9,19 @@ export declare function resolveSseHeartbeatGraceMs(env?: EnvLike): number | unde
 export declare function markEngineAliveIdle<E extends Error>(err: E): E;
 export declare function engineAliveIdleElapsedMs(err: unknown): number | undefined;
 export declare function isSseIdleError(err: unknown): boolean;
+export type StreamEndedReasonWord = (typeof SDK_STREAM_ENDED_REASONS)[number];
+export type StreamEndedUnknownWhy = 'not_this_class' | 'reason_unreadable' | 'reason_unrecognized';
+export type StreamEndedReading = {
+    readonly kind: 'read';
+    readonly reason: StreamEndedReasonWord;
+    readonly cause?: {} | null;
+} | {
+    readonly kind: 'unknown';
+    readonly why: StreamEndedUnknownWhy;
+};
+export declare function streamEndedReasonOf(err: {} | null | undefined): StreamEndedReading;
 export declare function isStreamEndedWithoutTerminalError(err: {} | null | undefined): boolean;
-export declare function probeEngineAlive(baseUrl: string, timeoutMs?: number): Promise<boolean>;
+export declare function probeEngineAlive(baseUrl: string): Promise<boolean>;
 export declare function diagnoseSseIdleTear<T>(inner: AsyncGenerator<T>, baseUrl: string, signal?: AbortSignal): AsyncGenerator<T>;
 export declare function engineAliveIdleContent(elapsedMs: number, detach?: {
     detached: true;

package/dist/sseIdleTriage.js

@@ -1,6 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, StreamEndedWithoutTerminalError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
-import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
+import { THROWN_SLOT_UNREADABLE, readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
+import { SDK_STREAM_ENDED_REASONS } from './generated/sdkFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { runNotFollowedNoticeRef } from './runFollow.js';
 export const SSE_HEARTBEAT_GRACE_ENV = 'SEMA_SSE_HEARTBEAT_GRACE_MS';
@@ -38,13 +39,30 @@ export function isSseIdleError(err) {
         return true;
     return readThrownSlot(err, 'name', 'data') === 'SseIdleError';
 }
+function streamEndedUnknown(why) {
+    return Object.freeze({ kind: 'unknown', why });
+}
+function isStreamEndedClass(err) {
+    return thrownIsInstanceOf(err, StreamEndedWithoutTerminalError) || readThrownSlot(err, 'name', 'data') === 'StreamEndedWithoutTerminalError';
+}
+export function streamEndedReasonOf(err) {
+    if (!isStreamEndedClass(err))
+        return streamEndedUnknown('not_this_class');
+    const raw = readThrownSlot(err, 'reason', 'data');
+    if (raw === THROWN_SLOT_UNREADABLE || raw === undefined)
+        return streamEndedUnknown('reason_unreadable');
+    const reason = SDK_STREAM_ENDED_REASONS.find((w) => w === raw);
+    if (reason === undefined)
+        return streamEndedUnknown('reason_unrecognized');
+    const cause = readThrownSlot(err, 'cause', 'data');
+    return Object.freeze(cause === THROWN_SLOT_UNREADABLE || cause === undefined ? { kind: 'read', reason } : { kind: 'read', reason, cause: cause });
+}
 export function isStreamEndedWithoutTerminalError(err) {
-    if (thrownIsInstanceOf(err, StreamEndedWithoutTerminalError))
-        return true;
-    return readThrownSlot(err, 'name', 'data') === 'StreamEndedWithoutTerminalError';
+    const reading = streamEndedReasonOf(err);
+    return reading.kind !== 'unknown' || reading.why !== 'not_this_class';
 }
-export async function probeEngineAlive(baseUrl, timeoutMs = 2_000) {
-    return (await sdkProbeHealth(baseUrl, timeoutMs)).alive;
+export async function probeEngineAlive(baseUrl) {
+    return (await sdkProbeHealth(baseUrl)).alive;
 }
 export async function* diagnoseSseIdleTear(inner, baseUrl, signal) {
     try {