@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/hitl/sessionPolicyWire.js

@@ -4,6 +4,10 @@ import { isEngineRefusedToolName } from './sessionPolicyDeliverable.js';
 import { RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
 import { RULES_LEGACY_TOOL_NAME, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { rosterMountedNames } from './rosterMountedNames.js';
+import { CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
+function isLegacyToolNameVerdict(v) {
+    return typeof v === 'string' && v !== 'current' && CORE_RULE_TOOL_NAME_VERDICTS.includes(v);
+}
 const RULE_FIELD_PRESENCE = {
     toolAllow: true,
     toolDeny: true,
@@ -14,7 +18,7 @@ const RULE_FIELD_PRESENCE = {
 export const SESSION_POLICY_RULE_FIELDS = Object.freeze(Object.keys(RULE_FIELD_PRESENCE));
 const MAX_RULE_ENTRIES = 10_000;
 export function classifySessionPolicyFailure(e) {
-    const { status, errorCode, message, bodyField, bodyName } = wireFailureShapeOf(e);
+    const { status, errorCode, message, bodyField, bodyName, bodyVerdict, bodyCurrentName } = wireFailureShapeOf(e);
     if (errorCode === undefined || errorCode === '')
         return { kind: 'no-verdict', message };
     if (errorCode === RULES_LEGACY_TOOL_NAME) {
@@ -23,6 +27,8 @@ export function classifySessionPolicyFailure(e) {
             message,
             ...(bodyField === 'toolDeny' || bodyField === 'toolAllow' ? { field: bodyField } : {}),
             ...(bodyName !== undefined && bodyName !== '' ? { name: bodyName } : {}),
+            ...(isLegacyToolNameVerdict(bodyVerdict) ? { verdict: bodyVerdict } : {}),
+            ...(bodyCurrentName !== undefined && bodyCurrentName !== '' ? { currentName: bodyCurrentName } : {}),
         };
     }
     if (isRulesRefusalCode(errorCode) && status !== undefined && status >= 400 && status < 500)
@@ -227,7 +233,7 @@ function unknownFrom(failure, leg) {
     }
 }
 function legacyToolNameOutcome(failure, prior, add) {
-    const { field, name } = failure;
+    const { field, name, verdict, currentName } = failure;
     let alreadyInRecord;
     if (field !== undefined && name !== undefined) {
         const inPrior = Object.hasOwn(prior, field) ? prior[field] : undefined;
@@ -242,6 +248,8 @@ function legacyToolNameOutcome(failure, prior, add) {
         message: failure.message,
         ...(field !== undefined ? { field } : {}),
         ...(name !== undefined ? { name } : {}),
+        ...(verdict !== undefined ? { verdict } : {}),
+        ...(currentName !== undefined ? { currentName } : {}),
         ...(alreadyInRecord !== undefined ? { alreadyInRecord } : {}),
     };
 }
@@ -344,6 +352,69 @@ export function sessionPolicyTightenNotice(outcome) {
             }
     }
 }
+const READ_NOTICE_GENERIC = 'This session’s rule record could not be shown, so what it holds is not known. Try reading it again.';
+const READ_NOTICE_NO_TARGET = 'There is no engine connection for this session, so its rule record cannot be read and what it holds is not known. Look again once it is connected.';
+function readFailureSentence(kind) {
+    switch (kind) {
+        case 'face-unavailable':
+            return 'This deployment does not keep per-session tool rules, so there is no session rule record to read.';
+        case 'loosen-forbidden':
+            return 'The engine answered this read with a refusal that only applies to relaxing rules, so this session’s rule record could not be read. Try again; if it keeps happening, whoever runs the engine needs to look at it.';
+        case 'store-corrupt':
+            return 'The engine could not establish which version this session’s rules are at, so it would not hand the record over. This needs an operator to look at the rule store.';
+        case 'cas-conflict':
+            return 'The engine reported a version clash on this session’s rule record, so it could not be read this time. Try again.';
+        case 'session-ownerless':
+            return 'This session has no owner, so it has no rule record to read.';
+        case 'session-not-found':
+            return 'This session is not readable from here — it may not exist, or it may belong to someone else — so its rule record cannot be shown. Check that you are connected to the engine and the session you meant, or continue in a new session.';
+        case 'request-rejected':
+            return 'The engine rejected the request to read this session’s rule record as malformed, so it could not be read. Sending the same request again will not change that; check which session was asked for.';
+        case 'legacy-tool-name':
+            return 'The engine answered this read with a refusal about a tool name it no longer accepts, so this session’s rule record could not be read. Try again; if it keeps happening, whoever runs the engine needs to look at it.';
+        case 'unauthorized':
+            return 'This call could not present a verifiable identity, so this session’s rule record could not be read.';
+        case 'error':
+            return 'The engine refused to hand over this session’s rule record for a reason this version has no wording for, so it could not be read. Try again; if it keeps happening, whoever runs the engine needs to look at it.';
+        case 'no-verdict':
+            return 'No clear answer came back from the engine when this session’s rule record was read, so what it holds is not known — that is not the same as holding nothing. Try again.';
+    }
+}
+function readMalformedSentence(why) {
+    switch (why) {
+        case 'envelope':
+            return 'The engine answered, but not in a form this version can read as a session rule record, so what the record holds is not known. Try again; if it keeps happening, this version and the engine may be out of step.';
+        case 'rev':
+            return 'The engine’s answer for this session’s rule record carried no usable version, so this version will not show it — a record it cannot place may still hold restrictions that are in effect. Try again.';
+        case 'rule_field':
+            return 'One of the lists in this session’s rule record came back in a form this version cannot read, so none of the record is shown rather than part of it — a partly shown record could leave out restrictions that are in effect.';
+    }
+}
+function ownRead(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}
+export function sessionPolicyReadNotice(outcome) {
+    try {
+        if (outcome === null || typeof outcome !== 'object')
+            return READ_NOTICE_GENERIC;
+        const arm = ownRead(outcome, 'kind');
+        if (arm === 'failed') {
+            const failure = ownRead(outcome, 'failure');
+            if (failure === null || typeof failure !== 'object')
+                return READ_NOTICE_GENERIC;
+            return readFailureSentence(ownRead(failure, 'kind')) ?? READ_NOTICE_GENERIC;
+        }
+        if (arm === 'malformed')
+            return readMalformedSentence(ownRead(outcome, 'why')) ?? READ_NOTICE_GENERIC;
+        if (arm === 'no_target')
+            return READ_NOTICE_NO_TARGET;
+        return READ_NOTICE_GENERIC;
+    }
+    catch {
+        return READ_NOTICE_GENERIC;
+    }
+}
 function withoutRefusedEntries(prior, mounted) {
     const REFUSABLE_NAME_FIELDS = ['toolDeny', 'toolAllow'];
     const isRefusable = (f) => REFUSABLE_NAME_FIELDS.includes(f);
@@ -425,6 +496,8 @@ async function attemptRemoval(facade, sessionId, mounted, opts) {
                     message: failure.message,
                     ...(failure.field !== undefined ? { field: failure.field } : {}),
                     ...(failure.name !== undefined ? { name: failure.name } : {}),
+                    ...(failure.verdict !== undefined ? { verdict: failure.verdict } : {}),
+                    ...(failure.currentName !== undefined ? { currentName: failure.currentName } : {}),
                 },
             };
         }

package/dist/hitl/suspendedReopen.js

@@ -1,4 +1,4 @@
-import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE } from '../engineErrorCodes.js';
+import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, refusalSaysStillPending } from '../engineErrorCodes.js';
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
 export function suspendedReopenOf(ev) {
@@ -25,7 +25,7 @@ export function resumeReopenFromError(err) {
     const code = err.errorCode;
     if (typeof code !== 'string' || !RESUME_REOPEN_CODES.includes(code))
         return null;
-    if (err.retriable !== true)
+    if (!refusalSaysStillPending(err))
         return null;
     const reason = code.slice('resume.'.length);
     return { code, reason, retriable: true };

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,4 +1,5 @@
 import { type GateCurrentPending, type HitlFailureStage, type HitlSafetyCode, type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
+import { type AllowRuleShadowedWireMember, type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
 import { type RuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
 import type { ToolPermissionRequest } from '../seatContract.js';
@@ -37,6 +38,7 @@ export type FsApprovalOutcome = {
     reason: string;
     code?: 'no_pending' | undefined;
     errorCode?: string | undefined;
+    retriable?: true;
     safetyCode?: HitlSafetyCode | undefined;
     retryExhausted?: true;
     currentPending?: GateCurrentPending | undefined;
@@ -130,7 +132,10 @@ export interface ApprovalCardRequest {
     inputHasBidi?: true;
     hasBidiControls?: true;
     persistedRuleShadowed?: string;
+    allowRuleShadow?: ApprovalAllowRuleShadow;
     probeCause?: unknown;
+    probeReason?: string;
+    rememberRefused?: true;
     ruleEvidence?: unknown;
     requiresRealApproval?: true;
     irreversibleParkGate?: true;
@@ -179,7 +184,10 @@ export interface ToolApprovalFrame {
     denialLimitFallback?: DenialLimitFallback;
     ruleStoreUnreadable?: string;
     persistedRuleShadowed?: string;
+    allowRuleShadowed?: readonly AllowRuleShadowedWireMember[];
     probeCause?: unknown;
+    probeReason?: string;
+    rememberRefused?: true;
     ruleEvidence?: unknown;
     requiresRealApproval?: true;
     mandated?: true;
@@ -204,7 +212,7 @@ export interface ToolApprovalDelegation {
     depth: number;
     agentName?: string;
 }
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "ruleStoreUnreadable", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "probeCause", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "ruleStoreUnreadable", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;

package/dist/hitl/toolApprovalWire.js

@@ -2,14 +2,16 @@ import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTran
 import { askParkRowArm } from './askParkRowRouting.js';
 import { hostLog } from '../host.js';
 import { readOwnNonEmptyString } from '../ownKey.js';
+import { readAskClassPair } from './askClassPair.js';
+import { legacyShadowedRuleTextOf, readAllowRuleShadowFromWire } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
-import { isRuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
 import { decideFailureNote } from '../decideFailureNote.js';
+import { refusalSaysStillPending } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, PERSISTED_RULE_MANDATES, } from '@sema-agent/sdk';
 export function isFsApprovalGate(gate) {
@@ -190,9 +192,9 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
     const callKey = approvalCallKey(gatedCallId, taskId);
     const ruleOffersReadOnly = readRuleOfferSupply(pending.ruleOffers, pending.ruleSuggestions);
     const durableProbeCause = pending.riskDescriptor?.probeCause;
-    const durableShadowedRule = pending.riskDescriptor?.shadowedRule;
+    const durableProbeReason = readProbeReason(pending.riskDescriptor);
+    const durableShadow = readAllowRuleShadowFromWire(pending, 'row');
     const durableRuleOffersAbsence = pending.ruleOffersAbsence;
-    const durableRuleStoreUnreadable = readRuleStoreUnreadable(pending.ruleStoreUnreadable);
     deps.onPresented?.();
     const card = await surfaceApprovalCard({
         toolName,
@@ -215,12 +217,10 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         ...(pending.hasBidiControls === true ? { hasBidiControls: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
         ...(isWireRecordCarrier(durableProbeCause) ? { probeCause: durableProbeCause } : {}),
-        ...(durableRuleStoreUnreadable !== undefined
-            ? { ruleStoreUnreadable: durableRuleStoreUnreadable }
-            : {}),
-        ...(typeof durableShadowedRule === 'string' && durableShadowedRule.trim() !== ''
-            ? { persistedRuleShadowed: durableShadowedRule }
-            : {}),
+        ...(durableProbeReason !== undefined ? { probeReason: durableProbeReason } : {}),
+        ...(readRememberRefused(pending) ? { rememberRefused: true } : {}),
+        ...(durableShadow !== undefined ? { allowRuleShadow: durableShadow } : {}),
+        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(durableShadow)),
         ...(typeof durableRuleOffersAbsence === 'string' && durableRuleOffersAbsence !== ''
             ? { ruleOffersAbsence: durableRuleOffersAbsence }
             : {}),
@@ -279,6 +279,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 catch (e) {
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
+                    const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
                     const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
                     return {
                         kind: 'failed',
@@ -288,6 +289,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
+                        ...(wireRetriable ? { retriable: true } : {}),
                         ...(safetyCode !== undefined ? { safetyCode } : {}),
                     };
                 }
@@ -335,6 +337,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 catch (e) {
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
+                    const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
                     const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
                     const attributionRefusal = denyAttributionRefusalFromError(e, lastSendCarriedAttribution);
                     return {
@@ -345,6 +348,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
+                        ...(wireRetriable ? { retriable: true } : {}),
                         ...(safetyCode !== undefined ? { safetyCode } : {}),
                         ...(attributionRefusal !== null ? { denyAttributionRefusal: attributionRefusal } : {}),
                     };
@@ -392,7 +396,10 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'inputHasBidi',
     'parked',
     'persistedRuleShadowed',
+    'allowRuleShadowed',
     'probeCause',
+    'probeReason',
+    'rememberRefused',
     'ruleEvidence',
     'requiresRealApproval',
     'expiresInMs',
@@ -437,30 +444,6 @@ export function toolPermissionRequestAskBits(card) {
         ...(askClassPair ?? {}),
     };
 }
-function readAskClassPair(v) {
-    if (typeof v !== 'object' || v === null)
-        return undefined;
-    const askClass = readOwnNonEmptyString(v, 'askClass');
-    if (askClass === undefined || !Object.hasOwn(v, 'classes'))
-        return undefined;
-    const raw = v.classes;
-    if (!Array.isArray(raw) || raw.length === 0)
-        return undefined;
-    const classes = [];
-    const seen = new Set();
-    for (let i = 0; i < raw.length; i++) {
-        if (!Object.hasOwn(raw, i))
-            return undefined;
-        const c = raw[i];
-        if (typeof c !== 'string' || c === '' || seen.has(c))
-            return undefined;
-        seen.add(c);
-        classes.push(c);
-    }
-    if (classes[0] !== askClass)
-        return undefined;
-    return { askClass, classes: Object.freeze(classes) };
-}
 function hasOwnStrictTrue(v, key) {
     return Object.hasOwn(v, key) && v[key] === true;
 }
@@ -644,6 +627,25 @@ function pathFromGateMessage(message) {
         return undefined;
     return body.slice(0, close);
 }
+function readProbeReason(v) {
+    try {
+        if (typeof v !== 'object' || v === null || !Object.hasOwn(v, 'probeReason'))
+            return undefined;
+        const raw = v.probeReason;
+        return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRememberRefused(v) {
+    try {
+        return typeof v === 'object' && v !== null && Object.hasOwn(v, 'rememberRefused') && v.rememberRefused === true;
+    }
+    catch {
+        return false;
+    }
+}
 function isNonNegativeFinite(v) {
     return typeof v === 'number' && Number.isFinite(v) && v >= 0;
 }
@@ -669,9 +671,6 @@ export function readDenialLimitFallback(v) {
         autoDenyAfterMs: d.autoDenyAfterMs,
     };
 }
-function readRuleStoreUnreadable(v) {
-    return isRuleStoreUnreadableKind(v) ? v : undefined;
-}
 function isRuleOfferMatch(v) {
     return typeof v === 'string' && RULE_OFFER_MATCHES.includes(v);
 }
@@ -857,6 +856,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
     const argsNotRealInput = argsFallback || lane?.argsUnavailable === true;
     const ruleOffers = readRuleOfferSupply(frame.ruleOffers, frame.ruleSuggestions);
     const denialLimitFallback = readDenialLimitFallback(frame.denialLimitFallback);
+    const frameShadow = readAllowRuleShadowFromWire(frame, 'frame');
     const card = await surfaceApprovalCard({
         toolName,
         args: args,
@@ -883,10 +883,11 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             ? { delegation: frame.delegation }
             : {}),
         ...(ruleOffers !== undefined ? { ruleOffers } : {}),
-        ...(typeof frame.persistedRuleShadowed === 'string' && frame.persistedRuleShadowed.trim() !== ''
-            ? { persistedRuleShadowed: frame.persistedRuleShadowed }
-            : {}),
+        ...((sh) => (sh !== undefined ? { allowRuleShadow: sh } : {}))(frameShadow),
+        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(frameShadow)),
         ...(isWireRecordCarrier(frame.probeCause) ? { probeCause: frame.probeCause } : {}),
+        ...((r) => (r !== undefined ? { probeReason: r } : {}))(readProbeReason(frame)),
+        ...(readRememberRefused(frame) ? { rememberRefused: true } : {}),
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
         ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(frame, 'mandated') ? { mandated: true } : {}),
@@ -897,7 +898,6 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             ? { ruleOffersAbsence: frame.ruleOffersAbsence }
             : {}),
         ...(denialLimitFallback !== undefined ? { denialLimitFallback } : {}),
-        ...((k) => (k !== undefined ? { ruleStoreUnreadable: k } : {}))(readRuleStoreUnreadable(frame.ruleStoreUnreadable)),
         ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(frame, 'origin')),
         ...(readAskClassPair(frame) ?? {}),
     });

package/dist/hookMatcherVerdict.d.ts

@@ -0,0 +1,29 @@
+export type HookMatcherUnjudgedReason = 'event_out_of_scope' | 'not_a_string' | 'oversize' | 'invalid_pattern' | 'pattern_unsupported' | 'over_budget';
+export type HookMatcherVerdict = {
+    readonly kind: 'matchesAll';
+} | {
+    readonly kind: 'accepted';
+    readonly reading: 'names';
+    readonly names: readonly string[];
+    readonly aliases: readonly {
+        readonly alias: string;
+        readonly canonical: string;
+    }[];
+} | {
+    readonly kind: 'accepted';
+    readonly reading: 'pattern';
+    readonly aliases: readonly {
+        readonly alias: string;
+        readonly canonical: string;
+    }[];
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'alias_without_canonical';
+    readonly reading: 'names' | 'pattern';
+    readonly alias: string;
+    readonly canonical: string;
+} | {
+    readonly kind: 'unjudged';
+    readonly reason: HookMatcherUnjudgedReason;
+};
+export declare function hookMatcherVerdict(event: string, matcher: unknown): HookMatcherVerdict;

package/dist/hookMatcherVerdict.js

@@ -0,0 +1,266 @@
+import { HOOK_TOOL_ALIASES } from './hookToolAliases.js';
+import { SETTINGS_TOOL_NAME_MATCHER_EVENTS } from './generated/settingsSchemaTables.js';
+const TOOL_NAME_MATCHER_EVENTS = new Set(SETTINGS_TOOL_NAME_MATCHER_EVENTS);
+const MATCHER_MAX_CHARS = 8192;
+const PATTERN_WORK_BUDGET = 10_000_000;
+const PATTERN_MAX_DEPTH = 32;
+const COUNTED_REPEAT_MAX = 1000;
+function unjudged(reason) {
+    return Object.freeze({ kind: 'unjudged', reason });
+}
+function refused(reading, p) {
+    return Object.freeze({ kind: 'refused', reason: 'alias_without_canonical', reading, alias: p.alias, canonical: p.canonical });
+}
+function aliasPairs() {
+    return Object.entries(HOOK_TOOL_ALIASES).map(([alias, canonical]) => ({ alias, canonical }));
+}
+function literalNames(matcher) {
+    const names = [];
+    let first = -1;
+    let last = -1;
+    for (let i = 0; i <= matcher.length; i++) {
+        const c = i < matcher.length ? matcher.charCodeAt(i) : 0x7c;
+        if (c === 0x7c || c === 0x2c) {
+            if (first !== -1)
+                names.push(matcher.slice(first, last + 1));
+            first = -1;
+            last = -1;
+            continue;
+        }
+        if (c === 0x20)
+            continue;
+        const nameChar = (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || c === 0x5f || c === 0x2d;
+        if (!nameChar)
+            return undefined;
+        if (first === -1)
+            first = i;
+        last = i;
+    }
+    return names;
+}
+const UNSUPPORTED = Symbol('unsupported');
+const SINGLE_CHAR_ESCAPES = 'dDwWsStnrfv^$\\.*+?()[]{}|/-';
+function patternBound(src, n) {
+    let i = 0;
+    let depth = 0;
+    const fail = () => {
+        throw UNSUPPORTED;
+    };
+    const quantifier = () => {
+        const c = src[i];
+        let lo;
+        let hi;
+        if (c === '*') {
+            lo = 0;
+            hi = Infinity;
+            i++;
+        }
+        else if (c === '+') {
+            lo = 1;
+            hi = Infinity;
+            i++;
+        }
+        else if (c === '?') {
+            lo = 0;
+            hi = 1;
+            i++;
+        }
+        else if (c === '{') {
+            const q = /^\{(\d{1,4})(?:(,)(\d{0,4}))?\}/.exec(src.slice(i, i + 12));
+            if (q === null)
+                return fail();
+            lo = Number(q[1]);
+            hi = q[2] === undefined ? lo : q[3] === '' || q[3] === undefined ? Infinity : Number(q[3]);
+            if (lo > COUNTED_REPEAT_MAX || (hi !== Infinity && hi > COUNTED_REPEAT_MAX) || hi < lo)
+                fail();
+            i += q[0].length;
+        }
+        else
+            return undefined;
+        if (src[i] === '?')
+            i++;
+        return { lo, hi };
+    };
+    const term = () => {
+        const c = src[i];
+        if (c === '^' || c === '$') {
+            i++;
+            if (quantifier() !== undefined)
+                fail();
+            return [1, 1];
+        }
+        if (c === '\\' && (src[i + 1] === 'b' || src[i + 1] === 'B')) {
+            i += 2;
+            if (quantifier() !== undefined)
+                fail();
+            return [1, 1];
+        }
+        let paths = 1;
+        let steps = 1;
+        let single = true;
+        if (c === '(') {
+            i++;
+            if (src[i] === '?') {
+                if (src[i + 1] === ':')
+                    i += 2;
+                else {
+                    const named = /^\?<([A-Za-z_$][A-Za-z0-9_$]*)>/.exec(src.slice(i, i + 80));
+                    if (named === null)
+                        fail();
+                    else
+                        i += named[0].length;
+                }
+            }
+            if (++depth > PATTERN_MAX_DEPTH)
+                fail();
+            [paths, steps] = disjunction();
+            if (src[i] !== ')')
+                fail();
+            i++;
+            depth--;
+            single = false;
+        }
+        else if (c === '[') {
+            i++;
+            if (src[i] === '^')
+                i++;
+            for (;;) {
+                if (i >= src.length)
+                    fail();
+                const d = src[i];
+                if (d === ']') {
+                    i++;
+                    break;
+                }
+                i += d === '\\' ? 2 : 1;
+            }
+        }
+        else if (c === '.')
+            i++;
+        else if (c === '\\') {
+            const e = src[i + 1];
+            if (e === undefined || !SINGLE_CHAR_ESCAPES.includes(e))
+                fail();
+            i += 2;
+        }
+        else if (c === undefined || '*+?{}]|)'.includes(c))
+            fail();
+        else
+            i++;
+        const q = quantifier();
+        if (q === undefined)
+            return [paths, steps];
+        if (single) {
+            if (q.lo > n)
+                return [1, n + 1];
+            const top = Math.min(q.hi, n);
+            return [top - q.lo + 1, top + 1];
+        }
+        const hiEff = Math.min(q.hi, Math.max(q.lo, n + 1));
+        if (q.lo > hiEff)
+            return [1, 1];
+        let sum = 0;
+        for (let k = q.lo; k <= hiEff; k++) {
+            sum += paths ** k;
+            if (sum === Infinity)
+                break;
+        }
+        return [sum, hiEff * steps + 1];
+    };
+    const alternative = () => {
+        let paths = 1;
+        let steps = 0;
+        while (i < src.length && src[i] !== '|' && src[i] !== ')') {
+            const [p, s] = term();
+            paths *= p;
+            steps += s;
+        }
+        return [paths, steps];
+    };
+    const disjunction = () => {
+        let [paths, steps] = alternative();
+        while (src[i] === '|') {
+            i++;
+            const [p, s] = alternative();
+            paths += p;
+            steps = Math.max(steps, s);
+        }
+        return [paths, steps];
+    };
+    try {
+        const r = disjunction();
+        if (i !== src.length)
+            fail();
+        return r;
+    }
+    catch (e) {
+        if (e === UNSUPPORTED)
+            return undefined;
+        throw e;
+    }
+}
+export function hookMatcherVerdict(event, matcher) {
+    if (typeof event !== 'string' || !TOOL_NAME_MATCHER_EVENTS.has(event))
+        return unjudged('event_out_of_scope');
+    if (matcher === undefined)
+        return Object.freeze({ kind: 'matchesAll' });
+    if (typeof matcher !== 'string')
+        return unjudged('not_a_string');
+    if (matcher.length > MATCHER_MAX_CHARS)
+        return unjudged('oversize');
+    if (matcher === '' || matcher === '*')
+        return Object.freeze({ kind: 'matchesAll' });
+    const pairs = aliasPairs();
+    const names = literalNames(matcher);
+    if (names !== undefined) {
+        const dead = pairs.find((p) => names.includes(p.alias) && !names.includes(p.canonical));
+        if (dead !== undefined)
+            return refused('names', dead);
+        return Object.freeze({
+            kind: 'accepted',
+            reading: 'names',
+            names: Object.freeze([...names]),
+            aliases: Object.freeze(pairs.filter((p) => names.includes(p.alias)).map((p) => Object.freeze({ ...p }))),
+        });
+    }
+    const src = `^(?:${matcher})$`;
+    let re;
+    try {
+        re = new RegExp(src);
+    }
+    catch {
+        return unjudged('invalid_pattern');
+    }
+    const subjects = pairs.flatMap((p) => [p.alias, p.canonical]);
+    const n = subjects.reduce((a, s) => Math.max(a, s.length), 0);
+    const bound = patternBound(src, n);
+    if (bound === undefined)
+        return unjudged('pattern_unsupported');
+    if (bound[0] * bound[1] * (n + 1) * subjects.length > PATTERN_WORK_BUDGET)
+        return unjudged('over_budget');
+    const selects = (name) => {
+        if (matcher === name)
+            return true;
+        try {
+            return re.test(name);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const selected = [];
+    for (const p of pairs) {
+        const a = selects(p.alias);
+        if (a === undefined)
+            return unjudged('invalid_pattern');
+        if (!a)
+            continue;
+        const c = selects(p.canonical);
+        if (c === undefined)
+            return unjudged('invalid_pattern');
+        if (!c)
+            return refused('pattern', p);
+        selected.push(p);
+    }
+    return Object.freeze({ kind: 'accepted', reading: 'pattern', aliases: Object.freeze(selected.map((p) => Object.freeze({ ...p }))) });
+}