@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/cloudConfigWireCaps.d.ts

@@ -1,18 +1,25 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import type { McpServerSpec } from './mcpWireCaps.js';
 import type { EnvLike } from './hostEnv.js';
+import type { McpEntryKeyIssue } from './generated/settingsSchemaTypes.js';
 export type { McpServerSpec };
 type Rec = Record<string, unknown>;
 export type { EnvLike };
-export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header';
+export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'principal-and-assertion-header' | 'tool-axes-invalid' | 'elicitation-invalid' | 'name-unusable' | 'transport-invalid';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;
+    path?: string;
+}
+export interface CloudMcpDegradedServer {
+    name: string;
+    lost: readonly McpEntryKeyIssue[];
 }
 export interface CloudMcpProjection {
     specs: McpServerSpec[];
     missingEnv: string[];
     droppedServers: CloudMcpDroppedServer[];
+    degradedServers: CloudMcpDegradedServer[];
 }
 export declare function cloudMcpToSpecs(servers: unknown, env: EnvLike): CloudMcpProjection;
 export declare function cloudSkillsToSpecs(manifestSkills: unknown, resolveBody: (contentHash: string) => string | null): SkillSpec[];
@@ -111,6 +118,7 @@ export interface CloudProjection {
     scope: string;
     skillsMissingBody: string[];
     droppedMcpServers: CloudMcpDroppedServer[];
+    degradedMcpServers: CloudMcpDegradedServer[];
     droppedModels: CloudDroppedModel[];
     execution: CloudExecutionProjection;
     effectiveWarnings: CloudEffectiveWarningsReading;
@@ -125,4 +133,5 @@ export interface CloudEffectiveNotice {
 }
 export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'> & {
     readonly mcp?: readonly McpServerSpec[];
+    readonly degradedMcpServers?: readonly CloudMcpDegradedServer[];
 }): CloudEffectiveNotice[];

package/dist/cloudConfigWireCaps.js

@@ -1,10 +1,14 @@
-import { MCP_CAPS, mcpAssertionHeaderNotSentNotice, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
+import { mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.js';
+import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_REQUEST_MCP_TRANSPORT } from './generated/settingsSchemaFns.js';
+import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
 import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
 import { modelsPolicyOf } from './model/modelsPolicy.js';
 import { normalizeEngineBaseUrl } from './engineUrl.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 import { SETTINGS_BUDGET_NUMBER_KEYS, SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS, SETTINGS_BUDGET_STRING_KEYS, SETTINGS_TIER_GROUP_NAME_RE, } from './generated/settingsSchemaTables.js';
 const asRec = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
 const asArr = (v) => (Array.isArray(v) ? v : []);
@@ -13,16 +17,13 @@ export function cloudMcpToSpecs(servers, env) {
     const specs = [];
     const missingEnv = [];
     const droppedServers = [];
-    const drop = (name, reason) => {
-        droppedServers.push({ ...(name ? { name } : {}), reason });
+    const degradedServers = [];
+    const drop = (name, reason, path) => {
+        droppedServers.push({ ...(name ? { name } : {}), reason, ...(path !== undefined ? { path } : {}) });
     };
     for (const raw of asArr(servers)) {
         const s = asRec(raw);
         const name = s ? asStr(s.name) : undefined;
-        if (specs.length >= MCP_CAPS.items) {
-            drop(name, 'capped');
-            continue;
-        }
         if (!s || s.enabled === false) {
             drop(name, s?.enabled === false ? 'disabled' : 'missing-field');
             continue;
@@ -32,77 +33,105 @@ export function cloudMcpToSpecs(servers, env) {
             drop(name, 'missing-field');
             continue;
         }
-        let transport = null;
-        if (t.kind === 'stdio') {
-            const command = asStr(t.command);
-            if (!command) {
-                drop(name, 'missing-field');
-                continue;
-            }
-            const envOut = {};
-            for (const [target, ref] of Object.entries(asRec(t.envRefs) ?? {})) {
+        if (!SETTINGS_IS_USABLE_WIRE_NAME(name)) {
+            drop(name, 'name-unusable');
+            continue;
+        }
+        let candidate;
+        let requiredRaw;
+        const missingHere = [];
+        const resolveRefs = (refs) => {
+            const out = [];
+            for (const [target, ref] of Object.entries(asRec(refs) ?? {})) {
                 const refName = asStr(ref);
                 if (!refName)
                     continue;
                 const v = env[refName];
                 if (v === undefined || v === '')
-                    missingEnv.push(refName);
+                    missingHere.push(refName);
                 else
-                    envOut[target] = v;
+                    out.push([target, v]);
             }
-            const args = asArr(t.args).filter((a) => typeof a === 'string');
-            transport = {
-                kind: 'stdio',
-                command,
-                ...(args.length > 0 ? { args } : {}),
-                ...(Object.keys(envOut).length > 0 ? { env: envOut } : {}),
-            };
-        }
-        else if (t.kind === 'http') {
-            const url = asStr(t.url);
-            if (!url) {
+            return out;
+        };
+        const dropHard = (issue, raw) => {
+            const missing = (issue.path === 'transport.command' || issue.path === 'transport.url') && asStr(raw) === undefined;
+            if (missing)
                 drop(name, 'missing-field');
-                continue;
-            }
-            const identity = readMcpHttpIdentityHeaders(t);
-            if (identity.kind === 'both_set') {
-                drop(name, 'principal-and-assertion-header');
-                continue;
+            else
+                drop(name, 'transport-invalid', issue.path);
+        };
+        try {
+            if (t.kind === 'stdio') {
+                const command = t.command;
+                requiredRaw = command;
+                const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'stdio', command });
+                if (!head.ok) {
+                    dropHard(head.issue, command);
+                    continue;
+                }
+                const envEntries = resolveRefs(t.envRefs);
+                candidate = { kind: 'stdio', command, args: snapshotArgs(t.args), env: envEntries.length > 0 ? Object.fromEntries(envEntries) : undefined };
             }
-            const headers = {};
-            for (const [headerName, ref] of Object.entries(asRec(t.headerRefs) ?? {})) {
-                const refName = asStr(ref);
-                if (!refName)
+            else if (t.kind === 'http') {
+                const url = t.url;
+                requiredRaw = url;
+                const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'http', url });
+                if (!head.ok) {
+                    dropHard(head.issue, url);
                     continue;
-                const v = env[refName];
-                if (v === undefined || v === '')
-                    missingEnv.push(refName);
-                else
-                    headers[headerName] = v;
+                }
+                const principalHeader = t.principalHeader;
+                const assertionHeader = t.assertionHeader;
+                if (readMcpHttpIdentityHeaders({ principalHeader, assertionHeader }).kind === 'both_set') {
+                    drop(name, 'principal-and-assertion-header');
+                    continue;
+                }
+                const headerEntries = resolveRefs(t.headerRefs);
+                candidate = { kind: 'http', url, headers: headerEntries.length > 0 ? Object.fromEntries(headerEntries) : undefined, principalHeader, assertionHeader };
+            }
+            else {
+                drop(name, 'unknown-transport');
+                continue;
             }
-            transport = {
-                kind: 'http',
-                url,
-                ...(Object.keys(headers).length > 0 ? { headers } : {}),
-                ...(identity.principalHeader !== undefined ? { principalHeader: identity.principalHeader } : {}),
-                ...(identity.assertionHeader !== undefined ? { assertionHeader: identity.assertionHeader } : {}),
-            };
         }
-        else {
-            drop(name, 'unknown-transport');
+        catch {
+            drop(name, 'transport-invalid', 'transport');
             continue;
         }
+        const read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
+        if (!read.ok) {
+            dropHard(read.issue, requiredRaw);
+            continue;
+        }
+        missingEnv.push(...missingHere);
+        const transport = wireTransportOf(read.transport);
+        const axesDeclared = s.toolAxes;
+        const axesVerdict = mcpToolAxesVerdict(axesDeclared);
+        if (axesVerdict.kind === 'bad') {
+            drop(name, 'tool-axes-invalid');
+            continue;
+        }
+        const axesShipped = axesVerdict.kind === 'ok' ? axesVerdict.toolAxes : axesDeclared;
+        const elVerdict = mcpElicitationVerdict(s.elicitation);
+        if (elVerdict.kind === 'bad') {
+            drop(name, 'elicitation-invalid');
+            continue;
+        }
+        const allowToolsWritten = Array.isArray(s.allowTools);
         const allowTools = asArr(s.allowTools).filter((a) => typeof a === 'string');
+        if (read.lost.length > 0)
+            degradedServers.push({ name, lost: Object.freeze([...read.lost]) });
         specs.push({
             name,
             transport,
-            ...(allowTools.length > 0 ? { allowTools } : {}),
-            ...(s.elicitation === true ? { elicitation: true } : {}),
+            ...(allowToolsWritten ? { allowTools } : {}),
+            ...(elVerdict.elicitation !== undefined ? { elicitation: elVerdict.elicitation } : {}),
             ...(s.toolFaces !== undefined ? { toolFaces: s.toolFaces } : {}),
-            ...(s.toolAxes !== undefined ? { toolAxes: s.toolAxes } : {}),
+            ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
         });
     }
-    return { specs, missingEnv: [...new Set(missingEnv)], droppedServers };
+    return { specs, missingEnv: [...new Set(missingEnv)], droppedServers, degradedServers };
 }
 export function cloudSkillsToSpecs(manifestSkills, resolveBody) {
     const specs = [];
@@ -553,7 +582,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
     const config = asRec(b.config) ?? {};
     const mcpDomain = asRec(config.mcp);
     const skillsDomain = asRec(config.skills);
-    const { specs: mcp, missingEnv: mcpMissing, droppedServers: droppedMcpServers } = cloudMcpToSpecs(mcpDomain?.servers, env);
+    const { specs: mcp, missingEnv: mcpMissing, droppedServers: droppedMcpServers, degradedServers: degradedMcpServers } = cloudMcpToSpecs(mcpDomain?.servers, env);
     const manifest = asArr(skillsDomain?.skills);
     const skills = cloudSkillsToSpecs(manifest, (hash) => skillBodies[hash] ?? null);
     const skillsMissingBody = manifest
@@ -578,6 +607,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
         scope: asStr(b.scope) ?? 'global',
         skillsMissingBody,
         droppedMcpServers,
+        degradedMcpServers,
         droppedModels: entriesRead === undefined ? [] : cloudModelsDropped({ models: entriesRead }),
         execution: cloudExecutionToPolicy(config.execution),
         effectiveWarnings: effectiveWarningsOf(b),
@@ -654,9 +684,21 @@ const MCP_DROP_SENTENCES = {
         level: 'warn',
         text: (who) => `cloud config: MCP server entries left out because they set both principalHeader and assertionHeader, which name the same identity header — keep only one of the two: ${who}`,
     },
-    capped: {
+    'tool-axes-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudToolAxesInvalid', { who })),
+    },
+    'elicitation-invalid': {
         level: 'warn',
-        text: (who) => `cloud config: MCP server entries left out because more than ${MCP_CAPS.items} were served to you and this client passes at most ${MCP_CAPS.items} to the engine: ${who}`,
+        text: (who) => renderMessage(msg('config.mcp.cloudElicitationInvalid', { who })),
+    },
+    'name-unusable': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudNameUnusable', { who })),
+    },
+    'transport-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudTransportInvalid', { who })),
     },
     disabled: {
         level: 'info',
@@ -666,9 +708,9 @@ const MCP_DROP_SENTENCES = {
 const MCP_DROP_UNRECOGNISED = (who) => `cloud config: MCP server entries left out for a reason this client does not recognise: ${who}`;
 const MCP_DROP_LIST_UNREADABLE = 'cloud config: the list of MCP server entries left out could not be read by this client — servers missing from the local tool list may have been left out without notice';
 const MCP_DROP_NAMES_SHOWN = 5;
-function mcpDropWho(names, unnamed) {
-    const distinct = [...new Set(names)];
-    const parts = distinct.slice(0, MCP_DROP_NAMES_SHOWN).map((n) => `"${n}"`);
+function mcpDropWho(labels, unnamed) {
+    const distinct = [...new Set(labels)];
+    const parts = distinct.slice(0, MCP_DROP_NAMES_SHOWN);
     if (distinct.length > MCP_DROP_NAMES_SHOWN)
         parts.push(`+${distinct.length - MCP_DROP_NAMES_SHOWN} more`);
     if (unnamed > 0)
@@ -706,6 +748,8 @@ function droppedMcpNotices(carrier) {
     catch {
         return listUnreadable;
     }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        return listUnreadable;
     const known = new Map();
     const unrecognised = { names: [], unnamed: 0 };
     for (let i = 0; i < count; i++) {
@@ -716,6 +760,15 @@ function droppedMcpNotices(carrier) {
             return typeof raw === 'string' && Object.hasOwn(MCP_DROP_SENTENCES, raw) ? raw : undefined;
         });
         const name = guarded(() => readOwnDataNonEmptyString(rowObj, 'name'));
+        const path = reason === 'transport-invalid' ? guarded(() => readOwnDataNonEmptyString(rowObj, 'path')) : undefined;
+        const pathLabel = path !== undefined && /^transport(\.[A-Za-z]{1,32})?$/.test(path) ? ` (${path})` : '';
+        const label = name === undefined
+            ? undefined
+            : reason === 'name-unusable'
+                ? SETTINGS_DESCRIBE_BAD_WIRE_NAME(name)
+                : reason === 'transport-invalid'
+                    ? `"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${pathLabel}`
+                    : `"${name}"${pathLabel}`;
         let bucket = unrecognised;
         if (reason !== undefined) {
             let b = known.get(reason);
@@ -723,10 +776,10 @@ function droppedMcpNotices(carrier) {
                 known.set(reason, (b = { names: [], unnamed: 0 }));
             bucket = b;
         }
-        if (name === undefined)
+        if (label === undefined)
             bucket.unnamed++;
         else
-            bucket.names.push(name);
+            bucket.names.push(label);
     }
     const out = [];
     for (const reason of Object.keys(MCP_DROP_SENTENCES)) {
@@ -739,6 +792,68 @@ function droppedMcpNotices(carrier) {
     }
     return out;
 }
+const DEGRADED_LOST_SHOWN = 80;
+const DEGRADED_NAME_SHOWN = 128;
+const LOST_PATH_SHAPE = /^transport(\.[A-Za-z_][A-Za-z0-9_]{0,31}){1,2}$/;
+function degradedLostLabels(rowObj) {
+    const lost = readOwnDataValue(rowObj, 'lost');
+    const out = [];
+    if (!Array.isArray(lost))
+        return out;
+    const n = guarded(() => lost.length) ?? 0;
+    for (let i = 0; i < n; i++) {
+        const one = guarded(() => readOwnDataValue(lost, String(i)));
+        const issue = typeof one === 'object' && one !== null ? one : undefined;
+        const path = guarded(() => readOwnDataNonEmptyString(issue, 'path'));
+        if (path === undefined || !LOST_PATH_SHAPE.test(path))
+            continue;
+        const member = guarded(() => readOwnDataNonEmptyString(issue, 'member'));
+        out.push(member !== undefined && !path.endsWith(`.${member}`) ? `${path} (member "${capForDisplay(member, DEGRADED_LOST_SHOWN)}")` : path);
+    }
+    return [...new Set(out)];
+}
+function degradedMcpNotices(carrier) {
+    const unreadable = [{ level: 'warn', text: renderMessage(msg('config.mcp.cloudTransportDegradedUnreadable')) }];
+    let desc;
+    try {
+        desc = Object.getOwnPropertyDescriptor(carrier, 'degradedMcpServers');
+    }
+    catch {
+        return unreadable;
+    }
+    if (desc === undefined)
+        return [];
+    if (!Object.hasOwn(desc, 'value'))
+        return unreadable;
+    const rows = desc.value;
+    let count = 0;
+    try {
+        if (!Array.isArray(rows))
+            return unreadable;
+        count = rows.length;
+    }
+    catch {
+        return unreadable;
+    }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        return unreadable;
+    const labels = [];
+    let unnamed = 0;
+    for (let i = 0; i < count; i++) {
+        const row = guarded(() => readOwnDataValue(rows, String(i)));
+        const rowObj = typeof row === 'object' && row !== null ? row : undefined;
+        const name = guarded(() => readOwnDataNonEmptyString(rowObj, 'name'));
+        if (name === undefined) {
+            unnamed++;
+            continue;
+        }
+        const paths = guarded(() => degradedLostLabels(rowObj)) ?? [];
+        labels.push(`"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${paths.length > 0 ? ` (${paths.join(', ')})` : ''}`);
+    }
+    if (labels.length + unnamed === 0)
+        return [];
+    return [{ level: 'warn', text: renderMessage(msg('config.mcp.cloudTransportDegraded', { who: mcpDropWho(labels, unnamed) })) }];
+}
 function budgetNotice(r) {
     switch (r.kind) {
         case 'configured': {
@@ -807,6 +922,7 @@ export function cloudEffectiveNotices(p) {
         });
     }
     out.push(...droppedMcpNotices(p));
+    out.push(...degradedMcpNotices(p));
     const assertionLine = mcpAssertionHeaderNotSentNotice(guarded(() => readOwnDataValue(p, 'mcp')) ?? []);
     if (assertionLine !== undefined)
         out.push({ level: 'warn', text: `cloud config: ${assertionLine}` });

package/dist/compactionStatus.d.ts

@@ -0,0 +1,34 @@
+export interface CompactionStatusReading {
+    readonly compacting: boolean;
+    readonly since?: number;
+}
+export type CompactionStatusChange = {
+    readonly kind: 'opened';
+    readonly pass: string;
+    readonly since?: number;
+} | {
+    readonly kind: 'closed';
+    readonly pass: string;
+    readonly result?: 'success' | 'failed';
+    readonly error?: string;
+};
+export interface CompactionStatusTracker {
+    take(input: {} | null | undefined): CompactionStatusChange | null;
+    streamEnded(): CompactionStatusChange | null;
+    reading(): CompactionStatusReading;
+}
+export interface PrintCompactionStatusFrame {
+    readonly type: 'system';
+    readonly subtype: 'status';
+    readonly status: 'compacting' | null;
+    readonly compact_result?: 'success' | 'failed';
+    readonly compact_error?: string;
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export interface PrintCompactionStatusCtx {
+    readonly sessionId: string;
+    readonly mintUuid: () => string;
+}
+export declare function createCompactionStatusTracker(): CompactionStatusTracker;
+export declare function compactionStatusFrameOf(change: CompactionStatusChange | null | undefined, ctx: PrintCompactionStatusCtx): PrintCompactionStatusFrame | null;

package/dist/compactionStatus.js

@@ -0,0 +1,196 @@
+import { readOwnDataValue } from './ownKey.js';
+import { snapshotIsSubFlow, snapshotSegmentIdentity } from './adapter/types.js';
+const _printStatusFramePins = [true, true];
+void _printStatusFramePins;
+const CLOSED_PASS_MEMORY = 1024;
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+const own = (o, key) => (typeof o === 'object' && o !== null ? readOwnDataValue(o, key) : undefined);
+function chromeLane(ev) {
+    const lane = own(own(ev, 'laneProof'), 'lane');
+    if (typeof lane !== 'string' || lane.length === 0)
+        return 'unreadable';
+    return lane === 'main' ? 'main' : 'other';
+}
+function armLane(m) {
+    const snap = snapshotSegmentIdentity(m);
+    if (snap === null)
+        return 'unreadable';
+    return snapshotIsSubFlow(snap) ? 'other' : 'main';
+}
+function openOf(pass, lane, startedAt, trigger) {
+    if (lane === 'unreadable')
+        return null;
+    if (nonEmpty(trigger) === undefined)
+        return null;
+    return { kind: 'open', pass, main: lane === 'main', ...(typeof startedAt === 'number' && Number.isFinite(startedAt) ? { startedAt } : {}) };
+}
+function parse(input) {
+    const plane = own(input, 'plane');
+    if (plane === 'chrome') {
+        const ev = own(input, 'event');
+        return typeof ev === 'object' && ev !== null ? parseChrome(ev) : null;
+    }
+    if (plane === 'transcript') {
+        const msg = own(input, 'message');
+        return typeof msg === 'object' && msg !== null ? parseMessage(msg) : null;
+    }
+    if (own(input, 'kind') !== undefined)
+        return parseChrome(input);
+    return parseMessage(input);
+}
+function parseChrome(ev) {
+    const kind = own(ev, 'kind');
+    const pass = nonEmpty(own(ev, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (kind === 'compaction_started')
+        return openOf(pass, chromeLane(ev), own(ev, 'startedAt'), own(ev, 'trigger'));
+    if (kind === 'compaction_outcome') {
+        const outcome = nonEmpty(own(ev, 'outcome'));
+        const reason = nonEmpty(own(ev, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+function parseMessage(m) {
+    const type = own(m, 'type');
+    if (type === 'system') {
+        if (own(m, 'subtype') !== 'compact_boundary')
+            return null;
+        const pass = nonEmpty(own(own(m, 'compact_metadata'), '_sema_pass'));
+        return pass === undefined ? null : { kind: 'close-landed', pass };
+    }
+    const pass = nonEmpty(own(m, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (type === 'compaction_started')
+        return openOf(pass, armLane(m), own(m, 'startedAt'), own(m, 'trigger'));
+    if (type === 'compaction_outcome') {
+        const outcome = nonEmpty(own(m, 'outcome'));
+        const reason = nonEmpty(own(m, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+export function createCompactionStatusTracker() {
+    const open = new Map();
+    const closed = new Set();
+    const remember = (pass) => {
+        closed.add(pass);
+        if (closed.size > CLOSED_PASS_MEMORY) {
+            const oldest = closed.values().next().value;
+            if (oldest !== undefined)
+                closed.delete(oldest);
+        }
+    };
+    const mainOpen = () => {
+        let n = 0;
+        for (const e of open.values())
+            if (e.main)
+                n++;
+        return n;
+    };
+    const since = () => {
+        let min;
+        for (const e of open.values())
+            if (e.main && e.startedAt !== undefined && (min === undefined || e.startedAt < min))
+                min = e.startedAt;
+        return min;
+    };
+    const reading = () => {
+        if (mainOpen() === 0)
+            return { compacting: false };
+        const s = since();
+        return { compacting: true, ...(s !== undefined ? { since: s } : {}) };
+    };
+    return {
+        take(input) {
+            try {
+                if (typeof input !== 'object' || input === null)
+                    return null;
+                const p = parse(input);
+                if (p === null)
+                    return null;
+                if (p.kind === 'open') {
+                    if (open.has(p.pass) || closed.has(p.pass))
+                        return null;
+                    const before = mainOpen();
+                    open.set(p.pass, { main: p.main === true, ...(p.startedAt !== undefined ? { startedAt: p.startedAt } : {}) });
+                    if (before === 0 && p.main === true) {
+                        const s = since();
+                        return { kind: 'opened', pass: p.pass, ...(s !== undefined ? { since: s } : {}) };
+                    }
+                    return null;
+                }
+                const entry = open.get(p.pass);
+                remember(p.pass);
+                if (entry === undefined)
+                    return null;
+                open.delete(p.pass);
+                if (!entry.main || mainOpen() > 0)
+                    return null;
+                if (p.kind === 'close-landed')
+                    return { kind: 'closed', pass: p.pass, result: 'success' };
+                if (p.outcome === 'failed')
+                    return { kind: 'closed', pass: p.pass, result: 'failed', ...(p.reason !== undefined ? { error: p.reason } : {}) };
+                return { kind: 'closed', pass: p.pass };
+            }
+            catch {
+                return null;
+            }
+        },
+        streamEnded() {
+            try {
+                let lastMain;
+                for (const [pass, e] of open) {
+                    if (e.main)
+                        lastMain = pass;
+                    remember(pass);
+                }
+                const wasCompacting = lastMain !== undefined;
+                open.clear();
+                return wasCompacting ? { kind: 'closed', pass: lastMain } : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        reading() {
+            try {
+                return reading();
+            }
+            catch {
+                return { compacting: false };
+            }
+        },
+    };
+}
+export function compactionStatusFrameOf(change, ctx) {
+    try {
+        if (typeof change !== 'object' || change === null)
+            return null;
+        const sessionId = nonEmpty(own(ctx, 'sessionId'));
+        const mintUuid = own(ctx, 'mintUuid');
+        if (sessionId === undefined || typeof mintUuid !== 'function')
+            return null;
+        const kind = own(change, 'kind');
+        if (kind === 'opened')
+            return { type: 'system', subtype: 'status', status: 'compacting', uuid: String(mintUuid()), session_id: sessionId };
+        if (kind !== 'closed')
+            return null;
+        const result = own(change, 'result');
+        const error = result === 'failed' ? nonEmpty(own(change, 'error')) : undefined;
+        return {
+            type: 'system',
+            subtype: 'status',
+            status: null,
+            ...(result === 'success' || result === 'failed' ? { compact_result: result } : {}),
+            ...(error !== undefined ? { compact_error: error } : {}),
+            uuid: String(mintUuid()),
+            session_id: sessionId,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/controlRouter.d.ts

@@ -1,6 +1,7 @@
 import type { TaskRequest, RunReceipt, CancelAck, Scenario, SteerPriority, AssistantTaskStatus } from '@sema-agent/sdk';
 import { type SteerPriorityReading } from './steerPriorityCapability.js';
 import { type PreemptOutcome } from './preemptWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface RunsResourceLike {
     create(req: TaskRequest, opts?: {
         idempotencyKey?: string | null;
@@ -75,6 +76,7 @@ export interface ErrCodes {
     status?: number | undefined;
 }
 export declare function errCodes(e: unknown): ErrCodes;
+export type SteerHostQueueFact = 'queued_until_turn_end' | 'dropped' | 'unknown';
 export declare function steeringStatusIs4xx(e: object): boolean;
 export interface SteerRefusalAdvice {
     safety: ControlSafetyCode;
@@ -83,8 +85,8 @@ export interface SteerRefusalAdvice {
     nextStep: string;
 }
 export type SteeringRefusedBeforeEngine = SteerRefusalAdvice;
-export declare function steeringRefusedBeforeEngine(e: object): SteeringRefusedBeforeEngine | undefined;
-export declare function steerRefusalAdviceOf(e: object): SteerRefusalAdvice | undefined;
+export declare function steeringRefusedBeforeEngine(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteeringRefusedBeforeEngine | undefined;
+export declare function steerRefusalAdviceOf(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteerRefusalAdvice | undefined;
 export interface SteerBody {
     readonly text: string;
     readonly mode?: 'all' | 'one-at-a-time';