windows-exe-decompiler-mcp-server 0.1.0 → 0.1.3

package/README.md

@@ -1,44 +1,43 @@
 # Windows EXE Decompiler MCP Server
 
-中文说明见 [`README_zh.md`](./README_zh.md).
+Chinese version: [`README_zh.md`](./README_zh.md)
 
-An MCP server for Windows binary reverse engineering.
+An MCP server for Windows reverse engineering. It exposes PE triage, Ghidra-backed inspection, DLL/COM profiling, runtime evidence ingestion, Rust/.NET recovery, source-like reconstruction, and LLM-assisted review as reusable MCP tools for any tool-calling LLM.
 
-It exposes PE triage, native and .NET analysis, Ghidra-backed function
-inspection, runtime evidence import, reconstruction workflows, and report
-generation as MCP tools that any tool-calling LLM can consume.
+## What this server is for
 
-## What this project is for
+This project is meant to be a reusable reverse-engineering tool surface, not a pile of one-off local scripts.
 
-This server is designed to provide a reusable reverse-engineering tool surface
-over MCP instead of one-off local scripts.
+It is designed to help MCP clients:
 
-Primary use cases:
+- triage Windows PE samples quickly
+- inspect imports, exports, strings, packers, runtime hints, and binary role
+- use Ghidra when available for decompile, CFG, search, and reconstruction
+- recover usable function indexes when Ghidra function extraction fails
+- correlate static evidence, runtime traces, memory snapshots, and semantic review artifacts
+- export source-like reconstruction output with optional build and harness validation
 
-- Windows PE triage
-- import / export / string / YARA analysis
-- Ghidra-assisted decompile, CFG, and function search
-- .NET metadata inspection
-- runtime trace and memory snapshot import
-- function naming and explanation review workflows
-- source-like reconstruction export with validation harnesses
+## Core capability areas
 
-## Current capability areas
-
-### Static analysis
+### Sample and static analysis
 
 - `sample.ingest`
 - `sample.profile.get`
 - `pe.fingerprint`
 - `pe.imports.extract`
 - `pe.exports.extract`
+- `pe.pdata.extract`
+- `dll.export.profile`
+- `com.role.profile`
 - `strings.extract`
 - `strings.floss.decode`
 - `yara.scan`
 - `runtime.detect`
 - `packer.detect`
+- `binary.role.profile`
+- `system.setup.guide`
 
-### Ghidra and code analysis
+### Ghidra and function analysis
 
 - `ghidra.health`
 - `ghidra.analyze`
@@ -50,18 +49,19 @@ Primary use cases:
 - `code.function.cfg`
 - `code.functions.reconstruct`
 
-### Reconstruction and review workflows
+### Recovery for Rust and hard native samples
+
+- `code.functions.smart_recover`
+- `pe.symbols.recover`
+- `code.functions.define`
+- `rust_binary.analyze`
+- `workflow.function_index_recover`
+
+### .NET and managed inspection
 
-- `code.reconstruct.plan`
-- `code.reconstruct.export`
 - `dotnet.metadata.extract`
 - `dotnet.types.list`
 - `dotnet.reconstruct.export`
-- `workflow.triage`
-- `workflow.deep_static`
-- `workflow.reconstruct`
-- `workflow.semantic_name_review`
-- `workflow.function_explanation_review`
 
 ### Runtime evidence and reporting
 
@@ -78,6 +78,155 @@ Primary use cases:
 - `artifacts.diff`
 - `tool.help`
 
+### Semantic review and reconstruction
+
+- `code.function.rename.prepare`
+- `code.function.rename.review`
+- `code.function.rename.apply`
+- `code.function.explain.prepare`
+- `code.function.explain.review`
+- `code.function.explain.apply`
+- `code.module.review.prepare`
+- `code.module.review`
+- `code.module.review.apply`
+- `code.reconstruct.plan`
+- `code.reconstruct.export`
+
+## High-level workflows
+
+These are the main orchestration entrypoints for MCP clients.
+
+### `workflow.triage`
+
+Fast first-pass triage for PE samples. Use this when you want a quick answer before deeper recovery.
+
+### `workflow.deep_static`
+
+Long-running static pipeline for deeper analysis and ranking. Supports async job mode.
+
+### `workflow.reconstruct`
+
+The main high-level reconstruction workflow.
+
+It can:
+
+- run binary preflight
+- detect Rust-oriented samples
+- profile DLL lifecycle, export dispatch, callback surface, and COM activation hints
+- auto-recover a function index when Ghidra function extraction is missing or degraded
+- export native or .NET reconstruction output
+- optionally validate build and run the generated harness
+- tune export strategy based on role-aware preflight for native Rust, DLL, and COM-oriented samples
+- carry runtime and semantic provenance through the result
+
+### `workflow.function_index_recover`
+
+High-level recovery chain for hard native binaries:
+
+- `code.functions.smart_recover`
+- `pe.symbols.recover`
+- `code.functions.define`
+
+Use this when Ghidra analysis exists but function extraction is empty or degraded.
+
+### `workflow.semantic_name_review`
+
+High-level semantic naming review workflow for external LLM clients. It can prepare evidence, request model review through MCP sampling when available, apply accepted names, and optionally refresh reconstruct/export output.
+
+### `workflow.function_explanation_review`
+
+High-level explanation workflow for external LLM clients. It can prepare evidence, request structured explanations, apply them, and optionally rerun reconstruct/export.
+
+### `workflow.module_reconstruction_review`
+
+High-level module review workflow for external LLM clients. It can prepare reconstructed modules for review, request structured module refinements through MCP sampling when available, apply accepted module summaries and guidance, and optionally refresh reconstruct/export output.
+
+## Universal recovery model
+
+This server does not assume Ghidra is always able to recover functions correctly.
+
+For difficult native samples, especially Rust, Go, or heavily optimized binaries, the recovery path is:
+
+1. `ghidra.analyze`
+2. if Ghidra post-script extraction fails, use `pe.pdata.extract`
+3. recover candidate function boundaries with `code.functions.smart_recover`
+4. recover names with `pe.symbols.recover`
+5. import the recovered boundaries with `code.functions.define`
+6. continue with `code.functions.list`, `code.functions.rank`, `code.functions.reconstruct`, or `workflow.reconstruct`
+
+This means `function_index` readiness is tracked separately from `decompile` and `cfg` readiness.
+
+## Evidence scope, semantic scope, and replayability
+
+Most high-level tools support explicit scope control so clients can choose between all history and the current session.
+
+Runtime evidence selection:
+
+- `evidence_scope=all`
+- `evidence_scope=latest`
+- `evidence_scope=session` with `evidence_session_tag`
+
+Semantic naming / explanation / module-review selection:
+
+- `semantic_scope=all`
+- `semantic_scope=latest`
+- `semantic_scope=session` with `semantic_session_tag`
+
+Comparison-aware outputs are also supported through:
+
+- `compare_evidence_scope`
+- `compare_evidence_session_tag`
+- `compare_semantic_scope`
+- `compare_semantic_session_tag`
+
+This allows MCP clients to ask not only "what is the current result?" but also "what changed compared with the previous evidence or semantic review session?"
+
+## LLM review layers
+
+This server supports multiple structured review layers for MCP clients with tool calling and optional sampling:
+
+- function naming review
+- function explanation review
+- module reconstruction review
+
+Each layer follows the same pattern:
+
+1. prepare a structured evidence bundle
+2. optionally ask the connected MCP client to perform a constrained review through sampling
+3. apply accepted results as stable semantic artifacts
+4. rerun reconstruct/export/report workflows against explicit semantic scope
+
+## Async job model
+
+Long-running workflows support queued execution and background completion:
+
+- `workflow.deep_static`
+- `workflow.reconstruct`
+- `workflow.semantic_name_review`
+- `workflow.function_explanation_review`
+- `workflow.module_reconstruction_review`
+
+Use these with:
+
+- `task.status`
+- `task.cancel`
+- `task.sweep`
+
+## Environment bootstrap and setup guidance
+
+If a client starts using the server before Python, dynamic-analysis extras, or Ghidra are configured, use:
+
+- `system.health`
+- `dynamic.dependencies`
+- `ghidra.health`
+- `system.setup.guide`
+
+These return structured setup actions and required user inputs so an MCP client can explicitly ask for:
+
+- `python -m pip install ...`
+- `GHIDRA_PATH` / `GHIDRA_INSTALL_DIR`
+- optional dynamic-analysis extras such as Speakeasy/Frida dependencies
+
 ## Project layout
 
 ```text
@@ -90,6 +239,8 @@ tests/                       unit and integration tests
 workers/                     Python worker, YARA rules, dynamic helpers
 install-to-codex.ps1         local Codex MCP install helper
 install-to-copilot.ps1       local GitHub Copilot MCP install helper
+install-to-claude.ps1        local Claude Code MCP install helper
+docs/QUALITY_EVALUATION.md   evaluation checklist for regression and release readiness
 ```
 
 ## Prerequisites
@@ -108,7 +259,7 @@ Optional but strongly recommended:
 - Python packages from [`requirements.txt`](./requirements.txt)
 - Python worker packages from [`workers/requirements.txt`](./workers/requirements.txt)
 
-## Local development setup
+## Local development
 
 Install JavaScript dependencies:
 
@@ -124,7 +275,7 @@ python -m pip install -r workers/requirements.txt
 python -m pip install -r workers/requirements-dynamic.txt
 ```
 
-Build the server:
+Build:
 
 ```bash
 npm run build
@@ -136,7 +287,7 @@ Run tests:
 npm test
 ```
 
-Start the server locally:
+Start locally:
 
 ```bash
 npm start
@@ -146,8 +297,6 @@ npm start
 
 ### Generic stdio config
 
-Most MCP clients can start this server with:
-
 ```json
 {
   "mcpServers": {
@@ -166,19 +315,32 @@ Most MCP clients can start this server with:
 
 ### Local install helpers
 
-This repository already includes local install scripts:
-
 - Codex: [`install-to-codex.ps1`](./install-to-codex.ps1)
+- Claude Code: [`install-to-claude.ps1`](./install-to-claude.ps1)
 - GitHub Copilot: [`install-to-copilot.ps1`](./install-to-copilot.ps1)
 
 Related docs:
 
 - [`CODEX_INSTALLATION.md`](./CODEX_INSTALLATION.md)
 - [`COPILOT_INSTALLATION.md`](./COPILOT_INSTALLATION.md)
+- [`CLAUDE_INSTALLATION.md`](./CLAUDE_INSTALLATION.md)
+
+## Persistent storage
+
+By default, runtime state is stored under the user profile instead of the current working directory:
+
+- Windows workspace root: `%USERPROFILE%/.windows-exe-decompiler-mcp-server/workspaces`
+- SQLite database: `%USERPROFILE%/.windows-exe-decompiler-mcp-server/data/database.db`
+- File cache: `%USERPROFILE%/.windows-exe-decompiler-mcp-server/cache`
+- Audit log: `%USERPROFILE%/.windows-exe-decompiler-mcp-server/audit.log`
+
+You can override these with environment variables or the user config file:
+
+- `%USERPROFILE%/.windows-exe-decompiler-mcp-server/config.json`
 
 ## Sample ingest note
 
-For local IDE clients such as VS Code or Copilot, prefer:
+For local IDE clients such as VS Code or Copilot, prefer local file paths:
 
 ```json
 {
@@ -189,23 +351,20 @@ For local IDE clients such as VS Code or Copilot, prefer:
 }
 ```
 
-Use `bytes_b64` only when the MCP client cannot access the same filesystem as
-the MCP server.
+Use `bytes_b64` only when the client cannot access the same filesystem as the server.
 
 ## Publishing to npm
 
-### What is included in the npm package
-
 The published package includes:
 
 - compiled `dist/`
-- a CLI entrypoint in `bin/`
+- the CLI entrypoint in `bin/`
 - Python workers and YARA rules
 - Ghidra helper scripts
 - the .NET metadata helper source
 - MCP client install scripts
 
-It intentionally excludes:
+It excludes:
 
 - tests
 - local workspaces
@@ -213,68 +372,49 @@ It intentionally excludes:
 - generated reports
 - scratch documents and internal progress notes
 
-### Pre-publish checklist
-
-1. Pick a package name that is available on npm.
-2. Update the version in [`package.json`](./package.json).
-3. Run:
-
-```bash
-npm run release:check
-```
-
-4. Inspect the dry-run pack list:
-
-```bash
-npm run pack:dry-run
-```
-
-5. Log in to npm:
-
-```bash
-npm login
-```
-
-6. Publish:
+Pre-publish checklist:
 
-```bash
-npm publish
-```
-
-### GitHub Actions
-
-This repository now includes:
+1. Update the version in [`package.json`](./package.json).
+2. Run `npm run release:check`.
+3. Inspect `npm run pack:dry-run`.
+4. Log in with `npm login`.
+5. Publish with `npm publish --access public`.
 
-- [`ci.yml`](./.github/workflows/ci.yml): build, Python syntax check, key unit tests, and `npm pack --dry-run`
-- [`publish-npm.yml`](./.github/workflows/publish-npm.yml): publish on `v*` tags or manual dispatch, then create a GitHub Release with the npm tarball attached
-- [`dependabot.yml`](./.github/dependabot.yml): weekly npm and GitHub Actions dependency updates
+GitHub automation included in this repository:
 
-Before npm publishing from GitHub Actions, add this repository secret:
+- [`ci.yml`](./.github/workflows/ci.yml)
+- [`publish-npm.yml`](./.github/workflows/publish-npm.yml)
+- [`dependabot.yml`](./.github/dependabot.yml)
 
-- `NPM_TOKEN`
+For GitHub Actions publishing, configure the `NPM_TOKEN` repository secret.
 
-Recommended release flow:
+## Security boundaries
 
-```bash
-npm version patch
-git push origin main --follow-tags
-```
+This project is for analysis workflows, not live malware operations.
 
-That tag push will trigger the publish workflow.
+Current strengths:
 
-## Contributing
+- PE triage and classification support
+- reverse-engineering evidence extraction
+- IOC and ATT&CK export
+- runtime evidence import and correlation
+- source-like reconstruction and review
 
-See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for local
-setup, validation, and release steps.
+Current non-goals:
 
-## Security
+- original source recovery for complex native binaries
+- guaranteed malware family attribution from static evidence alone
+- fully automatic unpacking for every packer
+- high-confidence semantic recovery of every function in heavily optimized code
 
-See [`SECURITY.md`](./SECURITY.md) for disclosure guidance
-and operational boundaries.
+## Contributing and release process
 
-### Using the published package
+- Contributor guide: [`CONTRIBUTING.md`](./CONTRIBUTING.md)
+- Quality evaluation notes: [`docs/QUALITY_EVALUATION.md`](./docs/QUALITY_EVALUATION.md)
+- Example benchmark corpus: [`examples/benchmark-corpus.example.json`](./examples/benchmark-corpus.example.json)
+- Security policy: [`SECURITY.md`](./SECURITY.md)
 
-Once published, an MCP client can use `npx`:
+## Using the published package
 
 ```json
 {
@@ -291,24 +431,6 @@ Once published, an MCP client can use `npx`:
 }
 ```
 
-## Security boundaries
-
-This project is designed for analysis workflows, not for live malware
-operations. Current practical strengths are:
-
-- triage and classification support
-- reverse-engineering evidence extraction
-- IOC and ATT&CK export
-- runtime evidence import and correlation
-- source-like reconstruction and review
-
-Current non-goals:
-
-- original source recovery for complex native binaries
-- guaranteed malware family attribution from static evidence alone
-- full automatic unpacking for all packers
-- high-confidence semantic recovery of every function in heavily optimized code
-
 ## License
 
-This project is released under the MIT license. See [`LICENSE`](./LICENSE).
+Released under the MIT license. See [`LICENSE`](./LICENSE).

package/dist/analysis-provenance.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { DynamicEvidenceScope, DynamicTraceSummary } from './dynamic-trace.js';
-import type { SemanticArtifactScope, SemanticFunctionExplanationIndex, SemanticNameSuggestionIndex } from './semantic-name-suggestion-artifacts.js';
+import type { SemanticArtifactScope, SemanticFunctionExplanationIndex, SemanticModuleReviewIndex, SemanticNameSuggestionIndex } from './semantic-name-suggestion-artifacts.js';
 export declare const ArtifactSelectionProvenanceSchema: z.ZodObject<{
     scope: z.ZodEnum<["all", "latest", "session"]>;
     session_selector: z.ZodNullable<z.ZodString>;
@@ -114,6 +114,34 @@ export declare const AnalysisProvenanceSchema: z.ZodObject<{
         earliest_artifact_at: string | null;
         latest_artifact_at: string | null;
     }>>;
+    semantic_module_reviews: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<["all", "latest", "session"]>;
+        session_selector: z.ZodNullable<z.ZodString>;
+        artifact_count: z.ZodNumber;
+        artifact_ids: z.ZodArray<z.ZodString, "many">;
+        session_tags: z.ZodArray<z.ZodString, "many">;
+        earliest_artifact_at: z.ZodNullable<z.ZodString>;
+        latest_artifact_at: z.ZodNullable<z.ZodString>;
+        scope_note: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        artifact_count: number;
+        scope_note: string;
+        artifact_ids: string[];
+        session_selector: string | null;
+        session_tags: string[];
+        scope: "all" | "latest" | "session";
+        earliest_artifact_at: string | null;
+        latest_artifact_at: string | null;
+    }, {
+        artifact_count: number;
+        scope_note: string;
+        artifact_ids: string[];
+        session_selector: string | null;
+        session_tags: string[];
+        scope: "all" | "latest" | "session";
+        earliest_artifact_at: string | null;
+        latest_artifact_at: string | null;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     runtime: {
         artifact_count: number;
@@ -125,6 +153,16 @@ export declare const AnalysisProvenanceSchema: z.ZodObject<{
         earliest_artifact_at: string | null;
         latest_artifact_at: string | null;
     };
+    semantic_module_reviews?: {
+        artifact_count: number;
+        scope_note: string;
+        artifact_ids: string[];
+        session_selector: string | null;
+        session_tags: string[];
+        scope: "all" | "latest" | "session";
+        earliest_artifact_at: string | null;
+        latest_artifact_at: string | null;
+    } | undefined;
     semantic_names?: {
         artifact_count: number;
         scope_note: string;
@@ -156,6 +194,16 @@ export declare const AnalysisProvenanceSchema: z.ZodObject<{
         earliest_artifact_at: string | null;
         latest_artifact_at: string | null;
     };
+    semantic_module_reviews?: {
+        artifact_count: number;
+        scope_note: string;
+        artifact_ids: string[];
+        session_selector: string | null;
+        session_tags: string[];
+        scope: "all" | "latest" | "session";
+        earliest_artifact_at: string | null;
+        latest_artifact_at: string | null;
+    } | undefined;
     semantic_names?: {
         artifact_count: number;
         scope_note: string;
@@ -179,6 +227,6 @@ export declare const AnalysisProvenanceSchema: z.ZodObject<{
 }>;
 type ArtifactSelectionProvenance = z.infer<typeof ArtifactSelectionProvenanceSchema>;
 export declare function buildRuntimeArtifactProvenance(dynamicEvidence: DynamicTraceSummary | null | undefined, scope: DynamicEvidenceScope, sessionTag?: string | null): ArtifactSelectionProvenance;
-export declare function buildSemanticArtifactProvenance(label: 'semantic naming artifacts' | 'semantic explanation artifacts', index: SemanticNameSuggestionIndex | SemanticFunctionExplanationIndex | null | undefined, scope: SemanticArtifactScope, sessionTag?: string | null): ArtifactSelectionProvenance;
+export declare function buildSemanticArtifactProvenance(label: 'semantic naming artifacts' | 'semantic explanation artifacts' | 'semantic module review artifacts', index: SemanticNameSuggestionIndex | SemanticFunctionExplanationIndex | SemanticModuleReviewIndex | null | undefined, scope: SemanticArtifactScope, sessionTag?: string | null): ArtifactSelectionProvenance;
 export {};
 //# sourceMappingURL=analysis-provenance.d.ts.map

package/dist/analysis-provenance.js

@@ -13,6 +13,7 @@ export const AnalysisProvenanceSchema = z.object({
     runtime: ArtifactSelectionProvenanceSchema,
     semantic_names: ArtifactSelectionProvenanceSchema.optional(),
     semantic_explanations: ArtifactSelectionProvenanceSchema.optional(),
+    semantic_module_reviews: ArtifactSelectionProvenanceSchema.optional(),
 });
 function emptyScopeNote(label, scope, sessionTag) {
     if (scope === 'session' && sessionTag?.trim()) {

package/dist/analysis-task-runner.js

@@ -5,6 +5,10 @@
 import { DecompilerWorker, GhidraProcessError } from './decompiler-worker.js';
 import { logger } from './logger.js';
 import { deepStaticWorkflow } from './workflows/deep-static.js';
+import { createReconstructWorkflowHandler } from './workflows/reconstruct.js';
+import { createSemanticNameReviewWorkflowHandler } from './workflows/semantic-name-review.js';
+import { createFunctionExplanationReviewWorkflowHandler } from './workflows/function-explanation-review.js';
+import { createModuleReconstructionReviewWorkflowHandler } from './workflows/module-reconstruction-review.js';
 export class AnalysisTaskRunner {
     jobQueue;
     decompilerWorker;
@@ -120,6 +124,10 @@ export class AnalysisTaskRunner {
                     timeout: job.timeout,
                     maxCpu: options.max_cpu || '4',
                     projectKey: options.project_key,
+                    processor: options.processor,
+                    languageId: options.language_id,
+                    cspec: options.cspec,
+                    scriptPaths: options.script_paths,
                     abortSignal,
                 });
                 return this.decompilerWorker.createJobResult(analysisResult, 0);
@@ -154,6 +162,90 @@ export class AnalysisTaskRunner {
                 },
             };
         }
+        if (job.tool === 'workflow.reconstruct') {
+            if (!this.cacheManager) {
+                throw new Error('workflow.reconstruct requires cache manager for queued execution');
+            }
+            this.jobQueue.updateProgress(job.id, 5);
+            const handler = createReconstructWorkflowHandler(this.workspaceManager, this.database, this.cacheManager);
+            const result = await handler(job.args || {});
+            this.jobQueue.updateProgress(job.id, 100);
+            return {
+                jobId: job.id,
+                ok: result.ok,
+                data: result.data,
+                errors: result.errors || [],
+                warnings: result.warnings || [],
+                artifacts: result.artifacts || [],
+                metrics: {
+                    elapsedMs: typeof result.metrics?.elapsed_ms === 'number' ? result.metrics.elapsed_ms : 0,
+                    peakRssMb: 0,
+                },
+            };
+        }
+        if (job.tool === 'workflow.semantic_name_review') {
+            if (!this.cacheManager) {
+                throw new Error('workflow.semantic_name_review requires cache manager for queued execution');
+            }
+            this.jobQueue.updateProgress(job.id, 5);
+            const handler = createSemanticNameReviewWorkflowHandler(this.workspaceManager, this.database, this.cacheManager);
+            const result = await handler(job.args || {});
+            this.jobQueue.updateProgress(job.id, 100);
+            return {
+                jobId: job.id,
+                ok: result.ok,
+                data: result.data,
+                errors: result.errors || [],
+                warnings: result.warnings || [],
+                artifacts: result.artifacts || [],
+                metrics: {
+                    elapsedMs: typeof result.metrics?.elapsed_ms === 'number' ? result.metrics.elapsed_ms : 0,
+                    peakRssMb: 0,
+                },
+            };
+        }
+        if (job.tool === 'workflow.function_explanation_review') {
+            if (!this.cacheManager) {
+                throw new Error('workflow.function_explanation_review requires cache manager for queued execution');
+            }
+            this.jobQueue.updateProgress(job.id, 5);
+            const handler = createFunctionExplanationReviewWorkflowHandler(this.workspaceManager, this.database, this.cacheManager);
+            const result = await handler(job.args || {});
+            this.jobQueue.updateProgress(job.id, 100);
+            return {
+                jobId: job.id,
+                ok: result.ok,
+                data: result.data,
+                errors: result.errors || [],
+                warnings: result.warnings || [],
+                artifacts: result.artifacts || [],
+                metrics: {
+                    elapsedMs: typeof result.metrics?.elapsed_ms === 'number' ? result.metrics.elapsed_ms : 0,
+                    peakRssMb: 0,
+                },
+            };
+        }
+        if (job.tool === 'workflow.module_reconstruction_review') {
+            if (!this.cacheManager) {
+                throw new Error('workflow.module_reconstruction_review requires cache manager for queued execution');
+            }
+            this.jobQueue.updateProgress(job.id, 5);
+            const handler = createModuleReconstructionReviewWorkflowHandler(this.workspaceManager, this.database, this.cacheManager);
+            const result = await handler(job.args || {});
+            this.jobQueue.updateProgress(job.id, 100);
+            return {
+                jobId: job.id,
+                ok: result.ok,
+                data: result.data,
+                errors: result.errors || [],
+                warnings: result.warnings || [],
+                artifacts: result.artifacts || [],
+                metrics: {
+                    elapsedMs: typeof result.metrics?.elapsed_ms === 'number' ? result.metrics.elapsed_ms : 0,
+                    peakRssMb: 0,
+                },
+            };
+        }
         throw new Error(`Unsupported queued tool: ${job.tool}`);
     }
 }