@dsh-workbench/shared 0.3.9 → 0.3.11

package/dist/lib/blocker-action.d.ts

@@ -18,18 +18,3 @@ export interface BlockerLabelState {
     readonly running: string | null;
     readonly copied: string | null;
 }
-/**
- * 这颗钮此刻该不该按成等待态：这一轮忙还没收，或有一支正在跑。
- * @param busy - 这一轮忙是不是还在。
- * @param running - 正在跑的那一支的 label；没有就给 `null`。
- * @returns 该等待给 `true`，否则 `false`。
- */
-export declare function blockerPending(busy: boolean, running: string | null): boolean;
-/**
- * 这颗钮此刻该显示什么字：正在重试说「重试中…」，正在跑的那一支说「修复中…」，刚复制过的说「已复制」，其余原样。
- * @param action - 这颗钮的形状（行为 + 平时文案）。
- * @param state - 此刻的运行态。
- * @param t - i18n 取词函数。
- * @returns 要显示的文案；三种临时态都不成立时就是 `action.label`。
- */
-export declare function blockerActionLabel(action: BlockerActionShape, state: BlockerLabelState, t: BlockerLabelTranslate): string;

package/dist/lib/blocker-action.js

@@ -1,25 +1 @@
-/**
- * 这颗钮此刻该不该按成等待态：这一轮忙还没收，或有一支正在跑。
- * @param busy - 这一轮忙是不是还在。
- * @param running - 正在跑的那一支的 label；没有就给 `null`。
- * @returns 该等待给 `true`，否则 `false`。
- */
-export function blockerPending(busy, running) {
-    return busy || running !== null;
-}
-/**
- * 这颗钮此刻该显示什么字：正在重试说「重试中…」，正在跑的那一支说「修复中…」，刚复制过的说「已复制」，其余原样。
- * @param action - 这颗钮的形状（行为 + 平时文案）。
- * @param state - 此刻的运行态。
- * @param t - i18n 取词函数。
- * @returns 要显示的文案；三种临时态都不成立时就是 `action.label`。
- */
-export function blockerActionLabel(action, state, t) {
-    if (action.kind === 'retry' && state.retrying)
-        return t('blocker.retry.running');
-    if (state.running === action.label)
-        return t('blocker.fix.running');
-    if (action.kind === 'copy' && state.copied === action.text)
-        return t('env.copied');
-    return action.label;
-}
+export {};

package/dist/lib/react-types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 从 react 借来的三个类型（`ReactNode` / `CSSProperties` / `ChangeEvent`）—— 模块从这里拿，
+ * 就不必自己直接依赖 react。只取类型：编译期擦除，不进任何产物。
+ */
+export type { ReactNode, CSSProperties, ChangeEvent } from 'react';

package/dist/lib/react-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/react.d.ts

@@ -4,50 +4,51 @@ import type * as ReactTypes from 'react';
  */
 export declare const h: typeof ReactTypes.createElement;
 /**
- * React 的 `Fragment` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `Fragment` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const Fragment: ReactTypes.ExoticComponent<ReactTypes.FragmentProps>;
 /**
- * React 的 `Component` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `Component` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const Component: typeof ReactTypes.Component;
 /**
- * React 的 `createContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `createContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const createContext: typeof ReactTypes.createContext;
 /**
- * React 的 `useContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useContext: typeof ReactTypes.useContext;
 /**
- * React 的 `useState` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useState` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useState: typeof ReactTypes.useState;
 /**
- * React 的 `useEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useEffect: typeof ReactTypes.useEffect;
 /**
- * React 的 `useLayoutEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useLayoutEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useLayoutEffect: typeof ReactTypes.useLayoutEffect;
 /**
- * React 的 `useMemo` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useMemo` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useMemo: typeof ReactTypes.useMemo;
 /**
- * React 的 `useCallback` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useCallback` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useCallback: typeof ReactTypes.useCallback;
 /**
- * React 的 `useRef` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useRef` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useRef: typeof ReactTypes.useRef;
 /**
- * React 的 `useSyncExternalStore` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useSyncExternalStore` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export declare const useSyncExternalStore: typeof ReactTypes.useSyncExternalStore;
 /**
- * 从 react 借来的三个类型（`ReactNode` / `CSSProperties` / `ChangeEvent`）—— 模块从这里拿，就不必自己直接依赖 react。
+ * 借来的三个类型从 `react-types.ts` 转一手：那份是**公开面**（模块 `import type` 从根入口拿），
+ * 组件内部照旧从这里引，别在两处各写一遍名字。
  */
-export type { ReactNode, CSSProperties, ChangeEvent } from 'react';
+export type { ReactNode, CSSProperties, ChangeEvent } from './react-types.js';

package/dist/lib/react.js

@@ -4,46 +4,46 @@ const react = require('react');
  */
 export const h = react.createElement;
 /**
- * React 的 `Fragment` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `Fragment` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const Fragment = react.Fragment;
 /**
- * React 的 `Component` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `Component` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const Component = react.Component;
 /**
- * React 的 `createContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `createContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const createContext = react.createContext;
 /**
- * React 的 `useContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useContext = react.useContext;
 /**
- * React 的 `useState` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useState` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useState = react.useState;
 /**
- * React 的 `useEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useEffect = react.useEffect;
 /**
- * React 的 `useLayoutEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useLayoutEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useLayoutEffect = react.useLayoutEffect;
 /**
- * React 的 `useMemo` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useMemo` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useMemo = react.useMemo;
 /**
- * React 的 `useCallback` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useCallback` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useCallback = react.useCallback;
 /**
- * React 的 `useRef` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useRef` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useRef = react.useRef;
 /**
- * React 的 `useSyncExternalStore` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
+ * React 的 `useSyncExternalStore` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
  */
 export const useSyncExternalStore = react.useSyncExternalStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-workbench/shared",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "工作台与模块共享的纯代码与契约类型：类型、纯逻辑、哑组件、平台解析。宿主侧的东西从 /host 进（不影响浏览器产物）。",
   "license": "MIT",
   "type": "module",

package/src/api/dsh-client.ts

@@ -254,7 +254,10 @@ export interface DshConversationService {
  * 浏览器侧的会话服务：快照加按 id 取作用域；create 是可选写口，不是每个 dsh 版本都有。
  */
 export interface DshSessionsService {
-  readonly list: { getSnapshot(): SessionsSnapshot };
+  readonly list: {
+    getSnapshot(): SessionsSnapshot;
+    subscribe?(listener: () => void): () => void;
+  };
   scope(sessionId: string): unknown | undefined;
   create?(request: {
     readonly workspaceId?: string;

package/src/api/dsh.ts

@@ -229,6 +229,22 @@ export interface DshToolRunContext {
     | undefined;
 }
 
+/**
+ * dsh 的审批服务（服务名 `approval`）：读一个会话此刻生效的审批策略。
+ * 方法可选：服务缺席或老版本没有它时，调用方必须当成「不知道」而不是「已关闭」。
+ */
+export interface DshApprovalService {
+  effectivePolicy?(session: unknown): 'ask' | 'never' | undefined;
+}
+
+/**
+ * dsh 的沙箱策略服务（服务名 `sandboxPolicy`）：按会话解析这次调用生效的文件边界。
+ * 方法可选：服务缺席或老版本没有它时，调用方必须当成「不知道」而不是「完全放行」。
+ */
+export interface DshSandboxPolicy {
+  resolve?(request?: { readonly session?: unknown }): { readonly mode?: string } | undefined;
+}
+
 /**
  * dsh 的工具表；register 回的清理函数负责在插件卸载时摘掉这条工具。
  */

package/src/api/host-write.ts

@@ -1,5 +1,3 @@
-import type { ApiResponse } from './workbench-client.js';
-
 /**
  * 宿主写口的五条通道（偏好、动作、供给、工坊调试、工坊录制），是写路由的第一段。
  */
@@ -10,17 +8,6 @@ export type WriteChannel =
   | 'diy-debug'
   | 'diy-record';
 
-/**
- * 由通道与资源拼出写路由。
- * @param channel 写通道。
- * @param resource 该通道下的资源名。
- * @returns 路由字符串；provision 只有一段，其余是 channel/resource。
- */
-export function writeRoute(channel: WriteChannel, resource: string): string {
-  if (channel === 'provision') return 'provision';
-  return `${channel}/${resource}`;
-}
-
 /**
  * 写通道统一的结果：成了带值，没成带一句能给人看的话（可选明细与帮助链接）。
  */
@@ -33,32 +20,3 @@ export type WriteOutcome<T> =
       readonly helpUrl?: string;
     };
 
-/**
- * 把写通道的响应翻成 WriteOutcome。
- * @param response 写口回的响应；null 表示请求本身没成（网络断了，宿主没答）。
- * @param networkText 拿不到任何服务端文案时兜底的那句。
- * @returns 失败时 message 优先用服务端自己的话，没有才用响应正文或 networkText。
- */
-export function writeOutcomeOf<T>(response: ApiResponse<T> | null, networkText: string): WriteOutcome<T> {
-  if (response === null) return { ok: false, message: networkText };
-  if (!response.ok) {
-    const box = response as {
-      readonly error?:
-        | { readonly message?: unknown; readonly detail?: unknown; readonly helpUrl?: unknown }
-        | undefined;
-      readonly text?: unknown;
-    };
-    const own = typeof box.error?.message === 'string' && box.error.message !== '' ? box.error.message : undefined;
-    const fallback = typeof box.text === 'string' && box.text !== '' ? box.text : networkText;
-    const detail = typeof box.error?.detail === 'string' ? box.error.detail : undefined;
-    const helpUrl =
-      typeof box.error?.helpUrl === 'string' && box.error.helpUrl !== '' ? box.error.helpUrl : undefined;
-    return {
-      ok: false,
-      message: own ?? fallback,
-      ...(detail === undefined ? {} : { detail }),
-      ...(helpUrl === undefined ? {} : { helpUrl }),
-    };
-  }
-  return { ok: true, value: response };
-}

package/src/api/unit-board.ts

@@ -1,6 +1,4 @@
 import type { ModuleBlocker } from './blocker.js';
-import type { CapabilityPayload } from './workbench-contract.js';
-import type { ApiError } from './workbench-client.js';
 
 /**
  * 卡片闸的两种档：capability 按环境读数判，none 无条件放行。
@@ -16,18 +14,6 @@ export interface UnitGate {
   readonly gated: boolean;
 }
 
-/**
- * 判这张卡现在能不能画。
- * @param capability 环境读数；还没读到给 null。
- * @param mode 闸档。
- * @returns mode 为 none 或读数还没到都放行（先放行让它读）；读到明确不通过（ok 与 unchecked 之外）才拦。
- */
-export function gateOf(capability: CapabilityPayload | null, mode: GateMode): UnitGate {
-  if (mode === 'none') return { gated: true };
-  if (capability === null) return { gated: true };
-  return { gated: capability.status === 'ok' || capability.status === 'unchecked' };
-}
-
 /**
  * 一个单元攒下的卡住态：blocker 顶掉卡片，notice 只提示；组装方产出，卡片消费。
  */
@@ -36,34 +22,3 @@ export interface UnitBlockers {
   readonly notice?: ModuleBlocker;
 }
 
-/**
- * 把候选卡住态分档，每档只留第一个。
- * @param candidates 候选（可能含 undefined），按优先级从高到低给。
- * @returns 分出的 blocker 与 notice；已经有 blocker 时不带 notice（挡住就不必再提示）。
- */
-export function splitBlocker(candidates: readonly (ModuleBlocker | undefined)[]): UnitBlockers {
-  let blocker: ModuleBlocker | undefined;
-  let notice: ModuleBlocker | undefined;
-  for (const candidate of candidates) {
-    if (candidate === undefined) continue;
-    if (candidate.severity === 'block') {
-      blocker ??= candidate;
-      continue;
-    }
-    notice ??= candidate;
-  }
-  return {
-    ...(blocker === undefined ? {} : { blocker }),
-    ...(blocker !== undefined || notice === undefined ? {} : { notice }),
-  };
-}
-
-/**
- * 由读口错误算出「出错搭车强探」的防抖键：同一个键只自动重探一次。
- * @param error 读口错误；undefined 表示这次没有错误。
- * @returns 键字符串；空 code 归一到 unknown。
- */
-export function probeKeyOf(error: ApiError | undefined): string | null {
-  if (error === undefined) return null;
-  return error.code === '' ? 'unknown' : error.code;
-}

package/src/components/icons.tsx

@@ -117,22 +117,6 @@ export function IconNpm({ size = 16 }: IconProps) {
   );
 }
 
-/**
- * 四宫格："模块"这个概念的通用单色图标（侧栏、面板那颗钮、市场节的标题）；默认 16px。
- * @param props.size - 边长像素，同时给 `width` 与 `height`。
- * @returns 一枚 `aria-hidden` 的 svg。
- */
-export function IconModules({ size = 16 }: IconProps) {
-  return (
-    <svg width={size} height={size} viewBox="0 0 16 16" fill="none" aria-hidden="true">
-      <rect x="2.5" y="2.5" width="4.6" height="4.6" rx="1.2" stroke="currentColor" strokeWidth="1.2" />
-      <rect x="8.9" y="2.5" width="4.6" height="4.6" rx="1.2" stroke="currentColor" strokeWidth="1.2" />
-      <rect x="2.5" y="8.9" width="4.6" height="4.6" rx="1.2" stroke="currentColor" strokeWidth="1.2" />
-      <rect x="8.9" y="8.9" width="4.6" height="4.6" rx="1.2" stroke="currentColor" strokeWidth="1.2" />
-    </svg>
-  );
-}
-
 /**
  * 模块类型标：渐变方块 + 白四宫格，用在"这是个模块"的行首；品牌物，颜色不跟主题走。默认 16px。
  * @param props.size - 边长像素，同时给 `width` 与 `height`。

package/src/config/storage.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { readFlag, readText, writeFlag, writeText } from './storage.js';
+import { readText, writeText } from './storage.js';
 
 function fakeStorage(options: { throwOnWrite?: boolean } = {}) {
   const data = new Map<string, string>();
@@ -44,30 +44,6 @@ describe('storage', () => {
     expect(fake.data.has('k')).toBe(false);
   });
 
-  it('没存过时读回 null / 默认值', () => {
-    useStorage();
-    expect(readText('missing')).toBeNull();
-    expect(readFlag('missing', true)).toBe(true);
-    expect(readFlag('missing', false)).toBe(false);
-  });
-
-  it('布尔开关按字面量往返', () => {
-    useStorage();
-    writeFlag('on', true);
-    writeFlag('off', false);
-    expect(readFlag('on', false)).toBe(true);
-    expect(readFlag('off', true)).toBe(false);
-  });
-
-  it('只有字面量 "true" 算真：脏数据不因为"非空"就把开关打开', () => {
-    useStorage();
-    writeText('weird', 'yes');
-    writeText('one', '1');
-    expect(readFlag('weird', true)).toBe(false);
-    expect(readFlag('one', true)).toBe(false);
-    expect(readFlag('never', true)).toBe(true);
-  });
-
   it('localStorage 抛异常时静默降级（隐私模式不该让面板崩掉）', () => {
     useStorage({ throwOnWrite: true });
     expect(() => writeText('k', 'v')).not.toThrow();

package/src/config/storage.ts

@@ -15,15 +15,3 @@ export function writeText(key: string, value: string | null): void {
   } catch {
   }
 }
-
-/** 读一个布尔开关：键不存在时返回 `fallback`，只有存进去的 `'true'` 算真。 */
-export function readFlag(key: string, fallback: boolean): boolean {
-  const raw = readText(key);
-  if (raw === null) return fallback;
-  return raw === 'true';
-}
-
-/** 把一个布尔开关写进 localStorage（存 `'true'` / `'false'`）；失败静默。 */
-export function writeFlag(key: string, value: boolean): void {
-  writeText(key, value ? 'true' : 'false');
-}

package/src/host/__tests__/browser-find.test.ts

@@ -217,7 +217,7 @@ describe('browserFind · 找到与找不到', () => {
     expect(out.ok).toBe(false);
     expect(out.code).toBe('cli-exec-failed');
     expect(out.detail).toContain('ENOENT');
-    expect(out.hint).toContain('opencli');
+    expect(out.hint).toContain('后台服务');
   });
 
   it('session / command / limit / textMax 都能覆盖（命令行每个 token 都加引号）', async () => {

package/src/host/__tests__/browser-read.test.ts

@@ -189,7 +189,7 @@ describe('browserRead · 命令这一层的问题', () => {
     const { shell } = fakeShell([{ stdout: 'not json at all' }]);
     const out = await browserRead({ shell, script, ...FAST });
     expect(out.code).toBe('cli-exec-failed');
-    expect(out.message).toContain('不是 JSON');
+    expect(out.message).toContain('格式不对');
   });
 });
 

package/src/host/browser-find.ts

@@ -229,7 +229,7 @@ export async function browserFind(options: BrowserFindOptions): Promise<BrowserF
       return {
         kind: 'failed',
         detail: error instanceof Error ? error.message : String(error),
-        hint: '确认这台机器上 opencli 能跑（工作台会自己把它挂好）',
+        hint: '确认后台服务能跑起来，再重试',
       };
     }
   };

package/src/host/browser-read.ts

@@ -140,8 +140,8 @@ async function evalOnce(
         result: {
           ok: false,
           code: 'cli-exec-failed',
-          message: '读不了：opencli 起不来',
-          hint: '确认这台机器上 opencli 能跑（工作台会自己把它挂好）',
+          message: '读不了：后台服务起不来',
+          hint: '确认后台服务能跑起来，再重试',
           detail: error instanceof Error ? error.message : String(error),
         },
       };
@@ -179,8 +179,8 @@ async function evalOnce(
         result: {
           ok: false,
           code: 'cli-exec-failed',
-          message: '读到了、但不是 JSON',
-          hint: '脚本必须回 JSON',
+          message: '读到的格式不对',
+          hint: '让 agent 检查一下这条读',
           detail: tailLines(attempt.stdout, 4),
         },
       };
@@ -210,7 +210,7 @@ async function openOnce(
       ok: false,
       code: 'cli-exec-failed',
       message: '打不开那个页面',
-      hint: '确认 opencli 能跑起来',
+      hint: '确认后台服务能跑起来，再重试',
       detail: error instanceof Error ? error.message : String(error),
       helpUrl: url,
     };

package/src/host/tool-approval.ts

@@ -75,9 +75,17 @@ export interface ApprovalCall {
   readonly session?: string | undefined;
 }
 
+/**
+ * 套件对一次写调用给出的判定：`read` 只是看看、`allow` 会写但本套件不问、`deny` 这一次根本跑不成
+ * （连问都不该问，`reason` 原样交给 agent）、`ask` 要用户点头（`question` 接在明细后，`fallback` 是没明细时的整句）。
+ */
 export type ApprovalVerdict =
   | { readonly kind: 'read' }
   | { readonly kind: 'allow' }
+  | {
+      readonly kind: 'deny';
+      readonly reason: string;
+    }
   | {
       readonly kind: 'ask';
       readonly reason: string;
@@ -87,10 +95,15 @@ export type ApprovalVerdict =
 
 export type ApprovalPolicy = (call: ApprovalCall) => ApprovalVerdict | undefined;
 
+/**
+ * 闸门的输入：`skipAsk` 为真表示会话已经不要审批提示（完全权限）—— 认领检查、`{blocked}` 与套件自己的
+ * `deny` 照旧，只是不再返回 `ask`；dsh 在 `approval: never` 下会把 `ask` 直接拒掉。
+ */
 export interface ApprovalContext {
   readonly writes?: boolean | undefined;
   readonly policy?: ApprovalPolicy | undefined;
   readonly declaredNote?: boolean | undefined;
+  readonly skipAsk?: boolean | undefined;
   readonly detailOf?:
     | ((call: ApprovalCall) => ApprovalFacts | undefined | Promise<ApprovalFacts | undefined>)
     | undefined;
@@ -134,6 +147,8 @@ export async function approvalFor(
 
   if (verdict?.kind === 'read' || verdict?.kind === 'allow') return undefined;
 
+  if (verdict?.kind === 'deny') return { kind: 'deny', reason: verdict.reason };
+
   if (verdict?.kind !== 'ask') {
     return {
       kind: 'deny',
@@ -151,6 +166,8 @@ export async function approvalFor(
   }
   if (facts !== undefined && 'blocked' in facts) return { kind: 'deny', reason: facts.blocked };
 
+  if (context.skipAsk === true) return undefined;
+
   return {
     kind: 'ask',
     reason: verdict.reason,