@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/modelSwitchFallback.js

@@ -0,0 +1,206 @@
+import { resultErrorCodeOf, resultSelectedModelOf } from './resultFrameKeys.js';
+import { readFrameStringKey, readOwnDataValue } from './ownKey.js';
+const trimmed = (v) => (typeof v === 'string' ? v.trim() : '');
+const reasonOf = (v) => {
+    const t = trimmed(v);
+    return t.length > 0 ? t : undefined;
+};
+function thrownReason(e) {
+    try {
+        if (e instanceof Error)
+            return reasonOf(e.message);
+        return reasonOf(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function modelSwitchProbeOutcomeOf(input) {
+    let model = '';
+    let lane;
+    let absent;
+    let probe;
+    try {
+        model = trimmed(input?.model);
+        lane = input?.lane;
+        absent = reasonOf(input?.engineAbsentReason);
+        probe = input?.probe;
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (model.length === 0)
+        return { ok: true, probed: false };
+    if (lane === 'unwired')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    if (lane === 'mock' || (lane === 'engine_absent' && absent === undefined))
+        return { ok: true, probed: false };
+    if (lane !== 'live' && lane !== 'engine_absent')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    let kind;
+    let verdict;
+    let error;
+    try {
+        kind = probe?.kind;
+        verdict = kind === 'verdict' ? probe.verdict : undefined;
+        error = kind === 'threw' ? probe.error : undefined;
+    }
+    catch {
+        kind = undefined;
+    }
+    if (kind === 'threw') {
+        const reason = thrownReason(error);
+        return { ok: false, kind: 'unavailable', cause: 'probe_threw', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    if (kind !== 'verdict' || verdict === null || typeof verdict !== 'object')
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    let valid;
+    let unchecked;
+    let why;
+    try {
+        valid = verdict.valid;
+        unchecked = verdict.unchecked;
+        why = reasonOf(verdict.error);
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (valid === true)
+        return { ok: true, probed: lane === 'live' };
+    if (unchecked === true) {
+        const reason = why ?? absent;
+        return { ok: false, kind: 'unavailable', cause: 'unchecked', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    return { ok: false, kind: 'rejected', model, ...(why !== undefined ? { reason: why } : {}) };
+}
+export async function runModelSwitchProbe(model, ports) {
+    let laneReading;
+    try {
+        const got = await ports.lane();
+        const lane = got?.lane;
+        const why = got?.engineAbsentReason;
+        laneReading = {
+            lane: lane === 'live' || lane === 'mock' || lane === 'engine_absent' || lane === 'unwired' ? lane : 'unwired',
+            ...(typeof why === 'string' ? { engineAbsentReason: why } : {}),
+        };
+    }
+    catch {
+        laneReading = { lane: 'unwired' };
+    }
+    const base = { model, ...laneReading };
+    const pre = modelSwitchProbeOutcomeOf(base);
+    if (pre.ok || (pre.kind === 'unavailable' && pre.cause !== 'probe_missing'))
+        return pre;
+    try {
+        const verdict = await ports.validate(trimmed(model));
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'verdict', verdict } });
+    }
+    catch (error) {
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'threw', error } });
+    }
+}
+const EMPTY_STREAM_ERROR_CODE = 'stream_torn';
+const LEDGER_SESSION_CAP = 1024;
+function isEmptyStreamFailureFrame(frame) {
+    try {
+        if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        if (readFrameStringKey(frame, 'type') !== 'result')
+            return false;
+        if (readOwnDataValue(frame, 'is_error') !== true)
+            return false;
+        return resultErrorCodeOf(frame) === EMPTY_STREAM_ERROR_CODE;
+    }
+    catch {
+        return false;
+    }
+}
+export function createModelSwitchFallbackLedger() {
+    const bySession = new Map();
+    let lastSeq = 0;
+    const drop = (sid) => {
+        if (sid.length > 0)
+            bySession.delete(sid);
+    };
+    return {
+        noteSwitch(input) {
+            let sid = '';
+            let current = '';
+            let previous = '';
+            try {
+                sid = trimmed(input?.sessionId);
+                current = trimmed(input?.to);
+                previous = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (sid.length === 0)
+                return undefined;
+            if (current.length === 0 || previous.length === 0 || previous === current) {
+                drop(sid);
+                return undefined;
+            }
+            lastSeq += 1;
+            const rec = Object.freeze({ previous, current, seq: lastSeq });
+            bySession.delete(sid);
+            bySession.set(sid, rec);
+            while (bySession.size > LEDGER_SESSION_CAP) {
+                const oldest = bySession.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                bySession.delete(oldest);
+            }
+            return rec;
+        },
+        peek(sessionId) {
+            const sid = trimmed(sessionId);
+            return sid.length > 0 ? bySession.get(sid) : undefined;
+        },
+        advisoryFor(input) {
+            let frame;
+            let sid = '';
+            let streamModel = '';
+            let served = '';
+            try {
+                frame = input?.frame;
+                sid = trimmed(input?.sessionId);
+                streamModel = trimmed(input?.streamModel);
+                served = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (!isEmptyStreamFailureFrame(frame))
+                return undefined;
+            if (sid.length === 0)
+                return undefined;
+            const rec = bySession.get(sid);
+            if (rec === undefined)
+                return undefined;
+            const frameModel = trimmed(resultSelectedModelOf(frame));
+            const candidates = frameModel.length > 0 && frameModel !== streamModel ? [streamModel, frameModel] : [streamModel];
+            for (const c of candidates) {
+                if (c.length === 0 || rec.current !== c)
+                    continue;
+                if (served === c)
+                    return undefined;
+                return rec;
+            }
+            return undefined;
+        },
+        release(sessionId, seq) {
+            const sid = trimmed(sessionId);
+            if (sid.length === 0)
+                return false;
+            const rec = bySession.get(sid);
+            if (rec === undefined || typeof seq !== 'number' || rec.seq !== seq)
+                return false;
+            bySession.delete(sid);
+            return true;
+        },
+        clear(sessionId) {
+            drop(trimmed(sessionId));
+        },
+    };
+}

package/dist/noticePresentation.d.ts

@@ -0,0 +1,68 @@
+export interface CutForDisplayOptions {
+    readonly boundary?: 'sentence' | 'word';
+    readonly mark?: string;
+}
+export interface CutForDisplayResult {
+    readonly shown: string;
+    readonly truncated: boolean;
+}
+export declare function cutForDisplay(text: string, budget: number, opts?: CutForDisplayOptions): CutForDisplayResult;
+export type NoticePresentationAudience = 'user' | 'operator' | 'unknown';
+export type NoticeOutlet = 'present' | 'absent' | 'unknown';
+export type NoticeOccurrence = {
+    readonly kind: 'event';
+} | {
+    readonly kind: 'occurrence';
+    readonly key: string;
+};
+export type NoticeSeatClass = 'persistent+hint' | 'persistent' | 'transient' | 'diagnostic';
+export type NoticeDeployment = 'local' | 'remote';
+export interface NoticePresentationFacts {
+    readonly audience: NoticePresentationAudience;
+    readonly outlet: NoticeOutlet;
+    readonly remedy?: string;
+    readonly occurrence: NoticeOccurrence;
+    readonly seatClass: NoticeSeatClass;
+}
+export declare const NOTICE_SEAT_CLASS: Readonly<Record<NoticePresentationAudience, Readonly<Record<NoticeOutlet, NoticeSeatClass>>>>;
+export declare function noticeSeatClassOf(audience: NoticePresentationAudience, outlet: NoticeOutlet, deployment?: NoticeDeployment): NoticeSeatClass;
+export declare function noticePresentationFacts(notice: unknown, deployment?: NoticeDeployment): NoticePresentationFacts;
+export declare const OUTLET_KINDS: readonly ["slash-command", "cli-command", "http-endpoint", "env-or-settings", "operator-action", "identity-attach", "resend"];
+export type OutletKind = (typeof OUTLET_KINDS)[number];
+export type OutletReachability = 'reachable' | 'unreachable' | 'unknown';
+export interface OutletReachabilityContext {
+    readonly lane: 'interactive' | 'print';
+    readonly engineManagedByShell: 'shell' | 'external-local' | 'remote' | 'unknown';
+    readonly configScope: 'reaches-engine' | 'does-not' | 'unknown';
+    readonly endpointAccess: 'has-address-and-credential' | 'no' | 'unknown';
+    readonly operator: 'present' | 'absent' | 'unknown';
+    readonly identityAttach: 'available' | 'unavailable' | 'unknown';
+}
+export declare function outletReachable(kind: OutletKind, ctx: OutletReachabilityContext): OutletReachability;
+export interface OutletRenderingPlan {
+    readonly state: readonly OutletKind[];
+    readonly confirm: readonly OutletKind[];
+    readonly omit: readonly OutletKind[];
+    readonly nothingReachable: boolean;
+}
+export declare function planOutletRendering(kinds: readonly OutletKind[], ctx: OutletReachabilityContext): OutletRenderingPlan;
+export declare const NOTICE_FULL_TEXT_CAP = 8000;
+export type NoticePrintCarrier = {
+    readonly kind: 'transcript';
+    readonly sessionId: string;
+} | {
+    readonly kind: 'stream-json';
+} | {
+    readonly kind: 'none';
+};
+export interface NoticePrintLineInput {
+    readonly text: string | undefined;
+    readonly audience: NoticePresentationAudience;
+    readonly code?: string;
+    readonly carrier: NoticePrintCarrier;
+}
+export interface NoticePrintLineResult {
+    readonly line: string;
+    readonly truncated: boolean;
+}
+export declare function noticePrintLine(input: NoticePrintLineInput): NoticePrintLineResult;

package/dist/noticePresentation.js

@@ -0,0 +1,247 @@
+import { capDisplay, displayUntrusted } from './displayUntrusted.js';
+import { engineNoticeInCatalog, noticeAudienceOf } from './engineNoticeCodes.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+const DEFAULT_CUT_MARK = '…';
+const CUT_KEEP_DIVISOR = 2;
+const CLOSERS = '"\')]”’」』）】';
+const ASCII_SENTENCE_END = '.!?;';
+const WIDE_SENTENCE_END = '。！？；';
+const ASCII_CLAUSE_END = ',:';
+const WIDE_CLAUSE_END = '，、：';
+const EM_DASH = '—';
+function isWs(c) {
+    return c !== '' && c.trim() === '';
+}
+function readCutOptions(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        return { boundary: 'sentence', mark: DEFAULT_CUT_MARK };
+    const boundary = guardedRead(() => readOwnDataValue(opts, 'boundary'));
+    const mark = guardedRead(() => readOwnDataValue(opts, 'mark'));
+    return { boundary: boundary === 'word' ? 'word' : 'sentence', mark: typeof mark === 'string' ? mark : DEFAULT_CUT_MARK };
+}
+function sentenceEndAt(src, j) {
+    const c = src.charAt(j);
+    const ascii = ASCII_SENTENCE_END.includes(c);
+    if (!ascii && !WIDE_SENTENCE_END.includes(c))
+        return -1;
+    let k = j + 1;
+    while (k < src.length && CLOSERS.includes(src.charAt(k)))
+        k++;
+    if (!ascii)
+        return k;
+    return k === src.length || isWs(src.charAt(k)) ? k : -1;
+}
+function clauseEndAt(src, j) {
+    const c = src.charAt(j);
+    if (WIDE_CLAUSE_END.includes(c))
+        return j + 1;
+    if (!ASCII_CLAUSE_END.includes(c))
+        return -1;
+    const k = j + 1;
+    return k === src.length || isWs(src.charAt(k)) ? k : -1;
+}
+function pickCut(src, limit, floor, boundary) {
+    let sentence = -1;
+    let clause = -1;
+    let word = -1;
+    for (let j = 0; j <= limit && j < src.length; j++) {
+        const c = src.charAt(j);
+        if (isWs(c)) {
+            word = j;
+            continue;
+        }
+        if (boundary === 'word')
+            continue;
+        const s = sentenceEndAt(src, j);
+        if (s !== -1 && s <= limit)
+            sentence = Math.max(sentence, s);
+        else if (c === EM_DASH && j > 0 && isWs(src.charAt(j - 1)) && (j + 1 === src.length || isWs(src.charAt(j + 1))))
+            sentence = Math.max(sentence, j);
+        const k = clauseEndAt(src, j);
+        if (k !== -1 && k <= limit)
+            clause = Math.max(clause, k);
+    }
+    if (boundary === 'word')
+        return word >= floor ? word : -1;
+    if (sentence >= floor)
+        return sentence;
+    if (clause >= floor)
+        return clause;
+    return word >= floor ? word : -1;
+}
+export function cutForDisplay(text, budget, opts) {
+    const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
+    if (typeof budget !== 'number' || !Number.isFinite(budget))
+        return { shown: src, truncated: false };
+    const limit = Math.max(0, Math.floor(budget));
+    if (src.length <= limit)
+        return { shown: src, truncated: false };
+    const { boundary, mark } = readCutOptions(opts);
+    const room = limit - mark.length;
+    if (room <= 0)
+        return { shown: limit >= mark.length ? mark : '', truncated: true };
+    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();
+    return { shown: `${kept}${mark}`, truncated: true };
+}
+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' }),
+    unknown: Object.freeze({ present: 'persistent+hint', unknown: 'persistent+hint', absent: 'persistent+hint' }),
+});
+export function noticeSeatClassOf(audience, outlet, deployment) {
+    const a = typeof audience === 'string' && Object.hasOwn(NOTICE_SEAT_CLASS, audience) ? audience : 'unknown';
+    const row = a === 'operator' && deployment !== 'remote' ? NOTICE_SEAT_CLASS.user : NOTICE_SEAT_CLASS[a];
+    return typeof outlet === 'string' && Object.hasOwn(row, outlet) ? row[outlet] : row.unknown;
+}
+const OCCURRENCE_KEY_BY_CODE = Object.freeze({
+    'memory.harvest_quarantined': 'reportId',
+    'memory.hold_opened': 'reportId',
+    'memory.hold_released': 'reportId',
+    'memory.hold_disposed': 'reportId',
+    'memory.consolidation_recommended': 'reportId',
+    'memory.capture_opted_out': 'sessionId',
+    'memory.delegation_static_mark_waived': 'runId',
+});
+export function noticePresentationFacts(notice, deployment) {
+    const envelope = typeof notice === 'object' && notice !== null ? notice : undefined;
+    const code = guardedRead(() => readOwnDataValue(envelope, 'code'));
+    const detailRaw = guardedRead(() => readOwnDataValue(envelope, 'detail'));
+    const detail = typeof detailRaw === 'object' && detailRaw !== null ? detailRaw : undefined;
+    const audience = typeof code === 'string' && engineNoticeInCatalog(code) ? noticeAudienceOf(code) : 'unknown';
+    const remedy = guardedRead(() => readOwnDataNonEmptyString(detail, 'remedy'));
+    const outlet = remedy !== undefined ? 'present' : 'unknown';
+    const keyField = typeof code === 'string' && Object.hasOwn(OCCURRENCE_KEY_BY_CODE, code) ? OCCURRENCE_KEY_BY_CODE[code] : undefined;
+    const identity = keyField !== undefined ? guardedRead(() => readOwnDataNonEmptyString(detail, keyField)) : undefined;
+    const occurrence = Object.freeze(identity !== undefined ? { kind: 'occurrence', key: identity } : { kind: 'event' });
+    return Object.freeze({
+        audience,
+        outlet,
+        ...(remedy !== undefined ? { remedy } : {}),
+        occurrence,
+        seatClass: noticeSeatClassOf(audience, outlet, deployment),
+    });
+}
+export const OUTLET_KINDS = Object.freeze(['slash-command', 'cli-command', 'http-endpoint', 'env-or-settings', 'operator-action', 'identity-attach', 'resend']);
+function ctxSlot(ctx, key, closed) {
+    if (typeof ctx !== 'object' || ctx === null)
+        return undefined;
+    const v = guardedRead(() => readOwnDataValue(ctx, key));
+    return typeof v === 'string' && closed.includes(v) ? v : undefined;
+}
+function isOutletKind(v) {
+    return typeof v === 'string' && OUTLET_KINDS.includes(v);
+}
+export function outletReachable(kind, ctx) {
+    if (!isOutletKind(kind))
+        return 'unknown';
+    const lane = ctxSlot(ctx, 'lane', ['interactive', 'print']);
+    switch (kind) {
+        case 'resend':
+        case 'cli-command':
+            return 'reachable';
+        case 'slash-command':
+            return lane === 'interactive' ? 'reachable' : lane === 'print' ? 'unreachable' : 'unknown';
+        case 'http-endpoint': {
+            if (lane === 'interactive')
+                return 'unreachable';
+            const access = ctxSlot(ctx, 'endpointAccess', ['has-address-and-credential', 'no', 'unknown']);
+            if (access === 'no')
+                return 'unreachable';
+            return lane === 'print' && access === 'has-address-and-credential' ? 'reachable' : 'unknown';
+        }
+        case 'env-or-settings': {
+            const scope = ctxSlot(ctx, 'configScope', ['reaches-engine', 'does-not', 'unknown']);
+            if (scope === 'reaches-engine')
+                return 'reachable';
+            if (scope === 'does-not')
+                return 'unreachable';
+            return ctxSlot(ctx, 'engineManagedByShell', ['shell', 'external-local', 'remote', 'unknown']) === 'remote' ? 'unreachable' : 'unknown';
+        }
+        case 'operator-action': {
+            const op = ctxSlot(ctx, 'operator', ['present', 'absent', 'unknown']);
+            return op === 'present' ? 'reachable' : op === 'absent' ? 'unreachable' : 'unknown';
+        }
+        case 'identity-attach': {
+            const id = ctxSlot(ctx, 'identityAttach', ['available', 'unavailable', 'unknown']);
+            return id === 'available' ? 'reachable' : id === 'unavailable' ? 'unreachable' : 'unknown';
+        }
+    }
+}
+const LIST_READ_MAX = 64;
+function listItems(list) {
+    if (guardedRead(() => (Array.isArray(list) ? true : undefined)) !== true)
+        return [];
+    const length = guardedRead(() => readOwnDataValue(list, 'length'));
+    if (typeof length !== 'number' || !Number.isInteger(length) || length < 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < Math.min(length, LIST_READ_MAX); i++) {
+        const item = guardedRead(() => readOwnDataValue(list, String(i)));
+        if (item !== undefined)
+            out.push(item);
+    }
+    return out;
+}
+export function planOutletRendering(kinds, ctx) {
+    const state = [];
+    const confirm = [];
+    const omit = [];
+    const seen = new Set();
+    for (const k of listItems(kinds)) {
+        if (!isOutletKind(k) || seen.has(k))
+            continue;
+        seen.add(k);
+        const r = outletReachable(k, ctx);
+        (r === 'reachable' ? state : r === 'unknown' ? confirm : omit).push(k);
+    }
+    return Object.freeze({
+        state: Object.freeze(state),
+        confirm: Object.freeze(confirm),
+        omit: Object.freeze(omit),
+        nothingReachable: state.length === 0 && confirm.length === 0 && omit.length > 0,
+    });
+}
+export const NOTICE_FULL_TEXT_CAP = 8000;
+const PRINT_BUDGET_USER = 1000;
+const PRINT_BUDGET_OPERATOR = 160;
+const PRINT_PREFIX = '[sema] ';
+const NO_TEXT_SENTENCE = 'Engine notice (no message text)';
+const PRINT_CODE_MAX = 160;
+const PRE_CAP_SLACK = 2;
+const PRINT_SESSION_MAX = 128;
+function lineFace(max) {
+    return max === undefined ? { foldLines: false, mark: 'dot' } : { foldLines: false, mark: 'dot', max };
+}
+function printCarrier(carrier) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return { kind: 'none' };
+    const kind = guardedRead(() => readOwnDataValue(carrier, 'kind'));
+    if (kind === 'stream-json')
+        return { kind };
+    if (kind === 'transcript') {
+        const sid = guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId'));
+        if (sid !== undefined) {
+            const shown = displayUntrusted(sid, lineFace(PRINT_SESSION_MAX));
+            if (shown !== '')
+                return { kind, sessionId: shown };
+        }
+    }
+    return { kind: 'none' };
+}
+export function noticePrintLine(input) {
+    const textRaw = guardedRead(() => readOwnDataValue(input, 'text'));
+    const audience = guardedRead(() => readOwnDataValue(input, 'audience'));
+    const codeRaw = guardedRead(() => readOwnDataValue(input, 'code'));
+    const carrier = printCarrier(guardedRead(() => readOwnDataValue(input, 'carrier')));
+    const washed = displayUntrusted(typeof textRaw === 'string' ? textRaw : '', lineFace(NOTICE_FULL_TEXT_CAP + PRE_CAP_SLACK));
+    const bounded = cutForDisplay(washed, NOTICE_FULL_TEXT_CAP);
+    const text = bounded.shown.trim() === '' ? NO_TEXT_SENTENCE : bounded.shown;
+    const budget = audience === 'operator' ? PRINT_BUDGET_OPERATOR : PRINT_BUDGET_USER;
+    const cut = carrier.kind === 'none' ? { shown: text, truncated: bounded.truncated } : cutForDisplay(text, budget);
+    const where = cut.truncated && carrier.kind === 'transcript' ? ` (full text: sema -r ${carrier.sessionId})` : '';
+    const code = typeof codeRaw === 'string' && codeRaw !== '' ? displayUntrusted(codeRaw, lineFace(PRINT_CODE_MAX)) : '';
+    return Object.freeze({ line: `${PRINT_PREFIX}${cut.shown}${where}${code !== '' ? ` [${code}]` : ''}`, truncated: cut.truncated });
+}

package/dist/notifications.js

@@ -1,7 +1,9 @@
 import { hostEnv } from './hostEnv.js';
 import { unrefTimer } from './unrefTimer.js';
 import { clearEnginePanelTaskResidentByWire, publishEngineAgentPanelEvent, } from './engineAgentPanelStore.js';
-import { isTaskNotificationTerminalStatus, isTerminalNotSuccess, isTerminalStatus } from './runTerminal.js';
+import { panelEndFact } from './panelReduce.js';
+import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess } from './terminalStatuses.js';
+import { cycleSeqValue } from './cycleOrder.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -130,7 +132,7 @@ export function parseTranscriptNotificationSeeds(messages) {
                     continue;
                 const external = /\btype="external"/.test(attrs);
                 renderedKeys.push(`${external ? 'external:' : ''}${taskId}:${status}`);
-                if (!external && (isTerminalStatus(status) || isTaskNotificationTerminalStatus(status))) {
+                if (!external && isCoreTaskNotificationTerminal(status)) {
                     notifiedKeys.push(taskId);
                 }
                 seeded++;
@@ -316,6 +318,10 @@ const BG_FIRST_SEQ = 1;
 function normalizeBgSeq(seq) {
     return typeof seq === 'number' && Number.isFinite(seq) && seq >= BG_FIRST_SEQ ? Math.floor(seq) : BG_FIRST_SEQ;
 }
+function notificationCycleOf(n) {
+    const cycleSeq = cycleSeqValue(n.seq);
+    return cycleSeq !== undefined ? { cycleSeq } : undefined;
+}
 function bgOutstandingKey(taskId, seq) {
     return `${taskId}:${seq}`;
 }
@@ -570,20 +576,15 @@ export function enqueueBgChildNotification(n) {
         return;
     }
     bgNotifiedKeys.add(key);
-    const terminal = isTaskNotificationTerminalStatus(n.status);
+    const terminal = isCoreTaskNotificationTerminal(n.status);
     if (terminal) {
         markRunNotified(n.taskId, cycle);
         cardEnqueuedRunIds.add(n.taskId);
     }
     if (terminal) {
         try {
-            clearEnginePanelTaskResidentByWire(n.taskId, typeof n.seq === 'number' && Number.isInteger(n.seq) && n.seq >= BG_FIRST_SEQ ? { cycleSeq: n.seq } : undefined);
-            publishEngineAgentPanelEvent({
-                kind: 'end',
-                taskId: n.taskId,
-                isError: isTerminalNotSuccess(n.status),
-                ...(typeof n.seq === 'number' && Number.isInteger(n.seq) && n.seq >= BG_FIRST_SEQ ? { cycleSeq: n.seq } : {}),
-            });
+            clearEnginePanelTaskResidentByWire(n.taskId, notificationCycleOf(n));
+            publishEngineAgentPanelEvent(panelEndFact(n.taskId, isCoreTaskNotificationTerminalNotSuccess(n.status), notificationCycleOf(n)));
         }
         catch {
         }
@@ -667,7 +668,7 @@ export function taskNotificationDeliverySupplement(objective) {
         return `${SUPPLEMENT_LINE_PREFIX}completed — only this notification delivery failed. Check /tasks for the result.`;
     }
     const statusNote = status && status.length > 0 ? ` (status: ${status})` : '';
-    if (isTaskNotificationTerminalStatus(status)) {
+    if (isCoreTaskNotificationTerminal(status)) {
         return `${SUPPLEMENT_LINE_PREFIX}already finished${statusNote} — only this notification delivery failed. Check /tasks for the result.`;
     }
     return `${SUPPLEMENT_LINE_PREFIX}is in a state this client cannot confirm${statusNote} — this notification delivery failed and the task's outcome is unknown here. Check /tasks for its current state.`;

package/dist/outputStyleSeatCapability.d.ts

@@ -12,5 +12,3 @@ export declare function noteEngineCapsForOutputStyleSeat(baseUrl: string, caps:
 }): void;
 export declare function observedOutputStyleSeat(baseUrl?: string | undefined): OutputStyleSeatReading;
 export declare function outputStyleSeatAdmitted(reading: OutputStyleSeatReading | undefined): boolean;
-export declare function forgetOutputStyleSeatReading(baseUrl: string | undefined): void;
-export declare function __resetOutputStyleSeatReadingsForTests(): void;

package/dist/outputStyleSeatCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectOutputStyleSeatCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'outputStyle'))
-            return { kind: 'not_reported' };
-        const v = caps.outputStyle;
+        const v = ownDataField(caps, 'outputStyle');
         if (v === undefined)
             return { kind: 'not_reported' };
         return v === true ? { kind: 'present', value: true } : undefined;
@@ -39,9 +37,3 @@ export function outputStyleSeatAdmitted(reading) {
         return false;
     }
 }
-export function forgetOutputStyleSeatReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetOutputStyleSeatReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/ownKey.d.ts

@@ -1,5 +1,13 @@
 export declare function putOwnKey<T>(table: Record<string, T>, key: string, value: T): void;
 export declare function readOwnNonEmptyString(v: object | null | undefined, key: string): string | undefined;
+export declare function readAskOrigin(carrier: object | null | undefined): string | undefined;
 export declare function readOwnDataNonEmptyString(v: object | null | undefined, key: string): string | undefined;
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
+export declare function guardedRead<T>(read: () => T | undefined): T | undefined;
+export declare function ownDataField(v: object, key: string): unknown;
+export declare function ownSendableField(v: object, key: string): unknown;
+export declare function ownDataRefusalKeyOf(e: unknown): string | undefined;
 export declare function readFrameStringKey(frame: unknown, key: string): string | undefined;
+export declare function readFrameTrueMark(frame: object | null | undefined, key: string): boolean;
+export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
+export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;