@sema-agent/server 7.108.0 → 7.110.0

package/dist/trace/engine-notice-wire.d.ts

@@ -16,38 +16,8 @@
  * 同文件 G1 e2e 的全码扇出夹具、以及契约文档附录 D.3 那张表(含**小节标题里的码数** —— 那道门本批
  * 刚立,立完就在下一次加码时自己咬住了)。
  */
-export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "task.halt_unconsumed", "task.late_approval", "config.durable_gate_unavailable", "peer.inbound_disposition", "peer.held_settled", "peer.idle_subscription", "classifier.denial_limit", "mcp.injection_dropped", "delegation.ask_unresolvable", "task.interrupt_unconsumed", "approval.read_root_granted", "approval.read_root_grant_rejected", "instructions.source_changed", "session.records_skipped", "server.model_unreachable", "classifier.unavailable", "config.permission_mode_unavailable", "permission.ask_released_by_mode", "permission.read_deny_unapplied", "permission.rule_store_unavailable"];
+export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "task.halt_unconsumed", "task.late_approval", "config.durable_gate_unavailable", "peer.inbound_disposition", "peer.held_settled", "peer.idle_subscription", "classifier.denial_limit", "mcp.injection_dropped", "delegation.ask_unresolvable", "task.interrupt_unconsumed", "approval.read_root_granted", "approval.read_root_grant_rejected", "instructions.source_changed", "session.records_skipped", "server.model_unreachable", "classifier.unavailable", "config.permission_mode_unavailable", "permission.ask_released_by_mode", "permission.read_deny_unapplied", "permission.rule_store_unavailable", "task.tool_turn_incomplete"];
 export type EngineNoticeWireCode = (typeof ENGINE_NOTICE_WIRE_CODES)[number];
-/**
- * S-690 —— **本仓自铸**的通告码与它们的受众(码 / 铸点 / 受众三者的属主都是本仓)。
- *
- * 为什么可以有这一族:core 的 `EngineNotice.code` 刻意是开放 `string`,顶注逐字「a host forwarding its own notices
- * through the same sink is a supported shape」—— 部署经同一只 `onNotice` 转发体投自己的通告,白名单 / 归属 / 消毒 /
- * 隔离四件判据一个不绕。为什么受众写在这里:core 的 `NOTICE_AUDIENCE` 只收录 core 自己铸的码,对本仓的码
- * `noticeAudienceOf` 只会读保守默认 `"operator"` —— 那是「不认识」,不是判决。顶注的「本仓不许自造第二份受众语义」
- * 说的是 **core 的码**;本表只收 core 码册里**没有**的码,这里是它们唯一的一份受众语义。
- *
- * 🔴 机器门(`test/engine-notice-wire.test.ts` 的 server 自铸码属主门):① 本表的码与 core 运行期码册 `ENGINE_NOTICE_CODES`
- * **零交集**(core 哪天铸了同名码 ⇒ 属主变成两个,当场红:销本表的行、改走 core 的受众与工厂);② 判 `"user"` 的码必须
- * 入白名单;③ 白名单里的码,受众一律由「本表 ∪ core 注册表」给,判出来必须是 `"user"`。
- */
-export declare const SERVER_NOTICE_AUDIENCE: {
-    readonly "instructions.source_changed": "user";
-    /**
-     * O2(7.101.0 合并复审)—— boot 期探测到 ≤7.30.x 引擎留下的锁住的记忆层(唯一铸点 `src/memory-layer-legacy-lock.ts`,
-     * 调用点 = `boot/stores.ts` 的 file 记忆引擎装配段)。受众 **operator**:恢复动词是运维在数据根上执行一次 `chmod -R u+w`,
-     * 而且铸在 boot 期、没有任何会话 ⇒ 不上 wire、不进白名单,只走转发体的日志终点(`engine_notice` warn)。
-     * `detail: { layers, remedy }` —— 层名(挂载面的直接子目录名)与那一句补救;条目名 / 内容不进。
-     */
-    readonly "memory.layer_locked_legacy": "operator";
-    /** S-612 —— 会话存档部分记录被跳过(唯一铸点 `src/session-records-skipped-notice.ts`);受众 user,理由见白名单键注。 */
-    readonly "session.records_skipped": "user";
-    /** S-925 —— 模型调用因建连失败终态(唯一铸点 `src/model-unreachable-notice.ts`);受众 user,理由见白名单键注。 */
-    readonly "server.model_unreachable": "user";
-};
-export type ServerNoticeCode = keyof typeof SERVER_NOTICE_AUDIENCE;
-/** 该码是否本仓自铸(属主判据单点:门与投递面都读这一个)。 */
-export declare function isServerNoticeCode(code: string): code is ServerNoticeCode;
 /** 白名单谓词(单点):路由与门都读这一个,不许第二处手抄码串。 */
 export declare function isEngineNoticeWireCode(code: string): code is EngineNoticeWireCode;
 /**
@@ -104,8 +74,19 @@ export declare function engineNoticeEventData(notice: {
     message: string;
     detail?: Record<string, unknown>;
 }, sessionId: string, nowMs: number): EngineNoticeWireRow;
-/** 一条 run 腿注册进来的投递口。抛错由 {@link EngineNoticeRouter.route} 隔离(见那里的 fail-open 登记)。 */
-export type EngineNoticeWireSink = (row: EngineNoticeWireRow) => void;
+/**
+ * 一条 run 腿注册进来的投递口。抛错由 {@link EngineNoticeRouter.route} 隔离(见那里的 fail-open 登记)。
+ * 返回值只对 {@link EngineNoticeRouter.routeConfirmed} 有意义(S-928 codex r1-F2 / r2-F1):durable 口交回它那一次账本写的 thenable,
+ * 兑现 `true` = 这一帧落进了账本;`false` / 拒绝 = 没落(写失败已由口自己留痕);同步口(live SSE)不交 thenable,**不是**落账确认。`route()` 不读返回值。
+ */
+export type EngineNoticeWireSink = (row: EngineNoticeWireRow) => unknown;
+/** 口的槽位(闭集):`live` = 流上的人(SSE),`durable` = 这条 run 的事件账。{@link EngineNoticeRouter.routeConfirmed} 只数 `durable` 槽的落账确认。 */
+export type EngineNoticeSlot = "live" | "durable";
+/** 一条腿的两只具名口(各自可缺席:bg 腿没有 live SSE,ephemeral sync 腿没有账本)。 */
+export interface EngineNoticeLegSlots {
+    readonly live?: EngineNoticeWireSink;
+    readonly durable?: EngineNoticeWireSink;
+}
 /**
  * sessionId → 该会话活跃 run 腿的投递口。**进程内**(`defaultSubagentTailBus` 同款姿势):
  * `onNotice` 是同进程的同步回调,通告与它要投的那条腿必然同副本,跨副本路由这件事结构上不存在。
@@ -130,8 +111,8 @@ export declare class EngineNoticeRouter {
      *
      * 每只口各自 try 隔离在 {@link route} 里,单口抛不牵连同腿另一口。
      */
-    registerLeg(sessionId: string, sinks: readonly EngineNoticeWireSink[]): () => void;
-    /** 单口腿的便捷形(测试与单终点腿用)。 */
+    registerLeg(sessionId: string, slots: EngineNoticeLegSlots): () => void;
+    /** 单口腿的便捷形(测试用):登记为 **durable** 槽 —— 这样 `route()` 与 `routeConfirmed()` 两条路都能用一只口测到(live 槽对后者结构上恒不计)。 */
     register(sessionId: string, sink: EngineNoticeWireSink): () => void;
     /** 诊断/门用:某会话此刻**最新代**有几只口在听(旧代不计——它们收不到帧)。 */
     sinkCount(sessionId: string): number;
@@ -148,6 +129,20 @@ export declare class EngineNoticeRouter {
         detail?: Record<string, unknown>;
         sessionId?: unknown;
     }, nowMs?: number): number;
+    /**
+     * S-928(codex r1-F2 / r2-F1;[ref] opus 腿 L2 改按槽判):同一只扇出,但**等**每只口交回的持久化结果 —— 返回**确认落账**的口数:
+     * 只数 **`durable` 槽**里交回 thenable 且兑现 `true` 的口;兑现 `false` / 拒绝不算;`live` 槽**结构上不计**(不管它返回什么 —— 流上的人收没收到说明不了落账;
+     * 修前按「交回 thenable」反推是不是 durable 口,哪天 live 口改成 async 返回 `true` 就会被计成落账)。给「投出之后要记一笔『告知过』」的铸点用:
+     * 记账必须跟在**落账**之后,不能跟在「调用了口」之后(后台腿唯一的口是事件账 append,写失败时 `route()` 的计数照样是 1)。判据(白名单 / 归属 / 最新代 / 隔离)与 `route()` 逐字同一条。
+     */
+    routeConfirmed(notice: {
+        code: string;
+        message: string;
+        detail?: Record<string, unknown>;
+        sessionId?: unknown;
+    }, nowMs?: number): Promise<number>;
+    /** 两只入口共用的扇出:返回每只**没抛**的口的持久化结果(promise 形一律先接住拒绝 ⇒ 绝不留未处理拒绝)。 */
+    private fanOut;
 }
 /** 进程单例(`defaultSubagentTailBus` 同款):分流器与 run 腿直接 import,不穿长参数列表;测试自 new 独立实例。 */
 export declare const defaultEngineNoticeRouter: EngineNoticeRouter;

package/dist/trace/engine-notice-wire.js

@@ -33,16 +33,8 @@ export const ENGINE_NOTICE_WIRE_CODES = [
     "permission.ask_released_by_mode",
     "permission.read_deny_unapplied",
     "permission.rule_store_unavailable",
+    "task.tool_turn_incomplete",
 ];
-export const SERVER_NOTICE_AUDIENCE = {
-    "instructions.source_changed": "user",
-    "memory.layer_locked_legacy": "operator",
-    "session.records_skipped": "user",
-    "server.model_unreachable": "user",
-};
-export function isServerNoticeCode(code) {
-    return Object.hasOwn(SERVER_NOTICE_AUDIENCE, code);
-}
 const WIRE_CODES = new Set(ENGINE_NOTICE_WIRE_CODES);
 export function isEngineNoticeWireCode(code) {
     return WIRE_CODES.has(code);
@@ -107,11 +99,13 @@ export function engineNoticeEventData(notice, sessionId, nowMs) {
         ts: nowMs,
     };
 }
+const isThenableResult = (v) => typeof v === "object" && v !== null && typeof v.then === "function";
 let nextLegId = 1;
 export class EngineNoticeRouter {
     legs = new Map();
-    registerLeg(sessionId, sinks) {
-        const leg = { legId: nextLegId++, sinks: [...sinks] };
+    registerLeg(sessionId, slots) {
+        const sinks = [...(slots.live ? [{ slot: "live", sink: slots.live }] : []), ...(slots.durable ? [{ slot: "durable", sink: slots.durable }] : [])];
+        const leg = { legId: nextLegId++, sinks };
         const list = this.legs.get(sessionId) ?? [];
         list.push(leg);
         this.legs.set(sessionId, list);
@@ -131,7 +125,7 @@ export class EngineNoticeRouter {
         };
     }
     register(sessionId, sink) {
-        return this.registerLeg(sessionId, [sink]);
+        return this.registerLeg(sessionId, { durable: sink });
     }
     sinkCount(sessionId) {
         const list = this.legs.get(sessionId);
@@ -141,27 +135,34 @@ export class EngineNoticeRouter {
         return this.legs.get(sessionId)?.length ?? 0;
     }
     route(notice, nowMs = Date.now()) {
+        return this.fanOut(notice, nowMs).length;
+    }
+    async routeConfirmed(notice, nowMs = Date.now()) {
+        const outcomes = await Promise.all(this.fanOut(notice, nowMs));
+        return outcomes.filter((ok) => ok).length;
+    }
+    fanOut(notice, nowMs) {
         if (!isEngineNoticeWireCode(notice.code))
-            return 0;
+            return [];
         const sessionId = engineNoticeSessionId(notice);
         if (sessionId === undefined)
-            return 0;
+            return [];
         const list = this.legs.get(sessionId);
         const leg = list && list.length > 0 ? list[list.length - 1] : undefined;
         if (!leg || leg.sinks.length === 0)
-            return 0;
+            return [];
         const row = engineNoticeEventData(notice, sessionId, nowMs);
-        let delivered = 0;
-        for (const sink of leg.sinks) {
+        const outcomes = [];
+        for (const { slot, sink } of leg.sinks) {
             try {
-                sink(row);
-                delivered++;
+                const result = sink(row);
+                outcomes.push(isThenableResult(result) ? Promise.resolve(result).then((v) => slot === "durable" && v === true, () => false) : Promise.resolve(false));
             }
             catch {
                 recordFailOpen("server.engine-notice.wire-sink-threw", `code=${notice.code}`);
             }
         }
-        return delivered;
+        return outcomes;
     }
 }
 export const defaultEngineNoticeRouter = new EngineNoticeRouter();
@@ -169,11 +170,10 @@ export function registerEngineNoticeLeg(opts) {
     const { sessionId, live, durable } = opts;
     if (sessionId === undefined || sessionId.length === 0)
         return () => undefined;
-    const sinks = [...(live ? [live] : []), ...(durable ? [durable] : [])];
-    if (sinks.length === 0)
+    if (live === undefined && durable === undefined)
         return () => undefined;
     const router = opts.router ?? defaultEngineNoticeRouter;
-    const unregister = router.registerLeg(sessionId, sinks);
+    const unregister = router.registerLeg(sessionId, { ...(live ? { live } : {}), ...(durable ? { durable } : {}) });
     for (const notice of opts.pending ?? [])
         router.route(notice);
     return unregister;

package/dist/trace/project.js

@@ -1,5 +1,5 @@
 import { admitProviderEcho, redactErrorMessage, redactModelText } from "../observability/run-terminal.js";
-import { isAskClass, isAskOrigin, isPermissionMode, isPersistedRuleMandate, MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
+import { isAskClass, isAskOrigin, isModeReleaseReason, isPermissionMode, isPersistedRuleMandate, MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets, redactDeep } from "./redact.js";
@@ -126,11 +126,10 @@ function modeLedgerDefect(d) {
         return "disposition.released.origin is outside the closed set";
     if (o.mandate !== undefined && !isPersistedRuleMandate(o.mandate))
         return "disposition.released.mandate is outside the closed set";
-    if (o.reason !== undefined && !(typeof o.reason === "string" && Object.hasOwn(RELEASE_REASON_WORDS, o.reason)))
+    if (o.reason !== undefined && !isModeReleaseReason(o.reason))
         return "disposition.released.reason is outside the closed set";
     return false;
 }
-const RELEASE_REASON_WORDS = { rule_unreadable: true };
 function screenedGateOrThrow(v) {
     if (v === null || typeof v !== "object") {
         if (v !== undefined)

package/dist/trace/self-minted-wire.d.ts

@@ -18,6 +18,20 @@ export declare const SELF_MINTED_WIRE: {
             };
         };
     };
+    /**
+     * S-928(7.110.0):`engine_notice` `task.user_steer_undrained` 上**本仓铸**的那一臂。词表属主是 core(`USER_STEER_UNDRAINED_CAUSES`,
+     * `leg_end` 由引擎铸、逐字过境,不在本表);本表登记的是「这个值自哪一版起由本服务出现在 wire 上」。`satisfies Record<CrashedCause, …>`:
+     * core 删掉 `crashed` ⇒ `CrashedCause` 成 never ⇒ 本行编译红。
+     */
+    readonly userSteerUndrainedServerCause: {
+        readonly at: "engine_notice task.user_steer_undrained detail.cause(本服务铸的臂;下一条同会话 run 开通告口那一拍)";
+        readonly members: {
+            crashed: {
+                attr: string;
+                since: string;
+            };
+        };
+    };
     /**
      * 会话所有者自助抹除面的**已分类拒** → HTTP 状态(S-930 起与 operator 面 `POST /v1/memory/erase` 同一只映射;`since` 记的是**本面**
      * 自哪一版起这样答 —— 7.107.0 及以前本面只认前两只,其余落 500 `internal.error`)。

package/dist/trace/self-minted-wire.js

@@ -6,6 +6,12 @@ export const SELF_MINTED_WIRE = {
             shutdown_before_park: { attr: "-", since: "7.108.0" },
         },
     },
+    userSteerUndrainedServerCause: {
+        at: "engine_notice task.user_steer_undrained detail.cause(本服务铸的臂;下一条同会话 run 开通告口那一拍)",
+        members: {
+            crashed: { attr: "-", since: "7.110.0" },
+        },
+    },
     sessionMemoryEraseStatus: {
         at: "POST /v1/sessions/:id/memory/erase(已分类拒 errorCode → HTTP 状态)",
         members: {

package/dist/unattended-permission-mode.d.ts

@@ -1,110 +1,71 @@
 /**
- * S-877 候裁 15 → B(主会话裁定 2026-09-29,收车档 ⑩)—— `UNATTENDED_PERMISSION_MODE`:**无人值守腿的模式,运维一处表态**。
+ * S-934 ①(S-906 / clay 裁 [ref];core 7.37.0 #1214,`docs/INTEGRATION-CORE.md` §4.6e)—— **无人值守腿:`default` 模式 + 按类作答的 onAsk**。
  *
  * ## 规则(一句)
- * 本仓**自己铸** spec、**没有调用方**能在请求上表态模式、也**没有审批席**的腿 —— leader worker(`src/leader/wire.ts`
- * provisionWorker 两车道)、leader 的两只修复腿(集成沙箱修复 `mkRepair`、模块门修复 `runModuleGate` / 单代理修复环
- * `attachRepairLoopDeps`)、run-local(`src/run-local.ts`,一次性 CLI)—— 它们的 `TaskSpec.permissionMode` 由本旋钮给,
- * 经 {@link unattendedPermissionMode} 这**一只**读函数取值,各腿不各读 config、不各写默认。
+ * 本仓**自己铸** spec、**没有调用方**能在请求上表态模式的腿 —— leader worker(`src/leader/wire.ts` provisionWorker 两车道)、leader 的
+ * 修复腿(集成沙箱修复 `mkRepair`、模块门修复 `leader.ts` `runModuleGate`、单代理修复环 `repair-wire.ts` `attachRepairLoopDeps`)、run-local
+ * (`src/run-local.ts`,一次性 CLI)与这些腿的 durable 续跑重挂(`CheckpointCtx.unattendedLeg`)—— 经 {@link withUnattendedLeg} 这**一只**
+ * 合并口铸两键:`permissionMode: "default"`(显式:续跑时盖过 checkpoint 记下的旧模式)与 `onAsk` = {@link createUnattendedOnAsk}。
+ * 那只 onAsk 读 `AskRequest.classes` **整体**:集非空且每一类都在 {@link UNATTENDED_ANSWERED_CLASSES}(= `{ordinary}`,常量,不是旋钮)⇒ 答 yes;
+ * 否则不答 —— 本腿**有席**(run-local 的 `createLocalApprover`:有 TTY 问人、无 TTY 当场拒;续跑腿的协调器席)⇒ 交给席;**无席** ⇒ 答
+ * `"unavailable"` = 交回 core 的缺席路(本腿武装了 durable park ⇒ park,等人经 `/decide` 答;否则 headless 拒 —— fail-closed)。
  *
- * ## 为什么要有它(对 v7.105.0 回归的修,codex 对抗复审 F1 [high] 亲核成立)
- * core 7.34.0 [ref]「Absent = `default`」:不带 `permissionMode` 的 spec 按 `default` 跑 —— 模式写门对每一次写先问、
- * 形状层对非只读 shell 先问。上面三类腿**没有人**能答那一问(leader 的 Runner 不接 `onAsk`,零名单部署也不给 durable 席;
- * run-local 无 TTY 时同形)⇒ headless 当场拒:worker `completed`、零写入。7.105.0 上这些腿不带模式也不问
- * (缺席臂只给 base、`shellGate` 不写)。core 同段逐字给出路:「A library embedder that writes files with no approver
- * now declares `permissionMode: "acceptEdits"` … or `"bypassPermissions"` … or wires an approver」——本仓对自己铸的
- * 那几条 spec 就是那个 embedder。
+ * ## 为什么是这一形(core §4.6e 推荐形逐条)
+ *  · **读整体,不读 `askClass`**:一问可以同属几类(探针问与写保护并存、组织裁决与 hook 并存),`askClass` 只是表序第一个;集里任一类
+ *    不答 ⇒ 整问不答。
+ *  · **缺席 = 不答的类**:没盖 `origin` 的站(共享制品读确认,KL-1214-a)、部署自铸的请求、7.37.0 之前 park 的行续跑(KL-1214-b,续跑不补)
+ *    都不带类 ⇒ 不答。
+ *  · **答集只 `ordinary`**:七个保护类(`probe` / `write_protection` / `rule_unreadable` / `tool_marks_mcp` / `tool_marks_a2a` /
+ *    `transcript_write` / `artifact_shared_read`)与 `mode`(plan 的写问)留给人;`RELEASABLE_ASK_CLASSES` 之外的类(hook / ask_rule /
+ *    org_rule / operator_forced / …,权威为人提的问)恒不答。function approver 的 yes 是「这一次调用的答」—— 它连 `requiresRealApproval`
+ *    都清得掉(引擎分不出函数与人),所以带那一位的类(`transcript_write` / `rule_unreadable` / `artifact_shared_read` / `policy_rra`)不进答集
+ *    (钉:test/unattended-permission-mode.test.ts「答集 ⊆ RELEASABLE_ASK_CLASSES,且与 RRA_EXPLAINERS ∪ {policy_rra} 不交」)。
+ *  · **`ordinary` 覆盖什么**(core 原句):`Read` 工具的根外读、shell 的根外**写**(`echo x > <outside>` —— 写守卫只判保护表)、模式写门对每一次
+ *    covered write 的问、形状层对非只读 shell 的问;shell 的根外**读**(`cat <outside>`)是 `probe`,不答。
  *
  * ## 三问
- *  · **谁需要**:用 leader / run-local 的部署(零审批名单是常态)—— 缺省值必须等于 7.105.0 的行为,否则升级即断。
- *  · **谁受伤**:想让无人值守腿更严的运维 —— **补偿** = 把旋钮设成 `acceptEdits`(根内写不问、非只读命令仍问 ⇒ 无人可答即拒)
- *    / `default` / `dontAsk`(一切会问的都拒)/ `plan`。部署的审批名单(`APPROVAL_REQUIRE` 等)与治理层的问(运维强制、ask 规则、
- *    hook)在任何一个词下都**照问**:bypassPermissions 只放行「普通」一类(core 7.34.0 [ref] 仲裁表,本仓不重推)。
- *  · **什么补偿**:缺省 = `bypassPermissions` —— 写门 / 形状层与 7.105.0 同(不问);词表外的值起服拒启([ref],不静默回缺省)。
- *    候裁 18 → D:缺省 bypass 会释放写保护 ⇒ 本腿把写保护从问改成拒({@link createUnattendedWriteProtectionPolicy});另六类释放 = 相对 7.105.0 的宽化,
- *    如实披露(见那只函数的「射程外」)。**过渡形**:core 7.37.0(S-906)后退成 `default` + 按类作答的 onAsk,旋钮硬删(拒启点名)。
+ *  · **谁需要**:用 leader / run-local 的部署 —— 普通写与非只读命令照跑(7.105.0 行为;7.106.0–7.108.0 过渡形靠 `bypassPermissions` 宽放给出的同一结果)。
+ *  · **谁受伤**:① 设了 `UNATTENDED_PERMISSION_MODE` 的部署 —— 起服拒启(`config.ts` 墓碑表,`removed` 族);② 靠过渡形缺省 bypass 放行
+ *    `probe` / MCP·A2A 标记工具 / 转录写 / 规则店读不出 / 共享制品读这六类的无人值守流程 —— 改成不答(有席交席、无席 park 或拒)。安全轴收紧。
+ *  · **什么补偿**:有人的腿照问人(run-local 在终端里跑;leader 配 durable 审批块 ⇒ park 到 `/decide`);答集是 core 推荐形的常量 ——
+ *    要放更多类的部署先立案候裁,不开旋钮。
  *
- * ## 写面:本旋钮只给模式的**仲裁**,不给 bypassPermissions 在 core 模式表里的**写面 open**
- * core 7.34.0 起 `modePolicyOf("bypassPermissions").writeFace === "open"`(工作区根之外也能写)。7.105.0 上这几条腿**没有模式**,
- * 写面恒是引擎缺省 `"roots"`。所以 {@link buildUnattendedLegSpec} 同时在任务席写 `writeFace: "roots"`(core 容纳面解析序:
- * 显式任务席在模式那一行**之前**,`dist/tools/fs/containment-face.d.ts` resolveContainmentFace 第 3 / 3′ 行)—— 缺省与 7.105.0
- * **逐字**同形,运维把旋钮设成任何词也不会顺手拿到根外写面(那是 HTTP 腿上 `TASK_WRITE_FACE_ESCALATION` 管的另一件事,
- * S-591;这几条腿不是请求,不经那道门)。⚠️ 这一格是按裁定的**意图**(「= 7.105.0 行为」)施工、比裁定字面多出的一半,
- * 收车档 ⑩ 单列,主会话可翻。
+ * ## 退役(硬破坏,零别名 / 零双读 / 零过渡臂)
+ * `UNATTENDED_PERMISSION_MODE` 旋钮(`config-catalog` 行 / `config` 解析 / `ServiceConfig.unattendedPermissionMode`)、`createUnattendedWriteProtectionPolicy`
+ * (#1211 的 `pathDenyRules` 过渡形)、`createUnattendedLeg` 的模式 / Runner 座参数、写面钉 `writeFace: "roots"`(那一钉只为不拿 bypass 的开放写面;
+ * `default` 模式行不给写面 ⇒ 引擎缺省 roots,与 7.105.0 同)、P-DEBT 臂 `server.unattended-leg.mode-releases-protective-asks`(FAIL-OPEN-CENSUS 第 101 行终态)。
  *
  * ## 射程外(成文)
- *  · HTTP 腿(`POST /v1/tasks|runs`):模式在请求上(`permissionMode` / `settings.permissions.defaultMode`),缺席 = core `default`
- *    原样过境(候裁 5 裁 A)—— 那里有调用方能表态,本旋钮不参与。
- *  · leader 的 planner 路由(无手 Runner,没有写 / shell 可问)不读本旋钮。
- *  · 中心下发 `RuntimeCaps.bypassPermissions === false` 时 core 把 bypass 折回 `default` 并发 `config.permission_mode_unavailable`
- *    —— 组织级拒优先。本仓今天不写这一位([ref] 未闭环),故这条今天只在 core 侧可达。
+ *  · HTTP 腿(`POST /v1/tasks|runs`):模式在请求上,有调用方能表态,不经本合并口。
+ *  · leader 的 planner 路由(无手 Runner,没有写 / shell 可问)不经本合并口。
+ *  · 续跑腿上的协调器席:`http/resume-legs.ts` 只在「run 行在场 ∧ 活卡协调器在场」时给 spec 另装活席(`deps.toolApproval && taskId`)——
+ *    leader worker 的会话没有 run 行,那一装今天够不着本腿;哪天够着了,活席会盖掉本层(方向 = 多问人,fail-closed),见收车档 ⑤。
  */
-import { type PermissionMode, type RunnerDeps, type TaskSpec, type ToolPolicy } from "@sema-agent/core";
-/** 旋钮的出厂值(主会话裁定候裁 15 B / 18 D)。写面由 {@link buildUnattendedLegSpec} 钉 roots;写保护由 {@link createUnattendedWriteProtectionPolicy} 改拒。 */
-export declare const UNATTENDED_PERMISSION_MODE_DEFAULT: "bypassPermissions";
-/** 解析结果:值 + 它从哪来(boot 一行 `unattended_permission_mode` 的两个字段)。 */
-export interface UnattendedPermissionModeSetting {
-    readonly value: PermissionMode;
-    readonly source: "env" | "default";
-}
+import type { AskClass, AskRequest, OnAsk, TaskSpec } from "@sema-agent/core";
 /**
- * `UNATTENDED_PERMISSION_MODE` 的**唯一**解析口。词表 = core `PERMISSION_MODES` 本尊(不手抄 —— core 加词本口随之受理,
- * 减词本口随之拒启);两侧空白裁掉后**逐字**比较(不折大小写:`Default` / `BYPASS` 落拒启臂)。
- * 未设 / 空串 ⇒ 出厂值,来源 `default`;词表外 ⇒ **拒启**,拒因点名旋钮与全部合法词([ref]:安全轴旋钮不许「以为设了其实没设」)。
+ * 按类作答的**答集** —— core §4.6e 推荐形:机器只答 `ordinary`。**常量,不是旋钮**([ref]):要放更多类是部署级的安全决定,先立案候裁。
+ * 不变量(测试钉):答集 ⊆ core `RELEASABLE_ASK_CLASSES`,且与带 `requiresRealApproval` 的类(core `RRA_EXPLAINERS` ∪ `policy_rra`)不交;`mode` 不在其中。
  */
-export declare function parseUnattendedPermissionMode(raw: string | undefined): UnattendedPermissionModeSetting;
-/** 三类无人值守腿的**唯一**读函数(见模块头注「规则」)。 */
-export declare function unattendedPermissionMode(config: {
-    readonly unattendedPermissionMode: PermissionMode;
-}): PermissionMode;
-/** 无人值守腿铸进 spec 的两键(纯数据 ⇒ `build*`):模式 = 旋钮值;写面 = `"roots"`(理由见模块头注「写面」)。 */
-export declare function buildUnattendedLegSpec(mode: PermissionMode): Required<Pick<TaskSpec, "permissionMode" | "writeFace">>;
+export declare const UNATTENDED_ANSWERED_CLASSES: ReadonlySet<AskClass>;
+/** onAsk 的函数臂(`"allow"` / `"deny"` 两个字面臂是姿态设置,不是席)—— 本腿的活审批席与本层自己都是这一形。 */
+export type UnattendedSeat = Extract<OnAsk, (req: AskRequest, signal?: AbortSignal) => unknown>;
+/** 这一问是不是机器答得了的:读 `classes` **整体** —— 在场、非空、且每一类都在答集;缺席 / 空 / 任一类在答集外 ⇒ 否。 */
+export declare function unattendedAnswers(req: Pick<AskRequest, "classes">): boolean;
 /**
- * 🔴 **S-877 候裁 18 → D(主会话续裁 2026-09-29)—— 无审批席的腿上,写保护从「问」改成「拒」**。
- *
- * **病**(codex 续车轮 R2-F1):core `MODE_ARBITRATION` 里 `bypassPermissions` 释放 `write_protection` 一类(`bypassImmune:false`)⇒ 旋钮缺省下写保护表里的
- * 目标零询问放行;7.105.0 这些腿无模式 ⇒ 写保护是一问 ⇒ 无人可答 ⇒ 拒。core 7.35 没有「放普通问、留保护问」的模式,也没有限定模式可释放类的座。
- *
- * **规则(一条)**:本腿的模式**会释放**写保护一问时(读 core 仲裁本尊 `arbitrateByMode`,不手抄模式词),把**本腿引擎判官用的同一张写保护表**
- * (`runnerSeats` = 构造本腿 Runner 的那份 deps 的两只座 {@link UnattendedLegRunnerSeats};`writeProtectedPaths` 缺席 = core 源表 `WRITE_PROTECTED_DEFAULT_TABLE`)经 core 的
- * `compileWriteProtection` 编成判官,每一行铸成一条 **core 路径拒行**(`ToolPolicy.pathDenyRules`,`faces:["write"]`)—— 引擎的写面把它们并进本腿的拒表:
- * 写工具的路径解析与 shell 站(重定向 / `tee` / `sed -i` / `cp`·`mv`·`touch` 操作数)都按拒表拒,模式**不释放拒**。**路径匹配全在 core**:每行的
- * `reaches` 就是判官自己的 `matchPath`(同一只折叠、同一只数据根放行 —— `dataRoot` 与引擎判官同源:本腿 Runner 的 `memoryEngineDir`),本仓不写一个字的
- * 路径比较。模式不释放写保护(`default` / `acceptEdits` / `plan` / `auto` / `dontAsk`)⇒ 不铸(那一问照旧问,有席的腿上人能答 —— run-local 有 TTY 时)。
- *
- * **射程外**(如实,收车档 ⑩ 候裁 18):缺省 bypass 还释放 `probe` / `tool_marks_mcp` / `tool_marks_a2a` / `transcript_write` / `rule_unreadable` /
- * `artifact_shared_read` 六类(core 对它们没有「拒」的座),相对 7.105.0 是宽化 —— CHANGELOG「谁受伤」与 MIGRATION 写明,补偿 = 旋钮 `acceptEdits` / `default`。
- * **过渡形**:core 7.37.0(S-906,`AskRequest.askClass?` / `classes?` 到货)后本仓改成 `default` 模式 + fail-closed 按类作答的 `onAsk`,本座与旋钮一并硬删。
- * **续跑**(codex r3 F1):本层是活闭包、进不了 checkpoint,而 core 续跑在 spec 不说模式时取 checkpoint 记下的模式 ⇒ durable 续跑必须重挂整条腿 ——
- * leader worker 的续跑上下文带 `CheckpointCtx.unattendedLeg`,续跑家族据此让 `resolveSpec` 在全部折叠之后调 {@link createUnattendedLeg} / {@link withUnattendedLeg}。
- * **已知过拒**(codex r3 F2,fail-closed 方向,随过渡形退役):core 的路径拒座在 shell 站把 `cp` 的**源**操作数也按写目标判(CC 同形,cli280.js:216993
- * `cp:"write"`),引擎写保护判官只判真写目标 ⇒ 从写保护目标复制出来在本层下被拒、7.105.0 上照跑。本仓不补路径比较(那是第二个判官),特征化钉在
- * test/run-local.test.ts「🚧 codex r3 F2」。
- * **附带效果**(S-877 四续 ⑫b,随过渡形退役):本层只能是一只 `ToolPolicy`(路径拒座挂在策略上,`check` 必填 —— 这里恒 `allow`),原先没有 toolPolicy
- * 的腿因此被引擎读成「有策略层」:系统提示多 `# Execution environment` 一块、UNGATED 告警不再发。7.35.2 上表达不了「只供拒行、不算策略层」;
- * 特征化钉在 test/unattended-permission-mode.test.ts「🚧 四续 ⑫b」。
- *
- * 返回 `undefined` = 本腿不需要这一层(模式不释放写保护,或运维把表清空 `[]`)。活对象(带判官闭包)⇒ `create*`。
- */
-export declare function createUnattendedWriteProtectionPolicy(mode: PermissionMode, runnerSeats: UnattendedLegRunnerSeats): ToolPolicy | undefined;
-/** 无人值守腿的全部铸件:模式 + 写面(纯数据)与写保护拒层(活对象,可缺席)。由 {@link createUnattendedLeg} 铸、{@link withUnattendedLeg} 并进 spec。 */
-export interface UnattendedLeg {
-    readonly spec: Required<Pick<TaskSpec, "permissionMode" | "writeFace">>;
-    readonly writeProtection: ToolPolicy | undefined;
-}
-/**
- * 引擎写保护判官读的两只 Runner 座(`RunnerDeps` 的同名切片):表(`writeProtectedPaths`,缺席 = core 源表)与数据根放行(`memoryEngineDir`,缺席 = 引擎缺省)。
- * 调用方递**构造本腿 Runner 的那一份** deps(或它的展开源)—— 表与根从哪来、根要不要在,都由那份 deps 说了算,腿的接线处不再单独读任何一只坐标
- * (本模块是唯一读者;S-877 四续:接线处各读一份就是「两边同一张表、同一个根」这句话的第二、三个写者)。
+ * 按类作答的 onAsk(活对象 ⇒ `create*`)。答得了 ⇒ `true`(这一次调用的答);答不了 ⇒ 有席交席(席的答原样返回,席自己的
+ * fail-closed 语义不动),无席 ⇒ `"unavailable"`(core G1:这一问此刻没有人够得着 ⇒ 改道 durable park;本腿没武装 park ⇒ headless 拒)。
+ * 不答的臂**从不**自己拒成 `false`:那会把「交给 park 的人」折成「机器拒了」,durable 审批块的 leader worker 就再也 park 不下来。
  */
-export type UnattendedLegRunnerSeats = Pick<RunnerDeps, "writeProtectedPaths" | "memoryEngineDir">;
-/** 三处无人值守腿(leader worker / 修复腿 / run-local)与续跑重挂的**唯一**铸点:`mode` 取 {@link unattendedPermissionMode},`runnerSeats` = 本腿 Runner 的 deps
- *  (引擎写保护判官与本层拒行同一张表、同一个数据根)。 */
-export declare function createUnattendedLeg(mode: PermissionMode, runnerSeats: UnattendedLegRunnerSeats): UnattendedLeg;
+export declare function createUnattendedOnAsk(seat: UnattendedSeat | undefined): UnattendedSeat;
+/** {@link withUnattendedLeg} 铸进 spec 的两键。 */
+export type UnattendedLegSpec = {
+    readonly permissionMode: "default";
+    readonly onAsk: UnattendedSeat;
+};
 /**
- * 把无人值守腿并进一条 spec —— 三处腿的**唯一**合并口:两键覆盖(本腿的模式与写面由旋钮说了算),写保护拒层与 spec 已有的 `toolPolicy` **合成**
- * (`combinePolicies`,deny-wins,携带 `pathDenyRules`)而不是覆盖(leader worker 的 durable 名单门、run-local 的治理链都在那里)。
- * 调用点必须在 spec 其余键(含治理折叠)**之后**调它,否则后铸的 `toolPolicy` 会把拒层盖掉。
+ * 无人值守腿并进一条 spec —— 各腿的**唯一**合并口:`permissionMode: "default"` + `onAsk: createUnattendedOnAsk(seat)`。`seat` = 本腿的
+ * 活审批席(run-local 递它的 `createLocalApprover`;leader 各腿与续跑重挂无席,不递)—— 席只经这个参数进来,从不从 spec 上读。
+ * 调用点必须在 spec 其余键(含治理折叠)**之后**调它;本口不碰 `toolPolicy`(没有策略层要并:过渡形的写保护拒层已退役)。
  */
-export declare function withUnattendedLeg<S extends Partial<TaskSpec>>(spec: S, leg: UnattendedLeg): S & Required<Pick<TaskSpec, "permissionMode" | "writeFace">>;
+export declare function withUnattendedLeg<S extends Partial<TaskSpec>>(spec: S, seat?: UnattendedSeat): S & UnattendedLegSpec;
 //# sourceMappingURL=unattended-permission-mode.d.ts.map

package/dist/unattended-permission-mode.js

@@ -1,65 +1,12 @@
-import { ASK_CLASSES, PERMISSION_MODES, arbitrateByMode, combinePolicies, compileWriteProtection, foldArbitrationRow } from "@sema-agent/core";
-import { recordFailOpen } from "./observability/fail-open.js";
-export const UNATTENDED_PERMISSION_MODE_DEFAULT = "bypassPermissions";
-export function parseUnattendedPermissionMode(raw) {
-    const trimmed = (raw ?? "").trim();
-    if (trimmed === "")
-        return { value: UNATTENDED_PERMISSION_MODE_DEFAULT, source: "default" };
-    const word = PERMISSION_MODES.find((m) => m === trimmed);
-    if (word === undefined) {
-        throw new Error(`env UNATTENDED_PERMISSION_MODE="${trimmed.slice(0, 120)}" is not a permission mode — use one of: ${PERMISSION_MODES.join(", ")} ` +
-            `(or leave it unset for the default "${UNATTENDED_PERMISSION_MODE_DEFAULT}", which keeps the unattended legs — leader workers / repairs and run-local — acting as they did before server 7.106.0). ` +
-            `The word is matched EXACTLY (surrounding whitespace trimmed, no case folding). ` +
-            `Refusing to boot rather than treating it as unset: that would run those legs under a mode the operator did not choose`);
-    }
-    return { value: word, source: "env" };
+export const UNATTENDED_ANSWERED_CLASSES = new Set(["ordinary"]);
+export function unattendedAnswers(req) {
+    const classes = req.classes;
+    return classes !== undefined && classes.length > 0 && classes.every((c) => UNATTENDED_ANSWERED_CLASSES.has(c));
 }
-export function unattendedPermissionMode(config) {
-    return config.unattendedPermissionMode;
+export function createUnattendedOnAsk(seat) {
+    return (req, signal) => (unattendedAnswers(req) ? true : seat !== undefined ? seat(req, signal) : "unavailable");
 }
-export function buildUnattendedLegSpec(mode) {
-    return { permissionMode: mode, writeFace: "roots" };
-}
-export function createUnattendedWriteProtectionPolicy(mode, runnerSeats) {
-    if (!modeReleases(mode, "write_protection"))
-        return undefined;
-    const dataRoot = runnerSeats.memoryEngineDir;
-    const judge = compileWriteProtection(runnerSeats.writeProtectedPaths, dataRoot !== undefined ? { dataRoot } : undefined);
-    if (judge === undefined)
-        return undefined;
-    const pathDenyRules = judge.rows.map((row) => ({
-        rule: `WriteProtected(${row.name})`,
-        tool: "Edit",
-        pattern: row.name,
-        faces: ["write"],
-        reaches: (absolutePath) => judge.matchPath(absolutePath)?.name === row.name,
-    }));
-    return {
-        check: () => ({ action: "allow" }),
-        pathDenyRules,
-    };
-}
-function modeReleases(mode, askClass) {
-    const classes = new Set([askClass]);
-    return arbitrateByMode(mode, { classes, askClass, row: foldArbitrationRow(classes) }).kind === "released";
-}
-const INTENDED_RELEASES = new Set(["ordinary", "mode"]);
-function releasedProtectiveClasses(mode) {
-    return ASK_CLASSES.filter((c) => !INTENDED_RELEASES.has(c) && c !== "write_protection" && modeReleases(mode, c));
-}
-const RELEASED_PROTECTIVE_ASKS_TAG = "server.unattended-leg.mode-releases-protective-asks";
-export function createUnattendedLeg(mode, runnerSeats) {
-    const debt = releasedProtectiveClasses(mode);
-    if (debt.length > 0)
-        recordFailOpen(RELEASED_PROTECTIVE_ASKS_TAG, `mode=${mode} released=${debt.join(",")}`);
-    return { spec: buildUnattendedLegSpec(mode), writeProtection: createUnattendedWriteProtectionPolicy(mode, runnerSeats) };
-}
-export function withUnattendedLeg(spec, leg) {
-    const wp = leg.writeProtection;
-    return {
-        ...spec,
-        ...leg.spec,
-        ...(wp !== undefined ? { toolPolicy: spec.toolPolicy !== undefined ? combinePolicies(spec.toolPolicy, wp) : wp } : {}),
-    };
+export function withUnattendedLeg(spec, seat) {
+    return { ...spec, permissionMode: "default", onAsk: createUnattendedOnAsk(seat) };
 }
 //# sourceMappingURL=unattended-permission-mode.js.map