@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/sessionBackgroundHandoff.d.ts

@@ -0,0 +1,54 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type BackgroundHandoffVerdict, type InteractiveEngineWire } from './sessionBackground.js';
+export declare const BACKGROUND_HANDOFF_ABORT_REASON = "background";
+export interface BackgroundHandoffRequest {
+    readonly wire: InteractiveEngineWire | undefined;
+    readonly sessionKey: string;
+    readonly onHandedOff: (reason: typeof BACKGROUND_HANDOFF_ABORT_REASON) => void;
+    readonly lang?: UiLanguage;
+}
+export type BackgroundHandoffOutcome = {
+    readonly kind: 'kept';
+    readonly verdict: Exclude<BackgroundHandoffVerdict, {
+        verdict: 'eligible';
+    }>;
+    readonly sentence: string;
+} | {
+    readonly kind: 'handed-off';
+    readonly run: BackgroundRun;
+    readonly hostNotified: boolean;
+    readonly sentence: string;
+};
+export interface BackgroundRun {
+    readonly taskId: string;
+    openFrames(signal?: AbortSignal): AsyncGenerator<AgentEvent>;
+    readonly settled: Promise<BackgroundRunSettlement>;
+    dispose(): void;
+}
+export type BackgroundRunSettlement = {
+    readonly runEnded: true;
+    readonly kind: 'completed' | 'failed' | 'cancelled' | 'parked';
+    readonly status: string;
+    readonly errorCode?: string;
+    readonly sentence: string;
+} | {
+    readonly runEnded: false;
+    readonly kind: 'observation-stopped';
+    readonly cause: 'window-exhausted' | 'disposed' | 'engine-ended';
+    readonly sentence: string;
+};
+export interface HandedOffRunRow {
+    readonly taskId: string;
+    readonly sessionKey: string;
+    readonly state: 'running' | 'ended' | 'unconfirmed';
+}
+export type HandedOffRunsReading = {
+    readonly kind: 'read';
+    readonly runs: readonly HandedOffRunRow[];
+} | {
+    readonly kind: 'unrecognized-wire';
+};
+export declare function handoffInteractiveRun(req: BackgroundHandoffRequest): BackgroundHandoffOutcome;
+export declare function handedOffRunsOf(wire: InteractiveEngineWire): HandedOffRunsReading;
+export declare function forgetHandedOffRun(wire: InteractiveEngineWire, taskId: string): boolean;

package/dist/sessionBackgroundHandoff.js

@@ -0,0 +1,321 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { abortableSleep } from './abortableSleep.js';
+import { REATTACH_WINDOW_MS, reattachBackoffMs } from './reattachWindow.js';
+import { terminalEventFromRunRow } from './headlessReconnectWire.js';
+import { RUN_CANCELLED_CODE } from './runCancelContext.js';
+import { readRunTerminal } from './runTerminal.js';
+import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { backgroundHandoffSentence, judgeHandoff, ownSlotOf, wireStateOf, } from './sessionBackground.js';
+export const BACKGROUND_HANDOFF_ABORT_REASON = 'background';
+const HANDED_OFF_ENDED_CAP = 256;
+const isObj = (v) => (typeof v === 'object' && v !== null) || typeof v === 'function';
+function slot(o, key) {
+    try {
+        return readOwnDataValue(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function slotString(o, key) {
+    try {
+        return readOwnDataNonEmptyString(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function executionSettlementOf(ev) {
+    try {
+        const type = slot(ev, 'type');
+        if (type === 'failed') {
+            const code = slotString(ev, 'errorCode');
+            if (code === RUN_CANCELLED_CODE)
+                return { runEnded: true, kind: 'cancelled', status: 'failed' };
+            return { runEnded: true, kind: 'failed', status: 'failed', ...(code !== undefined ? { errorCode: code } : {}) };
+        }
+        if (type !== 'done' || slot(ev, 'replay') === true)
+            return undefined;
+        const read = readRunTerminal(slot(ev, 'result'));
+        if (read === null)
+            return { runEnded: true, kind: 'completed', status: 'completed' };
+        switch (read.kind) {
+            case 'completed':
+                return { runEnded: true, kind: 'completed', status: 'completed' };
+            case 'paused':
+                return { runEnded: true, kind: 'parked', status: read.flatStatus ?? 'paused' };
+            case 'failed':
+                if (read.code === RUN_CANCELLED_CODE)
+                    return { runEnded: true, kind: 'cancelled', status: 'failed' };
+                return { runEnded: true, kind: 'failed', status: 'failed', ...(read.code !== undefined ? { errorCode: read.code } : {}) };
+            case 'blocked':
+                return { runEnded: true, kind: 'failed', status: 'blocked', ...(read.code !== undefined ? { errorCode: read.code } : {}) };
+            case 'unknown':
+                return { runEnded: true, kind: 'failed', status: read.word ?? 'unknown', ...(read.code !== undefined ? { errorCode: read.code } : {}) };
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function settlementSentence(s, lang) {
+    if (!s.runEnded)
+        return renderMessage(msg('session.background.settled.observationStopped'), lang);
+    switch (s.kind) {
+        case 'completed':
+            return renderMessage(msg('session.background.settled.completed'), lang);
+        case 'cancelled':
+            return renderMessage(msg('session.background.settled.cancelled'), lang);
+        case 'parked':
+            return renderMessage(msg('session.background.settled.parked'), lang);
+        case 'failed':
+            return renderMessage(msg('session.background.settled.failed', { code: s.errorCode ?? s.status }), lang);
+    }
+}
+function runRowOf(row) {
+    if (!isObj(row))
+        return null;
+    const status = slotString(row, 'status');
+    if (status === undefined)
+        return null;
+    const result = slot(row, 'result');
+    const errorCode = slotString(row, 'errorCode');
+    const error = slotString(row, 'error');
+    return {
+        status,
+        ...(result !== undefined ? { result } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(error !== undefined ? { error } : {}),
+    };
+}
+async function readRunRow(state, taskId, sessionId, signal) {
+    try {
+        const row = await state.get(taskId, signal !== undefined ? { session: sessionId, signal } : { session: sessionId });
+        return runRowOf(row);
+    }
+    catch {
+        return null;
+    }
+}
+async function* framesEndedWith(error) {
+    throw error;
+}
+function trimHandedOff(state) {
+    let ended = 0;
+    for (const e of state.handedOff.values())
+        if (e.state === 'ended')
+            ended++;
+    if (ended <= HANDED_OFF_ENDED_CAP)
+        return;
+    for (const [taskId, e] of [...state.handedOff]) {
+        if (ended <= HANDED_OFF_ENDED_CAP)
+            break;
+        if (e.state !== 'ended')
+            continue;
+        state.handedOff.delete(taskId);
+        ended--;
+    }
+}
+function ledgerSeqOf(ev) {
+    const id = slotString(ev, 'id');
+    return id !== undefined && /^\d+$/.test(id) ? Number(id) : undefined;
+}
+async function pump(state, taskId, sessionId, signal, finish) {
+    let deadline = Date.now() + REATTACH_WINDOW_MS;
+    let attempt = 0;
+    let farthest = -1;
+    for (;;) {
+        if (signal.aborted)
+            return;
+        let progressed = false;
+        try {
+            const frames = state.events(taskId, { session: sessionId, signal });
+            for await (const ev of frames) {
+                if (signal.aborted)
+                    return;
+                const seq = ledgerSeqOf(ev);
+                if (seq !== undefined && seq > farthest) {
+                    farthest = seq;
+                    progressed = true;
+                }
+                const s = executionSettlementOf(ev);
+                if (s !== undefined) {
+                    finish(s);
+                    return;
+                }
+            }
+        }
+        catch {
+        }
+        if (signal.aborted)
+            return;
+        const row = await readRunRow(state, taskId, sessionId, signal);
+        if (signal.aborted)
+            return;
+        const synthesized = terminalEventFromRunRow(row);
+        const s = synthesized === null ? undefined : executionSettlementOf(synthesized);
+        if (s !== undefined) {
+            finish(s);
+            return;
+        }
+        if (progressed) {
+            deadline = Date.now() + REATTACH_WINDOW_MS;
+            attempt = 0;
+        }
+        if (Date.now() >= deadline) {
+            finish({ runEnded: false, kind: 'observation-stopped', cause: 'window-exhausted' });
+            return;
+        }
+        attempt++;
+        await abortableSleep(reattachBackoffMs(attempt), signal);
+    }
+}
+function startBackground(state, taskId, sessionKey, sessionId, lang) {
+    const controller = new AbortController();
+    let resolveSettled = () => { };
+    const settled = new Promise((resolve) => {
+        resolveSettled = resolve;
+    });
+    let done = false;
+    let reconciling = false;
+    const finish = (s) => {
+        if (done)
+            return;
+        done = true;
+        entry.state = s.runEnded ? 'ended' : 'unconfirmed';
+        controller.abort();
+        resolveSettled(Object.freeze({ ...s, sentence: settlementSentence(s, lang) }));
+        if (s.runEnded)
+            trimHandedOff(state);
+    };
+    const entry = {
+        taskId,
+        sessionKey,
+        state: 'running',
+        stop: (cause) => finish({ runEnded: false, kind: 'observation-stopped', cause }),
+        reconcile: () => {
+            if (entry.state !== 'unconfirmed' || reconciling || state.retired)
+                return;
+            reconciling = true;
+            void readRunRow(state, taskId, sessionId, undefined)
+                .then((row) => {
+                const synthesized = terminalEventFromRunRow(row);
+                const s = synthesized === null ? undefined : executionSettlementOf(synthesized);
+                if (s !== undefined && s.runEnded && entry.state === 'unconfirmed') {
+                    entry.state = 'ended';
+                    trimHandedOff(state);
+                }
+            })
+                .finally(() => {
+                reconciling = false;
+            });
+        },
+    };
+    state.handedOff.set(taskId, entry);
+    void pump(state, taskId, sessionId, controller.signal, finish).catch(() => finish({ runEnded: false, kind: 'observation-stopped', cause: 'window-exhausted' }));
+    const run = Object.freeze({
+        taskId,
+        openFrames(signal) {
+            try {
+                return state.events(taskId, signal !== undefined ? { session: sessionId, signal } : { session: sessionId });
+            }
+            catch (e) {
+                return framesEndedWith(e);
+            }
+        },
+        settled,
+        dispose() {
+            finish({ runEnded: false, kind: 'observation-stopped', cause: 'disposed' });
+        },
+    });
+    return run;
+}
+function snapshotHandoffRequest(req) {
+    if (!isObj(req))
+        return { readable: false, wire: undefined, sessionKey: undefined, onHandedOff: undefined, lang: undefined };
+    const wireSlot = ownSlotOf(req, 'wire');
+    const sessionKey = slotString(req, 'sessionKey');
+    const onHandedOff = slot(req, 'onHandedOff');
+    const lang = slot(req, 'lang');
+    return {
+        readable: sessionKey !== undefined && typeof onHandedOff === 'function',
+        wire: wireSlot.state === 'unreadable' ? {} : wireSlot.state === 'data' ? wireSlot.value : undefined,
+        sessionKey,
+        onHandedOff: typeof onHandedOff === 'function' ? onHandedOff : undefined,
+        lang: typeof lang === 'string' ? lang : undefined,
+    };
+}
+function keptOf(verdict, lang) {
+    const v = verdict.verdict === 'eligible' ? Object.freeze({ verdict: 'unknown', reason: 'unreadable-input' }) : verdict;
+    const sentence = backgroundHandoffSentence(v, lang) ?? renderMessage(msg('session.background.unknown'), lang);
+    return Object.freeze({ kind: 'kept', verdict: v, sentence });
+}
+export function handoffInteractiveRun(req) {
+    let snap;
+    try {
+        snap = snapshotHandoffRequest(req);
+    }
+    catch {
+        return keptOf(Object.freeze({ verdict: 'unknown', reason: 'unreadable-input' }), undefined);
+    }
+    const lang = snap.lang;
+    if (!snap.readable || snap.sessionKey === undefined || snap.onHandedOff === undefined) {
+        return keptOf(Object.freeze({ verdict: 'unknown', reason: 'unreadable-input' }), lang);
+    }
+    const judged = judgeHandoff({ wire: snap.wire, sessionKey: snap.sessionKey });
+    const { verdict, rec, state } = judged;
+    if (verdict.verdict !== 'eligible' || rec === undefined || state === undefined || rec.sessionId === undefined)
+        return keptOf(verdict, lang);
+    const taskId = verdict.taskId;
+    const sessionId = rec.sessionId;
+    rec.phase = 'handing-off';
+    try {
+        rec.tear(BACKGROUND_HANDOFF_ABORT_REASON);
+    }
+    catch {
+    }
+    rec.phase = 'handed-off';
+    const run = startBackground(state, taskId, snap.sessionKey, sessionId, lang);
+    let hostNotified = true;
+    try {
+        snap.onHandedOff(BACKGROUND_HANDOFF_ABORT_REASON);
+    }
+    catch {
+        hostNotified = false;
+    }
+    const sentence = renderMessage(msg(hostNotified ? 'session.background.handedOff' : 'session.background.hostNotNotified'), lang);
+    return Object.freeze({ kind: 'handed-off', run, hostNotified, sentence });
+}
+export function handedOffRunsOf(wire) {
+    try {
+        const state = wireStateOf(wire);
+        if (state === undefined)
+            return Object.freeze({ kind: 'unrecognized-wire' });
+        const runs = [];
+        for (const e of state.handedOff.values()) {
+            if (e.state === 'unconfirmed')
+                e.reconcile();
+            runs.push(Object.freeze({ taskId: e.taskId, sessionKey: e.sessionKey, state: e.state }));
+        }
+        return Object.freeze({ kind: 'read', runs: Object.freeze(runs) });
+    }
+    catch {
+        return Object.freeze({ kind: 'unrecognized-wire' });
+    }
+}
+export function forgetHandedOffRun(wire, taskId) {
+    try {
+        const state = wireStateOf(wire);
+        if (state === undefined || typeof taskId !== 'string')
+            return false;
+        const entry = state.handedOff.get(taskId);
+        if (entry === undefined)
+            return false;
+        entry.stop('disposed');
+        state.handedOff.delete(taskId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sessionMap.js

@@ -2,7 +2,10 @@ export function engineNamespaceKeyFor(baseUrl) {
     if (!baseUrl)
         return 'local';
     try {
-        return new URL(baseUrl).origin.toLowerCase();
+        const u = new URL(baseUrl);
+        if (!/^(?:https?|wss?|ftp):$/.test(u.protocol))
+            return baseUrl.toLowerCase();
+        return u.origin.toLowerCase() + u.pathname.replace(/\/+$/, '');
     }
     catch {
         return baseUrl.toLowerCase();

package/dist/sessionPolicyCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'sessionPolicy',
     project: projectSessionPolicyCapability,
 });
-export function observedSessionPolicy(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSessionPolicy(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function sessionPolicyFaceAvailable(reading) {

package/dist/sessionRulesChildrenReadLive.d.ts

@@ -0,0 +1,6 @@
+export interface SessionRulesManifestSeat {
+    readonly sessionRules?: {
+        readonly childrenReadLive?: boolean;
+    };
+}
+export declare function sessionRulesChildrenReadLiveOf(manifest: SessionRulesManifestSeat | null | undefined): boolean | undefined;

package/dist/sessionRulesChildrenReadLive.js

@@ -0,0 +1,5 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export function sessionRulesChildrenReadLiveOf(manifest) {
+    const raw = guardedRead(() => readOwnDataValue(readOwnDataValue(manifest, 'sessionRules'), 'childrenReadLive'));
+    return typeof raw === 'boolean' ? raw : undefined;
+}

package/dist/sessionRulesNamespaceFormsCapability.d.ts

@@ -0,0 +1,12 @@
+export type SessionRulesNamespaceFormsReading = {
+    readonly kind: 'confirmed';
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedSessionRulesNamespaceForms(baseUrl?: string | undefined): SessionRulesNamespaceFormsReading;

package/dist/sessionRulesNamespaceFormsCapability.js

@@ -0,0 +1,29 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+const SESSION_RULES_NAMESPACE_FORMS_KEY = 'sessionRulesNamespaceForms';
+const CONFIRMED = Object.freeze({ kind: 'confirmed' });
+const ABSENT = Object.freeze({ kind: 'absent' });
+const DECLINED = Object.freeze({ kind: 'declined' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+export function observedSessionRulesNamespaceForms(baseUrl) {
+    try {
+        const base = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const slot = engineCapValue(typeof base === 'string' ? base : undefined, SESSION_RULES_NAMESPACE_FORMS_KEY);
+        switch (slot.kind) {
+            case 'unobserved':
+                return UNOBSERVED;
+            case 'not_reported':
+                return ABSENT;
+            case 'unreadable':
+                return UNREADABLE;
+            case 'null':
+                return DECLINED;
+            case 'value':
+                return slot.value === true ? CONFIRMED : DECLINED;
+        }
+    }
+    catch {
+        return UNOBSERVED;
+    }
+}

package/dist/sessionSyncFileHistoryCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSessionSyncFileHistoryCapability(caps) {
@@ -20,7 +20,7 @@ const reader = createEngineCapReader({
     name: 'sessionSyncFileHistory',
     project: projectSessionSyncFileHistoryCapability,
 });
-export function observedSessionSyncFileHistory(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSessionSyncFileHistory(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function sessionSyncFileHistoryAvailable(reading) {

package/dist/settingsCredentialKeyPaths.js

@@ -1,4 +1,4 @@
-import { looksLikeKnownSecret, queryCarriesCredential } from './displayUntrusted.js';
+import { configuredValueCarriesCredential, looksLikeKnownSecret, percentBoundaryReadingOf } from './displayUntrusted.js';
 const CREDENTIAL_WORDS = new Set([
     'key', 'keys', 'apikey', 'token', 'tokens', 'secret', 'secrets', 'password', 'passwd', 'pass', 'pwd', 'pin', 'otp',
     'auth', 'authorization', 'credential', 'credentials', 'cookie', 'cookies', 'session', 'private', 'cert', 'signature', 'salt',
@@ -6,6 +6,9 @@ const CREDENTIAL_WORDS = new Set([
 const CREDENTIAL_STEMS = ['PASSWORD', 'PASSWD', 'SECRET', 'TOKEN', 'APIKEY', 'CREDENTIAL', 'COOKIE', 'PRIVATE'];
 const CREDENTIAL_SUFFIXES = ['PASS', 'PWD', 'KEY', 'AUTH'];
 const SECRET_CONFIG_NAME = /(?:^|[-_.])(?:token|key|secret|password|authorization|credential|cookie)s?$/i;
+const FLATTENED_CREDENTIAL_TAILS = [
+    'apikey', 'token', 'tokens', 'secret', 'secrets', 'password', 'passwd', 'credential', 'credentials', 'cookie', 'cookies', 'authorization',
+];
 export function credentialNameWords(name) {
     if (typeof name !== 'string')
         return [];
@@ -24,30 +27,67 @@ export function isCredentialEnvName(name) {
     const upper = name.toUpperCase();
     return CREDENTIAL_STEMS.some((stem) => upper.includes(stem)) || CREDENTIAL_SUFFIXES.some((suffix) => upper.endsWith(suffix));
 }
+function legacyNameWords(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .split(/[_\-.\s]+/)
+        .filter((w) => w.length > 0)
+        .map((w) => w.toLowerCase());
+}
 export function isCredentialConfigKey(name) {
     if (typeof name !== 'string')
         return false;
     const words = credentialNameWords(name);
     const last = words[words.length - 1];
-    return SECRET_CONFIG_NAME.test(name) || (last !== undefined && CREDENTIAL_WORDS.has(last));
+    if (SECRET_CONFIG_NAME.test(name) || (last !== undefined && CREDENTIAL_WORDS.has(last)))
+        return true;
+    const legacy = legacyNameWords(name);
+    const legacyLast = legacy[legacy.length - 1];
+    if (legacyLast !== undefined && CREDENTIAL_WORDS.has(legacyLast))
+        return true;
+    const flattened = name.replace(/[_\-.\s]+/g, '').toLowerCase();
+    return FLATTENED_CREDENTIAL_TAILS.some((tail) => flattened.endsWith(tail));
 }
 const DECIMAL_INTEGER_RE = /^\s*\d+\s*$/;
-function stringCarriesCredential(value) {
-    if (looksLikeKnownSecret(value))
-        return true;
-    const text = value.trim();
-    if (!text.includes('://'))
-        return false;
-    let url;
-    try {
-        url = new URL(text);
-    }
-    catch {
+function percentDecodeOnce(s) {
+    return s.indexOf('%') === -1 ? s : s.replace(/%([0-7][0-9A-Fa-f])/g, (_m, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+const SCHEME_THEN_ENCODED_SPACE = /(?:^|[^A-Za-z0-9])(?:bearer|basic)(?:\+|%20)[^\s+%]{1,4096}/i;
+const FORM_READING_MAX_LAYERS = 3;
+function formEncodedCarriesCredential(value) {
+    if (value.indexOf('+') === -1 && value.indexOf('%') === -1)
         return false;
+    let layer = value;
+    for (let depth = 0;; depth++) {
+        const boundary = percentBoundaryReadingOf(layer);
+        for (const reading of boundary === layer ? [layer] : [layer, boundary]) {
+            if (SCHEME_THEN_ENCODED_SPACE.test(reading))
+                return true;
+            if (reading.indexOf('+') !== -1 && looksLikeKnownSecret(reading.replace(/\+/g, ' ')))
+                return true;
+        }
+        const next = percentDecodeOnce(layer);
+        if (next === layer)
+            return false;
+        if (depth === FORM_READING_MAX_LAYERS)
+            return true;
+        layer = next;
     }
-    if (url.username !== '' || url.password !== '')
+}
+function stringCarriesCredential(value) {
+    if (looksLikeKnownSecret(value) || formEncodedCarriesCredential(value))
         return true;
-    return url.search.length > 1 && queryCarriesCredential(url.search.slice(1));
+    let layer = value;
+    for (let depth = 0;; depth++) {
+        if (configuredValueCarriesCredential(layer))
+            return true;
+        if (depth === FORM_READING_MAX_LAYERS)
+            return false;
+        const next = percentDecodeOnce(layer);
+        if (next === layer)
+            return false;
+        layer = next;
+    }
 }
 const ENV_ASSIGNMENT_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s;
 const LONG_OPTION_RE = /^--?([A-Za-z][A-Za-z0-9_-]*)(?:=(.*))?$/s;

package/dist/settingsHooksSalvage.d.ts

@@ -41,4 +41,5 @@ export declare function hooksSalvageMaskOf(dropped: readonly {
 }[]): HooksSalvageMask;
 export declare function salvageSettingsHooksEntries(doc: SettingsDocument | null | undefined): HooksSalvage;
 export declare const HOOK_SETTINGS_SOURCE_TEXT: Readonly<Record<HookSettingsSource, string>>;
+export declare function layerNotAppliedRefusesTurn(source: HookSettingsSource): boolean;
 export declare function settingsHooksSalvageNotice(salvage: HooksSalvage, source: HookSettingsSource, doc?: SettingsDocument | null): string | undefined;

package/dist/settingsHooksSalvage.js

@@ -1,4 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
 const _tuplePins = [true, true, true, true, true, true];
 void _tuplePins;
@@ -116,6 +117,9 @@ export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
     localSettings: 'Local settings',
     flagSettings: 'Flag settings',
 });
+export function layerNotAppliedRefusesTurn(source) {
+    return source === 'policySettings';
+}
 const SALVAGE_LABEL_MAX = 80;
 const SALVAGE_PIECES_SHOWN = 3;
 const labelOf = (s) => (typeof s === 'number' ? String(s) : displayUntrusted(s, { max: SALVAGE_LABEL_MAX }));
@@ -194,11 +198,13 @@ export function settingsHooksSalvageNotice(salvage, source, doc) {
     try {
         if (salvage.outcome === 'loaded-partial') {
             const what = joinPhrases(salvage.dropped.map((d) => ({ key: d.path.join('\u0000'), text: dropPhrase(d, doc) })));
+            if (layerNotAppliedRefusesTurn(source))
+                return renderMessage(msg('config.hooks.salvage.managedPartial', { layer, what }));
             return `${layer}: ${what}. The rest of this file's hooks are applied.`;
         }
         if (salvage.outcome === 'rejected') {
             const why = joinPhrases(salvage.rejections.map((r) => ({ key: r.path.join('\u0000'), text: rejectionPhrase(r) })));
-            if (source === 'policySettings') {
+            if (layerNotAppliedRefusesTurn(source)) {
                 return `${layer}: hooks could not be loaded — ${why}. Requests are not sent while the managed hooks cannot be applied; ask your administrator to fix the managed settings.`;
             }
             return `${layer}: hooks were not loaded — ${why}; ${GUARD_RISK_TAIL}.`;

package/dist/settingsLayerAdmission.d.ts

@@ -0,0 +1,4 @@
+import type { HostSettingsLayer, WorkspaceTrustState } from './hostSettingsSource.js';
+export declare function layerAdmissionWord(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): string;
+export declare function layerAdmitted(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): boolean;
+export declare function admittedLayers<L extends HostSettingsLayer>(layers: readonly L[], trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): readonly L[];

package/dist/settingsLayerAdmission.js

@@ -0,0 +1,16 @@
+import { SETTINGS_LAYER_ADMISSION } from './generated/settingsSchemaFns.js';
+const TRUST_UNREADABLE_READING = 'declined';
+const ADMITTED = 'admitted';
+function layerAdmissionOf(layer, trust, category, member) {
+    const reading = trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+    return member === undefined ? SETTINGS_LAYER_ADMISSION(layer, reading, category) : SETTINGS_LAYER_ADMISSION(layer, reading, category, member);
+}
+export function layerAdmissionWord(layer, trust, category, member) {
+    return layerAdmissionOf(layer, trust, category, member);
+}
+export function layerAdmitted(layer, trust, category, member) {
+    return layerAdmissionOf(layer, trust, category, member) === ADMITTED;
+}
+export function admittedLayers(layers, trust, category, member) {
+    return layers.filter((layer) => layerAdmitted(layer, trust, category, member));
+}

package/dist/skillToolListsCapability.js

@@ -1,7 +1,7 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { ownDataField } from './ownKey.js';
+import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -21,13 +21,14 @@ const reader = createEngineCapReader({
     name: 'skillToolLists',
     project: projectSkillToolListsCapability,
 });
-export function observedSkillToolLists(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSkillToolLists(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function skillToolListsAvailable(reading) {
-    if (reading.kind === 'present')
+    const kind = guardedRead(() => readOwnDataValue(reading, 'kind'));
+    if (kind === 'present')
         return 'yes';
-    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+    if (kind === 'absent' || kind === 'not_reported')
         return 'no';
     return 'unknown';
 }