@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/memoryOriginCapability.js

@@ -1,14 +1,13 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
 export function projectMemoryOriginCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
         const c = caps;
-        if (!Object.hasOwn(c, 'memoryOrigin'))
-            return { kind: 'not_reported' };
-        const v = c.memoryOrigin;
+        const v = ownDataField(c, 'memoryOrigin');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -49,9 +48,6 @@ export function memoryOriginDoctorDetail(reading) {
             return 'external-origin face on — the origin listing and clearance endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds, and it says nothing about the listing being complete (the engine has no scope-enumeration read face, so an answer covers only the scopes the caller named and an empty one must never be read as a clean store)';
     }
 }
-export function forgetMemoryOriginReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetMemoryOriginReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/memoryVerbsWire.d.ts

@@ -21,7 +21,7 @@ export interface MemoryFacade {
 }
 export declare const MEMORY_VERB_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "store_absent", "operator_only", "operators_unconfigured", "unauthorized", "service_token_required", "id_invalid", "request_id_required", "body_shape", "query_invalid", "selector_invalid", "evidence_unavailable", "selector_mismatch", "census_incomplete", "clear_unattributed", "clear_invalid", "clear_not_marked", "clear_challenged", "clear_conflict", "clear_pending"];
 export type MemoryVerbRefusalCause = (typeof MEMORY_VERB_REFUSAL_CAUSES)[number];
-export declare const MEMORY_VERB_UNKNOWN_WHYS: readonly ["no_verdict", "server_fault", "control_plane_corrupt", "clear_unknown", "clear_failed", "result_unreadable", "unsupported_version", "identity_mismatch", "unclassified"];
+export declare const MEMORY_VERB_UNKNOWN_WHYS: readonly ["no_verdict", "server_fault", "control_plane_corrupt", "clear_unknown", "clear_failed", "result_unreadable", "unsupported_version", "identity_mismatch", "store_form_refused", "unclassified"];
 export type MemoryVerbUnknownWhy = (typeof MEMORY_VERB_UNKNOWN_WHYS)[number];
 export type MemoryVerbRefused = {
     status: 'refused';

package/dist/memoryVerbsWire.js

@@ -35,6 +35,7 @@ export const MEMORY_VERB_UNKNOWN_WHYS = Object.freeze([
     'result_unreadable',
     'unsupported_version',
     'identity_mismatch',
+    'store_form_refused',
     'unclassified',
 ]);
 function refusedBy(cause, message) {
@@ -90,6 +91,9 @@ export function classifyMemoryFailure(e) {
             return unknownBy('clear_unknown', message);
         case 'memory.origin_clear_failed':
             return unknownBy('clear_failed', message);
+        case 'memory.target_outside_store':
+        case 'memory.scope_home_not_directory':
+            return unknownBy('store_form_refused', message);
         case 'internal.memory_control_plane_corrupt':
             return unknownBy('control_plane_corrupt', message);
         default:

package/dist/model/liveCatalogShape.d.ts

@@ -0,0 +1,14 @@
+export type FrozenJsonValue = string | number | boolean | null | readonly FrozenJsonValue[] | {
+    readonly [k: string]: FrozenJsonValue;
+};
+export declare function frozenJsonCopyOf(v: unknown): FrozenJsonValue | undefined;
+export declare function liveModelRowCopy(row: unknown): FrozenJsonRow | undefined;
+export type FrozenJsonRow = {
+    readonly [k: string]: FrozenJsonValue;
+} & {
+    readonly name: string;
+};
+export declare function liveDefaultModelCopy(v: unknown): {
+    readonly id: string;
+    readonly name?: string;
+} | undefined;

package/dist/model/liveCatalogShape.js

@@ -0,0 +1,71 @@
+const MAX_DEPTH = 16;
+class Unreadable extends Error {
+}
+function frozenJsonCopy(v, depth) {
+    if (depth > MAX_DEPTH)
+        throw new Unreadable();
+    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            throw new Unreadable();
+        return v;
+    }
+    if (typeof v !== 'object')
+        throw new Unreadable();
+    if (Array.isArray(v)) {
+        const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            throw new Unreadable();
+        const out = [];
+        for (let i = 0; i < n; i += 1) {
+            const d = Object.getOwnPropertyDescriptor(v, String(i));
+            if (d === undefined || !('value' in d))
+                throw new Unreadable();
+            out.push(frozenJsonCopy(d.value, depth + 1));
+        }
+        return Object.freeze(out);
+    }
+    const out = {};
+    for (const k of Object.keys(v)) {
+        const d = Object.getOwnPropertyDescriptor(v, k);
+        if (d === undefined || !('value' in d))
+            throw new Unreadable();
+        if (d.value === undefined)
+            continue;
+        Object.defineProperty(out, k, { value: frozenJsonCopy(d.value, depth + 1), enumerable: true, writable: true, configurable: true });
+    }
+    return Object.freeze(out);
+}
+export function frozenJsonCopyOf(v) {
+    try {
+        return frozenJsonCopy(v, 0);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function liveModelRowCopy(row) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row))
+        return undefined;
+    const copy = frozenJsonCopyOf(row);
+    if (!isFrozenJsonObject(copy))
+        return undefined;
+    const name = copy.name;
+    return typeof name === 'string' && name.length > 0 ? copy : undefined;
+}
+const isFrozenJsonObject = (v) => v !== undefined && v !== null && typeof v === 'object' && !Array.isArray(v);
+export function liveDefaultModelCopy(v) {
+    if (v === null || typeof v !== 'object' || Array.isArray(v))
+        return undefined;
+    const c = frozenJsonCopyOf(v);
+    if (!isFrozenJsonObject(c))
+        return undefined;
+    const id = c.id;
+    const name = c.name;
+    if (typeof id !== 'string' || id.length === 0)
+        return undefined;
+    if (Object.hasOwn(c, 'name') && (typeof name !== 'string' || name.length === 0))
+        return undefined;
+    return c;
+}

package/dist/model/modelSupplyRules.d.ts

@@ -26,6 +26,7 @@ export interface DeleteWarningsInput {
     id: string;
     doc: {
         atModelAllowlist?: unknown;
+        atMention?: unknown;
         tierGroups?: unknown;
     } | null;
     tierGroups: TierGroupsView | null;

package/dist/model/modelSupplyRules.js

@@ -1,3 +1,5 @@
+import { SETTINGS_NARROW_AT_MENTION } from '../generated/settingsSchemaFns.js';
+import { modelsPolicyOf } from './modelsPolicy.js';
 import { inferFamily } from './providerPresets.js';
 function isPlainObject(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -13,15 +15,16 @@ export function resolveEntryVision(entry) {
 export function computeDeleteWarnings(input) {
     const { id, doc, tierGroups, survivingIds } = input;
     const out = [];
-    const allow = doc?.atModelAllowlist;
-    if (Array.isArray(allow)) {
-        const declared = allow.filter((x) => typeof x === 'string');
-        const effectiveBefore = declared.filter(n => n === id || survivingIds.includes(n));
-        const effectiveAfter = declared.filter(n => n !== id && survivingIds.includes(n));
-        if (effectiveBefore.length > 0 && effectiveAfter.length === 0) {
+    const am = modelsPolicyOf(doc).atMention;
+    if (am?.kind === 'read' && am.value.mode === 'only') {
+        const before = SETTINGS_NARROW_AT_MENTION(am.value, new Set([id, ...survivingIds]));
+        const after = SETTINGS_NARROW_AT_MENTION(am.value, new Set(survivingIds.filter((n) => n !== id)));
+        if (before.mode === 'only' && after.mode === 'none') {
             out.push({
                 kind: 'allowlist-empties',
-                consequence: 'it is the last usable model on your @-mention allowlist — deleting it empties the list, which means EVERY enabled model becomes @-mentionable',
+                consequence: am.from === 'atModelAllowlist'
+                    ? 'it is the last usable model on your @-mention allowlist — deleting it empties the list, which means EVERY enabled model becomes @-mentionable'
+                    : 'it is the last usable model on your @-mention allowlist — deleting it leaves no model that can be @-mentioned',
             });
         }
     }
@@ -47,15 +50,33 @@ export function computeDeleteWarnings(input) {
 export function computeDeleteBlockers(input) {
     const { id, doc, rosters } = input;
     const out = [];
-    if (doc && typeof doc.default === 'string' && doc.default === id) {
+    const policy = modelsPolicyOf(doc);
+    if (policy.unreadable) {
+        out.push({
+            kind: 'unreadable',
+            where: 'models.json (the document could not be read)',
+            fix: 'fix or re-save models.json so it can be read, then delete this model',
+        });
+    }
+    if (policy.defaultUnreadable) {
+        out.push({
+            kind: 'unreadable',
+            where: 'models.json `default` (the default model could not be read)',
+            fix: 'fix or re-save models.json so its default model can be read, then delete this model',
+        });
+    }
+    const dm = policy.defaultModel;
+    if (dm !== undefined && dm.name === id) {
         out.push({
             kind: 'default',
-            where: 'models.json `default`',
+            where: dm.from === 'default' ? 'models.json `default`' : 'models.json roles.default',
             fix: 'point another model at the default first (Model Hub: select it and press u), then delete this one',
         });
     }
     if (doc && isPlainObject(doc.roles)) {
         for (const [role, target] of Object.entries(doc.roles)) {
+            if (role === 'default' && dm?.from === 'roles.default')
+                continue;
             if (!isPlainObject(target) || typeof target.model !== 'string')
                 continue;
             if (target.model !== id)

package/dist/model/modelsPolicy.d.ts

@@ -0,0 +1,21 @@
+import { type SettingsAtMention } from '../generated/settingsSchemaFns.js';
+export interface CanonicalDefaultModel {
+    readonly name: string;
+    readonly from: 'default' | 'roles.default';
+}
+export type CanonicalAtMention = {
+    readonly kind: 'read';
+    readonly value: SettingsAtMention;
+    readonly from: 'atMention' | 'atModelAllowlist';
+    readonly unreadableEntries: number;
+} | {
+    readonly kind: 'unreadable';
+    readonly from: 'atMention' | 'atModelAllowlist';
+};
+export interface CanonicalModelsPolicy {
+    readonly defaultModel?: CanonicalDefaultModel;
+    readonly defaultUnreadable?: true;
+    readonly atMention?: CanonicalAtMention;
+    readonly unreadable?: true;
+}
+export declare function modelsPolicyOf(doc: unknown): CanonicalModelsPolicy;

package/dist/model/modelsPolicy.js

@@ -0,0 +1,90 @@
+import { SETTINGS_AT_MENTION_MODES } from '../generated/settingsSchemaFns.js';
+function ownData(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function atMentionOf(v) {
+    try {
+        if (!isRecord(v))
+            return undefined;
+        const mode = ownData(v, 'mode');
+        if (typeof mode !== 'string' || !SETTINGS_AT_MENTION_MODES.includes(mode))
+            return undefined;
+        if (mode !== 'only')
+            return { mode: mode };
+        const list = ownData(v, 'models');
+        if (!Array.isArray(list) || list.length === 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < list.length; i += 1) {
+            const d = Object.getOwnPropertyDescriptor(list, i);
+            if (d === undefined || !('value' in d) || typeof d.value !== 'string' || d.value.length === 0)
+                return undefined;
+            out.push(d.value);
+        }
+        return { mode: 'only', models: out };
+    }
+    catch {
+        return undefined;
+    }
+}
+function atModelAllowlistOf(v) {
+    if (!Array.isArray(v))
+        return { kind: 'unreadable', from: 'atModelAllowlist' };
+    const names = [];
+    let bad = 0;
+    for (let i = 0; i < v.length; i += 1) {
+        const d = Object.getOwnPropertyDescriptor(v, i);
+        const x = d !== undefined && 'value' in d ? d.value : undefined;
+        if (typeof x === 'string' && x.length > 0)
+            names.push(x);
+        else
+            bad += 1;
+    }
+    const value = names.length > 0 ? { mode: 'only', models: names } : { mode: 'all' };
+    return { kind: 'read', value, from: 'atModelAllowlist', unreadableEntries: bad };
+}
+export function modelsPolicyOf(doc) {
+    try {
+        if (!isRecord(doc))
+            return {};
+        let defaultModel;
+        let defaultUnreadable = false;
+        if (Object.hasOwn(doc, 'default')) {
+            const d = ownData(doc, 'default');
+            if (typeof d === 'string' && d.length > 0)
+                defaultModel = { name: d, from: 'default' };
+            else
+                defaultUnreadable = true;
+        }
+        if (defaultModel === undefined && !defaultUnreadable) {
+            const roles = ownData(doc, 'roles');
+            const rd = isRecord(roles) ? ownData(roles, 'default') : undefined;
+            const model = isRecord(rd) ? ownData(rd, 'model') : undefined;
+            if (typeof model === 'string' && model.length > 0)
+                defaultModel = { name: model, from: 'roles.default' };
+        }
+        let atMention;
+        if (Object.hasOwn(doc, 'atMention')) {
+            const am = atMentionOf(ownData(doc, 'atMention'));
+            atMention = am === undefined ? { kind: 'unreadable', from: 'atMention' } : { kind: 'read', value: am, from: 'atMention', unreadableEntries: 0 };
+        }
+        else if (Object.hasOwn(doc, 'atModelAllowlist')) {
+            atMention = atModelAllowlistOf(ownData(doc, 'atModelAllowlist'));
+        }
+        return {
+            ...(defaultModel !== undefined ? { defaultModel } : {}),
+            ...(defaultUnreadable ? { defaultUnreadable: true } : {}),
+            ...(atMention !== undefined ? { atMention } : {}),
+        };
+    }
+    catch {
+        return { unreadable: true };
+    }
+}

package/dist/modelIdentityResolvability.d.ts

@@ -28,7 +28,7 @@ export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unkn
 export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
-export declare function modelSetupDecision(identity: ModelIdentityResolvability | ModelIdentityReading, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupDecision(reading: ModelIdentityReading, hostCanConfigureModel: boolean): ModelSetupDecision;
 export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
 export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
 export {};

package/dist/modelIdentityResolvability.js

@@ -178,18 +178,11 @@ export function modelIdentityDetail(reading) {
             return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
     }
 }
-export function modelSetupDecision(identity, hostCanConfigureModel) {
-    let verdict;
-    if (typeof identity === 'string') {
-        verdict = identity;
-    }
-    else {
-        const a = analyse(identity);
-        if (a.verdict === 'not_resolvable' && a.why === 'route_gap')
-            return 'explain_route_gap';
-        verdict = a.verdict;
-    }
-    if (verdict !== 'not_resolvable')
+export function modelSetupDecision(reading, hostCanConfigureModel) {
+    const a = analyse(reading);
+    if (a.verdict === 'not_resolvable' && a.why === 'route_gap')
+        return 'explain_route_gap';
+    if (a.verdict !== 'not_resolvable')
         return 'proceed';
     if (hostCanConfigureModel === true)
         return 'offer_setup';

package/dist/modelSwitchFallback.d.ts

@@ -0,0 +1,69 @@
+export type ModelSwitchProbeLane = 'live' | 'mock' | 'engine_absent' | 'unwired';
+export interface ModelSwitchProbeVerdict {
+    readonly valid: boolean;
+    readonly error?: string;
+    readonly unchecked?: true;
+}
+export interface ModelSwitchProbeInput {
+    readonly model: string;
+    readonly lane: ModelSwitchProbeLane;
+    readonly engineAbsentReason?: string;
+    readonly probe?: {
+        readonly kind: 'verdict';
+        readonly verdict: ModelSwitchProbeVerdict;
+    } | {
+        readonly kind: 'threw';
+        readonly error: unknown;
+    };
+}
+export type ModelSwitchProbeOutcome = {
+    readonly ok: true;
+    readonly probed: boolean;
+} | {
+    readonly ok: false;
+    readonly kind: 'rejected';
+    readonly model: string;
+    readonly reason?: string;
+} | {
+    readonly ok: false;
+    readonly kind: 'unavailable';
+    readonly cause: 'unwired' | 'probe_missing' | 'probe_threw' | 'unchecked';
+    readonly model: string;
+    readonly reason?: string;
+};
+export declare function modelSwitchProbeOutcomeOf(input: ModelSwitchProbeInput): ModelSwitchProbeOutcome;
+export interface ModelSwitchProbePorts {
+    readonly lane: () => {
+        readonly lane: ModelSwitchProbeLane;
+        readonly engineAbsentReason?: string;
+    } | Promise<{
+        readonly lane: ModelSwitchProbeLane;
+        readonly engineAbsentReason?: string;
+    }>;
+    readonly validate: (model: string) => Promise<ModelSwitchProbeVerdict>;
+}
+export declare function runModelSwitchProbe(model: string, ports: ModelSwitchProbePorts): Promise<ModelSwitchProbeOutcome>;
+export interface ModelSwitchFallbackRecord {
+    readonly previous: string;
+    readonly current: string;
+    readonly seq: number;
+}
+export interface ModelSwitchNote {
+    readonly sessionId: string;
+    readonly to: string | null | undefined;
+    readonly lastServed: string | null | undefined;
+}
+export interface ModelSwitchAdvisoryInput {
+    readonly frame: unknown;
+    readonly sessionId: string;
+    readonly streamModel: string | null | undefined;
+    readonly lastServed: string | null | undefined;
+}
+export interface ModelSwitchFallbackLedger {
+    noteSwitch(input: ModelSwitchNote): ModelSwitchFallbackRecord | undefined;
+    peek(sessionId: string): ModelSwitchFallbackRecord | undefined;
+    advisoryFor(input: ModelSwitchAdvisoryInput): ModelSwitchFallbackRecord | undefined;
+    release(sessionId: string, seq: number): boolean;
+    clear(sessionId: string): void;
+}
+export declare function createModelSwitchFallbackLedger(): ModelSwitchFallbackLedger;

package/dist/modelSwitchFallback.js

@@ -0,0 +1,206 @@
+import { resultErrorCodeOf, resultSelectedModelOf } from './resultFrameKeys.js';
+import { readFrameStringKey, readOwnDataValue } from './ownKey.js';
+const trimmed = (v) => (typeof v === 'string' ? v.trim() : '');
+const reasonOf = (v) => {
+    const t = trimmed(v);
+    return t.length > 0 ? t : undefined;
+};
+function thrownReason(e) {
+    try {
+        if (e instanceof Error)
+            return reasonOf(e.message);
+        return reasonOf(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function modelSwitchProbeOutcomeOf(input) {
+    let model = '';
+    let lane;
+    let absent;
+    let probe;
+    try {
+        model = trimmed(input?.model);
+        lane = input?.lane;
+        absent = reasonOf(input?.engineAbsentReason);
+        probe = input?.probe;
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (model.length === 0)
+        return { ok: true, probed: false };
+    if (lane === 'unwired')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    if (lane === 'mock' || (lane === 'engine_absent' && absent === undefined))
+        return { ok: true, probed: false };
+    if (lane !== 'live' && lane !== 'engine_absent')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    let kind;
+    let verdict;
+    let error;
+    try {
+        kind = probe?.kind;
+        verdict = kind === 'verdict' ? probe.verdict : undefined;
+        error = kind === 'threw' ? probe.error : undefined;
+    }
+    catch {
+        kind = undefined;
+    }
+    if (kind === 'threw') {
+        const reason = thrownReason(error);
+        return { ok: false, kind: 'unavailable', cause: 'probe_threw', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    if (kind !== 'verdict' || verdict === null || typeof verdict !== 'object')
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    let valid;
+    let unchecked;
+    let why;
+    try {
+        valid = verdict.valid;
+        unchecked = verdict.unchecked;
+        why = reasonOf(verdict.error);
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (valid === true)
+        return { ok: true, probed: lane === 'live' };
+    if (unchecked === true) {
+        const reason = why ?? absent;
+        return { ok: false, kind: 'unavailable', cause: 'unchecked', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    return { ok: false, kind: 'rejected', model, ...(why !== undefined ? { reason: why } : {}) };
+}
+export async function runModelSwitchProbe(model, ports) {
+    let laneReading;
+    try {
+        const got = await ports.lane();
+        const lane = got?.lane;
+        const why = got?.engineAbsentReason;
+        laneReading = {
+            lane: lane === 'live' || lane === 'mock' || lane === 'engine_absent' || lane === 'unwired' ? lane : 'unwired',
+            ...(typeof why === 'string' ? { engineAbsentReason: why } : {}),
+        };
+    }
+    catch {
+        laneReading = { lane: 'unwired' };
+    }
+    const base = { model, ...laneReading };
+    const pre = modelSwitchProbeOutcomeOf(base);
+    if (pre.ok || (pre.kind === 'unavailable' && pre.cause !== 'probe_missing'))
+        return pre;
+    try {
+        const verdict = await ports.validate(trimmed(model));
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'verdict', verdict } });
+    }
+    catch (error) {
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'threw', error } });
+    }
+}
+const EMPTY_STREAM_ERROR_CODE = 'stream_torn';
+const LEDGER_SESSION_CAP = 1024;
+function isEmptyStreamFailureFrame(frame) {
+    try {
+        if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        if (readFrameStringKey(frame, 'type') !== 'result')
+            return false;
+        if (readOwnDataValue(frame, 'is_error') !== true)
+            return false;
+        return resultErrorCodeOf(frame) === EMPTY_STREAM_ERROR_CODE;
+    }
+    catch {
+        return false;
+    }
+}
+export function createModelSwitchFallbackLedger() {
+    const bySession = new Map();
+    let lastSeq = 0;
+    const drop = (sid) => {
+        if (sid.length > 0)
+            bySession.delete(sid);
+    };
+    return {
+        noteSwitch(input) {
+            let sid = '';
+            let current = '';
+            let previous = '';
+            try {
+                sid = trimmed(input?.sessionId);
+                current = trimmed(input?.to);
+                previous = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (sid.length === 0)
+                return undefined;
+            if (current.length === 0 || previous.length === 0 || previous === current) {
+                drop(sid);
+                return undefined;
+            }
+            lastSeq += 1;
+            const rec = Object.freeze({ previous, current, seq: lastSeq });
+            bySession.delete(sid);
+            bySession.set(sid, rec);
+            while (bySession.size > LEDGER_SESSION_CAP) {
+                const oldest = bySession.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                bySession.delete(oldest);
+            }
+            return rec;
+        },
+        peek(sessionId) {
+            const sid = trimmed(sessionId);
+            return sid.length > 0 ? bySession.get(sid) : undefined;
+        },
+        advisoryFor(input) {
+            let frame;
+            let sid = '';
+            let streamModel = '';
+            let served = '';
+            try {
+                frame = input?.frame;
+                sid = trimmed(input?.sessionId);
+                streamModel = trimmed(input?.streamModel);
+                served = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (!isEmptyStreamFailureFrame(frame))
+                return undefined;
+            if (sid.length === 0)
+                return undefined;
+            const rec = bySession.get(sid);
+            if (rec === undefined)
+                return undefined;
+            const frameModel = trimmed(resultSelectedModelOf(frame));
+            const candidates = frameModel.length > 0 && frameModel !== streamModel ? [streamModel, frameModel] : [streamModel];
+            for (const c of candidates) {
+                if (c.length === 0 || rec.current !== c)
+                    continue;
+                if (served === c)
+                    return undefined;
+                return rec;
+            }
+            return undefined;
+        },
+        release(sessionId, seq) {
+            const sid = trimmed(sessionId);
+            if (sid.length === 0)
+                return false;
+            const rec = bySession.get(sid);
+            if (rec === undefined || typeof seq !== 'number' || rec.seq !== seq)
+                return false;
+            bySession.delete(sid);
+            return true;
+        },
+        clear(sessionId) {
+            drop(trimmed(sessionId));
+        },
+    };
+}