@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/sessionCostReading.d.ts

@@ -0,0 +1,70 @@
+import { type AccountRowView } from './coreValuePorts.js';
+export declare const SESSION_COST_BOUNDS: readonly ["known", "lower_bound", "unknown"];
+export type SessionCostBound = (typeof SESSION_COST_BOUNDS)[number];
+export declare const SESSION_COST_HISTORY_BASES: readonly ["complete", "partial", "unread"];
+export type SessionCostHistoryBasis = (typeof SESSION_COST_HISTORY_BASES)[number];
+export declare const SESSION_COST_LOWER_BOUND_CAUSES: readonly ["usage_missing", "history_partial", "history_unread"];
+export type SessionCostLowerBoundCause = (typeof SESSION_COST_LOWER_BOUND_CAUSES)[number];
+export declare const SESSION_COST_UNKNOWN_WHYS: readonly ["port_absent", "lines_malformed", "fold_unreadable", "line_cost_unknown", "zero_lower_bound", "pending_run_cost"];
+export type SessionCostUnknownWhy = (typeof SESSION_COST_UNKNOWN_WHYS)[number];
+export interface SessionCostKnownFigure {
+    readonly bound: 'known';
+    readonly micro: number;
+    readonly usd: number;
+    readonly mark: '';
+}
+export interface SessionCostLowerBoundFigure {
+    readonly bound: 'lower_bound';
+    readonly micro: number;
+    readonly usd: number;
+    readonly mark: '+';
+    readonly causes: readonly SessionCostLowerBoundCause[];
+}
+export interface SessionCostUnknownFigure {
+    readonly bound: 'unknown';
+    readonly why: SessionCostUnknownWhy;
+    readonly mark: '';
+}
+export type SessionCostFigure = SessionCostKnownFigure | SessionCostLowerBoundFigure | SessionCostUnknownFigure;
+export interface SessionCostReading {
+    readonly frame: SessionCostFigure;
+    readonly cumulative: SessionCostFigure;
+    readonly sideQuery: SessionCostFigure;
+}
+export type SessionCostLine = AccountRowView | {
+    readonly account: AccountRowView;
+};
+export interface SessionCostInput {
+    readonly lines: Iterable<SessionCostLine>;
+    readonly history: SessionCostHistoryBasis;
+    readonly pendingTurns?: number;
+}
+export declare function sessionCostReadingOf(input: SessionCostInput): SessionCostReading;
+export interface SessionCostForkSource {
+    readonly lines: Iterable<SessionCostLine>;
+    readonly history: SessionCostHistoryBasis;
+}
+export interface SessionCostSeed {
+    readonly lines: readonly AccountRowView[];
+    readonly history: 'partial' | 'unread';
+    readonly reading: SessionCostReading;
+}
+export declare function forkSeedCostOf(source: SessionCostForkSource): SessionCostSeed;
+export declare const RUN_COST_SETTLEMENTS: readonly ["awaiting", "priced", "unpriced", "lost"];
+export type RunCostSettlement = (typeof RUN_COST_SETTLEMENTS)[number];
+export declare const TURN_COST_UNKNOWN_WHYS: readonly ["usage_missing", "unpriced", "absent", "malformed", "pending_terminal", "terminal_lost"];
+export type TurnCostUnknownWhy = (typeof TURN_COST_UNKNOWN_WHYS)[number];
+export interface TurnCostUsageView {
+    readonly costMicroUsd?: number;
+    readonly costUSD?: number;
+    readonly _sema_cost_absent?: true;
+    readonly usageMissing?: true;
+}
+export type TurnCostReading = {
+    readonly bound: 'known';
+    readonly usd: number;
+} | {
+    readonly bound: 'unknown';
+    readonly why: TurnCostUnknownWhy;
+};
+export declare function turnCostReadingOf(usage: TurnCostUsageView, settlement: RunCostSettlement): TurnCostReading;

package/dist/sessionCostReading.js

@@ -0,0 +1,150 @@
+import { foldAccount } from './coreValuePorts.js';
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
+export const SESSION_COST_BOUNDS = Object.freeze(['known', 'lower_bound', 'unknown']);
+export const SESSION_COST_HISTORY_BASES = Object.freeze(['complete', 'partial', 'unread']);
+export const SESSION_COST_LOWER_BOUND_CAUSES = Object.freeze(['usage_missing', 'history_partial', 'history_unread']);
+export const SESSION_COST_UNKNOWN_WHYS = Object.freeze(['port_absent', 'lines_malformed', 'fold_unreadable', 'line_cost_unknown', 'zero_lower_bound', 'pending_run_cost']);
+const MICRO_PER_USD = 1_000_000;
+function unknownFigure(why) {
+    return { bound: 'unknown', why, mark: '' };
+}
+function allUnknown(why) {
+    return { frame: unknownFigure(why), cumulative: unknownFigure(why), sideQuery: unknownFigure(why) };
+}
+function unwrapLines(lines) {
+    if (typeof lines !== 'object' || lines === null || typeof lines[Symbol.iterator] !== 'function')
+        return undefined;
+    const rows = [];
+    for (const line of lines) {
+        if (typeof line !== 'object' || line === null)
+            return undefined;
+        const origin = readOwnDataValue(line, 'origin');
+        const account = readOwnDataValue(line, 'account');
+        if (origin !== undefined && account !== undefined)
+            return undefined;
+        if (origin !== undefined) {
+            appendOwnElement(rows, line);
+        }
+        else if (typeof account === 'object' && account !== null) {
+            appendOwnElement(rows, account);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return rows;
+}
+function figureOf(total, history, pending) {
+    if (typeof total !== 'object' || total === null)
+        return unknownFigure('fold_unreadable');
+    const costSlot = Object.getOwnPropertyDescriptor(total, 'costMicroUsd');
+    if (costSlot === undefined)
+        return unknownFigure('line_cost_unknown');
+    const micro = Object.hasOwn(costSlot, 'value') ? costSlot.value : undefined;
+    if (typeof micro !== 'number' || !Number.isSafeInteger(micro) || micro < 0)
+        return unknownFigure('fold_unreadable');
+    const causes = [];
+    if (readOwnDataValue(total, 'usageMissing') === true)
+        appendOwnElement(causes, 'usage_missing');
+    if (history === 'partial')
+        appendOwnElement(causes, 'history_partial');
+    else if (history !== 'complete')
+        appendOwnElement(causes, 'history_unread');
+    if (causes.length > 0)
+        return micro === 0 ? unknownFigure('zero_lower_bound') : { bound: 'lower_bound', micro, usd: micro / MICRO_PER_USD, mark: '+', causes };
+    if (micro === 0 && pending > 0)
+        return unknownFigure('pending_run_cost');
+    return { bound: 'known', micro, usd: micro / MICRO_PER_USD, mark: '' };
+}
+export function sessionCostReadingOf(input) {
+    try {
+        let rows;
+        let account;
+        try {
+            rows = unwrapLines(readOwnDataValue(input, 'lines'));
+            if (rows === undefined)
+                return allUnknown('lines_malformed');
+            account = foldAccount(rows);
+        }
+        catch {
+            return allUnknown('lines_malformed');
+        }
+        if (account === undefined)
+            return allUnknown('port_absent');
+        const byOrigin = readOwnDataValue(account, 'byOrigin');
+        if (typeof byOrigin !== 'object' || byOrigin === null)
+            return allUnknown('fold_unreadable');
+        const history = readOwnDataValue(input, 'history');
+        const pendingRaw = readOwnDataValue(input, 'pendingTurns');
+        const pending = pendingRaw === undefined ? 0 : Number.isSafeInteger(pendingRaw) && pendingRaw >= 0 ? pendingRaw : Number.POSITIVE_INFINITY;
+        return {
+            frame: figureOf(readOwnDataValue(byOrigin, 'run'), history, pending),
+            cumulative: figureOf(account, history, pending),
+            sideQuery: figureOf(readOwnDataValue(byOrigin, 'side_query'), history, 0),
+        };
+    }
+    catch {
+        return allUnknown('fold_unreadable');
+    }
+}
+export function forkSeedCostOf(source) {
+    const empty = () => ({ lines: [], history: 'unread', reading: allUnknown('lines_malformed') });
+    try {
+        const rows = unwrapLines(readOwnDataValue(source, 'lines'));
+        if (rows === undefined)
+            return empty();
+        const sourceHistory = readOwnDataValue(source, 'history');
+        const history = sourceHistory === 'complete' || sourceHistory === 'partial' ? 'partial' : 'unread';
+        const reading = sessionCostReadingOf({ lines: rows, history });
+        if (reading.cumulative.bound === 'unknown' && reading.cumulative.why === 'lines_malformed')
+            return empty();
+        return { lines: rows, history, reading };
+    }
+    catch {
+        return empty();
+    }
+}
+export const RUN_COST_SETTLEMENTS = Object.freeze(['awaiting', 'priced', 'unpriced', 'lost']);
+export const TURN_COST_UNKNOWN_WHYS = Object.freeze(['usage_missing', 'unpriced', 'absent', 'malformed', 'pending_terminal', 'terminal_lost']);
+function turnUnknown(why) {
+    return { bound: 'unknown', why };
+}
+export function turnCostReadingOf(usage, settlement) {
+    try {
+        if (typeof usage !== 'object' || usage === null)
+            return turnUnknown('malformed');
+        if (readOwnDataValue(usage, 'usageMissing') === true)
+            return turnUnknown('usage_missing');
+        const costAbsent = readOwnDataValue(usage, '_sema_cost_absent') === true;
+        const micro = readOwnDataValue(usage, 'costMicroUsd');
+        const microIsNumber = typeof micro === 'number';
+        if (costAbsent && !(microIsNumber && Number.isFinite(micro) && micro > 0))
+            return turnUnknown('unpriced');
+        let usd;
+        if (micro !== undefined) {
+            if (!microIsNumber || !Number.isFinite(micro) || micro < 0)
+                return turnUnknown('malformed');
+            usd = micro / MICRO_PER_USD;
+        }
+        else {
+            const mirror = readOwnDataValue(usage, 'costUSD');
+            if (mirror === undefined)
+                return turnUnknown('absent');
+            if (typeof mirror !== 'number' || !Number.isFinite(mirror) || mirror < 0)
+                return turnUnknown('malformed');
+            usd = mirror;
+        }
+        if (usd > 0)
+            return { bound: 'known', usd };
+        if (settlement === 'priced')
+            return { bound: 'known', usd: 0 };
+        if (settlement === 'unpriced')
+            return turnUnknown('unpriced');
+        if (settlement === 'lost')
+            return turnUnknown('terminal_lost');
+        return turnUnknown('pending_terminal');
+    }
+    catch {
+        return turnUnknown('malformed');
+    }
+}

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/sessionHooksRoster.d.ts

@@ -0,0 +1,4 @@
+import { type HooksWirePlan } from './pluginHooksWire.js';
+import type { SessionHooksRoster } from './seatContract.js';
+import type { DeviceUnreadable } from './deviceRebind.js';
+export declare function sessionHooksRosterOf(plan: HooksWirePlan | null | undefined): SessionHooksRoster | DeviceUnreadable;

package/dist/sessionHooksRoster.js

@@ -0,0 +1,158 @@
+import { HOOK_ENTRY_TYPE_WORDS, PLUGIN_HOOK_DISPOSITIONS, PLUGIN_HOOK_EXCLUSION_REASONS, PLUGIN_HOOK_REASONS, SETTINGS_HOOK_DROP_REASONS, hooksWirePlanShapeOf, isEngineFiredHookEvent, } from './pluginHooksWire.js';
+import { HTTP_POLICY_DROP_REASONS } from './httpHookPolicy.js';
+import { HOOK_SETTINGS_SOURCE_TEXT } from './settingsHooksSalvage.js';
+import { SETTINGS_HOOK_EVENTS, SETTINGS_HOOKS_DROPPED_PIECE_CODES, SETTINGS_HOOKS_REJECTION_CODES } from './generated/settingsSchemaFns.js';
+import { appendOwnElement, ownDataField, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const inWords = (words, v) => typeof v === 'string' && words.includes(v);
+const isSource = (v) => typeof v === 'string' && Object.hasOwn(HOOK_SETTINGS_SOURCE_TEXT, v);
+const isIndex = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+const isObject = (v) => typeof v === 'object' && v !== null;
+function ownRowsOf(plan, key) {
+    const v = readOwnDataValue(plan, key);
+    if (!Array.isArray(v))
+        return undefined;
+    const n = ownDataField(v, 'length');
+    const out = [];
+    if (typeof n !== 'number')
+        return out;
+    for (let i = 0; i < n; i += 1)
+        appendOwnElement(out, readOwnDataValue(v, String(i)));
+    return out;
+}
+const field = (row, key) => (isObject(row) ? readOwnDataValue(row, key) : undefined);
+function coordOf(row) {
+    const source = field(row, 'source');
+    const event = field(row, 'event');
+    const groupIndex = field(row, 'groupIndex');
+    const hookIndex = field(row, 'hookIndex');
+    const type = field(row, 'type');
+    if (!isSource(source) || !inWords(SETTINGS_HOOK_EVENTS, event) || !isIndex(groupIndex) || !isIndex(hookIndex))
+        return undefined;
+    let typed = {};
+    if (type !== undefined) {
+        if (!inWords(HOOK_ENTRY_TYPE_WORDS, type))
+            return undefined;
+        typed = { type };
+    }
+    return { source, event, groupIndex, hookIndex, ...typed };
+}
+function droppedStatusOf(event, notRun) {
+    if (notRun)
+        return 'not_run';
+    return isEngineFiredHookEvent(event) ? 'shell' : undefined;
+}
+const rosterUnreadable = () => Object.freeze({ kind: 'unreadable', why: renderMessage(msg('config.hooks.roster.unreadable')) });
+export function sessionHooksRosterOf(plan) {
+    try {
+        if (hooksWirePlanShapeOf(plan) !== 'plan' || !isObject(plan))
+            return rosterUnreadable();
+        let unlisted = 0;
+        const rows = [];
+        const addRow = (row) => {
+            if (row === undefined)
+                unlisted += 1;
+            else
+                appendOwnElement(rows, Object.freeze(row));
+        };
+        for (const r of ownRowsOf(plan, 'settingsVerdicts') ?? []) {
+            const at = coordOf(r);
+            const disposition = field(r, 'disposition');
+            const reason = field(r, 'reason');
+            addRow(at !== undefined && inWords(PLUGIN_HOOK_DISPOSITIONS, disposition) && inWords(PLUGIN_HOOK_REASONS, reason) ? { ...at, status: disposition, reason } : undefined);
+        }
+        for (const r of ownRowsOf(plan, 'settingsDropped') ?? []) {
+            const at = coordOf(r);
+            const reason = field(r, 'reason');
+            const notRun = field(r, 'notRun');
+            const status = at !== undefined && typeof notRun === 'boolean' ? droppedStatusOf(at.event, notRun) : undefined;
+            addRow(at !== undefined && status !== undefined && inWords(SETTINGS_HOOK_DROP_REASONS, reason) ? { ...at, status, reason } : undefined);
+        }
+        for (const r of ownRowsOf(plan, 'settingsExcluded') ?? []) {
+            const at = coordOf(r);
+            const reason = field(r, 'reason');
+            addRow(at !== undefined && inWords(PLUGIN_HOOK_EXCLUSION_REASONS, reason) ? { ...at, status: 'not_run', reason } : undefined);
+        }
+        const layers = [];
+        for (const r of ownRowsOf(plan, 'settingsSalvage') ?? []) {
+            const layer = salvageLayerOf(r);
+            if (layer === undefined)
+                unlisted += 1;
+            else
+                appendOwnElement(layers, layer);
+        }
+        for (const r of ownRowsOf(plan, 'settingsWithheld') ?? []) {
+            const source = field(r, 'source');
+            if (isSource(source) && field(r, 'cause') === 'trust_withheld')
+                appendOwnElement(layers, Object.freeze({ source, state: 'trust_withheld' }));
+            else
+                unlisted += 1;
+        }
+        const http = [];
+        for (const r of ownRowsOf(plan, 'httpPolicyDrops') ?? []) {
+            const source = field(r, 'layer');
+            const event = field(r, 'event');
+            const reason = field(r, 'reason');
+            if (isSource(source) && inWords(SETTINGS_HOOK_EVENTS, event) && inWords(HTTP_POLICY_DROP_REASONS, reason)) {
+                appendOwnElement(http, Object.freeze({ source, event, reason }));
+            }
+            else
+                unlisted += 1;
+        }
+        const closedByRaw = readOwnDataValue(plan, 'closedBy');
+        const closedBy = closedByRaw === 'workspace_untrusted' || closedByRaw === 'governance_unreadable' || closedByRaw === 'policy_disable_all' ? closedByRaw : null;
+        const sourcesRaw = ownRowsOf(plan, 'settingsSources');
+        let sources;
+        if (sourcesRaw !== undefined) {
+            sources = [];
+            for (const s of sourcesRaw) {
+                if (isSource(s))
+                    appendOwnElement(sources, s);
+                else
+                    unlisted += 1;
+            }
+        }
+        return Object.freeze({
+            closedBy,
+            ...(sources === undefined ? {} : { sources: Object.freeze(sources) }),
+            rows: Object.freeze(rows),
+            layers: Object.freeze(layers),
+            http: Object.freeze(http),
+            unlisted,
+        });
+    }
+    catch {
+        return rosterUnreadable();
+    }
+}
+function salvageLayerOf(r) {
+    const source = field(r, 'source');
+    const outcome = field(r, 'outcome');
+    if (!isSource(source))
+        return undefined;
+    if (outcome === 'loaded-partial') {
+        const codes = codesOf(r, 'dropped', SETTINGS_HOOKS_DROPPED_PIECE_CODES);
+        return codes === undefined ? undefined : Object.freeze({ source, state: 'loaded-partial', codes });
+    }
+    if (outcome === 'rejected') {
+        const codes = codesOf(r, 'rejections', SETTINGS_HOOKS_REJECTION_CODES);
+        return codes === undefined ? undefined : Object.freeze({ source, state: 'rejected', codes });
+    }
+    return undefined;
+}
+function codesOf(r, key, words) {
+    if (!isObject(r))
+        return undefined;
+    const pieces = ownRowsOf(r, key);
+    if (pieces === undefined || pieces.length === 0)
+        return undefined;
+    const out = [];
+    for (const p of pieces) {
+        const code = field(p, 'code');
+        if (!inWords(words, code))
+            return undefined;
+        if (!out.includes(code))
+            appendOwnElement(out, code);
+    }
+    return Object.freeze(out);
+}

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

@@ -1,7 +1,7 @@
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 import { isUiLanguage } from './env/uiLanguage.js';
-import { msg, renderMessage } from './i18n/translate.js';
+import { msg, renderLanguageOf, renderMessage } from './i18n/translate.js';
 export const MEMORY_SYNC_WAY_OUT_DELETE_CURSOR = 'delete_cursor';
 const MEMORY_SYNC_PARKED_READ_MAX = 256;
 export function classifyMemoryStatusFailure(e) {
@@ -182,7 +182,7 @@ export function memorySyncParkingNotice(reading, lang) {
             return renderMessage(msg(count === 1 ? 'session.memorySync.parkedUnnamed.one' : 'session.memorySync.parkedUnnamed.other', { count, wayOut }), isUiLanguage(lang) ? lang : undefined);
         if (count === 1)
             return renderMessage(msg('session.memorySync.parked.one', { scope: scopes[0] ?? '', wayOut }), isUiLanguage(lang) ? lang : undefined);
-        return renderMessage(msg('session.memorySync.parked.other', { count, scopes: scopes.join(lang === 'zh' ? '、' : ', '), wayOut }), isUiLanguage(lang) ? lang : undefined);
+        return renderMessage(msg('session.memorySync.parked.other', { count, scopes: scopes.join(renderLanguageOf(lang) === 'zh' ? '、' : ', '), wayOut }), isUiLanguage(lang) ? lang : undefined);
     }
     catch {
         return undefined;

package/dist/sessionReadRedaction.d.ts

@@ -0,0 +1,7 @@
+export type SessionReadRedactionLeavesReading = {
+    readonly kind: 'redacted';
+    readonly leaves?: readonly string[];
+} | {
+    readonly kind: 'unconfirmed';
+};
+export declare function sessionReadRedactionOf(caps: object | null | undefined): SessionReadRedactionLeavesReading;

package/dist/sessionReadRedaction.js

@@ -0,0 +1,26 @@
+import { appendOwnElement, ownDataField } from './ownKey.js';
+export function sessionReadRedactionOf(caps) {
+    try {
+        if (typeof caps !== 'object' || caps === null || Array.isArray(caps))
+            return Object.freeze({ kind: 'unconfirmed' });
+        const bit = ownDataField(caps, 'sessionReadRedaction');
+        if (bit === true)
+            return Object.freeze({ kind: 'redacted' });
+        if (!Array.isArray(bit))
+            return Object.freeze({ kind: 'unconfirmed' });
+        const length = ownDataField(bit, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 1)
+            return Object.freeze({ kind: 'unconfirmed' });
+        const leaves = [];
+        for (let i = 0; i < length; i++) {
+            const leaf = ownDataField(bit, String(i));
+            if (typeof leaf !== 'string' || leaf === '')
+                return Object.freeze({ kind: 'unconfirmed' });
+            appendOwnElement(leaves, leaf);
+        }
+        return Object.freeze({ kind: 'redacted', leaves: Object.freeze(leaves) });
+    }
+    catch {
+        return Object.freeze({ kind: 'unconfirmed' });
+    }
+}

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,28 @@ export function isFileHistoryBlobMissing(err) {
         return false;
     }
 }
+const PUSH_ROW_BITS_SPEAKS = Object.freeze({
+    mirrored: false,
+    unsupported: false,
+    absent: false,
+    writer_side: true,
+});
+function pushRowBitsSpeaks(word) {
+    return PUSH_ROW_BITS_SPEAKS[word];
+}
+function isPushRowBitsWord(v) {
+    return Object.hasOwn(PUSH_ROW_BITS_SPEAKS, v);
+}
+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/settingsHooksSalvage.js

@@ -1,3 +1,4 @@
+import { requestCoordinateText } from './requestCoordinate.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { appendOwnElement } from './ownKey.js';
@@ -162,7 +163,7 @@ export function hooksEntryUnreadKeys(event, entry, notRead) {
     return unreadOf(raw, carried, own(carried, 'type') === 'command' ? READER_COMMAND_WIRE_KEYS : [], notRead);
 }
 export function hooksKeyCoordinateText(path) {
-    return `settings.${path.map(labelOf).join('.')}`;
+    return requestCoordinateText('settings', path, (seg) => labelOf(seg));
 }
 export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
     policySettings: 'Managed settings',