dsh-grill-first 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## 0.1.4
+
+"真的按你确认过的意思做"版本：修掉四个"配置写了但不生效"的地方，并让询问类消息不再被当成模糊任务。
+
+### 新增
+
+- **`gateMode: "ask"` 档位**：需求没确认时，变更类操作弹一张 DSH 原生确认卡片问你"照现在的理解直接动手吗"，你点头就放行——不想切 `strict` 硬门禁、又不想写配置文件的人用这个。卡片只弹一次，之后本次任务照常跑。
+- **`memoryScope` 配置**：项目背景与历史默认存工作区；改成 `global` 则落到全局目录的 `project.json`，跨项目共享。
+- **问句不再触发澄清**：问号、"怎么样 / 查一下 / 看看 / 解释一下 / 我想知道" 这类询问，以及 `look at / check my / tell me / explain` 这类英文问句，一律直接放行并接话作答——0.1.3 及以前会被当成"模糊任务"要求先澄清。
+- **`intensity` 真正生效**：`gentle` 两维齐就放行、`standard` 三维、`grill` 还要求写清验收标准（以前三个档位阈值完全一样）。
+- **英文任务也能判**：四张维度词表补了英文同义词（write/implement/refactor、only/scope、use/based on、test/verify…），英文按词边界匹配，不会把 `skipList` 误当跳过词。
+
+### 修复
+
+- **`maxRounds` 现在真的会到上限**：以前 `grill_start` 每次都把轮数清零，问多少轮都不会停；现在问满上限后直接放行，并在返回值里给出 `rounds_used`。
+- **用户追问不再把门禁关回去**：以前任何一条用户消息都会重置门禁，"继续""嗯""好的"也会；现在只把**新任务**当成新一轮，追问/答话不会打断进行中的工作。
+- **历史记录不再无限增长**：项目历史只保留最近 100 条（摘要只用最近 3 条，多的读不到只是白占地方）。
+- **删掉 `grill_memory` 这个不存在的只读白名单条目**（0.1.3 之前遗留的死引用）。
+
+### 内部
+
+- 单测/端到端用例从 94 个补到 127 个，新增：问句识别、intensity 阈值、`ask` 档位、追问不重置门禁、`maxRounds` 上限、`memoryScope`、历史裁剪，以及一张"主人真实说过的 11 句话"回归样例表。
+- CI 增加 `npm run typecheck`；新增 `.github/workflows/release.yml`：打 `v*` tag 自动发 npm（需要仓库 Secrets 配 `NPM_TOKEN`）。
+
 ## 0.1.3
 
 文档修正版。

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 InoriMutsumi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 InoriMutsumi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # dsh-grill-first
 
-![tests](https://img.shields.io/badge/tests-91%20passing-brightgreen)
+![tests](https://img.shields.io/badge/tests-127%20passing-brightgreen)
 ![license](https://img.shields.io/badge/license-MIT-blue)
 ![DSH plugin](https://img.shields.io/badge/DSH-plugin-blueviolet)
 
@@ -18,6 +18,8 @@ AI 助手最常见的失败不是"不会做"，而是"做完了才发现做的
 
 严格档位（`gateMode: "strict"`）下，需求没确认前模型无法执行写文件、跑命令这类**变更类**操作——从机制上保证"没问清就不许动手"。
 
+`ask` 档位（0.1.4 新增）介于两者之间：需求没确认时，变更类操作会弹一张 DSH 原生确认卡片问你"照现在的理解直接动手吗"，你点「是」就放行，点「否」由你补一句需求——不写配置文件也能当场决定。
+
 ## 安装
 
 装插件前请先退出正在跑的任务。三种方式任选：
@@ -56,38 +58,41 @@ dsh plugin --profile <你的 profile 名> add github:InoriMutsumi/dsh-grill-firs
 ### 想跳过提问时
 
 - 消息里带上「**直接做**」「**跳过提问**」「**不用问**」「**skip**」中任意一个 → 立刻开工；
+- 只是**问情况**（"这个插件怎么样""查一下我的仓库里有什么""解释一下这段代码"）→ 不算新任务，不追问；
 - 或者在设置里把 `enabled` 关掉 / 把 `gateMode` 调成 `off` → 整个插件静默。
 
 ## 配置项
 
-DSH 设置界面 → 插件 → dsh-grill-first，共 7 项：
+DSH 设置界面 → 插件 → dsh-grill-first，共 8 项：
 
 | 配置 | 类型 | 默认 | 说明 |
 |---|---|---|---|
 | `enabled` | 布尔 | `true` | 总开关。关闭后既不追问也不拦截工具 |
-| `gateMode` | `off` / `warn` / `strict` | `warn` | `off` 不拦截；`warn` 只在日志里记录"需求未确认"；`strict` 未确认前拦截变更类工具 |
+| `gateMode` | `off` / `warn` / `ask` / `strict` | `warn` | `off` 不拦截；`warn` 只在日志里记录"需求未确认"；`ask` 未确认时弹卡片问你；`strict` 未确认前直接拦截变更类工具 |
 | `maxQuestionsPerRound` | 1-6 | `3` | 每轮最多问几个问题 |
-| `maxRounds` | 1-10 | `3` | 最多追问几轮 |
-| `intensity` | `gentle` / `standard` / `grill` | `standard` | 追问力度：只问关键点 / 标准 / 刨根问底 |
+| `maxRounds` | 1-10 | `3` | 最多追问几轮；问满后 `grill_start` 直接放行 |
+| `intensity` | `gentle` / `standard` / `grill` | `standard` | 追问力度：`gentle` 两维齐就放行 / `standard` 三维 / `grill` 还要求写清验收标准 |
 | `bypassKeywords` | 字符串数组 | `["直接做","跳过提问","不用问","skip"]` | 命中即跳过提问 |
 | `memoryEnabled` | 布尔 | `true` | 是否启用两层记忆 |
+| `memoryScope` | `project` / `global` | `project` | 项目背景/历史存哪：`project` 存工作区，`global` 存全局目录（跨项目共享） |
 
 > 默认是 `warn` 而不是 `strict`：默认档位保证升级插件不会突然卡住你已有的工作流。想要硬门禁请手动切 `strict`。
 
 ### 怎么改配置
 
-DSH 设置页里的插件条目目前只提供「启用 / 停用」开关（客户端的插件页不渲染第三方插件的配置表单），要改上面 7 项请编辑 **profile 的补丁层** `cordis.patch.yml`：
+DSH 设置页里的插件条目目前只提供「启用 / 停用」开关（客户端的插件页不渲染第三方插件的配置表单），要改上面 8 项请编辑 **profile 的补丁层** `cordis.patch.yml`：
 
 ```yaml
 # <profile 目录>/cordis.patch.yml
 - id: dsh-grill-first
   name: dsh-grill-first
   config:
-    gateMode: strict          # off | warn | strict
+    gateMode: strict          # off | warn | ask | strict
     maxQuestionsPerRound: 3   # 1-6
     maxRounds: 3              # 1-10
     intensity: standard       # gentle | standard | grill
     memoryEnabled: true
+    memoryScope: project      # project | global
     bypassKeywords: [直接做, 跳过提问, 不用问, skip]
 ```
 
@@ -102,6 +107,8 @@ DSH 设置页里的插件条目目前只提供「启用 / 停用」开关（客
 | 全局层 | `<profile 目录>/grill-first/global.json`（不可写时退化到 `~/.dsh-grill-first/global.json`） | 通用偏好，如"注释一律用中文" |
 | 项目层 | `<工作区>/.dsh/grill-first/memory.json` | 项目背景、任务历史（任务名 + 需求摘要 + 日期） |
 
+项目层默认落在工作区；把 `memoryScope` 改成 `global` 后改落 `<全局目录>/project.json`——适合"所有项目通用"的背景约定，不想往每个仓库里塞 `.dsh/` 时也用这个。历史记录只保留最近 100 条（0.1.4 起）。
+
 下次追问时，`grill_start` 会把这些内容作为 `memory_context` 返回，模型就不会重复问你同一件事。
 
 ## 开发
@@ -109,7 +116,7 @@ DSH 设置页里的插件条目目前只提供「启用 / 停用」开关（客
 ```bash
 npm install          # 装开发依赖（schemastery 由宿主提供，仅开发期需要）
 npm run build        # TypeScript → dist/
-npm test             # 构建 + 94 个单测 / 端到端场景测试
+npm test             # 构建 + 127 个单测 / 端到端场景测试
 node scripts/selfcheck.mjs   # 静态自检：中文 JSDoc、any 用量、需求→代码位置
 ```
 
@@ -121,7 +128,7 @@ node scripts/selfcheck.mjs   # 静态自检：中文 JSDoc、any 用量、需求
 src/
   index.ts              插件装配入口（工具 + 协议段 + 门禁）
   config.ts             配置归一化（不依赖宿主，可单测）
-  configSchema.ts       Schemastery 配置声明（设置界面用，7 项）
+  configSchema.ts       Schemastery 配置声明（设置界面用，8 项）
   version.ts            从 package.json 读版本号，供 grill_start 返回
   judge/heuristics.ts   任务模糊度判定（纯函数）
   prompt/protocol.ts    注入系统提示的中文协议文本
@@ -145,7 +152,7 @@ src/
 > DSH 自己的门禁用 `semver.satisfies(..., { includePrerelease: true })` 判定，`^0.2.0-rc.2` 能匹配 `0.2.1-rc.2`；
 > 但标准 npm 语义（不加 `includePrerelease`）会判不匹配，所以上游要求写显式分支。
 
-已验证的宿主版本：`0.2.0-rc.2`（0.1.x 开发期）、`0.2.1-rc.2`（2026-10-17 复核：`typecheck`、94 个单测、`verify-installed` 一致，且实测加载运行）。升完 DSH 后的自检三步：
+已验证的宿主版本：`0.2.0-rc.2`（0.1.x 开发期）、`0.2.1-rc.2`（2026-10-17 复核：`typecheck`、94 个单测、`verify-installed` 一致，且实测加载运行；0.1.4 起 127 个单测）。升完 DSH 后的自检三步：
 
 ```bash
 node scripts/verify-installed.mjs   # 安装拷贝与仓库产物是否一致
@@ -156,6 +163,8 @@ node scripts/verify-installed.mjs   # 安装拷贝与仓库产物是否一致
 ## 已知限制
 
 - 门禁只对**根 agent**（能直接跟你对话的那个）生效；子 agent / 团队成员不拦，否则正常的委派工作流会被卡死。因此**委派类工具本身**（`subagent`、`workflow`、`spawn_teammate`…）在未确认前也会被拦，防止"派个子代理替自己动手"绕过门禁。
+- `ask` 档位**只问一次**：卡片弹过之后门禁即视为放行（否则一次任务里写 20 个文件就要弹 20 张卡片）。想每次都拦，请用 `strict`。
+- 判定器是**关键词启发式**，不是语义模型：问句靠问号/疑问词/"查一下/看看"这类信号识别，极少数既像提问又像下令的句子可能判错；判错时直接说「直接做」或让模型调一次 `grill_start` 即可纠正。英文关键词按词边界匹配，中文按子串匹配。
 - `warn` 档位只能"记录不拦截"：DSH 的 `tools/pre-execute` 事件没有"放行但同时给模型提示"这种返回形态。
 - 记忆是本地文件，不含加密；删掉对应 json 即清空。
 - `grill_confirm` 优先走 DSH 的结构化提问通道；该通道不可用时（例如子 agent 内部）会返回 `needs_user_confirmation: true`，由模型改用内置提问工具兜底。

package/cordis.patch.yml

@@ -1,4 +1,4 @@
-# DSH bundle 补丁：把本插件插入当前 profile 的插件表（格式参照已装插件 dsh-find-plugins）。
-- insert:
-    - id: dsh-grill-first
-      name: 'dsh-grill-first'
+# DSH bundle 补丁：把本插件插入当前 profile 的插件表（格式参照已装插件 dsh-find-plugins）。
+- insert:
+    - id: dsh-grill-first
+      name: 'dsh-grill-first'

package/dist/config.d.ts

@@ -1,5 +1,7 @@
-/** 门禁档位：off=不拦截、warn=只记录、strict=拦截变更类工具。 */
-export type GateMode = 'off' | 'warn' | 'strict';
+/** 门禁档位：off=不拦截、warn=只记录、strict=拦截变更类工具、ask=先弹卡片问用户。 */
+export type GateMode = 'off' | 'warn' | 'strict' | 'ask';
+/** 项目层记忆的落点：project=跟着当前工作区走、global=全局共享一份。 */
+export type MemoryScope = 'project' | 'global';
 /** 追问力度。 */
 export type Intensity = 'gentle' | 'standard' | 'grill';
 /** 归一化后的插件配置。 */
@@ -18,6 +20,8 @@ export interface GrillConfig {
     bypassKeywords: string[];
     /** 是否启用两层记忆（R5）。 */
     memoryEnabled: boolean;
+    /** 项目层记忆落在哪里（0.1.4 新增：有些项目不想被写进 .dsh/）。 */
+    memoryScope: MemoryScope;
 }
 /** 默认配置（与工作表 3.7 的默认值一致）。 */
 export declare const DEFAULT_CONFIG: GrillConfig;

package/dist/config.js

@@ -14,6 +14,7 @@ export const DEFAULT_CONFIG = {
     intensity: 'standard',
     bypassKeywords: [...DEFAULT_BYPASS_KEYWORDS],
     memoryEnabled: true,
+    memoryScope: 'project',
 };
 /** 取整并夹到 [min, max]；非法值返回 fallback。 */
 function clampInt(value, min, max, fallback) {
@@ -53,11 +54,12 @@ export function normalizeConfig(raw) {
     const input = (raw ?? {});
     return {
         enabled: pickBoolean(input.enabled, DEFAULT_CONFIG.enabled),
-        gateMode: pickEnum(input.gateMode, ['off', 'warn', 'strict'], DEFAULT_CONFIG.gateMode),
+        gateMode: pickEnum(input.gateMode, ['off', 'warn', 'strict', 'ask'], DEFAULT_CONFIG.gateMode),
         maxQuestionsPerRound: clampInt(input.maxQuestionsPerRound, 1, 6, DEFAULT_CONFIG.maxQuestionsPerRound),
         maxRounds: clampInt(input.maxRounds, 1, 10, DEFAULT_CONFIG.maxRounds),
         intensity: pickEnum(input.intensity, ['gentle', 'standard', 'grill'], DEFAULT_CONFIG.intensity),
         bypassKeywords: pickStringList(input.bypassKeywords, DEFAULT_CONFIG.bypassKeywords),
         memoryEnabled: pickBoolean(input.memoryEnabled, DEFAULT_CONFIG.memoryEnabled),
+        memoryScope: pickEnum(input.memoryScope, ['project', 'global'], DEFAULT_CONFIG.memoryScope),
     };
 }

package/dist/configSchema.d.ts

@@ -10,18 +10,20 @@ import z from '@deepseek-ai/schemastery';
 /** 插件配置 schema：改了这里，设置界面与 cordis.yml 校验同时生效。 */
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     enabled: z<boolean, boolean, "defined">;
-    gateMode: z<"off" | "warn" | "strict", "off" | "warn" | "strict", "defined">;
+    gateMode: z<"off" | "warn" | "strict" | "ask", "off" | "warn" | "strict" | "ask", "defined">;
     maxQuestionsPerRound: z<number, number, "defined">;
     maxRounds: z<number, number, "defined">;
     intensity: z<"gentle" | "standard" | "grill", "gentle" | "standard" | "grill", "defined">;
     bypassKeywords: z<string[], string[], "defined">;
     memoryEnabled: z<boolean, boolean, "defined">;
+    memoryScope: z<"project" | "global", "project" | "global", "defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
     enabled: z<boolean, boolean, "defined">;
-    gateMode: z<"off" | "warn" | "strict", "off" | "warn" | "strict", "defined">;
+    gateMode: z<"off" | "warn" | "strict" | "ask", "off" | "warn" | "strict" | "ask", "defined">;
     maxQuestionsPerRound: z<number, number, "defined">;
     maxRounds: z<number, number, "defined">;
     intensity: z<"gentle" | "standard" | "grill", "gentle" | "standard" | "grill", "defined">;
     bypassKeywords: z<string[], string[], "defined">;
     memoryEnabled: z<boolean, boolean, "defined">;
+    memoryScope: z<"project" | "global", "project" | "global", "defined">;
 }>>, "plain">;

package/dist/configSchema.js

@@ -9,13 +9,15 @@
 import z from '@deepseek-ai/schemastery';
 import { DEFAULT_BYPASS_KEYWORDS } from './judge/heuristics.js';
 /** 门禁档位 schema。 */
-const gateModeSchema = z.union([z.const('off'), z.const('warn'), z.const('strict')]).default('warn');
+const gateModeSchema = z
+    .union([z.const('off'), z.const('warn'), z.const('strict'), z.const('ask')])
+    .default('warn');
 /** 追问力度 schema。 */
 const intensitySchema = z.union([z.const('gentle'), z.const('standard'), z.const('grill')]).default('standard');
 /** 插件配置 schema：改了这里，设置界面与 cordis.yml 校验同时生效。 */
 export const Config = z.object({
     enabled: z.boolean().default(true).description('总开关：关闭后任何任务都不再追问，也不拦截工具。'),
-    gateMode: gateModeSchema.description('门禁档位：off 不拦截 / warn 只记录 / strict 未确认需求前拦截写类工具。'),
+    gateMode: gateModeSchema.description('门禁档位：off 不拦截 / warn 只记录 / strict 未确认需求前拦截写类工具 / ask 拦截前先弹卡片问一句。'),
     maxQuestionsPerRound: z
         .natural()
         .max(6)
@@ -28,4 +30,8 @@ export const Config = z.object({
         .default([...DEFAULT_BYPASS_KEYWORDS])
         .description('跳过关键词：用户消息里出现这些词就不再追问，直接开工。'),
     memoryEnabled: z.boolean().default(true).description('是否启用两层记忆（全局偏好 + 项目背景/历史）。'),
+    memoryScope: z
+        .union([z.const('project'), z.const('global')])
+        .default('project')
+        .description('项目层记忆落点：project 写进当前工作区的 .dsh/grill-first/，global 写进插件家目录。'),
 });

package/dist/gate/preExecute.d.ts

@@ -9,8 +9,8 @@
  * 3. warn 模式只记录不拦截（pre-execute 没有"放行 + 附带提示"这种返回形态）。
  */
 import type { GrillContext } from '../types.js';
-/** 门禁档位。 */
-export type GateMode = 'off' | 'warn' | 'strict';
+/** 门禁档位：ask 档在拦截前先弹一张"要不要继续"的卡片，交给人决定（0.1.4 新增）。 */
+export type GateMode = 'off' | 'warn' | 'strict' | 'ask';
 /** 门禁状态：open = 已确认或无需确认；closed = 尚未确认。 */
 export type GateState = 'open' | 'closed';
 /** 变更类工具名单（宁松勿紧）。 */
@@ -19,14 +19,16 @@ export declare const MUTATING_TOOLS: readonly string[];
 export declare const READ_ONLY_TOOLS: readonly string[];
 /** 拦截时给模型看的拒绝文案（工作表 3.6 原文）。 */
 export declare const GATE_DENY_REASON = "\u9700\u6C42\u5C1A\u672A\u786E\u8BA4\uFF1A\u8BF7\u5148\u8C03\u7528 grill_confirm \u5B8C\u6210\u9700\u6C42\u786E\u8BA4\uFF0C\u6216\u8BA9\u7528\u6237\u8BF4'\u76F4\u63A5\u505A'\u8DF3\u8FC7\u3002";
+/** ask 档弹给用户看的说明（宿主用 displayReason 渲染卡片正文）。 */
+export declare const GATE_ASK_REASON = "\u8FD9\u6B21\u4EFB\u52A1\u7684\u9700\u6C42\u8FD8\u6CA1\u786E\u8BA4\uFF0C\u8981\u7167\u73B0\u5728\u7684\u7406\u89E3\u76F4\u63A5\u52A8\u624B\u5417\uFF1F";
 /**
  * 判断某个工具名是否属于"会真正改动工作区/交付物"的变更类工具。
  * @param name 工具名。
  */
 export declare function isMutatingTool(name: string): boolean;
-/** 门禁判定结果。 */
+/** 门禁判定结果：ask = 弹卡片问用户后由其决定（宿主 PreToolDecision 支持）。 */
 export interface GateDecision {
-    action: 'allow' | 'deny';
+    action: 'allow' | 'deny' | 'ask';
     reason?: string;
 }
 /**
@@ -60,6 +62,14 @@ export interface GateOptions {
     mode: GateMode;
     /** warn 模式下的提示回调（默认写日志）。 */
     onWarning?: (toolName: string, agentId: string) => void;
+    /**
+     * 新用户消息到达时，是否把门禁重置为 closed。
+     *
+     * 0.1.4 修：以前每条用户消息都关门禁，导致"刚确认完、用户回一句继续"又被拦。
+     * 现在由判定器看一眼消息内容——追问/询问/说了跳过词之类不关门禁。
+     * 返回 true 才关门；未提供该回调时保持旧行为（一律关）。
+     */
+    shouldResetOnMessage?: (text: string) => boolean;
 }
 /**
  * 把门禁挂到宿主事件上：`tools/pre-execute` 拦截 + `agent/inbox/inserted` 重置。

package/dist/gate/preExecute.js

@@ -50,10 +50,11 @@ export const READ_ONLY_TOOLS = [
     'update_goal',
     'grill_start',
     'grill_confirm',
-    'grill_memory',
 ];
 /** 拦截时给模型看的拒绝文案（工作表 3.6 原文）。 */
 export const GATE_DENY_REASON = "需求尚未确认：请先调用 grill_confirm 完成需求确认，或让用户说'直接做'跳过。";
+/** ask 档弹给用户看的说明（宿主用 displayReason 渲染卡片正文）。 */
+export const GATE_ASK_REASON = '这次任务的需求还没确认，要照现在的理解直接动手吗？';
 const READ_ONLY_SET = new Set(READ_ONLY_TOOLS.map((n) => n.toLowerCase()));
 const MUTATING_SET = new Set(MUTATING_TOOLS.map((n) => n.toLowerCase()));
 /** univer_* 里只有这几个是只读的，其余按写类处理。 */
@@ -81,14 +82,46 @@ export function isMutatingTool(name) {
  * @param input 工具名 + 当前门禁状态 + 档位。
  */
 export function decideGate(input) {
-    if (input.mode !== 'strict')
+    // off / warn 只记录不拦截（warn 的提示在 registerGate 里单独打日志）。
+    if (input.mode === 'off' || input.mode === 'warn')
         return { action: 'allow' };
     if (input.state !== 'closed')
         return { action: 'allow' };
     if (!isMutatingTool(input.toolName))
         return { action: 'allow' };
+    if (input.mode === 'ask')
+        return { action: 'ask', reason: GATE_DENY_REASON };
     return { action: 'deny', reason: GATE_DENY_REASON };
 }
+/**
+ * 从宿主的 inbox 负载里尽量捞出用户消息文本。
+ *
+ * 不同宿主版本的字段名不统一（text / content / parts），取不到时返回空串；
+ * 空串表示"不知道用户说了什么"，此时保持旧行为（关门禁）最安全。
+ * @param payload `agent/inbox/inserted` 的事件负载。
+ */
+function extractMessageText(payload) {
+    const message = payload?.message;
+    if (typeof message === 'string')
+        return message.trim();
+    if (!message || typeof message !== 'object')
+        return '';
+    const record = message;
+    for (const key of ['text', 'content', 'body', 'prompt', 'parts']) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim() !== '')
+            return value.trim();
+        if (!Array.isArray(value))
+            continue;
+        const joined = value
+            .map((part) => (typeof part === 'string' ? part : part?.text))
+            .filter((part) => typeof part === 'string' && part.trim() !== '')
+            .join('\n');
+        if (joined.trim() !== '')
+            return joined.trim();
+    }
+    return '';
+}
 /** 每个 agent 的门禁状态表（agent 级隔离）。 */
 export class GateRegistry {
     states = new Map();
@@ -144,6 +177,17 @@ export function registerGate(ctx, gates, options) {
                 ctx.logger?.info?.(`[grill-first] 拦截 ${exec.name}（需求未确认，agent=${agentId}）`);
                 return { kind: 'deny', reason: decision.reason ?? GATE_DENY_REASON };
             }
+            if (decision.action === 'ask') {
+                // 只问一次：卡片弹过之后无论用户点头还是否决，都由用户决定，插件不再逐次弹
+                // （否则一次任务里写 20 个文件就会弹 20 张卡片）。
+                ctx.logger?.info?.(`[grill-first] 询问 ${exec.name}（需求未确认，agent=${agentId}）`);
+                gates.open(agentId);
+                return {
+                    kind: 'ask',
+                    reason: decision.reason ?? GATE_DENY_REASON,
+                    displayReason: GATE_ASK_REASON,
+                };
+            }
             if (options.mode === 'warn' && state === 'closed' && isMutatingTool(exec?.name ?? '')) {
                 options.onWarning?.(exec.name, agentId);
             }
@@ -159,6 +203,9 @@ export function registerGate(ctx, gates, options) {
         const agentId = payload?.agent?.id ?? '';
         if (agentId === '' || !isRootAgent(ctx, agentId))
             return;
+        const text = extractMessageText(payload);
+        if (text !== '' && options.shouldResetOnMessage && !options.shouldResetOnMessage(text))
+            return;
         gates.close(agentId);
     });
 }

package/dist/index.js

@@ -5,6 +5,7 @@
  * 在插件卸载/配置变更重挂载时自动清理。
  */
 import { normalizeConfig } from './config.js';
+import { judgeTask } from './judge/heuristics.js';
 import { Config } from './configSchema.js';
 import { GateRegistry, registerGate } from './gate/preExecute.js';
 import { PROTOCOL_SECTION_NAME, PROTOCOL_SECTION_ORDER, buildProtocolText } from './prompt/protocol.js';
@@ -68,6 +69,7 @@ export function apply(ctx, rawConfig) {
             gates,
             sessions,
             workspaceRoot,
+            memoryScope: () => config.memoryScope,
             ...(ctx.logger ? { logger: ctx.logger } : {}),
         }));
         register(createGrillConfirmTool({
@@ -75,6 +77,7 @@ export function apply(ctx, rawConfig) {
             gates,
             sessions,
             workspaceRoot,
+            memoryScope: () => config.memoryScope,
             questions: () => ctx.get('userQuestions'),
             ...(ctx.logger ? { logger: ctx.logger } : {}),
         }));
@@ -99,6 +102,16 @@ export function apply(ctx, rawConfig) {
     installProtocolSection(ctx, config);
     registerGate(ctx, gates, {
         mode: config.gateMode,
+        // 新消息到达时先看一眼内容：追问/询问类不关门禁，否则"刚确认完又被拦"。
+        shouldResetOnMessage: (text) => {
+            const judged = judgeTask({
+                text,
+                mode: 'new-task',
+                bypassKeywords: config.bypassKeywords,
+                intensity: config.intensity,
+            });
+            return judged.verdict !== 'clear';
+        },
         onWarning: (toolName, agentId) => {
             ctx.logger?.warn(`[grill-first] 需求尚未确认（warn 模式，仅记录未拦截）：${toolName}（agent=${agentId}）`);
         },

package/dist/judge/heuristics.d.ts

@@ -1,11 +1,13 @@
 /**
  * 纯函数启发式判定（R1）：不调 LLM，只看任务文本判断"需求是否已经够清楚"。
  *
- * 判定顺序（先命中先返回）：bypass 关键词 → 追问/继续类消息 → 文本过短且无动作 →
+ * 判定顺序（先命中先返回）：bypass 关键词 → 追问/继续类消息 → 纯询问（问句/只读咨询）→ 文本过短且无动作 →
  * 四个需求维度（目标/范围/约束/验收标准）的覆盖度。
  */
 /** 判定模式：新任务 / 任务中途的需求变更检查。 */
 export type JudgeMode = 'new-task' | 'drift-check';
+/** 追问力度：只影响判定阈值，不改变判定顺序。 */
+export type JudgeIntensity = 'gentle' | 'standard' | 'grill';
 /** 判定结论。 */
 export type JudgeVerdict = 'clear' | 'needs-clarification';
 /** 四个需求维度是否在文本里被提到。 */
@@ -20,6 +22,8 @@ export interface JudgeInput {
     text: string;
     mode: JudgeMode;
     bypassKeywords?: readonly string[];
+    /** 追问力度（默认 standard，保持旧行为）。 */
+    intensity?: JudgeIntensity;
 }
 /** 判定输出。 */
 export interface JudgeResult {
@@ -45,6 +49,13 @@ export declare function hasBypassKeyword(text: string, keywords: readonly string
 export declare function isFollowUpMessage(text: string): boolean;
 /** 由缺失维度生成追问提示。 */
 export declare function buildFocusHints(hit: DimensionHit, extra?: string[]): string[];
+/**
+ * 是否是"纯询问"消息：问句或让我查/看/评估，且没有任何动手信号。
+ *
+ * 这类消息不需要澄清——用户就是要一个回答，继续追问反而是打扰。
+ * @param text 用户原文。
+ */
+export declare function isInquiry(text: string): boolean;
 /**
  * 判定任务文本是否需要澄清（纯函数，可单测）。
  * @param input 任务文本 + 模式 + 跳过关键词。

package/dist/judge/heuristics.js

@@ -1,7 +1,7 @@
 /**
  * 纯函数启发式判定（R1）：不调 LLM，只看任务文本判断"需求是否已经够清楚"。
  *
- * 判定顺序（先命中先返回）：bypass 关键词 → 追问/继续类消息 → 文本过短且无动作 →
+ * 判定顺序（先命中先返回）：bypass 关键词 → 追问/继续类消息 → 纯询问（问句/只读咨询）→ 文本过短且无动作 →
  * 四个需求维度（目标/范围/约束/验收标准）的覆盖度。
  */
 /** 默认跳过关键词（R4）。 */
@@ -14,17 +14,23 @@ export const DIMENSION_HINTS = {
     acceptance: '验收标准缺失：怎样算完成？用什么方式验证？',
 };
 /** 维度关键词：目标（有动作、有产出）。 */
-const GOAL_WORDS = /(做|写|实现|搭建|开发|创建|新增|加个|修复|改|优化|重构|迁移|升级|翻译|整理|分析|生成|设计|部署|发布|测试|排查|调研|对比|总结|转换|导出|导入|接入|对接|编写|画|制作|搞|弄)/;
+const GOAL_WORDS = /(做|写|实现|搭建|开发|创建|新增|加个|修复|改|优化|重构|迁移|升级|翻译|整理|分析|生成|设计|部署|发布|测试|排查|调研|对比|总结|转换|导出|导入|接入|对接|编写|画|制作|搞|弄|\b(?:fix|add|implement|build|create|refactor|migrate|write|update|remove|delete|optimi[sz]e|translate|generate|analy[sz]e|design|deploy|publish|rewrite|upgrade|install|configure|support|enable|disable|clean|split|merge|rename)\b)/i;
 /** 维度关键词：范围（边界、对象）。 */
-const SCOPE_WORDS = /(只|仅|只要|只需要|范围|限定|针对|面向|所有|全部|部分|哪些|哪个|模块|页面|文件|目录|接口|字段|表|库|版本|第一步|先做|不含|除外)/;
+const SCOPE_WORDS = /(只|仅|只要|只需要|范围|限定|针对|面向|所有|全部|部分|哪些|哪个|模块|页面|文件|目录|接口|字段|表|库|版本|第一步|先做|不含|除外|\b(?:only|all|each|every|field|fields|page|pages|file|files|directory|module|api|endpoint|component|table|schema|version|repo|repository|branch|config|first)\b)/i;
 /** 维度关键词：约束（技术栈、限制、风格）。忽略大小写，便于匹配 Python / UTF-8 这类写法。 */
-const CONSTRAINT_WORDS = /(用|基于|必须|不能|不要|需要|依赖|兼容|保持|风格|注释|技术栈|框架|语言|不许|禁止|限制|预算|时间|截止|格式|规范|utf-?8|中文|英文|node|python|js|ts|react|vue|java|go|rust)/i;
+const CONSTRAINT_WORDS = /(用|基于|必须|不能|不要|需要|依赖|兼容|保持|风格|注释|技术栈|框架|语言|不许|禁止|限制|预算|时间|截止|格式|规范|utf-?8|中文|英文|node|python|js|ts|react|vue|java|go|rust|\b(?:must|should|shall|need|needs|require|requires|required|use|using|based\s+on|compatible|compatibility|keep|preserve|avoid|without|existing)\b)/i;
 /** 维度关键词：验收标准。 */
-const ACCEPTANCE_WORDS = /(验收|标准|测试|通过|算完成|完成标准|结果|输出|期望|应该|返回|效果|达到|满足|可运行|跑通|全绿|正确|不报错|可用|验证|检查|示例|样例|截图|对比)/;
+const ACCEPTANCE_WORDS = /(验收|标准|测试|通过|算完成|完成标准|结果|输出|期望|应该|返回|效果|达到|满足|可运行|跑通|全绿|正确|不报错|可用|验证|检查|示例|样例|截图|对比|\b(?:acceptance|criteria|test|tests|pass|passes|passing|expect|expected|output|verify|verified|green|works|working|screenshot|sample|example)\b)/i;
 /** 动作动词（用于"短文本是否已构成一个可执行指令"）。 */
 const ACTION_VERB = /(做|写|改|加|删|实现|搭建|开发|修复|优化|翻译|整理|分析|生成|设计|部署|测试|排查|调研|总结|转换|导出|接入|创建|重构|迁移|升级|安装|配置|画|制作)/;
 /** 追问/继续类消息的开头。 */
 const FOLLOW_UP_LEAD = /^(继续|接着|然后呢|然后|下一步|再来|嗯|好|可以|行|ok|OK|对|是的|收到|谢谢|辛苦)/;
+/** 问句收尾：出现即说明用户在提问，而不是在派活。 */
+const QUESTION_TAIL = /(吗|呢|么|嘛|是不是|能不能|可不可以|有没有|怎么样|如何|为什么|为啥|啥意思|多少|哪个好)\s*[？?]?$|[？?]\s*$/;
+/** 询问式开头：让我查/看/评估/解释，而不是让我动手。 */
+const INQUIRY_LEAD = /^(?:please\s+|pls\s+|could you\s+|can you\s+)?(请问|问一下|想问|问下|看看|看一下|检查|查一下|查查|列出|列一下|统计|解释|说明|对比|评估|推荐|你觉得|你认为|这个|那个|现在|目前|为啥|为什么|look|check|see|show|list|tell|explain|describe|review|evaluate|summari[sz]e|search|find|verify|what|why|how|which)/i;
+/** 明确的动手信号：一旦出现就不算纯询问（"改一下这个吗"仍然要先澄清）。 */
+const WRITE_SIGNAL = /(改|写|删|新建|实现|修复|重构|迁移|生成|替换|安装|部署|发布|合并|提交|制作|画|创建|搭建|开发|添加|增加|移除)|\b(?:fix|add|implement|build|create|refactor|migrate|write|update|remove|delete|change|edit|rename|move|split|merge|install|deploy|publish|upgrade|generate|replace)\b/i;
 /** 具体化信号：出现即说明用户给了可落地的细节。 */
 const SPECIFIC_PATTERNS = [
     /[A-Za-z0-9_\-./\\]+\.(ts|js|mjs|cjs|tsx|jsx|json|md|py|go|rs|java|c|cc|cpp|h|hpp|yml|yaml|toml|txt|csv|xlsx|png|jpg|jpeg|svg|html|css|vue|sh|ps1)/i,
@@ -92,6 +98,26 @@ export function buildFocusHints(hit, extra = []) {
     }
     return [...extra, ...hints].slice(0, 4);
 }
+/**
+ * 是否是"纯询问"消息：问句或让我查/看/评估，且没有任何动手信号。
+ *
+ * 这类消息不需要澄清——用户就是要一个回答，继续追问反而是打扰。
+ * @param text 用户原文。
+ */
+export function isInquiry(text) {
+    const flat = text.trim();
+    if (flat === '')
+        return false;
+    if (WRITE_SIGNAL.test(flat))
+        return false;
+    return QUESTION_TAIL.test(flat) || INQUIRY_LEAD.test(flat);
+}
+/** 各力度档位的判定阈值：维度下限 + 是否强制覆盖验收标准。 */
+const INTENSITY_THRESHOLDS = {
+    gentle: { dims: 2, needAcceptance: false },
+    standard: { dims: 3, needAcceptance: false },
+    grill: { dims: 3, needAcceptance: true },
+};
 /**
  * 判定任务文本是否需要澄清（纯函数，可单测）。
  * @param input 任务文本 + 模式 + 跳过关键词。
@@ -102,6 +128,8 @@ export function judgeTask(input) {
     const dimensions = detectDimensions(text);
     const satisfied = satisfiedCount(dimensions);
     const score = satisfied * 25;
+    const intensity = input.intensity ?? 'standard';
+    const threshold = INTENSITY_THRESHOLDS[intensity] ?? INTENSITY_THRESHOLDS.standard;
     if (text === '') {
         return {
             verdict: 'needs-clarification',
@@ -117,9 +145,12 @@ export function judgeTask(input) {
     if (isFollowUpMessage(text)) {
         return { verdict: 'clear', score: 95, focus_hints: [], dimensions, reason: 'follow-up' };
     }
+    if (isInquiry(text)) {
+        return { verdict: 'clear', score: 90, focus_hints: [], dimensions, reason: 'inquiry' };
+    }
     if (input.mode === 'drift-check') {
         const drift = DRIFT_MARKERS.test(text);
-        if (satisfied >= 3 && text.length >= 20) {
+        if (satisfied >= threshold.dims && text.length >= 20) {
             return { verdict: 'clear', score, focus_hints: [], dimensions, reason: 'drift-well-specified' };
         }
         return {
@@ -141,7 +172,7 @@ export function judgeTask(input) {
             reason: 'too-short',
         };
     }
-    if (satisfied >= 3) {
+    if (satisfied >= threshold.dims && (!threshold.needAcceptance || dimensions.acceptance)) {
         return { verdict: 'clear', score, focus_hints: [], dimensions, reason: 'dimensions-covered' };
     }
     if (satisfied === 2 && (hasSpecifics(text) || TRANSFORM_PATTERN.test(text))) {

package/dist/memory/store.d.ts

@@ -26,6 +26,10 @@ export interface MemorySnapshot {
 }
 /** forget() 的作用范围。 */
 export type MemoryScope = 'global' | 'project' | 'all';
+/** 项目层记忆的落点（0.1.4）：跟着工作区走，或全局共享一份。 */
+export type ProjectScope = 'project' | 'global';
+/** 项目层历史条目的保留上限（0.1.4 修：以前只增不减，文件会越长越大）。 */
+export declare const MAX_HISTORY = 100;
 /** 摘要长度上限（字符数），供注入提示用。 */
 export declare const SUMMARY_LIMIT = 500;
 /** 空全局层。 */
@@ -44,13 +48,18 @@ export declare function resolveWorkspace(workspaceRoot?: string): string;
  * 固定到 `~/.dsh/grill-first/`（跨 profile 共享用户偏好，语义上也更合理）。
  */
 export declare function globalMemoryPath(): string;
-/** 项目记忆文件路径：`<workspace>/.dsh/grill-first/memory.json`。 */
-export declare function projectMemoryPath(workspaceRoot?: string): string;
+/**
+ * 项目记忆文件路径。
+ * @param workspaceRoot 工作区根目录。
+ * @param scope project（默认）= `<workspace>/.dsh/grill-first/memory.json`；
+ *   global = 与 global.json 同目录的 `project.json`（不想往项目里写文件时用）。
+ */
+export declare function projectMemoryPath(workspaceRoot?: string, scope?: ProjectScope): string;
 /**
  * 读取两层记忆。
  * @param workspaceRoot 工作区根目录；省略时用 `process.cwd()`。
  */
-export declare function loadMemory(workspaceRoot?: string): Promise<MemorySnapshot>;
+export declare function loadMemory(workspaceRoot?: string, scope?: ProjectScope): Promise<MemorySnapshot>;
 /**
  * 追加一条全局偏好（按文本去重，重复则刷新 updated 时间）。
  * @param text 偏好原文，例如"注释一律用中文"。
@@ -63,14 +72,14 @@ export declare function savePreference(text: string, tags: string[], workspaceRo
  * @param text 项目背景原文。
  * @param workspaceRoot 工作区根目录。
  */
-export declare function saveProjectContext(text: string, workspaceRoot?: string): Promise<void>;
+export declare function saveProjectContext(text: string, workspaceRoot?: string, scope?: ProjectScope): Promise<void>;
 /**
  * 追加一条历史需求记录（R3：需求清单只进这里，绝不落盘成需求文件）。
  * @param task 任务原文或摘要。
  * @param requirements 用户确认过的四段式需求清单。
  * @param workspaceRoot 工作区根目录。
  */
-export declare function saveHistory(task: string, requirements: string, workspaceRoot?: string): Promise<void>;
+export declare function saveHistory(task: string, requirements: string, workspaceRoot?: string, scope?: ProjectScope): Promise<void>;
 /**
  * 清除记忆。
  * @param scope `global` 只清全局层、`project` 只清项目层、`all` 两层都清。

package/dist/memory/store.js

@@ -8,6 +8,8 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
+/** 项目层历史条目的保留上限（0.1.4 修：以前只增不减，文件会越长越大）。 */
+export const MAX_HISTORY = 100;
 /** 摘要长度上限（字符数），供注入提示用。 */
 export const SUMMARY_LIMIT = 500;
 /** 摘要里各段的条数上限。 */
@@ -43,8 +45,15 @@ export function globalMemoryPath() {
     const base = override && override.trim() !== '' ? path.resolve(override) : path.join(homedir(), '.dsh', 'grill-first');
     return path.join(base, 'global.json');
 }
-/** 项目记忆文件路径：`<workspace>/.dsh/grill-first/memory.json`。 */
-export function projectMemoryPath(workspaceRoot) {
+/**
+ * 项目记忆文件路径。
+ * @param workspaceRoot 工作区根目录。
+ * @param scope project（默认）= `<workspace>/.dsh/grill-first/memory.json`；
+ *   global = 与 global.json 同目录的 `project.json`（不想往项目里写文件时用）。
+ */
+export function projectMemoryPath(workspaceRoot, scope = 'project') {
+    if (scope === 'global')
+        return path.join(path.dirname(globalMemoryPath()), 'project.json');
     return path.join(resolveWorkspace(workspaceRoot), '.dsh', 'grill-first', 'memory.json');
 }
 /** 归一化用于去重比较的文本（去空白、统一小写、去尾部标点）。 */
@@ -109,9 +118,9 @@ function coerceProject(value) {
  * 读取两层记忆。
  * @param workspaceRoot 工作区根目录；省略时用 `process.cwd()`。
  */
-export async function loadMemory(workspaceRoot) {
+export async function loadMemory(workspaceRoot, scope = 'project') {
     const global = coerceGlobal(await readJson(globalMemoryPath(), emptyGlobal()));
-    const project = coerceProject(await readJson(projectMemoryPath(workspaceRoot), emptyProject()));
+    const project = coerceProject(await readJson(projectMemoryPath(workspaceRoot, scope), emptyProject()));
     return { global, project };
 }
 /**
@@ -152,11 +161,11 @@ export async function savePreference(text, tags, workspaceRoot) {
  * @param text 项目背景原文。
  * @param workspaceRoot 工作区根目录。
  */
-export async function saveProjectContext(text, workspaceRoot) {
+export async function saveProjectContext(text, workspaceRoot, scope = 'project') {
     const trimmed = text.trim();
     if (trimmed === '')
         return;
-    const file = projectMemoryPath(workspaceRoot);
+    const file = projectMemoryPath(workspaceRoot, scope);
     const memory = coerceProject(await readJson(file, emptyProject()));
     const key = normalizeKey(trimmed);
     if (!memory.project_context.some((t) => normalizeKey(t) === key)) {
@@ -170,14 +179,17 @@ export async function saveProjectContext(text, workspaceRoot) {
  * @param requirements 用户确认过的四段式需求清单。
  * @param workspaceRoot 工作区根目录。
  */
-export async function saveHistory(task, requirements, workspaceRoot) {
-    const file = projectMemoryPath(workspaceRoot);
+export async function saveHistory(task, requirements, workspaceRoot, scope = 'project') {
+    const file = projectMemoryPath(workspaceRoot, scope);
     const memory = coerceProject(await readJson(file, emptyProject()));
     memory.history.push({
         task: task.trim().slice(0, 200),
         requirements: requirements.trim().slice(0, 2000),
         date: new Date().toISOString().slice(0, 10),
     });
+    // 只保留最近 MAX_HISTORY 条：摘要只用最后 3 条，其余留着也读不到。
+    if (memory.history.length > MAX_HISTORY)
+        memory.history = memory.history.slice(-MAX_HISTORY);
     await writeJsonAtomic(file, memory);
 }
 /**

package/dist/tools/grillConfirm.d.ts

@@ -9,7 +9,7 @@
  *
  * R3 红线：需求清单只进记忆的 history 字段，绝不写任何需求文件。
  */
-import type { GrillConfig } from '../config.js';
+import type { GrillConfig, MemoryScope } from '../config.js';
 import type { GateRegistry } from '../gate/preExecute.js';
 import type { GrillAgent, ToolDefinition, UserQuestionsService } from '../types.js';
 import type { SessionRegistry } from './sessions.js';
@@ -20,6 +20,8 @@ export interface GrillConfirmDeps {
     sessions: SessionRegistry;
     /** 解析当前会话的工作区根目录（项目层记忆落点）。 */
     workspaceRoot: (agent?: GrillAgent) => string;
+    /** 项目层记忆落在工作区还是插件家目录（memoryScope 配置）。 */
+    memoryScope?: () => MemoryScope;
     /** 结构化提问服务（可能不存在）。 */
     questions: () => UserQuestionsService | undefined;
     logger?: {
@@ -38,6 +40,9 @@ export interface GrillConfirmResult {
     skipped?: boolean;
     reason?: string;
     error?: string;
+    /** 已追问轮数 / 剩余轮数（选"要改"时给出，供模型判断还要不要继续问）。 */
+    rounds_used?: number;
+    rounds_left?: number;
     saved?: {
         history: boolean;
         preferences: number;

package/dist/tools/grillConfirm.js

@@ -104,14 +104,15 @@ export function createGrillConfirmTool(deps) {
                 if (config.memoryEnabled) {
                     const root = deps.workspaceRoot(exec?.agent);
                     try {
-                        await saveHistory(task, requirements, root);
+                        const scope = deps.memoryScope?.() ?? 'project';
+                        await saveHistory(task, requirements, root, scope);
                         saved.history = true;
                         for (const preference of preferences) {
                             await savePreference(preference, ['用户确认'], root);
                             saved.preferences += 1;
                         }
                         const context = requirements.replace(/\s+/g, ' ').slice(0, PROJECT_CONTEXT_LIMIT);
-                        await saveProjectContext(context, root);
+                        await saveProjectContext(context, root, scope);
                         saved.project_context = true;
                     }
                     catch (error) {
@@ -176,12 +177,22 @@ export function createGrillConfirmTool(deps) {
                 const result = await accept('structured-question');
                 return custom === '' ? result : { ...result, user_note: custom };
             }
+            const rounds = deps.sessions.bumpRound(agentId);
+            const maxRounds = config.maxRounds;
+            const roundsLeft = Math.max(0, maxRounds - rounds);
             return {
                 confirmed: false,
                 requirements,
                 feedback: custom !== ''
                     ? custom
                     : '用户选择了"要改"，但没有写明改哪里：请追问具体修改点，修订需求清单后再次调用 grill_confirm。',
+                rounds_used: rounds,
+                rounds_left: roundsLeft,
+                ...(roundsLeft === 0
+                    ? {
+                        instructions: `已达追问轮数上限（${maxRounds} 轮）：不要再问，直接按当前理解开工——下次调用 grill_start 会返回 clear。`,
+                    }
+                    : {}),
             };
         },
     };

package/dist/tools/grillStart.d.ts

@@ -4,7 +4,7 @@
  * - clear：放行（门禁置 open），模型直接开工；
  * - needs-clarification：门禁置 closed，并返回记忆摘要、追问方向与轮次上限。
  */
-import type { GrillConfig } from '../config.js';
+import type { GrillConfig, MemoryScope } from '../config.js';
 import type { GateRegistry } from '../gate/preExecute.js';
 import type { GrillAgent, ToolDefinition } from '../types.js';
 import type { SessionRegistry } from './sessions.js';
@@ -15,6 +15,8 @@ export interface GrillStartDeps {
     sessions: SessionRegistry;
     /** 解析当前会话的工作区根目录（项目层记忆落点）。 */
     workspaceRoot: (agent?: GrillAgent) => string;
+    /** 项目层记忆落在工作区还是插件家目录（memoryScope 配置）。 */
+    memoryScope?: () => MemoryScope;
     logger?: {
         warn(message: string): void;
     };
@@ -35,6 +37,8 @@ export interface GrillStartResult {
     task_id?: string;
     previous_task?: string;
     hint?: string;
+    /** 已经追问过的轮数（达到 maxRounds 后不再追问）。 */
+    rounds_used?: number;
     /** 当前运行的插件版本（取自 package.json）：用于确认改动是否已随重启生效。 */
     version?: string;
 }

package/dist/tools/grillStart.js

@@ -43,6 +43,7 @@ const OUTPUT_SCHEMA = {
         task_id: { type: 'string' },
         previous_task: { type: 'string' },
         hint: { type: 'string' },
+        rounds_used: { type: 'number', description: '已经追问过的轮数' },
         version: { type: 'string', description: '运行中的插件版本；若缺失说明宿主加载的是旧版代码，需重启 DSH' },
     },
     additionalProperties: true,
@@ -77,7 +78,12 @@ export function createGrillStartTool(deps) {
                     version: PLUGIN_VERSION,
                 };
             }
-            const judged = judgeTask({ text: task, mode, bypassKeywords: config.bypassKeywords });
+            const judged = judgeTask({
+                text: task,
+                mode,
+                bypassKeywords: config.bypassKeywords,
+                intensity: config.intensity,
+            });
             const previous = deps.sessions.get(agentId);
             if (judged.verdict === 'clear') {
                 deps.sessions.end(agentId);
@@ -93,12 +99,29 @@ export function createGrillStartTool(deps) {
                 };
             }
             const startedAt = Date.now();
-            deps.sessions.start({ agentId, task, mode, startedAt });
+            // maxRounds 兜底：问够轮数就不再问，直接按当前理解开工（0.1.4 修：以前这个配置项根本没生效）。
+            const roundsUsed = previous?.rounds ?? 0;
+            if (roundsUsed >= config.maxRounds) {
+                deps.sessions.end(agentId);
+                deps.gates.open(agentId);
+                return {
+                    verdict: 'clear',
+                    skip: true,
+                    reason: 'max-rounds-reached',
+                    score: judged.score,
+                    gate_state: 'open',
+                    mode,
+                    rounds_used: roundsUsed,
+                    hint: `已经追问 ${roundsUsed} 轮（上限 ${config.maxRounds}），按当前理解直接开工；有歧义就先做最小可验证版本。`,
+                    version: PLUGIN_VERSION,
+                };
+            }
+            deps.sessions.start({ agentId, task, mode, startedAt, rounds: roundsUsed });
             deps.gates.close(agentId);
             let memoryContext = '';
             if (config.memoryEnabled) {
                 try {
-                    memoryContext = summarize(await loadMemory(deps.workspaceRoot(exec?.agent)));
+                    memoryContext = summarize(await loadMemory(deps.workspaceRoot(exec?.agent), (deps.memoryScope?.() ?? 'project')));
                 }
                 catch (error) {
                     deps.logger?.warn(`[grill-first] 读取记忆失败：${error instanceof Error ? error.message : String(error)}`);
@@ -118,6 +141,7 @@ export function createGrillStartTool(deps) {
                 intensity: config.intensity,
                 mode,
                 task_id: `${agentId}:${startedAt}`,
+                rounds_used: roundsUsed,
                 version: PLUGIN_VERSION,
                 ...(previous?.task ? { previous_task: previous.task } : {}),
             };

package/dist/tools/sessions.d.ts

@@ -9,12 +9,16 @@ export interface GrillSession {
     task: string;
     mode: JudgeMode;
     startedAt: number;
+    /** 已经追问过几轮（用户选"要改"算一轮），用于落实 maxRounds 上限。 */
+    rounds?: number;
 }
 /** agent → 会话 的内存态映射（进程内，不持久化）。 */
 export declare class SessionRegistry {
     private readonly sessions;
     /** 登记/覆盖一个 agent 的当前任务。 */
     start(session: GrillSession): void;
+    /** 记一轮追问（用户选"要改"时调用），返回累计轮数。 */
+    bumpRound(agentId: string): number;
     /** 读取某个 agent 的当前任务。 */
     get(agentId: string): GrillSession | undefined;
     /** 结束某个 agent 的澄清会话（确认完成或跳过）。 */

package/dist/tools/sessions.js

@@ -5,7 +5,15 @@ export class SessionRegistry {
     start(session) {
         if (!session.agentId)
             return;
-        this.sessions.set(session.agentId, session);
+        this.sessions.set(session.agentId, { ...session, rounds: session.rounds ?? 0 });
+    }
+    /** 记一轮追问（用户选"要改"时调用），返回累计轮数。 */
+    bumpRound(agentId) {
+        const session = this.sessions.get(agentId);
+        if (!session)
+            return 0;
+        session.rounds = (session.rounds ?? 0) + 1;
+        return session.rounds;
     }
     /** 读取某个 agent 的当前任务。 */
     get(agentId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-grill-first",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "DSH 插件：开工前刨根问底——把模糊需求问成明确需求，用户确认后才放行主任务",
   "icon": "./icon.png",
   "author": "InoriMutsumi",

package/README.repo.md

@@ -1,161 +0,0 @@
-# dsh-grill-first
-
-![tests](https://img.shields.io/badge/tests-91%20passing-brightgreen)
-![license](https://img.shields.io/badge/license-MIT-blue)
-![DSH plugin](https://img.shields.io/badge/DSH-plugin-blueviolet)
-
-> DSH（DeepSeek Harness）插件：**开工前先刨根问底**——把模糊需求问成明确需求，你在对话里点头之后，主任务才开工。
-
-## 它解决什么问题
-
-AI 助手最常见的失败不是"不会做"，而是"做完了才发现做的不是你要的"。这个插件在**任何新任务开工前**插入一道需求澄清环节：
-
-1. 模型先把你的任务原文交给 `grill_start` 判定；
-2. 任务模糊（缺目标 / 范围 / 约束 / 验收标准）→ 它按轮追问你，每轮 3 个问题，最多 3 轮，每轮都基于你上一轮的回答继续深挖；
-3. 问清后整理成中文四段清单（目标 / 范围 / 约束 / 验收标准），用 `grill_confirm` 请你确认；
-4. 你点"确认，按此开工"→ 本次任务放行；你点"要改"→ 它按你的反馈修订后再来一次；
-5. 一句话就能说清的小任务、以及带「直接做 / 跳过提问 / 不用问 / skip」字样的消息，**不会被打扰**。
-
-严格档位（`gateMode: "strict"`）下，需求没确认前模型无法执行写文件、跑命令这类**变更类**操作——从机制上保证"没问清就不许动手"。
-
-## 安装
-
-装插件前请先退出正在跑的任务。两种方式任选：
-
-**方式一：DSH 插件市场**（推荐）
-
-在 DSH 设置 → 插件里搜索 `dsh-grill-first` 一键安装。
-
-**方式二：本地包 / GitHub 仓库**
-
-```bash
-dsh plugin --profile <你的 profile 名> add /绝对路径/dsh-grill-first-0.1.1.tgz
-dsh plugin --profile <你的 profile 名> add github:InoriMutsumi/dsh-grill-first
-```
-
-装完**即生效**：本机实测 DSH 的 live profile 会热加载新插件，不需要重启（若你的 profile 是启动式、或列表里没出现，再完全退出 DSH 重开一次）。
-
-## 使用
-
-装好之后不需要你做什么：它靠两件事自动工作。
-
-- **协议提示段**：插件往系统提示里注入一小段中文协议（约 600 字），告诉模型"接到新任务先调 `grill_start`"。你在系统提示里能看到 `【开工前提问协议（grill-first）】` 就说明装好了。
-- **工具**：模型会用这两个工具推进澄清流程。
-
-| 工具 | 作用 |
-|---|---|
-| `grill_start` | 判定任务是否需要澄清；返回 `verdict`、`focus_hints`（该问什么）、`memory_context`（已知偏好，避免重复问） |
-| `grill_confirm` | 把四段式需求清单交给你确认；确认后放行任务，并把确认过的内容写进记忆 |
-
-### 想跳过提问时
-
-- 消息里带上「**直接做**」「**跳过提问**」「**不用问**」「**skip**」中任意一个 → 立刻开工；
-- 或者在设置里把 `enabled` 关掉 / 把 `gateMode` 调成 `off` → 整个插件静默。
-
-## 配置项
-
-DSH 设置界面 → 插件 → dsh-grill-first，共 7 项：
-
-| 配置 | 类型 | 默认 | 说明 |
-|---|---|---|---|
-| `enabled` | 布尔 | `true` | 总开关。关闭后既不追问也不拦截工具 |
-| `gateMode` | `off` / `warn` / `strict` | `warn` | `off` 不拦截；`warn` 只在日志里记录"需求未确认"；`strict` 未确认前拦截变更类工具 |
-| `maxQuestionsPerRound` | 1-6 | `3` | 每轮最多问几个问题 |
-| `maxRounds` | 1-10 | `3` | 最多追问几轮 |
-| `intensity` | `gentle` / `standard` / `grill` | `standard` | 追问力度：只问关键点 / 标准 / 刨根问底 |
-| `bypassKeywords` | 字符串数组 | `["直接做","跳过提问","不用问","skip"]` | 命中即跳过提问 |
-| `memoryEnabled` | 布尔 | `true` | 是否启用两层记忆 |
-
-> 默认是 `warn` 而不是 `strict`：默认档位保证升级插件不会突然卡住你已有的工作流。想要硬门禁请手动切 `strict`。
-
-### 怎么改配置
-
-DSH 设置页里的插件条目目前只提供「启用 / 停用」开关（客户端的插件页不渲染第三方插件的配置表单），要改上面 7 项请编辑 **profile 的补丁层** `cordis.patch.yml`：
-
-```yaml
-# <profile 目录>/cordis.patch.yml
-- id: dsh-grill-first
-  name: dsh-grill-first
-  config:
-    gateMode: strict          # off | warn | strict
-    maxQuestionsPerRound: 3   # 1-6
-    maxRounds: 3              # 1-10
-    intensity: standard       # gentle | standard | grill
-    memoryEnabled: true
-    bypassKeywords: [直接做, 跳过提问, 不用问, skip]
-```
-
-改完重启 DSH 生效。只写想改的项也可以，其余项用默认值。
-
-## 两层记忆
-
-只记录**你确认过**的内容，不记录对话原文，也不会把需求清单写成文件。
-
-| 层 | 位置 | 内容 |
-|---|---|---|
-| 全局层 | `<profile 目录>/grill-first/global.json`（不可写时退化到 `~/.dsh-grill-first/global.json`） | 通用偏好，如"注释一律用中文" |
-| 项目层 | `<工作区>/.dsh/grill-first/memory.json` | 项目背景、任务历史（任务名 + 需求摘要 + 日期） |
-
-下次追问时，`grill_start` 会把这些内容作为 `memory_context` 返回，模型就不会重复问你同一件事。
-
-## 开发
-
-```bash
-npm install          # 装开发依赖（schemastery 由宿主提供，仅开发期需要）
-npm run build        # TypeScript → dist/
-npm test             # 构建 + 94 个单测 / 端到端场景测试
-node scripts/selfcheck.mjs   # 静态自检：中文 JSDoc、any 用量、需求→代码位置
-```
-
-推送到 GitHub 后 `.github/workflows/ci.yml` 会自动跑上面那两条（`npm ci` + `npm test`）。`dist/` 是**故意提交**的：这样 `dsh plugin add github:…` 装完即可用，不需要在你的机器上编译。
-
-代码结构：
-
-```
-src/
-  index.ts              插件装配入口（工具 + 协议段 + 门禁）
-  config.ts             配置归一化（不依赖宿主，可单测）
-  configSchema.ts       Schemastery 配置声明（设置界面用，7 项）
-  version.ts            从 package.json 读版本号，供 grill_start 返回
-  judge/heuristics.ts   任务模糊度判定（纯函数）
-  prompt/protocol.ts    注入系统提示的中文协议文本
-  tools/grillStart.ts   grill_start 工具
-  tools/grillConfirm.ts grill_confirm 工具
-  gate/preExecute.ts    变更类工具门禁（tools/pre-execute + 新消息重置）
-  memory/store.ts       两层记忆的读写
-```
-
-## 兼容性与适配
-
-本插件对外只有两处依赖，都不归 DSH 的"插件版本门禁"管：
-
-- **peer 依赖**：只有 `@deepseek-ai/schemastery`（`^3.18.1`，宿主自带；DSH 0.2.1-rc.2 里解析到的实际版本是 3.18.5）。
-- **宿主扩展点**：cordis 上下文 API —— `ctx.tools`（注册工具）、`ctx.get('userQuestions')`（结构化提问通道）、`ctx.inject(['systemPrompt'])`、事件 `tools/pre-execute` 与 `agent/inbox/inserted`。
-
-它**不 import 任何 `@deepseek-ai/dsh*` 运行时包**，所以既没有 `engines.dsh`，也没有 `@deepseek-ai/dsh` peer。DSH 的 `plugin-compatibility` 检查（`dsh-app-boot` 里的 `evaluatePluginCompatibility`）只在插件声明了 `engines.dsh` 或 `@deepseek-ai/dsh*` peer 时才介入，判不过才会被拦；本插件两条都不沾，因此升 DSH 一般不需要改代码。
-
-> 以后若要 import harness 内部包，请显式声明 peer 范围并带上预发布分支，例如
-> `">=0.2.0-rc.2 <0.3.0-0 || >=0.2.1-rc.1 <0.3.0-0"`。
-> DSH 自己的门禁用 `semver.satisfies(..., { includePrerelease: true })` 判定，`^0.2.0-rc.2` 能匹配 `0.2.1-rc.2`；
-> 但标准 npm 语义（不加 `includePrerelease`）会判不匹配，所以上游要求写显式分支。
-
-已验证的宿主版本：`0.2.0-rc.2`（0.1.x 开发期）、`0.2.1-rc.2`（2026-10-17 复核：`typecheck`、94 个单测、`verify-installed` 一致，且实测加载运行）。升完 DSH 后的自检三步：
-
-```bash
-node scripts/verify-installed.mjs   # 安装拷贝与仓库产物是否一致
-# 调一次 grill_start：返回里的 version 就是当前正在跑的插件版本
-# 再执行一个需要确认的任务：确认门禁仍然会拦（而不是悄悄放行）
-```
-
-## 已知限制
-
-- 门禁只对**根 agent**（能直接跟你对话的那个）生效；子 agent / 团队成员不拦，否则正常的委派工作流会被卡死。因此**委派类工具本身**（`subagent`、`workflow`、`spawn_teammate`…）在未确认前也会被拦，防止"派个子代理替自己动手"绕过门禁。
-- `warn` 档位只能"记录不拦截"：DSH 的 `tools/pre-execute` 事件没有"放行但同时给模型提示"这种返回形态。
-- 记忆是本地文件，不含加密；删掉对应 json 即清空。
-- `grill_confirm` 优先走 DSH 的结构化提问通道；该通道不可用时（例如子 agent 内部）会返回 `needs_user_confirmation: true`，由模型改用内置提问工具兜底。
-- **改代码后必须重启 DSH**：DSH 加载的是 profile 里那份安装拷贝，而且插件**代码**改动不会热生效（实测：`cordis.patch.yml` 里的**配置**改动是热生效的，包代码不是）。判断运行中的是哪一版：调一次 `grill_start`，返回里的 `version` 字段就是当前在跑的版本；看不到 `version` 说明跑的是 0.1.0 之前的旧代码。
-- 跳过关键词里**英文按词边界匹配**（`skip` 能命中 `skip`、`Skip this`、`（skip）`，但不会命中 `skipList`、`skip_list`、`bypass-keyword` 这类标识符）；中文关键词按子串匹配（`直接做` 命中 `那你直接做好了`）。
-
-## 许可
-
-MIT，见 [LICENSE](./LICENSE)。