kcode-pi 0.1.35 → 0.1.39

package/extensions/kingdee-harness.ts

@@ -11,8 +11,10 @@ import {
 	ensurePhaseArtifact,
 	finishActiveRun,
 	listRuns,
+	openBlockingQuestions,
 	readActiveRun,
 	refreshGate,
+	reviseFact,
 	switchActiveRun,
 	updateProductProfile,
 	updatePhaseArtifact,
@@ -28,6 +30,7 @@ import { windowsPathHint } from "../src/platform/path.ts";
 import { repairPromptForRun, workflowPromptForRun } from "../src/harness/prompt.ts";
 import { recordVerifyResult, type VerifyResultOutcome } from "../src/harness/repair.ts";
 import { isSubagentChild, subagentRoleFromEnv, subagentToolCallBlockReason } from "../src/harness/delegation.ts";
+import { questionAskBlockReason } from "../src/harness/question-memory.ts";
 
 function requireRun(cwd: string): ReturnType<typeof readActiveRun> {
 	return readActiveRun(cwd);
@@ -172,13 +175,15 @@ const kdQuestionTool = defineTool({
 	name: "kd_question",
 	label: "KD 问题",
 	description:
-		"创建、回答或列出金蝶 Harness 结构化问题。每次必须只记录一个最阻塞的短问题。",
+		"创建、回答、修订或列出金蝶 Harness 结构化问题。每次必须只记录一个最阻塞的短问题。",
 	parameters: Type.Object({
-		action: Type.Optional(Type.String({ description: "操作类型：ask、answer 或 list，默认 ask。" })),
+		action: Type.Optional(Type.String({ description: "操作类型：ask、answer、revise 或 list，默认 ask。" })),
 		id: Type.Optional(Type.String({ description: "回答问题时的问题编号，例如 Q-001。" })),
 		question: Type.Optional(Type.String({ description: "提问内容；必须是一个短问题。" })),
 		answer: Type.Optional(Type.String({ description: "用户答案，action=answer 时使用。" })),
 		reason: Type.Optional(Type.String({ description: "当前阶段阻塞原因。" })),
+		factLabel: Type.Optional(Type.String({ description: "该问题要补齐的结构化事实标签，例如 目标 FormId/单据或表单标识。" })),
+		proposedFactValue: Type.Optional(Type.String({ description: "确认题中的候选事实值；用户回答是/yes 时写入 factLabel。" })),
 		choices: Type.Optional(Type.Array(Type.String(), { description: "候选答案；最多 3 个简短选项。" })),
 		blocking: Type.Optional(Type.Boolean({ description: "控制问题是否阻塞阶段推进，默认 true。" })),
 	}),
@@ -199,17 +204,24 @@ const kdQuestionTool = defineTool({
 		}
 
 		if (action === "answer") {
-			if (!params.id || !params.answer) {
+			if (!params.id || !params.answer?.trim()) {
 				return {
 					content: [{ type: "text", text: "kd_question action=answer 必须同时提供 id 和 answer。" }],
 					details: { error: "missing-answer-params" },
 				};
 			}
+			const existingQuestion = (run.questions ?? []).find((question) => question.id === params.id);
+			if (existingQuestion?.status === "answered") {
+				return {
+					content: [{ type: "text", text: `${params.id} 已回答，禁止重复覆盖。用户明确更正事实时使用 kd_question action=revise factLabel="<事实标签>" answer="<新值>" reason="<更正原因>"。` }],
+					details: { error: "question-already-answered", question: existingQuestion },
+				};
+			}
 			const answered = answerQuestion(ctx.cwd, run, params.id, params.answer);
 			if (!answered) {
 				return {
-					content: [{ type: "text", text: `未找到问题：${params.id}` }],
-					details: { error: "question-not-found", id: params.id },
+					content: [{ type: "text", text: existingQuestion ? `未能记录 ${params.id} 的答案；答案不能为空或占位内容。` : `未找到问题：${params.id}` }],
+					details: { error: existingQuestion ? "invalid-answer" : "question-not-found", id: params.id },
 				};
 			}
 			appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
@@ -220,9 +232,35 @@ const kdQuestionTool = defineTool({
 			};
 		}
 
+		if (action === "revise") {
+			if (!params.factLabel?.trim() || !params.answer?.trim()) {
+				return {
+					content: [{ type: "text", text: "kd_question action=revise 必须同时提供 factLabel 和 answer。" }],
+					details: { error: "missing-revise-params" },
+				};
+			}
+			const fact = reviseFact(ctx.cwd, run, {
+				factLabel: params.factLabel,
+				value: params.answer,
+				reason: params.reason,
+			});
+			if (!fact) {
+				return {
+					content: [{ type: "text", text: "未能修订结构化事实；factLabel 和 answer 不能为空。" }],
+					details: { error: "invalid-revision" },
+				};
+			}
+			appendQuestionEventToArtifact(ctx.cwd, run, [`- 已修订事实 ${fact.label}：${fact.value}`]);
+			const auto = autoAdvanceTool(ctx.cwd, run);
+			return {
+				content: [{ type: "text", text: `已修订事实 ${fact.label}：${fact.value}。${auto.advanced ? auto.message : `门禁仍阻塞：${auto.message}`}` }],
+				details: { fact, gate: readActiveRun(ctx.cwd)?.gate, autoAdvance: auto },
+			};
+		}
+
 		if (action !== "ask") {
 			return {
-				content: [{ type: "text", text: `未知 kd_question action：${params.action}。有效值：ask、answer、list。` }],
+				content: [{ type: "text", text: `未知 kd_question action：${params.action}。有效值：ask、answer、revise、list。` }],
 				details: { error: "unknown-action", action: params.action },
 			};
 		}
@@ -246,35 +284,39 @@ const kdQuestionTool = defineTool({
 							"登记第一个必须确认的问题，例如：",
 							"kd_question action=ask question=\"采购入库单 Form ID 是否为 pur_receivebill？\" choices=[\"是\", \"不是\"]",
 							"",
-							"交互模式弹出选择/输入对话并自动记录；非交互模式必须由用户在对话中回答，再用 kd_question action=answer 记录。",
+							"问题登记后保持 open；用户在下一条消息中回答，或使用 kd_question action=answer 记录。",
 						].join("\n"),
 					},
 				],
 				details: { error: "batched-question" },
 			};
 		}
+		const askBlockReason = questionAskBlockReason(run, { factLabel: params.factLabel });
+		if (askBlockReason) {
+			return {
+				content: [{ type: "text", text: askBlockReason }],
+				details: { error: "duplicate-fact-question", factLabel: params.factLabel },
+			};
+		}
 
+		const existingQuestionIds = new Set((run.questions ?? []).map((question) => question.id));
 		const question = addQuestion(ctx.cwd, run, {
 			question: params.question,
 			reason: params.reason,
+			factLabel: params.factLabel,
+			proposedFactValue: params.proposedFactValue,
 			choices: params.choices,
 			blocking: params.blocking,
 		});
-		appendQuestionEventToArtifact(ctx.cwd, run, formatQuestionArtifactLines(question));
-		const interactiveAnswer = await askQuestionInteractively(ctx, question.question, question.choices);
-		if (interactiveAnswer) {
-			const answered = answerQuestion(ctx.cwd, run, question.id, interactiveAnswer);
-			if (answered) {
-				appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
-				const auto = autoAdvanceTool(ctx.cwd, run);
-				return {
-					content: [{ type: "text", text: `用户已回答 ${answered.id}：${answered.answer}。${auto.advanced ? auto.message : `门禁仍阻塞：${auto.message}`}` }],
-					details: { question: answered, gate: readActiveRun(ctx.cwd)?.gate, answered: true, autoAdvance: auto },
-				};
-			}
+		if (existingQuestionIds.has(question.id)) {
+			return {
+				content: [{ type: "text", text: `${question.id} 已是 open 问题，禁止重复登记。等待用户回答，或使用 kd_question action=answer id=${question.id} answer=<答案> 记录。` }],
+				details: { question, gate: readActiveRun(ctx.cwd)?.gate, duplicate: true },
+			};
 		}
+		appendQuestionEventToArtifact(ctx.cwd, run, formatQuestionArtifactLines(question));
 
-		const text = `${formatQuestionCard(question)}\n\n未记录交互式答案；该问题保持 open，直至用户回答。`;
+		const text = `${formatQuestionCard(question)}\n\n问题已登记为 open。等待用户在下一条消息中回答，或执行 kd_question action=answer id=${question.id} answer=<答案>。`;
 		return { content: [{ type: "text", text }], details: { question, gate: readActiveRun(ctx.cwd)?.gate, answered: false } };
 	},
 });
@@ -351,6 +393,20 @@ export default function (pi: ExtensionAPI) {
 
 		if (!run) return { action: "continue" };
 
+		const openQuestions = openBlockingQuestions(run);
+		if (openQuestions.length === 1 && shouldAutoRecordQuestionAnswer(event.text)) {
+			const answered = answerQuestion(ctx.cwd, run, openQuestions[0].id, event.text);
+			const current = readActiveRun(ctx.cwd) ?? run;
+			if (answered) {
+				appendQuestionEventToArtifact(ctx.cwd, current, [`- 已回答 ${answered.id}：${answered.answer}`]);
+				if (ctx.hasUI) ctx.ui.notify(`已记录 ${answered.id} 的答案`, "info");
+				return {
+					action: "transform",
+					text: workflowPromptForRun(ctx.cwd, current, `用户已回答 ${answered.id}：${answered.answer}`),
+				};
+			}
+		}
+
 		return {
 			action: "transform",
 			text: workflowPromptForRun(ctx.cwd, run, event.text),
@@ -618,9 +674,14 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.notify("用法：/kd-answer Q-001 <答案>", "error");
 				return;
 			}
+			const existingQuestion = (run.questions ?? []).find((question) => question.id === id);
+			if (existingQuestion?.status === "answered") {
+				ctx.ui.notify(`${id} 已回答，禁止重复覆盖；用户更正事实时使用 kd_question action=revise。`, "warning");
+				return;
+			}
 			const answered = answerQuestion(ctx.cwd, run, id, answer);
 			if (!answered) {
-				ctx.ui.notify(`未找到问题：${id}`, "error");
+				ctx.ui.notify(existingQuestion ? `未能记录 ${id} 的答案；答案不能为空、占位内容或单独确认/否定。` : `未找到问题：${id}`, "error");
 				return;
 			}
 			appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
@@ -687,38 +748,17 @@ function formatQuestionCard(question: NonNullable<NonNullable<ReturnType<typeof
 		`阶段：${question.phase}`,
 		`问题：${question.question}`,
 		question.reason ? `原因：${question.reason}` : undefined,
+		question.factLabel ? `事实标签：${question.factLabel}` : undefined,
+		question.proposedFactValue ? `候选事实值：${question.proposedFactValue}` : undefined,
 		question.choices?.length ? `选项：${question.choices.join(" | ")}` : undefined,
 		question.answer ? `答案：${question.answer}` : undefined,
 		question.status === "open"
-			? `交互弹窗出现时直接回答；无弹窗时在对话中回复，并使用 kd_question action=answer id=${question.id} answer=<答案> 记录。`
+			? `回答方式：用户在下一条消息中回答，或使用 kd_question action=answer id=${question.id} answer=<答案> 记录。`
 			: undefined,
 	];
 	return lines.filter(Boolean).join("\n");
 }
 
-async function askQuestionInteractively(
-	ctx: ExtensionContext,
-	question: string,
-	choices: string[] | undefined,
-): Promise<string | undefined> {
-	if (!ctx.hasUI) return undefined;
-
-	const normalizedChoices = choices?.map((choice) => choice.trim()).filter(Boolean) ?? [];
-	try {
-		if (normalizedChoices.length === 0) {
-			return (await ctx.ui.input(question, "输入答案"))?.trim() || undefined;
-		}
-
-		const customChoice = "自定义输入";
-		const selected = await ctx.ui.select(question, [...normalizedChoices, customChoice]);
-		if (!selected) return undefined;
-		if (selected !== customChoice) return selected;
-		return (await ctx.ui.input(question, "输入答案"))?.trim() || undefined;
-	} catch {
-		return undefined;
-	}
-}
-
 function questionBatchProblem(question: string, choices?: string[]): string | undefined {
 	const text = question.trim();
 	const numberedItems = text.split(/\r?\n/).filter((line) => /^\s*(\d+[\.\)、)]|[-*]\s+)/.test(line)).length;
@@ -732,10 +772,22 @@ function questionBatchProblem(question: string, choices?: string[]): string | un
 	return undefined;
 }
 
+function shouldAutoRecordQuestionAnswer(text: string): boolean {
+	const trimmed = text.trim();
+	if (!trimmed || trimmed.startsWith("/")) return false;
+	if (trimmed.length > 300) return false;
+	if (/[?？]/.test(trimmed)) return false;
+	if (/^(先|暂停|等等|不用|不要|继续|开始|实现|修改|修复|提交|push|发布)\b/i.test(trimmed)) return false;
+	if (/^(先|暂停|等等|不用|不要|继续|开始|实现|修改|修复|提交|发布)/.test(trimmed)) return false;
+	return true;
+}
+
 function formatQuestionArtifactLines(question: NonNullable<NonNullable<ReturnType<typeof readActiveRun>>["questions"]>[number]): string[] {
 	return [
 		`- ${question.id} [${question.blocking ? "blocking" : "non-blocking"}] ${question.question}`,
 		question.reason ? `  - 原因：${question.reason}` : undefined,
+		question.factLabel ? `  - 事实标签：${question.factLabel}` : undefined,
+		question.proposedFactValue ? `  - 候选事实值：${question.proposedFactValue}` : undefined,
 		question.choices?.length ? `  - 选项：${question.choices.join(" | ")}` : undefined,
 		"  - 状态：open",
 	].filter(Boolean) as string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kcode-pi",
-  "version": "0.1.35",
+  "version": "0.1.39",
   "description": "面向金蝶开发的 Pi Coding Agent 启动器、工具包和 Harness 工作流",
   "type": "module",
   "private": false,

package/src/context/project-context.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, extname, join, relative } from "node:path";
+import { PROJECT_PERSISTENT_RULES, formatPromptLines } from "../harness/prompt-policy.js";
 
 const IGNORED_DIRS = new Set([
 	".git",
@@ -67,11 +68,9 @@ export function generateProjectContext(cwd: string): string {
 		"",
 		"## 持久规则",
 		"",
-		"- 本文件是 KCode 的项目记忆，计划或编辑代码前必须读取。",
-		"- 业务需求不得生成 demo/sample/scaffold 代码。",
+		...formatPromptLines(PROJECT_PERSISTENT_RULES),
 		"- 禁止假设模块结构。必须基于下方真实路径，并在编辑前确认目标文件。",
 		"- 调用文件工具时默认使用项目相对路径。在 Windows 中禁止把路径改写为 /mnt/<drive>/... 或 /<drive>/...；绝对路径只允许使用 Windows 路径。",
-		"- 本文件过期时，计划前运行 `kcode context --refresh` 重新生成。",
 		"- 只有 Harness 进入 `execute` 且 PLAN.md 写明真实目标路径后，才能写产品代码。",
 		"",
 		"## 项目结构摘要",

package/src/harness/data-source-policy.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import type { ActiveRun } from "./types.ts";
 import { readArtifact } from "./artifacts.ts";
-import { hasEvidenceEntry } from "./evidence.ts";
+import { hasEvidenceEntry, readEvidenceIndex } from "./evidence.ts";
 import { runRoot } from "./paths.ts";
 import { isSourceLikePath } from "./path-policy.ts";
 import {
@@ -19,6 +19,7 @@ import {
 	INTEGRATION_CONTEXT_FIELDS,
 	type ContractField,
 } from "./prompt-policy.ts";
+import { formatAnsweredQuestionFacts } from "./question-memory.ts";
 
 export const COSMIC_METADATA_EVIDENCE = "evidence/cosmic-metadata.json";
 export const DATA_SOURCE_EVIDENCE = "evidence/data-source.md";
@@ -53,8 +54,10 @@ export function hasValidDataSourceEvidence(cwd: string, run: ActiveRun): boolean
 	const path = join(runRoot(cwd, run), evidence);
 	if (!existsSync(path)) return false;
 	if (!hasEvidenceEntry(cwd, run, evidence)) return false;
-	if (evidence === COSMIC_METADATA_EVIDENCE) return true;
-	return dataSourceEvidenceContentLooksConcrete(readFileSync(path, "utf8"));
+	if (!hasSuccessfulEvidenceEntry(cwd, run, evidence)) return false;
+	const content = readFileSync(path, "utf8");
+	if (evidence === COSMIC_METADATA_EVIDENCE) return cosmicMetadataLooksConcrete(content);
+	return dataSourceEvidenceContentLooksConcrete(content);
 }
 
 export function dataSourceProductionWriteBlockReason(cwd: string, run: ActiveRun | undefined, path: string | undefined): string | undefined {
@@ -89,7 +92,12 @@ export function dataSourceContextBlockReason(cwd: string, run: ActiveRun): strin
 }
 
 function dataSourcePlanningText(cwd: string, run: ActiveRun, options: { includePlan?: boolean } = { includePlan: true }): string {
-	return [run.goal ?? "", readArtifact(cwd, run, "spec") ?? "", options.includePlan === false ? "" : readArtifact(cwd, run, "plan") ?? ""].join("\n");
+	return [
+		run.goal ?? "",
+		readArtifact(cwd, run, "spec") ?? "",
+		formatAnsweredQuestionFacts(run),
+		options.includePlan === false ? "" : readArtifact(cwd, run, "plan") ?? "",
+	].join("\n");
 }
 
 function planDeclaresConcreteDataSourceWork(cwd: string, run: ActiveRun): boolean {
@@ -132,7 +140,7 @@ function planDeclaresConcreteImplementationWork(cwd: string, run: ActiveRun): bo
 }
 
 function missingDataSourceContextItems(cwd: string, run: ActiveRun): string[] {
-	const text = dataSourcePlanningText(cwd, run);
+	const text = trustedDataSourceContextText(cwd, run);
 	const missing: string[] = [];
 
 	if (!hasTargetObjectIdentifier(text)) missing.push(DATA_SOURCE_FIELDS["target-form"].label);
@@ -144,6 +152,17 @@ function missingDataSourceContextItems(cwd: string, run: ActiveRun): string[] {
 	return missing;
 }
 
+function trustedDataSourceContextText(cwd: string, run: ActiveRun): string {
+	return [formatAnsweredQuestionFacts(run), dataSourceEvidenceContent(cwd, run)].join("\n");
+}
+
+function dataSourceEvidenceContent(cwd: string, run: ActiveRun): string {
+	const evidence = dataSourceEvidenceForRun(run);
+	if (!evidence) return "";
+	const path = join(runRoot(cwd, run), evidence);
+	return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+
 function hasTriggerOrEntry(text: string): boolean {
 	if (hasLabeledValue(text, IMPLEMENTATION_FIELDS.trigger)) return true;
 	return /(?:触发入口|执行时机|触发时机|入口|事件|生命周期|插件类型|按钮|操作|定时|任务|保存前|保存后|提交后|审核后|Before\w+|After\w+)\s*[：:=]\s*[^。\n\r，,；;]{2,}|(?:保存前|保存后|提交后|审核后|定时|按钮点击|操作执行)/i.test(text);
@@ -251,7 +270,7 @@ function hasAcceptanceSample(text: string): boolean {
 
 function hasTargetObjectIdentifier(text: string): boolean {
 	if (hasLabeledValue(text, DATA_SOURCE_FIELDS["target-form"])) return true;
-	return /(?:Form\s*ID|FormId|formid|表单标识|单据标识|目标单据|目标表单)\s*[：:=]\s*[A-Za-z0-9_.-]{2,}|(?:单据|表单)\s*[：:=]\s*[^。\n\r，,；;]{2,}/i.test(text);
+	return /["']?(?:Form\s*ID|FormId|formId|formid|表单标识|单据标识|目标单据|目标表单)["']?\s*[：:=]\s*["']?[A-Za-z0-9_.-]{2,}|(?:单据|表单)\s*[：:=]\s*[^。\n\r，,；;]{2,}/i.test(text);
 }
 
 function hasPluginHook(text: string): boolean {
@@ -286,17 +305,42 @@ function dataSourceEvidenceContentLooksConcrete(content: string): boolean {
 	return /Form\s*ID|FormId|formid|单据|表单|字段|实体|表名|数据源|BOS|DynamicObject|DataSet|数据库|测试数据/i.test(text);
 }
 
+function cosmicMetadataLooksConcrete(content: string): boolean {
+	try {
+		const parsed = JSON.parse(content) as unknown;
+		if (!parsed || (Array.isArray(parsed) && parsed.length === 0)) return false;
+		const text = JSON.stringify(parsed);
+		if (/待确认|未知|TODO|TBD|未提供/i.test(text)) return false;
+		return /Form\s*ID|FormId|formid|field|fields|entity|entities|字段|实体|单据体|name|key|id/i.test(text);
+	} catch {
+		return false;
+	}
+}
+
+function hasSuccessfulEvidenceEntry(cwd: string, run: ActiveRun, artifact: string): boolean {
+	const normalized = artifact.replace(/\\/g, "/").replace(/^\/+/, "").replace(/^\.\//, "");
+	const entry = readEvidenceIndex(cwd, run).entries.find((item) => typeof item.path === "string" && item.path.replace(/\\/g, "/") === normalized);
+	return Boolean(entry && entry.exitCode === 0);
+}
+
 function normalizeRelativePath(path: string): string {
 	return path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
 }
 
 function hasLabeledValue(text: string, field: ContractField): boolean {
-	return field.aliases.some((alias) => {
+	return [field.label, ...field.aliases].some((alias) => {
 		const escaped = escapeRegExp(alias);
-		return new RegExp(`(?:^|[\\r\\n\\-\\*\\s])${escaped}\\s*[：:=]\\s*[^\\r\\n。；;，,]{2,}`, "i").test(text);
+		const match = new RegExp(`(?:^|[\\r\\n\\-\\*\\s])${escaped}\\s*[：:=]\\s*([^\\r\\n。；;，,]{2,})`, "i").exec(text);
+		return Boolean(match && labeledValueLooksConcrete(match[1] ?? ""));
 	});
 }
 
+function labeledValueLooksConcrete(value: string): boolean {
+	const trimmed = value.trim();
+	if (trimmed.length < 2) return false;
+	return !/^(待确认|未知|不清楚|未提供|none|unknown|todo|tbd|n\/a|按实际|按实际环境|后续确认|以后再说)$/i.test(trimmed);
+}
+
 function escapeRegExp(value: string): string {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/src/harness/delegation.ts

@@ -4,6 +4,7 @@ import { formatStatus } from "./format.ts";
 import type { ActiveRun, KdPhase } from "./types.ts";
 import { PHASE_ORDER } from "./types.ts";
 import { isAbsolute, relative } from "node:path";
+import { formatQuestionMemory } from "./question-memory.ts";
 
 export type DelegationRole = "research" | "doc" | "code" | "review" | "verify";
 
@@ -21,6 +22,7 @@ export interface ParsedDelegationArgs extends DelegationRequest {
 const ROLE_GUIDANCE: Record<DelegationRole, string[]> = {
 	research: [
 		"只读调研项目、文档、SDK 线索和现有实现。",
+		"必须基于真实读取或搜索结果定位文件；禁止猜测路径。",
 		"输出压缩结论、证据文件/代码位置、风险和下一步指令。",
 		"禁止修改文件；禁止推进 Harness 状态。",
 	],
@@ -179,6 +181,7 @@ export function delegationGuidanceForWorkflow(): string {
 		"- 任务包含大量调研、独立交叉审查、长上下文复盘或可并行拆分内容时，使用 kd_subagent。",
 		"- 自动委派只做旁路工作；主 agent 仍负责采纳结论、修改文件、记录 evidence 和推进阶段。",
 		"- code 委派只能在 execute 阶段且限于 PLAN.md 批准文件；review/research 默认只读。",
+		"- kd_subagent 不是 shell/read/grep 失败的替代方案；基础文件搜索失败时，主 agent 必须报告阻塞原因或改用当前环境可用工具。",
 	].join("\n");
 }
 
@@ -202,6 +205,7 @@ export function buildDelegationPrompt(cwd: string, run: ActiveRun | undefined, r
 	const projectContext = readProjectContext(cwd);
 	const status = run ? formatStatus(cwd, run) : "当前没有 active KCode Harness run。";
 	const phaseContext = run ? delegationMemoryForRun(cwd, run) : "无 active run 阶段资料。";
+	const questionMemory = run ? formatQuestionMemory(run) : "无。";
 
 	return [
 		"KCode 子 agent 委派任务。",
@@ -219,6 +223,7 @@ export function buildDelegationPrompt(cwd: string, run: ActiveRun | undefined, r
 		...roleGuidance.map((item) => `- ${item}`),
 		"- 子 agent 不是主状态机；禁止调用 /kd-advance、/kd-finish 或改变 run 生命周期。",
 		"- 禁止创建子 agent；输出结果交回主 agent 统一决策。",
+		"- 禁止假设 bash、Linux 路径或猜测文件位置；Windows 项目按 PowerShell/Windows 路径语义描述命令。",
 		"",
 		"Harness 状态：",
 		status,
@@ -226,6 +231,9 @@ export function buildDelegationPrompt(cwd: string, run: ActiveRun | undefined, r
 		"阶段上下文：",
 		phaseContext,
 		"",
+		"KCode 已问已答事实：",
+		questionMemory,
+		"",
 		"项目上下文：",
 		projectContext ? trimForPrompt(projectContext, 1200) : "未生成。项目结构缺失时读取本地文件；无法读取时要求主 agent 运行 `kcode context --refresh`。",
 		"",

package/src/harness/messages.ts

@@ -168,5 +168,5 @@ export function implementationWriteBlockedReason(path: string, missing: string[]
 function nextQuestionInstruction(missing: string[]): string | undefined {
 	const question = questionForMissingLabel(missing[0]);
 	if (!question) return undefined;
-	return `阻断问题命令：kd_question action=ask question="${question}" reason="${missing[0]} 缺失会阻塞实现。"。`;
+	return `阻断问题命令：kd_question action=ask factLabel="${missing[0]}" question="${question}" reason="${missing[0]} 缺失会阻塞实现。"。`;
 }

package/src/harness/prompt-policy.ts

@@ -56,7 +56,7 @@ export const DATA_SOURCE_CONTEXT_FIELDS: ContractField[] = [
 	{
 		id: "target-form",
 		label: "目标 FormId/单据或表单标识",
-		aliases: ["目标 FormId", "FormId", "表单标识", "单据标识", "目标单据", "目标表单"],
+		aliases: ["目标 FormId", "FormId", "Form ID", "form id", "表单标识", "单据标识", "目标单据", "目标表单"],
 		question: "目标 FormId、单据或表单标识是什么？",
 	},
 	{
@@ -142,6 +142,25 @@ export const INTEGRATION_CONTEXT_FIELDS: ContractField[] = [
 	},
 ];
 
+export const PROJECT_PERSISTENT_RULES = [
+	"计划或编辑代码前必须读取本文件；本文件过期时先运行 `kcode context --refresh`。",
+	"信息不足时禁止开始编码。必须先登记一个最阻塞的结构化问题，获得可核验答案后再继续；禁止输出 demo/sample/scaffold、模板代码或占位实现。",
+	"API 文档、SDK 文档和知识库只能证明技术用法，不能替代业务事实。FormId、单据/表单标识、字段/实体/分录标识、插件类型与事件、SQL/KSQL 表名和数据库字段名必须来自用户确认、项目元数据或 evidence。",
+	`产品代码实现前必须具备通用实现契约：${IMPLEMENTATION_CONTRACT_FIELDS.map((field) => field.label).join("、")}。`,
+	`涉及业务数据源时必须具备数据源上下文：${DATA_SOURCE_CONTEXT_FIELDS.map((field) => field.label).join("、")}。`,
+	`涉及第三方对接时必须具备接口与运行上下文：${INTEGRATION_CONTEXT_FIELDS.map((field) => field.label).join("、")}。`,
+	"内部插件、自动下推、字段改写、数据同步等需求不得按场景写死提示词；统一通过实现契约、数据源上下文、第三方对接上下文补齐事实。",
+	"PLAN 自由文本不能单独证明 FormId、字段、插件事件或读写方式；门禁只信任结构化 facts 和 evidence。",
+	"`run.facts` 是唯一结构化事实源；已回答 questions 仅为审计记录，禁止在读取状态时从历史 question 反推事实。",
+	"`factLabel` 必须使用集中定义的事实标签或别名；未知标签、占位答案、口头确认语、待确认/TODO/TBD/按实际环境等不能解除门禁。",
+	"用户回答 open question 后，先用 `kd_question action=answer` 写入答案；用户更正事实时用 `kd_question action=revise`，禁止重复询问已确认事实。",
+	"企业版 Python 插件通常没有本地构建可替代验证；BOS 注册、外部系统操作、人工功能测试和生产环境验证必须由用户提供可核验证据并记录来源。",
+	"提示语集中管理为正式工程指令；禁止口语化、闲聊式、鼓励式提示词进入运行时规则。",
+	"工具使用必须匹配当前会话实际可用工具和操作系统；Windows 默认使用 PowerShell、`rg`、`Get-ChildItem`、`Get-Content`，禁止假设 bash 可用。",
+	"文件定位必须使用真实搜索或目录读取结果；工具不可用时明确说明阻塞原因和需要用户执行的命令，禁止猜测路径、反复自述工具失败或用 kd_subagent 代替基础文件搜索。",
+	"不做旧状态迁移兼容或旧问题答案推断；坏状态只过滤，缺失事实必须重新提问确认。",
+];
+
 export const PROMPT_STYLE_RULES = [
 	"使用正式、可执行的工程指令；禁止口语化、闲聊式、鼓励式表达。",
 	"事实不足时生成阻断问题；禁止输出模板代码、占位实现或基于猜测的业务标识。",
@@ -155,11 +174,16 @@ export const CORE_WORKFLOW_CONSTRAINTS = [
 	"业务数据源未知时禁止编码；确认目标 FormId/单据或表单、插件类型和事件、字段/实体/分录标识、数据读取写入方式后再编码；SQL/KSQL 同步确认表名和数据库字段名。",
 	"第三方对接确认接口文档、对接方向、触发时机、认证配置、字段映射、并发/幂等、重试超时限流、错误补偿、日志脱敏和验收样例后再编码。",
 	"事实缺失时使用 kd_question 登记一个最阻塞问题；禁止用 API 文档、SDK 知识库或推测替代业务事实。",
+	"用户输入是在回答 open question 时，必须先调用 kd_question action=answer 记录答案，再继续推进或登记下一个问题。",
+	"同一 factLabel 已有当前事实时禁止重复提问；用户明确更正时使用 kd_question action=revise 记录新事实和更正原因。",
+	"run.facts 是唯一结构化事实源；questions 仅作为问答审计记录，禁止从历史 question 反推门禁事实。",
+	"待确认、未知、按实际环境、TODO/TBD 等占位答案不能解除门禁。",
 	"Java/C# SDK 签名以当前项目 jar/dll、构建输出或官方元数据为准。",
 	"Java/Cosmic 使用当前项目 Gradle；C#/企业版使用 dotnet build。",
 	"evidence 必须记录命令、Exit 和关键输出；命令无法运行时记录阻塞原因。",
 	"外部系统操作、BOS 注册、人工功能测试和生产环境验证不能由 LLM 代办；必须要求用户提供验证结果或可核验证据，并记录证据来源。",
 	"Windows 路径规则：项目相对路径为默认；绝对路径使用 D:\\... 形式。",
+	"工具规则：按当前会话实际 shell 和工具执行；Windows 不假设 bash，可用 PowerShell/rg/Get-ChildItem/Get-Content；禁止猜路径或用 kd_subagent 代替基础搜索失败。",
 ];
 
 export const PHASE_GUIDANCE: Record<KdPhase, string> = {
@@ -194,3 +218,13 @@ export function questionForMissingLabel(label: string): string | undefined {
 	const fields = [...IMPLEMENTATION_CONTRACT_FIELDS, ...DATA_SOURCE_CONTEXT_FIELDS, ...INTEGRATION_CONTEXT_FIELDS];
 	return fields.find((field) => field.label === label)?.question;
 }
+
+export function canonicalFactLabel(label: string): string | undefined {
+	const normalized = normalizeLabel(label);
+	const fields = [...IMPLEMENTATION_CONTRACT_FIELDS, ...DATA_SOURCE_CONTEXT_FIELDS, ...INTEGRATION_CONTEXT_FIELDS];
+	return fields.find((field) => [field.label, ...field.aliases].some((item) => normalizeLabel(item) === normalized))?.label;
+}
+
+function normalizeLabel(label: string): string {
+	return label.trim().toLowerCase().replace(/\s+/g, "");
+}

package/src/harness/prompt.ts

@@ -5,6 +5,7 @@ import { formatStatus } from "./format.ts";
 import type { ActiveRun, KdPhase } from "./types.ts";
 import { PHASE_ORDER } from "./types.ts";
 import { CORE_WORKFLOW_CONSTRAINTS, PHASE_GUIDANCE, PROMPT_STYLE_RULES, formatPromptLines } from "./prompt-policy.ts";
+import { formatQuestionMemory } from "./question-memory.ts";
 
 export function workflowPromptForRun(cwd: string, run: ActiveRun, userText: string): string {
 	const status = formatStatus(cwd, run);
@@ -23,6 +24,9 @@ export function workflowPromptForRun(cwd: string, run: ActiveRun, userText: stri
 		"KCode 阶段资料：",
 		memory,
 		"",
+		"KCode 已问已答事实：",
+		formatQuestionMemory(run),
+		"",
 		"项目上下文：",
 		projectContext ? trimForPrompt(projectContext, 1200) : "未生成。项目结构缺失时运行 `kcode context --refresh`。",
 		"",