[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6DBNQYPKTP65EWXRCQENZMK":3,"skill-same:01M6DBNQYPKTP65EWXRCQENZMK":82},{"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":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":29,"linkOnly":30,"markdownContent":31,"markdownBody":32,"frontMatter":33,"refName":34,"commitSha":35,"skillDirectory":36,"forksCount":14,"repositoryHtmlUrl":37,"repositoryHomepageUrl":6,"ownerHtmlUrl":38,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":39,"install":40,"resources":53},"01M6DBNQYPKTP65EWXRCQENZMK","pbinfo-python-jit",null,"Makes Python solutions pass strict time limits on pbinfo.ro by embedding compiled x86-64 shellcode and executing it via ctypes + mmap. Use whenever a correct Python solution gets TLE (Limita de timp depasita \u002F Depasit) on pbinfo, especially at N around 10^6 with a sieve, BFS, sliding window, DP, or tight loop, or when the user wants 100p Python. Extends competitive-programming-solver.","Prekzursil\u002Fagent-skills-toolchain","Prekzursil","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F54636077?v=4","01M6DACZ1PCQHD99SCR1YXG28B","Andrei Mihai Visalon","01M6DACZ670WZF535V3WYYSS4Z",0,"MIT","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28],"python","jit","pbinfo python jit","loop","correct","programming","user","use","shellcode","time","2026-11-10 10:12:30",false,"---\nname: pbinfo-python-jit\ndescription: Makes Python solutions pass strict time limits on pbinfo.ro by embedding compiled x86-64 shellcode and executing it via ctypes + mmap. Use whenever a correct Python solution gets TLE (Limita de timp depasita \u002F Depasit) on pbinfo, especially at N around 10^6 with a sieve, BFS, sliding window, DP, or tight loop, or when the user wants 100p Python. Extends competitive-programming-solver.\n---\n\n# Pbinfo Python JIT — Shellcode Escalation\n\nWhen a Python solution on **pbinfo.ro** is algorithmically correct but too slow for the judge's tight time limits, this skill enables a final-resort technique: **embed compiled x86-64 machine code as a bytes literal in the Python source, then load it into executable memory via `mmap` + `ctypes` and call it as if it were a normal C function**.\n\nThis bypasses CPython's interpreter overhead entirely for the hot path. It has consistently moved Python solutions from 35–65 points to **100 points** on problems like `bunrau`, `xk`, `bitmove`, and `divq`.\n\n## When to use this skill\n\nOnly after the general `competitive-programming-solver` skill's Python techniques (bulk read, `array.array`, slice-assign sieves, ASCII digit-parity trick, linear sieves) have been tried and still TLE. Shellcode JIT has a setup cost — don't reach for it on easy problems.\n\nUse shellcode when:\n\n- pure Python stdlib version of an N=10^6 algorithm runs in ~2–3+ seconds locally (will TLE on judge)\n- the algorithm is a tight inner loop: nested sieves, sliding window with `while`, BFS over millions of edges, DP over a grid\n- the user has explicitly run out of options (\"am încercat tot, tot pică\")\n- the user has confirmed (via `bunrau_diag6.py` or prior experience) that pbinfo's sandbox allows `PROT_EXEC` on mmap pages\n\nDon't use shellcode when:\n\n- the problem fits in pure Python with the right algorithm\n- the user is targeting a judge other than pbinfo (most judges' sandboxes block `PROT_EXEC`)\n- there's risk the user can't accept the solution (school assignments where source review matters more than score)\n\n## Pbinfo sandbox capabilities (verified)\n\nEmpirically tested across multiple problems on pbinfo as of May 2026:\n\n✅ `mmap.mmap(-1, size, prot=PROT_READ|PROT_WRITE|PROT_EXEC)` works\n✅ `ctypes.CDLL(\"libc.so.6\")` and `ctypes.CFUNCTYPE` work\n✅ x86-64 shellcode in mmap'd page executes correctly\n✅ Function pointers via ctypes return correct exit values\n❌ `subprocess` to compile with gcc — gcc is present but cannot spawn `cc1`\u002F`as`\u002F`ld` (sandbox limits child processes)\n❌ `numpy`, `scipy`, `gmpy2`, `sympy`, `cython` — not installed\n\nThis means: **bring pre-compiled bytes**, don't try to compile at runtime.\n\nIf you ever need to verify the sandbox on a new pbinfo problem (in case they tightened things), use the diagnostic technique described in `references\u002Fdiagnostic-tricks.md`.\n\n## The shellcode JIT workflow\n\n### Step 1: Write the hot path in C\n\nWrite a `.c` file containing all the time-critical functions. Take the algorithm from the user's correct (but slow) Python and rewrite it in C. Make every function **position-independent** — no global variables, only arrays passed as pointers from Python.\n\nExample pattern from a real solution (bunrau):\n\n```c\nvoid sieve(long *sigma, long max_a) {\n    for (long d = 1; d \u003C= max_a; d++) {\n        long sq = d * d;\n        for (long j = d; j \u003C= max_a; j += d) sigma[j] += sq;\n    }\n}\n\nvoid compute_good(long *sigma, char *good, long max_a) {\n    for (long i = 1; i \u003C= max_a; i++) {\n        long x = sigma[i]; long s = 0;\n        while (x > 0) { s += x % 10; x \u002F= 10; }\n        good[i] = ((s & 1) == 0) ? 1 : 0;\n    }\n}\n```\n\nKey C rules for shellcode-safe output:\n- Pass **all** state as arguments (no globals)\n- Use only basic types (`int`, `long`, `char*`, `unsigned long long`)\n- No `printf`, `malloc`, `memset`, `memcpy`, or any library calls\n- No floating point (avoids libm dependency)\n- Plain loops; gcc -O2 will vectorize them safely with the right flags\n\n### Step 2: Compile with these specific flags\n\n```bash\ngcc -O2 -fno-stack-protector -fno-asynchronous-unwind-tables \\\n    -fno-plt -fcf-protection=none -fno-pic \\\n    -fno-tree-loop-distribute-patterns -fno-builtin \\\n    -c lib.c -o lib.o\n```\n\nCritical flags explained:\n- `-O2` — optimize; without this Python beats the result\n- `-fno-pic` — no GOT references; we want plain absolute jumps within the code\n- `-fno-stack-protector`, `-fno-asynchronous-unwind-tables`, `-fno-plt`, `-fcf-protection=none` — strip out everything that needs runtime support\n- **`-fno-tree-loop-distribute-patterns -fno-builtin`** — CRITICAL. Without these, gcc converts `for (i=0; i\u003CN; i++) arr[i]=0;` into a `memset` call. That introduces a relocation, which makes the shellcode segfault when loaded standalone. **This is the most common bug**\n\n### Step 3: Verify no relocations\n\n```bash\nobjdump -r lib.o\n```\n\nThe output should be **empty** (no relocation records). If you see lines like `R_X86_64_GOTPCRELX  memset-0x4`, the code calls an external function — go back to step 2 and add `-fno-builtin` and `-fno-tree-loop-distribute-patterns`, or rewrite the C to avoid the offending pattern (e.g., use a manual loop instead of `for (i=0; i\u003CN; i++) arr[i]=0;`).\n\n### Step 4: Extract the .text section and symbol offsets\n\nUse the helper script `scripts\u002Fextract_shellcode.py`:\n\n```bash\npython3 scripts\u002Fextract_shellcode.py lib.o\n```\n\nThis script parses the ELF64 object file directly (no need for `objcopy`) and prints:\n- The `.text` bytes as a hex string (already split into Python-literal-friendly lines)\n- The byte offset of each function symbol inside `.text`\n- The exact `len(_text)` value to assert at runtime\n\n### Step 5: Build the Python wrapper\n\n```python\nimport ctypes, mmap\n\n_TEXT_HEX = (\n    \"...\"   # hex string from extract_shellcode.py\n)\n_OFF_FUNC1 = 0\n_OFF_FUNC2 = 64\n# etc.\n\n_text = bytes.fromhex(_TEXT_HEX)\nassert len(_text) == EXPECTED_LEN\n\n# 4KB pages are usually enough; round up to the next multiple of 4096 if needed\n_mem = mmap.mmap(-1, 4096, prot=mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)\n_mem.write(_text)\n_base = ctypes.addressof(ctypes.c_char.from_buffer(_mem))\n\n# Build function pointers using CFUNCTYPE\n_T_FUNC1 = ctypes.CFUNCTYPE(\n    None,                              # return type (or ctypes.c_int, c_long, etc.)\n    ctypes.POINTER(ctypes.c_long),     # arg 1\n    ctypes.c_long,                     # arg 2\n)\nfunc1 = _T_FUNC1(_base + _OFF_FUNC1)\n# ...\n\n# Allocate buffers in Python and pass them in\nbuf = (ctypes.c_long * N)()\nfunc1(buf, N)\n```\n\nThe buffer types must match exactly what the C signatures expect. Use `ctypes.c_int` for `int`, `c_long` for `long`, `c_ulonglong` for `unsigned long long`, `c_char_p` for `char*` (or `create_string_buffer(N)` for mutable byte arrays).\n\n### Step 6: Verify correctness against the original Python\n\nGenerate random test inputs, run both the user's original Python (which is correct but slow) and the shellcode version, compare outputs byte-for-byte. Cover edge cases:\n- Smallest input (N=1)\n- Boundary values (K=1, K=N)\n- All-zero \u002F all-same values\n- Maximum N\n\nDon't skip this. A bug in the shellcode (wrong offset, wrong CFUNCTYPE signature, off-by-one in C) won't produce a friendly error — it produces garbage or segfaults.\n\n### Step 7: Benchmark\n\nLocally on Python 3.12 you should see the shellcode version run **10–50× faster** than the original Python. On pbinfo's Python 3.4 the slowdown factor vs your local 3.12 is ~1.5–2×, so divide accordingly when estimating judge timing.\n\nIf your local 3.12 time is X ms, expect pbinfo 3.4 to take ~1.5–2×X ms. For a 1.0s judge limit, aim for ≤300 ms locally.\n\n## Worked example: complete pipeline\n\nFor a concrete end-to-end example (the `bunrau` problem — σ_2 sieve + digit parity + sliding queries), see `references\u002Fworked-example.md`.\n\n## Diagnostic tricks for pbinfo\n\nPbinfo's \"Răspuns greșit\" details are minimal. To learn what's actually happening (e.g., \"is numpy available?\", \"does PROT_EXEC mmap work?\", \"what's in test 8?\"), encode information into the **exit code** of your Python script.\n\nWhen `sys.exit(N)` returns with N between 128 and 255, pbinfo displays \"Exited with error status N\" prominently in the test results. This gives you 7 bits of information per submission.\n\nSee `references\u002Fdiagnostic-tricks.md` for the full pattern: how to construct bitmap-encoded exit codes, how to interpret them, and how to write metadata into `out` files for tests where the WA detail might show your output.\n\n## Limitations and risks\n\n- **Architecture-specific**: x86-64 only. ARM judges (if any pbinfo gets) would break. Currently pbinfo runs x86-64 Linux, so it's safe.\n- **gcc version sensitivity**: gcc 11+ might emit slightly different instructions than gcc 9, but PIC-free code is robust. Recompile if the local gcc changes major versions.\n- **Source code looks alien**: the hex blob is opaque. If a teacher reads the source for educational purposes, they'll have questions. Educate the user accordingly.\n- **Slight ethical fuzziness**: this is hacky in spirit. Many judges would consider it against the rules. Pbinfo doesn't have an explicit ban (yet), and the user has already exhausted all \"normal\" Python paths, so use it knowingly.\n\n## Output expectations\n\nWhen delivering a shellcode-based solution:\n\n1. **Show the original C source** as a comment block in the Python file (or as a separate `.c` file). This makes the solution auditable and lets the user (or anyone reading it) understand what's actually running.\n2. **Explain briefly** in the response: which functions are in the shellcode, expected speedup vs. original, why pure Python couldn't make it.\n3. **Verify locally first** — never deliver an untested shellcode.\n\n## References\n\n- `references\u002Fworked-example.md` — Full pipeline walkthrough on the `bunrau` problem\n- `references\u002Fdiagnostic-tricks.md` — Exit code encoding, output metadata, probing sandbox\n- `references\u002Fc-compile-recipe.md` — Exhaustive gcc flag explanation and troubleshooting\n- `scripts\u002Fextract_shellcode.py` — Parse ELF .o → Python hex literal + offsets\n- `scripts\u002Fbuild_shellcode.sh` — One-shot: write C, compile, extract, emit Python wrapper template\n","# Pbinfo Python JIT — Shellcode Escalation\n\nWhen a Python solution on **pbinfo.ro** is algorithmically correct but too slow for the judge's tight time limits, this skill enables a final-resort technique: **embed compiled x86-64 machine code as a bytes literal in the Python source, then load it into executable memory via `mmap` + `ctypes` and call it as if it were a normal C function**.\n\nThis bypasses CPython's interpreter overhead entirely for the hot path. It has consistently moved Python solutions from 35–65 points to **100 points** on problems like `bunrau`, `xk`, `bitmove`, and `divq`.\n\n## When to use this skill\n\nOnly after the general `competitive-programming-solver` skill's Python techniques (bulk read, `array.array`, slice-assign sieves, ASCII digit-parity trick, linear sieves) have been tried and still TLE. Shellcode JIT has a setup cost — don't reach for it on easy problems.\n\nUse shellcode when:\n\n- pure Python stdlib version of an N=10^6 algorithm runs in ~2–3+ seconds locally (will TLE on judge)\n- the algorithm is a tight inner loop: nested sieves, sliding window with `while`, BFS over millions of edges, DP over a grid\n- the user has explicitly run out of options (\"am încercat tot, tot pică\")\n- the user has confirmed (via `bunrau_diag6.py` or prior experience) that pbinfo's sandbox allows `PROT_EXEC` on mmap pages\n\nDon't use shellcode when:\n\n- the problem fits in pure Python with the right algorithm\n- the user is targeting a judge other than pbinfo (most judges' sandboxes block `PROT_EXEC`)\n- there's risk the user can't accept the solution (school assignments where source review matters more than score)\n\n## Pbinfo sandbox capabilities (verified)\n\nEmpirically tested across multiple problems on pbinfo as of May 2026:\n\n✅ `mmap.mmap(-1, size, prot=PROT_READ|PROT_WRITE|PROT_EXEC)` works\n✅ `ctypes.CDLL(\"libc.so.6\")` and `ctypes.CFUNCTYPE` work\n✅ x86-64 shellcode in mmap'd page executes correctly\n✅ Function pointers via ctypes return correct exit values\n❌ `subprocess` to compile with gcc — gcc is present but cannot spawn `cc1`\u002F`as`\u002F`ld` (sandbox limits child processes)\n❌ `numpy`, `scipy`, `gmpy2`, `sympy`, `cython` — not installed\n\nThis means: **bring pre-compiled bytes**, don't try to compile at runtime.\n\nIf you ever need to verify the sandbox on a new pbinfo problem (in case they tightened things), use the diagnostic technique described in `references\u002Fdiagnostic-tricks.md`.\n\n## The shellcode JIT workflow\n\n### Step 1: Write the hot path in C\n\nWrite a `.c` file containing all the time-critical functions. Take the algorithm from the user's correct (but slow) Python and rewrite it in C. Make every function **position-independent** — no global variables, only arrays passed as pointers from Python.\n\nExample pattern from a real solution (bunrau):\n\n```c\nvoid sieve(long *sigma, long max_a) {\n    for (long d = 1; d \u003C= max_a; d++) {\n        long sq = d * d;\n        for (long j = d; j \u003C= max_a; j += d) sigma[j] += sq;\n    }\n}\n\nvoid compute_good(long *sigma, char *good, long max_a) {\n    for (long i = 1; i \u003C= max_a; i++) {\n        long x = sigma[i]; long s = 0;\n        while (x > 0) { s += x % 10; x \u002F= 10; }\n        good[i] = ((s & 1) == 0) ? 1 : 0;\n    }\n}\n```\n\nKey C rules for shellcode-safe output:\n- Pass **all** state as arguments (no globals)\n- Use only basic types (`int`, `long`, `char*`, `unsigned long long`)\n- No `printf`, `malloc`, `memset`, `memcpy`, or any library calls\n- No floating point (avoids libm dependency)\n- Plain loops; gcc -O2 will vectorize them safely with the right flags\n\n### Step 2: Compile with these specific flags\n\n```bash\ngcc -O2 -fno-stack-protector -fno-asynchronous-unwind-tables \\\n    -fno-plt -fcf-protection=none -fno-pic \\\n    -fno-tree-loop-distribute-patterns -fno-builtin \\\n    -c lib.c -o lib.o\n```\n\nCritical flags explained:\n- `-O2` — optimize; without this Python beats the result\n- `-fno-pic` — no GOT references; we want plain absolute jumps within the code\n- `-fno-stack-protector`, `-fno-asynchronous-unwind-tables`, `-fno-plt`, `-fcf-protection=none` — strip out everything that needs runtime support\n- **`-fno-tree-loop-distribute-patterns -fno-builtin`** — CRITICAL. Without these, gcc converts `for (i=0; i\u003CN; i++) arr[i]=0;` into a `memset` call. That introduces a relocation, which makes the shellcode segfault when loaded standalone. **This is the most common bug**\n\n### Step 3: Verify no relocations\n\n```bash\nobjdump -r lib.o\n```\n\nThe output should be **empty** (no relocation records). If you see lines like `R_X86_64_GOTPCRELX  memset-0x4`, the code calls an external function — go back to step 2 and add `-fno-builtin` and `-fno-tree-loop-distribute-patterns`, or rewrite the C to avoid the offending pattern (e.g., use a manual loop instead of `for (i=0; i\u003CN; i++) arr[i]=0;`).\n\n### Step 4: Extract the .text section and symbol offsets\n\nUse the helper script `scripts\u002Fextract_shellcode.py`:\n\n```bash\npython3 scripts\u002Fextract_shellcode.py lib.o\n```\n\nThis script parses the ELF64 object file directly (no need for `objcopy`) and prints:\n- The `.text` bytes as a hex string (already split into Python-literal-friendly lines)\n- The byte offset of each function symbol inside `.text`\n- The exact `len(_text)` value to assert at runtime\n\n### Step 5: Build the Python wrapper\n\n```python\nimport ctypes, mmap\n\n_TEXT_HEX = (\n    \"...\"   # hex string from extract_shellcode.py\n)\n_OFF_FUNC1 = 0\n_OFF_FUNC2 = 64\n# etc.\n\n_text = bytes.fromhex(_TEXT_HEX)\nassert len(_text) == EXPECTED_LEN\n\n# 4KB pages are usually enough; round up to the next multiple of 4096 if needed\n_mem = mmap.mmap(-1, 4096, prot=mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)\n_mem.write(_text)\n_base = ctypes.addressof(ctypes.c_char.from_buffer(_mem))\n\n# Build function pointers using CFUNCTYPE\n_T_FUNC1 = ctypes.CFUNCTYPE(\n    None,                              # return type (or ctypes.c_int, c_long, etc.)\n    ctypes.POINTER(ctypes.c_long),     # arg 1\n    ctypes.c_long,                     # arg 2\n)\nfunc1 = _T_FUNC1(_base + _OFF_FUNC1)\n# ...\n\n# Allocate buffers in Python and pass them in\nbuf = (ctypes.c_long * N)()\nfunc1(buf, N)\n```\n\nThe buffer types must match exactly what the C signatures expect. Use `ctypes.c_int` for `int`, `c_long` for `long`, `c_ulonglong` for `unsigned long long`, `c_char_p` for `char*` (or `create_string_buffer(N)` for mutable byte arrays).\n\n### Step 6: Verify correctness against the original Python\n\nGenerate random test inputs, run both the user's original Python (which is correct but slow) and the shellcode version, compare outputs byte-for-byte. Cover edge cases:\n- Smallest input (N=1)\n- Boundary values (K=1, K=N)\n- All-zero \u002F all-same values\n- Maximum N\n\nDon't skip this. A bug in the shellcode (wrong offset, wrong CFUNCTYPE signature, off-by-one in C) won't produce a friendly error — it produces garbage or segfaults.\n\n### Step 7: Benchmark\n\nLocally on Python 3.12 you should see the shellcode version run **10–50× faster** than the original Python. On pbinfo's Python 3.4 the slowdown factor vs your local 3.12 is ~1.5–2×, so divide accordingly when estimating judge timing.\n\nIf your local 3.12 time is X ms, expect pbinfo 3.4 to take ~1.5–2×X ms. For a 1.0s judge limit, aim for ≤300 ms locally.\n\n## Worked example: complete pipeline\n\nFor a concrete end-to-end example (the `bunrau` problem — σ_2 sieve + digit parity + sliding queries), see `references\u002Fworked-example.md`.\n\n## Diagnostic tricks for pbinfo\n\nPbinfo's \"Răspuns greșit\" details are minimal. To learn what's actually happening (e.g., \"is numpy available?\", \"does PROT_EXEC mmap work?\", \"what's in test 8?\"), encode information into the **exit code** of your Python script.\n\nWhen `sys.exit(N)` returns with N between 128 and 255, pbinfo displays \"Exited with error status N\" prominently in the test results. This gives you 7 bits of information per submission.\n\nSee `references\u002Fdiagnostic-tricks.md` for the full pattern: how to construct bitmap-encoded exit codes, how to interpret them, and how to write metadata into `out` files for tests where the WA detail might show your output.\n\n## Limitations and risks\n\n- **Architecture-specific**: x86-64 only. ARM judges (if any pbinfo gets) would break. Currently pbinfo runs x86-64 Linux, so it's safe.\n- **gcc version sensitivity**: gcc 11+ might emit slightly different instructions than gcc 9, but PIC-free code is robust. Recompile if the local gcc changes major versions.\n- **Source code looks alien**: the hex blob is opaque. If a teacher reads the source for educational purposes, they'll have questions. Educate the user accordingly.\n- **Slight ethical fuzziness**: this is hacky in spirit. Many judges would consider it against the rules. Pbinfo doesn't have an explicit ban (yet), and the user has already exhausted all \"normal\" Python paths, so use it knowingly.\n\n## Output expectations\n\nWhen delivering a shellcode-based solution:\n\n1. **Show the original C source** as a comment block in the Python file (or as a separate `.c` file). This makes the solution auditable and lets the user (or anyone reading it) understand what's actually running.\n2. **Explain briefly** in the response: which functions are in the shellcode, expected speedup vs. original, why pure Python couldn't make it.\n3. **Verify locally first** — never deliver an untested shellcode.\n\n## References\n\n- `references\u002Fworked-example.md` — Full pipeline walkthrough on the `bunrau` problem\n- `references\u002Fdiagnostic-tricks.md` — Exit code encoding, output metadata, probing sandbox\n- `references\u002Fc-compile-recipe.md` — Exhaustive gcc flag explanation and troubleshooting\n- `scripts\u002Fextract_shellcode.py` — Parse ELF .o → Python hex literal + offsets\n- `scripts\u002Fbuild_shellcode.sh` — One-shot: write C, compile, extract, emit Python wrapper template\n",{"name":5,"description":7},"main","a298c929b6cbd662e1fce54302ce520d5ceea1a5",".agents\u002Fskills\u002Fpbinfo-python-jit","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain","https:\u002F\u002Fgithub.com\u002FPrekzursil","2026-11-02 14:30:57",{"source":8,"skillName":5,"commands":41,"prompt":51,"zipAvailable":52},[42,45,48],{"tool":43,"command":44},"npx","npx skills add Prekzursil\u002Fagent-skills-toolchain --skill pbinfo-python-jit",{"tool":46,"command":47},"bunx","bunx skills add Prekzursil\u002Fagent-skills-toolchain --skill pbinfo-python-jit",{"tool":49,"command":50},"pnpm","pnpm dlx skills add Prekzursil\u002Fagent-skills-toolchain --skill pbinfo-python-jit","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002FSKILL.md",true,[54,60,64,68,72,78],{"path":55,"resourceType":56,"resourceTypeDesc":57,"sizeBytes":58,"sourceHtmlUrl":59},"agents\u002Fopenai.yaml","REFERENCE","参考文档",251,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Fagents\u002Fopenai.yaml",{"path":61,"resourceType":56,"resourceTypeDesc":57,"sizeBytes":62,"sourceHtmlUrl":63},"references\u002Fc-compile-recipe.md",6161,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Freferences\u002Fc-compile-recipe.md",{"path":65,"resourceType":56,"resourceTypeDesc":57,"sizeBytes":66,"sourceHtmlUrl":67},"references\u002Fdiagnostic-tricks.md",4742,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Freferences\u002Fdiagnostic-tricks.md",{"path":69,"resourceType":56,"resourceTypeDesc":57,"sizeBytes":70,"sourceHtmlUrl":71},"references\u002Fworked-example.md",5164,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Freferences\u002Fworked-example.md",{"path":73,"resourceType":74,"resourceTypeDesc":75,"sizeBytes":76,"sourceHtmlUrl":77},"scripts\u002Fbuild_shellcode.sh","SCRIPT","脚本",1730,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Fscripts\u002Fbuild_shellcode.sh",{"path":79,"resourceType":74,"resourceTypeDesc":75,"sizeBytes":80,"sourceHtmlUrl":81},"scripts\u002Fextract_shellcode.py",5695,"https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fpbinfo-python-jit\u002Fscripts\u002Fextract_shellcode.py",[83,104,135,162,176,191],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":29},"01M6DF7D7478R55P46REYH4QAC","clarify-requirements","Resolve genuine pre-execution ambiguity by scanning repo context, generating 1-6 grounded options, and asking 1-3 focused questions via AskUserQuestion. NOT for mid-task use (injection risk); NOT when the goal is already unambiguous; use to disambiguate vague prompts before any file edits.","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Fworkspace-hooks\u002Fskills\u002Fclarify-requirements\u002FSKILL.md",[],[90,91,92,93,94,95,96,97,98,26,99,100,101,102,103],"clarify requirements","clarify","requirements","risk","options","task","prompts","goal","scanning","context","repo","injection","execution","file",{"skillNo":105,"name":106,"nameZh":6,"description":107,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":108,"categories":109,"keywords":115,"publishedAt":29},"01M6DF79CA4BHJS66J8EZDBPWJ","openmm-md","Run FREE, open-source, Windows-native GPU molecular dynamics via the openmm-md MCP (OpenMM + CUDA on the local NVIDIA GPU). Use for protein \u002F protein-ligand MD when you want a free stack or are on Windows without a Schrodinger license. Covers the full workflow (prepare, solvate, minimize, equilibrate, production, analyze, mmgbsa) AND an honest decision guide vs Schrodinger Desmond, including how to run Desmond legitimately on Linux or a cloud GPU with a real license. This is a deliberately LESSER free alternative and does NOT replace the schrodinger MCP tools. Do NOT use it to pick a free tool when a validated FEP+, WaterMap, IFD-MD, or Prime MM-GBSA result is actually required.","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Fmcp\u002Fopenmm-md-mcp\u002Fskill\u002Fopenmm-md\u002FSKILL.md",[110],{"categoryNo":111,"categoryName":112,"taxonomyType":113,"taxonomyTypeDesc":114},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[116,117,118,119,120,121,122,123,124,125,126,127,128,129,26,130,131,132,133,134],"openmm md","how","decision","pick","linux","analyze","tool","stack","open","NVIDIA","gpu","license","workflow","windows","free","molecular dynamics","local","do","MCP",{"skillNo":136,"name":137,"nameZh":6,"description":138,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":139,"categories":140,"keywords":147,"publishedAt":29},"01M6DF76C1MG85VEWP8VZCBNMN","visual-review","Take screenshots of web pages and UI using Playwright for visual review and iteration","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Feditor\u002Fmetaswarm\u002Fskills\u002Fvisual-review\u002FSKILL.md",[141,144],{"categoryNo":142,"categoryName":143,"taxonomyType":113,"taxonomyTypeDesc":114},"01JBSEEDCAT000000000000003","演示文稿",{"categoryNo":145,"categoryName":146,"taxonomyType":113,"taxonomyTypeDesc":114},"01JBSEEDCAT000000000000008","测试与质量",[148,149,150,151,152,153,154,155,156,157,117,158,159,160,161],"review","visual","visual review","pages","web","false","iteration","take","check","slides","ui","screenshot","playwright","screenshots",{"skillNo":163,"name":164,"nameZh":6,"description":165,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":166,"categories":167,"keywords":168,"publishedAt":29},"01M6DF73AQVCBZKEN0YXEX9FXP","status","Diagnostic status report — shows metaswarm installation state, project setup, and potential issues","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Feditor\u002Fmetaswarm\u002Fskills\u002Fstatus\u002FSKILL.md",[],[164,169,170,171,172,173,174,175],"setup","report","project","installation","project setup","issues","state",{"skillNo":177,"name":178,"nameZh":6,"description":179,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":180,"categories":181,"keywords":183,"publishedAt":29},"01M6DF6X6C2XB0P6GX76P7TTYV","start","Use when starting work on any task, when the user mentions metaswarm, or when the user wants to begin tracked development work","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Feditor\u002Fmetaswarm\u002Fskills\u002Fstart\u002FSKILL.md",[182],{"categoryNo":111,"categoryName":112,"taxonomyType":113,"taxonomyTypeDesc":114},[178,184,95,185,186,187,26,25,188,189,190],"start issue","issue","ready","work on issue","work","work on","development",{"skillNo":192,"name":169,"nameZh":6,"description":193,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":194,"categories":195,"keywords":196,"publishedAt":29},"01M6DF6QMJ9AJKFKHHKRT005PQ","Interactive project setup — detects your project, configures metaswarm, writes project-local files","https:\u002F\u002Fgithub.com\u002FPrekzursil\u002Fagent-skills-toolchain\u002Fblob\u002Fmain\u002Ftools\u002Feditor\u002Fmetaswarm\u002Fskills\u002Fsetup\u002FSKILL.md",[],[169,171,132,197,173,198],"files","interactive"]