1bitclaw-mcp

Current MM_WF engine version (UI + runner + agreement flag) and the FINALITY/minConf tables. Ask, never remember.

All 43 authoring step kinds with wire kind, role/dom/trust axes, runner support, icon and trust glyph. The ONLY legal source of step kinds for flow design — inventing a step.type is prohibited.

One step kind in depth: axes, finality (minConf + which policy produced it), design rationale (why), trust glyph and its meaning.

All on-chain OP_RETURN record types the app writes — parsed LIVE from docs/reference/opreturn-formats.md (the same table a human reads), not a hand-typed mirror, so it can never drift stale. Covers every module, not just contracts/flows: GP (post-need/social/discover), TK/TR/TC2/DR2 (taskboard), DN …

One OP_RETURN type in depth (all variants, e.g. DN has REG/UPD/RENEW/SELL/XFER/ESCROW/IDX): pipe-delimited template, positional fields (position 0 is usually the literal type tag, not a real value — occasionally a placeholder itself contains alternation like <MOVE|TP|MINE|COMMIT>, read template + de…

Which app modules can be DRIVEN through ui_action's set_field/click_action (type into a field, click a button) — extracted live from deploy/modules/*.js, not hand-maintained: a module opts in by exporting a small mcpFields/mcpActions literal next to its own registration, and appears here automatical…

The AG AGENT handler contract: the `sandbox` object a `function handler(event, sandbox)` is called with, the `event` it receives, and the JSON rule DSL the no-code path compiles — parsed live from the two real _createSandbox() implementations (deploy/modules/run-agent.js for runtimeMode "browser", i…

One sandbox method in depth: the full rationale comment from the source (anchor derivation, the WF_KICK convention, the pitfalls each method exists to avoid), the exact draft it returns (type / record template / anchors), and both implementations side by side with their real divergences. Call list_a…

The contract catalog (KNOWN_CONTRACTS × _coverage.json × _guide-en.json), filterable by category / authClass / headlessOnly / verifiedOnly / q. PAGED: returns {total, offset, shown, nextOffset, rows} with COMPACT rows (counts instead of the per-method lists) — the full unpaged dump is ~100 KB and ge…

Full catalog card for one contract: descriptions (EN), method list, per-method coverage matrix, and the THREE verification layers kept separate (verifiedTxid / readiness tier / manifest state — all manifest entries are quarantine today; never say "signed").

The contract's actual sCrypt-TS SOURCE (deploy/scrypt-sources/<slug>.ts — the same file the contract card's source viewer shows). Use it to answer questions about what a contract DOES: its asserts, its state transitions, why a method is participant- or owner-class. Paged: pass offset from nextOffset…

Full contract-functionality analysis for one contract (adapter-backed): constructor params with types + human descriptions + accepted formats, method ABI (params, types, authClass, feasibility verdict), state props, structs, template state, coverage + the three verification layers. Use before fillin…

LIVE on-chain instances from the contracts indexer snapshot (the same data the app's "My Positions" uses — read-only, 60s TTL; the MCP reads, signing/broadcast stay in the browser). Filters by contractName and/or owner (base58 address or 40-hex pkh). Each row: instanceId, contractName, genesisTxid, …

Derive the canonical Merkle payment schedule for a WorkflowEscrowV2 deploy: given the wfId and up to 64 leaves {stepIdx, mode, recipientPkh, maxSats}, returns wfIdHash (64-hex — put it in the card's wfIdHash field, never the raw wfId text), root (64-hex — the card's leavesRoot field), budget (sum of…

Fill-and-validate a contract field set against the adapter ABI: stage=deploy (constructor params — required; state props — genesis, defaulted) or stage=call (method params — Sig/PubKey fields are optional, the signer/executor produces them at broadcast). Returns per-field: given/required/value/error…

Deterministic verdict for one contract.method BEFORE inserting a contract step: headless-ok | participant-resolve | owner-quota | proof-blocked | intent-only | unknown-method | not-in-catalog. proof has priority over every other class.

G4 — WHO for a participant-class method: resolves the exact address that should receive the WF_ASSIGN from the SUPPLIED decoded instance state (same trust boundary as the runner — infra/lib/participants.mjs). verdict: resolved | ambiguous | none; includes the full participant list + the /contracts/<…

G5 (analysis half) — analyze a SUPPLIED decoded contract instance: state props with values, constructor params, method list, participant identities → assignable addresses, and the /contracts/<name>/<txid> link. Answers covenant-limit / paramMapping questions against the state the app already decoded…

G6 — S5 deploy gates from the LOCAL runner config (never guessed): adapter loaded, WF_CONTRACT_EXEC, WF_SPEND_WIF presence ONLY (never the key), WF_DEPLOY_CONTRACTS allowlist, MAX_FUND_SATS_DEPLOY ceiling, and the owner's policy.maxDeploySats from the supplied policy object. verdict: deploy-ok | dep…

Canonical site-relative deep link for an entity (board/node/run/template/contract/contractMethod/contractInstance/entity/outboxDraft/inboxAssignment). Returns null for anything private or off-allowlist — never invent URLs yourself.

Freshness report: engine versions, source counts, generated stamps, file mtimes, and the five parity gates to run — any red gate means every catalog answer is stale (treat accordingly).

G1 — run the REAL mindmap.js compiler (same __test code path the browser uses) on a board JSON: per-step rows (type/actor/sats/headlessOnly/errors) + the flow facts (money sheet, actor map, caps, risks). Read-only: no outbox, no broadcast. Needs Playwright+Chromium (repo devDeps).

The shape of the board JSON the design tools pass around — read this BEFORE create_board. The 16 node types (with icon/label/description/category, and which are offered in the canvas's Simple mode) and the 7 link kinds, each with what it does to COMPILE ORDER: depends_on/references put the target BE…

Create a fresh draft board (root node only) — the working draft the agent then extends with add_node and validates with preview_compile/preflight/simulate. Pure: nothing is written anywhere; returns the board JSON for the next tool in the chain.

Append a node to a draft board (immutably). node.type is validated against the LIVE node catalog (mindmap.js NODE_TYPE_DEFS — never a hardcoded list); actionSpec must be valid JSON and is checked against the canvas preset for its kind, returning advisory `specWarnings` (missing fields, a string wher…

Ask the REAL compiler about ONE step, now — instead of finding out at preflight. Runs mindmap.js's own per-step checks (_stepPreflightIssues + normSpec) over jsdom, ~10ms warm, no browser: the same messages the step form shows ("Set a date/time or block height above", "Pick a contract node (or paste…

Append a link between two existing nodes (immutably), in the app's own {id, fromId, toId, kind, createdAt} shape. DIRECTION MATTERS and is not symmetric: `depends_on` (the default) and `references` mean the TARGET runs BEFORE the source — "A depends_on B" puts B first — while sends_on/grants/publish…

Patch a node's editable fields (title / actionSpec / type / parentId). actionSpec is validated as JSON. Immutable: returns the new board JSON.

Cascade-delete a node + its descendants + all links touching them (same behavior as the app's delete). Refuses the root. Immutable: returns the new board JSON.

One tool, oneOf by cs.kind (§9.8): add a contract step node whose wire kind is contract_call for all three kinds — contract_call (method on an instance), contract_deploy (fund a new instance), sc_cond (chain condition). Cross-gates against the live catalog: the contract must exist, and contract_call…

G2 — assemble the exact unsigned WF_CTRL frame the runner verifies (add / add_trigger / remove_trigger / export / pause / resume / kill; pause/resume/kill/export are run-scoped and need runId). Returns {frame, signatureRequired, signer} — the CLIENT signs and broadcasts; MCP never holds keys. Nothin…

G2 — assemble the exact WF_STEP|done record the app builds when a human resolves a step (mindmap.js _finalizeStepRecord): {wfId, runId, stepIdx, actorAddr, payload?} → record + anchors. The ACTOR signs and broadcasts it from their own wallet — MCP never holds keys.

G8 — the template catalogue (mindmap-templates.js, the SAME seed the gallery instantiates): id/title/category/desc/node+link counts/headlessOnly. Filter by category or free-text q.

G8 — full template body (nodes with actionSpec objects, links, placeholders) for instantiation in the browser. Templates are authoring seeds — the compiler validates after instantiation. NOTE: the bodies still carry SEED TOKENS (<ADDR:payee>, <TS:+30d>); mindmap.js _applyTplTokens resolves them in t…

G9 — text search over the contract catalog: name, aliases, category, descEn, methods, useCases. This is the filter list_contracts was missing ("escrow", "royalty", a method name).

G10 — per-board requireConf/minConf: for every step on the board, the minConf its wire kind demands (same FINALITY tables engine_version reports), plus the board-wide max = requireConf. Strict: board required.

G3 (analysis half) — classify the WF_RUN/WF_STEP/WF_ASSIGN/WF_CTRL breadcrumbs the caller already has: per-run status, step progress, last movement, stall level (slow/stuck — the UI's real 24h/7d thresholds), txids, and ?run=&step=&stall= deep links when the wfId→boardId is resolvable. The server ne…

G11 (Path B, §9.8) — generate a standalone sCrypt adapter DRAFT from the compiled artifact.json the agent already has (npx scrypt-cli compile), via the repo's real scrypt-adapter-gen.mjs. The draft lands in infra/mcp/.state/adapter-drafts/ — outside the live site AND outside the deployed directory, …

G14 — read the local request audit trail (infra/mcp/.state/_mcp-audit.jsonl): who/what/when for every tools/call (arguments summarized — boards/artifacts are shape-logged, never their body). Filter by tool, cap with limit.

Run the REAL Review & Prepare safety matrix (mindmap.js _flowPreflight): validity / people / money / runner / privacy checks with statuses (ready/warning/manual/blocked) + the publish gate verdict. Read-only: no outbox, no broadcast.

Deterministic offline walk of the flow (the SAME _simulateWalk the UI "▶ Simulate" button runs): branch/transform evaluate for real on the mock ctx, chain-bound gates resolve to their honest defaults (branch/wait → not met → onTimeout/pause; decision → opts.decisions[<nodeId>] or the walk pauses). Z…

G7 — wfId→boardId resolver: parse MM_WF records (v1/v2 wire format) the caller already has, or explicit {wfId, boardId} pairs, and get the canonical ?run= deep link. link_for("run") needs boardId; this is the missing step between run observation (wfId/runId) and a clickable link.

Classify outbox draft(s): record kind (MM_WF / WF_POLICY / WF_STEP / WF_ASSIGN / WF_CTRL / SC|D / SC|I / …), sats, anchors, status, bundle, and the /v3/outbox/<draftId> deep link. Input: items (outbox item JSONs), records (raw record strings), or draftIds already in the local pending file.

Diagnose FAILED outbox drafts (status:failed + the error string the app recorded via markFailed) and optionally FIX them. Supply the failed outbox item JSONs from the app — open_context.outbox.recent lists them, failed first, with the error string (or draftIds from the server pending file). Each row…

Assemble the exact draft(s) the app would queue into the Outbox. In the site chat the drafts are pushed straight into THIS browser's outbox over the live connection and the returned /v3/outbox/<draftId> link lands on the card; the server-side copy (infra/mcp/.state/_mcp-outbox.json) is an operator r…

Arm a PUBLISHED headless workflow so it starts running on its own. A published flow does NOT run by itself: a run is born from `WF_CTRL add` or from a trigger firing — there is no WF_CTRL "start" op — so without a trigger a freshly published workflow just sits there. This builds the MM_WF_TRIG defin…

SC|D deploy draft — build the REAL locking script from the adapter (createLockingScript) + the canonical SC|D index record/anchors, and place an unsigned scrypt_deploy draft (pushed live into the browser Outbox in the site chat; the server keeps an operator-side copy). The OWNER signs + broadcasts i…

Method-call draft for a LIVE contract instance. mode=intent (default): SC|I scrypt_call that indexes the intended call — the owner signs the real spend from the Outbox (always safe). mode=spend: SC|C scrypt_spend via the REAL createSpendDraft — the executable draft the beta executors run (check the …

Pay BSV to ONE or MANY addresses in a single transaction: assembles the exact `wallet_payment` draft the Wallet page's 💸 Send button queues (type:payment, paymentOutputs[]) and places it in the Outbox — pushed live into THIS browser's Outbox in the site chat (link /v3/outbox/<draftId>); the user re…

Write FREE-FORM data to the chain: a UTF-8 text record in an OP_RETURN output (plus optional anchors — "#tag"s the browser derives into 1-sat anchor outputs, or addresses — so the record is findable under that tag/address later). Assembles the generic `record`+`anchors` draft every app module's own …

READ-ONLY chain lookup via the public WhatsOnChain API (no keys, nothing signed). kind=balance {address, needSats?} → confirmed/unconfirmed/total sats + BSV, and with needSats an `enough`/`shortfallSats` verdict that already includes fee + change headroom — use it with ctx.wallet.address BEFORE queu…

Turn a place NAME into coordinates + geohash cells via Nominatim (OpenStreetMap's public geocoder — no key). Call it ONCE per place and reuse the values already in this conversation for follow-up questions about the same place — do NOT call it again "to be sure". If you ALREADY have lat/lon or a geo…

Pure offline geohash math — no network, instant, never rate-limited. Pass either `hash` (a geohash you already have — from geocode_place, a link, or the user) or `lat`+`lon`, and get back geo2/geo4/geo6, the canonical anchor `geo4` + its `#geo_<hash4>` tag, `cellsNear4` (anchor cell + its 8 neighbor…

Read the LIVE public indexer snapshots — the same data the app itself shows. Call with NO arguments to get the catalogue of kinds and their selects. kinds: profiles (people, skills, reputation) · market (tasks/agents/apps/proofs — the taskboard feed) · dns (.bit names, owners, expiry, sale status) ·…

OBSERVE workflow runs from the live indexer — the half analyze_wf_runs never had (that one classifies records you already hold; this one fetches them). kind=list → every run newest-first with status, progress (step n/N), age and a stall verdict (slow ≥24h, stuck ≥7d — the UI's own constants); filter…

Find records by ANCHOR — the address every write pays 1 sat to, which is what makes a topic searchable at all. by=geo (a geohash: what is posted in that cell — geo4 is where posts actually anchor, a deeper hash is usually empty) · by=dns (one .bit name's full history) · by=tag (a USER hashtag, colli…

Explain ONE record: pass `record` (the OP_RETURN text) or `txid` (read every OP_RETURN in that transaction). Matches the record against its documented template from docs/reference/opreturn-formats.md and returns NAMED fields — the answer to "what is this transaction?", which chain_query kind=tx coul…

What will this cost, and what is that in money? kind=record {record, anchors?} → the fee for writing that exact OP_RETURN (the same size formula the browser uses) · kind=payment {outputs:[{sats}], inputs?} → fee + total for a payment, with dust warnings · kind=bytes {bytes} → fee for a tx of that si…

Verify a transaction the trust-minimised way — the same SPV path the workflow runner uses for its confirmation gate: merkle proof → computed root → block header checked by its own proof-of-work → cross-checked against a SECOND independent provider. chain_query kind=tx only repeats what one API says;…

Compose a real app record through a module's OWN builder — the write path that does NOT need the module open on the right wizard step (unlike ui_action set_field/click_action). Call with no module to list what is available; call with `module` to see that module's kinds and fields. Then {module, kind…

Read the CURRENT app open-context snapshot the site chat widget pushed with this turn. Keys: view + route (where the user is); board {id,title,selId,nodes[] with actionSpec summaries, selNode with its FULL params/paramMapping}; contract {name, view, fields[] — every field of the open card incl. the …

Ask the chat widget to open/act on a UI surface in the app (the widget executes it in the browser — the server never clicks anything itself). Actions: open_file_picker (focus a board node and open its file attach dialog — the file is then encrypted + queued by the app), open_contract (navigate to /c…