@sema-agent/server 7.131.0 → 7.132.0

package/dist/http/routes/runs.js

@@ -17,7 +17,7 @@ import { ASK_DECISION_CONSUMER_ABSENT, outcomeOfDecidedRow, resolveStreamApprova
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
 import { causeOfAskRow } from "../../approval-deny-reasons.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
-import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
+import { sendJson, sendError, sendHttpError, sseHeaders } from "../send.js";
 import { mintCancelledResult } from "../../run-cancel-context.js";
 import { acceptedInputKindOf } from "../../user-input-ledger.js";
 import { INJECTION_TIERS } from "../../trace/injection-tier.js";
@@ -405,7 +405,7 @@ export async function handleRuns(req, res, match, ctx) {
         }
         catch (e) {
             if (e instanceof HttpError) {
-                sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
+                sendHttpError(res, e);
                 return;
             }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
@@ -693,7 +693,7 @@ export async function handleRuns(req, res, match, ctx) {
             }
             if (mintResult.unservable !== undefined) {
                 deps.logger?.warn?.("steer_wake_park_refused_stored_body", { taskId, sessionId: run.sessionId, ...storedBodyReplayLogFields(mintResult.unservable) });
-                const { status, body: { error, errorCode, ...rest } } = storedBodyReplayAnswer(mintResult.unservable, serviceVersion());
+                const { status, body: { error, errorCode, ...rest } } = storedBodyReplayAnswer(mintResult.unservable, serviceVersion(), false);
                 sendError(res, status, errorCode, error, rest);
                 return;
             }
@@ -730,7 +730,7 @@ export async function handleRuns(req, res, match, ctx) {
         }
         catch (e) {
             if (e instanceof HttpError) {
-                sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
+                sendHttpError(res, e);
                 return;
             }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
@@ -893,7 +893,7 @@ export async function handleRuns(req, res, match, ctx) {
         }
         catch (e) {
             if (e instanceof HttpError) {
-                sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
+                sendHttpError(res, e);
                 return;
             }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
@@ -944,7 +944,7 @@ export async function handleRuns(req, res, match, ctx) {
         }
         catch (e) {
             if (e instanceof HttpError) {
-                sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
+                sendHttpError(res, e);
                 return;
             }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
@@ -1170,7 +1170,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         }
         catch (e) {
             if (e instanceof HttpError) {
-                sendError(res, e.status, httpErrorCode(e.status, e.code), e.message);
+                sendHttpError(res, e);
                 return;
             }
             sendError(res, 400, "request.invalid_json", "invalid JSON body");

package/dist/http/routes/session-sync.js

@@ -6,6 +6,7 @@ import { exportSessionManifest, fileHistoryImportFace, replayFileHistory, replay
 import * as facts from "../../capability-facts.js";
 import { classifySyncRelationshipByIds, SyncConflictError } from "../../session-sync-kernel.js";
 import { isUuidShape } from "../../security.js";
+import { sqlBlobCapRefusalText } from "../../plugins/blob-backend.js";
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, msg } from "../send.js";
 import { buildDisplaySafeUrl } from "../../trace/redact.js";
 import { gatedPrincipal, explicitOperatorOk, sendUnauthorized } from "../principal-gate.js";
@@ -186,8 +187,9 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const fs = blobs.historyStore;
                 const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
-                if (deps.snapshotBlobSqlCapBytes !== undefined && body.byteLength > deps.snapshotBlobSqlCapBytes) {
-                    sendError(res, 413, "blob_too_large_for_sql", `blob of ${body.byteLength} bytes exceeds this deployment's SQL snapshot-blob cap (${deps.snapshotBlobSqlCapBytes} bytes — TiDB's txn-entry-size-limit is the low wall at 6MiB by default; the mysql-protocol packet limit sits above it) — configure MinIO object storage (MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY) for large snapshot blobs, or raise SNAPSHOT_BLOB_SQL_MAX_BYTES if your deployment lifted those limits`);
+                const sqlCap = deps.snapshotBlobSqlCap?.();
+                if (sqlCap !== undefined && body.byteLength > sqlCap.capBytes) {
+                    sendError(res, 413, "blob_too_large_for_sql", sqlBlobCapRefusalText(body.byteLength, sqlCap), { wallSource: sqlCap.source });
                     return;
                 }
                 if (createHash("sha256").update(body).digest("hex") !== hash) {

package/dist/http/routes/sessions.js

@@ -54,7 +54,7 @@ async function readLastLegMcp(deps, sessionId, principal) {
     const latest = await runStore.latestRunForSession(sessionId);
     if (latest === undefined)
         return undefined;
-    if (!sessionOwnerReadable(principal, latest.owner, deps.config) && !explicitOperatorOk(principal, deps.config.operatorPrincipals))
+    if (!sessionOwnerReadable(principal, latest.owner, deps) && !explicitOperatorOk(principal, deps.config.operatorPrincipals))
         return undefined;
     const events = await runStore.getEvents(latest.taskId, 0);
     for (let i = events.length - 1; i >= 0; i--) {

package/dist/http/routes/shared-memory.js

@@ -1,21 +1,10 @@
-import { SHARED_MEMORY_READ_CAP_BYTES, SharedMemoryStoreError } from "@sema-agent/core";
+import { isSharedMemoryDocumentPath, SHARED_MEMORY_READ_CAP_BYTES, SharedMemoryStoreError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 const RETRY_AFTER_SEC = 10;
 const HTTP_LIST_LIMIT = 100;
-const FORBIDDEN_PATH_CHARS = /[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Default_Ignorable_Code_Point}\u2028\u2029\\]/u;
-const DOCUMENT_SUFFIXES = [".md", ".txt", ".json", ".jsonl"];
-function isDocumentPath(path) {
-    if (!path.startsWith("/") || FORBIDDEN_PATH_CHARS.test(path))
-        return false;
-    const segments = path.slice(1).split("/");
-    const last = segments.at(-1);
-    if (last === undefined || !segments.every((s) => s !== "" && !s.startsWith(".")))
-        return false;
-    return DOCUMENT_SUFFIXES.some((s) => last.endsWith(s));
-}
 function refuseStore(res) {
     sendError(res, 404, "not_found.shared_memory_store", "not found");
 }
@@ -120,7 +109,7 @@ export async function handleSharedMemory(req, res, match, ctx) {
                 return;
             }
             const path = query.get("path");
-            if (path === null || path === "" || !isDocumentPath(path)) {
+            if (path === null || path === "" || !isSharedMemoryDocumentPath(path)) {
                 sendError(res, 400, "request.query_invalid", "missing or malformed ?path= (absolute, .md/.txt/.json/.jsonl)");
                 return;
             }

package/dist/http/routes/side-query.js

@@ -4,7 +4,7 @@ import { isAtMentionable, matchCatalogModel, refusedCatalogEntry, selectableCata
 import { modelUnavailableMessage } from "../../model-entry-refusal.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { admitProviderEcho, redactErrorMessage } from "../../observability/run-terminal.js";
-import { sendJson, sendError, httpErrorCode, msg } from "../send.js";
+import { sendJson, sendError, sendHttpError, msg } from "../send.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 const CORE_PREFLIGHT_VALIDATION_PREFIXES = ["Unknown model ref ", "No model for role "];
@@ -50,8 +50,7 @@ export async function handleSideQuery(req, res, match, ctx) {
                     body = raw;
                 }
                 catch (e) {
-                    const he = e instanceof HttpError ? e : new HttpError(400, msg(e));
-                    sendError(res, he.status, httpErrorCode(he.status, he.code), he.message);
+                    sendHttpError(res, e instanceof HttpError ? e : new HttpError(400, msg(e)));
                     return;
                 }
                 if (!Array.isArray(body.messages) || body.messages.length === 0) {

package/dist/http/routes/tasks.js

@@ -1,6 +1,6 @@
 import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { runWithVerification, runCascade, taskNotificationDedupKey, uuidv7 } from "@sema-agent/core";
-import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, HEARTBEAT_MS } from "../../runs.js";
+import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, HEARTBEAT_MS } from "../../runs.js";
 import { sealResultForExit, outwardPlane } from "../../terminal.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
@@ -14,7 +14,7 @@ import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "..
 import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { liveToolEndForBacklog } from "../../trace/tool-output-media.js";
-import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, textEndEventData, liveIdentityFields } from "../../trace/project.js";
+import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, textEndEventData, liveIdentityFields } from "../../trace/project.js";
 import { cascadeConfig, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { replayOfExistingRun } from "../submit-replay.js";
@@ -30,7 +30,7 @@ import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/
 import { buildSyncSubmitBody } from "../sync-submit-body.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
-import { buildCheckpointCtx } from "../checkpoint-ctx.js";
+import { persistSubmitCtx } from "../submit-ctx.js";
 import { serviceVersion } from "../../service-version.js";
 import { withModelReachScope } from "../../model-reach-scope.js";
 import { createInstructionSelectionLeg } from "../../instruction-selection.js";
@@ -286,14 +286,18 @@ export async function handleTasks(req, res, match, ctx) {
                     }
                     durableTaskId = tid;
                 }
+                if (deps.checkpointStore && prepared.spec.sessionId) {
+                    const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared.spec.sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() });
+                    if (ctxRefusal) {
+                        sseData(res, { type: "done", result: doneResultOfOutcome(ctxRefusal) });
+                        return ctxRefusal;
+                    }
+                }
                 commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
                 if (prepared.spec.sessionId)
                     markChildrenStoppedByUserOnAbort(ac.signal, durableTaskId ?? prepared.spec.sessionId, prepared.auth?.principal);
                 let ledgerSink;
                 let ledgerTerminal = false;
-                if (deps.checkpointStore && prepared.spec.sessionId) {
-                    await deps.checkpointStore.putCtx(prepared.spec.sessionId, buildCheckpointCtx({ body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() }));
-                }
                 if (durableTaskId && deps.runStore) {
                     const rs = deps.runStore;
                     const tid = durableTaskId;
@@ -541,6 +545,9 @@ export async function handleTasks(req, res, match, ctx) {
                                 else if (ev.type === "compaction_outcome") {
                                     sseData(res, { type: "compaction_outcome", ...compactionOutcomeEventData(ev) });
                                 }
+                                else if (ev.type === "compaction_started") {
+                                    sseData(res, { type: "compaction_started", ...compactionStartedEventData(ev) });
+                                }
                                 else if (ev.type === "wiring_manifest") {
                                     const wiringFace = wiringManifestFaceEventData(ev, wiringOperatorFace, instructionLeg.segment());
                                     wiringReceipt ??= wiringFace;
@@ -857,10 +864,12 @@ export async function handleTasks(req, res, match, ctx) {
                         return { status: placementReject.status, body: devicePlacementErrorBody(placementReject) };
                     durableTaskId = tid;
                 }
-                commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
                 if (deps.checkpointStore && prepared.spec.sessionId) {
-                    await deps.checkpointStore.putCtx(prepared.spec.sessionId, buildCheckpointCtx({ body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() }));
+                    const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared.spec.sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() });
+                    if (ctxRefusal)
+                        return ctxRefusal;
                 }
+                commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
                 const syncCancelCtrl = createRunAbort();
                 if (prepared.spec.sessionId)
                     markChildrenStoppedByUserOnAbort(syncCancelCtrl.signal, durableTaskId ?? prepared.spec.sessionId, prepared.auth?.principal);
@@ -933,7 +942,8 @@ export async function handleTasks(req, res, match, ctx) {
                     const retryAfterSec = resumeAtPlane.errorCode === "memory.admission_required" && result.retryAfterMs !== undefined
                         ? Math.max(1, Math.ceil(result.retryAfterMs / 1000))
                         : undefined;
-                    return { status: resumeAtStatus, body: { errorCode: resumeAtPlane.errorCode, error: redactErrorMessage(resumeAtPlane.errorMessage) ?? "resume-at failed", ...(retryAfterSec !== undefined ? { retryAfterSec } : {}) } };
+                    const refusalFacts = zeroWorkRefusalFacts(redactTerminalResult(sealResultForExit(result)).terminal);
+                    return { status: resumeAtStatus, body: { errorCode: resumeAtPlane.errorCode, error: redactErrorMessage(resumeAtPlane.errorMessage) ?? "resume-at failed", ...(retryAfterSec !== undefined ? { retryAfterSec } : {}), ...refusalFacts } };
                 }
                 const exitResult = await mintSubmitExitResult(result, deps.checkpointStore);
                 const syncPlane = outwardPlane(result.terminal);

package/dist/http/send.d.ts

@@ -10,6 +10,7 @@
 import type { ServerResponse } from "node:http";
 import { type SessionErrorFace } from "../session-error-wire.js";
 import type { HttpError } from "../security.js";
+import { type Refusal, type RefusalBody } from "./refusal-body.js";
 /**
  * [ref](黑板 [ref]②)—— 一条响应「是 SSE 流」的**在场标记**。
  *
@@ -70,19 +71,20 @@ export declare function sendJson(res: ServerResponse, status: number, body: unkn
  *  change), not a new response shape. Sites where the two machine-code channels genuinely disagree, or
  *  where `error`/`errorCode` aren't cleanly separable from the rest of the body, are left on raw
  *  `sendJson` (see the A6 migration notes for the callers still doing that on purpose). */
-export declare function sendError(res: ServerResponse, status: number, errorCode: string, message: string, extra?: Record<string, unknown>): void;
+export declare function sendError(res: ServerResponse, status: number, errorCode: string, message: string, extra?: Readonly<Record<string, unknown>>): void;
 /** B7([ref] lens1 §C3):`HttpError` 的兜底 catch-all 站点没有自己的语义分支——`err.code` 在 42 个
  *  throw 点里只有 3 个带。为了让「errorCode 恒在」在这些站点也成立(而不是靠豁免表放行),按**状态码**
  *  给一个诚实的粗码:它只声明「这类拒绝」,不冒充比 throw 点更细的语义。带 `code` 的 throw 点原样优先。 */
 export declare function httpErrorCode(status: number, code?: string): string;
 /**
- * 一只 `HttpError` 的**拒体成员**:`{ error, errorCode, ...extra }` —— 码经 {@link httpErrorCode}(带码的 throw 原样优先,否则按状态给粗码),
- * 句 = `message`,`extra`(拒的机读事实,如场景门的 `detail: { scenario, source }`)原样随体、排在最后。**全仓唯一组句器**:整面拒({@link sendHttpError}:
- * 全局兜底 catch 与准入段的 typed 拒)与把同一只拒当**数据**带进 200 体的面板(`GET /v1/sessions/:id/mcp` 的 `scenarioRefusal`)读的是它 ——
- * 同一只错在两处渲出的成员逐字同,面板不自己拼 `{ errorCode, error }`(拼了就丢 `extra`:壳分不出这次门拒是中心指派漂了还是部署缺省悬空)。
+ * 一只 `HttpError` 读成 {@link Refusal}:码经 {@link httpErrorCode}(带码的 throw 原样优先,否则按状态给粗码),句 = `message`,机读事实 = `extra`
+ * (如场景门的 `detail: { scenario, source }`、条数帽的 `field` / `reason` / `count` / `cap`)。**拆 `HttpError` 的唯一一处** —— 别的站点自己拆
+ * `status` / `code` / `message` 拼体就丢了 `extra`(`test/refusal-one-composer.test.ts` 的静态门钉着)。
  */
-export declare function httpErrorBody(e: HttpError): Record<string, unknown>;
-/** 整面拒:状态 = `e.status`,体 = {@link httpErrorBody}。 */
+export declare function httpErrorRefusal(e: HttpError): Refusal;
+/** 一只 `HttpError` 的拒体成员 = {@link refusalBody}({@link httpErrorRefusal})。 */
+export declare function httpErrorBody(e: HttpError): RefusalBody;
+/** 整面拒:状态 = `e.status`,体 = {@link httpErrorBody}。手里拿着一只 `HttpError` 的路由站点一律调它。 */
 export declare function sendHttpError(res: ServerResponse, e: HttpError): void;
 /**
  * 🔴 B1 / S-535 —— `SessionPolicyError` → 应答,经 {@link sessionPolicyErrorHttp} 那**一只**映射

package/dist/http/send.js

@@ -2,6 +2,7 @@ import { SessionError, SessionPolicyError } from "@sema-agent/core";
 import { sessionPolicyErrorFacts, sessionPolicyErrorHttp, sessionPolicyErrorSentence } from "../session-policy-wire.js";
 import { sessionErrorHttp } from "../session-error-wire.js";
 import { redactErrorMessage } from "../observability/run-terminal.js";
+import { refusalBody } from "./refusal-body.js";
 export const SSE_RESPONSE_MARK = Symbol("sema.http.sse-response");
 export function isSseResponse(res) {
     return res[SSE_RESPONSE_MARK] === true;
@@ -31,7 +32,7 @@ export function sendJson(res, status, body) {
     res.end(JSON.stringify(body));
 }
 export function sendError(res, status, errorCode, message, extra) {
-    sendJson(res, status, { error: message, errorCode, ...extra });
+    sendJson(res, status, refusalBody(extra === undefined ? { errorCode, message } : { errorCode, message, facts: extra }));
 }
 export function httpErrorCode(status, code) {
     if (code)
@@ -48,8 +49,12 @@ export function httpErrorCode(status, code) {
         default: return status >= 500 ? "internal.error" : "request.rejected";
     }
 }
+export function httpErrorRefusal(e) {
+    const errorCode = httpErrorCode(e.status, e.code);
+    return e.extra === undefined ? { errorCode, message: e.message } : { errorCode, message: e.message, facts: e.extra };
+}
 export function httpErrorBody(e) {
-    return { error: e.message, errorCode: httpErrorCode(e.status, e.code), ...e.extra };
+    return refusalBody(httpErrorRefusal(e));
 }
 export function sendHttpError(res, e) {
     sendJson(res, e.status, httpErrorBody(e));

package/dist/http/server.d.ts

@@ -10,6 +10,7 @@ import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchor
 import type { RuleConsentLane } from "../rules-consent.js";
 import { type MemorySyncRequest, type MemorySyncResponse } from "../memory-sync.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
+import type { SqlBlobCapReading } from "../plugins/blob-backend.js";
 import type { LeaderEndpoint } from "../leader/endpoint.js";
 import { type WorkflowAgentRegistry } from "../orchestration/workflow-agent-steer.js";
 import type { SubagentSteerRegistry } from "../orchestration/subagent-steer.js";
@@ -34,11 +35,10 @@ export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
 import { MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
-import { hasServiceAuth } from "./dispatch.js";
 import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath } from "./route-table.js";
 export { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, hasServiceAuth };
 export { MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills };
-import { explicitOperatorOk, isOperator } from "./principal-gate.js";
+import { explicitOperatorOk, isOperator, hasServiceAuth } from "./principal-gate.js";
 export { explicitOperatorOk, isOperator };
 /** Per-request authorization context resolved before building the spec (identity, owned session). */
 export interface RequestAuth {
@@ -777,12 +777,18 @@ export interface ServiceDeploymentDeps {
      *  `GET /v1/capabilities` 的 `memoryEngine` 位(窄投影)。缺席 = 这个进程不是由 composition root 装
      *  起来的(测试夹具形)⇒ 诊断面报 null、能力位取诚实下限 false。 */
     memoryPosture?: import("../memory-posture.js").MemoryPosture;
-    /** S-131:SQL 引擎姿态的 **live getter**(`sql-engine-posture.ts` 的单一推导点 —— boot 期借一条池连接
-     *  触发驱动的连接初始化,读的是 `SET` 之后**回读复核**过的真值)。两个读面共用:
-     *  `GET /v1/diagnostics/wiring` 的 `sqlEngine` 段(operator-only,全量含版本)与 `GET /v1/capabilities`
-     *  的 `store.sql` 位(窄投影;7.106.0 前是顶层 `sql`,S-866 ①)。getter 而不是快照:池重连后驱动会重新初始化并刷新事实,快照会说谎。
-     *  缺席 / 返回 null = 本部署没有 SQL 后端(env-only worker、local 文件后端)—— 诚实缺席,不铸空壳。 */
-    sqlEngineFacts?: () => import("../plugins/sql-driver.js").SqlEngineFacts | null;
+    /** S-131:SQL **引擎读口**(`sql-engine-posture.ts` 的单一推导点 —— boot 期借一条池连接触发驱动的连接初始化,交回本池的驱动:
+     *  `dialect`(SQL 文本轴,恒在)+ 活的 `facts`(`SET` 之后**回读复核**过的真值;池重连后驱动会重新初始化并刷新,快照会说谎)。
+     *  读者:`GET /v1/diagnostics/wiring` 的 `sqlEngine` 段(operator-only,全量含版本与两堵墙)与 `GET /v1/capabilities` 的 `store.sql` 位(窄投影;
+     *  7.106.0 前是顶层 `sql`,S-866 ①)读 `facts`;提交受理口的 413 把整只读口交给唯一判官 `sql-driver.ts` `sqlWallsOf`(本服务的装配另用同一只读口铸
+     *  `snapshotBlobSqlCap`,`PUT /sync/blobs` 的前置帽)—— 墙的方言只从这里来(与事实同出一只驱动),不另从店后端读。
+     *  两种缺席、两个值:**席缺席** = 本部署没有 SQL 后端(env-only worker、local 文件后端);**`facts` 是 `null`** = 有 SQL 后端、但事实此刻没建立
+     *  (池上最近一次连接初始化被拒,驱动当场作废了事实)。两者在两个读面上都报缺席(诚实缺席,不铸空壳);墙按方言读后者(MySQL 协议 ⇒ 最保守的假定墙)。
+     *  7.132.0 前这一席是 `sqlEngineFacts: () => SqlEngineFacts | null`(只给事实、不给方言);照旧传它 ⇒ `createHttpServer` 起服拒。
+     *  🔴 **SQL 后端在场(`backend` 交出了 `mysqlPool()` / `pgPool()`)⇒ 本席必填**,缺席 ⇒ `createHttpServer` 起服拒(席缺席只表示「没有 SQL 后端」,不能是「忘了给」);
+     *  本服务自己的装配(`boot/stores.ts` → `stage-10`)按同一个谓词(`sqlPoolsOf`)建立它,恒给。值形也在起服时判(同一只判官 `sqlEngineSeatIssue` 的另一臂):
+     *  `{ dialect: "tidb" | "pg", facts }`,`facts` 是 `null` 或带 `maxRowBytes` / `maxPacketBytes` / `wallSources` 的引擎事实;只改了键名的 `() => facts` 之类 ⇒ 起服拒。 */
+    sqlEngine?: import("../plugins/sql-driver.js").SqlEngineReading;
     /** S-138:**写保护名表**的姿态(`write-protection.ts` 的 boot 期单一推导点 —— 与递给每只 Runner 的
      *  `writeProtectedPaths` 座同一份 config 决定)。两个读面共用:`GET /v1/diagnostics/wiring` 的
      *  `writeProtection` 段(operator-only,**逐行**表 + 来源 + 被丢的缺省行名)与 `GET /v1/capabilities`
@@ -821,10 +827,14 @@ export interface ServiceDeploymentDeps {
 /** **数值旋钮**:部署可调的上限/拍距。缺省值写在消费点(`?? 256` 之类),此处只承载覆写。 */
 export interface ServiceKnobDeps {
     /** (a)(clay 拍 a+c,2026-07-27)当快照 blob 走 SQL 默认店时(逃生口形/覆写形),该店的 per-blob
-     *  承载帽——PUT /sync/blobs 面据此**前置 413**(typed `blob_too_large_for_sql`)。不设=不前置(MinIO
-     *  形无帽)。为什么在 HTTP 面重复店里的检查:店的 never-throw 结果形把一切写失败折成 502,而 502
+     *  承载帽的**读口**——PUT /sync/blobs 面每个请求调一次、据此**前置 413**(typed `blob_too_large_for_sql`)。
+     *  键缺席=不前置(MinIO 形无帽);读口答 `undefined`=此刻没有墙(pg 形)=不前置。读口而非数字:帽由库报的墙推导,
+     *  库调墙、池连接换代后活事实会变,门限必须跟着变(与店写口 `SqlBlobBackend` 读同一份池级事实、同一只函数
+     *  `sqlBlobCapOf`)。读口答的是**帽 + 它的出处**(`{ capBytes, source }`,`source` ∈ `operator` / `reported` / `assumed`,见 `SqlBlobCapReading`):
+     *  413 的句子与机读位 `wallSource` 按出处分三形(运维旋钮 / 库报的墙 / 假定的墙),不把假定或运维的旋钮说成库的上限。
+     *  为什么在 HTTP 面重复店里的检查:店的 never-throw 结果形把一切写失败折成 502,而 502
      *  语义=可重试,对端会对一个永远过不去的 blob 无限重试——413 才是「别再送了」的诚实形。 */
-    snapshotBlobSqlCapBytes?: number;
+    snapshotBlobSqlCap?: () => SqlBlobCapReading | undefined;
     /** [ref] SSE 连接帽(缺省 256/副本;超限 503+Retry-After=消费方回落 /head 轮询)。 */
     sessionEventsMaxConnections?: number;
     /** [ref] SSE 心跳/owner 复核拍距 ms(缺省 25s;测试注入用)。 */

package/dist/http/server.js

@@ -3,6 +3,7 @@ import { outwardPlane } from "../terminal.js";
 import { redactHead } from "../observability/run-terminal.js";
 import { validatePendingSteer } from "@sema-agent/core";
 import {} from "../web-admin-client/facade.js";
+import { describeValueShape } from "@sema-agent/settings-schema";
 import { HttpError } from "../security.js";
 import {} from "../memory-sync.js";
 import {} from "../orchestration/workflow-agent-steer.js";
@@ -19,15 +20,16 @@ import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
 import { sendError, sendHttpError, sendSessionError, msg } from "./send.js";
 import { createRequestGuards } from "./request-guards.js";
+import { sqlEngineSeatIssue } from "../sql-engine-posture.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
 import * as facts from "../capability-facts.js";
-import { createDispatch, hasServiceAuth } from "./dispatch.js";
+import { createDispatch } from "./dispatch.js";
 import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, isProbePath } from "./route-table.js";
 import { createApprovalSweeps } from "./approval-sweeps.js";
 export { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, hasServiceAuth };
 export { MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills };
-import { explicitOperatorOk, isOperator } from "./principal-gate.js";
+import { explicitOperatorOk, isOperator, hasServiceAuth } from "./principal-gate.js";
 export { explicitOperatorOk, isOperator };
 class DrainYieldingPreemptBook extends Map {
     drainingNow;
@@ -57,6 +59,30 @@ export function createHttpServer(rawDeps) {
     if (typeof deps.runnerFor !== "function") {
         throw new Error("createHttpServer: the runnerFor seat is required (it picks each task's Runner from its execution lane) — pass the hands-lane selector, or `runnerFor: () => runner` for a single-Runner embedding; refusing to start rather than run every task on the widest Runner");
     }
+    if (deps.snapshotBlobSqlCapBytes !== undefined) {
+        throw new Error("createHttpServer: snapshotBlobSqlCapBytes was replaced by snapshotBlobSqlCap in 7.132.0 — pass a reader `() => { capBytes, source } | undefined` (called on every PUT /v1/sessions/:id/sync/blobs/:hash; `source` is \"operator\" for a cap you set yourself, \"reported\" / \"assumed\" for one derived from the database's walls; `undefined` = no cap) — for a fixed cap: `() => ({ capBytes: <bytes>, source: \"operator\" })`; refusing to start rather than run without the blob cap");
+    }
+    if (deps.snapshotBlobSqlCap !== undefined && typeof deps.snapshotBlobSqlCap !== "function") {
+        throw new Error(`createHttpServer: snapshotBlobSqlCap must be a reader \`() => { capBytes, source } | undefined\` (called on every PUT /v1/sessions/:id/sync/blobs/:hash), got ${typeof deps.snapshotBlobSqlCap} — pass the reader (or \`() => undefined\` for no cap), or leave it unset; refusing to start rather than answer every blob upload with a 500`);
+    }
+    if (deps.sqlEngineFacts !== undefined) {
+        throw new Error("createHttpServer: sqlEngineFacts was replaced by sqlEngine in 7.132.0 — pass the SQL pool's engine reading as sqlEngine: `{ dialect: \"tidb\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded, or leave both unset when there is no SQL store; refusing to start rather than run the submit admission without the database's walls");
+    }
+    {
+        const issue = sqlEngineSeatIssue(deps.backend, deps.sqlEngine);
+        if (issue !== undefined) {
+            switch (issue) {
+                case "required":
+                    throw new Error("createHttpServer: sqlEngine is required when a SQL store backend is wired (the backend hands out a SQL pool) — pass the pool's engine reading as sqlEngine: `{ dialect: \"tidb\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded; refusing to start rather than read the database's row and statement limits as absent and admit task bodies the database cannot store");
+                case "bad_shape":
+                    throw new Error(`createHttpServer: sqlEngine must be the SQL pool's engine reading \`{ dialect: "tidb" | "pg", facts }\` where \`facts\` is read live (a getter) and is null while the pool's connection setup has not succeeded, otherwise the engine facts object (maxRowBytes, maxPacketBytes and wallSources included) — got ${typeof deps.sqlEngine === "function" ? "a function (the 7.131.x reader \`() => facts\` goes in as \`{ dialect, get facts() { return f(); } }\`)" : describeValueShape(deps.sqlEngine)}; refusing to start rather than answer every task submission with a 500`);
+                default: {
+                    const unhandled = issue;
+                    throw new Error(`sqlEngine seat issue without a refusal: ${String(unhandled)}`);
+                }
+            }
+        }
+    }
     const idemCache = new IdempotencyCache();
     const inflightRuns = new Map();
     const preemptableRuns = new DrainYieldingPreemptBook(() => deps.drainState?.draining === true);

package/dist/http/submit-ctx.d.ts

@@ -0,0 +1,25 @@
+import type { RunStore } from "../plugins/store-backend.js";
+import type { Logger } from "../observability/logger.js";
+import type { Metrics } from "../observability/metrics.js";
+import { buildCheckpointCtx } from "./checkpoint-ctx.js";
+import { type RefusalBody } from "./refusal-body.js";
+/** 写不进的那一种可答复的结局(各腿把它交回自己的出口:同步 / durable 腿直接回,活流腿编码成终帧)。 */
+export interface SubmitCtxRefusal {
+    readonly status: 413;
+    readonly body: RefusalBody;
+}
+/**
+ * 写这一笔(行体经续跑输入的唯一构造口 `buildCheckpointCtx` 铸 —— 新的持久化写都经它,读法记号随之盖上);写不进 ⇒ 撤掉
+ * `claim` 指的那条刚认领的 run(无 run 店的部署没有认领 ⇒ `undefined`),再按成因答复(见文件头)。
+ * 返回 `undefined` = 写进了,腿照常起跑。
+ */
+export declare function persistSubmitCtx(store: {
+    putCtx(sessionId: string, ctx: object): Promise<void>;
+}, deps: {
+    readonly logger?: Logger | undefined;
+    readonly metrics?: Metrics | undefined;
+}, claim: {
+    readonly runStore: RunStore;
+    readonly taskId: string;
+} | undefined, sessionId: string, fields: Parameters<typeof buildCheckpointCtx>[0]): Promise<SubmitCtxRefusal | undefined>;
+//# sourceMappingURL=submit-ctx.d.ts.map

package/dist/http/submit-ctx.js

@@ -0,0 +1,39 @@
+import { StoreRowTooLargeError } from "../plugins/sql-errors.js";
+import { releaseClaimedRun } from "./claimed-run.js";
+import { buildCheckpointCtx } from "./checkpoint-ctx.js";
+import { refusalBody } from "./refusal-body.js";
+function rowTooLargeRefusal(tooLarge) {
+    switch (tooLarge.wall) {
+        case "row":
+            return { status: 413, body: refusalBody({ errorCode: "request.payload_too_large", message: `the database refused to store this task: it is larger than the database keeps in one row (${tooLarge.dbMessage}) — nothing was run; shrink the inline images / userAttachments, or ask the operator to raise the database's single-row limit (TiDB performance.txn-entry-size-limit)` }) };
+        case "statement":
+            return { status: 413, body: refusalBody({ errorCode: "request.payload_too_large", message: `the database refused to store this task: it is larger than the database accepts in one statement (${tooLarge.dbMessage}) — nothing was run; shrink the inline images / userAttachments, or ask the operator to raise the database's max_allowed_packet` }) };
+        case "value":
+            return { status: 413, body: refusalBody({ errorCode: "request.payload_too_large", message: `the database refused to store this task: it is larger than PostgreSQL holds in one value (${tooLarge.dbMessage}) — nothing was run; shrink the inline images / userAttachments` }) };
+        default: {
+            const unhandled = tooLarge.wall;
+            throw new Error(`row-too-large refusal without an HTTP answer: ${String(unhandled)}`);
+        }
+    }
+}
+export async function persistSubmitCtx(store, deps, claim, sessionId, fields) {
+    try {
+        await store.putCtx(sessionId, buildCheckpointCtx(fields));
+        return undefined;
+    }
+    catch (err) {
+        const tooLarge = err instanceof StoreRowTooLargeError ? err : undefined;
+        if (claim !== undefined) {
+            const why = tooLarge !== undefined ? tooLarge.message : `the run's resume inputs could not be stored: ${err instanceof Error ? err.message : String(err)}`;
+            await releaseClaimedRun(claim.runStore, claim.taskId, why, (releaseErr, step) => {
+                deps.logger?.warn("submit_ctx_run_release_failed", { taskId: claim.taskId, sessionId, step, err: releaseErr instanceof Error ? releaseErr.message : String(releaseErr) });
+                deps.metrics?.inc("submit_ctx_run_release_failed_total", { step });
+            });
+        }
+        if (tooLarge === undefined)
+            throw err;
+        deps.logger?.warn("submit_ctx_row_too_large", { sessionId, taskId: claim?.taskId, wall: tooLarge.wall, db: tooLarge.dbMessage });
+        return rowTooLargeRefusal(tooLarge);
+    }
+}
+//# sourceMappingURL=submit-ctx.js.map

package/dist/http/wire-types.d.ts

@@ -322,7 +322,7 @@ export interface TaskRequestBody {
      *  `mcp__srv` / `mcp__srv__*` / 工具段通配;`"*"` = 本层不设名单;`[]` = 什么都不给)。宿主**原样透传**进 `TaskSpec.allowTools`:
      *  不算补集、不过滤、不与 `settings.permissions.allow`(免问)混词;真未知名(拼写合法、没有近似也没有退役对应:懒挂载的合法形)照跑(原样保留,今天什么都不准,之后挂上同名工具即生效;引擎告知运维一次),
    *  任何工具名都不可能有的拼法由引擎开跑前拒(`config.tool_face_control`,同步腿 400);7.131.0 起受理口另拒近似名(大小写孪生 `BASH`:想放的什么也没放 = 静默收窄,句子点名现名);
-   *  放行侧的退役名(`bash` · `Task`)、内容形(`Agent(Explore)`)与文法读不出照旧受理、交引擎既有通告。
+   *  放行侧的内容形(`Agent(Explore)`)、文法读不出与没有后继的退役名(`MultiEdit`)照旧受理、交引擎既有通告;有后继的退役名(`bash` · `Task`)引擎开跑前拒 `config.tool_face_control`(core 7.52.0 起,同步腿 400)。
      *  `excludeTools` 是同一只运算的减项(deny 赢)。值形:字符串数组(受理门 400 `request.field_invalid`,与 `excludeTools` 同一只门);
      *  装着的引擎不认该座 ⇒ 400 `request.field_invalid` 点名所需引擎版本(不静默丢)。无租户门(收窄)。 */
     allowTools?: string[];

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { composeExecutionLane, assertExecutionLaneInvariants, type ExecutionLane
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend, type StoreBackend, type SessionCaptureRecordSource } from "./plugins/store-backend.js";
-export { RetiredSchemaPresentError } from "./plugins/one-time-migrations.js";
+export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
 export { CachingSessionStore, type CachingOptions } from "./plugins/caching-session-store.js";
 export type { RunRecord, RunEvent } from "./plugins/store-contracts.js";
 export { runInBackground } from "./runs.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { composeExecutionLane, assertExecutionLaneInvariants } from "./boot/exec
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend } from "./plugins/store-backend.js";
-export { RetiredSchemaPresentError } from "./plugins/one-time-migrations.js";
+export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
 export { CachingSessionStore } from "./plugins/caching-session-store.js";
 export { runInBackground } from "./runs.js";
 export { createHardenedVmRunner, runInHardenedVm } from "./orchestration/hardened-vm-runner.js";

package/dist/lane-home-probe.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 执行环境的家目录:**声明 × 实测**的唯一判官(纯叶:零值依赖)。
+ *
+ * ## 病
+ * `REMOTE_EXEC_HOME_DIR` 是运维对「执行环境以哪个用户的家目录运行」的声明,它是 `~/` 形权限规则的基、引擎家锚拒读行(`~/.ssh` / `~/.npmrc` …)
+ * 的落点(`execution-lane-caps.ts` `executionLaneHomeDir` 一只属主,四个消费面同读)。k8s / local-docker / ssh 三条车道的家目录是镜像 / 目标机
+ * 登录用户的属性,boot 期不可知 —— 声明了就照单全收。声明 `/home/y` 而车道真实家目录是 `/home/x` 时,`Edit(~/.ssh/**)` 守的是 `/home/y`,
+ * `/home/x/.ssh` 照读照写,运维与用户零告警:限制写了不生效且无人知。
+ *
+ * ## 律(一句)
+ * 家目录只有一只真源:声明在场、车道能问的,**开环境那一拍问一次**(与命令同一条 shell、同一份 env:`printf %s "$HOME"`),两者不一致 ⇒
+ * 这只执行环境不开(拒句点名两值与两条改法),环境答了的判定记在环境上(同一镜像 / 同一目标机再问也是同一个答案,不重试成风暴);问不出答案同样不开
+ * (证不了声明 = 不拿一个没证过的目录去守),但不记 —— 与任何一次建连失败同,下一次重问。车道问不了的(adb / device)声明照单全收 —— 那是声明唯一的用处。
+ * 没声明的车道不问:规则基与 422 门在下单那一刻就要家目录,而那一刻执行环境还没开(把实测值接进规则基要引擎的座,见收车档)。
+ */
+/** 探针答案的行首标记:登录脚本 / profile 往 stdout 打的横幅不会被读成家目录 —— 只认带这个标记的那一行(取最后一行)。 */
+export declare const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
+/**
+ * 执行环境里问家目录的那一句 —— 经车道自己的命令通道跑(同一条 shell、同一份 env),答的就是命令看到的 `$HOME`。
+ * 先换一行再打标记行:横幅没以换行收尾时,标记行照样从行首开始。
+ */
+export declare const LANE_HOME_PROBE_COMMAND = "printf '\\nsema-lane-home=%s\\n' \"$HOME\"";
+/** 一次问家目录的读数:问到了(stdout 原文)/ 没问到(原因)。 */
+export type LaneHomeProbe = {
+    readonly ok: true;
+    readonly stdout: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * 判定:`undefined` = 一致,照开;否则这只环境不开 —— `refusal` 是拒句,`answered` = 环境**答了**它的家目录(不一致 / 不是绝对路径;同一镜像 / 同一登录用户
+ * 再问也是同一个答案 ⇒ 调用方记在环境上),`false` = 没答上(探针失败 / 超时 / 非零退出 / 输出里没有标记行 ⇒ 这一次不开、不记、下一次重问)。
+ */
+export type LaneHomeVerdict = {
+    readonly refusal: string;
+    readonly answered: boolean;
+} | undefined;
+/**
+ * 声明 × 实测的唯一判官。`lane` 只进句子。拒句三形:实测与声明不一致 / 实测不是绝对路径(含空)/ 没问到。每一形都点名声明值与改法,不回显任何别的东西。
+ */
+export declare function judgeLaneHome(lane: string, declared: string, probe: LaneHomeProbe): LaneHomeVerdict;
+//# sourceMappingURL=lane-home-probe.d.ts.map

package/dist/lane-home-probe.js

@@ -0,0 +1,35 @@
+export const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
+export const LANE_HOME_PROBE_COMMAND = `printf '\\n${LANE_HOME_PROBE_MARKER}%s\\n' "$HOME"`;
+const SHOWN_MAX = 256;
+const shown = (raw) => JSON.stringify(raw.length > SHOWN_MAX ? `${raw.slice(0, SHOWN_MAX)}…` : raw);
+const comparable = (p) => (p.length > 1 ? p.replace(/\/+$/, "") : p);
+function markedHome(stdout) {
+    const lines = stdout.split("\n").filter((l) => l.startsWith(LANE_HOME_PROBE_MARKER));
+    const last = lines[lines.length - 1];
+    return last === undefined ? undefined : last.slice(LANE_HOME_PROBE_MARKER.length).replace(/\r$/, "");
+}
+export function judgeLaneHome(lane, declared, probe) {
+    const head = `REMOTE_EXEC_HOME_DIR=${shown(declared)} is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under on the ${lane} execution lane`;
+    const measured = probe.ok ? markedHome(probe.stdout) : undefined;
+    if (measured === undefined) {
+        const reason = probe.ok ? "the probe printed no home line" : probe.reason;
+        return {
+            refusal: `${head}, but the home of this execution environment could not be read (${reason}) — the declaration cannot be confirmed, so this environment is not started. Fix the lane, or unset REMOTE_EXEC_HOME_DIR (home-relative rules are then refused at submission instead).`,
+            answered: false,
+        };
+    }
+    if (!measured.startsWith("/")) {
+        return {
+            refusal: `${head}, but this execution environment reports HOME=${shown(measured)}, not an absolute path — the declaration cannot be confirmed, so this environment is not started. Give the environment's user a home (HOME), or unset REMOTE_EXEC_HOME_DIR.`,
+            answered: true,
+        };
+    }
+    if (comparable(measured) === comparable(declared))
+        return undefined;
+    return {
+        refusal: `${head}, but its commands run with HOME=${shown(measured)} — rules would guard ${shown(declared)} while ${shown(measured)} stays readable and writable, ` +
+            `so this environment is not started. Set REMOTE_EXEC_HOME_DIR to ${shown(measured)}, or run the environment as the user whose home is ${shown(declared)}.`,
+        answered: true,
+    };
+}
+//# sourceMappingURL=lane-home-probe.js.map