@luckychen1993/pm-mcp 0.5.0 → 0.6.0

package/dist/doctor.js

@@ -5,7 +5,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { PACKAGE_SPEC, RUNTIME_CONTRACT, SERVER_NAME, TOOL_CATALOG_SIZE, VERSION } from "./version.js";
 import { canonicalProjectRoot, findCodexProjectEntry, isLocalLaunch, isLocalServerEntry, isPackageLaunch, readCodexConfig } from "./setup-project.js";
-import { localProjectLaunch, workbuddyConfigPath } from "./setup.js";
+import { localProjectLaunch, qoderConfigPath, workbuddyConfigPath } from "./setup.js";
 export function parseDoctorArgs(argv) {
     const options = { root: process.cwd() };
     for (let index = 0; index < argv.length; index++) {
@@ -19,8 +19,8 @@ export function parseDoctorArgs(argv) {
         if (arg === "--config")
             options.config = path.resolve(value);
         if (arg === "--client") {
-            if (value !== "codex" && value !== "workbuddy")
-                throw new Error("doctor 支持 --client codex|workbuddy，其他客户端可用 --entry 验证本地入口。");
+            if (value !== "codex" && value !== "workbuddy" && value !== "qoder")
+                throw new Error("doctor 支持 --client codex|workbuddy|qoder，其他客户端可用 --entry 验证本地入口。");
             options.client = value;
         }
         index++;
@@ -30,35 +30,35 @@ export function parseDoctorArgs(argv) {
     return options;
 }
 /**
- * 从 WorkBuddy 的 `mcp.json` 中取出 pm-mcp 条目。
+ * 从标准 `{ "mcpServers": { ... } }` 配置文件（WorkBuddy 的 mcp.json、Qoder 的 settings.json）中取出 pm-mcp 条目。
  *
  * 只读取启动定义（command/args），不复制也不输出任何自定义 env / 凭据。
  * 文件必须是**有界普通文件**：链接、目录、超 2MB 一律拒绝。
  */
-function readWorkbuddyEntry(file) {
+function readJsonMcpEntry(file, label) {
     if (!fs.existsSync(file))
         return undefined;
     const stat = fs.lstatSync(file);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 2 * 1024 * 1024)
-        throw new Error("WorkBuddy 配置必须为有界普通文件，禁止链接。");
+        throw new Error(`${label} 配置必须为有界普通文件，禁止链接。`);
     let parsed;
     try {
         parsed = JSON.parse(fs.readFileSync(file, "utf8"));
     }
     catch (error) {
-        throw new Error(`WorkBuddy 配置不是合法 JSON：${error.message}`);
+        throw new Error(`${label} 配置不是合法 JSON：${error.message}`);
     }
     const servers = parsed?.mcpServers;
     const entry = servers?.[SERVER_NAME];
     if (!entry)
         return undefined;
     if (entry.disabled === true)
-        throw new Error("WorkBuddy 中 pm-mcp 条目被禁用，现有客户端不会启动它。");
+        throw new Error(`${label} 中 pm-mcp 条目被禁用，现有客户端不会启动它。`);
     if (typeof entry.command !== "string" || entry.command.length === 0)
-        throw new Error("WorkBuddy 中 pm-mcp 条目缺少可识别的 command。");
+        throw new Error(`${label} 中 pm-mcp 条目缺少可识别的 command。`);
     const args = entry.args === undefined ? [] : entry.args;
     if (!Array.isArray(args) || !args.every((value) => typeof value === "string"))
-        throw new Error("WorkBuddy 中 pm-mcp 条目的 args 不是字符串数组。");
+        throw new Error(`${label} 中 pm-mcp 条目的 args 不是字符串数组。`);
     return { command: entry.command, args: args };
 }
 /** 短期本地读连接；不把探测新进程冒充已重新连接的客户端。 */
@@ -72,17 +72,20 @@ export async function runDoctor(options) {
     try {
         if (options.entry)
             launch = { command: process.execPath, args: [options.entry, "--root", root] };
-        else if (options.client === "workbuddy") {
-            const file = options.config ?? workbuddyConfigPath(process.env, os.homedir(), fs.existsSync);
-            const entry = readWorkbuddyEntry(file);
+        else if (options.client === "workbuddy" || options.client === "qoder") {
+            const label = options.client === "qoder" ? "Qoder" : "WorkBuddy";
+            const file = options.config ?? (options.client === "qoder"
+                ? qoderConfigPath(process.env, os.homedir(), fs.existsSync)
+                : workbuddyConfigPath(process.env, os.homedir(), fs.existsSync));
+            const entry = readJsonMcpEntry(file, label);
             if (!entry)
-                throw new Error("未在 WorkBuddy 的 mcp.json 中找到 pm-mcp 条目。");
+                throw new Error(`未在 ${label} 的 ${path.basename(file)} 中找到 pm-mcp 条目。`);
             report.configured_server = SERVER_NAME;
             if (!isLocalServerEntry(entry))
-                throw new Error("WorkBuddy 中的 pm-mcp 不是可识别的本地 pm-mcp 启动项；未执行未知启动命令。");
+                throw new Error(`${label} 中的 pm-mcp 不是可识别的本地 pm-mcp 启动项；未执行未知启动命令。`);
             // 配置通常不钉根（由会话工作区决定）；探测需要明确目标根，故补上 --root。
             launch = entry.args.includes("--root") ? entry : { command: entry.command, args: [...entry.args, "--root", root] };
-            report.configuration = "workbuddy_local_probe";
+            report.configuration = `${options.client}_local_probe`;
         }
         else {
             if (!options.config && fs.existsSync(path.join(root, ".codex", "config.toml")))

package/dist/git-state.js

@@ -4,6 +4,7 @@ import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { normSep } from "./budget.js";
 import { hashRegularFile } from "./project-fingerprint.js";
+import { ignoreMatcher, projectScanIgnores } from "./scan-policy.js";
 export function projectFilePath(relative) {
     const rel = path.posix.normalize(normSep(relative));
     if (!relative || path.isAbsolute(rel) || /^[a-z]:/i.test(rel) || rel === "." || rel === ".." || rel.startsWith("../")) {
@@ -11,16 +12,54 @@ export function projectFilePath(relative) {
     }
     return rel;
 }
+let gitCommandCache;
+/** PATH 缺 git 的宿主进程（对账 fail-closed 恒红）按常见安装路径兜底解析并缓存。 */
+export function resolveGitCommand() {
+    if (gitCommandCache !== undefined)
+        return gitCommandCache;
+    const probe = (command) => spawnSync(command, ["--version"], { encoding: "utf8", timeout: 5000, windowsHide: true }).status === 0;
+    if (probe("git")) {
+        gitCommandCache = "git";
+    }
+    else if (process.platform === "win32") {
+        const where = spawnSync("where", ["git"], { encoding: "utf8", timeout: 5000, windowsHide: true });
+        const located = where.status === 0 ? where.stdout.split(/\r?\n/).find(Boolean)?.trim() : undefined;
+        const programFiles = process.env["ProgramFiles"] ?? "C:\\Program Files";
+        const candidates = [
+            ...(located ? [located] : []),
+            path.join(programFiles, "Git", "cmd", "git.exe"),
+            "C:\\Program Files (x86)\\Git\\cmd\\git.exe",
+            path.join(process.env["LOCALAPPDATA"] ?? "", "Programs", "Git", "cmd", "git.exe"),
+        ];
+        gitCommandCache = candidates.find((candidate) => candidate && fs.existsSync(candidate) && probe(candidate)) ?? null;
+    }
+    else {
+        gitCommandCache = ["/usr/bin/git", "/usr/local/bin/git", "/opt/homebrew/bin/git"].find((candidate) => probe(candidate)) ?? null;
+    }
+    return gitCommandCache;
+}
+/** 仅测试用：清空解析缓存，模拟不同 PATH 环境。 */
+export function resetGitCommandCache() {
+    gitCommandCache = undefined;
+}
 /** 使用 NUL 分隔，避免中文转义、空格及文件名中的箭头被误解析。 */
 export function changedGitFiles(root) {
-    const result = spawnSync("git", ["status", "--porcelain=v1", "-z", "-uall"], { cwd: root, encoding: "utf8", timeout: 10000, maxBuffer: 16 * 1024 * 1024 });
+    const excluded = ignoreMatcher(projectScanIgnores(root));
+    const git = resolveGitCommand();
+    if (!git)
+        throw new Error("找不到 git 可执行文件（PATH 与常见安装路径均未命中），git 对账不可用");
+    const result = spawnSync(git, ["status", "--porcelain=v1", "-z", "-uall"], { cwd: root, encoding: "utf8", timeout: 10000, maxBuffer: 16 * 1024 * 1024 });
     if (result.error || result.status !== 0)
         throw new Error(result.error?.message ?? `git status 退出码 ${result.status}`);
     const records = result.stdout.split("\0");
     const changed = new Set();
     const add = (file) => {
         const rel = projectFilePath(file);
-        if (!rel.startsWith(".pm/") && rel !== "PROJECT.md" && rel !== ".gitignore")
+        const parts = rel.split("/");
+        if (!rel.startsWith(".pm/") &&
+            rel !== "PROJECT.md" &&
+            rel !== ".gitignore" &&
+            !parts.some((_, index) => excluded(parts.slice(0, index + 1).join("/"), index < parts.length - 1)))
             changed.add(rel);
     };
     for (let i = 0; i < records.length; i++) {

package/dist/governance-audit.js

@@ -101,6 +101,16 @@ function render(governance, graph, units, qualityCoverage, issues, maxLines) {
         lines.push(`- 🚩 未读取/超限文件样例: ${graph.coverage.skippedFiles.slice(0, 8).join(", ")}`);
     return foldLines(lines, { maxLines, hint: "用 impact_analysis 或治理过滤参数缩小范围" });
 }
+export function listGovernanceIssues(root, options = {}) {
+    const audit = auditGovernance(root, Number.MAX_SAFE_INTEGER);
+    const offset = Math.max(0, Math.trunc(options.offset ?? 0));
+    const limit = Math.min(100, Math.max(1, Math.trunc(options.limit ?? 50)));
+    const filtered = audit.issues.filter((issue) => (options.severity === undefined || options.severity === "all" || issue.severity === options.severity) &&
+        (!options.code || options.code === "all" || issue.code === options.code));
+    const items = filtered.slice(offset, offset + limit);
+    const nextOffset = offset + items.length < filtered.length ? offset + items.length : null;
+    return { total: filtered.length, offset, limit, items, nextOffset };
+}
 export function auditGovernance(root, maxLines = 150) {
     const absolute = path.resolve(root);
     const governance = loadGovernance(absolute);

package/dist/governance-tools.js

@@ -5,7 +5,7 @@ import { foldLines } from "./budget.js";
 import { refreshDerived } from "./dashboard.js";
 import { requireInitialized } from "./paths.js";
 import { initGovernance, loadGovernance, saveGovernance, } from "./governance-model.js";
-import { auditGovernance, dependencyGraphReport } from "./governance-audit.js";
+import { auditGovernance, dependencyGraphReport, listGovernanceIssues } from "./governance-audit.js";
 import { impactAnalysis } from "./semantic-graph.js";
 import { assessQualityCoverage, createQualityPlan, discoverProjectUnits, runQualityPlan } from "./language-adapters.js";
 import { buildPortfolioFromRegistry, buildPortfolioReport, loadPortfolioProject } from "./portfolio.js";
@@ -64,18 +64,21 @@ function qualityPlan(root, unit, kinds) {
 function qualityLines(commands) {
     return commands.map((command, index) => `${index + 1}. [${command.kind}] (${command.cwd}) ${command.command} ${command.args.join(" ")}`);
 }
-export function registerGovernanceTools(server, root) {
-    toolI(server, root, "init_governance", "为旧项目初始化 .pm/governance.json；新项目 init_project 已自动创建。", {}, () => {
+export function registerGovernanceTools(server, startupRoot) {
+    toolI(server, startupRoot, "init_governance", "为旧项目初始化 .pm/governance.json；新项目 init_project 已自动创建。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const governance = initGovernance(root, {});
         refreshDerived(root);
         return `✅ 治理模型已初始化（schema v${governance.schema_version}）。下一步用 upsert_module 声明模块、owner 与语言。`;
     });
-    toolR(server, root, "get_governance", "查看结构化模块、owner、公开接口、仓库依赖与强制策略。", {}, () => {
+    toolR(server, startupRoot, "get_governance", "查看结构化模块、owner、公开接口、仓库依赖与强制策略。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return compactGovernance(loadGovernance(root));
     });
-    toolW(server, root, "upsert_module", "新增或完整替换一个治理模块；root/owner/language/依赖边均经 schema 对账。", moduleInput, (args) => {
+    toolW(server, startupRoot, "upsert_module", "新增或完整替换一个治理模块；root/owner/language/依赖边均经 schema 对账。", moduleInput, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const governance = loadGovernance(root);
         const value = {
@@ -90,14 +93,15 @@ export function registerGovernanceTools(server, root) {
         refreshDerived(root);
         return `✅ module ${value.id} 已保存（roots ${value.roots.length}，owners ${value.owners.length}，languages ${value.languages.length}）。`;
     });
-    toolW(server, root, "upsert_interface", "新增或替换跨模块公开接口及契约文件、provider/consumers、版本。", {
+    toolW(server, startupRoot, "upsert_interface", "新增或替换跨模块公开接口及契约文件、provider/consumers、版本。", {
         id,
         kind: z.string().trim().min(1),
         provider: id,
         consumers: texts,
         contract_files: texts,
         version: z.string().trim().min(1),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const governance = loadGovernance(root);
         if (!governance.modules.some((module) => module.id === args.provider))
@@ -110,13 +114,14 @@ export function registerGovernanceTools(server, root) {
         refreshDerived(root);
         return `✅ interface ${args.id}@${args.version} 已保存：${args.provider} -> ${args.consumers.join(",") || "无消费者"}。`;
     });
-    toolW(server, root, "upsert_repository", "登记当前组合视图中的仓库、版本及跨仓 semver 约束。", {
+    toolW(server, startupRoot, "upsert_repository", "登记当前组合视图中的仓库、版本及跨仓 semver 约束。", {
         id,
         name: z.string().trim().min(1),
         root: z.string().trim().min(1),
         version: z.string().trim().min(1),
         dependencies: z.array(z.object({ repository: id, constraint: z.string().trim().min(1) })),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const governance = loadGovernance(root);
         replaceById(governance.repositories, args);
@@ -124,7 +129,7 @@ export function registerGovernanceTools(server, root) {
         refreshDerived(root);
         return `✅ repository ${args.id}@${args.version} 已保存（依赖 ${args.dependencies.length}）。`;
     });
-    toolW(server, root, "set_governance_policies", "更新治理强制策略；未传字段保持原值。", {
+    toolW(server, startupRoot, "set_governance_policies", "更新治理强制策略；未传字段保持原值。", {
         enforce_ownership: z.boolean().optional(),
         enforce_declared_dependencies: z.boolean().optional(),
         fail_on_unresolved: z.boolean().optional(),
@@ -133,7 +138,8 @@ export function registerGovernanceTools(server, root) {
         minimum_semantic_assurance: z.enum(["heuristic", "ast", "runtime"]).optional(),
         fail_on_semantic_fallback: z.boolean().optional(),
         required_quality_kinds: z.array(z.enum(["test", "build", "lint", "typecheck", "coverage", "security"])).optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const governance = loadGovernance(root);
         governance.policies = { ...governance.policies, ...args };
@@ -141,7 +147,8 @@ export function registerGovernanceTools(server, root) {
         refreshDerived(root);
         return `✅ 治理策略已更新：coverage>=${governance.policies.minimum_coverage_pct}% · semantic>=${governance.policies.minimum_semantic_assurance} · regex-fallback=${governance.policies.fail_on_semantic_fallback ? "forbidden" : "allowed"}`;
     });
-    toolR(server, root, "discover_languages", "递归发现 Node/Python/Go/Rust/JVM/.NET 单元及其受控质量命令，不执行命令。", {}, () => {
+    toolR(server, startupRoot, "discover_languages", "递归发现 Node/Python/Go/Rust/JVM/.NET 单元及其受控质量命令，不执行命令。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const units = discoverProjectUnits(root);
         const coverage = assessQualityCoverage(units);
@@ -152,41 +159,57 @@ export function registerGovernanceTools(server, root) {
             lines.push(`- 🚩 无质量命令: ${coverage.withoutCommands.join(", ")}`);
         return foldLines(lines, { maxLines: budgetLines(root), hint: "按模块拆分治理 root" });
     });
-    toolR(server, root, "audit_governance", "审计跨文件/模块/语言语义覆盖、owner、公开接口、依赖边界、循环、unresolved 与质量矩阵覆盖。", {}, () => {
+    toolR(server, startupRoot, "audit_governance", "审计跨文件/模块/语言语义覆盖、owner、公开接口、依赖边界、循环、unresolved 与质量矩阵覆盖。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return auditGovernance(root, budgetLines(root)).report;
     });
-    toolR(server, root, "dependency_graph", "查询跨文件/模块依赖图：全局摘要（关系/环/入出边枢纽）、模块与文件级循环、聚焦文件的依赖邻域（BFS 方向与深度可调、未解析引用）。", {
+    toolR(server, startupRoot, "list_governance_issues", "分页读取完整治理审计问题，不受 audit_governance 文本预算折叠影响；只读且按 offset/limit 返回。", {
+        offset: z.number().int().min(0).optional().describe("起始偏移，默认 0"),
+        limit: z.number().int().min(1).max(100).optional().describe("每页数量，默认 50"),
+        severity: z.enum(["all", "error", "warning"]).optional().describe("按级别过滤"),
+        code: z.string().trim().max(100).optional().describe("按问题 code 过滤"),
+    }, (args, ctx) => {
+        const root = ctx.root;
+        requireInitialized(root);
+        return JSON.stringify(listGovernanceIssues(root, args ?? {}), null, 2);
+    });
+    toolR(server, startupRoot, "dependency_graph", "查询跨文件/模块依赖图：全局摘要（关系/环/入出边枢纽）、模块与文件级循环、聚焦文件的依赖邻域（BFS 方向与深度可调、未解析引用）。", {
         focus: z.string().trim().min(1).max(512).optional().describe("聚焦文件（相对项目根路径）"),
         direction: z.enum(["deps", "dependents", "both"]).optional().describe("邻域方向，默认 both"),
         depth: z.number().int().min(1).max(6).optional().describe("邻域深度 1-6，默认 2"),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return dependencyGraphReport(root, args ?? {}, budgetLines(root));
     });
-    toolR(server, root, "list_semantic_evidence", "列出已登记的语言原生 AST、编译器或运行时语义证据；损坏文档会使整次读取失败。", {}, () => {
+    toolR(server, startupRoot, "list_semantic_evidence", "列出已登记的语言原生 AST、编译器或运行时语义证据；损坏文档会使整次读取失败。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return JSON.stringify(listSemanticEvidence(root), null, 2);
     });
-    toolI(server, root, "replace_semantic_evidence_for_file", "按源码文件原子替换语义证据：删除该文件旧 evidence，仅保留当前 hash-bound evidence。", {
+    toolI(server, startupRoot, "replace_semantic_evidence_for_file", "按源码文件原子替换语义证据：删除该文件旧 evidence，仅保留当前 hash-bound evidence。", {
         id: z.string().trim().min(1).max(128),
         document: SemanticEvidenceDocumentSchema,
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const saved = replaceSemanticEvidenceForFile(root, args.id, args.document);
         return `✅ semantic evidence replaced ${args.id}：${saved.file} · ${saved.analyzer.id} · ${saved.analyzer.assurance} · ${saved.status}`;
     });
-    toolI(server, root, "save_semantic_evidence", "保存一份绑定源码 SHA-256 的语言原生 AST/编译器/运行时证据；过期摘要在治理审计中严格失败。", {
+    toolI(server, startupRoot, "save_semantic_evidence", "保存一份绑定源码 SHA-256 的语言原生 AST/编译器/运行时证据；过期摘要在治理审计中严格失败。", {
         id: z.string().trim().min(1).max(128),
         document: SemanticEvidenceDocumentSchema,
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const saved = saveSemanticEvidence(root, args.id, args.document);
         return `✅ semantic evidence ${args.id} 已保存：${saved.file} · ${saved.analyzer.id} · ${saved.analyzer.assurance} · ${saved.status}`;
     });
-    toolR(server, root, "impact_analysis", "从变更文件沿 file/module 反向依赖闭包计算受影响文件与模块。", {
+    toolR(server, startupRoot, "impact_analysis", "从变更文件沿 file/module 反向依赖闭包计算受影响文件与模块。", {
         files: z.array(z.string().min(1)).min(1).max(100),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const audit = auditGovernance(root, budgetLines(root));
         const impact = impactAnalysis(audit.graph, args.files);
@@ -197,10 +220,11 @@ export function registerGovernanceTools(server, root) {
             ...(impact.unknownChangedFiles.length ? [`⚠️ 未进入语义图: ${impact.unknownChangedFiles.join(", ")}`] : []),
         ], { maxLines: budgetLines(root), hint: "缩小 files 输入或按模块运行" });
     });
-    toolR(server, root, "plan_quality_matrix", "生成跨语言真实质量命令计划；只规划，不启动进程。", {
+    toolR(server, startupRoot, "plan_quality_matrix", "生成跨语言真实质量命令计划；只规划，不启动进程。", {
         unit: z.string().optional(),
         kinds: z.array(z.enum(["test", "build", "lint", "typecheck", "coverage", "security"])).optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const plan = qualityPlan(root, args.unit, args.kinds);
         return foldLines([
@@ -209,12 +233,13 @@ export function registerGovernanceTools(server, root) {
             ...(plan.coverage.withoutCommands.length ? [`🚩 无命令单元: ${plan.coverage.withoutCommands.join(", ")}`] : []),
         ], { maxLines: budgetLines(root), hint: "用 unit/kinds 过滤；真实执行需 run_quality_matrix confirm_execute=true" });
     });
-    toolI(server, root, "run_quality_matrix", "显式执行跨语言质量矩阵。只运行受支持适配器生成的 argv，shell=false；缺工具/超时/非零均失败。", {
+    toolI(server, startupRoot, "run_quality_matrix", "显式执行跨语言质量矩阵。只运行受支持适配器生成的 argv，shell=false；缺工具/超时/非零均失败。", {
         confirm_execute: z.literal(true).describe("必须显式为 true；该操作会运行目标项目构建/测试命令"),
         unit: z.string().optional(),
         kinds: z.array(z.enum(["test", "build", "lint", "typecheck", "coverage", "security"])).optional(),
         stop_on_failure: z.boolean().optional(),
-    }, async (args) => {
+    }, async (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         if (args.confirm_execute !== true)
             throw new Error("必须显式 confirm_execute=true");
@@ -237,9 +262,10 @@ export function registerGovernanceTools(server, root) {
         lines.push("命令执行结果与任务完成证据分开判断；未知计数不等于已观察测试通过。");
         return foldLines(lines, { maxLines: budgetLines(root), hint: "查看 .pm/quality-runs 结构化摘要（不落原始输出）" });
     });
-    toolR(server, root, "get_portfolio", "聚合当前项目或全局注册项目的阶段、里程碑、债务、安全、语言、跨仓依赖/版本/cycle；加载失败不能假绿。", {
+    toolR(server, startupRoot, "get_portfolio", "聚合当前项目或全局注册项目的阶段、里程碑、债务、安全、语言、跨仓依赖/版本/cycle；加载失败不能假绿。", {
         current_only: z.boolean().optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const portfolio = args.current_only
             ? buildPortfolioReport({ projects: [loadPortfolioProject(root)], projectsRequested: 1 })

package/dist/index-store.js

@@ -35,7 +35,8 @@ export function computeEntry(root, rel, stat) {
         return {
             loc: countLoc(content),
             skip: needsSkipCount(rel, isTest) ? countSkipLines(content) : 0,
-            trivial: isTest && looksTrivialTest(content),
+            // fixtures 是测试的输入而非测试本身，不参与空测试嫌疑
+            trivial: isTest && !/(^|\/)fixtures(\/|$)/.test(rel) && looksTrivialTest(content),
             oversize: false,
             contentOk: true,
         };