@sema-agent/server 7.146.0 → 7.148.0

package/dist/task-settings.js

@@ -1,4 +1,4 @@
-import { combinePolicies, parseRuleText, resolveReasoningProfile, rankOf, isThinkingLevel, RUN_WORKFLOW_TOOL_NAME, PERMISSION_MODES, isPermissionMode, ruleToolGrammarOf, } from "@sema-agent/core";
+import { combinePolicies, parseRuleText, resolveReasoningProfile, rankOf, isThinkingLevel, RUN_WORKFLOW_TOOL_NAME, PERMISSION_MODES, isPermissionMode, ruleToolGrammarOf, hostChildEnvProblem, } from "@sema-agent/core";
 import { judgeUnmatchableToolNames } from "./config.js";
 import { NAME_TABLE_BEHAVIOR } from "./namespaced-rule-name.js";
 import { entryProblem } from "./entry-problems.js";
@@ -7,7 +7,7 @@ import { allowLayerEntryCountIssue, describeAllowLayerOverCap } from "./rule-ent
 import { limitRefusal } from "./limit-refusal.js";
 import { tightenGoverned } from "./governance-overrides.js";
 import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "./request-key-closure.js";
-import { hooksCoordinate, parseHooksConfig } from "./hooks/hook-runner.js";
+import { hooksFieldCoordinate, parseHooksConfig } from "./hooks/hook-runner.js";
 import { HTTP_HOOK_ALLOWLIST_KEYS, SETTINGS_SOURCES, containsSecretToken } from "@sema-agent/settings-schema";
 import { echoCallerText } from "./caller-text-echo.js";
 import { heldRuleName } from "./tool-rule-names.js";
@@ -78,6 +78,17 @@ export const MAX_SETTINGS_OUTPUT_STYLE_CHARS = 16_384;
 export const MAX_SETTINGS_ENV_VARS = 256;
 export const MAX_SETTINGS_ENV_VALUE_CHARS = 32_768;
 export const MAX_SETTINGS_ENV_KEY_CHARS = 256;
+function settingsEnvMemberReadable(k, val) {
+    return k.length > 0 && k.length <= MAX_SETTINGS_ENV_KEY_CHARS && typeof val === "string" && val.length <= MAX_SETTINGS_ENV_VALUE_CHARS;
+}
+function settingsEnvUnreadable(v) {
+    if (v === undefined || v === null)
+        return false;
+    if (typeof v !== "object" || Array.isArray(v))
+        return true;
+    const entries = Object.entries(v);
+    return entries.length > MAX_SETTINGS_ENV_VARS || entries.some(([k, val]) => !settingsEnvMemberReadable(k, val));
+}
 function cleanEnvMap(v) {
     if (v === null || typeof v !== "object" || Array.isArray(v))
         return undefined;
@@ -88,7 +99,7 @@ function cleanEnvMap(v) {
         if (n >= MAX_SETTINGS_ENV_VARS || seen >= MAX_SETTINGS_ENV_VARS * 8)
             break;
         seen++;
-        if (typeof k === "string" && k.length > 0 && k.length <= MAX_SETTINGS_ENV_KEY_CHARS && typeof val === "string" && val.length <= MAX_SETTINGS_ENV_VALUE_CHARS) {
+        if (settingsEnvMemberReadable(k, val)) {
             out[k] = val;
             n++;
         }
@@ -98,9 +109,9 @@ function cleanEnvMap(v) {
 export const SETTINGS_ENV_CREDENTIAL_MATCHES = ["name", "value_shape"];
 export function readSettingsEnv(settings) {
     if (settings === null || typeof settings !== "object" || Array.isArray(settings))
-        return { sent: false, reaching: undefined };
+        return { sent: false, reaching: undefined, unreadable: false };
     const env = settings.env;
-    return { sent: env !== undefined && env !== null, reaching: cleanEnvMap(env) };
+    return { sent: env !== undefined && env !== null, reaching: cleanEnvMap(env), unreadable: settingsEnvUnreadable(env) };
 }
 const MAX_CREDENTIAL_KEYS_NAMED = 8;
 const MATCH_PHRASE = { name: "a credential variable of this engine", value_shape: "a value shaped like a secret" };
@@ -129,9 +140,18 @@ export function settingsEnvCredentialIssue(reaching, credentialNames) {
         keys: hits.map((h) => h.key),
     };
 }
+const ENV_COMPOSE_REFUSAL_TAIL = "The request is refused rather than accepted into a task whose hooks and shell would fail to start: fix or remove the variable concerned";
+export function settingsEnvComposeIssue(reaching) {
+    if (reaching === undefined)
+        return null;
+    const verdict = hostChildEnvProblem([], reaching);
+    if (verdict === undefined)
+        return null;
+    return { message: `settings.env cannot be composed into a child process environment — ${echoCallerText(verdict, { maxChars: MAX_SETTINGS_ENV_KEY_CHARS + 128 })}. ${ENV_COMPOSE_REFUSAL_TAIL}`, field: "settings.env" };
+}
 export function withoutKeys(layer, keys) {
     const drop = new Set(keys);
-    return { sent: layer.sent, reaching: Object.fromEntries(Object.entries(layer.reaching ?? {}).filter(([k]) => !drop.has(k))) };
+    return { sent: layer.sent, reaching: Object.fromEntries(Object.entries(layer.reaching ?? {}).filter(([k]) => !drop.has(k))), unreadable: layer.unreadable };
 }
 export const SETTINGS_PERMISSION_BUCKETS = ["allow", "deny", "ask"];
 export const SETTINGS_PERMISSION_BUCKET_REFUSALS = ["over_cap", "bad_entry"];
@@ -250,7 +270,7 @@ export function hooksKeyIssue(raw, config) {
             return;
         for (const [key, value] of Object.entries(rawNode))
             if (value !== undefined && !Object.hasOwn(carried, key))
-                unknown.push(hooksCoordinate([...at, key]));
+                unknown.push(hooksFieldCoordinate([...at, key]));
     };
     for (const [event, groups] of Object.entries(config)) {
         for (const [groupIndex, group] of (groups ?? []).entries()) {
@@ -309,7 +329,7 @@ export function parseTaskSettings(raw, seats = {}) {
     }
     const envLayer = seats.settingsEnv ?? readSettingsEnv(s);
     const shellEnv = envLayer.reaching;
-    if (envLayer.sent && shellEnv === undefined)
+    if (envLayer.unreadable)
         deferred.push("env");
     const out = {};
     const perms = s.permissions;
@@ -383,16 +403,18 @@ export function acceptAppendSystemPrompt(v, warn) {
 const RULE_SOURCE_BY_BEHAVIOR = { ask: "settings.permissions.ask", deny: "settings.permissions.deny" };
 const WORKFLOW_ASK_NAMES = [RUN_WORKFLOW_TOOL_NAME];
 const isWorkflowName = (name) => name === RUN_WORKFLOW_TOOL_NAME;
-export function createWorkflowAskPolicy(isExempt) {
+export function createWorkflowAskPolicy(exemption) {
     return {
         async check(req) {
             if (heldRuleName(req, isWorkflowName) === undefined)
                 return { action: "allow" };
             const ask = { action: "ask", message: `dynamic workflow "${req.toolName}" requires approval in this permission mode`, decisionReason: "rule" };
-            if (isExempt && standingAnswerDurablyRecordable(policyAskStandingAnswerFacts(req, ask, false))) {
+            if (exemption && standingAnswerDurablyRecordable(policyAskStandingAnswerFacts(req, ask, false))) {
                 try {
-                    if (await isExempt(req.toolName))
+                    if (await exemption.has(req.toolName)) {
+                        exemption.onExempted(req.toolName);
                         return { action: "allow", decisionReason: "rule" };
+                    }
                 }
                 catch {
                 }
@@ -447,7 +469,7 @@ export function rulePolicyBucketsRefusal(permissions, bases) {
             if (names.length === 0)
                 continue;
             const declared = declaredFor(root);
-            const judged = judgeUnmatchableToolNames(`permissions.${bucket}`, names, { consumer: "rule-policy", behavior: bucket, ...(declared !== undefined ? { pathBases: declared } : {}) });
+            const judged = judgeUnmatchableToolNames(`permissions.${bucket}`, names, { consumer: "rule-policy", behavior: bucket, noticeSeat: "engine", ...(declared !== undefined ? { pathBases: declared } : {}) });
             if (judged === undefined)
                 continue;
             first ??= { bucket, message: judged.message };
@@ -556,7 +578,7 @@ export function deriveSettingsPolicy(settings, bases) {
 }
 export function neverAutoNamesRefusal(names) {
     const field = tightenOnlySeatField("neverAuto");
-    const judged = judgeUnmatchableToolNames(field.replace(/^settings\./, ""), names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR });
+    const judged = judgeUnmatchableToolNames(field.replace(/^settings\./, ""), names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR, noticeSeat: "server" });
     if (judged === undefined)
         return undefined;
     return { message: judged.message, problems: judged.bad.map((b) => entryProblem(SETTINGS_RULE_REFUSAL_CODE, field, b.name, b.reason)) };

package/dist/terminal.d.ts

@@ -1,24 +1,3 @@
-/**
- * 终局因由(`TaskResult.terminal`)的 server 侧**读**面 —— 一个叶子模块:依赖 `@sema-agent/core`、进程级记录器(`observability/fail-open.ts`)
- * 与秘密脱敏器(`trace/redact.ts`,只作码判官 {@link isCodeToken} 的一条合取);本仓的结果汇点 / 出口座反过来依赖本模块,本模块不依赖它们。
- *
- * core 7.6.0([ref] S6 D-8,BREAKING)把 `TaskResult` 上并列的八个平面键
- * (`status` / `errorCode` / `errorMessage` / `blockedReason` / `checkpointToken` / `checkpointId` /
- * `checkpointGate` / `workspaceRestoreMode`)删成**一条**带标因由 `terminal: TerminalCause`
- * (`completed` | `failed{code?,message?,nestedPause?}` | `blocked{reason}` | `paused{gate,token,…}`)。
- * 合法组合从此是**形状**而不是一串跨字段的口头约定(「`suspended` ⇔ 有 token」「review park 与 approval
- * park 不同时置位」)。
- *
- * ## 本仓的两条纪律(与 core 的单铸律配套)
- *
- * 1. **判断读因由,不读平面词**。`terminal.kind === "paused"` 是判据;`terminalProjection(terminal).status
- *    === "suspended"` 不是 —— 后者把一次投影塞进读点,于是同一个事实有了两个真源。
- * 2. **`terminalProjection` 只在明确的「投影出口」用一次**:必须继续说五词 `TaskStatus` 的那几张脸
- *    (run 行的 `status` / `error` 列、`tasks_total{status}` 计量标签、fleet 行的终态词)。出口之外不拼。
- *
- * wire 面(HTTP 任务体、SSE `done.result`)**就是结果本身**,所以它跟着 core 一起丢八键、带 `terminal`
- * —— 那里没有投影,只有转发(见 {@link sealResultForExit} 的例外)。
- */
 import { terminalProjection, type PausedCause, type TaskStatus, type TerminalCause } from "@sema-agent/core";
 /**
  * 这次失败带的**机器码**(`terminal.failed.code`);非失败终局 ⇒ `undefined`。
@@ -124,7 +103,8 @@ export declare function mapPauseSeats<T>(result: T, f: (seat: SeatObject, keys:
 /**
  * **一条结果离开引擎、进入本仓(可重放账本 / run 行 / wire)的唯一封口** —— 两件事,一个出口:
  *  ①摘掉**耐久恢复能力凭据**(`CheckpointToken`)—— 座表 {@link PAUSE_SEATS} 上的每一座;②把**域外的失败码**折成本仓的
- *  `internal.store_error`({@link outwardFailureCode},[ref])—— 码座两只:因由的 `terminal.code` 与 cascade 每一级的 `attempts[].errorCode`(同一类码,见 {@link foldOutwardFailureCodes})。
+ *  `internal.store_error`({@link outwardFailureCode},[ref])—— 码座两只:因由的 `terminal.code` 与 cascade 每一级的 `attempts[].errorCode`(同一类码,见 {@link foldOutwardFailureCodes});
+ *  因由上折码时**失败句同时换成对外句**(类别句 + 原码尾注,库驱动原句不上 wire,{@link outwardStoreFailure})。
  *
  * 🔴 为什么两件事合在一只函数里而不是并列两只(7.92.2 改名 `stripResumeToken` → `sealResultForExit`):
  * 它们是**同一个出口上的同一件事** —— 「这条结果可以见人了吗」。并列两只 = 六个结算点各自要记得调两次,
@@ -146,10 +126,10 @@ export declare function mapPauseSeats<T>(result: T, f: (seat: SeatObject, keys:
  * {@link sealStoredResult} —— 升级前落盘、还带着凭据的存量行在读面上同样摘掉。两件事都**幂等**,重复过口是同形。
  *
  * ── 折码的运维线索:一句定形字段,两只入口各说一只词 ──
- * 字段 `original=<码 | <not-a-code>> outward=<对外词> messageBytes=<n> at=<观看点>`,只有闭集词、数字与码({@link isCodeToken}):
- * 失败句只报字节数,**永不**报原文 —— 失败句是自由文本(驱动句里可以有连接串 / 口令),结果里的那份由结果汇点脱敏,运维线索没有汇点,
- * 所以压根不带它;码形座里装着文字的、长得像码的秘密同理只报 `<not-a-code>`。`at` 说这是哪一次观看,**一个入口一只词**(类型给定,不靠记得传):
- *  · 本函数 = 结果**第一次**离开引擎(店的写口 / 出口铸体)⇒ `at=exit`,每折一次一行 `[terminal] outward_failure_code_folded <字段>` —— 每次都是一件新的失败;
+ * 字段 `original=<码 | <not-a-code>> outward=<对外词> messageBytes=<n> at=<观看点>`,只有闭集词、数字与码({@link isCodeToken});码形座里装着文字的、长得像码的秘密同理只报 `<not-a-code>`。
+ * 失败句(库驱动原句,自由文本:可以有连接串 / 口令 / 库账号 / 表名)**不上 wire**({@link outwardStoreFailure}),只进**写入口**那一行的末尾格 `message=<JSON 串>` ——
+ * 经出口座的一句话行(`operator-log-text`:凭据形换记号、剥控制字符、有界),读座的再观看不带(同一行存量行每读一次就重放一次)。`at` 说这是哪一次观看,**一个入口一只词**(类型给定,不靠记得传):
+ *  · 本函数 = 结果**第一次**离开引擎(店的写口 / 出口铸体)⇒ `at=exit`,每折一次一行 `[terminal] outward_failure_code_folded <字段>[ message=<句>]` —— 每次都是一件新的失败;
  *  · {@link sealStoredResult} = 存量行的**再观看**(读座必填)⇒ 走 fail-open 纪律(登记 tag `server.terminal.stored-result-code-folded`):
  *    逐读计数 + 逐读探针行 + 每进程一次 warn,detail 即上面那句字段。读面每次轮询 / 每个观看者 / 每次重连都重放同一批行 ——
  *    计数让「旧失败被读了多少次」看得见,一次 warn 让日志不随读次放大;去重归记录器一只,不另造表。
@@ -166,6 +146,12 @@ export declare function sealResultForExit<T extends {
 export declare function sealStoredResult<T extends {
     readonly terminal?: unknown;
 }>(result: T, seat: StoredResultReadSeat): T;
+/**
+ * 腿**抛出**的错落进 run 行 `error` 列时的对外句(没有终局结果、没有因由的那一臂:`runs.ts` 后台腿的兜底腿与它的孪生 `resume-legs.ts` 兜底腿)—— 与终局因由是**同一只**
+ * 铸点({@link outwardStoreFailure}):抛出物自带的 `code`({@link errorCodeOf},字符串)出了本仓词法 ⇒ 同码同句;没有码 / 码在词法内(本仓与引擎自己的错、普通 `Error`)⇒ 文本逐字,非库错误照旧。
+ * `message` 是调用方已取出的抛出文本({@link errorText} 的产物,不抛);本函数不抛(读码口不抛)。
+ */
+export declare function outwardThrownMessage(err: unknown, message: string): string;
 /**
  * **投影出口的唯一属主**([ref])—— core 的 `terminalProjection` + 对外码归一,一次。
  *
@@ -208,30 +194,26 @@ export declare function pausedCauseOf(terminal: TerminalCause): PausedCause | un
  * **宿主边界上的诚实终局** —— 宿主 run 行停不停、停在哪个词上,只问这一只判官。
  *
  *  · 本腿自己的 `paused` ⇒ 原样(它就是宿主腿的停驻);
- *  · `failed.nestedPause` 且 `result.sessionId === hostSessionId` ⇒ 把那次停驻**整只**提成本腿的终局因由
- *    (门 / 凭据 / `checkpointId` 同址;结果的其余格 —— `stats` / `verification` / … —— 原样);
- *  · 其余 ⇒ **同一引用**原样(真失败;或嵌套停驻的卡不在宿主会话上)。
- *
- * 为什么判据是「停驻的那条腿跑在宿主会话上」:宿主的续跑链按会话把一张卡连回 run —— 决定腿按卡的会话找行
- * (`getActiveTaskId`)与续跑输入(`getCtx`),取消按 run 的会话找待决卡,过期收割按会话相等连行与卡。卡在宿主会话上,
- * 这条 run 才兑现得了它;判官只把兑现得了的停驻判成停驻。verify 的实现腿与修复轮跑在宿主会话上 ⇒ 提;cascade
- * 每级被引擎剥掉会话、级上的卡落在级自己现铸的会话上 ⇒ 不提(照常终局)。这不是按组合器分的特例:引擎让级上的卡落到
- * 宿主可连的会话上的那一天,答案随事实翻,本函数一个字不改。读 `result.sessionId` 而不去店里读卡:它与卡行的会话是同一次
- * `runTask` 的同一个量,零 I/O。
- *
- * 前提:结果出自 core 的组合器(可信产者)—— `failed.nestedPause` 只由引擎的嵌套边界包停驻铸,`paused` 只在卡行写入确认之后返回。
- * 判官**不**验证那张卡在不在、是不是这一张、此刻什么态;会话相等不是对卡的校验。验证器**自己**的停驻
- * (`verification.verifierPause`)不在结果因由里,本函数看不见它 —— 那一形照常终局;它那张卡本服务兑现不了,由结算点当场作废
+ *  · `failed.nestedPause` ⇒ 把那次停驻**整只**提成本腿的终局因由(门 / 凭据 / `checkpointId` 同址;结果的其余格 —— `stats` / `verification` / … —— 原样);
+ *  · 其余 ⇒ **同一引用**原样(真失败)。
+ *
+ * 为什么没有「停驻在不在宿主会话上」这一格:宿主的续跑链按**卡的归属会话**把卡连回 run(`checkpoint.host_session_id`,读法
+ * `plugins/checkpoint-index-columns.ts` 的 `hostSessionOf`:决断腿找 run 行与续跑输入、取消找 run 的卡、两条停驻收割、续跑输入回收都读它),
+ * 而组合入口在宿主边界上交回的每一次嵌套停驻,卡都归宿主的会话:verify 的实现腿与修复轮跑在宿主会话上(卡没有组合腿,归自己的会话 = 宿主会话);
+ * cascade 的每一级在自己现铸的会话里跑,卡上记着组合腿 `{ entry: "cascade", hostSessionId: spec.sessionId }`,归调用方的会话 = 宿主会话
+ * (本服务的组合写口恒带会话:提交腿没有不带会话的 run)。所以「宿主的续跑链兑现得了它」对每一次嵌套停驻都成立 —— 判官不读会话。
+ *
+ * 前提:结果出自 core 的组合器(可信产者),且组合器拿到的 spec 带宿主的会话 —— `failed.nestedPause` 只由引擎的嵌套边界包停驻铸,
+ * `paused` 只在卡行写入确认之后返回。判官**不**验证那张卡在不在、是不是这一张、此刻什么态。验证器**自己**的停驻
+ * (`verification.verifierPause`)不在结果因由里,本函数看不见它 —— 那一形照常终局;它那张卡归验证器自己的会话、本服务兑现不了,由结算点当场作废
  * (`verifier-pause-card.ts`),凭据由封口按座表摘。
  *
  * 纯函数,不读店、不抛。凭据随提升上来,摘除仍归 {@link sealResultForExit}(调用方照旧先 graft 后封口)。
  * 判官只答「该不该停驻」;认领保不保得住是停驻写口**写成功**与否的事(行写口对 `running` / `suspended` 行 CAS)。
- * `hostSessionId` 缺席 = 没有宿主会话 ⇒ 没有续跑链兑现得了嵌套停驻 ⇒ 原样(相等判自然为假,不另设臂)。
  */
 export declare function atHostBoundary<T extends {
     readonly terminal: TerminalCause;
-    readonly sessionId: string;
-}>(result: T, hostSessionId: string | undefined): T;
+}>(result: T): T;
 /**
  * **持久 blob 的平面读面** —— 把一条**任何年代**的持久终局结果读成五词 `status` + 三个平面文本格。
  *

package/dist/terminal.js

@@ -1,7 +1,10 @@
+import { writeLogText } from "./observability/logger.js";
 import { terminalProjection } from "@sema-agent/core";
 import { errorCodeOf } from "./observability/err-text.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { redactSecrets } from "./trace/redact.js";
+import { seatText } from "./trace/exit-seat.js";
+import { storeFaultSentenceOfCode } from "./plugins/store-fault.js";
 export function failureCodeOf(terminal) {
     return terminal.kind === "failed" ? terminal.code : undefined;
 }
@@ -72,12 +75,24 @@ function foldCauseCode(terminal, at) {
     const t = failedCauseWithCode(terminal);
     if (t === undefined)
         return terminal;
-    const outward = outwardFailureCode(t.code);
-    if (outward === t.code)
+    if (outwardFailureCode(t.code) === t.code)
         return terminal;
-    reportFold(t.code, outward, t.message, at);
-    const message = typeof t.message === "string" ? t.message : "the durable store failed";
-    return { ...t, code: outward, message: `${message} [original code: ${t.code}]` };
+    const folded = outwardStoreFailure(t.code, t.message, at);
+    return { ...t, code: folded.code, message: folded.message };
+}
+function outwardStoreFailure(code, message, at) {
+    const outward = outwardFailureCode(code);
+    reportFold(code, outward, message, at);
+    return { code: outward, message: outwardStoreMessage(code) };
+}
+function outwardStoreMessage(code) {
+    return `${storeFaultSentenceOfCode(code)} [original code: ${code}]`;
+}
+export function outwardThrownMessage(err, message) {
+    const code = errorCodeOf(err);
+    if (code === undefined || outwardFailureCode(code) === code)
+        return message;
+    return outwardStoreFailure(code, message, "exit").message;
 }
 function foldAttemptCodes(attempts, at) {
     if (!Array.isArray(attempts))
@@ -102,9 +117,11 @@ function reportFold(code, outward, message, at) {
     const messageBytes = typeof message === "string" ? Buffer.byteLength(message, "utf8") : 0;
     const fields = `original=${isCodeToken(code) ? code : "<not-a-code>"} outward=${outward} messageBytes=${messageBytes} at=${at}`;
     switch (at) {
-        case "exit":
-            console.warn(`[terminal] outward_failure_code_folded ${fields}`);
+        case "exit": {
+            const sentence = typeof message === "string" && message !== "" ? ` message=${JSON.stringify(seatText("operator-log-text", message))}` : "";
+            writeLogText("stderr", `[terminal] outward_failure_code_folded ${fields}${sentence}`);
             return;
+        }
         case "run.result":
         case "ev.done.result":
             recordFailOpen(STORED_RESULT_FOLD_TAG, fields);
@@ -126,7 +143,9 @@ export function outwardPlane(terminal) {
     if (plane.errorCode === undefined)
         return plane;
     const outward = outwardFailureCode(plane.errorCode);
-    return outward === plane.errorCode ? plane : { ...plane, errorCode: outward };
+    if (outward === plane.errorCode)
+        return plane;
+    return plane.status === "failed" ? { ...plane, errorCode: outward, errorMessage: outwardStoreMessage(plane.errorCode) } : { ...plane, errorCode: outward };
 }
 export function nestedPauseOf(terminal) {
     return terminal.kind === "failed" ? terminal.nestedPause : undefined;
@@ -134,9 +153,9 @@ export function nestedPauseOf(terminal) {
 export function pausedCauseOf(terminal) {
     return terminal.kind === "paused" ? terminal : nestedPauseOf(terminal);
 }
-export function atHostBoundary(result, hostSessionId) {
+export function atHostBoundary(result) {
     const parked = nestedPauseOf(result.terminal);
-    if (parked === undefined || result.sessionId !== hostSessionId)
+    if (parked === undefined)
         return result;
     return { ...result, terminal: parked };
 }
@@ -162,10 +181,11 @@ export function persistedPlaneOf(result) {
             };
         }
     }
+    const flatFolded = typeof r.errorCode === "string" && outwardFailureCode(r.errorCode) !== r.errorCode;
     return {
         ...(typeof r.status === "string" ? { status: r.status } : {}),
         ...(typeof r.errorCode === "string" ? { errorCode: outwardFailureCode(r.errorCode) } : {}),
-        ...(typeof r.errorMessage === "string" ? { errorMessage: r.errorMessage } : {}),
+        ...(typeof r.errorMessage === "string" ? { errorMessage: flatFolded && typeof r.errorCode === "string" ? outwardStoreMessage(r.errorCode) : r.errorMessage } : {}),
         ...(typeof r.blockedReason === "string" ? { blockedReason: r.blockedReason } : {}),
     };
 }