@sema-agent/client-core 0.108.0 → 0.109.0

package/dist/localEngineStopLadder.d.ts

@@ -0,0 +1,29 @@
+export declare const LOCAL_ENGINE_STOP_LADDER: Readonly<{
+    g: 1000;
+    P: 5000;
+    H: 20000;
+}>;
+export type StopLadderSignal = 'term' | 'term-2' | 'kill';
+export interface StopLadderState {
+    readonly mode: 'idle' | 'forced';
+    readonly target: {
+        readonly pid: number;
+        readonly startedAt?: number;
+    };
+    readonly t0: number;
+    readonly sent: readonly StopLadderSignal[];
+    readonly processedAt?: number;
+    readonly deadlineAt?: number;
+    readonly killedAt?: number;
+}
+export interface StopLadderObservation {
+    readonly nowMs: number;
+    readonly alive: 'alive' | 'gone' | 'unknown';
+    readonly health: object | null;
+}
+export interface StopLadderStepResult {
+    readonly state: StopLadderState;
+    readonly action: StopLadderSignal | 'wait' | 'done' | 'gave-up';
+    readonly waitMs?: number;
+}
+export declare function stopLadderStep(s: StopLadderState, obs: StopLadderObservation): StopLadderStepResult;

package/dist/localEngineStopLadder.js

@@ -0,0 +1,139 @@
+import { readEngineHealthFacts } from './engineHealthFacts.js';
+import { readOwnDataValue } from './ownKey.js';
+export const LOCAL_ENGINE_STOP_LADDER = Object.freeze({ g: 1000, P: 5000, H: 20000 });
+const SIGTERM_ACTION_ID = 'signal:SIGTERM';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTime(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+const SIGNALS = Object.freeze(['term', 'term-2', 'kill']);
+function stateOf(s) {
+    const mode = own(s, 'mode');
+    if (mode !== 'idle' && mode !== 'forced')
+        return undefined;
+    const target = own(s, 'target');
+    const pid = own(target, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const startedAt = own(target, 'startedAt');
+    const t0 = own(s, 't0');
+    if (!isTime(t0))
+        return undefined;
+    const sentRaw = own(s, 'sent');
+    let sent = [];
+    try {
+        if (!Array.isArray(sentRaw))
+            return undefined;
+        for (let i = 0; i < sentRaw.length; i++) {
+            const x = own(sentRaw, String(i));
+            if (!SIGNALS.includes(x))
+                return undefined;
+            if (!sent.includes(x))
+                sent.push(x);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    sent = SIGNALS.filter((x) => sent.includes(x));
+    const processedAt = own(s, 'processedAt');
+    const deadlineAt = own(s, 'deadlineAt');
+    const killedAt = own(s, 'killedAt');
+    if (processedAt !== undefined && !isTime(processedAt))
+        return undefined;
+    if (deadlineAt !== undefined && !isTime(deadlineAt))
+        return undefined;
+    if (killedAt !== undefined && !isTime(killedAt))
+        return undefined;
+    return {
+        mode,
+        target: isTime(startedAt) && startedAt > 0 ? { pid, startedAt } : { pid },
+        t0,
+        sent,
+        ...(processedAt !== undefined ? { processedAt } : {}),
+        ...(deadlineAt !== undefined ? { deadlineAt } : {}),
+        ...(killedAt !== undefined ? { killedAt } : {}),
+    };
+}
+function frozen(s) {
+    return Object.freeze({ ...s, target: Object.freeze({ ...s.target }), sent: Object.freeze([...s.sent]) });
+}
+function result(s, action, waitMs) {
+    return Object.freeze({ state: frozen(s), action, ...(waitMs !== undefined ? { waitMs: Math.max(0, waitMs) } : {}) });
+}
+export function stopLadderStep(s, obs) {
+    const st = stateOf(s);
+    if (st === undefined) {
+        return Object.freeze({ state: s, action: 'gave-up' });
+    }
+    const nowMs = own(obs, 'nowMs');
+    const alive = own(obs, 'alive');
+    if (alive === 'gone')
+        return result(st, 'done');
+    if (!isTime(nowMs))
+        return result(st, 'wait');
+    const { g, P, H } = LOCAL_ENGINE_STOP_LADDER;
+    const health = own(obs, 'health');
+    let facts;
+    try {
+        facts = typeof health === 'object' && health !== null ? readEngineHealthFacts(health) : undefined;
+    }
+    catch {
+        facts = undefined;
+    }
+    const draining = facts?.draining;
+    let next = st;
+    if (draining !== undefined) {
+        if (st.mode === 'idle') {
+            next = { ...next, deadlineAt: Math.max(st.deadlineAt ?? draining.deadlineAt, draining.deadlineAt) };
+        }
+        else if (st.processedAt === undefined && st.sent.includes('term') && draining.actionId === SIGTERM_ACTION_ID && draining.since >= st.t0) {
+            next = { ...next, processedAt: nowMs };
+        }
+    }
+    const isAlive = alive === 'alive';
+    if (next.sent.length === 0) {
+        if (isAlive)
+            return result({ ...next, sent: ['term'] }, 'term');
+        return result(next, nowMs >= next.t0 + H ? 'gave-up' : 'wait', next.t0 + H - nowMs);
+    }
+    const killAt = next.mode === 'idle'
+        ? Math.max(next.t0, next.deadlineAt ?? next.t0) + H
+        : next.processedAt !== undefined && next.processedAt <= next.t0 + P
+            ? next.processedAt + g + H
+            : next.t0 + H;
+    if (next.killedAt !== undefined || next.sent.includes('kill')) {
+        const giveUpAt = (next.killedAt ?? killAt) + H;
+        if (nowMs >= giveUpAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', giveUpAt - nowMs);
+    }
+    if (!isAlive) {
+        if (nowMs >= killAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', killAt - nowMs);
+    }
+    if (nowMs >= killAt)
+        return result({ ...next, sent: [...next.sent, 'kill'], killedAt: nowMs }, 'kill');
+    if (next.mode === 'forced' &&
+        next.processedAt !== undefined &&
+        nowMs >= next.processedAt + g &&
+        draining !== undefined &&
+        !next.sent.includes('term-2')) {
+        return result({ ...next, sent: [...next.sent.filter((x) => x !== 'kill'), 'term-2'] }, 'term-2');
+    }
+    const term2At = next.mode === 'forced' && next.processedAt !== undefined && !next.sent.includes('term-2') ? next.processedAt + g : Infinity;
+    return result(next, 'wait', Math.min(killAt, term2At) - nowMs);
+}

package/dist/localEngineSwapCard.d.ts

@@ -0,0 +1,43 @@
+import type { LocalEngineAnchoredProcess, LocalEngineRef } from './localEngineJudge.js';
+import type { LocalEngineOccupancy } from './localEngineOccupancy.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const LOCAL_ENGINE_SWAP_CAUSES: readonly ["version", "config", "credential", "model-default", "user", "unresponsive"];
+export type LocalEngineSwapCause = (typeof LOCAL_ENGINE_SWAP_CAUSES)[number];
+export interface LocalEngineSwapPolicy {
+    readonly credentialAuto?: boolean;
+}
+export declare function localEngineSwapAutoable(cause: LocalEngineSwapCause, serving: boolean, policy?: LocalEngineSwapPolicy): boolean;
+export type EngineSwapCardTarget = LocalEngineRef | LocalEngineAnchoredProcess;
+export type EngineSwapCardUnknown = 'others' | 'inflight' | 'bg' | 'self';
+export interface EngineSwapCardInput {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly occupancy: LocalEngineOccupancy;
+    readonly bgIds: readonly string[] | null;
+}
+export interface EngineSwapCardOthers {
+    readonly total: number;
+    readonly midTurn: number;
+}
+export interface EngineSwapCard {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly others: EngineSwapCardOthers | null;
+    readonly inflight: number | null;
+    readonly bgLive: number | null;
+    readonly unknown: readonly EngineSwapCardUnknown[];
+    readonly forcedWithinMs: number;
+    readonly fingerprint: string;
+}
+export declare function engineSwapCardOf(input: EngineSwapCardInput): EngineSwapCard | undefined;
+export interface EngineSwapCardText {
+    readonly title: string;
+    readonly lines: readonly string[];
+    readonly force: string;
+    readonly wait: string;
+}
+export declare function engineSwapCardText(card: EngineSwapCard, lang?: UiLanguage): EngineSwapCardText | undefined;

package/dist/localEngineSwapCard.js

@@ -0,0 +1,205 @@
+import { engineIdentityOf } from './engineIdentity.js';
+import { readOwnDataValue } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { LOCAL_ENGINE_STOP_LADDER } from './localEngineStopLadder.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const LOCAL_ENGINE_SWAP_CAUSES = Object.freeze(['version', 'config', 'credential', 'model-default', 'user', 'unresponsive']);
+function isCause(v) {
+    return typeof v === 'string' && LOCAL_ENGINE_SWAP_CAUSES.includes(v);
+}
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v) && !isArray(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+export function localEngineSwapAutoable(cause, serving, policy) {
+    if (!isCause(cause))
+        return false;
+    if (serving === false)
+        return true;
+    if (cause === 'version' || cause === 'user')
+        return true;
+    return cause === 'credential' && own(policy, 'credentialAuto') === true;
+}
+const FORCED_WITHIN_MS = LOCAL_ENGINE_STOP_LADDER.P + LOCAL_ENGINE_STOP_LADDER.g + LOCAL_ENGINE_STOP_LADDER.H;
+function targetOf(t) {
+    const pid = own(t, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const identity = own(t, 'identity');
+    if (isRecord(identity)) {
+        const port = own(t, 'port');
+        if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)
+            return undefined;
+        const id = Object.freeze({ ...engineIdentityOf(identity) });
+        const version = own(t, 'version');
+        const target = Object.freeze({ pid, port, identity: id, ...(typeof version === 'string' && version.length > 0 ? { version } : {}) });
+        return { target, key: id };
+    }
+    const startedAt = own(t, 'startedAt');
+    const target = Object.freeze({ pid, ...(typeof startedAt === 'number' && Number.isFinite(startedAt) && startedAt > 0 ? { startedAt } : {}) });
+    return { target, key: engineIdentityOf(target) };
+}
+export function engineSwapCardOf(input) {
+    try {
+        const cause = own(input, 'cause');
+        if (!isCause(cause))
+            return undefined;
+        const t = targetOf(own(input, 'target'));
+        if (t === undefined)
+            return undefined;
+        const occ = own(input, 'occupancy');
+        const unknown = [];
+        const o = own(occ, 'others');
+        const total = own(o, 'total');
+        const midTurn = own(o, 'midTurn');
+        const others = own(o, 'known') === true && isCount(total) && isCount(midTurn) ? Object.freeze({ total, midTurn }) : null;
+        if (others === null)
+            unknown.push('others');
+        const inflightRaw = own(occ, 'inflight');
+        const inflight = isCount(inflightRaw) ? inflightRaw : null;
+        if (inflight === null)
+            unknown.push('inflight');
+        const bgRaw = own(occ, 'bgLive');
+        const idsRaw = own(input, 'bgIds');
+        let bgIds = null;
+        if (Array.isArray(idsRaw)) {
+            const list = [];
+            let readable = true;
+            for (let i = 0; i < idsRaw.length && readable; i++) {
+                const id = own(idsRaw, String(i));
+                if (typeof id === 'string')
+                    list.push(id);
+                else
+                    readable = false;
+            }
+            bgIds = readable ? list : null;
+        }
+        const bgLive = isCount(bgRaw) && bgIds !== null && bgIds.length === bgRaw ? bgRaw : null;
+        if (bgLive === null) {
+            unknown.push('bg');
+            bgIds = null;
+        }
+        const self = own(occ, 'self');
+        if (self !== 'idle' && self !== 'busy')
+            unknown.push('self');
+        const runningRaw = own(input, 'running');
+        const ownRaw = own(input, 'own');
+        const running = typeof runningRaw === 'string' && runningRaw.length > 0 ? runningRaw : undefined;
+        const mine = typeof ownRaw === 'string' && ownRaw.length > 0 ? ownRaw : undefined;
+        const k = t.key;
+        const fingerprint = JSON.stringify([
+            'local-engine-swap-card/1',
+            cause,
+            [t.target.pid, k.pid ?? null, k.instanceId ?? null, k.startedAt ?? null],
+            running ?? null,
+            mine ?? null,
+            others === null ? null : [others.total, others.midTurn],
+            inflight,
+            bgLive,
+            bgIds === null ? null : [...bgIds].sort(),
+            unknown,
+            self === 'idle' || self === 'busy' ? self : null,
+        ]);
+        return Object.freeze({
+            cause,
+            target: t.target,
+            ...(running !== undefined ? { running } : {}),
+            ...(mine !== undefined ? { own: mine } : {}),
+            others,
+            inflight,
+            bgLive,
+            unknown: Object.freeze(unknown),
+            forcedWithinMs: FORCED_WITHIN_MS,
+            fingerprint,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const TITLE_KEYS = Object.freeze({
+    version: 'localEngine.card.title.version',
+    config: 'localEngine.card.title.config',
+    credential: 'localEngine.card.title.credential',
+    'model-default': 'localEngine.card.title.modelDefault',
+    user: 'localEngine.card.title.user',
+    unresponsive: 'localEngine.card.title.unresponsive',
+});
+const VERSION_DISPLAY_MAX = 64;
+export function engineSwapCardText(card, lang) {
+    try {
+        const cause = own(card, 'cause');
+        const forcedWithinMs = own(card, 'forcedWithinMs');
+        if (!isCause(cause) || !isCount(forcedWithinMs))
+            return undefined;
+        const say = (key, params) => renderMessage(msg(key, params), lang);
+        const lines = [];
+        const running = own(card, 'running');
+        const mine = own(card, 'own');
+        if (typeof running === 'string' && running.length > 0 && typeof mine === 'string' && mine.length > 0) {
+            lines.push(say('localEngine.card.versions', { running: displayUntrusted(running, { max: VERSION_DISPLAY_MAX }), own: displayUntrusted(mine, { max: VERSION_DISPLAY_MAX }) }));
+        }
+        const others = own(card, 'others');
+        const total = own(others, 'total');
+        const midTurn = own(others, 'midTurn');
+        if (isCount(total) && isCount(midTurn))
+            lines.push(say(total === 1 ? 'localEngine.card.others.one' : 'localEngine.card.others.other', { total, midTurn }));
+        else
+            lines.push(say('localEngine.card.others.unknown'));
+        const inflight = own(card, 'inflight');
+        if (isCount(inflight))
+            lines.push(say(inflight === 1 ? 'localEngine.card.inflight.one' : 'localEngine.card.inflight.other', { count: inflight }));
+        else
+            lines.push(say('localEngine.card.inflight.unknown'));
+        const bgLive = own(card, 'bgLive');
+        if (isCount(bgLive))
+            lines.push(say(bgLive === 1 ? 'localEngine.card.background.one' : 'localEngine.card.background.other', { count: bgLive }));
+        else
+            lines.push(say('localEngine.card.background.unknown'));
+        if (isCount(inflight) && inflight > 0 && isCount(bgLive) && bgLive > 0)
+            lines.push(say('localEngine.card.overlap'));
+        const unknown = own(card, 'unknown');
+        if (Array.isArray(unknown) && unknown.includes('self'))
+            lines.push(say('localEngine.card.selfUnknown'));
+        lines.push(say('localEngine.card.parked'));
+        return Object.freeze({
+            title: say(TITLE_KEYS[cause]),
+            lines: Object.freeze(lines),
+            force: say('localEngine.card.force', { seconds: Math.ceil(forcedWithinMs / 1000) }),
+            wait: say('localEngine.card.wait'),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/localEngineTiming.d.ts

@@ -0,0 +1,8 @@
+export declare const LOCAL_ENGINE_TIMING: Readonly<{
+    unansweredWaitMs: 60000;
+    prepareTimeoutMs: 10000;
+    stopProbeTimeoutMs: 4000;
+    crashWindowMs: 300000;
+    crashMaxDeaths: 3;
+    cooldownMs: readonly [60000, 120000, 240000, 480000, 600000, 600000];
+}>;

package/dist/localEngineTiming.js

@@ -0,0 +1,8 @@
+export const LOCAL_ENGINE_TIMING = Object.freeze({
+    unansweredWaitMs: 60000,
+    prepareTimeoutMs: 10000,
+    stopProbeTimeoutMs: 4000,
+    crashWindowMs: 300000,
+    crashMaxDeaths: 3,
+    cooldownMs: Object.freeze([60000, 120000, 240000, 480000, 600000, 600000]),
+});

package/dist/mcpReconnect.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
+import { inSlotReadOf, inValueOf } from './wireFailureShape.js';
 import { readMcpAuthorization } from './mcpLiveness.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
 export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
@@ -82,8 +83,11 @@ export function projectMcpReconnectResult(body) {
         added,
         removed,
     };
-    if ('toolNames' in body && body.toolNames !== undefined) {
-        const toolNames = stringList(body.toolNames);
+    const names = inValueOf(body, 'toolNames');
+    if (names.state === 'unproven')
+        return undefined;
+    if (names.state === 'present' && names.value !== undefined) {
+        const toolNames = stringList(names.value);
         if (toolNames === undefined)
             return undefined;
         view.toolNames = toolNames;
@@ -93,8 +97,11 @@ export function projectMcpReconnectResult(body) {
     const status = projectStatus(body.status);
     if (status !== undefined)
         view.status = status;
-    if ('listingIncomplete' in body && body.listingIncomplete !== undefined) {
-        const li = projectListingIncomplete(body.listingIncomplete);
+    const incomplete = inValueOf(body, 'listingIncomplete');
+    if (incomplete.state === 'unproven')
+        return undefined;
+    if (incomplete.state === 'present' && incomplete.value !== undefined) {
+        const li = projectListingIncomplete(incomplete.value);
         if (li === undefined)
             return undefined;
         view.listingIncomplete = li;
@@ -116,7 +123,7 @@ function unsettledVerdict(carrier) {
 }
 function isUnsettledBody(raw) {
     try {
-        return isRecord(raw) && !('outcome' in raw) && raw.errorCode === UNSETTLED_CODE;
+        return isRecord(raw) && inSlotReadOf(raw, 'outcome').state === 'absent' && raw.errorCode === UNSETTLED_CODE;
     }
     catch {
         return false;

package/dist/mcpWireCaps.js

@@ -329,7 +329,7 @@ function dropNotice(name, reason, problem, opts, path, transportKind) {
                     : reason === 'elicitation_invalid'
                         ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
                         : reason === 'allow_tools_invalid'
-                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: problem ?? '' })
                             : reason === 'identity_headers_both_set'
                                 ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
                                 : reason === 'transport_invalid'
@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.144.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.147.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryEntriesWire.d.ts

@@ -61,7 +61,7 @@ export interface MemoryEraseConflictRow {
     id: string;
     reason: string;
 }
-declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
+declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "clearanceCustody", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
 export type MemoryEraseCarrierClass = (typeof MEMORY_ERASE_CARRIER_CLASSES)[number];
 export type MemoryEraseCarrierReading = {
     removed: number;

package/dist/memoryEntriesWire.js

@@ -174,6 +174,7 @@ const MEMORY_ERASE_CARRIER_CLASSES = Object.freeze([
     'shadow',
     'indexLine',
     'quarantineCopy',
+    'clearanceCustody',
     'planArchive',
     'planWorkbook',
     'evidenceBinding',
@@ -237,6 +238,10 @@ function eraseResidualsOf(o, lane) {
             return null;
         const carriers = {};
         for (const cls of MEMORY_ERASE_CARRIER_CLASSES) {
+            if (!Object.hasOwn(rawCarriers, cls)) {
+                carriers[cls] = { unverified: true };
+                continue;
+            }
             const answer = carrierAnswerOf(readThrownSlot(rawCarriers, cls, 'data'));
             if (answer === null)
                 return null;

package/dist/noticePresentation.d.ts

@@ -6,7 +6,9 @@ export interface CutForDisplayResult {
     readonly shown: string;
     readonly truncated: boolean;
 }
+export declare function pairSafeCut(text: string, cut: number): number;
 export declare function cutForDisplay(text: string, budget: number, opts?: CutForDisplayOptions): CutForDisplayResult;
+export declare function elideMiddleForDisplay(text: string, budget: number): string;
 export type NoticePresentationAudience = 'user' | 'operator' | 'unknown';
 export type NoticeOutlet = 'present' | 'absent' | 'unknown';
 export type NoticeOccurrence = {

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 {