kcode-pi 0.1.20 → 0.1.24

package/skills/kd-plan/SKILL.md

@@ -13,8 +13,9 @@ Goal:
 - List files to inspect before editing.
 - List the inspected project layout and the exact target source root or file path before editing.
 - List expected files to modify.
+- State whether the plan involves product implementation, build, metadata, or SDK verification, with a brief basis for the decision.
 - List required `kd_sdk_signature`, `kd_search`, `kd_table`, metadata, and build/compile checks.
-- For Java/Cosmic/Cangqiong/Flagship projects, plan a Gradle build check for syntax/compile validation, using the current project command such as `.\gradlew.bat build`, `./gradlew build`, or `.\gradlew.bat :module:build`.
+- For Cangqiong/Xinghan/Flagship Java projects, plan a Gradle build check for syntax/compile validation, using the current project command such as `.\gradlew.bat build`, `./gradlew build`, or `.\gradlew.bat :module:build`.
 - For C#/Enterprise projects, plan `dotnet build` or `dotnet build <.sln/.csproj>` for syntax/compile validation.
 - List `## Execution Steps` using `- [ ] STEP-001: ...` style IDs.
 - List `## TDD / Red-Green Checks` with red evidence, green evidence, and the command/tool or product-specific check.
@@ -27,7 +28,7 @@ Gate:
 - Execution must not start without `PLAN.md`.
 - A plan for 星空旗舰版 is incomplete unless it records the existing project layout and exact target path to edit. If `code/` exists, follow its actual structure; if it does not, record the discovered source root or existing target file.
 - A plan without validation commands is incomplete.
-- A Java/C# plan that uses vague wording such as "compile in Kingdee IDE" instead of a real Gradle or dotnet command is incomplete.
+- A Java/C# plan without a concrete Gradle or dotnet validation command is incomplete.
 - A plan without structured `STEP-001` execution steps is incomplete.
 - A plan without TDD red/green checks is incomplete.
 - A plan that relies on unverified Kingdee API names is incomplete; bundled knowledge alone is not enough when local SDK jars/dlls or compile evidence are available.

package/skills/kd-verify/SKILL.md

@@ -10,7 +10,7 @@ Use this skill after implementation.
 Goal:
 
 - Run planned validation commands.
-- For Java/Cosmic/Cangqiong/Flagship projects, run the planned Gradle command to catch syntax/compile errors, for example `.\gradlew.bat build`, `./gradlew build`, or a narrow `:module:build` task.
+- For Cangqiong/Xinghan/Flagship Java projects, run the planned Gradle command to catch syntax/compile errors, for example `.\gradlew.bat build`, `./gradlew build`, or a narrow `:module:build` task.
 - For C#/Enterprise projects, run `dotnet build` or `dotnet build <.sln/.csproj>` to catch syntax/compile errors.
 - Run `kd_check` when code is available.
 - Collect evidence into `.pi/kd/runs/<run-id>/VERIFY.md`.
@@ -20,5 +20,5 @@ Rules:
 
 - Passing unit tests is not enough if acceptance criteria require workflow behavior.
 - If validation cannot run, state the exact blocker.
-- Do not use "Kingdee IDE" as a verification target. Evidence must show the real command, `Exit: 0`, and useful output summary.
+- Passing evidence must show the real command, `Exit: 0`, and useful output summary.
 - Do not ship while verification evidence is missing.

package/src/cli/kcode.ts

@@ -199,7 +199,7 @@ export function start(cwd: string, piArgs: string[]): KcodeCliResult {
 	if (!piCli) {
 		return {
 			exitCode: 1,
-			output: `${init.output}\n未找到随包 Pi CLI 或全局 pi 命令。请重新安装 kcode-cli 后再运行 kcode start。`,
+			output: `${init.output}\n未找到随包 Pi CLI 或全局 pi 命令。请重新安装 kcode-pi 后再运行 kcode start。`,
 		};
 	}
 
@@ -340,7 +340,7 @@ function piCliPackageVersion(piCli: PiCliCommand): string | undefined {
 
 function helpText(): string {
 	return [
-		"KCode 企业入口",
+		"KCode 金蝶开发入口",
 		"",
 		"用法：",
 		"  kcode init      初始化当前项目的 .pi/settings.json",

package/src/harness/artifacts.ts

@@ -47,11 +47,12 @@ export function defaultArtifactContent(phase: KdPhase, goal?: string, profile?:
 				"- 版本：未知",
 				`- 技术栈：${profile?.techStack ?? "未知"}`,
 				`- 语言：${profile?.language ?? "未知"}`,
-				"- 插件类型：未知",
-				"- 目标单据/实体/表单：未知",
+				"- 需求条目：未知",
+				"- 目标对象：未知",
+				"- 依赖和批次：未知",
 				"- 非目标范围：未知",
 				"- 待确认问题：",
-				"  - 确认金蝶产品/版本、技术栈、插件类型和目标对象。",
+				"  - 从需求来源中提取可确认事实；只把无法判断且阻塞推进的关键点列为待确认。",
 				"",
 			].join("\n");
 		case "spec":
@@ -60,9 +61,11 @@ export function defaultArtifactContent(phase: KdPhase, goal?: string, profile?:
 				"",
 				"## 验收标准",
 				"",
-				"## 生命周期 / 扩展点",
+				"## 需求条目",
 				"",
-				"## 数据对象和字段",
+				"## 数据对象、字段或影响范围",
+				"",
+				"## 依赖和批次",
 				"",
 				"## 异常行为和性能约束",
 				"",
@@ -81,12 +84,21 @@ export function defaultArtifactContent(phase: KdPhase, goal?: string, profile?:
 				"",
 				"## 允许修改的文件",
 				"",
+				"## 产品实现范围",
+				"",
+				"- 是否涉及产品实现、构建、元数据或 SDK 查证：待确认",
+				"- 判断依据：待确认",
+				"",
 				"## 必需的金蝶查证项",
 				"",
 				"- Java/C# 代码涉及 SDK 类、方法、构造器、枚举、属性时，必须先用 kd_sdk_signature 或项目构建输出确认真实签名。",
 				"- 知识库搜索、随包 Cosmic API 查询只能作为线索，不能作为最终方法签名事实。",
 				"- SDK 签名证据：evidence/sdk-signature.md",
 				"",
+				"## 需求条目 / 依赖 / 批次",
+				"",
+				"## 验收与验证对应关系",
+				"",
 				"## 执行步骤",
 				"",
 				"- [ ] STEP-001：检查现有目标文件，确认精确修改位置。",
@@ -103,10 +115,10 @@ export function defaultArtifactContent(phase: KdPhase, goal?: string, profile?:
 				"- Java 语法/编译检查：优先使用当前项目 Gradle 命令，例如 `./gradlew build`、`.\\gradlew.bat build` 或 `./gradlew :模块:build`。",
 				"- C# 语法/编译检查：使用 `dotnet build`、`dotnet build <.sln>` 或 `dotnet build <.csproj>`。",
 				"- 允许的检查：本地 SDK 签名查证、官方 API/基类/方法查证、元数据查证、kd_check、Gradle/dotnet 构建输出、项目已有测试框架、外部接口最小验证。",
-				"- 不要为了满足门禁引入第三方测试 jar 或框架。",
-				"- 不要写“Kingdee IDE 中编译”作为验证方式；命令无法运行时记录真实阻塞原因，不能作为绿灯证据。",
+				"- 测试框架：优先使用项目已有测试基础设施。",
+				"- 命令无法运行时记录真实阻塞原因和残余风险，不能作为绿灯证据。",
 				"- 如果无法自动化测试，记录一个产品相关、实现前应失败且实现后应通过的检查。",
-				"- 禁止凭记忆或随包知识库猜 SDK 方法签名；签名事实必须来自当前项目 jar/dll、构建输出或官方元数据。",
+				"- SDK 方法签名事实必须来自当前项目 jar/dll、构建输出或官方元数据。",
 				"",
 				"## 验证命令",
 				"",

package/src/harness/gates.ts

@@ -10,6 +10,15 @@ import { tddPlanBlockReason, tddVerifyBlockReason } from "./tdd-policy.ts";
 import { SDK_SIGNATURE_EVIDENCE, hasValidSdkSignatureEvidence, requiresSdkSignatureEvidence } from "./sdk-policy.ts";
 import { runRoot } from "./paths.ts";
 import { EVIDENCE_INDEX, hasEvidenceEntry } from "./evidence.ts";
+import {
+	missingArtifactsReason,
+	missingEvidenceReason,
+	missingForTargetReason,
+	missingMarkerReason,
+	openQuestionsReason,
+	unknownProductReason,
+	unknownRiskReason,
+} from "./messages.ts";
 
 const REQUIRED_MARKERS: Partial<Record<KdPhase, string[]>> = {
 	plan: ["## 验证命令"],
@@ -37,8 +46,9 @@ function collectGateProblems(cwd: string, run: ActiveRun, phase: KdPhase, mode:
 	const missing: string[] = [];
 	const reasonParts: string[] = [];
 
-	if (phase !== "discuss" && !isKnownProduct(run.profile?.product ?? run.product)) {
-		reasonParts.push(unknownProductReason());
+	if (phaseIndex >= PHASE_ORDER.indexOf("execute") && !isKnownProduct(run.profile?.product ?? run.product)) {
+		const declaration = productImplementationDeclaration(cwd, run);
+		if (declaration !== false) reasonParts.push(unknownProductReason(declaration));
 	}
 
 	if (phaseIndex >= PHASE_ORDER.indexOf("ship") && !hasRiskAssessment(cwd, run)) {
@@ -103,8 +113,17 @@ function gateResult(reasonParts: string[]): GateResult {
 	};
 }
 
-function unknownProductReason(): string {
-	return "不能离开 discuss：产品画像未知。下一步：根据需求或用户回答确认产品，然后执行 /kd-product <flagship|cosmic|xinghan|cangqiong|enterprise>；如果无法判断，先用 kd_question 只问一个最阻塞的产品确认问题。";
+function productImplementationDeclaration(cwd: string, run: ActiveRun): boolean | undefined {
+	const plan = readArtifact(cwd, run, "plan") ?? "";
+	const line = plan
+		.split(/\r?\n/)
+		.map((item) => item.trim())
+		.find((item) => item.includes("是否涉及产品实现、构建、元数据或 SDK 查证"));
+	if (!line) return undefined;
+	const value = line.replace(/^[-*]\s*/, "").split(/[：:]/).slice(1).join(":").trim();
+	if (/^(是|涉及|需要|yes|true)(\s|。|，|,|；|;|$)/i.test(value)) return true;
+	if (/^(否|不涉及|不需要|无|no|false)(\s|。|，|,|；|;|$)/i.test(value)) return false;
+	return undefined;
 }
 
 function hasRiskAssessment(cwd: string, run: ActiveRun): boolean {
@@ -114,10 +133,6 @@ function hasRiskAssessment(cwd: string, run: ActiveRun): boolean {
 	return riskSectionHasContent(readArtifact(cwd, run, "verify") ?? "") || riskSectionHasContent(readArtifact(cwd, run, "ship") ?? "");
 }
 
-function unknownRiskReason(): string {
-	return "不能进入 ship：风险等级或风险原因未知。下一步：根据 VERIFY.md 和 SHIP.md 的残余风险执行 /kd-risk <low|medium|high> <原因>，或在风险章节写入真实风险说明后再刷新门禁。";
-}
-
 function riskSectionHasContent(content: string): boolean {
 	const match = content.match(/##\s*(残余风险|风险)\s*\r?\n([\s\S]*?)(?=\r?\n##\s+|$)/);
 	if (!match) return false;
@@ -130,10 +145,7 @@ function riskSectionHasContent(content: string): boolean {
 function inspectOpenQuestions(run: ActiveRun): string | undefined {
 	const open = (run.questions ?? []).filter((question) => question.status === "open" && question.blocking);
 	if (open.length === 0) return undefined;
-	return [
-		`存在未回答的阻断问题：${open.map((question) => `${question.id} ${question.question}`).join("；")}`,
-		"下一步：先向用户等待或获取答案，然后用 kd_question action=answer id=<问题编号> answer=<用户答案> 记录；不要绕过问题推进阶段。",
-	].join("。");
+	return openQuestionsReason(open);
 }
 
 function inspectStepState(cwd: string, run: ActiveRun, phase: KdPhase): string | undefined {
@@ -159,7 +171,7 @@ function inspectMarkers(cwd: string, run: ActiveRun, phase: KdPhase): string | u
 
 	const missing = markers.filter((marker) => !content.includes(marker));
 	if (missing.length === 0) return undefined;
-	return `${PHASE_ARTIFACTS[phase]} 缺少必需章节：${missing.join(", ")}。下一步：更新 ${PHASE_ARTIFACTS[phase]}，补齐这些章节并写入真实内容；不要只添加空标题。`;
+	return missingMarkerReason(phase, missing);
 }
 
 function inspectEvidence(cwd: string, run: ActiveRun, phase: KdPhase): string | undefined {
@@ -203,51 +215,6 @@ function evidenceArtifactSatisfied(cwd: string, run: ActiveRun, artifact: string
 	return existsSync(join(runRoot(cwd, run), artifact)) && hasEvidenceEntry(cwd, run, artifact);
 }
 
-function missingArtifactsReason(artifacts: string[]): string {
-	return [
-		`缺少必需产物：${artifacts.join(", ")}`,
-		`下一步：使用 /kd-artifact <阶段> 创建或更新阶段文档，或按当前阶段要求补写 ${artifacts.join(", ")} 的真实内容后再刷新门禁。`,
-	].join("。");
-}
-
-function missingForTargetReason(target: KdPhase, artifacts: string[]): string {
-	const evidence = artifacts.filter((artifact) => artifact.startsWith("evidence/"));
-	const documents = artifacts.filter((artifact) => !artifact.startsWith("evidence/"));
-	const actions: string[] = [];
-	if (documents.length > 0) {
-		actions.push(`先补齐阶段文档 ${documents.join(", ")}，可用 /kd-artifact 创建模板后填入真实分析、计划或验证内容`);
-	}
-	if (evidence.length > 0) {
-		actions.push(evidenceAction(evidence));
-	}
-	return `不能进入 ${target}：缺少 ${artifacts.join(", ")}。下一步：${actions.join("；")}。`;
-}
-
-function missingEvidenceReason(artifacts: string[]): string {
-	return `缺少必需证据：${artifacts.join(", ")}。下一步：${evidenceAction(artifacts)}。`;
-}
-
-function evidenceAction(artifacts: string[]): string {
-	return artifacts.map(evidenceArtifactAction).join("；");
-}
-
-function evidenceArtifactAction(artifact: string): string {
-	switch (artifact) {
-		case SDK_SIGNATURE_EVIDENCE:
-			return "运行 kd_sdk_signature，从当前项目真实 SDK jar/dll 查证类、方法、构造器或属性签名，成功后自动写入 evidence/sdk-signature.md";
-		case COSMIC_CONFIG_EVIDENCE:
-			return "运行 kd_cosmic_config 生成 evidence/cosmic-config.txt；如果项目没有 ok-cosmic.json，先使用 KCode 默认配置，不要手写假结果";
-		case COSMIC_METADATA_EVIDENCE:
-			return "运行 kd_cosmic_metadata 查询目标表单/单据/字段元数据并生成 evidence/cosmic-metadata.json";
-		case COSMIC_API_EVIDENCE:
-			return "运行 kd_cosmic_api 查询相关 Cosmic API 线索并生成 evidence/cosmic-api.txt，再用 kd_sdk_signature 或构建输出确认签名";
-		case KSQL_LINT_EVIDENCE:
-			return "运行 kd_ksql_lint 校验 KSQL/SQL 交付内容并生成 evidence/ksql-lint.txt";
-		default:
-			return `运行 PLAN.md 中声明的验证命令，记录命令、Exit、STDOUT/STDERR 或工具输出到 ${artifact}`;
-	}
-}
-
 function planHasMetadataRequirement(cwd: string, run: ActiveRun): boolean {
 	const plan = readArtifact(cwd, run, "plan") ?? "";
 	return /kd_cosmic_metadata|cosmic-metadata|cosmic-metadata\.json|metadata evidence|字段元数据证据|元数据证据/i.test(plan);

package/src/harness/messages.ts

@@ -0,0 +1,113 @@
+import type { KdPhase } from "./types.ts";
+import { PHASE_ARTIFACTS } from "./types.ts";
+
+export function unknownProductReason(declaration: boolean | undefined): string {
+	if (declaration === undefined) {
+		return "不能进入 execute：产品画像未知，且 PLAN.md 未明确声明是否涉及产品实现、构建、元数据或 SDK 查证。下一步：先由当前需求和项目计划判断该范围；如果涉及产品实现，执行 /kd-product <flagship|xinghan|cangqiong|enterprise>；如果不涉及，在 PLAN.md 的“产品实现范围”写明“不涉及”及依据。";
+	}
+	return "不能进入 execute：PLAN.md 声明涉及产品实现、构建、元数据或 SDK 查证，但产品画像未知。下一步：根据需求、计划或用户回答确认产品，然后执行 /kd-product <flagship|xinghan|cangqiong|enterprise>；如果无法判断，先用 kd_question 只问一个最阻塞的产品确认问题。";
+}
+
+export function unknownRiskReason(): string {
+	return "不能进入 ship：风险等级或风险原因未知。下一步：根据 VERIFY.md 和 SHIP.md 的残余风险执行 /kd-risk <low|medium|high> <原因>，或在风险章节写入真实风险说明后再刷新门禁。";
+}
+
+export function openQuestionsReason(questions: Array<{ id: string; question: string }>): string {
+	return [
+		`存在未回答的阻断问题：${questions.map((question) => `${question.id} ${question.question}`).join("；")}`,
+		"下一步：先获取用户答案，然后用 kd_question action=answer id=<问题编号> answer=<用户答案> 记录。",
+	].join("。");
+}
+
+export function missingMarkerReason(phase: KdPhase, missing: string[]): string {
+	return `${PHASE_ARTIFACTS[phase]} 缺少必需章节：${missing.join(", ")}。下一步：更新 ${PHASE_ARTIFACTS[phase]}，补齐这些章节并写入真实内容。`;
+}
+
+export function missingArtifactsReason(artifacts: string[]): string {
+	return [
+		`缺少必需产物：${artifacts.join(", ")}`,
+		`下一步：使用 /kd-artifact <阶段> 创建或更新阶段文档，或按当前阶段要求补写 ${artifacts.join(", ")} 的真实内容后再刷新门禁。`,
+	].join("。");
+}
+
+export function missingForTargetReason(target: KdPhase, artifacts: string[]): string {
+	const evidence = artifacts.filter((artifact) => artifact.startsWith("evidence/"));
+	const documents = artifacts.filter((artifact) => !artifact.startsWith("evidence/"));
+	const actions: string[] = [];
+	if (documents.length > 0) {
+		actions.push(`先补齐阶段文档 ${documents.join(", ")}，可用 /kd-artifact 创建模板后填入真实分析、计划或验证内容`);
+	}
+	if (evidence.length > 0) {
+		actions.push(evidenceAction(evidence));
+	}
+	return `不能进入 ${target}：缺少 ${artifacts.join(", ")}。下一步：${actions.join("；")}。`;
+}
+
+export function missingEvidenceReason(artifacts: string[]): string {
+	return `缺少必需证据：${artifacts.join(", ")}。下一步：${evidenceAction(artifacts)}。`;
+}
+
+export function evidenceAction(artifacts: string[]): string {
+	return artifacts.map(evidenceArtifactAction).join("；");
+}
+
+export function evidenceArtifactAction(artifact: string): string {
+	switch (artifact) {
+		case "evidence/sdk-signature.md":
+			return "运行 kd_sdk_signature，从当前项目真实 SDK jar/dll 查证类、方法、构造器或属性签名，成功后自动写入 evidence/sdk-signature.md";
+		case "evidence/cosmic-config.txt":
+			return "运行 kd_cosmic_config 生成 evidence/cosmic-config.txt；如果项目没有 ok-cosmic.json，先使用 KCode 默认配置";
+		case "evidence/cosmic-metadata.json":
+			return "运行 kd_cosmic_metadata 查询目标表单/单据/字段元数据并生成 evidence/cosmic-metadata.json";
+		case "evidence/cosmic-api.txt":
+			return "运行 kd_cosmic_api 查询相关 Cosmic API 线索并生成 evidence/cosmic-api.txt，再用 kd_sdk_signature 或构建输出确认签名";
+		case "evidence/ksql-lint.txt":
+			return "运行 kd_ksql_lint 校验 KSQL/SQL 交付内容并生成 evidence/ksql-lint.txt";
+		default:
+			return `运行 PLAN.md 中声明的验证命令，记录命令、Exit、STDOUT/STDERR 或工具输出到 ${artifact}`;
+	}
+}
+
+export function flagshipWriteBlockedReason(path: string): string {
+	return `星空旗舰版代码必须跟随当前项目结构写入 code/ 下，不能写到 ${path}。下一步：先读取当前项目 code/ 下的真实模块结构，在 PLAN.md 记录目标源码路径，再把写入路径改为 code/... 下的项目相对路径。`;
+}
+
+export function planWriteBlockedReason(path: string): string {
+	return `PLAN.md 未批准写入 ${path}。下一步：停止写入该文件，回到 plan 阶段检查项目结构和影响范围，把该文件加入 PLAN.md 的 ## 允许修改的文件 和执行步骤；重新通过门禁后再写。`;
+}
+
+export function flagshipPlanNeedsCodePathReason(): string {
+	return "不能进入 execute：星空旗舰版 PLAN.md 需要先记录当前项目 code/ 下的实际目标路径。下一步：列出 code/ 下模块，识别当前项目是按云、按应用还是不分模块组织，在 PLAN.md 写明真实目标文件。";
+}
+
+export function flagshipPlanNeedsSourcePathReason(): string {
+	return "不能进入 execute：PLAN.md 需要先记录已检查当前项目结构，并写明实际源码根或目标文件路径。下一步：读取构建文件和 src/lib/bin 等目录，确认源码根后写入 PLAN.md 的 ## 已检查的项目结构、## 目标源码根 / 路径 和 ## 允许修改的文件。";
+}
+
+export function tddPlanMissingReason(): string {
+	return "PLAN.md 缺少 ## TDD / 红绿检查。下一步：回到 plan 补充该章节，明确红灯证据、绿灯证据、验证命令或无法自动化时的产品验证替代方案；至少写明 evidence/tdd-red.md、evidence/tdd-green.md 和要运行的真实检查。";
+}
+
+export function tddProductionMissingRedReason(path: string, evidenceName: string): string {
+	return `不能写生产源码 ${path}：缺少红灯证据 ${evidenceName}。下一步：先运行一个实现前应失败的检查，例如 kd_sdk_signature 方法不存在检查、元数据/API 检查、编译检查、kd_check、项目已有测试或外部接口最小验证；把命令、非 0 Exit 或失败输出写入 evidence/tdd-red.md 后再写生产源码。`;
+}
+
+export function tddVerifyBlockedReason(reasons: string[]): string {
+	return [
+		`不能进入 verify：${reasons.join("；")}。`,
+		"修复方式：重新运行 PLAN.md 中声明的同一验证命令或等价的产品验证命令，",
+		"并把命令、Exit、STDOUT/STDERR 或明确的工具输出写入对应 evidence 文件。",
+	].join("");
+}
+
+export function redEvidenceInvalidReason(evidenceName: string): string {
+	return `${evidenceName} 内容无效：需要包含真实失败输出或非 0 退出码`;
+}
+
+export function greenEvidenceInvalidReason(evidenceName: string): string {
+	return `${evidenceName} 内容无效：绿灯证据需要同时包含成功结论和 Exit: 0/退出码：0`;
+}
+
+export function sdkSignatureWriteBlockedReason(path: string, evidenceName: string): string {
+	return `不能写生产源码 ${path}：缺少本地 SDK 签名证据 ${evidenceName}。下一步：运行 kd_sdk_signature，从当前项目真实 jar/dll 查证即将使用的 SDK 类、方法、构造器或属性签名；成功生成 evidence/sdk-signature.md 后再写代码。禁止凭记忆或随包知识库猜 SDK API。`;
+}

package/src/harness/path-policy.ts

@@ -1,6 +1,12 @@
 import type { ActiveRun } from "./types.ts";
 import { existsSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
+import {
+	flagshipPlanNeedsCodePathReason,
+	flagshipPlanNeedsSourcePathReason,
+	flagshipWriteBlockedReason,
+	planWriteBlockedReason,
+} from "./messages.ts";
 
 const SOURCE_EXTENSIONS = new Set([
 	".java",
@@ -23,7 +29,7 @@ export function flagshipWriteBlockReason(run: ActiveRun | undefined, path: strin
 	if (normalized.startsWith(".pi/")) return undefined;
 	if (cwd && !hasWorkspaceCodeDir(cwd)) return undefined;
 	if (!normalized.startsWith("code/")) {
-		return `星空旗舰版代码必须跟随当前项目结构写入 code/ 下，不能写到 ${path}。下一步：先读取当前项目 code/ 下的真实模块结构，在 PLAN.md 记录目标源码路径，再把写入路径改为 code/... 下的项目相对路径。`;
+		return flagshipWriteBlockedReason(path);
 	}
 
 	return undefined;
@@ -37,7 +43,7 @@ export function planWriteBlockReason(cwd: string, run: ActiveRun | undefined, pa
 	if (normalized.startsWith(".pi/")) return undefined;
 	if (planMentionsPath(plan, normalized)) return undefined;
 
-	return `PLAN.md 未批准写入 ${normalized}。下一步：停止写入该文件，回到 plan 阶段检查项目结构和影响范围，把该文件加入 PLAN.md 的 ## 允许修改的文件 和执行步骤；重新通过门禁后再写。`;
+	return planWriteBlockedReason(normalized);
 }
 
 export function flagshipPlanBlockReason(cwd: string, run: ActiveRun | undefined, plan: string): string | undefined {
@@ -45,11 +51,11 @@ export function flagshipPlanBlockReason(cwd: string, run: ActiveRun | undefined,
 
 	if (hasWorkspaceCodeDir(cwd)) {
 		if (/(?:^|[\s`"'(])code[\\/][^\s`"')]+/i.test(plan)) return undefined;
-		return "不能进入 execute：星空旗舰版 PLAN.md 必须先记录当前项目 code/ 下的实际目标路径；不要按固定模块规则猜路径。下一步：列出 code/ 下模块，识别当前项目是按云、按应用还是不分模块组织，在 PLAN.md 写明真实目标文件。";
+		return flagshipPlanNeedsCodePathReason();
 	}
 
 	if (planMentionsDiscoveredSourcePath(plan)) return undefined;
-	return "不能进入 execute：PLAN.md 必须先记录已检查当前项目结构，并写明实际源码根或目标文件路径；当前项目没有 code/ 时更不能猜路径。下一步：读取构建文件和 src/lib/bin 等目录，确认源码根后写入 PLAN.md 的 ## 已检查的项目结构、## 目标源码根 / 路径 和 ## 允许修改的文件。";
+	return flagshipPlanNeedsSourcePathReason();
 }
 
 function hasWorkspaceCodeDir(cwd: string): boolean {

package/src/harness/prompt.ts

@@ -0,0 +1,68 @@
+import { readProjectContext } from "../context/project-context.ts";
+import { readArtifact } from "./artifacts.ts";
+import { formatStatus } from "./format.ts";
+import type { ActiveRun, KdPhase } from "./types.ts";
+import { PHASE_ORDER } from "./types.ts";
+
+export function workflowPromptForRun(cwd: string, run: ActiveRun, userText: string): string {
+	const status = formatStatus(cwd, run);
+	const memory = workflowMemoryForRun(cwd, run);
+	const phaseGuidance = phaseGuidanceForRun(run.phase);
+	const projectContext = readProjectContext(cwd);
+
+	return [
+		"用户输入：",
+		userText,
+		"",
+		"KCode Harness 状态：",
+		status,
+		"",
+		"KCode 阶段资料：",
+		memory,
+		"",
+		"项目上下文：",
+		projectContext ? trimForPrompt(projectContext, 1200) : "未生成。需要项目结构时先运行或提示用户运行 `kcode context --refresh`。",
+		"",
+		"当前阶段任务：",
+		phaseGuidance,
+		"",
+		"核心约束：",
+		"- 产品代码只在 execute 阶段写入，并限于 PLAN.md 批准的文件。",
+		"- Java/C# SDK 签名以当前项目 jar/dll、构建输出或官方元数据为准。",
+		"- Java/Cosmic 用当前项目 Gradle；C#/企业版用 dotnet build。",
+		"- evidence 记录命令、Exit 和关键输出；命令无法运行时记录阻塞原因。",
+		"- Windows 下优先使用项目相对路径；绝对路径使用 D:\\... 形式。",
+	].join("\n");
+}
+
+function phaseGuidanceForRun(phase: KdPhase): string {
+	const guidance: Record<KdPhase, string> = {
+		discuss: "梳理需求来源、范围、已知事实和一个最阻塞的待确认问题。",
+		spec: "把需求转成验收标准、数据对象、异常行为、依赖和风险。",
+		plan: "检查项目结构，写明目标路径、允许修改文件、查证项、验证命令和回滚说明。",
+		execute: "按 PLAN.md 实现，记录步骤结果、变更文件和 evidence。",
+		verify: "运行计划中的验证命令，更新 VERIFY.md、证据和残余风险。",
+		ship: "整理 SHIP.md，包括摘要、验证证据、风险和后续事项。",
+	};
+	return guidance[phase];
+}
+
+function workflowMemoryForRun(cwd: string, run: ActiveRun): string {
+	const currentIndex = PHASE_ORDER.indexOf(run.phase);
+	const phases = PHASE_ORDER.slice(Math.max(0, currentIndex - 1), currentIndex + 1);
+	return (
+		phases
+			.map((phase) => {
+				const content = readArtifact(cwd, run, phase);
+				if (!content) return undefined;
+				return [`## ${phase}`, trimForPrompt(content, 1500)].join("\n");
+			})
+			.filter(Boolean)
+			.join("\n\n") || `阶段文档路径：.pi/kd/runs/${run.id}/`
+	);
+}
+
+function trimForPrompt(content: string, maxLength: number): string {
+	if (content.length <= maxLength) return content;
+	return `${content.slice(0, maxLength)}\n\n[...已截断；需要完整内容时读取本地文件...]`;
+}

package/src/harness/sdk-policy.ts

@@ -4,6 +4,7 @@ import type { ActiveRun } from "./types.ts";
 import { runRoot } from "./paths.ts";
 import { isSourceLikePath } from "./path-policy.ts";
 import { hasEvidenceEntry } from "./evidence.ts";
+import { sdkSignatureWriteBlockedReason } from "./messages.ts";
 
 export const SDK_SIGNATURE_EVIDENCE = "evidence/sdk-signature.md";
 
@@ -31,7 +32,7 @@ export function sdkSignatureProductionWriteBlockReason(cwd: string, run: ActiveR
 	if (normalized.startsWith(".pi/")) return undefined;
 	if (hasValidSdkSignatureEvidence(cwd, run)) return undefined;
 
-	return `不能写生产源码 ${normalized}：缺少本地 SDK 签名证据 ${SDK_SIGNATURE_EVIDENCE}。下一步：运行 kd_sdk_signature，从当前项目真实 jar/dll 查证即将使用的 SDK 类、方法、构造器或属性签名；成功生成 evidence/sdk-signature.md 后再写代码。禁止凭记忆或随包知识库猜 SDK API。`;
+	return sdkSignatureWriteBlockedReason(normalized, SDK_SIGNATURE_EVIDENCE);
 }
 
 function normalizeRelativePath(path: string): string {

package/src/harness/state.ts

@@ -66,7 +66,7 @@ export function finishActiveRun(cwd: string, run: ActiveRun): ActiveRun {
 }
 
 export function createActiveRun(cwd: string, goal: string, productInput?: string, version?: string): ActiveRun {
-	const profile = resolveProductProfile(productInput ?? goal);
+	const profile = resolveProductProfile(productInput);
 	const now = new Date().toISOString();
 	const run: ActiveRun = {
 		id: createRunId(goal),
@@ -155,7 +155,7 @@ export function updateRisk(cwd: string, run: ActiveRun, risk: KdRisk, reason: st
 }
 
 export function ensurePhaseArtifact(cwd: string, run: ActiveRun, phase: KdPhase): string {
-	const path = ensureArtifact(cwd, run, phase, defaultArtifactContent(phase));
+	const path = ensureArtifact(cwd, run, phase, defaultArtifactContent(phase, run.goal, run.profile));
 	run.artifacts[phase] = PHASE_ARTIFACTS[phase];
 	run.gate = inspectGate(cwd, run);
 	writeActiveRun(cwd, run);

package/src/harness/tdd-policy.ts

@@ -4,13 +4,20 @@ import type { ActiveRun } from "./types.ts";
 import { runRoot } from "./paths.ts";
 import { isSourceLikePath } from "./path-policy.ts";
 import { hasEvidenceEntry } from "./evidence.ts";
+import {
+	greenEvidenceInvalidReason,
+	redEvidenceInvalidReason,
+	tddPlanMissingReason,
+	tddProductionMissingRedReason,
+	tddVerifyBlockedReason,
+} from "./messages.ts";
 
 export const TDD_RED_EVIDENCE = "evidence/tdd-red.md";
 export const TDD_GREEN_EVIDENCE = "evidence/tdd-green.md";
 
 export function tddPlanBlockReason(plan: string): string | undefined {
 	if (/##\s*TDD\s*\/\s*红绿检查/i.test(plan)) return undefined;
-	return "PLAN.md 缺少 ## TDD / 红绿检查。下一步：回到 plan 补充该章节，明确红灯证据、绿灯证据、验证命令或无法自动化时的产品验证替代方案；至少写明 evidence/tdd-red.md、evidence/tdd-green.md 和要运行的真实检查。";
+	return tddPlanMissingReason();
 }
 
 export function tddProductionWriteBlockReason(cwd: string, run: ActiveRun | undefined, path: string | undefined): string | undefined {
@@ -22,7 +29,7 @@ export function tddProductionWriteBlockReason(cwd: string, run: ActiveRun | unde
 	if (isTestLikePath(normalized)) return undefined;
 	if (hasValidTddEvidence(cwd, run, "red")) return undefined;
 
-	return `不能写生产源码 ${normalized}：缺少红灯证据 ${TDD_RED_EVIDENCE}。下一步：先运行一个实现前应失败的检查，例如 kd_sdk_signature 方法不存在检查、元数据/API 检查、编译检查、kd_check、项目已有测试或外部接口最小验证；把命令、非 0 Exit 或失败输出写入 evidence/tdd-red.md 后再写生产源码。`;
+	return tddProductionMissingRedReason(normalized, TDD_RED_EVIDENCE);
 }
 
 export function tddVerifyBlockReason(cwd: string, run: ActiveRun): string | undefined {
@@ -31,11 +38,7 @@ export function tddVerifyBlockReason(cwd: string, run: ActiveRun): string | unde
 		validateTddEvidence(cwd, run, "green"),
 	].filter((result) => !result.valid);
 	if (problems.length === 0) return undefined;
-	return [
-		`不能进入 verify：${problems.map((problem) => problem.reason).join("；")}。`,
-		"修复方式：不要反复修改 evidence 文案；必须重新运行 PLAN.md 中声明的同一验证命令或等价的产品验证命令，",
-		"并把命令、Exit、STDOUT/STDERR 或明确的工具输出写入对应 evidence 文件。",
-	].join("");
+	return tddVerifyBlockedReason(problems.map((problem) => problem.reason ?? "未知 TDD evidence 问题"));
 }
 
 function hasValidTddEvidence(cwd: string, run: ActiveRun, kind: "red" | "green"): boolean {
@@ -58,7 +61,7 @@ function validateTddEvidence(cwd: string, run: ActiveRun, kind: "red" | "green")
 		const hasFailure = /red|fail|failed|failure|error|失败|未通过|Exit\s*[：:]\s*[1-9]/i.test(content);
 		return hasFailure
 			? { valid: true }
-			: { valid: false, reason: `${evidenceName} 内容无效：必须包含真实失败输出或非 0 退出码，不能只写结论` };
+			: { valid: false, reason: redEvidenceInvalidReason(evidenceName) };
 	}
 
 	const hasGreenExit = /Exit\s*[：:]\s*0|退出码\s*[：:]\s*0/i.test(content);
@@ -67,7 +70,7 @@ function validateTddEvidence(cwd: string, run: ActiveRun, kind: "red" | "green")
 
 	return {
 		valid: false,
-		reason: `${evidenceName} 内容无效：绿灯证据必须同时包含成功结论和 Exit: 0/退出码：0，不能只写“通过”或人工结论`,
+		reason: greenEvidenceInvalidReason(evidenceName),
 	};
 }
 

package/src/product/profile.ts

@@ -1,4 +1,4 @@
-export type KdProduct = "unknown" | "flagship" | "cosmic" | "xinghan" | "cangqiong" | "enterprise";
+export type KdProduct = "unknown" | "flagship" | "xinghan" | "cangqiong" | "enterprise";
 export type KdPlatform = "unknown" | "cosmic" | "enterprise-csharp" | "enterprise-python";
 export type KdTechStack = "unknown" | "java-bos" | "java-cosmic" | "csharp-bos" | "python-bos" | "ksql";
 export type KdLanguage = "unknown" | "java" | "csharp" | "python" | "sql";
@@ -24,7 +24,7 @@ const PROFILES: Record<KdProduct, ProductProfile> = {
 		language: "unknown",
 		knowledgeScope: "common",
 		requiresMetadataVerification: true,
-		notes: ["尚未选择产品；不要假设 Java、C#、BOS、Cosmic 或 KSQL 规则。"],
+		notes: ["尚未选择产品；不要假设插件技术栈、BOS/Cosmic 平台规则或 KSQL/SQL 交付规则。"],
 	},
 	flagship: {
 		product: "flagship",
@@ -35,21 +35,11 @@ const PROFILES: Record<KdProduct, ProductProfile> = {
 		knowledgeScope: "flagship",
 		requiresMetadataVerification: true,
 		notes: [
-			"星空旗舰版属于 Cosmic 家族。使用 Cosmic 元数据、插件生命周期、SDK 和后置检查约束。",
+			"星空旗舰版基于苍穹/Cosmic 平台。使用平台元数据、插件生命周期、SDK 和后置检查约束，但接口可能存在旗舰版差异。",
 			"如果当前工作区存在 code/ 目录，产品代码应放在 code/ 下。",
 			"创建或编辑代码前，必须检查 code/ 下真实项目结构，并跟随其实际布局；可能按云、按应用组织，也可能不分模块。",
 		],
 	},
-	cosmic: {
-		product: "cosmic",
-		displayName: "金蝶 Cosmic 平台",
-		platform: "cosmic",
-		techStack: "java-cosmic",
-		language: "java",
-		knowledgeScope: "cosmic",
-		requiresMetadataVerification: true,
-		notes: ["Cosmic 是苍穹、星瀚和星空旗舰版的共享平台基础。"],
-	},
 	xinghan: {
 		product: "xinghan",
 		displayName: "金蝶星瀚",
@@ -58,7 +48,7 @@ const PROFILES: Record<KdProduct, ProductProfile> = {
 		language: "java",
 		knowledgeScope: "xinghan",
 		requiresMetadataVerification: true,
-		notes: ["除非存在星瀚特有规则，否则按 Cosmic 家族 Java 处理。"],
+		notes: ["星瀚基于苍穹/Cosmic 平台。默认按平台 Java 插件处理，但接口可能存在星瀚差异。"],
 	},
 	cangqiong: {
 		product: "cangqiong",
@@ -68,7 +58,7 @@ const PROFILES: Record<KdProduct, ProductProfile> = {
 		language: "java",
 		knowledgeScope: "cangqiong",
 		requiresMetadataVerification: true,
-		notes: ["使用苍穹/Cosmic 插件、SDK、元数据、KSQL 和生命周期规则。"],
+		notes: ["Cosmic 在 KCode 中按苍穹平台语境处理。使用苍穹/Cosmic 平台插件、SDK、元数据、KSQL/SQL 和生命周期规则。"],
 	},
 	enterprise: {
 		product: "enterprise",
@@ -86,7 +76,7 @@ const PRODUCT_ALIASES: Array<[RegExp, KdProduct]> = [
 	[/企业版|enterprise|csharp|c#|\.net/i, "enterprise"],
 	[/星瀚|xinghan/i, "xinghan"],
 	[/苍穹|cangqiong/i, "cangqiong"],
-	[/cosmic|云苍穹/i, "cosmic"],
+	[/cosmic|云苍穹/i, "cangqiong"],
 	[/星空旗舰版|星空旗舰|旗舰版|旗舰|flagship/i, "flagship"],
 ];