@luckychen1993/pm-mcp 0.4.0 → 0.6.0

package/README.md

@@ -8,7 +8,16 @@
 
 > 核心理念：**把恶化从「无声发生」变成「显式记账」，把上下文从「模型记忆」搬到「仓库文件」。**
 
-当前源码为 **0.3.0 本地候选版本，尚未由本轮工作发布**。下方公共安装示例仍使用已发布的 0.1.5。候选版可用 `setup --local` 绑定已构建的本地入口；未发布前不要配置依赖注册表中 0.3.0 的 npx 启动项。
+当前源码与 npm 最新发布为 **0.6.0**。公共安装示例使用 `@latest`；`setup --local` 可绑定已构建的本地入口。
+
+## 0.6.0：Qoder 接入发布、git 对账兜底与完成门禁指路
+
+- **发布 `launch` 子命令与 `--client qoder`**：npm 版可直接 `setup --client qoder`（条目写 `<QODER_CONFIG_DIR|~/.qoder-cn>/settings.json`，走 `pm-mcp launch` 适配器）；`install.ps1` 新增 `-Client qoder` 分支，修复其硬编码版本号。
+- **Qoder 多窗口按请求认领工作区**：Qoder 只派生一个常驻子进程复用所有窗口，项目根不再于启动期钉死——服务端用「工具名 + 参数 + 紧时间窗」指纹倒扫会话运行日志，命中调用方工作区（`root_source=qoder-session-log(request-match)`）。
+- **git 对账健壮性**：宿主进程 PATH 缺 git 时按 `where git` 与常见安装路径兜底解析并缓存，`git status` 对账不再恒红 fail-closed。
+- **完成门禁报错带下一步指引**：`update_task` 的证据过期/最新报告/范围校验拦截都附可执行的重试路径（先跑 `run_quality_matrix` 全绿再置 done），减少 AI 重试碰壁。
+- **审计误报修复**：skip/only 标记计数不再统计扫描器自身的正则模式定义与夹具字符串模板；fixtures 目录不参与空测试嫌疑。
+- **入口拆分**：`index.ts` 只留装配与启动，resources/prompts 注册拆到 `src/resources.ts`、`src/prompts.ts`。
 
 ## 0.3.0：升级生效、任务取全与证据分级
 
@@ -33,7 +42,7 @@ node dist/cli.js doctor --root .
 
 ## 已有管理流程
 
-用户仍然直接说“继续这个任务”“保存进度”“完成后帮我验收”。52 个工具全部保留，由 AI 组合调用，无需用户记工具名。
+用户仍然直接说“继续这个任务”“保存进度”“完成后帮我验收”。54 个工具全部保留，由 AI 组合调用，无需用户记工具名。
 
 - `update_task` 可同时更新进度、保存 `checkpoint:{note,next_step}` 并记录会话；完成时给 `record_session:true`，返回会话编号后不再另调 `log_session`。省略该参数仍兼容旧的手动记会话流程。同一幂等键重放不会重复落账；跨多个文件的异常仍遵守原有“不确定状态需核对”规则，不宣称事务原子性。
 - `feature/fix` 转 `done` 必须关联实际文件，并先通过 `run_quality_matrix` 执行相应测试。系统自动选择最新报告，核对执行成功、测试前后与当前源码摘要、测试单元目录和项目证据策略。`verification_run` 可明确指向最新报告，文字 `verification` 只作补充说明。报告存于 `.pm/quality-runs/`，任务保存报告与源码 SHA-256。目录范围匹配不等于代码覆盖率证明；第一方报告也不构成防篡改认证。
@@ -68,7 +77,7 @@ AI 编码项目的典型失控（本工具逐一给出机制）：
 
 ## 一个命令自动添加到 AI 编程助手
 
-本页安装示例使用 npm 上最新的**已发布**版本（当前为 **0.1.5**）。0.1.4 不支持 `setup --project`；验证这些能力时请确认实际运行版本为 0.1.5 或更新版本。仓库源码当前为 **0.3.0**（新增任务游标分页、完成证据分级、受控升级与 WorkBuddy 客户端等），**尚未发布到 npm**——需要这些能力时请从源码构建，或见下方各客户端的本地入口用法。
+本页安装示例使用 npm 上最新的**已发布**版本（当前为 **0.6.0**）。仓库源码与发布版本同步；需要本地验证时可用 `setup --local` 从源码构建后接入。
 
 要求：Node.js ≥ 22.18。Windows、macOS 和 Linux 使用同一条命令：
 
@@ -82,7 +91,7 @@ npx -y @luckychen1993/pm-mcp@latest setup
 npx -y @luckychen1993/pm-mcp@latest setup --dry-run
 ```
 
-非标准安装路径无法自动发现时，可在同一命令末尾指定 `--client codex|claude|zcode|cursor|vscode|workbuddy`；`--client print` 输出通用 MCP JSON。首次启动由 `npx` 下载并在本机运行，pm-mcp 本身不需要 API Key，也不会调用远程模型。
+非标准安装路径无法自动发现时，可在同一命令末尾指定 `--client codex|claude|zcode|cursor|vscode|workbuddy|qoder`；`--client print` 输出通用 MCP JSON。首次启动由 `npx` 下载并在本机运行，pm-mcp 本身不需要 API Key，也不会调用远程模型。
 
 ### 新项目一条命令上手（Codex 必用）
 
@@ -134,21 +143,12 @@ $u='https://raw.githubusercontent.com/happy520ai/pm-mcp/v0.1.5/install.ps1'; $f=
 
 #### WorkBuddy 桌面版
 
-> **要求 pm-mcp ≥ 0.3.0**：`--client workbuddy` 是 0.3.0 新增的客户端；npm 上当前的 0.1.5 **不支持**该参数，直接跑会报 `--client must be auto, all, codex, claude, zcode, cursor, vscode, or print`。
-
-0.3.0 发布后：
+要求 pm-mcp ≥ 0.3.0（`--client workbuddy` 为 0.3.0 新增）。一条命令接入：
 
 ```bash
 npx -y @luckychen1993/pm-mcp@latest setup --client workbuddy
 ```
 
-0.3.0 发布前，从源码构建后用本地入口接入（`--local` 绑定本包已构建的 `dist/index.js`）：
-
-```bash
-npm ci && npm run build
-node dist/cli.js setup --client workbuddy --local
-```
-
 写入 `<WorkBuddy 数据目录>/mcp.json`，结构与下方通用 JSON 一致。数据目录按 `WORKBUDDY_CONFIG_DIR` → `~/.workbuddy-ai`（当前版本）→ `~/.workbuddy`（旧版）顺序解析，写入前会生成带时间戳的备份，未知顶层字段与既有 server 全部保留。
 
 与其他客户端的关键差别：**WorkBuddy 的条目刻意不写 `--root`**。它的 MCP 子进程由会话工作区拉起，cwd 即当前项目，服务端按 cwd 解析项目根——因此一条配置同时服务所有工作区，不需要逐项目钉根；未初始化的目录只返回「未初始化」，不会写入任何文件。
@@ -179,14 +179,53 @@ node dist/cli.js doctor --root . --client workbuddy           # 核验 48 工具
 
 服务默认以客户端启动它时的工作目录作为项目根。若客户端不从项目目录启动，可在 `args` 末尾增加 `"--root", "项目绝对路径"`，或设置 `PM_ROOT`。第一次使用未初始化的项目时，让 AI 调用 `init_project`；MCP 工具可能读写目标项目的 `.pm/`，请按客户端提示确认信任。
 
+#### Qoder CLI / Qoder CN
+
+```bash
+npx -y @luckychen1993/pm-mcp setup --client qoder          # 发布版：条目写 ~/.qoder-cn/settings.json，走 `pm-mcp launch`
+node dist/cli.js setup --client qoder --local              # 本仓库：绑定已构建的 dist/qoder-launch.js
+node dist/cli.js doctor --root . --client qoder            # 真实握手核验（配置改完先跑这个）
+```
+
+Qoder 拉起 MCP 子进程时 cwd 是它的安装目录（worker cwd shim），且 1.1.57 实测不加载 `.qoder/settings.local.json` 的 `mcpServers`。**更关键的是：Qoder 只派生一个常驻 stdio 子进程，再用本地路由把所有窗口/会话复用到它上面**（实测同一 server uuid 被多个不同 session token 共用，进程可存活数天）。因此任何「启动时解析一次项目根」的做法对其它窗口必然是错的——运行日志目录名结尾的 `-p<pid>` 也是主进程 pid，`process.ppid` 无法区分会话。
+
+所以项目根是**每次调用重新认领**的：Qoder 在派发前会把 `tool.requested`（含工具名与参数原文）写进本会话运行日志，服务端用「工具名 + 参数 + 紧时间窗」做请求指纹倒扫最近日志，命中那份日志头部的 `initial_cwd` 就是调用方工作区。适配器 `dist/qoder-launch.js` 只负责打标记与给出启动期默认值：继承到的 `QODER_WORKER_CWD`，否则取最近在写的那份运行日志的 `initial_cwd`，通过 `PM_MCP_ROOT_HINT(_SOURCE)` 交给服务端，并**不再伪造 `--root`**，所以 `get_status` 报出的依据是真实来历而不是清一色的 `--root`。认领顺序：调用时显式传的 `root` 参数 > 请求指纹命中 > 唯一活跃会话 > 启动期提示（标 `spawn-time`）> 启动解析。指纹命中多个会话、或多个会话同时活跃又无指纹时**一律不猜**：退回启动根，在 `root_source` 里写明「未猜测」并列出候选，此时给本次调用传 `root` 即可确定。
+
+你在 `args` 里显式写 `--root` 时适配器完全尊重它：不打适配器标记，服务端也就不会按请求改根（适合「一个固定账本」的用法）。
+
+等价的手写配置（`setup --client qoder --local` 写的就是这个形状）：
+
+```json
+{
+  "mcpServers": {
+    "pm-mcp": {
+      "command": "node",
+      "args": ["<本仓库绝对路径>/dist/qoder-launch.js"]
+    }
+  }
+}
+```
+
+也可以跳过适配器直接指服务器：`["<绝对路径>/dist/index.js", "--root", "${QODER_WORKER_CWD}"]`。客户端支持 args 插值时直接生效；不支持时留在 `args` 里的字面量会被 pm-mcp 判为无效值忽略，转而采用继承到的 `QODER_WORKER_CWD` 本身。**但这条写法把项目根钉在派生那一刻**：进程被所有窗口共用时，后开的窗口会读到先开窗口的项目，只适合单工作区或你确实想要一个固定账本的场景。
+
+推荐用适配器写法：一条配置服务所有工作区，且每个窗口各归各的账本。核验：重连（`/mcp reload` 或重开会话）后调用 `get_status`，「项目根」后面会标出本次认领依据（正常应是 `qoder-session-log(request-match)`）；`structuredContent` 里同时带 `project`/`milestones`/`focus`/`health`/`last_session`，只呈现结构化载荷的客户端也能看到完整状态。
+
+> `launch` 子命令与 `--client qoder` 自 **0.6.0** 起随 npm 发布；旧版本请升级，或用 `setup --client qoder --local` 从源码构建后的入口接入。
+
 ### 环境变量与参数
 
 | 变量/参数 | 作用 |
 |---|---|
-| `--root <path>` | 项目根（最高优先级） |
-| `PM_ROOT` | 项目根（次优先级） |
+| `root`（工具参数） | 本次调用的项目根，优先级最高；仅在服务端报告「未猜测」时才需要传 |
+| `--root <path>` | 启动期项目根（未插值的 `${...}` 字面量视为未提供）。显式给出时**关闭按请求认领**，全程固定该根 |
+| `PM_ROOT` | 启动期项目根（次优先级） |
+| `PM_MCP_CLIENT_ADAPTER` | 由适配器设为 `qoder`：开启按请求认领调用方工作区；未设置时行为与从前完全一致（CLI/ZCode/直接 stdio 不受影响） |
+| `PM_MCP_ROOT_HINT` / `PM_MCP_ROOT_HINT_SOURCE` | 适配器给出的启动期默认根及其真实来历，`get_status` 会标成 `<来历>(spawn-time)` |
+| `QODER_WORKER_CWD` | 客户端工作区提示：仅当启动目录不是已初始化项目时采用，优先取已初始化的提示目录，其次取存在的目录 |
 | `PM_MCP_HOME` | 全局注册表重定向（默认 `~`；多环境/测试隔离用） |
 
+启动期解析顺序：`--root` > `PM_ROOT` > 适配器提示 > 已初始化的启动目录 > 客户端工作区提示 > 启动目录。**每次调用**再按「`root` 参数 > 请求指纹 > 唯一活跃会话 > 启动期提示 > 启动解析」重新认领（仅在 `PM_MCP_CLIENT_ADAPTER=qoder` 时生效）。`get_status` 与启动横幅都会回报本次采用的依据，依据里出现「未猜测」就说明证据不足、需要显式传 `root`。
+
 ### pm-mcp probe：标准 raw tools/list 直连探针
 
 宿主（ZCode/Codex/Cursor 等）是唯一 MCP client 持有者，不会向模型透传原始 `tools/list`；要拿服务器在协议线上的真实工具清单，用 `probe` 绕过宿主直连：
@@ -246,7 +285,7 @@ snapshot_codebase + audit_structure 对账；audit_security 安全体检；audit
 
 也可以直接用内置 prompts：`start-session` / `end-session` / `onboard` / `architecture-review` / `acceptance-review`；其中 `onboard` 会引导客户端读取状态并生成新人/AI 入职简报。
 
-## 工具清单（52 个）
+## 工具清单（54 个）
 
 | 域 | 工具 | 说明 |
 |---|---|---|
@@ -259,12 +298,12 @@ snapshot_codebase + audit_structure 对账；audit_security 安全体检；audit
 | 调试 | `log_debug` | 调试知识账：症状/根因/修法/验证 |
 | 求证 | `search_code` / `search_knowledge` / `annotate_file` | 代码检索（file:line）、七类知识源检索（含模块/接口/仓库治理）、文件用途索引 |
 | 审计 | `snapshot_codebase` / `audit_structure` | 结构快照；完整性/增长/漂移/债务/churn/复杂度/索引/足迹/测试/Git 十节对账 |
-| 安全 | `audit_security` / `list_findings` / `resolve_finding` | 密钥+危险模式+新增/通配依赖提示；扫描命中原文不落盘，处置 note 拒绝内置密钥形态 |
+| 安全 | `audit_security` / `list_findings` / `resolve_finding` / `search_code_public` | 密钥+危险模式+新增/通配依赖提示；扫描命中原文不落盘，处置 note 拒绝内置密钥形态；公开代码反查（联网默认关，confirm 门控，字面命中≠侵权结论） |
 | 法律 | `audit_license` | 依赖许可证清单、copyleft 冲突、GPL 头检测、LICENSE 检查、来源登记 |
 | 可观测 | `get_usage_log` / `get_runtime_log` | 使用日志（工具调用统计、错误率、耗时、输出与折叠省下的 token 估算——验证省不省 token）与运行日志（server/watcher/工具报错）；只记计量不记参数内容 |
 | 注册表 | `list_projects` | 本机所有被管理项目 |
 | 治理模型 | `init_governance` / `get_governance` / `upsert_module` / `upsert_interface` / `upsert_repository` / `set_governance_policies` | 结构化模块根、owner、语言、公开接口、允许/禁止依赖、跨仓版本约束与强制策略 |
-| 语义治理 | `discover_languages` / `audit_governance` / `dependency_graph` / `impact_analysis` / `list_semantic_evidence` / `save_semantic_evidence` / `replace_semantic_evidence_for_file` | 编译器/Tree-sitter AST 关系、hash-bound 原生分析器/运行时证据、模块与文件级循环、依赖邻域/枢纽/unresolved/覆盖率与变更反向闭包 |
+| 语义治理 | `discover_languages` / `audit_governance` / `list_governance_issues` / `dependency_graph` / `impact_analysis` / `list_semantic_evidence` / `save_semantic_evidence` / `replace_semantic_evidence_for_file` | 编译器/Tree-sitter AST 关系、hash-bound 原生分析器/运行时证据、模块与文件级循环、完整治理问题分页、依赖邻域/枢纽/unresolved/覆盖率与变更反向闭包 |
 | 质量与组合 | `plan_quality_matrix` / `run_quality_matrix` / `get_portfolio` / `find_duplicates` / `audit_osv` | plan 与真实执行严格分离；shell=false；跨仓阶段/债务/安全/版本/cycle 聚合；行指纹聚类跨文件重复块；OSV 联网漏洞比对（默认关，须显式 confirm=true） |
 | 标准化验收 | `list_acceptance_baselines` / `get_acceptance_baseline` / `save_acceptance_baseline_draft` / `approve_acceptance_baseline` / `evaluate_acceptance` | ISO/SQuaRE 对齐的版本化质量基线、冻结证据指针、需求—风险—测试追踪、机器判定报告与 SHA-256 manifest |
 

package/dist/acceptance-tools.js

@@ -268,46 +268,51 @@ export function evaluateAcceptanceFile(root, input) {
     refreshDerived(root);
     return { report, ...files };
 }
-export function registerAcceptanceTools(server, root) {
-    toolR(server, root, "list_acceptance_baselines", "列出版本化验收基线、审批状态、当前 fingerprint 和规模。", {}, () => {
+export function registerAcceptanceTools(server, startupRoot) {
+    toolR(server, startupRoot, "list_acceptance_baselines", "列出版本化验收基线、审批状态、当前 fingerprint 和规模。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return JSON.stringify(listAcceptanceBaselines(root), null, 2);
     });
-    toolR(server, root, "get_acceptance_baseline", "读取一个验收基线；默认返回摘要，full=true 返回严格 JSON。", {
+    toolR(server, startupRoot, "get_acceptance_baseline", "读取一个验收基线；默认返回摘要，full=true 返回严格 JSON。", {
         baseline_id: IdSchema,
         baseline_version: SemVerSchema,
         full: z.boolean().optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const baseline = loadAcceptanceBaseline(root, args.baseline_id, args.baseline_version);
         if (args.full)
             return JSON.stringify(baseline, null, 2);
         return JSON.stringify(listAcceptanceBaselines(root).find((item) => item.id === args.baseline_id && item.version === args.baseline_version), null, 2);
     });
-    toolI(server, root, "save_acceptance_baseline_draft", "从项目内 .pm/acceptance 下的严格 JSON 保存 draft 基线；批准后的同版本不可覆盖。", {
+    toolI(server, startupRoot, "save_acceptance_baseline_draft", "从项目内 .pm/acceptance 下的严格 JSON 保存 draft 基线；批准后的同版本不可覆盖。", {
         baseline_file: JsonPathSchema,
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const baseline = saveDraftAcceptanceBaselineFile(root, args.baseline_file);
         return `✅ draft ${baseline.baseline_id}@${baseline.baseline_version} 已保存；fingerprint=${acceptanceBaselineFingerprint(baseline)}`;
     });
-    toolI(server, root, "approve_acceptance_baseline", "按当前 SHA-256 fingerprint 原子批准基线；fingerprint 变化即拒绝，批准后修改必须升版。", {
+    toolI(server, startupRoot, "approve_acceptance_baseline", "按当前 SHA-256 fingerprint 原子批准基线；fingerprint 变化即拒绝，批准后修改必须升版。", {
         baseline_id: IdSchema,
         baseline_version: SemVerSchema,
         expected_fingerprint_sha256: Sha256Schema,
         approved_by: z.string().trim().min(1),
         approval_rationale: z.string().trim().min(8),
         approved_at: z.string().datetime({ offset: true }).optional(),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const approved = approveAcceptanceBaseline(root, args);
         return `✅ baseline ${approved.baseline_id}@${approved.baseline_version} 已批准；approved fingerprint=${acceptanceBaselineFingerprint(approved)}`;
     });
-    toolI(server, root, "evaluate_acceptance", "读取项目内 .pm/acceptance evaluation JSON，逐项复算证据 SHA-256，再生成不可手填、不可覆盖的正式报告。", {
+    toolI(server, startupRoot, "evaluate_acceptance", "读取项目内 .pm/acceptance evaluation JSON，逐项复算证据 SHA-256，再生成不可手填、不可覆盖的正式报告。", {
         baseline_id: IdSchema,
         baseline_version: SemVerSchema,
         evaluation_file: JsonPathSchema,
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const result = evaluateAcceptanceFile(root, args);
         const relativeJson = path.relative(path.resolve(root), result.json_file).replace(/\\/g, "/");

package/dist/audit-tools.js

@@ -10,39 +10,59 @@ import { budgetLines, toolR, toolW } from "./tool-base.js";
 import { walkRefresh } from "./index-store.js";
 import { renderDuplicates } from "./duplicates.js";
 import { renderOsv, auditOsv } from "./osv.js";
-export function registerAuditTools(server, root) {
-    toolW(server, root, "snapshot_codebase", "给代码结构拍快照（文件数/行数/目录分布/测试数/skip 标记/依赖清单）。之后 audit_structure 会与上次快照 diff。建议每个会话或每个里程碑结束时拍一次。", {}, () => {
+import { renderPublicSearch, searchPublicCode } from "./public-search.js";
+export function registerAuditTools(server, startupRoot) {
+    toolW(server, startupRoot, "snapshot_codebase", "给代码结构拍快照（文件数/行数/目录分布/测试数/skip 标记/依赖清单）。之后 audit_structure 会与上次快照 diff。建议每个会话或每个里程碑结束时拍一次。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const { snapshot, summary } = snapshotCodebase(root);
         refreshDerived(root);
         return [...summary, `下次 audit_structure 将以此为基线（${snapshot.file}）。`].join("\n");
-    }, () => { requireInitialized(root); walkRefresh(root, { forceContent: true }); });
-    toolR(server, root, "audit_structure", "八项结构对账（定期做）：①增长与新增依赖 ②漂移对账（功能↔文件，防幻觉）③债务与重构配额 ④churn 热点 ⑤复杂度预算 ⑥索引覆盖率 ⑦足迹/产出 ⑧测试健康（禁用/蒸发/空测试/背书占比）。", {}, () => {
+    }, (_args, ctx) => { const root = ctx.root; requireInitialized(root); walkRefresh(root, { forceContent: true }); });
+    toolR(server, startupRoot, "audit_structure", "八项结构对账（定期做）：①增长与新增依赖 ②漂移对账（功能↔文件，防幻觉）③债务与重构配额 ④churn 热点 ⑤复杂度预算 ⑥索引覆盖率 ⑦足迹/产出 ⑧测试健康（禁用/蒸发/空测试/背书占比）。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return auditStructure(root, budgetLines(root), true);
     });
-    toolR(server, root, "find_duplicates", "重复代码检测：注释剥离/字符串占位/空白归一化的行指纹滑动窗口聚类，跨文件重复块按长度降序列出。", {
+    toolR(server, startupRoot, "find_duplicates", "重复代码检测：注释剥离/字符串占位/空白归一化的行指纹滑动窗口聚类，跨文件重复块按长度降序列出。", {
         min_lines: z.number().int().min(4).max(20).optional().describe("最小重复行数（有效代码行），默认 6"),
         limit: z.number().int().min(1).max(100).optional().describe("最多列出的重复组数，默认 20"),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return renderDuplicates(root, args ?? {}, budgetLines(root));
     });
-    toolR(server, root, "audit_osv", "OSV.dev 已知漏洞查询（联网！默认关）：把 manifest 声明的依赖（仅包名/版本/生态）批量发给 api.osv.dev 比对；必须显式 confirm=true 才发起网络请求。", {
+    toolR(server, startupRoot, "audit_osv", "OSV.dev 已知漏洞查询（联网！默认关）：把 manifest 声明的依赖（仅包名/版本/生态）批量发给 api.osv.dev 比对；必须显式 confirm=true 才发起网络请求。", {
         confirm: z.literal(true).describe("显式确认联网：本工具会把依赖名与版本发送到 api.osv.dev"),
         timeout_ms: z.number().int().min(5000).max(120000).optional().describe("每批请求超时毫秒数，默认 30000"),
-    }, async (args) => {
+    }, async (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const scan = await auditOsv(root, { timeoutMs: args.timeout_ms });
         return renderOsv(scan, budgetLines(root));
     });
-    toolW(server, root, "audit_security", "安全体检（只扫描本地、不联网，结果写入安全台账）：密钥泄露 / 危险模式（eval、SQL 拼接、禁用证书校验等）/ 依赖风险。修复后重扫自动关闭；接受风险必须留理由。", {}, (_args, prepared) => {
+    toolR(server, startupRoot, "search_code_public", "公开代码反查（联网！默认关）：把一段本仓源码行作为精确短语发给 GitHub Code Search，列出包含相同代码的公开仓库；片段在参数里对用户全程可见，必须显式 confirm=true。", {
+        confirm: z.literal(true).describe("显式确认联网：本工具会把一段真实代码行发送到 GitHub"),
+        snippet: z.string().trim().min(8).max(400).optional().describe("要反查的单行代码片段（与 file 二选一）"),
+        file: z.string().trim().min(1).max(512).optional().describe("从该文件取一行作为片段（相对项目根；缺省取最长行）"),
+        line: z.number().int().min(1).optional().describe("指定取第几行（1-based）"),
+        max_results: z.number().int().min(1).max(30).optional().describe("列出的命中数上限，默认 10"),
+        timeout_ms: z.number().int().min(5000).max(120000).optional().describe("请求超时毫秒数，默认 30000"),
+    }, async (args, ctx) => {
+        const root = ctx.root;
+        requireInitialized(root);
+        const result = await searchPublicCode(root, { snippet: args.snippet, file: args.file, line: args.line, maxResults: args.max_results, timeoutMs: args.timeout_ms });
+        return renderPublicSearch(result, budgetLines(root));
+    });
+    toolW(server, startupRoot, "audit_security", "安全体检（只扫描本地、不联网，结果写入安全台账）：密钥泄露 / 危险模式（eval、SQL 拼接、禁用证书校验等）/ 依赖风险。修复后重扫自动关闭；接受风险必须留理由。", {}, (_args, ctx, prepared) => {
+        const root = ctx.root;
         requireInitialized(root);
         const report = auditSecurity(root, prepared);
         refreshDerived(root);
         return report.text.join("\n");
-    }, () => { requireInitialized(root); return prepareSecurityAudit(root); });
-    toolR(server, root, "list_findings", "查看安全台账（可按状态过滤）。", { status: z.enum(["open", "fixed", "accepted"]).optional() }, (args) => {
+    }, (_args, ctx) => { const root = ctx.root; requireInitialized(root); return prepareSecurityAudit(root); });
+    toolR(server, startupRoot, "list_findings", "查看安全台账（可按状态过滤）。", { status: z.enum(["open", "fixed", "accepted"]).optional() }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const list = listFindings(root, args.status);
         if (list.length === 0)
@@ -50,23 +70,26 @@ export function registerAuditTools(server, root) {
         const L = list.map((f) => `[${f.status}/${f.severity}] ${f.id} ${f.file}:${f.line} ${f.rule} — ${f.note.slice(0, 60)}`);
         return foldLines([`共 ${list.length} 条:`, ...L], { maxLines: budgetLines(root) });
     });
-    toolW(server, root, "resolve_finding", "处置安全发现：修复后标 fixed；带理由接受风险标 accepted（必须填 note——接受是显式选择，要留痕）。", {
+    toolW(server, startupRoot, "resolve_finding", "处置安全发现：修复后标 fixed；带理由接受风险标 accepted（必须填 note——接受是显式选择，要留痕）。", {
         id: z.string().describe("如 SEC-001"),
         status: z.enum(["fixed", "accepted"]),
         note: z.string().optional().describe("accepted 时必填：接受理由"),
-    }, (args) => {
+    }, (args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         const f = resolveFinding(root, args.id, args.status, args.note ?? "");
         refreshDerived(root);
         return `✅ ${f.id} 已置为 ${f.status}${f.note ? `（${f.note}）` : ""}。`;
     });
-    toolR(server, root, "audit_license", "许可证审计（法律账）：依赖许可证清单与 copyleft 冲突、源码中的 GPL 家族许可证头、LICENSE 文件检查、来源登记清单。离线启发式，不替代法务。", {}, () => {
+    toolR(server, startupRoot, "audit_license", "许可证审计（法律账）：依赖许可证清单与 copyleft 冲突、源码中的 GPL 家族许可证头、LICENSE 文件检查、来源登记清单。离线启发式，不替代法务。", {}, (_args, ctx) => {
+        const root = ctx.root;
         requireInitialized(root);
         return auditLicense(root, budgetLines(root), true);
     });
 }
-export function registerRegistryTools(server, root) {
-    toolR(server, root, "list_projects", "列出本机所有被 pm-mcp 管理的项目（全局注册表）。", {}, () => {
+export function registerRegistryTools(server, startupRoot) {
+    toolR(server, startupRoot, "list_projects", "列出本机所有被 pm-mcp 管理的项目（全局注册表）。", {}, (_args, ctx) => {
+        const root = ctx.root;
         const list = listRegistry();
         if (list.length === 0)
             return "（注册表为空。在任何项目里 init_project 后会自动登记。）";

package/dist/caller-workspace.js

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/* Qoder 只派生一个常驻 stdio 子进程服务所有窗口（实测：同一 server uuid 被三个不同 session token 复用），
+   所以项目根不能在启动时定格。本模块在每次工具调用时反查「是谁在调我」：客户端运行日志会先记下
+   tool.requested（含工具名与参数原文），再发起调用，于是用本次请求做指纹就能锁定调用方那个会话的
+   initial_cwd。取不到证据时一律如实降级并说明依据，绝不猜。 */
+export const CLIENT_ADAPTER_ENV = "PM_MCP_CLIENT_ADAPTER";
+export const ROOT_HINT_ENV = "PM_MCP_ROOT_HINT";
+export const ROOT_HINT_SOURCE_ENV = "PM_MCP_ROOT_HINT_SOURCE";
+export const QODER_ADAPTER = "qoder";
+/** 服务端工具名前缀：客户端把工具暴露成 mcp__<server>__<tool>，服务名可能是 pm_mcp 或 pm-mcp */
+const TOOL_NAME_PATTERN = /mcp__pm[_-]mcp__/;
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** 显式给了 QODER_CONFIG_DIR 就只看它：否则本机的真实 ~/.qoder-cn 会混进测试与隔离环境 */
+function configDirs(env) {
+    const fromEnv = env.QODER_CONFIG_DIR?.trim();
+    if (fromEnv && isDir(fromEnv))
+        return [path.resolve(fromEnv)];
+    const home = os.homedir();
+    return [".qoder-cn", ".qoder"].map((name) => path.join(home, name)).filter(isDir);
+}
+/** 日志目录名以 -p<pid> 结尾，但 Qoder 全部会话共用主进程 pid，因此 ppid 不能用来区分会话 */
+function runLogDirs(env) {
+    const out = [];
+    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)
+            out.push(path.join(runs, name, "qodercli.log"));
+    }
+    return out;
+}
+function workspaceOfLog(file) {
+    let head;
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buffer = Buffer.alloc(8192);
+            const bytes = fs.readSync(fd, buffer, 0, 8192, 0);
+            head = buffer.toString("utf8", 0, bytes);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return null;
+    }
+    const match = /initial_cwd=([\s\S]*?)\s+restore_cwd=/.exec(head);
+    const value = match?.[1]?.trim();
+    return value && isDir(value) ? path.resolve(value) : null;
+}
+function recentRunLogs(options) {
+    const logs = [];
+    for (const file of runLogDirs(options.env)) {
+        let stat;
+        try {
+            stat = fs.statSync(file);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile() || options.now - stat.mtimeMs > options.windowMs)
+            continue;
+        logs.push({ file, mtime: stat.mtimeMs, size: stat.size, workspace: workspaceOfLog(file) });
+    }
+    return logs.sort((a, b) => b.mtime - a.mtime);
+}
+/** 从日志尾部按块往前扫，扫到比本次请求还早就停：活跃会话日志可能几 MB，但相关行永远在最后几秒 */
+const CHUNK_BYTES = 256 * 1024;
+const MAX_SCAN_BYTES = 8 * 1024 * 1024;
+/** 日志记的是客户端发出的原始参数，服务端拿到的是 zod 解析后的（可能补了默认值）：只要求日志参数被本次参数覆盖 */
+function argsCovered(logged, received) {
+    if (logged === undefined || logged === null)
+        return true;
+    if (typeof logged !== "object" || typeof received !== "object" || received === null)
+        return logged === received;
+    if (Array.isArray(logged) !== Array.isArray(received))
+        return false;
+    const loggedRecord = logged;
+    const receivedRecord = received;
+    return Object.keys(loggedRecord).every((key) => argsCovered(loggedRecord[key], receivedRecord[key]));
+}
+function extractArgsJson(line) {
+    const marker = line.indexOf(" args=");
+    if (marker < 0)
+        return undefined;
+    try {
+        return JSON.parse(line.slice(marker + " args=".length));
+    }
+    catch {
+        return undefined;
+    }
+}
+function lineMatchesRequest(line, tool, args) {
+    if (!TOOL_NAME_PATTERN.test(line))
+        return false;
+    const payload = extractArgsJson(line);
+    if (payload === undefined || payload === null || typeof payload !== "object")
+        return false;
+    const record = payload;
+    if (typeof record.toolName === "string") {
+        return record.toolName.endsWith(`__${tool}`) && argsCovered(record.arguments, args);
+    }
+    const name = /tool_name="([^"]+)"/.exec(line)?.[1];
+    return name === `mcp__pm_mcp__${tool}` && argsCovered(record, args);
+}
+function lineTimestamp(line) {
+    const stamp = /^\s*(\d{4}-\d{2}-\d{2}T[\d:.]+(?:[+-]\d{2}:\d{2}|Z))/.exec(line)?.[1];
+    if (!stamp)
+        return null;
+    const parsed = Date.parse(stamp);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function inWindow(at, window) {
+    return at !== null && at <= window.now + window.tieMs && window.now - at <= window.maxAgeMs;
+}
+/** 倒着按块扫，按字节拼接后再解码，避免把多字节字符从中间截断成乱码 */
+function scanLogForRequest(log, tool, args, window) {
+    let fd;
+    try {
+        fd = fs.openSync(log.file, "r");
+    }
+    catch {
+        return null;
+    }
+    let best = null;
+    try {
+        let offset = log.size;
+        let scanned = 0;
+        let carry = Buffer.alloc(0);
+        while (offset > 0 && scanned < MAX_SCAN_BYTES) {
+            const length = Math.min(CHUNK_BYTES, offset);
+            offset -= length;
+            scanned += length;
+            const chunk = Buffer.alloc(length);
+            const bytes = fs.readSync(fd, chunk, 0, length, offset);
+            const buffer = Buffer.concat([bytes === length ? chunk : chunk.subarray(0, bytes), carry]);
+            const firstNewline = buffer.indexOf(0x0a);
+            if (firstNewline === -1) {
+                carry = buffer;
+                continue;
+            }
+            carry = buffer.subarray(0, firstNewline + 1);
+            const lines = buffer.subarray(firstNewline + 1).toString("utf8").split(/\r?\n/).filter((line) => line.length > 0);
+            let oldest = null;
+            for (let i = lines.length - 1; i >= 0; i -= 1) {
+                const line = lines[i];
+                const at = lineTimestamp(line);
+                if (at !== null)
+                    oldest = at;
+                if (!inWindow(at, window))
+                    continue;
+                if (!line.includes(tool) || !lineMatchesRequest(line, tool, args))
+                    continue;
+                if (!best || at > best.at)
+                    best = { workspace: log.workspace, at: at };
+            }
+            if (oldest !== null && window.now - oldest > window.maxAgeMs)
+                break;
+        }
+    }
+    catch {
+        return best;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return best;
+}
+/** 找出本次请求的指纹落在哪个会话日志里。
+    必须按时间收紧：客户端日志会长期留着「工具名+参数」，两个窗口先后发同一个无参调用会留下同样的指纹，
+    只有「刚刚写下」的那条才可能是本次调用方。 */
+export function matchCallerWorkspaces(options) {
+    const window = { now: options.now, maxAgeMs: options.maxAgeMs ?? 30_000, tieMs: options.tieMs ?? 2_000 };
+    const hits = [];
+    for (const log of options.logs) {
+        if (!log.workspace)
+            continue;
+        const hit = scanLogForRequest(log, options.tool, options.args, window);
+        if (hit)
+            hits.push(hit);
+    }
+    if (hits.length === 0)
+        return [];
+    hits.sort((a, b) => b.at - a.at);
+    const newest = hits[0];
+    return hits
+        .filter((hit) => newest.at - hit.at <= window.tieMs)
+        .filter((hit, index, all) => all.findIndex((other) => other.workspace === hit.workspace) === index);
+}
+/* 不缓存解析结果：两个窗口在几百毫秒内发同一个无参调用时，缓存会把前一个窗口的项目根串给后一个。
+   单次解析只扫最近几秒的日志尾部，代价可以接受，正确性优先。 */
+/** 每次工具调用解析项目根：显式 root 参数 > 请求指纹命中的会话工作区 > 唯一活跃会话 > 启动期提示 > 启动解析 */
+export function resolveRequestRoot(options) {
+    const env = options.env ?? process.env;
+    const now = options.now ?? Date.now();
+    const startup = { root: options.startupRoot, source: options.startupSource };
+    if (env[CLIENT_ADAPTER_ENV] !== QODER_ADAPTER)
+        return startup;
+    const explicit = typeof options.args.root === "string" ? options.args.root.trim() : "";
+    if (explicit && isDir(explicit))
+        return { root: path.resolve(explicit), source: "argument" };
+    const logs = recentRunLogs({ env, now, windowMs: options.scanWindowMs ?? 60_000 });
+    const matched = matchCallerWorkspaces({ tool: options.tool, args: options.args, logs, now });
+    if (matched.length === 1)
+        return { root: matched[0].workspace, source: "qoder-session-log(request-match)" };
+    if (matched.length > 1) {
+        return {
+            ...startup,
+            source: `startup(${options.startupSource});请求指纹同时命中 ${matched.length} 个会话，未猜测`,
+            candidates: matched.map((hit) => hit.workspace),
+        };
+    }
+    const hot = logs.filter((log) => log.workspace && now - log.mtime <= (options.hotWindowMs ?? 10_000));
+    const hotWorkspaces = [...new Set(hot.map((log) => log.workspace))];
+    if (hotWorkspaces.length === 1)
+        return { root: hotWorkspaces[0], source: "qoder-session-log(only-active)" };
+    // 多个会话同时活跃又没指纹：宁可如实报歧义，也不拿启动期那个可能早就过期的根去猜
+    if (hotWorkspaces.length > 1) {
+        return { ...startup, source: `startup(${options.startupSource});多个 Qoder 会话同时活跃，未猜测`, candidates: hotWorkspaces };
+    }
+    const hint = env[ROOT_HINT_ENV]?.trim();
+    if (hint && isDir(hint)) {
+        const basis = env[ROOT_HINT_SOURCE_ENV]?.trim() || "hint";
+        return { root: path.resolve(hint), source: `${basis}(spawn-time)` };
+    }
+    return startup;
+}
+export const __test = { recentRunLogs, runLogDirs, configDirs, scanLogForRequest };

package/dist/cli.js

@@ -13,7 +13,7 @@ else if (process.argv[2] === "doctor") {
     try {
         const { parseDoctorArgs, runDoctor } = await import("./doctor.js");
         if (process.argv.includes("--help") || process.argv.includes("-h"))
-            console.log("pm-mcp doctor --root <项目> [--client codex|workbuddy] [--config <配置文件> | --entry <本地入口>]");
+            console.log("pm-mcp doctor --root <项目> [--client codex|workbuddy|qoder] [--config <配置文件> | --entry <本地入口>]");
         else {
             const result = await runDoctor(parseDoctorArgs(process.argv.slice(3)));
             console.log(JSON.stringify(result, null, 2));
@@ -63,6 +63,16 @@ else if (process.argv[2] === "probe") {
         process.exitCode = 1;
     }
 }
+else if (process.argv[2] === "launch") {
+    try {
+        const { runQoderLaunch } = await import("./qoder-launch.js");
+        runQoderLaunch(process.argv.slice(3));
+    }
+    catch (error) {
+        console.error(`[pm-mcp launch] ERROR: ${error.message}`);
+        process.exitCode = 1;
+    }
+}
 else {
     await import("./index.js");
 }