@sema-agent/client-core 0.104.1 → 0.105.0

package/dist/hostSettingsSource.d.ts

@@ -121,7 +121,7 @@ export interface HostSettingsAdoption {
     };
     readonly overflow?: true;
 }
-export declare function adoptHostSettingsRead(read: HostSettingsRead, session: HostSettingsSession, allowAdmitted?: (layer: AdoptedLayer) => boolean): HostSettingsAdoption;
+export declare function adoptHostSettingsRead(read: HostSettingsRead, session: HostSettingsSession, allowAdmitted?: (layer: AdoptedLayer) => boolean, layeredRules?: boolean): HostSettingsAdoption;
 export type ManagedCommitVerdict = 'proceed' | 'refuse';
 export type ManagedRuleScopeVerdict = 'all-sources' | 'by-switch' | 'degrade';
 export type ManagedHooksRestrictionVerdict = 'use-read' | 'held-restrictions' | 'withhold';

package/dist/hostSettingsSource.js

@@ -524,7 +524,7 @@ function overflowOf(read, session) {
     return Object.freeze({ read, session: remintSameContent(session), trusted: false, clean: false, extraTighten: NO_EXTRA, allowByLayer: emptyByLayer(), overflow: true });
 }
 const carrierKeysOf = (read, layer) => read.layers[layer].carriers.map((c) => c.id);
-export function adoptHostSettingsRead(read, session, allowAdmitted = () => true) {
+export function adoptHostSettingsRead(read, session, allowAdmitted = () => true, layeredRules = false) {
     const B = session.baseline;
     const stackIssues = ADOPTED_LAYERS.flatMap((l) => read.layers[l].issues.map((x) => `${l}|${x}`));
     const loadedNow = ADOPTED_LAYERS.flatMap((l) => read.layers[l].malformed ? [] : read.layers[l].carriers.filter((c) => LOADED.has(c.status) || (c.status === 'empty' && c.emptyKind === 'empty-object')).map((c) => `${l}|${c.id}`));
@@ -627,9 +627,13 @@ export function adoptHostSettingsRead(read, session, allowAdmitted = () => true)
         effectiveLayers[l] = l === 'policySettings' ? snap : Object.freeze({ ...snap, doc: base.docs[l] });
     }
     const effective = Object.freeze({ ...read, layers: Object.freeze(effectiveLayers), current: read, debug: Object.freeze([]) });
-    const sentNow = (bucket) => new Set([...ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(base.docs[l], bucket)), ...extraTighten[bucket].map((r) => r.rule)]);
-    const readNow = (bucket) => new Set(ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(read.layers[l].doc, bucket)));
-    const drop = (bucket) => Object.freeze([...sentNow(bucket)].filter((r) => !readNow(bucket).has(r)).sort());
+    const idOf = (layer, rule) => (layeredRules ? JSON.stringify([layer, rule]) : rule);
+    const sentNow = (bucket) => [...ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(base.docs[l], bucket).map((rule) => ({ layer: l, rule }))), ...extraTighten[bucket]];
+    const readNow = (bucket) => new Set(ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(read.layers[l].doc, bucket).map((rule) => idOf(l, rule))));
+    const drop = (bucket) => {
+        const now = readNow(bucket);
+        return Object.freeze([...new Set(sentNow(bucket).filter((r) => !now.has(idOf(r.layer, r.rule))).map((r) => r.rule))].sort());
+    };
     const wouldDrop = Object.freeze({ deny: drop('deny'), ask: drop('ask') });
     const acceptable = !stackIssues.some((x) => !base.issues.includes(x)) && !anyMalformed && !ADOPTED_LAYERS.some((l) => read.layers[l].carriers.some((c) => c.status === 'unreadable' || c.status === 'not-loaded'));
     const s = mintHostSettingsSession(parentVersionOf(session), session.consented, baseline);

package/dist/hostTurnSettings.d.ts

@@ -8,7 +8,7 @@ import { type HostSettingsSession, type HostSettingsSource } from './hostSetting
 import { type SubmissionIdentity } from './request/submissionIdentity.js';
 import { type WebSearchApiKeyFor } from './webSearchWireCaps.js';
 import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
-import type { PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
+import { type PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
 export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle", "memory", "fileHistory"];
 export type HostSuppliedKey = (typeof HOST_SUPPLIED_KEYS)[number];
 export declare const HOST_SETTING_CAUSES: readonly ["carried", "entries_dropped", "source_rejected", "projection_failed", "source_unreadable", "empty", "no_source", "host_port_missing", "value_malformed", "held_previous", "policy_withheld"];

package/dist/hostTurnSettings.js

@@ -10,6 +10,7 @@ import { fileHistoryTightenVerdict, fileHistoryUnjudgedRefusal } from './fileHis
 import { msg, renderMessage } from './i18n/translate.js';
 import { newRulePortsProjection, projectPermissionsDeclaration, rulePortsMissingOf, WIRE_RULE_TRUST_ORDER } from './permissionsDeclaration.js';
 import { assemblyRefusalOf } from './wireFailureShape.js';
+import { permissionRuleLayersOn } from './permissionsAllowGrantCapability.js';
 import { layerAdmitted } from './settingsLayerAdmission.js';
 import { appendOwnElement, ownDataField } from './ownKey.js';
 export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
@@ -388,15 +389,15 @@ function allowAdmittedFor(read) {
 function badPermissionsSource() {
     return new HostSourceShapeError(`hostTurnSettings: sources.resolved must be 'none' or { allowGrantReading, cliArg?, session?, clientOwnedServers?, serverVersion? } — since 0.101.0 the permission rules of the settings files come from the settings the entry reads; do not pass snapshot — got something else (the value is not echoed).`);
 }
-function permissionsArm(src, side, adoption) {
+function readPermissionSource(src) {
     const key = 'settings.resolved';
     if (src.kind === 'missing')
-        return missingArm(key);
+        return { kind: 'arm', arm: missingArm(key) };
     if (src.kind === 'threw')
-        return unreadableArm(key);
+        return { kind: 'arm', arm: unreadableArm(key) };
     const v = src.value;
     if (v === 'none')
-        return noSourceArm(key);
+        return { kind: 'arm', arm: noSourceArm(key) };
     let allowGrantReading;
     let cliAllow;
     let cliDeny;
@@ -415,7 +416,7 @@ function permissionsArm(src, side, adoption) {
         const se = ownDataOf(v, 'session');
         const o = ownDataOf(v, 'clientOwnedServers');
         if (!g.ok || !c.ok || !se.ok || !o.ok)
-            return unreadableArm(key);
+            return { kind: 'arm', arm: unreadableArm(key) };
         allowGrantReading = g.value;
         const cv = c.value;
         const sv = se.value;
@@ -428,7 +429,7 @@ function permissionsArm(src, side, adoption) {
         const sd = sv === undefined ? { ok: true, value: undefined } : ownDataOf(sv, 'deny');
         const sa = sv === undefined ? { ok: true, value: undefined } : ownDataOf(sv, 'ask');
         if (!ca.ok || !cd.ok || !sd.ok || !sa.ok)
-            return unreadableArm(key);
+            return { kind: 'arm', arm: unreadableArm(key) };
         cliAllow = stringListOf(ca.value);
         cliDeny = stringListOf(cd.value);
         sesDeny = stringListOf(sd.value);
@@ -439,16 +440,32 @@ function permissionsArm(src, side, adoption) {
     catch (e) {
         if (e instanceof HostSourceShapeError)
             throw e;
-        return unreadableArm(key);
+        return { kind: 'arm', arm: unreadableArm(key) };
     }
     if (cliAllow === undefined || cliDeny === undefined || sesDeny === undefined || sesAsk === undefined || (owned === undefined && ownedRaw !== undefined))
         throw badPermissionsSource();
+    return { kind: 'facts', allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned, serverVersion };
+}
+function permissionsArm(facts, side, adoption, layered) {
+    const key = 'settings.resolved';
+    if (facts.kind === 'arm')
+        return facts.arm;
+    const { allowGrantReading, cliAllow, cliDeny, sesDeny, sesAsk, owned, serverVersion } = facts;
     if (side.kind === 'missing')
         return missingArm(key);
     const buckets = { deny: [], ask: [], allow: [] };
     const origins = { deny: new Map(), ask: new Map(), allow: new Map() };
     const rank = (o) => WIRE_RULE_TRUST_ORDER.indexOf(o);
+    const contributions = { deny: [], ask: [] };
+    const contributed = { deny: new Set(), ask: new Set() };
     const add = (bucket, rule, origin) => {
+        if (bucket !== 'allow') {
+            const k = JSON.stringify([origin, rule]);
+            if (!contributed[bucket].has(k)) {
+                contributed[bucket].add(k);
+                appendOwnElement(contributions[bucket], freeze({ rule, origin }));
+            }
+        }
         const prev = origins[bucket].get(rule);
         if (prev === undefined) {
             appendOwnElement(buckets[bucket], rule);
@@ -504,7 +521,7 @@ function permissionsArm(src, side, adoption) {
     let declared;
     if (projectionError === undefined) {
         try {
-            const d = projectPermissionsDeclaration({ deny: buckets.deny, ask: buckets.ask, allow: buckets.allow, origins, cliDeny, settingsRead: 'clean', ...(owned !== undefined && owned.length > 0 ? { clientOwnedServers: owned } : {}), ...(serverVersion !== undefined ? { serverVersion } : {}) }, allowGrantReading, portsProjection);
+            const d = projectPermissionsDeclaration({ deny: buckets.deny, ask: buckets.ask, allow: buckets.allow, origins, cliDeny, settingsRead: 'clean', ...(owned !== undefined && owned.length > 0 ? { clientOwnedServers: owned } : {}), ...(serverVersion !== undefined ? { serverVersion } : {}) }, allowGrantReading, portsProjection, layered ? freeze({ deny: freeze([...contributions.deny]), ask: freeze([...contributions.ask]) }) : undefined);
             declared = d.permissions !== undefined ? { permissions: d.permissions } : undefined;
         }
         catch (error) {
@@ -615,10 +632,12 @@ export function buildHostTurnSettings(input, judges) {
     if (rawSide.kind === 'read')
         for (const line of rawSide.read.debug)
             hostLog('debug', line);
-    const adoption = rawSide.kind === 'read' ? adoptHostSettingsRead(rawSide.read, session, allowAdmittedFor(rawSide.read)) : undefined;
+    const permissionSource = readPermissionSource(read('resolved'));
+    const layeredRules = permissionSource.kind === 'facts' && permissionRuleLayersOn(permissionSource.allowGrantReading);
+    const adoption = rawSide.kind === 'read' ? adoptHostSettingsRead(rawSide.read, session, allowAdmittedFor(rawSide.read), layeredRules) : undefined;
     const side = adoption !== undefined ? { kind: 'read', read: adoption.read } : rawSide;
     const nextSession = adoption?.session ?? remintSameContent(session);
-    const resolvedArm = permissionsArm(read('resolved'), side, adoption);
+    const resolvedArm = permissionsArm(permissionSource, side, adoption, layeredRules);
     let resolvedCarried = resolvedArm.carried;
     let resolvedError;
     if (resolvedCarried !== undefined) {

package/dist/i18n/messages.en.d.ts

@@ -187,6 +187,8 @@ declare const EN: {
     'config.mcp.nameReserved': string;
     'config.mcp.identityHeadersBothSet': string;
     'config.mcp.transportUnreadable': string;
+    'config.mcp.transportNotAdvertised': string;
+    'config.mcp.transportsNone': string;
     'config.mcp.transportInvalid': string;
     'config.mcp.transportDegraded': string;
     'config.mcp.toolAxesInvalid': string;
@@ -547,6 +549,13 @@ declare const EN: {
     'session.fileHistoryRefusal.notSaid': string;
     'session.fileHistoryRefusal.unrecognized': string;
     'session.fileHistoryRefusal.unreadable': string;
+    'session.memoryErase.personalStoreUnjudged': string;
+    'session.memorySync.parked.one': string;
+    'session.memorySync.parked.other': string;
+    'session.memorySync.parkedUnnamed.one': string;
+    'session.memorySync.parkedUnnamed.other': string;
+    'session.memorySync.wayOut.deleteCursor': string;
+    'session.memorySync.wayOut.unrecognized': string;
     'session.hostSettings.memorySwitchMalformed': string;
     'session.hostSettings.fileHistoryRestoreConflict': string;
     'session.hostSettings.projectionUnchecked': string;
@@ -670,6 +679,18 @@ declare const EN: {
     'session.steerRefusal.advice': string;
     'session.steerRefusal.hostQueue.queued': string;
     'session.steerRefusal.hostQueue.dropped': string;
+    'session.permissionModeSwitch.applied': string;
+    'session.permissionModeSwitch.folded': string;
+    'session.permissionModeSwitch.reason.entryFloor': string;
+    'session.permissionModeSwitch.reason.disableAutoMode': string;
+    'session.permissionModeSwitch.reason.engine': string;
+    'session.permissionModeSwitch.notPersisted': string;
+    'session.permissionModeSwitch.notRunning': string;
+    'session.permissionModeSwitch.notFound': string;
+    'session.permissionModeSwitch.refused': string;
+    'session.permissionModeSwitch.refusedWithCode': string;
+    'session.permissionModeSwitch.unconfirmed': string;
+    'session.permissionModeSwitch.unavailable': string;
     'notice.capability.subject.userInvokedSkills': string;
     'notice.capability.subject.skillToolLists': string;
     'notice.capability.subject.permissionRulesWrite': string;
@@ -1053,6 +1074,35 @@ declare const EN: {
     'config.mods.refusal.by': string;
     'config.mods.rewrite.resultInPlace': string;
     'config.mods.rewrite.inputBy': string;
+    'follow.notFollowed.headRun': string;
+    'follow.notFollowed.headTurn': string;
+    'follow.notFollowed.reason.exhaustedDraining': string;
+    'follow.notFollowed.reason.exhaustedConnectionLost': string;
+    'follow.notFollowed.reason.exhaustedStreamCap': string;
+    'follow.notFollowed.reason.exhausted': string;
+    'follow.notFollowed.reason.badInput': string;
+    'follow.notFollowed.reason.noRunId': string;
+    'follow.notFollowed.reason.runUnknown': string;
+    'follow.notFollowed.reason.unspecified': string;
+    'follow.notFollowed.endingUnknown': string;
+    'follow.notFollowed.exit.reattach': string;
+    'follow.notFollowed.exit.checkRuns': string;
+    'follow.notFollowed.exit.runUnknown': string;
+    'follow.notFollowed.idleTear': string;
+    'follow.notFollowed.idleGrace': string;
+    'approval.planReview.note.empty': string;
+    'approval.planReview.note.marked': string;
+    'approval.planReview.note.tooLarge': string;
+    'approval.planReview.note.notCarried': string;
+    'approval.planReview.note.unknown': string;
+    'approval.planReview.askAgain.shown': string;
+    'approval.planReview.askAgain.marked': string;
+    'approval.planReview.askAgain.tooLarge': string;
+    'approval.planReview.askAgain.notCarried': string;
+    'approval.planReview.askAgain.unknown': string;
+    'approval.planReview.askAgain.withNote': string;
+    'approval.planReview.option.askAgain.label': string;
+    'approval.planReview.option.askAgain.description': string;
 };
 export declare const EN_MESSAGES: Readonly<typeof EN>;
 export type MessageKey = keyof typeof EN;

package/dist/i18n/messages.en.js

@@ -187,6 +187,8 @@ const EN = {
     'config.mcp.nameReserved': 'MCP server name {name}{where} cannot be used, so the server was not started: names starting with "remote-" are kept for the MCP servers a connected device offers. Rename the server.',
     'config.mcp.identityHeadersBothSet': 'MCP server {name}{where} was not started: it sets both principalHeader and assertionHeader, which name the same identity header — keep only one of the two. The other MCP servers are unaffected.',
     'config.mcp.transportUnreadable': 'could not be read (a getter or proxy trap on the declaration threw)',
+    'config.mcp.transportNotAdvertised': 'MCP server {name}{where} was not started: it uses the {kind} transport, which the engine in use says it does not support (it supports: {supported}). The other MCP servers are unaffected.',
+    'config.mcp.transportsNone': 'none',
     'config.mcp.transportInvalid': 'MCP server {name}{where} was not started: its transport setting cannot be used — {path} {problem}. Fix that setting for this server (or remove the server); the other MCP servers are unaffected.',
     'config.mcp.transportDegraded': 'MCP server {name}{where} was started without part of its transport settings, which cannot be used as written: {lost}. The rest of its settings are applied; fix the settings named above to get them applied too.',
     'config.mcp.toolAxesInvalid': 'MCP server {name}{where} was not started: its toolAxes setting is not valid — {problem}. Fix the toolAxes entry for this server (or remove it); the other MCP servers are unaffected.',
@@ -547,6 +549,13 @@ const EN = {
     'session.fileHistoryRefusal.notSaid': 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can stop recording file history for a session, so sending now could record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.',
     'session.fileHistoryRefusal.unrecognized': 'Nothing was sent: file checkpointing is turned off in your settings, but this engine reported a file-history capture mode this client does not recognize, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.',
     'session.fileHistoryRefusal.unreadable': "Nothing was sent: file checkpointing is turned off in your settings, but this engine's report on whether it can stop recording file history for a session could not be read by this client, so sending now could record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.",
+    'session.memoryErase.personalStoreUnjudged': "Nothing was erased: part of this session's memory is kept in a personal memory store that this deployment cannot erase yet, so the erase was declined before anything changed.",
+    'session.memorySync.parked.one': 'Memory sync is paused on this deployment for the "{scope}" layer: its sync cursor could not be used. {wayOut}',
+    'session.memorySync.parked.other': 'Memory sync is paused on this deployment for {count} layers ({scopes}): their sync cursors could not be used. {wayOut}',
+    'session.memorySync.parkedUnnamed.one': 'Memory sync is paused on this deployment for 1 layer: its sync cursor could not be used. {wayOut}',
+    'session.memorySync.parkedUnnamed.other': 'Memory sync is paused on this deployment for {count} layers: their sync cursors could not be used. {wayOut}',
+    'session.memorySync.wayOut.deleteCursor': 'Syncing resumes once an operator deletes the sync cursor of each paused layer on the server; entries deleted on only one side since the last sync will come back and need to be deleted again.',
+    'session.memorySync.wayOut.unrecognized': 'The deployment named a way out that this client does not recognize, so none is suggested here.',
     'session.hostSettings.memorySwitchMalformed': 'The memory setting in your settings file could not be read, so turning memory off was not applied: this request was sent with memory available. Fix the memory section (memory.enabled must be true or false) to turn it off.',
     'session.hostSettings.fileHistoryRestoreConflict': 'Nothing was sent: file checkpointing was turned off in your settings after this request was prepared, but this request also restores files from a checkpoint, and a request cannot do both. To restore the files, turn file checkpointing back on in your settings; otherwise send the request without the file restore.',
     'session.hostSettings.projectionUnchecked': 'The settings for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
@@ -670,6 +679,18 @@ const EN = {
     'session.steerRefusal.advice': '{happened} — {nextStep}',
     'session.steerRefusal.hostQueue.queued': 'it stays queued and will be submitted as-is when this turn ends',
     'session.steerRefusal.hostQueue.dropped': 'it was not kept; {nextStep}',
+    'session.permissionModeSwitch.applied': 'The running turn now uses the {mode} permission mode.',
+    'session.permissionModeSwitch.folded': 'The running turn now uses the {mode} permission mode instead of the one you chose — {reason}.',
+    'session.permissionModeSwitch.reason.entryFloor': 'this deployment does not allow a looser mode than its floor',
+    'session.permissionModeSwitch.reason.disableAutoMode': "this task's settings turn auto mode off",
+    'session.permissionModeSwitch.reason.engine': 'the engine does not allow the chosen mode for this run',
+    'session.permissionModeSwitch.notPersisted': '{line} The switch was not saved with the run: if the run pauses and later resumes, it resumes in the mode it had before, so switch again after it resumes.',
+    'session.permissionModeSwitch.notRunning': 'This run is not running a turn right now (it is paused waiting on a decision, has finished, or is running elsewhere), so its mode was not switched.',
+    'session.permissionModeSwitch.notFound': 'No such run is visible to you, so no mode was switched.',
+    'session.permissionModeSwitch.refused': 'The engine refused to switch the mode of this run ({status}), so it keeps the mode it had.',
+    'session.permissionModeSwitch.refusedWithCode': 'The engine refused to switch the mode of this run ({status} {code}), so it keeps the mode it had.',
+    'session.permissionModeSwitch.unconfirmed': 'The switch was sent but no readable answer came back, so whether the mode changed is not known — switch again to be sure.',
+    'session.permissionModeSwitch.unavailable': 'Switching the mode of a running turn is not available here, so the mode was not changed.',
     'notice.capability.subject.userInvokedSkills': 'user-invoked skills',
     'notice.capability.subject.skillToolLists': 'skill tool lists',
     'notice.capability.subject.permissionRulesWrite': 'permission-rule write entry',
@@ -1053,5 +1074,34 @@ const EN = {
     'config.mods.refusal.by': 'Refused by {by}',
     'config.mods.rewrite.resultInPlace': 'Answered by {by} in place of the tool',
     'config.mods.rewrite.inputBy': 'Arguments changed by {by} before the call was let through',
+    'follow.notFollowed.headRun': 'This screen is no longer following run {taskId}{reason}{ending}{exit}',
+    'follow.notFollowed.headTurn': "This screen is no longer following this turn's run{reason}{ending}{exit}",
+    'follow.notFollowed.reason.exhaustedDraining': ": the engine instance serving it was going down when its last event stream closed, and this client's re-attach allowance has run out.",
+    'follow.notFollowed.reason.exhaustedConnectionLost': ": the connection dropped on the last attempt, and this client's re-attach allowance has run out.",
+    'follow.notFollowed.reason.exhaustedStreamCap': ": its event stream hit the engine's time limit on the last attempt, and this client's re-attach allowance has run out.",
+    'follow.notFollowed.reason.exhausted': ": this client's re-attach allowance has run out.",
+    'follow.notFollowed.reason.badInput': ': this client hit an internal error while re-attaching.',
+    'follow.notFollowed.reason.noRunId': ': this client never learned which run it was, so there is nothing to re-attach to.',
+    'follow.notFollowed.reason.runUnknown': ': the engine answered that it does not know that run — it may have been cleaned up, or this client asked with the wrong identity.',
+    'follow.notFollowed.reason.unspecified': '.',
+    'follow.notFollowed.endingUnknown': ' The engine has not said how that run ended — it may still be going.',
+    'follow.notFollowed.exit.reattach': ' What it does next shows up here only after this client re-attaches to it.',
+    'follow.notFollowed.exit.checkRuns': " Check this session's runs before sending the work again.",
+    'follow.notFollowed.exit.runUnknown': " Re-attaching will not bring it back here; check this session's runs before sending the work again.",
+    'follow.notFollowed.idleTear': "This turn's event stream went silent for {secs}s. {notice} {grace}",
+    'follow.notFollowed.idleGrace': 'If the run legitimately goes quiet this long (e.g. a long build), raising the idle grace may help next time: set {env} (settings env, integer ms, {min}-{max}; default {default}).',
+    'approval.planReview.note.empty': 'The plan is empty.',
+    'approval.planReview.note.marked': 'This plan contains characters that cannot be shown as written, so it cannot be approved from this card. Reject it, or ask for the plan to be presented again.',
+    'approval.planReview.note.tooLarge': 'This plan is too large to be shown in full ({length} characters), so it cannot be approved from this card. Reject it, or ask for a shorter plan.',
+    'approval.planReview.note.notCarried': "The engine did not bring this plan's text up to this card (it may be too long), so it cannot be approved from this card. Reject it, or ask for the plan to be presented again.",
+    'approval.planReview.note.unknown': 'This card cannot show the plan it would approve, so it cannot be approved from this card. Reject it, or ask for the plan to be presented again.',
+    'approval.planReview.askAgain.shown': 'The user asked for the plan to be presented again.',
+    'approval.planReview.askAgain.marked': 'The user could not approve this plan: it contains characters that cannot be shown as written. Present the plan again without those characters.',
+    'approval.planReview.askAgain.tooLarge': 'The user could not approve this plan: it is too large to be shown in full. Present a shorter plan.',
+    'approval.planReview.askAgain.notCarried': 'The user could not approve this plan: its text did not reach the approval card (it may be too long). Present a shorter plan.',
+    'approval.planReview.askAgain.unknown': 'The user could not approve this plan: the approval card could not show it. Present the plan again.',
+    'approval.planReview.askAgain.withNote': '{sentence} The user added: {note}',
+    'approval.planReview.option.askAgain.label': 'No, ask for the plan to be presented again',
+    'approval.planReview.option.askAgain.description': 'Do not approve; ask the model to present the plan again',
 };
 export const EN_MESSAGES = Object.freeze(EN);

package/dist/i18n/messages.zh.js

@@ -187,6 +187,8 @@ const ZH = {
     'config.mcp.nameReserved': 'MCP 服务器名 {name}{where} 不可用,所以没有启动:以 "remote-" 开头的名字留给已连接设备提供的 MCP 服务器。请给这台服务器换个名字。',
     'config.mcp.identityHeadersBothSet': 'MCP 服务器 {name}{where} 没有启动:它同时设置了 principalHeader 和 assertionHeader,而这两项指的是同一个身份头 —— 只保留其中一项。其他 MCP 服务器不受影响。',
     'config.mcp.transportUnreadable': '读不出(声明上的取值器或代理陷阱抛了错)',
+    'config.mcp.transportNotAdvertised': 'MCP 服务器 {name}{where} 没有启动:它用的是 {kind} 传输,而这台引擎说它不支持这种传输(它支持:{supported})。其他 MCP 服务器不受影响。',
+    'config.mcp.transportsNone': '无',
     'config.mcp.transportInvalid': 'MCP 服务器 {name}{where} 没有启动:它的传输设置不可用 —— {path} {problem}。请修正这台服务器的这项设置(或删掉这台服务器);其他 MCP 服务器不受影响。',
     'config.mcp.transportDegraded': 'MCP 服务器 {name}{where} 已启动,但它的部分传输设置不能照原样使用、被略去了:{lost}。其余设置照常生效;请修正上面点名的设置,让它们也生效。',
     'config.mcp.toolAxesInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 toolAxes 设置不合法 —— {problem}。请修正这台服务器的 toolAxes(或删掉它);其他 MCP 服务器不受影响。',
@@ -547,6 +549,13 @@ const ZH = {
     'session.fileHistoryRefusal.notSaid': '没有发送:你的设置里已关闭文件检查点,但这台引擎没有报告它能否按会话停止记录文件历史,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
     'session.fileHistoryRefusal.unrecognized': '没有发送:你的设置里已关闭文件检查点,但这台引擎报告了一个本客户端不认识的文件历史捕获模式,所以不知道它能否按会话停止记录文件历史,现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
     'session.fileHistoryRefusal.unreadable': '没有发送:你的设置里已关闭文件检查点,但这台引擎关于能否按会话停止记录文件历史的报告,本客户端读不出来,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'session.memoryErase.personalStoreUnjudged': '什么都没有抹除:这条会话的记忆有一部分存放在这台部署目前还抹除不了的个人记忆库里,所以抹除在任何改动之前就被拒绝了。',
+    'session.memorySync.parked.one': '这台部署上「{scope}」这一层的记忆同步已暂停:它的同步游标用不了。{wayOut}',
+    'session.memorySync.parked.other': '这台部署上 {count} 层的记忆同步已暂停({scopes}):它们的同步游标用不了。{wayOut}',
+    'session.memorySync.parkedUnnamed.one': '这台部署上 1 层的记忆同步已暂停:它的同步游标用不了。{wayOut}',
+    'session.memorySync.parkedUnnamed.other': '这台部署上 {count} 层的记忆同步已暂停:它们的同步游标用不了。{wayOut}',
+    'session.memorySync.wayOut.deleteCursor': '运维在服务器上删掉每个暂停层的同步游标后,同步即恢复;自上次同步以来只在一侧删掉的条目会回来,需要再删一次。',
+    'session.memorySync.wayOut.unrecognized': '部署给出的出路本客户端认不出,这里不给建议。',
     'session.hostSettings.memorySwitchMalformed': '设置文件里的记忆设置读不出,所以「关闭记忆」没有生效:这一次请求照常带着记忆发出。改好记忆那一段(memory.enabled 只能是 true 或 false)即可关闭。',
     'session.hostSettings.fileHistoryRestoreConflict': '没有发送:这次请求准备好之后,你在设置里关闭了文件检查点,但这次请求同时要从检查点还原文件,两者不能放在同一个请求里。要还原文件,请在设置里把文件检查点重新打开;否则请去掉文件还原再发送。',
     'session.hostSettings.projectionUnchecked': '这一次请求要带的设置在发出前没法核对,所以没有发送。请重新载入设置后再试。',
@@ -670,6 +679,18 @@ const ZH = {
     'session.steerRefusal.advice': '{happened} —— {nextStep}',
     'session.steerRefusal.hostQueue.queued': '它留在队列里,在这个 turn 结束时会原样提交',
     'session.steerRefusal.hostQueue.dropped': '它没有被保留;{nextStep}',
+    'session.permissionModeSwitch.applied': '正在跑的这一轮现在用 {mode} 权限模式。',
+    'session.permissionModeSwitch.folded': '正在跑的这一轮现在用 {mode} 权限模式,不是你选的那一档 —— {reason}。',
+    'session.permissionModeSwitch.reason.entryFloor': '这台部署不允许比它的下限更宽松的模式',
+    'session.permissionModeSwitch.reason.disableAutoMode': '这个任务的设置关掉了 auto 模式',
+    'session.permissionModeSwitch.reason.engine': '引擎不允许这条 run 用你选的模式',
+    'session.permissionModeSwitch.notPersisted': '{line}这次切档没有随 run 存下:run 停下后再续跑时会回到切档前的模式,续跑后请再切一次。',
+    'session.permissionModeSwitch.notRunning': '这条 run 此刻没在跑一轮(停在等决断上、已经结束,或在别处跑),所以没有切它的模式。',
+    'session.permissionModeSwitch.notFound': '你看不到这条 run,没有切任何模式。',
+    'session.permissionModeSwitch.refused': '引擎拒绝切这条 run 的模式({status}),它保持原来的模式。',
+    'session.permissionModeSwitch.refusedWithCode': '引擎拒绝切这条 run 的模式({status} {code}),它保持原来的模式。',
+    'session.permissionModeSwitch.unconfirmed': '切档请求已发出,但没有收到读得懂的答复,不知道模式变没变 —— 请再切一次以确认。',
+    'session.permissionModeSwitch.unavailable': '这里不能切正在跑的这一轮的模式,模式没有变。',
     'notice.capability.subject.userInvokedSkills': '用户点名的技能',
     'notice.capability.subject.skillToolLists': '技能工具清单',
     'notice.capability.subject.permissionRulesWrite': '权限规则写入口',
@@ -1053,10 +1074,40 @@ const ZH = {
     'config.mods.refusal.by': '被 {by} 拒绝',
     'config.mods.rewrite.resultInPlace': '由 {by} 代替工具作答',
     'config.mods.rewrite.inputBy': '参数在放行前被 {by} 改过',
+    'follow.notFollowed.headRun': '这块屏已不再跟着 run {taskId}{reason}{ending}{exit}',
+    'follow.notFollowed.headTurn': '这块屏已不再跟着这一轮的 run{reason}{ending}{exit}',
+    'follow.notFollowed.reason.exhaustedDraining': ':服务它的那台引擎实例在它最后一条事件流关闭时正在下线,而这个客户端的重新附着次数已经用完。',
+    'follow.notFollowed.reason.exhaustedConnectionLost': ':最后一次尝试时连接断了,而这个客户端的重新附着次数已经用完。',
+    'follow.notFollowed.reason.exhaustedStreamCap': ':最后一次尝试时它的事件流撞上了引擎的时长上限,而这个客户端的重新附着次数已经用完。',
+    'follow.notFollowed.reason.exhausted': ':这个客户端的重新附着次数已经用完。',
+    'follow.notFollowed.reason.badInput': ':这个客户端在重新附着时出了内部错误。',
+    'follow.notFollowed.reason.noRunId': ':这个客户端始终不知道它是哪一次 run,所以没有可以重新附着的对象。',
+    'follow.notFollowed.reason.runUnknown': ':引擎答复说它不认识那次 run —— 它可能已被清理,也可能是这个客户端用错了身份去问。',
+    'follow.notFollowed.reason.unspecified': '。',
+    'follow.notFollowed.endingUnknown': '引擎没有说那次 run 是怎么结束的 —— 它可能还在跑。',
+    'follow.notFollowed.exit.reattach': '它接下来的动作,只有在这个客户端重新附着到它之后才会显示在这里。',
+    'follow.notFollowed.exit.checkRuns': '再发一次这件工作之前,先查一下这个会话的 run。',
+    'follow.notFollowed.exit.runUnknown': '重新附着也不会把它带回这里;再发一次这件工作之前,先查一下这个会话的 run。',
+    'follow.notFollowed.idleTear': '这一轮的事件流静默了 {secs} 秒。{notice}{grace}',
+    'follow.notFollowed.idleGrace': '如果这次 run 本来就会安静这么久(比如一次长构建),下次可以调大空闲宽限:设置 {env}(settings 的 env 块,整数毫秒,{min}-{max};默认 {default})。',
+    'approval.planReview.note.empty': '计划为空。',
+    'approval.planReview.note.marked': '这份计划里有不能照原样显示的字符，不能在这张卡上批准。可以拒绝，或要模型重新呈一次计划。',
+    'approval.planReview.note.tooLarge': '这份计划太长，卡上显示不全（{length} 个字符），不能在这张卡上批准。可以拒绝，或要一份更短的计划。',
+    'approval.planReview.note.notCarried': '引擎没有把这份计划的正文带到卡上（可能过长），不能在这张卡上批准。可以拒绝，或要模型重新呈一次计划。',
+    'approval.planReview.note.unknown': '这张卡给不出它要批的计划正文，不能在这张卡上批准。可以拒绝，或要模型重新呈一次计划。',
+    'approval.planReview.askAgain.shown': '用户要求重新呈上这份计划。',
+    'approval.planReview.askAgain.marked': '用户没法批准这份计划：里面有不能照原样显示的字符。请去掉这些字符后重新呈上计划。',
+    'approval.planReview.askAgain.tooLarge': '用户没法批准这份计划：它太长，显示不全。请呈上一份更短的计划。',
+    'approval.planReview.askAgain.notCarried': '用户没法批准这份计划：计划正文没有到达审批卡（可能过长）。请呈上一份更短的计划。',
+    'approval.planReview.askAgain.unknown': '用户没法批准这份计划：审批卡显示不了它。请重新呈上计划。',
+    'approval.planReview.askAgain.withNote': '{sentence} 用户补充：{note}',
+    'approval.planReview.option.askAgain.label': '不，要模型重新呈上计划',
+    'approval.planReview.option.askAgain.description': '不批准；要模型重新呈上计划',
 };
 export const ZH_MESSAGES = Object.freeze(ZH);
 export const TERM_SLOTS = Object.freeze({
     'session.background.refusal.envOff': ['SEMA_HEADLESS_DETACH'],
+    'session.permissionModeSwitch.reason.disableAutoMode': ['auto'],
     'session.thinking.offWithUltracodeOnBody': ['Ultracode'],
     'config.mcp.toolAxesInvalid': ['toolAxes'],
     'config.mcp.toolFacesInvalid': ['toolFaces'],

package/dist/index.d.ts

@@ -77,6 +77,11 @@ export * from './steerPriorityCapability.js';
 export * from './permissionModesCapability.js';
 export * from './approvalDecidedByCapability.js';
 export * from './outputStyleSeatCapability.js';
+export * from './permissionModeWriteCapability.js';
+export { setRunPermissionMode, runPermissionModeSwitchLine } from './runPermissionModeSwitch.js';
+export type { RunPermissionModeSwitchOutcome, RunPermissionModeSwitchRuns, RunPermissionModeSwitchOptions, PermissionModeAdmissionView, PermissionModeReceiptView, } from './runPermissionModeSwitch.js';
+export { observedMcpTransportKinds, projectMcpTransportKindsCapability } from './mcpTransportKindsCapability.js';
+export type { McpRequestTransportKind, McpTransportKindsReading } from './mcpTransportKindsCapability.js';
 export * from './mcpProbeWire.js';
 export * from './connectorStatus.js';
 export * from './effectiveFacts.js';
@@ -84,7 +89,7 @@ export * from './gateOutcome.js';
 export * from './postureKnob.js';
 export * from './engineIdentity.js';
 export { readEngineHealthFacts } from './engineHealthFacts.js';
-export type { EngineHealthFacts, EngineHealthCenterFacts, EngineHealthAuthFacts, EngineHealthDrainingFacts } from './engineHealthFacts.js';
+export type { EngineHealthFacts, EngineHealthCenterFacts, EngineHealthAuthFacts, EngineHealthDrainingFacts, EngineHealthLeaseFacts } from './engineHealthFacts.js';
 export { transportFailureScene } from './engineWireFor.js';
 export type { EngineWireNoAnswerKind, TransportFailureChainEnd, TransportFailureLayer, TransportFailureScene, TransportFailureSocket } from './engineWireFor.js';
 export { engineUrlTransportVerdict, normalizeEngineBaseUrl } from './engineUrl.js';
@@ -105,6 +110,7 @@ export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
 export { displayUntrusted, displayUntrustedMarks, displayConfiguredUrl, queryCarriesCredential, cleanUntrustedScalar } from './displayUntrusted.js';
 export type { DisplayUntrustedOptions, DisplayMark, DisplayMarkSpan, DisplayUntrustedMarked } from './displayUntrusted.js';
+export { DISPLAY_DECISION_BODY } from './displayUntrusted.js';
 export { isDiagnosticValueWord } from './displayUntrusted.js';
 export type * from './types/engineState.js';
 export * from './hostEnv.js';
@@ -222,7 +228,8 @@ export { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from
 export { contextUsageReadingOf, type ContextUsageReading } from './ownKey.js';
 export { TURN_FAILURE_CATEGORIES, turnFailurePresentation, type TurnFailureCategory, type TurnFailurePresentation, type TurnFailureRetry } from './turnFailurePresentation.js';
 export { readSeatTurnFailure, seatTurnFailureOf, type SeatTurnFailure } from './turnFailurePresentation.js';
-export { REATTACH_BUDGET_FRESH, REATTACH_MAX_TRIES, runReattachPolicy, type ReattachBudget, type ReattachDecision, type ReattachEvent, type ReattachGiveUp, } from './runReattachPolicy.js';
+export { REATTACH_BUDGET_FRESH, REATTACH_BUDGET_NONE, REATTACH_MAX_TRIES, runReattachPolicy, type ReattachBudget, type ReattachDecision, type ReattachDrainingEvent, type ReattachEvent, } from './runReattachPolicy.js';
+export { runNotFollowedNotice, runNotFollowedOf, type ReattachBreak, type RunNotFollowed, type RunNotFollowedCause } from './runFollow.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
 export { SEMA_TOOL_HISTORY_ACCEPTED_KEY, classifyToolHistoryMismatch, readToolHistoryAcceptedKey, readToolHistoryMismatchKey, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
@@ -260,7 +267,7 @@ export type { InterruptedRunRow, InterruptedRunSettleDeps, InterruptedRunSettleV
 export { ENGINE_GENERATION_WINDOW_MARGIN_MS, ENGINE_STOPPED_CALL_PHASES, approvalWindowLeftMs, convergeEndedEngineGeneration } from './engineGenerationConvergence.js';
 export type { ApprovalWindowAnchor, EndedGenerationCard, EndedGenerationFacts, EndedGenerationOpenedCall, EndedGenerationPhaseChange, EndedGenerationPhaseHold, EngineGenerationConvergence, EngineStoppedCallPhase, } from './engineGenerationConvergence.js';
 export { AWAIT_ENGINE_INSTALL_POLL_MS, REATTACH_AWAIT_NEXT_ENGINE_MS, REATTACH_RUN_STATES, approvalFrameGenerationVerdict, awaitNextEngineInstalled, endedGenerationSettleStep, engineGenerationEnded, engineGenerationOfPort, engineGenerationReadingOf, unreachableForSettle, } from './engineGenerationPort.js';
-export type { ApprovalFrameGenerationFacts, AwaitNextEngineDeps, EndedGenerationMaterials, EndedGenerationSettleFacts, EndedGenerationSettleStep, EngineGenerationEndedFacts, EngineGenerationPort, EngineGenerationReading, ReattachLivenessReading, ReattachOutageStopLine, ReattachOutageStopLineParts, ReattachRunState, } from './engineGenerationPort.js';
+export type { ApprovalFrameGenerationFacts, AwaitNextEngineDeps, EndedGenerationMaterials, EndedGenerationSettleFacts, EndedGenerationSettleStep, EndedGenerationWaitReading, EngineGenerationEndFact, EngineGenerationEndedFacts, EngineGenerationPort, EngineGenerationReading, ReattachLivenessReading, ReattachOutageStopLine, ReattachOutageStopLineParts, ReattachRunState, } from './engineGenerationPort.js';
 export { POISON_FRAME_RAW_MAX, REATTACH_BACKOFF_CAP_MS, REATTACH_BACKOFF_START_MS, REATTACH_NOT_FOUND_CONFIRM, REATTACH_NOT_FOUND_MIN_ELAPSED_MS, REATTACH_WINDOW_MS, malformedFrameErrorOf, poisonFrameInitial, poisonFrameStep, reattachBackoffMs, reattachWindowOpen, reattachWindowStep, } from './reattachWindow.js';
 export type { PoisonFrameDecision, PoisonFrameEvent, PoisonFrameState, PoisonFrameStep, ReattachProbeResult, ReattachWindowDecision, ReattachWindowEvent, ReattachWindowState, ReattachWindowStep, ReattachWindowTuning, } from './reattachWindow.js';
 export * from './inheritEnvWire.js';
@@ -310,6 +317,11 @@ export { ruleToolNameVerdictOf } from './protocolSegment.js';
 export type { RuleToolNameReading } from './protocolSegment.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
+export type { PlanReviewCardFacts, PlanReviewBody, PlanBodyUnknownCause } from './planReviewCardFacts.js';
+export { planReviewBodyOf } from './planReviewCardFacts.js';
+export { planReviewCardNote } from './hitl/planReviewCard.js';
+export { readRunLedgerSnapshot } from './runLedgerSnapshot.js';
+export type { RunLedgerSnapshot, RunLedgerFold, RunLedgerSnapshotDeps } from './runLedgerSnapshot.js';
 export { decisionInFlightOf, decisionReadMark } from './hitl/decisionLedger.js';
 export { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent, askParkAutoReopenBlockOf, askParkRefusalBlockOf, claimAskParkAutoReopenBlockNotice, clearAskParkAutoReopenBlocks, } from './hitl/askParkAutoReopenBlock.js';
 export type { AskParkAutoReopenBlock, AskParkAutoReopenBlockNotice, AskParkGate } from './hitl/askParkAutoReopenBlock.js';

package/dist/index.js

@@ -66,6 +66,9 @@ export * from './steerPriorityCapability.js';
 export * from './permissionModesCapability.js';
 export * from './approvalDecidedByCapability.js';
 export * from './outputStyleSeatCapability.js';
+export * from './permissionModeWriteCapability.js';
+export { setRunPermissionMode, runPermissionModeSwitchLine } from './runPermissionModeSwitch.js';
+export { observedMcpTransportKinds, projectMcpTransportKindsCapability } from './mcpTransportKindsCapability.js';
 export * from './mcpProbeWire.js';
 export * from './connectorStatus.js';
 export * from './effectiveFacts.js';
@@ -88,6 +91,7 @@ export * from './classifierStatus.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
 export { displayUntrusted, displayUntrustedMarks, displayConfiguredUrl, queryCarriesCredential, cleanUntrustedScalar } from './displayUntrusted.js';
+export { DISPLAY_DECISION_BODY } from './displayUntrusted.js';
 export { isDiagnosticValueWord } from './displayUntrusted.js';
 export * from './hostEnv.js';
 export * from './unrefTimer.js';
@@ -191,7 +195,8 @@ export { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from
 export { contextUsageReadingOf } from './ownKey.js';
 export { TURN_FAILURE_CATEGORIES, turnFailurePresentation } from './turnFailurePresentation.js';
 export { readSeatTurnFailure, seatTurnFailureOf } from './turnFailurePresentation.js';
-export { REATTACH_BUDGET_FRESH, REATTACH_MAX_TRIES, runReattachPolicy, } from './runReattachPolicy.js';
+export { REATTACH_BUDGET_FRESH, REATTACH_BUDGET_NONE, REATTACH_MAX_TRIES, runReattachPolicy, } from './runReattachPolicy.js';
+export { runNotFollowedNotice, runNotFollowedOf } from './runFollow.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
 export { SEMA_TOOL_HISTORY_ACCEPTED_KEY, classifyToolHistoryMismatch, readToolHistoryAcceptedKey, readToolHistoryMismatchKey, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
@@ -254,6 +259,9 @@ export * from './coreValuePorts.js';
 export { ruleToolNameVerdictOf } from './protocolSegment.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
+export { planReviewBodyOf } from './planReviewCardFacts.js';
+export { planReviewCardNote } from './hitl/planReviewCard.js';
+export { readRunLedgerSnapshot } from './runLedgerSnapshot.js';
 export { decisionInFlightOf, decisionReadMark } from './hitl/decisionLedger.js';
 export { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent, askParkAutoReopenBlockOf, askParkRefusalBlockOf, claimAskParkAutoReopenBlockNotice, clearAskParkAutoReopenBlocks, } from './hitl/askParkAutoReopenBlock.js';
 export { HITL_DECISION_FAMILIES, HITL_DECISION_NOT_APPLIED_CAUSES, HITL_DECISION_NOT_SENT_CAUSES, HITL_DECISION_UNCONFIRMED_CAUSES, sendHitlDecision, hitlDecisionOutcomeContent, } from './hitl/decisionSend.js';

package/dist/mcpTransportKindsCapability.d.ts

@@ -0,0 +1,18 @@
+import type { McpServerSpec } from '@sema-agent/sdk';
+export type McpRequestTransportKind = McpServerSpec['transport']['kind'];
+export declare const MCP_TRANSPORT_KINDS_WHEN_NOT_STATED: readonly ["stdio", "http"];
+export type McpTransportKindsReading = {
+    readonly kind: 'stated';
+    readonly kinds: readonly McpRequestTransportKind[];
+    readonly unrecognized: readonly string[];
+} | {
+    readonly kind: 'not_stated';
+    readonly kinds: readonly McpRequestTransportKind[];
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function projectMcpTransportKindsCapability(caps: unknown): McpTransportKindsReading | undefined;
+export declare function observedMcpTransportKinds(baseUrl?: string | undefined): McpTransportKindsReading;
+export declare function mcpTransportNotAdvertised(reading: McpTransportKindsReading | undefined, transportKind: string): readonly McpRequestTransportKind[] | undefined;

package/dist/mcpTransportKindsCapability.js

@@ -0,0 +1,75 @@
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { appendOwnElement, ownDataField } from './ownKey.js';
+export const MCP_TRANSPORT_KINDS_WHEN_NOT_STATED = Object.freeze(['stdio', 'http']);
+const _kindsEqRequestFace = true;
+void _kindsEqRequestFace;
+const KNOWN = new Set(MCP_TRANSPORT_KINDS_WHEN_NOT_STATED);
+export function projectMcpTransportKindsCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'mcpTransportKinds');
+        if (v === undefined)
+            return { kind: 'not_stated', kinds: MCP_TRANSPORT_KINDS_WHEN_NOT_STATED };
+        if (!Array.isArray(v))
+            return undefined;
+        const len = ownDataField(v, 'length');
+        if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0 || len > 1000)
+            return undefined;
+        const kinds = [];
+        const unrecognized = [];
+        for (let i = 0; i < len; i++) {
+            if (!Object.hasOwn(v, i))
+                return undefined;
+            const w = ownDataField(v, String(i));
+            if (typeof w !== 'string')
+                return undefined;
+            if (KNOWN.has(w)) {
+                if (!kinds.includes(w))
+                    appendOwnElement(kinds, w);
+            }
+            else if (!unrecognized.includes(w))
+                appendOwnElement(unrecognized, w);
+        }
+        return { kind: 'stated', kinds, unrecognized };
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'mcpTransportKinds',
+    project: projectMcpTransportKindsCapability,
+});
+export function observedMcpTransportKinds(baseUrl = engineWireTargetBaseUrl()) {
+    return reader.observed(baseUrl);
+}
+export function mcpTransportNotAdvertised(reading, transportKind) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return undefined;
+        if (ownDataField(reading, 'kind') !== 'stated')
+            return undefined;
+        const kinds = ownDataField(reading, 'kinds');
+        if (!Array.isArray(kinds))
+            return undefined;
+        const len = ownDataField(kinds, 'length');
+        if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0 || len > MCP_TRANSPORT_KINDS_WHEN_NOT_STATED.length)
+            return undefined;
+        const list = [];
+        for (let i = 0; i < len; i++) {
+            if (!Object.hasOwn(kinds, i))
+                return undefined;
+            const k = ownDataField(kinds, String(i));
+            if (typeof k !== 'string' || !KNOWN.has(k))
+                return undefined;
+            if (!list.includes(k))
+                appendOwnElement(list, k);
+        }
+        return list.includes(transportKind) ? undefined : Object.freeze([...list]);
+    }
+    catch {
+        return undefined;
+    }
+}