@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/pluginHooksWire.js

@@ -1,4 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { appendOwnElement } 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';
 export const ENGINE_FIRED_HOOK_EVENTS = SETTINGS_ENGINE_OWNED_HOOK_EVENTS;
@@ -26,6 +28,7 @@ export const PLUGIN_HOOK_REASONS = [
     'hooks_module',
     'scope_unsupported',
     'source_incomplete',
+    'compaction_local_fallback',
 ];
 export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'workspace_untrusted',
@@ -54,6 +57,9 @@ export function hooksWirePlanShapeOf(v) {
             Array.isArray(o.settingsVerdicts) &&
             Array.isArray(o.settingsExcluded) &&
             arrayOrAbsent('settingsSalvage') &&
+            arrayOrAbsent('httpPolicyDrops') &&
+            arrayOrAbsent('settingsSources') &&
+            arrayOrAbsent('settingsWithheld') &&
             arrayOrAbsent('moduleVerdicts') &&
             arrayOrAbsent('sessionVerdicts') &&
             (!Object.hasOwn(o, 'sessionReader') || o.sessionReader === 'present' || o.sessionReader === 'absent' || o.sessionReader === 'failed') &&
@@ -69,8 +75,8 @@ export function hooksWirePlanShapeOf(v) {
         return 'threw';
     }
 }
-const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy', 'wire'];
-const LATER_PLAN_KEYS = new Set(['settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy']);
+const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'httpPolicyDrops', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy', 'settingsSources', 'settingsWithheld', 'wire'];
+const LATER_PLAN_KEYS = new Set(['settingsSalvage', 'httpPolicyDrops', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy', 'settingsSources', 'settingsWithheld']);
 const _planKeysPin = [true, true];
 void _planKeysPin;
 export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192, maxLlmEntriesPerEvent: 4 };
@@ -93,6 +99,9 @@ function hookExecutorOf(x) {
                         ? { reason: 'engine_llm_limit', certain: false }
                         : undefined;
         const compaction = COMPACTION_EVENTS.has(x.event);
+        if (compaction && x.compactionOnShell === true && x.shellRuns && (why === undefined || (!why.certain && why.reason !== 'engine_llm_limit'))) {
+            return judged('shell', 'compaction_local_fallback');
+        }
         if (why === undefined) {
             if (!x.shellRuns || x.engine.ownedByThisShell === true)
                 return judged('engine', 'projected');
@@ -225,7 +234,7 @@ export function decidePluginHooks(input) {
             return;
         }
         if (p.hooksModule === true && input.exclusion === undefined && !(input.managedOnly && p.managed !== true)) {
-            modules.push({ pluginId: typeof p.id === 'string' ? p.id : '', pluginName: typeof p.name === 'string' ? p.name : '', disposition: 'not_run', reason: 'hooks_module' });
+            appendOwnElement(modules, { pluginId: typeof p.id === 'string' ? p.id : '', pluginName: typeof p.name === 'string' ? p.name : '', disposition: 'not_run', reason: 'hooks_module' });
         }
         if (!isRecord(p.hooks)) {
             unreadable++;
@@ -252,37 +261,37 @@ export function decidePluginHooks(input) {
                 group.hooks.forEach((entry, hookIndex) => {
                     const key = { pluginId, pluginName, event, groupIndex, hookIndex };
                     if (input.exclusion !== undefined) {
-                        excluded.push({ ...key, reason: input.exclusion });
+                        appendOwnElement(excluded, { ...key, reason: input.exclusion });
                         return;
                     }
                     if (input.managedOnly && p.managed !== true) {
-                        excluded.push({ ...key, reason: 'managed_plugins_only' });
+                        appendOwnElement(excluded, { ...key, reason: 'managed_plugins_only' });
                         return;
                     }
                     const entryType = isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined;
                     if (!sourceOk) {
-                        verdicts.push({ ...key, disposition: 'not_run', reason: 'source_incomplete' });
+                        appendOwnElement(verdicts, { ...key, disposition: 'not_run', reason: 'source_incomplete' });
                         return;
                     }
                     if (!pieceMask.eventDropped(event) && pieceMask.entryDropped(event, groupIndex, hookIndex)) {
-                        verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        appendOwnElement(verdicts, { ...key, disposition: 'not_run', reason: 'malformed_entry' });
                         return;
                     }
                     const shape = classifyEntry(entry, src.options);
                     if (shape.kind === 'malformed') {
-                        verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        appendOwnElement(verdicts, { ...key, disposition: 'not_run', reason: 'malformed_entry' });
                         return;
                     }
                     if (shape.kind === 'shell_form' && shape.refusesUserConfig) {
-                        verdicts.push({ ...key, disposition: 'not_run', reason: 'shell_form_user_config' });
+                        appendOwnElement(verdicts, { ...key, disposition: 'not_run', reason: 'shell_form_user_config' });
                         return;
                     }
                     if (shape.kind === 'exec_form' && shape.unsetUserConfig) {
-                        verdicts.push({ ...key, disposition: 'not_run', reason: 'user_config_unset' });
+                        appendOwnElement(verdicts, { ...key, disposition: 'not_run', reason: 'user_config_unset' });
                         return;
                     }
                     if (!ENGINE_EVENTS.has(event)) {
-                        verdicts.push({
+                        appendOwnElement(verdicts, {
                             ...key,
                             ...(input.shellRuns(event, entryType)
                                 ? { disposition: 'shell', reason: 'shell_event' }
@@ -301,11 +310,11 @@ export function decidePluginHooks(input) {
                         ...(shape.kind === 'other' ? { pluginBlock: 'not_command' } : declaresSensitive(src.options) ? { pluginBlock: 'sensitive_options' } : {}),
                     });
                     if (ex.kind === 'excluded') {
-                        excluded.push({ ...key, reason: ex.reason });
+                        appendOwnElement(excluded, { ...key, reason: ex.reason });
                         return;
                     }
                     if (ex.disposition !== 'engine') {
-                        verdicts.push({ ...key, disposition: ex.disposition, reason: ex.reason });
+                        appendOwnElement(verdicts, { ...key, disposition: ex.disposition, reason: ex.reason });
                         return;
                     }
                     const plugin = { name: src.name, root: src.root, dataDir: src.dataDir };
@@ -318,9 +327,9 @@ export function decidePluginHooks(input) {
                         wireEntry.args = shape.args.map((a) => substituteUserConfig(a, src.options));
                     }
                     const verdict = { ...key, disposition: 'engine', reason: 'projected' };
-                    verdicts.push(verdict);
+                    appendOwnElement(verdicts, verdict);
                     const list = candidates.get(event) ?? [];
-                    list.push({ verdict, pluginIndex, group, wireEntry });
+                    appendOwnElement(list, { verdict, pluginIndex, group, wireEntry });
                     candidates.set(event, list);
                 });
             });
@@ -341,7 +350,7 @@ export function decidePluginHooks(input) {
         for (const c of fits) {
             const k = `${c.pluginIndex}\u0000${c.verdict.groupIndex}`;
             if (!groupKeys.includes(k))
-                groupKeys.push(k);
+                appendOwnElement(groupKeys, k);
         }
         const occ = input.occupied.get(event) ?? { groups: 0, entries: 0 };
         if (occ.groups + groupKeys.length > ENGINE_HOOK_LIMITS.maxGroupsPerEvent ||
@@ -356,7 +365,7 @@ export function decidePluginHooks(input) {
             const first = members[0];
             if (first === undefined)
                 continue;
-            groupsOut.push({ ...first.group, hooks: members.map((c) => c.wireEntry) });
+            appendOwnElement(groupsOut, { ...first.group, hooks: members.map((c) => c.wireEntry) });
         }
         projected.set(event, groupsOut);
     }
@@ -416,18 +425,18 @@ export function decideSessionHooks(input) {
                     const key = { origin, name, event, groupIndex, hookIndex };
                     const type = isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined;
                     if (rejectedWhole || (!mask.eventDropped(event) && mask.entryDropped(event, groupIndex, hookIndex)) || type === undefined) {
-                        out.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        appendOwnElement(out, { ...key, disposition: 'not_run', reason: 'malformed_entry' });
                         return;
                     }
                     const shellRuns = input.shellRuns(event, type);
                     if (!ENGINE_EVENTS.has(event)) {
-                        out.push({ ...key, ...(shellRuns ? { disposition: 'shell', reason: 'shell_event' } : { disposition: 'not_run', reason: 'no_executor' }) });
+                        appendOwnElement(out, { ...key, ...(shellRuns ? { disposition: 'shell', reason: 'shell_event' } : { disposition: 'not_run', reason: 'no_executor' }) });
                         return;
                     }
                     const ex = hookExecutorOf({ source: 'session', event, powershell: false, llmPosition: 0, engine: input.engine, shellRuns, promptAuthoredByUser: input.promptAuthoredByUser });
                     if (ex.kind === 'excluded')
                         return;
-                    out.push({ ...key, disposition: ex.disposition, reason: ex.reason });
+                    appendOwnElement(out, { ...key, disposition: ex.disposition, reason: ex.reason });
                 });
             });
         }
@@ -456,7 +465,7 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
         if (mask !== undefined && mask.groupDropped(event, groupIndex))
             return;
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
-            out.push(group);
+            appendOwnElement(out, group);
             return;
         }
         const kept = [];
@@ -474,18 +483,18 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
                         ? 'exec_form_unsupported'
                         : undefined;
             if (reason !== undefined) {
-                drops.push({ 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) });
                 changed = true;
                 return;
             }
             if (engineEvent && isRecord(entry) && judgeableSettingsEntry(entry)) {
                 const ex = judge(event, group, entry);
                 if (ex.kind === 'excluded') {
-                    excluded.push({ source, event, groupIndex, hookIndex, reason: ex.reason });
+                    appendOwnElement(excluded, { source, event, groupIndex, hookIndex, reason: ex.reason });
                     changed = true;
                     return;
                 }
-                verdicts.push({ source, event, groupIndex, hookIndex, disposition: ex.disposition, reason: ex.reason });
+                appendOwnElement(verdicts, { source, event, groupIndex, hookIndex, disposition: ex.disposition, reason: ex.reason });
                 if (ex.disposition === 'shell') {
                     changed = true;
                     return;
@@ -494,17 +503,17 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
             if (isRecord(entry) && Object.hasOwn(entry, 'plugin')) {
                 const copy = { ...entry };
                 delete copy.plugin;
-                kept.push(copy);
+                appendOwnElement(kept, copy);
                 stripped++;
                 changed = true;
                 return;
             }
-            kept.push(entry);
+            appendOwnElement(kept, entry);
         });
         if (!changed)
-            out.push(group);
+            appendOwnElement(out, group);
         else if (kept.length > 0)
-            out.push({ ...group, hooks: kept });
+            appendOwnElement(out, { ...group, hooks: kept });
     });
     return { groups: out, drops, stripped, verdicts, excluded };
 }
@@ -515,7 +524,7 @@ function judgeableSettingsEntry(entry) {
     const field = type === 'command' ? entry.command : type === 'http' ? entry.url : entry.prompt;
     return nonEmptyString(field) && !field.includes('\u0000');
 }
-export function createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser) {
+export function createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser, compactionOnShell) {
     const llm = new Map();
     const seen = new Map();
     return (event, group, entry) => {
@@ -544,6 +553,7 @@ export function createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser)
             engine,
             shellRuns: shellRuns(event, typeof type === 'string' ? type : undefined),
             promptAuthoredByUser,
+            ...(compactionOnShell === true ? { compactionOnShell: true } : {}),
         });
         if (isLlm && ex.kind === 'judged' && ex.disposition !== 'shell')
             llm.set(event, (llm.get(event) ?? 0) + 1);
@@ -610,7 +620,7 @@ export function dedupeSettingsHookGroups(groups) {
     const winner = new Map();
     for (const { source, group } of groups) {
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
-            keysOf.push([]);
+            appendOwnElement(keysOf, []);
             continue;
         }
         let groupKey;
@@ -627,21 +637,21 @@ export function dedupeSettingsHookGroups(groups) {
         for (const entry of group.hooks) {
             const entryKey = groupKey === undefined ? undefined : settingsHookEntryKey(entry);
             const key = entryKey === undefined ? undefined : `${groupKey}\u0000${entryKey}`;
-            keys.push(key);
+            appendOwnElement(keys, key);
             if (key === undefined)
                 continue;
             const prev = winner.get(key);
             if (prev === undefined || rank >= prev.rank)
                 winner.set(key, { entry, rank });
         }
-        keysOf.push(keys);
+        appendOwnElement(keysOf, keys);
     }
     const placed = new Set();
     const out = [];
     let removed = 0;
     groups.forEach(({ group }, gi) => {
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
-            out.push(group);
+            appendOwnElement(out, group);
             return;
         }
         const keys = keysOf[gi] ?? [];
@@ -650,7 +660,7 @@ export function dedupeSettingsHookGroups(groups) {
         group.hooks.forEach((entry, hi) => {
             const key = keys[hi];
             if (key === undefined) {
-                kept.push(entry);
+                appendOwnElement(kept, entry);
                 return;
             }
             if (placed.has(key)) {
@@ -662,12 +672,12 @@ export function dedupeSettingsHookGroups(groups) {
             const win = winner.get(key)?.entry ?? entry;
             if (win !== entry)
                 changed = true;
-            kept.push(win);
+            appendOwnElement(kept, win);
         });
         if (!changed)
-            out.push(group);
+            appendOwnElement(out, group);
         else if (kept.length > 0)
-            out.push({ ...group, hooks: kept });
+            appendOwnElement(out, { ...group, hooks: kept });
     });
     return { groups: out, removed };
 }
@@ -686,6 +696,20 @@ export function settingsHooksKeptLocally(plan, event, group, opts) {
         raw = undefined;
     }
     const hooks = raw;
+    if (Array.isArray(hooks) && hooks.length > 0) {
+        let layerSkipped;
+        try {
+            const src = isRecord(group) ? group.source : undefined;
+            const planRec0 = plan;
+            const allowed = typeof src === 'string' && isRecord(planRec0) ? ownField(planRec0, 'settingsSources') : undefined;
+            layerSkipped = Array.isArray(allowed) && !allowed.includes(src);
+        }
+        catch {
+            layerSkipped = false;
+        }
+        if (layerSkipped)
+            return [];
+    }
     if (!Array.isArray(hooks) || hooks.length === 0 || !ENGINE_EVENTS.has(event))
         return hooks;
     try {
@@ -729,7 +753,7 @@ export function settingsHooksKeptLocally(plan, event, group, opts) {
             if (skip)
                 kept ??= hooks.slice(0, i);
             else if (kept !== null)
-                kept.push(h);
+                appendOwnElement(kept, h);
         });
         return kept ?? hooks;
     }
@@ -807,6 +831,7 @@ const REASON_TEXT = {
     hooks_module: 'hooks registered in code by a plugin module run neither in the engine nor in this client',
     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')),
 };
 const DROP_TEXT = {
     exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
@@ -844,17 +869,17 @@ function escapeNoticeQuotes(s) {
                 j++;
             const want = s.charCodeAt(j) === 0x22 ? (j - i) * 2 : j - i;
             const take = Math.min(want, budget + 1 - len);
-            out.push('\\'.repeat(take));
+            appendOwnElement(out, '\\'.repeat(take));
             len += take;
             i = j;
             continue;
         }
         if (c === 0x22) {
-            out.push('\\"');
+            appendOwnElement(out, '\\"');
             len += 2;
         }
         else {
-            out.push(s.charAt(i));
+            appendOwnElement(out, s.charAt(i));
             len++;
         }
         i++;
@@ -882,13 +907,13 @@ export function hooksNotRunNotice(plan) {
         const k = `${v.pluginId}\u0000${v.reason}`;
         const row = byPlugin.get(k) ?? { name: v.pluginName, reason: v.reason, events: [], count: 0 };
         if (!row.events.includes(v.event))
-            row.events.push(v.event);
+            appendOwnElement(row.events, v.event);
         row.count++;
         byPlugin.set(k, row);
     }
     for (const row of byPlugin.values()) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
-        lines.push(`Plugin "${noticeLabel(row.name) || '(unnamed)'}": ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+        appendOwnElement(lines, `Plugin "${noticeLabel(row.name) || '(unnamed)'}": ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
     }
     const bySource = new Map();
     for (const d of plan.settingsDropped) {
@@ -897,13 +922,13 @@ export function hooksNotRunNotice(plan) {
         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))
-            row.events.push(d.event);
+            appendOwnElement(row.events, d.event);
         row.count++;
         bySource.set(k, row);
     }
     for (const row of bySource.values()) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
-        lines.push(`${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${settingsHookDropText(row.reason)}.`);
+        appendOwnElement(lines, `${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${settingsHookDropText(row.reason)}.`);
     }
     const settingsVerdicts = plan.settingsVerdicts;
     const byVerdict = new Map();
@@ -914,13 +939,13 @@ export function hooksNotRunNotice(plan) {
         const k = `${v.source}\u0000${v.reason}`;
         const row = byVerdict.get(k) ?? { source: v.source, reason: v.reason, events: [], count: 0 };
         if (!row.events.includes(v.event))
-            row.events.push(v.event);
+            appendOwnElement(row.events, v.event);
         row.count++;
         byVerdict.set(k, row);
     }
     for (const row of byVerdict.values()) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
-        lines.push(`${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+        appendOwnElement(lines, `${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
     }
     const moduleRows = plan.moduleVerdicts;
     for (const raw of Array.isArray(moduleRows) ? moduleRows : []) {
@@ -930,7 +955,7 @@ export function hooksNotRunNotice(plan) {
         const name = ownField(raw, 'pluginName');
         if (typeof reason !== 'string' || !REASON_SET.has(reason))
             continue;
-        lines.push(`Plugin "${noticeLabel(typeof name === 'string' ? name : '') || '(unnamed)'}": hooks module will not run — ${pluginHookReasonText(reason)}.`);
+        appendOwnElement(lines, `Plugin "${noticeLabel(typeof name === 'string' ? name : '') || '(unnamed)'}": hooks module will not run — ${pluginHookReasonText(reason)}.`);
     }
     const sessionRows = plan.sessionVerdicts;
     const bySession = new Map();
@@ -947,20 +972,32 @@ export function hooksNotRunNotice(plan) {
         const k = `${origin}\u0000${nm}\u0000${reason}`;
         const row = bySession.get(k) ?? { origin: origin, name: nm, reason: reason, events: [], count: 0 };
         if (!row.events.includes(event))
-            row.events.push(event);
+            appendOwnElement(row.events, event);
         row.count++;
         bySession.set(k, row);
     }
     for (const row of bySession.values()) {
         const events = row.events.map((e) => noticeLabel(e)).join(', ');
         const who = row.origin === 'sdk_host' ? 'Host application hooks' : `${row.origin === 'skill' ? 'Skill' : 'Agent'} "${noticeLabel(row.name) || '(unnamed)'}"`;
-        lines.push(`${who}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+        appendOwnElement(lines, `${who}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
     }
     const salvageRows = plan.settingsSalvage;
     for (const row of Array.isArray(salvageRows) ? salvageRows : []) {
         const notice = isRecord(row) ? ownField(row, 'notice') : undefined;
         if (typeof notice === 'string' && notice.length > 0)
-            lines.push(notice);
+            appendOwnElement(lines, notice);
+    }
+    const httpRows = plan.httpPolicyDrops;
+    for (const row of Array.isArray(httpRows) ? httpRows : []) {
+        const notice = isRecord(row) ? ownField(row, 'notice') : undefined;
+        if (typeof notice === 'string' && notice.length > 0)
+            appendOwnElement(lines, notice);
+    }
+    const withheldRows = plan.settingsWithheld;
+    for (const row of Array.isArray(withheldRows) ? withheldRows : []) {
+        const notice = isRecord(row) ? ownField(row, 'notice') : undefined;
+        if (typeof notice === 'string' && notice.length > 0)
+            appendOwnElement(lines, notice);
     }
     return lines;
 }
@@ -976,12 +1013,14 @@ export function userPromptSubmitExecutorOf(plan) {
         const settingsRows = ownField(p, 'settingsVerdicts');
         if (!Array.isArray(settingsRows))
             return 'unknown';
-        rows.push(...settingsRows);
+        for (const v of settingsRows)
+            appendOwnElement(rows, v);
         const sessionRows = ownField(p, 'sessionVerdicts');
         if (sessionRows !== undefined) {
             if (!Array.isArray(sessionRows))
                 return 'unknown';
-            rows.push(...sessionRows);
+            for (const v of sessionRows)
+                appendOwnElement(rows, v);
         }
         const ups = rows.filter((r) => isRecord(r) && ownField(r, 'event') === 'UserPromptSubmit').map((r) => ownField(r, 'disposition'));
         if (ups.length === 0)

package/dist/prepareRefusal.d.ts

@@ -1,7 +1,8 @@
-import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
-export type PrepareRefusalCode = typeof CONFIG_LEGACY_TOOL_NAME | typeof CONFIG_IMAGE_INVALID | typeof CONFIG_AGENT_UNKNOWN_TOOL | typeof PROMPT_ASSEMBLED_ROLE_REFUSED | typeof USER_ATTACHMENT_INVALID_ERROR_CODE | typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE | typeof CONFIG_TOOL_FACE_CONTROL;
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_MCP_SERVER_NAME_COLLISION, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+export type PrepareRefusalCode = typeof CONFIG_LEGACY_TOOL_NAME | typeof CONFIG_IMAGE_INVALID | typeof CONFIG_AGENT_UNKNOWN_TOOL | typeof PROMPT_ASSEMBLED_ROLE_REFUSED | typeof USER_ATTACHMENT_INVALID_ERROR_CODE | typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE | typeof CONFIG_TOOL_FACE_CONTROL | typeof CONFIG_MCP_SERVER_NAME_COLLISION;
 export interface PrepareRefusalNoteFacts {
     readonly index?: number;
+    readonly draftKept?: boolean;
 }
 export declare function prepareRefusalNoteOf(code: string | undefined, facts?: PrepareRefusalNoteFacts): string | undefined;
 export declare function prepareRefusalCodeOf(failure: {} | null | undefined): PrepareRefusalCode | undefined;

package/dist/prepareRefusal.js

@@ -1,8 +1,11 @@
-import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, } from './engineErrorCodes.js';
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_MCP_SERVER_NAME_COLLISION, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, } from './engineErrorCodes.js';
 import { REFUSED_NAME_CLASSES } from './hitl/refusedToolNameProse.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { readOwnDataValue } from './ownKey.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 const nonNegInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined);
+const draftKeptSegment = (facts) => Object.hasOwn(facts, 'draftKept') && facts.draftKept === true ? ` · ${renderMessage(msg('notice.prepareRefusal.draftKept'))}` : '';
+const indexOf = (facts) => nonNegInt(Object.hasOwn(facts, 'index') ? facts.index : undefined);
 const PREPARE_REFUSAL_NOTES = Object.freeze({
     [CONFIG_LEGACY_TOOL_NAME]: () => `The engine refused this run at setup: a tool rule applied to it names a tool the engine refuses — ${REFUSED_NAME_CLASSES} (the engine's own error text names the entry). ` +
         'Every later run fails the same way until that entry is removed from wherever it is set: this session’s rule record, the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules.',
@@ -13,17 +16,18 @@ const PREPARE_REFUSAL_NOTES = Object.freeze({
     [PROMPT_ASSEMBLED_ROLE_REFUSED]: () => 'The engine refused this run at setup: the role text sent with it contains the engine’s own prompt sections word for word — the engine’s own error text names the field · ' +
         'Send only your own role text (the engine assembles the rest), then send it again',
     [USER_ATTACHMENT_INVALID_ERROR_CODE]: (facts) => {
-        const index = nonNegInt(facts.index);
+        const index = indexOf(facts);
         return index !== undefined
-            ? `The engine refused attachment ${index + 1} of this message: it is in a form the engine does not accept, or larger than it takes · Your draft is kept · Remove or replace that attachment, then send it again`
-            : 'The engine refused the files attached to this message: together with the message they are more than it can take in one request on this model, or one of them is in a form it does not accept · ' +
-                'Your draft is kept · Remove some attachments or attach smaller parts, then send it again';
+            ? `The engine refused attachment ${index + 1} of this message: it is in a form the engine does not accept, or larger than it takes${draftKeptSegment(facts)} · Remove or replace that attachment, then send it again`
+            : 'The engine refused the files attached to this message: together with the message they are more than it can take in one request on this model, or one of them is in a form it does not accept' +
+                `${draftKeptSegment(facts)} · Remove some attachments or attach smaller parts, then send it again`;
     },
-    [USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE]: () => 'The engine refused this run at setup: a skill named for it is not one this run has loaded, or skills are turned off for this run · ' +
-        'Your draft is kept · Check the skill name, or load that skill, then send it again',
+    [USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE]: (facts) => 'The engine refused this run at setup: a skill named for it is not one this run has loaded, or skills are turned off for this run' +
+        `${draftKeptSegment(facts)} · Check the skill name, or load that skill, then send it again`,
     [CONFIG_TOOL_FACE_CONTROL]: () => 'The engine refused this run at setup: its tool set could not be put together as asked — usually a tool list on the request or one it inherits (allowed or excluded tools) names something no tool answers to, ' +
         'uses a form those lists do not accept, or excludes a tool this run depends on; it can also be the deployment’s own tool mounts — the engine’s own error text says what it refused and where · ' +
         'Sending the same request again is refused the same way; fix what it names (or ask whoever operates the engine, if it names the deployment’s tools), then send it',
+    [CONFIG_MCP_SERVER_NAME_COLLISION]: () => renderMessage(msg('notice.prepareRefusal.mcpServerNameCollision')),
 });
 function isPrepareRefusalCode(code) {
     return typeof code === 'string' && Object.hasOwn(PREPARE_REFUSAL_NOTES, code);
@@ -32,15 +36,29 @@ export function prepareRefusalNoteOf(code, facts) {
     try {
         if (!isPrepareRefusalCode(code))
             return undefined;
+        let bag;
+        try {
+            bag = typeof facts === 'object' && facts !== null && !Array.isArray(facts) ? facts : undefined;
+        }
+        catch {
+            bag = undefined;
+        }
         let index;
         try {
-            index = facts === undefined || facts === null ? undefined : facts.index;
+            index = readOwnDataValue(bag, 'index');
         }
         catch {
             index = undefined;
         }
+        let draftKept;
+        try {
+            draftKept = readOwnDataValue(bag, 'draftKept');
+        }
+        catch {
+            draftKept = undefined;
+        }
         const i = nonNegInt(index);
-        return PREPARE_REFUSAL_NOTES[code](i !== undefined ? { index: i } : {});
+        return PREPARE_REFUSAL_NOTES[code]({ ...(i !== undefined ? { index: i } : {}), ...(draftKept === true ? { draftKept: true } : {}) });
     }
     catch {
         return undefined;

package/dist/printInitToolFace.js

@@ -87,7 +87,7 @@ function snapshotStampKeys(rec) {
                     return undefined;
                 const d = Reflect.getOwnPropertyDescriptor(o, key);
                 if (d !== undefined) {
-                    if ('get' in d || 'set' in d)
+                    if (Object.hasOwn(d, 'get') || Object.hasOwn(d, 'set'))
                         return undefined;
                     if (depth === 0)
                         own = d;
@@ -112,7 +112,7 @@ function restoreStampKeys(rec, saved) {
             if (s.own !== undefined) {
                 if (now === undefined)
                     ok = Reflect.defineProperty(rec, s.key, s.own);
-                else if (!('value' in now) || !Object.is(now.value, s.own.value))
+                else if (!Object.hasOwn(now, 'value') || !Object.is(now.value, s.own.value))
                     ok = Reflect.set(rec, s.key, s.own.value);
             }
             else if (now !== undefined) {

package/dist/printModelStatus.js

@@ -77,7 +77,7 @@ function isMainLaneArm(msg) {
     const tri = (o, key) => {
         try {
             const d = Object.getOwnPropertyDescriptor(o, key);
-            if (d !== undefined && !('value' in d))
+            if (d !== undefined && !Object.hasOwn(d, 'value'))
                 return { ok: false };
             return { ok: true, v: readOwnDataValue(o, key) };
         }

package/dist/printToolResultFrame.js

@@ -41,7 +41,7 @@ export function toolEndResultToUserFrame(arm) {
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
         ...(gateView !== undefined ? { _sema_gate: gateView } : {}),
-        ...toolResultRowFlagParts(arm),
+        ...toolResultRowFlagParts(arm, gateView),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: rowIdentity.uuid,

package/dist/projectMemory.d.ts

@@ -0,0 +1,32 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const PROJECT_MEMORY_DISABLED: "disabled";
+export declare const PROJECT_MEMORY_WORDS: readonly ["on", "disabled", "absent"];
+export type ProjectMemoryWord = (typeof PROJECT_MEMORY_WORDS)[number];
+export interface ProjectMemoryManifestSeat {
+    readonly projectMemory?: string;
+}
+export declare function projectMemoryOf(manifest: ProjectMemoryManifestSeat | null | undefined): ProjectMemoryWord | undefined;
+export type ProjectMemoryCapabilityReading = {
+    readonly kind: 'confirmed';
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedProjectMemoryCapability(baseUrl?: string | undefined): ProjectMemoryCapabilityReading;
+export type ProjectMemoryWithheldCause = 'capability_absent' | 'capability_declined' | 'capability_unreadable';
+export interface ProjectMemoryWithheld {
+    readonly cause: ProjectMemoryWithheldCause;
+}
+export interface ProjectMemoryDeclaration {
+    readonly field: {
+        readonly projectMemory?: 'disabled';
+    };
+    readonly withheld?: ProjectMemoryWithheld;
+}
+export declare function projectMemoryDeclaration(intent: 'disabled' | undefined, reading: ProjectMemoryCapabilityReading): ProjectMemoryDeclaration;
+export declare function projectMemoryWithheldNotice(withheld: ProjectMemoryWithheld, lang?: UiLanguage): string;