@luckychen1993/pm-mcp 0.5.0 → 0.6.0

package/dist/project-tools.js

@@ -19,8 +19,8 @@ function taskLine(t, withNext = false) {
     }
     return parts.join(" ");
 }
-export function registerProjectTools(server, root) {
-    toolW(server, root, "init_project", "初始化当前项目的 .pm/ 状态目录（单一事实来源），并自动写入 AGENTS.md 工作规矩（已存在则增量合并，不覆盖你的内容）。每个新项目只调用一次；已初始化请用 update_project。", {
+export function registerProjectTools(server, startupRoot) {
+    toolW(server, startupRoot, "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\"]"),
@@ -29,7 +29,8 @@ export function registerProjectTools(server, root) {
         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) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         const project = initProject(root, { ...args, agentsMd: args.agents_md });
         refreshDerived(root);
         return [
@@ -40,7 +41,8 @@ export function registerProjectTools(server, root) {
             "建议顺序: upsert_module 声明模块/owner/语言 → add_milestone 建里程碑 → add_task 拆任务 → 开工前 get_status / 收工后 log_session。",
         ].join("\n");
     });
-    toolR(server, root, "get_status", "一站式「我在哪」：项目阶段 + 里程碑进度 + 进行中任务（含断点下一步）+ 健康摘要 + 最近变更。会话开工第一件事。since 可只看某日期以来的任务/会话变化。", { since: z.string().optional().describe("ISO 日期，如 2026-09-01：只看该日期以来的任务/会话变化") }, (args) => {
+    toolR(server, startupRoot, "get_status", "一站式「我在哪」：项目阶段 + 里程碑进度 + 进行中任务（含断点下一步）+ 健康摘要 + 最近变更。会话开工第一件事。since 可只看某日期以来的任务/会话变化。", { since: z.string().optional().describe("ISO 日期，如 2026-09-01：只看该日期以来的任务/会话变化") }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const project = loadProject(root);
         const { milestones } = loadRoadmap(root);
@@ -49,7 +51,9 @@ 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}`);
+        L.push(`运行版本: pm-mcp ${VERSION} · 项目根: ${root}（依据 ${ctx.rootSource}）`);
+        if (ctx.rootCandidates?.length)
+            L.push(`⚠️ 未能确定调用方工作区，候选: ${ctx.rootCandidates.join(" | ")}——需要精确时给本次调用传 root。`);
         if (project.description)
             L.push(project.description);
         L.push("");
@@ -72,8 +76,15 @@ export function registerProjectTools(server, root) {
         const openDebt = tasks.filter((t) => t.type === "debt" && t.status !== "done" && t.status !== "cancelled").length;
         const openFindings = security.findings.filter((f) => f.status === "open");
         L.push(`债务未清 ${openDebt} 条 · 安全未处理 ${openFindings.length} 个（高危 ${openFindings.filter((f) => f.severity === "high").length}）· 会话 ${sessions.length} 次。详细对账用 audit_structure / audit_security。`);
+        let governanceSummary = { modules: 0, interfaces: 0, repositories: 0, initialized: false };
         try {
             const governance = loadGovernance(root);
+            governanceSummary = {
+                modules: governance.modules.length,
+                interfaces: governance.interfaces.length,
+                repositories: governance.repositories.length,
+                initialized: true,
+            };
             L.push(`治理模型 ${governance.modules.length} 模块 / ${governance.interfaces.length} 接口 / ${governance.repositories.length} 仓库；实时语义门禁用 audit_governance。`);
         }
         catch {
@@ -87,6 +98,7 @@ export function registerProjectTools(server, root) {
             if (last.next_steps.length > 0)
                 L.push(`上次留下的下一步: ${last.next_steps.join("；")}`);
         }
+        let sinceSummary;
         if (args.since) {
             const parsed = Date.parse(args.since);
             const since = Number.isNaN(parsed) ? args.since : new Date(parsed).toISOString();
@@ -95,33 +107,94 @@ export function registerProjectTools(server, root) {
             L.push("");
             L.push(`## 自 ${since.slice(0, 10)} 以来`);
             L.push(`新增/更新任务 ${newTasks.length} 个，会话 ${newSessions.length} 次。`);
-            for (const t of newTasks.slice(-8).reverse())
-                L.push(`- ${taskLine(t)}`);
+            const items = newTasks.slice(-8).reverse().map((t) => taskLine(t));
+            for (const line of items)
+                L.push(`- ${line}`);
+            sinceSummary = { since, tasks: newTasks.length, sessions: newSessions.length, items };
         }
         L.push("");
         L.push("> 三段式定位：本状态 → search_code 精确到行 → 才读具体文件。别全量读代码。");
-        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。", {
+        // 结构化载荷必须自带全部状态：部分客户端（如 Qoder 的 mcp_call）只呈现 structuredContent，
+        // 只放 runtime 会让调用方看不到阶段/里程碑/进行中任务。
+        return JSON.stringify({
+            text: foldLines(L, { maxLines: budgetLines(root) }),
+            runtime: {
+                version: VERSION,
+                root,
+                contract: RUNTIME_CONTRACT,
+                root_source: ctx.rootSource,
+                ...(ctx.rootCandidates?.length ? { root_candidates: ctx.rootCandidates } : {}),
+            },
+            project: { name: project.name, phase: project.phase || null, description: project.description || null },
+            milestones: milestones.map((m) => ({ id: m.id, title: m.title, status: m.status, ...milestoneStats(tasks, m.id) })),
+            focus: active.slice(0, 10).map((t) => ({
+                id: t.id,
+                status: t.status,
+                title: t.title,
+                type: t.type,
+                milestone: t.milestone || null,
+                next_step: t.checkpoint?.next_step ?? null,
+                steps_done: t.steps.filter((s) => s.done).length,
+                steps_total: t.steps.length,
+            })),
+            health: {
+                open_debt: openDebt,
+                open_findings: openFindings.length,
+                high_findings: openFindings.filter((f) => f.severity === "high").length,
+                sessions: sessions.length,
+                governance: governanceSummary,
+            },
+            last_session: last ? { date: last.date, author: last.author || null, summary: last.summary, next_steps: last.next_steps } : null,
+            ...(sinceSummary ? { since: sinceSummary } : {}),
+        });
+    }, { cacheVersion: `runtime:${VERSION}`,
+        outputSchema: {
+            runtime: z.object({
+                version: z.string(),
+                root: z.string(),
+                contract: z.string(),
+                root_source: z.string(),
+                root_candidates: z.array(z.string()).optional(),
+            }),
+            project: z.object({ name: z.string(), phase: z.string().nullable(), description: z.string().nullable() }),
+            milestones: z.array(z.object({ id: z.string(), title: z.string(), status: z.string(), total: z.number(), done: z.number(), pct: z.number(), refactorish: z.number(), refactorPct: z.number() })),
+            focus: z.array(z.object({ id: z.string(), status: z.string(), title: z.string(), type: z.string(), milestone: z.string().nullable(), next_step: z.string().nullable(), steps_done: z.number(), steps_total: z.number() })),
+            health: z.object({
+                open_debt: z.number(),
+                open_findings: z.number(),
+                high_findings: z.number(),
+                sessions: z.number(),
+                governance: z.object({ modules: z.number(), interfaces: z.number(), repositories: z.number(), initialized: z.boolean() }),
+            }),
+            last_session: z.object({ date: z.string(), author: z.string().nullable(), summary: z.string(), next_steps: z.array(z.string()) }).nullable(),
+            since: z.object({ since: z.string(), tasks: z.number(), sessions: z.number(), items: z.array(z.string()) }).optional(),
+        },
+        decode: (value) => {
+            const result = JSON.parse(value);
+            const { text, ...data } = result;
+            return { text, data };
+        } });
+    toolR(server, startupRoot, "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) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return foldLines(renderUsageLogLines(root, args), { maxLines: budgetLines(root) });
     });
-    toolR(server, root, "get_runtime_log", "运行日志：server 就绪、watcher 状态、工具报错等服务级事件（info/warn/error），判断 pm-mcp 运行是否健康、哪里在反复出错。", {
+    toolR(server, startupRoot, "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) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return foldLines(renderRuntimeLogLines(root, args), { maxLines: budgetLines(root) });
     });
-    toolW(server, root, "update_project", "更新项目元信息/预算（描述、技术栈、目标、阶段、模块登记、许可证、暴露面、复杂度与输出预算）。", {
+    toolW(server, startupRoot, "update_project", "更新项目元信息/预算（描述、技术栈、目标、阶段、模块登记、许可证、暴露面、复杂度与输出预算）。", {
         description: z.string().optional(),
         stack: z.array(z.string()).optional(),
         goals: z.array(z.string()).optional(),
@@ -135,7 +208,8 @@ export function registerProjectTools(server, root) {
         refactor_quota_pct: z.number().min(0).max(100).optional().describe("里程碑重构类任务最低占比%"),
         session_blast_radius: z.number().int().min(1).optional().describe("单会话波及文件阈值"),
         output_budget_lines: z.number().int().min(20).optional().describe("读类工具输出行数预算"),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const project = loadProject(root);
         if (args.description !== undefined)
@@ -168,14 +242,16 @@ export function registerProjectTools(server, root) {
         refreshDerived(root);
         return `✅ 项目信息已更新（阶段: ${project.phase || "—"}，模块: ${project.modules.join(", ") || "—"}）。仪表盘已刷新。`;
     });
-    toolI(server, root, "regenerate_dashboard", "手动重新生成 PROJECT.md 仪表盘与 changelog.md（正常情况下每次写操作已自动刷新）。", {}, () => {
+    toolI(server, startupRoot, "regenerate_dashboard", "手动重新生成 PROJECT.md 仪表盘与 changelog.md（正常情况下每次写操作已自动刷新）。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         refreshDerived(root);
         return "✅ PROJECT.md 与 changelog.md 已重新生成。";
     });
 }
-export function registerRoadmapTools(server, root) {
-    toolW(server, root, "add_milestone", "添加里程碑（M1/M2…，按顺序自动编号）。路线图的骨架；任务挂到里程碑上。", { title: z.string().min(1), goal: z.string().optional().describe("这个里程碑要达成什么") }, (args) => {
+export function registerRoadmapTools(server, startupRoot) {
+    toolW(server, startupRoot, "add_milestone", "添加里程碑（M1/M2…，按顺序自动编号）。路线图的骨架；任务挂到里程碑上。", { title: z.string().min(1), goal: z.string().optional().describe("这个里程碑要达成什么") }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const data = loadRoadmap(root);
         const id = `M${data.seq + 1}`;
@@ -194,13 +270,14 @@ export function registerRoadmapTools(server, root) {
         refreshDerived(root);
         return `✅ 里程碑 ${id}「${args.title}」已创建（planned）。开始推进时用 update_milestone 置为 active。`;
     });
-    toolW(server, root, "update_milestone", "更新里程碑（状态流转 planned/active/done/paused、标题、目标、顺序）。", {
+    toolW(server, startupRoot, "update_milestone", "更新里程碑（状态流转 planned/active/done/paused、标题、目标、顺序）。", {
         id: z.string().describe("里程碑 id，如 M1"),
         status: z.enum(["planned", "active", "done", "paused"]).optional(),
         title: z.string().optional(),
         goal: z.string().optional(),
         order: z.number().int().optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const data = loadRoadmap(root);
         const m = data.milestones.find((x) => x.id === args.id);
@@ -228,7 +305,8 @@ export function registerRoadmapTools(server, root) {
         const s = milestoneStats(tasks, m.id);
         return [`✅ ${m.id} 已更新（${m.status}）。进度: ${s.done}/${s.total}（${s.pct}%）。`, ...warnings].join("\n");
     });
-    toolR(server, root, "get_roadmap", "查看路线图。depth=1 每个里程碑一行摘要（功能再多也不乱）；depth=2 额外展开活跃里程碑的任务明细与断点。", { depth: z.number().int().min(1).max(2).optional().describe("默认 1") }, (args) => {
+    toolR(server, startupRoot, "get_roadmap", "查看路线图。depth=1 每个里程碑一行摘要（功能再多也不乱）；depth=2 额外展开活跃里程碑的任务明细与断点。", { depth: z.number().int().min(1).max(2).optional().describe("默认 1") }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const { milestones } = loadRoadmap(root);
         const { tasks } = loadTasks(root);

package/dist/prompts.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+export function registerPrompts(server) {
+    server.registerPrompt("start-session", { description: "开工仪式：恢复项目上下文，从断点续做，不靠回忆。" }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "按以下顺序恢复项目上下文（本项目由 pm-mcp 管理，状态以 .pm/ 为准，不要凭记忆陈述）：",
+                        "1. 调用 get_status：了解阶段、里程碑进度、进行中任务及其 checkpoint 下一步。",
+                        "2. 若要动的模块不清楚，先 search_code 定位到具体文件与行，再读文件——三段式定位，不要全量读代码。",
+                        "3. 陈述本次计划：要做哪个任务、动哪些文件、验收标准是什么。",
+                        "4. 过程纪律：走捷径就 add_task(type=debt) 登记债务；修 bug 完成后 log_debug 记根因；长任务随手 checkpoint。",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("end-session", { description: "收工仪式：更新任务与里程碑、留断点、记会话——把本次上下文写回仓库。" }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "收工前依次完成（顺序执行，缺一不可）：",
+                        "1. feature/fix 先执行适用测试，生成最新质量报告；update_task 置 done，给 result_note 与实际 files，record_session=true 可一并归档。",
+                        "2. 未完成的任务：checkpoint 保存「进展 + 下一步具体动作」。",
+                        "3. 本次落地的功能：register_feature 登记（入口文件 + 测试文件）。",
+                        "4. 修过的 bug：log_debug 记录症状/根因/修法/验证。",
+                        "5. 走过的捷径：add_task(type=debt) 登记债务，别让它在沉默中腐烂。",
+                        "6. update_task 已返回自动会话编号时，不重复 log_session；否则用 log_session 记录真实改动清单。纯问答不需要另建任务或反复写会话。",
+                        "7. 若到达里程碑节点：update_milestone 流转状态；可 snapshot_codebase 拍快照 + audit_structure 对账。",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("onboard", { description: "入职简报工作流：引导客户端为新成员（人或 AI）生成项目现状一页纸。" }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "为新加入的成员（人或 AI）生成入职简报，数据全部来自 .pm/ 状态，不要编造：",
+                        "1. 读 pm://dashboard（或 PROJECT.md）：项目是什么、路线图到哪、健康状态如何。",
+                        "2. list_decisions + 阅读最近 3 条 ADR：理解关键取舍的「为什么」。",
+                        "3. list_features：了解已有功能地图与各功能入口文件。",
+                        "4. get_status：当前焦点与断点。",
+                        "5. 读 pm://architecture 与 pm://portfolio：模块 owner、公开接口、跨语言质量矩阵和跨仓版本风险。",
+                        "输出一页纸简报：项目一句话 / 技术栈与模块 / 路线图现状 / 关键决策与红线 / 模块与接口边界 / 当前焦点与下一步 / 哪里有坑（债务、安全、语义与跨仓风险）。",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("architecture-review", { description: "跨文件/模块/语言架构评审：先取证，再判断影响和门禁。" }, () => ({
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "按证据完成跨模块/跨语言架构评审：",
+                        "1. 读取 pm://architecture 或调用 audit_governance，先检查语义覆盖、unresolved、owner、私有接口、循环和边界违规。",
+                        "2. 对本次变更调用 impact_analysis，列出反向依赖文件与模块；未知文件不得忽略。",
+                        "3. 调用 plan_quality_matrix；这一步只是计划，不能声称测试通过。",
+                        "4. 只有用户明确要求执行时才调用 run_quality_matrix(confirm_execute=true)，并分别报告每种语言的真实结果。",
+                        "5. 跨仓变更读取 pm://portfolio，核对依赖目标、版本约束、加载失败与仓库循环。",
+                    ].join("\n"),
+                },
+            }],
+    }));
+    server.registerPrompt("acceptance-review", { description: "标准化终验：冻结质量基线后执行证据核验，不能把开发者自测冒充认证。" }, () => ({
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "按 pm-mcp 的标准化验收闭环执行，不得事后调低阈值：",
+                        "1. list_acceptance_baselines 并读取目标基线，确认 ISO/IEC 25010 九特性适用性、量化指标、风险和测试双向追踪。",
+                        "2. 只有产品负责人审阅 draft fingerprint 后，才能 approve_acceptance_baseline；批准后的同版本不可修改。",
+                        "3. 执行基线定义的质量、治理、性能与安全测试；失败、跳过、缺工具和过期证据都不得写成通过。",
+                        "4. evaluate_acceptance 会重算项目内证据 SHA-256，并由机器生成不可覆盖的 JSON/Markdown 报告。",
+                        "5. 分开陈述：第一方范围内验收、独立评价、托管 CI、生产证据和 ISO 认证；任何一层都不能冒充另一层。",
+                    ].join("\n"),
+                },
+            }],
+    }));
+}

package/dist/qoder-launch.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/* Qoder 客户端适配器。实测事实：Qoder 主进程只派生一个常驻 stdio 子进程，并用本地路由把
+   所有窗口/会话复用到它上面（同一 server uuid、不同 session token），子进程 cwd 是安装目录。
+   因此启动期解析出的工作区只能是「默认值」，绝不能当成 --root 钉死，否则别的窗口会读到错项目。
+   本适配器的职责：把客户端标记与启动期提示如实交给服务器，由服务器在每次调用时反查真正的调用方工作区。 */
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CLIENT_ADAPTER_ENV, QODER_ADAPTER, ROOT_HINT_ENV, ROOT_HINT_SOURCE_ENV } from "./caller-workspace.js";
+const PLACEHOLDER = /\$\{[^}]*\}/;
+export function usableDir(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed || PLACEHOLDER.test(trimmed))
+        return null;
+    const resolved = path.resolve(trimmed);
+    try {
+        return fs.statSync(resolved).isDirectory() ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 显式给了 QODER_CONFIG_DIR 就只看它，避免真实 ~/.qoder-cn 混进隔离环境 */
+function configDirs(env) {
+    const fromEnv = usableDir(env.QODER_CONFIG_DIR);
+    if (fromEnv)
+        return [fromEnv];
+    const home = os.homedir();
+    return [path.join(home, ".qoder-cn"), path.join(home, ".qoder")];
+}
+/** 运行日志目录名虽然以 `-p<pid>` 结尾，但 Qoder 所有会话共用主进程 pid，ppid 无法区分会话；
+    启动期只能取「最近在写」的那份日志作为默认提示，真正的认领交给服务器按请求指纹完成。 */
+export function workspaceFromRunLog(options = {}) {
+    const env = options.env ?? process.env;
+    const candidates = [];
+    for (const dir of configDirs(env)) {
+        const runs = path.join(dir, "logs", "runs");
+        let names;
+        try {
+            names = fs.readdirSync(runs);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const file = path.join(runs, name, "qodercli.log");
+            try {
+                const stat = fs.statSync(file);
+                if (stat.isFile())
+                    candidates.push({ file, mtime: stat.mtimeMs });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    const limit = options.limit ?? 8;
+    for (const candidate of candidates.sort((a, b) => b.mtime - a.mtime).slice(0, limit)) {
+        let head = "";
+        try {
+            head = fs.readFileSync(candidate.file, "utf8").slice(0, 8192);
+        }
+        catch {
+            continue;
+        }
+        const match = /initial_cwd=([\s\S]*?)\s+restore_cwd=/.exec(head);
+        const root = usableDir(match?.[1]);
+        if (root)
+            return root;
+    }
+    return null;
+}
+export function resolveQoderWorkspace(env = process.env) {
+    const fromEnv = usableDir(env.QODER_WORKER_CWD);
+    if (fromEnv)
+        return { root: fromEnv, source: "QODER_WORKER_CWD" };
+    const fromLog = workspaceFromRunLog({ env });
+    if (fromLog)
+        return { root: fromLog, source: "qodercli run log" };
+    return null;
+}
+/** 调用方自己钉了 --root 时完全尊重它：不标记适配器，服务器就不会按请求改根 */
+export function qoderLaunchEnv(argv = process.argv.slice(2), env = process.env) {
+    if (argv.includes("--root"))
+        return env;
+    const resolved = resolveQoderWorkspace(env);
+    return {
+        ...env,
+        [CLIENT_ADAPTER_ENV]: QODER_ADAPTER,
+        ...(resolved ? { [ROOT_HINT_ENV]: resolved.root, [ROOT_HINT_SOURCE_ENV]: resolved.source } : {}),
+    };
+}
+/** 参数原样透传：适配器不再伪造 --root，免得服务器把动态解析的依据报成「启动参数写死」 */
+export function qoderLaunchArgs(argv = process.argv.slice(2)) {
+    return argv;
+}
+export function qoderServerEntry() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = ["index.js", "index.ts"].map((name) => path.resolve(here, name));
+    return candidates.find((file) => fs.existsSync(file)) ?? candidates[0];
+}
+export function runQoderLaunch(argv = process.argv.slice(2)) {
+    const env = qoderLaunchEnv(argv);
+    const pinned = argv.includes("--root");
+    if (pinned) {
+        console.error("[pm-mcp qoder-launch] 调用方已钉 --root，按固定项目根运行（不做按请求认领）");
+    }
+    else if (env[ROOT_HINT_ENV]) {
+        console.error(`[pm-mcp qoder-launch] 启动期默认根: ${env[ROOT_HINT_ENV]} (source: ${env[ROOT_HINT_SOURCE_ENV]})；每次调用会按会话日志重新认领工作区`);
+    }
+    else {
+        console.error("[pm-mcp qoder-launch] 启动期未取到 Qoder 工作区，交给服务器按请求认领（get_status 会报告依据）");
+    }
+    const child = spawn(process.execPath, [qoderServerEntry(), ...qoderLaunchArgs(argv)], { stdio: "inherit", env });
+    child.on("exit", (code, signal) => {
+        if (signal)
+            process.kill(process.pid, signal);
+        else
+            process.exit(code ?? 1);
+    });
+    child.on("error", (error) => {
+        console.error(`[pm-mcp qoder-launch] 启动失败: ${error.message}`);
+        process.exit(1);
+    });
+    for (const name of ["SIGINT", "SIGTERM"])
+        process.on(name, () => child.kill(name));
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url))
+    runQoderLaunch();

package/dist/resources.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { dashboardFile, pmPath } from "./paths.js";
+import { loadRoadmap, loadTasks } from "./store.js";
+import { renderRoadmap } from "./roadmap.js";
+import { buildChangelog } from "./dashboard.js";
+import { auditGovernance } from "./governance-audit.js";
+import { buildPortfolioReport, loadPortfolioProject } from "./portfolio.js";
+import { listAcceptanceBaselines } from "./acceptance-tools.js";
+import { AcceptanceReportSchema } from "./acceptance-report.js";
+import { runCoalescedRead } from "./idempotency.js";
+import { budgetLines, recordUsage, requestContext } from "./tool-base.js";
+import { taskPage } from "./task-pagination.js";
+export function registerResources(server, root) {
+    function safeText(fn) {
+        try {
+            return fn();
+        }
+        catch (e) {
+            return `（不可用: ${e.message}）`;
+        }
+    }
+    async function resourceText(name, fn) {
+        const started = Date.now();
+        const target = requestContext(name, {}, root).root;
+        try {
+            const text = (await runCoalescedRead(target, `resource:${name}`, {}, () => safeText(() => fn(target)))).text;
+            recordUsage(target, `resource:${name}`, "read", started, { ok: true, text });
+            return text;
+        }
+        catch (error) {
+            recordUsage(target, `resource:${name}`, "read", started, { ok: false, error: error.message });
+            throw error;
+        }
+    }
+    server.registerResource("dashboard", "pm://dashboard", { description: "项目仪表盘（与仓库根 PROJECT.md 同源），路线图/健康摘要/任务/功能清单" }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: await resourceText("dashboard", (r) => fs.readFileSync(dashboardFile(r), "utf8")),
+            },
+        ],
+    }));
+    server.registerResource("roadmap", "pm://roadmap", { description: "路线图（里程碑进度 + 活跃里程碑任务明细）" }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: await resourceText("roadmap", (r) => renderRoadmap(loadRoadmap(r).milestones, loadTasks(r).tasks, 2).join("\n")),
+            },
+        ],
+    }));
+    server.registerResource("tasks", "pm://tasks", { description: "任务原始数据；大列表末尾返回 continuation，可通过 list_tasks 保持 include_done:true 连续取回后续任务" }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: await resourceText("tasks", (r) => {
+                    const data = loadTasks(r);
+                    const tasks = data.tasks;
+                    // 资源也要守 token 预算：全量 dump 大账本会吃爆上下文（截断后仍是合法 JSON）
+                    if (tasks.length <= 100)
+                        return JSON.stringify(tasks, null, 2);
+                    const page = taskPage(r, { include_done: true, page_size: 100 }, budgetLines(r) - 4, data);
+                    const shown = tasks.slice(0, page.returned);
+                    shown.push({
+                        id: `_TRUNCATED_${tasks.length - page.returned}`,
+                        title: `…本次输出已截断，另有 ${tasks.length - page.returned} 个任务，用 continuation 连续读取`,
+                        continuation: { tool: "list_tasks", arguments: { include_done: true, cursor: page.next_cursor } },
+                    });
+                    return JSON.stringify(shown, null, 2);
+                }),
+            },
+        ],
+    }));
+    server.registerResource("changelog", "pm://changelog", { description: "变更日志（由 sessions.json 生成的人类可读版本）" }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: await resourceText("changelog", (r) => buildChangelog(r)),
+            },
+        ],
+    }));
+    server.registerResource("architecture", "pm://architecture", { description: "跨文件/模块/语言治理审计：语义覆盖、依赖边界、接口、循环与质量矩阵" }, async (uri) => ({
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text: await resourceText("architecture", (r) => auditGovernance(r, 150).report) }],
+    }));
+    server.registerResource("portfolio", "pm://portfolio", { description: "当前项目的组合视图与跨仓依赖/版本风险" }, async (uri) => ({
+        contents: [{
+                uri: uri.href,
+                mimeType: "application/json",
+                text: await resourceText("portfolio", (r) => JSON.stringify(buildPortfolioReport({ projects: [loadPortfolioProject(r)], projectsRequested: 1 }), null, 2)),
+            }],
+    }));
+    server.registerResource("acceptance", "pm://acceptance", { description: "标准化产品验收概览：版本化预批准基线与最近一次机器判定报告" }, async (uri) => ({
+        contents: [{
+                uri: uri.href,
+                mimeType: "application/json",
+                text: await resourceText("acceptance", (r) => {
+                    const reportDir = pmPath(r, "acceptance", "reports");
+                    let latestReport = null;
+                    if (fs.existsSync(reportDir)) {
+                        const candidates = fs.readdirSync(reportDir, { withFileTypes: true })
+                            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+                            .map((entry) => ({ name: entry.name, mtime: fs.statSync(path.join(reportDir, entry.name)).mtimeMs }))
+                            .sort((a, b) => b.mtime - a.mtime || a.name.localeCompare(b.name));
+                        if (candidates[0])
+                            latestReport = AcceptanceReportSchema.parse(JSON.parse(fs.readFileSync(path.join(reportDir, candidates[0].name), "utf8")));
+                    }
+                    return JSON.stringify({ baselines: listAcceptanceBaselines(r), latest_report: latestReport }, null, 2);
+                }),
+            }],
+    }));
+}

package/dist/scan.js

@@ -78,6 +78,10 @@ export function looksTrivialTest(content) {
 export function countSkipLines(content) {
     let n = 0;
     for (const line of content.split("\n")) {
+        // 排除两类误报：正则模式定义行（本扫描器源码自身）与夹具字符串模板行（含转义 \n 的内嵌代码）
+        const trimmed = line.trim();
+        if (trimmed.startsWith("/") || line.includes("\\n"))
+            continue;
         if (SKIP_MARKER_PATTERNS.some((re) => re.test(line)))
             n += 1;
     }

package/dist/setup-project.js

@@ -90,7 +90,7 @@ export function isLocalServerEntry(entry) {
     if (!/^node(?:\.exe)?$/i.test(path.basename(entry.command)) || entry.args.length < 1 || !path.isAbsolute(entry.args[0]))
         return false;
     const file = path.resolve(entry.args[0]);
-    if (!/^(?:index|cli)\.(?:js|ts)$/.test(path.basename(file)))
+    if (!/^(?:index|cli|qoder-launch)\.(?:js|ts)$/.test(path.basename(file)))
         return false;
     try {
         const stat = fs.lstatSync(file);