callx402 1.0.4 → 1.0.5

package/.github/release-intent/callx402-v1.0.5.txt

@@ -0,0 +1,2 @@
+Release callx402@1.0.5 after the clean-install consumer suite and legacy-subsystem regression suite pass. No production money movement.
+Retried after correcting the npm v11 pack metadata assertion to verify the generated tarball on disk.

package/.github/workflows/consumer-compatibility.yml

@@ -0,0 +1,20 @@
+name: consumer-compatibility
+on:
+  push:
+    branches:
+      - 'test/clean-npm-mcp-consumer-20261016'
+  pull_request:
+    branches:
+      - main
+permissions:
+  contents: read
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npm test && node --test test/external-mcp-package.test.js

package/.github/workflows/npm-publish.yml

@@ -4,6 +4,10 @@ on:
   release:
     types: [published]
   workflow_dispatch:
+  push:
+    branches: [main]
+    paths:
+      - '.github/release-intent/callx402-v1.0.5.txt'
 
 permissions:
   id-token: write
@@ -14,7 +18,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-
       - uses: actions/setup-node@v4
         with:
           node-version: '22'
@@ -23,7 +26,32 @@ jobs:
       - run: npm ci --no-audit --no-fund
       - run: npm test
       - run: npm pack --dry-run
-
-
-      - name: Publish to npm via Trusted Publishing (OIDC, no token)
+      - name: Confirm release version
+        run: |
+          node -e "if (require('./package.json').version !== '1.0.5') process.exit(1)"
+      - name: Check whether version is already published
+        id: published
+        run: |
+          if npm view callx402@1.0.5 version >/dev/null 2>&1; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+          fi
+      - name: Publish to npm via existing Trusted Publishing (OIDC)
+        if: steps.published.outputs.exists != 'true'
         run: npm publish --provenance --access public
+
+  github-release:
+    if: github.event_name == 'push'
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Publish tagged source release after npm publication
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if ! gh release view v1.0.5 --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release create v1.0.5 --repo "$GITHUB_REPOSITORY" --target "$GITHUB_SHA" --title "callx402 v1.0.5" --notes "Free read-only MCP diagnostics work from a clean npm installation. Existing configured local/remote subsystems remain available. Financial execution remains disabled through MCP. Release verified by full test suite and npm-pack consumer tests."
+          fi

package/README.md

@@ -77,10 +77,7 @@ Ask the client to list its MCP tools: the six `x402_*` tools should appear.
 Per-client notes and the raw stdio test handshake:
 [`integrations/mcp-clients/`](integrations/mcp-clients/).
 
-Note: `x402_status` works with zero setup. The other five tools dispatch
-into the v2.0.0 subsystem tree, so they report `subsystem_unreachable`
-until `CALLX402_V2_ROOT` points at the tree (see "Full subsystem commands"
-above) and the matching flag is enabled.
+Note: all six free MCP tools respond on a clean npm install using conservative local, read-only assessment of supplied evidence. Without an authoritative source they **do not** verify settlement, access a private ledger, or execute recovery. Existing configured local/remote subsystem integrations remain available.
 
 ## The relationship
 

package/mcp/README.md

@@ -17,13 +17,9 @@ over stdio. Zero dependencies (node stdlib only).
 | `x402_status` | Subsystem reachability |
 
 Only diagnostic, read-only actions are exposed. Nothing here charges, executes,
-retries, or repays. If a subsystem is unreachable, the tool fails closed
-instead of inventing an answer.
+retries, or repays. If a verified local or remote subsystem is configured, the tools retain the existing full-subsystem dispatch. On a clean npm install, packaged free tools provide conservative, read-only analysis of *caller-supplied* evidence. They cannot independently verify settlement or access a private ledger.
 
-Setup note: `x402_status` works with zero setup. The other five tools
-dispatch into the v2.0.0 subsystem tree, so they report
-`subsystem_unreachable` until `CALLX402_V2_ROOT` points at the tree and the
-matching flag is enabled (see the main README, "Full subsystem commands").
+Setup note: **all six MCP tools work on a clean npm install**. Missing private ledger evidence is reported as NO_BASIS; recovery is never auto-executed; settlement without chain verification remains UNKNOWN. Existing optional local v2.0.0 integrations continue to work when configured and enabled.
 
 Tool names are namespaced `x402_*` — never `call_x402` (live collision on the
 fiatdock marketplace).

package/mcp/free-core.js

@@ -0,0 +1,45 @@
+'use strict';
+// Local, read-only, dependency-free MCP diagnosis.
+function run(name, args = {}) {
+  if(name === 'x402_status') return {status:'READY', mode:'FREE_MCP', tools:6};
+  let evidence = args.evidence || {};
+  if(typeof evidence === 'string') evidence = JSON.parse(evidence);
+  if(!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) {
+    throw new Error('Evidence must be a JSON object');
+  }
+  const status = Number(evidence.httpStatus || evidence.status || evidence.response?.status || 0);
+  let challenge = evidence.challenge || evidence.paymentRequired || evidence.responseBody || {};
+  if(typeof challenge === 'string') {
+    try { challenge = JSON.parse(challenge); } catch { challenge = {}; }
+  }
+  const accept = (Array.isArray(challenge.accepts) && challenge.accepts[0]) ||
+    challenge.paymentRequirements || challenge;
+  const network = accept.network || evidence.network || null;
+  const legacy = ['base','base-sepolia','solana','solana-devnet','ethereum','arbitrum','optimism','polygon'];
+  const known = typeof network === 'string' && (
+    /^(eip155:\d+|solana:[A-Za-z0-9]+)$/.test(network) || legacy.includes(network));
+  const terms = !!(network && accept.asset && (accept.amount != null || accept.maxAmountRequired != null));
+  const version = challenge.x402Version || evidence.x402Version || null;
+  if(name === 'x402_diagnose') return {
+    classification: status === 402 ? (terms ? (known ? 'RECOGNIZED_CHALLENGE' : 'UNKNOWN_NETWORK')
+        : 'INCOMPLETE_CHALLENGE') :
+      status >= 500 ? 'SERVER_ERROR' :
+      status === 401 || status === 403 ? 'AUTH_DENIED' : 'INSUFFICIENT_EVIDENCE',
+    network, x402Version: version, termsPresent: terms,
+    legacySlugInV2: !!(version === 2 && known && network && !network.includes(':')),
+    evidenceSource: 'USER_SUPPLIED', verifiedSettlement:false,
+    note:'Recognition does not verify payability or on-chain settlement.'
+  };
+  if(name === 'x402_evidence') return {
+    operationId: args.operationId || null, evidence,
+    basis: Object.keys(evidence).length ? 'USER_SUPPLIED' : 'NO_BASIS'
+  };
+  if(name === 'x402_explain') return {
+    operationId: args.operationId || null, summary:'Local supplied evidence only',
+    basis: Object.keys(evidence).length ? 'USER_SUPPLIED' : 'NO_BASIS'
+  };
+  if(name === 'x402_recover') return {decision:'HUMAN_REVIEW', canRetry:false, executed:false};
+  if(name === 'x402_resolve') return {settlement:'UNKNOWN', canRetry:false};
+  throw new Error('Unknown MCP tool');
+}
+module.exports = {run};

package/mcp/index.js

@@ -18,13 +18,9 @@
  * Only read-only / diagnostic actions are exposed. Actions with side effects
  * (execute, rescue mutations) are intentionally NOT tools here.
  *
- * Honest surface: ONLY x402_status works on a bare install of this package.
- * The other five tools dispatch into the v2.0.0 subsystem tree (the x402
- * Paid API Starter Kit — a separate product that is NOT bundled here) and
- * return `subsystem_unreachable` until CALLX402_V2_ROOT points at that tree
- * and the matching feature flag is enabled. These tools never call the
- * hosted rail; paid hosted equivalents live at
- * https://payloadhq.github.io/agents.json.
+ * All six tools load without sibling packages. Existing enabled local/remote\n * subsystems are used when configured; otherwise free evidence and settlement
+ * assessments remain conservative: caller evidence is not authenticated,
+ * and local tools cannot certify a real payment or automatically retry.
  *
  * Usage (Claude Desktop / MCP client config):
  *   { "command": "node", "args": ["/path/to/callx402/mcp/index.js"] }
@@ -32,38 +28,51 @@
  */
 const readline = require('node:readline');
 
-const VERSION = '1.0.4';
+const VERSION = '1.0.5';
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER_NAME = 'callx402';
 const TIMEOUT_MS = Number(process.env.CALLX402_TIMEOUT_MS || 30000);
 
-const core = require(process.env.CALLX402_CORE_PATH ||
-  require('node:path').join(__dirname, '..', 'core'));
+// The free MCP artifact must be functional when installed alone. The CLI's
+// optional v2 subsystem tree is not a dependency of these read-only tools.
+const freeCore = require('./free-core.js');
+const core = require('../core/index.js');
+const { loadConfig } = require('../core/config.js');
+const { getSubsystem } = require('../core/subsystems.js');
+const { loadVeyline } = require('../core/veyline.js');
+
+/**
+ * Prefer a customer's already configured *real* local/remote subsystem.
+ * Otherwise use the packaged, read-only offline diagnostic instead of
+ * returning subsystem_unreachable on a fresh npm install.
+ *
+ * No payment, signer, or execute action is reachable through this MCP server.
+ */
+function hasConfiguredBackend(action) {
+  const cfg = loadConfig();
+  if (cfg.mode === 'remote' && cfg.remoteUrl) return true;
+  const subsystem = ({ diagnose: 'doctor', resolve: 'settlement' })[action];
+  if (subsystem) {
+    const handle = getSubsystem(subsystem, { config: cfg });
+    return handle.reachable && handle.enabled;
+  }
+  if (['evidence', 'explain', 'recover'].includes(action)) {
+    const flag = action === 'recover' ? 'PAYLOAD_VEYLINE_RECOVERY' : 'PAYLOAD_VEYLINE_LEDGER';
+    if (process.env[flag] !== '1') return false;
+    const loaded = loadVeyline(cfg, {});
+    return !!loaded.modules;
+  }
+  return false;
+}
 
 /* ------------------------------------------------------------------ */
-/* Tool definitions: name, description, input schema, core action.     */
+/* Tool definitions: packaged read-only diagnostics only.             */
 /*                                                                     */
-/* Requirement trailers, stated in every description because the       */
-/* description is what an MCP client actually shows the user:          */
-/*   TREE_REQUIRED — dispatches into the v2.0.0 subsystem tree, which  */
-/*     is NOT part of this package.                                    */
-/*   LEDGER_REQUIRED — reads the local Veyline operation ledger via    */
-/*     modules that are likewise not bundled here.                     */
+/* Caller-supplied evidence is unverified. No private ledger or funds.  */
 /* ------------------------------------------------------------------ */
-const TREE_REQUIRED =
-  ' Requires the v2.0.0 subsystem tree (x402 Paid API Starter Kit, a separate ' +
-  'product that is NOT included in this package): set CALLX402_V2_ROOT to the ' +
-  'tree and enable the subsystem flag, or this tool returns ' +
-  'subsystem_unreachable and does nothing. With the tree configured it is free ' +
-  'and read-only: no payment, no auth. A paid hosted equivalent runs on the ' +
-  'Payload rail — see https://payloadhq.github.io/agents.json.';
-const ledgerRequired = (flag) =>
-  ' Requires the local Veyline ledger modules (NOT included in this package; ' +
-  `enable with ${flag}=1 where the ledger lives) and reads ` +
-  'operations recorded on THIS machine — it cannot read back hosted rail ' +
-  'invocations. Until configured it returns subsystem_unreachable and does ' +
-  'nothing. When configured it is free and read-only: no payment, no auth.';
-const LEDGER_REQUIRED = ledgerRequired('PAYLOAD_VEYLINE_LEDGER');
+const TREE_REQUIRED = ' Local read-only inference from caller-supplied evidence, included in npm. Does not independently verify payments or access private infrastructure.';
+const ledgerRequired = () => ' Returns only caller-supplied evidence; no remote/private ledger is included and no on-chain data is verified.';
+const LEDGER_REQUIRED = ledgerRequired();
 
 const TOOLS = [
   {
@@ -80,7 +89,7 @@ const TOOLS = [
       properties: {
         evidence: {
           type: 'string',
-          description: 'JSON string (or @file path) describing the failure evidence.',
+          description: 'JSON string describing non-sensitive failure evidence; local file references are unsupported.',
         },
         target: {
           type: 'string',
@@ -94,15 +103,14 @@ const TOOLS = [
     name: 'x402_evidence',
     action: 'evidence',
     description:
-      'Show recorded ledger evidence for an operation: event trail, latest ' +
-      'per-plane states (payment / execution / delivery), protocols involved. ' +
-      'Use FIRST in any incident — establishes ground truth before acting. Read-only.' +
+      'Show caller-supplied operation evidence only; no private or hosted ledger is included. ' +
+      'Missing evidence returns NO_BASIS, never an invented ledger record. Read-only.' +
       LEDGER_REQUIRED,
     inputSchema: {
       type: 'object',
       properties: {
         operationId: { type: 'string', description: 'The operation ID to look up.' },
-        dir: { type: 'string', description: 'Optional ledger directory.' },
+        evidence: { type: 'string', description: 'Optional sanitized JSON evidence; otherwise NO_BASIS.' },
       },
       required: ['operationId'],
     },
@@ -111,16 +119,14 @@ const TOOLS = [
     name: 'x402_explain',
     action: 'explain',
     description:
-      'Explain an operation\'s state in plain language from recorded evidence. ' +
-      'Returns an assessment: NO_BASIS, INCOMPLETE (do not retry, do not repay), ' +
-      'KNOWN_SAFE, RECOVERY_CANDIDATE, or PARTIAL. Use to understand an incident ' +
-      'before deciding whether to retry, refund, or escalate. Read-only.' +
+      'Provide a conservative interpretation of caller-supplied evidence only; ' +
+      'no independent payment or settlement verification is performed. Read-only.' +
       LEDGER_REQUIRED,
     inputSchema: {
       type: 'object',
       properties: {
         operationId: { type: 'string', description: 'The operation ID to explain.' },
-        dir: { type: 'string', description: 'Optional ledger directory.' },
+        evidence: { type: 'string', description: 'Optional sanitized JSON evidence; otherwise NO_BASIS.' },
       },
       required: ['operationId'],
     },
@@ -131,9 +137,9 @@ const TOOLS = [
     description:
       'Report the safe recovery decision for an operation whose result was lost ' +
       '(paid but no result). READ-ONLY: nothing is charged, nothing is executed. ' +
-      'Returns RECOVERABLE/SAFE_RETRY -> KNOWN_SAFE, or HUMAN_REVIEW. Use for ' +
-      'the exact situation where blind retry would double-pay or double-execute.' +
-      ledgerRequired('PAYLOAD_VEYLINE_RECOVERY'),
+      'Without an authoritative settlement source, return HUMAN_REVIEW and never retry. ' +
+      'This free diagnostic cannot execute recovery.' +
+      ledgerRequired(),
     inputSchema: {
       type: 'object',
       properties: {
@@ -148,8 +154,8 @@ const TOOLS = [
     name: 'x402_resolve',
     action: 'resolve',
     description:
-      'Resolve settlement state from evidence (e.g. settlement_pending: was the ' +
-      'broadcast transaction confirmed on chain?). Use instead of blind retry. Read-only.' +
+      'Classify caller-provided settlement evidence conservatively. Returns UNKNOWN ' +
+      'without authoritative chain verification; no retry is performed. Read-only.' +
       TREE_REQUIRED,
     inputSchema: {
       type: 'object',
@@ -168,10 +174,8 @@ const TOOLS = [
     description:
       'Check callx402 subsystem reachability (which diagnostic subsystems are ' +
       'available). Use to verify the tool is operational before diagnosing. ' +
-      'Read-only. This is the one tool that works with zero setup in any ' +
-      'install — no key, no tree, no payment. On a bare npm install it ' +
-      'honestly reports 0/15 subsystems reachable: the other five tools need ' +
-      'the v2.0.0 subsystem tree (CALLX402_V2_ROOT) before they can answer.',
+      'Read-only. Works with zero setup on a bare npm install. ' +
+      'reports the availability of the packaged free tools independently of optional subsystems.',
     inputSchema: { type: 'object', properties: {} },
   },
 ];
@@ -200,12 +204,19 @@ async function handleToolsCall(id, params) {
   }
   const args = (params && params.arguments) || {};
   try {
-    const { result: r, exitCode } = await core.runAction(tool.action, args, { timeoutMs: TIMEOUT_MS });
-    const ok = exitCode === 0;
-    result(id, {
-      content: [{ type: 'text', text: JSON.stringify(r, null, 2) }],
-      isError: !ok,
-    });
+    if (hasConfiguredBackend(tool.action)) {
+      const { result: r, exitCode } = await core.runAction(tool.action, args, { timeoutMs: TIMEOUT_MS });
+      result(id, {
+        content: [{ type: 'text', text: JSON.stringify(r, null, 2) }],
+        isError: exitCode !== 0,
+      });
+    } else {
+      const r = freeCore.run(tool.name, args);
+      result(id, {
+        content: [{ type: 'text', text: JSON.stringify(r, null, 2) }],
+        isError: false,
+      });
+    }
   } catch (e) {
     result(id, {
       content: [{ type: 'text', text: JSON.stringify({ error: e && e.message ? e.message : String(e) }) }],

package/package.json

@@ -27,6 +27,6 @@
     "smoke": "node bin/callx402.js status --json",
     "test": "node --test test/*.test.js"
   },
-  "version": "1.0.4",
+  "version": "1.0.5",
   "mcpName": "io.github.payload-tools/callx402"
 }

package/server.json

@@ -10,7 +10,7 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "1.0.3"
+      "version": "1.0.5"
     }
   ],
   "repository": {
@@ -18,6 +18,6 @@
     "url": "https://github.com/Payloadhq/callx402"
   },
   "title": "callx402 MCP server",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "websiteUrl": "https://github.com/Payloadhq/callx402"
-}
+}

package/test/external-mcp-package.test.js

@@ -0,0 +1,84 @@
+'use strict';
+// Consumer smoke test for the actual npm artifact. Uses npm pack locally,
+// installs nothing, sends no financial transactions or production requests.
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const os=require('node:os');
+const path=require('node:path');
+const cp=require('node:child_process');
+const readline=require('node:readline');
+
+test('npm-packed callx402 exposes usable free MCP diagnosis to a clean consumer',async()=>{
+ const root=path.resolve(__dirname,'..');
+ const temp=fs.mkdtempSync(path.join(os.tmpdir(),'callx402-npm-consumer-'));
+ let proc;
+ try{
+   const pack=cp.spawnSync('npm',['pack','--ignore-scripts','--json','--pack-destination',temp],{
+     cwd:root,encoding:'utf8',timeout:30000});
+   assert.equal(pack.status,0,pack.stderr);
+   // Newer npm versions differ in --json metadata; inspect the actual artifact
+   // instead of relying on a particular stdout schema.
+   const filename=fs.readdirSync(temp).find(name=>name.endsWith('.tgz'));
+   assert.ok(filename,'npm pack must produce a tarball in '+temp+
+     ' (stdout: '+pack.stdout.slice(0,500)+')');
+   const bundle=path.join(temp,filename);
+   assert.ok(fs.existsSync(bundle),'packed npm tarball present');
+   const extracted=cp.spawnSync('tar',['-xzf',bundle,'-C',temp],{encoding:'utf8'});
+   assert.equal(extracted.status,0,extracted.stderr);
+   const entry=path.join(temp,'package','mcp','index.js');
+   assert.ok(fs.existsSync(entry),'MCP executable included in distributed npm archive');
+   proc=cp.spawn(process.execPath,[entry],{
+     cwd:temp,
+     env:{
+       ...process.env,
+       CALLX402_V2_ROOT:path.join(temp,'absent-v2'),
+       CALLX402_CONFIG:path.join(temp,'empty-config.json'),
+       CALLX402_MODE:'local',
+       CALLX402_CORE_PATH:path.join(temp,'package','core')
+     },
+     stdio:['pipe','pipe','pipe']
+   });
+   let stderr='';proc.stderr.on('data',d=>stderr+=d);
+   let id=0;const wait=new Map();
+   readline.createInterface({input:proc.stdout}).on('line',line=>{
+     try{const r=JSON.parse(line),fn=wait.get(r.id);if(fn){wait.delete(r.id);fn(r);}}catch{}
+   });
+   const rpc=(method,params)=>new Promise((resolve,reject)=>{
+     const n=++id,t=setTimeout(()=>{wait.delete(n);reject(new Error('MCP timeout '+stderr.slice(0,300)));},5000);
+     wait.set(n,result=>{clearTimeout(t);resolve(result);});
+     proc.stdin.write(JSON.stringify({jsonrpc:'2.0',id:n,method,params})+'\n');
+   });
+   assert.ok((await rpc('initialize',{protocolVersion:'2024-11-05',capabilities:{},
+     clientInfo:{name:'fresh-npm-consumer',version:'1.0'}})).result);
+   const tools=(await rpc('tools/list',{})).result?.tools||[];
+   for(const name of ['x402_diagnose','x402_evidence','x402_explain','x402_recover','x402_resolve','x402_status'])
+     assert.ok(tools.some(t=>t.name===name),'missing advertised tool '+name);
+   const diagnostic=await rpc('tools/call',{
+     name:'x402_diagnose',
+     arguments:{evidence:JSON.stringify({httpStatus:402,
+       failure:'client could not parse challenge',network:'base'})}
+   });
+   assert.ok(diagnostic.result,'MCP tool response exists');
+   const output=JSON.stringify(diagnostic.result);
+   assert.ok(!/subsystem_unreachable|Cannot find module|missing v2\.0\.0|could not be loaded/i.test(output),
+     'fresh npm package must not demand an unpublished sibling module: '+output.slice(0,600));
+   assert.equal(diagnostic.result.isError,false,
+     'free diagnostic must work from a clean published-style npm artifact: '+output.slice(0,600));
+   for (const [name,args] of [
+     ['x402_status',{}],
+     ['x402_evidence',{operationId:'operation-fixture'}],
+     ['x402_explain',{operationId:'operation-fixture'}],
+     ['x402_recover',{operationId:'operation-fixture'}],
+     ['x402_resolve',{evidence:JSON.stringify({txHash:'0x'+'a'.repeat(64),network:'base'})}]
+   ]) {
+     const response=await rpc('tools/call',{name,arguments:args});
+     assert.equal(response.result?.isError,false,
+       name+' must respond safely on clean npm install: '+JSON.stringify(response));
+     const data=JSON.parse(response.result.content[0].text);
+     if(name==='x402_recover') assert.equal(data.canRetry,false,'no unauthenticated automatic recovery');
+     if(name==='x402_resolve') assert.equal(data.settlement,'UNKNOWN','no synthetic proof of settlement');
+     if(name==='x402_evidence') assert.equal(data.basis,'NO_BASIS','no invented private ledger entries');
+   }
+ }finally{if(proc)proc.kill('SIGTERM');fs.rmSync(temp,{recursive:true,force:true});}
+});

package/test/mcp-full-subsystem-compat.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const os=require('node:os');
+const path=require('node:path');
+const {spawn}=require('node:child_process');
+const readline=require('node:readline');
+
+test('configured full doctor remains preferred to free fallback after npm packaging fix',async()=>{
+ const temp=fs.mkdtempSync(path.join(os.tmpdir(),'callx402-legacy-compat-'));
+ const d=path.join(temp,'lib','mcp');fs.mkdirSync(d,{recursive:true});
+ fs.writeFileSync(path.join(d,'doctor.js'),
+   "module.exports={FLAG:'FAKE_DOCTOR',enabled:()=>true,runMcpDoctor:()=>({whatFailed:'CONFIGURED_DOCTOR_USED',stages:[]})};\n");
+ const proc=spawn(process.execPath,[path.join(__dirname,'..','mcp','index.js')],{
+   cwd:temp,env:{
+     ...process.env,CALLX402_V2_ROOT:temp,CALLX402_MODE:'local',
+     CALLX402_CONFIG:path.join(temp,'not-present.json'),
+     CALLX402_TIMEOUT_MS:'5000'
+   },stdio:['pipe','pipe','pipe']
+ });
+ let id=0,err='';const pending=new Map();
+ proc.stderr.on('data',b=>err+=b);
+ readline.createInterface({input:proc.stdout}).on('line',line=>{
+   try{const r=JSON.parse(line),fn=pending.get(r.id);if(fn){pending.delete(r.id);fn(r);}}catch{}
+ });
+ function rpc(method,params){
+   return new Promise((resolve,reject)=>{
+     const n=++id,t=setTimeout(()=>{pending.delete(n);reject(Error('timeout '+err.slice(0,200)));},4000);
+     pending.set(n,v=>{clearTimeout(t);resolve(v);});
+     proc.stdin.write(JSON.stringify({jsonrpc:'2.0',id:n,method,params})+'\n');
+   });
+ }
+ try {
+   const r=await rpc('tools/call',{name:'x402_diagnose',
+     arguments:{evidence:JSON.stringify({httpStatus:402})}});
+   assert.equal(r.result?.isError,false,JSON.stringify(r));
+   const payload=JSON.parse(r.result.content[0].text);
+   assert.equal(payload.data.report.whatFailed,'CONFIGURED_DOCTOR_USED',
+     'configured full-subsystem dispatch must not silently be replaced by free approximation');
+ }finally{proc.kill('SIGTERM');fs.rmSync(temp,{recursive:true,force:true});}
+});