@sema-agent/client-core 0.102.0 → 0.104.0

package/dist/mcpEngineLeg.js

@@ -1,4 +1,4 @@
-import { isMcpLivenessState } from './mcpLiveness.js';
+import { isMcpLivenessState, readMcpAuthorization } from './mcpLiveness.js';
 import { mcpSectionDroppedNamedRowsOf } from './ownKey.js';
 void true;
 void true;
@@ -121,12 +121,15 @@ export function mcpEngineLegConnectionOf(serverName, rows) {
     const errorCode = readKey(row, 'errorCode');
     const delivered = readKey(row, 'delivered');
     const httpStatus = readKey(row, 'httpStatus');
+    const authorization = readMcpAuthorization(row);
+    const authorizationUnreadable = authorization.kind === 'unreadable' || readKey(row, 'authorizationUnreadable') === true;
     return {
         state: 'not_connected',
         cause: 'failed',
         ...(typeof errorCode === 'string' && errorCode !== '' ? { errorCode } : {}),
         ...(typeof delivered === 'string' && delivered !== '' ? { delivered } : {}),
         ...(typeof httpStatus === 'number' && Number.isFinite(httpStatus) ? { httpStatus } : {}),
+        ...(authorization.kind === 'record' ? { authorization: authorization.authorization } : authorizationUnreadable ? { authorizationUnreadable: true } : {}),
     };
 }
 const rosterReadingOf = (v) => {

package/dist/mcpLiveness.d.ts

@@ -1,4 +1,5 @@
 import type { McpLivenessState } from '@sema-agent/sdk';
+import { CORE_MCP_FAILURE_KINDS } from './generated/engineFactTables.js';
 export declare const MCP_LIVENESS_STATES: readonly ["reachable", "unreachable", "unknown"];
 export type { McpLivenessState };
 export declare const isMcpLivenessState: (v: unknown) => v is McpLivenessState;
@@ -28,3 +29,20 @@ export interface McpEngineLegHealth {
 }
 export declare function mcpLivenessRollupOf(rows: readonly McpLivenessBearingRow[] | undefined): McpEngineLegHealth;
 export declare function mcpEngineLegHealthDetail(health: McpEngineLegHealth | undefined): string;
+export declare const MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "unknown"];
+export declare const MCP_AUTHORIZATION_REASONS: readonly ["rejected", "scope", "none"];
+export declare const MCP_FAILURE_UNAUTHORIZED: Extract<(typeof CORE_MCP_FAILURE_KINDS)[number], 'unauthorized'>;
+export interface McpAuthorizationView {
+    readonly reason: string;
+    readonly authorizeUrl?: string;
+    readonly resourceMetadataUrl?: string;
+}
+export type McpAuthorizationCell = {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'record';
+    readonly authorization: McpAuthorizationView;
+};
+export declare function readMcpAuthorization(row: {} | null | undefined): McpAuthorizationCell;

package/dist/mcpLiveness.js

@@ -1,4 +1,4 @@
-import { CORE_MCP_LIVENESS_STATES } from './generated/engineFactTables.js';
+import { CORE_MCP_AUTHORIZATION_REASONS, CORE_MCP_FAILURE_KINDS, CORE_MCP_LIVENESS_STATES } from './generated/engineFactTables.js';
 export const MCP_LIVENESS_STATES = CORE_MCP_LIVENESS_STATES;
 void MCP_LIVENESS_STATES;
 void true;
@@ -100,3 +100,50 @@ export function mcpEngineLegHealthDetail(health) {
                 + ` cannot tell which cause applies)${unreadable}`;
     }
 }
+export const MCP_FAILURE_KINDS = CORE_MCP_FAILURE_KINDS;
+export const MCP_AUTHORIZATION_REASONS = CORE_MCP_AUTHORIZATION_REASONS;
+export const MCP_FAILURE_UNAUTHORIZED = 'unauthorized';
+const ABSENT_AUTHORIZATION = Object.freeze({ kind: 'absent' });
+const UNREADABLE_AUTHORIZATION = Object.freeze({ kind: 'unreadable' });
+function ownDataCell(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return { kind: 'absent' };
+        if (!Object.hasOwn(d, 'value'))
+            return { kind: 'unreadable' };
+        return { kind: 'value', value: d.value };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+const nonEmptyString = (c) => c.kind === 'value' && typeof c.value === 'string' && c.value.length > 0 ? c.value : undefined;
+export function readMcpAuthorization(row) {
+    try {
+        if (!isRecord(row))
+            return UNREADABLE_AUTHORIZATION;
+        const cell = ownDataCell(row, 'authorization');
+        if (cell.kind === 'absent')
+            return ABSENT_AUTHORIZATION;
+        if (cell.kind === 'unreadable' || !isRecord(cell.value))
+            return UNREADABLE_AUTHORIZATION;
+        const rec = cell.value;
+        const reason = nonEmptyString(ownDataCell(rec, 'reason'));
+        if (reason === undefined)
+            return UNREADABLE_AUTHORIZATION;
+        const authorizeUrl = nonEmptyString(ownDataCell(rec, 'authorizeUrl'));
+        const resourceMetadataUrl = nonEmptyString(ownDataCell(rec, 'resourceMetadataUrl'));
+        return Object.freeze({
+            kind: 'record',
+            authorization: Object.freeze({
+                reason,
+                ...(authorizeUrl !== undefined ? { authorizeUrl } : {}),
+                ...(resourceMetadataUrl !== undefined ? { resourceMetadataUrl } : {}),
+            }),
+        });
+    }
+    catch {
+        return UNREADABLE_AUTHORIZATION;
+    }
+}

package/dist/mcpReconnect.d.ts

@@ -1,3 +1,4 @@
+import { type McpAuthorizationView } from './mcpLiveness.js';
 export declare const MCP_RECONNECT_OUTCOMES: readonly string[];
 export declare const MCP_RECONNECT_TRANSACTION_NOTICE: string;
 export declare const MCP_RECONNECT_UNSETTLED_NOTICE: string;
@@ -13,6 +14,8 @@ export interface McpReconnectStatusView {
     };
     error?: string;
     transportClosed?: true;
+    authorization?: McpAuthorizationView;
+    authorizationUnreadable?: true;
 }
 export interface McpReconnectListingIncompleteView {
     reason: string;

package/dist/mcpReconnect.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.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, ' +
     'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
@@ -33,6 +34,11 @@ function projectStatus(raw) {
         view.error = capForDisplay(raw.error, RECONNECT_TEXT_MAX);
     if (raw.transportClosed === true)
         view.transportClosed = true;
+    const authorization = readMcpAuthorization(raw);
+    if (authorization.kind === 'record')
+        view.authorization = authorization.authorization;
+    else if (authorization.kind === 'unreadable')
+        view.authorizationUnreadable = true;
     return view;
 }
 function projectListingIncomplete(raw) {

package/dist/mcpStatusSupersetKeys.js

@@ -1,3 +1,4 @@
+import { readMcpAuthorization } from './mcpLiveness.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
 function slot(input, key) {
     return guardedRead(() => readOwnDataValue(input, key));
@@ -13,6 +14,9 @@ function shellConnectionOf(input) {
         ...(typeof error === 'string' && error !== '' ? { error } : {}),
     });
 }
+const _legStructuralKeysPin = true;
+void _legStructuralKeysPin;
+const AUTHORIZATION_SEATS = new Set(['authorization', 'authorizationUnreadable']);
 function frozenCopyOfEngineLeg(leg) {
     if (typeof leg !== 'object' || leg === null)
         return undefined;
@@ -24,11 +28,30 @@ function frozenCopyOfEngineLeg(leg) {
     catch {
         return undefined;
     }
+    const put = (k, v) => {
+        Object.defineProperty(copy, k, { value: v, enumerable: true, writable: true, configurable: true });
+    };
+    const authorization = readMcpAuthorization(leg);
+    let authorizationPlaced = false;
+    const placeAuthorization = () => {
+        if (authorizationPlaced)
+            return;
+        authorizationPlaced = true;
+        if (authorization.kind === 'record')
+            put('authorization', authorization.authorization);
+        else if (authorization.kind === 'unreadable' || slot(leg, 'authorizationUnreadable') === true)
+            put('authorizationUnreadable', true);
+    };
     for (const k of keys) {
+        if (AUTHORIZATION_SEATS.has(k)) {
+            placeAuthorization();
+            continue;
+        }
         const v = slot(leg, k);
         if (typeof v === 'string' || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v)))
-            Object.defineProperty(copy, k, { value: v, enumerable: true, writable: true, configurable: true });
+            put(k, v);
     }
+    placeAuthorization();
     return typeof copy['state'] === 'string' ? Object.freeze(copy) : undefined;
 }
 export function mcpStatusSupersetKeys(input) {

package/dist/mcpWireCaps.d.ts

@@ -37,7 +37,6 @@ export type McpHttpIdentityHeaders = {
 export declare function readMcpHttpIdentityHeaders(transport: object): McpHttpIdentityHeaders;
 export declare function mcpConfigToSpec(name: string, c: McpConfigLike): McpServerSpec | null;
 export declare function mcpTransportVerdict(entry: McpTransportEntryLike | null | undefined): McpTransportVerdict;
-export declare function mcpConfigsToSpecs(servers: Record<string, McpConfigLike> | undefined): McpServerSpec[];
 export type McpToolAxesVerdict = {
     readonly kind: 'ok';
     readonly toolAxes?: Readonly<Record<string, object>>;
@@ -73,8 +72,8 @@ export type McpAllowToolsVerdict = {
     readonly problem: string;
 };
 export declare function mcpAllowToolsVerdict(read: () => {} | null | undefined, keyPrefix?: string): McpAllowToolsVerdict;
-export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'tool_faces_invalid' | 'elicitation_invalid' | 'allow_tools_invalid' | 'entry_not_object' | 'entry_unreadable';
-export type McpServerNameUnusableReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long';
+export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'tool_faces_invalid' | 'elicitation_invalid' | 'allow_tools_invalid' | 'entry_not_object' | 'entry_unreadable';
+export type McpServerNameUnusableReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved';
 export type McpServerNameVerdict = {
     readonly usable: true;
 } | {

package/dist/mcpWireCaps.js

@@ -1,4 +1,4 @@
-import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_MCP_IDENTITY_HEADERS, SETTINGS_READ_REQUEST_MCP_TRANSPORT, } from './generated/settingsSchemaFns.js';
+import { SETTINGS_DESCRIBE_BAD_MCP_SERVER_NAME, SETTINGS_IS_USABLE_MCP_SERVER_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_MCP_IDENTITY_HEADERS, SETTINGS_READ_REQUEST_MCP_TRANSPORT, } from './generated/settingsSchemaFns.js';
 import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
 import { appendOwnElement, guardedRead } from './ownKey.js';
 import { readMcpToolAxes, readToolFaces } from './coreValuePorts.js';
@@ -173,9 +173,6 @@ export function mcpTransportVerdict(entry) {
 function transportBadVerdict(key, detail) {
     return Object.freeze({ kind: 'bad', key, detail });
 }
-export function mcpConfigsToSpecs(servers) {
-    return projectMcpConfigs(servers).specs;
-}
 export function mcpToolAxesVerdict(declared) {
     if (declared === undefined)
         return Object.freeze({ kind: 'ok' });
@@ -252,11 +249,13 @@ export function mcpAllowToolsVerdict(read, keyPrefix = '') {
         return bad('allowTools', 'config.mcp.allowToolsUnreadable');
     }
 }
-const nameUsable = (name) => SETTINGS_IS_USABLE_WIRE_NAME(name);
+const nameUsable = (name) => SETTINGS_IS_USABLE_MCP_SERVER_NAME(name);
 function mcpNameDropReasonOf(name) {
     if (typeof name !== 'string' || name.trim().length === 0)
         return 'name_blank';
-    return name.trim() !== name ? 'name_edge_whitespace' : 'name_too_long';
+    if (name.trim() !== name)
+        return 'name_edge_whitespace';
+    return SETTINGS_IS_USABLE_WIRE_NAME(name) ? 'name_reserved' : 'name_too_long';
 }
 const _nameReasonsPin = true;
 void _nameReasonsPin;
@@ -316,7 +315,7 @@ function dropNotice(name, reason, problem, opts, path) {
     }
     const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
     const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
-    const badName = () => capForDisplay(SETTINGS_DESCRIBE_BAD_WIRE_NAME(name), DROP_BAD_NAME_SHOWN);
+    const badName = () => capForDisplay(SETTINGS_DESCRIBE_BAD_MCP_SERVER_NAME(name), DROP_BAD_NAME_SHOWN);
     const ref = reason === 'entry_not_object'
         ? msg('config.mcp.entryNotObject', { name: quoted, where })
         : reason === 'entry_unreadable'
@@ -339,7 +338,9 @@ function dropNotice(name, reason, problem, opts, path) {
                                             ? msg('config.mcp.nameCollides', { name: badName(), where })
                                             : reason === 'name_too_long'
                                                 ? msg('config.mcp.nameTooLong', { name: badName(), where })
-                                                : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
+                                                : reason === 'name_reserved'
+                                                    ? msg('config.mcp.nameReserved', { name: badName(), where })
+                                                    : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
     return renderMessage(ref, opts?.lang);
 }
 function degradedNotice(name, lost, opts) {
@@ -436,6 +437,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.134.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.139.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

@@ -38,10 +38,17 @@ export declare function scopeExternalOriginVerdict(reading: MemoryExportReading,
     originAware: boolean;
 }): ScopeExternalOriginVerdict;
 export type { MemoryErasedBinding };
+export type MemoryErasedBindingReading = Exclude<MemoryErasedBinding, {
+    state: 'bound';
+}> | (Omit<Extract<MemoryErasedBinding, {
+    state: 'bound';
+}>, 'slug'> & {
+    slug?: string;
+});
 export interface MemoryErasedRow {
     id: string;
     rev: string;
-    binding: MemoryErasedBinding | null;
+    binding: MemoryErasedBindingReading | null;
 }
 export interface MemoryEraseNotFoundRow {
     id: string;
@@ -54,6 +61,31 @@ export interface MemoryEraseConflictRow {
     id: string;
     reason: string;
 }
+declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
+export type MemoryEraseCarrierClass = (typeof MEMORY_ERASE_CARRIER_CLASSES)[number];
+export type MemoryEraseCarrierReading = {
+    removed: number;
+    remaining: number;
+} | {
+    unverified: true;
+};
+declare const ERASE_REPLAY_OF_LANE: Readonly<{
+    readonly journal: "converges";
+    readonly none: "unsupported";
+}>;
+export interface MemoryEraseResidualsReading {
+    carriers: Record<MemoryEraseCarrierClass, MemoryEraseCarrierReading>;
+    replay: (typeof ERASE_REPLAY_OF_LANE)[keyof typeof ERASE_REPLAY_OF_LANE];
+    propagation: 'local-store-only';
+}
+export type MemoryErasePartialCause = {
+    kind: 'entries_pending';
+} | {
+    kind: 'carriers_residual';
+    carriers: MemoryEraseCarrierClass[];
+} | {
+    kind: 'unknown';
+};
 export type MemoryEraseUnreadableCause = 'body_unreadable' | 'envelope_absent' | 'version_absent' | 'unsupported_version' | 'envelope_unreadable' | 'too_many_rows' | 'erased_rows_unreadable' | 'not_found_rows_unreadable' | 'conflict_rows_unreadable' | 'erased_previously_rows_unreadable';
 export type MemoryEraseReceiptReading = {
     kind: 'malformed';
@@ -73,6 +105,8 @@ export type MemoryEraseReceiptReading = {
     erasedPreviouslyDropped: number;
     conflicts: MemoryEraseConflictRow[];
     conflictsDropped: number;
+    residuals: MemoryEraseResidualsReading | null;
+    partialCause: MemoryErasePartialCause | null;
 };
 export declare function readMemoryEraseReceipt(body: unknown): MemoryEraseReceiptReading;
 export type MemoryEraseCounts = {

package/dist/memoryEntriesWire.js

@@ -38,12 +38,6 @@ function snapshotArray(v) {
     }
     return { items, unreadable, tooLarge: false };
 }
-function arrayLengthOrNull(v) {
-    const snap = snapshotArray(v);
-    if (snap === null || snap.tooLarge)
-        return null;
-    return snap.items.length + snap.unreadable;
-}
 function originMarkOf(row) {
     if (ownPresent(row, 'origin'))
         return 'marked';
@@ -175,7 +169,24 @@ export function scopeExternalOriginVerdict(reading, asked) {
     }
     return { kind: 'none_in_this_scope', scope: reading.scope };
 }
-const MEMORY_ERASE_RECEIPT_VERSION = 1;
+const MEMORY_ERASE_CARRIER_CLASSES = Object.freeze([
+    'projection',
+    'shadow',
+    'indexLine',
+    'quarantineCopy',
+    'planArchive',
+    'planWorkbook',
+    'evidenceBinding',
+    'backendDerived',
+]);
+const MEMORY_ERASE_CARRIER_CLASS_SET = new Set(MEMORY_ERASE_CARRIER_CLASSES);
+const ERASE_REPLAY_OF_LANE = Object.freeze({ journal: 'converges', none: 'unsupported' });
+const _eraseResidualsPin = true;
+void _eraseResidualsPin;
+const ERASE_RECEIPT_VERSIONS = new Map([
+    [1, Object.freeze({ boundSlug: 'required', carrierTable: false })],
+    [2, Object.freeze({ boundSlug: 'optional', carrierTable: true })],
+]);
 function eraseStatusOf(v) {
     return v === 'complete' || v === 'partial' ? v : null;
 }
@@ -185,7 +196,7 @@ function eraseEvidenceCapabilityOf(v) {
 function eraseCustodyStateOf(v) {
     return v === 'complete' || v === 'damaged' || v === 'capability-absent' ? v : null;
 }
-function erasedBindingOf(v) {
+function erasedBindingOf(v, slugRule) {
     if (!plainObject(v))
         return null;
     const state = v.state;
@@ -194,10 +205,75 @@ function erasedBindingOf(v) {
     if (state !== 'bound')
         return null;
     const scope = v.scope;
+    if (!nonEmptyString(scope))
+        return null;
+    const slugPresent = Object.hasOwn(v, 'slug');
+    if (!slugPresent)
+        return slugRule === 'optional' ? { state: 'bound', scope } : null;
     const slug = v.slug;
-    if (!nonEmptyString(scope) || !nonEmptyString(slug))
+    return nonEmptyString(slug) ? { state: 'bound', scope, slug } : null;
+}
+function carrierAnswerOf(v) {
+    if (!plainObject(v))
+        return null;
+    const unverified = readThrownSlot(v, 'unverified', 'data');
+    const removed = readThrownSlot(v, 'removed', 'data');
+    const remaining = readThrownSlot(v, 'remaining', 'data');
+    if (unverified !== undefined)
+        return unverified === true && removed === undefined && remaining === undefined ? { unverified: true } : null;
+    return nonNegativeInt(removed) && nonNegativeInt(remaining) ? { removed, remaining } : null;
+}
+function eraseResidualsOf(o, lane) {
+    try {
+        const raw = readThrownSlot(o, 'residuals', 'data');
+        if (!plainObject(raw))
+            return null;
+        const rawCarriers = readThrownSlot(raw, 'carriers', 'data');
+        const replay = readThrownSlot(raw, 'replay', 'data');
+        const propagation = readThrownSlot(raw, 'propagation', 'data');
+        if (!plainObject(rawCarriers) || replay !== ERASE_REPLAY_OF_LANE[lane] || propagation !== 'local-store-only')
+            return null;
+        if (Reflect.ownKeys(rawCarriers).some((k) => typeof k !== 'string' || !MEMORY_ERASE_CARRIER_CLASS_SET.has(k)))
+            return null;
+        const carriers = {};
+        for (const cls of MEMORY_ERASE_CARRIER_CLASSES) {
+            const answer = carrierAnswerOf(readThrownSlot(rawCarriers, cls, 'data'));
+            if (answer === null)
+                return null;
+            carriers[cls] = answer;
+        }
+        return { carriers, replay: ERASE_REPLAY_OF_LANE[lane], propagation };
+    }
+    catch {
         return null;
-    return { state: 'bound', scope, slug };
+    }
+}
+function erasePartialCauseOf(f) {
+    if (f.status === 'complete')
+        return null;
+    if (f.conflicts.length > 0)
+        return { kind: 'entries_pending' };
+    if (f.dropped > 0 || f.pinnedIds === null)
+        return { kind: 'unknown' };
+    const claimed = new Set([...f.erased.map((r) => r.id), ...(f.erasedPreviously ?? []).map((r) => r.id)]);
+    const notFound = new Set(f.notFound.map((r) => r.id));
+    let historyUnknown = false;
+    for (const id of f.pinnedIds) {
+        if (claimed.has(id))
+            continue;
+        if (!notFound.has(id))
+            return { kind: 'entries_pending' };
+        if (f.custodyState !== 'complete')
+            historyUnknown = true;
+    }
+    if (historyUnknown || f.residuals === null)
+        return { kind: 'unknown' };
+    const carriers = f.residuals.carriers;
+    const residual = MEMORY_ERASE_CARRIER_CLASSES.filter((c) => {
+        const a = carriers[c];
+        return 'unverified' in a || a.remaining > 0;
+    });
+    return residual.length > 0 ? { kind: 'carriers_residual', carriers: residual } : { kind: 'unknown' };
 }
 export function readMemoryEraseReceipt(body) {
     let o;
@@ -229,8 +305,10 @@ export function readMemoryEraseReceipt(body) {
         return { kind: 'malformed', why: 'envelope_absent' };
     if (rawV === undefined)
         return { kind: 'malformed', why: 'version_absent' };
-    if (rawV !== MEMORY_ERASE_RECEIPT_VERSION)
+    const rule = ERASE_RECEIPT_VERSIONS.get(rawV);
+    if (rule === undefined)
         return { kind: 'malformed', why: 'unsupported_version' };
+    const slugRule = rule.boundSlug;
     const status = eraseStatusOf(rawStatus);
     const evidenceCapability = eraseEvidenceCapabilityOf(rawEvidence);
     const custodyState = eraseCustodyStateOf(rawCustody);
@@ -241,13 +319,13 @@ export function readMemoryEraseReceipt(body) {
     let notFoundSnap;
     let conflictsSnap;
     let previouslySnap;
-    let selectedIds;
+    let selectedSnap;
     try {
         erasedSnap = snapshotArray(rawErased);
         notFoundSnap = snapshotArray(rawNotFound);
         conflictsSnap = snapshotArray(rawConflicts);
         previouslySnap = rawPreviously === undefined ? null : snapshotArray(rawPreviously);
-        selectedIds = arrayLengthOrNull(rawSelected);
+        selectedSnap = snapshotArray(rawSelected);
     }
     catch {
         return { kind: 'malformed', why: 'body_unreadable' };
@@ -255,6 +333,10 @@ export function readMemoryEraseReceipt(body) {
     if (erasedSnap === null || notFoundSnap === null || conflictsSnap === null) {
         return { kind: 'malformed', why: 'envelope_unreadable' };
     }
+    const selectedIds = selectedSnap === null || selectedSnap.tooLarge ? null : selectedSnap.items.length + selectedSnap.unreadable;
+    const pinnedIds = selectedSnap !== null && !selectedSnap.tooLarge && selectedSnap.unreadable === 0 && selectedSnap.items.every(nonEmptyString)
+        ? selectedSnap.items
+        : null;
     if (rawPreviously !== undefined && previouslySnap === null) {
         return { kind: 'malformed', why: 'envelope_unreadable' };
     }
@@ -277,7 +359,7 @@ export function readMemoryEraseReceipt(body) {
                 continue;
             }
             erasedSeen.add(id);
-            erased.push({ id, rev, binding: erasedBindingOf(item.binding) });
+            erased.push({ id, rev, binding: erasedBindingOf(item.binding, slugRule) });
         }
         catch {
             erasedDropped++;
@@ -367,6 +449,18 @@ export function readMemoryEraseReceipt(body) {
         }
         erasedPreviously = rows;
     }
+    const residuals = rule.carrierTable ? eraseResidualsOf(o, evidenceCapability) : null;
+    const partialCause = erasePartialCauseOf({
+        status,
+        custodyState,
+        pinnedIds,
+        erased,
+        erasedPreviously,
+        notFound,
+        conflicts,
+        dropped: erasedDropped + notFoundDropped + erasedPreviouslyDropped + conflictsDropped,
+        residuals,
+    });
     return {
         kind: 'present',
         requestId: rawRequestId,
@@ -382,6 +476,8 @@ export function readMemoryEraseReceipt(body) {
         erasedPreviouslyDropped,
         conflicts,
         conflictsDropped,
+        residuals,
+        partialCause,
     };
 }
 export function memoryEraseCounts(reading) {

package/dist/modsFace.js

@@ -2,7 +2,7 @@ import { modRowsOf } from './adapter/downstream/wiringManifestView.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { WIRE_FAILURE_UNRENDERABLE_TEXT, wireFailureTextsOf } from './wireFailureShape.js';
-import { gateOutcomeOf, isDeniedGate } from './gateOutcome.js';
+import { gateOutcomeOf, isDeniedGate, rewriteExtensionNamesOf, toolInputRewriteOf } from './gateOutcome.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf } from './ownKey.js';
 const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export const MOD_LOADER_VERBS = Object.freeze(['list', 'load', 'unload', 'status']);
@@ -31,8 +31,12 @@ export function modCardSentence(input, lang) {
             return undefined;
         if (toolResultBlockOf(input) !== undefined) {
             const by = readOwnDataNonEmptyString(input, '_sema_answered_by');
-            if (by === undefined)
-                return undefined;
+            if (by === undefined) {
+                const names = rewriteExtensionNamesOf(toolInputRewriteOf({ rewrite: readOwnDataValue(input, '_sema_rewrite') }));
+                if (names.length === 0)
+                    return undefined;
+                return renderMessage(msg('config.mods.rewrite.inputBy', { by: names.map(shownName).join(', ') }), lang);
+            }
             const gate = gateOutcomeOf({ gate: readOwnDataValue(input, '_sema_gate') });
             return isDeniedGate(gate)
                 ? renderMessage(msg('config.mods.refusal.by', { by: shownName(by) }), lang)

package/dist/postureKnob.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-export const POSTURE_SOURCE_WORDS = Object.freeze(['env', 'center', 'posture', 'engine-default']);
+export const POSTURE_SOURCE_WORDS = Object.freeze(['env', 'center', 'lane', 'posture', 'engine-default']);
 export function postureSourceIsOperatorPinned(source) {
     return source === 'env' || source === 'center';
 }

package/dist/prepareRefusal.d.ts

@@ -6,4 +6,3 @@ export interface PrepareRefusalNoteFacts {
 }
 export declare function prepareRefusalNoteOf(code: string | undefined, facts?: PrepareRefusalNoteFacts): string | undefined;
 export declare function prepareRefusalCodeOf(failure: {} | null | undefined): PrepareRefusalCode | undefined;
-export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;

package/dist/prepareRefusal.js

@@ -85,6 +85,3 @@ export function prepareRefusalCodeOf(failure) {
         return undefined;
     }
 }
-export function imageInvalidFailureNoteOf(code) {
-    return code === CONFIG_IMAGE_INVALID ? prepareRefusalNoteOf(code) : undefined;
-}

package/dist/printModelStatus.d.ts

@@ -20,6 +20,7 @@ export interface PrintModelStatusPayload {
     readonly elapsed_ms?: number;
     readonly timeout_ms?: number;
     readonly model?: string;
+    readonly seat?: string;
     readonly phase: RetryStatusNotice['phase'];
     readonly recourse?: NonNullable<RetryStatusNotice['recourse']>;
     readonly message: string;

package/dist/printModelStatus.js

@@ -41,6 +41,7 @@ function modelStatusPayload(status, ctx) {
         ...(elapsed !== undefined ? { elapsed_ms: elapsed } : {}),
         ...(ceiling !== undefined ? { timeout_ms: ceiling } : {}),
         ...(model !== undefined ? { model } : {}),
+        ...(typeof status.seat === 'string' ? { seat: status.seat } : {}),
         phase: notice.phase,
         ...(notice.recourse !== undefined ? { recourse: notice.recourse } : {}),
         message: notice.line,
@@ -49,6 +50,8 @@ function modelStatusPayload(status, ctx) {
 function apiRetryKeyOf(status) {
     const terminal = 'terminal' in status && status.terminal === true;
     const ok = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+    if (status.seat !== undefined)
+        return null;
     if (status.kind === 'waiting' || terminal || !ok(status.attempt) || !ok(status.maxRetries))
         return null;
     return `${String(status.attempt)}/${String(status.maxRetries)}/${String(status.errClass ?? '')}/${String(status.errorStatus ?? '')}`;
@@ -126,12 +129,13 @@ export function createPrintModelStatusTracker() {
                     clear();
                     return null;
                 }
-                const model = readOwnDataNonEmptyString(ctx, 'model');
+                const model = status.seat === undefined ? readOwnDataNonEmptyString(ctx, 'model') : undefined;
                 const key = apiRetryKeyOf(status);
                 const refresh = key !== null && key === lastApiRetryKey;
                 const safeCtx = { sessionId, nowMs, mintUuid, ...(model !== undefined ? { model } : {}) };
                 const frame = statusFrameOf(status, safeCtx, mintUuid(), refresh);
-                lastApiRetryKey = key;
+                if (status.seat === undefined)
+                    lastApiRetryKey = key;
                 last = { status, model };
                 return frame;
             }

package/dist/promptProfileWireCaps.d.ts

@@ -1,4 +1,2 @@
-import type { TaskRequest } from '@sema-agent/sdk';
 import { type EnvLike } from './hostEnv.js';
-export type PromptProfile = NonNullable<TaskRequest['promptProfile']>;
-export declare function promptProfileFromEnv(env?: EnvLike): PromptProfile | undefined;
+export declare function promptLeanFromEnv(env?: EnvLike): false | undefined;

package/dist/promptProfileWireCaps.js

@@ -1,7 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 const PROMPT_PROFILE_ENV = 'SEMA_PROMPT_PROFILE';
-export function promptProfileFromEnv(env = hostEnv()) {
+export function promptLeanFromEnv(env = hostEnv()) {
     const raw = env[PROMPT_PROFILE_ENV];
     const s = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
-    return s === 'simple' || s === 'classic' ? s : undefined;
+    return s === 'classic' ? false : undefined;
 }

package/dist/request/taskRequest.d.ts

@@ -39,7 +39,7 @@ export interface TaskRequestInput {
     selfOrchestration?: boolean;
     deferTools?: readonly string[];
     retainBackgroundProcesses?: boolean;
-    promptProfile?: string;
+    promptLean?: boolean;
     enableFork?: boolean;
     attachments?: Record<string, unknown>;
     attachmentIds?: readonly string[];