@luckychen1993/pm-mcp 0.1.4 → 0.3.0

package/dist/language-adapters.js

@@ -1,18 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { SCAN_IGNORE_DIRS, ignoreMatcher, projectScanIgnores } from "./scan-policy.js";
 import { parseManifestDependencies } from "./language-dependencies.js";
-const DEFAULT_IGNORE_DIRS = new Set([
-    ".git", ".pm", ".idea", ".vscode", ".venv", "venv", "env", "__pycache__",
-    "node_modules", "dist", "build", "out", "target", ".gradle", ".next", ".nuxt",
-    ".output", ".turbo", "coverage", ".cache",
-]);
-const LANGUAGE_ORDER = [
-    "javascript", "typescript", "python", "go", "rust", "java", "kotlin", "csharp",
-];
+const DEFAULT_IGNORE_DIRS = SCAN_IGNORE_DIRS;
+const LANGUAGE_ORDER = ["javascript", "typescript", "python", "go", "rust", "java", "kotlin", "csharp"];
 const KIND_ORDER = ["test", "build", "lint", "typecheck", "coverage", "security"];
 const DEFAULT_TIMEOUT_MS = 5 * 60_000;
-const DEFAULT_OUTPUT_BYTES = 64 * 1024;
+// 计数汇总（"# tests N"）在输出末尾，只保留头部会把它一起丢掉 → 计数器解析为 null → 验收把实测值判成 -1。
+const DEFAULT_OUTPUT_BYTES = 1024 * 1024;
 function normalize(value) {
     return value.replace(/\\/g, "/");
 }
@@ -258,6 +254,7 @@ export function discoverProjectUnits(root, options = {}) {
     if (!Number.isInteger(maxDepth) || maxDepth < 0)
         throw new Error("maxDepth must be a non-negative integer");
     const ignored = new Set([...DEFAULT_IGNORE_DIRS, ...(options.ignoreDirs ?? [])]);
+    const excluded = ignoreMatcher(projectScanIgnores(repositoryRoot));
     const grouped = new Map();
     const walk = (dir, depth) => {
         if (depth > maxDepth)
@@ -265,6 +262,8 @@ export function discoverProjectUnits(root, options = {}) {
         const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
         for (const entry of entries) {
             const absolute = path.join(dir, entry.name);
+            if (excluded(normalize(path.relative(repositoryRoot, absolute)), entry.isDirectory()))
+                continue;
             if (entry.isDirectory()) {
                 if (!ignored.has(entry.name))
                     walk(absolute, depth + 1);
@@ -403,7 +402,9 @@ async function runOne(item) {
         // shell:false is intentional: arguments never undergo shell parsing.
         let child;
         try {
-            child = spawn(item.command, item.args, { cwd: item.cwd, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+            // Node 测试宿主的内部标记会让子 node --test 直接跳过文件并退出0，不能泄漏给质量命令。
+            const { NODE_TEST_CONTEXT: _nodeTestContext, ...env } = process.env;
+            child = spawn(item.command, item.args, { cwd: item.cwd, env, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
         }
         catch (error) {
             const err = error;

package/dist/license.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { scanExclusionNote } from "./scan-policy.js";
 import path from "node:path";
 import { loadFileNotes, loadProject } from "./store.js";
 import { isTestFile, readDirectDeps } from "./scan.js";
@@ -11,10 +12,11 @@ import { foldLines } from "./budget.js";
  */
 const STRONG_COPYLEFT = ["GPL-2.0", "GPL-3.0", "AGPL-3.0", "SSPL-1.0", "GPL", "AGPL", "SSPL"];
 const WEAK_COPYLEFT = ["LGPL", "MPL-2.0", "MPL", "EPL", "CDDL", "EUPL", "Sleepycat"];
-const PERMISSIVE = ["MIT", "Apache-2.0", "Apache", "BSD-2-Clause", "BSD-3-Clause", "BSD", "ISC", "0BSD", "Unlicense", "Zlib", "Python-2.0", "BSL-1.0"];
+const PERMISSIVE = ["MIT", "Apache-2.0", "Apache", "BSD-2-Clause", "BSD-3-Clause", "BSD", "ISC", "0BSD", "Unlicense", "Zlib", "Python-2.0", "BSL-1.0", "BlueOak-1.0.0"];
 /** 单个包最多登记数（巨型依赖树保护；超出部分计数上报） */
 const MAX_DEPS = 800;
-function classify(license) {
+/** 单个许可标识的判定（不含 SPDX 表达式拆解）。 */
+function classifySingle(license) {
     const l = license.trim();
     if (!l)
         return "unknown";
@@ -31,6 +33,27 @@ function classify(license) {
         return "permissive";
     return "unknown";
 }
+/**
+ * 判定依赖许可证。支持 SPDX 表达式：去掉外层括号后按 OR 拆开，逐项判定并取【最严格】的一项。
+ * 取最严格而非最宽松，是为了不削弱发布门禁：(MIT OR GPL-3.0) 仍判 strong-copyleft；
+ * 只有全部操作数都为宽松许可时（如 (MIT OR WTFPL)）才不再落到 unknown。
+ */
+function classify(license) {
+    const stripped = license.trim().replace(/^\((.*)\)$/u, "$1").trim();
+    if (!stripped)
+        return "unknown";
+    if (/\s+OR\s+/iu.test(stripped)) {
+        const rank = { unknown: 0, permissive: 1, "weak-copyleft": 2, "strong-copyleft": 3 };
+        let worst = "unknown";
+        for (const part of stripped.split(/\s+OR\s+/iu)) {
+            const kind = classifySingle(part.replace(/^\((.*)\)$/u, "$1").trim());
+            if (rank[kind] > rank[worst])
+                worst = kind;
+        }
+        return worst;
+    }
+    return classifySingle(stripped);
+}
 function readPkgLicense(pkgFile) {
     try {
         const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf8"));
@@ -96,6 +119,8 @@ function readNodeLicenses(root) {
         if (!fs.existsSync(nested))
             continue;
         for (const entry of fs.readdirSync(nested, { withFileTypes: true })) {
+            if (entry.name.startsWith("."))
+                continue;
             if (entry.name.startsWith("@") && isDirLike(entry)) {
                 for (const sub of fs.readdirSync(path.join(nested, entry.name), { withFileTypes: true })) {
                     if (isDirLike(sub))
@@ -147,6 +172,7 @@ export function auditLicense(root, maxLines = 150, forceFresh = false, indexPrep
     const declared = project.license || pkgLicense;
     const projectKind = classify(declared);
     const L = [];
+    L.push(...scanExclusionNote(root));
     L.push("## 许可证审计");
     /* ① 项目声明 */
     L.push("");

package/dist/paths.js

@@ -57,7 +57,7 @@ export function ensurePmRuntimeIgnored(root) {
     fs.mkdirSync(directory, { recursive: true });
     fs.mkdirSync(path.join(directory, ".runtime", "idempotency"), { recursive: true });
     const file = path.join(directory, ".gitignore");
-    const required = [".lock", ".runtime/", "benchmarks/", "index.db*"];
+    const required = [".lock", ".runtime/", "benchmarks/", "index.db*", "usage-log*.jsonl*", "runtime-log*.jsonl*"];
     for (let attempt = 0; attempt < 3; attempt += 1) {
         const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
         const lines = current.split(/\r?\n/).map((line) => line.trim());

package/dist/probe.js

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { VERSION } from "./version.js";
+/**
+ * 标准 raw tools/list 直连探针。
+ *
+ * 宿主（ZCode/Codex/Cursor）是唯一 MCP client 持有者，不向模型透传原始
+ * `tools/list`；本探针绕过宿主，自己以 MCP client 身份直连服务器进程，
+ * 拿协议线上的原始工具清单，并可与期望表比对（如 Codex allowlist）。
+ */
+export const PROBE_USAGE = "pm-mcp probe [--timeout <毫秒>] [--expect <逗号分隔工具名> | --expect-file <json>] -- <启动 MCP 服务器的命令...>";
+export function parseProbeArgs(argv) {
+    const separator = argv.indexOf("--");
+    const optionArgs = separator >= 0 ? argv.slice(0, separator) : argv;
+    const serverArgs = separator >= 0 ? argv.slice(separator + 1) : [];
+    const options = { command: "", args: [], timeoutMs: 30_000 };
+    let expectSeen = 0;
+    for (let index = 0; index < optionArgs.length; index++) {
+        const arg = optionArgs[index], value = optionArgs[index + 1];
+        if (arg === "--timeout") {
+            const parsed = Number(value);
+            if (!value || !Number.isFinite(parsed) || parsed <= 0)
+                throw new Error(`probe 参数无效: ${arg} ${value ?? "(缺值)"}`);
+            options.timeoutMs = parsed;
+            index++;
+        }
+        else if (arg === "--expect" || arg === "--expect-file") {
+            if (!value)
+                throw new Error(`probe 参数无效: ${arg} (缺值)`);
+            if (++expectSeen > 1)
+                throw new Error("--expect 与 --expect-file 只能用一个。");
+            options.expect = arg === "--expect" ? parseExpectList(value) : readExpectFile(value);
+            index++;
+        }
+        else
+            throw new Error(`probe 参数无效: ${arg}。用法：${PROBE_USAGE}`);
+    }
+    if (separator < 0 || serverArgs.length === 0)
+        throw new Error(`缺少 "-- <服务器启动命令>"。用法：${PROBE_USAGE}`);
+    if (serverArgs.includes("--"))
+        throw new Error("服务器启动命令内部不能再出现 -- 分隔符。");
+    options.command = serverArgs[0];
+    options.args = serverArgs.slice(1);
+    return options;
+}
+function parseExpectList(value) {
+    const names = [...new Set(value.split(",").map((name) => name.trim()).filter(Boolean))];
+    if (names.length === 0)
+        throw new Error("--expect 至少需要一个工具名。");
+    return names;
+}
+/** 期望表接受：字符串数组、上一轮 probe 报告、或 {tools:[名字|{name}]}。 */
+function readExpectFile(file) {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 2 * 1024 * 1024)
+        throw new Error("expect 文件必须为有界普通文件，禁止链接。");
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`expect 文件不是合法 JSON：${error.message}`);
+    }
+    const list = Array.isArray(parsed) ? parsed
+        : Array.isArray(parsed?.tools) ? parsed.tools
+            : undefined;
+    if (!list)
+        throw new Error("expect 文件格式不识别：应为字符串数组、probe 报告或 {tools:[...]}。");
+    const names = [...new Set(list.map((entry) => typeof entry === "string" ? entry : entry?.name)
+            .filter((name) => typeof name === "string" && name.length > 0))];
+    if (names.length === 0)
+        throw new Error("expect 文件里没有可识别的工具名。");
+    return names;
+}
+export async function runProbe(options) {
+    const timeoutMs = options.timeoutMs;
+    const report = { ok: false, command: options.command, args: options.args, toolCount: 0, tools: [], issues: [] };
+    const client = new Client({ name: "pm-mcp-probe", version: VERSION });
+    // env 为覆盖式合并（SDK 先取默认安全白名单再覆盖），供 PM_MCP_HOME 之类的沙箱重定向。
+    const transport = new StdioClientTransport({ command: options.command, args: options.args, stderr: "pipe", env: options.env });
+    try {
+        await client.connect(transport, { timeout: timeoutMs });
+        transport.stderr?.on("data", () => undefined);
+        const info = client.getServerVersion();
+        if (info)
+            report.serverInfo = { name: info.name, version: info.version };
+        const tools = [];
+        let cursor;
+        do {
+            const page = await client.listTools(cursor ? { cursor } : {}, { timeout: timeoutMs });
+            for (const tool of page.tools)
+                tools.push({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema });
+            cursor = page.nextCursor;
+        } while (cursor);
+        report.tools = tools;
+        report.toolCount = tools.length;
+        if (tools.length === 0)
+            report.issues.push("服务器未暴露任何工具。");
+        if (options.expect) {
+            const actual = new Set(tools.map((tool) => tool.name));
+            const expected = [...new Set(options.expect)];
+            const missing = expected.filter((name) => !actual.has(name));
+            const extra = tools.map((tool) => tool.name).filter((name) => !expected.includes(name));
+            report.expect = { expected, missing, extra };
+            if (missing.length > 0)
+                report.issues.push(`服务器未暴露 ${missing.length} 个期望工具: ${missing.join(", ")}`);
+            if (extra.length > 0)
+                report.issues.push(`服务器暴露了 ${extra.length} 个期望之外的工具: ${extra.join(", ")}`);
+        }
+        report.ok = report.issues.length === 0;
+    }
+    catch (error) {
+        report.issues.push(`raw tools/list 探测失败: ${error.message}`);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+        hardKill(transport);
+    }
+    return report;
+}
+/** client.close() 正常会终止子进程；这里兜底清理仍存活的残留，避免夹具/服务器挂死。 */
+function hardKill(transport) {
+    const pid = transport.pid;
+    if (!pid)
+        return;
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return;
+    }
+    try {
+        if (process.platform === "win32")
+            spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true });
+        else
+            process.kill(pid, "SIGKILL");
+    }
+    catch { /* 尽力而为 */ }
+}

package/dist/project-fingerprint.js

@@ -1,11 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
-const DEFAULT_IGNORED_DIRECTORIES = new Set([
-    ".git", ".pm", ".cache", ".gradle", ".idea", ".next", ".nuxt", ".output", ".turbo", ".venv", ".vscode", ".zcode",
-    "__pycache__", "build", "coverage", "dist", "env", "node_modules", "out", "target", "venv",
-]);
-function hashRegularFile(file) {
+import { SCAN_IGNORE_DIRS, ignoreMatcher, projectScanIgnores } from "./scan-policy.js";
+const DEFAULT_IGNORED_DIRECTORIES = SCAN_IGNORE_DIRS;
+export function hashRegularFile(file) {
     const handle = fs.openSync(file, "r");
     const digest = createHash("sha256");
     const buffer = Buffer.allocUnsafe(1024 * 1024);
@@ -43,6 +41,10 @@ export function fingerprintProject(root) {
         throw new Error(`项目根必须是普通目录: ${absolute}`);
     const rootReal = fs.realpathSync.native(absolute);
     const tree = createHash("sha256");
+    const ignores = projectScanIgnores(root);
+    const excluded = ignoreMatcher(ignores);
+    if (ignores.length)
+        tree.update(`scan-ignore\0${JSON.stringify(ignores)}\0`);
     let files = 0;
     let bytes = 0;
     const visit = (directory, relativeDirectory) => {
@@ -52,6 +54,8 @@ export function fingerprintProject(root) {
                 continue;
             const absoluteEntry = path.join(directory, entry.name);
             const relative = path.posix.join(relativeDirectory.replace(/\\/g, "/"), entry.name);
+            if (excluded(relative, entry.isDirectory()))
+                continue;
             if (relative === "PROJECT.md")
                 continue; // generated dashboard; authoritative inputs live in .pm and source files
             const stat = fs.lstatSync(absoluteEntry);

package/dist/project-tools.js

@@ -8,6 +8,10 @@ import { loadGovernance } from "./governance-model.js";
 import { loadProject, loadRoadmap, loadSecurity, loadSessions, loadTasks, saveProject, saveRoadmap, } from "./store.js";
 import { now } from "./types.js";
 import { budgetLines, toolI, toolR, toolW } from "./tool-base.js";
+import { renderRuntimeLogLines, renderUsageLogLines } from "./usage-log.js";
+import { ScanIgnoreSchema } from "./scan-policy.js";
+import { VERSION, RUNTIME_CONTRACT } from "./version.js";
+import { CompletionEvidenceSchema } from "./quality-evidence.js";
 function taskLine(t, withNext = false) {
     const parts = [`[${t.status}]`, t.id, t.title, `(${t.type}${t.milestone ? `,${t.milestone}` : ""})`];
     if (withNext && t.checkpoint) {
@@ -16,7 +20,7 @@ function taskLine(t, withNext = false) {
     return parts.join(" ");
 }
 export function registerProjectTools(server, root) {
-    toolW(server, root, "init_project", "初始化当前项目的 .pm/ 状态目录（单一事实来源）。每个新项目只调用一次；已初始化请用 update_project。", {
+    toolW(server, root, "init_project", "初始化当前项目的 .pm/ 状态目录（单一事实来源），并自动写入 AGENTS.md 工作规矩（已存在则增量合并，不覆盖你的内容）。每个新项目只调用一次；已初始化请用 update_project。", {
         name: z.string().min(1).describe("项目名"),
         description: z.string().optional().describe("一句话描述"),
         stack: z.array(z.string()).optional().describe("技术栈，如 [\"TypeScript\",\"React\"]"),
@@ -24,13 +28,15 @@ export function registerProjectTools(server, root) {
         license: z.string().optional().describe("项目许可证（SPDX 名，如 MIT）"),
         exposure: z.enum(["local", "network", "public"]).optional().describe("暴露面，影响安全告警力度"),
         modules: z.array(z.string()).optional().describe("初始模块登记"),
+        agents_md: z.boolean().optional().describe("默认 true：自动写入/合并 AGENTS.md 工作规矩（false 关闭）"),
     }, (args) => {
-        const project = initProject(root, args);
+        const project = initProject(root, { ...args, agentsMd: args.agents_md });
         refreshDerived(root);
         return [
             `✅ 项目已初始化: ${project.name}`,
             `状态目录: ${pmPath(root, "")}（随 git 提交，团队/AI 共享）`,
             "仪表盘已生成: PROJECT.md",
+            args.agents_md === false ? "AGENTS.md 规矩：按要求跳过（agents_md:false）" : "AGENTS.md 工作规矩已写入（已存在则合并；ZCode 每次打开该项目自动加载）",
             "建议顺序: upsert_module 声明模块/owner/语言 → add_milestone 建里程碑 → add_task 拆任务 → 开工前 get_status / 收工后 log_session。",
         ].join("\n");
     });
@@ -43,6 +49,7 @@ export function registerProjectTools(server, root) {
         const security = loadSecurity(root);
         const L = [];
         L.push(`# ${project.name}${project.phase ? ` — ${project.phase}` : ""}`);
+        L.push(`运行版本: pm-mcp ${VERSION} · 项目根: ${root}`);
         if (project.description)
             L.push(project.description);
         L.push("");
@@ -93,7 +100,26 @@ export function registerProjectTools(server, root) {
         }
         L.push("");
         L.push("> 三段式定位：本状态 → search_code 精确到行 → 才读具体文件。别全量读代码。");
-        return foldLines(L, { maxLines: budgetLines(root) });
+        return JSON.stringify({ text: foldLines(L, { maxLines: budgetLines(root) }), runtime: { version: VERSION, root, contract: RUNTIME_CONTRACT } });
+    }, { cacheVersion: `runtime:${VERSION}`, outputSchema: { runtime: z.object({ version: z.string(), root: z.string(), contract: z.string() }) },
+        decode: (value) => { const result = JSON.parse(value); return { text: result.text, data: { runtime: result.runtime } }; } });
+    toolR(server, root, "get_usage_log", "使用日志：pm-mcp 被用了哪些工具、成败、耗时，以及输出 token 估算与「折叠省下的 token」——回答“用它到底省不省 token”。只记工具名与计量，不记参数内容。日志滚动保留约 2MB。", {
+        last: z.number().int().min(1).max(200).optional().describe("返回最近 N 条明细（默认 20；汇总始终覆盖全部保留日志）"),
+        tool: z.string().optional().describe("只看某工具，如 get_status"),
+        ok: z.boolean().optional().describe("true 只看成，false 只看败"),
+        since: z.string().optional().describe("ISO 日期/时间，只看该时间之后的明细"),
+    }, (args) => {
+        requireInitialized(root);
+        return foldLines(renderUsageLogLines(root, args), { maxLines: budgetLines(root) });
+    });
+    toolR(server, root, "get_runtime_log", "运行日志：server 就绪、watcher 状态、工具报错等服务级事件（info/warn/error），判断 pm-mcp 运行是否健康、哪里在反复出错。", {
+        last: z.number().int().min(1).max(200).optional().describe("返回最近 N 条明细（默认 20）"),
+        level: z.enum(["info", "warn", "error"]).optional().describe("只看某级别"),
+        event: z.string().optional().describe("只看某事件，如 tool.error / server.ready"),
+        since: z.string().optional().describe("ISO 日期/时间，只看该时间之后的明细"),
+    }, (args) => {
+        requireInitialized(root);
+        return foldLines(renderRuntimeLogLines(root, args), { maxLines: budgetLines(root) });
     });
     toolW(server, root, "update_project", "更新项目元信息/预算（描述、技术栈、目标、阶段、模块登记、许可证、暴露面、复杂度与输出预算）。", {
         description: z.string().optional(),
@@ -103,6 +129,8 @@ export function registerProjectTools(server, root) {
         license: z.string().optional(),
         exposure: z.enum(["local", "network", "public"]).optional(),
         modules: z.array(z.string()).optional().describe("模块登记（用于未登记目录检测）"),
+        scan_ignore: ScanIgnoreSchema.optional().describe("本项目产物/缓存的相对排除 glob，例如 release/**；传 [] 清除；不应排除真实源码"),
+        completion_evidence: CompletionEvidenceSchema.optional().describe("默认要求tests_observed；兼容无计数运行器时显式选择execution_only并记录原因"),
         max_file_loc: z.number().int().min(10).optional().describe("单文件行数预算"),
         refactor_quota_pct: z.number().min(0).max(100).optional().describe("里程碑重构类任务最低占比%"),
         session_blast_radius: z.number().int().min(1).optional().describe("单会话波及文件阈值"),
@@ -124,6 +152,10 @@ export function registerProjectTools(server, root) {
             project.exposure = args.exposure;
         if (args.modules !== undefined)
             project.modules = args.modules;
+        if (args.scan_ignore !== undefined)
+            project.scan_ignore = args.scan_ignore;
+        if (args.completion_evidence !== undefined)
+            project.completion_evidence = CompletionEvidenceSchema.parse(args.completion_evidence);
         if (args.max_file_loc !== undefined)
             project.budgets.maxFileLoc = args.max_file_loc;
         if (args.refactor_quota_pct !== undefined)

package/dist/quality-evidence.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const CompletionEvidenceSchema = z.object({
+    minimum: z.enum(["tests_observed", "execution_only"]),
+    reason: z.string().trim().min(8).max(1000),
+});
+const ranks = { unverified: 0, execution_only: 1, tests_observed: 2, coverage_observed: 3 };
+/** 等级描述观测强度，不代表测试充分、结果通过或来源不可伪造。 */
+export function evidenceLevel(kind, summary, truncated = false) {
+    if (truncated || !["test", "coverage"].includes(kind))
+        return "execution_only";
+    const counters = [summary.failed, summary.skipped, summary.cancelled, summary.todo];
+    if (summary.tests === null || !Number.isSafeInteger(summary.tests) || summary.tests <= 0 ||
+        counters.some((n) => n === null || !Number.isSafeInteger(n) || n < 0) ||
+        counters.reduce((total, n) => total + (n ?? 0), 0) > summary.tests)
+        return "execution_only";
+    if (summary.passed != null && summary.passed + counters.reduce((total, n) => total + (n ?? 0), 0) !== summary.tests)
+        return "execution_only";
+    const coverage = z.object({ lines_pct: z.number().min(0).max(100), branches_pct: z.number().min(0).max(100), functions_pct: z.number().min(0).max(100) }).safeParse(summary.coverage);
+    return coverage.success ? "coverage_observed" : "tests_observed";
+}
+export function weakestEvidence(levels) {
+    return levels.length ? levels.reduce((a, b) => ranks[a] < ranks[b] ? a : b) : "execution_only";
+}
+export function evidenceLabel(level) {
+    return { unverified: "无可用验证证据", execution_only: "仅执行记录，未确认测试数量", tests_observed: "已观察测试结果", coverage_observed: "已观察测试与覆盖率" }[level ?? ""] ?? "旧报告未标等级";
+}
+export function qualityResultSummary(item) {
+    const summary = qualityOutputSummary(item.command.kind, item.stdout, item.stderr, item.truncated);
+    return { ...summary, evidence_level: item.exitCode === null ? "unverified" : summary.evidence_level };
+}
+export function qualityOutputSummary(kind, stdout, stderr, truncated = false) {
+    const output = `${stdout}\n${stderr}`.replace(/\u001b\[[0-9;]*m/g, "");
+    const diagnostic = (label) => {
+        const matches = [...output.matchAll(new RegExp(`^[ \\t]*(?:ℹ|#)?[ \\t]*${label}[ \\t]+(\\d+)[ \\t]*\\r?$`, "gmi"))];
+        return matches.length ? Number(matches.at(-1)[1]) : null;
+    };
+    let counts = { tests: diagnostic("tests"), passed: diagnostic("pass"), failed: diagnostic("fail"), cancelled: diagnostic("cancelled"), skipped: diagnostic("skipped"), todo: diagnostic("todo") };
+    let counterSource = counts.tests === null ? "unknown" : "node_test_summary";
+    const jest = [...output.matchAll(/^\s*Tests:\s*(.+?)(\d+)\s+total\s*$/gm)].at(-1);
+    const vitest = [...output.matchAll(/^\s*Tests\s+(.+?)\s*\((\d+)\)\s*$/gm)].at(-1);
+    const pytest = [...output.matchAll(/^=+\s+((?:\d+\s+(?:passed|failed|skipped|xfailed|xpassed|deselected|errors?|warnings?)[,\s]*)+)\s+in\s+[\d.]+s.*?=+\s*$/gm)].at(-1);
+    if (counts.tests === null && (jest || vitest || pytest)) {
+        const text = (jest ?? vitest ?? pytest)[1];
+        const number = (label) => Number(new RegExp(`(\\d+)\\s+${label}\\b`).exec(text)?.[1] ?? 0);
+        const passed = number("passed"), failed = number("failed") + number("errors?") + number("xpassed");
+        const skipped = number("skipped") + number("xfailed") + number("deselected"), todo = number("todo");
+        counts = { tests: jest ? Number(jest[2]) : vitest ? Number(vitest[2]) : passed + failed + skipped + todo, passed, failed, skipped, todo, cancelled: 0 };
+        counterSource = jest ? "jest_summary" : vitest ? "vitest_summary" : "pytest_summary";
+    }
+    const coverage = output.match(/(?:^|\n)(?:ℹ|#)?\s*all files\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)(?:\s*\|\s*([\d.]+))?/i);
+    counts.coverage = coverage ? { lines_pct: Number(coverage[4] ?? coverage[1]), branches_pct: Number(coverage[2]), functions_pct: Number(coverage[3]) } : null;
+    return { stdout_bytes: Buffer.byteLength(stdout), stderr_bytes: Buffer.byteLength(stderr),
+        output_sha256: createHash("sha256").update(stdout).update("\0").update(stderr).digest("hex"),
+        ...counts, counter_source: counterSource, evidence_level: evidenceLevel(kind, counts, truncated) };
+}

package/dist/quality-store.js

@@ -1,48 +1,28 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createHash } from "node:crypto";
 import { atomicWrite, withLedgerLock } from "./store.js";
 import { refreshDerived } from "./dashboard.js";
-function numericDiagnostic(output, label) {
-    const match = output.match(new RegExp(`(?:^|\\n)(?:ℹ|#)?\\s*${label}\\s+(\\d+)(?:\\s|$)`, "i"));
-    return match ? Number(match[1]) : null;
-}
-function outputSummary(stdout, stderr) {
-    const combined = `${stdout}\n${stderr}`;
-    // Node's test reporter exposes line|branch|function, while Istanbul/c8 uses
-    // statement|branch|function|line. Preserve one normalized three-metric shape.
-    const coverage = combined.match(/(?:^|\n)(?:ℹ|#)?\s*all files\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)(?:\s*\|\s*([\d.]+))?/i);
-    return {
-        stdout_bytes: Buffer.byteLength(stdout),
-        stderr_bytes: Buffer.byteLength(stderr),
-        output_sha256: createHash("sha256").update(stdout, "utf8").update("\0", "utf8").update(stderr, "utf8").digest("hex"),
-        tests: numericDiagnostic(combined, "tests"),
-        passed: numericDiagnostic(combined, "pass"),
-        failed: numericDiagnostic(combined, "fail"),
-        cancelled: numericDiagnostic(combined, "cancelled"),
-        skipped: numericDiagnostic(combined, "skipped"),
-        todo: numericDiagnostic(combined, "todo"),
-        coverage: coverage ? { lines_pct: Number(coverage[4] ?? coverage[1]), branches_pct: Number(coverage[2]), functions_pct: Number(coverage[3]) } : null,
-    };
-}
+import { qualityResultSummary, weakestEvidence } from "./quality-evidence.js";
 /** Persist a secret-minimised quality summary; raw stdout/stderr never enter the ledger. */
 export function saveQualityRun(root, result, provenance) {
     const runAt = new Date();
     const stamp = runAt.toISOString().replace(/[-:]/g, "").replace("T", "-").replace(".", "-").replace(/Z$/, "");
     const effectiveOk = result.ok && result.execute && result.results.length > 0 && result.results.every((item) => item.status === "passed" && item.exitCode === 0 && item.signal === null);
+    const summaries = result.results.map(qualityResultSummary);
     const payload = JSON.stringify({
         schema_version: 2,
         run_at: runAt.toISOString(),
         ok: effectiveOk,
         reported_ok: result.ok,
         execute: result.execute,
+        evidence_level: result.execute && result.results.some((item) => item.exitCode !== null) ? weakestEvidence(summaries.filter((_item, i) => ["test", "coverage"].includes(result.results[i].command.kind)).map((item) => item.evidence_level)) : "unverified",
         environment: { platform: process.platform, arch: process.arch, node: process.version },
         source: provenance ? {
             before: provenance.source_before,
             after: provenance.source_after,
             stable: provenance.source_before.sha256 === provenance.source_after.sha256,
         } : null,
-        results: result.results.map((item) => ({
+        results: result.results.map((item, index) => ({
             unit_root: item.command.cwd,
             kind: item.command.kind,
             command: item.command.command,
@@ -52,7 +32,7 @@ export function saveQualityRun(root, result, provenance) {
             signal: item.signal,
             duration_ms: item.durationMs,
             output_truncated: item.truncated,
-            output_summary: outputSummary(item.stdout, item.stderr),
+            output_summary: summaries[index],
             error: item.error ?? "",
         })),
     }, null, 2) + "\n";

package/dist/registry.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { RegistrySchema, now } from "./types.js";
 import { registryFile } from "./paths.js";
@@ -23,9 +24,18 @@ export function saveRegistry(data) {
 }
 /** 登记/刷新一个项目（init 与每次写操作都会 touch） */
 export function touchRegistry(root, name) {
-    const data = loadRegistry();
     const abs = path.resolve(root);
-    const idx = data.projects.findIndex((p) => path.resolve(p.root) === abs);
+    // 防污染（T-034 根因）：临时目录里的"项目"从不进入真实注册表——
+    // 测试若未设 PM_MCP_HOME 沙箱，写入会被这里拦下而不是污染 ~/.pm-mcp。
+    // 沙箱化测试（显式设了 PM_MCP_HOME）不受影响，仍写沙箱注册表。
+    if (!process.env.PM_MCP_HOME?.trim() && isUnderTemp(abs)) {
+        console.error(`[pm-mcp] 跳过注册临时目录项目（如需管理请移出临时目录）: ${abs}`);
+        return;
+    }
+    const data = loadRegistry();
+    // Windows 路径大小写不敏感：按小写比较去重（e:/E: 重复注册缺陷）
+    const key = abs.toLowerCase();
+    const idx = data.projects.findIndex((p) => path.resolve(p.root).toLowerCase() === key);
     const entry = { name, root: abs, last_seen: now() };
     if (idx >= 0)
         data.projects[idx] = entry;
@@ -33,6 +43,22 @@ export function touchRegistry(root, name) {
         data.projects.push(entry);
     saveRegistry(data);
 }
+function isUnderTemp(abs) {
+    const normalized = abs.toLowerCase();
+    // tmpdir 可能以 8.3 短名返回（ADMINI~1），与注册表里的长名不一致——两种形态都比对
+    let tmpLong = os.tmpdir().toLowerCase();
+    try {
+        tmpLong = fs.realpathSync.native(os.tmpdir()).toLowerCase();
+    }
+    catch {
+        /* keep default */
+    }
+    for (const tmp of new Set([tmpLong, os.tmpdir().toLowerCase()])) {
+        if (normalized === tmp || normalized.startsWith(tmp.replace(/\$/, "") + path.sep))
+            return true;
+    }
+    return false;
+}
 export function listRegistry() {
     return loadRegistry().projects.sort((a, b) => b.last_seen.localeCompare(a.last_seen));
 }

package/dist/scan-policy.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { globToRegExp, normSep } from "./budget.js";
+export const SCAN_IGNORE_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", "out", ".next", ".nuxt", ".output", ".turbo", "coverage",
+    "__pycache__", ".venv", "venv", "env", ".pm", ".idea", ".vscode", "target", ".cache", ".gradle",
+    ".zcode", ".runtime", "EBWebView",
+    // 包管理器缓存 / 运行时数据 / 临时与上下文目录：属于环境而非项目源码（T-045）
+    ".pnpm-cache", ".pnpm-store", ".npm-cache", ".yarn-cache", ".data", ".tmp", ".temp",
+    ".codex-context", "userdata", "logs",
+]);
+export const ScanIgnoreSchema = z.array(z.string().trim().min(1).max(512).transform(normSep).refine((glob) => !glob.startsWith("/") && !glob.startsWith("!") && !/^[a-z]:/i.test(glob) && !glob.split("/").includes(".."), "扫描排除必须是项目内的正向相对 glob")).max(100);
+export function projectScanIgnores(root) {
+    const file = path.join(root, ".pm", "project.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    return [...new Set(ScanIgnoreSchema.parse(JSON.parse(raw).scan_ignore ?? []))].sort();
+}
+export function ignoreMatcher(globs) {
+    const patterns = globs.map(globToRegExp);
+    return (rel, directory = false) => patterns.some((pattern) => pattern.test(rel) || (directory && pattern.test(`${rel}/`)));
+}
+export function scanExclusionNote(root) {
+    const ignores = projectScanIgnores(root);
+    return ignores.length ? [`扫描范围排除：${ignores.join(", ")}；排除内容不属于本次检查结论。`] : [];
+}