wowdump 0.3.2 → 0.3.4

package/dist/toolchain.js

@@ -1,29 +1,28 @@
-import { createHash } from "node:crypto";
-import { createReadStream, readdirSync, statSync } from "node:fs";
+import { readdirSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { pipeline } from "node:stream/promises";
-export const WOWDUMP_HOME_DIRECTORIES = ["profiles", "logs", "runtime", "cache", "skills", "monitors", "toolchains"];
+import { resolveWowdumpHome } from "./core/build-store.js";
 export const DEFAULT_WOWDUMP_SKILL = `---
 name: wowdump
-description: 使用 Frida 运行时证据和 IDA/iced-x86 定位 WoW 字段，生成 Reader 可用 profile。
+description: 用 Frida 运行时证据和 IDA Pro MCP 或 iced-x86 定位 WoW 字段，生成并验证 Reader profile。
 ---
 
 # wowdump
 
-查字段时先读取 targets，再用显式 GumJS 导出运行时线索。静态定位优先交给可用的 IDA Pro MCP；没有时运行 \`wowdump analyze disassemble\`，由 Agent 根据 iced-x86 输出分析并补齐字段定义。两条路径都必须最终生成 \`wowdump.profile.v1\`，且只有地址、类型和证据齐全时才标记 \`reader_ready\`。详情见 references/workflow.md、references/dynamic.md、references/disassemble.md 和 references/profiles.md。
+先运行 \`wowdump targets\`，再复用 \`~/.wowdump/<buildKey>/database/\`。动态脚本必须由 Agent 显式提供；runtime dump 保存当前 session 的二进制证据，Reader 只读取 build profile。详情见 references/workflow.md、references/commands.md、references/dynamic.md、references/disassemble.md 和 references/profiles.md。
 `;
 export const DEFAULT_WOWDUMP_COMMANDS = `# wowdump 命令参考
 
 1. \`wowdump targets\`
-2. \`wowdump analyze runtime --pid <pid> --build <buildKey> --kind text --confirm\`
-3. \`wowdump analyze dynamic --pid <pid> --build <buildKey> --script <GumJS> --export collect --confirm\`
-4. \`wowdump analyze disassemble --exe <Wow.exe> --build <buildKey> --runtime-export <runtime.json> --output <profile.json>\`
-5. \`wowdump memory read --pid <pid> --build <buildKey> --profile <profile.json> --field <name>\`
+2. \`wowdump database status --build <buildKey>\`
+3. \`wowdump analyze runtime --pid <pid> --build <buildKey> --kind dump --confirm\`
+4. \`wowdump analyze dynamic --pid <pid> --build <buildKey> --script <GumJS> --export collect --confirm\`
+5. \`wowdump analyze runtime --pid <pid> --build <buildKey> --kind verify --profile <profile.json> --confirm\`
+6. \`wowdump memory read --pid <pid> --build <buildKey> --profile <profile.json> --field <name>\`
 
-若 Agent 能调用 IDA Pro MCP，先用 MCP 分析 runtime text，再把结果保存为 JSON 并通过 \`--ida-evidence\` 交给 disassemble 命令。未确认的候选 profile 放在 runtime 目录；确认后才复制到当前 build 的 profile 目录。
+\`dump\` 默认流式导出供 IDA/iced-x86 分析的 PE 段并生成 manifest；\`verify\` 只验证已有候选 RVA。未确认的候选 profile 放在 runtime session 目录；确认后才复制到当前 build 的 profile 目录。
 `;
 function normalizePath(value) { return resolve(value.trim().replace(/^"|"$/g, "")); }
 function directoryExists(value) { try {
@@ -48,7 +47,7 @@ catch (error) {
     else
         throw error;
 } }
-export function resolveWowdumpHome(env = process.env, userHome = homedir()) { return normalizePath(env.WOWDUMP_HOME || join(userHome, ".wowdump")); }
+export { resolveWowdumpHome, sha256File } from "./core/build-store.js";
 export function resolveWowdumpSkillHome(env = process.env, userHome = homedir()) { return normalizePath(env.WOWDUMP_SKILL_HOME || join(userHome, ".agents", "skills")); }
 export async function initializeWowdumpHome(options = {}) {
     const env = options.env ?? process.env;
@@ -56,15 +55,6 @@ export async function initializeWowdumpHome(options = {}) {
     const created = [];
     const preserved = [];
     await mkdir(home, { recursive: true });
-    for (const name of WOWDUMP_HOME_DIRECTORIES) {
-        const dir = join(home, name);
-        if (directoryExists(dir))
-            preserved.push(dir);
-        else {
-            await mkdir(dir, { recursive: true });
-            created.push(dir);
-        }
-    }
     const configFile = join(home, "config.json");
     await createFileIfMissing(configFile, `${JSON.stringify({ schema: "wowdump.config.v1" }, null, 2)}\n`, created, preserved);
     const skillDirectory = join(normalizePath(options.skillHome ?? resolveWowdumpSkillHome(env, options.userHome)), "wowdump");
@@ -108,7 +98,6 @@ export async function initializeWowdumpHome(options = {}) {
 }
 export async function bootstrapToolchain(options = {}) { const home = await initializeWowdumpHome(options); return { ...home, toolchain: { ready: true, disassembler: "iced-x86" }, installed: [] }; }
 export function resolveToolchain(options = {}) { return { home: normalizePath(options.home ?? resolveWowdumpHome(options.env ?? process.env, options.userHome)), ready: true, disassembler: "iced-x86" }; }
-export async function sha256File(file) { const hash = createHash("sha256"); await pipeline(createReadStream(file), hash); return hash.digest("hex"); }
 export function inspectPeSections(buffer) { if (buffer.length < 0x40 || buffer.toString("ascii", 0, 2) !== "MZ")
     return []; const pe = buffer.readUInt32LE(0x3c); if (pe + 24 > buffer.length || buffer.toString("ascii", pe, pe + 4) !== "PE\0\0")
     return []; const count = buffer.readUInt16LE(pe + 6); const optional = buffer.readUInt16LE(pe + 20); const table = pe + 24 + optional; const out = []; for (let i = 0; i < count; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowdump",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "WoW native memory analysis CLI with Frida evidence, IDA/iced-x86 disassembly, and an elevated reader broker",
   "license": "MIT",
   "repository": {
@@ -42,5 +42,9 @@
   "devDependencies": {
     "@types/node": "^22.13.4",
     "typescript": "^5.7.3"
+  },
+  "allowScripts": {
+    "frida@17.17.0": true,
+    "koffi@2.16.3": true
   }
 }

package/skills/wowdump/SKILL.md

@@ -5,18 +5,21 @@ description: 以 Frida 运行时探测为主，按证据需要交替使用 IDA P
 
 # wowdump
 
-用于读取角色属性、Buff/Debuff、技能冷却、附近单位等原生字段。优先从当前进程取得真实值；需要长期复用时，再把已验证的线索固化为带证据的 `wowdump.profile.v1`。
+用于读取角色属性、Buff/Debuff、技能冷却、附近单位等原生字段。每个 build 有一个静态数据库，运行时证据按 session 保存，Reader 只读取已验证的 profile。
 
 ## 默认策略
 
-1. 先运行 `wowdump targets`，确认 PID、Wow.exe 路径和 buildKey；多个目标时让用户选择。
-2. 在 `~/.wowdump/<buildKey>/runtime/<session>/` 保存临时证据，在 `~/.wowdump/<buildKey>/profile/` 只保存用户确认的持久化 profile。
-3. 默认编写并显式传入 GumJS，使用 `wowdump analyze dynamic --script <GumJS> --confirm` 做运行时发现、原生 Hook、快照或事件采集。
-4. 若已有 `reader_ready` profile，先用 reader 读取；若动态结果已足够回答问题，直接返回，不强行做静态分析。
-5. 动态结果需要函数 RVA、对象布局或字段类型时，再对相关样本调用 IDA Pro MCP；没有 IDA 时才用 `wowdump analyze disassemble` 的 iced-x86 输出。静态和动态可以交替执行，每轮只扩大当前字段所需的证据范围。
-6. 将确认的 RVA、指针链、类型、边界和证据写入候选 profile。字段证据不足时保持 `candidate`，回到 dynamic 补采样或回到 IDA/iced 缩小候选。
-7. 用 `wowdump memory read --profile <profile> --field <name>` 做 broker-backed 验证；只有地址、类型和实际读取都成功后才标记 `reader_ready`。经用户确认后再保存到该 build 的 `profile/`。
+1. 先运行 `wowdump targets`，确认 PID、Wow.exe 路径、哈希和 buildKey；多个目标时让用户选择。该命令会创建或复用 `~/.wowdump/<buildKey>/database/`。
+2. 先检查 `wowdump database status --build <buildKey>`。同一可执行文件哈希、首选 image base 和模块大小时复用已有 IDA 数据库；哈希变化时数据库为 `stale`。
+3. 有 `reader_ready` profile 时先用 `wowdump memory read --pid <pid> --build <buildKey> --profile <profile> --field <name>`；Reader 不读取 IDA 数据库、dump 二进制或 runtime JSON。
+4. 没有可用 profile 时，由 Agent 编写并显式传入 GumJS：`wowdump analyze dynamic --pid <pid> --build <buildKey> --script <GumJS> --confirm`。脚本可做快照、有限 Hook 和事件采集。
+5. 动态线索需要静态证据时运行 `wowdump analyze runtime --kind dump`。dump 只写当前 session 的 `.text/.rdata/.pdata`，`.data` 通过 `--sections` 按需加入；不创建新的静态数据库。
+6. 优先让 IDA Pro MCP 打开该 build 的 `database/ida/Wow.i64`，按 manifest 将 runtime overlay 映射到原始 Wow.exe，输出函数 RVA、字符串 RVA、XREF、结构偏移和字段类型。没有 IDA MCP 时，用 iced-x86 对相关范围局部反汇编。
+7. 将静态结果和动态证据合并为 runtime session 下的 `candidate.profile.json`，只保存 RVA/相对偏移，不保存绝对地址。
+8. 用 `wowdump analyze runtime --kind verify --profile <candidate> --confirm` 做 broker 实读；确认 build/hash、地址、类型、边界和读取值一致后，才把 profile 复制到 `~/.wowdump/<buildKey>/profile/`。
 
 不要把 dynamic、IDA 或 iced 固定成一次性线性流水线。选择下一步的依据是当前字段缺少什么证据：值用 dynamic，函数/布局用 IDA/iced，稳定读取用 reader。
 
-具体的交替决策见 [references/workflow.md](references/workflow.md)；动态 Hook 规则见 [references/dynamic.md](references/dynamic.md)；IDA/iced 的选择和交替策略见 [references/disassemble.md](references/disassemble.md)；请求字段和 profile 生命周期见 [references/request-schema.md](references/request-schema.md) 与 [references/profiles.md](references/profiles.md)。
+具体决策见 [references/workflow.md](references/workflow.md)；命令参数见 [references/commands.md](references/commands.md)；动态 Hook 规则见 [references/dynamic.md](references/dynamic.md)；IDA/iced 规则见 [references/disassemble.md](references/disassemble.md)；请求字段和 profile 生命周期见 [references/request-schema.md](references/request-schema.md) 与 [references/profiles.md](references/profiles.md)。
+
+IDA MCP 使用长 TTL 会话（默认 `idle_ttl_sec: 3600`）。每次查询前先做 health probe；出现 `worker not reachable` 时按 `references/disassemble.md` 重新打开并只重试一次。IDA worker 与 Windows broker 独立，broker 的 UAC 复用不会保持 IDA worker 存活。

package/skills/wowdump/references/commands.md

@@ -21,31 +21,49 @@ wowdump analyze dynamic `
   --export collect `
   --args '{"fields":["playerAuras","nearbyEnemies","cooldowns"]}' `
   --duration-ms 5000 `
-  --confirm > $HOME\.wowdump\runtime\<session-id>\state.json
+  --confirm
 ```
 
-固定采样：
+CLI 会把结果保存到 `~/.wowdump/<buildKey>/runtime/<session-id>/dynamic.json`，并在 stdout 返回 session 目录。
+
+导出供静态分析的运行时模块段。默认只导出 `.text/.rdata/.pdata`；需要运行时全局状态时显式加入 `.data`：
 
 ```powershell
 wowdump analyze runtime `
   --pid 33976 `
   --build "retail@12.1.0.69587" `
-  --kind text `
-  --duration-ms 5000 `
-  --max-events 100 `
-  --confirm > $HOME\.wowdump\runtime\<session-id>\text.json
+  --kind dump `
+  --sections .text .rdata .pdata `
+  --confirm
 ```
 
-## 需要时做静态定位
+输出写入 `~/.wowdump/<buildKey>/runtime/<session-id>/dump/`，包含 `manifest.json` 和二进制段文件。Frida 按块发送，worker 直接写盘；stdout 只返回 manifest 路径、段摘要、字节数和 SHA-256，不打印 Base64 或整段十六进制。相同 build 哈希、段选择和限制参数会复用已有 manifest。
 
-只有 dynamic 结果缺少函数 RVA、对象布局或字段类型时，才调用 IDA Pro MCP；没有 IDA 时使用 iced-x86 兜底：
+查看静态数据库状态：
 
 ```powershell
-wowdump analyze disassemble `
-  --exe "D:\Game\World of Warcraft\_retail_\Wow.exe" `
+wowdump database status --build "retail@12.1.0.69587"
+```
+
+验证已有候选 profile：
+
+```powershell
+wowdump analyze runtime `
+  --pid 33976 `
   --build "retail@12.1.0.69587" `
-  --runtime-export "$HOME\.wowdump\runtime\<session-id>\state.json" `
-  --output "$HOME\.wowdump\runtime\<session-id>\retail-12.1.0.69587.profile.json"
+  --kind verify `
+  --profile "$HOME\.wowdump\retail@12.1.0.69587\runtime\candidate.profile.json" `
+  --confirm
+```
+
+`verify` 不负责发现地址；没有 profile 时会直接提示缺少验证目标。
+
+## 静态定位
+
+只有 dynamic 结果缺少函数 RVA、对象布局或字段类型时，才调用 IDA Pro MCP。优先复用 `~/.wowdump/<buildKey>/database/ida/Wow.i64`；runtime manifest 只作为 overlay 证据，不作为独立程序导入。没有 IDA MCP 时使用 iced-x86 对 manifest 指向的局部范围兜底。静态结果保存到当前 session 的 `ida-evidence.json`，候选 profile 保存到 `candidate.profile.json`。
+
+```powershell
+IDA MCP 或 iced-x86 的输出至少包含：函数 RVA、字符串 RVA、XREF、结构偏移、字段类型、调用关系和证据来源。
 ```
 
 ## 读取

package/skills/wowdump/references/disassemble.md

@@ -1,18 +1,52 @@
 # 反汇编与 IDA Pro 分支
 
-静态分析是按需使用的证据放大器，不是每个查询的必经步骤。运行时 text、字节样本、Hook 调用记录或返回值都可以作为输入。先检查当前 Agent 是否能调用本机 IDA Pro MCP：
+静态分析是按需使用的证据放大器，不是每个查询的必经步骤。需要静态证据时，先用 `wowdump analyze runtime --kind dump` 导出运行时 `.text`、`.rdata`、`.pdata` 以及 manifest；`.data` 只有在字段需要运行时全局状态时才通过 `--sections` 加入。原始 Wow.exe 始终是 IDA 的主输入，runtime 二进制只是 overlay 证据。先检查当前 Agent 是否能调用本机 IDA Pro MCP：
+
+## IDA Pro MCP 下载与安装
+
+官方来源：
+
+- GitHub：https://github.com/mrexodia/ida-pro-mcp
+- Hex-Rays 插件页：https://plugins.hex-rays.com/mrexodia/ida-pro-mcp
+
+使用 Codex 时，官方仓库提供插件市场安装方式：
+
+```text
+codex plugin marketplace add mrexodia/codex-marketplace
+codex plugin add ida-pro-mcp@mrexodia
+```
+
+IDA Pro MCP 需要 **IDA Pro 8.3+**（不支持 IDA Free）、Python 3.11+，headless `idalib` 路径还需要 `uv`。安装后重启 IDA 和 Codex，使 MCP 工具生效。若插件市场不可用，按官方仓库 README 的 GUI 或 `idalib-mcp` 安装说明操作；不要在项目中复制或维护 MCP 的内部 Python/IDA 代码。
 
 - 能调用时，让 MCP 只分析当前字段相关样本附近的函数、字符串、调用关系和结构，把结果保存为 JSON。随后回到 dynamic Hook 验证候选函数，不要直接把静态候选当成可读字段。
-- 不能调用时执行：
-
-```powershell
-wowdump analyze disassemble `
-  --exe "C:\Games\World of Warcraft\_retail_\Wow.exe" `
-  --build "retail@VERSION" `
-  --runtime-export "$HOME\.wowdump\runtime\SESSION\text.json" `
-  --output "$HOME\.wowdump\runtime\SESSION\candidate.profile.json"
+
+## IDA MCP 会话保活与重连
+
+IDA 的 headless worker 不是常驻进程。`idb_list` 中仍有 session 记录，不代表对应 worker 仍然可用；查询返回 `Worker for session ... is not reachable` 时，不能继续复用该 session。
+
+打开数据库时使用较长的空闲 TTL，并开启自动分析和缓存：
+
+```json
+{
+  "input_path": "C:\\Games\\World of Warcraft\\_retail_\\Wow.exe",
+  "mode": "prefer_headless",
+  "run_auto_analysis": true,
+  "build_caches": true,
+  "init_hexrays": true,
+  "idle_ttl_sec": 3600
+}
 ```
 
-CLI 使用 `iced-x86` 解码 runtime 样本，返回模块基址、RVA、指令文本、PE sections 和证据。Agent 负责把这些线索与运行时字段对应起来，再用 dynamic 验证 `root`、`pointerChain`、`layout/type`、计数上限和停止条件。不要把一次运行的绝对地址写进持久化 profile。
+每次查询前先调用 `server_health({ database: sessionId })`，确认 `status: "ok"`、`auto_analysis_ready: true`。长查询之间也要做一次 health probe，避免 worker 被回收后才发现会话失效。
+
+失联时只做一次恢复：
+
+1. 丢弃失联的 session ID；如果服务仍列出它，调用 `idb_close`。
+2. 用相同 `input_path` 和 `idle_ttl_sec: 3600` 重新调用 `idb_open`。
+3. 对新 session 做 `server_health`，成功后重试原查询一次。
+4. 第二次仍失联时停止扩大分析范围，保存已取得的 JSON 证据并转用 iced-x86 或请求用户稍后重试。
+
+不要把 `session_id`、IDA 临时 worker PID 或 `0x140000000` 这类 IDA image base 写入持久化 profile。profile 只保存相对模块的 RVA、字段类型和可复核证据。IDA MCP 会话和 wowdump 的 Windows broker 是两条独立链路：前者负责反汇编，后者负责管理员内存读取；broker 复用不会延长 IDA worker 生命周期。
+- IDA 不可用时，Agent 使用 npm 内置的 `iced-x86` 对 manifest 指向的局部 RVA 反汇编，输出模块 RVA、指令文本、访问偏移和证据。Agent 负责把这些线索与运行时字段对应起来，再用 dynamic 验证 `root`、`pointerChain`、`layout/type`、计数上限和停止条件。不要把一次运行的绝对地址写进持久化 profile。
 
 输出中的 `readerStatus: "reader_ready"` 只适用于每个字段都有可验证 RVA/地址、类型和边界，并且 reader 实际读成功的情况；否则保持 `candidate`，回到 dynamic 或继续局部静态分析。只做一次性查询时可以不生成持久化 profile。

package/skills/wowdump/references/evidence-workflow.md

@@ -16,7 +16,7 @@
 
 ## Disassemble（按需使用）
 
-`--runtime-export` 指向 dynamic JSON。只有 dynamic 线索不足以确认函数、布局或类型时才调用 IDA Pro MCP；没有时再用 `analyze disassemble` 的 iced-x86 解码。分析后回到 dynamic 验证。输出 profile 时，每个字段至少给出：
+`analyze runtime --kind dump` 的 `manifest.json` 和段文件是静态分析输入；`--runtime-export` 仍可指向 dynamic JSON。只有 dynamic 线索不足以确认函数、布局或类型时才调用 IDA Pro MCP；没有时再用 iced-x86 解码。分析后回到 dynamic 或 `analyze runtime --kind verify --profile <file>` 验证。输出 profile 时，每个字段至少给出：
 
 ```json
 {

package/skills/wowdump/references/profiles.md

@@ -6,9 +6,20 @@
 
 ```text
 ~/.wowdump/<buildKey>/
-└── profile/                 # 只放用户确认保存的 profile
-    ├── player-state.json
-    └── combat-state.json
+├── build.json
+├── database/
+│   ├── database.json
+│   └── ida/Wow.i64
+├── profile/                 # 只放用户确认保存的 profile
+│   ├── player-state.json
+│   └── combat-state.json
+└── runtime/<session-id>/    # 当前任务证据
+    ├── target.json
+    ├── dynamic.json
+    ├── dump/manifest.json
+    ├── ida-evidence.json
+    ├── candidate.profile.json
+    └── verify.json
 ```
 
 buildKey 只能作为单层目录名使用。保留 `@`、点和连字符；拒绝路径分隔符、`..` 和其他会改变目录层级的字符。不同 build 必须使用不同目录。
@@ -18,7 +29,7 @@ buildKey 只能作为单层目录名使用。保留 `@`、点和连字符；拒
 动态导出、反汇编候选和未确认的 profile 放到本次任务的临时目录，例如：
 
 ```text
-~/.wowdump/runtime/<session-id>/
+~/.wowdump/<buildKey>/runtime/<session-id>/
 ```
 
 它们不是持久化 profile，任务结束后可以清理。不要把候选文件直接写入 `<buildKey>/profile/`。
@@ -29,6 +40,6 @@ buildKey 只能作为单层目录名使用。保留 `@`、点和连字符；拒
 2. 向用户展示候选 profile 的路径、字段和验证结果，询问是否保存为该 build 的持久化 profile。
 3. 用户确认后，将候选复制到 `~/.wowdump/<buildKey>/profile/<profile-id>.json`，保留 `buildKey`、来源和验证证据。
 4. 目标文件已存在时先询问覆盖，或使用新的 profile-id；不要静默覆盖。
-5. 后续读取优先使用这个绝对路径，或用 `wowdump profiles --directory ~/.wowdump/<buildKey>/profile` 列出它。
+5. 后续读取优先使用这个绝对路径，或用 `wowdump profiles --build <buildKey>` 列出它。Reader 只读取 profile，不读取 `database/ida` 和 `runtime/dump/*.bin`。
 
 profile 只对记录的 buildKey 和模块布局有效。发现 buildKey 不匹配时停止读取并重新走分析流程，不修改旧 profile。

package/skills/wowdump/references/request-schema.md

@@ -1,6 +1,6 @@
 # 字段请求格式
 
-先把用户要查的内容写成一个请求文件。字段名是本次任务的目标，不是地址；地址由 dynamic 和 disassemble 阶段产生。
+先把用户要查的内容写成一个请求文件。字段名是本次任务的目标，不是地址；地址由 dynamic 证据和 IDA Pro MCP/iced-x86 局部分析产生。
 
 ```json
 {

package/skills/wowdump/references/workflow.md

@@ -11,6 +11,7 @@
 | --- | --- | --- |
 | 不知道模块/进程 | `wowdump targets` | PID、路径、buildKey、模块基址明确 |
 | 不知道对象或函数是否被调用 | Dynamic GumJS 枚举、有限扫描或 Hook | 得到对象地址、候选函数或调用事件 |
+| 需要给 IDA/iced 模块证据 | `wowdump analyze runtime --kind dump` | 得到默认 `.text`、`.rdata`、`.pdata` 和 manifest；`.data` 仅按需加入 |
 | 有候选函数但不知道其语义 | Dynamic Hook，配合用户触发一次相关动作 | `this`、参数、返回值与目标字段相关 |
 | 有调用但不知道字段偏移/类型 | IDA Pro MCP 局部反汇编；无 IDA 时 iced-x86 | 指令访问行为能解释对象和字段 |
 | 静态候选需要运行时确认 | 回到 Dynamic Hook 或快照 | 候选 RVA 在当前模块命中且数据变化符合预期 |
@@ -20,8 +21,8 @@
 
 1. 先检查是否已有同 build 的 `reader_ready` profile；有则直接 Reader，失败再回到 Dynamic。
 2. 没有 profile 时优先执行 Agent 编写的 GumJS。脚本可以直接 Hook 已知 RVA，也可以在限定范围内扫描候选。
-3. Dynamic 只拿到线索时，再让 IDA Pro MCP 分析对应函数或字节附近区域。不要对整个模块做无目标导出。
-4. 没有 IDA 时使用 `analyze disassemble`/iced-x86 作为局部解码工具，得到候选后仍回到 Dynamic 验证。
+3. Dynamic 只拿到线索时，先用 `analyze runtime --kind dump` 导出当前 session 的相关 PE 段，再让 IDA Pro MCP 复用 build database 分析对应函数、字符串和交叉引用。不要把 dump 当成 profile。
+4. 没有 IDA MCP 时直接使用 iced-x86 对 manifest 指向的局部范围解码，得到候选后仍回到 Dynamic 验证。
 5. 每轮最多扩大一个维度：函数数量、扫描范围、读取字节数或采样时长。连续两轮没有新增证据时，停止扩大并请求用户触发相关游戏动作或确认字段范围。
 
 ## 证据门槛

package/dist/analysis/disassemble.js

@@ -1,77 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { access } from "node:fs/promises";
-import { constants } from "node:fs";
-import { resolve } from "node:path";
-import { Decoder, DecoderOptions, Formatter, FormatterSyntax } from "iced-x86";
-import { inspectPeSections, sha256File } from "../toolchain.js";
-function record(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : {}; }
-function array(value) { return Array.isArray(value) ? value.filter(item => item && typeof item === "object" && !Array.isArray(item)) : []; }
-function hex(value) { if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
-    return BigInt(value); if (typeof value === "string" && /^0x[0-9a-f]+$/i.test(value.trim()))
-    return BigInt(value); return undefined; }
-function hexText(value) { return `0x${value.toString(16)}`; }
-function moduleInfo(runtime) { const module = record(runtime.module); const base = hex(module.moduleBase ?? module.base ?? runtime.moduleBase) ?? 0n; const size = Number(module.moduleSize ?? module.size ?? runtime.moduleSize ?? 0); return { base, size: Number.isFinite(size) ? size : 0, name: String(module.name ?? "Wow.exe") }; }
-function sampleBytes(item) { const value = item.bytesHex ?? item.dataHex; if (typeof value !== "string" || !/^[0-9a-f]*$/i.test(value) || value.length % 2 !== 0)
-    return undefined; return Buffer.from(value, "hex"); }
-function sampleRva(item) { return hex(item.rva) ?? (hex(item.address) !== undefined ? hex(item.address) : undefined); }
-function decodeSamples(runtime, maxInstructions) {
-    const info = moduleInfo(runtime);
-    const samples = [...array(runtime.samples), ...array(runtime.records)];
-    const formatter = new Formatter(FormatterSyntax.Masm);
-    const output = [];
-    let remaining = maxInstructions;
-    for (const sample of samples) {
-        if (remaining <= 0)
-            break;
-        const bytes = sampleBytes(sample);
-        const raw = sampleRva(sample);
-        if (!bytes || raw === undefined)
-            continue;
-        const rva = raw >= info.base && info.base > 0n ? raw - info.base : raw;
-        const ip = info.base + rva;
-        const decoder = new Decoder(64, bytes, DecoderOptions.None);
-        decoder.ip = ip;
-        const instructions = [];
-        while (remaining > 0 && decoder.canDecode) {
-            const instruction = decoder.decode();
-            if (instruction.code === 0)
-                break;
-            instructions.push(formatter.format(instruction));
-            remaining--;
-        }
-        output.push({ rva: hexText(rva), address: hexText(ip), bytesHex: bytes.toString("hex"), instructions, source: "frida-text" });
-    }
-    return output;
-}
-function fieldCandidates(runtime, ida) {
-    const candidates = {};
-    const source = { ...record(runtime.fields), ...record(ida.fields) };
-    for (const [name, value] of Object.entries(source)) {
-        const item = record(value);
-        const rva = item.rva ?? record(item.root).rva;
-        const type = item.type ?? (record(item.layout).type);
-        const layout = item.layout;
-        if (rva !== undefined && (typeof type === "string" || (layout && typeof layout === "object" && !Array.isArray(layout))))
-            candidates[name] = { ...item, root: item.root ?? { rva }, ...(type ? { type } : {}), evidence: [...array(item.evidence), { source: ida && Object.keys(ida).length ? "ida-pro-mcp" : "iced-x86", kind: "runtime-guided" }] };
-    }
-    return candidates;
-}
-export async function runDisassembly(options) {
-    const executable = resolve(options.exe);
-    await access(executable, constants.R_OK);
-    if (!options.buildKey?.trim())
-        throw new Error("buildKey is required");
-    const runtime = record(JSON.parse(await readFile(resolve(options.runtimeExport), "utf8")));
-    const ida = options.idaEvidence ? record(JSON.parse(await readFile(resolve(options.idaEvidence), "utf8"))) : {};
-    const info = moduleInfo(runtime);
-    const decoded = decodeSamples(runtime, Math.min(Math.max(options.maxInstructions ?? 256, 1), 10_000));
-    const sections = inspectPeSections(await readFile(executable));
-    const fields = fieldCandidates(runtime, ida);
-    const ready = Object.keys(fields).length > 0 && Object.values(fields).every(field => { const value = record(field); return value.root !== undefined && (value.type !== undefined || value.layout !== undefined); });
-    const outputFile = resolve(options.output ?? `${executable}.${options.buildKey.replace(/[^A-Za-z0-9_.@-]+/g, "-")}.profile.json`);
-    const profile = { schema: "wowdump.profile.v1", id: `${options.buildKey}-runtime`, buildKey: options.buildKey, readerStatus: ready ? "reader_ready" : "candidate", confidence: ready ? "confirmed" : "candidate", module: { name: info.name, rvaBase: "0x0" }, executable: { path: executable, sha256: await sha256File(executable) }, sections, fields, evidence: [{ source: "frida", kind: "runtime-text", samples: decoded.length }, { source: options.idaEvidence ? "ida-pro-mcp" : "iced-x86", kind: "disassembly", instructions: decoded.length }], analysis: { engine: options.idaEvidence ? "ida-pro-mcp+iced-x86" : "iced-x86", generatedAt: new Date().toISOString() } };
-    const disassembly = { module: { name: info.name, moduleBase: hexText(info.base), moduleSize: info.size }, sections, instructions: decoded, idaEvidence: options.idaEvidence ?? null };
-    if (!options.dryRun)
-        await writeFile(outputFile, `${JSON.stringify(profile, null, 2)}\n`, "utf8");
-    return { ok: true, command: "analyze.disassemble", engine: options.idaEvidence ? "ida-pro-mcp" : "iced-x86", buildKey: options.buildKey, executable, outputFile, profile, disassembly };
-}