@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/hostTurnSettings.js

@@ -1,6 +1,18 @@
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
-import { hooksWirePlanShapeOf } from './pluginHooksWire.js';
-export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle']);
+import { hostLog } from './host.js';
+import { layerNotAppliedRefusesTurn, salvageSettingsHooksEntries } from './settingsHooksSalvage.js';
+import { ADOPTED_LAYERS, HOST_SETTINGS_LAYERS, HostSettingsSourceShapeError, permissionRulesOf, MANAGED_READING_DISPOSITIONS, adoptHostSettingsRead, mintHostSettingsSession, readHostSettingsOnce, remintSameContent, sessionSnapshotOf, settingsValueOf, sourceOfRead, } from './hostSettingsSource.js';
+import { hooksWirePlan } from './hooksWireCaps.js';
+import { submissionSurfaceOf } from './request/submissionIdentity.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { resolveWebSearchVerdict, webSearchVerdictMessage } from './webSearchWireCaps.js';
+import { fileHistoryTightenVerdict, fileHistoryUnjudgedRefusal } from './fileHistoryCaptureCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { newRulePortsProjection, projectPermissionsDeclaration, rulePortsMissingOf, WIRE_RULE_TRUST_ORDER } from './permissionsDeclaration.js';
+import { assemblyRefusalOf } from './wireFailureShape.js';
+import { layerAdmitted } from './settingsLayerAdmission.js';
+import { appendOwnElement, ownDataField } from './ownKey.js';
+export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
 export const HOST_SETTING_CAUSES = Object.freeze([
     'carried',
     'entries_dropped',
@@ -10,19 +22,33 @@ export const HOST_SETTING_CAUSES = Object.freeze([
     'empty',
     'no_source',
     'host_port_missing',
+    'value_malformed',
+    'held_previous',
+    'policy_withheld',
 ]);
-export const HOST_SETTING_DISPOSITIONS = Object.freeze(['carry', 'carry_partial', 'withhold_notice', 'refuse_turn', 'unwired', 'nothing_to_carry']);
+export const HOST_SETTING_DISPOSITIONS = Object.freeze(['carry', 'carry_partial', 'withhold_notice', 'withhold_by_policy', 'hold_for_consent', 'refuse_turn', 'unwired', 'nothing_to_carry']);
 const HOST_SETTING_NOTICE_TEXT = {
     'HS-UNWIRED': (what) => `This app has not connected ${what} from your settings, so it is not sent with your requests.`,
     'HS-MANAGED-REJECTED': () => 'Managed settings: the hooks your administrator configured could not be loaded, so requests are not sent until the managed settings are fixed.',
-    'HS-PROJECTION': () => 'The hooks for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
+    'HS-PROJECTION': (sentence) => (sentence === '' ? renderMessage(msg('session.hostSettings.projectionUnchecked')) : sentence),
     'HS-SOURCE-UNREADABLE': (what) => `This app could not read ${what} from your settings, so the request is not sent. Reload your settings and try again.`,
+    'HS-WEBSEARCH-MALFORMED': (sentence) => sentence,
+    'HS-SWITCH-MALFORMED': () => renderMessage(msg('session.hostSettings.memorySwitchMalformed')),
+    'HS-FILEHISTORY-UNJUDGED': (sentence) => sentence,
+    'HS-FILEHISTORY-RESTORE': () => renderMessage(msg('session.hostSettings.fileHistoryRestoreConflict')),
+    'HS-MANAGED-UNREADABLE': () => renderMessage(msg('session.hostSettings.managedUnreadable')),
+    'HS-LAYER-NOT-LOADED': (sentence) => sentence,
+    'HS-HELD-PREVIOUS': () => renderMessage(msg('session.hostSettings.heldPrevious')),
+    'HS-STYLE-MISSING': (what) => renderMessage(msg('session.hostSettings.styleMissing', { name: what })),
+    'HS-STYLE-SAFE': () => renderMessage(msg('session.hostSettings.styleSafeMode')),
 };
 const KEY_NOUN = {
     'settings.hooks': 'the hooks',
     'settings.resolved': 'the permission rules',
     'settings.webSearch': 'the web search setup',
     'settings.outputStyle': 'the output style',
+    memory: 'auto-memory',
+    fileHistory: 'file checkpoints',
 };
 const BASE_DISPOSITION = {
     carried: 'carry',
@@ -33,6 +59,9 @@ const BASE_DISPOSITION = {
     empty: 'nothing_to_carry',
     no_source: 'nothing_to_carry',
     host_port_missing: 'unwired',
+    value_malformed: 'refuse_turn',
+    held_previous: 'carry',
+    policy_withheld: 'withhold_by_policy',
 };
 const freeze = (o) => Object.freeze(o);
 const mint = (o) => o;
@@ -48,18 +77,6 @@ function readSource(sources, key) {
         return { kind: 'threw' };
     }
 }
-function unwrap(v, field) {
-    if (v === 'none')
-        return { kind: 'none' };
-    try {
-        if (typeof v !== 'object' || v === null || Array.isArray(v) || !Object.hasOwn(v, field))
-            return { kind: 'bad' };
-        return { kind: 'value', value: v[field] };
-    }
-    catch {
-        return { kind: 'bad' };
-    }
-}
 const isRecordShape = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function hooksPassJudge(wire) {
     try {
@@ -69,8 +86,11 @@ function hooksPassJudge(wire) {
         return false;
     }
 }
+class HostSourceShapeError extends TypeError {
+    code = 'host_source_shape';
+}
 function badSource(key, want) {
-    return new TypeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
+    return new HostSourceShapeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
 }
 const missingArm = (key) => ({
     row: freeze({ key, cause: 'host_port_missing', disposition: BASE_DISPOSITION.host_port_missing }),
@@ -81,41 +101,50 @@ const unreadableArm = (key) => ({
     notices: [notice('HS-SOURCE-UNREADABLE', 'turn', KEY_NOUN[key])],
 });
 const noSourceArm = (key) => ({ row: freeze({ key, cause: 'no_source', disposition: BASE_DISPOSITION.no_source }), notices: [] });
+const emptyArm = (key) => ({ row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] });
 const carriedArm = (key, value) => ({ row: freeze({ key, cause: 'carried', disposition: BASE_DISPOSITION.carried }), notices: [], carried: value });
-function hooksArm(src) {
+function hooksArm(src, side) {
     const key = 'settings.hooks';
     if (src.kind === 'missing')
         return missingArm(key);
     if (src.kind === 'threw')
         return unreadableArm(key);
-    const u = unwrap(src.value, 'plan');
-    if (u.kind === 'none')
+    const facts = src.value;
+    if (facts === 'none')
         return noSourceArm(key);
-    if (u.kind === 'bad' || hooksWirePlanShapeOf(u.value) !== 'plan')
-        throw badSource(key, '{ plan } with the plan returned by hooksWirePlan() for this turn');
-    const plan = u.value;
-    let wire;
-    let salvageRows;
-    let closedBy;
+    let hasPlan;
+    let hasSettings;
     try {
-        wire = plan.wire;
-        salvageRows = plan.settingsSalvage;
-        closedBy = plan.closedBy;
+        if (!isRecordShape(facts))
+            throw badSource(key, "the hooks plan facts ({ baseUrl?, engineOwnedByThisShell?, shellHookEvents?, … }) — since 0.101.0 the entry builds the plan from the settings it reads");
+        hasPlan = Object.hasOwn(facts, 'plan');
+        hasSettings = Object.hasOwn(facts, 'settings');
     }
-    catch {
-        throw badSource(key, '{ plan } with a readable plan');
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
     }
-    const rows = Array.isArray(salvageRows) ? salvageRows : [];
-    const layersOf = (outcome) => rows.filter((r) => isRecordShape(r) && r.outcome === outcome && typeof r.source === 'string').map((r) => r.source);
-    const managedRejected = layersOf('rejected').includes('policySettings');
-    if (managedRejected || layersOf('loaded-partial').includes('policySettings')) {
+    if (hasPlan || hasSettings)
+        throw badSource(key, "the hooks plan facts — since 0.101.0 do not pass { plan } (the entry builds the plan) nor settings (pass it once as the entry's settings)");
+    if (side.kind === 'missing')
+        return missingArm(key);
+    if (side.kind === 'none')
+        return noSourceArm(key);
+    const plan = hooksWirePlan({ ...facts, settings: sourceOfRead(side.read) });
+    const wire = plan.wire;
+    const rows = plan.settingsSalvage;
+    const layersOf = (outcome) => rows.filter((r) => r.outcome === outcome).map((r) => r.source);
+    const refusingRejected = layersOf('rejected').filter(layerNotAppliedRefusesTurn);
+    const refusingPartial = layersOf('loaded-partial').filter(layerNotAppliedRefusesTurn);
+    if (refusingRejected.length > 0 || refusingPartial.length > 0) {
         return {
-            row: freeze({ key, cause: managedRejected ? 'source_rejected' : 'entries_dropped', disposition: 'refuse_turn', layers: freeze(['policySettings']) }),
+            row: freeze({ key, cause: refusingRejected.length > 0 ? 'source_rejected' : 'entries_dropped', disposition: 'refuse_turn', layers: freeze([...new Set([...refusingRejected, ...refusingPartial])]) }),
             notices: [notice('HS-MANAGED-REJECTED', 'turn')],
             plan,
         };
     }
-    if (closedBy === 'governance_unreadable')
+    if (plan.closedBy === 'governance_unreadable')
         return { ...unreadableArm(key), plan };
     if (wire !== undefined && !hooksPassJudge(wire)) {
         return { row: freeze({ key, cause: 'projection_failed', disposition: BASE_DISPOSITION.projection_failed }), notices: [notice('HS-PROJECTION', 'turn')], plan };
@@ -129,23 +158,372 @@ function hooksArm(src) {
         return { row: freeze({ key, cause, disposition: carried !== undefined ? 'carry_partial' : 'withhold_notice', layers }), notices: [], carried, plan };
     }
     if (carried === undefined)
-        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [], plan };
+        return { ...emptyArm(key), plan };
     return { ...carriedArm(key, carried), plan };
 }
-function passArm(key, field, src, want) {
+function webSearchArm(src, side) {
+    const key = 'settings.webSearch';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let env;
+    let apiKeyFor;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'env') || Object.hasOwn(v, 'settings') || Object.hasOwn(v, 'section')) {
+            throw badSource(key, "{ env, apiKeyFor? } with the environment (since 0.101.0 the webSearch section comes from the settings the entry reads — do not pass section)");
+        }
+        env = v.env;
+        apiKeyFor = v.apiKeyFor;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (!isRecordShape(env))
+        throw badSource(key, '{ env } where env is the environment record (pass {} where there is none)');
+    if (apiKeyFor !== undefined && typeof apiKeyFor !== 'function')
+        throw badSource(key, '{ env, apiKeyFor? } where apiKeyFor is a function');
+    if (side.kind === 'missing')
+        return missingArm(key);
+    const section = side.kind === 'read' ? settingsValueOf(side.read, 'webSearch') : undefined;
+    const verdict = resolveWebSearchVerdict(env, section, apiKeyFor);
+    if (verdict.kind === 'absent')
+        return emptyArm(key);
+    if (verdict.kind === 'honored')
+        return carriedArm(key, freeze({ ...verdict.settings }));
+    return {
+        row: freeze({ key, cause: 'value_malformed', disposition: BASE_DISPOSITION.value_malformed }),
+        notices: [notice('HS-WEBSEARCH-MALFORMED', 'turn', webSearchVerdictMessage(verdict, 'submit') ?? '')],
+    };
+}
+function memoryArm(src, side, judge) {
+    const key = 'memory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let flag;
+    try {
+        if (!isRecordShape(v) || Object.hasOwn(v, 'settingsMemory'))
+            throw badSource(key, '{ flag? } with the --memory flag word (since 0.101.0 the memory section comes from the settings the entry reads — do not pass settingsMemory)');
+        flag = v.flag;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (judge({ flag }))
+        return carriedArm(key, 'off');
+    if (side.kind === 'missing')
+        return missingArm(key);
+    const settingsMemory = side.kind === 'read' ? settingsValueOf(side.read, 'memory') : undefined;
+    let bySettings;
+    try {
+        bySettings = judge({ settingsMemory });
+    }
+    catch {
+        return { row: freeze({ key, cause: 'value_malformed', disposition: 'withhold_notice' }), notices: [notice('HS-SWITCH-MALFORMED', 'session')] };
+    }
+    if (bySettings)
+        return carriedArm(key, 'off');
+    return emptyArm(key);
+}
+const UNOBSERVED_READING = Object.freeze({ kind: 'unobserved' });
+function fileHistoryReadingSnapshot(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return UNOBSERVED_READING;
+        const kind = reading.kind;
+        if (kind === 'present') {
+            const word = reading.word;
+            return Object.freeze({ kind, word });
+        }
+        return Object.freeze({ kind });
+    }
+    catch {
+        return UNOBSERVED_READING;
+    }
+}
+function fileHistoryArm(src) {
+    const key = 'fileHistory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let reading;
+    let captureOff;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'captureOff'))
+            throw badSource(key, '{ reading, captureOff } with the engine capability reading and the switch');
+        reading = v.reading;
+        captureOff = v.captureOff;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (typeof captureOff !== 'boolean')
+        throw badSource(key, '{ reading, captureOff } where captureOff is a boolean');
+    const snap = fileHistoryReadingSnapshot(reading);
+    const verdict = fileHistoryTightenVerdict(snap, captureOff);
+    if (verdict === 'declare')
+        return carriedArm(key, 'disabled');
+    if (verdict === 'unjudged') {
+        return {
+            row: freeze({ key, cause: 'value_malformed', disposition: 'refuse_turn' }),
+            notices: [notice('HS-FILEHISTORY-UNJUDGED', 'turn', fileHistoryUnjudgedRefusal(snap, true) ?? fileHistoryUnjudgedRefusal(UNOBSERVED_READING, true) ?? '')],
+        };
+    }
+    return emptyArm(key);
+}
+function outputStyleArm(src, side) {
+    const key = 'settings.outputStyle';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let readBody;
+    try {
+        if (!isRecordShape(v) || Object.hasOwn(v, 'name'))
+            throw badSource(key, '{ readBody(name) } (since 0.101.0 the style name comes from the settings the entry reads — do not pass name)');
+        readBody = v.readBody;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (typeof readBody !== 'function')
+        throw badSource(key, '{ readBody(name) } where readBody is a method');
+    if (side.kind === 'missing')
+        return missingArm(key);
+    if (side.kind === 'none')
+        return noSourceArm(key);
+    const name = settingsValueOf(side.read, 'outputStyle');
+    if (typeof name !== 'string' || name === '')
+        return emptyArm(key);
+    if (side.read.startup === 'safe') {
+        return { row: freeze({ key, cause: 'policy_withheld', disposition: BASE_DISPOSITION.policy_withheld }), notices: [notice('HS-STYLE-SAFE', 'diagnostic')] };
+    }
+    let body;
+    try {
+        body = readBody.call(v, name);
+    }
+    catch {
+        body = undefined;
+    }
+    const state = ownDataOf(body, 'state');
+    const text = state.ok && state.value === 'present' ? ownDataOf(body, 'body') : undefined;
+    const reminder = state.ok && state.value === 'present' ? ownDataOf(body, 'turnReminder') : undefined;
+    if (text !== undefined && text.ok && typeof text.value === 'string' && reminder !== undefined && reminder.ok && (reminder.value === undefined || typeof reminder.value === 'string')) {
+        const facts = freeze({ name, body: text.value, ...(reminder.value !== undefined ? { turnReminder: reminder.value } : {}) });
+        return { ...carriedArm(key, name), facts };
+    }
+    return {
+        row: freeze({ key, cause: 'source_unreadable', disposition: 'withhold_notice' }),
+        notices: [notice('HS-STYLE-MISSING', 'session', displayUntrusted(name))],
+    };
+}
+function stringListOf(v) {
+    if (v === undefined)
+        return [];
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        const ld = Object.getOwnPropertyDescriptor(v, 'length');
+        if (ld === undefined || !Object.hasOwn(ld, 'value') || typeof ld.value !== 'number' || !Number.isSafeInteger(ld.value) || ld.value < 0 || ld.value > 100_000)
+            return undefined;
+        const len = ld.value;
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            const d = Object.getOwnPropertyDescriptor(v, i);
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string')
+                return undefined;
+            appendOwnElement(out, d.value);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+function permissionMemberAdmitted(layer, read, bucket) {
+    return layerAdmitted(layer, read.trust, 'permissions', bucket);
+}
+function allowAdmittedFor(read) {
+    const disp = MANAGED_READING_DISPOSITIONS[read.managed];
+    const policyDoc = read.layers.policySettings.doc;
+    const managedOnlySwitch = disp.ruleScope === 'by-switch' && policyDoc !== null && managedOnlySwitchOn(policyDoc);
+    const degrade = disp.ruleScope === 'degrade';
+    return (layer) => {
+        if (degrade || managedOnlySwitch)
+            return false;
+        try {
+            const doc = read.layers[layer].doc;
+            if (doc !== null && salvageSettingsHooksEntries(doc).outcome === 'rejected')
+                return false;
+            return layerAdmitted(layer, read.trust, 'permissions', 'allow');
+        }
+        catch {
+            return false;
+        }
+    };
+}
+function badPermissionsSource() {
+    return new HostSourceShapeError(`hostTurnSettings: sources.resolved must be 'none' or { allowGrantReading, cliArg?, session?, clientOwnedServers?, serverVersion? } — since 0.101.0 the permission rules of the settings files come from the settings the entry reads; do not pass snapshot — got something else (the value is not echoed).`);
+}
+function permissionsArm(src, side, adoption) {
+    const key = 'settings.resolved';
     if (src.kind === 'missing')
         return missingArm(key);
     if (src.kind === 'threw')
         return unreadableArm(key);
-    const u = unwrap(src.value, field);
-    if (u.kind === 'none')
+    const v = src.value;
+    if (v === 'none')
         return noSourceArm(key);
-    if (u.kind === 'bad')
-        throw badSource(key, want);
-    if (u.value === undefined || u.value === null)
-        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
-    return carriedArm(key, u.value);
+    let allowGrantReading;
+    let cliAllow;
+    let cliDeny;
+    let sesDeny;
+    let sesAsk;
+    let owned;
+    let ownedRaw;
+    let serverVersion;
+    try {
+        if (!isRecordShape(v) || Object.hasOwn(v, 'snapshot') || !Object.hasOwn(v, 'allowGrantReading'))
+            throw badPermissionsSource();
+        const sver = ownDataOf(v, 'serverVersion');
+        serverVersion = sver.ok && typeof sver.value === 'string' ? sver.value : undefined;
+        const g = ownDataOf(v, 'allowGrantReading');
+        const c = ownDataOf(v, 'cliArg');
+        const se = ownDataOf(v, 'session');
+        const o = ownDataOf(v, 'clientOwnedServers');
+        if (!g.ok || !c.ok || !se.ok || !o.ok)
+            return unreadableArm(key);
+        allowGrantReading = g.value;
+        const cv = c.value;
+        const sv = se.value;
+        if (cv !== undefined && !isRecordShape(cv))
+            throw badPermissionsSource();
+        if (sv !== undefined && !isRecordShape(sv))
+            throw badPermissionsSource();
+        const ca = cv === undefined ? { ok: true, value: undefined } : ownDataOf(cv, 'allow');
+        const cd = cv === undefined ? { ok: true, value: undefined } : ownDataOf(cv, 'deny');
+        const sd = sv === undefined ? { ok: true, value: undefined } : ownDataOf(sv, 'deny');
+        const sa = sv === undefined ? { ok: true, value: undefined } : ownDataOf(sv, 'ask');
+        if (!ca.ok || !cd.ok || !sd.ok || !sa.ok)
+            return unreadableArm(key);
+        cliAllow = stringListOf(ca.value);
+        cliDeny = stringListOf(cd.value);
+        sesDeny = stringListOf(sd.value);
+        sesAsk = stringListOf(sa.value);
+        ownedRaw = o.value;
+        owned = o.value === undefined ? undefined : stringListOf(o.value);
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (cliAllow === undefined || cliDeny === undefined || sesDeny === undefined || sesAsk === undefined || (owned === undefined && ownedRaw !== undefined))
+        throw badPermissionsSource();
+    if (side.kind === 'missing')
+        return missingArm(key);
+    const buckets = { deny: [], ask: [], allow: [] };
+    const origins = { deny: new Map(), ask: new Map(), allow: new Map() };
+    const rank = (o) => WIRE_RULE_TRUST_ORDER.indexOf(o);
+    const add = (bucket, rule, origin) => {
+        const prev = origins[bucket].get(rule);
+        if (prev === undefined) {
+            appendOwnElement(buckets[bucket], rule);
+            origins[bucket].set(rule, origin);
+        }
+        else if (rank(origin) < rank(prev))
+            origins[bucket].set(rule, origin);
+    };
+    let projectionError;
+    const portsProjection = newRulePortsProjection();
+    if (side.kind === 'read') {
+        const read = side.read;
+        const disp = MANAGED_READING_DISPOSITIONS[read.managed];
+        const policyDoc = read.layers.policySettings.doc;
+        const managedOnlySwitch = disp.ruleScope === 'by-switch' && policyDoc !== null && managedOnlySwitchOn(policyDoc);
+        const degrade = disp.ruleScope === 'degrade';
+        try {
+            for (const bucket of Object.keys(buckets)) {
+                if (bucket === 'allow' && degrade)
+                    continue;
+                if (permissionMemberAdmitted('policySettings', read, bucket))
+                    for (const r of permissionRulesOf(policyDoc, bucket))
+                        add(bucket, r, 'policySettings');
+            }
+            if (!managedOnlySwitch) {
+                for (const l of ADOPTED_LAYERS) {
+                    for (const bucket of ['deny', 'ask'])
+                        if (permissionMemberAdmitted(l, read, bucket))
+                            for (const r of permissionRulesOf(read.layers[l].doc, bucket))
+                                add(bucket, r, l);
+                    if (!degrade && permissionMemberAdmitted(l, read, 'allow'))
+                        for (const r of adoption?.allowByLayer[l] ?? [])
+                            add('allow', r, l);
+                }
+                for (const bucket of ['deny', 'ask'])
+                    for (const r of adoption?.extraTighten[bucket] ?? [])
+                        if (permissionMemberAdmitted(r.layer, read, bucket))
+                            add(bucket, r.rule, r.layer);
+            }
+        }
+        catch (error) {
+            projectionError = freeze({ error: error });
+        }
+    }
+    for (const r of cliAllow)
+        add('allow', r, 'cliArg');
+    for (const r of sesDeny)
+        add('deny', r, 'session');
+    for (const r of sesAsk)
+        add('ask', r, 'session');
+    let declared;
+    if (projectionError === undefined) {
+        try {
+            const d = projectPermissionsDeclaration({ deny: buckets.deny, ask: buckets.ask, allow: buckets.allow, origins, cliDeny, settingsRead: 'clean', ...(owned !== undefined && owned.length > 0 ? { clientOwnedServers: owned } : {}), ...(serverVersion !== undefined ? { serverVersion } : {}) }, allowGrantReading, portsProjection);
+            declared = d.permissions !== undefined ? { permissions: d.permissions } : undefined;
+        }
+        catch (error) {
+            projectionError = freeze({ error: error });
+        }
+    }
+    if (projectionError !== undefined)
+        return { row: freeze({ key, cause: 'projection_failed', disposition: BASE_DISPOSITION.projection_failed }), notices: [projectionRefusedNotice(projectionError.error, portsProjection)], refusalCause: projectionError };
+    if (declared === undefined)
+        return emptyArm(key);
+    return carriedArm(key, declared);
+}
+function projectionRefusedNotice(error, projection) {
+    const ports = rulePortsMissingOf(error, projection);
+    if (ports !== undefined && ports.length > 0)
+        return notice('HS-PROJECTION', 'turn', renderMessage(msg('session.hostSettings.projectionUncheckedPortsMissing', { ports: ports.join(' / ') })));
+    if (assemblyRefusalOf(error)?.cause === 'judge_unanswerable')
+        return notice('HS-PROJECTION', 'turn', renderMessage(msg('session.hostSettings.projectionUncheckedJudgeFailed')));
+    return notice('HS-PROJECTION', 'turn');
 }
+const REFUSAL_CAUSE = Symbol('hostTurnSettings.refusalCause');
 const RESOLVED_DEFERRED_ERROR = Symbol('hostTurnSettings.resolvedDeferredError');
 export function rethrowHostResolvedDeferred(product) {
     const rec = product;
@@ -155,7 +533,60 @@ export function rethrowHostResolvedDeferred(product) {
     if (box !== undefined)
         throw box.error;
 }
-export function buildHostTurnSettings(input, materialize) {
+function sessionOf(previous) {
+    const s = sessionSnapshotOf(previous);
+    if (s === undefined)
+        throw new HostSourceShapeError('hostTurnSettings: previous must be the session of the previous product of this session (product.session) or absent — got something else (the value is not echoed).');
+    return s;
+}
+const NON_MANAGED_LAYERS = HOST_SETTINGS_LAYERS.filter((l) => l !== 'policySettings');
+function fnv1a(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
+}
+function notLoadedLayers(read, plan) {
+    const out = [];
+    for (const layer of NON_MANAGED_LAYERS) {
+        const snap = read.layers[layer];
+        if (!snap.enabled)
+            continue;
+        const down = snap.carriers.filter((c) => c.status === 'unreadable' || c.status === 'not-loaded');
+        if (snap.malformed || down.length > 0) {
+            appendOwnElement(out, { layer, how: 'unreadable', key: JSON.stringify([layer, 'unreadable', down.map((c) => [c.id, c.status])]) });
+            continue;
+        }
+        if (plan?.settingsSalvage.some((r) => r.source === layer && r.outcome === 'rejected') === true) {
+            appendOwnElement(out, { layer, how: 'rejected', key: JSON.stringify([layer, 'rejected', fnv1a(JSON.stringify(snap.doc))]) });
+        }
+    }
+    return out;
+}
+function notLoadedSentence(n, form) {
+    const layer = msg(`session.hostSettings.layer.${n.layer}`);
+    return renderMessage(msg(form === 'hold' ? `session.hostSettings.layerNotLoaded.hold.${n.how}` : 'session.hostSettings.layerNotLoaded.sent.unreadable', { layer }));
+}
+function settingsSideOf(input) {
+    let given;
+    let has;
+    try {
+        has = typeof input === 'object' && input !== null && Object.hasOwn(input, 'settings');
+        given = has ? input.settings : undefined;
+    }
+    catch {
+        throw new HostSettingsSourceShapeError('hostTurnSettings: reading input.settings threw — pass the HostSettingsSource for this turn, or \'none\'.');
+    }
+    if (!has || given === undefined)
+        return { kind: 'missing' };
+    if (given === 'none')
+        return { kind: 'none' };
+    return { kind: 'read', read: readHostSettingsOnce(given, 'hostTurnSettings') };
+}
+export function buildHostTurnSettings(input, judges) {
+    const materialize = judges.materialize;
     let sources;
     let sourcesThrew = false;
     try {
@@ -165,8 +596,28 @@ export function buildHostTurnSettings(input, materialize) {
         sourcesThrew = true;
     }
     const read = (key) => (sourcesThrew ? { kind: 'threw' } : readSource(sources, key));
-    const resolved = passArm('settings.resolved', 'snapshot', read('resolved'), '{ snapshot } with the resolver snapshot');
-    let resolvedCarried = resolved.carried;
+    let identityIn;
+    let previousIn;
+    try {
+        identityIn = input.identity;
+        previousIn = input.previous;
+    }
+    catch {
+        throw new HostSourceShapeError('hostTurnSettings: reading input.identity / input.previous threw (the value is not echoed).');
+    }
+    const surface = submissionSurfaceOf(identityIn);
+    if (surface === undefined)
+        throw new HostSourceShapeError('hostTurnSettings: identity must be the submission identity of this turn ({ surface, origin, tools }) — got something else (the value is not echoed).');
+    const session = sessionOf(previousIn);
+    const rawSide = settingsSideOf(input);
+    if (rawSide.kind === 'read')
+        for (const line of rawSide.read.debug)
+            hostLog('debug', line);
+    const adoption = rawSide.kind === 'read' ? adoptHostSettingsRead(rawSide.read, session, allowAdmittedFor(rawSide.read)) : undefined;
+    const side = adoption !== undefined ? { kind: 'read', read: adoption.read } : rawSide;
+    const nextSession = adoption?.session ?? remintSameContent(session);
+    const resolvedArm = permissionsArm(read('resolved'), side, adoption);
+    let resolvedCarried = resolvedArm.carried;
     let resolvedError;
     if (resolvedCarried !== undefined) {
         try {
@@ -176,25 +627,182 @@ export function buildHostTurnSettings(input, materialize) {
             resolvedError = freeze({ error });
         }
     }
-    const hooks = hooksArm(read('hooks'));
-    const webSearch = passArm('settings.webSearch', 'settings', read('webSearch'), '{ settings } with the web search settings');
-    const outputStyle = passArm('settings.outputStyle', 'name', read('outputStyle'), '{ name } with the output style name');
-    const arms = [hooks, resolved, webSearch, outputStyle];
+    const hooks = hooksArm(read('hooks'), side);
+    const webSearch = webSearchArm(read('webSearch'), side);
+    const outputStyle = outputStyleArm(read('outputStyle'), side);
+    const memory = memoryArm(read('memory'), side, judges.memoryOffDeclared);
+    const fileHistory = fileHistoryArm(read('fileHistory'));
+    let resolved = resolvedArm;
+    let armsByKey = [hooks, resolved, webSearch, outputStyle, memory, fileHistory];
+    if (side.kind === 'read' && MANAGED_READING_DISPOSITIONS[side.read.managed].commit === 'refuse') {
+        let said = false;
+        const managedArm = (a) => {
+            if (a.row.cause === 'host_port_missing' || a.row.cause === 'no_source')
+                return a;
+            const out = { row: freeze({ key: a.row.key, cause: 'source_unreadable', disposition: 'refuse_turn', layers: freeze(['policySettings']) }), notices: said ? [] : [notice('HS-MANAGED-UNREADABLE', 'turn')] };
+            said = true;
+            return out;
+        };
+        const hooksM = managedArm(hooks);
+        resolved = managedArm(resolved);
+        armsByKey = [{ ...hooksM, ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, resolved, managedArm(webSearch), outputStyle, memory, fileHistory];
+    }
+    if (adoption?.overflow === true) {
+        const over = (a) => (a.row.cause === 'host_port_missing' || a.row.cause === 'no_source' || a.row.disposition === 'refuse_turn' ? a : unreadableArm(a.row.key));
+        armsByKey = [{ ...over(armsByKey[0]), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, over(armsByKey[1]), armsByKey[2], armsByKey[3], armsByKey[4], armsByKey[5]];
+    }
+    const heldLayer = (l) => adoption !== undefined && !adoption.trusted && (session.baseline?.loaded.some((k) => k.startsWith(`${l}|`)) ?? false);
+    const notLoaded = side.kind === 'read' ? notLoadedLayers(side.read, hooks.plan).filter((n) => !heldLayer(n.layer)) : [];
+    let consentKey;
+    const notLoadedNotices = [];
+    if (notLoaded.length > 0) {
+        const key = `hs1-${fnv1a(JSON.stringify(notLoaded.map((n) => n.key)))}`;
+        const ask = surface === 'interactive' && !session.consented.includes(key);
+        const layers = freeze(notLoaded.map((n) => n.layer));
+        const cause = notLoaded.some((n) => n.how === 'unreadable') ? 'source_unreadable' : 'source_rejected';
+        const reshape = (a) => {
+            const d = a.row.disposition;
+            if (d === 'refuse_turn' || d === 'unwired' || a.row.cause === 'no_source')
+                return a;
+            const disposition = ask ? 'hold_for_consent' : a.carried !== undefined ? 'carry_partial' : 'withhold_notice';
+            return { ...a, row: freeze({ key: a.row.key, cause, disposition, layers }) };
+        };
+        const before = armsByKey;
+        armsByKey = [{ ...reshape(before[0]), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, reshape(before[1]), before[2], before[3], before[4], before[5]];
+        if (ask && armsByKey.slice(0, 2).some((a) => a.row.disposition === 'hold_for_consent'))
+            consentKey = key;
+        for (const n of notLoaded) {
+            if (consentKey !== undefined)
+                appendOwnElement(notLoadedNotices, notice('HS-LAYER-NOT-LOADED', 'turn', notLoadedSentence(n, 'hold')));
+            else if (n.how === 'unreadable')
+                appendOwnElement(notLoadedNotices, notice('HS-LAYER-NOT-LOADED', 'session', notLoadedSentence(n, 'sent')));
+        }
+    }
+    const heldNotices = [];
+    let held;
+    if (adoption?.held !== undefined) {
+        held = freeze({ wouldDrop: adoption.held.wouldDrop, version: nextSession.version });
+        const mark = (a) => (a.row.disposition === 'carry' && a.row.cause === 'carried' ? { ...a, row: freeze({ ...a.row, cause: 'held_previous' }) } : a);
+        armsByKey = [{ ...mark(armsByKey[0]), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, mark(armsByKey[1]), armsByKey[2], armsByKey[3], armsByKey[4], armsByKey[5]];
+        appendOwnElement(heldNotices, notice('HS-HELD-PREVIOUS', 'diagnostic'));
+    }
+    const arms = armsByKey;
     const rows = freeze(arms.map((a) => a.row));
-    const notices = freeze(arms.flatMap((a) => a.notices));
+    const notices = freeze([...arms.flatMap((a) => a.notices), ...notLoadedNotices, ...heldNotices]);
     const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
-    const verdict = refusal === undefined ? freeze({ kind: 'send' }) : freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notice('HS-PROJECTION', 'turn') });
+    const verdict = refusal !== undefined
+        ? freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notices.find((n) => n.plane === 'turn') ?? notice('HS-PROJECTION', 'turn') })
+        : consentKey !== undefined
+            ? freeze({ kind: 'hold', consentKey, notice: notLoadedNotices[0] })
+            : freeze({ kind: 'send' });
+    const carriedOf = (i) => {
+        const a = arms[i];
+        return a.row.disposition === 'carry' || a.row.disposition === 'carry_partial' || a.row.disposition === 'hold_for_consent' ? a.carried : undefined;
+    };
+    const hooksCarried = carriedOf(0);
+    const resolvedOut = arms[1]?.row.disposition === 'carry' || arms[1]?.row.disposition === 'carry_partial' || arms[1]?.row.disposition === 'hold_for_consent' ? resolvedCarried : undefined;
     const carried = freeze({
-        ...(hooks.carried !== undefined ? { hooks: hooks.carried } : {}),
-        ...(resolvedCarried !== undefined ? { resolved: resolvedCarried } : {}),
-        ...(webSearch.carried !== undefined ? { webSearch: webSearch.carried } : {}),
-        ...(outputStyle.carried !== undefined ? { outputStyle: outputStyle.carried } : {}),
+        ...(hooksCarried !== undefined ? { hooks: hooksCarried } : {}),
+        ...(resolvedOut !== undefined ? { resolved: resolvedOut } : {}),
+        ...(carriedOf(2) !== undefined ? { webSearch: carriedOf(2) } : {}),
+        ...(carriedOf(3) !== undefined ? { outputStyle: carriedOf(3) } : {}),
+        ...(carriedOf(4) !== undefined ? { memory: 'off' } : {}),
+        ...(carriedOf(5) !== undefined ? { fileHistory: 'disabled' } : {}),
     });
-    const product = { verdict, rows, notices, hooks: hooks.plan, carried };
-    if (resolvedError !== undefined)
+    const styleFacts = arms[3]?.row.disposition === 'carry' ? outputStyle.facts : undefined;
+    const product = { verdict, rows, notices, hooks: hooks.plan, carried, session: nextSession, outputStyle: styleFacts, held };
+    if (resolvedError !== undefined && resolvedOut !== undefined)
         Object.defineProperty(product, RESOLVED_DEFERRED_ERROR, { value: resolvedError, enumerable: false });
+    const resolvedFinal = arms[1];
+    if (resolvedFinal?.refusalCause !== undefined && resolvedFinal.row.cause === 'projection_failed' && resolvedFinal.row.disposition === 'refuse_turn') {
+        Object.defineProperty(product, REFUSAL_CAUSE, { value: freeze({ key: resolvedFinal.row.key, error: resolvedFinal.refusalCause.error }), enumerable: false });
+    }
+    if (adoption?.held?.candidate !== undefined)
+        Object.defineProperty(product, ACCEPT_CANDIDATE, { value: adoption.held.candidate, enumerable: false });
     return mint(freeze(product));
 }
+export function hostSettingsConsent(product) {
+    const snap = hostTurnSettingsOf(product);
+    if (snap === undefined || snap === UNWIRED_HOST_TURN_SETTINGS)
+        throw new HostSourceShapeError('hostSettingsConsent: pass the product returned by hostTurnSettings() for this turn (the value is not echoed).');
+    const p = snap;
+    if (p.verdict.kind !== 'hold')
+        return product;
+    const key = p.verdict.consentKey;
+    const rows = freeze(p.rows.map((r) => r.disposition !== 'hold_for_consent'
+        ? r
+        : freeze({ ...r, disposition: (Object.hasOwn(p.carried, carriedKeyOf(r.key)) ? 'carry_partial' : 'withhold_notice') })));
+    const notices = freeze(p.notices.filter((n) => !(n.id === 'HS-LAYER-NOT-LOADED' && n.plane === 'turn')));
+    const session = mintHostSettingsSession(p.session.parent, [...p.session.consented, key], p.session.baseline);
+    if (session === undefined)
+        return product;
+    return mint(freeze({ verdict: freeze({ kind: 'send' }), rows, notices, hooks: p.hooks, carried: p.carried, session, outputStyle: p.outputStyle, held: p.held }));
+}
+const ACCEPT_CANDIDATE = Symbol('hostTurnSettings.acceptCandidate');
+export function hostSettingsAcceptCurrent(product, confirmation) {
+    const c = captureConfirmation(confirmation);
+    if (c === undefined)
+        throw new HostSourceShapeError('hostSettingsAcceptCurrent: confirmation must be { version, deny, ask } — the session version of the product the user saw (held.version) and the deny / ask rules the user confirmed to stop sending (the value is not echoed).');
+    let candidate;
+    let held;
+    try {
+        if (typeof product !== 'object' || product === null)
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(product, ACCEPT_CANDIDATE);
+        candidate = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+        const h = Object.getOwnPropertyDescriptor(product, 'held');
+        held = h !== undefined && Object.hasOwn(h, 'value') ? h.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (candidate === undefined || !isRecordShape(held))
+        return undefined;
+    const h = held;
+    if (h.version !== c.version)
+        return undefined;
+    const wd = h.wouldDrop;
+    if (!isRecordShape(wd) || !Array.isArray(wd.deny) || !Array.isArray(wd.ask))
+        return undefined;
+    if (!wd.deny.every((r) => typeof r === 'string' && c.deny.includes(r)))
+        return undefined;
+    if (!wd.ask.every((r) => typeof r === 'string' && c.ask.includes(r)))
+        return undefined;
+    return candidate;
+}
+function captureConfirmation(v) {
+    const version = ownDataOf(v, 'version');
+    const deny = ownDataOf(v, 'deny');
+    const ask = ownDataOf(v, 'ask');
+    if (!version.ok || !deny.ok || !ask.ok || typeof version.value !== 'string' || version.value.length === 0)
+        return undefined;
+    const strs = (x) => {
+        try {
+            if (!Array.isArray(x))
+                return undefined;
+            const ld = Object.getOwnPropertyDescriptor(x, 'length');
+            if (ld === undefined || !Object.hasOwn(ld, 'value') || typeof ld.value !== 'number' || !Number.isSafeInteger(ld.value) || ld.value < 0 || ld.value > 100_000)
+                return undefined;
+            const len = ld.value;
+            const out = [];
+            for (let i = 0; i < len; i++) {
+                const d = Object.getOwnPropertyDescriptor(x, i);
+                if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string')
+                    return undefined;
+                appendOwnElement(out, d.value);
+            }
+            return out;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const dn = strs(deny.value);
+    const ak = strs(ask.value);
+    if (dn === undefined || ak === undefined)
+        return undefined;
+    return freeze({ version: version.value, deny: freeze(dn), ask: freeze(ak) });
+}
 export function hostSettingsSelfCheck(product) {
     try {
         const rows = product.rows;
@@ -207,17 +815,19 @@ export function hostSettingsSelfCheck(product) {
                 continue;
             seen.add(r.key);
             if (r.disposition === 'unwired' && HOST_SUPPLIED_KEYS.includes(r.key))
-                out.push(r.key);
+                appendOwnElement(out, r.key);
         }
         for (const k of HOST_SUPPLIED_KEYS)
             if (!seen.has(k) && !out.includes(k))
-                out.push(k);
+                appendOwnElement(out, k);
         return freeze(out);
     }
     catch {
         return HOST_SUPPLIED_KEYS;
     }
 }
+export const hostProjectionNotice = () => notice('HS-PROJECTION', 'turn');
+export const hostFileHistoryRestoreNotice = () => notice('HS-FILEHISTORY-RESTORE', 'turn');
 export class HostSettingsRefused extends Error {
     notice;
     constructor(n) {
@@ -260,25 +870,36 @@ export function hostTurnSettingsOf(v, depth = 'full') {
         const p = view;
         const rows = p.rows;
         const carried = p.carried;
-        const subs = HOST_SUPPLIED_KEYS.map((k) => k.slice('settings.'.length));
+        const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
         if (Object.keys(carried).some((k) => !subs.includes(k)))
             return undefined;
+        if (carried.memory !== undefined && carried.memory !== 'off')
+            return undefined;
+        if (carried.fileHistory !== undefined && carried.fileHistory !== 'disabled')
+            return undefined;
         let refuses = false;
+        let holds = false;
         for (const [i, r] of rows.entries()) {
             const disposition = r.disposition;
             if (!HOST_SETTING_DISPOSITIONS.includes(disposition))
                 return undefined;
             if (disposition === 'refuse_turn')
                 refuses = true;
+            if (disposition === 'hold_for_consent')
+                holds = true;
+            if (r.cause === 'projection_failed' && disposition !== 'refuse_turn')
+                return undefined;
             const sub = subs[i] ?? '';
             const has = Object.hasOwn(carried, sub) && carried[sub] !== undefined;
-            if (has !== CARRYING.has(disposition))
+            if (disposition !== 'hold_for_consent' && has !== CARRYING.has(disposition))
                 return undefined;
         }
         const verdict = p.verdict;
-        if (verdict.kind !== (refuses ? 'refuse' : 'send'))
+        if (verdict.kind !== (refuses ? 'refuse' : holds ? 'hold' : 'send'))
+            return undefined;
+        if ((refuses || holds) && !(isRecordShape(verdict.notice) && typeof verdict.notice.text === 'string'))
             return undefined;
-        if (refuses && !(isRecordShape(verdict.notice) && typeof verdict.notice.text === 'string'))
+        if (!refuses && holds && typeof verdict.consentKey !== 'string')
             return undefined;
         if (Object.hasOwn(carried, 'hooks') && carried.hooks !== undefined && !hooksPassJudge(carried.hooks))
             return undefined;
@@ -288,4 +909,281 @@ export function hostTurnSettingsOf(v, depth = 'full') {
         return undefined;
     }
 }
-export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {} }, (snapshot) => snapshot);
+function wireFormOf(v) {
+    const text = JSON.stringify(v);
+    return text === undefined ? undefined : JSON.parse(text);
+}
+function sameJson(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameJson(x, b[i]));
+    const ra = a;
+    const rb = b;
+    const ka = Object.keys(ra);
+    if (ka.length !== Object.keys(rb).length)
+        return false;
+    return ka.every((k) => Object.hasOwn(rb, k) && sameJson(ra[k], rb[k]));
+}
+function groupHead(g) {
+    if (!isRecordShape(g))
+        return undefined;
+    const head = {};
+    for (const k of Object.keys(g))
+        if (k !== 'hooks')
+            head[k] = g[k];
+    return head;
+}
+export function intersectHostHooks(sent, now) {
+    try {
+        return intersectHostHooksUnguarded(sent, now);
+    }
+    catch {
+        return { hooks: undefined, dropped: 0, judged: false };
+    }
+}
+function intersectHostHooksUnguarded(sentIn, nowIn) {
+    const sent = wireFormOf(sentIn);
+    const now = nowIn === undefined ? undefined : wireFormOf(nowIn);
+    const entriesOf = (cfg) => {
+        if (!isRecordShape(cfg))
+            return 0;
+        let n = 0;
+        for (const ev of Object.keys(cfg)) {
+            const groups = cfg[ev];
+            if (!Array.isArray(groups))
+                continue;
+            for (const g of groups)
+                if (isRecordShape(g) && Array.isArray(g.hooks))
+                    n += g.hooks.length;
+        }
+        return n;
+    };
+    const total = entriesOf(sent);
+    if (!isRecordShape(sent))
+        return { hooks: undefined, dropped: 0, judged: true };
+    if (!isRecordShape(now))
+        return { hooks: undefined, dropped: total, judged: true };
+    const out = {};
+    let kept = 0;
+    for (const ev of Object.keys(sent)) {
+        const groups = sent[ev];
+        const nowGroups = now[ev];
+        if (!Array.isArray(groups) || !Array.isArray(nowGroups))
+            continue;
+        const pool = nowGroups.map((g) => ({ head: groupHead(g), left: isRecordShape(g) && Array.isArray(g.hooks) ? [...g.hooks] : [] }));
+        const evOut = [];
+        for (const g of groups) {
+            const head = groupHead(g);
+            if (head === undefined || !isRecordShape(g) || !Array.isArray(g.hooks))
+                continue;
+            const keep = [];
+            for (const entry of g.hooks) {
+                for (const slot of pool) {
+                    if (slot.head === undefined || !sameJson(slot.head, head))
+                        continue;
+                    const at = slot.left.findIndex((x) => sameJson(x, entry));
+                    if (at < 0)
+                        continue;
+                    slot.left.splice(at, 1);
+                    appendOwnElement(keep, entry);
+                    break;
+                }
+            }
+            if (keep.length > 0)
+                appendOwnElement(evOut, { ...head, hooks: keep });
+            kept += keep.length;
+        }
+        if (evOut.length > 0)
+            out[ev] = evOut;
+    }
+    const hooks = Object.keys(out).length > 0 ? out : undefined;
+    return { hooks, dropped: total - kept, judged: hooks === undefined || hooksPassJudge(hooks) };
+}
+function ownDataOf(o, k) {
+    if (typeof o !== 'object' || o === null)
+        return { ok: false };
+    try {
+        return { ok: true, value: ownDataField(o, k) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function managedOnlySwitchOn(policyDoc) {
+    const r = ownDataOf(policyDoc, 'allowManagedPermissionRulesOnly');
+    return r.ok && r.value === true;
+}
+function noticeCopyOf(n) {
+    const id = ownDataOf(n, 'id');
+    const plane = ownDataOf(n, 'plane');
+    const text = ownDataOf(n, 'text');
+    if (!id.ok || !plane.ok || !text.ok || typeof id.value !== 'string' || typeof plane.value !== 'string' || typeof text.value !== 'string')
+        return undefined;
+    return freeze({ id: id.value, plane: plane.value, text: text.value });
+}
+function turnNoticesOf(product) {
+    try {
+        return turnNoticesUnguarded(product);
+    }
+    catch {
+        return undefined;
+    }
+}
+function turnNoticesUnguarded(product) {
+    const ns = ownDataOf(product, 'notices');
+    if (!ns.ok || !Array.isArray(ns.value))
+        return undefined;
+    const len = ownDataOf(ns.value, 'length');
+    if (!len.ok || typeof len.value !== 'number')
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len.value; i++) {
+        const e = ownDataOf(ns.value, String(i));
+        const copy = e.ok ? noticeCopyOf(e.value) : undefined;
+        if (copy === undefined)
+            return undefined;
+        if (copy.plane === 'turn')
+            appendOwnElement(out, copy);
+    }
+    return freeze(out);
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null) {
+        for (const x of Object.values(v))
+            deepFreeze(x);
+        Object.freeze(v);
+    }
+    return v;
+}
+export function hostIntakeSnapshotOf(product, onResolved) {
+    try {
+        return intakeSnapshotUnguarded(product, onResolved);
+    }
+    catch {
+        return undefined;
+    }
+}
+function intakeSnapshotUnguarded(product, onResolved) {
+    if (product === UNWIRED_HOST_TURN_SETTINGS) {
+        return freeze({
+            carried: freeze({}),
+            refuses: false,
+            dispositions: freeze(Object.fromEntries(HOST_SUPPLIED_KEYS.map((k) => [k, 'unwired']))),
+            refusingKeys: freeze([]),
+            turnNotices: freeze([]),
+            notice: undefined,
+            refusalCause: undefined,
+        });
+    }
+    const c = ownDataOf(product, 'carried');
+    if (!c.ok || !isRecordShape(c.value))
+        return undefined;
+    const carriedIn = c.value;
+    const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
+    let keys;
+    try {
+        keys = Reflect.ownKeys(carriedIn);
+    }
+    catch {
+        return undefined;
+    }
+    if (keys.some((k) => typeof k !== 'string' || !subs.includes(k)))
+        return undefined;
+    const values = {};
+    const resolvedR = ownDataOf(carriedIn, 'resolved');
+    if (!resolvedR.ok)
+        return undefined;
+    onResolved?.(resolvedR.value);
+    if (resolvedR.value !== undefined)
+        values.resolved = resolvedR.value;
+    for (const sub of subs.filter((x) => x !== 'resolved')) {
+        const r = ownDataOf(carriedIn, sub);
+        if (!r.ok)
+            return undefined;
+        const copy = deepFreeze(wireFormOf(r.value));
+        if (copy !== undefined)
+            values[sub] = copy;
+    }
+    const rowsR = ownDataOf(product, 'rows');
+    if (!rowsR.ok || !Array.isArray(rowsR.value) || rowsR.value.length !== HOST_SUPPLIED_KEYS.length)
+        return undefined;
+    let refuses = false;
+    let anyRefuse = false;
+    const refusingKeys = [];
+    const dispositions = {};
+    for (const [i, key] of HOST_SUPPLIED_KEYS.entries()) {
+        const rowR = ownDataOf(rowsR.value, String(i));
+        if (!rowR.ok)
+            return undefined;
+        const k = ownDataOf(rowR.value, 'key');
+        const d = ownDataOf(rowR.value, 'disposition');
+        if (!k.ok || !d.ok || k.value !== key || !HOST_SETTING_DISPOSITIONS.includes(d.value))
+            return undefined;
+        const cause = ownDataOf(rowR.value, 'cause');
+        if (!cause.ok || (cause.value === 'projection_failed' && d.value !== 'refuse_turn'))
+            return undefined;
+        if (d.value === 'refuse_turn' || d.value === 'hold_for_consent') {
+            refuses = true;
+            appendOwnElement(refusingKeys, key);
+        }
+        if (d.value === 'refuse_turn')
+            anyRefuse = true;
+        dispositions[key] = d.value;
+        if (d.value !== 'hold_for_consent' && (values[carriedKeyOf(key)] !== undefined) !== CARRYING.has(d.value))
+            return undefined;
+    }
+    if (values.memory !== undefined && values.memory !== 'off')
+        return undefined;
+    if (values.fileHistory !== undefined && values.fileHistory !== 'disabled')
+        return undefined;
+    if (values.hooks !== undefined && !hooksPassJudge(values.hooks))
+        return undefined;
+    const v = ownDataOf(product, 'verdict');
+    if (!v.ok)
+        return undefined;
+    const kind = ownDataOf(v.value, 'kind');
+    if (!kind.ok || kind.value !== (anyRefuse ? 'refuse' : refuses ? 'hold' : 'send'))
+        return undefined;
+    const noticeR = refuses ? ownDataOf(v.value, 'notice') : undefined;
+    const notice = noticeR === undefined ? undefined : ((noticeR.ok ? noticeCopyOf(noticeR.value) : undefined) ?? hostProjectionNotice());
+    return freeze({
+        carried: freeze(values),
+        refuses,
+        dispositions: freeze(dispositions),
+        refusingKeys: freeze(refusingKeys),
+        turnNotices: turnNoticesOf(product),
+        notice,
+        refusalCause: anyRefuse ? refusalCauseOf(product) : undefined,
+    });
+}
+function refusalCauseOf(product) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(product, REFUSAL_CAUSE);
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hostSettingsRefusedError(n, intake, firstSeatedKey) {
+    const e = new HostSettingsRefused(n);
+    const cause = intake.refusalCause;
+    if (cause !== undefined && firstSeatedKey === cause.key && n.id === 'HS-PROJECTION')
+        Object.defineProperty(e, 'cause', { value: cause.error, writable: true, enumerable: false, configurable: true });
+    return e;
+}
+const UNWIRED_IDENTITY = Object.freeze({ surface: 'print', origin: 'user', tools: 'full' });
+export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {}, identity: UNWIRED_IDENTITY }, {
+    materialize: (snapshot) => snapshot,
+    memoryOffDeclared: () => false,
+});
+function carriedKeyOf(k) {
+    return k.startsWith('settings.') ? k.slice('settings.'.length) : k;
+}
+const _armsPin = [true, true, true, true];
+void _armsPin;