dsh-grill-first 0.1.3 → 0.1.5

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.5",
   "description": "DSH 插件：开工前刨根问底——把模糊需求问成明确需求，用户确认后才放行主任务",
   "icon": "./icon.png",
   "author": "InoriMutsumi",