@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/generated/engineAskFaceTables.js

@@ -7,6 +7,6 @@ export const CORE_SHELL_FACE_TOOL_NAMES = Object.freeze([
     "Monitor",
 ]);
 export const CORE_RELEASABLE_ASK_CLASSES_BY_FACE = Object.freeze({
-    "shell": Object.freeze(["transcript_write", "rule_unreadable", "target_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
-    "other": Object.freeze(["transcript_write", "rule_unreadable", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
+    "shell": Object.freeze(["transcript_write", "target_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
+    "other": Object.freeze(["transcript_write", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
 });

package/dist/generated/engineFactTables.d.ts

@@ -8,7 +8,7 @@ export declare const CORE_DENIED_BY_VALUES: readonly ["policy", "hook", "org", "
 export declare const CORE_PERMISSION_MODE_FOLD_REASONS: readonly string[];
 export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
-export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable", "target_unresolved"];
+export declare const CORE_MODE_RELEASE_REASONS: readonly ["target_unresolved"];
 export declare const CORE_HOOK_TOOL_ALIASES: Readonly<Record<string, string>>;
 export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
 export declare const CORE_SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];
@@ -21,9 +21,9 @@ export interface CoreModeArbitrationRow {
     readonly ruleMayClear: boolean;
     readonly hookAskFloor: boolean;
 }
-export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "target_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "target_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare const CORE_SKILL_GRANT_ORIGINS: readonly ["model", "user", "inherited"];
-export declare const CORE_ALLOW_ENTRY_INERT_REASONS: readonly ["wildcard_all", "namespace_wildcard", "content_unsupported", "grammar", "tool_name", "near_miss"];
+export declare const CORE_ALLOW_ENTRY_INERT_REASONS: readonly ["wildcard_all", "namespace_wildcard", "content_unsupported", "grammar", "tool_name", "near_miss", "earlier_grammar"];
 export declare const CORE_ALLOW_RULE_MEMBERS: readonly ["hook", "deployment", "persisted", "skill", "request"];
 export declare const CORE_RULE_TOOL_NAME_VERDICTS: readonly ["current", "retired", "unprefixed_namespace", "unmintable_segment"];
 export declare const CORE_SETTLEMENT_KINDS: readonly ["human_allowed", "human_refused", "approval_window_expired", "denial_limit_window_expired", "park_sla_expired", "no_approver", "approver_unavailable", "approver_error", "approver_contract", "presentation_failed", "blanket_allow_refused", "policy_allowed", "policy_refused", "task_aborted"];
@@ -42,3 +42,22 @@ export declare const CORE_PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "ti
 export declare const CORE_PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
 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", "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

@@ -112,7 +112,6 @@ export const CORE_TOOL_DECLARATION_CODES = Object.freeze([
     "config.reserved_tool_name",
 ]);
 export const CORE_MODE_RELEASE_REASONS = Object.freeze([
-    "rule_unreadable",
     "target_unresolved",
 ]);
 export const CORE_HOOK_TOOL_ALIASES = Object.freeze(Object.assign(Object.create(null), Object.fromEntries([
@@ -146,12 +145,11 @@ export const CORE_MODE_ARBITRATION = Object.freeze({
     "hook": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
     "ancestor": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
     "dangerous_delete": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
-    "unverifiable_delete": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "unverifiable_delete": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "unverifiable_shell_text": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "transcript_write": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "org_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
-    "governance_unavailable": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
-    "rule_unreadable": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "rule_unreadable": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
     "ask_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "denial_limit_fallback": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
     "classifier_no_ruling": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
@@ -181,6 +179,7 @@ export const CORE_ALLOW_ENTRY_INERT_REASONS = Object.freeze([
     "grammar",
     "tool_name",
     "near_miss",
+    "earlier_grammar",
 ]);
 export const CORE_ALLOW_RULE_MEMBERS = Object.freeze([
     "hook",
@@ -281,3 +280,51 @@ export const CORE_PERSISTED_RULE_MANDATES = Object.freeze([
     "write_protection",
     "target_unresolved",
 ]);
+export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze([
+    "completed",
+    "failed",
+    "killed",
+    "cancelled",
+]);
+export const CORE_RESUME_STARTUP_CAUSES = Object.freeze([
+    "environment",
+    "session_gone",
+    "transcript_corrupt",
+    "tool_unavailable",
+    "configuration",
+    "decision_rejected",
+]);
+export const CORE_BUILTIN_SUBAGENT_TYPES = Object.freeze([
+    "Explore",
+    "Plan",
+    "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

@@ -8,6 +8,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "config.read_face_deployment_clamped",
     "config.write_face_swapped",
     "config.write_face_deployment_clamped",
+    "config.read_deny_swapped",
     "config.tool_model_gate_removed",
     "config.tool_model_gate_unknown_class",
     "config.tool_model_gate_env_invalid",
@@ -24,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",
@@ -63,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",
@@ -85,10 +88,12 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "skills.listing_truncated",
     "agents.listing_truncated",
     "tool_result.offload_put_failed",
+    "tool_result.media_refused",
     "instructions.source_changed",
     "session.records_skipped",
     "memory.layer_locked_legacy",
     "server.model_unreachable",
+    "permission.entry_mode_clamped",
 ]);
 export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "config.autocompact_window_clamped": "operator",
@@ -100,6 +105,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "config.read_face_deployment_clamped": "operator",
     "config.write_face_swapped": "operator",
     "config.write_face_deployment_clamped": "operator",
+    "config.read_deny_swapped": "operator",
     "config.tool_model_gate_removed": "operator",
     "config.tool_model_gate_unknown_class": "operator",
     "config.tool_model_gate_env_invalid": "operator",
@@ -116,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",
@@ -155,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",
@@ -177,10 +185,12 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "skills.listing_truncated": "operator",
     "agents.listing_truncated": "operator",
     "tool_result.offload_put_failed": "operator",
+    "tool_result.media_refused": "operator",
     "instructions.source_changed": "user",
     "session.records_skipped": "user",
     "memory.layer_locked_legacy": "operator",
     "server.model_unreachable": "user",
+    "permission.entry_mode_clamped": "user",
 });
 export const CORE_MCP_INJECTION_DROP_REASONS = Object.freeze([
     "malformed_entry",
@@ -198,6 +208,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "config.read_face_deployment_clamped": "engine",
     "config.write_face_swapped": "engine",
     "config.write_face_deployment_clamped": "engine",
+    "config.read_deny_swapped": "engine",
     "config.tool_model_gate_removed": "engine",
     "config.tool_model_gate_unknown_class": "engine",
     "config.tool_model_gate_env_invalid": "engine",
@@ -214,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",
@@ -253,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",
@@ -275,10 +288,12 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "skills.listing_truncated": "engine",
     "agents.listing_truncated": "engine",
     "tool_result.offload_put_failed": "engine",
+    "tool_result.media_refused": "engine",
     "instructions.source_changed": "server",
     "session.records_skipped": "server",
     "memory.layer_locked_legacy": "server",
     "server.model_unreachable": "server",
+    "permission.entry_mode_clamped": "server",
 });
 export const CORE_USER_INPUT_UNDRAINED_CAUSES = Object.freeze([
     "leg_end",

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;

package/dist/generated/settingsSchemaHooksClassifier.js

@@ -0,0 +1,254 @@
+export const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE = (HOOK_EVENTS) => {
+    const HOOK_GUARD_EVENTS = ["PreToolUse", "PermissionRequest"];
+    const HOOK_SHELLS = ["bash", "powershell"];
+    const HOOK_ENTRY_COMMON_FIELDS = { if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?" };
+    const HOOK_ENTRY_FIELDS = {
+        command: { command: "text", shell: "shell?", async: "boolean?", asyncRewake: "boolean?", ...HOOK_ENTRY_COMMON_FIELDS },
+        prompt: { prompt: "text", model: "string?", ...HOOK_ENTRY_COMMON_FIELDS },
+        agent: { prompt: "text", model: "string?", ...HOOK_ENTRY_COMMON_FIELDS },
+        http: { url: "text", headers: "stringRecord?", allowedEnvVars: "stringList?", ...HOOK_ENTRY_COMMON_FIELDS },
+        mcp_tool: { server: "string", tool: "string", input: "record?", ...HOOK_ENTRY_COMMON_FIELDS },
+    };
+    function hookIsRecord(value) {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const proto = Object.getPrototypeOf(value);
+        return proto === Object.prototype || proto === null;
+    }
+    function hookGuardKeyOf(node) {
+        for (const key of Object.keys(node)) {
+            if (!HOOK_GUARD_EVENTS.includes(key))
+                continue;
+            const value = node[key];
+            if (value !== null && value !== undefined && !(Array.isArray(value) && value.length === 0))
+                return key;
+        }
+        return undefined;
+    }
+    function hookLooksLikeMatcher(value) {
+        if (!hookIsRecord(value))
+            return false;
+        const inner = Object.hasOwn(value, "hooks") ? value.hooks : undefined;
+        if (Array.isArray(inner))
+            return inner.length > 0;
+        return hookIsRecord(inner) && (Object.hasOwn(value, "matcher") || typeof inner.type === "string");
+    }
+    function hookGuardSignIn(root, rootPath, place) {
+        const frames = [];
+        const pending = [[root, -1, place]];
+        const seen = { matcherList: new Set(), matcher: new Set(), other: new Set() };
+        const pathTo = (frame, tail) => {
+            const segments = [...tail];
+            for (let f = frame; f >= 0; f = frames[f].parent)
+                segments.unshift(frames[f].key);
+            return [...rootPath, ...segments];
+        };
+        while (pending.length > 0) {
+            const [node, frame, at] = pending.pop();
+            if (node === null || typeof node !== "object" || seen[at].has(node))
+                continue;
+            seen[at].add(node);
+            if (Array.isArray(node)) {
+                for (let i = node.length - 1; i >= 0; i--) {
+                    frames.push({ key: i, parent: frame });
+                    pending.push([node[i], frames.length - 1, at === "matcherList" ? "matcher" : "other"]);
+                }
+                continue;
+            }
+            const guardKey = hookGuardKeyOf(node);
+            if (guardKey !== undefined)
+                return pathTo(frame, [guardKey]);
+            if (at !== "matcher" && hookLooksLikeMatcher(node))
+                return pathTo(frame, []);
+            const keys = Object.keys(node);
+            for (let i = keys.length - 1; i >= 0; i--) {
+                frames.push({ key: keys[i], parent: frame });
+                pending.push([node[keys[i]], frames.length - 1, "other"]);
+            }
+        }
+        return undefined;
+    }
+    function hookSignKeyOf(at, sign) {
+        const key = sign[at.length];
+        return key === undefined ? "hooks" : String(key);
+    }
+    function hookFieldFits(base, value) {
+        switch (base) {
+            case "text":
+                return typeof value === "string" && value.length > 0 && !value.includes("\0");
+            case "string":
+                return typeof value === "string";
+            case "shell":
+                return typeof value === "string" && HOOK_SHELLS.includes(value);
+            case "boolean":
+                return typeof value === "boolean";
+            case "seconds":
+                return typeof value === "number" && Number.isFinite(value) && value > 0;
+            case "stringRecord":
+                return hookIsRecord(value) && Object.values(value).every((v) => typeof v === "string");
+            case "stringList":
+                if (!Array.isArray(value))
+                    return false;
+                for (let i = 0; i < value.length; i++)
+                    if (typeof value[i] !== "string")
+                        return false;
+                return true;
+            case "record":
+                return hookIsRecord(value);
+            default: {
+                const unknownKind = base;
+                throw new Error(`hook entry field table: unknown field kind '${String(unknownKind)}'`);
+            }
+        }
+    }
+    function hookEntryRead(entry) {
+        if (!hookIsRecord(entry))
+            return {};
+        const type = Object.hasOwn(entry, "type") ? entry.type : undefined;
+        if (typeof type !== "string" || !Object.hasOwn(HOOK_ENTRY_FIELDS, type))
+            return { field: "type" };
+        const fields = HOOK_ENTRY_FIELDS[type];
+        const out = { type };
+        for (const field of Object.keys(fields)) {
+            const kind = fields[field];
+            const optional = kind.endsWith("?");
+            const value = Object.hasOwn(entry, field) ? entry[field] : undefined;
+            if (value === undefined) {
+                if (optional)
+                    continue;
+                return { field };
+            }
+            const base = (optional ? kind.slice(0, -1) : kind);
+            if (!hookFieldFits(base, value))
+                return { field };
+            out[field] = Array.isArray(value) ? value.slice() : hookIsRecord(value) ? Object.fromEntries(Object.entries(value)) : value;
+        }
+        return { entry: out };
+    }
+    function hookMatcherRead(matcher, at, guardEvent, reject, drop) {
+        if (!hookIsRecord(matcher)) {
+            if (guardEvent || hookGuardSignIn(matcher, at, "matcher") !== undefined)
+                reject("guard-matcher-invalid", at);
+            else
+                drop("matcher-invalid", at);
+            return undefined;
+        }
+        const entries = Object.hasOwn(matcher, "hooks") ? matcher.hooks : undefined;
+        const signField = hookGuardKeyOf(matcher) ??
+            Object.keys(matcher).find((key) => !(key === "hooks" && Array.isArray(entries)) && hookGuardSignIn(matcher[key], [...at, key], "other") !== undefined);
+        if (signField !== undefined) {
+            reject("guard-matcher-invalid", at, signField);
+            return undefined;
+        }
+        const entrySigns = [];
+        if (Array.isArray(entries))
+            for (let j = 0; j < entries.length; j++)
+                entrySigns.push(hookGuardSignIn(entries[j], [...at, "hooks", j], "other"));
+        const name = Object.hasOwn(matcher, "matcher") ? matcher.matcher : undefined;
+        const badField = name !== undefined && typeof name !== "string" ? "matcher" : !Array.isArray(entries) ? "hooks" : undefined;
+        if (badField !== undefined || !Array.isArray(entries)) {
+            if (guardEvent || entrySigns.some((sign) => sign !== undefined))
+                reject("guard-matcher-invalid", at, badField);
+            else
+                drop("matcher-invalid", at, badField);
+            return undefined;
+        }
+        const kept = [];
+        for (let j = 0; j < entries.length; j++) {
+            const where = [...at, "hooks", j];
+            const sign = entrySigns[j];
+            if (sign !== undefined) {
+                reject("guard-entry-invalid", where, hookIsRecord(entries[j]) ? hookSignKeyOf(where, sign) : undefined);
+                continue;
+            }
+            const read = hookEntryRead(entries[j]);
+            if (read.entry !== undefined)
+                kept.push(read.entry);
+            else if (guardEvent)
+                reject("guard-entry-invalid", where, read.field);
+            else
+                drop("entry-invalid", where, read.field);
+        }
+        return typeof name === "string" ? { matcher: name, hooks: kept } : { hooks: kept };
+    }
+    function hookBlockRead(hooks, reject, drop) {
+        if (!hookIsRecord(hooks)) {
+            if (Array.isArray(hooks) && hooks.some((x) => x !== null && typeof x === "object"))
+                reject("hooks-is-matcher", ["hooks"]);
+            else
+                drop("hooks-not-object", ["hooks"]);
+            return undefined;
+        }
+        if (hookLooksLikeMatcher(hooks) || typeof hooks.type === "string") {
+            reject("hooks-is-matcher", ["hooks"]);
+            return undefined;
+        }
+        const loaded = {};
+        for (const event of Object.keys(hooks)) {
+            const value = hooks[event];
+            const at = ["hooks", event];
+            if (!HOOK_EVENTS.includes(event)) {
+                if (hookGuardSignIn(value, at, Array.isArray(value) ? "matcherList" : "other") !== undefined)
+                    reject("guard-under-unknown-event", at);
+                else
+                    drop("unknown-event", at);
+                continue;
+            }
+            const guardEvent = HOOK_GUARD_EVENTS.includes(event);
+            if (!Array.isArray(value)) {
+                if ((guardEvent && value !== null) || hookGuardSignIn(value, at, "other") !== undefined)
+                    reject("guard-event-not-array", at);
+                else
+                    drop("event-not-array", at);
+                continue;
+            }
+            const matchers = [];
+            for (let i = 0; i < value.length; i++) {
+                const read = hookMatcherRead(value[i], [...at, i], guardEvent, reject, drop);
+                if (read !== undefined)
+                    matchers.push(read);
+            }
+            loaded[event] = matchers;
+        }
+        return loaded;
+    }
+    function classifyHooksConfig(settingsDoc) {
+        const rejections = [];
+        const dropped = [];
+        const reject = (code, path, field) => {
+            rejections.push(field === undefined ? { code, path } : { code, path, field });
+        };
+        const drop = (code, path, field) => {
+            dropped.push(field === undefined ? { code, path } : { code, path, field });
+        };
+        let hooks;
+        if (settingsDoc !== null && typeof settingsDoc === "object" && !Array.isArray(settingsDoc)) {
+            const doc = settingsDoc;
+            for (const key of Object.keys(doc)) {
+                const value = doc[key];
+                if (key === "hooks") {
+                    hooks = hookBlockRead(value, reject, drop);
+                    continue;
+                }
+                const sign = key === "matcher" && hookLooksLikeMatcher(doc)
+                    ? [key]
+                    : HOOK_GUARD_EVENTS.includes(key) && value !== null && value !== undefined && !(Array.isArray(value) && value.length === 0)
+                        ? [key]
+                        : hookGuardSignIn(value, [key], "other");
+                if (sign !== undefined)
+                    reject("guard-outside-hooks", sign);
+            }
+        }
+        else {
+            const sign = hookGuardSignIn(settingsDoc, [], "other");
+            if (sign !== undefined)
+                reject("guard-outside-hooks", sign);
+        }
+        if (rejections.length > 0)
+            return { outcome: "rejected", hooks: undefined, dropped: [], rejections };
+        if (dropped.length > 0)
+            return { outcome: "loaded-partial", hooks, dropped, rejections: [] };
+        return { outcome: "loaded", hooks, dropped: [], rejections: [] };
+    }
+    return classifyHooksConfig;
+};

package/dist/generated/settingsSchemaTables.d.ts

@@ -9,3 +9,4 @@ export declare const SETTINGS_BUDGET_STRING_KEYS: readonly ["mode", "budgetDurat
 export declare const SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS: readonly ["maxBudgetUsd", "tpmLimit", "rpmLimit"];
 export declare const SETTINGS_MODEL_API_WORDS: readonly ["openai-completions", "anthropic-messages"];
 export declare const SETTINGS_TOOL_NAME_MATCHER_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure"];
+export declare const SETTINGS_UI_LANGUAGE_VALUES: readonly ["en", "zh"];

package/dist/generated/settingsSchemaTables.js

@@ -41,3 +41,7 @@ export const SETTINGS_TOOL_NAME_MATCHER_EVENTS = Object.freeze([
     "PostToolUse",
     "PostToolUseFailure",
 ]);
+export const SETTINGS_UI_LANGUAGE_VALUES = Object.freeze([
+    "en",
+    "zh",
+]);