callx402 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Payload
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,230 @@
-# Temporary Holding Version
+> **Payload** — Developer infrastructure for x402, agent payments, and programmable revenue.
+> PAYLOAD → VEYLINE (flagship) → CALLX402 (action layer) → REVRULE (separate) → developer products → free utilities.
+> This repo: **callx402 by Payload — the universal action layer into Veyline's x402 infrastructure.**
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center"><img src="docs/logo.png" alt="callx402 logo" width="200"></p>
+# callx402 by Payload
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Node >= 18](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
+[![MCP stdio](https://img.shields.io/badge/MCP-stdio-blue.svg)](mcp/README.md)
+
+**Powered by Veyline. When x402 breaks, callx402.**
+
+callx402 is the universal action layer into Veyline's x402 infrastructure. Say what you need done in plain language (or hit an HTTP endpoint) and callx402 routes it to the production system that does the real work: diagnose a broken x402 payment, rescue a failed transaction, route an agent job to the cheapest viable path, resolve settlement state from on-chain evidence, or execute under an explicit budget with fail-closed safety rules.
+
+**Why it exists:** x402 failures are expensive and opaque. A settlement attempt ends in `settlement_pending` and nobody knows whether the money moved. A 402 response your wallet misreads. A retry that signs a second authorization for the same intent and pays twice. callx402 exists for exactly those moments: `diagnose` pins the failure to a stage, `rescue` triages the incident, `resolve` settles the question from evidence, `route` finds the cheapest viable path, `execute` runs under a hard budget.
+
+**Try it (one minute):**
+```sh
+git clone https://github.com/Payloadhq/callx402
+cd callx402 && npm install && npm link
+callx402 diagnose --target "https://api.example.com/x402/pay"
+```
+
+If it saves you one debugging session, star the repo and read on.
+
+## MCP server: connect in 60 seconds
+
+This repo ships a zero-dependency, read-only MCP server (`mcp/index.js`, node
+stdlib only, stdio transport) exposing six `x402_*` diagnostic tools. Nothing
+here charges, executes, retries, or repays.
+
+```sh
+git clone https://github.com/Payloadhq/callx402
+# no npm install needed for the MCP server
+```
+
+Add this block to your MCP client config (replace the path), then restart the
+client:
+
+| Client | Config file |
+|---|---|
+| Claude Desktop | `claude_desktop_config.json` (`~/Library/Application Support/Claude/` on macOS, `%APPDATA%\Claude\` on Windows) |
+| Cursor | `~/.cursor/mcp.json` (user scope) or `.cursor/mcp.json` (project scope) |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
+
+```json
+{
+  "mcpServers": {
+    "callx402": {
+      "command": "node",
+      "args": ["/absolute/path/to/callx402/mcp/index.js"]
+    }
+  }
+}
+```
+
+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/).
+
+## The relationship
+
+- **PAYLOAD** = the parent company.
+- **VEYLINE** = production infrastructure for x402 + MCP. The flagship brand.
+- **CALLX402 BY PAYLOAD** = the x402 response/action layer, powered by Veyline.
+  The entry action into Veyline's production infrastructure, not the flagship
+  name. Nothing here renames Veyline.
+
+Discovery path: a developer searching for x402 finds callx402, uses it, and
+learns Veyline. Payload is not affiliated with the x402 Foundation.
+
+## What it does
+
+- **Diagnose** an x402 or MCP failure
+- **Rescue** a failed transaction (auth-gated)
+- **Route** a paid agent job to the cheapest viable path
+- **Resolve** settlement state from on-chain evidence
+- **Execute** under an explicit budget, with fail-closed safety rules
+
+Behavioral usage language (not trademark claims):
+
+- "Need to diagnose x402? callx402."
+- "Need to rescue a transaction? callx402."
+- "Need to route a paid agent job? callx402."
+- "Need settlement certainty? callx402."
+- "Need to execute under a budget? callx402."
+
+## Quickstart
+
+```sh
+npm install callx402
+```
+
+Alternative — install direct from GitHub (keeps working as a fallback):
+
+```sh
+npm install Payloadhq/callx402
+```
+
+Alternative — clone and link for local development:
+
+```sh
+git clone https://github.com/Payloadhq/callx402
+cd callx402
+npm install
+npm link        # exposes the `callx402` command
+```
+
+```sh
+callx402 status
+callx402 "complete this job for under $1"
+callx402 diagnose --target "https://api.example.com/x402/pay"
+callx402 rescue --incident inc_123
+callx402 route --goal "fetch 100 product prices for under $0.50"
+callx402 resolve --evidence '{"txHash":"0xabc..."}'
+```
+
+### JavaScript SDK
+
+```js
+const { callx402 } = require('callx402');
+
+const result = await callx402({
+  intent: 'complete this job for under $1',
+  maxBudget: 1.00,
+  networks: ['base'],
+  assets: ['USDC'],
+  approvalThreshold: 5.00,
+  idempotencyKey: 'job-42',
+});
+```
+
+### Python SDK
+
+```python
+import callx402
+
+result = callx402.callx402(
+    intent="complete this job for under $1",
+    max_budget=1.00,
+    networks=["base"],
+    assets=["USDC"],
+    approval_threshold=5.00,
+    idempotency_key="job-42",
+)
+```
+
+### HTTP server
+
+```sh
+CALLX402_PORT=8787 node server/index.js
+curl -X POST http://127.0.0.1:8787/call \
+  -H 'Content-Type: application/json' \
+  -d '{"intent":"complete this job for under $1","maxBudget":1.00,"dryRun":true}'
+```
+
+Full HTTP surface: `server/openapi.yaml` (served live at `GET /openapi.json`).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `callx402 "natural language intent"` | Intent mode: parse, plan, budget-check, route, execute |
+| `callx402 status [--json]` | Subsystem reachability and flag state |
+| `callx402 diagnose [--target ...]` | Diagnose an x402 / MCP failure |
+| `callx402 rescue --incident <id>` | Rescue a transaction (auth-gated) |
+| `callx402 route --goal <text>` | Route a paid job to the cheapest viable path |
+| `callx402 resolve --evidence <json\|@file>` | Resolve settlement state from evidence |
+| `callx402 doctor` | Run the MCP doctor checks |
+| `callx402 execute --intent <text> [--max-budget N] [--dry-run]` | Execute under an explicit budget |
+| `callx402 monitor [--once\|--watch]` | Watch subsystem/incident state |
+| `callx402 preflight` | Preflight checks before a paid run |
+| `callx402 inspect [--query <text>]` | Inspect capability graph / state |
+| `callx402 config list \| get <k> \| set <k> <v>` | Manage local config |
+
+## Integrations
+
+Working entry points for agent frameworks, automation, MCP clients, and x402
+facilitators — all in [`integrations/`](integrations/) and tested against the
+live rail:
+
+- **LangChain** — 9 tools (`integrations/langchain/`): diagnose, recover,
+  resolve, evidence, explain, safe-retry, duplicate-payment risk, preflight,
+  plus the free live fee schedule
+- **CrewAI** — the same actions as CrewAI Tools (`integrations/crewai/`)
+- **n8n** — importable incident-guard workflow (`integrations/n8n/`): maps an
+  incident to a callx402 action, fetches the free live quote, invokes when
+  credentialed, otherwise emits payment instructions — never auto-pays
+- **MCP clients** — Claude Desktop / Cursor / Windsurf setup for the free
+  read-only MCP server (`integrations/mcp-clients/`)
+- **x402 facilitators** — `settle-guard.js` (`integrations/facilitator/`):
+  resolve settlement state from evidence *before* re-broadcasting a payment
+
+Problem → action map: [`docs/problem-map.md`](docs/problem-map.md).
+Machine front door for agents: https://payloadhq.github.io/agents.json.
+
+## Money-safety rules
+
+- **Settlement UNKNOWN is never auto-retried and never repaid.**
+- **Over-budget intents are refused with zero side effects.**
+- **Approval thresholds fail closed.**
+- **Idempotency keys dedupe** — repeats return the original, never re-execute.
+- **Disabled or unreachable subsystems fail closed** — success is never faked.
+- **Non-custodial** — callx402 dispatches work; it never holds funds or private keys.
+
+## What callx402 is not
+
+- Not the flagship product name. The product is **Veyline**.
+- Not a broker, negotiator, or custodian. It dispatches; it never holds funds.
+- The phrases above are usage language, not exclusivity claims.
+
+## Links
+
+- Canonical docs: https://payloadhq.github.io/
+- Payload org profile: https://github.com/Payloadhq/Payloadhq
+- RevRule by Payload (separate product): https://github.com/Payloadhq/revrule-console
+
+Full subsystem reference: `docs/README.md`. Behavioral language: `docs/ACTION_LANGUAGE.md`.
+Design spec: `SPEC.md`.
+
+## License
+
+MIT. See `LICENSE`.
+
+---
+
+**More from Payload** · [payloadhq.github.io](https://payloadhq.github.io/) · [all Payload repos](https://github.com/Payloadhq)
+
+Related: [x402-manifest-check](https://github.com/Payloadhq/x402-manifest-check) · [x402-observatory](https://github.com/Payloadhq/x402-observatory) · [flow-agentic-demo](https://github.com/Payloadhq/flow-agentic-demo)

package/SPEC.md

@@ -0,0 +1,264 @@
+# callx402 — Universal Action Layer — Build Spec
+
+**FUNDAMENTAL RULE: callx402 is the ACTION, not the product name.**
+The flagship keeps a separate unique brand (forthcoming). Do NOT rename Sentinel,
+Rescue, Doctor, Router, Valuator, SpendGuard, Settlement Resolver, MCP fabric,
+RevRule, the Payload brand, or any marketplace listing. callx402 is an
+access/dispatch layer that CALLS existing subsystems. Architecture:
+
+```
+UNIQUE PRODUCT BRAND  →  accessed through  →  callx402
+```
+
+## 1. Non-negotiables
+
+- **NEVER modify** `~/workspace/products/x402-paid-api-starter-kit/v2.0.0/`. Import from it
+  via relative require. Verify at the end with `git` status or a checksum spot-check
+  that the tree is untouched (it is not a git repo necessarily; at minimum do not
+  write any file under it).
+- **Real working code only.** No placeholders, no stubs presented as functional.
+  If a subsystem is feature-flag disabled or needs live infra that isn't reachable,
+  the command must say so clearly and exit non-zero. Never fake success.
+- **No logic duplication.** Every command dispatches into the existing subsystem.
+- **Do NOT publish** to npm, PyPI, or Docker Hub. Packages must be publish-*ready*
+  only. (npm `payloadtools` account suspended until 2026-10-07 12:14 CDT;
+  PyPI blocked on owner's account + 2FA.)
+- **Do NOT** create an MCP tool named exactly `call_x402` (collides with an existing
+  live tool on the fiatdock marketplace). MCP identity stays a DEFERRED decision doc.
+- Behavioral language only ("Need to diagnose x402? callx402."). Never claim
+  exclusive trademark ownership of the phrase.
+- Stdlib only for the core/CLI/HTTP server. No new external dependencies.
+  (Python SDK: stdlib only — `subprocess`, `json`, `argparse`, `shutil`.)
+- Node >= 18 (runtime here is v24.20.0). Python >= 3.9 (runtime 3.12.3).
+
+## 2. Directory layout (all under ~/workspace/products/callx402/)
+
+```
+SPEC.md
+package.json                  # name: callx402, version 0.1.0, MIT, bin {callx402: ./bin/callx402.js},
+                              # main ./sdk/js/index.js, homepage + repository
+                              # https://github.com/Payloadhq/callx402
+bin/callx402.js               # CLI entry (shebang, stdlib only, requires ../core)
+core/
+  index.js                    # runAction(name, args, opts), runIntent(text, opts), getStatus()
+  subsystems.js               # lazy require map of v2.0.0 modules + enabled() checks
+  config.js                   # config file (~/.config/callx402/config.json, $CALLX402_CONFIG),
+                              # env overrides (CALLX402_*), safe defaults
+  envelope.js                 # result envelope builders + exit codes
+  pipeline.js                 # intent pipeline stage orchestration
+sdk/js/
+  index.js                    # callx402({...}) -> Promise<result envelope>
+sdk/python/
+  pyproject.toml              # name callx402, version 0.1.0, console_scripts callx402,
+                              # bundles ../bin + ../core as package data, invokes via node
+  callx402/__init__.py        # callx402(...) -> dict (subprocess to bundled CLI --json)
+  callx402/cli.py             # argparse main() -> same path
+server/
+  index.js                    # node:http server: GET /health, GET /openapi.json,
+                              # POST /call /rescue /route /resolve /diagnose
+  openapi.yaml
+docs/
+  README.md                   # callx402 is the action; flagship brand separate/forthcoming
+  ACTION_LANGUAGE.md           # behavioral phrases
+  MCP_IDENTITY.md             # DEFERRED decision doc
+test/                         # (test agent) node --test suite
+```
+
+## 3. Subsystem module map (v2.0.0 root = ../../x402-paid-api-starter-kit/v2.0.0)
+
+Default v2Root: `path.resolve(__dirname, '../../x402-paid-api-starter-kit/v2.0.0')`.
+Overridable via `CALLX402_V2_ROOT` env or config `v2Root`. All requires lazy (inside
+functions) so `status` can report per-module reachability.
+
+| Subsystem          | Require path (from v2Root)        | Key exports |
+|--------------------|----------------------------------|-------------|
+| Sentinel           | `lib/sentinel/index.js`           | `createSentinel(opts)`, `createInertSentinel()`, `INCIDENT_TYPES`, `FLAG` (`PAYLOAD_SENTINEL`?), `enabled()` |
+| Rescue             | `lib/rescue/index.js`             | `createRescue({...})`, `incidents`, `detector`, `actions`, `autorescue`, `receipts`, `pricing`, `RESCUE_VERSION`, `FLAG='PAYLOAD_RESCUE'`, `enabled()` |
+| Doctor             | `lib/mcp/doctor.js`              | `runMcpDoctor(evidence)`, `classifyMcpFailure`, `STAGES`, `FLAG='PAYLOAD_MCP_DOCTOR'`, `enabled()` |
+| Router             | `lib/mcp/smart-router.js`         | `selectTool`, `rankTools`, `normalizeCandidate`, `totalCost`, `POLICIES`, `DEFAULTS`, `enabled()` |
+| Router (paths)     | `lib/mcp/route-decider.js`        | `choosePath`, `selectPath`, `expectedCost`, `enabled()` |
+| Valuator           | `valuator/quote.js`               | inspect before use |
+| SpendGuard         | `lib/mcp/spendguard.js`           | `createTaskSpendGuard({...})`, `DEFAULT_PHASES`, `enabled()` |
+| Settlement Resolver| `lib/settlement-resolver.js`      | `resolve(evidence)`, `STATES`, `POLICY_MATRIX`, `createMockChain`, `createMockFacilitator`, `FLAG='PAYLOAD_SETTLEMENT_RESOLVER'`, `enabled()` |
+| Intent Engine      | `lib/mcp/intent-engine.js`        | `parse(text)` / `parseIntent`, `createEngine`, `GOALS`, `enabled()` |
+| Capability Graph   | `lib/mcp/capability-graph.js`     | `createGraph()` → `{upsertTool, getToolProfile, findTools, recordObservation, stats, save, load}`, `enabled()` |
+| Economic Planner   | `lib/mcp/economic-planner.js`     | `planGoal(opts)`, `scorePlan`, `OBJECTIVES`, `DEFAULTS`, `enabled()` |
+| MCP fabric         | `lib/mcp/index.js`                | `transactional, saga, spendguard, resultRecovery, effectProof, executionKernel, ...` |
+| RevRule            | `lib/revrule-events.js`           | `createEmitter({sink, idempotencyRegistry})`, `buildEvent`, `createMemorySink`, `enabled()` |
+| Preflight          | `lib/mcp/preflight.js`            | `runMcpPreflight`, `buildChecks`, `enabled()` |
+| Effect Proof       | `lib/mcp/effect-proof.js`         | `issueEffectProof`, `verifyEffectProof`, `enabled()` |
+| Execution Kernel   | `lib/mcp/execution-kernel.js`     | `createKernel`, `STATES`, `TERMINAL`, `enabled()` |
+| Result Recovery    | `lib/mcp/result-recovery.js`      | `createRecoveryStore`, `createResultRecoveryCache`, `buildOperationIdentity`, `enabled()` |
+
+**Flag rule:** every module exposes `enabled()` (checks `process.env[FLAG]==='1'`)
+and `FLAG`. Before dispatch, call `enabled()`. If false, return
+`subsystemStatus: 'disabled'` naming the flag — do NOT fake success.
+(You may document that the user can export the flag; do not silently force-enable
+anything that guards real money movement. Read-only/diagnostic modules may note
+the flag to enable.)
+
+**Status honesty:** `getStatus()` must report per subsystem: `reachable` (require
+succeeded), `enabled` (flag on), `version` where available, and `note` for
+prototype/stub status (e.g. rescue-service `_rescue-stub.js` exists — inspect and
+report honestly; never present a stub as production).
+
+## 4. Result envelope (JSON everywhere: CLI --json, SDKs, HTTP)
+
+```json
+{
+  "ok": true,
+  "action": "diagnose",
+  "disposition": "human-readable outcome",
+  "subsystem": "doctor",
+  "subsystemStatus": "ok | disabled | unreachable | prototype",
+  "data": {},
+  "settlement": "DEFINITELY_PAID | DEFINITELY_NOT_PAID | AUTHORIZED_NOT_SETTLED | PENDING | CONFLICT | UNKNOWN | null",
+  "txHash": "0x... | null",
+  "receipt": {},
+  "idempotencyKey": "string | null",
+  "deduped": false,
+  "error": { "code": "string", "message": "string" }
+}
+```
+
+`error` is null on success. `ok:false` whenever `error` is set.
+
+**Exit codes (CLI):** 0 ok · 1 generic failure · 2 usage/validation error ·
+3 subsystem disabled or unreachable · 4 budget refused (SpendGuard) ·
+5 settlement UNKNOWN (must never auto-retry/repay — surface and stop).
+
+**Money-safety invariants (hard):**
+- Settlement `UNKNOWN` → never auto-retry, never repay. Return exit 5 with
+  instructions for manual resolution.
+- An explicit `--force-retry`/`retry` flag on execute MUST be rejected when the
+  prior settlement state is UNKNOWN (unsafe retry refusal).
+- Over-budget intent → SpendGuard refusal, exit 4, zero execution side effects.
+- Duplicate `idempotencyKey` → return the ORIGINAL stored result with
+  `deduped:true`; do not re-execute. Use result-recovery store.
+
+## 5. Config (`core/config.js`)
+
+- File: `~/.config/callx402/config.json`, overridable by `$CALLX402_CONFIG`.
+- Env overrides: `CALLX402_V2_ROOT`, `CALLX402_MODE` (local|remote),
+  `CALLX402_REMOTE_URL`, `CALLX402_AUTH_TOKEN`, `CALLX402_DEFAULT_NETWORK`,
+  `CALLX402_DEFAULT_ASSET`, `CALLX402_DEFAULT_BUDGET_USD`, `CALLX402_APPROVAL_THRESHOLD_USD`.
+- `config get|set|list` via CLI (`callx402 config list`, `callx402 config set key value`).
+- Safe defaults: mode local, no auto-spend, budget default 1.00 USD, approval
+  threshold default 5.00 USD (above → require explicit `--approve` or fail closed).
+- Remote mode: CLI/SDK dispatch via HTTP to a callx402 server (auth header when
+  `CALLX402_AUTH_TOKEN` set). Unreachable remote → clear error, non-zero exit.
+
+## 6. Intent pipeline (`core/pipeline.js`)
+
+`runIntent(text, opts)` stages (each honest about availability):
+1. **Intent Engine** `parse(text)` → structured intent (extract budget like
+   "under $1" → maxBudget).
+2. **Capability Graph** `findTools` → candidate tools.
+3. **Economic Planner** `planGoal` → costed plan.
+4. **SpendGuard** `createTaskSpendGuard` → budget check vs `maxBudget`
+   (opts override; default from config). Over → refuse (exit 4).
+5. **Router** `selectTool`/`choosePath` → route.
+6. **x402/MCP execution** via execution kernel — ONLY if a live executable route
+   exists; otherwise return `disposition: 'no executable route available'`
+   with `subsystemStatus` honest, no fake execution.
+7. **Effect Proof** `issueEffectProof`/`verifyEffectProof`.
+8. **Settlement** `resolve` → settlement state recorded; UNKNOWN → exit 5 path.
+9. **Delivery + Reconciliation** → receipt.
+10. **RevRule** `createEmitter` → emit economic event (idempotent).
+
+Options: `maxBudget, deadline, speed ('fast'|'balanced'|'cheap'), risk
+('low'|'medium'|'high'), networks[], assets[], providers[], approvalThreshold,
+idempotencyKey, timeoutMs, dryRun`.
+
+`runAction(name, args, {deps}={})` — `deps` is an internal/test seam allowing
+subsystem handle overrides. Document as internal.
+
+## 7. CLI contract (`bin/callx402.js`)
+
+```
+callx402 <command> [args] [options]
+callx402 "natural language intent"        # intent mode
+callx402 --help | -h
+callx402 --version | -v
+callx402 status [--json]
+callx402 diagnose [--target ...] [--json]
+callx402 rescue --incident <id> [--json]  # auth-gated; without auth -> clear error
+callx402 route --goal <text> [--json]
+callx402 resolve --evidence <json|@file> [--json]
+callx402 doctor [--json]
+callx402 execute --intent <text> [--max-budget 1.00] [--dry-run] [--idempotency-key K]
+callx402 monitor [--once|--watch] [--json]
+callx402 preflight [--json]
+callx402 inspect [--query <text>] [--json]
+callx402 config list | get <k> | set <k> <v>
+```
+- Global: `--json` (envelope on stdout), `--timeout <ms>`.
+- Unknown command → usage error, exit 2, list valid commands.
+- Malformed input (bad JSON, bad flags) → exit 2 with clear message.
+- Default (no --json): concise human-readable summary + key fields.
+
+## 8. JS SDK (`sdk/js/index.js`)
+
+```js
+const { callx402 } = require('callx402'); // or require('./sdk/js')
+const result = await callx402({
+  intent: 'complete this job for under $1',
+  maxBudget: 1.00, deadline: '2026-10-07T00:00:00Z',
+  speed: 'balanced', risk: 'low',
+  networks: ['base'], assets: ['USDC'], providers: [],
+  approvalThreshold: 5.00, idempotencyKey: '...', timeoutMs: 30000, dryRun: false,
+});
+// result: envelope (see §4). Also export: callx402.version, callx402.status(), sub-actions
+// callx402.diagnose(), .rescue(), .route(), .resolve(), .doctor(), .execute(), .monitor(), .preflight(), .inspect()
+```
+Requires `../..` core directly (same process). No duplication.
+
+## 9. Python SDK (`sdk/python/`)
+
+- `pyproject.toml`: name `callx402`, version `0.1.0`, `console_scripts: callx402 =
+  callx402.cli:main`. Bundles `../../bin` + `../../core` as package data;
+  at runtime finds `node` via `shutil.which('node')` and invokes the bundled
+  `bin/callx402.js --json`. If node missing → clear RuntimeError.
+- `callx402/__init__.py`: `def callx402(intent=None, max_budget=None, deadline=None,
+  speed=None, risk=None, networks=None, assets=None, providers=None,
+  approval_threshold=None, idempotency_key=None, timeout_ms=None, dry_run=False,
+  action=None, **kwargs) -> dict`. Maps kwargs → CLI argv, parses stdout JSON.
+  Internal helper module may be named `call_x402.py` ONLY if needed for
+  snake_case conventions; the PUBLIC import stays `callx402`.
+- `callx402/cli.py`: `main()` with argparse mirroring the node CLI surface
+  (subset: command + common options + --json passthrough).
+
+## 10. HTTP server (`server/index.js`, node:http only)
+
+- `GET /health` → `{ok, version, subsystems: {...}}` (reuse getStatus).
+- `GET /openapi.json` → serves openapi.yaml as JSON (convert or embed).
+- `POST /call` → `{intent, maxBudget, deadline, speed, risk, networks, assets, providers, approvalThreshold, idempotencyKey, dryRun}` → runIntent.
+- `POST /rescue` → `{incidentId, ...}` → rescue dispatch.
+- `POST /route` → `{goal, ...}` → router dispatch.
+- `POST /resolve` → `{evidence}` → settlement resolve.
+- `POST /diagnose` → `{target/evidence}` → doctor dispatch.
+- Auth: if `CALLX402_AUTH_TOKEN` set, require `Authorization: Bearer` — else 401.
+- `openapi.yaml`: document all routes + envelope schema.
+
+## 11. Docs
+
+- `docs/README.md`: what callx402 is (the action), what it is not (not the product
+  name), architecture diagram (brand → callx402 → subsystems), quickstart
+  (install from GitHub, `callx402 status`, `callx402 "…"`, SDK snippets),
+  money-safety rules, link to v2.0.0 subsystem docs.
+- `docs/ACTION_LANGUAGE.md`: the five behavioral phrases, framed as usage
+  language, explicitly NOT trademark claims.
+- `docs/MCP_IDENTITY.md`: DEFERRED. Proposed pattern: server name tied to future
+  flagship brand; tool `[future_brand]_call`; description "Call x402
+  infrastructure for routing, rescue, diagnosis, settlement resolution and
+  execution." Rationale for avoiding bare `call_x402` (live collision on
+  fiatdock). Mark clearly: DO NOT FINALIZE until flagship brand chosen.
+
+## 12. Definition of done (per builder)
+
+- `node bin/callx402.js --help`, `--version`, `status` all work for real.
+- Every command dispatches to the real subsystem or reports honestly why not.
+- `npm install` works offline (zero deps). `npm link` exposes `callx402`.
+- Python: `pip install -e ./sdk/python` works; `python -c "import callx402"`.
+- No file written under v2.0.0. No publish attempted.
+- Smoke-test every command you build and report the literal outputs.