@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/frameBinding.d.ts

@@ -1,5 +1,8 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
+import type { ApprovalFrameContext } from './eventLeg.js';
+export declare function registerApprovalFrameContext(frame: AgentEvent, ctx: ApprovalFrameContext): void;
+export declare function approvalFrameContextOfFrame(frame: object | null | undefined): ApprovalFrameContext | undefined;
 export declare function registerFrameBinding(frame: AgentEvent, binding: EngineBoundRun): void;
 export declare function frameBindingOf(frame: AgentEvent): EngineBoundRun | undefined;
 export declare function inheritFrameBinding<T extends AgentEvent>(from: AgentEvent, to: T): T;

package/dist/frameBinding.js

@@ -1,4 +1,13 @@
 const frameBindings = new WeakMap();
+const approvalFrameContexts = new WeakMap();
+export function registerApprovalFrameContext(frame, ctx) {
+    if (typeof frame !== 'object' || frame === null || approvalFrameContexts.has(frame))
+        return;
+    approvalFrameContexts.set(frame, ctx);
+}
+export function approvalFrameContextOfFrame(frame) {
+    return typeof frame === 'object' && frame !== null ? approvalFrameContexts.get(frame) : undefined;
+}
 export function registerFrameBinding(frame, binding) {
     if (typeof frame !== 'object' || frame === null)
         return;
@@ -19,5 +28,8 @@ export function inheritFrameBinding(from, to) {
     const binding = frameBindings.get(from);
     if (binding !== undefined && !frameBindings.has(to))
         frameBindings.set(to, binding);
+    const ctx = approvalFrameContexts.get(from);
+    if (ctx !== undefined && !approvalFrameContexts.has(to))
+        approvalFrameContexts.set(to, ctx);
     return to;
 }

package/dist/gateOutcome.js

@@ -237,9 +237,23 @@ export function gateOutcomeOf(frame) {
     return readGateRecord(frame)?.view;
 }
 export function isGateParkedToolEnd(frame) {
-    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+    if (typeof frame !== 'object' || frame === null)
+        return false;
+    try {
+        if (Array.isArray(frame))
+            return false;
+        if (readOwnDataValue(frame, 'errorCode') === GATE_PARKED_ERROR_CODE)
+            return true;
+        if (readOwnDataValue(frame, 'role') !== 'toolResult')
+            return false;
+        const details = readOwnDataValue(frame, 'details');
+        if (typeof details !== 'object' || details === null || Array.isArray(details))
+            return false;
+        return readOwnDataValue(details, 'code') === GATE_PARKED_ERROR_CODE;
+    }
+    catch {
         return false;
-    return frame.errorCode === GATE_PARKED_ERROR_CODE;
+    }
 }
 export function gateModeRelease(g) {
     return g?.disposition.kind === 'allowed' ? g.disposition.released : undefined;

package/dist/gateVocabulary.d.ts

@@ -1,4 +1,5 @@
 import { CORE_DENIED_BY_VALUES, CORE_PERSISTED_RULE_MANDATES } from './generated/engineFactTables.js';
+import type { UiLanguage } from './env/uiLanguage.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,15 +8,15 @@ export declare function ccToolDenialKindForSettledBy(settledBy: unknown): CcTool
 export type GateDeniedByWord = (typeof CORE_DENIED_BY_VALUES)[number];
 export declare const GATE_DENIED_BY_WORDS: readonly GateDeniedByWord[];
 export declare function isGateDeniedByWord(v: unknown): v is GateDeniedByWord;
-export declare function gateDeniedByDetail(deniedBy: unknown): string;
-export declare function askOriginDetail(origin: unknown): string;
-export declare function askOriginNoteOf(origin: string | undefined): string | undefined;
+export declare function gateDeniedByDetail(deniedBy: unknown, lang?: UiLanguage): string;
+export declare function askOriginDetail(origin: unknown, lang?: UiLanguage): string;
+export declare function askOriginNoteOf(origin: string | undefined, lang?: UiLanguage): string | undefined;
 export declare function ruleOffersAbsenceDetail(reason: string | undefined, opts?: {
     readonly deploymentListSessionRow?: boolean;
-}): string | undefined;
-export declare function ruleOfferUncoveredDetail(reason: string | undefined): string;
-export declare function mandatedApprovalDetail(): string;
+}, lang?: UiLanguage): string | undefined;
+export declare function ruleOfferUncoveredDetail(reason: string | undefined, lang?: UiLanguage): string;
+export declare function mandatedApprovalDetail(lang?: UiLanguage): string;
 export declare const APPROVAL_MANDATE_WORDS: readonly (typeof CORE_PERSISTED_RULE_MANDATES)[number][];
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
-export declare function approvalMandateDetail(word: ApprovalMandateWord): string;
+export declare function approvalMandateDetail(word: ApprovalMandateWord, lang?: UiLanguage): string;

package/dist/gateVocabulary.js

@@ -1,5 +1,6 @@
 import { CORE_DENIED_BY_VALUES, CORE_PERSISTED_RULE_MANDATES } from './generated/engineFactTables.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const CC_TOOL_DENIAL_KINDS = Object.freeze([
     'user-rejected',
     'permission-rule',
@@ -25,53 +26,53 @@ export function ccToolDenialKindForSettledBy(settledBy) {
 export const GATE_DENIED_BY_WORDS = Object.freeze([...CORE_DENIED_BY_VALUES]);
 const _deniedByWordsPin = true;
 void _deniedByWordsPin;
-const DENIED_BY_SENTENCES = Object.freeze({
-    policy: "denied by this deployment's permission policy",
-    hook: 'denied by a PreToolUse hook',
-    org: 'denied by an organization rule',
-    persisted_rule: 'denied by a persisted rule',
-    classifier: 'denied by the auto-mode classifier',
-    compliance: 'denied by a compliance lock',
-    write_protection: 'denied because the write landed on a write-protected path',
-    ask_resolution: 'denied when the approval was resolved',
-    read_boundary: 'denied by the read boundary',
-    mode: "denied by this session's permission mode",
+const DENIED_BY_KEYS = Object.freeze({
+    policy: 'approval.deniedBy.policy',
+    hook: 'approval.deniedBy.hook',
+    org: 'approval.deniedBy.org',
+    persisted_rule: 'approval.deniedBy.persistedRule',
+    classifier: 'approval.deniedBy.classifier',
+    compliance: 'approval.deniedBy.compliance',
+    write_protection: 'approval.deniedBy.writeProtection',
+    ask_resolution: 'approval.deniedBy.askResolution',
+    read_boundary: 'approval.deniedBy.readBoundary',
+    mode: 'approval.deniedBy.mode',
 });
 export function isGateDeniedByWord(v) {
     return typeof v === 'string' && GATE_DENIED_BY_WORDS.includes(v);
 }
-export function gateDeniedByDetail(deniedBy) {
-    if (typeof deniedBy === 'string' && Object.hasOwn(DENIED_BY_SENTENCES, deniedBy)) {
-        return DENIED_BY_SENTENCES[deniedBy];
+export function gateDeniedByDetail(deniedBy, lang) {
+    if (typeof deniedBy === 'string' && Object.hasOwn(DENIED_BY_KEYS, deniedBy)) {
+        return renderMessage(msg(DENIED_BY_KEYS[deniedBy]), lang);
     }
-    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, so it cannot say which layer refused this call or why`;
+    const word = typeof deniedBy === 'string' && deniedBy.length > 0 ? deniedBy : msg('approval.card.noWord');
+    return renderMessage(msg('approval.deniedBy.unknown', { word }), lang);
 }
-const ASK_ORIGIN_SENTENCES = Object.freeze({
-    content_question: 'the tool itself asked you a question',
-    plan_review: 'the model paused its run for your verdict on the plan it proposed',
-    ancestor_marked: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate; this client cannot tell which from the origin alone): it must reach the park with no synchronous decision-maker in between',
-    org_unavailable: 'the organization policy was unavailable, so this call asks',
-    org_rule: 'an organization rule asks about this call',
-    rule_store_unavailable: 'this call could not be checked against your standing deny/ask rules, so it asks',
-    hook: 'a PreToolUse hook asked about this call',
-    ask_rule: 'a persisted ask rule matches this call',
-    denial_limit_fallback: 'the auto-mode classifier hit its denial limit and handed this call back to you',
-    shell_gate_tighten: 'the coarse shell check rates this command above the tier it lets through, so it asks',
-    safety_tighten: 'the gate tightened on this call’s own facts (network egress, irreversibility, or a protected write; this client cannot tell which from the origin alone)',
-    policy: 'this deployment’s permission policy, or the permission mode’s default, asks about this call',
+const ASK_ORIGIN_KEYS = Object.freeze({
+    content_question: 'approval.origin.contentQuestion',
+    plan_review: 'approval.origin.planReview',
+    ancestor_marked: 'approval.origin.ancestorMarked',
+    org_unavailable: 'approval.origin.orgUnavailable',
+    org_rule: 'approval.origin.orgRule',
+    rule_store_unavailable: 'approval.origin.ruleStoreUnavailable',
+    hook: 'approval.origin.hook',
+    ask_rule: 'approval.origin.askRule',
+    denial_limit_fallback: 'approval.origin.denialLimitFallback',
+    shell_gate_tighten: 'approval.origin.shellGateTighten',
+    safety_tighten: 'approval.origin.safetyTighten',
+    policy: 'approval.origin.policy',
 });
-export function askOriginDetail(origin) {
-    const known = typeof origin === 'string' && Object.hasOwn(ASK_ORIGIN_SENTENCES, origin)
-        ? ASK_ORIGIN_SENTENCES[origin]
+export function askOriginDetail(origin, lang) {
+    const known = typeof origin === 'string' && Object.hasOwn(ASK_ORIGIN_KEYS, origin)
+        ? ASK_ORIGIN_KEYS[origin]
         : undefined;
     if (known !== undefined)
-        return known;
-    const word = typeof origin === 'string' && origin.length > 0 ? origin : '(none)';
-    return unknownAskOriginSentence(word);
+        return renderMessage(msg(known), lang);
+    const word = typeof origin === 'string' && origin.length > 0 ? origin : msg('approval.card.noWord');
+    return renderMessage(unknownAskOriginSentence(word), lang);
 }
 function unknownAskOriginSentence(word) {
-    return `this call asks; its origin ${word === undefined ? '' : `${word} `}is a word newer than this client, so answer it as usual`;
+    return word === undefined ? msg('approval.origin.unknownNoWord') : msg('approval.origin.unknownWithWord', { word });
 }
 const ASK_ORIGIN_QUIET = Object.freeze({
     content_question: true,
@@ -87,51 +88,48 @@ const ASK_ORIGIN_QUIET = Object.freeze({
     safety_tighten: false,
     policy: true,
 });
-export function askOriginNoteOf(origin) {
+export function askOriginNoteOf(origin, lang) {
     if (typeof origin !== 'string' || origin === '')
         return undefined;
     if (Object.hasOwn(ASK_ORIGIN_QUIET, origin)) {
-        return ASK_ORIGIN_QUIET[origin] === true ? undefined : askOriginDetail(origin);
+        return ASK_ORIGIN_QUIET[origin] === true ? undefined : askOriginDetail(origin, lang);
     }
-    return unknownAskOriginSentence(undefined);
+    return renderMessage(unknownAskOriginSentence(undefined), lang);
 }
-const NO_REMEMBER_HEAD = 'no "don\'t ask again" option here';
-const RULE_OFFERS_ABSENCE_LINES = Object.freeze({
+const RULE_OFFERS_ABSENCE_KEYS = Object.freeze({
     mandated: { line: null },
-    allow_outranked: {
-        line: `${NO_REMEMBER_HEAD}: an allow rule already matches this call, but this question outranks it — another allow rule would be outranked the same way`,
-    },
+    allow_outranked: { line: 'approval.ruleOffer.absence.allowOutranked' },
     ask_rule_matched: {
-        line: `${NO_REMEMBER_HEAD}: an ask rule matches this call and keeps asking — an allow rule changes nothing while it stands; to stop being asked, review your ask rules`,
-        deploymentList: `${NO_REMEMBER_HEAD}: this deployment asks about every call to this tool and your own rules cannot switch that off — the "in this session" option stops it asking again until the session ends`,
+        line: 'approval.ruleOffer.absence.askRuleMatched',
+        deploymentList: 'approval.ruleOffer.absence.askRuleMatchedDeploymentList',
     },
-    lane_cannot_speak: { line: `${NO_REMEMBER_HEAD}: this approval lane cannot persist rules` },
+    lane_cannot_speak: { line: 'approval.ruleOffer.absence.laneCannotSpeak' },
 });
-export function ruleOffersAbsenceDetail(reason, opts) {
+export function ruleOffersAbsenceDetail(reason, opts, lang) {
     if (typeof reason !== 'string' || reason === '')
         return undefined;
-    if (Object.hasOwn(RULE_OFFERS_ABSENCE_LINES, reason)) {
-        const entry = RULE_OFFERS_ABSENCE_LINES[reason];
+    if (Object.hasOwn(RULE_OFFERS_ABSENCE_KEYS, reason)) {
+        const entry = RULE_OFFERS_ABSENCE_KEYS[reason];
         if (entry.line === null)
             return undefined;
         const onList = guardedRead(() => readOwnDataValue(opts, 'deploymentListSessionRow')) === true;
-        return onList && entry.deploymentList !== undefined ? entry.deploymentList : entry.line;
+        return renderMessage(msg(onList && entry.deploymentList !== undefined ? entry.deploymentList : entry.line), lang);
     }
-    return `${NO_REMEMBER_HEAD} (the reason is one this build does not know yet)`;
+    return renderMessage(msg('approval.ruleOffer.absence.unknown'), lang);
 }
-const RULE_OFFER_UNCOVERED_LINES = Object.freeze({
-    redirection: 'always asks (shell redirection)',
-    no_rule_form: 'no coverable rule form',
-    cap_overflow: 'trimmed by the offer cap',
+const RULE_OFFER_UNCOVERED_KEYS = Object.freeze({
+    redirection: 'approval.ruleOffer.uncovered.redirection',
+    no_rule_form: 'approval.ruleOffer.uncovered.noRuleForm',
+    cap_overflow: 'approval.ruleOffer.uncovered.capOverflow',
 });
-export function ruleOfferUncoveredDetail(reason) {
-    if (typeof reason === 'string' && Object.hasOwn(RULE_OFFER_UNCOVERED_LINES, reason)) {
-        return RULE_OFFER_UNCOVERED_LINES[reason];
+export function ruleOfferUncoveredDetail(reason, lang) {
+    if (typeof reason === 'string' && Object.hasOwn(RULE_OFFER_UNCOVERED_KEYS, reason)) {
+        return renderMessage(msg(RULE_OFFER_UNCOVERED_KEYS[reason]), lang);
     }
-    return 'a reason this build does not know yet';
+    return renderMessage(msg('approval.ruleOffer.uncovered.unknown'), lang);
 }
-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 or by an automatic check the deployment runs — and an answer covers only that call';
+export function mandatedApprovalDetail(lang) {
+    return renderMessage(msg('approval.mandate.generic'), lang);
 }
 export const APPROVAL_MANDATE_WORDS = Object.freeze([...CORE_PERSISTED_RULE_MANDATES]);
 const _mandateWordsPin = true;
@@ -139,18 +137,18 @@ void _mandateWordsPin;
 export function isApprovalMandateWord(v) {
     return APPROVAL_MANDATE_SET.has(v);
 }
-const APPROVAL_MANDATE_SENTENCES = Object.freeze({
-    operator_always: 'this deployment requires a separate confirmation for each shell command, and this call is one of them',
-    tool_marks: 'this tool declares that it reaches outside this machine or makes changes that cannot be undone',
-    probe_mandate: 'the check run on this call marked it as needing its own confirmation (the built-in shell check does so for a read outside the directories allowed for this session)',
-    probe_unanswered: 'the check run on this call did not answer (it timed out or failed; this client cannot tell which), so whether the call stays inside the directories allowed for this session is unknown',
-    write_protection: "this change lands on a protected location (the agent's own configuration), which is confirmed one change at a time",
-    target_unresolved: 'where this change lands on disk could not be determined (a link on the way could not be examined, or the target could not be resolved), so whether it lands on a guarded location is unknown',
+const APPROVAL_MANDATE_KEYS = Object.freeze({
+    operator_always: 'approval.mandate.word.operatorAlways',
+    tool_marks: 'approval.mandate.word.toolMarks',
+    probe_mandate: 'approval.mandate.word.probeMandate',
+    probe_unanswered: 'approval.mandate.word.probeUnanswered',
+    write_protection: 'approval.mandate.word.writeProtection',
+    target_unresolved: 'approval.mandate.word.targetUnresolved',
 });
 const APPROVAL_MANDATE_SET = new Set(APPROVAL_MANDATE_WORDS);
-export function approvalMandateDetail(word) {
-    if (typeof word === 'string' && Object.hasOwn(APPROVAL_MANDATE_SENTENCES, word)) {
-        return APPROVAL_MANDATE_SENTENCES[word];
+export function approvalMandateDetail(word, lang) {
+    if (typeof word === 'string' && Object.hasOwn(APPROVAL_MANDATE_KEYS, word)) {
+        return renderMessage(msg(APPROVAL_MANDATE_KEYS[word]), lang);
     }
-    return 'the reason reported for this confirmation is not one this client recognises, so it shows no reason';
+    return renderMessage(msg('approval.mandate.unknownWord'), lang);
 }

package/dist/generated/engineFactTables.d.ts

@@ -43,5 +43,21 @@ export declare const CORE_PERMISSION_MODES: readonly ["default", "acceptEdits",
 export declare const CORE_APPROVAL_REACH: readonly ["none"];
 export declare const CORE_PERSISTED_RULE_MANDATES: readonly ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "target_unresolved"];
 export declare const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "cancelled"];
-export declare const CORE_RESUME_STARTUP_CAUSES: readonly ["environment", "session_gone", "tool_unavailable", "configuration", "decision_rejected"];
+export declare const CORE_RESUME_STARTUP_CAUSES: readonly ["environment", "session_gone", "transcript_corrupt", "tool_unavailable", "configuration", "decision_rejected"];
 export declare const CORE_BUILTIN_SUBAGENT_TYPES: readonly ["Explore", "Plan", "fork", "general-purpose"];
+export declare const CORE_USER_ATTACHMENT_KINDS: readonly ["text", "notebook", "image", "pdf", "directory", "client_text", "client_image"];
+export declare const CORE_USER_ATTACHMENT_SUPPLIES: readonly ["path", "content_text", "content_image"];
+export declare const CORE_USER_ATTACHMENT_OUTCOMES: readonly ["attached", "partial", "unchanged", "not_attached"];
+export interface CoreUserAttachmentSeatLimits {
+    readonly maxEntries: number;
+    readonly maxRenderedTextChars: number;
+}
+export interface CoreUserAttachmentSeat {
+    readonly entries: readonly string[];
+    readonly kinds: readonly (typeof CORE_USER_ATTACHMENT_KINDS)[number][];
+    readonly supplies: readonly (typeof CORE_USER_ATTACHMENT_SUPPLIES)[number][];
+    readonly limits: CoreUserAttachmentSeatLimits;
+}
+export declare const CORE_USER_ATTACHMENT_SEAT: CoreUserAttachmentSeat;
+export declare const CORE_USER_ATTACHMENTS_MAX: number;
+export declare const CORE_USER_ATTACHMENT_LABEL_MAX: number;

package/dist/generated/engineFactTables.js

@@ -289,6 +289,7 @@ export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze([
 export const CORE_RESUME_STARTUP_CAUSES = Object.freeze([
     "environment",
     "session_gone",
+    "transcript_corrupt",
     "tool_unavailable",
     "configuration",
     "decision_rejected",
@@ -299,3 +300,31 @@ export const CORE_BUILTIN_SUBAGENT_TYPES = Object.freeze([
     "fork",
     "general-purpose",
 ]);
+export const CORE_USER_ATTACHMENT_KINDS = Object.freeze([
+    "text",
+    "notebook",
+    "image",
+    "pdf",
+    "directory",
+    "client_text",
+    "client_image",
+]);
+export const CORE_USER_ATTACHMENT_SUPPLIES = Object.freeze([
+    "path",
+    "content_text",
+    "content_image",
+]);
+export const CORE_USER_ATTACHMENT_OUTCOMES = Object.freeze([
+    "attached",
+    "partial",
+    "unchanged",
+    "not_attached",
+]);
+export const CORE_USER_ATTACHMENT_SEAT = Object.freeze({
+    entries: Object.freeze(["objective"]),
+    kinds: CORE_USER_ATTACHMENT_KINDS,
+    supplies: CORE_USER_ATTACHMENT_SUPPLIES,
+    limits: Object.freeze({ maxEntries: 20, maxRenderedTextChars: 100000 }),
+});
+export const CORE_USER_ATTACHMENTS_MAX = 20;
+export const CORE_USER_ATTACHMENT_LABEL_MAX = 4096;

package/dist/generated/engineNoticeTables.js

@@ -25,12 +25,14 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "config.peer_admission_out_of_range",
     "config.peer_lane_unmounted",
     "config.secret_env_scrubbed",
+    "config.credential_not_withheld",
     "config.permission_mode_unavailable",
     "permission.ask_released_by_mode",
     "permission.read_deny_unapplied",
     "permission.rule_store_unavailable",
     "permission.rule_row_dropped",
     "permission.allowed_tool_not_granted",
+    "mods.registration_refused",
     "peer.inbound_disposition",
     "peer.held_settled",
     "peer.idle_subscription",
@@ -64,7 +66,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "memory.project_scope_absent",
     "route.fallback_to_primary",
     "route.classifier_unroutable",
-    "route.base_url_changed_key_unchanged",
+    "route.credential_origin_mismatch",
     "route.response_model_mismatch",
     "route.tool_call_id_folded",
     "route.finish_reason_unknown",
@@ -120,12 +122,14 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "config.peer_admission_out_of_range": "operator",
     "config.peer_lane_unmounted": "operator",
     "config.secret_env_scrubbed": "operator",
+    "config.credential_not_withheld": "operator",
     "config.permission_mode_unavailable": "user",
     "permission.ask_released_by_mode": "user",
     "permission.read_deny_unapplied": "user",
     "permission.rule_store_unavailable": "user",
     "permission.rule_row_dropped": "user",
     "permission.allowed_tool_not_granted": "user",
+    "mods.registration_refused": "user",
     "peer.inbound_disposition": "user",
     "peer.held_settled": "user",
     "peer.idle_subscription": "user",
@@ -159,7 +163,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "memory.project_scope_absent": "operator",
     "route.fallback_to_primary": "operator",
     "route.classifier_unroutable": "operator",
-    "route.base_url_changed_key_unchanged": "operator",
+    "route.credential_origin_mismatch": "user",
     "route.response_model_mismatch": "operator",
     "route.tool_call_id_folded": "operator",
     "route.finish_reason_unknown": "user",
@@ -221,12 +225,14 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "config.peer_admission_out_of_range": "engine",
     "config.peer_lane_unmounted": "engine",
     "config.secret_env_scrubbed": "engine",
+    "config.credential_not_withheld": "engine",
     "config.permission_mode_unavailable": "engine",
     "permission.ask_released_by_mode": "engine",
     "permission.read_deny_unapplied": "engine",
     "permission.rule_store_unavailable": "engine",
     "permission.rule_row_dropped": "engine",
     "permission.allowed_tool_not_granted": "engine",
+    "mods.registration_refused": "engine",
     "peer.inbound_disposition": "engine",
     "peer.held_settled": "engine",
     "peer.idle_subscription": "engine",
@@ -260,7 +266,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "memory.project_scope_absent": "engine",
     "route.fallback_to_primary": "engine",
     "route.classifier_unroutable": "engine",
-    "route.base_url_changed_key_unchanged": "engine",
+    "route.credential_origin_mismatch": "engine",
     "route.response_model_mismatch": "engine",
     "route.tool_call_id_folded": "engine",
     "route.finish_reason_unknown": "engine",

package/dist/generated/settingsSchemaFns.d.ts

@@ -1,3 +1,4 @@
+import type { HooksClassification } from './settingsSchemaTypes.js';
 export declare const SETTINGS_AT_MENTION_MODES: readonly ["all", "none", "only"];
 export type SettingsAtMention = {
     readonly mode: Exclude<(typeof SETTINGS_AT_MENTION_MODES)[number], 'only'>;
@@ -11,3 +12,8 @@ export declare const SETTINGS_IS_HIERARCHICAL_URL: (raw: string) => boolean;
 export declare const SETTINGS_NARROW_AT_MENTION: (atMention: SettingsAtMention, available: ReadonlySet<string>) => SettingsAtMention;
 export declare const SETTINGS_HOOK_MATCHER_SELECTS: (matcher: string | undefined, name: string) => boolean | 'invalid';
 export declare const SETTINGS_HOOK_MATCHER_FORM: (matcher: string | undefined) => SettingsHookMatcherForm;
+export declare const SETTINGS_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "Notification", "UserPromptSubmit", "UserPromptExpansion", "SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PermissionRequest", "PermissionDenied", "Setup", "TeammateIdle", "TaskCreated", "TaskCompleted", "Elicitation", "ElicitationResult", "ConfigChange", "WorktreeCreate", "WorktreeRemove", "InstructionsLoaded", "CwdChanged", "FileChanged", "MessageDisplay", "DirectoryAdded", "PreModelSwitch", "PostModelSwitch"];
+export declare const SETTINGS_HOOKS_CLASSIFICATION_OUTCOMES: readonly ["loaded", "loaded-partial", "rejected"];
+export declare const SETTINGS_HOOKS_DROPPED_PIECE_CODES: readonly ["hooks-not-object", "unknown-event", "event-not-array", "matcher-invalid", "entry-invalid"];
+export declare const SETTINGS_HOOKS_REJECTION_CODES: readonly ["guard-outside-hooks", "hooks-is-matcher", "guard-under-unknown-event", "guard-event-not-array", "guard-matcher-invalid", "guard-entry-invalid"];
+export declare const SETTINGS_CLASSIFY_HOOKS_CONFIG: (settingsDoc: unknown) => HooksClassification;

package/dist/generated/settingsSchemaFns.js

@@ -1,3 +1,4 @@
+import { SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE } from './settingsSchemaHooksClassifier.js';
 export const SETTINGS_AT_MENTION_MODES = Object.freeze([
     "all",
     "none",
@@ -73,3 +74,59 @@ export const SETTINGS_HOOK_MATCHER_FORM = function hookMatcherForm(matcher) {
         }
     }
 };
+export const SETTINGS_HOOK_EVENTS = Object.freeze([
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "Notification",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "SessionStart",
+    "SessionEnd",
+    "Stop",
+    "StopFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "PermissionRequest",
+    "PermissionDenied",
+    "Setup",
+    "TeammateIdle",
+    "TaskCreated",
+    "TaskCompleted",
+    "Elicitation",
+    "ElicitationResult",
+    "ConfigChange",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "InstructionsLoaded",
+    "CwdChanged",
+    "FileChanged",
+    "MessageDisplay",
+    "DirectoryAdded",
+    "PreModelSwitch",
+    "PostModelSwitch",
+]);
+export const SETTINGS_HOOKS_CLASSIFICATION_OUTCOMES = Object.freeze([
+    "loaded",
+    "loaded-partial",
+    "rejected",
+]);
+export const SETTINGS_HOOKS_DROPPED_PIECE_CODES = Object.freeze([
+    "hooks-not-object",
+    "unknown-event",
+    "event-not-array",
+    "matcher-invalid",
+    "entry-invalid",
+]);
+export const SETTINGS_HOOKS_REJECTION_CODES = Object.freeze([
+    "guard-outside-hooks",
+    "hooks-is-matcher",
+    "guard-under-unknown-event",
+    "guard-event-not-array",
+    "guard-matcher-invalid",
+    "guard-entry-invalid",
+]);
+export const SETTINGS_CLASSIFY_HOOKS_CONFIG = SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE(SETTINGS_HOOK_EVENTS);

package/dist/generated/settingsSchemaHooksClassifier.d.ts

@@ -0,0 +1,2 @@
+import type { HooksClassification } from './settingsSchemaTypes.js';
+export declare const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE: (HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "Notification", "UserPromptSubmit", "UserPromptExpansion", "SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PermissionRequest", "PermissionDenied", "Setup", "TeammateIdle", "TaskCreated", "TaskCompleted", "Elicitation", "ElicitationResult", "ConfigChange", "WorktreeCreate", "WorktreeRemove", "InstructionsLoaded", "CwdChanged", "FileChanged", "MessageDisplay", "DirectoryAdded", "PreModelSwitch", "PostModelSwitch"]) => (settingsDoc: unknown) => HooksClassification;