@sema-agent/client-core 0.107.0 → 0.108.0

package/dist/liveModelCatalog.js

@@ -189,6 +189,45 @@ function rowIdentityUnreadable(row) {
         return true;
     }
 }
+function aliasesOf(cat) {
+    const ALIASES_ABSENT = Object.freeze({ kind: 'absent' });
+    const ALIASES_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+    try {
+        const d = Object.getOwnPropertyDescriptor(cat, 'aliases');
+        if (d === undefined)
+            return ALIASES_ABSENT;
+        if (!Object.hasOwn(d, 'value'))
+            return ALIASES_UNREADABLE;
+        const raw = d.value;
+        if (raw === undefined)
+            return ALIASES_ABSENT;
+        if (!Array.isArray(raw))
+            return ALIASES_UNREADABLE;
+        const n = ownDataOf(raw, 'length');
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            return ALIASES_UNREADABLE;
+        const entries = [];
+        for (let i = 0; i < n; i += 1) {
+            const ed = Object.getOwnPropertyDescriptor(raw, String(i));
+            if (ed === undefined || !Object.hasOwn(ed, 'value'))
+                return ALIASES_UNREADABLE;
+            const e = ed.value;
+            if (e === null || typeof e !== 'object' || !isPlainRecord(e))
+                return ALIASES_UNREADABLE;
+            const nd = Object.getOwnPropertyDescriptor(e, 'name');
+            if (nd === undefined || !Object.hasOwn(nd, 'value') || typeof nd.value !== 'string' || nd.value.length === 0)
+                return ALIASES_UNREADABLE;
+            const bit = atMentionBitOf(e);
+            if (bit === 'malformed' || bit === 'unreadable')
+                return ALIASES_UNREADABLE;
+            appendOwnElement(entries, Object.freeze({ name: nd.value, bit }));
+        }
+        return Object.freeze({ kind: 'listed', entries: Object.freeze(entries) });
+    }
+    catch {
+        return ALIASES_UNREADABLE;
+    }
+}
 export function modelAcceptanceOf(model, catalog = getLiveModelCatalog()) {
     const name = typeof model === 'string' && model.length > 0 ? model : undefined;
     try {
@@ -211,22 +250,45 @@ export function modelAcceptanceOf(model, catalog = getLiveModelCatalog()) {
                 defaultModel = undefined;
         }
         const withDefault = defaultModel === undefined ? {} : { defaultModel };
+        const cannotSay = () => Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: name });
         const reservedReading = () => Object.freeze({ verdict: 'unknown', why: 'reserved_word', model: name, ...withDefault });
-        if (reserved)
-            return reservedReading();
-        const row = liveModelRowOf(catalog, name);
-        if (row !== undefined) {
-            const normalized = ownDataOf(row, 'name');
-            if (typeof normalized !== 'string' || normalized.length === 0)
-                return Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: name });
-            if (isReservedModelWord(normalized))
+        const notMentionable = () => Object.freeze({ verdict: 'refused', why: 'not_at_mentionable', model: name, ...withDefault });
+        const byRow = (row) => {
+            if (ownDataOf(row, 'enabled') === false)
+                return Object.freeze({ verdict: 'refused', why: 'disabled', model: name, ...withDefault });
+            const bit = atMentionBitOf(row);
+            if (bit === 'refused')
+                return notMentionable();
+            if (bit === 'malformed' || bit === 'unreadable')
+                return cannotSay();
+            return Object.freeze({ verdict: 'accepted', why: 'listed', model: name, ...withDefault });
+        };
+        const aliases = aliasesOf(catalog);
+        if (aliases.kind === 'absent') {
+            if (reserved)
                 return reservedReading();
-            return ownDataOf(row, 'enabled') === false
-                ? Object.freeze({ verdict: 'refused', why: 'disabled', model: name, ...withDefault })
-                : Object.freeze({ verdict: 'accepted', why: 'listed', model: name, ...withDefault });
+            const row = liveModelRowOf(catalog, name);
+            if (row !== undefined) {
+                const normalized = ownDataOf(row, 'name');
+                if (typeof normalized !== 'string' || normalized.length === 0)
+                    return cannotSay();
+                if (isReservedModelWord(normalized))
+                    return reservedReading();
+                return byRow(row);
+            }
+        }
+        else {
+            const row = rows.find((r) => ownDataOf(r, 'name') === name);
+            if (row !== undefined)
+                return byRow(row);
+            if (aliases.kind === 'unreadable')
+                return cannotSay();
+            const alias = aliases.entries.find((a) => a.name === name);
+            if (alias !== undefined)
+                return alias.bit === 'refused' ? notMentionable() : Object.freeze({ verdict: 'accepted', why: 'aliased', model: name, ...withDefault });
         }
         if (rows.some(rowIdentityUnreadable))
-            return Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: name });
+            return cannotSay();
         const dropped = droppedModelEntriesOf(catalog);
         if (droppedDisabledNamed(dropped, name))
             return Object.freeze({ verdict: 'refused', why: 'disabled', model: name, ...withDefault });
@@ -246,7 +308,7 @@ export function modelNotServedNotice(reading, lang) {
         if (ownDataOf(reading, 'verdict') !== 'refused')
             return undefined;
         const why = ownDataOf(reading, 'why');
-        if (why !== 'not_listed' && why !== 'disabled')
+        if (why !== 'not_listed' && why !== 'disabled' && why !== 'not_at_mentionable')
             return undefined;
         const model = ownDataOf(reading, 'model');
         const shown = typeof model === 'string' && model.length > 0 ? quoteUntrustedForSentence(model, NOT_SERVED_NAME_MAX) : undefined;
@@ -254,6 +316,11 @@ export function modelNotServedNotice(reading, lang) {
             return undefined;
         const dm = ownDataOf(reading, 'defaultModel');
         const fallback = typeof dm === 'string' && dm.length > 0 ? quoteUntrustedForSentence(dm, NOT_SERVED_NAME_MAX) : undefined;
+        if (why === 'not_at_mentionable') {
+            return fallback === undefined
+                ? renderMessage(msg('model.notMentionable.noDefault', { model: shown }), lang)
+                : renderMessage(msg('model.notMentionable.withDefault', { model: shown, default: fallback }), lang);
+        }
         return fallback === undefined
             ? renderMessage(msg('model.notServed.noDefault', { model: shown }), lang)
             : renderMessage(msg('model.notServed.withDefault', { model: shown, default: fallback }), lang);
@@ -420,6 +487,24 @@ export function modelPlaneOf(catalog = getLiveModelCatalog()) {
         return unreadable;
     }
 }
+export function modelPlaneSentence(reading, lang) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return undefined;
+        if (ownDataOf(reading, 'kind') !== 'read')
+            return undefined;
+        const served = ownDataOf(reading, 'servedTable');
+        const stance = ownDataOf(reading, 'catalog');
+        if (served !== 'env')
+            return undefined;
+        if (stance !== 'absent' && stance !== 'refused')
+            return undefined;
+        return renderMessage(msg('model.catalog.envServed', { stance }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
 const CONFIG_DOMAIN_WORD = /^[a-z][a-z0-9_.-]{0,63}$/;
 export function modelCandidateRejectedContent(reading, lang) {
     try {
@@ -467,6 +552,7 @@ export function readLiveModelCatalog(body) {
         const droppedKey = envelopeKey(body, 'droppedEntries');
         const candidateKey = envelopeKey(body, 'candidateRejected');
         const planeKey = envelopeKey(body, 'modelPlane');
+        const aliasesKey = envelopeKey(body, 'aliases');
         const raw = modelsKey.present ? modelsKey.value : undefined;
         if (!Array.isArray(raw))
             return unreadableCatalog('models_not_array');
@@ -479,7 +565,7 @@ export function readLiveModelCatalog(body) {
         let unreadableRows = 0;
         for (let i = 0; i < len; i += 1) {
             const d = Object.getOwnPropertyDescriptor(raw, String(i));
-            const row = d !== undefined && Object.hasOwn(d, 'value') ? liveModelRowCopy(d.value) : undefined;
+            const row = d !== undefined && Object.hasOwn(d, 'value') ? modelRowTransitCopy(d.value) : undefined;
             if (row === undefined || names.has(row.name)) {
                 unreadableRows += 1;
                 continue;
@@ -504,12 +590,60 @@ export function readLiveModelCatalog(body) {
             out.candidateRejected = frozenJsonCopyOf(candidateKey.value) ?? null;
         if (planeKey.present && planeKey.value !== undefined)
             out.modelPlane = frozenJsonCopyOf(planeKey.value) ?? null;
+        if (aliasesKey.present && aliasesKey.value !== undefined)
+            out.aliases = aliasesTransitCopy(aliasesKey.value);
         return Object.freeze({ kind: 'read', catalog: Object.freeze(out), unreadableRows, ...(defaultModelMalformed ? { defaultModelMalformed: true } : {}) });
     }
     catch {
         return unreadableCatalog('unreadable');
     }
 }
+function aliasesTransitCopy(v) {
+    const copy = frozenJsonCopyOf(v);
+    if (copy === undefined)
+        return null;
+    const before = aliasesOf({ aliases: v });
+    const after = aliasesOf({ aliases: copy });
+    if (before.kind !== after.kind)
+        return null;
+    if (before.kind === 'listed' && after.kind === 'listed') {
+        if (before.entries.length !== after.entries.length)
+            return null;
+        for (let i = 0; i < before.entries.length; i += 1) {
+            const b = before.entries[i];
+            const a = after.entries[i];
+            if (b === undefined || a === undefined || b.name !== a.name || b.bit !== a.bit)
+                return null;
+        }
+    }
+    return copy;
+}
+const ACCEPTANCE_ROW_KEYS = Object.freeze(['id', 'enabled', 'atMentionable']);
+function modelRowTransitCopy(row) {
+    const copy = liveModelRowCopy(row);
+    if (copy === undefined || row === null || typeof row !== 'object')
+        return copy;
+    let restated;
+    for (const key of ACCEPTANCE_ROW_KEYS) {
+        if (Object.hasOwn(copy, key))
+            continue;
+        let value;
+        try {
+            const d = Object.getOwnPropertyDescriptor(row, key);
+            if (d === undefined)
+                continue;
+            value = Object.hasOwn(d, 'value') ? (d.value === undefined ? undefined : (frozenJsonCopyOf(d.value) ?? null)) : null;
+        }
+        catch {
+            value = null;
+        }
+        if (value === undefined)
+            continue;
+        restated ??= { ...copy };
+        Object.defineProperty(restated, key, { value, enumerable: true, writable: true, configurable: true });
+    }
+    return restated === undefined ? copy : Object.freeze(restated);
+}
 function droppedEntriesCopy(v) {
     if (!Array.isArray(v))
         return frozenJsonCopyOf(v) ?? null;
@@ -544,23 +678,27 @@ export function liveDefaultModelOf(catalog = getLiveModelCatalog()) {
         return Object.freeze({ kind: 'unknown', why: 'unreadable' });
     }
 }
+function atMentionBitOf(o) {
+    const d = Object.getOwnPropertyDescriptor(o, 'atMentionable');
+    if (d === undefined)
+        return 'not_governed';
+    if (!(Object.hasOwn(d, 'value')))
+        return 'unreadable';
+    if (d.value === undefined)
+        return 'not_governed';
+    if (d.value === true)
+        return 'allowed';
+    if (d.value === false)
+        return 'refused';
+    return 'malformed';
+}
 export function atMentionOf(model, catalog = getLiveModelCatalog()) {
     try {
         const target = targetRowOf(model, catalog);
         if (target.kind !== 'row')
             return Object.freeze({ kind: 'unknown', why: target.why });
-        const d = Object.getOwnPropertyDescriptor(target.row, 'atMentionable');
-        if (d === undefined)
-            return Object.freeze({ kind: 'not_governed' });
-        if (!(Object.hasOwn(d, 'value')))
-            return Object.freeze({ kind: 'unknown', why: 'unreadable' });
-        if (d.value === undefined)
-            return Object.freeze({ kind: 'not_governed' });
-        if (d.value === true)
-            return Object.freeze({ kind: 'allowed' });
-        if (d.value === false)
-            return Object.freeze({ kind: 'refused' });
-        return Object.freeze({ kind: 'unknown', why: 'malformed' });
+        const bit = atMentionBitOf(target.row);
+        return bit === 'malformed' || bit === 'unreadable' ? Object.freeze({ kind: 'unknown', why: bit }) : Object.freeze({ kind: bit });
     }
     catch {
         return Object.freeze({ kind: 'unknown', why: 'unreadable' });

package/dist/model/catalogDefault.d.ts

@@ -1,4 +1,6 @@
 import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL, type SETTINGS_DEFAULT_ROLE_TIER_LADDER } from '../generated/settingsSchemaFns.js';
+import { SETTINGS_MODEL_PLANE_REFUSAL_CODES } from '../generated/settingsSchemaTables.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
 export type CatalogDefaultModelsInput = Parameters<typeof SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL>[0];
 export type CatalogDefaultSource = 'roles.default' | 'fallback' | `tierGroup.${(typeof SETTINGS_DEFAULT_ROLE_TIER_LADDER)[number]}`;
 export interface CatalogDefaultDangling {
@@ -22,3 +24,26 @@ export interface CatalogDefaultSelect {
 }
 export type CatalogDefaultModel = CatalogDefaultNamed | CatalogDefaultSelect;
 export declare function resolveCatalogDefaultModel(models: CatalogDefaultModelsInput, has: (name: string) => boolean, fallback: string): CatalogDefaultModel;
+export type CatalogDefaultRefusalCode = Extract<(typeof SETTINGS_MODEL_PLANE_REFUSAL_CODES)[number], 'config.default_model_missing'>;
+export interface CatalogDefaultModelVerdictInput {
+    readonly models: CatalogDefaultModelsInput;
+    readonly has: (name: string) => boolean;
+    readonly fallback: string;
+    readonly face: object;
+}
+export interface CatalogDefaultResolvable {
+    readonly ok: true;
+    readonly default: CatalogDefaultModel;
+}
+export interface CatalogDefaultRefused {
+    readonly ok: false;
+    readonly code: CatalogDefaultRefusalCode;
+    readonly default: CatalogDefaultModel;
+    readonly detail: {
+        readonly cause: string;
+        readonly role: string;
+    };
+}
+export type CatalogDefaultModelVerdict = CatalogDefaultResolvable | CatalogDefaultRefused;
+export declare function catalogDefaultModelVerdict(input: CatalogDefaultModelVerdictInput): CatalogDefaultModelVerdict | undefined;
+export declare function catalogDefaultRefusalContent(verdict: CatalogDefaultModelVerdict, lang?: UiLanguage): string | undefined;

package/dist/model/catalogDefault.js

@@ -1,4 +1,48 @@
 import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL } from '../generated/settingsSchemaFns.js';
+import { modelFaceResolvable } from '../coreValuePorts.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { displayUntrusted } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export function resolveCatalogDefaultModel(models, has, fallback) {
     return SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL(models, has, fallback);
 }
+const CATALOG_DEFAULT_REFUSAL_CODE = 'config.default_model_missing';
+export function catalogDefaultModelVerdict(input) {
+    const { models, has, fallback, face } = input;
+    const chain = resolveCatalogDefaultModel(models, has, fallback);
+    const verdict = modelFaceResolvable(face, { spec: { modelRole: 'default' } });
+    if (verdict === undefined || typeof verdict !== 'object' || verdict === null)
+        return undefined;
+    const okSlot = slotReadOf(verdict, 'ok');
+    if (okSlot.presence !== 'present')
+        return undefined;
+    if (okSlot.value === true)
+        return Object.freeze({ ok: true, default: chain });
+    if (okSlot.value !== false)
+        return undefined;
+    const codeSlot = slotReadOf(verdict, 'code');
+    const roleSlot = slotReadOf(verdict, 'role');
+    const code = codeSlot.presence === 'present' ? codeSlot.value : undefined;
+    const role = roleSlot.presence === 'present' ? roleSlot.value : undefined;
+    if (typeof code !== 'string' || code.length === 0 || typeof role !== 'string' || role.length === 0)
+        return undefined;
+    return Object.freeze({
+        ok: false,
+        code: CATALOG_DEFAULT_REFUSAL_CODE,
+        default: chain,
+        detail: Object.freeze({ cause: code, role }),
+    });
+}
+export function catalogDefaultRefusalContent(verdict, lang) {
+    if (typeof verdict !== 'object' || verdict === null || verdict.ok !== false)
+        return undefined;
+    const d = verdict.default;
+    if (typeof d !== 'object' || d === null)
+        return undefined;
+    if (d.kind === 'named' && typeof d.name === 'string') {
+        return renderMessage(msg('model.catalogDefault.refused.named', { name: displayUntrusted(d.name, { max: 64 }) }), lang);
+    }
+    if (d.kind === 'select')
+        return renderMessage(msg('model.catalogDefault.refused.select'), lang);
+    return undefined;
+}

package/dist/permissionWireCaps.d.ts

@@ -4,6 +4,7 @@ export type { PermissionMode };
 export interface PermissionModeField {
     permissionMode?: PermissionMode;
 }
+export declare function permissionModeTitle(word: string): string | undefined;
 export declare function permissionModeField(mode: string | undefined, opts?: {
     stampDefault?: boolean;
     permissionModes?: PermissionModesReading | undefined;

package/dist/permissionWireCaps.js

@@ -2,6 +2,17 @@ import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
 import { permissionModeAdmitted } from './permissionModesCapability.js';
 const _permissionModePin = true;
 void _permissionModePin;
+const PERMISSION_MODE_TITLES = {
+    default: 'Manual',
+    acceptEdits: 'Accept edits',
+    plan: 'Plan',
+    auto: 'Auto',
+    bypassPermissions: 'Bypass Permissions',
+    dontAsk: "Don't Ask",
+};
+export function permissionModeTitle(word) {
+    return typeof word === 'string' && Object.hasOwn(PERMISSION_MODE_TITLES, word) ? PERMISSION_MODE_TITLES[word] : undefined;
+}
 const BIT_GATED_MODE = 'dontAsk';
 const KNOWN = new Set(PERMISSION_MODE_WORDS.filter((w) => w !== BIT_GATED_MODE));
 export function permissionModeField(mode, opts) {

package/dist/pluginHooksWire.d.ts

@@ -8,11 +8,11 @@ export declare const ENGINE_FIRED_HOOK_EVENTS: readonly ["PreToolUse", "PostTool
 export type EngineFiredHookEvent = (typeof ENGINE_FIRED_HOOK_EVENTS)[number];
 export declare const PLUGIN_HOOK_DISPOSITIONS: readonly ["engine", "shell", "not_run"];
 export type PluginHookDisposition = (typeof PLUGIN_HOOK_DISPOSITIONS)[number];
-export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete", "compaction_local_fallback"];
+export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete", "compaction_local_fallback", "key_not_read", "source_not_authored"];
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
-export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported"];
+export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored"];
 export type SettingsHookDropReason = (typeof SETTINGS_HOOK_DROP_REASONS)[number];
 export type HookSettingsSource = 'policySettings' | 'userSettings' | 'projectSettings' | 'localSettings' | 'flagSettings';
 export interface PluginHookKey {
@@ -36,6 +36,7 @@ export interface SettingsHookDrop {
     readonly hookIndex: number;
     readonly reason: SettingsHookDropReason;
     readonly notRun: boolean;
+    readonly unreadKeys?: readonly (readonly (string | number)[])[];
 }
 export interface SettingsHookVerdict {
     readonly source: HookSettingsSource;
@@ -147,6 +148,7 @@ export interface PluginHookDecisionInput {
     readonly promptAuthoredByUser: boolean;
     readonly occupied: ReadonlyMap<string, EventOccupancy>;
     readonly suppressedLocally?: ReadonlySet<string>;
+    readonly readerNotRead: readonly string[];
 }
 export interface PluginHookDecision {
     readonly verdicts: readonly PluginHookVerdict[];
@@ -166,7 +168,7 @@ export declare function decideSessionHooks(input: SessionHookDecisionInput): {
     readonly verdicts: readonly SessionHookVerdict[];
     readonly unreadable: number;
 };
-export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, mask?: HooksSalvageMask): SettingsHookFilterResult;
+export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, readerNotRead: readonly string[], mask?: HooksSalvageMask): SettingsHookFilterResult;
 export interface SettingsHookFilterResult {
     readonly groups: WireHookGroup[];
     readonly drops: SettingsHookDrop[];

package/dist/pluginHooksWire.js

@@ -1,8 +1,8 @@
 import { displayUntrusted } from './displayUntrusted.js';
-import { appendOwnElement } from './ownKey.js';
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
-import { HOOK_SETTINGS_SOURCE_TEXT, hooksSalvageMaskOf, salvageSettingsHooksEntries, } from './settingsHooksSalvage.js';
+import { HOOK_SETTINGS_SOURCE_TEXT, hooksEntryUnreadKeys, hooksGroupAuthoredSource, hooksGroupUnreadKeys, hooksKeyCoordinateText, hooksSalvageMaskOf, salvageSettingsHooksEntries, } from './settingsHooksSalvage.js';
 export const ENGINE_FIRED_HOOK_EVENTS = SETTINGS_ENGINE_OWNED_HOOK_EVENTS;
 export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
 export const PLUGIN_HOOK_REASONS = [
@@ -29,6 +29,8 @@ export const PLUGIN_HOOK_REASONS = [
     'scope_unsupported',
     'source_incomplete',
     'compaction_local_fallback',
+    'key_not_read',
+    'source_not_authored',
 ];
 export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'workspace_untrusted',
@@ -38,7 +40,7 @@ export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'managed_plugins_only',
     'prompt_not_user_authored',
 ];
-export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported'];
+export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported', 'key_not_read', 'source_not_authored'];
 export function hooksWirePlanShapeOf(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -257,7 +259,9 @@ export function decidePluginHooks(input) {
                     unreadable++;
                     return;
                 }
-                ;
+                const authored = hooksGroupAuthoredSource(group);
+                const groupUnread = authored === 'unreadable' ? undefined : hooksGroupUnreadKeys(event, group);
+                const groupSourceAuthored = authored === 'unreadable' || (authored === 'present' && groupUnread !== undefined);
                 group.hooks.forEach((entry, hookIndex) => {
                     const key = { pluginId, pluginName, event, groupIndex, hookIndex };
                     if (input.exclusion !== undefined) {
@@ -317,6 +321,15 @@ export function decidePluginHooks(input) {
                         appendOwnElement(verdicts, { ...key, disposition: ex.disposition, reason: ex.reason });
                         return;
                     }
+                    const entryUnread = isRecord(entry) ? hooksEntryUnreadKeys(event, entry, input.readerNotRead) : undefined;
+                    if (groupSourceAuthored && (authored === 'unreadable' || entryUnread !== undefined)) {
+                        appendOwnElement(verdicts, { ...key, ...fallback(event, entryType, 'source_not_authored') });
+                        return;
+                    }
+                    if (entryUnread !== undefined && ((groupUnread?.length ?? 0) > 0 || entryUnread.length > 0)) {
+                        appendOwnElement(verdicts, { ...key, ...fallback(event, entryType, 'key_not_read') });
+                        return;
+                    }
                     const plugin = { name: src.name, root: src.root, dataDir: src.dataDir };
                     const options = projectedOptions(src.options);
                     if (options !== undefined)
@@ -454,7 +467,18 @@ function carriesArgs(entry) {
     }
     return true;
 }
-export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, judge, mask) {
+function unreadKeyPathsOf(event, groupIndex, hookIndex, groupUnread, entryUnread) {
+    if (entryUnread === undefined)
+        return Object.freeze([]);
+    const out = [];
+    for (const k of groupUnread)
+        appendOwnElement(out, Object.freeze(['hooks', event, groupIndex, k]));
+    for (const k of entryUnread)
+        if (k !== 'plugin')
+            appendOwnElement(out, Object.freeze(['hooks', event, groupIndex, 'hooks', hookIndex, k]));
+    return Object.freeze(out);
+}
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, shellRunsType, judge, readerNotRead, mask) {
     const drops = [];
     const verdicts = [];
     const excluded = [];
@@ -470,20 +494,35 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
         }
         const kept = [];
         let changed = false;
+        const authored = hooksGroupAuthoredSource(group);
+        const groupUnread = authored === 'unreadable' ? undefined : hooksGroupUnreadKeys(event, group);
+        const groupSourceAuthored = authored === 'unreadable' || (authored === 'present' && groupUnread !== undefined);
         group.hooks.forEach((entry, hookIndex) => {
             if (mask !== undefined && mask.entryDropped(event, groupIndex, hookIndex)) {
                 changed = true;
                 return;
             }
-            const reason = !isRecord(entry)
+            const earlier = !isRecord(entry)
                 ? undefined
                 : entry.type === 'mcp_tool'
                     ? 'mcp_tool_unsupported'
                     : entry.type === 'command' && carriesArgs(entry) && !execFormCapable
                         ? 'exec_form_unsupported'
                         : undefined;
+            const entryUnread = earlier === undefined && isRecord(entry) ? hooksEntryUnreadKeys(event, entry, readerNotRead) : undefined;
+            const sourceNotAuthored = earlier === undefined && groupSourceAuthored && (authored === 'unreadable' || entryUnread !== undefined);
+            const unreadKeys = earlier === undefined && !sourceNotAuthored ? unreadKeyPathsOf(event, groupIndex, hookIndex, groupUnread ?? [], entryUnread) : [];
+            const reason = earlier ?? (sourceNotAuthored ? 'source_not_authored' : unreadKeys.length > 0 ? 'key_not_read' : undefined);
             if (reason !== undefined) {
-                appendOwnElement(drops, { source, event, groupIndex, hookIndex, reason, notRun: engineEvent && !shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined) });
+                appendOwnElement(drops, {
+                    source,
+                    event,
+                    groupIndex,
+                    hookIndex,
+                    reason,
+                    notRun: engineEvent && !shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined),
+                    ...(reason === 'key_not_read' ? { unreadKeys } : {}),
+                });
                 changed = true;
                 return;
             }
@@ -510,6 +549,8 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
             }
             appendOwnElement(kept, entry);
         });
+        if (((groupUnread?.length ?? 0) > 0 || groupSourceAuthored) && kept.length === 0)
+            changed = true;
         if (!changed)
             appendOwnElement(out, group);
         else if (kept.length > 0)
@@ -832,10 +873,14 @@ const REASON_TEXT = {
     scope_unsupported: 'hooks registered for a skill, an agent or by the host application are not sent to the engine, and this client does not run this event',
     source_incomplete: 'the plugin was reported without its id, name, root folder or data folder',
     compaction_local_fallback: renderMessage(msg('config.hooks.plan.reason.compactionLocalFallback')),
+    key_not_read: renderMessage(msg('config.hooks.plan.reason.keyNotRead')),
+    source_not_authored: renderMessage(msg('config.hooks.plan.reason.sourceNotAuthored')),
 };
 const DROP_TEXT = {
     exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
     mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
+    key_not_read: REASON_TEXT.key_not_read,
+    source_not_authored: REASON_TEXT.source_not_authored,
 };
 const SOURCE_TEXT = HOOK_SETTINGS_SOURCE_TEXT;
 export function pluginHookReasonText(reason) {
@@ -898,8 +943,52 @@ function capNoticeLabel(s) {
     }
     return `${s.slice(0, end)}…`;
 }
+const KEY_NOT_READ_SHOWN = 3;
+function unreadPathsOfRow(d) {
+    const raw = d.unreadKeys;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((p) => Array.isArray(p) && p.length > 0 && p.every((x) => typeof x === 'string' || typeof x === 'number'));
+}
+function namedPathsOfRow(d) {
+    switch (d.reason) {
+        case 'key_not_read':
+            return unreadPathsOfRow(d);
+        case 'source_not_authored':
+            return typeof d.event === 'string' && Number.isInteger(d.groupIndex) && d.groupIndex >= 0 ? [['hooks', d.event, d.groupIndex, 'source']] : [];
+        case 'exec_form_unsupported':
+        case 'mcp_tool_unsupported':
+            return [];
+    }
+}
+function namedCoordinatesText(coordinates) {
+    const shown = coordinates.slice(0, KEY_NOT_READ_SHOWN).join(', ');
+    return coordinates.length > KEY_NOT_READ_SHOWN ? renderMessage(msg('config.hooks.plan.keyNotRead.more', { shown, rest: coordinates.length - KEY_NOT_READ_SHOWN })) : shown;
+}
+function keyNotReadLine(source, row) {
+    const events = row.events.map((e) => noticeLabel(e)).join(', ');
+    const hooks = `${row.count} ${events} ${row.count === 1 ? 'hook' : 'hooks'}`;
+    const coordinates = namedCoordinatesText(row.coordinates);
+    const line = renderMessage(msg(row.coordinates.length === 1 ? 'config.hooks.plan.keyNotRead.oneKey' : 'config.hooks.plan.keyNotRead.manyKeys', { layer: SOURCE_TEXT[source], hooks, coordinates }));
+    return row.onFailure ? renderMessage(msg('config.hooks.plan.keyNotRead.withOnFailure', { line })) : line;
+}
+function sourceNotAuthoredLine(source, row) {
+    const events = row.events.map((e) => noticeLabel(e)).join(', ');
+    const hooks = `${row.count} ${events} ${row.count === 1 ? 'hook' : 'hooks'}`;
+    const coordinates = namedCoordinatesText(row.coordinates);
+    return renderMessage(msg(row.coordinates.length === 1 ? 'config.hooks.plan.sourceNotAuthored.oneKey' : 'config.hooks.plan.sourceNotAuthored.manyKeys', { layer: SOURCE_TEXT[source], hooks, coordinates }));
+}
 export function hooksNotRunNotice(plan) {
     const lines = [];
+    let closedBy;
+    try {
+        closedBy = isRecord(plan) ? readOwnDataValue(plan, 'closedBy') : undefined;
+    }
+    catch {
+        closedBy = undefined;
+    }
+    if (closedBy === 'policy_disable_all')
+        appendOwnElement(lines, renderMessage(msg('config.hooks.plan.disableAllHooks')));
     const byPlugin = new Map();
     for (const v of plan.verdicts) {
         if (v.disposition !== 'not_run')
@@ -916,9 +1005,27 @@ export function hooksNotRunNotice(plan) {
         appendOwnElement(lines, `Plugin "${noticeLabel(row.name) || '(unnamed)'}": ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
     }
     const bySource = new Map();
+    const namedBySource = new Map();
     for (const d of plan.settingsDropped) {
         if (!d.notRun)
             continue;
+        const named = d.reason === 'key_not_read' || d.reason === 'source_not_authored' ? namedPathsOfRow(d) : [];
+        if (named.length > 0 && (d.reason === 'key_not_read' || d.reason === 'source_not_authored')) {
+            const nk = `${d.source}\u0000${d.reason}`;
+            const row = namedBySource.get(nk) ?? { source: d.source, reason: d.reason, events: [], count: 0, coordinates: [], onFailure: false };
+            if (!row.events.includes(d.event))
+                appendOwnElement(row.events, d.event);
+            row.count++;
+            for (const path of named) {
+                const c = hooksKeyCoordinateText(path);
+                if (!row.coordinates.includes(c))
+                    appendOwnElement(row.coordinates, c);
+                if (d.reason === 'key_not_read' && path[path.length - 1] === 'onFailure')
+                    row.onFailure = true;
+            }
+            namedBySource.set(nk, row);
+            continue;
+        }
         const k = `${d.source}\u0000${d.reason}`;
         const row = bySource.get(k) ?? { source: d.source, reason: d.reason, events: [], count: 0 };
         if (!row.events.includes(d.event))
@@ -930,6 +1037,8 @@ export function hooksNotRunNotice(plan) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
         appendOwnElement(lines, `${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${settingsHookDropText(row.reason)}.`);
     }
+    for (const row of namedBySource.values())
+        appendOwnElement(lines, row.reason === 'key_not_read' ? keyNotReadLine(row.source, row) : sourceNotAuthoredLine(row.source, row));
     const settingsVerdicts = plan.settingsVerdicts;
     const byVerdict = new Map();
     for (const raw of Array.isArray(settingsVerdicts) ? settingsVerdicts : []) {

package/dist/queuedDelivery.d.ts

@@ -15,6 +15,7 @@ export interface QueueEntry {
     readonly intentKey?: string;
     readonly screening?: 'pending' | 'result';
     readonly upsExecutor?: 'shell' | 'engine' | 'unknown' | 'none';
+    readonly _sema_task_notification?: {} | null | undefined;
 }
 export type QueuedHoldReason = 'barrier' | 'share_incomplete' | 'not_steerable' | 'in_flight' | 'attempted' | 'no_run';
 export interface QueuedDeliveryPlan {