@sema-agent/server 7.107.0 → 7.109.0

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -410,6 +410,10 @@ export interface BatchRow {
     updatedAtMs: number;
 }
 /** design 定稿 §4 的持久层接口。协调器接线(车2)、恢复扫描消费(车5)不在本车范围——本车只落这些方法。 */
+/** 一次调用在一条腿上的坐标({@link ApprovalAskStore.listByCall} 的四列;型从 {@link AskRow} 派生,不手抄)。 */
+export type AskCallCoordinate = Pick<AskRow, "taskId" | "legKey" | "toolCallId" | "sourceTaskId">;
+/** 「这一行在这次调用上」的唯一判据(四列逐字相等):InMemory twin 的筛子与 SQL twin 的出口对齐读同一只。 */
+export declare function askRowOnCall(row: AskRow, call: AskCallCoordinate): boolean;
 export interface ApprovalAskStore {
     /** 幂等 upsert。返回**行 + 本次是否真插入**(判别位语义见 {@link EnsureAskResult})。 */
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
@@ -464,6 +468,19 @@ export interface ApprovalAskStore {
      *  等待」只被**部分**缓解(不再叠加调用方侧的等待,池侧仍会堆)。真正的取消要 driver 级 seam,登记为
      *  后续件。 */
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
+    /**
+     * 🔴 S-944 / SN-C1:**这次调用在这条腿上的全部行** —— 任意状态、任意 ask 身份(同一调用不同类集 = 不同 askId 的几只问、升级前按旧派生
+     * 写的行,都在其中)。坐标 = {@link AskCallCoordinate} 四列**精确**匹配;序 = `created_at_ms ASC, ask_id ASC`(确定性)。
+     *
+     * 唯一消费者 = 会话授权短路的争议判据(`tool-approval.ts` `sessionGrantUncontestedByRow`):「这次调用在腿内有行 ⇒ 一揽子放行不得代答」。
+     * 为什么按调用而不是按 askId 点读:争议的真源是**调用**(人对这次调用说过什么 / 这次调用还有一张卡挂着),ask 身份只是其中一问的主键;
+     * 身份可以加轴(S-944 加了类集),争议判据不得依赖身份 —— 按身份点读在身份加轴的那一刻就把同调用的别的问、旧派生的行读成「不存在」。
+     *
+     * 三 twin 同答:SQL twin 读后按四列逐字再滤一遍 —— MySQL 协议的 VARCHAR 等值带 PAD SPACE(`'tc'` = `'tc '`),PG(`COLLATE "C"`)与
+     * InMemory 严格比较;不在入口拒(调用 id 是引擎铸的原值,首尾空白不归本店判),在出口对齐。索引:走 `idx_ask_task_state`
+     * `(task_id, state)` 的 `task_id` 前缀(一条 run 的行数 = 真出过卡的问数;grant 代答的问不落行),不另加索引。
+     */
+    listByCall(call: AskCallCoordinate): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     /** 回决幂等回放的读口。🔴 `taskId` **必填**且是键的第一维——UNIQUE 已改 `(task_id, idempotency_key)`
      *  (车4 §12-E),裸按 key 全局查在多租户库上既可能回**别人 task** 的行(存在性外泄),也可能在同 key
@@ -621,6 +638,7 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     listByState(state: AskState, limit: number): Promise<AskRow[]>;
     listPendingByTask(taskId: string, signal?: AbortSignal): Promise<AskRow[]>;
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
+    listByCall(call: AskCallCoordinate): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;

package/dist/plugins/approval-ask-store-sql.js

@@ -81,6 +81,9 @@ export function projectAskTerminalClaimTruth(row) {
         settledBy: row.settledBy,
     };
 }
+export function askRowOnCall(row, call) {
+    return row.taskId === call.taskId && row.legKey === call.legKey && row.toolCallId === call.toolCallId && row.sourceTaskId === call.sourceTaskId;
+}
 export const APPROVAL_ASK_TABLE = "approval_ask";
 export const APPROVAL_BATCH_TABLE = "approval_batch";
 export const TIDB_APPROVAL_ASK_STATEMENTS = [
@@ -675,6 +678,10 @@ export class SqlApprovalAskStore {
             : this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
         return rows.map(mapAskRow);
     }
+    async listByCall(call) {
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND leg_key = ? AND tool_call_id = ? AND source_task_id = ? ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND leg_key = $2 AND tool_call_id = $3 AND source_task_id = $4 ORDER BY created_at_ms ASC, ask_id ASC`), [call.taskId, call.legKey, call.toolCallId, call.sourceTaskId]);
+        return rows.map(mapAskRow).filter((r) => askRowOnCall(r, call));
+    }
     async getAsk(askId) {
         const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [
             askId,

package/dist/plugins/park-commit-watch.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 🔴 **S-929 F1(7.108.0 [ref] 合并复审 codex 腿 A ①,[high] 回归修)—— park 提交的唯一观察点。**
+ *
+ * core 的 durable park 就是对本仓 checkpoint 店的一次 `put`(SQL 孪生 / 本地文件店都是本仓的 `CheckpointStore` 实现,
+ * 一只实例、四个消费点 —— 见 `boot/stage-06-runners.ts` 的构造注)。审批协调器交出 park 路由(ask 回调返回 `"unavailable"`)
+ * **之后** core 才铸行、才 `put`;两者之间隔着 core 自己的 park 前置(会话叶、环境快照…)。所以「ask 回调返回」**不是**
+ * 「park 落盘」,有序关停若把前者当后者,就会在 `put` 之下关掉连接池(修前病:park 行没提交,审计账本却已记「结清」)。
+ *
+ * 本模块给店加**一层**装饰(两店同用,不读 core 私有键 —— [ref]):
+ *  ① **计在飞 `put`**:`quiesce(deadlineMs)` 等到零或到期(绝对时刻,`Date.now()` 域),如实返回残余数 —— 收尾链在
+ *     `backend.close()` 之前等它(`boot/shutdown.ts`),审批协调器的关停收尾也等它(`ToolApprovalCoordinator.drainForShutdown`);
+ *  ② **报 park 提交** —— 「这只店里有了这一行」的两种观察,同一件事实:一次 `put` 落定(resolve);或一次 `put` 抛错之后,同一 token 的
+ *     `get` 读到了行(写已落、回执丢了 —— core 的挂起序正是用这一次回读确认提交的,本层观察的就是那一次读,不另读;车内 codex r1)。
+ *     那一行是审批停车行(`pendingAction.kind === "tool_approval"`,kind 先判 —— core d.ts「Every consumer that reads the tool fields MUST
+ *     branch on `kind` first」)⇒ 把**停车行自己陈述的**调用身份交给订阅者({@link CommittedParkCalls})。抛错且回读不到 = 没提交,不报。
+ *     身份取自**读到的那一行**(不是本进程想写的那一只):哪怕 token 撞了别人的行,报出去的也只是那一行真握着的调用。
+ *
+ * 订阅者契约:**不得抛**。订阅者跑在 `put` 已提交之后、返回给 core 之前 —— 一只抛错的订阅者会把一次**已提交**的 park 报成失败。
+ * 唯一的订阅者是审批协调器(写审计 settle 行,那只 sink 自吞失败并按 [ref] 留痕),它在自己那一侧兜住(同 tag 扩射程,见协调器)。
+ */
+import type { CheckpointStore } from "@sema-agent/core";
+/**
+ * 一只**已提交**的审批停车行说它握着哪些调用(停车行自己的陈述,原样,不是推断):
+ *  · `sessionId` —— 行停住的会话 `cp.sessionId`(执行这次调用的会话:委派 / 后台子代的行落在**子会话**上)。core 铸行用的是 prepare-task 的
+ *    同一个 `sessionId`,它也是同一次调用的 ask 上的 `sourceTaskId`(`askSourceIdentity`)⇒ 订阅者按**相等**配,不做别名(车 SO:
+ *    调用 id 只在 run 内唯一,宿主会话若当子代的等价别名,宿主停车行会冒充子代的提交);
+ *  · `toolCallIds` —— 停在门前的那只调用(`pendingAction.toolCallId`)∪ 同一条助手消息里**尚未执行**的调用
+ *    (`batchToolCallIds − completedCallIds`,core d.ts「#k+1..N are still pending」):那些调用随这一行一起被持久挂起,
+ *    续跑时重新过门 —— 它们的等待同样由这一行承载。
+ */
+export interface CommittedParkCalls {
+    readonly sessionId: string;
+    readonly toolCallIds: readonly string[];
+}
+/** 装饰层的观察面(`create*` 产出的活对象的一半;另一半是装饰后的店本身)。 */
+export interface ParkCommitWatch {
+    /** 订阅 park 提交(见模块头「订阅者契约」:不得抛)。 */
+    onParkCommitted(listener: (calls: CommittedParkCalls) => void): void;
+    /** 等在飞 `put` 归零或到 `deadlineMs`(绝对时刻,`Date.now()` 域);返回那一刻的残余在飞数(0 = 静默了)。从不抛。 */
+    quiesce(deadlineMs: number): Promise<{
+        inFlight: number;
+    }>;
+}
+export declare function createParkCommitWatch<S extends Pick<CheckpointStore, "put" | "get">>(inner: S): {
+    store: S;
+    watch: ParkCommitWatch;
+};
+//# sourceMappingURL=park-commit-watch.d.ts.map

package/dist/plugins/park-commit-watch.js

@@ -0,0 +1,87 @@
+function committedParkCallsOf(cp) {
+    const pa = cp.pendingAction;
+    if (pa.kind !== "tool_approval")
+        return undefined;
+    const completed = new Set(pa.completedCallIds);
+    const toolCallIds = [pa.toolCallId, ...pa.batchToolCallIds.filter((id) => id !== pa.toolCallId && !completed.has(id))];
+    return { sessionId: cp.sessionId, toolCallIds };
+}
+const UNCONFIRMED_PUT_TOKENS_MAX = 256;
+export function createParkCommitWatch(inner) {
+    const listeners = [];
+    let inFlight = 0;
+    const idleWaiters = new Set();
+    const unconfirmed = new Set();
+    const notify = (row) => {
+        const calls = committedParkCallsOf(row);
+        if (calls !== undefined)
+            for (const l of listeners)
+                l(calls);
+    };
+    const put = async (token, cp) => {
+        inFlight += 1;
+        try {
+            try {
+                await inner.put(token, cp);
+            }
+            catch (err) {
+                unconfirmed.add(token);
+                if (unconfirmed.size > UNCONFIRMED_PUT_TOKENS_MAX) {
+                    const oldest = unconfirmed.values().next();
+                    if (oldest.done !== true)
+                        unconfirmed.delete(oldest.value);
+                }
+                throw err;
+            }
+            notify(cp);
+        }
+        finally {
+            inFlight -= 1;
+            if (inFlight === 0)
+                for (const wake of [...idleWaiters])
+                    wake();
+        }
+    };
+    const get = async (token) => {
+        if (!unconfirmed.has(token))
+            return inner.get(token);
+        unconfirmed.delete(token);
+        const row = await inner.get(token);
+        if (row !== null)
+            notify(row);
+        return row;
+    };
+    const store = new Proxy(inner, {
+        get(target, prop) {
+            if (prop === "put")
+                return put;
+            if (prop === "get")
+                return get;
+            const v = Reflect.get(target, prop, target);
+            return typeof v === "function" ? v.bind(target) : v;
+        },
+    });
+    const watch = {
+        onParkCommitted(listener) {
+            listeners.push(listener);
+        },
+        quiesce(deadlineMs) {
+            if (inFlight === 0 || Date.now() >= deadlineMs)
+                return Promise.resolve({ inFlight });
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    idleWaiters.delete(wake);
+                    resolve({ inFlight });
+                }, deadlineMs - Date.now());
+                const wake = () => {
+                    clearTimeout(timer);
+                    idleWaiters.delete(wake);
+                    resolve({ inFlight: 0 });
+                };
+                idleWaiters.add(wake);
+            });
+        },
+    };
+    return { store, watch };
+}
+//# sourceMappingURL=park-commit-watch.js.map

package/dist/request-key-closure.js

@@ -20,7 +20,7 @@ export function keyClosureClause(names, label) {
 const TASK_BODY_DECLARED_KEYS = [
     "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents",
     "appendSystemPrompt", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
-    "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "enableFork",
+    "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "disableSkills", "enableFork",
     "excludeAllTools", "excludeTools", "fileHistory",
     "finalVerification", "forwardSubagentEvents", "images", "inheritEnv", "interactiveTools", "jobId", "limits", "maxCostUsd",
     "maxTokens", "mcpServers", "memory", "memoryCapture", "memoryWrite", "model", "objective", "oneShot", "outputRetries",

package/dist/router/route-orchestration.js

@@ -1,5 +1,6 @@
 import { COARSE_SHELL_TOOLS } from "@sema-agent/core";
 import { operatorAlwaysHumanAsk } from "../operator-ask.js";
+import { heldRuleName } from "../tool-rule-names.js";
 export function routeOrchestration(s) {
     if (s.explicitMode)
         return { mode: s.explicitMode, reason: `explicit:${s.explicitMode}` };
@@ -42,9 +43,13 @@ export function isIsolatedExecEnv(provider, runtimeClass) {
 const WRITE_HAND_TOOLS = new Set(["Edit", "Write", "NotebookEdit"]);
 const SHELL_TOOLS = new Set(COARSE_SHELL_TOOLS);
 export function supPostureOverrides() {
-    const ask = (toolName) => operatorAlwaysHumanAsk(`supervisor routing(capability-danger:${toolName})`, `${toolName} gated by supervisor routing (capability-danger task)`);
     const gate = {
-        check: (req) => (WRITE_HAND_TOOLS.has(req.toolName) || SHELL_TOOLS.has(req.toolName) ? ask(req.toolName) : { action: "allow" }),
+        check: (req) => {
+            const hit = heldRuleName(req, (n) => WRITE_HAND_TOOLS.has(n) || SHELL_TOOLS.has(n));
+            return hit !== undefined
+                ? operatorAlwaysHumanAsk(`supervisor routing(capability-danger:${hit})`, `${req.toolName} gated by supervisor routing (capability-danger task)`)
+                : { action: "allow" };
+        },
     };
     return { shellGate: "always", toolPolicy: gate };
 }

package/dist/run-local.js

@@ -9,7 +9,7 @@ import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { Runner, uuidv7, FileStorageBackend, NodeExecutionEnv, TtlSessionStore, CenterPromptSource, FilePromptArtifactStore, FilePromptSourceStateStore, MemoryPromptArtifactStore, MemoryPromptSourceStateStore, defaultTaskRegistry } from "@sema-agent/core";
 import { singleUserAutoAcceptBaselineApplies } from "./approval.js";
-import { createUnattendedLeg, unattendedPermissionMode, withUnattendedLeg } from "./unattended-permission-mode.js";
+import { withUnattendedLeg } from "./unattended-permission-mode.js";
 import { createBrain } from "./brain.js";
 import { assertGuardPatternsUsable, buildOnlySensitiveBaselineWarning, createApprovalBaselinePolicy, createDeploymentGovernanceInputs, } from "./deployment-governance.js";
 import { applyRuntimeGovernance } from "./runtime-governance.js";
@@ -568,7 +568,6 @@ export async function runLocal(argv, deps = {}) {
         ...(maxCostUsd !== undefined ? { maxCostUsd } : {}),
         ...(maxTokens !== undefined ? { maxTokens } : {}),
     };
-    const unattendedLeg = createUnattendedLeg(unattendedPermissionMode(config), runnerDeps);
     const spec = withUnattendedLeg(applyLocalGovernance({
         objective: mention.cleanedObjective,
         sessionId,
@@ -585,7 +584,7 @@ export async function runLocal(argv, deps = {}) {
         ...(mcp ? { mcp } : {}),
         ...(a2a ? { a2a } : {}),
         ...(Object.keys(limits).length > 0 ? { limits } : {}),
-    }, config, workspaceDir, memoryEngine?.root), unattendedLeg);
+    }, config, workspaceDir, memoryEngine?.root), onAsk);
     logger.info("run_local_start", { scenario: scenarioName, model: spec.model, sessionId, exec: executionLaneOf(config.remoteExec?.provider) });
     const settleSessionBackground = async () => {
         const reaped = defaultTaskRegistry.reapSessionBackground(sessionId, scope);

package/dist/runs.js

@@ -5,6 +5,7 @@ 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 { withModelReachScope } from "./model-reach-scope.js";
 import { redactSecrets } from "./trace/redact.js";
 import { taskNotificationEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "./trace/project.js";
 import { createLedgerSink } from "./trace/ledger-sink.js";
@@ -419,7 +420,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 await append("suggestions", { suggestions: suggestions.map((s) => redactSecrets(s)) });
             }
         };
-        await withPrincipal(principal, () => {
+        await withModelReachScope(spec.sessionId, () => withPrincipal(principal, () => {
             const withElicit = elicitation
                 ? () => elicitation.runWithContext({ taskId, owner: elicitOwner ?? owner, emit: elicitEmit, abortSignal: cancelCtrl.signal }, runBody)
                 : runBody;
@@ -442,7 +443,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             return sendUserFile
                 ? sendUserFile.runWithContext({ taskId, emit: (frame) => { const { type, ...rest } = frame; return append(type, rest); } }, withApproval)
                 : withApproval();
-        });
+        }));
         if (!reached && cancelCtrl.signal.aborted) {
             try {
                 await flush();

package/dist/runtime-governance.d.ts

@@ -188,9 +188,9 @@ export interface GovernancePosture {
  * (checkpoint 行没有这一列,core 的 `CheckpointGate`/`PendingAction`/`Checkpoint` 顶层都不带它)。反向
  * (checkpoint → ask)今天**没有读口**:两条 list 读口都硬过滤 `state='STREAM_PENDING'`,而 park 完的行是
  * `PARKED`;唯一精确的连接键是 ask 行上的 `gate_token`,要按它反查得给店加一个新读口(SQL 面 = 双库集成
- * 门)。派生 `deriveAskId(...)` 也不行:它吃 `legKey`(= 上一腿 resume token 的摘要)与 `parentToolCallId`,
- * 这两维从 checkpoint 行推不出来,二腿/子代形上会算出一个**错**的 id —— 在「等的谁」这条通道上,错 id
- * 比缺席坏得多(`http/active-run-conflict.ts` 的 `resumeEntryForGate` 的 default 臂是同一条纪律)。故诚实缺席。
+ * 门)。派生 `deriveAskId(...)` 也不行:它吃 `legKey`(= 上一腿 resume token 的摘要)、`parentToolCallId` 与这一问的
+ * 类集(S-944);前两维从 checkpoint 行推不出来,类集在 park 行上老行缺席、续跑不补 —— 二腿/子代/老行形上会算出一个
+ * **错**的 id —— 在「等的谁」这条通道上,错 id 比缺席坏得多(`http/active-run-conflict.ts` 的 `resumeEntryForGate` 的 default 臂是同一条纪律)。故诚实缺席。
  */
 export declare function governanceOriginOf(gate: {
     riskDescriptor?: {

package/dist/runtime-governance.js

@@ -2,6 +2,7 @@ import { combinePolicies, COARSE_SHELL_TOOLS as CORE_COARSE_SHELL_TOOLS, createC
 import { GovernanceConfig } from "@sema-agent/settings-schema";
 import { currentGovernanceAskMarks } from "./governance-ask-marks.js";
 import { operatorAsk, withDeploymentAuthorship } from "./operator-ask.js";
+import { heldRuleName } from "./tool-rule-names.js";
 const COMMAND_RULE_SHAPE = GovernanceConfig.shape.commandPolicy.unwrap().element.shape;
 const COMMAND_DECISIONS = COMMAND_RULE_SHAPE.decision.options;
 export const AUTONOMY_MODES = GovernanceConfig.shape.autonomy.unwrap().options;
@@ -20,7 +21,7 @@ function createCommandAskListPolicy(askCommands, tools = COARSE_SHELL_TOOLS) {
     const ask = (message, rule) => operatorAsk(rule, message);
     return {
         check(req) {
-            if (!shellTools.has(req.toolName))
+            if (heldRuleName(req, (n) => shellTools.has(n)) === undefined)
                 return { action: "allow" };
             const command = req.args?.command;
             if (typeof command !== "string")
@@ -135,7 +136,7 @@ function createGovernanceShellGateMarkPolicy(marksOf, tools = COARSE_SHELL_TOOLS
     const shellTools = new Set(tools);
     return {
         check(req) {
-            if (shellTools.has(req.toolName))
+            if (heldRuleName(req, (n) => shellTools.has(n)) !== undefined)
                 marksOf()?.setMarked(req.toolCallId, true);
             return { action: "allow" };
         },

package/dist/task-settings.js

@@ -3,6 +3,7 @@ import { findUnmatchableToolNames, formatUnmatchableToolNames } from "./config.j
 import { CONTROL_AND_BIDI_STRIP_RE } from "./text-bidi.js";
 import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "./request-key-closure.js";
 import { parseHooksConfig } from "./hooks/hook-runner.js";
+import { heldRuleName } from "./tool-rule-names.js";
 export const PERMISSION_MODE_REQUEST_FACE = {
     default: "request",
     acceptEdits: "request",
@@ -278,10 +279,11 @@ function createRuleListPolicy(names, behavior, pathBases) {
     }
 }
 const WORKFLOW_ASK_NAMES = [RUN_WORKFLOW_TOOL_NAME];
+const isWorkflowName = (name) => name === RUN_WORKFLOW_TOOL_NAME;
 function createWorkflowAskPolicy(isExempt) {
     return {
         async check(req) {
-            if (req.toolName !== RUN_WORKFLOW_TOOL_NAME)
+            if (heldRuleName(req, isWorkflowName) === undefined)
                 return { action: "allow" };
             if (isExempt) {
                 try {
@@ -299,7 +301,7 @@ function createWorkflowAskPolicy(isExempt) {
 function createWorkflowPlanDenyPolicy() {
     return {
         check(req) {
-            return req.toolName === RUN_WORKFLOW_TOOL_NAME
+            return heldRuleName(req, isWorkflowName) !== undefined
                 ? { action: "deny", message: `Plan mode is active — "${req.toolName}" is a write/mutating tool and is read-only-blocked.`, decisionReason: "rule" }
                 : { action: "allow" };
         },

package/dist/tool-approval.d.ts

@@ -1,10 +1,11 @@
 import type { HostDecidedBy, HostSettledBy } from "./host-decision.js";
 import type { IncomingMessage } from "node:http";
-import { type AskRequest, type AskOutcome, type CheckpointGate, type PendingAction, type PersistedRuleMandate, type ReadRootGrantCandidate, type RuleOffer } from "@sema-agent/core";
+import { type AskClass, type AskRequest, type AskOutcome, type CheckpointGate, type PendingAction, type PersistedRuleMandate, type ReadRootGrantCandidate, type RuleOffer } from "@sema-agent/core";
 import { type CardRulePersisted, type RuleConsentLane } from "./rules-consent.js";
 import { type DenialLimitFallback, type RuleOffersAbsence, type ApprovalRequestFrame, type ApprovalRevokeFrame, type RuleEvidenceProjection } from "./approval-card.js";
 import { type ApprovalAskStore, type AskRow } from "./plugins/approval-ask-store-sql.js";
 import type { ApprovalAskAuditSink } from "./approval-ask-audit-store.js";
+import type { ParkCommitWatch } from "./plugins/park-commit-watch.js";
 import { type GovernanceAskMarks } from "./governance-ask-marks.js";
 import { type GovernancePosture } from "./runtime-governance.js";
 /** [ref]:审批 gate kind 闭集(core gateMatch 的 `human`/`irreversible_ask` ↔ outcome.gate "policy_ask")。
@@ -284,6 +285,19 @@ export interface ToolApprovalFrame {
      * ask」,治理策略产的与普通策略产的在这一个词上同形 ⇒ 顶替不了(逐字论证见 `governance-ask-marks.ts` 顶注)。
      */
     origin?: string;
+    /**
+     * **S-934 ②(core 7.37.0 #1214;ADDITIVE,`"tool_approval"` only)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
+     * `MODE_ARBITRATION` 的行键(权限模式读的就是它 / 它们)。引擎在每一个铸 `origin` 的站盖章(策略自报的值在盖章处被替换),本仓经
+     * `approval-card.ts` 的 `readAskClassPair(req)` 结构窄读(成员筛 = core `isAskClass`,本仓不抄词表;在场却读不出 ⇒ 两键都不投 + 计一次
+     * S-249 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core KL-1214-a),不是「无类」。
+     * display:壳按类渲卡(cli 卡面、client-core CC-272),durable 审批席按类答;**本仓不按它裁决**(无人值守腿的按类作答读 core 交来的
+     * `AskRequest.classes` 本身)。同一对的其余面:`card_json` 卡面 / `approval_request` 呈卡帧 / 断连重放帧(同一份素材)、运维队列行
+     * (`parkRowFacts`,读停车行孪生座 `PendingAction.tool_approval.askClass`);inbox 行不带(core `CheckpointSummary` 不回显)。
+     */
+    askClass?: AskClass;
+    /** S-934 ②:这一问属于的**全部**类(core `ASK_CLASSES` 序,`classes[0] === askClass`,非空)—— 读整只集合,别只读 {@link askClass}(一问可同属
+     *  几类)。与 `askClass` 同在同缺、同一只窄读;逐字同序过境,不排序不去重。 */
+    classes?: AskClass[];
     /**
      * **[ref]**(core 7.19.0;**ADDITIVE**,`"tool_approval"` only)—— 这只**根外读** ask 的**清障目录**:
      * 把 `dir` 加进本会话的读目录(壳侧既有的 `/add-dir` 口),同一条调用就不会再问。
@@ -1126,6 +1140,15 @@ export declare class ToolApprovalCoordinator {
     /** S-877 候裁 16 → A:耐久会话授权店的**读面**(`/decide` 的 `remember:"session"` 写、本席读)。在场 ⇔ 部署有 store backend
      *  (装配点 `boot/coordinators.ts`,与 `/decide` 写的是**同一只**店)。读口唯一 = {@link standingGrantSettles}。 */
     private readonly sessionGrants;
+    /** S-929:有序关停已开始(`drainForShutdown` 锁存,不复位 —— 进程正在退出)。之后登记的每一张卡在登记那一刻按关停收场。 */
+    private shutdownDraining;
+    /** S-929:此刻在 `askBroadcast` 里的 ask 数(进出成对,见那里的 try/finally)—— 关停等待「还没登记进 `pending` 的卡」的计数。 */
+    private asksInFlight;
+    /** S-929 F1:park 提交的观察面(checkpoint 店的装饰层;在场 ⇔ 本部署有 park 设施,装配点 `boot/stage-06-runners.ts`)。 */
+    private readonly parkCommits;
+    /** S-929 F1:有序关停下路由到 park、**处置尚未被观察到**的卡 —— 审计 settle 行在这里候着({@link settleParksAwaitingCommit})。
+     *  只在关停期有成员(进程随后退出,不需要回收)。 */
+    private readonly parksAwaitingCommit;
     constructor(opts?: {
         ttlMs?: number;
         /** [ref](案A):零活流铸造的 ask 的窗(见 {@link unreachedTtlMs})。装配点在协议**上场**时才传
@@ -1155,6 +1178,8 @@ export declare class ToolApprovalCoordinator {
         askAudit?: ApprovalAskAuditSink;
         /** S-877 候裁 16:耐久会话授权店的读面(见 {@link ToolApprovalCoordinator.sessionGrants})。 */
         sessionGrants?: SessionGrantReader;
+        /** S-929 F1:park 提交的观察面(见 {@link ToolApprovalCoordinator.parkCommits})。 */
+        parkCommits?: ParkCommitWatch;
     });
     /**
      * [ref] R-13 C —— 「**无人可答**」这一类终局的**唯一**成形口(park 路由 vs deny 政策)。
@@ -1309,6 +1334,54 @@ export declare class ToolApprovalCoordinator {
      *  流没了,值相等即目标集;极端复用形下多转的那条也只是从流内卡变 durable 卡,方向保守。
      *  返回触发条数(0 = 无流内未决 ask,调用方照旧 abort)。幂等:已结算条目跳过,重复调用无害。 */
     parkOpenAsksForTask(wireTaskId: string): number;
+    /**
+     * 🔴 **S-929 —— 有序关停的审批面收尾(一只;`boot/shutdown.ts` 的 `hardShutdown` 起点调,SIGTERM / SIGINT / SIGHUP 三条停止路同一处)。**
+     *
+     * 病(cli [ref] S7):修前关停序不碰协调器 ⇒ 本进程握着的活卡在下一次 boot 被审计收敛器标成 `crashed_before_park`,
+     * 用户屏上看到「crashed」而实为有序重启。
+     *
+     * 三步:
+     *  ① 本进程握着的**每一张**未决卡(可达 / 悬挂 / 委派子代,不挑)按**断连同路**收场 —— {@link PendingApproval.forceParkNow}(park 路由;
+     *     `deny` 政策下是部署政策拒;有持久 ask 店时走同一把终局 claim)。有序关停与断连是同一件事:投递面要没了,**不是**有人拒了
+     *     (不交裸 `false`,S-689 同律)。审计 settle 行携 `cause:"shutdown_before_park"`(成因在 `settle` 咽喉读锁存位,F10);
+     *  ② 在 `deadlineMs` 之前等:未决卡结清、在飞腿闭合(闭了的腿照常落 `leg_closed`)、**本次路由到 park 的卡全部结清**
+     *     (F1:观察到 core 已处置这次调用 —— 停车行提交或承载它的腿退场 ⇒ 那张卡的审计 settle 行此刻才写,见 {@link settleParksAwaitingCommit})、
+     *     店里在飞的 `put` 静默;
+     *  ③ 到期:仍未闭的腿 ⇒ 审计落 `interrupted_by_shutdown` 记号(下一次 boot 收敛照样列出它,decided 臂的 `resumeSafe:false` 提醒不丢);
+     *     仍未提交的 park ⇒ settle 行**不写**(账本上仍是 pending 孤儿 ⇒ 下一次 boot 与崩溃同路收敛,证据不丢),交回调用方
+     *     (`uncommittedParks`,运维 warn `approval_park_uncommitted_at_shutdown` 由关停序落 —— 它握 logger)。之后才观察到的照样写 settle 行
+     *     (观察到就是结清,迟到也是)。
+     * **一条规则覆盖先后两批卡**(codex r1 F2):收尾一开始就锁存 {@link shutdownDraining};此后**登记**的卡(收尾开始时还在 `ensureAsk`
+     * 的 await 里 —— 零活流的后台 / 委派子代也在内)在登记那一刻按同一条路收场(`askBroadcast` 的铸造审计点之后读这一位)。等待条件
+     * 因此数「在飞的 ask」({@link asksInFlight},`askBroadcast` 进出计数)而不只是 `pending` —— 尚未登记的卡不在 `pending` 里。
+     * `deadlineMs` 是绝对时刻(`Date.now()` 域):关停序对审批面与店 quiesce 读**同一个**到期点(一个宽限窗,不是两个)。
+     * 从不抛错(关停序不许被审计面卡住);再调一次 = 再等一次(记号有去重集,零重写)。
+     */
+    drainForShutdown(deadlineMs: number): Promise<{
+        uncommittedParks: Array<{
+            approvalId: string;
+            taskId: string;
+        }>;
+    }>;
+    /**
+     * S-929 F1:checkpoint 店的观察层报「一只审批停车行提交了」({@link CommittedParkCalls}:行自己陈述的会话与握着的调用)⇒ 候着的
+     * **同一次调用**结清:执行会话**相等**(候者记的是 ask 自己陈述的发起会话,行陈述的是它停住的会话 —— core 同一个变量)∧ 调用 id ∈ 行握着的调用。
+     * 不做「会话相交」:调用 id 只在 run 内唯一(父子各自的第一只调用常同名),宿主会话若作子代的等价别名,宿主停车行一提交就会冒充子代的提交(车 SO)。
+     * 只在关停期有候者;非关停期的提交一个不碰。
+     * 🔴 观察层的订阅者契约是**不得抛**(它跑在 `put` 已提交之后、返回 core 之前 —— 抛了会把一次已提交的 park 报成失败),见下面的写行口。
+     */
+    private noteParkCommitted;
+    /**
+     * S-929 F1 的**结清口**(一处):有序关停下 park 路由的卡,在**观察到 core 已处置这次调用**时写它的审计 settle 行 —— 两种观察,同一件事实:
+     *  · `park-committed` —— 停车行提交了(观察层看到 `put` 落定,或 core 回读确认的那一次 `get` 读到了行);
+     *  · `leg-closed`     —— **承载它的那条腿**退场了(`runWithContext` finally 按 ctx 身份配 {@link ParkAwaitingCommit.carrierLeg}:core 已走完这条腿 ——
+     *                        停靠了,或拒了停靠 fail-closed 继续)。
+     * 两者都没观察到就退出 ⇒ 这行不写,与崩溃同路(下一次 boot 列 pending 孤儿)。委派 / 后台子代与零活流的卡没有被追踪的承载腿,只有第一种观察
+     * (子代的出处是宿主:宿主腿退场不是子代这次调用的处置 —— 车 SO)。
+     * 写行的 sink 自吞失败;sink 实现**自身**抛的那一形在这里兜住并按 [ref] 留痕,同 tag 扩射程(`http/server.ts` `noteLateSettleIfAccepted`
+     * 同一先例):丢的只是这一条审计行 —— 下一次 boot 它被当 pending 孤儿列出(证据方向),park 行本身不受影响。
+     */
+    private settleParksAwaitingCommit;
     /** 测试/可观测性钩子(X-2):某 (taskId) 维当前占用的准入名额数。 */
     admittedCount(taskId: string): number;
     /** [ref] 车2(D5 store 故障姿势):任何 store 调用 throw ⇒ fail-open 到进程内机械照旧(store 是记账/
@@ -1380,23 +1453,31 @@ export declare class ToolApprovalCoordinator {
         sessionId?: string;
     }) => ((req: AskRequest) => Promise<AskOutcome>);
     /**
-     * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据)。
+     * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据;S-944 / SN-C1 换读口)。
+     *
+     * 回 `true` = 「这次调用在这条腿上从来没有过持久出处」⇒ 一揽子放行可以短路;
+     * 回 `false` = 这次调用在腿内有行(任何状态、任何 ask 身份),**或**读不出来(不知道 = 不放宽)⇒ 调用方必须往下走真出卡。
+     *
+     * 为什么只读不写:短路的全部价值就是「不铸卡、不落行、不占 pending」,做一次按调用坐标的读保住这个价值,
+     * 而 `ensureAsk` 会写行。为什么一行都没有就放行:这次调用在这条腿上的行只可能由**这次调用的某一问**铸出来,
+     * 一行都没有 ⇒ 从来没有过一份能反驳本地判据的持久出处(这也是常见形:grant 命中的调用多半是头一次到)。
      *
-     * 回 `true` = 「这只 ask 从来没有过持久出处」⇒ 一揽子放行可以短路;
-     * 回 `false` = 行在(任何状态),**或**读不出来(不知道 = 不放宽)⇒ 调用方必须往下走真出卡。
+     * ## 争议按**调用**判,不按 ask 身份判(S-944 / SN-C1)
      *
-     * 为什么只读不写:短路的全部价值就是「不铸卡、不落行、不占 pending」,做一次主键点读保住这个价值,
-     * 而 `ensureAsk` 会写行。为什么行不在就放行:确定性 askId 的行只可能由**这只 ask 自己**铸出来,
-     * 行不在 ⇒ 从来没有过一份能反驳本地判据的持久出处(这也是常见形:grant 命中的 ask 多半是头一次到)。
+     * 争议的真源是调用:人对这次调用说过什么、这次调用还有没有一张卡挂着。ask 身份(`deriveAskId`)只是其中**一问**的主键,而身份会加轴 ——
+     * S-944 把这一问的类集并进身份后,按身份点读会把两类行读成「不存在」:① 同一调用另一类集的那一问(core #1218 的委派第二张卡与首卡);
+     * ② 升级前按旧派生写的行(同一 resume token 重投 = 同一 `legKey`,跨版本重入同一调用)。两形都让一揽子放行代答、人拒 / 挂着的卡被绕过
+     * (codex 车内 r1 [high] + [ref] gpt-6 腿 A 同指)。⇒ 读口 = 店的 `listByCall`(四列 = 这次调用在这条腿上的坐标,精确匹配),本函数不派生 askId。
+     * **身份可以加轴,争议判据不得依赖身份。**
      *
      * ## 判据的单一原则:**短路不得产生与「没有 grant 时那条路」不同的终局**
      *
-     * 没有 grant 时,同一条行在下面 `askBroadcast` 里都有确定去处:终局行(DECIDED/PARKED/DENIED/VOID)
-     * 走 `replayTerminalAskRow`(deny 回放 `false`、park 回放 `"unavailable"`);活着的 STREAM_PENDING 行走
-     * `ensureAsk` 的幂等命中(采信行上的卡与 deadline,等真决议)。短路一旦 return,这两条腿结构上都够不着
-     * —— 所以只要行在,短路就是在用一个**更宽**的答案顶替那条路。⇒ 判据 = `row === null`。
+     * 没有 grant 时,这次调用在腿内的任何一行都让下面 `askBroadcast` 有确定去处:同身份的终局行(DECIDED/PARKED/DENIED/VOID)
+     * 走 `replayTerminalAskRow`(deny 回放 `false`、park 回放 `"unavailable"`);同身份的活 STREAM_PENDING 行走 `ensureAsk` 的幂等命中
+     * (采信行上的卡与 deadline,等真决议);别的身份的行(另一类集 / 旧派生)⇒ 本问的身份无行 ⇒ 出卡再问(fail-closed)。短路一旦 return,
+     * 这些腿结构上都够不着 —— 所以只要这次调用在腿内有行,短路就是在用一个**更宽**的答案顶替那条路。⇒ 判据 = `rows.length === 0`。
      *
-     * 这条原则是分两次到位的,两次漏的都是「行 = 真源」的一部分:
+     * 这条原则是分几次到位的,每次漏的都是「行 = 真源」的一部分:
      *  · **[ref]**(codex R1-[high]):首版只查**本地** peek,行上标治理的那一半漏了 —— 本地标表是
      *    进程内表,failover / 重启后幂等命中既有行时它恒空。
      *  · **[ref]**(2026-08-19 三轴组复审,refuter 真运行复现三形):补丁把行读到手里,却只看
@@ -1406,12 +1487,13 @@ export declare class ToolApprovalCoordinator {
      *  · **codex 交叉复审**([ref] 同批,验真后采纳):只补终态判据仍漏「卡还在别处挂着」——
      *    STREAM_PENDING 行意味着已有一张卡在等人,凭 grant 抢跑会让行上的终局与真实执行长期矛盾
      *    (那张卡随后可被人/另一副本决成相反答案,或 TTL 到点被收敛成幻影 gate)。
-     * 三次都不是各自独立的 bug,是同一句话没说全,故最终判据收成一条而不是三个分支。
+     *  · **S-944 / SN-C1**(见上节):读口按身份点读,身份加轴后漏掉同调用别的问与旧派生的行。
+     * 几次都不是各自独立的 bug,是同一句话没说全,故最终判据收成一条而不是几个分支。
      *
-     * 零额外 IO(行已经在手里),且 fail-closed **by construction**:将来 `AskState` 加词也不需要动这里。
+     * 零额外 IO(一次读),且 fail-closed **by construction**:将来 `AskState` 加词、ask 身份再加轴,都不需要动这里。
      *
      * 🔴 **已登记的残余([ref],PARTIAL,本批不修)**:这一步是一次**非原子的 check-then-act** ——
-     * 另一副本正在为同一确定性 askId 落行、而本次点读抢在其提交前完成时,本副本仍会短路。真解 = 把出处
+     * 另一副本正在为同一调用落行、而本次按调用坐标的读(`listByCall`)抢在其提交前完成时,本副本仍会短路。真解 = 把出处
      * 判定与 grant 消费合并成**同一次**原子存储操作(带条件 upsert / CAS),属店语义级改动,须本模块属主
      * 立件(与上面 R4-F1/[ref] 两条同源残余同一处置)。「行不在 ⇒ 不短路」不是修法:grant 命中的 ask
      * 多半头一次到,那等于把一揽子放行整只废掉。窗的上界由本判据定死:行**一提交**窗即关。
@@ -1570,6 +1652,8 @@ export declare class ToolApprovalCoordinator {
      *  送达某个客户端之后发生(respond 需要客户端手上有这个 id),这是 outcome==="allowed"/"denied" 与
      *  "expired"(TTL/abort/run-exit-cleanup/emit 广播全灭四类共用)的天然分野。 */
     private askBroadcast;
+    /** {@link askBroadcast} 的本体(计数在外层,一处进出)。 */
+    private askBroadcastCounted;
     /** `POST /v1/tool-approvals/:id/respond` — settle a parked approval with the shell's decision. Owner-gated with a
      *  404 (no existence oracle), body validated first (400 is existence-independent) — question/steer parity. The HTTP
      *  layer owns auth (gatedPrincipal + REQUIRE_PRINCIPAL) before calling.