@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/noticePresentation.js

@@ -69,6 +69,14 @@ function pickCut(src, limit, floor, boundary) {
         return clause;
     return word >= floor ? word : -1;
 }
+export function pairSafeCut(text, cut) {
+    if (cut <= 0 || cut >= text.length || text.charAt(cut) !== '\\' || text.charAt(cut - 1) !== '\\')
+        return cut;
+    let start = cut - 1;
+    while (start > 0 && text.charAt(start - 1) === '\\')
+        start--;
+    return (cut - start) % 2 === 1 ? cut - 1 : cut;
+}
 export function cutForDisplay(text, budget, opts) {
     const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
     if (typeof budget !== 'number' || !Number.isFinite(budget))
@@ -83,9 +91,79 @@ export function cutForDisplay(text, budget, opts) {
     const head = capDisplay(src, room, 'escape');
     const floor = Math.ceil(head.length / CUT_KEEP_DIVISOR);
     const at = pickCut(src, head.length, floor, boundary);
-    const kept = (at === -1 ? head : src.slice(0, at)).trimEnd();
+    const kept = src.slice(0, pairSafeCut(src, at === -1 ? head.length : at)).trimEnd();
     return { shown: `${kept}${mark}`, truncated: true };
 }
+const ELISION_MARK = '…';
+const ELISION_MIN_ROOM = 8;
+const ELISION_SOFT_BACKOFF = 24;
+const CLUSTER_EXTENDER = /^[\p{M}‍︀-️\u{1F3FB}-\u{1F3FF}\u{E0020}-\u{E007F}]/u;
+const REGIONAL_INDICATOR = /^[\u{1F1E6}-\u{1F1FF}]$/u;
+const RTL_LETTER = /^[\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}]$/u;
+function codePointBefore(text, i) {
+    return text.slice(Math.max(0, i - 2), i).match(/[\s\S]$/u)?.[0] ?? '';
+}
+function codePointAfter(text, i) {
+    const cp = i < text.length ? text.codePointAt(i) : undefined;
+    return cp === undefined ? '' : String.fromCodePoint(cp);
+}
+function hardSafeBoundary(text, i) {
+    return i <= 0 || i >= text.length || (capDisplay(text, i, 'escape').length === i && pairSafeCut(text, i) === i);
+}
+function calmBoundary(text, i) {
+    const before = codePointBefore(text, i);
+    const after = codePointAfter(text, i);
+    if (before === '' || after === '')
+        return true;
+    if (before === '‍' || CLUSTER_EXTENDER.test(after))
+        return false;
+    if (RTL_LETTER.test(before) || RTL_LETTER.test(after))
+        return false;
+    if (REGIONAL_INDICATOR.test(before) && REGIONAL_INDICATOR.test(after)) {
+        let run = 0;
+        for (let j = i; j > 0;) {
+            const cp = codePointBefore(text, j);
+            if (!REGIONAL_INDICATOR.test(cp))
+                break;
+            run++;
+            j -= cp.length;
+        }
+        return run % 2 === 0;
+    }
+    return true;
+}
+function settleOnCalm(text, at, step) {
+    for (let k = 0; k <= ELISION_SOFT_BACKOFF; k++) {
+        const i = at + step * k;
+        if (i < 0 || i > text.length)
+            break;
+        if (hardSafeBoundary(text, i) && calmBoundary(text, i))
+            return i;
+    }
+    return at;
+}
+export function elideMiddleForDisplay(text, budget) {
+    const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
+    if (typeof budget !== 'number' || !Number.isFinite(budget))
+        return src;
+    const limit = Math.max(0, Math.floor(budget));
+    if (src.length <= limit)
+        return src;
+    const room = limit - ELISION_MARK.length;
+    if (room < ELISION_MIN_ROOM)
+        return cutForDisplay(src, limit).shown;
+    const headRoom = Math.ceil(room / 2);
+    const tailRoom = room - headRoom;
+    let head = headRoom;
+    while (head > 0 && !hardSafeBoundary(src, head))
+        head--;
+    let tail = src.length - tailRoom;
+    while (tail < src.length && !hardSafeBoundary(src, tail))
+        tail++;
+    head = settleOnCalm(src, head, -1);
+    tail = settleOnCalm(src, tail, 1);
+    return `${src.slice(0, head).trimEnd()}${ELISION_MARK}${src.slice(tail)}`;
+}
 export const NOTICE_SEAT_CLASS = Object.freeze({
     user: Object.freeze({ present: 'persistent+hint', unknown: 'persistent+hint', absent: 'persistent' }),
     operator: Object.freeze({ present: 'transient', unknown: 'transient', absent: 'diagnostic' }),

package/dist/ownKey.d.ts

@@ -32,8 +32,18 @@ export interface HumanInputAttachmentView {
     kind?: string;
     outcome: string;
     label?: string;
+    declinedBy?: HumanInputAttachmentDeclinedByView;
+}
+export interface HumanInputAttachmentDeclinedByView {
+    kind: 'extension';
+    name: string;
 }
 export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | undefined;
+export interface HumanInputAuthorKeys {
+    author?: string;
+    extension?: string;
+}
+export declare function humanInputAuthorKeys(frame: {} | null | undefined): HumanInputAuthorKeys;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
 export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;
 export interface PromptManifestSectionRow {

package/dist/ownKey.js

@@ -175,7 +175,14 @@ export function humanInputAttachmentsOf(frame) {
                     return undefined;
                 const kind = readOwnDataNonEmptyString(r, 'kind');
                 const label = readOwnDataNonEmptyString(r, 'label');
-                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}) };
+                const declinedBy = guardedRead(() => {
+                    const d = readOwnDataValue(r, 'declinedBy');
+                    if (typeof d !== 'object' || d === null || Array.isArray(d))
+                        return undefined;
+                    const name = readOwnDataNonEmptyString(d, 'name');
+                    return readOwnDataValue(d, 'kind') === 'extension' && name !== undefined ? { kind: 'extension', name } : undefined;
+                });
+                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}), ...(declinedBy !== undefined ? { declinedBy } : {}) };
             });
             if (row !== undefined)
                 appendOwnElement(rows, row);
@@ -186,6 +193,13 @@ export function humanInputAttachmentsOf(frame) {
         return undefined;
     }
 }
+export function humanInputAuthorKeys(frame) {
+    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+        return {};
+    const author = guardedRead(() => readOwnDataNonEmptyString(frame, 'author'));
+    const extension = guardedRead(() => readOwnDataNonEmptyString(frame, 'extension'));
+    return { ...(author !== undefined ? { author } : {}), ...(extension !== undefined ? { extension } : {}) };
+}
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
 export function markMcpSectionDroppedNamedRows(rows, dropped) {
     if (dropped.size === 0)

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 {

package/dist/queuedDelivery.js

@@ -3,6 +3,7 @@ import { imageVisionOf } from './liveModelCatalog.js';
 import { userPromptSubmitExecutorOf } from './pluginHooksWire.js';
 import { observedUserAttachmentSeat } from './userAttachmentSeat.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { taskNotificationOf } from './notifications.js';
 const own = (o, key) => guardedRead(() => readOwnDataValue(o, key));
 const str = (o, key) => {
     const v = own(o, key);
@@ -43,6 +44,8 @@ export function batchCompatible(head, follower, plan) {
             return false;
         if (typeof head !== 'object' || head === null || typeof follower !== 'object' || follower === null)
             return false;
+        if (carriesCompletionIdentity(head) || carriesCompletionIdentity(follower))
+            return false;
         const executor = userPromptSubmitExecutorOf(plan);
         if (executor === 'engine' || executor === 'unknown')
             return false;
@@ -84,6 +87,15 @@ export function batchCompatible(head, follower, plan) {
         return false;
     }
 }
+function carriesCompletionIdentity(e) {
+    const slot = peek(e, '_sema_task_notification');
+    if (slot === undefined || slot === null)
+        return false;
+    if (slot === UNREADABLE)
+        return true;
+    const fact = taskNotificationOf({ _sema_task_notification: slot });
+    return fact === undefined || fact.completionId !== undefined;
+}
 function upsExecutorWordOk(v) {
     return v === undefined || v === 'shell' || v === 'engine' || v === 'unknown' || v === 'none';
 }

package/dist/resultFrameKeys.js

@@ -1,4 +1,4 @@
-import { readFrameStringKey, readFrameTrueMark } from './ownKey.js';
+import { guardedRead, readFrameStringKey, readFrameTrueMark, readOwnDataValue } from './ownKey.js';
 export function resultErrorCodeOf(frame) {
     return readFrameStringKey(frame, '_sema_error_code');
 }
@@ -12,5 +12,7 @@ export function resultParkFailedReasonOf(frame) {
     return readFrameStringKey(frame, '_sema_park_failed_reason');
 }
 export function resultErrorCodeInTextOf(frame) {
-    return readFrameTrueMark(frame, '_sema_error_code_in_text') ? true : undefined;
+    if (!readFrameTrueMark(frame, '_sema_error_code_in_text'))
+        return undefined;
+    return guardedRead(() => (Array.isArray(readOwnDataValue(frame, 'errors')) ? true : undefined));
 }

package/dist/resumeRefusalCopy.js

@@ -2,21 +2,27 @@ import { msg, renderMessage } from './i18n/translate.js';
 import { readBlockedBy, readErrorNumber, readErrorString, readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { CORE_RESUME_STARTUP_CAUSES } from './generated/engineFactTables.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, isRefusedParkCode, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_PRINCIPAL_MISMATCH, RESUME_COMPOSITION_MISMATCH, RESUME_PARENT_CONSTRAINT_MISSING, RESUME_PARENT_CONSTRAINT_MISMATCH, RESUME_CONSTRAINT_UNPROJECTABLE, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, isRefusedParkCode, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineVersionTier } from './supportFloor.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
-export const RESUME_REFUSAL_CODES = Object.freeze([
-    RESUME_PLACEMENT_MISMATCH,
-    RESUME_PREFLIGHT_REJECTED,
-]);
+const REFUSAL_COPY_KEYS = Object.freeze({
+    [RESUME_PLACEMENT_MISMATCH]: 'resume.refusal.placementMismatch',
+    [RESUME_PREFLIGHT_REJECTED]: null,
+    [RESUME_PRINCIPAL_MISMATCH]: 'resume.refusal.principalMismatch',
+    [RESUME_COMPOSITION_MISMATCH]: 'resume.refusal.compositionMismatch',
+    [RESUME_PARENT_CONSTRAINT_MISSING]: 'resume.refusal.parentConstraintMissing',
+    [RESUME_PARENT_CONSTRAINT_MISMATCH]: 'resume.refusal.parentConstraintMismatch',
+    [RESUME_CONSTRAINT_UNPROJECTABLE]: 'resume.refusal.constraintUnprojectable',
+});
+export const RESUME_REFUSAL_CODES = Object.freeze(Object.keys(REFUSAL_COPY_KEYS));
 export function resumeRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
     const code = guardedRead(() => ownDataField(err, 'errorCode'));
     if (typeof code !== 'string' || !RESUME_REFUSAL_CODES.includes(code))
         return null;
-    if (code === RESUME_PLACEMENT_MISMATCH) {
+    if (code !== RESUME_PREFLIGHT_REJECTED) {
         return { code, waitable: false };
     }
     const timed = resumeRetryLaterFromError(err);
@@ -29,8 +35,9 @@ export function resumeRefusalFromError(err) {
     };
 }
 export function resumeRefusalContent(detail, lang) {
-    if (detail.code === RESUME_PLACEMENT_MISMATCH)
-        return renderMessage(msg('resume.refusal.placementMismatch'), lang);
+    const copyKey = typeof detail.code === 'string' && Object.hasOwn(REFUSAL_COPY_KEYS, detail.code) ? REFUSAL_COPY_KEYS[detail.code] : null;
+    if (copyKey !== null && copyKey !== undefined)
+        return renderMessage(msg(copyKey, { safe: msg('resume.refusal.untouched') }), lang);
     return renderMessage(msg(detail.waitable ? 'resume.refusal.preflightWaitable' : 'resume.refusal.preflightNoWait'), lang);
 }
 export function resumePolicyBlockFromError(err) {

package/dist/ruleReadings.js

@@ -122,7 +122,7 @@ export function ruleNearMissSentence(rows, lang) {
     const named = shown
         .map((it) => renderMessage(msg('rules.refusal.item', {
         rule: `"${capForDisplay(it.rule, NEAR_MISS_RULE_MAX)}"`,
-        reason: renderMessage(msg('rules.nearMiss.reason', { mounted: capForDisplay(displayUntrusted(it.mounted), NEAR_MISS_NAME_MAX) }), lang),
+        reason: renderMessage(msg('rules.nearMiss.reason', { mounted: displayUntrusted(it.mounted, { max: NEAR_MISS_NAME_MAX, escapeBackslashes: 'auto' }) }), lang),
     }), lang))
         .join(separator);
     const rest = items.length - shown.length;

package/dist/runPermissionModeSwitch.d.ts

@@ -2,7 +2,7 @@ import type { UiLanguage } from './env/uiLanguage.js';
 import { type PermissionModeReceiptView } from './adapter/downstream/wiringManifestView.js';
 import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
 import { type PermissionModeWriteReading } from './permissionModeWriteCapability.js';
-import type { PermissionMode } from './permissionWireCaps.js';
+import { type PermissionMode } from './permissionWireCaps.js';
 export type { PermissionModeReceiptView };
 type AdmissionFold = (typeof SDK_PERMISSION_MODE_ADMISSION_FOLDS)[number];
 type PersistMiss = (typeof SDK_PERMISSION_MODE_PERSIST_MISSES)[number];
@@ -40,6 +40,7 @@ export type RunPermissionModeSwitchOutcome = {
     readonly status?: number;
 } | {
     readonly kind: 'unavailable';
+    readonly code?: string;
 };
 export interface RunPermissionModeSwitchRuns {
     setPermissionMode(taskId: string, mode: PermissionMode, opts?: {

package/dist/runPermissionModeSwitch.js

@@ -3,8 +3,9 @@ import { readPermissionModeReceiptSegment } from './adapter/downstream/wiringMan
 import { displayUntrusted } from './displayUntrusted.js';
 import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { ownDataField } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 import { permissionModeWriteAvailable } from './permissionModeWriteCapability.js';
+import { permissionModeTitle } from './permissionWireCaps.js';
 import { isDisplayableWireCode } from './wireFailureShape.js';
 export const PERMISSION_MODE_SWITCH_RESULT_KEYS = Object.freeze(['taskId', 'sessionId', 'status', 'permissionMode', 'admission', 'persisted', 'persistMiss']);
 const NOT_RUNNING_CODE = 'steering.not_running';
@@ -19,7 +20,9 @@ function guardedSlot(o, key) {
         return undefined;
     }
 }
-const unavailable = () => Object.freeze({ kind: 'unavailable' });
+const unavailable = (code) => Object.freeze(code !== undefined ? { kind: 'unavailable', code } : { kind: 'unavailable' });
+const RUN_STORE_REQUIRED_CODE = 'capability.run_store_required';
+const CHECKPOINT_STORE_REQUIRED_CODE = 'capability.checkpoint_store_required';
 const unreadableAnswer = () => Object.freeze({ kind: 'unconfirmed', why: 'unreadable-answer' });
 function admissionOf(raw) {
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
@@ -72,7 +75,7 @@ function switchOutcomeOf(taskId, sent, body) {
 function failureOutcomeOf(e) {
     const v = atMostOnceVerdictOf(e);
     if (v.status === 501)
-        return unavailable();
+        return unavailable(v.code);
     if (v.delivery === 'rejected' && v.status !== undefined) {
         if (v.status === 404)
             return Object.freeze({ kind: 'not-found' });
@@ -110,7 +113,8 @@ export async function setRunPermissionMode(runs, taskId, mode, opts = {}) {
 export function runPermissionModeSwitchLine(outcome, lang) {
     switch (outcome.kind) {
         case 'switched': {
-            const mode = displayUntrusted(outcome.permissionMode.effective, { max: 64 });
+            const effective = outcome.permissionMode.effective;
+            const mode = permissionModeTitle(effective) ?? displayUntrusted(effective, { max: 64 });
             const reason = outcome.admission !== undefined
                 ? msg(outcome.admission.foldedBy === 'entry_floor' ? 'session.permissionModeSwitch.reason.entryFloor' : 'session.permissionModeSwitch.reason.disableAutoMode')
                 : outcome.permissionMode.foldedBy !== undefined
@@ -129,7 +133,13 @@ export function runPermissionModeSwitchLine(outcome, lang) {
                 : renderMessage(msg('session.permissionModeSwitch.refused', { status: String(outcome.status) }), lang);
         case 'unconfirmed':
             return renderMessage(msg('session.permissionModeSwitch.unconfirmed'), lang);
-        case 'unavailable':
-            return renderMessage(msg('session.permissionModeSwitch.unavailable'), lang);
+        case 'unavailable': {
+            const code = readOwnDataValue(outcome, 'code');
+            return renderMessage(msg(code === RUN_STORE_REQUIRED_CODE
+                ? 'session.permissionModeSwitch.unavailableRunStore'
+                : code === CHECKPOINT_STORE_REQUIRED_CODE
+                    ? 'session.permissionModeSwitch.unavailableCheckpointStore'
+                    : 'session.permissionModeSwitch.unavailable'), lang);
+        }
     }
 }