@sema-agent/server 7.142.0 → 7.144.0

package/dist/approval-ask-audit-store.js

@@ -16,6 +16,12 @@ function isSettleOutcome(v) {
 export function buildCheckpointAnchorHash(token) {
     return createHash("sha256").update(token, "utf8").digest("hex").slice(0, 16);
 }
+function ledgerRecordToDisk(rec) {
+    if (rec.kind !== "ask")
+        return rec;
+    const { sourceSessionId, ...rest } = rec;
+    return { ...rest, ...(sourceSessionId !== undefined ? { sourceTaskId: sourceSessionId } : {}) };
+}
 function readSettleCause(v) {
     if (v === undefined)
         return { cause: undefined, outOfSet: false };
@@ -54,7 +60,7 @@ function readLedgerRecord(u, noteOutOfSetSeat) {
             }
             const toolCallId = s("toolCallId");
             const sessionId = s("sessionId");
-            const sourceTaskId = s("sourceTaskId");
+            const sourceSessionId = s("sourceTaskId");
             return {
                 kind: "ask",
                 approvalId,
@@ -66,7 +72,7 @@ function readLedgerRecord(u, noteOutOfSetSeat) {
                 owner,
                 ...(toolCallId !== undefined ? { toolCallId } : {}),
                 ...(sessionId !== undefined ? { sessionId } : {}),
-                ...(sourceTaskId !== undefined ? { sourceTaskId } : {}),
+                ...(sourceSessionId !== undefined ? { sourceSessionId } : {}),
             };
         }
         case "settle": {
@@ -378,7 +384,7 @@ export class FileApprovalAskAuditStore {
     }
     appendOrThrow(rec) {
         this.log ??= this.openLog(this.ledgerPath);
-        this.log.append(rec, true);
+        this.log.append(ledgerRecordToDisk(rec), true);
     }
     static callAnchorKey(session, toolCallId) {
         return `${session}\u0000${toolCallId}`;
@@ -388,8 +394,8 @@ export class FileApprovalAskAuditStore {
         const sessions = new Set();
         if (rec.sessionId !== undefined)
             sessions.add(rec.sessionId);
-        if (rec.sourceTaskId !== undefined)
-            sessions.add(rec.sourceTaskId);
+        if (rec.sourceSessionId !== undefined)
+            sessions.add(rec.sourceSessionId);
         for (const session of sessions) {
             const bucket = rec.toolCallId !== undefined ? this.askByCallAnchor : this.askBySessionOnly;
             const key = rec.toolCallId !== undefined ? FileApprovalAskAuditStore.callAnchorKey(session, rec.toolCallId) : session;
@@ -550,7 +556,7 @@ export class FileApprovalAskAuditStore {
             if (typeof id !== "string")
                 continue;
             lastAt.set(id, Math.max(lastAt.get(id) ?? Number.NEGATIVE_INFINITY, atMsOf(rec)));
-            const cells = rec.kind === "ask" ? [rec.taskId, rec.sessionId, rec.sourceTaskId] : rec.kind === "late_settle" ? [rec.taskId, rec.sessionId] : [];
+            const cells = rec.kind === "ask" ? [rec.taskId, rec.sessionId, rec.sourceSessionId] : rec.kind === "late_settle" ? [rec.taskId, rec.sessionId] : [];
             const list = anchorsOf.get(id) ?? [];
             for (const c of cells)
                 if (c !== undefined)

package/dist/approval-ask-machine.d.ts

@@ -34,17 +34,25 @@ export declare function noteRecordedReceipt(requestNote: string | undefined, lan
 export declare function canAskTransition(from: AskState, to: AskState): boolean;
 /** 批转移合法性,同形。 */
 export declare function canBatchTransition(from: BatchState, to: BatchState): boolean;
-/** 一只 ask 的请求侧身份素材 = core `AskRequest` 上的三格(型从 core 派生,不手抄;整只 `AskRequest` 可直接交)。 */
-export type AskIdentityRequest = Pick<AskRequest, "toolCallId" | "classes"> & {
+/**
+ * `AskRequest.boundInputHash` 的**边界窄读**(唯一一只):ask 身份第四轴的入参那一半与行上 `bound_input_hash` 列(收敛器判据 1 的对账键)读的都是它。
+ * core 在闸站铸值(`onAsk({ ...bare, boundInputHash: boundInputHashOf(presented.value), … })`,core 5.15.0 起每一只经 `resolveAsk` 的问都带);
+ * `boundInputHashOf` 不在 core 的公开导出面上(包 `exports` 只有 `.` / `./bench` / `./fixtures`),本服务既算不出也不该算 —— 只原样读。
+ * 非字符串 / 空串一律按缺席:一个形不对的摘要比没有摘要更危险(它会让「硬相等」这道门在一个垃圾值上偶然成立)。
+ * 钉:`test/stream-approval-on-e2e.test.ts` 件4(正控 / 缺席 / 空串三臂)。
+ */
+export declare function readBoundInputHash(req: unknown): string | null;
+/** 一只 ask 的请求侧身份素材 = core `AskRequest` 上的五格(型从 core 派生,不手抄;整只 `AskRequest` 可直接交;`toolName` 必填 ⇒ 漏带是编译错)。 */
+export type AskIdentityRequest = Pick<AskRequest, "toolName" | "toolCallId" | "classes" | "boundInputHash"> & {
     readonly delegation?: Pick<NonNullable<AskRequest["delegation"]>, "parentToolCallId">;
 };
-/** ask_id = sha256('ask' ⊕ sourceTaskId ⊕ runId ⊕ toolCallId ⊕ legKey ⊕ parentToolCallId ⊕ 类集规范形).slice(0,64)。
+/** ask_id = sha256('ask' ⊕ sourceSessionId ⊕ runId ⊕ toolCallId ⊕ legKey ⊕ parentToolCallId ⊕ 类集规范形 ⊕ 工具名 ⊕ 展示入参摘要).slice(0,64)。
  *  确定性:同参数元组(含重试/failover/闭包再入)永远派生同一个 id——这是 ensureAsk 幂等 upsert 成立的前提;
- *  同调用不同类集 ⇒ 不同 id([ref])。 */
-export declare function deriveAskId(sourceTaskId: string, runId: string, legKey: string, request: AskIdentityRequest): string;
-/** batch_id = sha256('batch' ⊕ sourceTaskId ⊕ runId ⊕ legKey).slice(0,64)。同一 (sourceTaskId, runId,
+ *  同调用不同类集 ⇒ 不同 id([ref]);同调用不同的展示动作(工具名或入参摘要)⇒ 不同 id(7.143.0)。 */
+export declare function deriveAskId(sourceSessionId: string, runId: string, legKey: string, request: AskIdentityRequest): string;
+/** batch_id = sha256('batch' ⊕ sourceSessionId ⊕ runId ⊕ legKey).slice(0,64)。同一 (sourceSessionId, runId,
  *  legKey) 恒派生同一批——批 = 同一决策点的兄弟 ask 集合,故不掺 toolCallId。 */
-export declare function deriveBatchId(sourceTaskId: string, runId: string, legKey: string): string;
+export declare function deriveBatchId(sourceSessionId: string, runId: string, legKey: string): string;
 /**
  * 🔴 [ref] codex R1-F1:**单 ask 批** —— batch_id = sha256('ask-batch' ⊕ askId).slice(0,64)。
  *

package/dist/approval-ask-machine.js

@@ -36,11 +36,17 @@ function deterministicId(prefix, parts) {
 function askClassSetKey(classes) {
     return classes === undefined ? "" : [...new Set(classes)].sort().join(ID_SEPARATOR);
 }
-export function deriveAskId(sourceTaskId, runId, legKey, request) {
-    return deterministicId("ask", [sourceTaskId, runId, request.toolCallId, legKey, request.delegation?.parentToolCallId, askClassSetKey(request.classes)]);
+export function readBoundInputHash(req) {
+    if (req === null || typeof req !== "object")
+        return null;
+    const v = Reflect.get(req, "boundInputHash");
+    return typeof v === "string" && v.length > 0 ? v : null;
 }
-export function deriveBatchId(sourceTaskId, runId, legKey) {
-    return deterministicId("batch", [sourceTaskId, runId, legKey]);
+export function deriveAskId(sourceSessionId, runId, legKey, request) {
+    return deterministicId("ask", [sourceSessionId, runId, request.toolCallId, legKey, request.delegation?.parentToolCallId, askClassSetKey(request.classes), request.toolName, readBoundInputHash(request) ?? ""]);
+}
+export function deriveBatchId(sourceSessionId, runId, legKey) {
+    return deterministicId("batch", [sourceSessionId, runId, legKey]);
 }
 export function deriveAskScopedBatchId(askId) {
     return deterministicId("ask-batch", [askId]);

package/dist/approval-card.d.ts

@@ -21,7 +21,7 @@
  * 没有方法、没有捕获的行为。
  */
 import { z } from "zod";
-import { ALLOW_RULE_MEMBERS, READ_ROOT_CANDIDATE_DIR_MAX, type AskClass, type AskEvidenceAbsence, type CheckpointSummary as CoreCheckpointSummary, type PendingAction as CorePendingAction, type ReadRootGrantCandidate, type ResumeStartupCause, type RuleOffer, type RuleOffersAbsence as CoreRuleOffersAbsence, type SteerReplayFacet, type ToolApprovalCard } from "@sema-agent/core";
+import { ALLOW_RULE_MEMBERS, READ_ROOT_CANDIDATE_DIR_MAX, type AskClass, type AskEvidenceAbsence, type AskReason as CoreAskReason, type HookQuestionCause, type CheckpointSummary as CoreCheckpointSummary, type PendingAction as CorePendingAction, type ReadRootGrantCandidate, type ResumeStartupCause, type RuleOffer, type RuleOffersAbsence as CoreRuleOffersAbsence, type SteerReplayFacet, type ToolApprovalCard } from "@sema-agent/core";
 import type { AskRow } from "./plugins/approval-ask-store-sql.js";
 import type { SettleCause, SettleOutcome } from "./approval-deny-reasons.js";
 import type { ToolApprovalFrame } from "./tool-approval.js";
@@ -86,8 +86,8 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
         host: "host";
         name: "name";
         path: "path";
-        pattern: "pattern";
         tool: "tool";
+        pattern: "pattern";
         exact: "exact";
         prefix: "prefix";
         wildcard: "wildcard";
@@ -105,8 +105,8 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
             host: "host";
             name: "name";
             path: "path";
-            pattern: "pattern";
             tool: "tool";
+            pattern: "pattern";
             exact: "exact";
             prefix: "prefix";
             wildcard: "wildcard";
@@ -210,8 +210,8 @@ export declare function readProbeCause(req: unknown): ProbeCauseProjection | und
  * `AskRequest.probeReason`(core 5.33.0 [ref]:`probeCause` 的**散文**兄弟 —— 探针对「为什么没清掉这一问」的一句话)的
  * **边界窄读**,活卡帧(`ToolApprovalFrame.probeReason`)的**唯一**铸造点。
  *
- * 🔴 **只有活卡帧**:`card_json` / 呈卡帧不携本键(`ApprovalCardSchema` 是 `.strict()` 的耐久信封,加键 = 回滚窗内旧二进制读不动新行,
- * 要另行裁定)。耐久面的对偶 = `gate.riskDescriptor.probeReason`(park 行整体透传,出门前过 `redactRiskDescriptor` 的 `text` 叶,
+ * 🔴 **不在卡上**:`ApprovalCardSchema`(`.strict()`)没有本键;呈卡帧 `approval_request` 顶层带它(活面事实座之一,{@link APPROVAL_REQUEST_LIVE_FACT_KEYS}),
+ * 7.143.0 起同一份值随卡落进卡信封的 `liveFacts` 座 ⇒ 断连重放帧与活铸帧同值({@link buildApprovalCardEnvelope})。耐久面的对偶 = `gate.riskDescriptor.probeReason`(park 行整体透传,出门前过 `redactRiskDescriptor` 的 `text` 叶,
  * 与本函数同一只脱敏规则 ⇒ 对同一句话两面同值)。
  *
  * 姿势逐条(与 {@link readProbeCause} / {@link readRuleEvidence} 同款分工):
@@ -431,6 +431,27 @@ export interface AskClassPair {
     askClass: NonNullable<ToolApprovalPark["askClass"]>;
     classes: Array<NonNullable<ToolApprovalPark["classes"]>[number]>;
 }
+/**
+ * **谁问的、为什么问 —— `askReasons` 的唯一窄读**(core 7.61.0:一只座,`AskRequest.askReasons` 与寄存行 `PendingAction.tool_approval.askReasons`
+ * 是同一个值、一次铸)。一条 = 一位问者 + 它自己的话:策略链的问 `{ by, words }`(`by` = 引擎出身闭集 `ASK_ORIGINS` 除 `hook`),
+ * hook / 扩展的问 `{ by: "hook", registration?, cause, words? }`(`cause` = `HOOK_QUESTION_CAUSES`)。结构化审批面按它渲理由行,不渲 `message`
+ * (`message` 照旧逐字转给只读文本的消费方)。活卡帧、呈卡帧的卡、运维队列行三面读这一只。
+ *  · 缺席 ⇒ 缺席(不计数):老引擎、老行、引擎自己铸的通用问句(写门默认问句 / 计划模式两句不铸条目)。
+ *  · 在场 ⇒ 每条逐键窄读:`by` 在集、hook 条的 `cause` 在集、`words` / `registration` 是串;问者的话(部署策略 / hook / 扩展写的自由文本)过
+ *    `redactSecrets` 再截长(与卡上 `message` 同一只帽),注册名截到标识帽。任一条形不合 ⇒ **整座不投**(卡上少一行理由 ≪ 卡上出现半条理由)
+ *    + 计一次 `server.approval-card.closed-word-out-of-set`(detail 前缀 `askReasons=`)。
+ */
+export declare function readAskReasons(carrier: unknown): AskReasonProjection[] | undefined;
+/** 一条理由的投影形(帧 / 卡 / 队列行同一形)。值型取 core 的 `AskReason`(core 改形 ⇒ 下面的围栏编译红,读法就得重判)。 */
+export type AskReasonProjection = {
+    by: "hook";
+    registration?: string;
+    cause: HookQuestionCause;
+    words?: string;
+} | {
+    by: Exclude<CoreAskReason["by"], "hook">;
+    words: string;
+};
 /**
  * 🔴 [ref] P1(client-core [ref] / cli [ref] 的根子;板 [ref] 订正 → [ref] 立案)—— **park 行事实**:
  * 运维队列行(`GET /v1/approvals` + `/stream`)顶层展开的那几位。型**从 core 寄存行派生,不手抄**([ref] 同一条
@@ -456,7 +477,7 @@ export interface AskClassPair {
  * (「本会话放行」可按工具记)。摘要读自停驻行本身 —— 不靠整行的检查点摘要,所以 SQL 腿那一次整行读失败也不丢这一臂;要 core 校验的清单与成因词走
  * 另一只投影 {@link skillCardFacts}。
  */
-export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "ruleOffersAbsence" | "mandated" | "mandate" | "origin" | "askClass" | "classes" | "boundGrantDigest" | "boundGrantAbsence">;
+export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "ruleOffersAbsence" | "mandated" | "mandate" | "origin" | "askClass" | "classes" | "boundGrantDigest" | "boundGrantAbsence" | "askReasons">;
 /**
  * [ref] —— park 行事实的**唯一投影**(`pendingAction` 是寄存行上 core 铸的那一只,读自持久层 ⇒ `unknown`)。
  *
@@ -496,24 +517,18 @@ export declare function parkRowFacts(stored: unknown): ParkRowFacts;
  * (「never a list beside a digest that binds another」—— 一份与摘要对不上的清单会让批准人看着一份清单、批的却是另一份绑定);成因词只在闭集成员时回显。
  * 本仓**不重算哈希**(core 的 `boundInputHashOf` 不在公开导出面上,清单校验读口 `readBoundBinding` 同样不导出),所以**不许**拿寄存行 `pendingAction` 上的原清单直接投 ——
  * 原值上的清单是未经哈希校验的(这正是它此前不上队列行的原因,见 `trace/core-keyset-guard.ts` ⑧b 记账的旧注)。两只店各自拿到「这一行的摘要」的办法不同
- * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生对可能带两位之一的行读一次该行再调 core 的 `summarizeCheckpoint`,见 `plugins/checkpoint-store-sql.ts`),
+ * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生在判官要的那一次整行读里调 core 的 `summarizeCheckpoint` —— 两位与 `rowVerdict` 同一次读、
+ * 同一份按字节摘要的记忆,见 `plugins/checkpoint-store-sql.ts` 的 `storedRowProjections`),
  * 但投影只有这一只:OMIT 契约 —— 缺席即缺席,恒不铸 `undefined` 值的键。
  *
  * `boundGrants` 是**部署文本**(技能名、清单条目):本函数不脱敏、不转义,与收件箱行逐字同口径 —— 渲染按上下文转义是客户端的事(契约同句)。
- * 两位都不进 `card_json`(同步路铸点,另一条纪律)。
+ * 本投影的产物不进 `card_json`(它是停驻面的投影);问行卡信封的活面事实座(7.143.0)存的是呈卡帧上同名两位(活铸素材,与停驻孪生同一只工厂铸)。
  *
- * 🚧 清单校验读口 `readBoundBinding` 若成为 core 的公开导出,SQL 孪生那一次整行读与 {@link parkRowCarriesSkillCardFacts} 一并退役:`parkRowFacts` 直接读寄存行原值经 core 的读口投两位
- * (`grantBindingOf` 也改成它的薄包装 —— 那时 core 是绑定读法的唯一属主)。
+ * 🚧 清单校验读口 `readBoundBinding` 若成为 core 的公开导出:`grantBindingOf` 改成它的薄包装(那时 core 是绑定读法的唯一属主)。SQL 孪生的整行读不随之退役 ——
+ * 7.144.0 起它首先是判官 `judgeCheckpointRow` 要的([ref]:判官读要求表要整行),两位随它同一次读、同一份记忆,不另开读法。
  */
 export type SkillCardFacts = Pick<CoreCheckpointSummary, "boundGrants" | "classifierNoRuling">;
 export declare function skillCardFacts(summary: SkillCardFacts): SkillCardFacts;
-/**
- * 这一行的寄存行(`pendingAction`,读自持久层 ⇒ `unknown`)**有没有可能**让 core 的摘要投出两位里的任何一位 —— 只回答「值不值得为它取一次摘要」,**不投值**:
- * `tool_approval` 臂上摘要字段是串(core 只在这时回显清单),或成因词键在场(是不是闭集成员由 core 的摘要判)。判错的方向只有一个 —— 多取一次摘要(摘要读数为空),
- * 绝不漏取:摘要字段不是串 ⇒ core 的摘要没有清单;成因词键不在 ⇒ 无成因词 —— 两者都不满足的行,摘要里这两位恒空。普通卡(绝大多数行)因此零额外读。
- * 只读键在不在 / 是不是串,不读值的内容,所以不需要 {@link readClosedWordSeat} 那样的计数。
- */
-export declare function parkRowCarriesSkillCardFacts(stored: unknown): boolean;
 /** [ref](core 7.4.0 [ref])—— 回落卡的计数与窗。`limit` 是**闭二词**(core d.ts 逐字),两个计数是
  *  非负整数,`autoDenyAfterMs` 是 core 契约里的 `0..2147483647` 非负整数(`0` = 本卡不武装窗:部署把
  *  旋钮关了,或 TOTAL 档的卡按 [ref]① 恒 0 等人)。四成员**全必填**——core 的 `DenialLimitFallback` 上
@@ -578,6 +593,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
         fetch: "fetch";
         workflow: "workflow";
         generic: "generic";
+        "computer-access": "computer-access";
+        "computer-control": "computer-control";
     }>>;
     inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
     allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -598,8 +615,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
             host: "host";
             name: "name";
             path: "path";
-            pattern: "pattern";
             tool: "tool";
+            pattern: "pattern";
             exact: "exact";
             prefix: "prefix";
             wildcard: "wildcard";
@@ -617,8 +634,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
                 host: "host";
                 name: "name";
                 path: "path";
-                pattern: "pattern";
                 tool: "tool";
+                pattern: "pattern";
                 exact: "exact";
                 prefix: "prefix";
                 wildcard: "wildcard";
@@ -687,8 +704,22 @@ export declare const ApprovalCardSchema: z.ZodObject<{
     askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
     classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
     fromSubagent: z.ZodOptional<z.ZodLiteral<true>>;
-    sourceTaskId: z.ZodOptional<z.ZodString>;
+    sourceSessionId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
     sourceAgentName: z.ZodOptional<z.ZodString>;
+    askReasons: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        by: z.ZodLiteral<"hook">;
+        registration: z.ZodOptional<z.ZodString>;
+        cause: z.ZodEnum<{
+            asked: "asked";
+            verdict_unreadable: "verdict_unreadable";
+            verdict_unfinished: "verdict_unfinished";
+        }>;
+        words: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        by: z.ZodCustom<"org_rule" | "org_unavailable" | "content_question" | "plan_review" | "ancestor_marked" | "rule_store_unavailable" | "ask_rule" | "denial_limit_fallback" | "shell_gate_tighten" | "safety_tighten" | "policy", "org_rule" | "org_unavailable" | "content_question" | "plan_review" | "ancestor_marked" | "rule_store_unavailable" | "ask_rule" | "denial_limit_fallback" | "shell_gate_tighten" | "safety_tighten" | "policy">;
+        words: z.ZodString;
+    }, z.core.$strict>]>>>;
     delegation: z.ZodOptional<z.ZodObject<{
         parentToolCallId: z.ZodString;
         depth: z.ZodNumber;
@@ -704,6 +735,14 @@ export type ApprovalCard = z.infer<typeof ApprovalCardSchema>;
  * 应答口 / 读口)一律读行的键、不读这一格;写它是给滚动升级窗里上一版的副本(它们的 strict 信封 schema 要求这一格并照它重放)。
  * 唯一读这一格的是 local 车道的启动收敛 —— 拿它去审计账里查前世这只 ask 的成因:审计行记的就是当时呈出的那个 id
  * (更早写下的行上是当年的登记本地 id)。
+ *
+ * `liveFacts`(7.143.0)= 这只 ask 的**活面事实座**({@link APPROVAL_REQUEST_LIVE_FACT_KEYS}:卡外、只在呈卡帧顶层的那十一位),铸卡时与 `card` **同一条写**落下,
+ * 值就是活铸呈卡帧顶层那一份(同一只挑键函数从同一只帧对象挑,见 {@link buildApprovalCardEnvelope})。重放帧只读这一座 —— 不读停驻行孪生座、不重算、不从内存兜。
+ * 信封这一层只认「这一格在不在」(`unknown`);它的形由唯一读者 {@link readStoredCardEnvelope} 用 {@link ApprovalRequestLiveFactsSchema} 整座判:读不出 ⇒ 与这一格缺席
+ * (本版之前铸的行)同读 —— 「活面事实不在行上」,卡照常可读、重放帧带 `liveFactsUnknown`。信封层不判它的形,是为了一座读不出的事实不连带把卡也读丢
+ * (卡读丢 ⇒ 重放跳过 / 幂等重入走 park,比「不知道事实」的那一形更坏)。
+ * 回滚窗代价与卡上的 additive 键同族:`.strict()` 下上一版二进制读不动带这一格的新行 ⇒ 重放跳过 + 幂等重入走 park(fail-safe,`schemaVersion` 不动);
+ * 区别是这一格**每一行都带**(空座也写),所以混版窗里上一版副本读不动的是本版写下的每一行 —— 整队滚前,见 CHANGELOG 本条。
  */
 export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -732,6 +771,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
             fetch: "fetch";
             workflow: "workflow";
             generic: "generic";
+            "computer-access": "computer-access";
+            "computer-control": "computer-control";
         }>>;
         inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
         allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -752,8 +793,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                 host: "host";
                 name: "name";
                 path: "path";
-                pattern: "pattern";
                 tool: "tool";
+                pattern: "pattern";
                 exact: "exact";
                 prefix: "prefix";
                 wildcard: "wildcard";
@@ -771,8 +812,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                     host: "host";
                     name: "name";
                     path: "path";
-                    pattern: "pattern";
                     tool: "tool";
+                    pattern: "pattern";
                     exact: "exact";
                     prefix: "prefix";
                     wildcard: "wildcard";
@@ -841,14 +882,29 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
         askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
         classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
         fromSubagent: z.ZodOptional<z.ZodLiteral<true>>;
-        sourceTaskId: z.ZodOptional<z.ZodString>;
+        sourceSessionId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
         sourceAgentName: z.ZodOptional<z.ZodString>;
+        askReasons: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            by: z.ZodLiteral<"hook">;
+            registration: z.ZodOptional<z.ZodString>;
+            cause: z.ZodEnum<{
+                asked: "asked";
+                verdict_unreadable: "verdict_unreadable";
+                verdict_unfinished: "verdict_unfinished";
+            }>;
+            words: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            by: z.ZodCustom<"org_rule" | "org_unavailable" | "content_question" | "plan_review" | "ancestor_marked" | "rule_store_unavailable" | "ask_rule" | "denial_limit_fallback" | "shell_gate_tighten" | "safety_tighten" | "policy", "org_rule" | "org_unavailable" | "content_question" | "plan_review" | "ancestor_marked" | "rule_store_unavailable" | "ask_rule" | "denial_limit_fallback" | "shell_gate_tighten" | "safety_tighten" | "policy">;
+            words: z.ZodString;
+        }, z.core.$strict>]>>>;
         delegation: z.ZodOptional<z.ZodObject<{
             parentToolCallId: z.ZodString;
             depth: z.ZodNumber;
             agentName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strict>;
+    liveFacts: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strict>;
 export type ApprovalCardEnvelope = z.infer<typeof ApprovalCardEnvelopeSchema>;
 /** 本车铸的信封形版本(写侧=刀 3b,读侧=本文件)。 */
@@ -892,7 +948,9 @@ export interface ApprovalCardSource {
     askClass?: AskClass;
     classes?: readonly AskClass[];
     fromSubagent?: true;
-    sourceTaskId?: string;
+    sourceSessionId?: string;
+    /** core 7.61.0:委派腿的 agent id(见 `ApprovalCardSchema.agentId`)。 */
+    agentId?: string;
     /** 已 redactSecrets。 */
     sourceAgentName?: string;
     delegation?: {
@@ -912,8 +970,22 @@ export interface ApprovalCardSource {
  * 头注。)
  */
 export declare function buildApprovalCard(source: ApprovalCardSource, req: unknown, requiresRealApproval: boolean): ApprovalCard;
-/** 落库信封的纯构造(写侧;读侧 = {@link readStoredCardEnvelope},**同一个 schema**)。 */
-export declare function buildApprovalCardEnvelope(approvalId: string, card: ApprovalCard): ApprovalCardEnvelope;
+/**
+ * 落库信封的纯构造(写侧;读侧 = {@link readStoredCardEnvelope},**同一个 schema**)。`liveFacts` = 活铸呈卡帧顶层的那一份活面事实(调用点交的是**同一只帧对象**,
+ * 经与活铸帧同一只挑键函数 {@link pickApprovalRequestLiveFacts} 落座:只拷在场的位、缺席不铸 `undefined` 键)。座恒写 —— 一位事实都没有的问写空座 `{}`,
+ * 于是「行上有座」与「本版之前铸的行」在读侧是两形(后者读作「不知道」)。
+ * 🔴 唯一不落座的一形:这组事实里有 NUL / 孤代理(判官 `pgHasUnstorable`)。PG 问店的 `card_json` 走有损臂(那两类码点换成 U+FFFD,
+ * `plugins/pg-safe-json.ts`),落下去的就不是逐字的那一份 —— 而座是「与活铸帧逐字同」的记录(读根目录要原样回传)。这样的一组不落座,
+ * 行读作「不知道」(重放帧带 `liveFactsUnknown`),每只店同判;绝不落一份会被某个后端改写的「同值」。卡本身照旧(卡是展示投影,有损臂是它的既有读法)。
+ */
+export declare function buildApprovalCardEnvelope(approvalId: string, card: ApprovalCard, liveFacts: ApprovalRequestLiveFacts): ApprovalCardEnvelope;
+/**
+ * 存下的卡的**读数**({@link readStoredCardEnvelope} 的产出):卡与身份照信封;`liveFacts` = 行上那一座读得出时的活面事实,**缺席 = 不知道**
+ * (这一行是本版之前铸的,或那一座读不出 —— 两形同读,见 {@link ApprovalCardEnvelopeSchema} 的 `liveFacts` 注)。
+ */
+export type StoredApprovalCard = Omit<ApprovalCardEnvelope, "liveFacts"> & {
+    liveFacts?: ApprovalRequestLiveFacts;
+};
 /**
  * 🔴 **存下的卡的唯一读者入口**([ref])—— `approval_ask.card_json` 的每一个读点(断连重放 {@link buildReplayFrame}、回决口的「要不要人」
  * {@link storedCardDemandsAPerson}、幂等重入与规则兑付两处(`tool-approval.ts`)、local 车道的启动收敛(`approval-crash-convergence.ts`))都经这一只,
@@ -924,8 +996,10 @@ export declare function buildApprovalCardEnvelope(approvalId: string, card: Appr
  * (`retired-card-words.ts`),**响亮**:每改写一次计一次 `server.approval-card.retired-card-word-read`(计数 + probe + 一次 warn,detail 只报座名)。
  * 窗关(登记表 M18)后读侧半场随起服改写一起删,本函数回到「只 `safeParse`」。读不出(真坏形)⇒ `undefined`,各读点的处置不变(跳过 + warn / park /
  * 按要人 / 素材缺席 / 收敛成因按缺省)。
+ * 7.143.0 起信封上的活面事实座也只在这里读(整座过 {@link ApprovalRequestLiveFactsSchema}):读得出 ⇒ 读数带 `liveFacts`;缺席或读不出 ⇒ 不带(= 不知道),卡照读。
+ * 同一入口还有一次性迁移 M37 的读侧({@link renameRetiredSourceKey}):本版之前铸的卡上的委派出处旧键先改名,再过 M18 与 schema。
  */
-export declare function readStoredCardEnvelope(cardJson: unknown): ApprovalCardEnvelope | undefined;
+export declare function readStoredCardEnvelope(cardJson: unknown): StoredApprovalCard | undefined;
 /**
  * 🔴 **停驻行 `tool_approval` 臂的读侧入口**([ref];一次性迁移 M18 的读侧半场)—— 读它两座的两个读者(运维队列行 {@link parkRowFacts}、
  * 耐久 `/decide` 的 remember 判据 `tool-approval.ts` `parkRowStandingAnswerFacts`)先经这一只:7.50.x 停驻的行上两座的退役词按 M18 那一只改写读,
@@ -935,8 +1009,9 @@ export declare function readStoredCardEnvelope(cardJson: unknown): ApprovalCardE
  */
 export declare function currentParkArm<T>(pendingAction: T): T;
 /**
- * [ref] §3.1 的呈卡帧(设计稿 §4.1)—— **live 铸造**形(重放形见 {@link buildReplayFrame},
- * 两者投的是同一种帧,区别只在 `card` 的来源:这里是刚投影出来的,那里是从行上回读的)。
+ * [ref] §3.1 的呈卡帧(设计稿 §4.1)—— **唯一构造**:活铸(`tool-approval.ts` 的 `askBroadcast`)与重放({@link buildReplayFrame})投的是同一种帧、
+ * 经同一只函数,区别只在素材的来源:活铸的卡与活面事实是刚铸的那一份,重放的是行上卡信封回读的那一份(同一次写落下的)。
+ * `live` 缺席 ⇒ 帧带 `liveFactsUnknown: true`、不带任何一位活面事实 —— 只有重放会交缺席(行上没有那一座 / 读不出);活铸恒交帧对象。
  *
  * `expiresAtMs` **入参**而不是在这里现算:同一只 ask 的窗**只铸一次**(§3.1「永不赋新 deadline」),
  * 调用点已经算好了它(既是定时器时长的来源,也是落库 `expires_at_ms` 的值)——在这里重算会铸出第二个
@@ -949,7 +1024,7 @@ export declare function buildApprovalRequestFrame(input: {
     card: ApprovalCard;
     expiresAtMs: number;
     nowMs: number;
-    live: ApprovalRequestLiveFacts;
+    live: ApprovalRequestLiveFacts | undefined;
 }): ApprovalRequestFrame;
 /**
  * 🔴 **呈卡帧的活面事实座**(呈卡腿上旧族退役之后,开卡帧的全部事实都由本族承载)。
@@ -959,31 +1034,51 @@ export declare function buildApprovalRequestFrame(input: {
  * 卡外的事实此前只骑活卡帧,呈卡腿的消费方靠「两帧按 approvalId 合读」拿到它们。呈卡腿自此只发本族帧 ⇒ 它们挪到**活铸**的
  * 呈卡帧顶层,同名同型同值 —— 值取自同一只帧对象(活卡帧的那一次铸定,`tool-approval.ts` 的 `askBroadcast`),本仓不另算一遍。
  *
- * 在场面与它们在活卡帧上的在场面**逐字相同**:只在活铸的帧上,断连重放帧({@link buildReplayFrame},从 `card_json` 回读)上恒缺席 ——
- * 活卡帧从来不重放,卡外事实也从来不在重放面上;是否把其中某几位收进卡(耐久、随重放)是另一件事,各自要过 `.strict()` 信封的回滚窗判断
- * (`readRootCandidate` 有不进卡的硬理由:耐久面兑现不了它,见活卡帧该座顶注)。
+ * 🔴 **一只 ask 一份事实,活铸帧与重放帧同读(7.143.0)**:铸卡时同一只帧对象经同一只挑键函数落进问行卡信封的 `liveFacts` 座(与 `card` 同一条写,
+ * {@link buildApprovalCardEnvelope});断连重放帧({@link buildReplayFrame}:断流续读、开流 preamble、只经 preamble 到达的后台子代的问、起服接管的列表行、按问读口)
+ * 只读这一座 ⇒ 在场的每一位与活铸帧逐字同,缺席即缺席。行上没有这一座(本版之前铸的行)或它读不出 ⇒ 重放帧带 `liveFactsUnknown: true`、一位都不带
+ * (不伪造,不回填,不从停驻行孪生座 join —— 那是另一份店、另一个写者)。同一只问被另一腿再问(幂等命中既有行)时,重入那一腿的活铸帧也读这一座
+ * ({@link adoptStoredLiveFacts};行 = 真源)。带 NUL / 孤代理的一组不落座(某个后端存不下逐字的那一份,见 {@link buildApprovalCardEnvelope})。
+ * 卡面(`ApprovalCardSchema`)照旧不带这十一位(`approvalCard` 除外,见本注末段):
+ * 它们在帧顶层、不在 `card` 里,信封上是卡旁边的一座,不是卡的键。
+ * `readRootCandidate` 随重放的射程与卡上 `ruleOffers` 同一句(`ApprovalCardSchema.ruleOffers` 顶注):回授经重放帧自己的 `approvalId` 走活应答口,
+ * 有等待腿的副本兑得动;接管登记 / 耐久回决口上没有等待腿,应答照收、目录不加(没有 `approval.read_root_granted` 通告 = 什么都没加)。
  *
  * `requiresRealApproval` 不在表里:卡上 `risk.requiresRealApproval` 是同一个事实(铸卡第三参就是它),一个事实一个读法。
  * ⚠️ **`approvalCard` 是表里唯一一位 7.136.0 起同时在卡上的座**(`ApprovalCardSchema.approvalCard`:断连重放的卡要渲回同一张专卡,卡词必须进卡;
  * 同一次读定、同值)。按上一句的规矩它该离表(活铸帧顶层这一份退役 —— wire BREAKING,下游 sdk 的孪生表同改),本版按 additive 交付、未退役:
  * 一个事实两处读,登记为待收的债,收法 = 离表 + 消费方改读 `card.approvalCard`,不是在这里加第三处。
+ * 7.143.0 起卡信封的活面事实座按本表落座 ⇒ 这一位在信封上也是两份(`card.approvalCard` 与 `liveFacts.approvalCard`,同一次读、同值),仍是这一笔债、不是新的一笔:
+ * 离表那一刻帧顶层(活铸 / 重放)与信封座里的这一份一起退;座的读形是 `.strict()` 的,离表那一版要让读者在窗内容下带着它的在飞行(否则那些行读作「不知道」)。
  */
 export declare const APPROVAL_REQUEST_LIVE_FACT_KEYS: readonly ["mandated", "mandate", "origin", "boundGrantDigest", "boundGrants", "classifierNoRuling", "boundGrantAbsence", "approvalCard", "readRootCandidate", "probeReason", "requestedBy"];
 /** 呈卡帧活面事实座的类型面 = 活卡帧同名座的 `Pick`(同型由构造保证,不手抄)。 */
 export type ApprovalRequestLiveFacts = Pick<ToolApprovalFrame, (typeof APPROVAL_REQUEST_LIVE_FACT_KEYS)[number]>;
+/**
+ * 幂等重入采信行(「行 = 真源」家族,7.143.0):把一只活卡帧上的十一位换成行上卡信封那一座 —— 座里在场的照抄、座里缺席的删键。
+ * 读者 = `tool-approval.ts` 的 `askBroadcast` 幂等命中既有行那一臂(行上有座才调;没有座 ⇒ 无可采信,不调)。于是重入那一腿的活铸帧
+ * 与这只问的每一只重放帧是同一组事实;条目上的强制位 / 强制词 / 出身词随后从这只帧读,授予绑定读同一座(展示与判据同源)。
+ */
+export declare function adoptStoredLiveFacts(frame: ApprovalRequestLiveFacts, seat: ApprovalRequestLiveFacts): void;
 /**
  * [ref] §3.1 的呈卡帧(设计稿 §4.1 逐字)。
  *
  * 🔴 **一条腿一个帧族**:呈卡协议在一条腿上场(腿的审批上下文接了 `emitCard`)⇒ 这条腿上一只 ask 的开卡 / 消卡 / 撤卡只走本族
  * (`approval_request` / {@link ApprovalCompleteFrame} / {@link ApprovalRevokeFrame}),旧族 `tool_approval` / `tool_approval_complete`
  * 一帧都不发;协议未上场的腿只发旧族。同一只 ask 在同一条腿上不再有两种开卡帧,消费方不再按 `approvalId` 去重。
- * 开卡的全部事实因此在本帧上:卡(`card`,耐久信封)+ 活面事实座({@link ApprovalRequestLiveFacts},只在活铸的帧上)。
+ * 开卡的全部事实因此在本帧上:卡(`card`,耐久信封)+ 活面事实座({@link ApprovalRequestLiveFacts};活铸帧与重放帧同一份,见 {@link APPROVAL_REQUEST_LIVE_FACT_KEYS} 顶注)。
  */
 export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
+    /**
+     * 7.143.0 **ADDITIVE**:**这只 ask 的活面事实不在它的行上** —— 只在重放帧上、只取字面 `true`:行是本版之前铸的(卡信封上没有那一座),或那一座读不出。
+     * 在场时本帧一位活面事实都不带,它们的缺席**不是**断言:强制与否、出身、授予绑定……都按「不知道」读(强制与否不知道 ⇒ 按强制读,不让规则替人答)。
+     * 活铸帧恒不带;行上有座的重放帧不带(座里缺的那一位就是真缺席)。不回填:存量行随窗到期收敛。
+     */
+    liveFactsUnknown?: true;
     /** = SSE 具名事件名(与 `tool_approval` 同约定)。 */
     type: "approval_request";
     schemaVersion: 1;
-    /** `deriveAskId` 派生(持久层主键;六元身份元组 —— [ref] / 7.109.0 起含这一问的类集 —— 见 approval-ask-machine.ts)。 */
+    /** `deriveAskId` 派生(持久层主键;八元身份元组 —— 7.109.0 起含这一问的类集,7.143.0 起含展示的动作(工具名 + 入参摘要) —— 见 approval-ask-machine.ts)。 */
     askId: string;
     /** wire run id(= 协调器 ctx 的 taskId)。 */
     taskId: string;
@@ -1092,13 +1187,34 @@ export declare function buildRevokeFrame(batchId: string, askIds: readonly strin
  *  - **零写**:本函数不碰 store —— 重放腿只读,不 `transitionAsk`、不改 `expires_at_ms`、不重挂定时器。
  *    过窗未收敛的行(`expiresInMs === 0`)**仍然重放**,不在这里代打 `expireAsk` CAS(那会制造第五个
  *    竞争者;收敛是车2 的窗到期竞争者与车5 恢复扫描的职责)。
+ *  - **与活铸帧同一份事实**(7.143.0):卡与活面事实座都取自行上的卡信封(同一次写落下的),经与活铸帧同一只构造 {@link buildApprovalRequestFrame};
+ *    行上没有座 / 座读不出 ⇒ `liveFactsUnknown`(见帧型该键)。
  */
 export declare function buildReplayFrame(row: Pick<AskRow, "askId" | "taskId" | "expiresAtMs" | "cardJson">, nowMs: number): ApprovalRequestFrame | undefined;
 /**
- * [ref] —— 持久行上那张卡**要不要人**:卡面 `risk.requiresRealApproval`(铸卡时取自引擎在 `AskRequest` 上盖的同一位,
- * {@link buildApprovalCard} 第三参)。读者 = 耐久 ask 回决口在裁决之前交给引擎判官 `policyCannotAnswer` 的那一问(`host-decision.ts` 的 `heldAskOf`)。
- * 🔴 读不出卡(`card_json` 形不合)⇒ **按要人读**(fail-closed):这一位只用来**拒**策略的放行,读坏的行上拒一次可以改成人答 / 策略拒
- * 再来;反方向(读坏当不要人)会让一次引擎终将拒掉的放行先落成一条宣称 approve 的行。
+ * 「这一问要人」(core `requiresRealApproval`:只有真人逐次答得了 —— 一揽子席、记住的放行、策略的放行都不行)的**唯一读法**:
+ * 引擎在**这一腿**请求上盖的那一位 ∪ 这只问**行上那张卡**记着的那一位(`risk.requiresRealApproval`;新铸的卡上那一位就是本函数对铸卡那一腿的读数,
+ * 见 {@link buildApprovalCard} 第三参)。任一为真即真 —— 并集只升不降:同一只问被另一腿再问(换副本重入、混版窗)读到不同的引擎事实时取严,
+ * 永不因采信行或采信请求而放宽。
+ * 两个输入各自可缺,调用方只交「手里有什么」:手里还没有行(会话授权短路、新铸那张卡、无问店)⇒ `recordCard` 缺席;手里没有这一腿的请求
+ * (起服接管的登记、耐久问回决口 —— 只有行)⇒ `legRequest` 缺席。请求上的位按引擎的契约 `=== true` 严判(真才带;别的真值是照另一份契约写的)。
+ * 读者:`tool-approval.ts` 的活审批腿(读侧会话授权短路的事实、铸卡、条目定稿 —— 条目 / 「本会话放行」判据 / 策略放行门 / 两族帧 / 列表行、
+ * 起服接管登记、策略层自己交出去的问)与本文件的 {@link storedCardDemandsAPerson}。core 停驻行(`PendingAction.tool_approval`)上的孪生座是
+ * 另一只店、另一个写者,读法是 {@link readParkRowTrueSeat}。
+ */
+export declare function askDemandsAPerson(legRequest: {
+    readonly requiresRealApproval?: unknown;
+} | undefined, recordCard: Pick<ApprovalCard, "risk"> | undefined): boolean;
+/**
+ * 问行上存的卡(`card_json`)交给 {@link askDemandsAPerson} 的那份**记录**:读得出 ⇒ 那张卡;读不出 ⇒ 一份「要人」的记录。
+ * 🔴 读不出按要人(fail-closed):这一位只用来**拒**(策略的放行、记住的放行),读坏的行上拒一次可以改成人答 / 策略拒再来;反方向(读坏当不要人)
+ * 会让一次引擎终将拒掉的放行先落成一条宣称 approve 的行、或让一张要人卡被记住。读者:{@link storedCardDemandsAPerson} 与 `tool-approval.ts` 里
+ * 「行在、但这一腿没有采信行上信封」的那一臂(`ensureAsk` 报错后复核读读到行)。
+ */
+export declare function storedPersonDemandRecord(cardJson: unknown): Pick<ApprovalCard, "risk">;
+/**
+ * [ref] —— 持久行上那张卡**要不要人**(手里只有行:经 {@link askDemandsAPerson},请求缺席;读不出按要人,见 {@link storedPersonDemandRecord})。
+ * 读者 = 耐久 ask 回决口在裁决之前交给引擎判官 `policyCannotAnswer` 的那一问(`host-decision.ts` 的 `heldAskOf`)。
  */
 export declare function storedCardDemandsAPerson(cardJson: unknown): boolean;
 /** {@link buildApprovalPreamble} 的返回形——帧 + 两个**计数**(调用方按自己的 logger 记 warn;本模块