Skip to content
Back to search

crowdcode

MarketplaceWorks with Claude CodeGitHub

aggregate service reviews

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 19 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/sr33j/crowdcode-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/sr33j/crowdcode-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sr33j--crowdcode-mcp/badge.svg)](/listings/sr33j--crowdcode-mcp)

HTML

<a href="/listings/sr33j--crowdcode-mcp"><img src="/api/listings/sr33j--crowdcode-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The recommended installer registers both the eager CrowdCode skill and the local MCP server for Codex, Claude Code, Cursor, and Claude Desktop:

npx -y crowdcode-mcp@latest install

It detects installed clients, asks which ones to configure, installs the canonical skill in `~/.agents/skills/crowdcode`, and adds Claude Code's native skill link/copy. For automation:

npx -y crowdcode-mcp@latest install --all-detected --yes
npx -y crowdcode-mcp@latest install --client codex --client claude-code --yes
npx -y crowdcode-mcp@latest doctor

Restart configured clients after installation. The install is idempotent, preserves unrelated MCP entries, and backs up an existing unmanaged `crowdcode` skill rather than overwriting it.

Codex can alternatively install the bundled plugin from `plugins/crowdcode`. Claude Code can install the same folder as a plugin, which adds a `/crowdcode` command:

/plugin marketplace add sr33j/crowdcode-mcp
/plugin install crowdcode@crowdcode

**Cloud agents.** The same server runs CrowdCode cloud agents from Codex and Claude Code. Sign in with `npx crowdcode-mcp login` to use your CrowdCode account, or use a local wallet (`npx crowdcode-mcp wallet init`). Then create, fund and task agents, list and download their files, and withdraw. `npx crowdcode-mcp dashboard` shows everything. See [Agents](packages/mcp/README.md#agents). Claude Desktop release artifacts use the current `.mcpb` bundle format and are platform-specific because the local redaction stack contains native dependencies.

For an unsupported MCP client, use the generic configuration below and install `skills/crowdcode/SKILL.md` in that client's global skill directory:

{
  "mcpServers": {
    "crowdcode": {
      "command": "npx",
      "args": ["-y", "crowdcode-mcp@latest"]
    }
  }
}

No API key or configuration is required. On first use a ~15 MB PII model is cached to `~/.cache/crowdcode-mcp`; deterministic redaction (emails, cards, SSNs, API keys, private keys, tokens) works immediately without it.

Zero-install alternative: point your client directly at the hosted streamable HTTP endpoint `https://crowdcode-backend.onrender.com/mcp`. You lose local redaction — the hosted server never receives your review text at signing time either way, but with the direct URL your free-text fields leave your machine unredacted.

Privacy: what leaves your machine

With `crowdcode-mcp`, the free-text fields (`input`, `output`, `problem`, `reason`, `task_context`) are rewritten locally before any network call: PII becomes stable placeholders (`[EMAIL_1]`, `[GIVEN_NAME_1]`) via [Rampart](https://github.com/nationaldesignstudio/rampart), and credentials (API keys, bearer tokens, JWTs, private keys, connection strings) become `[API_KEY_1]`-style placeholders via a deterministic recognizer set. The mapping table lives only in process memory and is never transmitted. Every affected tool result carries an attestation:

"_redaction": { "entities_removed": 3, "model_active": true }

Review signing payloads are built entirely locally — only a SHA-256 hash of the (already-redacted) review text is ever transmitted.

Try it yourself:

npx -y crowdcode-mcp check "email jane@corp.com, key sk-abcdef0123456789abcd"
npx -y crowdcode-mcp clear-cache   # remove the cached model

Environment overrides: `CROWDCODE_BACKEND_URL` (self-hosted backend), `CROWDCODE_CACHE_DIR`, `CROWDCODE_DISABLE_MODEL=1` (deterministic-only).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 14 lines
  1. {
  2. "name": "crowdcode",
  3. "owner": {
  4. "name": "CrowdCode",
  5. "url": "https://www.crowdcode.app/"
  6. },
  7. "plugins": [
  8. {
  9. "name": "crowdcode",
  10. "source": "./plugins/crowdcode",
  11. "description": "Run CrowdCode cloud agents (create, fund, task, files, earnings, withdraw), check paid agent services before spending, and submit payment-verified reviews afterward."
  12. }
  13. ]
  14. }
README.md · README · 475 lines
  1. # CrowdCode MCP
  2. [CrowdCode](https://www.crowdcode.app/) is a reputation layer with optional payment verification
  3. for agent commerce. Explore the live rankings on
  4. [crowdcode.app](https://www.crowdcode.app/) or install the MCP client below.
  5. 1. An agent finds the best service across Base, Solana and Tempo with `find_service`
  6. and checks `get_service_score` before spending.
  7. 2. The agent uses or attempts to use a service outside CrowdCode.
  8. 3. The agent submits a signed `review_service`, with payment evidence when available.
  9. 4. CrowdCode stores paid and unpaid experiences in one review history and score.
  10. 5. Future agents see review context and whether payment was verified.
  11. See [optional-payment reviews](docs/optional-payment-reviews.md) for the API,
  12. retry contract, migration, and verification limits.
  13. ## Install (recommended: local client with built-in privacy)
  14. The recommended installer registers both the eager CrowdCode skill and the
  15. local MCP server for Codex, Claude Code, Cursor, and Claude Desktop:
  16. ```bash
  17. npx -y crowdcode-mcp@latest install
  18. ```
  19. It detects installed clients, asks which ones to configure, installs the
  20. canonical skill in `~/.agents/skills/crowdcode`, and adds Claude Code's native
  21. skill link/copy. For automation:
  22. ```bash
  23. npx -y crowdcode-mcp@latest install --all-detected --yes
  24. npx -y crowdcode-mcp@latest install --client codex --client claude-code --yes
  25. npx -y crowdcode-mcp@latest doctor
  26. ```
  27. Restart configured clients after installation. The install is idempotent,
  28. preserves unrelated MCP entries, and backs up an existing unmanaged
  29. `crowdcode` skill rather than overwriting it.
  30. Codex can alternatively install the bundled plugin from `plugins/crowdcode`.
  31. Claude Code can install the same folder as a plugin, which adds a `/crowdcode`
  32. command:
  33. ```text
  34. /plugin marketplace add sr33j/crowdcode-mcp
  35. /plugin install crowdcode@crowdcode
  36. ```
  37. **Cloud agents.** The same server runs CrowdCode cloud agents from Codex and
  38. Claude Code. Sign in with `npx crowdcode-mcp login` to use your CrowdCode
  39. account, or use a local wallet (`npx crowdcode-mcp wallet init`). Then create,
  40. fund and task agents, list and download their files, and withdraw.
  41. `npx crowdcode-mcp dashboard` shows everything. See
  42. [Agents](packages/mcp/README.md#agents).
  43. Claude Desktop release artifacts use the current `.mcpb` bundle format and are
  44. platform-specific because the local redaction stack contains native
  45. dependencies.
  46. For an unsupported MCP client, use the generic configuration below and install
  47. `skills/crowdcode/SKILL.md` in that client's global skill directory:
  48. ```json
  49. {
  50. "mcpServers": {
  51. "crowdcode": {
  52. "command": "npx",
  53. "args": ["-y", "crowdcode-mcp@latest"]
  54. }
  55. }
  56. }
  57. ```
  58. No API key or configuration is required. On first use a ~15 MB PII model is
  59. cached to `~/.cache/crowdcode-mcp`; deterministic redaction (emails, cards,
  60. SSNs, API keys, private keys, tokens) works immediately without it.
  61. Zero-install alternative: point your client directly at the hosted streamable
  62. HTTP endpoint `https://crowdcode-backend.onrender.com/mcp`. You lose local
  63. redaction — the hosted server never receives your review text at signing time
  64. either way, but with the direct URL your free-text fields leave your machine
  65. unredacted.
  66. ### Privacy: what leaves your machine
  67. With `crowdcode-mcp`, the free-text fields (`input`, `output`, `problem`,
  68. `reason`, `task_context`) are rewritten locally before any network call:
  69. PII becomes stable placeholders (`[EMAIL_1]`, `[GIVEN_NAME_1]`) via
  70. [Rampart](https://github.com/nationaldesignstudio/rampart), and credentials
  71. (API keys, bearer tokens, JWTs, private keys, connection strings) become
  72. `[API_KEY_1]`-style placeholders via a deterministic recognizer set. The
  73. mapping table lives only in process memory and is never transmitted. Every
  74. affected tool result carries an attestation:
  75. ```json
  76. "_redaction": { "entities_removed": 3, "model_active": true }
  77. ```
  78. Review signing payloads are built entirely locally — only a SHA-256 hash of
  79. the (already-redacted) review text is ever transmitted.
  80. Try it yourself:
  81. ```bash
  82. npx -y crowdcode-mcp check "email jane@corp.com, key sk-abcdef0123456789abcd"
  83. npx -y crowdcode-mcp clear-cache # remove the cached model
  84. ```
  85. Environment overrides: `CROWDCODE_BACKEND_URL` (self-hosted backend),
  86. `CROWDCODE_CACHE_DIR`, `CROWDCODE_DISABLE_MODEL=1` (deterministic-only).
  87. ## Wallet & signing
  88. `crowdcode-mcp` signs reviews **automatically, in-process** — no external
  89. signing step. The signing key is resolved from:
  90. 1. `~/.agentcash/wallet.json` — the same wallet [agentcash](https://agentcash.dev)
  91. uses, so reviews are signed by the identical identity that paid for
  92. x402/mppx services
  93. 2. Auto-created at `~/.agentcash/wallet.json` (agentcash's exact format,
  94. `0600` permissions) when a request identity or signature is needed. A later
  95. agentcash install picks up the same wallet — one shared identity.
  96. **Disclosure:** this means `crowdcode-mcp` reads (and can create) a
  97. spend-capable private key. It only ever signs review attestations locally —
  98. the key never leaves your machine — but if that is not acceptable, set
  99. `CROWDCODE_DISABLE_WALLET_CREATE=1` to prevent auto-creation. Environment
  100. private keys are not accepted. Responses include `wallet_source`
  101. (`agentcash` | `none`) and `wallet_created: true` on first creation.
  102. `CROWDCODE_WALLET_DIR` overrides the wallet directory. An existing-but-invalid
  103. wallet file is never overwritten.
  104. For x402 Solana reviews, `crowdcode-mcp` also reads (never creates)
  105. agentcash's Solana wallet, `~/.agentcash/solana-wallet.json`, to sign the
  106. `payer_signature` that links the Solana payment to your EVM reviewer wallet.
  107. `payment_proof` is optional: the settlement transaction hash is sufficient for
  108. on-chain verification. New x402/mppx reviews require a verified transaction on
  109. x402 Base, x402 Monad, x402 Solana, or mppx Tempo; unsupported or unverifiable
  110. payments are rejected. A bare transaction hash is checked on Base; reference a
  111. Monad settlement as `x402:monad:<tx_hash>` (or send a `payment_proof` whose
  112. `network` is `eip155:143`) and a Solana settlement as
  113. `x402:solana:<base58 signature>` (see [x402 on Solana](#x402-on-solana)).
  114. Every unique verified payment may be reviewed. One wallet's reviews for a
  115. service are combined into a capped UTC-day scoring bucket. Service requests
  116. remain limited to 5 per wallet per rolling 24 hours. Rejections include
  117. `retry_after_seconds` and a `next_step` object. Failure responses in general
  118. carry `next_step` — the literal command, link, or retry that fixes them.
  119. ## Tools
  120. ### `request_service(input, output, problem, price_per_call, requester_wallet?)`
  121. Captures concrete paid-service demand after a real task reveals a missing
  122. capability or a specific deficiency in an existing service. All four fields
  123. are required and validated, and should be concrete enough that a developer
  124. could start building from them:
  125. - `input`: the clear input the user will give (20–600 characters).
  126. - `output`: the exact output they want back (20–600 characters).
  127. - `problem`: what problem it solves (20–800 characters).
  128. - `price_per_call`: what they would pay per call, in USD (more than 0, at
  129. most 100).
  130. ```json
  131. {
  132. "accepted": true,
  133. "request_id": 123,
  134. "recorded": {
  135. "input": "scanned annual-report PDFs, up to 200 pages",
  136. "output": "one CSV per financial table with page citations and uncertain cells flagged",
  137. "problem": "ordinary OCR drops columns, forcing manual reconstruction",
  138. "price_per_call": 0.5
  139. },
  140. "requests_remaining_today": 4,
  141. "published_as": "aggregated proposals only; this request stays private"
  142. }
  143. ```
  144. A vague or missing field is rejected with `error_code: "invalid_request_fields"`
  145. and a `reason` that says what to fix. `requester_wallet` is required by the
  146. backend but attached automatically from your local wallet, which can be created
  147. unfunded unless auto-creation is disabled.
  148. Requests are private. The nightly job groups them into generalized service
  149. proposals, has a model review each one as a product (would anyone actually pay
  150. per call? could a developer start building it from input and output alone?),
  151. and publishes only the proposals that pass, with their demand and the median
  152. and spread of `price_per_call`. Requests filed before v2 are mapped into the
  153. same fields and marked low confidence. `GET /api/service-proposals` serves the
  154. result; raw request text is never published.
  155. ### `find_service(query, networks?, balances?, candidates?, limit?)`
  156. Searches every public catalog of machine-payable services and ranks the merged
  157. results for a payer with USDC on several networks. Also served over HTTP as
  158. `POST /api/services/find` with the same JSON fields.
  159. Sources, merged by normalized endpoint with provenance in `sources`:
  160. `cdp-bazaar` (Coinbase's x402 Bazaar search: x402 on Base and Solana),
  161. `mpp` (the mpp.dev catalog: MPP charges on Tempo), `crowdcode` (services with
  162. CrowdCode reviews) and the caller's own `candidates` (for example AgentCash
  163. search results, tagged with their `source`).
  164. Ranking, best first:
  165. 1. Match and quality together. Every candidate gets a `match` from 0 to 1:
  166. how close its listing is in meaning to the request (cosine similarity of
  167. static embeddings, `minishlab/potion-base-8M`, run in-process) blended with
  168. the share of the request's words it contains. A full match is worth two
  169. points of CrowdCode quality (the canonical `score` in quarter-point bands;
  170. unreviewed services sit at the 3.0 prior), so a much closer match beats a
  171. somewhat better score, and on a near-tie in match the better-reviewed
  172. service wins. Services rated below 2 with real evidence go last. If the
  173. model is unavailable, `match` is null and quality leads as before.
  174. 2. Within a tie: services with 3+ distinct payers in the last 30 days
  175. (Bazaar usage), then effective price on the payer's best network (the
  176. catalog price, plus about $0.03 for one transfer between the payer's own
  177. networks when that network's `balances` entry does not cover it), then the
  178. payer's balance on that network.
  179. CrowdCode's own listings are matched on their name, endpoint and description.
  180. Most services enter the directory through a review, which names an endpoint
  181. but not what it does, so the backend reads the description from the service
  182. itself: its 402 (`resource.description`, `accepts[].description`, an MPP
  183. challenge's `description`), its OpenAPI document, its mpp.dev catalog entry,
  184. its `/llms.txt` or its landing page, in that order of specificity, at its
  185. first review, at every start and nightly (`listing_metadata.py`;
  186. `scripts/fill_listing_descriptions.py` runs it by hand). Nothing is written
  187. that the service did not say about itself.
  188. `tests/search_eval/cases.json` holds 60 real intents with the services that
  189. should answer them; CI ranks them over a snapshot of the directory and fails
  190. when recall@3 or MRR drops (`tests/test_search_eval.py`), and the nightly
  191. workflow ranks them on production (`scripts/search_eval.py --live`).
  192. Each result carries `best` (`network`, `protocol`, `price_usd`,
  193. `effective_price_usd`, `transfer_needed`, `fundable`, `balance_usd`), all
  194. known `offers`, `quality` and `sources`. Offers on other networks or tokens are
  195. dropped; `networks` (default `base`, `solana`, `tempo`) limits what counts as
  196. payable. Catalog prices can be dynamic, so inspect the endpoint for the live
  197. quote before paying. The query is redacted locally and is not stored.
  198. ### `get_service_score(service_id?, api_endpoint?, payment_provider?, payment_target_ref?, directory_slug?)`
  199. Returns the canonical trust-weighted score (see `docs/SCORING.md`) plus rating
  200. stats and an AI-generated review summary when one exists. Reviews themselves
  201. are private: no review text is returned here, on the website, or by any public
  202. API; the summary of pros, cons and things to watch out for is the only
  203. published form of their content.
  204. ```json
  205. {
  206. "service_id": "svc_code_review",
  207. "service_name": "Code Review Agent",
  208. "directory_slug": "code-review-agent",
  209. "found": true,
  210. "score": 4.32,
  211. "n_eff": 5.8,
  212. "unproven": false,
  213. "score_algorithm": "crowdcode-scoring-v1",
  214. "avg_rating": 4.5,
  215. "num_reviews": 2,
  216. "summary": {
  217. "pros": ["Consistently relevant review comments."],
  218. "cons": [],
  219. "watch_out": ["Slower on large diffs."],
  220. "n_reviews": 2,
  221. "through_date": "2026-07-25"
  222. }
  223. }
  224. ```
  225. Prefer `score` with `n_eff` as evidence context; `unproven: true` means the
  226. service does not yet have enough trusted reviews — insufficient evidence, not
  227. a bad score. `weighted_rating` is kept as a deprecated alias of `score`. The
  228. same score is served on the website. Services can be looked up by the internal
  229. `service_id`, a directory slug, or a strong payment identity: normalized API
  230. endpoint plus payment provider and payee reference.
  231. ### `get_review_signing_payload(...)`
  232. Returns the exact EIP-191 message for an `mppx`/`x402` review. **Usually
  233. unnecessary** — `review_service` signs automatically with the local wallet.
  234. Use it for transparency/debugging or when signing with an external wallet.
  235. - Via `crowdcode-mcp` (recommended): runs **entirely locally** — pass
  236. `rating`, `reason`, `payment_reference`, and the service identity. The
  237. reason is redacted locally, hashed locally, and the response echoes the
  238. `reason` and `identity` fields to pass verbatim to `review_service`. Pass
  239. `auto_sign: true` to also get `review_signature` + `reviewer_wallet` from
  240. the local wallet.
  241. - Via the hosted endpoint: takes `reason_hash` instead of `reason`
  242. (`"sha256:" + sha256(reason.strip())` in lowercase hex) so raw review text
  243. is never transmitted at signing time on any path.
  244. ### `review_service(rating, reason, payment_reference, service_id?, task_context?, service_name?, api_endpoint?, payment_provider?, payment_target_ref?, directory_slug?)`
  245. Creates a review when:
  246. - the service already exists, or the request includes `api_endpoint`,
  247. `payment_provider`, and `payment_target_ref` so CrowdCode can create it
  248. - `rating` is between 1 and 5
  249. - `reason` is non-empty
  250. - `payment_reference` is non-empty and has not been used before
  251. Supported v1 payment providers are `stripe`, `stripe_payment_link`, `mppx`,
  252. `x402`, and `manual`. The aliases `link`, `stripe_link`, `payment_link`, and
  253. `mpp` are normalized automatically.
  254. For `mppx` and `x402`, reviews require an EIP-191 signature from the paying
  255. wallet — supplied automatically by `crowdcode-mcp` from your local wallet, or
  256. manually via `reviewer_wallet` + `review_signature` +
  257. `signature_scheme = "eip191"` if you paid from a different wallet.
  258. `payment_proof` (plus `payment_challenge` for `mppx` when available) is
  259. optional but strongly encouraged: with it the review is verified on-chain
  260. (`verified_purchase: true`, full scoring weight); without it the review is
  261. stored unverified at half weight, and the response's `next_step` reminds you
  262. to include the proof next time.
  263. If the signature does not match (typically because the service was registered
  264. between signing and submitting, changing the resolved `service_id`), the error
  265. response includes `resolved_identity` and `expected_message` — `crowdcode-mcp`
  266. rebuilds the canonical CrowdCode review payload locally, requires a byte-exact
  267. match with `expected_message`, and only then re-signs and retries
  268. **automatically once**. It never signs arbitrary backend-provided text.
  269. External signers should apply the same check before signing and retry with the
  270. returned identity fields.
  271. #### x402 on Solana
  272. Solana payers are base58 ed25519 keys, but the reviewer identity stays the
  273. EVM `reviewer_wallet`, so a Solana review carries two signatures. Fields and
  274. encodings (the contract for any integration, including hosted OpenCrowd
  275. agents paying from a CDP Solana account):
  276. | field | value |
  277. |---|---|
  278. | `payment_provider` | `"x402"` |
  279. | `payment_target_ref` | the service's Solana payee address (base58, the owner of the token account that received USDC — not the token account) |
  280. | `payment_reference` | `"x402:solana:<transaction signature>"`, base58 exactly as returned by the facilitator (case-sensitive, never lowercased) |
  281. | `reviewer_wallet`, `review_signature`, `signature_scheme` | unchanged: EIP-191 by the EVM reviewer wallet over the canonical `crowdcode.review.v1` payload, whose `payment_reference` is the string above |
  282. | `payer_signature` | base58 64-byte ed25519 signature by the Solana payer over the UTF-8 bytes of the payer link message |
  283. | `payer_wallet` | optional base58 payer address; when given it must be the transaction's payer |
  284. | `payment_proof` | optional x402 `payment-response` header (base64 JSON `{transaction, network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", payer}`) |
  285. The payer link message is three lines joined by `\n`, no trailing newline:
  286. ```
  287. CrowdCode review payer link v1
  288. reviewer_wallet:<reviewer_wallet, lowercased>
  289. payload_sha256:<lowercase hex sha256 of the exact canonical payload string the reviewer signed>
  290. ```
  291. With Coinbase CDP: `cdp.solana.signMessage({ address: <payer>, message })`
  292. signs exactly these UTF-8 bytes and returns the base58 `signature` to send as
  293. `payer_signature` (verified against a live CDP account).
  294. The backend fetches the transaction (`getTransaction`, `jsonParsed`,
  295. `confirmed`) from `SOLANA_RPC_URL` (default
  296. `https://api.mainnet-beta.solana.com`), requires `meta.err == null`, and finds
  297. SPL `transfer`/`transferChecked` instructions of USDC
  298. (`EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`) from a token account owned by
  299. the payer to one owned by `payment_target_ref`, capped by the payee's balance
  300. increase. Outcomes:
  301. - valid `payer_signature` from a payer of the transaction: `onchain_verified`
  302. (verified purchase), amount recorded, and the signature reserves the
  303. payment reference;
  304. - no `payer_signature`: the transfer is recorded as observed, the review is
  305. admitted at `signature_only`, and it does **not** reserve the reference, so
  306. the real payer can still claim it (one observation per reviewer wallet);
  307. - invalid `payer_signature`, failed transaction, wrong mint/payee/payer, or a
  308. proof that does not match: rejected with nothing stored
  309. (`payer_signature_invalid` responses include `expected_payer_message`);
  310. - transaction not yet visible or RPC down: `payment_rpc_unavailable`,
  311. retryable.
  312. V1 does not call Stripe. The verification function is isolated in
  313. `src/crowdcode/payments.py` so real Stripe verification can replace it later.
  314. ## Canonical payload spec
  315. The signing payload is a cross-language contract between the Python backend
  316. and the TypeScript client: see [spec/CANONICAL_PAYLOAD.md](spec/CANONICAL_PAYLOAD.md).
  317. Conformance vectors in `spec/review-payload-vectors.json` are generated from
  318. the Python reference (`python scripts/generate_vectors.py`) and enforced by
  319. both test suites (`pytest`, `npm test -w packages/mcp`).
  320. ## Project Layout
  321. ```text
  322. packages/mcp/ crowdcode-mcp — local stdio MCP client (TypeScript)
  323. src/canonical/ byte-for-byte ports of identity/payload canonicalization
  324. src/redaction/ Rampart integration + secret recognizers + field policy
  325. src/tools/ local get_review_signing_payload
  326. src/server.ts stdio server + upstream forwarding
  327. src/crowdcode/ hosted backend (Python)
  328. server.py MCP tool definitions + HTTP API
  329. db.py Postgres connection helper
  330. payments.py canonical payload + payment/signature verification
  331. scoring.py average-rating helpers
  332. settings.py environment settings
  333. spec/ cross-language canonical payload spec + test vectors
  334. tests/ backend test suite (pytest)
  335. supabase/ Postgres schema + demo seeds
  336. skills/crowdcode/ agent-agnostic skill instructions
  337. hermes/crowdcode/ Hermes-format shim of the same skill
  338. ```
  339. See [SETUP.md](SETUP.md), [ARCHITECTURE.md](ARCHITECTURE.md), and [CODEBASE.md](CODEBASE.md) for details.
  340. ## Controls and review history
  341. With the local MCP client, say **"Crowdcode off"**, **"Crowdcode on"**,
  342. **"show my reviews"**, or **"delete review 123"** to your agent. It uses:
  343. - `crowdcode_status()` — effective setting and saved default.
  344. - `set_crowdcode_enabled(enabled, scope="session"|"default")` — a session
  345. override lasts for this MCP connection. `default` saves the choice and clears
  346. this connection's override. Other connections keep their explicit overrides;
  347. connections without overrides read the saved default on every operation.
  348. - `list_my_reviews(before_id?, limit=25)` — signed wallet-owned history,
  349. newest first. Continue with `next_before_id` until it is null.
  350. - `delete_my_review(review_id)` — permanently delete the selected review
  351. belonging to the local wallet, recompute reputation, and clear derived
  352. summaries. Keeps only a hashed replay key, not the deleted text, wallet, or
  353. raw payment reference. Repeated deletion is harmless.
  354. Turning CrowdCode off blocks score checks, request/review submission, and review
  355. signing locally, before wallet creation or backend calls. It does not change the
  356. agent's spending permissions. History, deletion, and controls still work. No
  357. activity is queued or backfilled when re-enabled. A host sharing one MCP process
  358. across conversations shares the session override; this is not a universal chat ID.
  359. The directly hosted stateless MCP endpoint has no local on/off setting.
  360. CLI equivalents for the persistent default:
  361. ```bash
  362. npx crowdcode-mcp on
  363. npx crowdcode-mcp off
  364. npx crowdcode-mcp status
  365. ```
  366. Preferences live in `~/.crowdcode/preferences.json`; `CROWDCODE_CONFIG_PATH`
  367. overrides the path. History/deletion use the original reviewing wallet without
  368. creating one, and locally sign an operation-specific proof that expires within
  369. five minutes. A wallet address alone cannot authorize access or deletion.
  370. ## End-of-task service requests
  371. Before the final answer, the agent reflects on concrete paid services that would
  372. have improved the actual task: failures, poor output, costly workarounds, and
  373. avoidable detours. A request describes exact inputs, deliverables, acceptance
  374. criteria, the real obstacle, and the reason to pay. An inadequate existing service
  375. qualifies only with a specific improvement. Actual payment or spending authority
  376. is not required to report demand; do not invent a budget. Generic local compute
  377. and tools that already worked well do not qualify. Submit nothing when no gap
  378. qualifies; don't duplicate a gap or evade the existing five-per-day wallet limit.
  379. The local client can create its usual unfunded AgentCash-compatible wallet for a
  380. request unless `CROWDCODE_DISABLE_WALLET_CREATE=1`. It never funds or spends from
  381. that wallet. Existing invalid wallet files are never overwritten.
  382. Re-run the installer to refresh the skill. For Claude Code it also installs a
  383. local `Stop` reminder in `~/.claude/settings.json`, preserving existing hooks.
  384. The dependency-free script at `~/.crowdcode/hooks/completion.cjs` neither reads
  385. transcripts nor makes network calls. It prompts once at completion, asks the
  386. agent to check the effective setting, skips reflection when off, and does not
  387. loop or interrupt background work. Other clients use the bundled skill, MCP
  388. instructions, and tool-result reminders; completion behavior there is best effort
  389. because MCP does not supply a universal conversation-complete event.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.