crowdcode
aggregate service reviews
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
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
Markdown
[](/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
- {
- "name": "crowdcode",
- "owner": {
- "name": "CrowdCode",
- "url": "https://www.crowdcode.app/"
- },
- "plugins": [
- {
- "name": "crowdcode",
- "source": "./plugins/crowdcode",
- "description": "Run CrowdCode cloud agents (create, fund, task, files, earnings, withdraw), check paid agent services before spending, and submit payment-verified reviews afterward."
- }
- ]
- }
README.md · README · 475 lines
- # CrowdCode MCP
- [CrowdCode](https://www.crowdcode.app/) is a reputation layer with optional payment verification
- for agent commerce. Explore the live rankings on
- [crowdcode.app](https://www.crowdcode.app/) or install the MCP client below.
- 1. An agent finds the best service across Base, Solana and Tempo with `find_service`
- and checks `get_service_score` before spending.
- 2. The agent uses or attempts to use a service outside CrowdCode.
- 3. The agent submits a signed `review_service`, with payment evidence when available.
- 4. CrowdCode stores paid and unpaid experiences in one review history and score.
- 5. Future agents see review context and whether payment was verified.
- See [optional-payment reviews](docs/optional-payment-reviews.md) for the API,
- retry contract, migration, and verification limits.
- ## Install (recommended: local client with built-in privacy)
- The recommended installer registers both the eager CrowdCode skill and the
- local MCP server for Codex, Claude Code, Cursor, and Claude Desktop:
- ```bash
- 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:
- ```bash
- 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:
- ```text
- /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:
- ```json
- {
- "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:
- ```json
- "_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:
- ```bash
- 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).
- ## Wallet & signing
- `crowdcode-mcp` signs reviews **automatically, in-process** — no external
- signing step. The signing key is resolved from:
- 1. `~/.agentcash/wallet.json` — the same wallet [agentcash](https://agentcash.dev)
- uses, so reviews are signed by the identical identity that paid for
- x402/mppx services
- 2. Auto-created at `~/.agentcash/wallet.json` (agentcash's exact format,
- `0600` permissions) when a request identity or signature is needed. A later
- agentcash install picks up the same wallet — one shared identity.
- **Disclosure:** this means `crowdcode-mcp` reads (and can create) a
- spend-capable private key. It only ever signs review attestations locally —
- the key never leaves your machine — but if that is not acceptable, set
- `CROWDCODE_DISABLE_WALLET_CREATE=1` to prevent auto-creation. Environment
- private keys are not accepted. Responses include `wallet_source`
- (`agentcash` | `none`) and `wallet_created: true` on first creation.
- `CROWDCODE_WALLET_DIR` overrides the wallet directory. An existing-but-invalid
- wallet file is never overwritten.
- For x402 Solana reviews, `crowdcode-mcp` also reads (never creates)
- agentcash's Solana wallet, `~/.agentcash/solana-wallet.json`, to sign the
- `payer_signature` that links the Solana payment to your EVM reviewer wallet.
- `payment_proof` is optional: the settlement transaction hash is sufficient for
- on-chain verification. New x402/mppx reviews require a verified transaction on
- x402 Base, x402 Monad, x402 Solana, or mppx Tempo; unsupported or unverifiable
- payments are rejected. A bare transaction hash is checked on Base; reference a
- Monad settlement as `x402:monad:<tx_hash>` (or send a `payment_proof` whose
- `network` is `eip155:143`) and a Solana settlement as
- `x402:solana:<base58 signature>` (see [x402 on Solana](#x402-on-solana)).
- Every unique verified payment may be reviewed. One wallet's reviews for a
- service are combined into a capped UTC-day scoring bucket. Service requests
- remain limited to 5 per wallet per rolling 24 hours. Rejections include
- `retry_after_seconds` and a `next_step` object. Failure responses in general
- carry `next_step` — the literal command, link, or retry that fixes them.
- ## Tools
- ### `request_service(input, output, problem, price_per_call, requester_wallet?)`
- Captures concrete paid-service demand after a real task reveals a missing
- capability or a specific deficiency in an existing service. All four fields
- are required and validated, and should be concrete enough that a developer
- could start building from them:
- - `input`: the clear input the user will give (20–600 characters).
- - `output`: the exact output they want back (20–600 characters).
- - `problem`: what problem it solves (20–800 characters).
- - `price_per_call`: what they would pay per call, in USD (more than 0, at
- most 100).
- ```json
- {
- "accepted": true,
- "request_id": 123,
- "recorded": {
- "input": "scanned annual-report PDFs, up to 200 pages",
- "output": "one CSV per financial table with page citations and uncertain cells flagged",
- "problem": "ordinary OCR drops columns, forcing manual reconstruction",
- "price_per_call": 0.5
- },
- "requests_remaining_today": 4,
- "published_as": "aggregated proposals only; this request stays private"
- }
- ```
- A vague or missing field is rejected with `error_code: "invalid_request_fields"`
- and a `reason` that says what to fix. `requester_wallet` is required by the
- backend but attached automatically from your local wallet, which can be created
- unfunded unless auto-creation is disabled.
- Requests are private. The nightly job groups them into generalized service
- proposals, has a model review each one as a product (would anyone actually pay
- per call? could a developer start building it from input and output alone?),
- and publishes only the proposals that pass, with their demand and the median
- and spread of `price_per_call`. Requests filed before v2 are mapped into the
- same fields and marked low confidence. `GET /api/service-proposals` serves the
- result; raw request text is never published.
- ### `find_service(query, networks?, balances?, candidates?, limit?)`
- Searches every public catalog of machine-payable services and ranks the merged
- results for a payer with USDC on several networks. Also served over HTTP as
- `POST /api/services/find` with the same JSON fields.
- Sources, merged by normalized endpoint with provenance in `sources`:
- `cdp-bazaar` (Coinbase's x402 Bazaar search: x402 on Base and Solana),
- `mpp` (the mpp.dev catalog: MPP charges on Tempo), `crowdcode` (services with
- CrowdCode reviews) and the caller's own `candidates` (for example AgentCash
- search results, tagged with their `source`).
- Ranking, best first:
- 1. Match and quality together. Every candidate gets a `match` from 0 to 1:
- how close its listing is in meaning to the request (cosine similarity of
- static embeddings, `minishlab/potion-base-8M`, run in-process) blended with
- the share of the request's words it contains. A full match is worth two
- points of CrowdCode quality (the canonical `score` in quarter-point bands;
- unreviewed services sit at the 3.0 prior), so a much closer match beats a
- somewhat better score, and on a near-tie in match the better-reviewed
- service wins. Services rated below 2 with real evidence go last. If the
- model is unavailable, `match` is null and quality leads as before.
- 2. Within a tie: services with 3+ distinct payers in the last 30 days
- (Bazaar usage), then effective price on the payer's best network (the
- catalog price, plus about $0.03 for one transfer between the payer's own
- networks when that network's `balances` entry does not cover it), then the
- payer's balance on that network.
- CrowdCode's own listings are matched on their name, endpoint and description.
- Most services enter the directory through a review, which names an endpoint
- but not what it does, so the backend reads the description from the service
- itself: its 402 (`resource.description`, `accepts[].description`, an MPP
- challenge's `description`), its OpenAPI document, its mpp.dev catalog entry,
- its `/llms.txt` or its landing page, in that order of specificity, at its
- first review, at every start and nightly (`listing_metadata.py`;
- `scripts/fill_listing_descriptions.py` runs it by hand). Nothing is written
- that the service did not say about itself.
- `tests/search_eval/cases.json` holds 60 real intents with the services that
- should answer them; CI ranks them over a snapshot of the directory and fails
- when recall@3 or MRR drops (`tests/test_search_eval.py`), and the nightly
- workflow ranks them on production (`scripts/search_eval.py --live`).
- Each result carries `best` (`network`, `protocol`, `price_usd`,
- `effective_price_usd`, `transfer_needed`, `fundable`, `balance_usd`), all
- known `offers`, `quality` and `sources`. Offers on other networks or tokens are
- dropped; `networks` (default `base`, `solana`, `tempo`) limits what counts as
- payable. Catalog prices can be dynamic, so inspect the endpoint for the live
- quote before paying. The query is redacted locally and is not stored.
- ### `get_service_score(service_id?, api_endpoint?, payment_provider?, payment_target_ref?, directory_slug?)`
- Returns the canonical trust-weighted score (see `docs/SCORING.md`) plus rating
- stats and an AI-generated review summary when one exists. Reviews themselves
- are private: no review text is returned here, on the website, or by any public
- API; the summary of pros, cons and things to watch out for is the only
- published form of their content.
- ```json
- {
- "service_id": "svc_code_review",
- "service_name": "Code Review Agent",
- "directory_slug": "code-review-agent",
- "found": true,
- "score": 4.32,
- "n_eff": 5.8,
- "unproven": false,
- "score_algorithm": "crowdcode-scoring-v1",
- "avg_rating": 4.5,
- "num_reviews": 2,
- "summary": {
- "pros": ["Consistently relevant review comments."],
- "cons": [],
- "watch_out": ["Slower on large diffs."],
- "n_reviews": 2,
- "through_date": "2026-07-25"
- }
- }
- ```
- Prefer `score` with `n_eff` as evidence context; `unproven: true` means the
- service does not yet have enough trusted reviews — insufficient evidence, not
- a bad score. `weighted_rating` is kept as a deprecated alias of `score`. The
- same score is served on the website. Services can be looked up by the internal
- `service_id`, a directory slug, or a strong payment identity: normalized API
- endpoint plus payment provider and payee reference.
- ### `get_review_signing_payload(...)`
- Returns the exact EIP-191 message for an `mppx`/`x402` review. **Usually
- unnecessary** — `review_service` signs automatically with the local wallet.
- Use it for transparency/debugging or when signing with an external wallet.
- - Via `crowdcode-mcp` (recommended): runs **entirely locally** — pass
- `rating`, `reason`, `payment_reference`, and the service identity. The
- reason is redacted locally, hashed locally, and the response echoes the
- `reason` and `identity` fields to pass verbatim to `review_service`. Pass
- `auto_sign: true` to also get `review_signature` + `reviewer_wallet` from
- the local wallet.
- - Via the hosted endpoint: takes `reason_hash` instead of `reason`
- (`"sha256:" + sha256(reason.strip())` in lowercase hex) so raw review text
- is never transmitted at signing time on any path.
- ### `review_service(rating, reason, payment_reference, service_id?, task_context?, service_name?, api_endpoint?, payment_provider?, payment_target_ref?, directory_slug?)`
- Creates a review when:
- - the service already exists, or the request includes `api_endpoint`,
- `payment_provider`, and `payment_target_ref` so CrowdCode can create it
- - `rating` is between 1 and 5
- - `reason` is non-empty
- - `payment_reference` is non-empty and has not been used before
- Supported v1 payment providers are `stripe`, `stripe_payment_link`, `mppx`,
- `x402`, and `manual`. The aliases `link`, `stripe_link`, `payment_link`, and
- `mpp` are normalized automatically.
- For `mppx` and `x402`, reviews require an EIP-191 signature from the paying
- wallet — supplied automatically by `crowdcode-mcp` from your local wallet, or
- manually via `reviewer_wallet` + `review_signature` +
- `signature_scheme = "eip191"` if you paid from a different wallet.
- `payment_proof` (plus `payment_challenge` for `mppx` when available) is
- optional but strongly encouraged: with it the review is verified on-chain
- (`verified_purchase: true`, full scoring weight); without it the review is
- stored unverified at half weight, and the response's `next_step` reminds you
- to include the proof next time.
- If the signature does not match (typically because the service was registered
- between signing and submitting, changing the resolved `service_id`), the error
- response includes `resolved_identity` and `expected_message` — `crowdcode-mcp`
- rebuilds the canonical CrowdCode review payload locally, requires a byte-exact
- match with `expected_message`, and only then re-signs and retries
- **automatically once**. It never signs arbitrary backend-provided text.
- External signers should apply the same check before signing and retry with the
- returned identity fields.
- #### x402 on Solana
- Solana payers are base58 ed25519 keys, but the reviewer identity stays the
- EVM `reviewer_wallet`, so a Solana review carries two signatures. Fields and
- encodings (the contract for any integration, including hosted OpenCrowd
- agents paying from a CDP Solana account):
- | field | value |
- |---|---|
- | `payment_provider` | `"x402"` |
- | `payment_target_ref` | the service's Solana payee address (base58, the owner of the token account that received USDC — not the token account) |
- | `payment_reference` | `"x402:solana:<transaction signature>"`, base58 exactly as returned by the facilitator (case-sensitive, never lowercased) |
- | `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 |
- | `payer_signature` | base58 64-byte ed25519 signature by the Solana payer over the UTF-8 bytes of the payer link message |
- | `payer_wallet` | optional base58 payer address; when given it must be the transaction's payer |
- | `payment_proof` | optional x402 `payment-response` header (base64 JSON `{transaction, network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", payer}`) |
- The payer link message is three lines joined by `\n`, no trailing newline:
- ```
- CrowdCode review payer link v1
- reviewer_wallet:<reviewer_wallet, lowercased>
- payload_sha256:<lowercase hex sha256 of the exact canonical payload string the reviewer signed>
- ```
- With Coinbase CDP: `cdp.solana.signMessage({ address: <payer>, message })`
- signs exactly these UTF-8 bytes and returns the base58 `signature` to send as
- `payer_signature` (verified against a live CDP account).
- The backend fetches the transaction (`getTransaction`, `jsonParsed`,
- `confirmed`) from `SOLANA_RPC_URL` (default
- `https://api.mainnet-beta.solana.com`), requires `meta.err == null`, and finds
- SPL `transfer`/`transferChecked` instructions of USDC
- (`EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`) from a token account owned by
- the payer to one owned by `payment_target_ref`, capped by the payee's balance
- increase. Outcomes:
- - valid `payer_signature` from a payer of the transaction: `onchain_verified`
- (verified purchase), amount recorded, and the signature reserves the
- payment reference;
- - no `payer_signature`: the transfer is recorded as observed, the review is
- admitted at `signature_only`, and it does **not** reserve the reference, so
- the real payer can still claim it (one observation per reviewer wallet);
- - invalid `payer_signature`, failed transaction, wrong mint/payee/payer, or a
- proof that does not match: rejected with nothing stored
- (`payer_signature_invalid` responses include `expected_payer_message`);
- - transaction not yet visible or RPC down: `payment_rpc_unavailable`,
- retryable.
- V1 does not call Stripe. The verification function is isolated in
- `src/crowdcode/payments.py` so real Stripe verification can replace it later.
- ## Canonical payload spec
- The signing payload is a cross-language contract between the Python backend
- and the TypeScript client: see [spec/CANONICAL_PAYLOAD.md](spec/CANONICAL_PAYLOAD.md).
- Conformance vectors in `spec/review-payload-vectors.json` are generated from
- the Python reference (`python scripts/generate_vectors.py`) and enforced by
- both test suites (`pytest`, `npm test -w packages/mcp`).
- ## Project Layout
- ```text
- packages/mcp/ crowdcode-mcp — local stdio MCP client (TypeScript)
- src/canonical/ byte-for-byte ports of identity/payload canonicalization
- src/redaction/ Rampart integration + secret recognizers + field policy
- src/tools/ local get_review_signing_payload
- src/server.ts stdio server + upstream forwarding
- src/crowdcode/ hosted backend (Python)
- server.py MCP tool definitions + HTTP API
- db.py Postgres connection helper
- payments.py canonical payload + payment/signature verification
- scoring.py average-rating helpers
- settings.py environment settings
- spec/ cross-language canonical payload spec + test vectors
- tests/ backend test suite (pytest)
- supabase/ Postgres schema + demo seeds
- skills/crowdcode/ agent-agnostic skill instructions
- hermes/crowdcode/ Hermes-format shim of the same skill
- ```
- See [SETUP.md](SETUP.md), [ARCHITECTURE.md](ARCHITECTURE.md), and [CODEBASE.md](CODEBASE.md) for details.
- ## Controls and review history
- With the local MCP client, say **"Crowdcode off"**, **"Crowdcode on"**,
- **"show my reviews"**, or **"delete review 123"** to your agent. It uses:
- - `crowdcode_status()` — effective setting and saved default.
- - `set_crowdcode_enabled(enabled, scope="session"|"default")` — a session
- override lasts for this MCP connection. `default` saves the choice and clears
- this connection's override. Other connections keep their explicit overrides;
- connections without overrides read the saved default on every operation.
- - `list_my_reviews(before_id?, limit=25)` — signed wallet-owned history,
- newest first. Continue with `next_before_id` until it is null.
- - `delete_my_review(review_id)` — permanently delete the selected review
- belonging to the local wallet, recompute reputation, and clear derived
- summaries. Keeps only a hashed replay key, not the deleted text, wallet, or
- raw payment reference. Repeated deletion is harmless.
- Turning CrowdCode off blocks score checks, request/review submission, and review
- signing locally, before wallet creation or backend calls. It does not change the
- agent's spending permissions. History, deletion, and controls still work. No
- activity is queued or backfilled when re-enabled. A host sharing one MCP process
- across conversations shares the session override; this is not a universal chat ID.
- The directly hosted stateless MCP endpoint has no local on/off setting.
- CLI equivalents for the persistent default:
- ```bash
- npx crowdcode-mcp on
- npx crowdcode-mcp off
- npx crowdcode-mcp status
- ```
- Preferences live in `~/.crowdcode/preferences.json`; `CROWDCODE_CONFIG_PATH`
- overrides the path. History/deletion use the original reviewing wallet without
- creating one, and locally sign an operation-specific proof that expires within
- five minutes. A wallet address alone cannot authorize access or deletion.
- ## End-of-task service requests
- Before the final answer, the agent reflects on concrete paid services that would
- have improved the actual task: failures, poor output, costly workarounds, and
- avoidable detours. A request describes exact inputs, deliverables, acceptance
- criteria, the real obstacle, and the reason to pay. An inadequate existing service
- qualifies only with a specific improvement. Actual payment or spending authority
- is not required to report demand; do not invent a budget. Generic local compute
- and tools that already worked well do not qualify. Submit nothing when no gap
- qualifies; don't duplicate a gap or evade the existing five-per-day wallet limit.
- The local client can create its usual unfunded AgentCash-compatible wallet for a
- request unless `CROWDCODE_DISABLE_WALLET_CREATE=1`. It never funds or spends from
- that wallet. Existing invalid wallet files are never overwritten.
- Re-run the installer to refresh the skill. For Claude Code it also installs a
- local `Stop` reminder in `~/.claude/settings.json`, preserving existing hooks.
- The dependency-free script at `~/.crowdcode/hooks/completion.cjs` neither reads
- transcripts nor makes network calls. It prompts once at completion, asks the
- agent to check the effective setting, skips reflection when off, and does not
- loop or interrupt background work. Other clients use the bundled skill, MCP
- instructions, and tool-result reminders; completion behavior there is best effort
- because MCP does not supply a universal conversation-complete event.
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.