@sema-agent/client-core 0.106.0 → 0.107.0

package/dist/i18n/messages.en.js

@@ -246,7 +246,11 @@ const EN = {
     'approval.settle.cause.broadcastLost': 'it never reached any open connection',
     'approval.settle.cause.streamDisconnected': 'the connection carrying this card dropped',
     'approval.settle.cause.undeliverable': 'it could not be delivered to any approval surface',
-    'approval.decide.requiresBinding': 'This decision was sent without the binding that ties it to the exact action on the approval card, so the engine refused it · Nothing was decided and the approval is still pending · Fetch the pending approvals again and decide from the card as it is listed now; if the listed card itself carries no binding, it cannot be decided here — cancel the run or let the approval expire',
+    'approval.decide.requiresBinding': 'This decision was sent without the binding that ties it to the exact action on the approval card, so the engine refused it · Nothing was decided and the approval is still pending · Fetch the pending approvals again and decide from the card as it is listed now; if the listed card itself carries no binding, {wayOut}',
+    'approval.decide.unboundWayOut': 'it cannot be decided here — cancel the run or let the approval expire',
+    'approval.rowUnresumable.fallback': 'this engine does not report that it can continue this pending approval, so it was not shown as a card that can be approved; nothing was sent',
+    'approval.rowUnresumable.askNotSurfaced': 'the pending row (task {taskId}) cannot be continued by this engine, so it is not surfaced as a card that can be answered: {sentence}',
+    'approval.park.stillParked': '{gate} gate could not be answered: {reason} — the run is still parked on this approval.',
     'approval.decision.grantChanged': 'The engine refused this approval because the skill grant it was bound to has changed since the card was shown · Nothing was decided and the request is still waiting, but approving it again will be refused the same way · Deny this request so the model can activate the skill again',
     'approval.decision.settledElsewhereContrary.deniedFirst': 'This request was already answered elsewhere and denied, so your approval did not take effect.',
     'approval.decision.settledElsewhereContrary.approvedFirst': 'This request was already answered elsewhere and approved, so your denial did not take effect.',
@@ -408,7 +412,7 @@ const EN = {
     'session.selfHeal.injected.handedOffWatch': '{lead} was passed to the reply already in progress{id} instead of starting a new one — watch that reply for what it does with it.',
     'session.selfHeal.injected.interruptedFinishing': '{lead} was not delivered: the earlier reply{id} that was stopped is still finishing, so sema did not send it and did not retry — the model has not seen it. Give it a moment, then try again.',
     'session.selfHeal.injected.notDelivered': '{lead} was not delivered: this session was still busy with an earlier reply{id}, and there was no open card you could answer to free it{noView}. sema did not retry, so the model has not seen it.',
-    'session.selfHeal.injected.redundant': '{lead} was not passed on: it was about the reply already in progress{id}, which has already resumed on its own, so it has nothing to add.',
+    'session.selfHeal.injected.redundant': '{lead} was not passed on: the reply it was about{id} resumed on its own after that decision, so it has nothing to add.',
     'session.selfHeal.injected.deferred': '{lead} is waiting: this session is busy with an earlier reply{id}, so sema kept the message and will send it as a new message once that reply has finished or paused.',
     'session.selfHeal.decisionInFlight': 'The previous turn is parked {parkedOn} and your answer to that card is still on its way to the engine, so sema did not show the card again — answering it a second time would send a second decision. It did NOT cancel the run. Your message was NOT sent; send it again in a moment, once the engine has applied that decision.',
     'session.selfHeal.parkedOn.ask': 'waiting for your decision (run {taskId})',
@@ -422,6 +426,7 @@ const EN = {
     'session.selfHeal.row.askDecided.inferred': 'The previous turn was parked on an approval that your permission rules decided on their own (no card was needed); run {taskId} resumed and has since finished — sema is re-sending your message; if that run has not fully let go of the session yet, you may have to send it once more.',
     'session.selfHeal.row.askDecided.releaseUnknown': 'The previous turn was parked on an approval that your permission rules decided on their own (no card was needed), so run {taskId} should be resuming{status}. sema could not yet confirm it finished, so your message was not sent — wait a moment and send it again.',
     'session.selfHeal.row.askReopenFailed.withKeep': 'The previous turn is parked waiting for your decision (run {taskId}) and sema could not reopen that card here{noView}. It did NOT cancel the run — that would have decided it for you. Your message was NOT sent. To keep this conversation, {keep}: the card comes back when the session resumes, if it is still waiting. Or {wayOut} if you no longer want it.{viaEngine}',
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': 'The previous turn is parked waiting for your decision (run {taskId}), but this engine cannot continue that pending request, so there is no card to reopen: {sentence} · {unbound}. It did NOT cancel the run. Your message was NOT sent.',
     'session.selfHeal.row.askReopenFailed.noKeep': 'The previous turn is parked waiting for your decision (run {taskId}) and sema could not reopen that card here{noView}. It did NOT cancel the run — that would have decided it for you. Your message was NOT sent; {wayOut} if you no longer want it.{viaEngine}',
     'session.selfHeal.row.planReopenFailed.dismissed': 'The previous turn is parked waiting for a plan review (run {taskId}), and you closed its approval card — {closed}. It did NOT cancel the run — that would have discarded the plan for you. Your message was NOT sent; send it again to bring the card back.',
     'session.selfHeal.row.planReopenFailed.withKeep': 'The previous turn is parked waiting for a plan review (run {taskId}) and sema could not reopen that approval card{noView}. It did NOT cancel the run — that would have discarded the plan for you. Your message was NOT sent. To keep this conversation, {keep}: the card comes back when the session resumes, if it is still waiting. Or {wayOut} if you no longer want that plan.{viaEngine}',
@@ -983,6 +988,7 @@ const EN = {
     'notice.wireRefusal.hostPosture.both': "The engine refused this request before anything ran: the request asked both for the shell to inherit this machine's whole environment and for bypassPermissions, and this deployment refused at least one of them; the refusal does not say which · {notLocal}; send it again without one or both (the whole-environment setting is honored only on a single-user deployment)",
     'notice.wireRefusal.hostPosture.unattributed': "The engine refused this request before anything ran: this deployment does not accept a setting in it that only a single-user deployment may use; the engine's own message names it · {notLocal}; send it again without that setting",
     'notice.wireRefusal.autonomyLane': 'The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting',
+    'notice.wireRefusal.sessionArchiveStamped': "This session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written · Delete the session and push it again",
     'notice.wireRefusal.unsupportedRule': 'The engine refused this request, so none of it took effect: a rule in it is a form the engine does not support — {detail} · Remove or rewrite that rule (to stop a tool altogether, write its name alone), then send it again',
     'notice.wireRefusal.unsupportedRule.other': 'The engine refused this request, so none of it took effect: {count} rules in it are forms the engine does not support — {detail} · Remove or rewrite those rules (to stop a tool altogether, write its name alone), then send it again',
     'notice.wireRefusal.unsupportedRule.stored': 'The engine refused to continue this work: the request stored for it has a rule in it that is a form the engine does not support — {detail} · It cannot continue as stored. Remove or rewrite that rule (to stop a tool altogether, write its name alone), cancel the work if it is still suspended, then submit it again as a new request',

package/dist/i18n/messages.zh.js

@@ -246,7 +246,11 @@ const ZH = {
     'approval.settle.cause.broadcastLost': '它没有送达任何一个打开着的连接',
     'approval.settle.cause.streamDisconnected': '承载这张卡的连接断了',
     'approval.settle.cause.undeliverable': '它没能送达任何审批界面',
-    'approval.decide.requiresBinding': '这次决定没有带上把它绑到审批卡上那个具体动作的绑定,引擎拒绝了 · 什么都没有决定,这条审批仍在等待 · 请重新获取待决审批,按现在列出的那张卡再决定;如果列出的卡本身就没有绑定,这里决不了 —— 取消这次运行,或等这条审批过期',
+    'approval.decide.requiresBinding': '这次决定没有带上把它绑到审批卡上那个具体动作的绑定,引擎拒绝了 · 什么都没有决定,这条审批仍在等待 · 请重新获取待决审批,按现在列出的那张卡再决定;如果列出的卡本身就没有绑定,{wayOut}',
+    'approval.decide.unboundWayOut': '这里决不了 —— 取消这次运行,或等这条审批过期',
+    'approval.rowUnresumable.fallback': '这台引擎没说它续得了这条待决审批,所以没有呈成可批的卡;什么都没发',
+    'approval.rowUnresumable.askNotSurfaced': '这条待决行(任务 {taskId})这台引擎续不了,所以没有呈成可作答的卡:{sentence}',
+    'approval.park.stillParked': '{gate} 这道门没能作答:{reason} —— 这一跑仍停在这条审批上。',
     'approval.decision.grantChanged': '引擎拒收了这次批准:它绑定的技能授予在卡呈出之后已经变了 · 什么都没有决定,这一请求仍在等待,但再批一次会以同样的理由被拒 · 请拒绝这一请求,让模型重新激活那个技能',
     'approval.decision.settledElsewhereContrary.deniedFirst': '这一请求已在别处被答复为拒绝,你的批准没有生效。',
     'approval.decision.settledElsewhereContrary.approvedFirst': '这一请求已在别处被答复为批准,你的拒绝没有生效。',
@@ -408,7 +412,7 @@ const ZH = {
     'session.selfHeal.injected.handedOffWatch': '{lead}已交给正在进行的那一轮回复{id},没有另开一轮 —— 请留意那一轮回复怎么处理它。',
     'session.selfHeal.injected.interruptedFinishing': '{lead}没有送达:被叫停的较早那一轮回复{id}仍在收尾,sema 没有发送它也没有重试,所以模型没有看到它。稍等片刻后再试一次。',
     'session.selfHeal.injected.notDelivered': '{lead}没有送达:这个会话还被较早的一轮回复占着{id},而且没有可以回答来放行的打开的卡{noView}。sema 没有重试,所以模型没有看到它。',
-    'session.selfHeal.injected.redundant': '{lead}没有转交:它说的就是正在进行的那一轮回复{id},那一轮回复已经自己接着往下走了,它没有什么可补充的。',
+    'session.selfHeal.injected.redundant': '{lead}没有转交:它说的那一轮回复{id}在那次决定之后已经自己接着往下走了,它没有什么可补充的。',
     'session.selfHeal.injected.deferred': '{lead}正在等待:这个会话正被较早的一轮回复{id}占着,sema 保留了这条消息,等那一轮回复结束或暂停后再作为一条新消息发送。',
     'session.selfHeal.decisionInFlight': '上一个 turn 处于 parked 状态,{parkedOn},而你对那张卡的回答还在送往引擎的路上,所以 sema 没有再次显示那张卡 —— 再回答一次会发出第二个决断。它没有取消这次 run。你的消息没有发出;请稍等片刻,等引擎应用了那个决断之后再发一次。',
     'session.selfHeal.parkedOn.ask': '在等你的决断(run {taskId})',
@@ -422,6 +426,7 @@ const ZH = {
     'session.selfHeal.row.askDecided.inferred': '上一个 turn 曾 parked 在一个审批上,你的权限规则自己做了决断(不需要卡);run {taskId} 已经 resume 并随后结束 —— sema 正在重新发送你的消息;如果那次 run 还没完全放开这个会话,你可能得再发一次。',
     'session.selfHeal.row.askDecided.releaseUnknown': '上一个 turn 曾 parked 在一个审批上,你的权限规则自己做了决断(不需要卡),所以 run {taskId} 应该正在 resume{status}。sema 还不能确认它已经结束,所以你的消息没有发出 —— 请稍等片刻再发一次。',
     'session.selfHeal.row.askReopenFailed.withKeep': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),而 sema 没能在这里重新打开那张卡{noView}。它没有取消这次 run —— 那等于替你做了决断。你的消息没有发出。想保住这段对话,请{keep}:会话 resume 之后,如果它还在等,那张卡会回来。如果你不再需要它,也可以{wayOut}。{viaEngine}',
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),而这台引擎续不了那条待决请求,所以没有卡可以重新打开:{sentence} · {unbound}。它没有取消这次 run。你的消息没有发出。',
     'session.selfHeal.row.askReopenFailed.noKeep': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),而 sema 没能在这里重新打开那张卡{noView}。它没有取消这次 run —— 那等于替你做了决断。你的消息没有发出;如果你不再需要它,请{wayOut}。{viaEngine}',
     'session.selfHeal.row.planReopenFailed.dismissed': '上一个 turn 处于 parked 状态,在等一次计划审阅(run {taskId}),而你关掉了它的审批卡 —— {closed}。它没有取消这次 run —— 那等于替你把计划丢掉了。你的消息没有发出;再发一次可以把卡叫回来。',
     'session.selfHeal.row.planReopenFailed.withKeep': '上一个 turn 处于 parked 状态,在等一次计划审阅(run {taskId}),而 sema 没能重新打开那张审批卡{noView}。它没有取消这次 run —— 那等于替你把计划丢掉了。你的消息没有发出。想保住这段对话,请{keep}:会话 resume 之后,如果它还在等,那张卡会回来。如果你不再需要那份计划,也可以{wayOut}。{viaEngine}',
@@ -983,6 +988,7 @@ const ZH = {
     'notice.wireRefusal.hostPosture.both': '引擎在任何东西运行之前就拒绝了这个请求:请求既要求 shell 继承这台机器的整份环境,又要求 bypassPermissions,而这个部署至少拒绝了其中一项;拒绝并没有说明是哪一项 · {notLocal};请去掉其中一项或两项后重新发送(整份环境设置只在单用户部署上才被采纳)',
     'notice.wireRefusal.hostPosture.unattributed': '引擎在任何东西运行之前就拒绝了这个请求:这个部署不接受请求里只有单用户部署才能使用的某项设置;引擎自己的消息会点名它 · {notLocal};请去掉那项设置后重新发送',
     'notice.wireRefusal.autonomyLane': '引擎没有启动这次 leader 运行:这个部署运行在只做计划的自主档,而 leader 运行没有办法让它的计划被审阅,所以什么也没有启动 · 请改为作为普通运行提交这项工作,或请运维这台引擎的人更改它的自主设置',
+    'notice.wireRefusal.sessionArchiveStamped': '这个会话存下的存档仍带着更早版本的服务端写下的属主戳,所以不能被 fork,也不能替换它的日志;什么都没有写入 · 请删除这个会话,然后重新推送',
     'notice.wireRefusal.unsupportedRule': '引擎拒绝了这个请求,所以其中任何内容都没有生效:里面有一条规则是引擎不支持的写法 —— {detail} · 请删掉或改写那条规则(要整只拦下一个工具,请只写工具名),再重新发送',
     'notice.wireRefusal.unsupportedRule.other': '引擎拒绝了这个请求,所以其中任何内容都没有生效:里面有 {count} 条规则是引擎不支持的写法 —— {detail} · 请删掉或改写这些规则(要整只拦下一个工具,请只写工具名),再重新发送',
     'notice.wireRefusal.unsupportedRule.stored': '引擎拒绝继续这件工作:为它保存的请求里有一条规则是引擎不支持的写法 —— {detail} · 它无法按保存的样子继续。请删掉或改写那条规则(要整只拦下一个工具,请只写工具名);若这件工作仍停驻着,请先取消它,然后作为新请求重新提交',
@@ -1201,6 +1207,7 @@ export const TERM_SLOTS = Object.freeze({
     'session.selfHeal.row.askDecided.releaseUnknown': ['parked', 'run', 'turn'],
     'session.selfHeal.row.askReopenFailed.withKeep': ['parked', 'run', 'turn'],
     'session.selfHeal.row.askReopenFailed.noKeep': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': ['parked', 'run', 'turn'],
     'session.selfHeal.row.planReopenFailed.dismissed': ['parked', 'run', 'turn'],
     'session.selfHeal.row.planReopenFailed.withKeep': ['parked', 'run', 'turn'],
     'session.selfHeal.row.planReopenFailed.noKeep': ['parked', 'run', 'turn'],

package/dist/index.d.ts

@@ -365,6 +365,7 @@ export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, allowRuleShadow
 export { projectCrashConverged } from './hitl/crashConverged.js';
 export type { ApprovalsListEnvelope, CrashConvergedOrphanState, CrashConvergedProjection, CrashConvergedRowReading } from './hitl/crashConverged.js';
 export type { ApprovalQueueKindedRow, ApprovalQueueRow } from './hitl/crashConverged.js';
+export { checkpointQueueRowSortOf, type CheckpointQueueRowSort } from './hitl/approvalQueueRow.js';
 export * from './hitl/crashConvergedNotice.js';
 export { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
 export { approvalCompleteCauseOf } from './hitl/approvalEndingCause.js';

package/dist/index.js

@@ -295,6 +295,7 @@ export { noAllowCauseOf } from './hitl/noAllowCause.js';
 export { policyDenyReason } from './hitl/frameRouter.js';
 export { readApprovalAllowRuleShadow, approvalAllowRuleShadowed, allowRuleShadowSentence, } from './hitl/allowRuleShadow.js';
 export { projectCrashConverged } from './hitl/crashConverged.js';
+export { checkpointQueueRowSortOf } from './hitl/approvalQueueRow.js';
 export * from './hitl/crashConvergedNotice.js';
 export { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
 export { approvalCompleteCauseOf } from './hitl/approvalEndingCause.js';

package/dist/injectionLaneNotice.js

@@ -1,3 +1,4 @@
+import { executionLaneWordIsNone } from './executionLaneWords.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export const INJECTION_SOURCES = Object.freeze(['stdio_mcp', 'credentialed_mcp', 'task_hooks']);
@@ -16,7 +17,7 @@ function remoteLaneWordOf(lane) {
             return undefined;
         if (view.toolsOnThisHost !== false)
             return undefined;
-        if (view.isolatedAbsent === 'no_hands' || view.provider === 'in-process')
+        if (view.isolatedAbsent === 'no_hands' || executionLaneWordIsNone(view.provider))
             return undefined;
         if (typeof view.provider !== 'string' || view.provider === '')
             return undefined;

package/dist/noticePresentation.js

@@ -102,6 +102,8 @@ const OCCURRENCE_KEY_BY_CODE = Object.freeze({
     'memory.hold_released': 'reportId',
     'memory.hold_disposed': 'reportId',
     'memory.consolidation_recommended': 'reportId',
+    'memory.harvest_refused': 'reportId',
+    'memory.harvest_conflict': 'reportId',
     'memory.capture_opted_out': 'sessionId',
     'memory.delegation_static_mark_waived': 'runId',
 });

package/dist/sdkWireTransit.d.ts

@@ -2,4 +2,4 @@ export { AgentClient } from '@sema-agent/sdk';
 export { isApprovalRequestFrameV1, isApprovalRevokeFrameV1 } from '@sema-agent/sdk';
 export { pushSessionBundle, pullSessionBundle, importSessionBundle, APIError } from '@sema-agent/sdk';
 export { APPROVAL_DECIDE_GATE_KINDS, PLAN_REVIEW_GATE_KINDS } from '@sema-agent/sdk';
-export type { TaskRequest, SessionPermissionRules, SemaSettings, SkillSpec, AgentEvent, RunReceipt, CancelAck, RunRecord, ToolApprovalRespondAck, FleetTaskRow, FleetWorkflowRow, ApprovalCard, ApprovalRequestFrame, ApprovalRiskAxes, AskDecisionAck, AskDecisionBody, PolicyInfo, CcImportLayer, CcImportPrepareResult, CcImportRedeemResult, CcImportSettingsLayer, CcImportSkippedRule, PersistedRule, RuleRevokeRequest, RuleRevokeResult, ApprovalDecideGateKind, PlanReviewGateKind, } from '@sema-agent/sdk';
+export type { TaskRequest, SessionPermissionRules, SemaSettings, SkillSpec, AgentEvent, RunReceipt, CancelAck, RunRecord, ToolApprovalRespondAck, FleetTaskRow, FleetWorkflowRow, ApprovalCard, ApprovalRequestFrame, ApprovalRiskAxes, AskDecisionAck, AskDecisionBody, PolicyInfo, CcImportLayer, CcImportPrepareResult, CcImportSettingsLayer, CcImportSkippedRule, PersistedRule, RuleRevokeRequest, RuleRevokeResult, ApprovalDecideGateKind, PlanReviewGateKind, } from '@sema-agent/sdk';

package/dist/seatContract.d.ts

@@ -21,6 +21,7 @@ export interface SeatValidationFailure {
     field?: string;
 }
 export type SeatValidation = true | SeatValidationFailure;
+export declare const isSecretKeyName: (k: string) => boolean;
 export type EipcMethodKind = "invoke" | "event";
 export interface EipcMethodSpec {
     kind: EipcMethodKind;

package/dist/seatContract.js

@@ -192,7 +192,9 @@ const keyWords = (k) => k
     .filter((w) => w.length > 0);
 const SECRET_KEY_WORDS = new Set(["token", "secret", "password", "passwd", "authorization", "bearer", "sealed"]);
 const SECRET_KEY_PAIRS = new Set(["api key", "device code", "access key", "private key"]);
-const isSecretKeyName = (k) => {
+export const isSecretKeyName = (k) => {
+    if (typeof k !== "string")
+        return false;
     const words = keyWords(k);
     for (let i = 0; i < words.length; i += 1) {
         if (SECRET_KEY_WORDS.has(words[i]))

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
@@ -139,6 +139,11 @@ export interface AutonomyLaneRefusalDetail {
 }
 export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
 export declare function autonomyLaneRefusalContent(lang?: UiLanguage): string;
+export interface SessionArchiveStampedDetail {
+    readonly code: typeof CONFLICT_SESSION_ARCHIVE_STAMPED;
+}
+export declare function sessionArchiveStampedFromError(err: {} | null | undefined): SessionArchiveStampedDetail | null;
+export declare function sessionArchiveStampedContent(lang?: UiLanguage): string;
 export interface UnsupportedRuleRefusalProblem {
     readonly code: string;
     readonly field?: string;

package/dist/wireRefusalCopy.js

@@ -1,6 +1,6 @@
 import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { appendOwnElement, guardedRead, readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -809,6 +809,12 @@ export function autonomyLaneRefusalFromError(err) {
 export function autonomyLaneRefusalContent(lang) {
     return renderMessage(msg('notice.wireRefusal.autonomyLane'), lang);
 }
+export function sessionArchiveStampedFromError(err) {
+    return effectiveWireErrorCode(err) === CONFLICT_SESSION_ARCHIVE_STAMPED ? { code: CONFLICT_SESSION_ARCHIVE_STAMPED } : null;
+}
+export function sessionArchiveStampedContent(lang) {
+    return renderMessage(msg('notice.wireRefusal.sessionArchiveStamped'), lang);
+}
 const REQUEST_UNPROCESSABLE = 'request.unprocessable';
 const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;
 const nonEmptyString = (v) => (typeof v === 'string' && v !== '' ? v : undefined);