@sema-agent/server 7.147.0 → 7.149.0

package/dist/runs.d.ts

@@ -9,12 +9,14 @@ import { type RunAbort } from "./run-cancel-context.js";
 import type { ModelUsageTracker, PromptManifestTracker } from "./budget.js";
 import type { ElicitationCoordinator } from "./elicitation.js";
 import type { QuestionCoordinator } from "./question.js";
+import type { ApprovalLegOrigin } from "./approval-leg-origin.js";
 import { type ApprovalFrameFamily, type ToolApprovalCoordinator } from "./tool-approval.js";
 import { type FleetRunPublisher } from "./fleet/fleet-bus.js";
 import { type WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
 import type { RunAcceptance } from "./run-acceptance.js";
 import type { SessionWorkspaceRecorder } from "./session-workspace.js";
 import type { VerifyRoundsSpec } from "./http/verify-rounds.js";
+import { type ParkLedgerEventType } from "./trace/ledger-events.js";
 import type { UserInputLedger } from "./user-input-ledger.js";
 /**
  * stoppedBy (core 1.252): a service cancel is a USER stop — mark the run's still-running background
@@ -94,7 +96,7 @@ export declare function taskHandleStop(registry: typeof defaultTaskRegistry, han
  * 已 fire 的信号永不回调,那样一次真实的人为断连会被吞成「无归因」(子代 settle 时记成 system)。
  * 语义上这两种时序是同一件事:本请求赢下了这条 session,而这条 session 的连接是被人断掉的。
  */
-export declare function markChildrenStoppedByUserOnAbort(signal: AbortSignal, taskId: string, principal: string | null | undefined): void;
+export declare function markChildrenStoppedByUserOnAbort(signal: AbortSignal, taskId: string, subject: string | null | undefined): void;
 export declare function resumeAtHttpStatus(result: {
     terminal: TerminalCause;
 }): number | undefined;
@@ -114,7 +116,7 @@ export declare function resumeAtHttpStatus(result: {
 export declare function syncRefusalHttpStatus(result: Pick<TaskResult, "terminal" | "stats">): number | undefined;
 /**
  * 同步腿零工作拒体的机读事实(交 `refusalBody` 的 `facts`)—— 唯一一处。入参是**出口封口 + 脱敏后**的终局(调用方递 `redactTerminalResult(sealResultForExit(result)).terminal`,
- * 与 run 记录读面 / 流式 `done.result` 上的 `terminal` 同一只来源),本函数只按码取它的 `detail.detail`,不另读、不另脱。码不在登记表里、终局不是 `failed`、
+ * 与 run 记录读面 / 流式 `done.result` 上的 `terminal` 同一只来源),本函数只按码取它的 `detail.detail` 经闭集映射({@link attachmentCauseFacts}),不另读、不另脱。码不在登记表里、终局不是 `failed`、
  * 引擎没给 `coded` 因由 ⇒ `{}`(缺席不造键)。
  * 两张工具名清单的码({@link ENGINE_TOOL_LIST_REFUSAL_CODES})是另一臂:体事实不取引擎的因由,取 `admissionReadings`(受理口对放行侧选择器清单的读数,`PreparedTaskSubmission.warnings`)
  * 去掉 `not_in_roster`、且 `code` 与终局的码相同(同一族清单)的那些 —— 与受理口 400 同一只机读位形;没有读数 ⇒ `{}`。
@@ -132,8 +134,8 @@ export declare function releaseKeyIfZeroWorkRefusal(runStore: {
     releaseIdemKey(taskId: string): Promise<void>;
 }, taskId: string, result: Pick<TaskResult, "terminal" | "stats">): Promise<void>;
 /**
- * E18 resume-at — per-turn anchor capture, shared by runInBackground AND the resume-leg driveResume so the (single,
- * tricky) capture rule can't drift between the two stream-drain loops.
+ * E18 resume-at — per-turn anchor capture, shared by runInBackground, the resume-leg driveResume AND the sync `POST /v1/tasks`
+ * leg's plain form so the (single, tricky) capture rule can't drift between the stream-drain loops.
  *
  * A "turn" in core = ONE assistant message + its tool batch. resume-at is valid ONLY at a SETTLED rewindable boundary
  * — core's prepare-task accepts "user messages or finished assistant-text turns" and REJECTS an assistant message that
@@ -151,7 +153,7 @@ export declare function releaseKeyIfZeroWorkRefusal(runStore: {
  * observable instead of a silent feature outage.
  */
 /**
- * 「这一次用户消息提交是不是这个 run 的**开场提示**」的唯一读法 —— 三处用户回退锚(后台腿与续跑腿的 {@link TurnAnchorCapture}、`/v1/tasks/stream`
+ * 「这一次用户消息提交是不是这个 run 的**开场提示**」的唯一读法 —— 四处用户回退锚(后台腿 / 续跑腿 / 同步腿 `POST /v1/tasks` 的 {@link TurnAnchorCapture}、`/v1/tasks/stream`
  * 腿的 `userMsgEntryId`)同调这一只;调用点零各自判、零按正文判,且都是「最后一次交出的赢」。
  *
  * **回退锚 = 该轮开场提示,一个 run 一个(开场窗 + 闩)**:run 一开始就开着一个**开场窗**,收集第一次模型输出之前的 user 提交;窗关上之后(闩上),同 run 的 user-role 提交 ——
@@ -189,13 +191,13 @@ export declare function releaseKeyIfZeroWorkRefusal(runStore: {
 export declare function createPromptCommitReader(): (ev: {
     readonly type: string;
 }) => string | undefined;
-/** 回退锚写在哪条腿上(探针行的 `leg=`):流式腿 `POST /v1/tasks/stream`、后台腿 `POST /v1/runs`、续跑腿。 */
-export type ResumeAnchorLeg = "stream" | "bg" | "resume";
+/** 回退锚写在哪条腿上(探针行的 `leg=`):流式腿 `POST /v1/tasks/stream`、同步腿 `POST /v1/tasks`(非流式)、后台腿 `POST /v1/runs`、续跑腿。 */
+export type ResumeAnchorLeg = "stream" | "sync" | "bg" | "resume";
 /**
- * 回退锚的**唯一**写法(三条腿同一只):**有界** await 写入(单行店操作期限 {@link BASELINE_IO_DEADLINE_MS},与项目指令基线的
+ * 回退锚的**唯一**写法(四条腿同一只):**有界** await 写入(单行店操作期限 {@link BASELINE_IO_DEADLINE_MS},与项目指令基线的
  * 读写同一只数、同一只 {@link withinIoDeadline} —— 同为单行 PK 写、同在腿的关键路径上);写失败或到期 ⇒ 不抛(锚是这次提示词能不能
  * 回退的手柄,不是 run 的成败),记一次登记过的 fail-open `server.resume-anchor.capture-failed`(`reason=error|timeout`;计数 + 探针行 + 一次性 warn)。
- * 调用方在本腿的终帧(流式腿的 `done`)**之前** await 它 ⇒ 客户端拿到终帧时锚已落定或已知没落定,没有「锚晚到」的窗;锚店挂住至多让终帧晚一个期限。
+ * 调用方在本腿的终帧(流式腿的 `done`、同步腿的 200 应答)**之前** await 它 ⇒ 客户端拿到终帧时锚已落定或已知没落定,没有「锚晚到」的窗;锚店挂住至多让终帧晚一个期限。
  * 到期只放手不取消:那次写照常在飞,迟到落定的锚照样可用(迟到的失败被吞,不重复计数)。
  * 用户面的读数仍只有一处:会话视图用户消息行的 `taskId?`(present-iff 锚在)与 `resumeAt` 的 404 `resume_at.unknown_event`。
  */
@@ -211,7 +213,7 @@ export declare class TurnAnchorCapture {
      *  `message_committed{role:"user"}` event — its `entryId` is the persisted user-message `SessionTreeEntry.id`,
      *  ALWAYS a valid `resumeAt` target (core accepts a user message; it rejects a tool-result / mid-tool-call
      *  assistant). This is the CC rewind target ("rewind to the prompt" = the code-restore parity path — a code
-     *  change happens in a tool turn WITHIN a prompt's run, so rewinding to the prompt + rewindFiles undoes it).
+     *  change happens in a tool turn WITHIN a prompt's run, so rewinding to the prompt + restoreFiles undoes it).
      *  Keyed by the run's taskId (the handle the shell already holds from the POST response — no eventId→entryId
      *  side map / no leaf-read inference needed). The assistant-turn capture above stays as an additive bonus.
      *  The anchor is the run's OPENING prompt (the reader's opening window: provisional on the first user commit, corrected
@@ -232,7 +234,7 @@ export declare class TurnAnchorCapture {
      *  `message_committed{role:"user"}` event — its `entryId` is the persisted user-message `SessionTreeEntry.id`,
      *  ALWAYS a valid `resumeAt` target (core accepts a user message; it rejects a tool-result / mid-tool-call
      *  assistant). This is the CC rewind target ("rewind to the prompt" = the code-restore parity path — a code
-     *  change happens in a tool turn WITHIN a prompt's run, so rewinding to the prompt + rewindFiles undoes it).
+     *  change happens in a tool turn WITHIN a prompt's run, so rewinding to the prompt + restoreFiles undoes it).
      *  Keyed by the run's taskId (the handle the shell already holds from the POST response — no eventId→entryId
      *  side map / no leaf-read inference needed). The assistant-turn capture above stays as an additive bonus.
      *  The anchor is the run's OPENING prompt (the reader's opening window: provisional on the first user commit, corrected
@@ -283,16 +285,24 @@ export declare function parkToolCallId(result: unknown, cs: ParkCheckpointReader
  *  不塞进 `checkpointGate`——那是 core 的类型,server 不改其形)。非 park / 无 token / tool-less /
  *  读失败 ⇒ **同一引用**原样返回(键缺席)。graft 不负责 strip——组合序恒为 graft → strip。 */
 export declare function graftParkToolCallId<T>(result: T, cs: ParkCheckpointReader | undefined): Promise<T>;
+/** 一份结果在等的那张卡与它停在的停驻词(暂停因由 ∧ 投影出口给的词是停驻词);不是停驻 ⇒ `undefined`。后台腿的停驻臂与兜底腿、续跑腿的兜底同读它。 */
+export interface HeldPark {
+    readonly word: ParkLedgerEventType;
+    readonly token: CheckpointToken;
+}
+export declare function heldParkOf(result: TaskResult): HeldPark | undefined;
 /**
- * 🔴 [ref] **停驻没落定就以失败收场的腿:卡的命运先于认领释放**(后台腿与续跑腿同读这一只;动词 = `card-void.ts` 的结算作废)。
+ * 🔴 [ref] **手里握着已提交的卡却以终局收场的腿:卡的命运先于认领释放**(后台腿与续跑腿同读这一只;动词 = `card-void.ts` 的结算作废)。
  *
- * 腿要以失败收场(行 `failed`、认领释放),而手里的结果是宿主层停驻 —— 引擎交回结果之前已把卡落进 checkpoint 店,卡在本 run 的会话上 ——
+ * 腿要以终局收场(行 `failed`、认领释放),而手里的结果是宿主层停驻 —— 引擎交回结果之前已把卡落进 checkpoint 店,卡在本 run 的会话上 ——
  * ⇒ 先把那张卡按它自己的 scope 作废,调用方再放认领。不作废 ⇒ 待决面上留一张卡,兑现它的 run 已经 `failed`、认领已放:决定口照样受理,
  * 续跑在没有认领的会话上驱动(`resume-legs.ts` 认领缺席的成因清单)。顺序承重:先放认领、后作废 ⇒ 两步之间(作废没做成时一直)就是那一形。
- * 停驻没落定的成因不在判据里(停驻行 / 用量行 / 结果到手之后的任何一笔账本写抛):判据只读手里那份结果。
+ * 走到这里的只剩「这条 run 真的不再等这张卡」的形:取消落在结果到手之后(两条腿)、暂停结果不是停驻词。
+ * 停驻簿记写抛(账本帧 / 用量差 / 结果到手之后的清单行与缓冲文本)**不**走到这里 —— 卡已提交 ⇒ 照常提交停驻({@link commitParkRow}),
+ * 簿记只留痕;行的停驻写被店答出拒(行已不是本腿的)由提交口自己作废那张卡。
  *
- * `held` = 手里那份结果过了宿主判官之后的形(判官提上来的嵌套停驻同样算;不在本 run 会话上的嵌套停驻 —— cascade 级上的卡 —— 判官不提,
- * 不归本腿作废)。不是停驻 ⇒ 零 I/O。不抛:作废没做成 ⇒ 卡回到「留在待决面上、由兜底收割收走」的形,响亮留痕。
+ * `held` = 手里那份结果过了宿主判官之后的形(判官提上来的嵌套停驻同样算 —— verify 的实现腿 / 修复轮、cascade 的级上卡,都归本 run 的会话)。
+ * 不是停驻 ⇒ 零 I/O。不抛:作废没做成 ⇒ 卡回到「留在待决面上、由兜底收割收走」的形,响亮留痕。
  */
 export declare function voidHeldParkCard(held: {
     readonly terminal: TerminalCause;
@@ -328,11 +338,22 @@ export declare function voidHeldParkCard(held: {
  * only — a suspended run is steered durably via the checkpoint's `setPendingSteer` instead, and only the
  * plain-stream path holds a steerable stream (the verify/cascade branches return a result, not a stream).
  */
-export declare function runInBackground(runner: Runner, spec: TaskSpec, runStore: RunStore, taskId: string, metrics?: Metrics, principal?: string, verify?: VerifyRoundsSpec, // 快审 F1:number 参升整对象——cost 顶随传
+export declare function runInBackground(runner: Runner, spec: TaskSpec, runStore: RunStore, taskId: string, 
+/**
+ * 本腿停驻的两条事实,只有一个读者 —— 停驻提交({@link commitParkRow}):`legId` = 本腿的持有腿(建行 `createRun` 交回的 `{ ok: true, legId }`,
+ * 停驻写只许它落下);`runStaleSec` = 判活窗(秒,`REAP_RUN_STALE_SEC`,活配置;路由层 `deps.config.runStaleSec`;缺席 ⇒ 缺省窗),店故障时再提交的上界。
+ * 必填:持有腿是认领交给本腿的,不是读来的 —— 调用方不交它,停驻就无从提交(编译期红,不留运行期的缺席臂)。
+ */
+parkCommit: {
+    readonly legId: string;
+    readonly runStaleSec: number | undefined;
+}, metrics?: Metrics, 
+/** 本跑的属主主体(分区键;行属主 / ALS 读它)。 */
+principal?: string, verify?: VerifyRoundsSpec, // 快审 F1:number 参升整对象——cost 顶随传
 cascade?: CascadeConfig, instrumentDegenerate?: (result: TaskResult) => void, planCacheProbe?: {
     record: (scope: string | undefined, objective: string, completed: boolean) => void;
 }, persistThinking?: boolean, inflight?: Map<string, RunAbort>, preemptable?: Map<string, AbortController>, steerable?: Map<string, TaskStream>, modelUsage?: ModelUsageTracker, elicitation?: ElicitationCoordinator, 
-/** E23: the VERIFIED principal (gatedPrincipal) that may answer this run's elicitations — matches the respond
+/** E23: the VERIFIED principal (gatedSubject) that may answer this run's elicitations — matches the respond
  *  owner-gate's identity source (NOT the cost-attribution `principal`, which on a direct door is the self-asserted
  *  header → can be null while a JWT principal exists). Falls back to the run owner when not supplied. */
 elicitOwner?: string | null, 
@@ -386,8 +407,8 @@ approval?: {
     streamApprovalOn: boolean;
     windowMs: number | undefined;
     windowMarginMs: number;
-    declaredFamilies: ReadonlySet<ApprovalFrameFamily>; /** 出处带车道:这条执行上下文的车道(装配点 `durable-run-leg.ts` 写 `ctx.lane`)。 */
-    executionLane: import("./execution-lane-caps.js").ExecutionLane;
+    declaredFamilies: ReadonlySet<ApprovalFrameFamily>; /** 出处带车道 + 化身:这条执行上下文的车道与那一读的住客(装配点 `durable-run-leg.ts` 经 `approvalLegOriginOf` 写)。 */
+    origin: ApprovalLegOrigin;
 }, 
 /** 本腿结算用的 checkpoint 店(`deps.checkpointStore`),两件事:①[ref] park 投影腿的读口 —— 在场时 durable park 的
  *  `suspended` 事件带 `toolCallId`(graft 见 {@link parkToolCallId});②停驻没落定就以失败收场时作废手里那张卡({@link voidHeldParkCard})。
@@ -434,7 +455,21 @@ workspaceRecorder?: SessionWorkspaceRecorder,
  * 这条 run 交给引擎的技能名册(`wiring_manifest.skills` 段;部署事实 `LegFacts.skills`,`leg-facts.ts`:受理漏斗在复制之前读出)。
  * 缺席 = 嵌入方自带的装配器没铸 ⇒ 账本行不带技能段。
  */
-runSkills?: readonly RunSkillEntry[]): Promise<void>;
+runSkills?: readonly RunSkillEntry[], 
+/**
+ * 这次提交登记的工作目录(部署事实 `LegFacts.registeredCwd`)。只在两条组合腿(verify / cascade)上经 `compositionLegRoot` 交给引擎 ——
+ * 梯子的级 / 验证器腿跑在引擎现铸的会话里,工厂按会话读不到它;普通流形跑在根会话上,工厂自己读得到。缺席 = 没登记 ⇒ 每一条腿照旧落临时目录。
+ */
+registeredCwd?: string): Promise<void>;
+/** 一次心跳要的那一面(run 店的带属主刷新;交回「行还在 running 吗」)。 */
+export interface RunHeartbeatStore {
+    heartbeat(taskId: string, owner: string | null): Promise<boolean>;
+}
+/**
+ * 🔴 **一次心跳**(四条腿的心跳拍与认领心跳 `http/claim-heartbeat.ts` 同一只 —— 判法只在这里):刷新,店交回「这条 run 的行还在 running 吗」;不在 ⇒ `onLost()`,持有者停下自己的腿。
+ * 判死一条行(观察口 / 认领冲突 / 收割器)拦不住它的执行者 —— 心跳打空今天不报,两个执行者会同写一只会话;这一答补上那一半。刷新失败不抛(`onError` 计数),下一拍再刷。
+ */
+export declare function beatRunHeartbeat(runStore: RunHeartbeatStore, taskId: string, owner: string | null, onLost: () => void, onError: () => void): void;
 /** How often a running instance refreshes its run's updated_at (liveness, independent of events).
  *  Must stay strictly below `runStaleSec` (asserted at startup AND on every hot config candidate) or the
  *  reaper would race live runs. [ref]:数值的单源是 `config-invariants.ts`(那条不变量的属主),两个消费面

package/dist/runs.js

@@ -1,13 +1,17 @@
 import { runWithVerification, runCascade, defaultTaskRegistry, taskNotificationDedupKey, DURABLE_AGENT_HANDLE_RE } from "@sema-agent/core";
-import { atHostBoundary, failureCodeOf, sealResultForExit, outwardPlane } from "./terminal.js";
+import { atHostBoundary, failureCodeOf, sealResultForExit, outwardPlane, outwardThrownMessage } from "./terminal.js";
 import { voidVerifierPauseCard } from "./verifier-pause-card.js";
 import { voidPendingCard } from "./card-void.js";
+import { commitParkRow } from "./park-row-commit.js";
 import { NOT_IN_ROSTER, entryProblemsFacts } from "./entry-problems.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
 import { TOOL_DECLARATION_HTTP_STATUS } from "./tool-declaration-http-status.js";
 import { isSessionErrorCode, sessionErrorHttp } from "./session-error-wire.js";
 import { redactErrorMessage } from "./observability/run-terminal.js";
-import { withPrincipal } from "./observability/principal-context.js";
+import { withSubject } from "./observability/principal-context.js";
+import { partsOf } from "./owner-brands.js";
+import { recoveredSubject } from "./owner-faces.js";
+import { taskSpecIdentityOf } from "./engine-identity.js";
 import { withModelReachScope } from "./model-reach-scope.js";
 import { createInstructionSelectionLeg } from "./instruction-selection.js";
 import { redactSecrets } from "./trace/redact.js";
@@ -16,7 +20,8 @@ import { createLedgerSink } from "./trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "./trace/engine-notice-wire.js";
 import { recordTurnActivity } from "./turn-activity.js";
 import { buildCancelledLedgerRow, CANCELLED_CODE, createRunAbort, mintCancelledResult } from "./run-cancel-context.js";
-import { createApprovalCardEmitter, resolveApprovalLeg } from "./tool-approval.js";
+import { resolveApprovalLeg } from "./tool-approval.js";
+import { createHitlTransport } from "./hitl-delivery.js";
 import { fleetRunResiduals } from "./fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "./orchestration/workflow-completion-inbox.js";
@@ -25,6 +30,7 @@ import { recordFailOpen } from "./observability/fail-open.js";
 import { BASELINE_IO_DEADLINE_MS, IoDeadlineExceeded, withinIoDeadline } from "./instruction-source-notice.js";
 import { errorText as errText } from "./observability/err-text.js";
 import { LIVENESS_HEARTBEAT_MS } from "./config-invariants.js";
+import { compositionLegRoot } from "./task-cwd.js";
 export async function backgroundAgentOutput(registry, handle, access, agentStore) {
     const row = registry.getAccessibleTask(handle, access);
     if (!row || row.type !== "background_agent") {
@@ -55,7 +61,9 @@ export async function taskHandleStop(registry, handle, access, agentStore) {
     registry.markStopSource(handle, "user");
     return registry.stopTask(handle, access);
 }
-export function markChildrenStoppedByUserOnAbort(signal, taskId, principal) {
+export function markChildrenStoppedByUserOnAbort(signal, taskId, subject) {
+    const recovered = recoveredSubject(subject);
+    const principal = taskSpecIdentityOf(recovered === undefined ? undefined : partsOf(recovered)).principal;
     const mark = () => {
         try {
             defaultTaskRegistry.markStopSourceForOwner({ owner: taskId, scope: principal ?? "default" }, "user", { skipSessionScoped: true });
@@ -85,6 +93,7 @@ const PREPARE_REFUSAL_HTTP_STATUS = {
     "config.invalid_checkpoint_store": 400,
     "config.skill_listing_budget_invalid": 400,
     "config.user_invoked_skill_unknown": 400,
+    "config.skill_deny_unreadable": 409,
     "config.image_invalid": 400,
     "config.user_attachment_invalid": 400,
     "config.tool_face_control": 400,
@@ -127,6 +136,15 @@ export function syncRefusalHttpStatus(result) {
     return resumeAtHttpStatus(result);
 }
 const ZERO_WORK_REFUSAL_DETAIL_CODES = new Set(["config.user_attachment_invalid"]);
+function attachmentCauseFacts(cause) {
+    if (cause === null || typeof cause !== "object")
+        return {};
+    const c = cause;
+    return {
+        ...(typeof c.path === "string" && c.path !== "" ? { field: c.path } : {}),
+        ...(typeof c.index === "number" && Number.isInteger(c.index) && c.index >= 0 ? { index: c.index } : {}),
+    };
+}
 const ENGINE_ENTRY_SPELLING_REASONS = new Set(["near_miss", "unknown_name"]);
 function engineReasonOf(detail) {
     if (detail === null || typeof detail !== "object")
@@ -155,7 +173,7 @@ export function zeroWorkRefusalFacts(terminal, admissionReadings = []) {
     if (cause === null || typeof cause !== "object")
         return {};
     const c = cause;
-    return c.kind === "coded" && c.detail !== undefined ? { detail: c.detail } : {};
+    return c.kind === "coded" ? attachmentCauseFacts(c.detail) : {};
 }
 const RETRY_CLASS_WORDS = { transient: true, terminal: true };
 function engineRetryClassOf(terminal) {
@@ -286,12 +304,18 @@ export async function graftParkToolCallId(result, cs) {
     const id = await parkToolCallId(result, cs);
     return id === undefined ? result : { ...result, toolCallId: id };
 }
+export function heldParkOf(result) {
+    if (result.terminal.kind !== "paused")
+        return undefined;
+    const word = outwardPlane(result.terminal).status;
+    return isParkLedgerEventType(word) ? { word, token: result.terminal.token } : undefined;
+}
 export async function voidHeldParkCard(held, hostSessionId, cards, leg) {
     if (held?.terminal.kind !== "paused")
         return;
     await voidPendingCard({ token: held.terminal.token, sessionId: hostSessionId }, cards, "server.park.held-card-void-failed", `leg=${leg}`);
 }
-export async function runInBackground(runner, spec, runStore, taskId, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, checkpointCards, pendingEngineNotices, trustedInternals, userInputLedger, acceptance, workspaceRecorder, runSkills) {
+export async function runInBackground(runner, spec, runStore, taskId, parkCommit, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, checkpointCards, pendingEngineNotices, trustedInternals, userInputLedger, acceptance, workspaceRecorder, runSkills, registeredCwd) {
     const startedAt = Date.now();
     metrics?.addGauge("runs_active", 1);
     fleetPublisher?.onStart();
@@ -329,17 +353,17 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     if (approval) {
         const coordinator = approval.coordinator;
         spec.onAsk = approvalLeg.unattended
-            ? coordinator.boundUnattendedAsk({ owner: elicitOwner ?? owner, taskId, ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), executionLane: approval.executionLane }, approvalLeg.unattended)
+            ? coordinator.boundUnattendedAsk({ owner: elicitOwner ?? owner, taskId, ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), ...approval.origin }, approvalLeg.unattended)
             : coordinator.boundAsk({
                 owner: elicitOwner ?? owner,
                 taskId,
                 ...(spec.sessionId ? { sessionId: spec.sessionId } : {}),
-                executionLane: approval.executionLane,
+                ...approval.origin,
                 ...(approvalLeg.active ? { legKey: "", ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}) } : {}),
             });
     }
     const heartbeat = setInterval(() => {
-        void runStore.heartbeat(taskId, owner).catch(() => { metrics?.inc("run_signal_poll_errors_total", { kind: "heartbeat" }); });
+        beatRunHeartbeat(runStore, taskId, owner, () => cancelCtrl.abort("stall_verdict"), () => { metrics?.inc("run_signal_poll_errors_total", { kind: "heartbeat" }); });
         if (!cancelCtrl.signal.aborted) {
             void runStore.isCancelRequested(taskId, owner).then((c) => { if (c)
                 cancelCtrl.abort("cancel_verb"); }).catch(() => { metrics?.inc("run_signal_poll_errors_total", { kind: "cancel" }); });
@@ -359,23 +383,26 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     let legLive = true;
     const notifiedKeys = new NotifiedKeys();
     const subagentHandleEvictions = [];
-    const parkRowWrite = {
-        suspended: (sealed) => runStore.setSuspended(taskId, sealed),
-        needs_review: (sealed) => runStore.setNeedsReview(taskId, sealed),
-    };
-    const parkLeg = async (word, res) => {
+    const parkLeg = async ({ word, token }, res) => {
         const grafted = await graftParkToolCallId(res, checkpointCards);
         await sink.appendParked(word, grafted);
         const sealed = sealResultForExit(grafted);
         reached = { kind: word, result: sealed };
-        await parkRowWrite[word](sealed);
+        const committed = await commitParkRow({
+            runStore, taskId, word, result: sealed, card: { token, sessionId: spec.sessionId }, cards: checkpointCards, leg: "bg",
+            legId: parkCommit.legId, staleWindowMs: parkCommit.runStaleSec === undefined ? undefined : parkCommit.runStaleSec * 1000,
+        });
+        if (committed.kind === "ended") {
+            reached = undefined;
+            settledAsCancel = committed.row?.errorCode === CANCELLED_CODE;
+        }
         acceptance?.settle(sealed);
     };
     const settleLegResult = async (engineResult) => {
-        const result = atHostBoundary(engineResult, spec.sessionId);
-        const parkWord = result.terminal.kind === "paused" ? outwardPlane(result.terminal).status : undefined;
-        if (parkWord !== undefined && isParkLedgerEventType(parkWord)) {
-            await parkLeg(parkWord, result);
+        const result = atHostBoundary(engineResult);
+        const held = heldParkOf(result);
+        if (held !== undefined) {
+            await parkLeg(held, result);
             return;
         }
         const settled = causeAtDone !== undefined ? cancelledResult(causeAtDone, result) : result;
@@ -397,24 +424,16 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     modelUsage?.register(taskId);
     const manifestSeat = createPromptManifestSeat(promptManifests, taskId);
     const flushPromptManifest = () => manifestSeat.drain(append);
-    const elicitEmit = (frame) => {
-        const { type, ...rest } = frame;
-        return append(type, rest);
-    };
-    const questionEmit = (frame) => {
-        const { type, ...rest } = frame;
-        return append(type, rest);
-    };
-    const approvalEmit = (frame) => {
-        const { type, ...rest } = frame;
-        return append(type, rest);
-    };
+    const hitlTransport = createHitlTransport({ ledger: append });
     const unregisterEngineNotice = registerEngineNoticeLeg({
         sessionId: spec.sessionId,
+        taskId,
         ...(pendingEngineNotices !== undefined ? { pending: pendingEngineNotices } : {}),
         durable: (row) => append("engine_notice", row).then(() => true, () => (recordFailOpen("server.engine-notice.durable-append-failed", `leg=bg code=${row.code} task=${taskId}`), false)),
     });
     try {
+        if (typeof parkCommit?.legId !== "string" || parkCommit.legId === "")
+            throw new TypeError(`runInBackground: run ${taskId} was started without the holding leg its claim handed back (parkCommit.legId) — refusing to start a run whose park could never be committed`);
         if (userInputLedger && spec.sessionId)
             await userInputLedger.announceUndrained({ sessionId: spec.sessionId, taskId });
         await emitPendingWorkflowCompletions(workflowCompletionInbox, spec.sessionId, elicitOwner ?? owner, (frame) => {
@@ -471,10 +490,11 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     void sink.appendStatus(e).catch((err) => completionDiagLog?.("status_event_append_failed", { route: "bg-run-composite", taskId, err: err instanceof Error ? err.message : String(err) }));
                 },
             };
+            const compositeInternals = { ...fwdInternals, ...statusSeat, ...compositionLegRoot(registeredCwd) };
             const compositeLeg = verify !== undefined
-                ? () => runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, { ...fwdInternals, ...statusSeat })
+                ? () => runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, compositeInternals)
                 : cascade !== undefined
-                    ? () => runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, { ...fwdInternals, ...statusSeat })
+                    ? () => runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, compositeInternals)
                     : undefined;
             if (compositeLeg !== undefined) {
                 const result = await compositeLeg();
@@ -532,12 +552,12 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 await append("suggestions", { suggestions: suggestions.map((s) => redactSecrets(s)) });
             }
         };
-        await instructionLeg.run(spec.sessionId, () => withModelReachScope({ sessionId: spec.sessionId, taskId }, () => withPrincipal(principal, () => {
+        await instructionLeg.run(spec.sessionId, () => withModelReachScope({ sessionId: spec.sessionId, taskId }, () => withSubject(recoveredSubject(principal), () => {
             const withElicit = elicitation
-                ? () => elicitation.runWithContext({ taskId, owner: elicitOwner ?? owner, emit: elicitEmit, abortSignal: cancelCtrl.signal }, runBody)
+                ? () => elicitation.runWithContext({ taskId, owner: elicitOwner ?? owner, transport: hitlTransport, abortSignal: cancelCtrl.signal }, runBody)
                 : runBody;
             const withQuestion = () => question
-                ? question.runWithContext({ taskId, owner: elicitOwner ?? owner, emit: questionEmit, abortSignal: cancelCtrl.signal }, withElicit)
+                ? question.runWithContext({ taskId, owner: elicitOwner ?? owner, transport: hitlTransport, abortSignal: cancelCtrl.signal }, withElicit)
                 : withElicit();
             const withApproval = () => approval && approvalLeg.active && approvalLeg.unattended === undefined
                 ? approval.coordinator.runWithContext({
@@ -545,9 +565,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     owner: elicitOwner ?? owner,
                     abortSignal: cancelCtrl.signal,
                     ...(spec.sessionId ? { sessionId: spec.sessionId } : {}),
-                    executionLane: approval.executionLane,
-                    emitCard: createApprovalCardEmitter({ appendDurable: (f) => approvalEmit(f) }),
-                    emitRevoke: (f) => approvalEmit(f),
+                    ...approval.origin,
+                    family: "approval_request",
+                    transport: hitlTransport,
                     legKey: "",
                     ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}),
                 }, withQuestion)
@@ -594,9 +614,12 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 acceptance?.settle(reached.result);
             }
             else if (reached !== undefined) {
-                await parkRowWrite[reached.kind](reached.result);
                 acceptance?.settle(reached.result);
             }
+            else if (thrownCancelCause === undefined && observedDone !== undefined && heldParkOf(atHostBoundary(observedDone)) !== undefined) {
+                recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-held ${message}`);
+                await settleLegResult(observedDone);
+            }
             else if (thrownCancelCause !== undefined && observedDone === undefined) {
                 const c = cancelledResult(thrownCancelCause);
                 settledAsCancel = failureCodeOf(c.terminal) === CANCELLED_CODE;
@@ -610,8 +633,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             }
             else {
                 settledAsCancel = false;
-                const safeMsg = redactErrorMessage(message) ?? message;
-                await voidHeldParkCard(observedDone === undefined ? undefined : atHostBoundary(observedDone, spec.sessionId), spec.sessionId, checkpointCards, "bg");
+                const outwardMsg = outwardThrownMessage(err, message);
+                const safeMsg = redactErrorMessage(outwardMsg) ?? outwardMsg;
+                await voidHeldParkCard(observedDone === undefined ? undefined : atHostBoundary(observedDone), spec.sessionId, checkpointCards, "bg");
                 try {
                     await append("failed", { errorMessage: safeMsg });
                 }
@@ -644,7 +668,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 if (verdict.kind === "park")
                     fleetPublisher.onTerminal(verdict.word);
                 else if (verdict.result !== null)
-                    fleetPublisher.onTerminal(verdict.label, fleetRunResiduals(verdict.result));
+                    fleetPublisher.onTerminal(verdict.label, fleetRunResiduals(verdict.result, failureCodeOf(verdict.result.terminal)));
                 else
                     fleetPublisher.onTerminal(verdict.label, {
                         ...(verdict.label === CANCELLED_CODE ? { stoppedBy: "user" } : {}),
@@ -667,5 +691,11 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         }
     }
 }
+export function beatRunHeartbeat(runStore, taskId, owner, onLost, onError) {
+    void runStore.heartbeat(taskId, owner).then((running) => {
+        if (!running)
+            onLost();
+    }, onError);
+}
 export const HEARTBEAT_MS = LIVENESS_HEARTBEAT_MS;
 //# sourceMappingURL=runs.js.map

package/dist/runtime-caps-resolver.d.ts

@@ -23,8 +23,8 @@
  *  · `forceDurableGate`— prepare-task.js 的 durable/content mandate、活 content-ask 抑制、
  *                        durable question face（该处合取 `resolveCheckpointStore(spec, deps) !== undefined`
  *                        ⇒ **无 checkpoint 店的部署上这一面本就不成立**，该键在那里 inert）
- *  · `autoMode`        — prepare-task.js `=== true` **∧** `deps.autoMode !== undefined`（部署需先具备分类器；
- *                        显式 opt-in 极性，且 [ref] 起本侧传的是三态 org deny 位，见 toCoreRuntimeCaps 头注）
+ *  · `autoMode`        — 武装式 `spec.permissionMode === "auto"` **∧** `deps.autoMode !== undefined` **∧** `runtimeCaps?.autoMode !== false`
+ *                        （部署需先具备分类器；三态 org deny 位：`true` 与缺席同义、只有 `false` 是拒，见 toCoreRuntimeCaps 头注）
  *  · `bypassPermissions` — `dist/core/mode-policy.js` 的模式折叠（请求 `bypassPermissions` ∧ 本位 `=== false` ⇒ 这条腿跑在
  *                        `default`、发 `config.permission_mode_unavailable{by:"operator_deny"}`、回执 `foldedBy:"operator_deny"`）；
  *                        deny 形，缺席 = 不阻。[ref] D2 起由 center 的 `allowBypassPermissions` 写（此前本仓零写点）
@@ -107,6 +107,15 @@ export interface EntitlementsResolverOpts {
     /** Observability hook for a resolve failure (defaults to a `runtime_caps_resolve_failed` warn). */
     onError?: (err: Error, principal: string) => void;
 }
+/**
+ * 中心拒了 auto 时**是哪一键拒的**(闭集)。中心的 entitlement 里 auto 的拒位今天有两个键(`autoMode` 与 `allowAutoMode`,settings-schema 里一个事实两个源 ——
+ * 折成一键归那个仓),引擎只有一只拒位;读者(`GET /v1/capabilities` 的 `permissionModeAuto.refusedBy`)靠这一词分清该去改中心的哪一键。
+ * 中心折成一键之后两词退役、本词集随之删(零别名)。
+ */
+export declare const AUTO_MODE_REFUSED_BY: readonly ["center.autoMode", "center.allowAutoMode", "both"];
+export type AutoModeRefusedBy = (typeof AUTO_MODE_REFUSED_BY)[number];
+/** 中心这一答拒没拒 auto、哪一键拒的 —— 拒位与来源词的**同一只判**({@link toCoreRuntimeCaps} 的拒位读它)。缺席 = 中心没拒(任一键的 `true` 都不是授予,不覆盖另一键的 `false`)。 */
+export declare function autoModeRefusedByOf(ent: Pick<EntitlementRuntimeCaps, "autoMode" | "allowAutoMode">): AutoModeRefusedBy | undefined;
 /** Map center's `EntitlementRuntimeCaps` → the subset core's engine enforces. `allowUltracode` (shell/UX) is
  *  dropped on purpose (not a core primitive); `allowWorkflows` / `forceDurableGate` / `allowFork` are **three of the
  *  six** the engine reads — the other three (`allowObservers` / `autoMode` / `allowMemoryOptOut`) are documented
@@ -151,6 +160,12 @@ export declare function toCoreRuntimeCaps(ent: EntitlementRuntimeCaps | null | u
  * 所以本谓词为 false **不再**意味着 auto 不武装;「会不会武装」由 `auto-mode-face.ts` 的三项合取答。
  */
 export declare function centerEntitlementSourceWired(config: Pick<ServiceConfig, "webAdmin">): boolean;
+/** 只读腿的一次读数:拒位(caps)与中心拒 auto 的来源词出自**同一个**缓存项。 */
+export interface RuntimeCapsReading {
+    readonly caps: RuntimeCaps | undefined;
+    /** 只在中心亲口拒了 auto 时在场({@link AutoModeRefusedBy})。 */
+    readonly autoModeRefusedBy?: AutoModeRefusedBy;
+}
 /** The two per-principal faces served off ONE caps fetch + cache. */
 export interface PrincipalEntitlementsClient {
     /** core's `RunnerDeps.runtimeCapsResolver` seam — FAIL-CLOSED on error (deny workflows/fork/autoMode/bypassPermissions;
@@ -171,7 +186,7 @@ export interface PrincipalEntitlementsClient {
      *
      * 🔴 **界画在「这句话是谁说的」**(codex r2 [high] 逐条核后的定界,不是「读面完全不碰缓存」):
      *  · **成功项 = center 亲口答的那份** —— 与提交腿自己抓到的**逐字同一份**、同一条 `ttlMs`、同一个**已验证**
-     *    身份(读面的 principal 走 `gatedPrincipal` → `verifiedPrincipal`,与提交腿同源,读不到别人的格)。读面
+     *    身份(读面的 principal 走 `gatedSubject` → `verifiedPrincipal`,与提交腿同源,读不到别人的格)。读面
      *    只是把这个 principal 自己那一格**预热**了一下;org 撤销后的陈旧窗由部署级 `ttlMs` 定义,与哪一腿预热
      *    的无关(提交腿自己预热同样如此),本批**零改动**。
      *  · **降级项 = server 自铸的判决** —— center 从没说过这句 deny,是本层在故障时替它说的。让一次**读**铸的
@@ -185,17 +200,17 @@ export interface PrincipalEntitlementsClient {
      * 而它硬失败 ⇒ 该降级项当场升格为执法项(codex r1 [medium]:否则一条总抢在提交前面的轮询会让每次提交
      * 都重抓,denyTtl 的界对提交腿失效)。让它升格的是一次真提交自己吃到的硬失败,不是那次读。
      */
-    peekRuntimeCaps: (principal: string | undefined) => Promise<RuntimeCaps | undefined>;
+    peekRuntimeCapsReading: (principal: string | undefined) => Promise<RuntimeCapsReading>;
     /** The resolved per-principal scenario ruling for resolveSpec's gateScenarioRequest — a three-state read
      *  ({@link ScenarioRulingRead}): the ruling; `undefined` = absent (no principal ⇒ no center call; older center without
      *  the scenario keys) = no governance; `"unavailable"` = the center could not answer (hard fetch failure — same error entry
      *  as the caps face's fail-closed deny — or malformed ruling keys) ⇒ the gate refuses the run. */
     scenarioRuling: (principal: string | undefined) => Promise<ScenarioRulingRead>;
     /**
-     * {@link PrincipalEntitlementsClient.scenarioRuling} 的**只读**孪生(同 {@link PrincipalEntitlementsClient.peekRuntimeCaps} 的界):同一只缓存 / 同一条抓取 /
+     * {@link PrincipalEntitlementsClient.scenarioRuling} 的**只读**孪生(同 {@link PrincipalEntitlementsClient.peekRuntimeCapsReading} 的界):同一只缓存 / 同一条抓取 /
      * 同一份三态读数(故障 ⇒ `"unavailable"`,读面与提交腿同拒),唯一的差别是 center 硬失败时本腿铸的降级项**只对读面自己算数**,提交腿不认、照常重抓。
      * 读面(`GET /v1/capabilities/mcp?scenario=` 的场景门)问中心裁定时必须走这一只 —— 经 `scenarioRuling` 问,center 抖动的那一拍会替这个主体的**真提交**
-     * 留下 `{allowWorkflows:false, allowFork:false, autoMode:false}` 的短窗 deny(读面成了别人被拒的原因,与 `peekRuntimeCaps` 的病灶同一类)。
+     * 留下 `{allowWorkflows:false, allowFork:false, autoMode:false}` 的短窗 deny(读面成了别人被拒的原因,与 `peekRuntimeCapsReading` 的病灶同一类)。
      */
     peekScenarioRuling: (principal: string | undefined) => Promise<ScenarioRulingRead>;
     /** (stage7 P5) The resolved per-principal execution-lane ruling for resolveSpec's

package/dist/runtime-caps-resolver.js

@@ -37,6 +37,12 @@ const CENTER_ENGINE_CAP_KEYS = [
     "allowBypassPermissions",
     "allowMemoryOptOut",
 ];
+export const AUTO_MODE_REFUSED_BY = ["center.autoMode", "center.allowAutoMode", "both"];
+export function autoModeRefusedByOf(ent) {
+    const byAutoMode = ent.autoMode === false;
+    const byAllowAutoMode = ent.allowAutoMode === false;
+    return byAutoMode && byAllowAutoMode ? "both" : byAutoMode ? "center.autoMode" : byAllowAutoMode ? "center.allowAutoMode" : undefined;
+}
 export function toCoreRuntimeCaps(ent) {
     if (!ent)
         return undefined;
@@ -53,7 +59,7 @@ export function toCoreRuntimeCaps(ent) {
         caps.allowFork = ent.allowFork;
     if (typeof ent.allowObservers === "boolean")
         caps.allowObservers = ent.allowObservers;
-    if (ent.autoMode === false || ent.allowAutoMode === false)
+    if (autoModeRefusedByOf(ent) !== undefined)
         caps.autoMode = false;
     else if (ent.autoMode === true)
         caps.autoMode = true;
@@ -87,7 +93,6 @@ export function gateExecutionLane(ruling, ownLane, logger = defaultLogger) {
 export function createPrincipalEntitlementsClient(opts) {
     const ttlMs = opts.ttlMs ?? 60_000;
     const denyTtlMs = opts.denyTtlMs ?? Math.min(ttlMs, 10_000);
-    const fetchImpl = opts.fetchImpl ?? fetch;
     const fetchCaps = opts.fetchCaps ?? fetchPrincipalCaps;
     const now = opts.now ?? (() => Date.now());
     const onError = opts.onError ?? ((err, principal) => defaultLogger.warn("runtime_caps_resolve_failed", { principal, err: String(err) }));
@@ -130,12 +135,13 @@ export function createPrincipalEntitlementsClient(opts) {
             return dup;
         const p = (async () => {
             try {
-                const r = await fetchCaps(bin.center, principal, cached?.etag, fetchImpl, opts.worker);
+                const r = await fetchCaps(bin.center, principal, cached?.etag, opts.fetchImpl, opts.worker);
                 if (r === null) {
                     const entry = {
                         caps: cached?.caps,
                         ...(cached?.scenario ? { scenario: cached.scenario } : {}),
                         ...(cached?.execution ? { execution: cached.execution } : {}),
+                        ...(cached?.autoModeRefusedBy ? { autoModeRefusedBy: cached.autoModeRefusedBy } : {}),
                         ...(cached?.etag ? { etag: cached.etag } : {}),
                         expiresAt: now() + ttlMs,
                     };
@@ -148,8 +154,10 @@ export function createPrincipalEntitlementsClient(opts) {
                 if (r.scenarioDrift) {
                     audit(new Error(`scenario ruling wire drift: ${r.scenarioDrift}`), principal);
                 }
+                const refusedBy = r.runtimeCaps ? autoModeRefusedByOf(r.runtimeCaps) : undefined;
                 const entry = {
                     caps: toCoreRuntimeCaps(r.runtimeCaps),
+                    ...(refusedBy !== undefined ? { autoModeRefusedBy: refusedBy } : {}),
                     ...(r.scenarioDrift ? { scenario: "unavailable" } : r.scenario ? { scenario: r.scenario } : {}),
                     ...(r.execution ? { execution: r.execution } : {}),
                     ...(r.etag ? { etag: r.etag } : {}),
@@ -182,7 +190,12 @@ export function createPrincipalEntitlementsClient(opts) {
     }
     return {
         resolveRuntimeCaps: async (principal) => (principal ? (await load(principal)).caps : undefined),
-        peekRuntimeCaps: async (principal) => (principal ? (await load(principal, false)).caps : undefined),
+        peekRuntimeCapsReading: async (principal) => {
+            if (!principal)
+                return { caps: undefined };
+            const entry = await load(principal, false);
+            return { caps: entry.caps, ...(entry.autoModeRefusedBy !== undefined ? { autoModeRefusedBy: entry.autoModeRefusedBy } : {}) };
+        },
         scenarioRuling: async (principal) => (principal ? (await load(principal)).scenario : undefined),
         peekScenarioRuling: async (principal) => (principal ? (await load(principal, false)).scenario : undefined),
         executionRuling: async (principal) => (principal ? (await load(principal)).execution : undefined),

package/dist/runtime-governance.d.ts

@@ -24,7 +24,7 @@
  * name). Real isolation is the `executionEnv` sandbox. Same caveat core documents on `createCoarseCommandNamePolicy`.
  */
 import { type PermissionMode, type ShellGateDoctrine, type TaskSpec, type ToolPolicy } from "@sema-agent/core";
-import { AUTONOMY_MODES, type GovernanceConfig } from "@sema-agent/settings-schema";
+import { AUTONOMY_MODES, GovernanceConfig } from "@sema-agent/settings-schema";
 import { type GovernanceAskMarks } from "./governance-ask-marks.js";
 import { type GovernanceOverrides } from "./governance-overrides.js";
 /** 运维 autonomy 四档的**闭集**(契约成员表本尊,照旧从本模块转出)。`config.ts` 的 `parseAutonomy` 也从这里读 —— 四档词表全仓一份。 */
@@ -38,7 +38,7 @@ export type Autonomy = NonNullable<GovernanceConfig["autonomy"]>;
 /** 导出给 `test/coarse-shell-tools-mirror.test.ts` 的同源钉用(见那里的顶注)。 */
 export declare const COARSE_SHELL_TOOLS_MIRROR: readonly string[];
 /** Validate `commandPolicy` rules — the shape (array of {command, decision}), the `command` (a bare argv[0] name,
- *  see {@link VALID_COMMAND_NAME}), AND the `decision` enum. Returns the list of human-readable errors (empty =
+ *  judged by the contract's own cell, see {@link commandNameRefused}), AND the `decision` enum. Returns the list of human-readable errors (empty =
  *  OK). Called at config-apply (web-admin-client/facade.ts `applyRuntimeHot`) so a malformed rule that BYPASSED the
  *  registry schema (a hand-edited config.d / a non-conformant publish) is rejected LOUDLY rather than
  *  silently mis-compiling — review MEDIUM: an out-of-enum `decision` (e.g. "DENY") would otherwise fall through