# Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen (npm · @slp-dev1/qwen-dap-mcp) C/C++ crash, hang and dump debugging for Claude Code, Codex and Qwen via GDB, LLDB and MCP - Trust score: 80/100 (high trust) - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-11-05 ## Components - npm · `@slp-dev1/qwen-dap-mcp`: 80/100 (this document), [markdown](https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp.md), [page](https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp) ## Channel facts - Registry: `npm` - Package: `@slp-dev1/qwen-dap-mcp` - Version: `0.19.4` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-05. - **Supply Chain Security**: 98/100 - No malware found by supply-chain analysis. - No known CVEs affecting this package version or its production dependencies. - No install/post-install scripts declared. - 1 of 4 dependencies flagged as unhealthy. - **Provenance & Transparency**: 100/100 - Source repository is publicly reachable at the declared URL. - Cryptographically verified build provenance (signed, bound to spk-c/Qwen-dap-mcp). - Clear OSI-approved license (Apache-2.0). - Actively maintained (last published 1 days ago). - Publishes a security disclosure policy (SECURITY.md). - **Schema Quality & AI Usability**: 63/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 6238 tokens (~346/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 10/100 - Stability observed for 3 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (100% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - We read all 18 captured tool definition(s), and no name or description among them implies an irreversible operation. - An AI judge read all 19 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a current MCP spec version (2026-07-28). ## Install ### How do I install the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen runs locally as an npm package, launched with npx -y @slp-dev1/qwen-dap-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add spk-c-qwen-dap-mcp -- npx -y @slp-dev1/qwen-dap-mcp ``` ### Cursor ```json { "mcpServers": { "spk-c-qwen-dap-mcp": { "command": "npx", "args": [ "-y", "@slp-dev1/qwen-dap-mcp" ] } } } ``` ### VS Code ```json { "servers": { "spk-c-qwen-dap-mcp": { "command": "npx", "args": [ "-y", "@slp-dev1/qwen-dap-mcp" ] } } } ``` ### Codex ```bash codex mcp add spk-c-qwen-dap-mcp -- npx -y @slp-dev1/qwen-dap-mcp ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "spk-c-qwen-dap-mcp": { "type": "local", "command": [ "npx", "-y", "@slp-dev1/qwen-dap-mcp" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add spk-c-qwen-dap-mcp --command npx --arg -y --arg @slp-dev1/qwen-dap-mcp ``` ### Hermes ```yaml mcp_servers: spk-c-qwen-dap-mcp: command: "npx" args: ["-y", "@slp-dev1/qwen-dap-mcp"] ``` ### Netclaw ```json { "McpServers": { "spk-c-qwen-dap-mcp": { "Transport": "stdio", "Command": "npx", "Arguments": [ "-y", "@slp-dev1/qwen-dap-mcp" ] } } } ``` ### Vellum ```bash assistant mcp add spk-c-qwen-dap-mcp -t stdio -c npx -a -y @slp-dev1/qwen-dap-mcp ``` ### Other ```json { "mcpServers": { "spk-c-qwen-dap-mcp": { "command": "npx", "args": [ "-y", "@slp-dev1/qwen-dap-mcp" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-04 (score 80, +16) - [security improvement] Malware scan: unverified → pass ### 2026-11-03 (score 64, +11) - [security improvement] Malware scan: unverified → pass - [security improvement] Known CVEs: unverified → pass - [functional improvement] Stability: unverified → 0.03 - [functional improvement] Dependency health: unverified → 0.86 - [functional] Package version: 0.19.3 → 0.19.4 ### 2026-11-02 (score 53) First indexed and scored. ## MCP tools (18) ### `debug_sessions` (~140 tokens) Manage Debug Sessions Use this tool to list, create, or close isolated DAP sessions before routing other debugger tools with sessionId. Omit sessionId on normal debug tools only when the backward-compatible default session is intended; do not use a global session selector for concurrent work. Input parameters: - `action` (string): Management action: list current sessions, create a new isolated session, or close one session. - `sessionId` (string): Requested ID for create, or target ID for close. Omit on create to generate a bounded session-N identifier. - `terminateDebuggee` (boolean): For close only: request debugger termination of the live target before resetting/removing the session. Output parameters: - `action` (string) - `defaultSessionId` (string) - `maxSessions` (integer) - `removed` (boolean) - `sessionId` (string) - `sessions` (array) ### `debug_compare_runs` (~182 tokens) Compare bounded runtime evidence from two existing stopped DAP sessions. Use this for baseline or known-good versus candidate or failing differential debugging after both sessions have reached comparable stops. It compares stack identities, locals, registers, exception state, symbol health, and modules semantically; non-null raw address-only changes are marked unstable rather than causal evidence. Do not use it to launch, resume, or alter either target; prepare both runtime states with the normal lifecycle tools first. Input parameters: - `baselineSessionId` (string, required): Session representing the known-good or baseline runtime state. - `candidateSessionId` (string, required): Session representing the failing or changed runtime state. - `snapshot` (object): Bounded evidence capture settings applied independently to both sessions. - `timeoutMs` (integer): Aggregate deadline for collecting both snapshots. Cancellation propagates to pending DAP requests/event waits in this operation context. Output parameters: - `baseline` (object) - `baselineSessionId` (string) - `candidate` (object) - `candidateSessionId` (string) - `diff` (object) - `evidenceBudget` (object) - `guidance` (array) ### `debug_snapshot` (~305 tokens) Capture Runtime Debug Snapshot Capture bounded evidence from the current stopped debug state without resuming execution. Use this when an agent needs raw stack, locals, registers, exception details, modules, or nearby instructions; prefer debug_diagnose_stop when you also want ranked crash hypotheses and project-frame selection. This is read-only with respect to the debuggee and returns best-effort evidence plus collection errors for optional data that an adapter cannot provide. Input parameters: - `disassembleAfter` (integer): Number of instructions after the current instruction to request when disassembly is enabled. - `disassembleBefore` (integer): Number of instructions before the current instruction to request when disassembly is enabled. - `includeDisassembly` (boolean): Include best-effort instructions around the selected frame instruction pointer when supported. - `includeExceptionInfo` (boolean): Include structured exception information for the stopped thread when the adapter supports it. - `includeModules` (boolean): Include a bounded list of loaded executable images and libraries. - `maxVariablesPerScope` (integer): Maximum variables returned per inspected scope, bounding output size. - `moduleCount` (integer): Maximum loaded modules to return when includeModules is true. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `stackLevels` (integer): Maximum number of stack frames to include, from the selected thread top downward. - `threadId` (integer): Stopped DAP thread to inspect; omit to use the session-selected stopped thread. Output parameters: - `collectionErrors` (array) - `disassembly` (array) - `exception` - `frame` (object) - `locals` (array) - `modules` (array) - `postmortem` (boolean) - `registers` (array) - `scopes` (array) - `stack` (array) - `stopped` - `symbolHealth` (object) - `thread` (object) ### `debug_status` (~78 tokens) Debug Session Status Inspect debugger lifecycle state, the selected stop, recent DAP events, and bounded adapter stderr without changing target execution. Use this to determine whether a session is initialized, running, stopped, postmortem, exited, or failed before choosing another debug tool; it is diagnostic only and does not resume, launch, attach, or terminate the debuggee. Output parameters: - `activeRequest` (string) - `adapterId` (string) - `adapterPid` (integer) - `adapterRunning` (boolean) - `capabilities` (object) - `configured` (boolean) - `initialized` (boolean) - `recentAdapterStderr` (array) - `recentEvents` (array) ### `debug_disconnect` (~135 tokens) Disconnect Debugger End the active DAP session and stop its local adapter process. Use this when debugging is finished or the session must be reset; do not call it when more runtime evidence is still needed. With terminateDebuggee=true it may also terminate a live target process, so this operation can destroy the current runtime state and cannot be treated as read-only. Input parameters: - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `terminateDebuggee` (boolean): Whether the debugger should terminate the live debuggee while disconnecting; set false to request detach/preserve behavior when the adapter supports it. Output parameters: - `disconnected` (boolean) ### `debug_run_to_stop` (~250 tokens) Run Until Debug Stop or Exit Run one live launch or attach through an already initialized DAP adapter until the first stopped, exited, or terminated event. Use this when you need deterministic runtime evidence from a reproduction; do not use it for a postmortem dump or when executing/attaching to the local target is not authorized. Launch mode executes application code and attach mode changes debugger control of an existing process, so normal target side effects may occur before the stop. Returns the request result, terminal/stopped outcome, session status, and a bounded snapshot only when a stopped event is captured. Input parameters: - `breakpoints` (array): Optional source breakpoint groups configured before the debugger completes launch/attach setup. - `configuration` (object, required): Adapter-specific DAP launch or attach configuration. - `request` (string): Choose launch to start a new target from configuration, or attach to connect to an existing authorized local target. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `snapshot` (object): Optional bounds and evidence categories for the snapshot captured only when execution stops. - `timeoutMs` (integer): Maximum milliseconds to wait for the first stopped, exited, or terminated event. Output parameters: - `outcome` (object) - `request` (string) - `requestResult` - `snapshot` (object) - `status` ### `debug_diagnose_stop` (~329 tokens) Diagnose Current Debug Stop Diagnose an already stopped live or postmortem debug session without changing execution state. Use this when a debugger has captured the failure and you want project-frame selection, crash classification, operand/register/variable bindings, call-chain provenance, ranked hypotheses, and a fix/rebuild/reproduce/verify plan; use debug_snapshot instead when only raw evidence is needed. The tool is read-only and returns both the bounded snapshot and the derived diagnosis, including collection limitations when optional debugger evidence is unavailable. Input parameters: - `analysis` (object): Hints used to distinguish project code from runtime, system, or third-party frames. - `disassembleAfter` (integer): Number of instructions after the selected instruction to request. - `disassembleBefore` (integer): Number of instructions before the selected instruction to request. - `includeDisassembly` (boolean): Include best-effort disassembly around the selected instruction pointer when supported. - `includeExceptionInfo` (boolean): Request structured exception information for the stopped thread when supported. - `includeModules` (boolean): Include a bounded list of loaded executable images and libraries. - `maxVariablesPerScope` (integer): Maximum variables returned per inspected scope, bounding evidence size. - `moduleCount` (integer): Maximum loaded modules to include when module collection is enabled. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `stackLevels` (integer): Maximum number of stack frames to inspect when collecting crash evidence. - `threadId` (integer): Stopped DAP thread to inspect; omit to use the session-selected stopped thread. Output parameters: - `diagnosis` - `snapshot` (object) ### `debug_source_disassembly` (~231 tokens) Correlate Source and Disassembly Correlate source locations, disassembly, registers, and pointer-like locals for the raw fault frame and the first likely project-controlled frame. Use this for low-level root-cause evidence when a crash is already stopped and instruction/operand provenance matters; prefer debug_diagnose_stop for a broader ranked diagnosis. This is read-only, does not resume the target, and returns frame-selection reasoning, both correlations, operand bindings, and any best-effort collection errors. Input parameters: - `analysis` (object): Hints used to distinguish project code from runtime, system, or third-party frames. - `disassembleAfter` (integer): Instructions after the selected instruction included in each disassembly window. - `disassembleBefore` (integer): Instructions before the selected instruction included in each disassembly window. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `stackLevels` (integer): Maximum stack frames considered while selecting the project-controlled frame. - `threadId` (integer): Stopped DAP thread to inspect; omit to use the session-selected stopped thread. Output parameters: - `collectionErrors` (array) - `faultCorrelation` - `frameSelection` - `operandAnalysis` - `projectCorrelation` - `projectFrame` (object) ### `debug_this_crash` (~711 tokens) Debug This Crash Preferred high-level native crash workflow. Use mode=current for an already stopped session, dump for read-only postmortem analysis, codelldb to discover CodeLLDB, lldb-dap to discover upstream LLVM lldb-dap, gdb to discover GNU GDB built-in DAP interpreter, or live with an already initialized generic DAP adapter. Do not use codelldb/lldb-dap/gdb/live when executing or attaching to the target is not authorized: those modes can run application code and cause its normal side effects, while current/dump only inspect stopped evidence. workflow.stage selects initial diagnosis, verification against a prior baseline, or the bounded autonomous cycle. Returns runtime evidence, diagnosis, verification/autonomous metadata, and debugger status with deterministic fixed/blocked/budget-exhausted outcomes where applicable. Input parameters: - `adapterPath` (string): Optional explicit debugger executable/adapter path for codelldb/lldb-dap/gdb/dump modes; omit to auto-discover the selected adapter. - `analysis` (object): Hints used to distinguish project code from runtime, system, or third-party frames. - `args` (array): Command-line arguments passed to the launched program in codelldb/lldb-dap/gdb modes. - `breakpoints` (array): Optional source breakpoints configured before a live/codelldb reproduction completes setup. - `configuration` (object): Required for mode=live: adapter-specific DAP launch/attach configuration. - `cwd` (string): Working directory for the selected debugger/target launch and a project-root hint for diagnosis. - `dumpAdapter` (string): For mode=dump, choose CodeLLDB, upstream LLVM lldb-dap coreFile loading, or GNU GDB coreFile attach semantics. - `dumpPath` (string): Required for mode=dump: local path to the native core/minidump file. - `env` (object): Environment variables supplied to the launched program in codelldb/lldb-dap/gdb modes. - `mode` (string): current inspects an existing stop; live uses an initialized generic DAP session; codelldb starts CodeLLDB; lldb-dap starts upstream LLVM lldb-dap; gdb starts GNU GDB with --interpreter=dap; dump open… - `program` (string): Required for codelldb/lldb-dap/gdb launch modes; optional for CodeLLDB/GDB dumps but required when dumpAdapter=lldb-dap. Local path to the native executable. - `request` (string): For mode=live, choose whether the initialized DAP adapter launches a target or attaches to an existing authorized target. - `requestTimeoutMs` (integer): Per-request DAP timeout in milliseconds for the selected debugger adapter. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `snapshot` (object): Bounds and optional evidence categories for a runtime crash snapshot. - `sourceMap` (object): For mode=dump, map source paths stored in debug symbols to local source paths. - `stopOnEntry` (boolean): When true in codelldb/lldb-dap/gdb modes, request an initial debugger stop at program entry before normal execution. - `timeoutMs` (integer): Maximum milliseconds to wait for the reproduction to stop, exit, or terminate. - `workflow` (object): Controls one-shot diagnosis, explicit verification, or the bounded autonomous crash workflow. Output parameters: - `diagnosis` - `mode` (string) - `status` (object) - `workflow` ### `debug_causal_trace` (~179 tokens) Trace Runtime Causality Build a bounded consumer-to-writer evidence chain for one suspicious debugger-visible value. Use it after crash or differential evidence identifies a value whose runtime producers matter. It combines the current stopped snapshot with repeated watchpoint writer tracing. Do not use it for frozen dumps or unsafe-to-resume targets, and do not treat an observed writer as automatic proof of root cause. Input parameters: - `maxDepth` (integer): Maximum number of confirmed writer events promoted into the causal producer chain. - `maxStops` (integer): Maximum watchpoint stops available to the underlying bounded temporal trace. - `name` (string, required): Debugger-visible variable or expression whose producer chain should be traced. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `timeoutMs` (integer): Aggregate deadline for the entire causal trace operation. Output parameters: - `conclusion` (string) - `consumer` (object) - `limitations` (array) - `producerChain` (array) - `query` (object) - `trace` (object) ### `debug_progress_probe` (~156 tokens) Probe Runtime Progress Sample a live target across short resume/pause intervals to distinguish no observed progress, same-frame execution movement, and probable busy loops. Use it when a process appears hung but a single thread snapshot cannot distinguish blocking from spinning. Do not use it when resuming the target is unsafe; sampling perturbs scheduling and is not proof of application-level progress. Input parameters: - `intervalMs` (integer): Approximate execution interval between debugger samples. - `samples` (integer): Number of stopped runtime samples to collect across resume/pause intervals. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `threadId` (integer): Preferred thread to sample; omit to follow the debugger-selected stopped thread. Output parameters: - `captures` (array) - `classification` (string) - `evidence` (object) - `intervalMs` (integer) - `limitations` (array) - `samples` (integer) - `status` (object) ### `debug_runtime_report` (~173 tokens) Build Runtime Debug Report Create a shareable structured report from the current stopped target with normalized crash fingerprinting, Symbol Doctor status, sanitizer stderr correlation, poison-pattern memory hazard detection, ABI register-to-argument mapping, and recent debugger output. Use it only for evidence-driven triage and issue handoff. Do not treat heuristic poison patterns, ABI mappings, or sanitizer text correlation as standalone proof. Input parameters: - `abi` (string): ABI used to map argument registers; auto infers from debugger registers and host platform when possible. - `includeOutputTail` (boolean): Include the bounded recent adapter stderr tail used for sanitizer correlation. - `redactPaths` (boolean): Replace path-like portions of the report fingerprint frame key with a generic marker. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. Output parameters: - `abi` - `apiAnalysis` - `breakpointPlan` - `exceptionKey` (string) - `fingerprint` (string) - `fingerprintsV2` (object) - `frameKey` (string) - `hypotheses` (array) - `limitations` (array) - `memoryHazards` (array) - `outputTail` (array) - `sanitizer` (array) - `snapshot` (object) - `stackIntegrity` - `symbolDoctor` - `symbolStatus` (string) ### `debug_trace_lifetime` (~186 tokens) Trace Object Lifetime Trace lifetime evidence for one debugger-visible pointer or object handle using the current snapshot, sanitizer/runtime output, bounded forward writer tracing, and optional reverse stepping when supported. Use this for suspected use-after-free, stale ownership, or unexpected pointer replacement. Do not use forward tracing on a frozen dump or when resuming the target is unsafe. Input parameters: - `direction` (string): Forward uses writer watchpoints, reverse uses stepBack, and hybrid collects both when supported. - `maxStops` (integer): Maximum forward writer observations. - `name` (string, required): Debugger-visible pointer/object expression whose lifetime should be investigated. - `reverseSteps` (integer): Maximum reverse stepBack operations when reverse or hybrid is selected. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `timeoutMs` (integer): Aggregate bound for forward temporal tracing. Output parameters: - `allocationDeallocationHints` (array) - `forwardTimeline` (object) - `guidance` (array) - `initial` (object) - `memoryHazards` (array) - `query` (string) - `reverseTimeline` (array) - `sanitizer` (array) ### `debug_adaptive_evidence` (~154 tokens) Collect Adaptive Runtime Evidence Collect runtime evidence in progressively richer bounded phases instead of immediately requesting a maximal snapshot. Use it when token/DAP cost matters or the amount of evidence needed is unknown: it starts with stack and small locals, expands only when symbols, exception state, or variables are insufficient, and finishes with a full runtime report when needed. Do not use it to replace deliberate deep inspection when the required evidence is already known. Input parameters: - `forceFull` (boolean): Force the full evidence phase even if the cheap snapshot already looks sufficient. - `maxVariables` (integer): Maximum locals/registers per scope in the richest phase. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. Output parameters: - `evidenceBudget` - `expansionReasons` (array) - `report` (object) - `selectedPhase` (string) - `snapshot` (object) ### `debug_this_hang` (~687 tokens) Debug This Hang High-level native hang workflow for all-thread triage. Use it when a live process appears stuck, deadlocked, waiting forever, or spinning and you need bounded stacks from every thread, wait-state/deadlock heuristics, and cross-thread Pointer-Provenance v2. In current mode it inspects an existing configured session and pauses a running live target when necessary; codelldb, lldb-dap, gdb, and live modes can launch or attach to an authorized local target, observe it for a bounded interval, then pause it for evidence. Do not use executable/attach modes when target execution or debugger control is not authorized, and do not treat a deadlock-candidate as a proven lock cycle because generic DAP does not expose portable lock ownership. Input parameters: - `adapterPath` (string): Optional explicit CodeLLDB, lldb-dap, or GDB executable path; omit to use adapter discovery. - `analysis` (object): Optional project roots/modules used to recognize project-controlled frames across all threads. - `args` (array): Command-line arguments for codelldb/lldb-dap/gdb launch modes. - `captureTimeoutMs` (integer): Global deadline for all-thread stack/scope/variable evidence collection after the pause phase. When it expires, remaining threads are retained as partial/unclassified evidence instead of extending th… - `configuration` (object): Required only for mode=live: adapter-specific DAP launch/attach configuration. - `cwd` (string): Working directory for adapter-owned launches and a project-root hint for hang triage. - `env` (object): Environment variables supplied to adapter-owned launched programs. - `framesWithVariables` (integer): Maximum frames per thread whose locals/arguments are collected, prioritizing the top frame and first project-controlled frame. - `maxThreads` (integer): Maximum threads to collect for bounded all-thread triage. - `maxVariablesPerFrame` (integer): Maximum local/argument variables collected per selected frame scope for Pointer-Provenance v2. - `mode` (string): current triages the configured session; live uses an already initialized generic DAP adapter; codelldb/lldb-dap/gdb discover and start that adapter before launch/attach. - `observeMs` (integer): Bounded interval after launch/attach during which a normal stop or process exit prevents automatic hang-timeout classification. - `pauseBudgetMs` (integer): Aggregate wall-clock budget across thread enumeration and all pause requests. This prevents per-thread pause timeouts from multiplying across large thread sets. - `pauseTimeoutMs` (integer): Maximum time to wait for any single pause request used to freeze a suspected live hang. - `pid` (integer): Required for codelldb/lldb-dap/gdb attach modes; ignored for launch and generic live configuration. - `program` (string): Required for codelldb/lldb-dap/gdb launch; optional executable image hint for adapter-specific attach. - `request` (string): For live or adapter-owned modes, launch starts a program and attach connects to an existing authorized process. - `requestTimeoutMs` (integer): Per-request timeout for starting and configuring an adapter-owned DAP session. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `stackLevels` (integer): Maximum stack frames collected per thread. Output parameters: - `diagnosis` (object) - `evidence` (array) - `mode` (string) - `observation` (object) - `status` (object) ### `debug_find_writer` (~487 tokens) Find Runtime Writer Temporarily watch a variable or debugger expression, resume an authorized live target, and capture the first resulting stop to identify the immediate writer candidate. Use this after a stopped-state diagnosis suggests a value was corrupted and runtime provenance is needed; do not use it for crash dumps or when resuming is unsafe. Adapters with DAP data-breakpoint support use that protocol directly; GDB 14/15 uses a bounded watch/rwatch/awatch command through DAP REPL because those releases do not advertise native data breakpoints. The tool removes only the temporary watch it created and never automatically continues through an unrelated stop. Input parameters: - `accessType` (string): Requested watchpoint access mode. write is the normal choice when finding who corrupts a value; GDB maps these to watch/rwatch/awatch. - `condition` (string): Optional adapter-supported condition for native DAP data breakpoints. Intentionally rejected by the bounded GDB fallback. - `frameId` (integer): Optional stopped frame used to resolve an expression; omit to use the current snapshot frame. Ignored by native DAP child resolution when variablesReference is supplied. - `hitCondition` (string): Optional adapter-supported hit-count condition for native DAP data breakpoints. Intentionally rejected by the bounded GDB fallback. - `name` (string, required): Variable child name or debugger expression to watch. Without variablesReference, the expression is resolved in frameId/current frame when supported. GDB fallback expressions must not contain control… - `replaceExistingDataBreakpoints` (boolean): For native DAP data breakpoints, temporarily replace existing MCP-managed watches when true. The GDB fallback never deletes unrelated CLI watchpoints and only removes its own temporary watch. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `snapshot` (object): Bounds for the evidence snapshot captured after execution stops. - `threadId` (integer): Stopped thread to resume and inspect; omit to use the debugger-selected stopped thread. - `timeoutMs` (integer): Maximum time in milliseconds to wait for a stop, exit, or termination after resuming. - `variablesReference` (integer): Optional DAP variable-container reference when the adapter advertises native data breakpoints. Omit for the GDB watch-command fallback and pass a debugger-visible expression in name instead. Output parameters: - `before` (object) - `cleanupWarning` (string) - `guidance` (string) - `hitConfirmed` (boolean) - `installed` - `outcome` (object) - `priorDataBreakpointCount` (integer) - `query` (object) - `replaceExistingDataBreakpoints` (boolean) - `resolution` - `snapshot` (object) - `status` (object) - `strategy` (string) - `writerCorrelation` - `writerFrame` (object) ### `debug_trace_value` (~298 tokens) Trace Runtime Value Writes Build a bounded temporal write timeline for one debugger-visible variable or expression. Use this after differential or crash evidence identifies a suspicious value and repeated live-target resume is safe. The tool installs one temporary data breakpoint or watchpoint at a time, resumes to the next confirmed writer, captures bounded runtime evidence, removes only its own temporary watch, and repeats. Do not use it for crash dumps, unsafe-to-resume targets, or as proof that an observed writer is the root cause; it stops on unrelated debugger events rather than continuing through them. Input parameters: - `accessType` (string): Watch writes only by default; readWrite may be used when read access is also relevant. - `maxStops` (integer): Maximum confirmed or unrelated writer-stop observations before the trace ends. - `name` (string, required): Debugger-visible variable or expression to watch. Control characters and line breaks are rejected by the GDB fallback. - `perStopTimeoutMs` (integer): Maximum bounded wait allocated to each individual writer observation, also capped by the aggregate deadline. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `snapshot` (object): Optional bounded evidence settings for each observed writer stop. - `threadId` (integer): Initial stopped thread; omit to use the debugger-selected stopped thread. Writer snapshots follow the actual stopped event thread. - `timeoutMs` (integer): Aggregate operation deadline across the entire write timeline. Output parameters: - `events` (array) - `finalSnapshot` (object) - `guidance` (array) - `query` (object) - `status` (object) - `stopReason` (string) - `terminalError` (string) ### `debug_open_dump` (~465 tokens) Open Native Crash Dump Open a local native core/minidump with CodeLLDB, upstream LLVM lldb-dap, or GNU GDB DAP and capture bounded postmortem evidence. Use this when the failure is already recorded and no target process should execute; use debug_run_to_stop or debug_this_crash for a live reproduction instead. The tool starts only the selected local debugger adapter, never launches or resumes the crashed program, treats the dump as read-only, and returns the initial stack/locals/registers plus optional modules and disassembly. Input parameters: - `adapter` (string): Debugger adapter used for postmortem inspection. lldb-dap and gdb use their native coreFile attach semantics. - `adapterPath` (string): Optional explicit executable path for the selected debugger adapter; omit to use its normal discovery logic. - `cwd` (string): Working directory for the local debugger adapter process; this does not execute the crashed target. - `dumpPath` (string, required): Absolute or local path to the native core/minidump file to inspect. - `includeDisassembly` (boolean): Include best-effort instructions around the selected crash frame. - `includeModules` (boolean): Include loaded executable images and libraries recorded in the dump. - `maxVariablesPerScope` (integer): Maximum variables returned per scope in the initial snapshot. - `moduleCount` (integer): Maximum number of modules to include when includeModules is true. - `program` (string): Path to the matching executable image. Optional for CodeLLDB/GDB, but required when adapter=lldb-dap because LLVM coreFile loading binds the dump to its program image. - `requestTimeoutMs` (integer): Per-request DAP timeout in milliseconds while opening and inspecting the dump. - `sessionId` (string): Optional DAP session ID. Omit to use the backward-compatible default session. - `sourceMap` (object): Optional mapping from source paths recorded in symbols to local source paths. Supported by CodeLLDB/lldb-dap; GDB currently rejects this field rather than guessing undocumented semantics. - `stackLevels` (integer): Maximum stack frames to include in the initial postmortem snapshot. - `threadId` (integer): Specific dump thread to inspect; omit to use the debugger-selected stopped/crashed thread. Output parameters: - `adapter` - `adapterKind` (string) - `attach` - `capabilities` - `dumpPath` (string) - `guidance` (object) - `mode` (string) - `program` (string) - `readOnlyTarget` (boolean) - `snapshot` (object) ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp#diagnostics ## Score history - 2026-11-05: 80 - 2026-11-04: 80 - 2026-11-03: 64 - 2026-11-02: 53 ## Common questions ### What is the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen is listed in the public MCP registry as io.github.spk-c/qwen-dap-mcp. C/C++ crash, hang and dump debugging for Claude Code, Codex and Qwen via GDB, LLDB and MCP. This page covers its npm package (@slp-dev1/qwen-dap-mcp). ### Is the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server safe to use? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen scores 80 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server expose? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen exposes 18 tools: debug_sessions, debug_compare_runs, debug_snapshot, debug_status, debug_disconnect, and 13 more. Their descriptions and schemas cost roughly 5,146 tokens of context every time the server is loaded. ### Is the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server still maintained? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ### What licence is the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server under? Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls. ### What did VerifyMCP test on the Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen server? VerifyMCP ran 16 checks on Qwen DAP MCP — C/C++ Debugger for Claude Code, Codex & Qwen, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out. ## Links - npm package: https://www.npmjs.com/package/@slp-dev1/qwen-dap-mcp - Socket report: https://socket.dev/npm/package/@slp-dev1/qwen-dap-mcp - Repository: https://github.com/spk-c/Qwen-dap-mcp - Changelog RSS feed: https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp.xml - Changelog JSON feed: https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp/changelog.json - Trust report (JSON): https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp.json - HTML version of this page: https://verifymcp.io/servers/spk-c-qwen-dap-mcp/slp-dev1-qwen-dap-mcp