@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/engineWireFor.js

@@ -0,0 +1,399 @@
+import { settleWithinDeadline } from './abortableSleep.js';
+import { makeEngineWireClient } from './engineWireSdk.js';
+import { engineWireTargetFor } from './engineWireTarget.js';
+export const INJECTED_WIRE_SETTLE_MS = 60_000;
+export function engineWireFor(wire, sessionKey, usable) {
+    if (wire !== undefined) {
+        let client;
+        let capsBaseUrl;
+        try {
+            if (wire === null || typeof wire !== 'object')
+                return { kind: 'injected-unusable' };
+            client = wire.client;
+            capsBaseUrl = wire.capsBaseUrl;
+        }
+        catch {
+            return { kind: 'injected-unusable' };
+        }
+        if (client === null || typeof client !== 'object')
+            return { kind: 'injected-unusable' };
+        const candidate = client;
+        if (!usable(candidate))
+            return { kind: 'injected-unusable' };
+        return { kind: 'injected', client: candidate, capsBaseUrl: typeof capsBaseUrl === 'string' && capsBaseUrl !== '' ? capsBaseUrl : undefined };
+    }
+    const installed = engineWireTargetFor(sessionKey);
+    if (!installed)
+        return { kind: 'no-target' };
+    const target = Object.freeze({
+        baseUrl: installed.baseUrl,
+        ...(installed.token !== undefined ? { token: installed.token } : {}),
+        ...(installed.principal !== undefined ? { principal: installed.principal } : {}),
+    });
+    return {
+        kind: 'target',
+        target,
+        make: (opts) => makeEngineWireClient({
+            baseUrl: target.baseUrl,
+            ...(target.token ? { token: target.token } : {}),
+            principal: target.principal,
+            ...(opts?.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
+            ...(opts?.maxRetries !== undefined ? { maxRetries: opts.maxRetries } : {}),
+        }),
+    };
+}
+export function clientHasVerbs(client, verbs) {
+    try {
+        if (client === null || typeof client !== 'object')
+            return false;
+        for (const path of verbs) {
+            let cur = client;
+            for (const seg of path) {
+                if (cur === null || (typeof cur !== 'object' && typeof cur !== 'function'))
+                    return false;
+                cur = cur[seg];
+            }
+            if (typeof cur !== 'function')
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function callerSignalOf(signal) {
+    return signal === null ? undefined : signal;
+}
+function quietlyRemoveAbortListener(signal, listener) {
+    try {
+        signal.removeEventListener('abort', listener);
+    }
+    catch {
+    }
+}
+export function linkedAbortSignal(caller, deadline) {
+    const from = callerSignalOf(caller);
+    if (from === undefined)
+        return { signal: deadline, dispose: () => { } };
+    if (typeof AbortSignal.any === 'function')
+        return { signal: AbortSignal.any([from, deadline]), dispose: () => { } };
+    const ac = new AbortController();
+    if (from.aborted || deadline.aborted) {
+        ac.abort();
+        return { signal: ac.signal, dispose: () => { } };
+    }
+    const onAbort = () => ac.abort();
+    from.addEventListener('abort', onAbort, { once: true });
+    deadline.addEventListener('abort', onAbort, { once: true });
+    return {
+        signal: ac.signal,
+        dispose: () => {
+            quietlyRemoveAbortListener(from, onAbort);
+            quietlyRemoveAbortListener(deadline, onAbort);
+        },
+    };
+}
+export function injectedDeadlineDetail(ms) {
+    const within = ms === undefined ? 'the time limit this client allows' : `${ms} ms`;
+    return `no answer from the engine within ${within} — the request was abandoned (it may still have been received)`;
+}
+const NO_ANSWER_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-no-answer');
+const CANCELLED_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-cancelled');
+function branded(e, brand) {
+    return Object.prototype.hasOwnProperty.call(e, brand) && e[brand] === true;
+}
+export class EngineWireNoAnswerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EngineWireNoAnswerError';
+        Object.defineProperty(this, NO_ANSWER_BRAND, { value: true, enumerable: false });
+    }
+}
+export function cancelledWaitDetail() {
+    return 'no answer from the engine — the wait was cancelled after the request was sent (cancelling stops only the wait, not the request: it may still have been received)';
+}
+export class EngineWireCancelledError extends Error {
+    constructor() {
+        super(cancelledWaitDetail());
+        this.name = 'EngineWireCancelledError';
+        Object.defineProperty(this, CANCELLED_BRAND, { value: true, enumerable: false });
+    }
+}
+const NOT_SENT_MARK = Symbol.for('@sema-agent/client-core:engine-wire-not-sent');
+function markNotSent(error) {
+    try {
+        if (error !== null && (typeof error === 'object' || typeof error === 'function') && Object.isExtensible(error)) {
+            Object.defineProperty(error, NOT_SENT_MARK, { value: true, enumerable: false, configurable: true, writable: false });
+        }
+    }
+    catch {
+    }
+    return error;
+}
+function clearNotSent(error) {
+    try {
+        if (error !== null && (typeof error === 'object' || typeof error === 'function') && Object.prototype.hasOwnProperty.call(error, NOT_SENT_MARK)) {
+            delete error[NOT_SENT_MARK];
+        }
+    }
+    catch {
+    }
+    return error;
+}
+function markedNotSent(e) {
+    return Object.prototype.hasOwnProperty.call(e, NOT_SENT_MARK) && e[NOT_SENT_MARK] === true;
+}
+export function connectionLostDetail() {
+    return 'no answer from the engine — the connection failed before an answer came back (the request may still have been received)';
+}
+function isPreSendCode(code, syscall) {
+    switch (code) {
+        case 'ECONNREFUSED':
+        case 'ENOTFOUND':
+        case 'EAI_AGAIN':
+        case 'UND_ERR_CONNECT_TIMEOUT':
+        case 'ERR_INVALID_URL':
+        case 'ERR_INVALID_CHAR':
+        case 'ERR_HTTP_INVALID_HEADER_VALUE':
+        case 'ERR_INVALID_ARG_TYPE':
+        case 'ERR_TLS_CERT_ALTNAME_FORMAT':
+        case 'ERR_TLS_CERT_ALTNAME_INVALID':
+        case 'ERR_TLS_DH_PARAM_SIZE':
+        case 'ERR_TLS_HANDSHAKE_TIMEOUT':
+        case 'ERR_TLS_INVALID_CONTEXT':
+        case 'ERR_TLS_INVALID_PROTOCOL_METHOD':
+        case 'ERR_TLS_INVALID_PROTOCOL_VERSION':
+        case 'ERR_TLS_PROTOCOL_VERSION_CONFLICT':
+        case 'CERT_CHAIN_TOO_LONG':
+        case 'CERT_HAS_EXPIRED':
+        case 'CERT_NOT_YET_VALID':
+        case 'CERT_REJECTED':
+        case 'CERT_REVOKED':
+        case 'CERT_SIGNATURE_FAILURE':
+        case 'CERT_UNTRUSTED':
+        case 'CRL_HAS_EXPIRED':
+        case 'CRL_NOT_YET_VALID':
+        case 'CRL_SIGNATURE_FAILURE':
+        case 'DEPTH_ZERO_SELF_SIGNED_CERT':
+        case 'ERROR_IN_CERT_NOT_AFTER_FIELD':
+        case 'ERROR_IN_CERT_NOT_BEFORE_FIELD':
+        case 'ERROR_IN_CRL_LAST_UPDATE_FIELD':
+        case 'ERROR_IN_CRL_NEXT_UPDATE_FIELD':
+        case 'HOSTNAME_MISMATCH':
+        case 'INVALID_CA':
+        case 'INVALID_PURPOSE':
+        case 'PATH_LENGTH_EXCEEDED':
+        case 'SELF_SIGNED_CERT_IN_CHAIN':
+        case 'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY':
+        case 'UNABLE_TO_DECRYPT_CERT_SIGNATURE':
+        case 'UNABLE_TO_DECRYPT_CRL_SIGNATURE':
+        case 'UNABLE_TO_GET_CRL':
+        case 'UNABLE_TO_GET_ISSUER_CERT':
+        case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY':
+        case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE':
+            return true;
+        case 'EHOSTUNREACH':
+        case 'ENETUNREACH':
+        case 'ETIMEDOUT':
+            return syscall === 'connect';
+        default:
+            return false;
+    }
+}
+function allAttemptsFailedBeforeSend(errors) {
+    if (!Array.isArray(errors) || errors.length === 0 || errors.length > 16)
+        return false;
+    return errors.every((x) => x !== null && typeof x === 'object' && isPreSendCode(x.code, x.syscall));
+}
+function failedBeforeSend(e) {
+    let cur = e;
+    for (let depth = 0; depth < 4 && cur !== null && typeof cur === 'object'; depth++) {
+        const o = cur;
+        if (isPreSendCode(o.code, o.syscall))
+            return true;
+        if (allAttemptsFailedBeforeSend(o.errors))
+            return true;
+        cur = cur.cause;
+    }
+    return false;
+}
+export function noAnswerKindOf(e) {
+    try {
+        if (e === null || typeof e !== 'object')
+            return null;
+        if (e instanceof EngineWireNoAnswerError || branded(e, NO_ANSWER_BRAND))
+            return 'deadline';
+        if (e instanceof EngineWireCancelledError || branded(e, CANCELLED_BRAND))
+            return 'cancelled';
+        if (markedNotSent(e))
+            return null;
+        const name = e.name;
+        if (name === 'TimeoutError')
+            return 'time-limit';
+        if ((e instanceof TypeError || name === 'TypeError') && !failedBeforeSend(e))
+            return 'connection-lost';
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function noAnswerDetailFrom(e) {
+    const kind = noAnswerKindOf(e);
+    if (kind === 'deadline') {
+        try {
+            return e.message;
+        }
+        catch {
+            return injectedDeadlineDetail();
+        }
+    }
+    if (kind === 'time-limit')
+        return injectedDeadlineDetail();
+    if (kind === 'connection-lost')
+        return connectionLostDetail();
+    if (kind === 'cancelled')
+        return cancelledWaitDetail();
+    return null;
+}
+function signalAborted(signal) {
+    try {
+        return signal !== undefined && signal !== null && signal.aborted === true;
+    }
+    catch {
+        return false;
+    }
+}
+function abortedBeforeSendError() {
+    const e = new Error('This operation was aborted');
+    e.name = 'AbortError';
+    return e;
+}
+function answeredByEngine(e) {
+    try {
+        if (e === null || typeof e !== 'object')
+            return false;
+        const o = e;
+        return typeof o.status === 'number' || typeof o.errorCode === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+const SETTLED_BY_PACKAGE_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-settled');
+function settledByPackage(value) {
+    try {
+        return value !== null && typeof value === 'object' && branded(value, SETTLED_BY_PACKAGE_BRAND);
+    }
+    catch {
+        return false;
+    }
+}
+function abortReasonIfAborted(signal) {
+    try {
+        return signal !== undefined && signal.aborted === true ? { value: signal.reason } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function sendOnce(signal, run) {
+    const callerSignal = callerSignalOf(signal);
+    const abortedBefore = signalAborted(callerSignal);
+    const reasonBefore = abortedBefore ? abortReasonIfAborted(callerSignal) : undefined;
+    let returned;
+    try {
+        returned = run();
+    }
+    catch (error) {
+        throw markNotSent(error);
+    }
+    const innerSettled = settledByPackage(returned);
+    try {
+        return await Promise.resolve(returned);
+    }
+    catch (error) {
+        if (!innerSettled)
+            clearNotSent(error);
+        if (abortedBefore) {
+            if (reasonBefore !== undefined && error === reasonBefore.value && !answeredByEngine(error))
+                throw markNotSent(error);
+            throw error;
+        }
+        if (signalAborted(callerSignal) &&
+            !answeredByEngine(error) &&
+            noAnswerKindOf(error) !== 'deadline' &&
+            noAnswerKindOf(error) !== 'cancelled' &&
+            !provablyNotSent(error)) {
+            throw new EngineWireCancelledError();
+        }
+        throw error;
+    }
+}
+function provablyNotSent(e) {
+    try {
+        return e !== null && typeof e === 'object' && (markedNotSent(e) || failedBeforeSend(e));
+    }
+    catch {
+        return false;
+    }
+}
+export function settleInjected(ms, signal, run) {
+    const settled = settleInjectedOnce(ms, signal, run);
+    Object.defineProperty(settled, SETTLED_BY_PACKAGE_BRAND, { value: true, enumerable: false });
+    return settled;
+}
+async function settleInjectedOnce(ms, signal, run) {
+    const callerSignal = callerSignalOf(signal);
+    if (signalAborted(callerSignal))
+        throw abortedBeforeSendError();
+    let captured;
+    let cancelled = false;
+    let detach = () => { };
+    let unlink = () => { };
+    const got = await settleWithinDeadline(ms, (deadline) => {
+        let pending;
+        try {
+            const linked = linkedAbortSignal(callerSignal, deadline);
+            unlink = linked.dispose;
+            pending = Promise.resolve(run(linked.signal));
+        }
+        catch (error) {
+            captured = { error: markNotSent(error) };
+            throw error;
+        }
+        const verb = pending.catch((error) => {
+            captured = { error: clearNotSent(error) };
+            throw error;
+        });
+        if (callerSignal === undefined)
+            return verb;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                cancelled = true;
+                reject(new EngineWireCancelledError());
+            };
+            try {
+                callerSignal.addEventListener('abort', onAbort, { once: true });
+                detach = () => quietlyRemoveAbortListener(callerSignal, onAbort);
+            }
+            catch {
+            }
+            if (signalAborted(callerSignal))
+                onAbort();
+            verb.then(resolve, reject);
+        });
+    });
+    detach();
+    unlink();
+    if (got.kind === 'value')
+        return got.value;
+    if (got.kind === 'deadline')
+        throw new EngineWireNoAnswerError(injectedDeadlineDetail(ms));
+    if (cancelled)
+        throw new EngineWireCancelledError();
+    if (captured !== undefined)
+        throw captured.error;
+    throw new Error(got.detail);
+}

package/dist/engineWireSdk.d.ts

@@ -6,11 +6,17 @@ export type WireAuthTokenSource = string | (() => string | undefined);
 export declare function isLoopbackWireUrl(url: string): boolean;
 export declare function resolveWireAuth(baseUrl: string | undefined, token?: string): WireAuthToken;
 export declare function wireAuthTokenFor(baseUrl: string, token?: string): WireAuthToken;
+export type EngineProbeClient = Pick<AgentClient, 'capabilities' | 'scenarioCapabilities'>;
+export interface EngineWireInjection<C> {
+    client: C;
+    capsBaseUrl?: string;
+}
 export type EngineProbeOpts = {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;
     authToken?: WireAuthTokenSource | undefined;
     principal?: string | undefined;
+    client?: EngineProbeClient;
 };
 export type EngineWireClientConfig = {
     baseUrl: string;

package/dist/fileHistoryCaptureCapability.d.ts

@@ -6,13 +6,16 @@ export type FileHistoryCaptureReading = {
     kind: 'present';
     word: string;
 };
-export type FileHistoryCaptureMode = 'off' | 'on-always' | 'unknown';
+export type FileHistoryCaptureMode = 'off' | 'on-always' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
     generation?: number;
 }): void;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
+export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
+    fileHistory: 'disabled';
+} | Record<string, never>;
 export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
 export declare function forgetFileHistoryCaptureReading(baseUrl: string | undefined): void;
 export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
         return undefined;
@@ -25,29 +26,62 @@ export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl
     return reader.observed(baseUrl);
 }
 export function fileHistoryCaptureMode(reading) {
-    if (reading.kind !== 'present')
+    if (typeof reading !== 'object' || reading === null)
         return 'unknown';
-    if (reading.word === 'off')
+    let kind;
+    let word;
+    try {
+        kind = reading.kind;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return 'unknown';
+    }
+    if (kind !== 'present')
+        return 'unknown';
+    if (word === 'off')
         return 'off';
-    if (reading.word === 'on-always')
+    if (word === 'on-optional')
+        return 'on-optional';
+    if (word === 'on-always')
         return 'on-always';
     return 'unknown';
 }
+export function fileHistoryDeclarationField(reading, captureOff) {
+    return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
+}
 const WORD_DETAIL_MAX = 40;
 export function fileHistoryCaptureDoctorDetail(reading) {
-    switch (reading.kind) {
-        case 'unobserved':
-            return 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+    const unobserved = 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+    if (typeof reading !== 'object' || reading === null)
+        return unobserved;
+    let kind;
+    let word;
+    try {
+        kind = reading.kind;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return unobserved;
+    }
+    switch (kind) {
         case 'not_reported':
             return 'file history capture not reported by this engine — only newer engines advertise it; this does not say whether file history is captured here';
         case 'present':
-            if (reading.word === 'off') {
+            if (typeof word !== 'string' || word.length === 0)
+                return unobserved;
+            if (word === 'off') {
                 return 'file history capture off on this deployment — the engine takes no snapshots of the files it changes; whether code can be rewound here is answered separately by the rewind readings';
             }
-            if (reading.word === 'on-always') {
+            if (word === 'on-optional') {
+                return 'file history capture on — the engine snapshots files before changing them, and a session on this deployment can opt out of capture for its own runs';
+            }
+            if (word === 'on-always') {
                 return 'file history capture always on — the engine snapshots files before changing them in every session, and it cannot be turned off for a single session here';
             }
-            return `file history capture reported as "${capForDisplay(reading.word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+            return `file history capture reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+        default:
+            return unobserved;
     }
 }
 export function forgetFileHistoryCaptureReading(baseUrl) {

package/dist/gateVocabulary.d.ts

@@ -1,4 +1,5 @@
 import type { DeniedBy } from '@sema-agent/sdk';
+import type { APPROVAL_MANDATE_WORDS } from './hitl/toolApprovalWire.js';
 export declare const CC_TOOL_DENIAL_KINDS: readonly ["user-rejected", "permission-rule", "automode-blocked", "automode-unavailable", "automode-parsing-error", "interrupted", "cancelled"];
 export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
 export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
@@ -7,14 +8,12 @@ export declare function ccToolDenialKindForSettledBy(settledBy: unknown): CcTool
 export declare const GATE_DENIED_BY_WORDS: readonly DeniedBy[];
 export declare function isGateDeniedByWord(v: unknown): v is DeniedBy;
 export declare function gateDeniedByDetail(deniedBy: unknown): string;
-export declare const ASK_ORIGIN_WORDS: readonly string[];
 export declare function askOriginDetail(origin: unknown, message?: unknown): string;
 export declare const RULE_STORE_UNREADABLE_KINDS: readonly ["store", "call"];
 export type RuleStoreUnreadableKind = (typeof RULE_STORE_UNREADABLE_KINDS)[number];
 export declare function isRuleStoreUnreadableKind(v: unknown): v is RuleStoreUnreadableKind;
 export declare function ruleStoreUnreadableDetail(kind: RuleStoreUnreadableKind): string;
 export declare function mandatedApprovalDetail(): string;
-export declare const APPROVAL_MANDATE_WORDS: readonly ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"];
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
 export declare function approvalMandateDetail(word: ApprovalMandateWord): string;

package/dist/gateVocabulary.js

@@ -54,19 +54,6 @@ export function gateDeniedByDetail(deniedBy) {
     const word = typeof deniedBy === 'string' && deniedBy.length > 0 ? deniedBy : '(none)';
     return `denied by a layer this build does not know (${word}) — this build does not know this layer name: a newer engine may have added it, or the record may be damaged; this client cannot tell which`;
 }
-export const ASK_ORIGIN_WORDS = Object.freeze([
-    'content_question',
-    'ancestor_marked',
-    'org_unavailable',
-    'org_rule',
-    'rule_store_unavailable',
-    'hook',
-    'ask_rule',
-    'denial_limit_fallback',
-    'shell_gate_tighten',
-    'safety_tighten',
-    'policy',
-]);
 const ASK_ORIGIN_SENTENCES = Object.freeze({
     content_question: 'the tool itself asked you a question',
     ancestor_marked: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate): it must reach the park with no synchronous decision-maker in between',
@@ -118,17 +105,8 @@ export function ruleStoreUnreadableDetail(kind) {
 export function mandatedApprovalDetail() {
     return 'no saved allow rule and no remembered answer can retire this question; each call is settled on its own — by you here, by a hook, or by an automatic check the deployment runs — and an answer covers only that call';
 }
-export const APPROVAL_MANDATE_WORDS = Object.freeze([
-    'operator_always',
-    'tool_marks',
-    'probe_mandate',
-    'probe_unanswered',
-    'write_protection',
-    'write_protection_unresolved',
-]);
 const _mandateWordsPin = true;
 void _mandateWordsPin;
-const APPROVAL_MANDATE_SET = new Set(APPROVAL_MANDATE_WORDS);
 export function isApprovalMandateWord(v) {
     return APPROVAL_MANDATE_SET.has(v);
 }
@@ -140,6 +118,7 @@ const APPROVAL_MANDATE_SENTENCES = Object.freeze({
     write_protection: "this change lands on a protected location (the agent's own configuration), which is confirmed one change at a time",
     write_protection_unresolved: 'the protected-location check could not tell where this change lands, so whether it touches a protected location is unknown',
 });
+const APPROVAL_MANDATE_SET = new Set(Object.keys(APPROVAL_MANDATE_SENTENCES));
 export function approvalMandateDetail(word) {
     if (typeof word === 'string' && Object.hasOwn(APPROVAL_MANDATE_SENTENCES, word)) {
         return APPROVAL_MANDATE_SENTENCES[word];

package/dist/generated/engineNoticeTables.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_ENGINE_NOTICE_CODES: readonly string[];
+export declare const CORE_NOTICE_AUDIENCE: Readonly<Record<string, 'user' | 'operator'>>;
+export declare const CORE_MCP_INJECTION_DROP_REASONS: readonly string[];