@morlay/dsh-sandbox-local 0.0.3 → 0.0.5

package/README.md

@@ -1,63 +1,12 @@
 # @morlay/dsh-sandbox-local
 
-可配置沙箱 bundle：替换官方 `ctx.sandbox`（进程沙箱）与 `ctx.fs`（文件系统围栏），
-在官方语义之上叠加 `access` 规则——`rw <path>` 追加工作区之外的可写根，
-`r- <path>` 只读（读放行、写拒绝），`-- <pattern>` 拒绝访问（读与写都拒）。
+可配置沙箱与审批的**运行时策略面** bundle：替换官方 `ctx.sandbox`（进程沙箱）与 `ctx.fs`（文件系统围栏），在官方
+语义之上叠加 `access` 规则——`rw <path>` 追加工作区之外的可写根，`r- <path>` 只读（读放行、写拒绝），
+`-- <pattern>` 拒绝访问（读与写都拒）；并接管模型看到的运行时快照（`sandbox:policy` / `approval:policy`）。
 
-## 为什么
+## 用法
 
-上游沙箱策略只有两个字段：`mode`（`read-only` / `workspace-write` /
-`danger-full-access`）与 `workspaceRoot`；`workspace-write` 的可写路径是硬编码的
-`[工作区, /tmp, os.tmpdir()]`（`vendor/deepseek-harness/packages/sandbox/sandbox/src/roots.ts:52-55`），
-没有任何追加可写根或拒绝项的配置面。于是「让 agent 能写 `$XDG_CACHE_HOME`，
-但永远不许碰项目里的 `mise.*.toml`」这类诉求只能整块放弃隔离。
-
-本包把「能表达多少就说多少」明确下来：Seatbelt 完整生效，其余平台按方言降级，
-并在加载期告警，而不是静默失效。
-
-## 行为
-
-替换两个服务，规则在两个入口保持同一语义：
-
-| 条目        | `ctx.fs`（read / write / edit / list 工具）  | `ctx.sandbox`（bash 等子进程）                                                                      |
-| ----------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------- |
-| `-- <path>` | 任何模式下读与写都拒（`resolve` 入口即拦截） | Seatbelt：读 + 写；bwrap：退化为只读；Landlock / Windows ACL：无表达（加载期告警）                  |
-| `r- <path>` | 任何模式下读放行、写拒绝（优先于可写根）     | Seatbelt：`(deny file-write* …)`；bwrap：`--ro-bind-try`（只读挂载）；Landlock / Windows：无表达    |
-| `rw <path>` | `workspace-write` 下计入可写根               | Seatbelt：`(allow file-write* (subpath …))`；bwrap：`--bind-try`；Landlock：`--rw`；Windows：无表达 |
-| 无条目      | 与官方 `fs-sandbox` 行为一致                 | 与官方 argv 逐字一致（不做任何改写）                                                                |
-
-- **进程沙箱侧是复用，不是重写**：`ConfigurableSandboxProvider` 继承官方
-  `LocalSandboxProvider`，`confine` 先走 `super.confine()`（runner 探测与选择、
-  Windows ACL 私有 temp、拒绝方言与 runner 失败规则全部保留），再按方言把规则追加到
-  返回的 argv 上。
-- **Seatbelt 规则追加在 profile 末尾**：SBPL 的后置规则覆盖先置规则，因此
-  `(deny file-read* file-write* …)` 能压过官方已写入的 `(allow file-write* (subpath …))`；
-  已用真实 `sandbox-exec` 验证（`src/__tests__/seatbelt.e2e.spec.ts`）。
-- **三类条目在两个入口同步**：上游把 `writableRoots` 同时喂给 Seatbelt profile 与
-  进程内 fs 围栏，只改一侧会造出「bash 能写、write 工具不能写」的裂缝。
-- **命中优先级 `--` > `r-` > `rw` / 平台可写根**：显式拒绝覆盖只读声明，只读声明覆盖
-  更宽的可写授予（例如 `rw {{ env.XDG_DATA_HOME }}` 与 `r- {{ env.XDG_DATA_HOME }}/secrets`
-  同时存在时，后者胜）。
-- **`r-` / `--` 条目在 `danger-full-access` 下仍然生效**（`ctx.fs` 侧）：它们是显式写下的
-  用户规则，不是模式的推论；进程沙箱侧在 `danger-full-access` 下不经过沙箱，本包也无从施加。
-
-## 配置
-
-六个字段都上设置页：`access` 可改（**改完规则当场重算**，不用重挂这一行）；其余五个是**装配事实**，页面上只读
-可见——它们在 `Config` 上标了 `.volatile().disabled()`，所以能看清「这一行现在装配成什么样」而改不了。`volatile`
-会让解析后的值变成**引用**，而官方 `LocalSandboxProvider` / `LocalFileSystem` 在构造时读一次这些字段并做装配期
-校验，所以交给基类的那份配置先由 `upstreamConfigOf` 解包成值（`src/config.ts`）。
-
-| 字段                      | 默认            | 含义                                                                                          |
-| ------------------------- | --------------- | --------------------------------------------------------------------------------------------- |
-| `access`                  | `[]`            | 规则条目：`rw <path>` 可写根 / `r- <path>` 只读 / `-- <pattern>` 拒绝访问；数组或一段多行文本 |
-| `runnerCommand`           | `[]`            | 透传官方 `sandbox-local`：替换 runner argv（配置了它就不能用规则）                            |
-| `runnerFailureSignatures` | `[]`            | 透传官方 `sandbox-local`：自定义 runner 的失败签名                                            |
-| `probeTimeoutMs`          | `5000`          | 透传官方 `sandbox-local`：候选 runner 的探测超时                                              |
-| `cwd`                     | `process.cwd()` | 透传官方 `fs-local`：相对路径的解析基准                                                       |
-| `diffBasisMaxBytes`       | `10485760`      | 透传官方 `fs-local`：overwrite diff 单侧字节上限                                              |
-
-两种写法等价（数组每项一条，或多行文本每行一条；多行文本的空行忽略）：
+`access` 的两种写法等价（数组每项一条，或多行文本每行一条；空行忽略）：
 
 ```yaml
 - id: sandbox-local
@@ -69,87 +18,28 @@
       - "-- **/*.pem"
 ```
 
-```yaml
-- id: sandbox-local
-  config:
-    access: |-
-      rw {{ env.XDG_CACHE_HOME }}
-      r- {{ env.XDG_CONFIG_HOME }}
-      -- mise.*.toml
-      -- **/*.pem
-```
-
-条目语法：
-
-- 每条必须以 `rw ` / `r- ` / `-- ` 开头；缺前缀、或前缀后没有路径，加载即失败（规则
-  不因写法歧义而变形）。
-- 语义：`rw` 允许读写；`r-` 只允许读；`--` 读与写都拒绝。优先级 `--` > `r-` > `rw`。
-- `{{ env.NAME }}` 在加载期按进程环境展开；变量未设置或为空时插件加载失败。
-- 相对路径相对**会话工作区**（不是 `cwd` 配置项）解析。
-- `r-` 与 `--` 条目接受 glob：`*` 与 `?` 不跨 `/`，`**` 跨层级（`**/` 也匹配零层），
-  `[!ab]` 取反；生成的正则同时用于进程内匹配与 SBPL 的 `(regex #"…")`，因此只用两者
-  共有的语法。
-- 字面（无通配）的 `r-` / `--` 条目命中自身**及其全部后代**；`rw` 条目必须是具体路径
-  （可写根没有「通配」语义）。
-
-## 装配
-
-本包自带 `cordis.patch.yml`（禁用官方 `sandbox` / `fs-sandbox` 两行 + 插入自己的一行），
-把本包作为**独立 bundle** 采用的部署直接列进 `dsh.profile.bundles` 即可；行不带 config
-（schema 默认是空规则），patch 内容见该文件。
+- 每条必须以 `rw ` / `r- ` / `-- ` 开头；缺前缀或前缀后没有路径，加载即失败。
+- 命中优先级 `--` > `r-` > `rw` / 平台可写根；`r-` / `--` 在 `danger-full-access` 下仍然生效。
+- `{{ env.NAME }}` 加载期按进程环境展开（未设置或为空即失败）；相对路径相对**会话工作区**解析。
+- `r-` / `--` 接受 glob（`*` / `?` 不跨 `/`，`**` 跨层级，`[!ab]` 取反）；`rw` 必须是具体路径。
 
-**本部署走的就是这条路径**：示例 app 的 `dsh.profile.bundles` 列出了本包（排在
-[`@morlay/dsh-profile`](../../bundles/sandbox-profile/README.md) 之前），因此"禁用官方两行 + 插入本行"由这份
-patch 负责；`access` 规则的值由 `dsh-profile` 按 id 做 config 覆盖——装配与配置各归一处
-（`@morlay/dsh-profile` 已在 `dependencies` 声明本包）。patch 层级的合并顺序与放置理由见
-[设计 host 层部署配置](../../bundles/sandbox-profile/README.md)。
-两种采用方式互斥：同时上线会重复插入同一行。
+字段、规则语义、平台表达能力与装配链路见[设计 可配置沙箱的规则面与平台降级](./.agents/designs/20260929-可配置沙箱的规则面与平台降级.md)。
 
-## 接管 `sandbox:policy`
+## 运行时快照（runtime context）
 
-换了 `ctx.sandbox` / `ctx.fs`，模型看到的那段运行时策略文本也得跟着换：上游
-`@deepseek-ai/dsh-sandbox-policy` 在**全局层**注册 `sandbox:policy`，文本只描述官方策略（只读 /
-workspace-write / 全权 + workspace root），不知道本部署追加的 `rw` / `r-` / `--` 规则。
+模型每步看到的那段动态快照里，本部署替换掉两条（都在 agent 创建时按 agent 作用域注册同名 context，近的作用域遮蔽
+上游在全局层注册的那条；agentless 装配仍读上游那条）：
 
-全局层同名注册会抛错（`NamedEntries.insert`），上游给的官方路径是**按 agent 作用域覆盖**：本包在
-`system-prompt/assemble` 时为每个 agent 在它的 `ctx` 上注册同名 context，装配时近的作用域遮蔽全局那条
-（[`src/policy.ts`](./src/policy.ts)）。文本保留官方三种 mode 的语义（重写中文），并在规则非空时追加
-本部署的额外可写根 / 只读项 / 拒绝项；没有 agent 的装配（agentless 调用）保持官方那条。
+| context           | 上游文本                                                        | 本包的文本                                                                                          |
+| ----------------- | --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| `sandbox:policy`  | 官方三种 mode 的英文描述                                        | 中文简化版 + 本部署的规则行（`额外可写` / `只读（不可写）` / `拒绝（读写都拒）`）                   |
+| `approval:policy` | 英文 `Approval policy: ask…` / `Approval prompts are disabled…` | 按会话有效策略（`ctx.approval` 的 `overrideOf` 优先，否则 `config.policy`，再退 `ask`）选中文那一段 |
 
-**升级注意**：这段文本是照上游 `renderPolicyContext` 的语义重写的——上游改了模式集合或措辞时测试不会自动
-发现，同步上游时要读一眼
-`vendor/deepseek-harness/packages/sandbox/sandbox-policy/src/index.ts`。
+注册时机是 agent 创建（`agent/created` + 覆盖已存在的 agent）：`SystemPrompt.assemble()` 先把 `contexts` merge 好
+再进瀑布，挂在瀑布里注册只能从**第二次**装配起生效（会话里就是"先英文后中文"）。
 
-## 前提
-
-- 官方 `sandbox` 与 `fs-sandbox` 行必须禁用：同一 scope 内重复注册同名服务会 fail loud
-  （`service "sandbox" has been registered at …`），而不是覆盖。
-- 启用规则的层必须同时做三件事——禁用官方两行、插入本包行、写规则：只做后两件时官方
-  实现仍在提供 `ctx.sandbox` / `ctx.fs`，规则没有生效点，沙箱静默退回「只有工作区 +
-  `/tmp` 可写」（命令照常跑，没有报错）。装配守卫见 `@morlay/dsh-profile` 的
-  `patch.spec.ts`。
-- 规则与 `runnerCommand` 互斥：自定义 runner 的 argv 方言无法识别，此时配了规则会在
-  `confine` 抛错（宁可失败也不让规则静默失效）。
-- `read-only` 模式不追加 `rw` 条目（显式选定的只读边界不因额外可写根放松），但 `r-`
-  与 `--` 条目仍然生效。
-
-## 已知限制
-
-- **Linux / Windows 的子进程侧降级**：bwrap 把 `r-` 与 `--` 都表达成只读挂载
-  （`--ro-bind-try`，所以 `--` 在 bwrap 上退化为「只拒写入」），Landlock 无法表达任何
-  子路径规则，Windows ACL runner 的 argv 没有承载额外 grant 的入口（`rw` 同样不生效）。
-  加载期对每种降级都打 warn，`ctx.fs` 侧（read / write / edit 工具）在所有平台保持完整
-  语义。
-- **bwrap 参数顺序未实测**：`--bind-try` / `--ro-bind-try` 的「后挂载覆盖先挂载」与
-  `-try` 缺路径语义来自 bwrap 文档而非本仓库的测试证据（本机为 macOS）。
-- **`r-` / `--` 条目不隐藏目录项**：`ls` 仍能看到被保护文件的名字，被拦的是内容读取
-  （仅 `--`）与写入。
-- **`ctx.fs` 侧是策略检查，不是内核边界**：与它替换掉的官方 `fs-sandbox` 同一威胁模型
-  （受信代码 + 模型可控路径）；内核级隔离仍是 `ctx.sandbox` 的职责。
-- **Windows 额外授权未实现**：官方 `AclWriteGrant` 可以做预授权，但没有把 `AclWriteGrant`
-  接进 `confine` 的现成路径，本版只告警。
-
-## 验证
+## 装配
 
-构建、测试与 lint 走根 `justfile`（含 `seatbelt.e2e.spec.ts`——非 macOS 或被更外层 Seatbelt
-拦住时自动跳过）；本包的接缝与判据见 [`.agents/standards/`](./.agents/standards/)。
+行数据在本包的 `./rows` 出口（禁官方 `sandbox` / `fs-sandbox` 两行 + 插入本包一行）；采用它的部署 bundle 是
+[`@morlay/sandbox-profile`](../../bundles/sandbox-profile/README.md)——它渲染出这份 patch，并在同一份 patch 里按 id
+给 `sandbox-local` 的 `access` 值。部署侧只需把那个 bundle 列进 `dsh.profile.bundles`。

package/dist/client.cjs

@@ -5,29 +5,20 @@ window.__ModuleLoader__.load({
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 		//#region src/client/locales.ts
-		/** 本包在配置页上的字段文案（命名空间 `settings.sandbox-local`）。 */
 		const zh = {
 			access: "额外可写根与拒绝项",
-			accessHint: "一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；支持 `~`、环境变量与 glob。改完当场生效。"
+			accessHint: "一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；支持环境变量模板与 glob（`rw` 项必须是具体路径）。改完当场生效。"
 		};
 		const en = {
 			access: "Extra writable roots and refusals",
-			accessHint: "One entry per line: `rw:<path>` grants a writable root, `r-:<path>` makes it read-only, `--:<path>` denies it; `~`, env templates, and globs work. Edits apply immediately."
+			accessHint: "One entry per line: `rw <path>` grants a writable root, `r- <path>` makes it read-only, `-- <path>` denies it; env templates and globs work (`rw` entries must name a concrete path). Edits apply immediately."
 		};
 		//#endregion
 		//#region src/client/index.ts
-		/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
 		const SANDBOX_NS = "sandbox-local";
-		/** 这一行里需要中文文案的字段。 */
 		const FIELDS = ["access"];
-		/** 本页字典的命名空间。 */
 		const NS = "settings.sandbox-local";
-		/** 需要的服务：槽位（字段槽）与字典。 */
 		const inject = ["locale"];
-		/**
-		* 给 `access` 补文案。
-		* @param ctx - 浏览器插件上下文。
-		*/
 		function apply(ctx) {
 			const t = ctx.locale.bind(NS);
 			ctx.effect(() => ctx.locale.register(NS, {

package/dist/client.d.cts

@@ -1,29 +1,20 @@
 import { Context } from "@deepseek-ai/cordis";
 //#region src/client/locales.d.ts
-/** 本包在配置页上的字段文案（命名空间 `settings.sandbox-local`）。 */
 declare const zh: {
   readonly access: "额外可写根与拒绝项";
-  readonly accessHint: "一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；支持 `~`、环境变量与 glob。改完当场生效。";
+  readonly accessHint: "一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；支持环境变量模板与 glob（`rw` 项必须是具体路径）。改完当场生效。";
 };
 type SandboxFieldLocaleKey = keyof typeof zh;
 //#endregion
 //#region src/client/index.d.ts
-/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
 declare const SANDBOX_NS = "sandbox-local";
-/** 本页字典的命名空间。 */
 declare const NS = "settings.sandbox-local";
 declare module "@deepseek-ai/dsh-client-ui-slots" {
   interface LocaleNamespaceMap {
-    /** 设置页里这一行的字段文案。 */
     "settings.sandbox-local": SandboxFieldLocaleKey;
   }
 }
-/** 需要的服务：槽位（字段槽）与字典。 */
 declare const inject: string[];
-/**
- * 给 `access` 补文案。
- * @param ctx - 浏览器插件上下文。
- */
 declare function apply(ctx: Context): void;
 //#endregion
 export { NS, SANDBOX_NS, apply, inject };

package/dist/client.d.mts

@@ -1,29 +1,20 @@
 import { Context } from "@deepseek-ai/cordis";
 //#region src/client/locales.d.ts
-/** 本包在配置页上的字段文案（命名空间 `settings.sandbox-local`）。 */
 declare const zh: {
   readonly access: "额外可写根与拒绝项";
-  readonly accessHint: "一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；支持 `~`、环境变量与 glob。改完当场生效。";
+  readonly accessHint: "一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；支持环境变量模板与 glob（`rw` 项必须是具体路径）。改完当场生效。";
 };
 type SandboxFieldLocaleKey = keyof typeof zh;
 //#endregion
 //#region src/client/index.d.ts
-/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
 declare const SANDBOX_NS = "sandbox-local";
-/** 本页字典的命名空间。 */
 declare const NS = "settings.sandbox-local";
 declare module "@deepseek-ai/dsh-client-ui-slots" {
   interface LocaleNamespaceMap {
-    /** 设置页里这一行的字段文案。 */
     "settings.sandbox-local": SandboxFieldLocaleKey;
   }
 }
-/** 需要的服务：槽位（字段槽）与字典。 */
 declare const inject: string[];
-/**
- * 给 `access` 补文案。
- * @param ctx - 浏览器插件上下文。
- */
 declare function apply(ctx: Context): void;
 //#endregion
 export { NS, SANDBOX_NS, apply, inject };

package/dist/index.d.cts

@@ -7,13 +7,6 @@ import { Config as Config$2 } from "@deepseek-ai/dsh-sandbox-local";
 interface Config extends Config$2, Config$1 {
   access?: string | string[];
 }
-/**
- * schema 解析之后的形状：`access` 是 **volatile 稳定引用**（页面可改的那一项），读它要过 `.get()`。
- *
- * 其余字段也是 volatile，但页面把它们画成**只读**（schema 上的 `disabled()`）：它们是装配事实——runner 命令、
- * 进程 cwd、上游基类读一次的超时与差额上限——放在页面上是为了看清「这一行现在装配成什么样」，改它们要重挂
- * 这一行。所以给上游基类的那份配置是**解包后的值**（{@link upstreamConfigOf}）：基类读的是值，不是引用。
- */
 interface ResolvedConfig extends Omit<Config, "access" | "runnerCommand" | "runnerFailureSignatures" | "probeTimeoutMs" | "cwd" | "diffBasisMaxBytes"> {
   readonly access: Volatile<string | string[]>;
   readonly runnerCommand: Volatile<readonly string[]>;

package/dist/index.d.mts

@@ -7,13 +7,6 @@ import { Volatile } from "@deepseek-ai/cosmokit";
 interface Config extends Config$2, Config$1 {
   access?: string | string[];
 }
-/**
- * schema 解析之后的形状：`access` 是 **volatile 稳定引用**（页面可改的那一项），读它要过 `.get()`。
- *
- * 其余字段也是 volatile，但页面把它们画成**只读**（schema 上的 `disabled()`）：它们是装配事实——runner 命令、
- * 进程 cwd、上游基类读一次的超时与差额上限——放在页面上是为了看清「这一行现在装配成什么样」，改它们要重挂
- * 这一行。所以给上游基类的那份配置是**解包后的值**（{@link upstreamConfigOf}）：基类读的是值，不是引用。
- */
 interface ResolvedConfig extends Omit<Config, "access" | "runnerCommand" | "runnerFailureSignatures" | "probeTimeoutMs" | "cwd" | "diffBasisMaxBytes"> {
   readonly access: Volatile<string | string[]>;
   readonly runnerCommand: Volatile<readonly string[]>;

package/dist/index.mjs

@@ -6,15 +6,11 @@ import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { canonicalPath, writableRoots } from "@deepseek-ai/dsh-sandbox";
 import { LocalSandboxProvider } from "@deepseek-ai/dsh-sandbox-local";
 //#region src/config.ts
-/**
-* 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
-* （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
-*/
 const localized = (text) => text;
 const Config = z.object({
 	access: z.union([z.array(z.string()), z.string()]).default([]).description(localized({
-		zh: "额外可写根与拒绝项，一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；支持 `~`、环境变量与 glob。改它当场生效（沙箱规则每次按当前值重算），不用重挂这一行。",
-		en: "Extra writable roots and refusals, one entry per line: `rw:<path>` grants a writable root, `r-:<path>` makes it read-only, `--:<path>` denies it; `~`, env templates, and globs are supported. Edits take effect on the next rule compile without remounting the row."
+		zh: "额外可写根与拒绝项，一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；路径可用环境变量模板与 glob（`rw` 项必须是具体路径）。改它当场生效（沙箱规则每次按当前值重算），不用重挂这一行。",
+		en: "Extra writable roots and refusals, one entry per line: `rw <path>` grants a writable root, `r- <path>` makes it read-only, `-- <path>` denies it; env templates and globs work (`rw` entries must name a concrete path). Edits take effect on the next rule compile without remounting the row."
 	})).volatile(),
 	runnerCommand: z.array(z.string()).default([]).disabled().description(localized({
 		zh: "沙箱 runner 的启动命令；空数组表示按平台自带的链去选。改它要重挂这一行。",
@@ -37,14 +33,6 @@ const Config = z.object({
 		en: "Per-side byte cap for overwrite diffs (10 MiB by default)."
 	})).volatile()
 });
-/**
-* 交给上游基类的那份配置：装配事实取当前值。
-*
-* 上游 `LocalSandboxProvider` / `LocalFileSystem` 在构造时读一次这些字段并做装配期校验，所以它们要的是值；
-* 设置页改它们走的是「写盘 → Loader 重挂这一行 → 重新解析」这条路。
-* @param config - 本行解析后的配置。
-* @returns 上游两个基类认的普通配置对象。
-*/
 function upstreamConfigOf(config) {
 	return {
 		runnerCommand: [...config.runnerCommand.get()],
@@ -248,7 +236,6 @@ var ConfigurableFileSystem = class extends LocalFileSystem {
 		this.defaultMode = ctx.sandboxPolicy.defaultMode;
 		this.access = config.access;
 	}
-	/** 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。 */
 	get source() {
 		return ruleSourceOf(this.access.get(), process.env);
 	}
@@ -287,7 +274,6 @@ var ConfigurableFileSystem = class extends LocalFileSystem {
 		for (const root of writableRootsWith(rules, policy)) if (await isPathUnder(fresh.targetKey, root)) return fresh;
 		throw new FsError(`cannot write "${target.displayPath}": file access denied under workspace-write mode`, "FS_SANDBOX_DENIED");
 	}
-	/** 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。 */
 	rulesFor(workspaceRoot) {
 		const access = this.access.get();
 		const key = `${workspaceRoot}\u0000${JSON.stringify(access ?? null)}`;
@@ -300,74 +286,69 @@ var ConfigurableFileSystem = class extends LocalFileSystem {
 };
 //#endregion
 //#region src/policy.ts
-/**
-* 接管 `sandbox:policy` 那条运行时上下文。
-*
-* 上游 [`@deepseek-ai/dsh-sandbox-policy`] 在**全局层**注册它，文本只描述官方策略（只读 /
-* workspace-write / 全权 + workspace root）——它不知道本部署追加的 `rw` / `r-` / `--` 规则，
-* 模型因此拿不到"哪些额外路径可写、哪些被拒"。本包替换了 `ctx.sandbox` / `ctx.fs`，这条文本也得跟着换。
-*
-* 全局层同名注册会抛错（`NamedEntries.insert`），上游给的官方路径是**按 agent 作用域覆盖**：
-* `systemPrompt.context()` 在 scope 上注册同名项，装配时近的作用域遮蔽全局那条
-* （`ScopedLayers.merge`）。所以这里在每个 agent 的 `ctx` 上注册一次。
-*/
-/** 上游注册的运行时上下文名：同名才叫接管。 */
 const SANDBOX_POLICY_CONTEXT = "sandbox:policy";
-/**
-* 策略文本：官方三种 mode 的语义（重写中文，与其它注入文案一致）+ 本部署追加的规则。
-* @param policy - 该会话解析出来的策略（模式与 workspace root）。
-* @param rules - 本部署解析后的访问规则（已展开环境变量模板）。
-* @returns 给模型看的一段文本。
-*/
+const APPROVAL_POLICY_CONTEXT = "approval:policy";
 function renderPolicyContext(policy, rules) {
 	const base = (() => {
 		switch (policy.mode) {
-			case "read-only": return "当前 DSH 文件策略：只读。任何可用的操作都不能修改 standing 模式下的文件。别仅凭这条策略就拒绝必需的修改：照常尝试可用工具，并遵循它给出的拒绝与升级指引。";
-			case "workspace-write": return `当前 DSH 文件策略：workspace-write（工作区可写）。任何可用的操作都可修改会话工作区 ${JSON.stringify(policy.workspaceRoot)} 下的文件；部分平台临时目录同样可写。`;
-			case "danger-full-access": return "当前 DSH 文件策略：danger-full-access（全权）。DSH 文件沙箱不再限制可用操作对文件的修改。";
+			case "read-only": return "文件策略：只读——不能修改任何文件。别因此拒绝必需的修改：照常尝试工具，按它的拒绝与升级指引行动。";
+			case "workspace-write": return `文件策略：workspace-write——可改会话工作区 ${JSON.stringify(policy.workspaceRoot)} 下的文件，部分平台临时目录同样可写。`;
+			case "danger-full-access": return "文件策略：全权——文件改动不再受限。";
 		}
 	})();
 	const extras = [];
-	if (rules.allowWrite.length > 0) extras.push(`本部署额外授权的可写根：${rules.allowWrite.join("、")}。`);
-	if (rules.readOnly.length > 0) extras.push(`只读（一律不可写）：${rules.readOnly.join("、")}。`);
-	if (rules.deny.length > 0) extras.push(`拒绝访问（读与写都拒）：${rules.deny.join("、")}。`);
+	if (rules.allowWrite.length > 0) extras.push(`额外可写：${rules.allowWrite.join("、")}。`);
+	if (rules.readOnly.length > 0) extras.push(`只读（不可写）：${rules.readOnly.join("、")}。`);
+	if (rules.deny.length > 0) extras.push(`拒绝（读写都拒）：${rules.deny.join("、")}。`);
 	return extras.length === 0 ? base : `${base} ${extras.join("")}`;
 }
-/**
-* 在给定作用域注册同名策略文本（agent 的 `ctx`，或 preset 子树）。
-* @param scope - 拥有这次注册的 ctx；它的 scope 因此遮蔽全局那条。
-* @param rules - 本部署的访问规则。
-* @param resolve - 按会话解析策略（生产传 `ctx.sandboxPolicy.resolve`）。
-*/
+const APPROVAL_ASK_TEXT = "审批策略：ask——需要审批的操作会询问用户；没有可用的应答者时直接失败。";
+const APPROVAL_NEVER_TEXT = "审批提示已禁用：需要审批的操作一律自动拒绝——不要请求沙箱升级（不要设 sandbox_permissions）。";
+function renderApprovalContext(policy) {
+	return policy === "never" ? APPROVAL_NEVER_TEXT : APPROVAL_ASK_TEXT;
+}
+function effectiveApprovalPolicy(approval, session) {
+	return approval.overrideOf(session) ?? approval.config.policy ?? "ask";
+}
 function registerPolicyContext(scope, rules, resolve) {
-	scope.inject(["systemPrompt"], (scoped) => {
-		scoped.systemPrompt.context({
-			name: SANDBOX_POLICY_CONTEXT,
-			order: scoped.systemPrompt.getContextOrder("SANDBOX_POLICY"),
-			text: (context) => {
-				const session = context.agent?.session;
-				return session === void 0 ? "" : renderPolicyContext(resolve(session), rules);
-			}
-		});
+	const prompt = scope.get("systemPrompt");
+	if (prompt === void 0) return;
+	prompt.context({
+		name: SANDBOX_POLICY_CONTEXT,
+		order: prompt.getContextOrder("SANDBOX_POLICY"),
+		text: (context) => {
+			const session = context.agent?.session;
+			return session === void 0 ? "" : renderPolicyContext(resolve(session), rules);
+		}
 	});
 }
-/**
-* 每个 agent 注册一次（装配期做，与 scope 出口同一时机与理由：创建期服务可用性还在变）。
-* @param ctx - 本插件的 ctx（host 平面）。
-* @param rules - 本部署的访问规则。
-* @param resolve - 按会话解析策略。
-*/
-function installPolicyContext(ctx, rules, resolve) {
-	const registered = /* @__PURE__ */ new WeakSet();
-	ctx.on("system-prompt/assemble", (_assembly, context, next) => {
-		const agent = context.agent;
-		if (agent !== void 0 && !registered.has(agent)) {
-			registered.add(agent);
-			registerPolicyContext(agent.ctx, rules, resolve);
+function registerApprovalContext(scope) {
+	const prompt = scope.get("systemPrompt");
+	if (prompt === void 0) return;
+	prompt.context({
+		name: APPROVAL_POLICY_CONTEXT,
+		order: prompt.getContextOrder("APPROVAL_POLICY"),
+		text: (context) => {
+			const agent = context.agent;
+			if (agent === void 0) return "";
+			const approval = agent.ctx.get("approval");
+			return approval === void 0 ? "" : renderApprovalContext(effectiveApprovalPolicy(approval, agent.session));
 		}
-		return next();
 	});
 }
+function installRuntimeContexts(ctx, rules, resolve) {
+	const installed = /* @__PURE__ */ new WeakSet();
+	const install = (agent) => {
+		if (installed.has(agent)) return;
+		installed.add(agent);
+		registerPolicyContext(agent.ctx, rules, resolve);
+		registerApprovalContext(agent.ctx);
+	};
+	ctx.on("agent/created", ({ agent }) => {
+		install(agent);
+	});
+	for (const agent of ctx.get("agents")?.list() ?? []) install(agent);
+}
 //#endregion
 //#region src/dialects.ts
 const SEPARATOR = "--";
@@ -448,7 +429,6 @@ var ConfigurableSandboxProvider = class extends LocalSandboxProvider {
 		super(ctx, upstreamConfigOf(config));
 		this.access = config.access;
 	}
-	/** 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。 */
 	get source() {
 		return ruleSourceOf(this.access.get(), process.env);
 	}
@@ -462,7 +442,6 @@ var ConfigurableSandboxProvider = class extends LocalSandboxProvider {
 			argv: extendConfinedArgv(confined.argv, effective)
 		};
 	}
-	/** 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。 */
 	rulesFor(workspaceRoot) {
 		const access = this.access.get();
 		const key = `${workspaceRoot}\u0000${JSON.stringify(access ?? null)}`;
@@ -491,7 +470,7 @@ function apply(ctx, config) {
 	warnAboutDegradedRules(ctx, rules);
 	new ConfigurableSandboxProvider(ctx, config);
 	new ConfigurableFileSystem(ctx, config);
-	installPolicyContext(ctx, rules, (session) => ctx.sandboxPolicy.resolve({ session }));
+	installRuntimeContexts(ctx, rules, (session) => ctx.sandboxPolicy.resolve({ session }));
 }
 //#endregion
 export { Config, apply, inject, name };

package/dist/rows.d.cts

@@ -1,23 +1,14 @@
 //#region src/rows.d.ts
-/**
- * 本包作为能力包发布的**装配数据**：行本身在部署那一层装（`packages/bundles/sandbox-profile` 引用它渲染 patch）。
- *
- * 官方 `sandbox`（进程沙箱）与 `fs-sandbox`（文件围栏）两个服务只能有一份实现，所以那两行禁掉、换成
- * 本包那一行；`config.access` 的值由部署那层给（schema 默认是空规则）。
- */
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
 interface PatchRow {
   readonly id?: string;
   readonly disabled?: boolean;
   readonly insert?: readonly RowEntry[];
 }
-/** `insert` 里的一个条目。 */
 interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
-/** 沙箱替换的装配行：禁官方两行 + 插本包一行（值由部署那层按 id 覆盖）。 */
 declare function sandboxRows(): readonly PatchRow[];
 //#endregion
 export { PatchRow, RowEntry, sandboxRows };

package/dist/rows.d.mts

@@ -1,23 +1,14 @@
 //#region src/rows.d.ts
-/**
- * 本包作为能力包发布的**装配数据**：行本身在部署那一层装（`packages/bundles/sandbox-profile` 引用它渲染 patch）。
- *
- * 官方 `sandbox`（进程沙箱）与 `fs-sandbox`（文件围栏）两个服务只能有一份实现，所以那两行禁掉、换成
- * 本包那一行；`config.access` 的值由部署那层给（schema 默认是空规则）。
- */
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
 interface PatchRow {
   readonly id?: string;
   readonly disabled?: boolean;
   readonly insert?: readonly RowEntry[];
 }
-/** `insert` 里的一个条目。 */
 interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
-/** 沙箱替换的装配行：禁官方两行 + 插本包一行（值由部署那层按 id 覆盖）。 */
 declare function sandboxRows(): readonly PatchRow[];
 //#endregion
 export { PatchRow, RowEntry, sandboxRows };

package/dist/rows.mjs

@@ -1,5 +1,4 @@
 //#region src/rows.ts
-/** 沙箱替换的装配行：禁官方两行 + 插本包一行（值由部署那层按 id 覆盖）。 */
 function sandboxRows() {
 	return [
 		{

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
-    "title": "Configurable Sandbox",
-    "description": "Replaces the shipped process sandbox and filesystem fence with implementations that add extra writable roots, read-only roots and access denials."
+    "title": "Configurable Sandbox & Approval",
+    "description": "Replaces the shipped process sandbox and filesystem fence with implementations that add extra writable roots, read-only roots and access denials, and owns the runtime-context snapshot (sandbox:policy / approval:policy) wording."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
-    "title": "可配置沙箱",
-    "description": "替换官方的进程沙箱与文件系统围栏：在官方语义之上追加额外可写根、只读根与拒绝项。"
+    "title": "可配置沙箱与审批",
+    "description": "替换官方的进程沙箱与文件系统围栏：在官方语义之上追加额外可写根、只读根与拒绝项，并接管运行时快照（sandbox:policy / approval:policy）的措辞。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morlay/dsh-sandbox-local",
-  "version": "0.0.3",
-  "description": "Configurable sandbox bundle: replaces the shipped process-sandbox provider and filesystem fence with implementations that add extra writable roots, read-only roots and access denials on top of the upstream semantics.",
+  "version": "0.0.5",
+  "description": "Configurable sandbox bundle: replaces the shipped process-sandbox provider and filesystem fence with implementations that add extra writable roots, read-only roots and access denials on top of the upstream semantics, and owns the runtime-context snapshot (`sandbox:policy` / `approval:policy`) with the deployment's own wording.",
   "keywords": [
     "dsh",
     "dsh-bundle",
@@ -34,36 +34,38 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cosmokit": "1.8.5",
-    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-locale": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs-local": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs-sandbox": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-local": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-scope": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
-    "@morlay/dsh-client-ui-primitives": "0.0.2"
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs-local": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs-sandbox": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox-local": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-scope": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.1",
+    "@morlay/dsh-client-ui-primitives": "0.0.5"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/cosmokit": "^1.8.5",
-    "@deepseek-ai/dsh-agent": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs-local": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs-sandbox": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-local": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs-local": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs-sandbox": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox-local": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-sandbox-policy": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-session": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.1",
     "@deepseek-ai/schemastery": "^3.18.4",
-    "@morlay/dsh-client-ui-primitives": "0.0.2"
+    "@morlay/dsh-client-ui-primitives": "0.0.5"
   },
   "dsh": {
     "client": {

package/src/client/index.ts

@@ -1,36 +1,31 @@
-/**
- * client 半：这一行的配置页由通用 schema 表单按 volatile 字段生成（`access` 是页面可改的那一项，改完规则
- * 当场重算），本包只把键名换成中文标签与说明。
- */
+// client 半：这一行的配置页由通用 schema 表单按 volatile 字段生成（`access` 是页面可改的那一项，改完规则
+// 当场重算），本包只把键名换成中文标签与说明。
 
 import type { Context } from "@deepseek-ai/cordis";
 import type {} from "@deepseek-ai/dsh-client-locale/client";
 import type {} from "@deepseek-ai/dsh-client-ui-slots";
 import { en, zh, type SandboxFieldLocaleKey } from "./locales.ts";
 
-/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
+// 本包 host 行 id：行配置页读的就是这个命名空间。
 export const SANDBOX_NS = "sandbox-local";
 
-/** 这一行里需要中文文案的字段。 */
+// 这一行里需要中文文案的字段。
 const FIELDS = ["access"] as const;
 
-/** 本页字典的命名空间。 */
+// 本页字典的命名空间。
 export const NS = "settings.sandbox-local";
 
 declare module "@deepseek-ai/dsh-client-ui-slots" {
   interface LocaleNamespaceMap {
-    /** 设置页里这一行的字段文案。 */
+    // 设置页里这一行的字段文案。
     "settings.sandbox-local": SandboxFieldLocaleKey;
   }
 }
 
-/** 需要的服务：槽位（字段槽）与字典。 */
+// 需要的服务：槽位（字段槽）与字典。
 export const inject = ["locale"];
 
-/**
- * 给 `access` 补文案。
- * @param ctx - 浏览器插件上下文。
- */
+// 给 `access` 补文案。
 export function apply(ctx: Context): void {
   const t = ctx.locale.bind(NS);
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), "sandbox-local: field locale");

package/src/client/locales.ts

@@ -1,15 +1,15 @@
-/** 本包在配置页上的字段文案（命名空间 `settings.sandbox-local`）。 */
+// 本包在配置页上的字段文案（命名空间 `settings.sandbox-local`）。
 
 export const zh = {
   access: "额外可写根与拒绝项",
   accessHint:
-    "一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；支持 `~`、环境变量与 glob。改完当场生效。",
+    "一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；支持环境变量模板与 glob（`rw` 项必须是具体路径）。改完当场生效。",
 } as const;
 
 export const en: Record<keyof typeof zh, string> = {
   access: "Extra writable roots and refusals",
   accessHint:
-    "One entry per line: `rw:<path>` grants a writable root, `r-:<path>` makes it read-only, `--:<path>` denies it; `~`, env templates, and globs work. Edits apply immediately.",
+    "One entry per line: `rw <path>` grants a writable root, `r- <path>` makes it read-only, `-- <path>` denies it; env templates and globs work (`rw` entries must name a concrete path). Edits apply immediately.",
 };
 
 export type SandboxFieldLocaleKey = keyof typeof zh;

package/src/config.ts

@@ -7,13 +7,9 @@ export interface Config extends UpstreamSandboxConfig, UpstreamFsConfig {
   access?: string | string[];
 }
 
-/**
- * schema 解析之后的形状：`access` 是 **volatile 稳定引用**（页面可改的那一项），读它要过 `.get()`。
- *
- * 其余字段也是 volatile，但页面把它们画成**只读**（schema 上的 `disabled()`）：它们是装配事实——runner 命令、
- * 进程 cwd、上游基类读一次的超时与差额上限——放在页面上是为了看清「这一行现在装配成什么样」，改它们要重挂
- * 这一行。所以给上游基类的那份配置是**解包后的值**（{@link upstreamConfigOf}）：基类读的是值，不是引用。
- */
+// schema 解析之后的形状：`access` 是 volatile 稳定引用（读它要过 `.get()`）；其余字段也是 volatile，
+// 但 schema 上标了 `disabled()`，页面把它们画成**只读**的装配事实。所以给上游基类的那份配置是
+// **解包后的值**（`upstreamConfigOf`）——基类读的是值，不是引用。
 export interface ResolvedConfig extends Omit<
   Config,
   | "access"
@@ -31,10 +27,8 @@ export interface ResolvedConfig extends Omit<
   readonly diffBasisMaxBytes: Volatile<number>;
 }
 
-/**
- * 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
- * （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
- */
+// 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
+// （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
 const localized = (text: { zh: string; en: string }): string => text as unknown as string;
 
 export const Config: z<Config, ResolvedConfig> = z.object({
@@ -44,11 +38,12 @@ export const Config: z<Config, ResolvedConfig> = z.object({
     .description(
       localized({
         zh:
-          "额外可写根与拒绝项，一行一条：`rw:<路径>` 追加可写根，`r-:<路径>` 只读，`--:<路径>` 拒绝；" +
-          "支持 `~`、环境变量与 glob。改它当场生效（沙箱规则每次按当前值重算），不用重挂这一行。",
+          "额外可写根与拒绝项，一行一条：`rw <路径>` 追加可写根，`r- <路径>` 只读，`-- <路径>` 拒绝；" +
+          "路径可用环境变量模板与 glob（`rw` 项必须是具体路径）。改它当场生效（沙箱规则每次按当前值重算），不用重挂这一行。",
         en:
-          "Extra writable roots and refusals, one entry per line: `rw:<path>` grants a writable root, " +
-          "`r-:<path>` makes it read-only, `--:<path>` denies it; `~`, env templates, and globs are supported. " +
+          "Extra writable roots and refusals, one entry per line: `rw <path>` grants a writable root, " +
+          "`r- <path>` makes it read-only, `-- <path>` denies it; env templates and globs work " +
+          "(`rw` entries must name a concrete path). " +
           "Edits take effect on the next rule compile without remounting the row.",
       }),
     )
@@ -110,14 +105,8 @@ export const Config: z<Config, ResolvedConfig> = z.object({
     .volatile(),
 });
 
-/**
- * 交给上游基类的那份配置：装配事实取当前值。
- *
- * 上游 `LocalSandboxProvider` / `LocalFileSystem` 在构造时读一次这些字段并做装配期校验，所以它们要的是值；
- * 设置页改它们走的是「写盘 → Loader 重挂这一行 → 重新解析」这条路。
- * @param config - 本行解析后的配置。
- * @returns 上游两个基类认的普通配置对象。
- */
+// 交给上游基类的配置：装配事实取当前值——基类在构造时读一次这些字段并做装配期校验，所以它们要的是值；
+// 设置页改它们走「写盘 → Loader 重挂这一行 → 重新解析」。返回上游两个基类认的普通配置对象。
 export function upstreamConfigOf(config: ResolvedConfig): UpstreamSandboxConfig & UpstreamFsConfig {
   return {
     runnerCommand: [...config.runnerCommand.get()],

package/src/fs.ts

@@ -37,7 +37,7 @@ export class ConfigurableFileSystem extends LocalFileSystem {
     this.access = config.access;
   }
 
-  /** 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。 */
+  // 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。
   private get source(): RuleSource {
     return ruleSourceOf(this.access.get(), process.env);
   }
@@ -134,7 +134,7 @@ export class ConfigurableFileSystem extends LocalFileSystem {
     );
   }
 
-  /** 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。 */
+  // 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。
   private rulesFor(workspaceRoot: string): CompiledRules {
     const access = this.access.get();
     const key = `${workspaceRoot}\u0000${JSON.stringify(access ?? null)}`;

package/src/index.ts

@@ -1,7 +1,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { ResolvedConfig } from "./config.ts";
 import { ConfigurableFileSystem } from "./fs.ts";
-import { installPolicyContext } from "./policy.ts";
+import { installRuntimeContexts } from "./policy.ts";
 import { ruleSourceOf, type RuleSource } from "./rules.ts";
 import { ConfigurableSandboxProvider } from "./sandbox.ts";
 
@@ -39,6 +39,7 @@ export function apply(ctx: Context, config: ResolvedConfig): void {
   warnAboutDegradedRules(ctx, rules);
   new ConfigurableSandboxProvider(ctx, config);
   new ConfigurableFileSystem(ctx, config);
-  // 替换了 ctx.sandbox / ctx.fs，`sandbox:policy` 那段运行时文本也要跟着换（见 policy.ts）。
-  installPolicyContext(ctx, rules, (session) => ctx.sandboxPolicy.resolve({ session }));
+  // 替换了 ctx.sandbox / ctx.fs，`sandbox:policy` 那段运行时文本也要跟着换，`approval:policy` 换成中文
+  // （见 policy.ts）。
+  installRuntimeContexts(ctx, rules, (session) => ctx.sandboxPolicy.resolve({ session }));
 }

package/src/policy.ts

@@ -3,96 +3,126 @@ import type { Context } from "@deepseek-ai/cordis";
 import type { SandboxExecutionPolicy } from "@deepseek-ai/dsh-sandbox";
 import type { Session } from "@deepseek-ai/dsh-session";
 import type {} from "@deepseek-ai/dsh-system-prompt";
+// Type-only：`approval:policy` 的取值面（`ApprovalPolicy` 与 `ApprovalService.overrideOf`）。
+import type { ApprovalPolicy } from "@deepseek-ai/dsh-user-approval";
 import type { RuleSource } from "./rules.ts";
 
-/**
- * 接管 `sandbox:policy` 那条运行时上下文。
- *
- * 上游 [`@deepseek-ai/dsh-sandbox-policy`] 在**全局层**注册它，文本只描述官方策略（只读 /
- * workspace-write / 全权 + workspace root）——它不知道本部署追加的 `rw` / `r-` / `--` 规则，
- * 模型因此拿不到"哪些额外路径可写、哪些被拒"。本包替换了 `ctx.sandbox` / `ctx.fs`，这条文本也得跟着换。
- *
- * 全局层同名注册会抛错（`NamedEntries.insert`），上游给的官方路径是**按 agent 作用域覆盖**：
- * `systemPrompt.context()` 在 scope 上注册同名项，装配时近的作用域遮蔽全局那条
- * （`ScopedLayers.merge`）。所以这里在每个 agent 的 `ctx` 上注册一次。
- */
+// 接管两条运行时上下文：上游在**全局层**注册的 `sandbox:policy`（`@deepseek-ai/dsh-sandbox-policy`）与
+// `approval:policy`（`@deepseek-ai/dsh-user-approval`）。本部署换了沙箱实现、也要自己的中文措辞，两条都在
+// agent 自己的 `ctx` 上注册**同名** context——装配时近的作用域遮蔽全局那条（`ScopedLayers.merge`），全局那条
+// 对 agentless 装配仍然生效。全局层同名注册会抛错（`NamedEntries.insert`），作用域遮蔽是上游给的官方路径。
+//
+// 时机：注册必须早于该 agent 的**第一次**装配。`SystemPrompt.assemble()` 先把 `contexts` merge 好、再进
+// `system-prompt/assemble` 瀑布，所以挂在瀑布里注册只能从第二次装配起生效（会话里表现为"先英文后中文"）；
+// `agent/created` 是创建期最后一步、早于第一次装配，在那里注册即可（persona 用的是同一手法）。
 
-/** 上游注册的运行时上下文名：同名才叫接管。 */
+// 上游注册的运行时上下文名：同名才叫接管。
 export const SANDBOX_POLICY_CONTEXT = "sandbox:policy";
+export const APPROVAL_POLICY_CONTEXT = "approval:policy";
 
-/**
- * 策略文本：官方三种 mode 的语义（重写中文，与其它注入文案一致）+ 本部署追加的规则。
- * @param policy - 该会话解析出来的策略（模式与 workspace root）。
- * @param rules - 本部署解析后的访问规则（已展开环境变量模板）。
- * @returns 给模型看的一段文本。
- */
+// 策略文本：官方三种 mode 的中文语义 + 本部署追加的规则；返回给模型看的一段文本。
 export function renderPolicyContext(policy: SandboxExecutionPolicy, rules: RuleSource): string {
   const base = ((): string => {
     switch (policy.mode) {
       case "read-only":
-        return "当前 DSH 文件策略：只读。任何可用的操作都不能修改 standing 模式下的文件。别仅凭这条策略就拒绝必需的修改：照常尝试可用工具，并遵循它给出的拒绝与升级指引。";
+        return "文件策略：只读——不能修改任何文件。别因此拒绝必需的修改：照常尝试工具，按它的拒绝与升级指引行动。";
       case "workspace-write":
-        return `当前 DSH 文件策略：workspace-write（工作区可写）。任何可用的操作都可修改会话工作区 ${JSON.stringify(policy.workspaceRoot)} 下的文件；部分平台临时目录同样可写。`;
+        return `文件策略：workspace-write——可改会话工作区 ${JSON.stringify(policy.workspaceRoot)} 下的文件，部分平台临时目录同样可写。`;
       case "danger-full-access":
-        return "当前 DSH 文件策略：danger-full-access（全权）。DSH 文件沙箱不再限制可用操作对文件的修改。";
+        return "文件策略：全权——文件改动不再受限。";
     }
   })();
 
   const extras: string[] = [];
   if (rules.allowWrite.length > 0) {
-    extras.push(`本部署额外授权的可写根：${rules.allowWrite.join("、")}。`);
+    extras.push(`额外可写：${rules.allowWrite.join("、")}。`);
   }
   if (rules.readOnly.length > 0) {
-    extras.push(`只读（一律不可写）：${rules.readOnly.join("、")}。`);
+    extras.push(`只读（不可写）：${rules.readOnly.join("、")}。`);
   }
   if (rules.deny.length > 0) {
-    extras.push(`拒绝访问（读与写都拒）：${rules.deny.join("、")}。`);
+    extras.push(`拒绝（读写都拒）：${rules.deny.join("、")}。`);
   }
   return extras.length === 0 ? base : `${base} ${extras.join("")}`;
 }
 
-/**
- * 在给定作用域注册同名策略文本（agent 的 `ctx`，或 preset 子树）。
- * @param scope - 拥有这次注册的 ctx；它的 scope 因此遮蔽全局那条。
- * @param rules - 本部署的访问规则。
- * @param resolve - 按会话解析策略（生产传 `ctx.sandboxPolicy.resolve`）。
- */
-export function registerPolicyContext(
+// `approval:policy` 的两段文本。`never` 是确定性拒绝，所以顺带告诉模型别去要沙箱升级。
+const APPROVAL_ASK_TEXT = "审批策略：ask——需要审批的操作会询问用户；没有可用的应答者时直接失败。";
+const APPROVAL_NEVER_TEXT =
+  "审批提示已禁用：需要审批的操作一律自动拒绝——不要请求沙箱升级（不要设 sandbox_permissions）。";
+
+// 策略文本按会话的有效策略选段。
+export function renderApprovalContext(policy: ApprovalPolicy): string {
+  return policy === "never" ? APPROVAL_NEVER_TEXT : APPROVAL_ASK_TEXT;
+}
+
+// 上游 `ApprovalService` 的公开面：`overrideOf`（会话日志里最后一条 `approval/policy`）与 `config.policy`
+// （部署默认）。`effectivePolicy` 是私有的，所以在这里复刻它的同一算法（override 优先，否则 config 默认，
+// 再退到 `ask`——schema 已经把缺省填成 `ask`，这一层只是兜住手写的装配 config）。
+interface ApprovalSource {
+  overrideOf(session: Session): ApprovalPolicy | undefined;
+  readonly config: { readonly policy?: ApprovalPolicy };
+}
+
+// 某个会话此刻生效的审批策略。
+function effectiveApprovalPolicy(approval: ApprovalSource, session: Session): ApprovalPolicy {
+  return approval.overrideOf(session) ?? approval.config.policy ?? "ask";
+}
+
+// 在给定作用域注册同名策略文本（agent 的 `ctx`）——该 scope 因此遮蔽全局那条。
+// `ctx.get` 而不是 `ctx.systemPrompt`：本行没在 `inject` 里点名 systemPrompt，属性访问会被 cordis 拒绝。
+function registerPolicyContext(
   scope: Context,
   rules: RuleSource,
   resolve: (session: Session) => SandboxExecutionPolicy,
 ): void {
-  // 回调参数 ctx 才是解锁了 `systemPrompt` 的那个 ctx，注册也就落在它的 scope 上。
-  scope.inject(["systemPrompt"], (scoped) => {
-    scoped.systemPrompt.context({
-      name: SANDBOX_POLICY_CONTEXT,
-      order: scoped.systemPrompt.getContextOrder("SANDBOX_POLICY"),
-      text: (context) => {
-        const session = context.agent?.session;
-        return session === undefined ? "" : renderPolicyContext(resolve(session), rules);
-      },
-    });
+  const prompt = scope.get("systemPrompt");
+  if (prompt === undefined) return;
+  prompt.context({
+    name: SANDBOX_POLICY_CONTEXT,
+    order: prompt.getContextOrder("SANDBOX_POLICY"),
+    text: (context) => {
+      const session = context.agent?.session;
+      return session === undefined ? "" : renderPolicyContext(resolve(session), rules);
+    },
   });
 }
 
-/**
- * 每个 agent 注册一次（装配期做，与 scope 出口同一时机与理由：创建期服务可用性还在变）。
- * @param ctx - 本插件的 ctx（host 平面）。
- * @param rules - 本部署的访问规则。
- * @param resolve - 按会话解析策略。
- */
-export function installPolicyContext(
+// 同上，接管 `approval:policy`：读的是上游服务公开面里的有效策略，文本按它选段。
+function registerApprovalContext(scope: Context): void {
+  const prompt = scope.get("systemPrompt");
+  if (prompt === undefined) return;
+  prompt.context({
+    name: APPROVAL_POLICY_CONTEXT,
+    order: prompt.getContextOrder("APPROVAL_POLICY"),
+    text: (context) => {
+      const agent = context.agent;
+      if (agent === undefined) return "";
+      // 审批能力是可选的（headless 部署可能没装）：没装就按"没有这条"读，空串遮蔽不了任何东西。
+      const approval = agent.ctx.get("approval") as ApprovalSource | undefined;
+      return approval === undefined
+        ? ""
+        : renderApprovalContext(effectiveApprovalPolicy(approval, agent.session));
+    },
+  });
+}
+
+// 每个 agent 注册一次，时机是它创建时——必须早于第一次装配（见文件头）。
+export function installRuntimeContexts(
   ctx: Context,
   rules: RuleSource,
   resolve: (session: Session) => SandboxExecutionPolicy,
 ): void {
-  const registered = new WeakSet<Agent>();
-  ctx.on("system-prompt/assemble", (_assembly, context, next) => {
-    const agent = context.agent as Agent | undefined;
-    if (agent !== undefined && !registered.has(agent)) {
-      registered.add(agent);
-      registerPolicyContext(agent.ctx, rules, resolve);
-    }
-    return next();
+  const installed = new WeakSet<Agent>();
+  const install = (agent: Agent): void => {
+    if (installed.has(agent)) return;
+    installed.add(agent);
+    registerPolicyContext(agent.ctx, rules, resolve);
+    registerApprovalContext(agent.ctx);
+  };
+  ctx.on("agent/created", ({ agent }) => {
+    install(agent);
   });
+  // 本行晚于已有 agent 挂载时（行重挂 / HMR）也要覆盖它们：`agent/created` 不会再为它们发一次。
+  for (const agent of ctx.get("agents")?.list() ?? []) install(agent);
 }

package/src/rows.ts

@@ -1,25 +1,22 @@
-/**
- * 本包作为能力包发布的**装配数据**：行本身在部署那一层装（`packages/bundles/sandbox-profile` 引用它渲染 patch）。
- *
- * 官方 `sandbox`（进程沙箱）与 `fs-sandbox`（文件围栏）两个服务只能有一份实现，所以那两行禁掉、换成
- * 本包那一行；`config.access` 的值由部署那层给（schema 默认是空规则）。
- */
+// 本包作为能力包发布的**装配数据**：行本身在部署那一层装（`packages/bundles/sandbox-profile` 引用它
+// 渲染 patch）。官方 `sandbox` 与 `fs-sandbox` 两个服务只能有一份实现，所以那两行禁掉、换成本包那一行；
+// `config.access` 的值由部署那层给（schema 默认是空规则）。
 
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
+// 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。
 export interface PatchRow {
   readonly id?: string;
   readonly disabled?: boolean;
   readonly insert?: readonly RowEntry[];
 }
 
-/** `insert` 里的一个条目。 */
+// `insert` 里的一个条目。
 export interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
 
-/** 沙箱替换的装配行：禁官方两行 + 插本包一行（值由部署那层按 id 覆盖）。 */
+// 沙箱替换的装配行：禁官方两行 + 插本包一行（值由部署那层按 id 覆盖）。
 export function sandboxRows(): readonly PatchRow[] {
   return [
     { id: "sandbox", disabled: true },

package/src/sandbox.ts

@@ -23,7 +23,7 @@ export class ConfigurableSandboxProvider extends LocalSandboxProvider {
     this.access = config.access;
   }
 
-  /** 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。 */
+  // 规则源现场重算：`access` 是 volatile 引用，页面改完下一次编译就是新规则。
   private get source(): RuleSource {
     return ruleSourceOf(this.access.get(), process.env);
   }
@@ -40,7 +40,7 @@ export class ConfigurableSandboxProvider extends LocalSandboxProvider {
     return { ...confined, argv: extendConfinedArgv(confined.argv, effective) };
   }
 
-  /** 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。 */
+  // 编译结果按「工作区 + 当前 access」缓存：access 是页面可改的引用，改了就是另一份规则。
   private rulesFor(workspaceRoot: string): CompiledRules {
     const access = this.access.get();
     const key = `${workspaceRoot}\u0000${JSON.stringify(access ?? null)}`;