berry-agent 0.1.0-alpha.1

package/dist/goal/todo-tool.js

@@ -0,0 +1,174 @@
+/**
+ * goal 段 todo 工具件（03 §10.5 段约束执法位 = todo 工具执行段）。
+ *
+ * 换装关系：goal active 期间组合根以本件**替换** conversation 的
+ * `createTodoTool` 产物（同名 `todo` 工具——模型面无感换装）；durable
+ * `todo/write` 事件同词承载扩展字段（conversation fold 读侧剥离未知字段，
+ * 两向兼容）。
+ *
+ * GOAL_TODO_SCOPE 双向执法（执行段机器面）：
+ *  - goal 段内（scope 在场）：deferred 必携 resume_when（词法可 parse 可
+ *    判窗）、completed 必携后继二择一（follow_up 或 noFollowUp）——缺即拒；
+ *  - 非 goal 段（scope 缺席）：申报任何扩展字段即拒（goal 段词汇不悬空）；
+ *  - gate 声明申报位 fail-closed：command 须 exec seam 在场（hasCommandExec
+ *    判据——03 §10.5 s 批补注①诚实缺席律，判序先于双位合取）且过 needsWrite
+ *    双位、diagnostics 缺 lsp 查询面——申报即拒（评测位 gates.ts 双拦）。
+ */
+import { Type } from 'typebox';
+import { BaseError } from '../contracts/index.js';
+import { parseResumeWhen } from './fold.js';
+/** 扩展字段名集（非 goal 段申报即拒的判据面——与 schema 字段面同源人工互镜） */
+const EXTENDED_FIELDS = ['resumeWhen', 'role', 'taskClass', 'followUp', 'noFollowUp', 'gate'];
+/** goal 段 todo 工具件（全量快照式提交——与 conversation 件同律，扩展语义段内执法） */
+export function createGoalTodoTool(deps) {
+    const nowMs = deps.nowMs ?? (() => Date.now());
+    return {
+        name: 'todo',
+        description: '维护当前任务清单（全量快照式：每次调用提交完整清单覆盖旧表）。goal 段扩展语义：' +
+            'deferred 项必携 resume_when（after@<ISO> 或 after@+<n>[mhd]）；completed 项必携后继二择一' +
+            '（follow_up 或 no_follow_up: true）；可选 gate 声明判据门（command/files/diagnostics）。' +
+            '清单跨对话轮与续跑轮持续存活（goal 生命周期段 fold——用户出手不重置）。',
+        parameters: Type.Object({
+            items: Type.Array(Type.Object({
+                status: Type.Union(['pending', 'in-progress', 'completed', 'deferred'].map((s) => Type.Literal(s))),
+                content: Type.String(),
+                activeForm: Type.Optional(Type.String()),
+                // —— goal 段扩展字段（段内缺必携即拒、段外申报即拒——GOAL_TODO_SCOPE）——
+                resume_when: Type.Optional(Type.String()),
+                role: Type.Optional(Type.Union([Type.Literal('agent'), Type.Literal('user')])),
+                task_class: Type.Optional(Type.String()),
+                follow_up: Type.Optional(Type.String()),
+                no_follow_up: Type.Optional(Type.Boolean()),
+                gate: Type.Optional(Type.Union([
+                    Type.Object({ kind: Type.Literal('command'), command: Type.String() }),
+                    Type.Object({ kind: Type.Literal('files'), paths: Type.Array(Type.String()) }),
+                    Type.Object({ kind: Type.Literal('diagnostics'), files: Type.Array(Type.String()) }),
+                ])),
+            }, 
+            // 扩展字段全列 schema（与 conversation 件的 additionalProperties:false
+            // 第一道闸分立——本件即 goal 段第二道闸，段约束执法在执行段）
+            { additionalProperties: false })),
+        }, { additionalProperties: false }),
+        effect: 'read',
+        execute: async (args) => {
+            const raw = args.items;
+            if (!Array.isArray(raw))
+                throw new BaseError('GOAL_TODO_SCOPE', 'items 须为数组');
+            const scope = deps.getScope();
+            const anchor = nowMs();
+            const items = raw.map((entry) => normalizeItem(entry));
+            // 双向执法逐条过堂（先逐条校验再统一落账——半批不入 durable）
+            for (const item of items)
+                enforceScope(item, scope, deps, anchor);
+            deps.append({ items: items.map((item) => ({ ...item })) });
+            return { content: [{ type: 'text', text: receipt(items, scope) }] };
+        },
+    };
+}
+/** 载荷条目收窄（schema 已校验——此处产 GoalTodoItem 干净形：undefined 腿剔除） */
+function normalizeItem(entry) {
+    if (typeof entry !== 'object' || entry === null) {
+        throw new BaseError('GOAL_TODO_SCOPE', '条目须为对象');
+    }
+    const c = entry;
+    // 可写局部（WritableGoalTodoItem——readonly 契约形由返回承载）
+    const item = { status: c.status, content: c.content };
+    if (typeof c.activeForm === 'string')
+        item.activeForm = c.activeForm;
+    if (typeof c.resume_when === 'string')
+        item.resumeWhen = c.resume_when;
+    if (c.role === 'agent' || c.role === 'user')
+        item.role = c.role;
+    if (typeof c.task_class === 'string')
+        item.taskClass = c.task_class;
+    if (typeof c.follow_up === 'string')
+        item.followUp = c.follow_up;
+    if (c.no_follow_up === true)
+        item.noFollowUp = true;
+    if (isRawGate(c.gate)) {
+        item.gate =
+            c.gate.kind === 'command'
+                ? { kind: 'command', command: c.gate.command }
+                : c.gate.kind === 'files'
+                    ? { kind: 'files', paths: [...c.gate.paths] }
+                    : { kind: 'diagnostics', files: [...c.gate.files] };
+    }
+    return item;
+}
+/** gate 声明形判（窄收窄——schema 已挡大半，防御读侧漂移） */
+function isRawGate(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const g = value;
+    if (g.kind === 'command' && typeof g.command === 'string')
+        return true;
+    if (g.kind === 'files' && Array.isArray(g.paths) && g.paths.every((p) => typeof p === 'string'))
+        return true;
+    if (g.kind === 'diagnostics' && Array.isArray(g.files) && g.files.every((f) => typeof f === 'string'))
+        return true;
+    return false;
+}
+/** 段约束执法（执行段机器面——坏输入一律 BaseError 响亮拒，半批不落账） */
+function enforceScope(item, scope, deps, anchorMs) {
+    const extended = EXTENDED_FIELDS.filter((field) => item[field] !== undefined);
+    if (scope === null) {
+        if (extended.length > 0) {
+            throw new BaseError('GOAL_TODO_SCOPE', `当前不在 goal 段（无 active goal）——扩展字段不悬空：条目「${item.content}」携带 ${extended.join('/')}`);
+        }
+        return;
+    }
+    // goal 段内：deferred/completed 的必携纪律
+    if (item.status === 'deferred' && item.resumeWhen === undefined) {
+        throw new BaseError('GOAL_TODO_SCOPE', `deferred 条目「${item.content}」必携 resume_when（after@<ISO> 或 after@+<n>[mhd]）`);
+    }
+    if (item.resumeWhen !== undefined) {
+        const parsed = parseResumeWhen(item.resumeWhen, anchorMs);
+        if (!parsed.ok)
+            throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」resume_when 词法坏形：${parsed.error}`);
+    }
+    if (item.status === 'completed' && item.followUp === undefined && item.noFollowUp !== true) {
+        throw new BaseError('GOAL_TODO_SCOPE', `completed 条目「${item.content}」必携后继二择一（follow_up 或 no_follow_up: true）——防完成即失联`);
+    }
+    // gate 声明申报位 fail-closed（评测位 gates.ts 双拦）；command 位三判序
+    // ——seam 在场（s 批补注①：缺席即拒，先于双位——批准也无用）→ 双位两档全拒
+    // （文案分档仅指引差——f-1 定形注③：not-approved 档给 /goal approve 指路）
+    if (item.gate !== undefined) {
+        if (item.gate.kind === 'command') {
+            if (!deps.hasCommandExec) {
+                throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」command 判据门不可申报——exec 执行面缺席（组合根未接线，fail-closed 非静默跳过）`);
+            }
+            const status = deps.commandGateStatus(scope.goalId);
+            if (!status.allowed) {
+                throw new BaseError('GOAL_TODO_SCOPE', status.reason === 'not-approved'
+                    ? `条目「${item.content}」command 判据门不可申报——goal 已申报 needsWrite 但未获人面批准（/goal approve ${scope.goalId} 批准后方可申报）`
+                    : `条目「${item.content}」command 判据门不可申报——goal 未申报 needsWrite（防模型自造命令免审批自跑）`);
+            }
+            if (item.gate.command.trim().length === 0) {
+                throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」command 判据门命令为空——空门即非门`);
+            }
+        }
+        if (item.gate.kind === 'diagnostics') {
+            if (!deps.hasLsp) {
+                throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」diagnostics 判据门不可申报——lsp 诊断查询面缺席（fail-closed 非静默跳过）`);
+            }
+            if (item.gate.files.length === 0) {
+                throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」diagnostics 判据门目标集为空——空门即非门`);
+            }
+        }
+        if (item.gate.kind === 'files' && item.gate.paths.length === 0) {
+            throw new BaseError('GOAL_TODO_SCOPE', `条目「${item.content}」files 判据门目标集为空——空门即非门`);
+        }
+    }
+}
+/** 回执文本（计数总览 + 段标记——模型可编程依赖的稳定词面） */
+function receipt(items, scope) {
+    const counts = { pending: 0, 'in-progress': 0, completed: 0, deferred: 0 };
+    for (const item of items)
+        counts[item.status] += 1;
+    const head = `已更新任务清单：${items.length} 项` +
+        `（进行中 ${counts['in-progress']} · 待办 ${counts.pending} · ` +
+        `已完成 ${counts.completed} · 缓办 ${counts.deferred}）`;
+    const gated = items.filter((item) => item.gate !== undefined).length;
+    const tail = scope === null ? '' : `〔goal ${scope.goalId} 段·判据门 ${gated} 项〕`;
+    return tail === '' ? head : `${head}${tail}`;
+}

package/dist/goal/types.js

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

package/dist/goal/update-tool.js

@@ -0,0 +1,46 @@
+/**
+ * goal_update 工具件（03 §10.5 open 项完成否决律——模型面的终态申报通道）。
+ *
+ * 申报与验证分离在工具管道内闭环（schema → 守门 → 执行段机器否决）——
+ * 模型自报文本不再是完成唯一通道：completed 申报由服务层 fold open 项 +
+ * 判据门评测机器否决（GOAL_TRANSITION_INVALID 响亮回执列原因），工具件
+ * 只做通道与收尾渲染。
+ */
+import { Type } from 'typebox';
+import { BaseError } from '../contracts/index.js';
+/** goal_update 工具件（终态申报——机器否决在服务层） */
+export function createGoalUpdateTool(deps) {
+    return {
+        name: 'goal_update',
+        description: '申报 goal 终态。status=completed 必附 evidence（完成证据——机器会独立核验：' +
+            '任务清单不得有 open 项〔一切非 completed 项，含 deferred〕、判据门须全绿，' +
+            '不符即拒并回执原因）；status=abandoned 可附 reason。当前会话的 active goal 作用。',
+        parameters: Type.Object({
+            status: Type.Union([Type.Literal('completed'), Type.Literal('abandoned')]),
+            evidence: Type.Optional(Type.String()),
+            reason: Type.Optional(Type.String()),
+        }, { additionalProperties: false }),
+        effect: 'read',
+        execute: async (args) => {
+            const status = args.status;
+            const active = deps.service.activeFor(deps.getSessionId());
+            if (active === undefined) {
+                throw new BaseError('GOAL_TRANSITION_INVALID', '当前会话无 active goal——无可申报终态');
+            }
+            const row = status === 'completed'
+                ? await deps.service.complete(active.id, typeof args.evidence === 'string' ? args.evidence : '')
+                : await deps.service.abandon(active.id, typeof args.reason === 'string' ? args.reason : undefined);
+            const note = row.endingNote ?? '';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: status === 'completed'
+                            ? `goal 已完成（机器核验通过：open 项清零 + 判据门全绿）。证据：${note}`
+                            : `goal 已放弃。理由：${note}`,
+                    },
+                ],
+            };
+        },
+    };
+}

package/dist/host/approval-cmd.js

@@ -0,0 +1,276 @@
+/**
+ * host/approval-cmd — 审批分档人面命令件（04 §9 定形块⑤ explain 人面 +
+ * ⑥ 预设打包——2026-09-11 审批分档批 ap-3）。`/approval` TUI 命令（assembly
+ * 直挂——与 /reload、/doors 同位，机制宿主有、不随插件换代卸除）。
+ *
+ * 四动词（无参 = status 缺省）：
+ *  - `status`——当前态：sandbox 档 + 审批 policy 各自值与来源（四层解析
+ *    胜者的标注面——装配根注入）+ 三档预设一览；
+ *  - `entries`——策略表全列（**活体现读** tool-policy.json——与装配期快照
+ *    分立；含文件路径与命中序说明：deny 命中恒最先终局、allow 取首个）；
+ *  - `explain <tool> [pattern]`——真 adjudication 干跑：与守门行同一
+ *    matchToolPolicy 纯函数（04 §9 ⑤定形），条目=活体现读、pattern=用户
+ *    给定实参模拟；只读零副作用；
+ *  - `preset <名>`——预设写盘（settings.json 两键 + tool-policy.json 建议
+ *    集 append；半应用防护=坏形全拒；切换不清不删既有条目）；成功尾经
+ *    onPresetApplied 落 preset/applied 审计（恰一笔——包装方 warn 不阻塞）。
+ *
+ * 无 CLI 入口（07 §5：CLI 面只有 `--preset <名>` 逐次旗标——逐次生效不写
+ * 盘，与写盘动词生效语义分立，04 §9 ⑥ ap-3 定形补充）。
+ */
+import { join, resolve as resolvePath } from 'node:path';
+import { canonicalPath, FS_WRITE_TOOLS, matchToolPolicy, policyHitNote } from '../safety/index.js';
+import { approvalPresetOf, APPROVAL_PRESETS, presetSuggestedEntries } from '../safety/index.js';
+import { appendToolPolicyEntry, readToolPolicy, TOOL_POLICY_BASENAME } from './tool-policy-store.js';
+import { writeHostSettings } from './settings-store.js';
+/** 用法说明（TUI 命令描述位 + 解析错回执共用单源） */
+export const APPROVAL_USAGE = `/approval [status] | entries | explain <tool> [pattern] | preset <名>
+  status                 当前态：sandbox 档 + 审批 policy（值 + 来源）+ 三档预设一览
+  entries                策略表全列（活体现读 tool-policy.json——装配期快照外的当前真身）
+  explain <tool> [pattern]  真裁决干跑（守门行同一 matchToolPolicy）：fs 族须带路径前缀参数、bash 须带命令原文、整名族三档并列
+  preset <名>            预设写盘（conservative|balanced|open——settings.json 两键 + 建议集 append；下次启动/新装配生效）
+（CLI 面无本命令——「berry-agent run --preset <名>」为逐次生效不写盘）`;
+/**
+ * TUI 面 argv 解析（零旗标面——本命令族无旗标）。无参 = status 缺省动词。
+ */
+export function parseApprovalArgv(argv) {
+    const [verb, ...rest] = argv;
+    if (verb === undefined)
+        return { ok: true, sub: { sub: 'status' } };
+    if (verb.startsWith('--'))
+        return { ok: false, message: `本命令族无旗标。\n${APPROVAL_USAGE}` };
+    if (rest.some((tok) => tok.startsWith('--')))
+        return { ok: false, message: `本命令族无旗标。\n${APPROVAL_USAGE}` };
+    if (verb === 'status') {
+        if (rest.length > 0)
+            return { ok: false, message: `status 不收位置参数。\n${APPROVAL_USAGE}` };
+        return { ok: true, sub: { sub: 'status' } };
+    }
+    if (verb === 'entries') {
+        if (rest.length > 0)
+            return { ok: false, message: `entries 不收位置参数。\n${APPROVAL_USAGE}` };
+        return { ok: true, sub: { sub: 'entries' } };
+    }
+    if (verb === 'explain') {
+        if (rest.length < 1 || rest.length > 2 || rest[0] === '') {
+            return {
+                ok: false,
+                message: `explain 须带 <tool> 一至两参（fs 族须带路径前缀、bash 须带命令原文）。\n${APPROVAL_USAGE}`,
+            };
+        }
+        return {
+            ok: true,
+            sub: { sub: 'explain', tool: rest[0], ...(rest[1] !== undefined ? { pattern: rest[1] } : {}) },
+        };
+    }
+    if (verb === 'preset') {
+        if (rest.length !== 1 || rest[0] === '') {
+            return { ok: false, message: `preset 须带 <名> 一参数（conservative|balanced|open）。\n${APPROVAL_USAGE}` };
+        }
+        return { ok: true, sub: { sub: 'preset', name: rest[0] } };
+    }
+    return { ok: false, message: `未知子命令：${verb}（合法：status/entries/explain/preset）。\n${APPROVAL_USAGE}` };
+}
+/** 策略表条目单行渲染（entries 与 explain 命中行共用——六字段全列） */
+function renderEntry(entry, index) {
+    const bits = [`tool=${entry.tool}`];
+    if (entry.pattern !== undefined)
+        bits.push(`pattern=${entry.pattern}`);
+    bits.push(`decision=${entry.decision}`);
+    if (entry.effect !== undefined)
+        bits.push(`effect=${entry.effect}`);
+    if (entry.reason !== undefined)
+        bits.push(`reason=${entry.reason}`);
+    if (entry.expiresAt !== undefined)
+        bits.push(`expiresAt=${new Date(entry.expiresAt).toISOString()}`);
+    return `  [${index}] ${bits.join(' ')}`;
+}
+/** status 渲染（当前态两旋钮 + 来源 + 三档预设一览——纯读零副作用） */
+function renderStatus(deps) {
+    const lines = [];
+    lines.push('当前态（四层解析胜者——工具参数 > 会话策略 > CLI 旗标 > settings.json > 代码常量）：');
+    lines.push(`  sandbox 档 = ${deps.status.mode}（来源：${deps.status.modeSource}）`);
+    lines.push(`  审批 policy = ${deps.status.policy}（来源：${deps.status.policySource}）`);
+    lines.push(`  （本面为装配期快照——/approval entries 与 explain 现读策略表文件〔活体〕）`);
+    lines.push('预设三档（preset <名> 写盘——下次启动/新装配生效，当前进程不变）：');
+    for (const preset of APPROVAL_PRESETS) {
+        lines.push(`  ${preset.name}: ${preset.description}`);
+    }
+    return { ok: true, text: lines.join('\n') };
+}
+/** entries 渲染（活体现读——装配期快照外的当前真身；含命中序说明） */
+function renderEntries(deps) {
+    if (deps.dataDir === null) {
+        return { ok: true, text: '纯 memory 诊断形无数据目录——策略表缺席（空清单）。' };
+    }
+    const load = readToolPolicy(deps.dataDir);
+    const path = join(deps.dataDir, TOOL_POLICY_BASENAME);
+    if (!load.healthy) {
+        // 坏形真源随载（发现 #26）：升格语境下真源可以是旧名 allowlist.json——
+        // 指错文件会把用户引去修一个不存在的新名文件
+        const badPath = load.unhealthyPath ?? path;
+        return { ok: false, text: `策略表文件级坏形（${badPath}）——已降级视同空清单；手改修复前 preset 写动词同拒。` };
+    }
+    const lines = [];
+    lines.push(`策略表（活体现读 ${path}——装配期载入的是启动时快照，两时点可分立）：`);
+    if (load.entries.length === 0) {
+        lines.push('  （空——无任何条目）');
+    }
+    else {
+        load.entries.forEach((entry, index) => lines.push(renderEntry(entry, index)));
+    }
+    lines.push('命中序：deny 命中恒最先且终局（硬拒，任何面不可翻转）；无 deny 命中时取首个未过期 allow（免问）。');
+    return { ok: true, text: lines.join('\n') };
+}
+/**
+ * explain 干跑（04 §9 ⑤——真 adjudication 纯函数，与守门行同一
+ * matchToolPolicy + policyHitNote 三面同源）：
+ *  - fs 族（write/edit）：只试 write 档 + pattern 参数必填（作为写目标
+ *    canonical 路径模拟——相对则锚 workspace）；
+ *  - bash：只试 exec 档 + pattern 参数必填（作为命令原文——剥壳词干判定）；
+ *  - 其余整名族：read/write/exec 三档并列（无实参依赖，三档各自成行）。
+ * 条目 = 活体现读；只读零副作用。
+ */
+function renderExplain(sub, deps) {
+    if (deps.dataDir === null) {
+        return { ok: true, text: '纯 memory 诊断形无数据目录——策略表缺席（空清单），无条目可判。' };
+    }
+    const load = readToolPolicy(deps.dataDir);
+    if (!load.healthy) {
+        // 坏形真源随载（发现 #26——同 renderEntries 注）
+        const badPath = load.unhealthyPath ?? join(deps.dataDir, TOOL_POLICY_BASENAME);
+        return { ok: false, text: `策略表文件级坏形（${badPath}）——已降级视同空清单，干跑不可判。` };
+    }
+    const now = Date.now();
+    const workspaceRoot = deps.workspace();
+    const lines = [];
+    lines.push(`explain ${sub.tool}${sub.pattern !== undefined ? ` ${sub.pattern}` : ''}（活体干跑——条目现读 ${join(deps.dataDir, TOOL_POLICY_BASENAME)}）：`);
+    // fs 族：pattern 必填（写目标路径模拟——canonical 化同守门行语义）
+    if (FS_WRITE_TOOLS.has(sub.tool)) {
+        if (sub.pattern === undefined) {
+            return {
+                ok: false,
+                text: `${sub.tool} 属 fs 写族——explain 须带路径前缀第二参（写目标模拟：/approval explain ${sub.tool} <路径>）。\n${APPROVAL_USAGE}`,
+            };
+        }
+        // 相对路径锚 workspace 后 canonical 化（macOS /var 符号链→/private/var
+        // 等陷阱——与守门行 extractWritePaths 产物的 canonical 绝对形同语义；
+        // canonicalPath 自带父目录递归解析，不存在路径亦得稳定绝对形）
+        const target = canonicalPath(resolvePath(workspaceRoot, sub.pattern));
+        const hit = matchToolPolicy(load.entries, { tool: sub.tool, effect: 'write', writePaths: [target], workspace: workspaceRoot }, now);
+        lines.push(hit === undefined
+            ? `  write 档（写目标 ${target}）：无命中——照问照审（回落审批）`
+            : `  write 档（写目标 ${target}）：命中 ${policyHitNote(hit)} → ${hit.entry.decision === 'deny' ? '硬拒（用户主权，任何面不可翻转）' : '免问放行（advisory——fence/可写根照走）'}`);
+        if (hit !== undefined)
+            lines.push(renderEntry(hit.entry, hit.index));
+        return { ok: true, text: lines.join('\n') };
+    }
+    // bash 族：pattern 必填（命令原文——剥壳词干判定）
+    if (sub.tool === 'bash') {
+        if (sub.pattern === undefined) {
+            return {
+                ok: false,
+                text: `bash explain 须带命令原文第二参（/approval explain bash <命令>）。\n${APPROVAL_USAGE}`,
+            };
+        }
+        const hit = matchToolPolicy(load.entries, { tool: 'bash', effect: 'exec', bashCommand: sub.pattern, workspace: workspaceRoot }, now);
+        lines.push(hit === undefined
+            ? `  exec 档（命令「${sub.pattern}」）：无命中——照问照审（回落审批）`
+            : `  exec 档（命令「${sub.pattern}」）：命中 ${policyHitNote(hit)} → ${hit.entry.decision === 'deny' ? '硬拒（用户主权，任何面不可翻转）' : '免问放行（advisory——confine/沙箱面照走）'}`);
+        if (hit !== undefined)
+            lines.push(renderEntry(hit.entry, hit.index));
+        return { ok: true, text: lines.join('\n') };
+    }
+    // 整名族：三档并列（pattern 忽略——整名匹配形条目不收实参）
+    if (sub.pattern !== undefined) {
+        lines.push(`  （${sub.tool} 属整名族——第二参忽略〔条目命中不依赖调用实参〕）`);
+    }
+    let any = false;
+    for (const effect of ['read', 'write', 'exec']) {
+        const hit = matchToolPolicy(load.entries, { tool: sub.tool, effect, workspace: workspaceRoot }, now);
+        if (hit === undefined) {
+            lines.push(`  ${effect} 档：无命中`);
+            continue;
+        }
+        any = true;
+        lines.push(`  ${effect} 档：命中 ${policyHitNote(hit)} → ${hit.entry.decision === 'deny' ? '硬拒（用户主权，任何面不可翻转）' : '免问放行（advisory）'}`);
+        lines.push(renderEntry(hit.entry, hit.index));
+    }
+    if (!any)
+        lines.push('  （无任何命中——该工具照问照审）');
+    return { ok: true, text: lines.join('\n') };
+}
+/**
+ * preset 写盘（04 §9 ⑥——展开式非引用式；序 = 预设名解析 → 策略表健康前置
+ * 〔半应用防护：坏形全拒，settings 不写〕 → settings.json 两键合并写 →
+ * 建议集逐条经写侧唯一正门 append〔幂等去重〕 → 审计恰一笔 → 诚实回执）。
+ */
+function runPreset(name, deps) {
+    const preset = approvalPresetOf(name);
+    if (preset === undefined) {
+        return {
+            ok: false,
+            text: `未知预设名：${name}（合法：${APPROVAL_PRESETS.map((p) => p.name).join('|')}）。\n${APPROVAL_USAGE}`,
+        };
+    }
+    if (deps.dataDir === null) {
+        return { ok: false, text: '纯 memory 诊断形无数据目录——preset 写动词不可用（无落点）。' };
+    }
+    // 半应用防护第一闸：策略表坏形期全拒（档位与条目两文件原子性不可得，宁全
+    // 拒不留半应用态——04 §9 ⑥ ap-3 定形补充）
+    const load = readToolPolicy(deps.dataDir);
+    if (!load.healthy) {
+        // 坏形真源随载（发现 #26——同 renderEntries 注）
+        const badPath = load.unhealthyPath ?? join(deps.dataDir, TOOL_POLICY_BASENAME);
+        return {
+            ok: false,
+            text: `策略表文件级坏形（${badPath}）——preset 全拒（防半应用态：不写 settings.json 亦不 append 条目）；手改修复后重试。`,
+        };
+    }
+    // 两旋钮合并写（保留未知键——用户手编面不因预设切换损毁）
+    const write = writeHostSettings(deps.dataDir, {
+        sandboxMode: preset.sandboxMode,
+        approvalPolicy: preset.approvalPolicy,
+    });
+    if (write === 'rejected') {
+        return { ok: false, text: 'settings.json 坏形期拒写——preset 全败（手改修复后重试）。' };
+    }
+    // 建议集展开 append（写侧唯一正门——幂等去重；conservative/balanced 空集零写入）
+    const drafts = presetSuggestedEntries(preset.name, deps.workspace());
+    let appended = 0;
+    for (const draft of drafts) {
+        const result = appendToolPolicyEntry(deps.dataDir, draft);
+        if (result === 'appended')
+            appended += 1;
+        if (result === 'rejected') {
+            return {
+                ok: false,
+                text: `条目追加被拒（策略表坏形期拒写）——settings.json 两键已写（${preset.sandboxMode}/${preset.approvalPolicy}）、条目追加 ${appended} 条后中止；手改修复 tool-policy.json 后重试补齐。`,
+            };
+        }
+    }
+    // 审计恰一笔（成功尾——包装方 warn 不阻塞）
+    deps.onPresetApplied?.(preset.name, preset.sandboxMode, preset.approvalPolicy, appended);
+    const lines = [];
+    lines.push(`已切换预设：${preset.name}——${preset.description}`);
+    lines.push(`  settings.json ← sandboxMode=${preset.sandboxMode} + approvalPolicy=${preset.approvalPolicy}（合并写，未知键保留）`);
+    lines.push(appended > 0
+        ? `  tool-policy.json ← 建议集追加 ${appended} 条（幂等去重——重复条目不二写）`
+        : '  tool-policy.json ← 建议集空，零写入');
+    lines.push('  切换不清不删既有条目（含从 open 切回——撤除建议条目归手删）；既有会话粘性与在身审批不受影响。');
+    lines.push('生效时点（诚实）：sandbox 档与策略表均装配期快照——当前进程不变，下次启动/新装配生效；/approval entries 与 explain 现读文件（活体）即时可见。');
+    return { ok: true, text: lines.join('\n') };
+}
+/** `/approval` 命令面主入口（sub → 结算形；写动词失败零审计） */
+export function runApprovalCommand(sub, deps) {
+    switch (sub.sub) {
+        case 'status':
+            return renderStatus(deps);
+        case 'entries':
+            return renderEntries(deps);
+        case 'explain':
+            return renderExplain(sub, deps);
+        case 'preset':
+            return runPreset(sub.name, deps);
+    }
+}