@sema-agent/client-core 0.110.0 → 0.112.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/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/sessionIdSegment.d.ts

@@ -1,3 +1,4 @@
+export declare function isDotSegment(seg: string): boolean;
 export declare function isSessionIdPathSegment(id: unknown): id is string;
 export type SessionIdRefusalWhy = 'not_string' | 'bad_shape' | 'bad_version' | 'bad_variant';
 export interface SessionIdRefusal {

package/dist/sessionIdSegment.js

@@ -1,5 +1,8 @@
+export function isDotSegment(seg) {
+    return seg === '.' || seg === '..';
+}
 export function isSessionIdPathSegment(id) {
-    if (typeof id !== 'string' || id === '' || id === '.' || id === '..')
+    if (typeof id !== 'string' || id === '' || isDotSegment(id))
         return false;
     try {
         encodeURIComponent(id);

package/dist/sessionMemoryErase.js

@@ -2,6 +2,7 @@ import { isLoopbackWireUrl, resolveWireAuth } from './engineWireSdk.js';
 import { INJECTED_WIRE_SETTLE_MS, connectionLostDetail, noAnswerDetailFrom, noAnswerKindOf, provablyNotSent, settleInjected } from './engineWireFor.js';
 import { memoryEraseReplayPosture, readMemoryEraseReceipt } from './memoryEntriesWire.js';
 import { normalizeWirePrincipal } from './principalWire.js';
+import { MEMORY_CONTROL_PLANE_CORRUPT } from './engineErrorCodes.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const PRINCIPAL_HEADER = 'x-agent-principal';
@@ -359,7 +360,7 @@ function bandOfCode(code) {
             return { unconfirmed: 'store_link_outside' };
         case 'memory.scope_home_not_directory':
             return { unconfirmed: 'store_home_not_directory' };
-        case 'internal.memory_control_plane_corrupt':
+        case MEMORY_CONTROL_PLANE_CORRUPT:
             return { unconfirmed: 'control_plane_corrupt' };
         case 'internal.error':
             return { unconfirmed: 'engine_fault' };

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

@@ -66,18 +66,17 @@ 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) {
-    switch (word) {
-        case 'writer_side':
-            return true;
-        case 'mirrored':
-        case 'unsupported':
-        case 'absent':
-            return false;
-    }
+    return PUSH_ROW_BITS_SPEAKS[word];
 }
 function isPushRowBitsWord(v) {
-    return v === 'mirrored' || v === 'unsupported' || v === 'absent' || v === 'writer_side';
+    return Object.hasOwn(PUSH_ROW_BITS_SPEAKS, v);
 }
 export function sessionPushRowBitsNotice(result, lang) {
     if (result === null || typeof result !== 'object')

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',

package/dist/sha256Bytes.d.ts

@@ -0,0 +1 @@
+export declare function sha256BytesHex(msg: Uint8Array): string;

package/dist/sha256Bytes.js

@@ -0,0 +1,46 @@
+export function sha256BytesHex(msg) {
+    const k = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+    const len = msg.length;
+    const padded = new Uint8Array(((len + 8) >>> 6) * 64 + 64);
+    padded.set(msg);
+    padded[len] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(len / 0x20000000));
+    view.setUint32(padded.length - 4, (len << 3) >>> 0);
+    const w = new Array(64).fill(0);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < padded.length; off += 64) {
+        for (let t = 0; t < 16; t++)
+            w[t] = view.getUint32(off + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const x = w[t - 15] ?? 0;
+            const y = w[t - 2] ?? 0;
+            const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
+            const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10);
+            w[t] = ((w[t - 16] ?? 0) + s0 + (w[t - 7] ?? 0) + s1) | 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let t = 0; t < 64; t++) {
+            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + (k[t] ?? 0) + (w[t] ?? 0)) | 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        const next = [a, b, c, d, e, f, g, hh];
+        for (let i = 0; i < 8; i++)
+            h[i] = ((h[i] ?? 0) + (next[i] ?? 0)) | 0;
+    }
+    return h.map((x) => (x >>> 0).toString(16).padStart(8, '0')).join('');
+}

package/dist/skillOverrideChain.d.ts

@@ -0,0 +1,83 @@
+import type { SettingsDocument } from './host.js';
+export declare const SKILL_OVERRIDE_STATES: readonly ["on", "name-only", "user-invocable-only", "off"];
+export type SkillOverrideState = (typeof SKILL_OVERRIDE_STATES)[number];
+export declare const SKILL_ORIGINS: readonly ["skills", "synced", "commands", "mcp", "plugin", "builtin", "bundled"];
+export type SkillOrigin = (typeof SKILL_ORIGINS)[number];
+export declare const SKILL_OVERRIDE_LAYERS: readonly ["policySettings", "flagSettings", "localSettings", "projectSettings", "userSettings"];
+export type SkillOverrideLayer = (typeof SKILL_OVERRIDE_LAYERS)[number];
+type PlainLayer = 'localSettings' | 'projectSettings' | 'userSettings';
+export declare const SKILL_OVERRIDE_DECIDERS: readonly ["policySettings", "flagSettings", "localSettings", "projectSettings", "userSettings", "session", "default", "plugin", "builtin_clamp", "hidden_behind_plugin"];
+export type SkillOverrideDecider = (typeof SKILL_OVERRIDE_DECIDERS)[number];
+export declare const SKILL_OVERRIDE_LOCK_SOURCES: readonly ["policy", "flag", "plugin", "skill-author", "reserved-name"];
+export type SkillOverrideLockSource = (typeof SKILL_OVERRIDE_LOCK_SOURCES)[number];
+export interface SkillSyncedName {
+    readonly name: string;
+    readonly bare: string;
+}
+export interface SkillOverrideSubject {
+    readonly name: string;
+    readonly origin: SkillOrigin;
+    readonly unqualifiedName?: string;
+    readonly bareNameReserved?: boolean;
+    readonly aliases?: readonly string[];
+    readonly mcpLabels?: readonly string[];
+    readonly reservedLabels?: readonly string[];
+    readonly syncedNames?: readonly SkillSyncedName[];
+    readonly followsSyncedSkillState?: boolean;
+    readonly disableModelInvocation?: boolean;
+    readonly hiddenBehindPlugin?: boolean;
+}
+export interface SkillOverrideLayers {
+    readonly policySettings?: SettingsDocument | null;
+    readonly flagSettings?: SettingsDocument | null;
+    readonly localSettings?: SettingsDocument | null;
+    readonly projectSettings?: SettingsDocument | null;
+    readonly userSettings?: SettingsDocument | null;
+    readonly session?: {
+        readonly [name: string]: string;
+    } | null;
+    readonly disabledSources?: readonly PlainLayer[];
+    readonly bundledSkillsDisabledByEnv?: boolean;
+}
+export interface SkillOverrideEffective {
+    readonly value: SkillOverrideState;
+    readonly decidedBy: SkillOverrideDecider;
+}
+export interface SkillOverrideLock {
+    readonly source: SkillOverrideLockSource;
+    readonly value: SkillOverrideState;
+}
+export interface ShapedSkillSubject {
+    readonly name: string;
+    readonly origin: SkillOrigin;
+    readonly unqualifiedName: string | undefined;
+    readonly bareNameReserved: boolean;
+    readonly aliases: readonly string[];
+    readonly mcpLabels: readonly string[];
+    readonly reservedLabels: readonly string[];
+    readonly syncedNames: readonly SkillSyncedName[];
+    readonly followsSyncedSkillState: boolean;
+    readonly disableModelInvocation: boolean;
+    readonly hiddenBehindPlugin: boolean;
+}
+export declare function shapeSkillSubject(v: SkillOverrideSubject | null | undefined): ShapedSkillSubject | undefined;
+export interface ShapedSkillLayers {
+    readonly docs: {
+        readonly [L in SkillOverrideLayer]: object | undefined;
+    };
+    readonly session: object | undefined;
+    readonly enabled: (layer: SkillOverrideLayer) => boolean;
+    readonly bundledDisabled: boolean;
+}
+export declare function shapeSkillLayers(v: SkillOverrideLayers | null | undefined): ShapedSkillLayers;
+export declare function bareNameOf(s: ShapedSkillSubject): string | undefined;
+export declare function secondaryNamesOf(s: ShapedSkillSubject): string[];
+export declare function effectiveOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideEffective;
+export declare function lockOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideLock | undefined;
+export declare function skillOverrideEffectiveOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideEffective | undefined;
+export declare function skillOverrideLockOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideLock | undefined;
+export declare function ownValueIn(ov: object | undefined, s: ShapedSkillSubject): SkillOverrideState | undefined;
+export declare function stateAt(ov: object | undefined, key: string | undefined): SkillOverrideState | undefined;
+export declare function lowerTierOf(L: ShapedSkillLayers, s: ShapedSkillSubject, target: 'localSettings' | 'userSettings', skipTargetBare: boolean): SkillOverrideState | undefined;
+export declare function withLayerDoc(L: ShapedSkillLayers, layer: SkillOverrideLayer, doc: SettingsDocument): ShapedSkillLayers;
+export {};