kcode-pi 0.1.2 → 0.1.5

package/dist/cli/kcode.d.ts

@@ -10,6 +10,7 @@ export interface PiCliCommand {
 }
 export declare function runKcodeCli(args: string[], cwd?: string): KcodeCliResult;
 export declare function initProject(cwd: string): KcodeCliResult;
+export declare function context(cwd: string, args: string[]): KcodeCliResult;
 export declare function doctor(cwd: string): KcodeCliResult;
 export declare function start(cwd: string, piArgs: string[]): KcodeCliResult;
 export declare function resolvePiCliCommand(piArgs?: string[]): PiCliCommand | undefined;

package/dist/cli/kcode.js

@@ -3,6 +3,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
+import { ensureProjectContext, writeProjectContext } from "../context/project-context.js";
 const packageRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
 const require = createRequire(import.meta.url);
 const packageName = readPackageName(packageRoot) ?? "kcode-pi";
@@ -11,6 +12,8 @@ export function runKcodeCli(args, cwd = process.cwd()) {
     switch (command) {
         case "init":
             return initProject(cwd);
+        case "context":
+            return context(cwd, args.slice(1));
         case "doctor":
             return doctor(cwd);
         case "start":
@@ -32,9 +35,18 @@ export function initProject(cwd) {
     settings.packages = packages;
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+    const projectContext = ensureProjectContext(cwd);
     return {
         exitCode: 0,
-        output: [`已更新项目级 Pi 配置：${settingsPath}`, `已保留当前 KCode package：${kcodePackage}`].join("\n"),
+        output: [`已更新项目级 Pi 配置：${settingsPath}`, `已保留当前 KCode package：${kcodePackage}`, `项目上下文：${projectContext.path}`].join("\n"),
+    };
+}
+export function context(cwd, args) {
+    const refresh = args.includes("--refresh") || args.includes("-r");
+    const projectContext = refresh ? writeProjectContext(cwd) : ensureProjectContext(cwd);
+    return {
+        exitCode: 0,
+        output: [`项目上下文已${refresh ? "刷新" : "就绪"}：${projectContext.path}`, "", projectContext.content].join("\n"),
     };
 }
 export function doctor(cwd) {
@@ -47,6 +59,7 @@ export function doctor(cwd) {
     lines.push(`Pi CLI：${formatPiCliStatus(piCli, pi)}`);
     lines.push(`KCode package：${packageRoot}`);
     lines.push(`项目配置：${existsSync(settingsPath) ? settingsPath : "未创建，请先运行 kcode init"}`);
+    lines.push(`项目上下文：${existsSync(join(cwd, ".pi", "kd", "PROJECT_CONTEXT.md")) ? join(cwd, ".pi", "kd", "PROJECT_CONTEXT.md") : "未创建，请运行 kcode context"}`);
     if (existsSync(settingsPath)) {
         const settings = readSettings(settingsPath);
         const hasKcode = (settings.packages ?? []).includes(normalizePath(packageRoot));
@@ -167,6 +180,7 @@ function helpText() {
         "",
         "用法：",
         "  kcode init      初始化当前项目的 .pi/settings.json",
+        "  kcode context   生成或刷新 .pi/kd/PROJECT_CONTEXT.md",
         "  kcode doctor    检查 Node、随包 Pi CLI、KCode package 和项目级配置",
         "  kcode start     初始化项目配置后启动 KCode 工作环境",
     ].join("\n");

package/dist/context/project-context.d.ts

@@ -0,0 +1,9 @@
+export interface ProjectContextResult {
+    path: string;
+    content: string;
+}
+export declare function projectContextPath(cwd: string): string;
+export declare function readProjectContext(cwd: string): string | undefined;
+export declare function ensureProjectContext(cwd: string): ProjectContextResult;
+export declare function writeProjectContext(cwd: string): ProjectContextResult;
+export declare function generateProjectContext(cwd: string): string;

package/dist/context/project-context.js

@@ -0,0 +1,193 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, extname, join, relative } from "node:path";
+const IGNORED_DIRS = new Set([
+    ".git",
+    ".idea",
+    ".pi",
+    ".tmp",
+    ".vscode",
+    "bin",
+    "build",
+    "dist",
+    "node_modules",
+    "out",
+    "target",
+]);
+const SOURCE_EXTENSIONS = new Set([".java", ".kt", ".kts", ".cs", ".py", ".xml", ".properties", ".yml", ".yaml", ".sql", ".ksql"]);
+const BUILD_FILE_NAMES = new Set(["pom.xml", "build.gradle", "build.gradle.kts", "gradlew", "gradlew.bat", "mvnw", "mvnw.cmd", "package.json"]);
+const MAX_DEPTH = 5;
+const MAX_ENTRIES = 3000;
+const MAX_SOURCE_SAMPLES = 60;
+const MAX_MODULES = 80;
+export function projectContextPath(cwd) {
+    return join(cwd, ".pi", "kd", "PROJECT_CONTEXT.md");
+}
+export function readProjectContext(cwd) {
+    const path = projectContextPath(cwd);
+    return existsSync(path) ? readFileSync(path, "utf8") : undefined;
+}
+export function ensureProjectContext(cwd) {
+    const path = projectContextPath(cwd);
+    if (existsSync(path))
+        return { path, content: readFileSync(path, "utf8") };
+    return writeProjectContext(cwd);
+}
+export function writeProjectContext(cwd) {
+    const path = projectContextPath(cwd);
+    const content = generateProjectContext(cwd);
+    mkdirSync(join(cwd, ".pi", "kd"), { recursive: true });
+    writeFileSync(path, content, "utf8");
+    return { path, content };
+}
+export function generateProjectContext(cwd) {
+    const scan = scanProject(cwd);
+    const codeDir = scan.directories.includes("code");
+    const likelyRoots = detectLikelySourceRoots(scan);
+    const modules = detectModules(scan);
+    const buildFiles = scan.files.filter((file) => BUILD_FILE_NAMES.has(basename(file).toLowerCase()) || isSolutionOrProject(file));
+    const sourceSamples = scan.files.filter((file) => SOURCE_EXTENSIONS.has(extname(file).toLowerCase())).slice(0, MAX_SOURCE_SAMPLES);
+    return [
+        "# KCode Project Context",
+        "",
+        `- Project root: ${cwd}`,
+        `- Project name: ${basename(cwd)}`,
+        `- Generated at: ${new Date().toISOString()}`,
+        "",
+        "## Persistent Rules",
+        "",
+        "- This file is project memory for KCode. Read it before planning or editing code.",
+        "- Do not create demo/sample/scaffold code for business requirements.",
+        "- Do not assume module layout. Follow the actual paths below and verify target files before editing.",
+        "- Use project-relative paths when calling file tools. On Windows, do not rewrite paths to /mnt/<drive>/... or /<drive>/...; use Windows paths only when an absolute path is necessary.",
+        "- If this file is stale, regenerate with `kcode context --refresh` before planning.",
+        "- Write product code only after the Harness reaches `execute` and PLAN.md names the real target path.",
+        "",
+        "## Layout Summary",
+        "",
+        `- Has code directory: ${codeDir ? "yes" : "no"}`,
+        `- Likely source roots: ${formatList(likelyRoots)}`,
+        `- Build files: ${formatList(buildFiles)}`,
+        `- Detected modules: ${formatList(modules)}`,
+        "",
+        "## Source Samples",
+        "",
+        formatBlockList(sourceSamples),
+        "",
+        "## Top-Level Directories",
+        "",
+        formatBlockList(scan.directories.filter((dir) => !dir.includes("/") && !dir.includes("\\")).sort()),
+        "",
+    ].join("\n");
+}
+function scanProject(cwd) {
+    const files = [];
+    const directories = [];
+    const queue = [{ path: cwd, depth: 0 }];
+    let entries = 0;
+    while (queue.length > 0 && entries < MAX_ENTRIES) {
+        const current = queue.shift();
+        if (!current)
+            break;
+        let children;
+        try {
+            children = readdirSync(current.path);
+        }
+        catch {
+            continue;
+        }
+        for (const child of children) {
+            if (entries >= MAX_ENTRIES)
+                break;
+            const fullPath = join(current.path, child);
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            const rel = normalize(relative(cwd, fullPath));
+            entries++;
+            if (stat.isDirectory()) {
+                if (IGNORED_DIRS.has(child))
+                    continue;
+                directories.push(rel);
+                if (current.depth < MAX_DEPTH)
+                    queue.push({ path: fullPath, depth: current.depth + 1 });
+                continue;
+            }
+            if (stat.isFile())
+                files.push(rel);
+        }
+    }
+    return { files: files.sort(), directories: directories.sort() };
+}
+function detectLikelySourceRoots(scan) {
+    const roots = new Set();
+    const knownRoots = [
+        "code/src/main/java",
+        "code/src/main/resources",
+        "src/main/java",
+        "src/main/resources",
+        "src",
+        "script",
+        "scripts",
+        "plugins",
+    ];
+    for (const root of knownRoots) {
+        if (scan.directories.includes(root) || scan.files.some((file) => file.startsWith(`${root}/`)))
+            roots.add(root);
+    }
+    for (const file of scan.files) {
+        if (!SOURCE_EXTENSIONS.has(extname(file).toLowerCase()))
+            continue;
+        const marker = sourceRootFromFile(file);
+        if (marker)
+            roots.add(marker);
+    }
+    return [...roots].slice(0, MAX_MODULES);
+}
+function detectModules(scan) {
+    const modules = new Set();
+    for (const file of scan.files) {
+        const name = basename(file).toLowerCase();
+        if (!BUILD_FILE_NAMES.has(name) && !isSolutionOrProject(file))
+            continue;
+        const dir = normalize(file.slice(0, -basename(file).length).replace(/[\\/]$/, ""));
+        modules.add(dir || ".");
+    }
+    for (const sourceRoot of detectLikelySourceRoots(scan)) {
+        const parts = sourceRoot.split("/");
+        if (parts.length > 3)
+            modules.add(parts.slice(0, -3).join("/") || ".");
+    }
+    return [...modules].filter(Boolean).sort().slice(0, MAX_MODULES);
+}
+function sourceRootFromFile(file) {
+    const normalized = normalize(file);
+    const javaIndex = normalized.indexOf("/src/main/java/");
+    if (javaIndex >= 0)
+        return normalized.slice(0, javaIndex + "/src/main/java".length);
+    const resourcesIndex = normalized.indexOf("/src/main/resources/");
+    if (resourcesIndex >= 0)
+        return normalized.slice(0, resourcesIndex + "/src/main/resources".length);
+    const srcIndex = normalized.indexOf("/src/");
+    if (srcIndex >= 0)
+        return normalized.slice(0, srcIndex + "/src".length);
+    const first = normalized.split("/")[0];
+    return first && SOURCE_EXTENSIONS.has(extname(normalized).toLowerCase()) ? first : undefined;
+}
+function isSolutionOrProject(file) {
+    return [".sln", ".csproj"].includes(extname(file).toLowerCase());
+}
+function formatList(values) {
+    return values.length > 0 ? values.join(", ") : "none detected";
+}
+function formatBlockList(values) {
+    if (values.length === 0)
+        return "- none detected";
+    return values.map((value) => `- ${value}`).join("\n");
+}
+function normalize(path) {
+    return path.replace(/\\/g, "/");
+}

package/docs/DEVELOPMENT.md

@@ -0,0 +1,162 @@
+# KCode 开发与发布说明
+
+本文档面向 KCode 维护者。用户安装和使用说明请看根目录 `README.md`。
+
+## 源码开发
+
+克隆仓库并安装依赖：
+
+```powershell
+git clone <KCodeV2仓库地址>
+cd KCodeV2
+npm install
+```
+
+源码仓库内可用 npm script 调试同一个入口：
+
+```powershell
+npm run kcode -- doctor
+npm run kcode -- init
+npm run kcode -- start
+```
+
+## 本地验证
+
+常用检查：
+
+```powershell
+npm run check
+npm run build:cli
+npm run smoke:knowledge
+npm run smoke:checker
+npm run smoke:harness
+npm run smoke:official
+npm run smoke:build-debug
+npm run smoke:package
+npm run smoke:kcode-cli
+```
+
+这些 smoke 分别验证：
+
+- TypeScript 类型检查。
+- CLI 构建产物。
+- 金蝶知识库搜索。
+- `kd_check` 静态规则。
+- Harness 阶段和门禁。
+- 官方能力 Node 适配器。
+- 构建/调试诊断。
+- package manifest、skills、vendor 文件完整性。
+- `kcode` 项目级入口逻辑。
+
+## CLI 构建
+
+全局 `kcode` 命令来自：
+
+```text
+src/cli/main.ts
+```
+
+构建输出：
+
+```text
+dist/cli/main.js
+dist/cli/kcode.js
+```
+
+构建命令：
+
+```powershell
+npm run build:cli
+```
+
+`package.json` 中的关键发布字段：
+
+```json
+{
+  "bin": {
+    "kcode": "./dist/cli/main.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "extensions",
+    "skills",
+    "prompts",
+    "themes",
+    "knowledge",
+    "vendor",
+    "docs/KCODE_DISTRIBUTION.md",
+    "README.md"
+  ]
+}
+```
+
+注意：`extensions/*.ts` 运行时会引用 `../src/**`，因此发布包必须包含 `src`。
+
+## 发布 npm 包
+
+发布前确认：
+
+- `package.json.name` 是预期包名。
+- `package.json.version` 已递增。
+- npm registry 指向正确位置。
+- `npm pack --dry-run` 包含 `dist`、`src`、`extensions`、`skills`、`prompts`、`themes`、`knowledge`、`vendor`。
+
+发布检查：
+
+```powershell
+npm run check
+npm run build:cli
+npm run smoke:package
+npm run smoke:kcode-cli
+npm pack --dry-run
+```
+
+发布：
+
+```powershell
+npm publish
+```
+
+如果使用 scoped 包并发布到公网 npm：
+
+```powershell
+npm publish --access public
+```
+
+`prepack` 会自动执行：
+
+```powershell
+npm run build:cli
+npm run smoke:package
+```
+
+## 发行策略
+
+KCode 不 fork Pi，也不替换 Pi 生态。KCode 作为 Pi package 提供金蝶工具、skills、prompts、themes 和知识库；`kcode` 启动器负责项目初始化、环境检查和启动随包 Pi CLI。
+
+详细发行边界见：
+
+```text
+docs/KCODE_DISTRIBUTION.md
+```
+
+## 第三方 Pi package 策略
+
+默认不内置第三方 Pi packages。
+
+允许接入前必须检查：
+
+- package 来源和维护状态。
+- license 是否允许企业内部分发。
+- 是否注册 extensions、hooks、commands、tools。
+- 是否写全局配置或访问敏感路径。
+- 是否与 KCode harness、权限策略、上下文策略冲突。
+
+通过审查后优先使用项目级推荐安装，写入 `.pi/settings.json`。只有离线交付或强依赖时，才考虑 `dependencies` + `bundledDependencies` 内置。
+
+## 当前维护事项
+
+- 当前包名是 `kcode-pi`；如果企业侧要叫 `kcode-cli`，发布前需要调整 `package.json.name`。
+- 更深层的 reviewer 语义规则、HTML 审查报告、自动 SQL 产物生成仍在后续计划中。
+- 集成进度见根目录 `OFFICIAL_SKILLS_STATUS.md`。

package/docs/KCODE_DISTRIBUTION.md

@@ -88,4 +88,4 @@ kcode start     初始化后启动 KCode 工作环境
 
 ## 当前限制
 
-当前仍是仓库内启动器原型，尚未拆成独立 npm 全局包。真实交互式 Pi runtime smoke 需要在具备可用模型/API 配置的环境中执行。
+当前仓库已可作为 npm 包发布，并提供全局 `kcode` 命令。真实交互式 Pi runtime smoke 需要在具备可用模型/API 配置的环境中执行。

package/extensions/kingdee-harness.ts

@@ -11,6 +11,14 @@ import {
 	updateProductProfile,
 	updatePhaseArtifact,
 } from "../src/harness/state.ts";
+import { readArtifact } from "../src/harness/artifacts.ts";
+import { flagshipWriteBlockReason, isSourceLikePath, planWriteBlockReason } from "../src/harness/path-policy.ts";
+import { tddProductionWriteBlockReason } from "../src/harness/tdd-policy.ts";
+import { readProjectContext } from "../src/context/project-context.ts";
+import { windowsPathHint } from "../src/platform/path.ts";
+
+const KINGDEE_INTENT_PATTERN =
+	/金蝶|苍穹|星瀚|星空|旗舰|企业版|单据|表单|列表|插件|操作插件|校验器|反写|转换|工作流|基础资料|动态对象|DynamicObject|BOS|Cosmic|IronPython|Python\s*插件|py\s*插件|kd_|KSQL/i;
 
 function requireRun(cwd: string): ReturnType<typeof readActiveRun> {
 	return readActiveRun(cwd);
@@ -59,6 +67,82 @@ function parseProductArgs(args: string): { product: string; version?: string } |
 	return { product, version: parsed.version };
 }
 
+function shouldStartHarnessFromInput(text: string): boolean {
+	if (!text.trim() || text.trim().startsWith("/")) return false;
+	return KINGDEE_INTENT_PATTERN.test(text);
+}
+
+function workflowPromptForRun(cwd: string, run: NonNullable<ReturnType<typeof readActiveRun>>, userText: string): string {
+	const status = formatStatus(cwd, run);
+	const memory = workflowMemoryForRun(cwd, run);
+	const phaseGuidance: Record<KdPhase, string> = {
+		discuss:
+			"当前处于 discuss。先使用 kd-discuss 梳理需求、产品版本、插件类型、目标单据/表单、生命周期、边界和开放问题；不要生成 demo，不要编辑产品代码。",
+		spec:
+			"当前处于 spec。先使用 kd-spec 明确验收标准、生命周期、字段/元数据/API 假设和风险；不要编辑产品代码。",
+		plan:
+			"当前处于 plan。先使用 kd-plan 检查当前项目结构，写明实际目标路径、要检查和要修改的文件、Kingdee 查证项、验证命令和回滚说明；不要编辑产品代码。",
+		execute:
+			"当前处于 execute。只能实现 PLAN.md 中批准的内容。先读取 PLAN.md 和实际项目文件，遵循既有结构写真实可用代码；不要写 demo/sample/scaffold。",
+		verify:
+			"当前处于 verify。先使用 kd-verify 收集验证证据，不要继续扩大代码改动。",
+		ship:
+			"当前处于 ship。整理发布摘要、验证证据、风险和后续事项，不要继续扩大代码改动。",
+	};
+
+	return [
+		"用户输入：",
+		userText,
+		"",
+		"KCode 项目常驻上下文：",
+		readProjectContext(cwd) ?? "未生成。请在终端运行 `kcode context --refresh` 后继续；在生成前不要猜测项目目录。",
+		"",
+		"KCode Harness 状态：",
+		status,
+		"",
+		"KCode 本次工作流本地文档：",
+		memory,
+		"",
+		phaseGuidance[run.phase],
+		"必须先理解当前业务项目已有目录、模块、包名、基类和本地封装，再决定文件位置和实现方式。",
+		"路径规则：在 Windows 工作区内，优先使用项目相对路径；如需绝对路径必须使用 `D:\\...` 这类 Windows 路径，禁止把路径改写成 `/mnt/d/...`、`/d/...` 等 WSL/MSYS 风格路径。",
+		"execute 阶段只能写 PLAN.md 明确列出的源码文件；如果目标文件不在计划内，必须先回到 plan 更新 PLAN.md。",
+		"写生产源码前必须先有红灯证据 evidence/tdd-red.md；红绿证据可以是 API/基类/方法签名、元数据、编译、既有测试框架或外部接口最小验证，不要为了测试引入额外 jar。",
+	].join("\n");
+}
+
+function workflowMemoryForRun(cwd: string, run: NonNullable<ReturnType<typeof readActiveRun>>): string {
+	const phases = PHASE_ORDER.slice(0, PHASE_ORDER.indexOf(run.phase) + 1);
+	return phases
+		.map((phase) => {
+			const content = readArtifact(cwd, run, phase);
+			if (!content) return undefined;
+			return [`## ${phase}`, trimForPrompt(content, 6000)].join("\n");
+		})
+		.filter(Boolean)
+		.join("\n\n") || "暂无阶段文档。";
+}
+
+function trimForPrompt(content: string, maxLength: number): string {
+	if (content.length <= maxLength) return content;
+	return `${content.slice(0, maxLength)}\n\n[...文档过长，已截断；如需完整内容必须读取本地文件...]`;
+}
+
+function codeWriteBlockReason(cwd: string, path: string | undefined): string | undefined {
+	if (!path || !isSourceLikePath(path)) return undefined;
+
+	const run = readActiveRun(cwd);
+	if (!run) {
+		return "KCode 工作流未启动，不能直接写产品代码。请先用自然语言说明需求，KCode 会进入 discuss，或手动运行 /kd-start <需求>。";
+	}
+
+	if (run.phase !== "execute") {
+		return `当前 KCode 阶段是 ${run.phase}，不能写产品代码。请先完成 discuss -> spec -> plan 并进入 execute。`;
+	}
+
+	return tddProductionWriteBlockReason(cwd, run, path) ?? planWriteBlockReason(cwd, run, path, readArtifact(cwd, run, "plan") ?? "");
+}
+
 const kdPlanStatusTool = defineTool({
 	name: "kd_plan_status",
 	label: "KD Status",
@@ -77,6 +161,44 @@ const kdPlanStatusTool = defineTool({
 export default function (pi: ExtensionAPI) {
 	pi.registerTool(kdPlanStatusTool);
 
+	pi.on("input", async (event, ctx) => {
+		if (event.source === "extension") return { action: "continue" };
+
+		let run = readActiveRun(ctx.cwd);
+		if (!run && shouldStartHarnessFromInput(event.text)) {
+			run = createActiveRun(ctx.cwd, event.text);
+			if (ctx.hasUI) {
+				ctx.ui.notify(`Started Kingdee harness run: ${run.id} (${run.profile?.product}/${run.profile?.techStack})`, "info");
+			}
+		}
+
+		if (!run) return { action: "continue" };
+
+		return {
+			action: "transform",
+			text: workflowPromptForRun(ctx.cwd, run, event.text),
+		};
+	});
+
+	pi.on("tool_call", (event, ctx) => {
+		const input = event.input as Record<string, unknown>;
+		const path = typeof input.path === "string" ? input.path : undefined;
+		const hint = path ? windowsPathHint(path) : undefined;
+		if (hint && ["read", "write", "edit"].includes(event.toolName)) {
+			const reason = `当前是 Windows 工作区，不能使用 WSL/MSYS 路径 ${path}。请改用项目相对路径，或使用 Windows 路径 ${hint}。`;
+			if (ctx.hasUI) ctx.ui.notify(reason, "warning");
+			return { block: true, reason };
+		}
+
+		if (event.toolName !== "write" && event.toolName !== "edit") return undefined;
+
+		const reason = codeWriteBlockReason(ctx.cwd, path) ?? flagshipWriteBlockReason(readActiveRun(ctx.cwd), path, ctx.cwd);
+		if (!reason) return undefined;
+
+		if (ctx.hasUI) ctx.ui.notify(reason, "warning");
+		return { block: true, reason };
+	});
+
 	pi.registerCommand("kd-status", {
 		description: "Show the active Kingdee harness run and gate status",
 		handler: async (_args, ctx) => {

package/extensions/kingdee-tools.ts

@@ -17,9 +17,10 @@ import {
 	type OfficialEvidenceFile,
 	isCosmicFamily,
 	ksqlLintCommand,
-	runCommand,
+	runOfficialCommand,
 	writeOfficialEvidence,
 } from "../src/official/kingdee-skills.ts";
+import { resolveWorkspacePath } from "../src/platform/path.ts";
 
 const extensionDir = dirname(fileURLToPath(import.meta.url));
 const knowledgePath = join(extensionDir, "..", "knowledge");
@@ -41,6 +42,7 @@ function editionForBundledKnowledge(profile: ProductProfile, edition: string | u
 
 function scopesForProfile(profile: ProductProfile, edition: string | undefined): KnowledgeScope[] | undefined {
 	if (profile.product === "unknown") return edition ? [normalizeEdition(edition)] : undefined;
+	if (profile.techStack === "python-bos") return ["enterprise", "enterprise-python"];
 	if (profile.platform === "enterprise-csharp") return ["enterprise"];
 	if (profile.platform === "cosmic") {
 		const scopes: KnowledgeScope[] = ["cosmic"];
@@ -51,11 +53,13 @@ function scopesForProfile(profile: ProductProfile, edition: string | undefined):
 }
 
 function normalizeLanguage(value: string | undefined): CheckLanguage {
+	if (value === "python") return "python";
 	return value === "csharp" ? "csharp" : "java";
 }
 
 function languageForProfile(profile: ProductProfile, value: string | undefined): CheckLanguage {
 	if (value) return normalizeLanguage(value);
+	if (profile.language === "python") return "python";
 	if (profile.language === "csharp") return "csharp";
 	return "java";
 }
@@ -80,7 +84,7 @@ async function runOrDryRun(
 		};
 	}
 
-	const result = await runCommand(command);
+	const result = await runOfficialCommand(command);
 	const evidencePath = evidenceFile ? writeOfficialEvidence(ctx.cwd, evidenceFile, result) : undefined;
 	return {
 		content: [{ type: "text" as const, text: formatCommandResult(result) }],
@@ -176,12 +180,12 @@ const kdCheckTool = defineTool({
 	name: "kd_check",
 	label: "KD Check",
 	description:
-		"Check Kingdee Java/C# plugin code for magic values, naming issues, DB calls in loops, and empty catch blocks.",
+		"Check Kingdee Java/C#/Python plugin code for magic values, naming issues, DB calls in loops, and empty catch blocks.",
 	parameters: Type.Object({
 		code: Type.Optional(Type.String({ description: "Source code to check. Use this or path." })),
 		path: Type.Optional(Type.String({ description: "Path to a source file to check. Use this or code." })),
 		product: Type.Optional(Type.String({ description: "Kingdee product. Used to derive Java or C# when language is omitted." })),
-		language: Type.Optional(Type.String({ description: "Language: java or csharp. Overrides product-derived language." })),
+		language: Type.Optional(Type.String({ description: "Language: java, csharp, or python. Overrides product-derived language." })),
 	}),
 
 	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -191,7 +195,7 @@ const kdCheckTool = defineTool({
 		let source = "inline";
 
 		if (!code && params.path) {
-			const filePath = join(ctx.cwd, params.path);
+			const filePath = resolveWorkspacePath(ctx.cwd, params.path);
 			code = readFileSync(filePath, "utf8");
 			source = params.path;
 		}