@sema-agent/client-core 0.104.0 → 0.105.0

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;
+    }
+}

package/dist/mcpWireCaps.d.ts

@@ -1,5 +1,6 @@
 import type { McpServerSpec } from '@sema-agent/sdk';
 import type { McpEntryKeyIssue } from './generated/settingsSchemaTypes.js';
+import { type McpTransportKindsReading } from './mcpTransportKindsCapability.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export type { McpServerSpec };
 export interface McpConfigLike {
@@ -16,6 +17,7 @@ export interface McpConfigLike {
     toolFaces?: unknown;
     toolAxes?: unknown;
     startupTimeoutMs?: number;
+    sessionMetaKey?: string;
 }
 export type McpTransportEntryLike = Pick<McpConfigLike, 'type' | 'command' | 'args' | 'env' | 'url' | 'headers' | 'principalHeader' | 'assertionHeader'>;
 export type McpTransportVerdict = {
@@ -72,7 +74,7 @@ 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' | '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 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' | 'transport_not_advertised';
 export type McpServerNameUnusableReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'name_reserved';
 export type McpServerNameVerdict = {
     readonly usable: true;
@@ -100,6 +102,7 @@ export interface McpConfigProjection {
 }
 export interface ProjectMcpConfigsOptions {
     readonly sourceLabel?: (serverName: string) => string | undefined;
+    readonly transportKinds?: McpTransportKindsReading;
     readonly lang?: UiLanguage;
 }
 export declare function projectMcpConfigs(servers: Record<string, McpConfigLike> | undefined, opts?: ProjectMcpConfigsOptions): McpConfigProjection;

package/dist/mcpWireCaps.js

@@ -4,14 +4,16 @@ import { appendOwnElement, guardedRead } from './ownKey.js';
 import { readMcpToolAxes, readToolFaces } from './coreValuePorts.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { mcpTransportNotAdvertised } from './mcpTransportKindsCapability.js';
 const _mcpServerSpecPin = true;
 void _mcpServerSpecPin;
-function transparentKeys(startupTimeoutMs, axes, faces, elicitation) {
+function transparentKeys(startupTimeoutMs, axes, faces, elicitation, sessionMetaKey) {
     return {
         ...(faces !== undefined ? { toolFaces: faces } : {}),
         ...(axes !== undefined ? { toolAxes: axes } : {}),
         ...(elicitation !== undefined ? { elicitation } : {}),
         ...(startupTimeoutMs !== undefined ? { startupTimeoutMs } : {}),
+        ...(sessionMetaKey !== undefined ? { sessionMetaKey } : {}),
     };
 }
 export function readMcpHttpIdentityHeaders(transport) {
@@ -36,7 +38,7 @@ function entryShapeOf(c) {
 function readEntryOwnKeys(c) {
     try {
         const allowTools = c.allowTools;
-        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs };
+        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs, sessionMetaKey: c.sessionMetaKey };
     }
     catch {
         return undefined;
@@ -153,7 +155,7 @@ function specOf(name, c, own, axes, faces, elicitation, allowTools) {
         name,
         transport: t.transport,
         ...(allowTools !== undefined ? { allowTools } : {}),
-        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation),
+        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation, own.sessionMetaKey),
     };
     return { kind: 'ok', spec, lost: t.lost };
 }
@@ -305,7 +307,7 @@ const DROP_LABEL_SHOWN = 140;
 const DROP_PROBLEM_SHOWN = 300;
 const DROP_BAD_NAME_SHOWN = 160;
 const DEGRADED_LOST_SHOWN = 400;
-function dropNotice(name, reason, problem, opts, path) {
+function dropNotice(name, reason, problem, opts, path, transportKind) {
     let label;
     try {
         label = opts?.sourceLabel?.(name);
@@ -332,15 +334,17 @@ function dropNotice(name, reason, problem, opts, path) {
                                 ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
                                 : reason === 'transport_invalid'
                                     ? msg('config.mcp.transportInvalid', { name: quoted, where, path: capForDisplay(path ?? 'transport', DROP_NAME_SHOWN), problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
-                                    : reason === 'name_blank'
-                                        ? msg('config.mcp.nameBlank', { name: badName(), where })
-                                        : reason === 'name_collides_after_trim'
-                                            ? msg('config.mcp.nameCollides', { name: badName(), where })
-                                            : reason === 'name_too_long'
-                                                ? msg('config.mcp.nameTooLong', { name: badName(), where })
-                                                : reason === 'name_reserved'
-                                                    ? msg('config.mcp.nameReserved', { name: badName(), where })
-                                                    : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
+                                    : reason === 'transport_not_advertised'
+                                        ? msg('config.mcp.transportNotAdvertised', { name: quoted, where, kind: capForDisplay(transportKind ?? '', DROP_NAME_SHOWN), supported: problem !== undefined && problem.length > 0 ? problem : renderMessage(msg('config.mcp.transportsNone'), opts?.lang) })
+                                        : reason === 'name_blank'
+                                            ? msg('config.mcp.nameBlank', { name: badName(), where })
+                                            : reason === 'name_collides_after_trim'
+                                                ? msg('config.mcp.nameCollides', { name: badName(), where })
+                                                : reason === 'name_too_long'
+                                                    ? msg('config.mcp.nameTooLong', { 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) {
@@ -381,6 +385,13 @@ export function projectMcpConfigs(servers, opts) {
         }
         const out = slotUnreadable ? { spec: null, entryUnreadable: true } : mcpConfigEntry(name, c);
         if (out.spec !== null) {
+            const kind = out.spec.transport.kind;
+            const supported = opts?.transportKinds === undefined ? undefined : mcpTransportNotAdvertised(opts.transportKinds, kind);
+            if (supported !== undefined) {
+                const listed = supported.join(', ');
+                dropped.push({ name, reason: 'transport_not_advertised', path: 'transport.kind', problem: listed, notice: dropNotice(name, 'transport_not_advertised', listed, opts, 'transport.kind', kind) });
+                continue;
+            }
             specs.push(out.spec);
             if (out.transportLost !== undefined)
                 degraded.push({ name, lost: Object.freeze([...out.transportLost]), notice: degradedNotice(name, out.transportLost, opts) });

package/dist/notifications.d.ts

@@ -42,6 +42,14 @@ export declare function taskNotificationDedupKey(n: {
     seq?: number | string;
     taskType?: string;
 }): string;
+export interface TaskNotificationRenderKeyInput {
+    taskId: string;
+    status: string;
+    seq?: number | string;
+    taskType?: string;
+    completionId?: string;
+}
+export declare function taskNotificationRenderKeys(n: TaskNotificationRenderKeyInput): readonly [selfKey: string, ...completionKey: string[]];
 export declare function taskNotificationDedupKeyFromWire(raw: Record<string, unknown>): string;
 export interface TranscriptNotificationSeeds {
     renderedKeys: string[];
@@ -120,6 +128,7 @@ export interface EngineWorkflowCompletion {
     runId: string;
     status: 'completed' | 'failed';
     summary: string;
+    completionId?: string;
 }
 export declare function enqueueBgChildNotification(raw: {
     taskId: string;

package/dist/notifications.js

@@ -5,7 +5,7 @@ import { panelEndFact } from './panelReduce.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess } from './terminalStatuses.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
-import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue } from './ownKey.js';
+import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue, workflowCompletionExtrasOf } from './ownKey.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -244,6 +244,14 @@ export function taskNotificationDedupKey(n) {
     const lane = n.taskType === 'external' ? 'external:' : '';
     return `${lane}${n.taskId}:${n.status}${seq ? `:${seq}` : ''}`;
 }
+const COMPLETION_KEY_PREFIX = 'completion:';
+export function taskNotificationRenderKeys(n) {
+    const own = taskNotificationDedupKey(n);
+    const id = n.completionId;
+    if (n.taskType === 'external' || !isCoreTaskNotificationTerminal(n.status) || typeof id !== 'string' || id.length === 0)
+        return [own];
+    return [own, `${COMPLETION_KEY_PREFIX}${id}`];
+}
 export function taskNotificationDedupKeyFromWire(raw) {
     const n = ownSnapshotRecord(raw) ?? {};
     return taskNotificationDedupKey({
@@ -830,6 +838,7 @@ function enqueueBgChild(n, identity) {
         ...identity,
     }));
 }
+const completionIdOnly = (x) => (x.completionId !== undefined ? { completionId: x.completionId } : {});
 export function enqueueEngineWorkflowNotification(raw) {
     const c = ownSnapshotRecord(raw);
     if (c === undefined) {
@@ -843,7 +852,7 @@ export function enqueueEngineWorkflowNotification(raw) {
     }
     markRunNotified(c.runId);
     cardEnqueuedRunIds.add(c.runId);
-    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary }));
+    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...completionIdOnly(workflowCompletionExtrasOf(c)) }));
 }
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();

package/dist/ownKey.d.ts

@@ -71,3 +71,7 @@ export interface SampledRecord {
 export declare function ownSnapshotWhenTyped<V>(value: V, word: string): SampledJson;
 export declare function ownSnapshotTyped<T extends object>(value: T): T | undefined;
 export declare function ownSnapshotRecord<V>(value: V): SampledRecord | undefined;
+export declare function workflowCompletionExtrasOf(c: object): {
+    completionId?: string;
+    diagnostics?: string;
+};

package/dist/ownKey.js

@@ -440,3 +440,11 @@ function sampleObject(src, depth, run) {
         run.path.delete(src);
     }
 }
+export function workflowCompletionExtrasOf(c) {
+    const completionId = guardedRead(() => readOwnDataNonEmptyString(c, 'completionId'));
+    const diagnostics = guardedRead(() => readOwnDataNonEmptyString(c, 'diagnostics'));
+    return {
+        ...(completionId !== undefined ? { completionId } : {}),
+        ...(diagnostics !== undefined ? { diagnostics } : {}),
+    };
+}

package/dist/permissionModeWriteCapability.d.ts

@@ -0,0 +1,13 @@
+export type PermissionModeWriteReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'unreadable';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    value: boolean;
+};
+export declare function projectPermissionModeWriteCapability(caps: unknown): PermissionModeWriteReading | undefined;
+export declare function observedPermissionModeWrite(baseUrl?: string | undefined): PermissionModeWriteReading;
+export declare function permissionModeWriteAvailable(reading: PermissionModeWriteReading | undefined): boolean;

package/dist/permissionModeWriteCapability.js

@@ -0,0 +1,35 @@
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+export function projectPermissionModeWriteCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'permissionModeWrite');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'permissionModeWrite',
+    project: projectPermissionModeWriteCapability,
+});
+export function observedPermissionModeWrite(baseUrl = engineWireTargetBaseUrl()) {
+    return reader.observed(baseUrl);
+}
+export function permissionModeWriteAvailable(reading) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        return readOwnDataValue(reading, 'value') === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/permissionsAllowGrantCapability.d.ts

@@ -1,3 +1,4 @@
+export declare const RULE_LAYERS_CAP_LEAF: "layers";
 export type PermissionsAllowGrantReading = {
     kind: 'unobserved';
 } | {
@@ -8,10 +9,12 @@ export type PermissionsAllowGrantReading = {
     kind: 'present';
     grants: boolean;
     layer?: boolean;
+    layers?: boolean;
 };
 export declare function projectPermissionsAllowGrantCapability(caps: unknown): PermissionsAllowGrantReading | undefined;
 export declare function observedPermissionsAllowGrant(baseUrl?: string | undefined): PermissionsAllowGrantReading;
 export declare function permissionsAllowGrantAvailable(reading: PermissionsAllowGrantReading): boolean;
 export declare function allowWireForm(reading: PermissionsAllowGrantReading): 'layer' | 'grant' | 'off';
 export declare function allowRulesGate(reading: PermissionsAllowGrantReading, settingsRead: 'clean' | 'partial' | 'unreadable' | undefined): 'open' | 'capability_off' | 'settings_read_not_clean';
+export declare function permissionRuleLayersOn(reading: PermissionsAllowGrantReading | undefined): boolean;
 export declare function permissionsAllowGrantDoctorDetail(reading: PermissionsAllowGrantReading, settingsRead?: 'clean' | 'partial' | 'unreadable'): string;

package/dist/permissionsAllowGrantCapability.js

@@ -4,6 +4,7 @@ import { ownDataField } from './ownKey.js';
 import { hasCoreValuePort } from './coreValuePorts.js';
 const ALLOW_GRANT_CAP_PATH = ['settings', 'permissions', 'allowGrant'];
 const ALLOW_LAYER_CAP_LEAF = 'allowLayer';
+export const RULE_LAYERS_CAP_LEAF = 'layers';
 export function projectPermissionsAllowGrantCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -18,9 +19,21 @@ export function projectPermissionsAllowGrantCapability(caps) {
                 if (typeof v !== 'boolean')
                     return undefined;
                 const layer = ownDataField(node, ALLOW_LAYER_CAP_LEAF);
-                if (layer === undefined)
-                    return { kind: 'present', grants: v };
-                return typeof layer === 'boolean' ? { kind: 'present', grants: v, layer } : undefined;
+                if (layer !== undefined && typeof layer !== 'boolean')
+                    return undefined;
+                let layers;
+                try {
+                    layers = ownDataField(node, RULE_LAYERS_CAP_LEAF);
+                }
+                catch {
+                    layers = undefined;
+                }
+                return {
+                    kind: 'present',
+                    grants: v,
+                    ...(layer !== undefined ? { layer } : {}),
+                    ...(typeof layers === 'boolean' ? { layers } : {}),
+                };
             }
             if (v === null || typeof v !== 'object' || Array.isArray(v))
                 return undefined;
@@ -61,6 +74,16 @@ export function allowRulesGate(reading, settingsRead) {
         return 'capability_off';
     return settingsRead === 'clean' ? 'open' : 'settings_read_not_clean';
 }
+export function permissionRuleLayersOn(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        return ownDataField(reading, 'kind') === 'present' && ownDataField(reading, RULE_LAYERS_CAP_LEAF) === true;
+    }
+    catch {
+        return false;
+    }
+}
 function ownReadingField(reading, key) {
     try {
         if (reading === null || typeof reading !== 'object' || Array.isArray(reading))