@sema-agent/client-core 0.106.0 → 0.108.0

package/dist/index.js

@@ -209,6 +209,7 @@ export { encodeHumanTurn, deliveredUuidsOf, imageSentOnUnknownVision, otherBodyB
 export { batchCompatible, planQueuedDelivery, humanTurnCapsOf, humanTextForKeywordScan, selfHealSteerEligible } from './queuedDelivery.js';
 export { SUBMISSION_SURFACES, SUBMISSION_ORIGINS, SUBMISSION_TOOLS, SUBMISSION_KINDS, submissionProvenanceOf, submissionIdentityOf, requestLaneOf, submissionOriginOf, } from './request/submissionIdentity.js';
 export { taskNotificationOf, taskNotificationQueueCommand } from './notifications.js';
+export { taskNotificationAdmissionOf } from './taskNotificationAdmission.js';
 export { resultErrorCodeInTextOf } from './resultFrameKeys.js';
 export { humanTurnRefusalSentence, humanTurnDegradedSentence, printImageVisionSentence } from './humanTurnSentences.js';
 export { observedUserAttachmentSeat, projectUserAttachmentSeatCapability, userAttachmentSeatAdmits } from './userAttachmentSeat.js';
@@ -295,6 +296,8 @@ export { noAllowCauseOf } from './hitl/noAllowCause.js';
 export { policyDenyReason } from './hitl/frameRouter.js';
 export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, allowRuleShadowSentence, } from './hitl/allowRuleShadow.js';
 export { projectCrashConverged } from './hitl/crashConverged.js';
+export { checkpointQueueRowSortOf } from './hitl/approvalQueueRow.js';
+export { subagentSourceSessionOf } from './hitl/subagentSource.js';
 export * from './hitl/crashConvergedNotice.js';
 export { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
 export { approvalCompleteCauseOf } from './hitl/approvalEndingCause.js';
@@ -322,6 +325,7 @@ export * from './agentSession/contract.js';
 export * from './agentSession/backgroundView.js';
 export { readAssistantInbox } from './assistantInbox.js';
 export { checkpointRowVerdictOf } from './checkpointRowVerdict.js';
+export { checkpointRowBarOf, checkpointRowBarSentence } from './checkpointRowVerdict.js';
 export { checkpointRequirementsDamagedOf } from './checkpointRowVerdict.js';
 export { READ_CREDENTIAL_NOT_ACCEPTED_NOTICE, isReadCredentialRefusal } from './readCredentialRefusal.js';
 export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from './agentSession/engineAgentRegistryRead.js';
@@ -357,5 +361,5 @@ export { PROJECT_MEMORY_WORDS, projectMemoryOf, observedProjectMemoryCapability,
 export { sessionRulesChildrenReadLiveOf } from './sessionRulesChildrenReadLive.js';
 export { scenarioSkillsOf, observedScenarioSkillsCapability } from './scenarioSkills.js';
 export { observedApprovalFrameFamilies, approvalFrameFamiliesDeclaration } from './approvalFrameFamilies.js';
-export { sessionEngineBindingFor, commitSessionEngine, readSessionEngine, sessionDispatchTarget } from './sessionEngine.js';
+export { sessionEngineBindingFor, commitSessionEngine, readSessionEngine, sessionDispatchTarget, sessionDispatchRefusedFor } from './sessionEngine.js';
 export { foldSessionPlacement } from './deviceRebind.js';

package/dist/injectionLaneNotice.js

@@ -1,3 +1,4 @@
+import { executionLaneWordIsNone } from './executionLaneWords.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export const INJECTION_SOURCES = Object.freeze(['stdio_mcp', 'credentialed_mcp', 'task_hooks']);
@@ -16,7 +17,7 @@ function remoteLaneWordOf(lane) {
             return undefined;
         if (view.toolsOnThisHost !== false)
             return undefined;
-        if (view.isolatedAbsent === 'no_hands' || view.provider === 'in-process')
+        if (view.isolatedAbsent === 'no_hands' || executionLaneWordIsNone(view.provider))
             return undefined;
         if (typeof view.provider !== 'string' || view.provider === '')
             return undefined;

package/dist/liveModelCatalog.d.ts

@@ -23,6 +23,7 @@ export interface LiveModelCatalog {
     droppedEntries?: readonly LiveModelDroppedEntry[];
     candidateRejected?: unknown;
     modelPlane?: {} | null;
+    aliases?: {} | null;
 }
 export declare function setLiveModelCatalog(next: LiveModelCatalog | null): void;
 export declare function setLiveModelCatalogRefresher(fn: (() => Promise<LiveModelCatalog | null>) | null): void;
@@ -51,12 +52,12 @@ export declare function effortLevelHonored(reading: EffortLevelsReading, level:
 export declare function liveDefaultModelName(): string | null;
 export type ModelAcceptanceReading = {
     readonly verdict: 'accepted';
-    readonly why: 'listed';
+    readonly why: 'listed' | 'aliased';
     readonly model: string;
     readonly defaultModel?: string;
 } | {
     readonly verdict: 'refused';
-    readonly why: 'not_listed' | 'disabled';
+    readonly why: 'not_listed' | 'disabled' | 'not_at_mentionable';
     readonly model: string;
     readonly defaultModel?: string;
 } | {
@@ -118,6 +119,7 @@ export type ModelPlaneReading = {
     readonly kind: 'unreadable';
 };
 export declare function modelPlaneOf(catalog?: LiveModelCatalog | null): ModelPlaneReading;
+export declare function modelPlaneSentence(reading: ModelPlaneReading, lang?: UiLanguage): string | undefined;
 export declare function modelCandidateRejectedContent(reading: ModelCandidateRejectedReading, lang?: UiLanguage): string | undefined;
 export interface RoutePairingVerdict {
     verdict: 'ok' | 'broken' | 'unknown';

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/noticePresentation.js

@@ -102,6 +102,8 @@ const OCCURRENCE_KEY_BY_CODE = Object.freeze({
     'memory.hold_released': 'reportId',
     'memory.hold_disposed': 'reportId',
     'memory.consolidation_recommended': 'reportId',
+    'memory.harvest_refused': 'reportId',
+    'memory.harvest_conflict': 'reportId',
     'memory.capture_opted_out': 'sessionId',
     'memory.delegation_static_mark_waived': 'runId',
 });

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[];