[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6M81CWMP6YX6AB2G2RMRN6S":3,"skill-same:01M6M81CWMP6YX6AB2G2RMRN6S":95},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":16,"sourceHtmlUrl":17,"categories":18,"keywords":24,"publishedAt":47,"linkOnly":48,"markdownContent":49,"markdownBody":50,"frontMatter":51,"refName":52,"commitSha":53,"skillDirectory":54,"forksCount":55,"repositoryHtmlUrl":56,"repositoryHomepageUrl":6,"ownerHtmlUrl":57,"ownerBlogUrl":58,"ownerDescription":59,"updatedAt":60,"install":61,"resources":74},"01M6M81CWMP6YX6AB2G2RMRN6S","proofforge",null,"Fix financial code in Lean 4 against a locked ProofForge specification and prove every requirement, checked by the ProofForge judge (six kernels, leanchecker, axiom audit, property tests) with a Passport as the result. Use when a task names a ProofForge task, a locked spec under spec\u002F, candidate\u002FSolution.lean, a requirement such as REQ-..., a Passport, or the proofforge MCP tools.","jiayaoqijia\u002Fcryptoskill","jiayaoqijia","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F1453879?v=4","01M6GMYTX7Q7S504VC6E756ENR","YQ","01M6GMYV1QKJ1CC75MTTGT9PR0",81,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FSKILL.md",[19],{"categoryNo":20,"categoryName":21,"taxonomyType":22,"taxonomyTypeDesc":23},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[5,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],"tests","when","prove","result","candidate","kernels","with","axiom audit","judge","axiom","as","MCP","task","specification","use","lean","fix","Tools","audit","mcp tools","code","spec","2026-11-10 10:12:30",false,"---\nname: proofforge\ndescription: Fix financial code in Lean 4 against a locked ProofForge specification and prove every requirement, checked by the ProofForge judge (six kernels, leanchecker, axiom audit, property tests) with a Passport as the result. Use when a task names a ProofForge task, a locked spec under spec\u002F, candidate\u002FSolution.lean, a requirement such as REQ-..., a Passport, or the proofforge MCP tools.\n---\n\n# ProofForge: fix, prove, check\n\nA ProofForge task is a Lean 4 (v4.35, core library, no Mathlib) project with a locked\nspecification. The only file you change is `candidate\u002FSolution.lean`. The task is done when\n`check_candidate` returns `\"status\": \"VERIFIED\"`: every requirement proved, the proofs accepted\nby six kernels, and the executable built from the same file passing the property tests. No proof,\nno merge: a fix that compiles but leaves a requirement `sorry`, REFUTED or UNRESOLVED is not done.\n\n## Tools (MCP server `proofforge`)\n\n| Tool | Use | Cost |\n|---|---|---|\n| `prior_attempts` | only in a resumed run: what earlier attempts proved (re-checked by Lean against your current file, with a file that installs it all) and how they failed on the goals they left open | once, first |\n| `show_task` | issue report, definitions under repair, every locked requirement (id, theorem, exact statement, plain-language text), the rules | instant |\n| `goal_at` | the exact proof state at each `sorry` (or error, or a given line) of one declaration | seconds |\n| `check_snippet_fast` | a lemma or proof attempt checked after the candidate on a persistent Lean session: errors, and the state at each `sorry` | seconds |\n| `try_tactics` | a fixed portfolio of tactics on one theorem proved by `sorry`; returns the proof that closes it | seconds |\n| `refute_statement` | a proposed helper statement evaluated on concrete values; FALSE comes with a kernel-checked counterexample | seconds |\n| `search_library` | ProofForgeFin theorems, tactics and simp sets; pass `goal` (a statement or a declaration name) to rank by the goal's shape | instant |\n| `try_snippet` | a full compile of a snippet after the candidate, without changing the file | a compile |\n| `lean_build` | Lean's own output: `lake build Solution`, or `lake env lean \u003Cfile>` for a scratch file; with the full toolset, also the required theorems the build proves and the best compiling version so far (`.proofforge\u002Fbest.lean`) | a compile |\n| `check_candidate` | the official check (`bin\u002Fproofforge check`): VERIFIED \u002F REFUTED \u002F UNRESOLVED per requirement, witnesses, kernel-checked counterexamples, Lean errors, sorry status, Passport | minutes |\n| `verify_passport` | reproduce a Passport (`bin\u002Fproofforge verify`) | minutes |\n| `list_tasks` | the task catalog | instant |\n\nThere is no local Lean installation in the shell; Lean runs through these tools. If a tool in\nthis table is not offered by the server, skip the step that uses it.\n\nNone of the tools edits `candidate\u002FSolution.lean`; you write every change yourself. A tool that\nfinds a proof (`try_tactics`) or proved declarations (`prior_attempts`) gives you their text.\n\nA response, its reasoning included, stops at an output limit of 32,000 tokens. A response cut\nthere is lost with everything it worked out, and a session can end after a few of them in a row.\nWork out the next step only and act on it in the same response, with a tool call or an edit; write\na long proof as `have` steps ending in `sorry` and check them one at a time, rather than working\nout the whole proof before the first call.\n\n## Workflow\n\n1. **Start from what is known.** In a resumed run, call `prior_attempts` first. Take the\n   declarations it re-checked (paste them, or copy\n   `.proofforge\u002Fprior-attempts\u002FSolution-with-carried.lean` over the candidate when you want them\n   all), and read its failure notes: do not repeat an approach that already failed on a goal.\n2. **Read the locked spec.** Call `show_task`, then read `spec\u002F\u003CLib>\u002FSpec.lean` (the requirement\n   predicates), `spec\u002F\u003CLib>\u002FChallenge.lean` (the definitions under repair and the required\n   theorems, each `:= sorry`) and `spec\u002F\u003CLib>\u002FLemmas.lean` if present. The theorem statements in\n   `Challenge.lean` are what the judge compares, byte for byte after elaboration.\n3. **Check, to find the defect.** Run `check_candidate` on the starting file. Each REFUTED\n   requirement comes with a witness (an input, the output, the violated requirement) and a\n   counterexample: the negation of the locked statement proved about the current code by the\n   kernel. That input is the bug. Fix the definition so the witness no longer violates the\n   requirement; do not weaken behavior on valid inputs (requirements that demand success still\n   have to hold).\n4. **Write the fix in the specification's terms.** When the specification states the result of a\n   call in closed form (`s' = { s with ... }` built from its own definitions: an index update, a\n   start, a credit), write that call of the fixed definition as\n   `if \u003Cthe requirement's preconditions> then some \u003Cthat closed form> else none`, with the\n   specification's definitions wherever the code computes the same quantity and the corrected\n   condition where the bug was. The effect requirements are then `simp only [impl] at h` and\n   `split at h`, the success requirement is the precondition, and a requirement over sequences of\n   calls rewrites each call with the same equation. A line-by-line port of the deployed code\n   (`Option` binds, checked subtraction, local `let`s, two-phase updates) needs, before any\n   requirement, one equation lemma per call (`impl s c = if ok then some next else none`) proved\n   by unfolding and case splits, and every later proof goes through it; keep the port only if\n   you prove those equations first, one call at a time.\n5. **Decompose.** Put each required theorem in the file with its locked statement and `sorry`,\n   and the helper lemmas you plan to use above it, each `:= by sorry`. Compile with `lean_build`.\n   Before you spend effort on a helper, run `refute_statement` on it (by `name`, or pass a\n   `statement` before writing it), above all for inequalities with subtraction, division, rounding\n   or scaling and for claims about every input. A FALSE result gives the values that break it:\n   add the missing hypothesis or fix the bound, and sample it again.\n6. **Bank the short requirements first.** Once the fixed definition compiles, run `try_tactics`\n   on every required theorem, and prove the ones that follow directly from the definitions, from\n   the locked lemmas or from another requirement (a bound given by the routine's last step, an\n   equality with the deployed algorithm, a consequence of a requirement already proved) before\n   starting a long proof. A long proof can outlast the budget; the requirements already proved\n   are kept.\n7. **Prove, cheapest first.** For each open theorem, helpers first:\n   - `try_tactics` on it. If a tactic closes it, put the returned proof in the file.\n   - Otherwise `goal_at` to see the exact hypotheses and goal at each `sorry`; then\n     `search_library` with `goal` set to the theorem's name for lemmas whose conclusion fits.\n     `import ProofForgeFin` (or one module) is allowed and its declarations are checked by the\n     same kernels. The library's `lib_defs` tactic rewrites definitions that match ProofForgeFin\n     definitions (and sums restated by recursion) into the library's, so its lemmas apply.\n   - Write the proof in steps with `have h : P := by sorry` and iterate with\n     `check_snippet_fast` (seconds) until it has no error; then `try_snippet` (a full compile)\n     and put it in the file. Break a step that resists into a new helper and go back to step 5.\n   - When a library module fits the argument (its doc ends with \"Using the module\", as\n     `ProofForgeFin.Accumulator.Market` does for reward indices over runs of operations), follow\n     that recipe step by step: it names the lemma for each step and the bridges from the\n     specification's definitions to the library's, most of them by `rfl`.\n8. **Keep the file compiling.** Move a proof into `candidate\u002FSolution.lean` only once it compiles\n   as a snippet, and run `lean_build` after every edit of the file. Where `lean_build` keeps the\n   best compiling version as `.proofforge\u002Fbest.lean`, restore it\n   (`cp .proofforge\u002Fbest.lean candidate\u002FSolution.lean`) when an edit breaks the file and the error\n   is not a quick fix. `#print axioms` in a scratch file that imports `Solution` shows which\n   theorems still depend on `sorryAx`. Fix a failed build from its first error; later errors\n   often follow from it. From the third failed build in a row `lean_build` names the declarations\n   with errors: put `sorry` in place of their proofs so that the file compiles, and work each out\n   with `check_snippet_fast`.\n9. **Check and iterate.** `check_candidate`. A new witness or counterexample means the behavior\n   is still wrong: go back to step 3 with it. `lean_errors` and `theorem_status` show what is\n   not proved; `proof_check.reasons` names scan violations or a Comparator rejection (a statement\n   that differs from the lock, a forbidden axiom, a kernel that rejects a declaration).\n10. **Done.** Stop only at `\"status\": \"VERIFIED\"`. Report the Passport path and `passport_sha256`;\n   `verify_passport` reproduces it.\n\n## Rules the judge enforces\n\n- Files under `spec\u002F`, `app\u002F`, `lakefile.toml`, `lake-manifest.json` and `lean-toolchain` are\n  locked; the judge uses the repository's copies and rejects a workspace whose copies differ.\n- Imports: the task's `Spec` and `Lemmas`, `Init.*`, `Std.*`, `ProofForgeFin.*`.\n- Forbidden in the candidate: `sorry`, `axiom`, `opaque`, `implemented_by`, `extern`, `unsafe`,\n  `@[export]`, `@[csimp]`, `macro`, `elab`, `syntax`, `initialize`, `#eval`, `run_cmd`,\n  `native_decide`, `set_option`, simprocs and any other elaboration-time code.\n- Permitted axioms: `propext`, `Quot.sound`, `Classical.choice`.\n- At a literal scale such as `10 ^ 18` or `10 ^ 36`, prove arithmetic over a variable scale and\n  instantiate it: two of the six kernels unfold literal powers in equations Lean's kernel accepts.\n\n## Lean 4.35 notes\n\n- `omega` handles linear arithmetic over `Nat` and `Int` with literals; it does not see through\n  definitions: `simp only [f]` or `unfold f` first.\n- Nonlinear facts (`a * b \u002F c` bounds): `Nat.div_le_div_right`, `Nat.mul_le_mul`,\n  `Nat.div_mul_le_self`, `Nat.lt_div_mul_add`, or the library's `ceilDiv` and fixed-point lemmas.\n- `split`, `cases h : e`, `by_cases`, `match` on the shape of the definition keep goals small;\n  `simp_all` on a large state is slow and brittle.\n- `decide` is fine on small closed propositions; `native_decide` is rejected.\n- Mathlib tactics do not exist here: `by_contra` (use `apply Classical.byContradiction` then\n  `intro h`, or `by_cases`), `set` (`generalize hx : e = x`), `ring` and `ring_nf` (`grind`, or\n  `Nat.mul_comm`, `Nat.mul_assoc`, `Nat.mul_add` rewrites and `ac_rfl`), `linarith` (`omega`),\n  `interval_cases` (a case split, then `omega`), `norm_num` (`decide`, `simp`, `omega`),\n  `push_neg` (`Nat.not_lt`, `Nat.not_le`, `Classical.not_not`), `positivity` (`Nat.mul_pos`,\n  `Nat.pow_pos`). A file that uses one does not compile.\n","# ProofForge: fix, prove, check\n\nA ProofForge task is a Lean 4 (v4.35, core library, no Mathlib) project with a locked\nspecification. The only file you change is `candidate\u002FSolution.lean`. The task is done when\n`check_candidate` returns `\"status\": \"VERIFIED\"`: every requirement proved, the proofs accepted\nby six kernels, and the executable built from the same file passing the property tests. No proof,\nno merge: a fix that compiles but leaves a requirement `sorry`, REFUTED or UNRESOLVED is not done.\n\n## Tools (MCP server `proofforge`)\n\n| Tool | Use | Cost |\n|---|---|---|\n| `prior_attempts` | only in a resumed run: what earlier attempts proved (re-checked by Lean against your current file, with a file that installs it all) and how they failed on the goals they left open | once, first |\n| `show_task` | issue report, definitions under repair, every locked requirement (id, theorem, exact statement, plain-language text), the rules | instant |\n| `goal_at` | the exact proof state at each `sorry` (or error, or a given line) of one declaration | seconds |\n| `check_snippet_fast` | a lemma or proof attempt checked after the candidate on a persistent Lean session: errors, and the state at each `sorry` | seconds |\n| `try_tactics` | a fixed portfolio of tactics on one theorem proved by `sorry`; returns the proof that closes it | seconds |\n| `refute_statement` | a proposed helper statement evaluated on concrete values; FALSE comes with a kernel-checked counterexample | seconds |\n| `search_library` | ProofForgeFin theorems, tactics and simp sets; pass `goal` (a statement or a declaration name) to rank by the goal's shape | instant |\n| `try_snippet` | a full compile of a snippet after the candidate, without changing the file | a compile |\n| `lean_build` | Lean's own output: `lake build Solution`, or `lake env lean \u003Cfile>` for a scratch file; with the full toolset, also the required theorems the build proves and the best compiling version so far (`.proofforge\u002Fbest.lean`) | a compile |\n| `check_candidate` | the official check (`bin\u002Fproofforge check`): VERIFIED \u002F REFUTED \u002F UNRESOLVED per requirement, witnesses, kernel-checked counterexamples, Lean errors, sorry status, Passport | minutes |\n| `verify_passport` | reproduce a Passport (`bin\u002Fproofforge verify`) | minutes |\n| `list_tasks` | the task catalog | instant |\n\nThere is no local Lean installation in the shell; Lean runs through these tools. If a tool in\nthis table is not offered by the server, skip the step that uses it.\n\nNone of the tools edits `candidate\u002FSolution.lean`; you write every change yourself. A tool that\nfinds a proof (`try_tactics`) or proved declarations (`prior_attempts`) gives you their text.\n\nA response, its reasoning included, stops at an output limit of 32,000 tokens. A response cut\nthere is lost with everything it worked out, and a session can end after a few of them in a row.\nWork out the next step only and act on it in the same response, with a tool call or an edit; write\na long proof as `have` steps ending in `sorry` and check them one at a time, rather than working\nout the whole proof before the first call.\n\n## Workflow\n\n1. **Start from what is known.** In a resumed run, call `prior_attempts` first. Take the\n   declarations it re-checked (paste them, or copy\n   `.proofforge\u002Fprior-attempts\u002FSolution-with-carried.lean` over the candidate when you want them\n   all), and read its failure notes: do not repeat an approach that already failed on a goal.\n2. **Read the locked spec.** Call `show_task`, then read `spec\u002F\u003CLib>\u002FSpec.lean` (the requirement\n   predicates), `spec\u002F\u003CLib>\u002FChallenge.lean` (the definitions under repair and the required\n   theorems, each `:= sorry`) and `spec\u002F\u003CLib>\u002FLemmas.lean` if present. The theorem statements in\n   `Challenge.lean` are what the judge compares, byte for byte after elaboration.\n3. **Check, to find the defect.** Run `check_candidate` on the starting file. Each REFUTED\n   requirement comes with a witness (an input, the output, the violated requirement) and a\n   counterexample: the negation of the locked statement proved about the current code by the\n   kernel. That input is the bug. Fix the definition so the witness no longer violates the\n   requirement; do not weaken behavior on valid inputs (requirements that demand success still\n   have to hold).\n4. **Write the fix in the specification's terms.** When the specification states the result of a\n   call in closed form (`s' = { s with ... }` built from its own definitions: an index update, a\n   start, a credit), write that call of the fixed definition as\n   `if \u003Cthe requirement's preconditions> then some \u003Cthat closed form> else none`, with the\n   specification's definitions wherever the code computes the same quantity and the corrected\n   condition where the bug was. The effect requirements are then `simp only [impl] at h` and\n   `split at h`, the success requirement is the precondition, and a requirement over sequences of\n   calls rewrites each call with the same equation. A line-by-line port of the deployed code\n   (`Option` binds, checked subtraction, local `let`s, two-phase updates) needs, before any\n   requirement, one equation lemma per call (`impl s c = if ok then some next else none`) proved\n   by unfolding and case splits, and every later proof goes through it; keep the port only if\n   you prove those equations first, one call at a time.\n5. **Decompose.** Put each required theorem in the file with its locked statement and `sorry`,\n   and the helper lemmas you plan to use above it, each `:= by sorry`. Compile with `lean_build`.\n   Before you spend effort on a helper, run `refute_statement` on it (by `name`, or pass a\n   `statement` before writing it), above all for inequalities with subtraction, division, rounding\n   or scaling and for claims about every input. A FALSE result gives the values that break it:\n   add the missing hypothesis or fix the bound, and sample it again.\n6. **Bank the short requirements first.** Once the fixed definition compiles, run `try_tactics`\n   on every required theorem, and prove the ones that follow directly from the definitions, from\n   the locked lemmas or from another requirement (a bound given by the routine's last step, an\n   equality with the deployed algorithm, a consequence of a requirement already proved) before\n   starting a long proof. A long proof can outlast the budget; the requirements already proved\n   are kept.\n7. **Prove, cheapest first.** For each open theorem, helpers first:\n   - `try_tactics` on it. If a tactic closes it, put the returned proof in the file.\n   - Otherwise `goal_at` to see the exact hypotheses and goal at each `sorry`; then\n     `search_library` with `goal` set to the theorem's name for lemmas whose conclusion fits.\n     `import ProofForgeFin` (or one module) is allowed and its declarations are checked by the\n     same kernels. The library's `lib_defs` tactic rewrites definitions that match ProofForgeFin\n     definitions (and sums restated by recursion) into the library's, so its lemmas apply.\n   - Write the proof in steps with `have h : P := by sorry` and iterate with\n     `check_snippet_fast` (seconds) until it has no error; then `try_snippet` (a full compile)\n     and put it in the file. Break a step that resists into a new helper and go back to step 5.\n   - When a library module fits the argument (its doc ends with \"Using the module\", as\n     `ProofForgeFin.Accumulator.Market` does for reward indices over runs of operations), follow\n     that recipe step by step: it names the lemma for each step and the bridges from the\n     specification's definitions to the library's, most of them by `rfl`.\n8. **Keep the file compiling.** Move a proof into `candidate\u002FSolution.lean` only once it compiles\n   as a snippet, and run `lean_build` after every edit of the file. Where `lean_build` keeps the\n   best compiling version as `.proofforge\u002Fbest.lean`, restore it\n   (`cp .proofforge\u002Fbest.lean candidate\u002FSolution.lean`) when an edit breaks the file and the error\n   is not a quick fix. `#print axioms` in a scratch file that imports `Solution` shows which\n   theorems still depend on `sorryAx`. Fix a failed build from its first error; later errors\n   often follow from it. From the third failed build in a row `lean_build` names the declarations\n   with errors: put `sorry` in place of their proofs so that the file compiles, and work each out\n   with `check_snippet_fast`.\n9. **Check and iterate.** `check_candidate`. A new witness or counterexample means the behavior\n   is still wrong: go back to step 3 with it. `lean_errors` and `theorem_status` show what is\n   not proved; `proof_check.reasons` names scan violations or a Comparator rejection (a statement\n   that differs from the lock, a forbidden axiom, a kernel that rejects a declaration).\n10. **Done.** Stop only at `\"status\": \"VERIFIED\"`. Report the Passport path and `passport_sha256`;\n   `verify_passport` reproduces it.\n\n## Rules the judge enforces\n\n- Files under `spec\u002F`, `app\u002F`, `lakefile.toml`, `lake-manifest.json` and `lean-toolchain` are\n  locked; the judge uses the repository's copies and rejects a workspace whose copies differ.\n- Imports: the task's `Spec` and `Lemmas`, `Init.*`, `Std.*`, `ProofForgeFin.*`.\n- Forbidden in the candidate: `sorry`, `axiom`, `opaque`, `implemented_by`, `extern`, `unsafe`,\n  `@[export]`, `@[csimp]`, `macro`, `elab`, `syntax`, `initialize`, `#eval`, `run_cmd`,\n  `native_decide`, `set_option`, simprocs and any other elaboration-time code.\n- Permitted axioms: `propext`, `Quot.sound`, `Classical.choice`.\n- At a literal scale such as `10 ^ 18` or `10 ^ 36`, prove arithmetic over a variable scale and\n  instantiate it: two of the six kernels unfold literal powers in equations Lean's kernel accepts.\n\n## Lean 4.35 notes\n\n- `omega` handles linear arithmetic over `Nat` and `Int` with literals; it does not see through\n  definitions: `simp only [f]` or `unfold f` first.\n- Nonlinear facts (`a * b \u002F c` bounds): `Nat.div_le_div_right`, `Nat.mul_le_mul`,\n  `Nat.div_mul_le_self`, `Nat.lt_div_mul_add`, or the library's `ceilDiv` and fixed-point lemmas.\n- `split`, `cases h : e`, `by_cases`, `match` on the shape of the definition keep goals small;\n  `simp_all` on a large state is slow and brittle.\n- `decide` is fine on small closed propositions; `native_decide` is rejected.\n- Mathlib tactics do not exist here: `by_contra` (use `apply Classical.byContradiction` then\n  `intro h`, or `by_cases`), `set` (`generalize hx : e = x`), `ring` and `ring_nf` (`grind`, or\n  `Nat.mul_comm`, `Nat.mul_assoc`, `Nat.mul_add` rewrites and `ac_rfl`), `linarith` (`omega`),\n  `interval_cases` (a case split, then `omega`), `norm_num` (`decide`, `simp`, `omega`),\n  `push_neg` (`Nat.not_lt`, `Nat.not_le`, `Classical.not_not`), `positivity` (`Nat.mul_pos`,\n  `Nat.pow_pos`). A file that uses one does not compile.\n",{"name":5,"description":7},"main","0347f65a343fe8183c977f21d290a42d5a58301b","skills\u002Fmcp-servers\u002Fdavidwilliam-proofforge",17,"https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia","https:\u002F\u002Feth2030.com","Hardcore infra. Building @alt-research and applied cryptography.","2026-11-14 02:27:51",{"source":8,"skillName":5,"commands":62,"prompt":72,"zipAvailable":73},[63,66,69],{"tool":64,"command":65},"npx","npx skills add jiayaoqijia\u002Fcryptoskill --skill proofforge",{"tool":67,"command":68},"bunx","bunx skills add jiayaoqijia\u002Fcryptoskill --skill proofforge",{"tool":70,"command":71},"pnpm","pnpm dlx skills add jiayaoqijia\u002Fcryptoskill --skill proofforge","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FSKILL.md",true,[75,79,85,91],{"path":76,"resourceType":76,"resourceTypeDesc":77,"sizeBytes":78,"sourceHtmlUrl":16},"LICENSE","许可证",11358,{"path":80,"resourceType":81,"resourceTypeDesc":82,"sizeBytes":83,"sourceHtmlUrl":84},"NOTICE","OTHER","其他",644,"https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FNOTICE",{"path":86,"resourceType":87,"resourceTypeDesc":88,"sizeBytes":89,"sourceHtmlUrl":90},"SOURCE.md","REFERENCE","参考文档",358,"https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FSOURCE.md",{"path":92,"resourceType":87,"resourceTypeDesc":88,"sizeBytes":93,"sourceHtmlUrl":94},"TRUST.auto.yaml",2217,"https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fmcp-servers\u002Fdavidwilliam-proofforge\u002FTRUST.auto.yaml",[96,125,147,165,178,188],{"skillNo":97,"name":98,"nameZh":6,"description":99,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":100,"licenseFileUrl":101,"sourceHtmlUrl":102,"categories":103,"keywords":104,"publishedAt":47},"01M712C436EQYE43342Q4E7GG1","recipe-performance","Diagnose a specific MetaMask user flow's real-app performance and Sentry critical-user-flow telemetry with deterministic mm-harness recipes. Use for CUF boundaries, cold\u002Fwarm\u002Fbackground-resume behavior, latency regressions, lifecycle tags, duplicate or blocking network requests, long tasks, layout\u002Fpaint cost, screen redraws, React rerenders, or browser trace analysis where tests alone cannot prove the real app.","MIT","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fwallets\u002Fmetamask-official-recipe-performance\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fwallets\u002Fmetamask-official-recipe-performance\u002FSKILL.md",[],[105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124],"performance","recipe performance","recipe","mm","sentry","harness","app","deterministic","recipes","flow","cold","critical","analysis","tasks","react","browser","layout","screen","network","metamask",{"skillNo":126,"name":127,"nameZh":6,"description":128,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":129,"sourceHtmlUrl":130,"categories":131,"keywords":132,"publishedAt":47},"01M70XT2F8A5CQZ81JBP98KSW3","mexc-spot-websocket","MEXC Spot WebSocket workflows for public streams, protobuf handling, depth maintenance, listen keys, and private streams without exposing API keys.","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-spot-websocket\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-spot-websocket\u002FSKILL.md",[],[133,134,135,136,137,138,139,140,141,142,143,144,145,146],"mexc spot websocket","spot","websocket","api","workflows","public","listen","streams","depth","keys","for","api keys","maintenance","protobuf",{"skillNo":148,"name":149,"nameZh":6,"description":150,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":151,"sourceHtmlUrl":152,"categories":153,"keywords":154,"publishedAt":47},"01M70XT0MBXN3WZY1BKN0CPNKR","mexc-spot-rest","MEXC Spot REST workflows for public data, signed account requests, orders, wallet\u002Fadmin actions, and secure signing without exposing API keys.","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-spot-rest\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-spot-rest\u002FSKILL.md",[],[155,134,156,157,158,159,160,144,143,142,161,162,163,138,164,137,136],"mexc spot rest","REST","admin","signing","Wallet","requests","actions","secure","data","orders",{"skillNo":166,"name":167,"nameZh":6,"description":168,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":169,"sourceHtmlUrl":170,"categories":171,"keywords":172,"publishedAt":47},"01M70XSYSVZ2N0N91XCAR2CAK0","mexc-futures-websocket","MEXC Futures WebSocket workflows for public streams, private account\u002Forder\u002Fposition streams, ping\u002Fpong, subscriptions, and depth maintenance.","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-futures-websocket\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fexchanges\u002Fmncrftfrcnm-mexc-futures-websocket\u002FSKILL.md",[],[173,174,135,175,176,145,143,177,141,140,138,137],"mexc futures websocket","futures","position","ping","subscriptions",{"skillNo":179,"name":180,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":100,"licenseFileUrl":181,"sourceHtmlUrl":182,"categories":183,"keywords":184,"publishedAt":47},"01M6H0ZWHVE5W04WG2DKQE2SQC","0xklen-version-and-refresh-sanctions-lists","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fpayments\u002F0xklen-version-and-refresh-sanctions-lists\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fpayments\u002F0xklen-version-and-refresh-sanctions-lists\u002FSKILL.md",[],[185,186,187],"refresh","0xklen version and refresh sanctions lists","version",{"skillNo":189,"name":190,"nameZh":6,"description":191,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":100,"licenseFileUrl":192,"sourceHtmlUrl":193,"categories":194,"keywords":195,"publishedAt":47},"01M6H0Z28Q3R8J0S799GJQWXM3","verify-tests-cover-changed-lines","Use when a PR adds code that the existing suite may not exercise. Measures patch coverage — the share of newly changed lines hit by tests — before approving.","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fpayments\u002F0xklen-verify-tests-cover-changed-lines\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fjiayaoqijia\u002Fcryptoskill\u002Fblob\u002Fmain\u002Fskills\u002Fpayments\u002F0xklen-verify-tests-cover-changed-lines\u002FSKILL.md",[],[25,196,197,198,199,200,201,39,202,45,203],"cover","verify tests cover changed lines","verify","coverage","pr","exercise","patch","share"]