@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/memoryComplianceCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export const MEMORY_ENGINE_REQUIRED_CODE = 'capability.memory_engine_required';
 export function projectMemoryComplianceCapability(caps) {
@@ -21,11 +21,7 @@ export function projectMemoryComplianceCapability(caps) {
 const reader = createEngineCapReader({
     name: 'memoryCompliance',
     project: projectMemoryComplianceCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForMemoryCompliance(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedMemoryCompliance(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -38,6 +34,8 @@ export function memoryComplianceVerbsAvailable(reading) {
 }
 export function memoryComplianceDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('memory compliance face');
         case 'unobserved':
             return 'memory compliance face not observed — the engine reports it on /v1/capabilities (memoryCompliance); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
@@ -48,6 +46,3 @@ export function memoryComplianceDoctorDetail(reading) {
             return 'memory compliance face on — the entry-provenance and erasure endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds (a damaged control-plane ledger is a runtime fact and arrives as a typed 500)';
     }
 }
-export function __resetMemoryComplianceReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/memoryOriginCapability.d.ts

@@ -1,5 +1,7 @@
 export type MemoryOriginReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -8,10 +10,6 @@ export type MemoryOriginReading = {
     kind: 'present';
 };
 export declare function projectMemoryOriginCapability(caps: unknown): MemoryOriginReading | undefined;
-export declare function noteEngineCapsForMemoryOrigin(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedMemoryOrigin(baseUrl?: string | undefined): MemoryOriginReading;
 export declare function memoryOriginVerbsAvailable(reading: MemoryOriginReading): 'yes' | 'no' | 'unknown';
 export declare function memoryOriginDoctorDetail(reading: MemoryOriginReading): string;
-export declare function __resetMemoryOriginReadingsForTests(): void;

package/dist/memoryOriginCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
 export function projectMemoryOriginCapability(caps) {
@@ -21,11 +21,7 @@ export function projectMemoryOriginCapability(caps) {
 const reader = createEngineCapReader({
     name: 'memoryOrigin',
     project: projectMemoryOriginCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForMemoryOrigin(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedMemoryOrigin(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -38,6 +34,8 @@ export function memoryOriginVerbsAvailable(reading) {
 }
 export function memoryOriginDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('external-origin face');
         case 'unobserved':
             return 'external-origin face not observed — the engine reports it on /v1/capabilities (memoryOrigin); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
@@ -48,6 +46,3 @@ export function memoryOriginDoctorDetail(reading) {
             return 'external-origin face on — the origin listing and clearance endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds, and it says nothing about the listing being complete (the engine has no scope-enumeration read face, so an answer covers only the scopes the caller named and an empty one must never be read as a clean store)';
     }
 }
-export function __resetMemoryOriginReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/memorySpecWire.js

@@ -1,5 +1,5 @@
 import { CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH } from './engineErrorCodes.js';
-import { capForDisplay } from './fleetTaskDesc.js';
+import { escapeDisplayControlChars } from './fleetTaskDesc.js';
 export const KNOWN_AGENT_MEMORY_SPEC_KEYS = Object.freeze([
     'enabled',
     'scopeContract',
@@ -128,7 +128,7 @@ function quotedKeyForDisplay(key) {
     let out = '';
     let truncated = false;
     for (const ch of key) {
-        const tok = ch === '\\' ? '\\\\' : ch === '"' ? '\\"' : capForDisplay(ch, 8);
+        const tok = ch === '\\' ? '\\\\' : ch === '"' ? '\\"' : escapeDisplayControlChars(ch);
         if (out.length + tok.length > MEMORY_SPEC_KEY_DISPLAY_MAX) {
             truncated = true;
             break;

package/dist/modelIdentityResolvability.d.ts

@@ -25,10 +25,10 @@ export interface RemoteEngineModelIdentityReading {
 }
 export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngineModelIdentityReading;
 export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
-export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'proceed';
+export type ModelSetupDecision = 'offer_setup' | 'offer_route_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'explain_route_unconfigurable' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
-export declare function modelSetupDecision(reading: ModelIdentityReading, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupDecision(reading: ModelIdentityReading, hostCanConfigureModel: boolean, hostCanConfigureRoute?: boolean): ModelSetupDecision;
 export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
 export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
 export {};

package/dist/modelIdentityResolvability.js

@@ -1,4 +1,4 @@
-import { engineCapValue } from './engineCapsCache.js';
+import { engineCapsLandingOf } from './engineCapsCache.js';
 import { engineWireTarget } from './engineWireTarget.js';
 function laneOrder() {
     return ['processEnv', 'settingsEnv', 'modelCatalogFile', 'followedSettingsFile', 'followedProviderEnv'];
@@ -178,10 +178,15 @@ export function modelIdentityDetail(reading) {
             return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
     }
 }
-export function modelSetupDecision(reading, hostCanConfigureModel) {
+export function modelSetupDecision(reading, hostCanConfigureModel, hostCanConfigureRoute) {
     const a = analyse(reading);
-    if (a.verdict === 'not_resolvable' && a.why === 'route_gap')
+    if (a.verdict === 'not_resolvable' && a.why === 'route_gap') {
+        if (hostCanConfigureRoute === true)
+            return 'offer_route_setup';
+        if (hostCanConfigureRoute === false)
+            return 'explain_route_unconfigurable';
         return 'explain_route_gap';
+    }
     if (a.verdict !== 'not_resolvable')
         return 'proceed';
     if (hostCanConfigureModel === true)
@@ -196,12 +201,16 @@ export function modelSetupNotice(decision) {
             return 'no model name is configured for the engine, and it does not start without one — opening model setup';
         case 'explain_unconfigured':
             return 'this engine has no model configured, and it cannot be configured from this client — ask whoever runs the engine to set one up';
+        case 'offer_route_setup':
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — opening setup so the route can be set';
         case 'explain_route_gap':
-            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — fix the route; model setup will not help';
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — the route has to be set before the engine can run';
+        case 'explain_route_unconfigurable':
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — the route cannot be set from this client; ask whoever runs the engine to set it';
         default:
             return null;
     }
 }
 export function observedEngineAnswer(baseUrl = engineWireTarget()?.baseUrl) {
-    return engineCapValue(baseUrl, 'version').kind === 'unobserved' ? 'not_observed' : 'answered';
+    return engineCapsLandingOf(baseUrl).kind === 'not_landed' ? 'not_observed' : 'answered';
 }

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, DISPLAY_CAP_BACKOFF_MAX, 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 = DISPLAY_CAP_BACKOFF_MAX + 1;
+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/outputStyleSeatCapability.d.ts

@@ -1,5 +1,7 @@
 export type OutputStyleSeatReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -12,4 +14,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 __resetOutputStyleSeatReadingsForTests(): void;

package/dist/outputStyleSeatCapability.js

@@ -17,7 +17,6 @@ export function projectOutputStyleSeatCapability(caps) {
 const reader = createEngineCapReader({
     name: 'outputStyleSeat',
     project: projectOutputStyleSeatCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForOutputStyleSeat(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -37,6 +36,3 @@ export function outputStyleSeatAdmitted(reading) {
         return false;
     }
 }
-export function __resetOutputStyleSeatReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/ownKey.d.ts

@@ -3,9 +3,11 @@ export declare function readOwnNonEmptyString(v: object | null | undefined, key:
 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;

package/dist/ownKey.js

@@ -25,6 +25,14 @@ export function readOwnDataValue(v, key) {
     const d = Object.getOwnPropertyDescriptor(v, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
+export function guardedRead(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
 export function ownDataField(v, key) {
     return ownField(v, key, false);
 }
@@ -56,6 +64,16 @@ export function readFrameStringKey(frame, key) {
         return undefined;
     }
 }
+export function readFrameTrueMark(frame, key) {
+    try {
+        if (frame === null || frame === undefined || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        return ownDataField(frame, key) === true;
+    }
+    catch {
+        return false;
+    }
+}
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
 export function markMcpSectionDroppedNamedRows(rows, dropped) {
     if (dropped.size === 0)

package/dist/peerFrames.js

@@ -1,4 +1,4 @@
-import { applyDisplayFace, LEGACY_NAME_FACE } from './displayUntrusted.js';
+import { applyDisplayFace, PEER_NAME_FACE } from './displayUntrusted.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS, CORE_PERMISSION_MODE_CLASSES } from './generated/engineFactTables.js';
 const WIRE_KEY_FROM = 'from';
 const WIRE_KEY_BODY = 'body';
@@ -42,14 +42,16 @@ function nonEmptyString(v) {
 function finiteNumber(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
-function provenanceAgrees(n, lane, carrierFrom) {
+function provenanceAgrees(n, lane, carrierFromRaw) {
     const prov = dataProp(n, WIRE_KEY_PROVENANCE);
     if (prov === null || typeof prov !== 'object')
         return false;
     if (dataProp(prov, WIRE_KEY_KIND) !== lane)
         return false;
-    const provFrom = cleanName(dataProp(prov, WIRE_KEY_FROM));
-    if (provFrom === undefined || (carrierFrom !== undefined && provFrom !== carrierFrom))
+    const provFromRaw = dataProp(prov, WIRE_KEY_FROM);
+    if (typeof provFromRaw !== 'string' || cleanName(provFromRaw) === undefined)
+        return false;
+    if (carrierFromRaw !== undefined && provFromRaw !== carrierFromRaw)
         return false;
     const taskId = nonEmptyString(dataProp(n, WIRE_KEY_TASK_ID));
     if (taskId === undefined || nonEmptyString(dataProp(prov, WIRE_KEY_PROV_TASK_ID)) !== taskId)
@@ -61,9 +63,10 @@ export function classifyPeerNotification(n) {
     const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
     const agentMessage = dataProp(n, WIRE_KEY_AGENT_MESSAGE);
     if (agentMessage !== undefined) {
-        const from = cleanName(dataProp(agentMessage, WIRE_KEY_FROM));
+        const fromRaw = dataProp(agentMessage, WIRE_KEY_FROM);
+        const from = cleanName(fromRaw);
         const body = dataProp(agentMessage, WIRE_KEY_BODY);
-        if (from !== undefined && typeof body === 'string' && provenanceAgrees(n, 'agent_message', from)) {
+        if (from !== undefined && typeof fromRaw === 'string' && typeof body === 'string' && provenanceAgrees(n, 'agent_message', fromRaw)) {
             const agentType = nonEmptyString(dataProp(dataProp(n, WIRE_KEY_PROVENANCE), WIRE_KEY_AGENT_TYPE));
             return {
                 lane: 'agent_message',
@@ -77,9 +80,10 @@ export function classifyPeerNotification(n) {
     }
     const crossSessionMessage = dataProp(n, WIRE_KEY_CROSS_SESSION_MESSAGE);
     if (crossSessionMessage !== undefined) {
-        const from = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM));
+        const fromRaw = dataProp(crossSessionMessage, WIRE_KEY_FROM);
+        const from = cleanName(fromRaw);
         const body = dataProp(crossSessionMessage, WIRE_KEY_BODY);
-        if (from === undefined || typeof body !== 'string' || !provenanceAgrees(n, 'cross_session_message', from))
+        if (from === undefined || typeof fromRaw !== 'string' || typeof body !== 'string' || !provenanceAgrees(n, 'cross_session_message', fromRaw))
             return null;
         const fromSession = nonEmptyString(dataProp(crossSessionMessage, WIRE_KEY_FROM_SESSION));
         const fromName = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM_NAME));
@@ -117,7 +121,7 @@ function neutralizeAuthorityTags(text) {
 function cleanName(v) {
     if (typeof v !== 'string')
         return undefined;
-    const t = applyDisplayFace(v, LEGACY_NAME_FACE);
+    const t = applyDisplayFace(v, PEER_NAME_FACE);
     return t.length > 0 ? t : undefined;
 }
 function escapeEnvelopeTag(tag, text) {

package/dist/peerLaneCapability.d.ts

@@ -1,5 +1,7 @@
 export type PeerLaneReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/peerLaneCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectPeerLaneCapability(caps) {
     try {
@@ -21,7 +21,6 @@ export function projectPeerLaneCapability(caps) {
 const reader = createEngineCapReader({
     name: 'peerLane',
     project: projectPeerLaneCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForPeerLane(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -38,6 +37,8 @@ export function peerLaneAvailable(reading) {
 }
 export function peerLaneDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('cross-session lane');
         case 'unobserved':
             return 'cross-session lane not observed — the engine reports it on /v1/capabilities (peerLane); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':