From f7bbec41f1ea5574a5953171d73067ac6d0ae9ec Mon Sep 17 00:00:00 2001 From: WeiQing Chen <40507679+david6666666@users.noreply.github.com> Date: Tue, 27 Oct 2026 03:54:00 -0700 Subject: [PATCH 1/3] knowledge: add Lily portable AREX candidate graph Distill exact-model layout, strict API/session state and native/benchmark qualification; retain missing compiler and Metal/model gaps. Agent-assisted-by: Codex / gpt-6.1-sol [effort=xhigh] (approved_arex_author; author and integrator) Agent-assisted-by: Codex / gpt-6.1-sol [effort=xhigh] (runtime_memory_author; author) Agent-assisted-by: Codex / gpt-6.1-sol [effort=xhigh] (serving_state_author; author) Agent-assisted-by: Codex / gpt-6.1-sol [effort=xhigh] (qualification_author; author) Signed-off-by: WeiQing Chen <530634352@qq.com> --- docs/knowledge-base.md | 8 +- docs/reference-matrix.md | 6 + docs/searchspace-matrix.md | 7 + src/inferrsi/data/skill_library/README.md | 15 +- .../skill_library/repositories/lily/LICENSE | 202 ++++++++++++++++++ .../skill_library/repositories/lily/NOTICE.md | 66 ++++++ .../skill_library/repositories/lily/SKILL.md | 82 +++++++ .../repositories/lily/metadata.json | 107 ++++++++++ .../lily/references/repo-provenance.md | 50 +++++ .../references/repo-routing-metadata.json | 13 ++ .../lily/references/source-identity.json | 49 +++++ .../lily/sub-skills/model-runtime/SKILL.md | 89 ++++++++ .../references/model-and-memory.md | 129 +++++++++++ .../references/troubleshooting.md | 25 +++ .../model-runtime/scripts/screen_config.py | 90 ++++++++ .../lily/sub-skills/qualification/SKILL.md | 89 ++++++++ .../references/troubleshooting.md | 22 ++ .../references/verification-contract.md | 181 ++++++++++++++++ .../scripts/audit_benchmark_record.py | 118 ++++++++++ .../lily/sub-skills/serving-cache/SKILL.md | 87 ++++++++ .../references/api-and-session.md | 164 ++++++++++++++ .../references/troubleshooting.md | 35 +++ .../serving-cache/scripts/request_template.py | 100 +++++++++ .../data/skill_library/skill-index.json | 4 + tests/check_installed.py | 6 +- .../lily/reports/final/final-skill-report.md | 36 ++++ .../reports/integration/integration-notes.md | 25 +++ .../lily/reports/integration/plan.json | 130 +++++++++++ .../lily/reports/license-resolution.json | 12 ++ .../lily/reports/self-refine/evals.json | 185 ++++++++++++++++ .../lily/reports/self-refine/iteration-1.md | 3 + .../native-verification-report.json | 54 +++++ .../repo_to_skill/lily/test-cases/index.md | 16 ++ .../README.md | 16 ++ .../assertions.json | 22 ++ .../user_request.txt | 1 + .../strict-config-request-and-state/README.md | 16 ++ .../assertions.json | 22 ++ .../user_request.txt | 1 + .../root/strict-offline-request/README.md | 15 ++ .../strict-offline-request/assertions.json | 21 ++ .../strict-offline-request/user_request.txt | 1 + .../README.md | 30 +++ .../assertions.json | 31 +++ .../fixtures/config-screen-only.json | 70 ++++++ .../user_request.txt | 1 + .../same-bits-wrong-layout/README.md | 29 +++ .../same-bits-wrong-layout/assertions.json | 27 +++ .../fixtures/wrong-group-config.json | 70 ++++++ .../same-bits-wrong-layout/user_request.txt | 1 + .../audit-saved-production-record/README.md | 29 +++ .../assertions.json | 25 +++ .../user_request.txt | 1 + .../README.md | 29 +++ .../assertions.json | 27 +++ .../user_request.txt | 1 + .../cpu-reference-is-not-gpu-proof/README.md | 29 +++ .../assertions.json | 28 +++ .../user_request.txt | 1 + .../same-key-not-a-token-prefix/README.md | 19 ++ .../assertions.json | 25 +++ .../user_request.txt | 1 + .../README.md | 19 ++ .../assertions.json | 28 +++ .../fixtures/invalid-request.json | 1 + .../fixtures/valid-request.json | 1 + .../user_request.txt | 1 + tests/test_lily_repo_to_skill.py | 110 ++++++++++ tests/test_skill_index.py | 10 +- tests/test_skill_library.py | 2 +- 70 files changed, 2949 insertions(+), 17 deletions(-) create mode 100644 src/inferrsi/data/skill_library/repositories/lily/LICENSE create mode 100644 src/inferrsi/data/skill_library/repositories/lily/NOTICE.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/SKILL.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/metadata.json create mode 100644 src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json create mode 100644 src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md create mode 100644 src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py create mode 100644 tests/fixtures/repo_to_skill/lily/reports/final/final-skill-report.md create mode 100644 tests/fixtures/repo_to_skill/lily/reports/integration/integration-notes.md create mode 100644 tests/fixtures/repo_to_skill/lily/reports/integration/plan.json create mode 100644 tests/fixtures/repo_to_skill/lily/reports/license-resolution.json create mode 100644 tests/fixtures/repo_to_skill/lily/reports/self-refine/evals.json create mode 100644 tests/fixtures/repo_to_skill/lily/reports/self-refine/iteration-1.md create mode 100644 tests/fixtures/repo_to_skill/lily/reports/verification/native-verification-report.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/index.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/fixtures/config-screen-only.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/fixtures/wrong-group-config.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/user_request.txt create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/README.md create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/assertions.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/invalid-request.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/valid-request.json create mode 100644 tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/user_request.txt create mode 100644 tests/test_lily_repo_to_skill.py diff --git a/docs/knowledge-base.md b/docs/knowledge-base.md index ec46594e..88d1fa8e 100644 --- a/docs/knowledge-base.md +++ b/docs/knowledge-base.md @@ -14,7 +14,7 @@ separate work, not an implemented capability of this knowledge base. ```text src/inferrsi/data/skill_library/ README.md Library navigation - skill-index.json Stable IDs → categorized paths/backend (60 skills) + skill-index.json Stable IDs → categorized paths/backend (61 skills) hardware/{ascend,cuda,host}// Hardware/platform-specific complete skills frameworks/// Framework-owned complete skills repositories// Engine entry, sub-skills and focused complete skills @@ -171,18 +171,18 @@ Complete procedures, sidecars, references and cases are packaged, with 13 Ascend repositories, methods or workflows. The 21 engine and research-router skills use the same ownership layout under `repositories//` and `workflows/inference-engine-research/`, including their sub-skills and references. -The library contains 81 `SKILL.md` files, all in English. +The library contains 85 `SKILL.md` files, all in English. The collection overview, import notes and source manifest belong to the research workflow's references; Strata design-space analysis belongs to Strata. The library root contains only navigation and the registry. The [generated catalog](../src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md) -projects the 60 registered skills into the contribution catalog. Its records +projects the 61 registered skills into the contribution catalog. Its records use `inferrsi..skills.` IDs, with `ascend` and `cuda` for scopes that depend on those backends and `common` for the remaining skills. Each `skill_documents.original` points to the full packaged procedure. The `skills` CLI retains the original hyphenated skill IDs and defaults to this -60-ID registry; engine procedures remain available through library navigation +61-ID registry; engine procedures remain available through library navigation and catalog document pointers. The registered [h3.c runtime audit](../src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md) diff --git a/docs/reference-matrix.md b/docs/reference-matrix.md index ee72605f..023cc69f 100644 --- a/docs/reference-matrix.md +++ b/docs/reference-matrix.md @@ -402,3 +402,9 @@ readset. Original contribution access (2026-10-14), HiCache access (2026-10-15) and diffusion archive inspection (2026-10-22) remain separate. This navigation adds no upstream reinspection, common dependency tuple or validation result; source maps, notices and imported/candidate states stay with their owners. + +## Lily portable AREX extraction + +| Source / revision | Inspected scope | Reuse, extraction and limits | +| --- | --- | --- | +| perplexityai/pplx-garden `lily/` @ `1ed972ed3f0bd5616c997c9507c25616c63394fc`; AREX method @ `ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6` | Selected exact architecture/affine packing, Metal ownership, strict API/session prefixes, native-test gating and versioned benchmark methods | [Lily graph](../src/inferrsi/data/skill_library/repositories/lily/SKILL.md), bounded hashes, safe offline helpers and Apache-2.0/NOTICE retention. Actual portable native-Rust/Metal adaptation, not a DisCo CLI/model run. Cargo/native/model/quality/performance evidence unavailable; later long-context prefill negatives and runner/report version mismatch are retained. `NO_LICENSE` is the unauthenticated resolver fallback, not a legal finding. | diff --git a/docs/searchspace-matrix.md b/docs/searchspace-matrix.md index d18f9812..19c1b45c 100644 --- a/docs/searchspace-matrix.md +++ b/docs/searchspace-matrix.md @@ -439,3 +439,10 @@ Network coverage. Existing resource cells and maturity boundaries remain unchang This adds conditional Hopper guidance without new measured or green coverage. Registers, SMEM and HBM remain device resources; local CTA/cluster coordination and tile scheduling add no RAM/Host, SSD, Network or OS-control coverage. + +## Lily exact-model source contracts + +| Resource | Stage / named mechanism | Canonical owner | Evidence boundary | +| --- | --- | --- | --- | +| Accelerator / RAM | Diagnose / Configure / Verify: exact affine-Q4 plus role-Q8, shared buffer views, state/scratch/sequence capacity and completion ownership | [model-runtime](../src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md) | Source/Python selected-rule checks, not Rust loading, actual memory fit, Metal synchronization or model quality. | +| Host / Accelerator / service boundary | Diagnose / Verify: strict API, extra lookahead token, strict token prefix before key preference, actually-fed state retention and version/metric qualification | [serving-cache](../src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md) and [qualification](../src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md) | Compiler/native/model stages not run; CPU references and ignored/cfg-omitted tests are not GPU evidence. No measured service or Network coverage is added. | diff --git a/src/inferrsi/data/skill_library/README.md b/src/inferrsi/data/skill_library/README.md index 1e41f230..179c0ef9 100644 --- a/src/inferrsi/data/skill_library/README.md +++ b/src/inferrsi/data/skill_library/README.md @@ -1,7 +1,7 @@ # InferRSI skill library -The English-only library contains **81 skill documents**: 60 registered skills -and 21 engine and research-router skills. Complete procedures, metadata, +The English-only library contains **85 skill documents**: 61 registered roots (including the Lily graph), +21 separately indexed engine/router documents and three Lily sub-skills. Complete procedures, metadata, references, cases and source notices ship with the package. ## Browse by owner @@ -20,7 +20,7 @@ existing resource directory. ## Read registered skills -[`skill-index.json`](skill-index.json) maps 60 stable skill IDs to their canonical +[`skill-index.json`](skill-index.json) maps 61 stable skill IDs to their canonical paths and backend scopes. Install the optional `skills` extra for these commands: ```bash @@ -118,7 +118,7 @@ guidance; it establishes no cross-pin implementation compatibility. Five repository entry skills, 15 focused sub-skills and one research router provide source-grounded procedures. These 21 documents are available through -the links and catalog records below, separately from the 60-ID registry. +the links and catalog records below, separately from the 61-ID registry. The registered ComfyUI and stable-diffusion.cpp audits are listed alongside these imports and use generated abstracts rather than runtime repository packs. @@ -227,3 +227,10 @@ separates mined mechanisms, unmined source headers and Blackwell-only recipes; [source/license qualifications](hardware/cuda/reason-hopper-kernels/references/sources.md) retain contradictions and distribution discrepancies. GPU execution and efficacy remain not_run. + +## Lily portable AREX candidate + +[Lily](repositories/lily/SKILL.md) owns exact architecture/MLX-affine-Q4 runtime, +strict text API/token-prefix state and native/benchmark qualification guidance. +Its compiler/Metal/model gaps remain blocked; offline Python helpers are not +Rust execution. Catalog ID: `inferrsi.common.skills.lily`. diff --git a/src/inferrsi/data/skill_library/repositories/lily/LICENSE b/src/inferrsi/data/skill_library/repositories/lily/LICENSE new file mode 100644 index 00000000..bd3b52f5 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2026 Perplexity AI, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/inferrsi/data/skill_library/repositories/lily/NOTICE.md b/src/inferrsi/data/skill_library/repositories/lily/NOTICE.md new file mode 100644 index 00000000..c80f5407 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/NOTICE.md @@ -0,0 +1,66 @@ +lily +Copyright 2026 Perplexity AI, Inc. + +This product includes software developed as part of the lily project, +licensed under the Apache License, Version 2.0 (see LICENSE). + +-------------------------------------------------------------------------------- +Third-party attribution +-------------------------------------------------------------------------------- + +MLX +https://github.com/ml-explore/mlx + +MLX-LM +https://github.com/ml-explore/mlx-lm + + lily reads MLX's affine 4-bit weight format ({codes, scales, biases}, group- + wise). Portions of these Metal implementations were adapted from MLX and + MLX-LM for lily's own dispatch and tile geometry: + + src/kernels/metal/attention.metal + MLX sdpa_vector.h, sdpa_vector_2pass_1 + Copyright © 2024 Apple Inc. + + src/kernels/metal/quant.metal + MLX quantized.h + Copyright © 2023-2024 Apple Inc. + + src/kernels/metal/moe.metal + MLX quantized.h and MLX-LM qwen3_next.py and switch_layers.py + Copyright © 2023-2024 Apple Inc. + Copyright © 2025 Apple Inc. + + src/kernels/metal/gdn.metal + MLX-LM gated_delta.py + +MLX and MLX-LM are licensed under the following terms: + +MIT License + +Copyright © 2023 Apple Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The Gated DeltaNet recurrence that tests/support/cpu_ref.rs and +src/kernels/gdn.rs implement, and the online-softmax formulation the +flash-attention prefill kernel uses, are published algorithms; the +implementations here are lily's. diff --git a/src/inferrsi/data/skill_library/repositories/lily/SKILL.md b/src/inferrsi/data/skill_library/repositories/lily/SKILL.md new file mode 100644 index 00000000..30e096b3 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/SKILL.md @@ -0,0 +1,82 @@ +--- +name: lily +description: "Investigate Lily's exact Qwen3.6-35B-A3B MLX-affine-Q4 contract, Metal state and kernels, strict greedy text API, token-prefix session cache and source-qualified validation or benchmark plans." +license: NO_LICENSE +disable-model-invocation: true +metadata: + disco-role: operating +--- + +# Lily inference engineering + +Use this source-derived candidate to investigate representation, state or +qualification questions in `perplexityai/pplx-garden/lily`. It is not a generic +Metal/MLX runner. Read [source and method provenance](references/repo-provenance.md) +before applying it to a different revision, model or device. + +## Route the question + +| Question | Route | Expected result | +| --- | --- | --- | +| A nominally 4-bit model fails to load, or memory/sequence capacity is unclear | [model-runtime](sub-skills/model-runtime/SKILL.md) | Exact architecture/layout and ownership/capacity contract | +| A request is rejected, or equal keys/history do not reuse state as expected | [serving-cache](sub-skills/serving-cache/SKILL.md) | Strict API, token-prefix and state-lifetime diagnosis | +| CPU references look green, a golden is ignored, or MLX comparisons disagree | [qualification](sub-skills/qualification/SKILL.md) | Matching native evidence, version and metric boundaries | + +The focused routes bundle safe offline screening/request support where useful. +Those helpers do not invoke Rust, compile shaders, load tensors, tokenize a real +checkpoint or start inference. Their positive result is not native acceptance. + +## Establish the execution tuple + +Record engine/source and Cargo lock/toolchain, macOS/chip/GPU family, exact +checkpoint and tensor payload identities, config/affine layout, tokenizer/chat +template and output-stop identity. Add sequence/output budgets, greedy policy, +input history, prefix-cache state, workload and quality/measurement requirements. + +Equal nominal bit width, file size, API name or `prompt_cache_key` does not +identify equivalent tensors, rendered tokens or valid recurrent/KV state. +Separate reported benchmark identity from the checked-out runner's version. + +## Native preparation boundary + +The source requires Rust 1.92, macOS 26 and Apple GPU family 10/M5 or newer. +For an authorized source build the public command is +`cargo build --release --locked`; shader source is compiled at runtime, not by +an offline metallib step. Inspect an installed binary's help before any model +run. Building a package does not supply its supported checkpoint or qualify it. + +This extraction has neither Cargo/Rust nor a compatible Mac/model environment. +AREX's Python-package preparation was explicitly adapted to native Rust/Metal +identity and small offline helper checks. No installed Python distribution, +Rust test run or native backend success is fabricated. + +## Work one bounded hypothesis + +1. Read the selected bundled contract and failure notes. +2. Resolve exact input representation and actual API semantics before tuning. +3. Trace owner, logical token frontier, allocation, cache key and release or + restore boundary. Matching visible text is weaker than exact token identity. +4. Preserve the source's extra request lookahead slot when budgeting; do not + replace its checked arithmetic with only prompt-plus-visible-output length. +5. Freeze workload, checkpoint/version, numerical/quality controls and metrics + before comparing. Gates and campaign revisions belong in an acceptance issue. +6. Distinguish source inspection, offline helper checks, compiled native tests, + real Metal operators, matched-model goldens and service measurements. + +## Stop and report + +Return exact source/model/device identity, observation, invariant, alternate +cause, smallest falsifier, actual check result and remaining gap. Stop at +unsupported format/API, missing compiler/backend/checkpoint, unfrozen gates or +the authorized budget. Do not install a toolchain, download a model, alter the +API or weaken an ignored/golden test merely to obtain a green result. + +Required native compiler/Metal/model evidence remains blocked. CPU reference +functions and Python screening are not GPU test execution; skipped or ignored +cases do not become passing evidence. No quality, performance, service or +behavioral skill-efficacy qualification is claimed. Final partial-candidate +admission is a separate informed decision, not automatic import. + +Source [Apache-2.0 license](LICENSE) and [NOTICE](NOTICE.md) are retained. +`NO_LICENSE` is the actual AREX unauthenticated-CLI fallback, not a legal finding; +model weights and third-party material retain their own obligations. diff --git a/src/inferrsi/data/skill_library/repositories/lily/metadata.json b/src/inferrsi/data/skill_library/repositories/lily/metadata.json new file mode 100644 index 00000000..c4088431 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/metadata.json @@ -0,0 +1,107 @@ +{ + "schema_version": 1, + "kind": "skill", + "origin": [ + "external" + ], + "status": "candidate", + "empirical_validation": "not_run", + "license": "NO_LICENSE", + "tags": [ + "lily", + "rust", + "metal", + "apple-silicon", + "mlx-affine-q4", + "session-prefix", + "numerical-validation", + "benchmark-provenance" + ], + "sources": [ + { + "type": "git", + "url": "https://github.com/perplexityai/pplx-garden", + "commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "paths": [ + "lily/README.md", + "lily/Cargo.toml", + "lily/Cargo.lock", + "lily/rust-toolchain.toml", + "lily/CONTRIBUTING.md", + "lily/LICENSE", + "lily/NOTICE", + "lily/src/lib.rs", + "lily/src/config.rs", + "lily/src/weights.rs", + "lily/src/safetensors.rs", + "lily/src/tensor.rs", + "lily/src/metal.rs", + "lily/src/model.rs", + "lily/src/serve.rs", + "lily/src/serve/session.rs", + "lily/src/chat.rs", + "lily/src/generate.rs", + "lily/src/tokenizer.rs", + "lily/src/kernels/attention.rs", + "lily/src/kernels/gdn.rs", + "lily/src/kernels/gemm.rs", + "lily/src/kernels/skinny.rs", + "lily/src/bin/lily-bench.rs", + "lily/tests/support/cpu_ref.rs", + "lily/tests/test_shader_compile.rs", + "lily/tests/test_e2e_35b.rs", + "lily/tests/test_tokenizer.rs", + "lily/tests/unit/weights.rs", + "lily/tests/unit/serve.rs", + "lily/tests/unit/serve/session.rs", + "lily/tests/unit/generate.rs", + "lily/tests/unit/kernels/gemm.rs", + "lily/tests/unit/kernels/gdn.rs", + "lily/tests/unit/kernels/skinny.rs", + "lily/docs/2026-09-01-performance-mlx-0.31.2.md", + "lily/docs/2026-09-02-performance-mlx-0.32.2.md", + "lily/benchmarks/run_matrix.py", + "lily/benchmarks/bench_mlx.py", + "lily/benchmarks/requirements.txt" + ], + "license": "Apache-2.0", + "scope": "Lily subtree only; independent lily/LICENSE and NOTICE retained.", + "readset": "references/source-identity.json" + }, + { + "type": "git", + "url": "https://github.com/VectorSpaceLab/AREX-Skill", + "commit": "ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6", + "paths": [ + "cli/packages/coding-agent/src/disco/skills/create-repo-skill", + "cli/packages/coding-agent/src/disco/skills/prepare-repo-skill-env", + "cli/packages/coding-agent/src/disco/skills/workflow-authoring", + "cli/packages/coding-agent/src/disco/skills/verify-repo-skill" + ], + "scope": "Portable native Rust/Metal adaptation executed by a compatible agent; not a DisCo CLI/model run." + } + ], + "construction": { + "anchor_kind": "source", + "distillation_form": "repository-operating-graph", + "strategy": "arex-portable-meta-skills", + "status": "partial-candidate", + "native_import": "not-run", + "method": "User-approved native Rust/Metal and partial drafting adaptation; stable-ID lanes, integrated source graph and assertion/helper verification. Missing compiler/backend/checkpoint remains explicit." + }, + "applicability": { + "scope": "Exact Lily source/checkpoint/layout/API/cache/qualification investigation; common catalog classification is not CPU inference or cross-device support." + }, + "limitations": [ + "Cargo/Rust1.92, supported M5/macOS26/Metal and model resources are unavailable; native evidence remains BLOCKED_REQUIRED_BACKEND.", + "Offline Python helper checks are not Rust serde/loader/tokenizer, native kernel/state/cache, model quality, service or performance validation.", + "Current benchmark source and later report have distinct package/harness identities; negative long-context prefill observations remain author-reported.", + "Only selected source bodies are mined; complete kernel/format/platform/failure coverage and behavioral skill efficacy remain unverified.", + "NO_LICENSE is the actual unauthenticated GitHub CLI fallback, not a legal conclusion; lily Apache-2.0 LICENSE and NOTICE are independently retained." + ], + "provenance_readsets": [ + "references/repo-provenance.md", + "references/source-identity.json" + ], + "consumption_mode": "packaged" +} diff --git a/src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md b/src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md new file mode 100644 index 00000000..6b14cfcd --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md @@ -0,0 +1,50 @@ +# Source and method provenance + +Schema: `disco.repo-provenance.v1` (native Rust/Metal adaptation). + +- Canonical source: `perplexityai/pplx-garden`, subtree `lily/`. +- Commit: `1ed972ed3f0bd5616c997c9507c25616c63394fc`, branch `main`; + clean tracked source at capture, no exact tag asserted. +- Package: Cargo `lily` 0.1.0, edition 2024, pinned Rust 1.92.0. This is source + metadata, not a locally installed or executed native package. +- Method: AREX-Skill `ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6`, portable + create/prepare/workflow-authoring/verify instructions with compatible-agent + stable-ID lanes and whole-graph integration. Native adaptation/partial drafting + were explicitly accepted. No DisCo CLI/model API or managed import ran. +- Destination: InferRSI's candidate library and its existing registry/catalog; + no new engine runner, repository type or live skill collection is installed. + +## Evidence and refresh + +The [source inventory](source-identity.json) hashes the bounded input files; +focused references identify selected bodies and line readsets. The extraction +uses Cargo/platform gates, model/config/weight/tensor contracts, selected model/ +kernel/state/serve/session code, source test boundaries and benchmark methods. +File hashes do not mean every body, shader or failure path was mined. + +Other monorepo projects, complete kernels, model payloads/downloads and actual +Mac/toolchain qualification are outside scope. The two performance reports and +checked-out benchmark runner retain their own version/harness identities; +source documents are not automatically mutually reproducible. + +Refresh model/schema/layout, state/cache, API, test gating and benchmark-version +guidance before reuse at another revision. Common catalog placement describes +discovery only, not CPU support or cross-device compatibility. + +The source tests/reports identify `mlx-community/Qwen3.6-35B-A3B-4bit` at +`38740b847e4cb78f352aba30aa41c76e08e6eb46`. This is retained research identity, +not downloaded/authenticated payload evidence or a general experiment default. + +## Licensing and validation boundary + +The actual repository/commit GitHub CLI license lookup was unauthenticated and +returned `NO_LICENSE`. This warning fallback is not a legal determination. +`lily/LICENSE` is Apache-2.0; its `NOTICE` is retained with a Markdown filename +for package inclusion. Third-party/model terms do not disappear through import. + +No Cargo/Rust compiler, compatible M5/macOS26 host or checkpoint is available in +this extraction. Native compile, shaders, operators, recurrent/session state, +matched-model quality, performance and skill efficacy remain unverified. Small +offline Python helpers test their own bounded screening logic, not the Rust +implementation or target tensor payloads. Final candidate admission remains +manual after exact verification gaps are presented. diff --git a/src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json b/src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json new file mode 100644 index 00000000..718fa692 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json @@ -0,0 +1,13 @@ +{ + "schema_version": "2.0", + "repo_id": "perplexityai/pplx-garden", + "skill_id": "lily", + "taxonomy_sha256": "f8c306386015711634ddbb43a5eb95d1f58909c3513ce2063ba42efdd583a431", + "routing_status": "classified", + "assignments": [ + { + "area": "Model Deployment and Optimization", + "family": "Inference Serving" + } + ] +} diff --git a/src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json b/src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json new file mode 100644 index 00000000..33802c9a --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "repository": "perplexityai/pplx-garden", + "subdirectory": "lily", + "commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "coverage": "Selected bodies only; file hashes are source identities, not complete mining or execution.", + "files": { + "lily/README.md": "4c5ad11f80a222f3f45599eda52de4d29d8e3d4954554ab7415e2ac25f113627", + "lily/Cargo.toml": "2cc501146aedd8458abda2fa1404529ebfbf7afb2274271e4c531d9bae5d36e6", + "lily/Cargo.lock": "ac89db7238fd2114563e065cf86001dbee1f0113cda6eb7428f9013ae41a86dd", + "lily/rust-toolchain.toml": "04cb50fe7668e4367e8e603d7fcb4dee057541c14e6d7989dfec7bc9d5f7ec09", + "lily/CONTRIBUTING.md": "e92b27a8631f3b6f5a86f435c5b8a1fd10b9c4a8ba1481be62aa300cf1841d2e", + "lily/LICENSE": "b9e2b50a48a09fb39dafa71ab1a11a6e87389addda17faa99d55f5f74a0001ac", + "lily/NOTICE": "7a01e666044fb8aca1fd88c636bca43bcc95b8b1fecbe101dce4c7c80fbb5759", + "lily/src/lib.rs": "74ce0f1e90674982d5bcd0bd177b30975e5f836195cd681939d894b940d0ae19", + "lily/src/config.rs": "633f1ccf93494d8589de3c7a4ba6943b949661922fe8ba612c26abd726f994f6", + "lily/src/weights.rs": "2d797f9e24a395cec8ce6e96141be18bd869c1e1556fd928875fa135e2f5c7cc", + "lily/src/safetensors.rs": "01d98906984c650e553e65f643329eff0da5047065d71a16223aa631a0f7e7c1", + "lily/src/tensor.rs": "87d765f15fa37ee1a4d20b7c162230f3f3fd273f299b4c9d6772e15237bfccab", + "lily/src/metal.rs": "dfa57ae244dd55062e170df77afaef29c66cf3af511c3d3331c6dd781b7f3150", + "lily/src/model.rs": "79ec9237a9f03bbe339c6117fd378dd62ac695f3b30029d19c973160f22aa125", + "lily/src/serve.rs": "4d55fc1a1bac1b38582fa5d6cbe71c12cf20199552086dbb19707cd635a9bc5b", + "lily/src/serve/session.rs": "2d173f33970d72f9c6c13aa7f54f1ae5427f6b195803efb72efcefaf8f16e8b2", + "lily/src/chat.rs": "bb2aebe1ca978408d2011380b10926fc77fa6a8e079cde2949443b57400e5b6a", + "lily/src/generate.rs": "df2ba9ac70c77565ef90b30013e0401769c65c45ba39b6fb18f0847d977ea1eb", + "lily/src/tokenizer.rs": "c234d5f364148da4c133791bbf8b130d22335c507a5c1f9bc8fe191a76a8c01d", + "lily/src/kernels/attention.rs": "17b9e774325e9857ada11a0c77f169031b4d94a1049855c07e48c6540bfe93c6", + "lily/src/kernels/gdn.rs": "24b358b7bab16cfafec4e80dc98bae8cb24ed4a14517043f9fdf7a164bca6fa5", + "lily/src/kernels/gemm.rs": "9e338149c28065b1da8424bdb40aa5597ceebdffc90a51d93961baba73c68c85", + "lily/src/kernels/skinny.rs": "a47945a185e07e7dd339a3693715cfbf9d1ab65a7db266f3094e9a2ab7f9cfab", + "lily/src/bin/lily-bench.rs": "bb28a92e88d9228130e78016b1c56a93f303719ff82c368950bcece60295e19c", + "lily/tests/support/cpu_ref.rs": "c3322d257cc9484acf2469f2b35ecc62aa7f9417027810966b3b3c0386d0daf5", + "lily/tests/test_shader_compile.rs": "a6c82c654fe514bb4178cf2b5f63d00f2e5c8409bc782d89b1032d8799bd048e", + "lily/tests/test_e2e_35b.rs": "b08d712e696e6c99c1e6cd027d174bc09c44db0a87d0405635822af36e6b0ca5", + "lily/tests/test_tokenizer.rs": "87573f06f8bf4ece9037ed377e2dcfb6c18f8d8f91b810b85a64166ec854f317", + "lily/tests/unit/weights.rs": "6824fb86eac3be6a9389d7d3694256631bd8d06ca5d367e9434a793f5dc891b6", + "lily/tests/unit/serve.rs": "ebb9963067b32fb2baa70cad7e2f4a3a024d21ac3a0fda63cebb2b98b3cb67a0", + "lily/tests/unit/serve/session.rs": "e7fd1395367eefc2fa66181b7c7bc2dd58a68e39693d130357710ff86baec1ce", + "lily/tests/unit/generate.rs": "b3a7519457ddca917dc0f7074fb0fcc83144ab10fe8da473293c41cf91185d95", + "lily/tests/unit/kernels/gemm.rs": "26e870f1a1b49ed8ccd1479871ba33d108cf537c4a7aa67557fb7600f24ab5c5", + "lily/tests/unit/kernels/gdn.rs": "87a0b78d96774c40f9089b16402fa5f0ea94d7846b0f87721ca8fbe153991dff", + "lily/tests/unit/kernels/skinny.rs": "48d6c456b0146648fd3aedbda92521805e31723f8b408413fa5e54c75bd6e258", + "lily/docs/2026-09-01-performance-mlx-0.31.2.md": "8803f32fc55099877acdfafc920023eb84b63e547463fac84a3d35605fb6d28b", + "lily/docs/2026-09-02-performance-mlx-0.32.2.md": "2802dfe9ad7d432affbaa28b31daf9ff433e002fd5be3f2e9c6889cdc7b1faa3", + "lily/benchmarks/run_matrix.py": "b3f9af845fe9b5656d0813fa23bc2bc36197443f1a14381ce924f31daf0c5e06", + "lily/benchmarks/bench_mlx.py": "c4f08568e439e6cad703dd49d68ab95731aa901c2654239b3951628984d1a3df", + "lily/benchmarks/requirements.txt": "7aa22ce31516e006cfe1c5d5752a4f596eb7cb8a7c2ba8dc8f9187b3e73c7bdc" + } +} diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md new file mode 100644 index 00000000..940946ee --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md @@ -0,0 +1,89 @@ +--- +name: model-runtime +description: "Screen Lily's exact Qwen3.6-35B-A3B MLX affine checkpoint contract and audit packed weights, Metal tensor views, per-session state and sequence capacity without claiming native execution." +license: NO_LICENSE +metadata: + disco-role: operating +disable-model-invocation: true +--- + +# Lily model and runtime + +Use this route for checkpoint compatibility, same-bit-width layout confusion, +loader errors, tensor-view changes, sequence-capacity questions and memory +ownership. Lily is not a generic Qwen or GGUF runner: the inspected engine +targets one exact Qwen3.6-35B-A3B architecture converted to MLX affine Q4, +group size 64, with specific Q8 router/gate exceptions. + +Native execution needs Rust 1.92/Cargo and the locked dependency set, macOS 26 +or later and Apple GPU family 10 (M5 or newer), plus compatible actual weights. +Non-macOS `cfg` gates expose some pure modules; they are not a CPU inference +backend. Python screening does not satisfy a missing Rust compiler or Metal +runtime. Required backend/compiler gaps remain explicit. + +## Establish identity and representation + +Record source revision, exact checkpoint bytes/revision, text configuration, +tensor names/shapes/dtypes, quantization group/mode/packing, requested maximum +sequence, actual tokenized workload, platform and compiler/runtime versions. +Read [model and memory](references/model-and-memory.md) for the full bundled +contract and [troubleshooting](references/troubleshooting.md) before changing +formats or lifetimes. + +## Procedure + +1. **Screen the exact shape.** Require the supported wrapper model type, + dimensions, expert counts and 40-layer attention pattern. The top-level + quantization is required; absent mode defaults to affine, but a non-affine + mode, non-Q4 bits or group size other than 64 is rejected. An offline first + screen is available in [screen_config.py](scripts/screen_config.py); its + successful result is deliberately only `passed_selected_rules`. +2. **Verify actual tensor representation.** Ordinary projections and embedding + use low-element-first packed U32 codes with BF16 scales and additive biases. + The router and shared-expert gate require Q8 storage, inferred from packed + width. Do not rewrite those to Q4 to match the global config. Native loading + checks expected names, role-specific dimensions and consumed tensors; config + screening cannot establish those facts. +3. **Separate loading from execution.** Shard/header discovery and range reads + are followed by native dtype/layout and shape checks. Weight bytes are read + into shared-storage Metal buffers, not proven usable by a file-size match. + A skipped vision tower is not an implemented multimodal path. Preserve + missing, unsupported and unconsumed-tensor failures instead of hiding them. +4. **Account unique allocations and views.** A cloned Tensor or fused-weight + row view shares storage, with a byte offset. Bind `(buffer, offset)` and + preserve four-byte view alignment; a bare buffer identity can collide across + distinct weights. Do not sum view handles as full allocations or assume + shared storage permits concurrent host writes. +5. **Preserve command ownership.** Concurrent decode dispatches require explicit + dependency barriers; committed pending passes must finish before host reads, + resets or overwrites touching their buffers. State position can advance at + encoding before GPU completion. Idle-GPU assumptions are part of correctness, + not optional measurement overhead. +6. **Budget state plus scratch, not weights alone.** Each decode state has GDN + recurrent FP32 state and double BF16 convolution windows, plus full-attention + BF16 K/V sized by maximum sequence. Scratch has fused views and prefill + buffers grown on demand. Count cached session states and physical allocation + overlap, not just active requests or checkpoint size. +7. **Respect sequence semantics.** The server clamps its requested ceiling to a + smaller nonzero checkpoint window. The kernel ceiling still applies. A + request is checked using actual rendered prompt tokens plus `max_tokens` + **plus one** extra slot, with overflow rejection. Character counts and a + nominal prompt-plus-output total are insufficient. + +## Safe offline screening + +From this sub-skill directory, with a small public JSON configuration: + +```sh +python scripts/screen_config.py --config --max-seq 4096 +``` + +The helper reads only that JSON file and prints selected-rule findings. It +does not read weights, import an engine, compile Rust/MSL, allocate device memory, +verify tokenization or calculate a safe physical-memory budget. Its explicit +unchecked list remains part of every result; do not shorten it to “compatible.” + +Stop at shape/layout mismatch, missing source bytes, a sequence exceeding the +effective ceiling, unsafe buffer lifetime, unavailable native resources or the +authorized task boundary. A candidate, header screen or installed knowledge read +does not qualify model quality, memory fit, performance or service behavior. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md new file mode 100644 index 00000000..c834fc8f --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md @@ -0,0 +1,129 @@ +# Lily checkpoint, tensor and state contract + +## Source boundary + +This bounded readset is from `perplexityai/pplx-garden`, subdirectory `lily`, +at revision `1ed972ed3f0bd5616c997c9507c25616c63394fc`. No Rust build, native +test, shader compile, weight load, Metal execution or memory measurement is +implied. The source is Apache-2.0 with its retained MLX/MLX-LM notices; weights +have separate licensing. The generated `NO_LICENSE` field records AREX's +unavailable authenticated-CLI lookup, not an absence of legal source licensing. + +## Exact model identity, not a family guess + +The wrapper's `model_type` is `qwen3_5_moe`; the runtime name Qwen3.6-35B-A3B +does not change that JSON spelling. Lily reads `text_config` and intentionally +ignores vision weights. The native architecture check requires: + +| Area | Required values | +| --- | --- | +| Core | hidden size 2048; 40 layers; vocabulary 248320; untied embeddings | +| Sparse FFN | 256 experts; 8 per token; routed and shared intermediate widths 512 | +| Full attention | 16 query heads; 2 KV heads; head dimension 256; output gate enabled | +| Linear attention | 16 key heads; 32 value heads; key/value dimensions 128; convolution width 4 | +| Layer pattern | Repeated three `linear_attention` layers then one `full_attention`, exactly 40 entries | +| Top-level quantization | required; `bits: 4`, `group_size: 64`, `mode: affine` or omitted/null mode | + +The native parser also consumes required RMS epsilon, RoPE parameters, EOS and +other typed fields. A top-level EOS setting overrides the text-config EOS when +present. This skill's helper intentionally screens selected shape/quantization +rules only: a JSON passing it can still fail required-field deserialization, +tokenizer/template, weight, native geometry or runtime checks. No config-only +screen proves it is the benchmark's immutable checkpoint. + +## Packed weights and loader checks + +Ordinary quantized matrices use `w = scale * q + bias` per 64 input elements. +For logical shape `[out, in]`, Q4 codes are U32 `[out, in/8]`, low element/nibble +first; BF16 scales and additive biases are `[out, in/64]`. A signed symmetric +int4 matrix, a zero-point convention from another library, an AWQ/GPTQ packing, +GGUF blocks or raw BF16 weights are not interchangeable with these triples. + +The global Q4 setting has deliberate per-role Q8 exceptions: +`mlp.gate` and `mlp.shared_expert_gate`. The native loader infers bits from +packed width and checks against the expected role. Their code width is +`in/4` U32 words rather than the ordinary Q4 `in/8`; BF16 scale/bias grouping +still uses the configured group size. Mixed precision here is an exact +checkpoint-layout contract, not a newly selectable broad quantization mode. + +Expected text names begin with `language_model.model.`; the untied head is +`language_model.lm_head`. Expert stacks flatten expert and output-row axes. +Some projections concatenate gate/up or q/k/v rows into one physical buffer, +then hand out row views. The loader validates expected features/shapes, +quantized-code U32 and BF16 scale/bias types, and records consumed tensor names. +Only explicitly skip-listed `vision_tower.` names can remain unused; arbitrary +extra names trigger a drift error rather than being silently ignored. + +The safetensors reader discovers shards from the index or a single file, +rejects duplicate tensor names across shards and reversed data offsets, and +uses exact range reads into caller-sized destinations. Recognizing a header +or index is not payload integrity authentication. Do not claim that the +inspected reader is a complete untrusted-file security validator or that a +digest of a header authenticates complete weights. + +## Tensor and Metal ownership + +`Tensor` is a reference-counted shared Metal buffer plus shape, dtype and byte +offset. Clone and row views share data. Views must stay within the logical +tensor and start on a four-byte-aligned offset; BF16 views therefore start at +an even element. Kernel binding must use `binding()` rather than assume a +zero offset. Weight cache identity includes base storage plus view offset. + +`MetalContext` owns the device/queue and compiled-pipeline cache keyed by +function name and MSL version. It refuses GPU families below 10. MSL sources +compile at runtime, so a Rust binary build is not a shader-compile result. +Shared buffers are zero-initialized by the allocator because Metal fresh +contents are not a model-state reset guarantee. + +Serial prefill passes provide order; concurrent decode encoders require +explicit buffer barriers between dependency levels. A pending committed pass +must be waited before reading its output on the host or mutating any buffer +it touches. Decode position increments at encode/submit time, not proof that +the GPU has completed. Retaining a tensor handle protects ownership but does +not by itself establish synchronization. + +## Memory ledger and sequence capacity + +| Item | Owner/lifetime | Budget implication | +| --- | --- | --- | +| Model weights | Model, with fused-view aliases | Count each backing buffer once, including packed codes, scales and biases | +| GDN recurrent state | Each DecodeState, FP32 `[32,128,128]` per linear layer | Fixed state for 30 linear layers, plus double BF16 convolution windows | +| Full-attention K/V | Each DecodeState, BF16 `[2,max_seq,256]` for K and V per full layer | Linear in selected maximum sequence for 10 full layers | +| Decode scratch | Engine execution scratch, fused output segments are views | Count unique scratch allocations and dequant/routing/attention intermediates | +| Prefill scratch | Scratch-owned, grown on demand in bounded powers of two | Growth drops old buffers first; warm larger prompts can retain larger scratch | +| Cached session state | Session store, not only current request | Two resident cache entries may retain separate DecodeStates; key equality does not merge buffers | +| Host/checkpoint/runtime objects | Host loader and Metal runtime | Tensor payload sums are not total physical/RSS/driver peak memory | + +For illustration of the **payload geometry**, full-attention KV alone uses +`10 layers × 2(K,V) × 2 KV heads × max_seq × 256 × 2 bytes` per allocated +DecodeState. GDN state adds +`30 layers × 32 heads × 128 × 128 × 4 bytes`, plus two convolution windows per +linear layer. These are source-derived component formulas, not a capacity +guarantee or a measured peak; no model-weight and scratch bytes are omitted +from an actual fit decision. + +Reset requires an idle GPU, clears GDN/conv state and rewinds position; K/V +rows past the reset position need not be cleared because they must never be +read before being overwritten. Preserve this frontier invariant during reuse. + +`--max-seq` is not output tokens alone. Server load clamps it to a smaller +nonzero `max_position_embeddings`; zero means no checkpoint-declared clamp. +The effective value must be at least two for serving and must satisfy the +262144-token kernel limit. Request validation uses rendered/tokenized prompt +length plus `max_tokens` **plus one** extra slot, with checked arithmetic. +Do not use character count, omit template overhead, or fill the whole ceiling +with prompt plus output and assume equality is accepted. + +## Bounded readset + +- `README.md:1-23,70-84`: supported checkpoint/platform and high-level capacity. +- `Cargo.toml:1-8,47-52`, `rust-toolchain.toml`, `src/lib.rs:8-33`: compiler and macOS gates. +- `src/config.rs:17-30,54-111,114-197`: native configuration and exact shape. +- `src/weights.rs:22-82,85-112,163-224,276-321,324-425,539-586`: packing, roles, loader and drift checks. +- `src/safetensors.rs:11-24,81-114,135-163,167-205`: index/header/read boundaries. +- `src/tensor.rs:26-77,80-127,173-203`: aliases, views, offset identity and idle-GPU contract. +- `src/metal.rs:76-175,208-242,275-345,378-390`: native family gate, pipeline/buffer and pass ownership. +- `src/model.rs:35-43,100-185,199-233,505-577,660-713`: model/state/scratch and encode frontiers. +- `src/serve.rs:41-46,144-160,179-191`, `src/kernels/attention.rs:10`, `src/kernels/gdn.rs:18`: sequence/kernel/state rules. +- `tests/unit/weights.rs:1-32`, `tests/unit/serve.rs:27-30`: role-bit and extra-token assertions, read not executed. +- `NOTICE:1-69`: source and MLX/MLX-LM attribution, not weight-license permission. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md new file mode 100644 index 00000000..55b11ba4 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md @@ -0,0 +1,25 @@ +# Model-runtime troubleshooting + +| Symptom | Check and interpretation | Recovery/stop | +| --- | --- | --- | +| “unsupported model_type” despite Qwen branding | Native wrapper spelling is `qwen3_5_moe`, and the exact shape must match | Do not rename a dense/smaller model's field to bypass the gate; stop at incompatible architecture | +| Global Q4 config but a router is rejected | Routers/shared-expert gates require the checkpoint's Q8 packed width | Restore the compatible per-role layout; do not force all tensors to Q4 | +| A 4-bit checkpoint lacks scales/biases or loads nonsense | MLX affine uses U32 low-element-first codes with BF16 scales and additive biases per input group | Matching bits does not convert AWQ/GPTQ/GGUF/symmetric layouts. Require a verified conversion/compatible checkpoint, separately authorized | +| “checkpoint tensors were not consumed” | Unexpected names survive the explicit vision skip list | Treat as layout drift; do not broaden the skip list just to obtain a successful load | +| Config screen succeeds but native load fails | The helper does not check all required typed fields, tensor names, shapes, dtypes, payloads or tokenizer | Preserve the native error; helper output is selected-rule screening, not compatibility acceptance | +| Model fits but longer contexts or cached conversations do not | K/V allocation scales with maximum sequence per DecodeState; GDN and scratch are additional | Inventory unique buffers and retained states. Lower the supported ceiling/workload only within authorized scope; no weight-size-only estimate | +| Two views of one allocation appear identical to a weight cache | View offset was lost from binding or identity | Bind buffer+offset, preserve four-byte alignment and include offset in identity | +| Recycled state or host read produces unstable output | A pending pass may still read/write buffers, or GDN/conv reset/frontier rules were violated | Wait for GPU completion before host access/reset; preserve barriers and state position. Source reading cannot validate the repaired native path | +| Prompt plus output equals the ceiling but request is refused | Actual rendered prompt tokens plus max_tokens plus one must fit | Count actual tokenized template bytes via the supported tokenizer, retain extra slot and overflow checks | +| Non-macOS pure modules compile | GPU modules are `cfg(target_os=macos)` gated | This is not CPU inference. Missing Rust1.92, M5/macOS26, shaders or weights remains blocked, not a skip/pass | + +## Support-tool and authorization boundary + +The bundled screen is a narrow Python adaptation of native configuration +predicates, not a substitute Rust implementation. It accepts only the supplied +JSON and optional maximum-sequence value, reads no checkpoint payloads and +performs no native compile/import/device work. Model download commands are +excluded because they alter external storage and require separate license, +capacity and network decisions. Benchmark scripts are reference-only here: +they build/execute native engines and external MLX, outside the offline screen. +Do not repair an absent toolchain by installing a host runtime without approval. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py new file mode 100644 index 00000000..3b2b0693 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Screen selected Lily config predicates, never complete model compatibility. + +Adapted into Python from perplexityai/pplx-garden/lily/src/config.rs:122-182 +at 1ed972ed3f0bd5616c997c9507c25616c63394fc (Apache-2.0; retain owner notices). +Sequence screening follows serve.rs:148-150 and attention.rs:10. +Changes: selected JSON predicates only, explicit unchecked scope and CLI JSON; +no serde/Rust equivalence, weight reads, tokenizer, model import or device use. +Example: python screen_config.py --config public-config.json --max-seq 4096 +""" + +import argparse +import json +from pathlib import Path + +EXPECTED = { + "hidden_size": 2048, "num_hidden_layers": 40, "vocab_size": 248320, + "num_experts": 256, "num_experts_per_tok": 8, "moe_intermediate_size": 512, + "shared_expert_intermediate_size": 512, "num_attention_heads": 16, + "num_key_value_heads": 2, "head_dim": 256, "linear_num_key_heads": 16, + "linear_num_value_heads": 32, "linear_key_head_dim": 128, + "linear_value_head_dim": 128, "linear_conv_kernel_dim": 4, +} +UNCHECKED = [ + "remaining required Rust/serde fields, EOS, RMS epsilon and RoPE validity", + "tensor names, shapes, per-role Q8 exceptions, dtypes, packing and payload bytes", + "tokenizer/template and actual request token budget", + "Rust1.92 compilation, Metal shaders/device execution, memory fit and quality", +] + + +def screen_config(config, max_seq=None): + """Return selected-rule findings; successful screening is not native acceptance.""" + errors = [] + if not isinstance(config, dict): + raise ValueError("config must be a JSON object") + if config.get("model_type") != "qwen3_5_moe": + errors.append("model_type must be qwen3_5_moe") + text = config.get("text_config") + if not isinstance(text, dict): + raise ValueError("text_config must be a JSON object") + for name, expected in EXPECTED.items(): + if type(text.get(name)) is not int or text[name] != expected: + errors.append(f"text_config.{name} must equal {expected}") + for name, expected in (("attn_output_gate", True), ("tie_word_embeddings", False)): + if text.get(name) is not expected: + errors.append(f"text_config.{name} must be {str(expected).lower()}") + layers = ["full_attention" if i % 4 == 3 else "linear_attention" for i in range(40)] + if text.get("layer_types") != layers: + errors.append( + "layer_types must repeat three linear_attention then full_attention, 40 total" + ) + quant = config.get("quantization") + if not isinstance(quant, dict): + errors.append("top-level quantization object is required") + elif (quant.get("mode") not in (None, "affine") + or type(quant.get("bits")) is not int or quant["bits"] != 4 + or type(quant.get("group_size")) is not int or quant["group_size"] != 64): + errors.append("quantization must be affine bits=4 group_size=64") + declared = text.get("max_position_embeddings", 0) + effective = None + if type(declared) is not int or declared < 0: + errors.append("max_position_embeddings must be a nonnegative integer if supplied") + elif max_seq is not None: + if type(max_seq) is not int or max_seq < 2: + errors.append("requested max_seq must be an integer at least 2") + else: + effective = min(max_seq, declared) if declared else max_seq + if not 2 <= effective <= 262144: + errors.append("effective max_seq must be 2..262144 after checkpoint clamp") + return {"status": "failed_selected_rules" if errors else "passed_selected_rules", + "screen_only": True, "native_validation": "not_run", "errors": errors, + "effective_sequence_ceiling": effective, "unchecked": UNCHECKED} + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--config", type=Path, required=True) + parser.add_argument("--max-seq", type=int) + args = parser.parse_args(argv) + try: + result = screen_config(json.loads(args.config.read_text(encoding="utf-8")), args.max_seq) + except (OSError, ValueError) as error: + parser.error(str(error)) + print(json.dumps(result, sort_keys=True)) + return 1 if result["errors"] else 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md new file mode 100644 index 00000000..715b87fd --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md @@ -0,0 +1,89 @@ +--- +name: qualification +description: "Qualify Lily's exact-checkpoint Rust/Metal inference by separating CPU reference algorithms, executed GPU kernels, shader builds, model goldens and version-bound production-throughput reports. Use for test coverage, route boundaries, numerical changes, benchmark evidence or performance claims." +license: NO_LICENSE +disable-model-invocation: true +metadata: + disco-role: operating +--- + +# Qualify native behavior and benchmark evidence + +This route is source-derived candidate guidance. It does not certify Rust +compilation, Metal execution, model quality or performance. Read the +[verification contract](references/verification-contract.md) for test semantics, +measurement boundaries and preserved report limitations; use +[troubleshooting](references/troubleshooting.md) for a misleading green test, +missing pipeline, changed golden or version mismatch. + +## Establish the exact tuple + +Record source/build and lockfile identities, compiler, macOS and Apple GPU +family, checkpoint revision plus actual weight/tokenizer/template hashes, +quantization layout, numerical settings, prompt/token sequence, sequence and +output budgets, cache state and request workload. Lily's inspected model loader +supports one Qwen3.6-35B-A3B affine-Q4 checkpoint layout, not arbitrary 4-bit +models or a general Qwen family. Route representation/runtime work to +[model-runtime](../model-runtime/SKILL.md). + +For comparisons, additionally freeze engine/harness/MLX package versions, +binary/source/harness digests, production versus diagnostic mode, timing +boundaries, warmup/lookahead policy, sample schedule, quality/latency/resource +gates, validators and authorized stop condition before experimentation. + +## Procedure + +1. **Determine what compiled and executed.** Non-macOS library module gating is + not a supported CPU inference backend. The plain-Rust CPU reference is a + numerical oracle used by Metal tests; its library exposure is itself + macOS-and-test gated. A test named “matches CPU” can allocate a Metal device, + dispatch a real GPU kernel and compare its result with that oracle. Report + compiler availability, cfg omissions, ignored tests and actual test counts. +2. **Separate pipeline existence from correctness.** Runtime Metal source + compilation/pipeline creation can catch missing functions or shader errors. + It does not prove numerical agreement, route selection or state correctness. + MSL versions expose different kernels. The current production GEMM requires + native tensor units; do not infer an older-device fallback from a general + language-version comment. +3. **Test boundaries against an independent reference.** Preserve BF16 input + rounding and F32 recurrence/reference semantics. Cover shape/packing route + predicates on both sides and execute the selected kernels, including tails, + nonzero views, stacked/sliced layouts and recurrent-state continuation. + A successful fallback is not evidence that the intended fast route ran. +4. **Use checkpoint-matched goldens for their actual claim.** The selected + tokenizer and E2E tests are explicitly ignored unless requested; their + environment variable supplies model files, not proof of the checkpoint + identity. Tokenizer/template parity and a greedy continuation golden are + separate checks. Neither alone qualifies the HTTP API, cache isolation or + concurrency. Send those to [serving-cache](../serving-cache/SKILL.md). +5. **Audit supplied records before interpreting speed.** The bundled + [record auditor](scripts/audit_benchmark_record.py) checks a saved Lily report's + selected source/mode/count/finite-value/digest consistency without importing + MLX, launching a process or reading a model. Its success means only internally + consistent supplied metadata; it authenticates no execution or binary bytes. +6. **Match the metric and version contract.** Published comparisons measure + in-process free-running production generation, not identical isolated graphs + or HTTP E2E. Preserve the distinct prefill-first-yield and decode-inter-yield + boundaries, exact-shape warmup and drained unused lookahead. MLX computes + full-vocabulary logprobs that Lily does not expose. Per-engine repeated token + digests are not cross-engine numerical equivalence. +7. **Keep refusals and negative boundaries.** Source/version mismatch, + incomplete arms, nonfinite/unstable timings, changed repeated digests, + interference or power/thermal uncertainty cannot become a valid result by + selecting the favorable rows. Preserve that the later MLX report has + long-context prefill cases where Lily is slower, despite its reported decode + advantage. Never transfer ratios across package versions, models or devices. + +## Report and stop + +Return executed/failed/ignored/cfg-omitted/not-run checks separately, the exact +artifact identities, workload and metric boundary, counterexamples and remaining +native/model/service gaps. No compiler means Rust checks were not run; no +supported Mac or checkpoint means required native evidence remains +`BLOCKED_REQUIRED_BACKEND`. Python fixture or static-record checks do not clear +that gate and establish no skill efficacy or campaign PASS. + +Stop at unsupported hardware/model/layout, unresolved report-version identity, +failed numerical/state/quality gates, missing frozen evidence or the authorized +budget. Reading this skill grants no toolchain installation, model download, +process survey, benchmark run, host change or candidate promotion authority. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md new file mode 100644 index 00000000..d9fcf33f --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md @@ -0,0 +1,22 @@ +# Qualification troubleshooting + +| Symptom | Likely boundary | Discriminating next check/recovery | Stop condition | +| --- | --- | --- | --- | +| “Matches CPU” test is cited as CPU-only GPU validation | CPU reference is an oracle; selected tests allocate/dispatch Metal and are cfg gated | Identify actual compiled modules, named executed tests, device, readback and reference comparison | No native device/compile evidence means no GPU proof | +| Non-macOS library check is green | Only non-GPU modules may have been compiled; integration targets differ | Report exact Cargo target/flags/cfg and counts; do not generalize a library check into all-target or runtime support | No compiler was available here; Rust checks remain not run | +| Tokenizer/E2E test did nothing or is ignored | Explicit ignored checkpoint tests, filtering or an absent-fixture path elsewhere | Inspect named test state and fixture bytes; the selected ignored tests error when explicitly run without their model variable | A green summary or short duration is not positive model execution evidence | +| Shader test passes but GEMM fails later | Different MSL function availability, unsupported GPU family, shape or route | Distinguish 3.1/4.x pipeline build, actual family-10 requirement and numerical dispatch/readback | Do not infer an older-Mac production fallback from a generic version comment | +| Fast-path benchmark looks good but boundary output changes | Route/reduction variant, packed layout, subview or tile tail changed | Check predicate and numeric agreement on both sides, stack-versus-slice route uniformity and actual selected kernel | A fallback's time cannot qualify the intended kernel | +| One recurrent step agrees but long continuation diverges | State accumulation or chunk/capture semantics changed | Compare output and F32 recurrent state over multiple steps/block boundaries, then full matched-model quality | One operator test is not complete quality evidence | +| Golden tokens differ after “equivalent” checkpoint replacement | Exact weight/router exception, tokenizer/template, thinking or arithmetic identity differs | Retain first divergence and confirm actual hashes and fixture thinking mode before analysis | Do not rewrite a frozen golden to silence a candidate failure | +| Runner refuses MLX 0.32.2 though a report uses it | Current source pins 0.31.2; later report names different harness/environment digests | Resolve historical artifacts or freeze a new versioned comparison with explicit changes | Do not bypass version checks and call it unchanged reproduction | +| Decode digest repeats within engines but differs across engines | Each engine follows its own greedy trajectory, affecting MoE routes | Treat repetition as within-engine stability; use same-prefix numeric/quality checks for equivalence | Repeated digests alone do not prove identical graphs or model quality | +| Native throughput is called HTTP or agent latency | Loading/tokenization/template/HTTP/detokenization excluded; production lookahead cadence measured | Measure client-observed request latency/load and complete task quality separately | No E2E claim from in-process cadence alone | +| Diagnostic report is mixed into production table | GPU timing mode retains command buffers/timestamp data | Verify declared mode and timing-record shape against the frozen plan with the offline auditor | No silent metric-mode substitution | +| Favorable decode rows hide slower long-context prefill | Version/metric/context selection bias | Preserve both reports and later long-context prefill ratios below one with exact conditions | No universal “faster” claim or cross-version pooled ratio | +| A JSON audit passes without native tools | Only supplied fields/digest were checked | Authenticate actual binaries/model bytes/execution and complete required native checks | Static consistency cannot clear `BLOCKED_REQUIRED_BACKEND` or grant admission | + +Do not copy process surveys, host names, private paths or prompts into shared +evidence. Redaction must preserve version identity, missing stages and failures. +Do not install a toolchain, download a checkpoint, launch a model process or +survey unrelated processes to investigate without authorization for that action. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md new file mode 100644 index 00000000..5b1d08ae --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md @@ -0,0 +1,181 @@ +# Lily verification contract + +This reference distills the root provenance's pinned `pplx-garden/lily` source. +Paths and spans identify inspected primary evidence; the operational contracts +are bundled here so source-checkout files are not runtime dependencies. + +## What each test can establish + +| Evidence layer | Source behavior | Limit | +| --- | --- | --- | +| Compile/typecheck | Selected non-GPU modules are exposed on non-macOS; GPU modules and CPU-reference test module have explicit cfg gates | A library-only non-macOS check does not compile or run every integration target, nor provide CPU inference | +| Plain-Rust reference | F32 numerical reference implementations; BF16 inputs pre-rounded before GPU comparisons | An oracle is not evidence that GPU outputs agree until the actual kernel/readback comparison runs | +| Kernel numeric test | Creates a Metal context, tensors and command pass, dispatches a kernel, waits and compares readback with the CPU reference | Covers its selected shapes/route/numerical tolerance only; not whole-model quality or service | +| Shader/pipeline test | Compiles shipped source through the Metal framework and builds functions at selected MSL versions | Pipeline creation alone does not validate outputs, routing or performance | +| Tokenizer/template golden | Explicitly ignored checkpoint test compares exact rendered prompt token IDs | Distinct from model recurrence, greedy continuation or HTTP/cache behavior | +| E2E greedy golden | Explicitly ignored checkpoint test loads the model and compares generated tokens to a selected stored chat golden | One matched prompt/checkpoint fixture is not general model quality, API qualification or a service SLO | + +`src/lib.rs:8-33` gates generation, kernels, Metal, model, serving, tensors, +tokenizer and weights to macOS; `cpu_ref` is exposed only under +`cfg(all(target_os = "macos", test))`. Selected checkpoint integration tests +import those gated modules rather than universally compiling away on Linux. +Do not claim a generic `cargo test` on another OS proves all-target coverage. +This extraction had neither Cargo/Rust nor the supported native platform; +none of these Rust/native stages was executed. + +Evidence: `Cargo.toml:1-57`; `CONTRIBUTING.md:1-42`; `src/lib.rs:1-33`; +`tests/support/cpu_ref.rs:1-120`; `tests/unit/kernels/gemm.rs:12-57`; +`tests/test_shader_compile.rs:1-74`; `tests/test_tokenizer.rs:14-52`; +`tests/test_e2e_35b.rs:1-47`. + +### Interpreting a green result + +The contributor guide warns that absent-fixture early returns can look green +under captured test output. The selected tokenizer/E2E tests currently use +`#[ignore = "requires LILY_MODEL_DIR_35B"]`; when explicitly selected, a missing +variable returns an error. Preserve the actual test implementation and report +which mechanism applied instead of assuming every green is either a skip or a +real run. Capture test enumeration, ignored/cfg/filtered counts, named completed +cases, fixture identity and native device evidence. A short duration is a clue, +not conclusive proof that a test did nothing. Model-loading tests sharing a GPU +need serialized execution under an authorized run, not concurrent memory races. + +### Shader and device boundaries + +The shader test is macOS gated. Its MSL 3.1 pass permits `gemm.metal` to expose +no functions because that file's tensor-op kernel is MSL4-only; the MSL4 pass +requires functions from every shipped shader. Kernel enumeration/pipeline build +is useful evidence of coverage at that version, not a run of every shape. +`MetalContext::new` requires Apple GPU family 10 or later. Production GEMM +probes its native tensor-unit pipeline at supported MSL4 versions and errors +when none compiles. A broader comment about keeping a 3.1 fallback is not an +implemented production GEMM fallback or support promise for older Macs. + +Evidence: `tests/test_shader_compile.rs:1-74`; `src/metal.rs:46-98,105-160`; +`src/kernels/gemm.rs:12-46`. + +## Numerical and route checks + +- Compare the intended GPU computation to independent plain-Rust F32 formulas, + not the previous optimized version. Pre-round inputs to BF16 when isolating + accumulation error; distinguish storage-rounding from accumulation/reduction + differences. GDN state is F32 because recurrent rounding compounds. +- Cover the actual shape predicate and numerical outputs on both sides. The + inspected skinny-Q4 route depends on M, output width and complete group-64 + block walks. Fused stacks and their slices must choose the same reduction + variant; a new route can change arithmetic even with equal real-valued math. +- Include tile tails/odd dimensions where supported, model-shaped tensors, + subviews/nonzero offsets and packing/dtype rejection. Do not broaden a valid + group-64 U32-code/BF16-activation result to other four-bit formats. +- Check recurrent output **and** state across chunk/block boundaries and after + repeated steps. A one-step output match cannot establish a long-context + continuation or cache restore. +- Record the route actually executed. A shape that falls back safely may pass + correctness while telling nothing about the candidate kernel's performance. + Preserve fallback/unsupported/error states rather than hiding them in timing. + +Evidence: `CONTRIBUTING.md:30-42`; `tests/support/cpu_ref.rs:1-120`; +`src/kernels/gdn.rs:17-55`; `src/kernels/skinny.rs:15-45,74-112`; +`tests/unit/kernels/skinny.rs:315-370,598-603`; +`tests/unit/kernels/gdn.rs:7-105`. This is a selected readset, not a complete +kernel/state audit. + +## Exact checkpoint and golden scope + +Both performance reports identify the same immutable +`mlx-community/Qwen3.6-35B-A3B-4bit` snapshot, MLX affine Q4 with group size 64 +and checkpoint-declared affine-Q8 router exceptions. The exact snapshot ID is +retained in root provenance/model guidance; it is research identity, not an +experiment default for other models. Preserve model payload, config, +tokenizer/template and quantization identities together. + +The selected E2E test consumes `golden_35b_chat.json` prompt token IDs and +chosen-token steps; the separate tokenizer golden renders its prompt with the +test's chosen thinking mode. The HTTP server's thinking-disabled contract is a +different interface. Passing the golden does not prove streaming, tools, +sampling, multimodal inputs or speculative decoding—which the inspected public +interface does not support. Use the bundled serving route for that strict API. + +## Production-throughput measurement boundary + +The reports compare batch-one greedy in-process generation on an Apple M5 Max +40-core GPU with 128 GB unified memory and macOS 27.0. They use deterministic +synthetic prompt IDs, fresh processes, exact-shape warmup, one measured prefill +and a fixed count of decode deliveries. These are **author-reported** records, +not locally reproduced results from this knowledge extraction. + +| Metric/control | Distilled boundary | Incorrect interpretation | +| --- | --- | --- | +| Prefill throughput | Prompt tokens until first delivery with first decode already submitted; MLX uses the first production generator yield | Isolated transformer-prefill kernel time or complete user TTFT | +| Decode throughput | Subsequent literal inter-yield/delivery intervals; one-token lookahead before delivery and final unused lookahead drained outside timing | Single-kernel latency, synchronous identical graphs or HTTP E2E | +| Warmup | Exact measured prompt shape and asynchronous cadence; unused work synchronized before measured state | A generic warmup of another shape or unfinished GPU work leaking into measurement | +| Internal graph | Stock MLX-LM also returns a full-vocabulary logprob vector that Lily does not expose | Equal token counts imply identical executed graphs | +| Tokens/digest | Each engine repeats its own free-running greedy trajectory; cross-engine equality is informational | Repeated within-engine digest proves cross-engine numerical equivalence or same MoE routes | +| Diagnostic flag | Retained command buffers/timestamp records are a separate diagnostic mode | A diagnostic report can silently substitute for production timing | + +Source timing evidence: `src/bin/lily-bench.rs:31-180`; +`benchmarks/bench_mlx.py:53-84,97-153`; both performance reports' measurement +sections. Model loading, tokenization, template rendering, HTTP and +detokenization lie outside the reported timed regions. E2E service/quality +claims need their own authorized workload and frozen evidence. + +## Version mismatch and preserved negative observations + +The September 1 report names MLX **0.31.2**, MLX-LM **0.31.3** and Transformers +**5.14.1**. The September 2 report names MLX **0.32.2** with the same MLX-LM and +Transformers versions, and different binary/harness/requirements digests. +At the inspected source snapshot, `benchmarks/requirements.txt`, +`run_matrix.py:27` and `bench_mlx.py:27-31` pin **0.31.2** and reject another +package map. Therefore the currently checked-out runner is not an exact +reproducer of the later report merely because its filename matches the +instructions. Resolve the historical harness/environment bytes or prepare a +new explicitly versioned experiment; do not edit expected-version checks and +describe the resulting run as unchanged reproduction. + +The later report's prefill rows at 32,768, 65,536 and 131,072 context have +Lily/MLX ratios below one. Preserve that longer-context prefill disadvantage +alongside its reported decode advantage. The earlier and later ratios cannot +be pooled into a universal claim or transferred to other devices, model sizes, +formats, API loads or precision modes. Raw historical run artifacts were not +downloaded/authenticated here; source reports and their declared hashes remain +imported evidence with that availability limit. + +Evidence: `docs/2026-09-01-performance-mlx-0.31.2.md:1-97`; +`docs/2026-09-02-performance-mlx-0.32.2.md:1-101`; +`benchmarks/run_matrix.py:27,268-278`; `benchmarks/bench_mlx.py:27-31,97-99`. + +## Fail-closed evidence workflow + +Before an authorized comparison, freeze source/binary/lockfile/harness and model +hashes, expected package map, workload and timing boundaries, diagnostic mode, +sample schedule, quality/metric gates and stop condition. Record baseline and +candidate arms without letting missing/failed/noisy samples disappear. + +The source runner checks source/clean state, package pins and report source/mode +counts; alternates engine order and reverses contexts; checkpoints a manifest +before/after each fresh-process arm; records thermal/power/interference; and +refuses incomplete, nonfinite, unstable or within-engine digest-changing rows. +Its fixed publication thresholds belong to that source experiment, not generic +InferRSI defaults. `--ignore-foreign-load` records rather than gates foreign +load and must remain visible as a changed policy. Process survey output, model +paths, host names and command lines require privacy review before publication. + +The bundled [record auditor](../scripts/audit_benchmark_record.py) adapts only +the safe supplied-record validation idea: source/mode/count fields, positive +finite times/rates, token IDs and FNV digest. It reads one JSON file and uses +only Python's standard library. It neither imports the upstream runner/MLX nor +surveys processes, runs binaries, reads model files or grants a qualification +verdict. A consistent forged/stale record can still pass; authenticate external +bytes and execution separately. + +Script inventory: `run_matrix.py` and `bench_mlx.py` are **reference-only** +because they launch native/MLX model processes, require prepared weights and +perform machine/process surveys with privacy implications. The selected +`validate_lily_report` logic is **adapted** into the offline helper with stricter +identity/value/digest checks, not copied as an executable matrix runner. Model +download commands and toolchain installers are **excluded**; no host setup or +network/model operation is authorized by this procedure. + +Required native Rust compile, supported Metal/kernel/model/state/golden and +service evidence remains blocked in this extraction. Static helper or Python +fixture success verifies only that helper and the supplied metadata shape. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py new file mode 100644 index 00000000..e0fcc000 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python3 +"""Check selected consistency fields of a saved Lily benchmark JSON record. + +Adapted from perplexityai/pplx-garden lily/benchmarks/run_matrix.py's +validate_lily_report idea (Apache-2.0), at the owning skill's source provenance. +Changes: standalone offline JSON audit, stricter values/identity/digest checks; +no model, MLX imports, subprocesses, machine surveys, network or verdict. + +Example: python audit_benchmark_record.py --report record.json + --source-id <40-hex-source-id> --decode-steps 64 [--diagnostic] +Consistency of supplied fields does not authenticate execution or file hashes. +""" + +from __future__ import annotations + +import argparse +import json +import math +import re +from pathlib import Path + + +def positive(value: object) -> bool: + return ( + isinstance(value, (int, float)) + and not isinstance(value, bool) + and math.isfinite(value) + and value > 0 + ) + + +def audit(document: object, source_id: str, steps: int, diagnostic: bool = False) -> dict: + if not re.fullmatch(r"[0-9a-f]{40}", source_id) or type(steps) is not int or steps <= 0: + raise ValueError("expected a lowercase full source SHA and positive decode count") + if ( + not isinstance(document, dict) + or type(document.get("schema_version")) is not int + or document["schema_version"] != 1 + ): + raise ValueError("expected a schema-version-1 report object") + meta = document.get("meta", {}) + workload = document.get("workload", {}) + if not isinstance(meta, dict) or not isinstance(workload, dict): + raise ValueError("meta and workload must be objects") + if meta.get("engine") != "lily" or meta.get("source_id") != source_id: + raise ValueError("engine/source identity mismatch") + if workload.get("gpu_timing_diagnostic") is not diagnostic: + raise ValueError("diagnostic mode mismatch") + if ( + type(workload.get("decode_steps")) is not int + or workload["decode_steps"] != steps + or type(workload.get("prompt_len")) is not int + or workload["prompt_len"] <= 0 + ): + raise ValueError("workload counts mismatch") + results = document.get("results") + if not isinstance(results, dict): + raise ValueError("results must be an object") + for metric in ("prefill", "decode"): + value = results.get(metric) + if not isinstance(value, dict) or not all( + positive(value.get(field)) for field in ("wall_secs", "tok_s") + ): + raise ValueError("times and rates must be finite positive numbers") + decode = results["decode"] + intervals, tokens = decode.get("step_wall_secs"), decode.get("token_ids") + if not isinstance(intervals, list) or len(intervals) != steps or not all( + positive(value) for value in intervals + ): + raise ValueError("decode intervals mismatch") + if not isinstance(tokens, list) or len(tokens) != steps or not all( + type(token) is int and 0 <= token <= 0xFFFFFFFF for token in tokens + ): + raise ValueError("decode token IDs mismatch") + digest = 0xCBF29CE484222325 + for token in tokens: + digest = ((digest ^ token) * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF + if decode.get("token_digest") != f"{digest:016x}": + raise ValueError("token digest mismatch") + passes, lookahead = decode.get("gpu_passes"), decode.get("lookahead_gpu_pass") + if diagnostic: + if not isinstance(passes, list) or len(passes) != steps or not isinstance( + lookahead, dict + ): + raise ValueError("diagnostic GPU record shape mismatch") + elif passes != [] or lookahead is not None: + raise ValueError("production record contains diagnostic GPU timing") + return { + "record_consistent": True, + "source_id": source_id, + "decode_steps": steps, + "diagnostic": diagnostic, + "scope": "supplied metadata only; no native execution or byte authentication", + } + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--report", required=True, type=Path) + parser.add_argument("--source-id", required=True) + parser.add_argument("--decode-steps", required=True, type=int) + parser.add_argument("--diagnostic", action="store_true") + args = parser.parse_args() + try: + result = audit( + json.loads(args.report.read_text(encoding="utf-8")), + args.source_id, + args.decode_steps, + args.diagnostic, + ) + except (OSError, ValueError, TypeError, OverflowError) as error: + parser.exit(2, f"record inconsistent: {error}\n") + print(json.dumps(result, indent=2)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md new file mode 100644 index 00000000..91654be7 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md @@ -0,0 +1,87 @@ +--- +name: serving-cache +description: "Prepare Lily's strict text-only greedy Chat Completions requests and diagnose its two-entry exact-token-prefix session cache, key preferences, template history and decode-state lifetime." +license: NO_LICENSE +disable-model-invocation: true +metadata: + disco-role: operating +--- + +# Lily serving and session cache + +Use for a rejected OpenAI-style client request, a changed multi-turn prefix, an +unexpected cache miss or an incorrect assumption about `prompt_cache_key`. +This is source-derived candidate guidance, not native Rust/Metal/model +validation. Read [API and session contracts](references/api-and-session.md) +for exact fields, cache-selection rules and the bounded readset; use +[troubleshooting](references/troubleshooting.md) for recovery and falsifiers. + +## Establish the contract + +Record source/build version, exact supported checkpoint and tokenizer/template, +macOS/GPU, `--max-seq`, full ordered text messages, requested output length, +optional cache key and recent request order. Lily is a serial, single-checkpoint +server, not a general OpenAI proxy, streaming server or multi-tenant session +service. The supported model identifier is `Qwen3.6-35B-A3B`. + +Do not add fields a general SDK normally sends. Sampling controls, tools, +structured output, multimodal content and thinking switches are not this +server's request API. `temperature: 0` is still an unknown field; greedy decode +is inherent, not configured through that parameter. + +## Procedure + +1. **Screen the request offline.** Use the bundled + [request helper](scripts/request_template.py), which constructs or checks + only the documented JSON surface and never contacts a server. The accepted + fields are `model`, `messages`, `max_tokens`, `stream` and + `prompt_cache_key`; messages have only `role` and string `content`. +2. **Require the supported conversation shape.** Roles are `system`, `user` or + `assistant`, and the final message must be `user`. `messages` must not be + empty. `stream` must be false/omitted and `max_tokens` positive. Unknown + fields are errors, not ignored options. Template-level constraints remain + authoritative after this structural screening. +3. **Freeze tokenization and thinking semantics.** The server always chooses + disabled-thinking rendering from the checkpoint template. Lily deliberately + retains a closed empty reasoning block in earlier assistant turns to keep + direct-answer histories prefix-cacheable. Do not compare visible strings + alone or replace the template/tokenizer with another checkpoint's files. +4. **Budget the actual rendered tokens.** Source validation requires + `rendered_prompt_tokens + max_tokens + 1 <= effective_max_seq`, with checked + arithmetic. The extra token is reserved by the implementation. The effective + limit is clamped to the checkpoint's declared position capacity. The offline + helper cannot compute native template/token counts or prove that capacity. +5. **Check exact prefix before the key.** A cached token sequence must be + shorter than, and exactly equal to the beginning of, the new prompt. Same + key, semantically equivalent text or an equal-length exact prompt cannot + bypass that strict predicate. Among valid candidates a matching explicit + key is preferred, then the longest prefix; another key is not an isolation + barrier. +6. **Trace owned state, not response text.** The selected session is checked + out of the store while used. Its state position must equal retained token + count. Generation feeds the uncached suffix, then the greedy decode loop; + the retained history appends only generated tokens actually fed into the + decode state, which need not be every token returned to the client. +7. **Explain eviction and error paths.** The store holds at most two released + sessions. With no matching prefix and a full store, it resets and reuses the + least-recently-used entry's state; otherwise it allocates a new state. Only + a successful position-consistent session is released back. Failure is not + permission to synthesize KV state or repair only the token vector. +8. **Choose one smallest falsifier.** Compare the exact rendered token prefix, + state position, request order and reported + `usage.prompt_tokens_details.cached_tokens`. Test same-key/different-prefix + and different-key/valid-prefix separately. Execute native comparisons only + with the supported authorized hardware/model and a frozen request sequence. + +## Report and stop + +Return the JSON/API decision, effective token budget, strict-prefix decision, +key preference, retained-state boundary, LRU context, observed result and one +counter-explanation. A helper pass proves only its own structural checks; a +health/model-list response is not model correctness or performance evidence. + +Stop before unapproved service startup/exposure, model downloads, toolchain +installation or unavailable native execution. Rust tests were not run where +Cargo/rustc are unavailable; M5+/macOS 26/Metal/model checks remain +`BLOCKED_REQUIRED_BACKEND`. Python request construction is not Rust API, cache, +tokenizer, device-state or service qualification. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md new file mode 100644 index 00000000..20e19934 --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md @@ -0,0 +1,164 @@ +# Lily API and session contracts + +Bounded static read of `perplexityai/pplx-garden/lily` at monorepo commit +`1ed972ed3f0bd5616c997c9507c25616c63394fc`. All guidance is bundled here; +source paths below identify evidence, not files a future user must reopen. +Native Rust/Metal, actual checkpoint tokenization and real inference were not +executed by this author lane. + +## A deliberately small API + +| Method/path | Meaning | +| --- | --- | +| `GET /health` | HTTP handler health after engine startup | +| `GET /v1/models` | The one served ID, `Qwen3.6-35B-A3B` | +| `POST /v1/chat/completions` | Serial, text-only, greedy completion | + +Other routes return 404. This snapshot does not implement Responses, Anthropic +Messages, streaming, tool calling or structured-output endpoints. The inspected +server has no application authentication/TLS layer; keep a separately authorized +deployment local or behind the appropriate independently reviewed protection. +Do not add a permissive public bind merely to make an SDK connect. + +### Exact request surface + +```json +{ + "model": "Qwen3.6-35B-A3B", + "messages": [{"role": "user", "content": "Hello"}], + "max_tokens": 32, + "stream": false, + "prompt_cache_key": "conversation-a" +} +``` + +- `model`: required string, exactly the served ID; it does not hot-load weights. +- `messages`: required nonempty list, ending in a `user` message. Each object + has exactly `role` and string `content`; roles are `system`, `user`, + `assistant`. The checkpoint template can impose further history constraints. +- `max_tokens`: optional positive native unsigned integer; default 128. Zero, + negative numbers, booleans, fractional values and null are not valid here. +- `stream`: optional boolean default false; true is rejected, null is not the + same as omission. +- `prompt_cache_key`: optional string or null. The native field does not + require a nonempty string, and the helper does not invent that restriction. + +Request and message structs deny unknown fields. Thus `temperature`, even zero, +`top_p`, `seed`, `tools`, `tool_choice`, `response_format`, +`max_completion_tokens`, `chat_template_kwargs`, reasoning fields and image +content arrays are not supported request substitutions. The total body is +limited to 1 MiB. Malformed/unsupported input is a 400 +`invalid_request_error`; internal failures are 500 `server_error` with a generic +public message while diagnostic detail stays in the server log. + +The bundled helper's native-sized integer screen targets the supported +64-bit Apple runtime. It intentionally does not emulate the tokenizer, load +weights, check GPU capacity, start a service or validate a real response. + +## Template, capacity and greedy generation + +The tokenizer reads `tokenizer.json`; the template comes from +`chat_template.jinja`, falling back to the string `chat_template` field in +`tokenizer_config.json`. It renders with an assistant generation prompt and +no tools. Encode does not implicitly add special tokens because the rendered +template already owns its markers. + +The HTTP engine chooses `Thinking::Disabled`. Earlier assistant history turns +receive the closed empty reasoning block where the checkpoint template would +otherwise drop it. This deliberate history rewrite keeps exact multi-turn +prefixes stable for direct answers. It does not expose configurable reasoning +or make this server a sampling-compatible replacement for other runtimes. + +Request capacity uses checked addition: + +```text +required_tokens = rendered_prompt_tokens + max_tokens + 1 +required_tokens <= effective_max_seq +``` + +The engine clamps configured capacity to the checkpoint's declared +`max_position_embeddings` when nonzero. This is more specific than a +prompt-plus-response-only estimate: an exact boundary without the extra token +fails. An offline character count is not a substitute for rendered token count. + +Generation prefills the nonempty uncached suffix and selects greedily. It +recognizes configured tokenizer/config stop tokens. A stop token at the output +limit still makes the finish reason `stop`; otherwise exhaustion is `length`. +Pipelined work may already be submitted when a stop is observed and is waited +for. Do not confuse returned response tokens with tokens actually fed into +the retained decode state. + +## Two-entry exact-prefix store + +Each `Session` owns its token history, `DecodeState`, optional preferred key and +last-use clock. `SessionStore` holds released sessions with configured state +capacity; the HTTP engine constructs it with exactly two entries. The server +handles requests serially with one shared scratch object, not a concurrent +multi-lane scheduler. + +Selection proceeds in this order: + +1. Filter every entry by `cached_tokens.len() < new_prompt.len()` and exact + `new_prompt.starts_with(cached_tokens)`. +2. Among those valid prefixes, rank a matching explicit key before a + nonmatching key, then prefer the longer prefix. +3. Remove the chosen session from the store for exclusive use and verify + `state.pos == cached_tokens.len()`. +4. If none matches, reuse/reset the least-recently-used released state when + the two-entry store is full; otherwise allocate a new state. Return no + cached token prefix for this cold path. + +The explicit key is a selection preference **only**. It does not bypass token +equality, partition entries by caller, provide authentication, persist a +conversation or guarantee a hit. A different-key entry may still be selected +if it has a valid prefix and no preferred valid candidate outranks it. An +equal-length exact prompt is deliberately not a strict prefix and cannot +produce an empty generation suffix through this path. + +On completion the retained token history appends the prompt suffix, then only +`generation.fed - suffix.len()` generated tokens. This tracks the actual +decode-state position; appending all returned tokens indiscriminately can make +state/history inconsistent. The code verifies equality before release. Release +drops an inconsistent session instead of caching it; successful release stamps +recency and replaces its preferred key with the current request's key. + +The response reports the selected prefix length as +`usage.prompt_tokens_details.cached_tokens`; prompt usage remains the full +prompt count. The store is in process memory, not a persistent disk API or +durable remote conversation service. Restart, eviction, changed template or a +non-prefix transcript can legitimately require full prefill. + +## Smallest diagnostic and evidence limit + +Use a fixed supported checkpoint/template and compare: an exact continuation, +same key with an edited earlier turn, another key with a genuine prefix, and a +repeat equal-length prompt. Keep recent request order fixed to distinguish +identity from LRU eviction. Compare exact token arrays, cached-token usage and +state position, not human-visible semantic similarity. No native values are +available from the offline helper. + +Source predicate/unit tests are inspected evidence. Without Cargo/rustc, the +supported M5+/macOS 26 Metal runtime and checkpoint, neither their execution nor +model-state correctness is established. Required gaps remain +`BLOCKED_REQUIRED_BACKEND`; Python structural tests do not clear them. + +## Bounded source readset + +Paths are relative to the `lily/` subdirectory of the pinned monorepo. + +- `README.md`: supported model/hardware/API/cache and test boundaries. +- `src/serve.rs`: 20–46 model ID/request schema/budget; 90–128 error classes; + 134–257 engine load, validation, completion and state-history accounting; + 261–362 serial HTTP loop, route dispatch and body limit. +- `src/serve/session.rs`: complete file (1–87): strict prefix, preferred-key + ranking, checked-out state, LRU reset, consistency-checked release. +- `src/chat.rs`: complete file (1–54): roles and text-only message schema. +- `src/generate.rs`: complete file (1–133): tokenizer-backed greedy loop, + stop semantics, actual fed-token count and pipelined completion waits. +- `src/tokenizer.rs`: complete file (1–252): checkpoint tokenizer/template + loading, no implicit special tokens and disabled-thinking history rewrite. +- `tests/unit/serve.rs`: complete file (1–44): unknown fields, token-budget + overflow and public/internal error boundaries. +- `tests/unit/serve/session.rs`: complete file: strict versus equal-length or + changed-token prefix examples; `tests/unit/generate.rs`: complete file + (1–8): stop-token classification at the generation limit. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md new file mode 100644 index 00000000..ddce04ed --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md @@ -0,0 +1,35 @@ +# Lily interface and cache diagnostics + +These are source-grounded hypotheses and proposed checks, not observations from +a running engine. Read [API and session contracts](api-and-session.md) before +adapting a client from a broader OpenAI-compatible implementation. + +| Symptom | Distinguish | Smallest useful check | Safe recovery / stopping boundary | +| --- | --- | --- | --- | +| Request with `temperature: 0` is rejected | Greedy behavior versus a supported sampling field | Screen the top-level keys with the bundled request helper | Remove unsupported settings only if that preserves the user's intended semantics; do not claim non-greedy sampling works | +| Streaming/tools/schema request fails | Deliberately unsupported capability versus malformed syntax | Identify the actual endpoint and unsupported fields | Offer the strict text-only nonstreaming subset; use a separately chosen runtime if the user requires these features | +| Final assistant message fails | History continuation versus the required final user query | Check message roles and last role | Preserve complete history but finish with the intended user turn; do not forge a user message merely to hide an incompatible workflow | +| Same `prompt_cache_key` misses | Key preference versus exact strict token-prefix eligibility | Compare actual rendered token arrays and lengths, not only the key/text | Re-prefill is correct for edited history, equal-length prompt or a non-prefix; never mark old state valid from the key | +| Another key appears to reuse a prefix | Preference versus caller partitioning | Check whether it is a strict prefix and whether a valid matching-key candidate existed | This store is not key-isolated. Do not use keys as authentication or a confidentiality guarantee | +| Only two recent sessions remain warm | Fixed two-entry LRU and serial checkout/release | Repeat with a frozen request order; identify the reset oldest released state | Treat expected eviction separately from a leak; increasing concurrency is not an exposed cache option | +| Visible history matches but token prefix diverges | Checkpoint template/tokenizer and empty reasoning-block rewrite | Freeze exact files and rendered bytes/tokens across the earlier assistant turn | Restore matching template semantics; do not retokenize old KV under a different template | +| `request needs ... tokens` at an apparently exact fit | Native rendered prompt plus output plus one extra token | Apply `prompt_tokens + max_tokens + 1`, then the clamped effective capacity | Reduce requested output/history or choose supported capacity within actual memory; character counts do not prove fit | +| Token/state position mismatch | Returned tokens versus tokens fed into decode state | Compare retained history count with `DecodeState.pos` and source `generation.fed` accounting | Drop/rebuild invalid state; do not append every response token or repair only the vector | +| Stop at max output reported as `stop` | Stop-token termination versus simple length exhaustion | Check whether the final returned token is configured as a stop | Preserve source stop semantics; finish reason alone is not evidence of output-quality success | +| New request fails after an internal generation error | Selected state removed from store versus successful release | Verify the error category and whether a consistent session was returned | Retain failure and cold-rebuild; do not advertise persistence/recovery guarantees absent native evidence | +| Client expects Responses/Anthropic routes | Minimal Chat subset versus general proxy | Compare requested path against the three implemented routes | Use supported Chat shape or another explicitly selected engine; no route rewrite can add missing semantics | + +## Offline helper boundary + +The sibling `scripts/request_template.py` adapts request screening from the +source request/message structs and `validate_request`. It constructs a tiny body +or checks an existing body using only Python's standard library. It rejects +unknown keys, wrong types, unsupported roles/streaming and an incorrect model, +but it cannot load the checkpoint or validate its template. It prints JSON only; +it never sends a request, starts a listener, loads a model or contacts a network. + +The source native tests are not copied as runnable Python replacements. Their +Rust serde, tokenizer and device-state behavior must be tested by the original +implementation on the appropriate toolchain/hardware. A helper pass is only +evidence about the helper, not parity or native usability. Preserve the missing +compiler and `BLOCKED_REQUIRED_BACKEND` state explicitly. diff --git a/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py new file mode 100644 index 00000000..776cecef --- /dev/null +++ b/src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Construct or structurally screen Lily Chat JSON without network/model use. + +Adapted from lily/src/serve.rs and lily/src/chat.rs in perplexityai/pplx-garden +at 1ed972ed3f0bd5616c997c9507c25616c63394fc (Apache-2.0 source; root notices +retain attribution). This is not native Rust, tokenizer or backend validation. + +Example: python request_template.py --prompt 'Hello' --max-tokens 32 +Example: python request_template.py --request request.json +""" + +import argparse +import json +import sys +from pathlib import Path + +MODEL_ID = "Qwen3.6-35B-A3B" +MAX_BODY_BYTES = 1 << 20 +MAX_USIZE = (1 << 64) - 1 # Supported 64-bit Apple runtime, not arbitrary targets. +FIELDS = {"model", "messages", "max_tokens", "stream", "prompt_cache_key"} +ROLES = {"system", "user", "assistant"} + + +def unique_object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise ValueError("duplicate JSON field") + result[key] = value + return result + + +def validate(body): + """Return a structurally screened body; do not infer native token capacity.""" + if not isinstance(body, dict) or set(body) - FIELDS: + raise ValueError("request must be an object containing only supported Lily fields") + if body.get("model") != MODEL_ID: + raise ValueError("model must be Qwen3.6-35B-A3B") + messages = body.get("messages") + if not isinstance(messages, list) or not messages: + raise ValueError("messages must be a non-empty array") + for message in messages: + if not isinstance(message, dict) or set(message) != {"role", "content"}: + raise ValueError("each message must contain only role and content") + if not isinstance(message["role"], str) or message["role"] not in ROLES: + raise ValueError("message role must be system, user or assistant") + if not isinstance(message["content"], str): + raise ValueError("message content must be a string") + if messages[-1]["role"] != "user": + raise ValueError("the final message must have role=user") + maximum = body.get("max_tokens", 128) + if type(maximum) is not int or not 0 < maximum <= MAX_USIZE: + raise ValueError("max_tokens must be a positive 64-bit unsigned integer") + stream = body.get("stream", False) + if type(stream) is not bool or stream: + raise ValueError("stream must be false or omitted") + key = body.get("prompt_cache_key") + if key is not None and not isinstance(key, str): + raise ValueError("prompt_cache_key must be a string or null") + encoded = json.dumps(body, ensure_ascii=False, allow_nan=False).encode("utf-8") + if len(encoded) > MAX_BODY_BYTES: + raise ValueError("request body exceeds 1 MiB") + return body + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + source = parser.add_mutually_exclusive_group(required=True) + source.add_argument("--prompt", help="one text user message") + source.add_argument("--request", type=Path, help="existing JSON body to screen") + parser.add_argument("--max-tokens", type=int, help="constructor output limit, default 128") + parser.add_argument("--cache-key", help="preference only, not authentication/isolation") + args = parser.parse_args() + try: + if args.request is not None: + if args.max_tokens is not None or args.cache_key is not None: + raise ValueError("--request cannot be combined with constructor options") + raw = args.request.read_bytes() + if len(raw) > MAX_BODY_BYTES: + raise ValueError("request body exceeds 1 MiB") + body = json.loads(raw.decode("utf-8"), object_pairs_hook=unique_object) + else: + body = { + "model": MODEL_ID, + "messages": [{"role": "user", "content": args.prompt}], + "max_tokens": 128 if args.max_tokens is None else args.max_tokens, + "stream": False, + } + if args.cache_key is not None: + body["prompt_cache_key"] = args.cache_key + validate(body) + # Compact output preserves the checked byte limit even near 1 MiB. + print(json.dumps(body, ensure_ascii=False, allow_nan=False), end="") + except (OSError, UnicodeError, ValueError) as error: + parser.error(str(error)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/inferrsi/data/skill_library/skill-index.json b/src/inferrsi/data/skill_library/skill-index.json index 53c3ccef..88831c8f 100644 --- a/src/inferrsi/data/skill_library/skill-index.json +++ b/src/inferrsi/data/skill_library/skill-index.json @@ -240,6 +240,10 @@ "reason-hopper-kernels": { "path": "hardware/cuda/reason-hopper-kernels", "backend": "cuda" + }, + "lily": { + "path": "repositories/lily", + "backend": "common" } } } diff --git a/tests/check_installed.py b/tests/check_installed.py index 40c599c7..a7c9f80d 100644 --- a/tests/check_installed.py +++ b/tests/check_installed.py @@ -17,7 +17,7 @@ "This check requires an installed package" ) records = knowledge_records() -assert len(records) == 108, "Knowledge is missing from the installation" +assert len(records) == 109, "Knowledge is missing from the installation" assert ( files("inferrsi") .joinpath("data", "repo_packs", "vllm_omni", "knowledge", "README.md") @@ -43,7 +43,7 @@ ) == files("inferrsi").joinpath(*mlx_document.split("/")).read_bytes() assert files("inferrsi").joinpath("data/platform_packs/mlx/pack.json").is_file() skill_index = search_knowledge(repo="inferrsi", limit=100) -assert len(skill_index) == 60, "Missing installed skill abstracts" +assert len(skill_index) == 61, "Missing installed skill abstracts" assert all(record["index_type"] == "packaged-skill" for record in skill_index) indexed = KnowledgeReader().read("inferrsi.ascend.skills.ascend_operator_profiling") assert "data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md" in indexed.content @@ -143,7 +143,7 @@ data = resource.read_bytes().replace(b"\r\n", b"\n") assert hashlib.sha256(data).hexdigest() == expected_hash, relative registry = json.loads(library.joinpath("skill-index.json").read_text(encoding="utf-8"))["skills"] -assert len(registry) == 60 +assert len(registry) == 61 for entry in registry.values(): assert library.joinpath(*entry["path"].split("/"), "SKILL.md").is_file() router = library.joinpath("workflows", "inference-engine-research") diff --git a/tests/fixtures/repo_to_skill/lily/reports/final/final-skill-report.md b/tests/fixtures/repo_to_skill/lily/reports/final/final-skill-report.md new file mode 100644 index 00000000..fe18b676 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/final/final-skill-report.md @@ -0,0 +1,36 @@ +# Final Lily skill report + +## Source and method +perplexityai/pplx-garden lily/ at1ed972ed3f0bd5616c997c9507c25616c63394fc; +clean tracked source. Cargo lily0.1.0/Rust1.92 is source metadata only. AREX +portable meta-skills ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6 were executed by +compatible-agent manual orchestration under accepted Rust/Metal partial drafting. +No DisCo CLI/model API or managed import ran. + +## Coverage +Root plus model-runtime, serving-cache and qualification; six focused references, +source hash inventory, provenance, taxonomy fragment, Apache2/NOTICE retention +and3 offline helpers. Exact architecture/packing, allocation/state/API/cache and +native/benchmark evidence boundaries are covered. Complete kernels/platforms, +model payloads and all failure paths remain explicit long-tail gaps. + +## Actual verification +10 assertion-bearing cases, two difficult cases per route and two integrated +scenarios. Ruff and3 root graph/helper tests pass. Author lanes ran config4+/13-, +request5+/16-, production/diagnostic record fixtures and8 negative cases with +CLI/help/error checks. Recursive license validation is valid over4 SKILL.md +files withNO_LICENSE warning from the actual unauthenticatedgh lookup. Source +lily/LICENSE and NOTICE are independently retained; no legal absence inferred. + +## Native boundary +No Cargo/Rust compiler or compatible M5/macOS26/Metal/model is available. Rust +compile/tests are not_run; required native/model/state evidence remains +BLOCKED_REQUIRED_BACKEND. CPU-reference code is an oracle inside selected GPU +checks, not an executed CPU substitute. Offline helpers do not establish native +loader/tokenizer/cache/quality/performance, service or skill efficacy. + +## Import readiness +Not fully verified and not eligible for automatic admission. Final manual +candidate decision after these exact gaps remains pending. Independent review, +full scaffold/wheel checks and exact-head CI are separate records; no GitHub +approval or native success is prefilled by authors. diff --git a/tests/fixtures/repo_to_skill/lily/reports/integration/integration-notes.md b/tests/fixtures/repo_to_skill/lily/reports/integration/integration-notes.md new file mode 100644 index 00000000..20052e1e --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/integration/integration-notes.md @@ -0,0 +1,25 @@ +# Lily integrated graph + +The root author inspected the actual complete files of all three stable-ID lanes +before any final checks. model-runtime owns exact config/layout and unique-buffer +lifetime; serving-cache owns strict API/template/request budget, prefix eligibility +and state release; qualification owns native/cfg/ignored test layers and exact +version/metric evidence. All selected routes have concrete references, support +helpers, failure diagnoses and at least two difficult synthetic cases. + +Material authors: Codex approved_arex_author (root/integration), +runtime_memory_author, serving_state_author and qualification_author; all actual +inherited gpt-6.1-sol xhigh. Independent review is separate, not author-prefilled. + +Cross-route reconciliation preserved Q4 with role-specific Q8, buffer+offset +identity, the extra request lookahead slot, strict-prefix eligibility before key +preference, actually-fed state tokens, and macOS-gated CPU-reference/GPU tests. +Current MLX0.31.2 runner and later0.32.2 report are not silently conflated. + +Safe config/request/record screening is bundled. Upstream matrix/model/MLX +runners are reference-only because they build/execute models and survey processes; +model downloads and host toolchain installers are excluded. Full kernels and every +platform/format/failure path are explicit long-tail gaps. Rust/Cargo1.92 and the +M5/macOS26/Metal/checkpoint environment are unavailable. No native test was run +or disguised as a Python substitute. Required evidence remains blocked. Partial +drafting consent does not grant final candidate admission or managed import. diff --git a/tests/fixtures/repo_to_skill/lily/reports/integration/plan.json b/tests/fixtures/repo_to_skill/lily/reports/integration/plan.json new file mode 100644 index 00000000..6afbd2cc --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/integration/plan.json @@ -0,0 +1,130 @@ +{ + "workflow": "AREX portable create/prepare/workflow-authoring/verify", + "method_revision": "ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6", + "source": "perplexityai/pplx-garden", + "subdirectory": "lily", + "source_commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "scope_decision": "user accepted native Rust/Metal adaptation and partial drafting; final admission pending", + "included": [ + "lily README/Cargo metadata/LICENSE/NOTICE", + "src config/weights/tensor/metal/model and selected kernels", + "src serve/session/chat/generate", + "tests CPU-reference/native/golden boundaries", + "benchmarks and performance method contracts" + ], + "excluded": [ + "other pplx-garden projects", + "weights/downloads", + "full kernel audit or performance reproduction", + "host Rust/toolchain installation" + ], + "subskills": [ + { + "id": "model-runtime", + "owner": "runtime_memory_author", + "responsibility": "exact35B config, affineQ4 representation and model/runtime/Metal ownership", + "references": [ + "model-and-memory.md", + "troubleshooting.md" + ], + "synthetic_cases": [ + "same-bits-wrong-layout", + "checkpoint-shape-and-sequence-budget" + ], + "native_candidates": [ + "Rust config/weights unit checks; GPU tests remain required blocked" + ] + }, + { + "id": "serving-cache", + "owner": "serving_state_author", + "responsibility": "strict text API, greedy/template semantics and fixed2entry token-prefix session cache", + "references": [ + "api-and-session.md", + "troubleshooting.md" + ], + "synthetic_cases": [ + "same-key-not-a-token-prefix", + "unsupported-stream-tools-and-last-role" + ], + "native_candidates": [ + "Rust serve/session unit checks, unavailable compiler/native backend" + ] + }, + { + "id": "qualification", + "owner": "qualification_author", + "responsibility": "CPUreference versus GPU execution, exactcheckpoint golden tests and fair failclosed benchmark comparisons", + "references": [ + "verification-contract.md", + "troubleshooting.md" + ], + "synthetic_cases": [ + "cpu-reference-is-not-gpu-proof", + "benchmark-version-and-metric-boundaries" + ], + "native_candidates": [ + "Rust kernel/shader/e2e tests; benchmark parser safe subsets if found" + ] + } + ], + "backend_plan": { + "required": [ + { + "backend_requirement": "accelerator-specific", + "backend_criticality": "required", + "cpu_substitute": "partial", + "capability": "native Lily Metal/kernel/model/session execution", + "dependency_variant": "Rust1.92 + Cargo.lock, macOS26/M5+, exact MLX affineQ4 35B checkpoint", + "hardware_prerequisites": "Apple GPU family10+ and actual weights", + "verification_expectation": "actual native compile/shader/operator/state/model/quality cases", + "assigned_environment": "unavailable", + "status": "BLOCKED_REQUIRED_BACKEND" + } + ], + "compiler": { + "status": "unavailable", + "fact": "cargo/rustc absent; no host runtime installation authorized or performed" + }, + "alternative": [ + { + "backend_requirement": "cpu", + "backend_criticality": "alternative", + "cpu_substitute": "full", + "capability": "bundled static metadata/request/evidence helpers only", + "dependency_variant": "private Python3.12 stdlib", + "verification_expectation": "positive/negative tiny fixtures, not Rust execution" + } + ] + }, + "source_script_inventory": [ + { + "source": "benchmarks/run_matrix.py", + "decision": "reference-only", + "reason": "builds/runs native model benchmark and external MLX; distill failclosed controls" + }, + { + "source": "README checkpoint download command", + "decision": "exclude", + "reason": "large network/model-license/storage side effects" + }, + { + "source": "src/config.rs and src/serve.rs validation", + "decision": "adapt", + "reason": "small offline metadata/request screening helpers only, explicitly not native implementation proof" + } + ], + "integration_cases": [ + "strict-config-request-and-state", + "benchmark-cache-and-native-evidence" + ], + "rubric": [ + "exactmodel/formatidentity", + "strictinterface", + "stateownership", + "selfcontainedreferences", + "safehelpers", + "native/compilergapshonest" + ], + "final_candidate_admission": "pending informed decision after exact verification" +} diff --git a/tests/fixtures/repo_to_skill/lily/reports/license-resolution.json b/tests/fixtures/repo_to_skill/lily/reports/license-resolution.json new file mode 100644 index 00000000..640b67cc --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/license-resolution.json @@ -0,0 +1,12 @@ +{ + "repository": "perplexityai/pplx-garden", + "source_commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "source": "GitHub CLI (gh api)", + "value": "NO_LICENSE", + "status": "unavailable", + "reason": "GitHub CLI is not authenticated", + "old_license_value": "unavailable", + "runtime_files_updated": 4, + "independent_source_license": "Apache-2.0 (lily subtree)", + "independent_source_evidence": "lily/LICENSE and NOTICE retained; helper unavailable status unchanged." +} diff --git a/tests/fixtures/repo_to_skill/lily/reports/self-refine/evals.json b/tests/fixtures/repo_to_skill/lily/reports/self-refine/evals.json new file mode 100644 index 00000000..3112773a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/self-refine/evals.json @@ -0,0 +1,185 @@ +{ + "skill_name": "lily", + "evals": [ + { + "id": 1, + "prompt": "The Lily test compares against a CPU reference and reports green on my Linux log, so I want to publish GPU quality and HTTP speed. I also ran the current matrix with MLX0.32.2 because the later report uses it. Is that the same experiment?", + "expected_output": "The answer distinguishes cfg/ignored/actual GPU execution and does not treat a CPU reference as CPU-only GPU proof.; The answer preserves the current0.31.2 runner versus later0.32.2 report and distinct harness identity.; The answer distinguishes in-process throughput from HTTP/cache/service quality evidence.; The answer preserves reported long-context prefill disadvantages rather than a universal faster claim.", + "files": [ + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer distinguishes cfg/ignored/actual GPU execution and does not treat a CPU reference as CPU-only GPU proof.", + "The answer preserves the current0.31.2 runner versus later0.32.2 report and distinct harness identity.", + "The answer distinguishes in-process throughput from HTTP/cache/service quality evidence.", + "The answer preserves reported long-context prefill disadvantages rather than a universal faster claim." + ] + }, + { + "id": 2, + "prompt": "I have an MLX4bit checkpoint and a Lily cache key that matched yesterday. I changed an earlier user message, set max_tokens so prompt plus output equals max-seq, and want to bypass all loader checks because the config screen passed. Diagnose without a Mac.", + "expected_output": "The answer distinguishes selected JSON config screening from exact tensor/roleQ8/native compatibility.; The answer preserves the extra lookahead slot beyond rendered prompt plus max_tokens.; The answer applies exact strict-token-prefix eligibility before key preference and does not force reuse after history edits.; The answer retains missing compiler/Metal/model gaps without native execution.", + "files": [ + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer distinguishes selected JSON config screening from exact tensor/roleQ8/native compatibility.", + "The answer preserves the extra lookahead slot beyond rendered prompt plus max_tokens.", + "The answer applies exact strict-token-prefix eligibility before key preference and does not force reuse after history edits.", + "The answer retains missing compiler/Metal/model gaps without native execution." + ] + }, + { + "id": 3, + "prompt": "Prepare a tiny valid Lily request offline, without Rust, a model or network. My SDK normally includes temperature0 and streamtrue. Which fields must I remove, and can a JSON helper prove the actual token budget?", + "expected_output": "The answer uses the bundled offline request helper and exact supported model/fields.; The answer rejects temperature and streaming fields rather than silently treating them as supported.; The answer does not claim native tokenizer/token-capacity/backend validation.", + "files": [ + "sub-skills/serving-cache/scripts/request_template.py", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer uses the bundled offline request helper and exact supported model/fields.", + "The answer rejects temperature and streaming fields rather than silently treating them as supported.", + "The answer does not claim native tokenizer/token-capacity/backend validation." + ] + }, + { + "id": 4, + "prompt": "The small JSON supplied here passes Lily's selected shape screen. Does that prove the checkpoint and Metal runtime work? I requested max_seq 4096, but the checkpoint declares max_position_embeddings 2048. My actual rendered prompt has 1900 tokens and I requested 148 output tokens. Also, I cloned a tensor view and want to reset its buffers while a submitted decode pass is still pending. Explain the effective sequence and ownership checks without running native inference.", + "expected_output": "The response calls the fixture a selected-rule screen only and preserves all unchecked fields, tensor payloads, Rust compilation and Metal execution gaps.; The response clamps requested max_seq4096 to the smaller nonzero checkpoint limit2048 and retains the kernel ceiling.; The response calculates actual prompt1900 plus output148 plus extra slot1 as2049, refusing the request at2048 rather than claiming equality fits.; The response explains that Tensor clone and view alias backing storage and that buffer offsets matter to bindings and identity.; The response waits for pending GPU work before host reset/read/write and retains recurrent/conv reset versus KV frontier semantics.; The response distinguishes model weights, each cached DecodeState, KV growth, GDN and scratch from a total physical-memory estimate.; The response does not launch native code, install tools, download weights or turn source/helper success into backend qualification.", + "files": [ + "sub-skills/model-runtime/SKILL.md", + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/model-runtime/references/troubleshooting.md", + "sub-skills/model-runtime/scripts/screen_config.py" + ], + "assertions": [ + "The response calls the fixture a selected-rule screen only and preserves all unchecked fields, tensor payloads, Rust compilation and Metal execution gaps.", + "The response clamps requested max_seq4096 to the smaller nonzero checkpoint limit2048 and retains the kernel ceiling.", + "The response calculates actual prompt1900 plus output148 plus extra slot1 as2049, refusing the request at2048 rather than claiming equality fits.", + "The response explains that Tensor clone and view alias backing storage and that buffer offsets matter to bindings and identity.", + "The response waits for pending GPU work before host reset/read/write and retains recurrent/conv reset versus KV frontier semantics.", + "The response distinguishes model weights, each cached DecodeState, KV growth, GDN and scratch from a total physical-memory estimate.", + "The response does not launch native code, install tools, download weights or turn source/helper success into backend qualification." + ] + }, + { + "id": 5, + "prompt": "I have a Qwen-branded 4-bit checkpoint with group_size 128 and GPTQ packing. Can Lily use it if I change config.json to say affine, bits 4 and group_size 64? Its router is also 4-bit, which seems consistent with the global config. Explain the actual tensor/layout contract, what a config-only screen can and cannot establish, and where to stop. Do not modify the checkpoint, install Rust or download another model.", + "expected_output": "The response routes to model-runtime and refuses to treat changing config fields as conversion of GPTQ or group128 payloads.; The response specifies MLX affine group64, U32 low-element-first packed codes, BF16 multiplicative scales and additive biases.; The response distinguishes global Q4 from required Q8 router and shared-expert-gate storage.; The response uses or names the bundled screen as selected-rule screening only, with tensor names/shapes/dtypes/packing/payload and native execution unchecked.; The response rejects the wrong-group fixture without claiming it represents a complete checkpoint.; The response retains missing Rust1.92 and Apple Metal requirements and does not call Python checks native validation.; The response stops before modifying weights, installing a compiler, downloading a model or asserting quality/performance.", + "files": [ + "sub-skills/model-runtime/SKILL.md", + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/model-runtime/references/troubleshooting.md", + "sub-skills/model-runtime/scripts/screen_config.py" + ], + "assertions": [ + "The response routes to model-runtime and refuses to treat changing config fields as conversion of GPTQ or group128 payloads.", + "The response specifies MLX affine group64, U32 low-element-first packed codes, BF16 multiplicative scales and additive biases.", + "The response distinguishes global Q4 from required Q8 router and shared-expert-gate storage.", + "The response uses or names the bundled screen as selected-rule screening only, with tensor names/shapes/dtypes/packing/payload and native execution unchecked.", + "The response rejects the wrong-group fixture without claiming it represents a complete checkpoint.", + "The response retains missing Rust1.92 and Apple Metal requirements and does not call Python checks native validation.", + "The response stops before modifying weights, installing a compiler, downloading a model or asserting quality/performance." + ] + }, + { + "id": 6, + "prompt": "I have a saved Lily production benchmark JSON and its expected full source SHA and decode count. I want an offline consistency check only: source identity, production versus diagnostic fields, finite timings, interval/token counts and token digest. Can the bundled helper do this without MLX, model files or process inspection, and would success prove the GPU run happened?", + "expected_output": "The response references audit_benchmark_record.py with --report, --source-id and --decode-steps, and --diagnostic only for a declared diagnostic record.; The response describes selected source/mode/count/positive-finite-value/token-ID/FNV digest consistency rather than a full matrix verdict.; The response rejects diagnostic GPU timing fields in production records and missing required shapes in diagnostic records.; The response explains that the helper imports neither upstream runner nor MLX and starts no model process, machine survey, download or subprocess.; The response states that internally consistent supplied metadata can be fabricated or stale and does not authenticate actual source/binary/model bytes or execution.; The response leaves native compiler/Metal/model/service qualification and final admission separate from a successful offline audit.", + "files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response references audit_benchmark_record.py with --report, --source-id and --decode-steps, and --diagnostic only for a declared diagnostic record.", + "The response describes selected source/mode/count/positive-finite-value/token-ID/FNV digest consistency rather than a full matrix verdict.", + "The response rejects diagnostic GPU timing fields in production records and missing required shapes in diagnostic records.", + "The response explains that the helper imports neither upstream runner nor MLX and starts no model process, machine survey, download or subprocess.", + "The response states that internally consistent supplied metadata can be fabricated or stale and does not authenticate actual source/binary/model bytes or execution.", + "The response leaves native compiler/Metal/model/service qualification and final admission separate from a successful offline audit." + ] + }, + { + "id": 7, + "prompt": "The September 2 Lily report uses MLX 0.32.2, but this checkout's requirements and both benchmark scripts require 0.31.2. Can I change that constant and call it exact reproduction, then combine the best ratios from both reports to claim faster HTTP latency and equivalent graphs? Each engine repeats its own output digest. Explain the limits, including long-context prefill, without running the matrix or surveying processes.", + "expected_output": "The response identifies the current 0.31.2 pins versus the later 0.32.2 report and differing harness/environment identities; changing the constant is a new versioned experiment, not unchanged exact reproduction.; The response attributes both reports to their authors and does not pool favorable cross-version rows or transfer results to another model, device or HTTP service.; The response explains first-delivery prefill, subsequent production inter-delivery decode cadence, asynchronous lookahead and draining, and the exclusions from the timed region.; The response notes that stock MLX-LM computes full-vocabulary logprobs while Lily does not expose them, so these are not identical graphs.; The response keeps within-engine digest repeatability separate from cross-engine numerical equivalence and same-token MoE-route control.; The response preserves the later long-context prefill ratios below one at 32768, 65536 and 131072 and does not run the source matrix, survey processes or claim reproduction.", + "files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response identifies the current 0.31.2 pins versus the later 0.32.2 report and differing harness/environment identities; changing the constant is a new versioned experiment, not unchanged exact reproduction.", + "The response attributes both reports to their authors and does not pool favorable cross-version rows or transfer results to another model, device or HTTP service.", + "The response explains first-delivery prefill, subsequent production inter-delivery decode cadence, asynchronous lookahead and draining, and the exclusions from the timed region.", + "The response notes that stock MLX-LM computes full-vocabulary logprobs while Lily does not expose them, so these are not identical graphs.", + "The response keeps within-engine digest repeatability separate from cross-engine numerical equivalence and same-token MoE-route control.", + "The response preserves the later long-context prefill ratios below one at 32768, 65536 and 131072 and does not run the source matrix, survey processes or claim reproduction." + ] + }, + { + "id": 8, + "prompt": "Our Linux library check was green. Lily's tests say matches_cpu, and the model goldens are ignored, so I want to record Metal correctness as passed without an M5 or checkpoint. The shader test is also cfg-gated. Review that conclusion and give the smallest evidence ladder for a new shape-dependent Q4 route. Do not install Rust, run models or change fixtures.", + "expected_output": "The response routes to qualification and distinguishes non-macOS library-only compilation from all-target compilation or a CPU inference backend.; The response explains that CPU-reference algorithms are numerical oracles and selected matches_cpu tests create a Metal context, dispatch and read back GPU results.; The response reports cfg-omitted, ignored, filtered, completed and not-run checks separately and does not treat a green summary or short duration as native proof.; The response separates shader function/pipeline construction from numerical, route-selection, recurrent-state, matched-model and service correctness.; The response requires the route predicate and actual numerical GPU checks on both sides, including packing/tails/views and stack-versus-slice reduction consistency.; The response keeps absent Rust/compiler/M5/macOS/model evidence blocked and does not install, execute a model, rewrite a golden or claim Metal PASS.", + "files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response routes to qualification and distinguishes non-macOS library-only compilation from all-target compilation or a CPU inference backend.", + "The response explains that CPU-reference algorithms are numerical oracles and selected matches_cpu tests create a Metal context, dispatch and read back GPU results.", + "The response reports cfg-omitted, ignored, filtered, completed and not-run checks separately and does not treat a green summary or short duration as native proof.", + "The response separates shader function/pipeline construction from numerical, route-selection, recurrent-state, matched-model and service correctness.", + "The response requires the route predicate and actual numerical GPU checks on both sides, including packing/tails/views and stack-versus-slice reduction consistency.", + "The response keeps absent Rust/compiler/M5/macOS/model evidence blocked and does not install, execute a model, rewrite a golden or claim Metal PASS." + ] + }, + { + "id": 9, + "prompt": "For Lily, assume the retained rendered token history is [1, 2] with prompt_cache_key \"conversation-a\". A new request with the same key renders [1, 9, 3]; another renders exactly [1, 2]. Can either skip prefill because the key matches? What about a request with a different key rendering [1, 2, 3]? Explain the two-entry cache selection and decode-state consistency rules without running a model or treating the key as authentication.", + "expected_output": "The response rejects [1,2] reuse for [1,9,3] despite the same explicit key.; It rejects an equal-length [1,2] prompt as not a strict prefix and does not return an empty generation suffix.; It allows a different-key [1,2,3] candidate to be considered because key equality is preference, not an eligibility or authentication barrier.; It explains that valid strict prefixes are filtered before matching-key then prefix-length ranking.; It identifies the fixed two-entry released-session LRU and reset/reuse cold path without inventing concurrent serving lanes or disk persistence.; It requires retained token length to equal DecodeState.pos and appends only returned tokens actually fed into state.; It does not run inference or equate source/Python checks with Rust/Metal/model cache verification.", + "files": [ + "sub-skills/serving-cache/SKILL.md", + "sub-skills/serving-cache/references/api-and-session.md", + "sub-skills/serving-cache/references/troubleshooting.md" + ], + "assertions": [ + "The response rejects [1,2] reuse for [1,9,3] despite the same explicit key.", + "It rejects an equal-length [1,2] prompt as not a strict prefix and does not return an empty generation suffix.", + "It allows a different-key [1,2,3] candidate to be considered because key equality is preference, not an eligibility or authentication barrier.", + "It explains that valid strict prefixes are filtered before matching-key then prefix-length ranking.", + "It identifies the fixed two-entry released-session LRU and reset/reuse cold path without inventing concurrent serving lanes or disk persistence.", + "It requires retained token length to equal DecodeState.pos and appends only returned tokens actually fed into state.", + "It does not run inference or equate source/Python checks with Rust/Metal/model cache verification." + ] + }, + { + "id": 10, + "prompt": "My OpenAI client sends Lily this body: {\"model\":\"Qwen3.6-35B-A3B\",\"messages\":[{\"role\":\"assistant\",\"content\":\"Continue\"}],\"temperature\":0,\"stream\":true,\"tools\":[],\"max_tokens\":32}. It fails although I asked for greedy output. Explain every relevant interface mismatch and show how to prepare a valid text-only request without silently dropping required user features. Also explain why a rendered prompt of 10 tokens and max_tokens 20 needs capacity 31, not 30. Use only offline checks; do not start a server or load weights.", + "expected_output": "The response identifies temperature and tools as unknown fields, including zero/empty values, rather than supported ignored options.; It identifies stream:true as unsupported and the final assistant role as invalid for the required user-last request.; It explains that the server is inherently greedy and uses disabled-thinking template rendering, not configurable sampling or reasoning fields.; It offers a valid explicitly text-only user request while disclosing lost streaming/tool semantics instead of silently changing the user's goal.; It uses or references the bundled offline request helper without starting a service or loading a model.; It states the checked budget is rendered_prompt_tokens + max_tokens + 1 and computes 10 + 20 + 1 = 31.; It distinguishes helper structural screening from native template token counts, Rust API execution and Metal/model verification.", + "files": [ + "sub-skills/serving-cache/SKILL.md", + "sub-skills/serving-cache/references/api-and-session.md", + "sub-skills/serving-cache/references/troubleshooting.md", + "sub-skills/serving-cache/scripts/request_template.py" + ], + "assertions": [ + "The response identifies temperature and tools as unknown fields, including zero/empty values, rather than supported ignored options.", + "It identifies stream:true as unsupported and the final assistant role as invalid for the required user-last request.", + "It explains that the server is inherently greedy and uses disabled-thinking template rendering, not configurable sampling or reasoning fields.", + "It offers a valid explicitly text-only user request while disclosing lost streaming/tool semantics instead of silently changing the user's goal.", + "It uses or references the bundled offline request helper without starting a service or loading a model.", + "It states the checked budget is rendered_prompt_tokens + max_tokens + 1 and computes 10 + 20 + 1 = 31.", + "It distinguishes helper structural screening from native template token counts, Rust API execution and Metal/model verification." + ] + } + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/reports/self-refine/iteration-1.md b/tests/fixtures/repo_to_skill/lily/reports/self-refine/iteration-1.md new file mode 100644 index 00000000..256511f3 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/self-refine/iteration-1.md @@ -0,0 +1,3 @@ +# Content self-refine + +Root author inspected all complete lane files and helpers together, plus each assertion. Exact Q4/roleQ8, +1 request budget, strict prefix before key ranking, actually-fed token retention and native/cfg/ignored test boundaries agree across routes. Added the actual source-identified checkpoint revision where the qualification reference promised it. Internal links, YAML/JSON/resources, helper scope and privacy checks pass; root3 helper/graph tests and Ruff pass. Fresh independent runtime-only usability/source review remains pending. No Python helper result replaces native Rust/Metal/model evidence. diff --git a/tests/fixtures/repo_to_skill/lily/reports/verification/native-verification-report.json b/tests/fixtures/repo_to_skill/lily/reports/verification/native-verification-report.json new file mode 100644 index 00000000..cf5dba24 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/reports/verification/native-verification-report.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "source_commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "subdirectory": "lily", + "environment": "Linux x86_64; private Python3.12 helper checks only; Cargo/rustc and supported Apple native resources unavailable.", + "stage_order": "All author lanes and root integrated/reviewed before final graph/helper verification. No original Rust/native test was run.", + "cases": [ + { + "id": "source-native-rust", + "status": "NOT_RUN_MISSING_TOOLCHAIN", + "reason": "cargo/rustc absent; no host toolchain install performed", + "scope": "Compile/cfg/integration tests not executed; source reading is not compiler evidence." + }, + { + "id": "offline-config-helper", + "status": "PASS", + "scope": "Lane4 positive+13 negative fixtures, CLI/help and explicit screen-only/unchecked boundary; not full serde/config/native loader parity." + }, + { + "id": "offline-request-helper", + "status": "PASS", + "scope": "Lane5 positive+16 negative structural shapes, CLI/help/fixtures and conflicts; not tokenizer, native request/cache or capacity validation." + }, + { + "id": "offline-record-auditor", + "status": "PASS", + "scope": "Production/diagnostic supplied records and8 negative fixtures plus CLI/help; consistency is not authentic execution." + }, + { + "id": "graph-and-helper-regression", + "status": "PASS", + "tests": 3, + "scope": "Root YAML/JSON/links/resources/helper tests and Ruff; recursive license gate valid4." + }, + { + "id": "native-metal-model-state", + "status": "BLOCKED_REQUIRED_BACKEND", + "backend_requirement": "accelerator-specific", + "backend_criticality": "required", + "cpu_substitute": "partial", + "dependency_variant": "Rust1.92 locked crate, macOS26/M5+, exact supported MLX affine checkpoint", + "hardware_prerequisites": "Apple GPU family10+, actual compatible model/tokenizer/template bytes", + "verification_expectation": "native compile/shader/operator/recurrent/session/golden and model/quality/service cases", + "assigned_environment": "unavailable" + } + ], + "not_run": [ + "Rust compilation and native tests", + "Metal shader/operator/state/model execution", + "model payload/tokenizer/template validation", + "service quality/performance and behavioral skill efficacy" + ], + "final_admission": "pending informed manual candidate decision; native block is not removed by helper checks" +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/index.md b/tests/fixtures/repo_to_skill/lily/test-cases/index.md new file mode 100644 index 00000000..28e9c2e1 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/index.md @@ -0,0 +1,16 @@ +# Lily assertion-backed cases + +| Case | Route | Assertions | +| --- | --- | --- | +| integration/benchmark-cache-and-native-evidence | integration | 4 | +| integration/strict-config-request-and-state | integration | 4 | +| root/strict-offline-request | lily | 3 | +| sub-skills/model-runtime/checkpoint-shape-and-sequence-budget | model-runtime | 7 | +| sub-skills/model-runtime/same-bits-wrong-layout | model-runtime | 7 | +| sub-skills/qualification/audit-saved-production-record | qualification | 6 | +| sub-skills/qualification/benchmark-version-and-metric-boundaries | qualification | 6 | +| sub-skills/qualification/cpu-reference-is-not-gpu-proof | qualification | 6 | +| sub-skills/serving-cache/same-key-not-a-token-prefix | serving-cache | 7 | +| sub-skills/serving-cache/unsupported-stream-tools-and-last-role | serving-cache | 7 | + +10 cases with 57 assertions. Every focused route has two difficult synthetic cases and source-native anchors; qualification also has a checkpoint/control case. Two integrated source-backed scenarios cross exact configuration/request/state and benchmark/native-evidence boundaries. No assertion is an executed Rust/GPU/model result. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/README.md new file mode 100644 index 00000000..7c288894 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/README.md @@ -0,0 +1,16 @@ +# benchmark-cache-and-native-evidence + +## User Persona +An operator needing source-qualified diagnosis without native execution authority. + +## Scenario Coverage +Advanced integration route. Source-backed combined scenario, not a model test run. + +## Expected Successful Behavior +- The answer distinguishes cfg/ignored/actual GPU execution and does not treat a CPU reference as CPU-only GPU proof. +- The answer preserves the current0.31.2 runner versus later0.32.2 report and distinct harness identity. +- The answer distinguishes in-process throughput from HTTP/cache/service quality evidence. +- The answer preserves reported long-context prefill disadvantages rather than a universal faster claim. + +## Failure Signals +Forcing unsupported layout/API/state, missing lookahead or a static/ignored result upgraded to native/E2E proof. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/assertions.json new file mode 100644 index 00000000..faaaacac --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/assertions.json @@ -0,0 +1,22 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "integration", + "target_capability": "benchmark-cache-and-native-evidence", + "difficulty": "advanced", + "evidence_basis": [ + "lily/README.md", + "lily/src/serve.rs", + "lily/src/lib.rs", + "lily/benchmarks/run_matrix.py" + ], + "expected_skill_files": [ + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer distinguishes cfg/ignored/actual GPU execution and does not treat a CPU reference as CPU-only GPU proof.", + "The answer preserves the current0.31.2 runner versus later0.32.2 report and distinct harness identity.", + "The answer distinguishes in-process throughput from HTTP/cache/service quality evidence.", + "The answer preserves reported long-context prefill disadvantages rather than a universal faster claim." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/user_request.txt new file mode 100644 index 00000000..e1d12796 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/benchmark-cache-and-native-evidence/user_request.txt @@ -0,0 +1 @@ +The Lily test compares against a CPU reference and reports green on my Linux log, so I want to publish GPU quality and HTTP speed. I also ran the current matrix with MLX0.32.2 because the later report uses it. Is that the same experiment? diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/README.md new file mode 100644 index 00000000..423cee3a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/README.md @@ -0,0 +1,16 @@ +# strict-config-request-and-state + +## User Persona +An operator needing source-qualified diagnosis without native execution authority. + +## Scenario Coverage +Advanced integration route. Source-backed combined scenario, not a model test run. + +## Expected Successful Behavior +- The answer distinguishes selected JSON config screening from exact tensor/roleQ8/native compatibility. +- The answer preserves the extra lookahead slot beyond rendered prompt plus max_tokens. +- The answer applies exact strict-token-prefix eligibility before key preference and does not force reuse after history edits. +- The answer retains missing compiler/Metal/model gaps without native execution. + +## Failure Signals +Forcing unsupported layout/API/state, missing lookahead or a static/ignored result upgraded to native/E2E proof. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/assertions.json new file mode 100644 index 00000000..ff89701a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/assertions.json @@ -0,0 +1,22 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "integration", + "target_capability": "strict-config-request-and-state", + "difficulty": "advanced", + "evidence_basis": [ + "lily/README.md", + "lily/src/serve.rs", + "lily/src/lib.rs", + "lily/benchmarks/run_matrix.py" + ], + "expected_skill_files": [ + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer distinguishes selected JSON config screening from exact tensor/roleQ8/native compatibility.", + "The answer preserves the extra lookahead slot beyond rendered prompt plus max_tokens.", + "The answer applies exact strict-token-prefix eligibility before key preference and does not force reuse after history edits.", + "The answer retains missing compiler/Metal/model gaps without native execution." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/user_request.txt new file mode 100644 index 00000000..64d14064 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/integration/strict-config-request-and-state/user_request.txt @@ -0,0 +1 @@ +I have an MLX4bit checkpoint and a Lily cache key that matched yesterday. I changed an earlier user message, set max_tokens so prompt plus output equals max-seq, and want to bypass all loader checks because the config screen passed. Diagnose without a Mac. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/README.md new file mode 100644 index 00000000..de7bc8e9 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/README.md @@ -0,0 +1,15 @@ +# strict-offline-request + +## User Persona +An operator needing source-qualified diagnosis without native execution authority. + +## Scenario Coverage +Advanced lily route. Source-backed combined scenario, not a model test run. + +## Expected Successful Behavior +- The answer uses the bundled offline request helper and exact supported model/fields. +- The answer rejects temperature and streaming fields rather than silently treating them as supported. +- The answer does not claim native tokenizer/token-capacity/backend validation. + +## Failure Signals +Forcing unsupported layout/API/state, missing lookahead or a static/ignored result upgraded to native/E2E proof. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/assertions.json new file mode 100644 index 00000000..ced4a8cf --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/assertions.json @@ -0,0 +1,21 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "lily", + "target_capability": "strict-offline-request", + "difficulty": "advanced", + "evidence_basis": [ + "lily/README.md", + "lily/src/serve.rs", + "lily/src/lib.rs", + "lily/benchmarks/run_matrix.py" + ], + "expected_skill_files": [ + "sub-skills/serving-cache/scripts/request_template.py", + "sub-skills/serving-cache/references/api-and-session.md" + ], + "assertions": [ + "The answer uses the bundled offline request helper and exact supported model/fields.", + "The answer rejects temperature and streaming fields rather than silently treating them as supported.", + "The answer does not claim native tokenizer/token-capacity/backend validation." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/user_request.txt new file mode 100644 index 00000000..34d856fc --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/root/strict-offline-request/user_request.txt @@ -0,0 +1 @@ +Prepare a tiny valid Lily request offline, without Rust, a model or network. My SDK normally includes temperature0 and streamtrue. Which fields must I remove, and can a JSON helper prove the actual token budget? diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/README.md new file mode 100644 index 00000000..2ff4eb6f --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/README.md @@ -0,0 +1,30 @@ +# Shape screen, sequence ceiling and pending ownership + +## User Persona +A maintainer connecting static metadata screening to sequence allocation and +asynchronous shared-buffer reuse. + +## Scenario Coverage +- Skill area: model-runtime. +- Capability: screen limits, checkpoint-clamped sequence and buffer frontiers. +- Difficulty: advanced. +- Prompt file: `user_request.txt`. +- Expected resources: model-runtime, model-and-memory, troubleshooting and + the offline screen helper. +- Trigger expectation: capacity and tensor lifetime belong to model-runtime. +- Synthetic extension: combines checkpoint shape predicates, server extra-slot + budget assertion and Metal pending-pass ownership. This tests guidance rather + than reproducing a native run. +- Fixture: `fixtures/config-screen-only.json` intentionally passes the helper's + selected rules but omits other required native fields and all tensor payloads. + +## Expected Successful Behavior +Report only selected-rule screening; retain compiler/backend/weights checks. +Clamp 4096 to 2048 and calculate 1900 + 148 + 1 = 2049, so the request does not +fit. Explain clone/view aliasing, offsets and idle-GPU reset requirements. Do not +execute or turn component formulas into a physical-memory fit claim. + +## Failure Signals +Calling the fixture fully compatible, omitting the extra slot, using the +unclamped ceiling, treating clone as data copy, resetting while pending, or +promising memory fit from weight size alone. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/assertions.json new file mode 100644 index 00000000..6520514a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/assertions.json @@ -0,0 +1,31 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "model-runtime", + "target_capability": "Sequence capacity and shared asynchronous state ownership", + "difficulty": "advanced", + "evidence_basis": [ + "lily/src/config.rs:114-182", + "lily/src/serve.rs:41-46", + "lily/src/serve.rs:144-160", + "lily/src/serve.rs:179-191", + "lily/src/tensor.rs:26-77", + "lily/src/model.rs:127-142", + "lily/src/metal.rs:321-345", + "lily/tests/unit/serve.rs:27-30" + ], + "expected_skill_files": [ + "sub-skills/model-runtime/SKILL.md", + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/model-runtime/references/troubleshooting.md", + "sub-skills/model-runtime/scripts/screen_config.py" + ], + "assertions": [ + "The response calls the fixture a selected-rule screen only and preserves all unchecked fields, tensor payloads, Rust compilation and Metal execution gaps.", + "The response clamps requested max_seq4096 to the smaller nonzero checkpoint limit2048 and retains the kernel ceiling.", + "The response calculates actual prompt1900 plus output148 plus extra slot1 as2049, refusing the request at2048 rather than claiming equality fits.", + "The response explains that Tensor clone and view alias backing storage and that buffer offsets matter to bindings and identity.", + "The response waits for pending GPU work before host reset/read/write and retains recurrent/conv reset versus KV frontier semantics.", + "The response distinguishes model weights, each cached DecodeState, KV growth, GDN and scratch from a total physical-memory estimate.", + "The response does not launch native code, install tools, download weights or turn source/helper success into backend qualification." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/fixtures/config-screen-only.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/fixtures/config-screen-only.json new file mode 100644 index 00000000..d00f8d03 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/fixtures/config-screen-only.json @@ -0,0 +1,70 @@ +{ + "model_type": "qwen3_5_moe", + "text_config": { + "hidden_size": 2048, + "num_hidden_layers": 40, + "vocab_size": 248320, + "num_experts": 256, + "num_experts_per_tok": 8, + "moe_intermediate_size": 512, + "shared_expert_intermediate_size": 512, + "num_attention_heads": 16, + "num_key_value_heads": 2, + "head_dim": 256, + "linear_num_key_heads": 16, + "linear_num_value_heads": 32, + "linear_key_head_dim": 128, + "linear_value_head_dim": 128, + "linear_conv_kernel_dim": 4, + "attn_output_gate": true, + "tie_word_embeddings": false, + "max_position_embeddings": 2048, + "layer_types": [ + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention" + ] + }, + "quantization": { + "bits": 4, + "group_size": 64, + "mode": "affine" + } +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/user_request.txt new file mode 100644 index 00000000..06ad1531 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/checkpoint-shape-and-sequence-budget/user_request.txt @@ -0,0 +1 @@ +The small JSON supplied here passes Lily's selected shape screen. Does that prove the checkpoint and Metal runtime work? I requested max_seq 4096, but the checkpoint declares max_position_embeddings 2048. My actual rendered prompt has 1900 tokens and I requested 148 output tokens. Also, I cloned a tensor view and want to reset its buffers while a submitted decode pass is still pending. Explain the effective sequence and ownership checks without running native inference. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/README.md new file mode 100644 index 00000000..cde70ef1 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/README.md @@ -0,0 +1,29 @@ +# Same bits, wrong layout + +## User Persona +A quantization-aware operator who treats a nominal bit width and edited config +as a conversion between unrelated packing formats. + +## Scenario Coverage +- Skill area: model-runtime. +- Capability: exact checkpoint/packing and role-specific bits. +- Difficulty: troubleshooting. +- Prompt file: `user_request.txt`. +- Expected resources: model-runtime, model-and-memory, troubleshooting and + `scripts/screen_config.py`. +- Trigger expectation: model-runtime must establish representation first. +- Synthetic extension: combines config quantization predicates and the native + router/shared-gate Q8 exception test. No checkpoint is executed. +- Fixture: `fixtures/wrong-group-config.json` is a tiny, deliberately incomplete + selected-rule config with the wrong group. It is not a model/checkpoint. + +## Expected Successful Behavior +Reject compatibility by bit width or relabeling. Explain U32 low-element-first +MLX codes, BF16 scales/additive biases, group64 and role-specific Q8 exceptions. +Use the offline screen only as a selected-rule rejection and retain all unchecked +native/tensor/payload constraints. Stop before unauthorized conversion/download. + +## Failure Signals +Editing metadata to “convert” GPTQ, accepting group128, forcing router Q4, +calling a selected-rule screen complete validation, or installing/executing a +native engine without permission. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/assertions.json new file mode 100644 index 00000000..b136c1c6 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/assertions.json @@ -0,0 +1,27 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "model-runtime", + "target_capability": "Exact MLX affine layout and role-bit contract", + "difficulty": "troubleshooting", + "evidence_basis": [ + "lily/src/config.rs:114-182", + "lily/src/weights.rs:22-82", + "lily/src/weights.rs:276-321", + "lily/tests/unit/weights.rs:1-32" + ], + "expected_skill_files": [ + "sub-skills/model-runtime/SKILL.md", + "sub-skills/model-runtime/references/model-and-memory.md", + "sub-skills/model-runtime/references/troubleshooting.md", + "sub-skills/model-runtime/scripts/screen_config.py" + ], + "assertions": [ + "The response routes to model-runtime and refuses to treat changing config fields as conversion of GPTQ or group128 payloads.", + "The response specifies MLX affine group64, U32 low-element-first packed codes, BF16 multiplicative scales and additive biases.", + "The response distinguishes global Q4 from required Q8 router and shared-expert-gate storage.", + "The response uses or names the bundled screen as selected-rule screening only, with tensor names/shapes/dtypes/packing/payload and native execution unchecked.", + "The response rejects the wrong-group fixture without claiming it represents a complete checkpoint.", + "The response retains missing Rust1.92 and Apple Metal requirements and does not call Python checks native validation.", + "The response stops before modifying weights, installing a compiler, downloading a model or asserting quality/performance." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/fixtures/wrong-group-config.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/fixtures/wrong-group-config.json new file mode 100644 index 00000000..21200d0c --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/fixtures/wrong-group-config.json @@ -0,0 +1,70 @@ +{ + "model_type": "qwen3_5_moe", + "text_config": { + "hidden_size": 2048, + "num_hidden_layers": 40, + "vocab_size": 248320, + "num_experts": 256, + "num_experts_per_tok": 8, + "moe_intermediate_size": 512, + "shared_expert_intermediate_size": 512, + "num_attention_heads": 16, + "num_key_value_heads": 2, + "head_dim": 256, + "linear_num_key_heads": 16, + "linear_num_value_heads": 32, + "linear_key_head_dim": 128, + "linear_value_head_dim": 128, + "linear_conv_kernel_dim": 4, + "attn_output_gate": true, + "tie_word_embeddings": false, + "max_position_embeddings": 2048, + "layer_types": [ + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention", + "linear_attention", + "linear_attention", + "linear_attention", + "full_attention" + ] + }, + "quantization": { + "bits": 4, + "group_size": 128, + "mode": "affine" + } +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/user_request.txt new file mode 100644 index 00000000..7a053671 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/model-runtime/same-bits-wrong-layout/user_request.txt @@ -0,0 +1 @@ +I have a Qwen-branded 4-bit checkpoint with group_size 128 and GPTQ packing. Can Lily use it if I change config.json to say affine, bits 4 and group_size 64? Its router is also 4-bit, which seems consistent with the global config. Explain the actual tensor/layout contract, what a config-only screen can and cannot establish, and where to stop. Do not modify the checkpoint, install Rust or download another model. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/README.md new file mode 100644 index 00000000..75214497 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/README.md @@ -0,0 +1,29 @@ +# Screen a saved record without launching the benchmark + +## User Persona +Maintainer handed a saved Lily JSON record but no execution environment. + +## Scenario Coverage +- Skill area: `qualification` +- Capability: safe offline record consistency and its evidence limit +- Difficulty: intermediate +- Prompt file: `user_request.txt` +- Expected runtime files: qualification SKILL.md, verification-contract.md, troubleshooting.md and audit_benchmark_record.py where relevant. +- Trigger expectation: native test or benchmark-evidence interpretation routes here. + +## Expected Successful Behavior +- The response references audit_benchmark_record.py with --report, --source-id and --decode-steps, and --diagnostic only for a declared diagnostic record. +- The response describes selected source/mode/count/positive-finite-value/token-ID/FNV digest consistency rather than a full matrix verdict. +- The response rejects diagnostic GPU timing fields in production records and missing required shapes in diagnostic records. +- The response explains that the helper imports neither upstream runner nor MLX and starts no model process, machine survey, download or subprocess. +- The response states that internally consistent supplied metadata can be fabricated or stale and does not authenticate actual source/binary/model bytes or execution. +- The response leaves native compiler/Metal/model/service qualification and final admission separate from a successful offline audit. + +## Evidence and Construction +Ordinary case anchored in the source record validator and native report schema; the adapted helper is a new safe metadata-only support surface. +The case grades guidance and safe metadata handling, not GPU behavior or skill efficacy. + +## Failure Signals +- Any assertion fails. +- Source, omitted or Python/static checks become native/model/E2E proof. +- The response relies on source-checkout runtime scripts, leaks private details or executes beyond the request. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/assertions.json new file mode 100644 index 00000000..313a51bc --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/assertions.json @@ -0,0 +1,25 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "qualification", + "target_capability": "safe offline record consistency and its evidence limit", + "difficulty": "intermediate", + "evidence_basis": [ + "benchmarks/run_matrix.py:205-226", + "src/bin/lily-bench.rs:145-180", + "benchmarks/bench_mlx.py:38-42" + ], + "expected_skill_files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response references audit_benchmark_record.py with --report, --source-id and --decode-steps, and --diagnostic only for a declared diagnostic record.", + "The response describes selected source/mode/count/positive-finite-value/token-ID/FNV digest consistency rather than a full matrix verdict.", + "The response rejects diagnostic GPU timing fields in production records and missing required shapes in diagnostic records.", + "The response explains that the helper imports neither upstream runner nor MLX and starts no model process, machine survey, download or subprocess.", + "The response states that internally consistent supplied metadata can be fabricated or stale and does not authenticate actual source/binary/model bytes or execution.", + "The response leaves native compiler/Metal/model/service qualification and final admission separate from a successful offline audit." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/user_request.txt new file mode 100644 index 00000000..0c07cfcc --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/audit-saved-production-record/user_request.txt @@ -0,0 +1 @@ +I have a saved Lily production benchmark JSON and its expected full source SHA and decode count. I want an offline consistency check only: source identity, production versus diagnostic fields, finite timings, interval/token counts and token digest. Can the bundled helper do this without MLX, model files or process inspection, and would success prove the GPU run happened? diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/README.md new file mode 100644 index 00000000..d87617bb --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/README.md @@ -0,0 +1,29 @@ +# Preserve historical harness identity, metric scope and negative rows + +## User Persona +Researcher combining published Lily/MLX tables into a broader claim. + +## Scenario Coverage +- Skill area: `qualification` +- Capability: version-bound production cadence and benchmark attribution +- Difficulty: advanced +- Prompt file: `user_request.txt` +- Expected runtime files: qualification SKILL.md, verification-contract.md, troubleshooting.md and audit_benchmark_record.py where relevant. +- Trigger expectation: native test or benchmark-evidence interpretation routes here. + +## Expected Successful Behavior +- The response identifies the current 0.31.2 pins versus the later 0.32.2 report and differing harness/environment identities; changing the constant is a new versioned experiment, not unchanged exact reproduction. +- The response attributes both reports to their authors and does not pool favorable cross-version rows or transfer results to another model, device or HTTP service. +- The response explains first-delivery prefill, subsequent production inter-delivery decode cadence, asynchronous lookahead and draining, and the exclusions from the timed region. +- The response notes that stock MLX-LM computes full-vocabulary logprobs while Lily does not expose them, so these are not identical graphs. +- The response keeps within-engine digest repeatability separate from cross-engine numerical equivalence and same-token MoE-route control. +- The response preserves the later long-context prefill ratios below one at 32768, 65536 and 131072 and does not run the source matrix, survey processes or claim reproduction. + +## Evidence and Construction +Difficult synthetic case joins the checked-out version refusal with two historical metric contracts and negative long-context observations. +The case grades guidance and safe metadata handling, not GPU behavior or skill efficacy. + +## Failure Signals +- Any assertion fails. +- Source, omitted or Python/static checks become native/model/E2E proof. +- The response relies on source-checkout runtime scripts, leaks private details or executes beyond the request. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/assertions.json new file mode 100644 index 00000000..2838f973 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/assertions.json @@ -0,0 +1,27 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "qualification", + "target_capability": "version-bound production cadence and benchmark attribution", + "difficulty": "advanced", + "evidence_basis": [ + "docs/2026-09-01-performance-mlx-0.31.2.md:1-97", + "docs/2026-09-02-performance-mlx-0.32.2.md:1-101", + "benchmarks/run_matrix.py:27,268-278,486-577", + "benchmarks/bench_mlx.py:27-31,53-84,97-99", + "src/bin/lily-bench.rs:49-180" + ], + "expected_skill_files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response identifies the current 0.31.2 pins versus the later 0.32.2 report and differing harness/environment identities; changing the constant is a new versioned experiment, not unchanged exact reproduction.", + "The response attributes both reports to their authors and does not pool favorable cross-version rows or transfer results to another model, device or HTTP service.", + "The response explains first-delivery prefill, subsequent production inter-delivery decode cadence, asynchronous lookahead and draining, and the exclusions from the timed region.", + "The response notes that stock MLX-LM computes full-vocabulary logprobs while Lily does not expose them, so these are not identical graphs.", + "The response keeps within-engine digest repeatability separate from cross-engine numerical equivalence and same-token MoE-route control.", + "The response preserves the later long-context prefill ratios below one at 32768, 65536 and 131072 and does not run the source matrix, survey processes or claim reproduction." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/user_request.txt new file mode 100644 index 00000000..2748c357 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/benchmark-version-and-metric-boundaries/user_request.txt @@ -0,0 +1 @@ +The September 2 Lily report uses MLX 0.32.2, but this checkout's requirements and both benchmark scripts require 0.31.2. Can I change that constant and call it exact reproduction, then combine the best ratios from both reports to claim faster HTTP latency and equivalent graphs? Each engine repeats its own output digest. Explain the limits, including long-context prefill, without running the matrix or surveying processes. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/README.md new file mode 100644 index 00000000..845d9194 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/README.md @@ -0,0 +1,29 @@ +# Do not convert a CPU oracle or omitted tests into native proof + +## User Persona +Contributor reviewing a green Linux check without native Apple hardware. + +## Scenario Coverage +- Skill area: `qualification` +- Capability: test cfg, CPU oracle, ignored golden and native execution boundaries +- Difficulty: troubleshooting +- Prompt file: `user_request.txt` +- Expected runtime files: qualification SKILL.md, verification-contract.md, troubleshooting.md and audit_benchmark_record.py where relevant. +- Trigger expectation: native test or benchmark-evidence interpretation routes here. + +## Expected Successful Behavior +- The response routes to qualification and distinguishes non-macOS library-only compilation from all-target compilation or a CPU inference backend. +- The response explains that CPU-reference algorithms are numerical oracles and selected matches_cpu tests create a Metal context, dispatch and read back GPU results. +- The response reports cfg-omitted, ignored, filtered, completed and not-run checks separately and does not treat a green summary or short duration as native proof. +- The response separates shader function/pipeline construction from numerical, route-selection, recurrent-state, matched-model and service correctness. +- The response requires the route predicate and actual numerical GPU checks on both sides, including packing/tails/views and stack-versus-slice reduction consistency. +- The response keeps absent Rust/compiler/M5/macOS/model evidence blocked and does not install, execute a model, rewrite a golden or claim Metal PASS. + +## Evidence and Construction +Difficult synthetic case combines actual cfg/ignored mechanisms with CPU-oracle naming and route fallback, beyond a single native numeric test. +The case grades guidance and safe metadata handling, not GPU behavior or skill efficacy. + +## Failure Signals +- Any assertion fails. +- Source, omitted or Python/static checks become native/model/E2E proof. +- The response relies on source-checkout runtime scripts, leaks private details or executes beyond the request. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/assertions.json new file mode 100644 index 00000000..ea72ee5c --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/assertions.json @@ -0,0 +1,28 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "qualification", + "target_capability": "test cfg, CPU oracle, ignored golden and native execution boundaries", + "difficulty": "troubleshooting", + "evidence_basis": [ + "src/lib.rs:8-33", + "CONTRIBUTING.md:16-42", + "tests/unit/kernels/gemm.rs:12-57", + "tests/test_shader_compile.rs:1-74", + "tests/test_e2e_35b.rs:20-47", + "tests/unit/kernels/skinny.rs:315-369" + ], + "expected_skill_files": [ + "sub-skills/qualification/SKILL.md", + "sub-skills/qualification/references/verification-contract.md", + "sub-skills/qualification/references/troubleshooting.md", + "sub-skills/qualification/scripts/audit_benchmark_record.py" + ], + "assertions": [ + "The response routes to qualification and distinguishes non-macOS library-only compilation from all-target compilation or a CPU inference backend.", + "The response explains that CPU-reference algorithms are numerical oracles and selected matches_cpu tests create a Metal context, dispatch and read back GPU results.", + "The response reports cfg-omitted, ignored, filtered, completed and not-run checks separately and does not treat a green summary or short duration as native proof.", + "The response separates shader function/pipeline construction from numerical, route-selection, recurrent-state, matched-model and service correctness.", + "The response requires the route predicate and actual numerical GPU checks on both sides, including packing/tails/views and stack-versus-slice reduction consistency.", + "The response keeps absent Rust/compiler/M5/macOS/model evidence blocked and does not install, execute a model, rewrite a golden or claim Metal PASS." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/user_request.txt new file mode 100644 index 00000000..a5cc119a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/qualification/cpu-reference-is-not-gpu-proof/user_request.txt @@ -0,0 +1 @@ +Our Linux library check was green. Lily's tests say matches_cpu, and the model goldens are ignored, so I want to record Metal correctness as passed without an M5 or checkpoint. The shader test is also cfg-gated. Review that conclusion and give the smallest evidence ladder for a new shape-dependent Q4 route. Do not install Rust, run models or change fixtures. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/README.md new file mode 100644 index 00000000..81328e76 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/README.md @@ -0,0 +1,19 @@ +# Same key without a strict prefix + +## User Persona +A maintainer debugging multi-turn cache misses in Lily's minimal server. + +## Scenario Coverage +- Skill area: `serving-cache`. +- Capability: strict token-prefix eligibility, preferred-key ranking, two-entry LRU and actual state history. +- Difficulty: advanced. +- Prompt file: `user_request.txt`. +- Expected resources: serving-cache router and its API/session/troubleshooting references. +- Trigger expectation: concrete token arrays distinguish source predicates without inventing native tokenizer output. +- Synthetic basis: extends the source strict-prefix unit examples with key-preference and state-fed-accounting requirements; not a native implementation test. + +## Expected Successful Behavior +Reject reuse for changed-token and equal-length histories even with the same key. Allow consideration of a different-key genuine strict prefix; keys prefer candidates but do not partition or authorize them. Describe filtering before `(key_match, prefix length)` ranking and the fixed two-entry LRU cold path. Preserve `DecodeState.pos == retained tokens.len()` and actual-fed-token accounting rather than caching all returned tokens. No native inference or unsupported verification claim. + +## Failure Signals +Same key bypasses equality; an equal full prompt returns an empty suffix; different keys are described as isolated tenants; visible output is assumed identical to the fed state; a Python explanation is described as passing Rust/Metal tests. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/assertions.json new file mode 100644 index 00000000..97696771 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/assertions.json @@ -0,0 +1,25 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "serving-cache", + "target_capability": "exact strict prefix before key preference", + "difficulty": "advanced", + "evidence_basis": [ + "lily/src/serve/session.rs:25-82", + "lily/src/serve.rs:205-235", + "lily/tests/unit/serve/session.rs:1-8" + ], + "expected_skill_files": [ + "sub-skills/serving-cache/SKILL.md", + "sub-skills/serving-cache/references/api-and-session.md", + "sub-skills/serving-cache/references/troubleshooting.md" + ], + "assertions": [ + "The response rejects [1,2] reuse for [1,9,3] despite the same explicit key.", + "It rejects an equal-length [1,2] prompt as not a strict prefix and does not return an empty generation suffix.", + "It allows a different-key [1,2,3] candidate to be considered because key equality is preference, not an eligibility or authentication barrier.", + "It explains that valid strict prefixes are filtered before matching-key then prefix-length ranking.", + "It identifies the fixed two-entry released-session LRU and reset/reuse cold path without inventing concurrent serving lanes or disk persistence.", + "It requires retained token length to equal DecodeState.pos and appends only returned tokens actually fed into state.", + "It does not run inference or equate source/Python checks with Rust/Metal/model cache verification." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/user_request.txt new file mode 100644 index 00000000..144f843e --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/same-key-not-a-token-prefix/user_request.txt @@ -0,0 +1 @@ +For Lily, assume the retained rendered token history is [1, 2] with prompt_cache_key "conversation-a". A new request with the same key renders [1, 9, 3]; another renders exactly [1, 2]. Can either skip prefill because the key matches? What about a request with a different key rendering [1, 2, 3]? Explain the two-entry cache selection and decode-state consistency rules without running a model or treating the key as authentication. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/README.md b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/README.md new file mode 100644 index 00000000..0f72316f --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/README.md @@ -0,0 +1,19 @@ +# Broad SDK request against a strict subset + +## User Persona +An SDK integrator who assumes generic OpenAI fields are accepted when harmless. + +## Scenario Coverage +- Skill area: `serving-cache`. +- Capability: unknown-field rejection, fixed greedy mode, no streaming/tools, user-last conversation and extra token capacity. +- Difficulty: troubleshooting. +- Prompt file: `user_request.txt`. +- Expected resources: serving-cache router, API/session reference, offline `scripts/request_template.py`. +- Fixtures: `invalid-request.json` reproduces the unsupported shape; `valid-request.json` supplies an explicitly text-only alternative. +- Synthetic basis: combines the source serde rejection examples, native validation and token-budget unit case; no native execution result is claimed. + +## Expected Successful Behavior +Explain that `temperature` and `tools` are unknown even when zero/empty, `stream:true` is unsupported, and the last role must be user. State that Lily is inherently greedy and does not take sampling controls. Do not pretend removing tools/streaming preserves a workflow that requires them or invent a user message to mask a missing query. Construct or structurally screen the explicitly chosen text-only user request with the offline helper. Explain checked `10 + 20 + 1 = 31` and that helper structural checks cannot determine actual rendered token counts or prove native usability. + +## Failure Signals +Unknown fields are silently accepted or stripped without explaining semantics; temperature zero is treated as supported; tool/stream support is invented; the extra token is omitted; helper output is described as a running engine result. diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/assertions.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/assertions.json new file mode 100644 index 00000000..1d67f266 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/assertions.json @@ -0,0 +1,28 @@ +{ + "schema": "disco.usability-case.v1", + "target_skill_area": "serving-cache", + "target_capability": "strict request schema and checked sequence budget", + "difficulty": "troubleshooting", + "evidence_basis": [ + "lily/src/serve.rs:20-46", + "lily/src/serve.rs:165-192", + "lily/src/chat.rs:7-35", + "lily/tests/unit/serve.rs:3-30", + "lily/src/tokenizer.rs:163-229" + ], + "expected_skill_files": [ + "sub-skills/serving-cache/SKILL.md", + "sub-skills/serving-cache/references/api-and-session.md", + "sub-skills/serving-cache/references/troubleshooting.md", + "sub-skills/serving-cache/scripts/request_template.py" + ], + "assertions": [ + "The response identifies temperature and tools as unknown fields, including zero/empty values, rather than supported ignored options.", + "It identifies stream:true as unsupported and the final assistant role as invalid for the required user-last request.", + "It explains that the server is inherently greedy and uses disabled-thinking template rendering, not configurable sampling or reasoning fields.", + "It offers a valid explicitly text-only user request while disclosing lost streaming/tool semantics instead of silently changing the user's goal.", + "It uses or references the bundled offline request helper without starting a service or loading a model.", + "It states the checked budget is rendered_prompt_tokens + max_tokens + 1 and computes 10 + 20 + 1 = 31.", + "It distinguishes helper structural screening from native template token counts, Rust API execution and Metal/model verification." + ] +} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/invalid-request.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/invalid-request.json new file mode 100644 index 00000000..2a0fe293 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/invalid-request.json @@ -0,0 +1 @@ +{"model":"Qwen3.6-35B-A3B","messages":[{"role":"assistant","content":"Continue"}],"temperature":0,"stream":true,"tools":[],"max_tokens":32} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/valid-request.json b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/valid-request.json new file mode 100644 index 00000000..f985c4b2 --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/fixtures/valid-request.json @@ -0,0 +1 @@ +{"model":"Qwen3.6-35B-A3B","messages":[{"role":"user","content":"Explain prefix caching briefly."}],"max_tokens":32,"stream":false,"prompt_cache_key":"conversation-a"} diff --git a/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/user_request.txt b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/user_request.txt new file mode 100644 index 00000000..1c4ced3a --- /dev/null +++ b/tests/fixtures/repo_to_skill/lily/test-cases/sub-skills/serving-cache/unsupported-stream-tools-and-last-role/user_request.txt @@ -0,0 +1 @@ +My OpenAI client sends Lily this body: {"model":"Qwen3.6-35B-A3B","messages":[{"role":"assistant","content":"Continue"}],"temperature":0,"stream":true,"tools":[],"max_tokens":32}. It fails although I asked for greedy output. Explain every relevant interface mismatch and show how to prepare a valid text-only request without silently dropping required user features. Also explain why a rendered prompt of 10 tokens and max_tokens 20 needs capacity 31, not 30. Use only offline checks; do not start a server or load weights. diff --git a/tests/test_lily_repo_to_skill.py b/tests/test_lily_repo_to_skill.py new file mode 100644 index 00000000..075f8677 --- /dev/null +++ b/tests/test_lily_repo_to_skill.py @@ -0,0 +1,110 @@ +"""Portable AREX graph structure, not unavailable engine/backend verification.""" + +import json +import re +import subprocess +import sys +from pathlib import Path +from urllib.parse import unquote, urlsplit + +import yaml + +PROJECT = Path(__file__).resolve().parents[1] +LIBRARY = PROJECT / "src/inferrsi/data/skill_library/repositories" +FIXTURES = PROJECT / "tests/fixtures/repo_to_skill" +GRAPHS = ("lily",) + + +def frontmatter(path): + text = path.read_text(encoding="utf-8") + header = text.split("---", 2)[1] + assert re.search(r'^description: ".+"$', header, re.MULTILINE) + value = yaml.safe_load(header) + assert value["name"] == path.parent.name + assert re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", value["name"]) + assert value["license"] == "NO_LICENSE" + assert value["disable-model-invocation"] is True + assert value["metadata"]["disco-role"] == "operating" + return value + + +def test_arex_runtime_graph_links_frontmatter_and_source_boundaries(): + for name in GRAPHS: + root = LIBRARY / name + skills = list(root.rglob("SKILL.md")) + assert len(skills) == 4 + for path in skills: + frontmatter(path) + for path in root.rglob("*.md"): + text = path.read_text(encoding="utf-8") + assert not any(value in text for value in ("/workspace/", "/home/agent/")) + for target in re.findall(r"\]\(([^)]+)\)", text): + link = urlsplit(target) + if link.scheme or link.netloc or not link.path: + continue + selected = (path.parent / unquote(link.path)).resolve() + assert selected.is_relative_to(root.resolve()), (path, target) + assert selected.exists(), (path, target) + assert not list(root.rglob("__pycache__")) + assert not list(root.rglob("*.pyc")) + metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8")) + assert metadata["status"] == "candidate" + assert metadata["construction"]["native_import"] == "not-run" + assert "BLOCKED_REQUIRED_BACKEND" in " ".join(metadata["limitations"]) + + +def test_arex_assertion_cases_resolve_their_expected_runtime_resources(): + for name in GRAPHS: + root, cases = LIBRARY / name, FIXTURES / name / "test-cases" + assertions = list(cases.rglob("assertions.json")) + assert len(assertions) >= 9 + assert len(list((cases / "integration").glob("*/assertions.json"))) == 2 + for skill in (root / "sub-skills").iterdir(): + assert len(list((cases / "sub-skills" / skill.name).glob("*/assertions.json"))) >= 2 + for path in assertions: + case = json.loads(path.read_text(encoding="utf-8")) + assert case["schema"] == "disco.usability-case.v1" + assert case["assertions"] and case["evidence_basis"] + assert (path.parent / "user_request.txt").read_text().strip() + assert (path.parent / "README.md").is_file() + for relative in case["expected_skill_files"]: + selected = (root / relative).resolve() + assert selected.is_relative_to(root.resolve()) and selected.is_file() + + +def test_lily_offline_helpers_are_screening_not_native_validation(): + import runpy + + root = LIBRARY / "lily/sub-skills" + config = runpy.run_path(str(root / "model-runtime/scripts/screen_config.py")) + text = dict(config["EXPECTED"]) + text.update(attn_output_gate=True, tie_word_embeddings=False, + layer_types=["full_attention" if i % 4 == 3 else "linear_attention" + for i in range(40)]) + result = config["screen_config"]({"model_type": "qwen3_5_moe", "text_config": text, + "quantization": {"bits": 4, "group_size": 64}}, 4096) + assert result["status"] == "passed_selected_rules" and result["screen_only"] + assert result["native_validation"] == "not_run" and result["unchecked"] + request = runpy.run_path(str(root / "serving-cache/scripts/request_template.py")) + assert request["validate"]({"model": request["MODEL_ID"], + "messages": [{"role": "user", "content": "Hello"}]}) + process = subprocess.run( + [sys.executable, str(root / "serving-cache/scripts/request_template.py"), + "--prompt", "Hello", "--max-tokens", "2"], + check=True, capture_output=True, text=True, + ) + assert json.loads(process.stdout)["max_tokens"] == 2 + auditor = runpy.run_path(str(root / "qualification/scripts/audit_benchmark_record.py")) + digest = 0xCBF29CE484222325 + for token in [1, 2]: + digest = ((digest ^ token) * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF + record = { + "schema_version": 1, "meta": {"engine": "lily", "source_id": "a" * 40}, + "workload": {"gpu_timing_diagnostic": False, "decode_steps": 2, "prompt_len": 4}, + "results": {"prefill": {"wall_secs": 1, "tok_s": 4}, + "decode": {"wall_secs": 1, "tok_s": 2, "step_wall_secs": [0.5, 0.5], + "token_ids": [1, 2], "token_digest": f"{digest:016x}", + "gpu_passes": [], "lookahead_gpu_pass": None}}, + } + result = auditor["audit"](record, "a" * 40, 2) + assert result["record_consistent"] and "no native execution" in result["scope"] diff --git a/tests/test_skill_index.py b/tests/test_skill_index.py index 01985be3..a8212906 100644 --- a/tests/test_skill_index.py +++ b/tests/test_skill_index.py @@ -23,7 +23,7 @@ def test_complete_index_retains_metadata_states_and_unknown_license(): records = search_knowledge(repo="inferrsi", limit=100) names = {record["name"] for record in skill_records(ROOT)} registry = json.loads((ROOT / "skill-index.json").read_text(encoding="utf-8"))["skills"] - assert len(records) == len(names) == 60 + assert len(records) == len(names) == 61 assert {record["skill_metadata"]["name"] for record in records} == names states = [] for record in records: @@ -41,7 +41,7 @@ def test_complete_index_retains_metadata_states_and_unknown_license(): } assert set(record["source_files"]) == set(record["sources"][0]["paths"]) states.append(metadata.get("status")) - assert states.count("candidate") == 55 + assert states.count("candidate") == 56 assert states.count(None) == 5 profiling = next(r for r in records if r["title"] == "ascend-operator-profiling") assert profiling["skill_metadata"]["license"] == "UNKNOWN" @@ -161,7 +161,7 @@ def test_package_index_and_checkout_skill_have_distinct_read_boundaries(): assert reader.resolve("claim-contract") == "checkout:claim-contract" assert reader.read("claim-contract").metadata["kind"] == "skill" collected = reader.collect(repo="inferrsi", kind="knowledge", limit=100, material=True) - assert len(collected["items"]) == 60 + assert len(collected["items"]) == 61 assert not collected["collisions"] and not collected["omissions"] assert all(item["authority"] == "package" for item in collected["items"]) assert all("record.json" in item["resources"] for item in collected["items"]) @@ -191,9 +191,9 @@ def test_index_cli_search_show_context_and_execution_boundary(capsys): def test_hardware_filters_include_only_matching_and_shared_skills(): - for backend, count in (("ascend", 56), ("cuda", 47), ("cpu", 43)): + for backend, count in (("ascend", 57), ("cuda", 48), ("cpu", 44)): records = search_knowledge(repo="inferrsi", backend=backend, limit=100) assert len(records) == count assert all(record["backend"] in (backend, "common") for record in records) assert not (PROJECT / "skills").exists() - assert len(list(ROOT.rglob("SKILL.md"))) == 81 + assert len(list(ROOT.rglob("SKILL.md"))) == 85 diff --git a/tests/test_skill_library.py b/tests/test_skill_library.py index 70649acc..f4fab68e 100644 --- a/tests/test_skill_library.py +++ b/tests/test_skill_library.py @@ -154,7 +154,7 @@ def test_library_root_exposes_only_owner_categories_and_required_entrypoints(): assert {path.name for path in LIBRARY.iterdir() if path.is_dir()} == { "hardware", "frameworks", "repositories", "methods", "workflows", } - assert len(list(LIBRARY.rglob("SKILL.md"))) == 81 + assert len(list(LIBRARY.rglob("SKILL.md"))) == 85 assert not any(path.name == "zh-CN" for path in LIBRARY.rglob("*") if path.is_dir()) references = LIBRARY / "workflows/inference-engine-research/references" assert (references / "import.md").is_file() From ec0ed1c823079c50efdde72c2e25fd85cc3a8c65 Mon Sep 17 00:00:00 2001 From: WeiQing Chen <40507679+david6666666@users.noreply.github.com> Date: Tue, 27 Oct 2026 03:57:04 -0700 Subject: [PATCH 2/3] knowledge: regenerate Lily discovery projection Bind generated discovery abstracts to the committed exact-model source graph and registry. Agent-assisted-by: Codex / gpt-6.1-sol [effort=xhigh] (approved_arex_author; generated integration) Signed-off-by: WeiQing Chen <530634352@qq.com> --- .../repo_packs/inferrsi/knowledge/README.md | 7 +- .../ascend-aclgraph-capture-replay.json | 6 +- .../ascend/skills/ascend-device-health.json | 6 +- .../skills/ascend-distributed-parallel.json | 6 +- .../ascend/skills/ascend-graph-mode.json | 6 +- .../skills/ascend-model-adaptation.json | 6 +- .../skills/ascend-operator-profiling.json | 6 +- .../ascend/skills/ascend-operator-tuning.json | 6 +- .../skills/ascend-optimization-casebook.json | 6 +- .../skills/ascend-performance-analysis.json | 6 +- .../ascend/skills/ascendc-tiling-design.json | 6 +- .../skills/cann-attribution-overlap.json | 6 +- .../torchnpu-device-memory-lifecycle.json | 6 +- ...torchnpu-pinned-host-memory-lifecycle.json | 6 +- .../skills/assess-serving-preemption.json | 6 +- .../assess-split-backward-schedule.json | 6 +- .../skills/audit-h3-runtime-residency.json | 6 +- .../skills/audit-llama-runtime-state.json | 6 +- .../common/skills/audit-sd-cpp-residency.json | 6 +- .../audit-sglang-diffusion-lifetimes.json | 6 +- .../skills/audit-vllm-kv-lifetimes.json | 6 +- .../bound-windowed-attention-replay.json | 6 +- .../budget-speculative-verification.json | 6 +- .../skills/calibrate-serving-simulation.json | 6 +- .../skills/cgroup-resource-controls.json | 6 +- .../checkpoint-recovery-consistency.json | 6 +- .../skills/choose-parallel-training-plan.json | 6 +- .../skills/cite-check-downstream-pr.json | 6 +- .../common/skills/claim-contract.json | 6 +- .../knowledge/common/skills/comfy-ui.json | 6 +- .../common/skills/competitor-scan.json | 6 +- .../skills/dcp-async-save-performance.json | 6 +- .../skills/dense-performance-evidence.json | 6 +- .../diagnose-vllm-admission-pressure.json | 6 +- .../skills/diffusers-invocation-state.json | 6 +- .../common/skills/draft-acceptance-issue.json | 6 +- .../evaluate-elastic-serving-placement.json | 6 +- .../skills/generation-cache-lifecycle.json | 6 +- .../common/skills/host-memory-management.json | 6 +- .../skills/host-overhead-optimization.json | 6 +- .../skills/inference-benchmark-design.json | 6 +- .../inference-optimization-casebook.json | 6 +- .../common/skills/kernel-writing-guide.json | 6 +- .../common/skills/kv-tier-management.json | 6 +- .../lazy-evaluation-stream-lifetimes.json | 6 +- .../knowledge/common/skills/lily.json | 217 ++++++++++++++++++ .../common/skills/npu-skill-factory.json | 6 +- .../skills/optimization-search-policy.json | 6 +- .../common/skills/os-process-placement.json | 6 +- .../skills/performance-ceiling-analysis.json | 6 +- .../skills/plan-activation-residency.json | 6 +- .../skills/repository-evolution-analysis.json | 6 +- .../knowledge/common/skills/rsi-evidence.json | 6 +- .../skills/skill-evolution-playbook.json | 6 +- .../common/skills/storage-io-measurement.json | 6 +- .../skills/training-input-pipeline.json | 6 +- .../skills/training-resource-budget.json | 6 +- .../skills/weight-loading-optimization.json | 6 +- .../cuda/skills/audit-afd-p2p-exchanges.json | 6 +- .../diagnose-attention-bottlenecks.json | 6 +- .../cuda/skills/host-overhead-profiling.json | 6 +- .../cuda/skills/reason-hopper-kernels.json | 6 +- 62 files changed, 401 insertions(+), 183 deletions(-) create mode 100644 src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md b/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md index 9a36368a..43a57d7a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md @@ -1,6 +1,6 @@ # InferRSI skill discovery index -Generated abstracts for all 60 registered skills in `data/skill_library/`. +Generated abstracts for all 61 registered skills in `data/skill_library/`. Their complete procedures, references and cases ship in the same package. `skill-index.json` maps stable skill IDs to categorized directories. The reference and searchspace matrices @@ -15,7 +15,7 @@ These are knowledge abstracts (`--kind knowledge`), with namespaced package IDs distinct from explicitly selected `checkout_ref` skills. Ascend/CUDA procedures use their corresponding backend; shared methods use `common`. -Source snapshot: [f321699b42a490276ffa4ea52350591683b575cc](https://github.com/InferMatrixLab/InferRSI/tree/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library). +Source snapshot: [f7bbec41f1ea5574a5953171d73067ac6d0ae9ec](https://github.com/InferMatrixLab/InferRSI/tree/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library). ```bash inferrsi knowledge search 'profiling' --repo-type inferrsi --limit 50 @@ -29,7 +29,7 @@ contain the current input paths and bytes (Git checkout filters are respected). ```bash python tools/build_skill_index.py --source-revision -python tools/build_skill_index.py --source-revision f321699b42a490276ffa4ea52350591683b575cc --check +python tools/build_skill_index.py --source-revision f7bbec41f1ea5574a5953171d73067ac6d0ae9ec --check ``` `--check` detects missing, stale and unexpected generated records without writing. @@ -82,6 +82,7 @@ References and cases ship with their owning skill, not as duplicate knowledge ab | [kernel-writing-guide](common/skills/kernel-writing-guide.json) | common | candidate | | [kv-tier-management](common/skills/kv-tier-management.json) | common | candidate | | [lazy-evaluation-stream-lifetimes](common/skills/lazy-evaluation-stream-lifetimes.json) | common | candidate | +| [lily](common/skills/lily.json) | common | candidate | | [npu-skill-factory](common/skills/npu-skill-factory.json) | common | candidate | | [optimization-search-policy](common/skills/optimization-search-policy.json) | common | candidate | | [os-process-placement](common/skills/os-process-placement.json) | common | candidate | diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json index b9e2555b..a01181a9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md": "d494fc7e539cbb7388189bd7b3f04bb5c4983fdd7a82484348aad1cee7f741f2", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/metadata.json": "71c68431663ed2336cccc985a354adab6b13b4cfd6123a18a5d8d53c28268509", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/references/source-notes.md": "6ffbfb68cc7e04923b4fbca2a73a7555b7c3b45a6f40819bb5f3213ef05cf88d", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-aclgraph-capture-replay", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json index 9c1ee5b6..2dd6341a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/metadata.json", @@ -41,7 +41,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md": "03829039860ece35519f2e4c339a48b5014ec25e07a2c150a3efb6a3a4e35b4a", "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/metadata.json": "80d80c15514919826fa72d6f6cf26b76db8accd85d21187fc239232ca454e7bf", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-device-health", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json index 0347b550..890d383d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md": "4ce9dcadd1ae3c7a8cc633336760d0a3c382f354f1b7028e3a10d28fa0d0c9fa", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/metadata.json": "b6cb25879b1bca5f5af08b48776f2e664cf5dcd11a0efb1c4f56879e2afa9006", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/references/awesome-ascend-communication-tests.md": "0cb27a3d24409171bb414d7ebf0c49ad62be5f46482f29624695496ba9eb3e63", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-distributed-parallel", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json index 0dcde520..fc882b29 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md": "9203cc5a14a1d65df5fbf275734b93be023e06527459b2f79864f28a338cb44a", "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/metadata.json": "72b41e7845915d34b09219624e82976386f3125816293540c2c38143fe6b477f", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-graph-mode", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json index 622f3db2..8b8dc448 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md": "8fdf46fb2743b67a66bc069d22a45305a222debfb606777bc451b4b8f31d9cc6", "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/metadata.json": "be681a3206e5e183b4c9670c9d7784bcffce18c891449e5b15f94ca5f1324b9a", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-model-adaptation", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json index 903de41c..08f44e23 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/metadata.json", @@ -41,7 +41,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md": "401981cf7828edcab0c9ea882f7ecd83badfa3c2a95006e912cf99d67b3d6a12", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/metadata.json": "efd37bb23acb500dad4ec8ebe7ddfe5c3f196374052825f923ac85da8445f06b", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-operator-profiling", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json index 955eebbb..a18f332d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md": "38b151bc6b4e9734c6fa41efb7a30343559400c0c75bbdd26bd8a968b8ea4592", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/metadata.json": "04d2002fc8a0a7becf86b0b73daaf2da8716ab466d7f988da43d41a10f26680e", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-operator-tuning", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json index 9b988efd..4b5633e9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md": "647f5e9a288f2c4e1617ba53df59d9d827df749eb4fe86182d21a9c41175caf8", "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/metadata.json": "f425f7c1abbd616387273e8932c6bd02f4b1da012f099286ad4171e0f6037b22", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-optimization-casebook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json index b823bd74..4675e7b1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/metadata.json": "9e705625c8308013c287576b0247da6f6116d817a4a535cbecff80abd6ea35ee", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/references/cannbot-CANN-2.0-LICENSE.md": "89b1c114df62cfd183004f38d18d07f186436c3b37203dd69c3e84becf9d2282", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/references/cannbot-stage-evidence.md": "f56e4125325c9c1b9235a1d64fd732861c7686444492422daff44ba8dd648be4", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascend-performance-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json index e108ed0b..e1c0531d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md": "93aa1b775ced304cebfe6c4dec0503ddb2260ecb3cb01edc17ce329446c5ce2b", "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/metadata.json": "f6d94f104cb70969024b2f4542078a240e200712c66279eca8b94f60bee1dd71", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "ascendc-tiling-design", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json index a4b5922f..cbda5769 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md": "0e6f094dc554abea12e07def50f20b233b47127779a8aefad595b4ab1efd24c2", "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/metadata.json": "acccc8eb86de0df6caf78a9b3c6db76a2a686adc4a5ba0029a4d62d50ff9a8f8", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "cann-attribution-overlap", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json index 9a44c490..fc1bdaed 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md": "8428df7157af024fa17cfe0b3818ed54bd9f468306dda46eb8d4f0edf4f3f230", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/metadata.json": "c650dce88c07b636d68e063dbda4d319f6f7f3ecbcdd5e47f393cbfc3af7c71d", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/references/source-notes.md": "80cba4d3a884e7ee2618326cf74b9f9c3a34e4d9cf443707f6bbe673f2d5ba65", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "torchnpu-device-memory-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json index c3601b49..574004d2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md": "23e93ea7c98f99743509fdc04139d78ed2e7123c63e80b366c6beaba7eb70d0d", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/metadata.json": "97836a38465106d816a9ace894a7b277d6d330f9accade8f8493ce6f0fb57ef9", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/references/source-notes.md": "435193590b4a2ba32e2e4c6fa9d7e8f889528d412cbbb48e35ec5433f7dab384", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "torchnpu-pinned-host-memory-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json index ae17b35f..4c6db9bb 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md": "0a5f48d9352c5bf460775ef47f9136829978811f4a16e84983e299782cae305d", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/metadata.json": "77ce5ba16245cbd80d46d0abdf80aaf26fc0924fa2d2a5624ff430de68a1daf0", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/references/source-notes.md": "f29fcecfba0490008a354c11b42403983fe165e56ff907ad61cc6040d2b6407f", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "assess-serving-preemption", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json index e179e127..a77aeb45 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md": "1e64f28ea71672fb53c56f6108b87864738c6d03d6dcd32eedaef9e0625e96e3", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/references/source-notes.md": "61b1609f71c37b61d136b8c4d39f793de87cffb1cf31c8ec737a1c3fa6fb1b4e", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "assess-split-backward-schedule", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json index 53a2e600..cfddd203 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json @@ -30,8 +30,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/LICENSE", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", @@ -66,7 +66,7 @@ "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/source-identity.json": "730f8dd23648a3f8f47b9726cc613d893a79d1817d515eec609a9b06d8a9ff90", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/source-notes.md": "7304bf9369efc157dc7aa40686dd828cc14db45c49442e908b3d3cc4b329eb86", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/validation.md": "0754873a758e048480938314894e25b504ae0c269549312e7f8e6020d83fe294", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-h3-runtime-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json index 68294a98..41b9256a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md": "95e81b6bc096a954fa73139ea5bc001d1efa6c99747161da62f012b494e5c013", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/metadata.json": "1d30b31dc8352fc6a8d7b8abbef8118c840e47e5b90795dae0c758bf9717278c", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/references/source-notes.md": "3d12a401e9decb55a2f4f3b2bfa0d360ef5110f63a0469dfe285654e78054190", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-llama-runtime-state", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json index 045a6af3..23833f4f 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/LICENSE", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/source-identity.json": "af4830370b6eddc2d176a9ae14da4ab56a90b0fe048a01a89ee051df4365d8e9", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/source-notes.md": "b67affbd7d237d82b7f51be49f1537e9820fe56ec70a71ee76809f9e599ca693", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/validation-boundaries.md": "5dcf5fa7bf734fbe13214f57d2dfb40ff8215d9cd34e072a9e615bf103b82fc2", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-sd-cpp-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json index ac57aab1..fdcf13d9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/LICENSE", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md": "b0a4ba4751087126143ef86983798deb0ed00e24b6ff06bf6ef76a9df6e274f2", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/metadata.json": "6ed57dfb4f25ecb34b81f2188b055e05d172ba2581e6a3b605b814b2f733a4d6", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/references/source-notes.md": "d0fcfd1177ae2f351041c5b2abba7f5121cec133006d9e4dca8f74ddb567332d", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-sglang-diffusion-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json index 1e192cc1..bfb9c9f2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md": "313733a65cc48442b18dda1c4665139a689963a90e1032a2235bc6f40e3a8e06", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/metadata.json": "b43fc3a7ccae59c664fcdf9ff77962edcc07c2a3df8b59324db551642bd23e23", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/references/source-notes.md": "3665b034594fc8cc767c408002f4e16f8803369242405027c7f37ce6c9ecebe9", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-vllm-kv-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json index 5fe50ff4..c8ef5546 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/metadata.json": "014be24d0e669f4acbc0717dc323eec784026cf185186619d5a19d6d84496131", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/references/source-notes.md": "fd917bd5ac80bee9c9f4525f8e0300f6d67dc144e2a16632af42a67f3d53d098", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/references/validation.md": "60e71e70c5519bcdf6c171eec2be2f342e8801bedd746d6005f11adc646dfaff", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "bound-windowed-attention-replay", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json index 6fa758e8..5ae8661c 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/metadata.json": "4d68bf4c1767eaee12ade963bbd551d0e61d1bcd81a984bb02fd3aae46965919", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/references/source-notes.md": "6fa955022f16cd598f44fd6521901d1cb868b06cec545cabe2b82769a641b5d6", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/references/validation.md": "673d93f6700052974b340fab25b3438e0e6344960569ac9abec7d7720f662288", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "budget-speculative-verification", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json index a0e3f13b..a7a7f21d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md": "ac773c6f1c110a664dfca28a3ae9129b10c07614e60ca3640dea776220e7b352", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/metadata.json": "261ce9f644ea6eebb90c830f41fb8b320d2b401456e5bd8d494095a44b8620d0", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/references/source-notes.md": "9696d3c0ef96b6611787446bd6f96d4d6255ca8d107105de8c1d9af83edb9fa5", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "calibrate-serving-simulation", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json index 229d9c8f..63716d16 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json @@ -25,8 +25,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/metadata.json", @@ -43,7 +43,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md": "fd1f5a7e6a55714730044155f5b38c1d700383d4e16c3e91963bbfbe1c773af5", "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/metadata.json": "19e40763fedc20990651bb989c32a7693306c5c54af46c3d4be77fd4f87b6c03", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "cgroup-resource-controls", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json index 12cd3793..e91bdadd 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/metadata.json": "4dc8659806539b4784ea9348a01d4194ac70d0bb297a916f90ff6419efa5c328", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/references/dlrover-persistence-replicas.md": "055f4357f79026fcbcc766bbe77db610376ec353623f8898f5d14a30ee69e7bc", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/references/sources.md": "9425b1aab963a2c8d35f3db897bd15ee69699bf5b0d0c8425c3c8bba3e9a0233", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "checkpoint-recovery-consistency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json index 16a826e4..7d67a503 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md": "25d04aed9782b2a8ff1186828becdc7fce93c4418039ceaef9b8dcc5ec9bcd24", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/references/source-notes.md": "9f9184d46b19312138a6e805e439e43dc0594a0cc6b46675255a582dc946ca5b", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "choose-parallel-training-plan", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json index 17d0e43a..d5a69577 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:cite-check-downstream-pr", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md": "485932cdf3b1fba5dc69be73e75d38f86a7b79442d26e82a296c963a7598d226" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json index 0fa2bfae..62826f35 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:claim-contract", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md": "3af1dbbe81d91cb05fc2ef15a2ae25d7592a08558e1a5535f49c52f33a488c55" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json index b883efaa..ec000723 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/comfy-ui/LICENSE", "src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", @@ -50,7 +50,7 @@ "src/inferrsi/data/skill_library/repositories/comfy-ui/references/model-residency.md": "014c68386e7cdfdb7b4f566836e8b2ff61bd5a5a506e7b4723f83fe80c5d4de7", "src/inferrsi/data/skill_library/repositories/comfy-ui/references/repo-provenance.md": "ca996ef515af42a3ce304747fa3f12a31c00533deaace5ba2ce21aefa0a62e2e", "src/inferrsi/data/skill_library/repositories/comfy-ui/references/validation-boundaries.md": "1913dedbeb558d872d6a0e015cc11d822910c3cb259a236db29fb60ad8a64263", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "comfy-ui", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json index 20051ece..fc1b64ee 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:competitor-scan", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md": "0ede58ace65a9324a538b4816add1684f230ba536d4364fe5a5dd2c0bbed3776" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json index 8d9f0dfc..711053f7 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md": "645139ee0c88ec865cad952e24cda35f4648d4b777b732c9b7d274b6c7830845", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/metadata.json": "db7ad368394ccbfdeff6a16e3423c300d51305b1f95ff5c3936df91738a8cc35", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/references/sources.md": "22afe4f4d77f441096cc657d55d763473bfcbea8fb531c8e493fe49ab84955f7", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "dcp-async-save-performance", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json index 92fa7f4f..d6a2cfef 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", "src/inferrsi/data/skill_library/methods/dense-performance-evidence/metadata.json", @@ -39,7 +39,7 @@ "source_files": { "src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md": "53cc1867a13f54d1006d50517dea8848869ca50df3f0cd610b2424cc8d18c933", "src/inferrsi/data/skill_library/methods/dense-performance-evidence/metadata.json": "a0d1e3b17140295510a764045d1b222e19be3a3406e6d1e7dddaad49ff474490", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "dense-performance-evidence", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json index c1297aca..65f83785 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/metadata.json", @@ -67,7 +67,7 @@ "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/papers-20261015/references/loongserve-readset.md": "f1a383e7bdbbd5a5a472d7f6e1292c8a17d4910ff736ca5a6aa422e1bee74f8c", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/papers-20261015/references/orca-readset.md": "a497ef23b7e60c0fbc15d95b7e07cd20547cfe56f37c24dfe6ed70d79ef7a3cf", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/source-notes.md": "84033fd514773f10c0bddd9914fabb980497ba2b308f226a922c3e1888413827", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "diagnose-vllm-admission-pressure", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json index 3150a889..af3b1d07 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/metadata.json", @@ -46,7 +46,7 @@ "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/ownership.md": "40688cc44183027efbf2fca8d3548c299cdf2e33fef54f76ab3549353eb9bd1b", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/source-map.md": "10562a75683bd9bd07ec2e37a1cbd0f93f2534d6f85b55a566adb2d97485215f", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/validation.md": "5a0b854b87d091d7d505b0bdd5c03330052507a851ab6edf35b93a6675f2d4f7", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "diffusers-invocation-state", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json index cbcd7bd9..2fe13079 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:draft-acceptance-issue", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md": "ce983acfb7d7d3272775e7cf00c92e4ddadd97511b602575a76e5ab7ade01b56" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json index c7f36401..ec05b2f4 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md": "82d0099d3c33706f46c657d4fa7f76d3d486e019b36760d1de001921328a60cc", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/metadata.json": "37379a4d4a058ca46da2b20a920dc01be9ec11e557c32b2332702ec76027f4b5", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/references/source-notes.md": "ea416831fd7d0874e06d0a76fb0c7196df53072b717673a0cdf635db6bfd917b", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "evaluate-elastic-serving-placement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json index eb11dbe8..ebe2ea78 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/metadata.json", @@ -48,7 +48,7 @@ "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/generation-batch.md": "f16d3c57d45e63bcaffd3871aa41c76972ee11f7dbf1e12b45d9b170303cad9b", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/source-map.md": "91d26181f246307f2113f94b12ac9587d689b654dcd216e9f14b11cf5ebb650c", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/validation.md": "73b5dd347017baba519ecc85415aead9993c1751d116b9ba4f07689f58c5f783", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "generation-cache-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json index b9c9c8fe..d85cc1f9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json @@ -27,8 +27,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/metadata.json", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-LICENSE.md": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-native-offload-readset.json": "cc6c2011be746002ba3ff96ccefab1809863748ddd17eb102b75e7b0e134fe55", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-native-offload.md": "6c2a72b5ba3708a01d229e0576570837a617e6a42dbb0b5312a26a65a6c31542", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "host-memory-management", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json index 413037ff..5a790ebe 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md": "36ef88826a32ac3147b869001004ded17a8d5a491e25bfe105005ba39ea9d1eb", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/metadata.json": "ae71c389dfdb1a19d267feecb4c6f1fbb4c9afad501ff6d8fab7e38b29bcc37a", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/references/deepinfer-zero-overhead-scheduling.md": "f452bf40132c9195d739f1c86b3aa18857138c7ed0f1861af5853d93b9955924", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "host-overhead-optimization", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json index 7ab9fa93..4819c6e1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json @@ -30,8 +30,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/metadata.json", @@ -52,7 +52,7 @@ "src/inferrsi/data/skill_library/methods/inference-benchmark-design/metadata.json": "18310402a8ade03fd48ac687f79ba9d447871e90337de84c0e1bc15c0b827306", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/references/benchmark-commands.md": "0898424e0bff3a6246e1eeeda6abd6c5bd974c047fe32f3bbd5ab9d31ce17cd3", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/references/task-benchmark-selection.md": "0d4bb080a754e26846e81680023db0dff5e6a4c96be4327c411c3b72ac4ef8e2", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "inference-benchmark-design", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json index e070e2f0..df619d6d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/admission-drain-occupancy.json", @@ -55,7 +55,7 @@ "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/qwen-b300-rejected-directions.json": "146ea1564a46ed03092c7dc5796b318fc05b04b1821105ee00eb7fa7fa1333e2", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/qwen-b300-rejected-directions.md": "cce2930f544a0f78f21797fba4d8ded298e4a81f76c34d7977b0e31d361bc738", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/metadata.json": "fb55067fb45970319787068a3206110641cceaf0ccbabd706be6d0b3d2afc2ed", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "inference-optimization-casebook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json index 46f71cc8..9e0792d2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json @@ -27,8 +27,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/metadata.json", @@ -47,7 +47,7 @@ "src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md": "01fb1712d7eb988c5e412f02340d2e48b4f8564fcf4ab232dc5897869d0d50a0", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/metadata.json": "0189d184337662056fc6952c7beffc1bf6154c4fa173ae3e3e463bd22d70f36c", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/references/akg-affine-tail-guards.md": "113deb2db10b171db3425bb3f1792bee763706b794c8cc2e222b4cc0d0114118", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "kernel-writing-guide", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json index 22dd509c..e464f0f1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md": "e4b78f368d70c8abb74a935acb910414015f1aeec1b50f7a295e836822ec4b27", "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/metadata.json": "c221189b8d85fac3bd41ef1c7cd560f1aebc8cfa0381c182d1d571a7169be829", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "kv-tier-management", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json index 96bdafa5..335277ea 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/metadata.json", @@ -46,7 +46,7 @@ "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/execution-lifetime.md": "c4bc41e08aca68f661325f61e6f0db1760a079dc362f295c847bdc374fee3bf6", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/source-map.md": "798b9cb89ed6b885eb47464ca9f137d2802a54571b9327e631d7742d3e5abd5d", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/validation.md": "ebfc00bf7d6ab0a1dc415953ae84d56ccdc713d5614aff85e433c4a843793bff", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "lazy-evaluation-stream-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json new file mode 100644 index 00000000..a11e2639 --- /dev/null +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json @@ -0,0 +1,217 @@ +{ + "schema_version": 1, + "id": "inferrsi.common.skills.lily", + "title": "lily", + "repo": "inferrsi", + "tier": "contribution", + "backend": "common", + "component": "skills", + "scenario": "skills.discovery", + "status": "imported", + "summary": "Investigate Lily's exact Qwen3.6-35B-A3B MLX-affine-Q4 contract, Metal state and kernels, strict greedy text API, token-prefix session cache and source-qualified validation or benchmark plans.", + "tags": [ + "lily", + "rust", + "metal", + "apple-silicon", + "mlx-affine-q4", + "session-prefix", + "numerical-validation", + "benchmark-provenance" + ], + "origin": [ + "external" + ], + "sources": [ + { + "type": "git", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/lily/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", + "paths": [ + "src/inferrsi/data/skill_library/repositories/lily/LICENSE", + "src/inferrsi/data/skill_library/repositories/lily/NOTICE.md", + "src/inferrsi/data/skill_library/repositories/lily/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/metadata.json", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json", + "src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py", + "src/inferrsi/data/skill_library/skill-index.json" + ], + "content_sha256": "db815674d5d36964902041d310d3df844d00ab2e6bef0ce4b72ed2696ab2b9aa" + } + ], + "index_type": "packaged-skill", + "skill_documents": { + "original": "data/skill_library/repositories/lily/SKILL.md" + }, + "checkout_ref": "checkout:lily", + "source_files": { + "src/inferrsi/data/skill_library/repositories/lily/LICENSE": "b9e2b50a48a09fb39dafa71ab1a11a6e87389addda17faa99d55f5f74a0001ac", + "src/inferrsi/data/skill_library/repositories/lily/NOTICE.md": "7a01e666044fb8aca1fd88c636bca43bcc95b8b1fecbe101dce4c7c80fbb5759", + "src/inferrsi/data/skill_library/repositories/lily/SKILL.md": "db815674d5d36964902041d310d3df844d00ab2e6bef0ce4b72ed2696ab2b9aa", + "src/inferrsi/data/skill_library/repositories/lily/metadata.json": "6d9d54e84f957881cc26894eb82ae666f106cfc6c505924f9a6fb6b35eab457f", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md": "96182f6cb3666f89adf1aed6e216c0a84ce3a04a0685a4257e286100ba8ee367", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json": "f2f3becb51056e03081c7c4140e19572a6318c3d63015884df56eb49d38a00fc", + "src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json": "4595559c11611c855be150919fca3eeb89e7f96c7a8dd133b9f79a5cd8e05e62", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md": "dc800f07fa0e82213483c7b848dea95d609386296006bfec7a34cbb194a83de6", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md": "d5a862303d646ebbaf745818caed8f96c7323cd442cb6d6e2aae00b0361080a1", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md": "b32fab02b561c3ab4e683abdfa80cd4a8f929c514147709febaa6b6d1df65909", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py": "5961bb6f31ceca43473683127b37faee268234040a013ae49bbb4898eacb6f04", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md": "0231b50b9bebb68d0fc5f2ce19aa7c6e5ffd498d8eef4cc00d39e82908cbbe91", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md": "01607534ce1f09fb046255c78f8c1c436aac61874b93b65a9d62f3eb480496c2", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md": "6934779f67b878bf7cdb5f2cbe461f6716c243c662a29272c6db37f64cb317c7", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py": "59534f58d46ad438c7bf88886a9b05a8716c922d817f2d9c58ff1b71ae50ee85", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md": "7e062ff9af76125ef08c98b4465e0439c66e9e237f0c39ea0285005cc5496cfb", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md": "7262bb077c24f2f7549d450473ec7944829940d09cca89db9c12f37ac90d5db0", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md": "6e2f36d2f7ab9eae665d87a676e34c0ebd2f46f3df6fa5f2e589a306749a87b5", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py": "d6b00c9f0b38c7fb0a0e52e396993a832542ea0aa6e2456026fabc0c39a4d33a", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" + }, + "skill_metadata": { + "name": "lily", + "description": "Investigate Lily's exact Qwen3.6-35B-A3B MLX-affine-Q4 contract, Metal state and kernels, strict greedy text API, token-prefix session cache and source-qualified validation or benchmark plans.", + "license": "NO_LICENSE", + "disable-model-invocation": true, + "metadata": { + "disco-role": "operating" + }, + "schema_version": 1, + "kind": "skill", + "origin": [ + "external" + ], + "status": "candidate", + "empirical_validation": "not_run", + "tags": [ + "lily", + "rust", + "metal", + "apple-silicon", + "mlx-affine-q4", + "session-prefix", + "numerical-validation", + "benchmark-provenance" + ], + "sources": [ + { + "type": "git", + "url": "https://github.com/perplexityai/pplx-garden", + "commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "paths": [ + "lily/README.md", + "lily/Cargo.toml", + "lily/Cargo.lock", + "lily/rust-toolchain.toml", + "lily/CONTRIBUTING.md", + "lily/LICENSE", + "lily/NOTICE", + "lily/src/lib.rs", + "lily/src/config.rs", + "lily/src/weights.rs", + "lily/src/safetensors.rs", + "lily/src/tensor.rs", + "lily/src/metal.rs", + "lily/src/model.rs", + "lily/src/serve.rs", + "lily/src/serve/session.rs", + "lily/src/chat.rs", + "lily/src/generate.rs", + "lily/src/tokenizer.rs", + "lily/src/kernels/attention.rs", + "lily/src/kernels/gdn.rs", + "lily/src/kernels/gemm.rs", + "lily/src/kernels/skinny.rs", + "lily/src/bin/lily-bench.rs", + "lily/tests/support/cpu_ref.rs", + "lily/tests/test_shader_compile.rs", + "lily/tests/test_e2e_35b.rs", + "lily/tests/test_tokenizer.rs", + "lily/tests/unit/weights.rs", + "lily/tests/unit/serve.rs", + "lily/tests/unit/serve/session.rs", + "lily/tests/unit/generate.rs", + "lily/tests/unit/kernels/gemm.rs", + "lily/tests/unit/kernels/gdn.rs", + "lily/tests/unit/kernels/skinny.rs", + "lily/docs/2026-09-01-performance-mlx-0.31.2.md", + "lily/docs/2026-09-02-performance-mlx-0.32.2.md", + "lily/benchmarks/run_matrix.py", + "lily/benchmarks/bench_mlx.py", + "lily/benchmarks/requirements.txt" + ], + "license": "Apache-2.0", + "scope": "Lily subtree only; independent lily/LICENSE and NOTICE retained.", + "readset": "references/source-identity.json" + }, + { + "type": "git", + "url": "https://github.com/VectorSpaceLab/AREX-Skill", + "commit": "ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6", + "paths": [ + "cli/packages/coding-agent/src/disco/skills/create-repo-skill", + "cli/packages/coding-agent/src/disco/skills/prepare-repo-skill-env", + "cli/packages/coding-agent/src/disco/skills/workflow-authoring", + "cli/packages/coding-agent/src/disco/skills/verify-repo-skill" + ], + "scope": "Portable native Rust/Metal adaptation executed by a compatible agent; not a DisCo CLI/model run." + } + ], + "construction": { + "anchor_kind": "source", + "distillation_form": "repository-operating-graph", + "strategy": "arex-portable-meta-skills", + "status": "partial-candidate", + "native_import": "not-run", + "method": "User-approved native Rust/Metal and partial drafting adaptation; stable-ID lanes, integrated source graph and assertion/helper verification. Missing compiler/backend/checkpoint remains explicit." + }, + "applicability": { + "scope": "Exact Lily source/checkpoint/layout/API/cache/qualification investigation; common catalog classification is not CPU inference or cross-device support." + }, + "limitations": [ + "Cargo/Rust1.92, supported M5/macOS26/Metal and model resources are unavailable; native evidence remains BLOCKED_REQUIRED_BACKEND.", + "Offline Python helper checks are not Rust serde/loader/tokenizer, native kernel/state/cache, model quality, service or performance validation.", + "Current benchmark source and later report have distinct package/harness identities; negative long-context prefill observations remain author-reported.", + "Only selected source bodies are mined; complete kernel/format/platform/failure coverage and behavioral skill efficacy remain unverified.", + "NO_LICENSE is the actual unauthenticated GitHub CLI fallback, not a legal conclusion; lily Apache-2.0 LICENSE and NOTICE are independently retained." + ], + "provenance_readsets": [ + "references/repo-provenance.md", + "references/source-identity.json" + ], + "consumption_mode": "packaged" + }, + "applicability": { + "scope": "Exact Lily source/checkpoint/layout/API/cache/qualification investigation; common catalog classification is not CPU inference or cross-device support." + }, + "recommendations": [ + "Read the pinned SKILL.md and its prerequisites before choosing this procedure.", + "Read the packaged references and owner-local cases alongside the procedure." + ], + "limitations": [ + "This generated abstract points to the complete packaged skill; external evidence and upstream repositories remain source links.", + "The imported status describes this index, not the original skill; its declared status is candidate.", + "Reading or indexing does not authorize execution, validate efficacy, promote a candidate or grant a license.", + "The backend categorizes the procedure's hardware dependency; it does not certify compatibility, and skills.discovery is a discovery scenario.", + "Cargo/Rust1.92, supported M5/macOS26/Metal and model resources are unavailable; native evidence remains BLOCKED_REQUIRED_BACKEND.", + "Offline Python helper checks are not Rust serde/loader/tokenizer, native kernel/state/cache, model quality, service or performance validation.", + "Current benchmark source and later report have distinct package/harness identities; negative long-context prefill observations remain author-reported.", + "Only selected source bodies are mined; complete kernel/format/platform/failure coverage and behavioral skill efficacy remain unverified.", + "NO_LICENSE is the actual unauthenticated GitHub CLI fallback, not a legal conclusion; lily Apache-2.0 LICENSE and NOTICE are independently retained." + ], + "verification": { + "locally_verified": false, + "evidence_level": "guidance" + } +} diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json index 5a104514..fb0c9144 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", @@ -54,7 +54,7 @@ }, "checkout_ref": "checkout:npu-skill-factory", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md": "74cd863df2e80dc2bda1713d24207809173a3116f30325e3487e1e3517cfec1e", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/metadata.json": "12fc9272bd5fbf02dd9b897d8ca40984b72ae54f20492ace5304711bbc4d71c3", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/references/papers-20261015/COMPARISON.md": "38587678a96581f5c2dc697d982127343565504bffa191352811dffcc165aa23", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json index e53af73a..e10eef85 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", "src/inferrsi/data/skill_library/methods/optimization-search-policy/metadata.json", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/knowledge/adaptation-interfaces.md": "5e761957cb5ecd93926e6ffc13deee7c830c6e8f0ee3c3846e9dd3b50dc74446", "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/references/source-notes.md": "54d83c3713045d59a48821bcf93598374ba4a630e3891ad39498f919317c4fb8", "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/updates/optimization-search-policy.md": "d3db44fa9a6831b86a02c638b323ed943e69fe256866213f10d68c72d762879e", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "optimization-search-policy", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json index 080d9f9f..f5b19da4 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md": "2003492e4d89fde0443b180d74933e764bd1979435e109c8d26e20eb8f6e5053", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/metadata.json": "ec02995c075f0a540921f57b4846f2cafe334eb90f44389f17c3c50457c3e9c5", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/references/llama-numa-thread-readset.md": "748b254b3b043a5ddb0f480eb4a566854d27eedd7b111499863e9bf0a5a6951e", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "os-process-placement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json index 51d4d4a3..eb5b3e50 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/metadata.json", @@ -78,7 +78,7 @@ "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/references/roofline-contract.md": "419ec4bcaec45ac579a133bce083d4f48779f26e664d7a86f720fa65f343b1d1", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/references/roofline-example.json": "597cd3205df043cff3ae9d15924c77934e8d8eb300c00c4840f6bb2921f90faf", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/scripts/roofline.py": "524de48a6764401695fe1444f1fa3d38f363069b0cd2fba4715a86ca4b28a5d4", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "performance-ceiling-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json index 0898c3cb..f6e2b395 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", "src/inferrsi/data/skill_library/methods/plan-activation-residency/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md": "542d8a1e6963f5019986e1fbd79d3a247a045a51487c09313026087ac457c15e", "src/inferrsi/data/skill_library/methods/plan-activation-residency/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/plan-activation-residency/references/source-notes.md": "5ff52655cfd06fcf970ed2a7d4d4fe1c31115b102af2d41497de0c74848ed2b3", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "plan-activation-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json index a1a7eb39..d7420c34 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md": "7e20d3390f2501263e5e298e026c47cac16c234f2397833131e15ae5d34c0b97", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/metadata.json": "d0e4d6950250e4cec43d82e23324c9301a925d4c22be30b4d2713d790cb6504b", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/references/capability-presence-audit.md": "c21eb4a6aabe811a49a6540a34c54dbcfdcf7efae3052a79b54034c7838026a5", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "repository-evolution-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json index af6d0ea3..90a919f3 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:rsi-evidence", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1", + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3", "src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md": "a55610874b658b86a39a1a049efb4e4eab0140f6579ed74dd7718a4ca8cedaca" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json index 8b46a9de..c7e21b09 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/metadata.json", @@ -39,7 +39,7 @@ "source_files": { "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md": "9cd37f21fe0d862069e4798edca8a04d59f8b840e55d521901594a63dddd9ba3", "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/metadata.json": "92b36338b9257e2e41b95e4370694d7de52ed84bc7971056b3bfced07b0993d8", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "skill-evolution-playbook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json index 076a3c9f..83293fa1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md": "63b883c10a8d3e7d918abfc7175b72e2b401ff1e02697f94b8382ec1c8f369b7", "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/metadata.json": "0a41c7b00978332b54ee1e4a7c1ade88ecde3e961128f24d1b4f7708caff5ff5", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "storage-io-measurement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json index ffe45aa8..78f7a83a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", "src/inferrsi/data/skill_library/methods/training-input-pipeline/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md": "64bd2c6b795d966045d1d3cca55976d3d49b08b06df7c7e06a70c2824cf55b7e", "src/inferrsi/data/skill_library/methods/training-input-pipeline/metadata.json": "80659099fce6a6ec05e9084b75452c877a5812e30f60a78f31ef8c7efcdc1bac", "src/inferrsi/data/skill_library/methods/training-input-pipeline/references/sources.md": "60e0f3e88655d8e1d5eb4797f39ca4370deda01614f265b8d2ea4559d8ac020f", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "training-input-pipeline", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json index 8d02f9a5..fadbb091 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", "src/inferrsi/data/skill_library/methods/training-resource-budget/metadata.json", @@ -57,7 +57,7 @@ "src/inferrsi/data/skill_library/methods/training-resource-budget/references/papers-20261015/references/source-readset.md": "2a5c166767f56fa47e7eba7386f1f36da8cb73702e5b5bbe14d6a456ca9ebfae", "src/inferrsi/data/skill_library/methods/training-resource-budget/references/sources.md": "6d248f58af8b350fc66c22898988d6f451ac60d03bcd805cd6e84df5e55174ac", "src/inferrsi/data/skill_library/methods/training-resource-budget/references/stas-decision-notes.md": "f1a993e6c4ca9a035a2effcaf5500081f227b0cc56cc885a6b22fda0041fc744", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "training-resource-budget", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json index e7910bf4..16838aca 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json @@ -26,8 +26,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/metadata.json", @@ -48,7 +48,7 @@ "src/inferrsi/data/skill_library/methods/weight-loading-optimization/metadata.json": "798cbff6f10b7c24b188080ebf233b188b0e98ef2c6fdb5e00e1fe3eff727c0f", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/references/fastsafetensors-transfer-readset.md": "5a39f14b102b0cee304541e011aa31e44e6b13527d1bee9987c3f3b66c064d3d", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/references/llama-loading-readset.md": "6c640f28ee3f0253a17b81461c865cb9f947367002cb75bf72550c4572d02e97", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "weight-loading-optimization", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json index 7dfe3e17..3e0dcfff 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/metadata.json": "4e6100dfb9fc7bc00b19915f4fd38ad509704f2a609c658adf4d632d4e05b6c1", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/references/afd-plugin-LICENSE.md": "0e8566ea362276878e1f38f97da49964dbea301c15d4aa9d727f97a4c39fd943", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/references/source-notes.md": "5073d87450cb60d1b245308dff8807e73749c07de976d50f2fa26694fad81a72", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "audit-afd-p2p-exchanges", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json index 496d7c54..044c741e 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/metadata.json", @@ -52,7 +52,7 @@ "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/papers-20261015/cases/partitioning-after-fusion.md": "4d4cabe0991eab554dcfbd4fa9c8199e61fa4767709b0c4cd646e2588bb398a2", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/papers-20261015/knowledge/attention-cost-model-boundaries.md": "5ed8f888443e38ccb72545b6025447aab7b92936f78c151fed680e582126239b", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/sources.md": "53436e0de4e6dda2d29426591bf61f8526378cdc6f9ec7967b88b1bcd4c61e6f", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "diagnose-attention-bottlenecks", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json index ccf4f80e..1c26d9d4 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md": "326e566fbe30d3ba04e4b50c3e87aad9df037f0ac4ad6fe129165ae97dc5f91d", "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/metadata.json": "76e34c1c64aba473a9e126b032a776417caa0f913f6ac3cf4dba3a5d123b1ee0", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "host-overhead-profiling", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json index 06c5752f..7fc1d9b1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json @@ -36,8 +36,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/f321699b42a490276ffa4ea52350591683b575cc/src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", - "commit": "f321699b42a490276ffa4ea52350591683b575cc", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/f7bbec41f1ea5574a5953171d73067ac6d0ae9ec/src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", + "commit": "f7bbec41f1ea5574a5953171d73067ac6d0ae9ec", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/metadata.json", @@ -72,7 +72,7 @@ "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/source-inventory.json": "1dc09c895c970a0c9708158bcc6dd65cdb736274fd2c35d44542c70407d3849d", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/sources.md": "6b74b9e774f2a80db0860510d9e6940d36284430f29c1e124f115a9eaf25833d", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/synchronization.md": "4322f6b3c0e4368bf8c192b4ec752529767f50d19c0c38dad8fdf9cd781e41d9", - "src/inferrsi/data/skill_library/skill-index.json": "8ce35e18f7629260d67a95617b9918eecff73ed8d9370dd3d4595c725ada9aa1" + "src/inferrsi/data/skill_library/skill-index.json": "224fa4bec0da83ed46546783335aabedf2b44e5fd9d1e1658c045dc1f6f491d3" }, "skill_metadata": { "name": "reason-hopper-kernels", From e6ec61c76dc7b75b7756b008636fe1137bda2abc Mon Sep 17 00:00:00 2001 From: WeiQing Chen <40507679+david6666666@users.noreply.github.com> Date: Tue, 27 Oct 2026 05:28:10 -0700 Subject: [PATCH 3/3] knowledge: regenerate cumulative Lily projection Signed-off-by: WeiQing Chen <530634352@qq.com> Agent-assisted-by: Codex / approved_arex_author (gpt-6.1-sol, xhigh) --- .../repo_packs/inferrsi/knowledge/README.md | 7 +- .../ascend-aclgraph-capture-replay.json | 6 +- .../ascend/skills/ascend-device-health.json | 6 +- .../skills/ascend-distributed-parallel.json | 6 +- .../ascend/skills/ascend-graph-mode.json | 6 +- .../skills/ascend-model-adaptation.json | 6 +- .../skills/ascend-operator-profiling.json | 6 +- .../ascend/skills/ascend-operator-tuning.json | 6 +- .../skills/ascend-optimization-casebook.json | 6 +- .../skills/ascend-performance-analysis.json | 6 +- .../ascend/skills/ascendc-tiling-design.json | 6 +- .../skills/cann-attribution-overlap.json | 6 +- .../torchnpu-device-memory-lifecycle.json | 6 +- ...torchnpu-pinned-host-memory-lifecycle.json | 6 +- .../skills/assess-serving-preemption.json | 6 +- .../assess-split-backward-schedule.json | 6 +- .../skills/audit-h3-runtime-residency.json | 6 +- .../skills/audit-llama-runtime-state.json | 6 +- .../common/skills/audit-sd-cpp-residency.json | 6 +- .../audit-sglang-diffusion-lifetimes.json | 6 +- .../skills/audit-vllm-kv-lifetimes.json | 6 +- .../bound-windowed-attention-replay.json | 6 +- .../budget-speculative-verification.json | 6 +- .../skills/calibrate-serving-simulation.json | 6 +- .../skills/cgroup-resource-controls.json | 6 +- .../checkpoint-recovery-consistency.json | 6 +- .../skills/choose-parallel-training-plan.json | 6 +- .../skills/cite-check-downstream-pr.json | 6 +- .../common/skills/claim-contract.json | 6 +- .../knowledge/common/skills/comfy-ui.json | 6 +- .../common/skills/competitor-scan.json | 6 +- .../skills/dcp-async-save-performance.json | 6 +- .../skills/dense-performance-evidence.json | 6 +- .../diagnose-vllm-admission-pressure.json | 6 +- .../skills/diffusers-invocation-state.json | 6 +- .../common/skills/draft-acceptance-issue.json | 6 +- .../knowledge/common/skills/dwarfstar.json | 6 +- .../evaluate-elastic-serving-placement.json | 6 +- .../skills/generation-cache-lifecycle.json | 6 +- .../common/skills/host-memory-management.json | 6 +- .../skills/host-overhead-optimization.json | 6 +- .../skills/inference-benchmark-design.json | 6 +- .../inference-optimization-casebook.json | 6 +- .../common/skills/kernel-writing-guide.json | 6 +- .../common/skills/kv-tier-management.json | 6 +- .../lazy-evaluation-stream-lifetimes.json | 6 +- .../knowledge/common/skills/lily.json | 217 ++++++++++++++++++ .../common/skills/npu-skill-factory.json | 6 +- .../skills/optimization-search-policy.json | 6 +- .../common/skills/os-process-placement.json | 6 +- .../skills/performance-ceiling-analysis.json | 6 +- .../skills/plan-activation-residency.json | 6 +- .../skills/repository-evolution-analysis.json | 6 +- .../knowledge/common/skills/rsi-evidence.json | 6 +- .../skills/skill-evolution-playbook.json | 6 +- .../knowledge/common/skills/splash.json | 6 +- .../common/skills/storage-io-measurement.json | 6 +- .../skills/training-input-pipeline.json | 6 +- .../skills/training-resource-budget.json | 6 +- .../skills/weight-loading-optimization.json | 6 +- .../cuda/skills/audit-afd-p2p-exchanges.json | 6 +- .../diagnose-attention-bottlenecks.json | 6 +- .../cuda/skills/host-overhead-profiling.json | 6 +- .../cuda/skills/reason-hopper-kernels.json | 6 +- 64 files changed, 407 insertions(+), 189 deletions(-) create mode 100644 src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md b/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md index 94356e43..162ef872 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/README.md @@ -1,6 +1,6 @@ # InferRSI skill discovery index -Generated abstracts for all 62 registered skills in `data/skill_library/`. +Generated abstracts for all 63 registered skills in `data/skill_library/`. Their complete procedures, references and cases ship in the same package. `skill-index.json` maps stable skill IDs to categorized directories. The reference and searchspace matrices @@ -15,7 +15,7 @@ These are knowledge abstracts (`--kind knowledge`), with namespaced package IDs distinct from explicitly selected `checkout_ref` skills. Ascend/CUDA procedures use their corresponding backend; shared methods use `common`. -Source snapshot: [99fca181e71fab22c09bb1967335d0653852eff3](https://github.com/InferMatrixLab/InferRSI/tree/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library). +Source snapshot: [7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c](https://github.com/InferMatrixLab/InferRSI/tree/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library). ```bash inferrsi knowledge search 'profiling' --repo-type inferrsi --limit 50 @@ -29,7 +29,7 @@ contain the current input paths and bytes (Git checkout filters are respected). ```bash python tools/build_skill_index.py --source-revision -python tools/build_skill_index.py --source-revision 99fca181e71fab22c09bb1967335d0653852eff3 --check +python tools/build_skill_index.py --source-revision 7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c --check ``` `--check` detects missing, stale and unexpected generated records without writing. @@ -83,6 +83,7 @@ References and cases ship with their owning skill, not as duplicate knowledge ab | [kernel-writing-guide](common/skills/kernel-writing-guide.json) | common | candidate | | [kv-tier-management](common/skills/kv-tier-management.json) | common | candidate | | [lazy-evaluation-stream-lifetimes](common/skills/lazy-evaluation-stream-lifetimes.json) | common | candidate | +| [lily](common/skills/lily.json) | common | candidate | | [npu-skill-factory](common/skills/npu-skill-factory.json) | common | candidate | | [optimization-search-policy](common/skills/optimization-search-policy.json) | common | candidate | | [os-process-placement](common/skills/os-process-placement.json) | common | candidate | diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json index ffadf29f..c1204c89 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-aclgraph-capture-replay.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/SKILL.md": "d494fc7e539cbb7388189bd7b3f04bb5c4983fdd7a82484348aad1cee7f741f2", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/metadata.json": "71c68431663ed2336cccc985a354adab6b13b4cfd6123a18a5d8d53c28268509", "src/inferrsi/data/skill_library/hardware/ascend/ascend-aclgraph-capture-replay/references/source-notes.md": "6ffbfb68cc7e04923b4fbca2a73a7555b7c3b45a6f40819bb5f3213ef05cf88d", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-aclgraph-capture-replay", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json index 80eaf11f..7f8b9130 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-device-health.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/metadata.json", @@ -41,7 +41,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/SKILL.md": "03829039860ece35519f2e4c339a48b5014ec25e07a2c150a3efb6a3a4e35b4a", "src/inferrsi/data/skill_library/hardware/ascend/ascend-device-health/metadata.json": "80d80c15514919826fa72d6f6cf26b76db8accd85d21187fc239232ca454e7bf", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-device-health", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json index 5a900380..9bf82b4c 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-distributed-parallel.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/SKILL.md": "4ce9dcadd1ae3c7a8cc633336760d0a3c382f354f1b7028e3a10d28fa0d0c9fa", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/metadata.json": "b6cb25879b1bca5f5af08b48776f2e664cf5dcd11a0efb1c4f56879e2afa9006", "src/inferrsi/data/skill_library/hardware/ascend/ascend-distributed-parallel/references/awesome-ascend-communication-tests.md": "0cb27a3d24409171bb414d7ebf0c49ad62be5f46482f29624695496ba9eb3e63", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-distributed-parallel", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json index 53431ca2..19e06f7d 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-graph-mode.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/SKILL.md": "9203cc5a14a1d65df5fbf275734b93be023e06527459b2f79864f28a338cb44a", "src/inferrsi/data/skill_library/hardware/ascend/ascend-graph-mode/metadata.json": "72b41e7845915d34b09219624e82976386f3125816293540c2c38143fe6b477f", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-graph-mode", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json index e5db1ceb..bb0ea984 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md": "8fdf46fb2743b67a66bc069d22a45305a222debfb606777bc451b4b8f31d9cc6", "src/inferrsi/data/skill_library/hardware/ascend/ascend-model-adaptation/metadata.json": "be681a3206e5e183b4c9670c9d7784bcffce18c891449e5b15f94ca5f1324b9a", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-model-adaptation", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json index 218c0080..b208a2f4 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-profiling.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/metadata.json", @@ -41,7 +41,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/SKILL.md": "401981cf7828edcab0c9ea882f7ecd83badfa3c2a95006e912cf99d67b3d6a12", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-profiling/metadata.json": "efd37bb23acb500dad4ec8ebe7ddfe5c3f196374052825f923ac85da8445f06b", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-operator-profiling", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json index e33d0a7a..4fceda2a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-operator-tuning.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/SKILL.md": "38b151bc6b4e9734c6fa41efb7a30343559400c0c75bbdd26bd8a968b8ea4592", "src/inferrsi/data/skill_library/hardware/ascend/ascend-operator-tuning/metadata.json": "04d2002fc8a0a7becf86b0b73daaf2da8716ab466d7f988da43d41a10f26680e", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-operator-tuning", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json index 95e3908a..426090e2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-optimization-casebook.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/SKILL.md": "647f5e9a288f2c4e1617ba53df59d9d827df749eb4fe86182d21a9c41175caf8", "src/inferrsi/data/skill_library/hardware/ascend/ascend-optimization-casebook/metadata.json": "f425f7c1abbd616387273e8932c6bd02f4b1da012f099286ad4171e0f6037b22", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-optimization-casebook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json index e8acff5d..03b5358a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-performance-analysis.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/metadata.json": "9e705625c8308013c287576b0247da6f6116d817a4a535cbecff80abd6ea35ee", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/references/cannbot-CANN-2.0-LICENSE.md": "89b1c114df62cfd183004f38d18d07f186436c3b37203dd69c3e84becf9d2282", "src/inferrsi/data/skill_library/hardware/ascend/ascend-performance-analysis/references/cannbot-stage-evidence.md": "f56e4125325c9c1b9235a1d64fd732861c7686444492422daff44ba8dd648be4", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascend-performance-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json index fc282d1f..1f5e0b10 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/ascendc-tiling-design.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/SKILL.md": "93aa1b775ced304cebfe6c4dec0503ddb2260ecb3cb01edc17ce329446c5ce2b", "src/inferrsi/data/skill_library/hardware/ascend/ascendc-tiling-design/metadata.json": "f6d94f104cb70969024b2f4542078a240e200712c66279eca8b94f60bee1dd71", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "ascendc-tiling-design", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json index f8e41324..d6ea7aea 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/cann-attribution-overlap.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/SKILL.md": "0e6f094dc554abea12e07def50f20b233b47127779a8aefad595b4ab1efd24c2", "src/inferrsi/data/skill_library/hardware/ascend/cann-attribution-overlap/metadata.json": "acccc8eb86de0df6caf78a9b3c6db76a2a686adc4a5ba0029a4d62d50ff9a8f8", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "cann-attribution-overlap", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json index 2638cb14..e8aecc18 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-device-memory-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/SKILL.md": "8428df7157af024fa17cfe0b3818ed54bd9f468306dda46eb8d4f0edf4f3f230", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/metadata.json": "c650dce88c07b636d68e063dbda4d319f6f7f3ecbcdd5e47f393cbfc3af7c71d", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-device-memory-lifecycle/references/source-notes.md": "80cba4d3a884e7ee2618326cf74b9f9c3a34e4d9cf443707f6bbe673f2d5ba65", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "torchnpu-device-memory-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json index 40318107..b9ed42f5 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/ascend/skills/torchnpu-pinned-host-memory-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/SKILL.md": "23e93ea7c98f99743509fdc04139d78ed2e7123c63e80b366c6beaba7eb70d0d", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/metadata.json": "97836a38465106d816a9ace894a7b277d6d330f9accade8f8493ce6f0fb57ef9", "src/inferrsi/data/skill_library/hardware/ascend/torchnpu-pinned-host-memory-lifecycle/references/source-notes.md": "435193590b4a2ba32e2e4c6fa9d7e8f889528d412cbbb48e35ec5433f7dab384", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "torchnpu-pinned-host-memory-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json index c07ea999..a36664a6 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-serving-preemption.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/assess-serving-preemption/SKILL.md": "0a5f48d9352c5bf460775ef47f9136829978811f4a16e84983e299782cae305d", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/metadata.json": "77ce5ba16245cbd80d46d0abdf80aaf26fc0924fa2d2a5624ff430de68a1daf0", "src/inferrsi/data/skill_library/methods/assess-serving-preemption/references/source-notes.md": "f29fcecfba0490008a354c11b42403983fe165e56ff907ad61cc6040d2b6407f", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "assess-serving-preemption", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json index 98a4e169..ef8ecec2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/assess-split-backward-schedule.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/SKILL.md": "1e64f28ea71672fb53c56f6108b87864738c6d03d6dcd32eedaef9e0625e96e3", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/assess-split-backward-schedule/references/source-notes.md": "61b1609f71c37b61d136b8c4d39f793de87cffb1cf31c8ec737a1c3fa6fb1b4e", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "assess-split-backward-schedule", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json index 87738f21..1b6fe114 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-h3-runtime-residency.json @@ -30,8 +30,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/LICENSE", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/SKILL.md", @@ -66,7 +66,7 @@ "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/source-identity.json": "730f8dd23648a3f8f47b9726cc613d893a79d1817d515eec609a9b06d8a9ff90", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/source-notes.md": "7304bf9369efc157dc7aa40686dd828cc14db45c49442e908b3d3cc4b329eb86", "src/inferrsi/data/skill_library/repositories/h3-c/audit-h3-runtime-residency/references/validation.md": "0754873a758e048480938314894e25b504ae0c269549312e7f8e6020d83fe294", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-h3-runtime-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json index 41f65ad4..052bcd5f 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-llama-runtime-state.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/SKILL.md": "95e81b6bc096a954fa73139ea5bc001d1efa6c99747161da62f012b494e5c013", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/metadata.json": "1d30b31dc8352fc6a8d7b8abbef8118c840e47e5b90795dae0c758bf9717278c", "src/inferrsi/data/skill_library/repositories/llama-cpp/audit-llama-runtime-state/references/source-notes.md": "3d12a401e9decb55a2f4f3b2bfa0d360ef5110f63a0469dfe285654e78054190", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-llama-runtime-state", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json index 32156630..3a978657 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sd-cpp-residency.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/LICENSE", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/SKILL.md", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/source-identity.json": "af4830370b6eddc2d176a9ae14da4ab56a90b0fe048a01a89ee051df4365d8e9", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/source-notes.md": "b67affbd7d237d82b7f51be49f1537e9820fe56ec70a71ee76809f9e599ca693", "src/inferrsi/data/skill_library/repositories/stable-diffusion-cpp/audit-sd-cpp-residency/references/validation-boundaries.md": "5dcf5fa7bf734fbe13214f57d2dfb40ff8215d9cd34e072a9e615bf103b82fc2", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-sd-cpp-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json index 72973aaa..97fdd149 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-sglang-diffusion-lifetimes.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/LICENSE", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/SKILL.md": "b0a4ba4751087126143ef86983798deb0ed00e24b6ff06bf6ef76a9df6e274f2", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/metadata.json": "6ed57dfb4f25ecb34b81f2188b055e05d172ba2581e6a3b605b814b2f733a4d6", "src/inferrsi/data/skill_library/repositories/sglang/audit-sglang-diffusion-lifetimes/references/source-notes.md": "d0fcfd1177ae2f351041c5b2abba7f5121cec133006d9e4dca8f74ddb567332d", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-sglang-diffusion-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json index 6407479c..025fab0b 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/audit-vllm-kv-lifetimes.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/SKILL.md": "313733a65cc48442b18dda1c4665139a689963a90e1032a2235bc6f40e3a8e06", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/metadata.json": "b43fc3a7ccae59c664fcdf9ff77962edcc07c2a3df8b59324db551642bd23e23", "src/inferrsi/data/skill_library/repositories/vllm/audit-vllm-kv-lifetimes/references/source-notes.md": "3665b034594fc8cc767c408002f4e16f8803369242405027c7f37ce6c9ecebe9", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-vllm-kv-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json index 5f6b36eb..4ca1a312 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/bound-windowed-attention-replay.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/SKILL.md", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/metadata.json": "014be24d0e669f4acbc0717dc323eec784026cf185186619d5a19d6d84496131", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/references/source-notes.md": "fd917bd5ac80bee9c9f4525f8e0300f6d67dc144e2a16632af42a67f3d53d098", "src/inferrsi/data/skill_library/repositories/deepinfer/bound-windowed-attention-replay/references/validation.md": "60e71e70c5519bcdf6c171eec2be2f342e8801bedd746d6005f11adc646dfaff", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "bound-windowed-attention-replay", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json index 9f5628a0..dd0c55c1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/budget-speculative-verification.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/SKILL.md", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/metadata.json": "4d68bf4c1767eaee12ade963bbd551d0e61d1bcd81a984bb02fd3aae46965919", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/references/source-notes.md": "6fa955022f16cd598f44fd6521901d1cb868b06cec545cabe2b82769a641b5d6", "src/inferrsi/data/skill_library/repositories/deepinfer/budget-speculative-verification/references/validation.md": "673d93f6700052974b340fab25b3438e0e6344960569ac9abec7d7720f662288", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "budget-speculative-verification", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json index d2bd7cb4..7612807b 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/calibrate-serving-simulation.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/SKILL.md": "ac773c6f1c110a664dfca28a3ae9129b10c07614e60ca3640dea776220e7b352", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/metadata.json": "261ce9f644ea6eebb90c830f41fb8b320d2b401456e5bd8d494095a44b8620d0", "src/inferrsi/data/skill_library/methods/calibrate-serving-simulation/references/source-notes.md": "9696d3c0ef96b6611787446bd6f96d4d6255ca8d107105de8c1d9af83edb9fa5", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "calibrate-serving-simulation", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json index cb7561e9..e33e7697 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cgroup-resource-controls.json @@ -25,8 +25,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/metadata.json", @@ -43,7 +43,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/SKILL.md": "fd1f5a7e6a55714730044155f5b38c1d700383d4e16c3e91963bbfbe1c773af5", "src/inferrsi/data/skill_library/hardware/host/cgroup-resource-controls/metadata.json": "19e40763fedc20990651bb989c32a7693306c5c54af46c3d4be77fd4f87b6c03", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "cgroup-resource-controls", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json index 21821477..451ee9d5 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/checkpoint-recovery-consistency.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/SKILL.md", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/metadata.json": "4dc8659806539b4784ea9348a01d4194ac70d0bb297a916f90ff6419efa5c328", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/references/dlrover-persistence-replicas.md": "055f4357f79026fcbcc766bbe77db610376ec353623f8898f5d14a30ee69e7bc", "src/inferrsi/data/skill_library/methods/checkpoint-recovery-consistency/references/sources.md": "9425b1aab963a2c8d35f3db897bd15ee69699bf5b0d0c8425c3c8bba3e9a0233", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "checkpoint-recovery-consistency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json index f4e67fff..309cf396 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/choose-parallel-training-plan.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/SKILL.md": "25d04aed9782b2a8ff1186828becdc7fce93c4418039ceaef9b8dcc5ec9bcd24", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/choose-parallel-training-plan/references/source-notes.md": "9f9184d46b19312138a6e805e439e43dc0594a0cc6b46675255a582dc946ca5b", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "choose-parallel-training-plan", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json index 21c60e5b..d9e8f5a0 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/cite-check-downstream-pr.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:cite-check-downstream-pr", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/cite-check-downstream-pr/SKILL.md": "485932cdf3b1fba5dc69be73e75d38f86a7b79442d26e82a296c963a7598d226" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json index 6accb28d..07b5a30f 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/claim-contract.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:claim-contract", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/claim-contract/SKILL.md": "3af1dbbe81d91cb05fc2ef15a2ae25d7592a08558e1a5535f49c52f33a488c55" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json index d9f647c7..150a90ca 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/comfy-ui.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/comfy-ui/LICENSE", "src/inferrsi/data/skill_library/repositories/comfy-ui/SKILL.md", @@ -50,7 +50,7 @@ "src/inferrsi/data/skill_library/repositories/comfy-ui/references/model-residency.md": "014c68386e7cdfdb7b4f566836e8b2ff61bd5a5a506e7b4723f83fe80c5d4de7", "src/inferrsi/data/skill_library/repositories/comfy-ui/references/repo-provenance.md": "ca996ef515af42a3ce304747fa3f12a31c00533deaace5ba2ce21aefa0a62e2e", "src/inferrsi/data/skill_library/repositories/comfy-ui/references/validation-boundaries.md": "1913dedbeb558d872d6a0e015cc11d822910c3cb259a236db29fb60ad8a64263", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "comfy-ui", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json index df1fdc8f..c5115059 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/competitor-scan.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:competitor-scan", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/competitor-scan/SKILL.md": "0ede58ace65a9324a538b4816add1684f230ba536d4364fe5a5dd2c0bbed3776" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json index c4b1d1ca..289b7961 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dcp-async-save-performance.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/SKILL.md": "645139ee0c88ec865cad952e24cda35f4648d4b777b732c9b7d274b6c7830845", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/metadata.json": "db7ad368394ccbfdeff6a16e3423c300d51305b1f95ff5c3936df91738a8cc35", "src/inferrsi/data/skill_library/frameworks/pytorch/dcp-async-save-performance/references/sources.md": "22afe4f4d77f441096cc657d55d763473bfcbea8fb531c8e493fe49ab84955f7", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "dcp-async-save-performance", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json index b33909aa..88a3fb35 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dense-performance-evidence.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md", "src/inferrsi/data/skill_library/methods/dense-performance-evidence/metadata.json", @@ -39,7 +39,7 @@ "source_files": { "src/inferrsi/data/skill_library/methods/dense-performance-evidence/SKILL.md": "53cc1867a13f54d1006d50517dea8848869ca50df3f0cd610b2424cc8d18c933", "src/inferrsi/data/skill_library/methods/dense-performance-evidence/metadata.json": "a0d1e3b17140295510a764045d1b222e19be3a3406e6d1e7dddaad49ff474490", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "dense-performance-evidence", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json index 5aead954..c4b2c4c9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diagnose-vllm-admission-pressure.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/SKILL.md", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/metadata.json", @@ -67,7 +67,7 @@ "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/papers-20261015/references/loongserve-readset.md": "f1a383e7bdbbd5a5a472d7f6e1292c8a17d4910ff736ca5a6aa422e1bee74f8c", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/papers-20261015/references/orca-readset.md": "a497ef23b7e60c0fbc15d95b7e07cd20547cfe56f37c24dfe6ed70d79ef7a3cf", "src/inferrsi/data/skill_library/repositories/vllm/diagnose-vllm-admission-pressure/references/source-notes.md": "84033fd514773f10c0bddd9914fabb980497ba2b308f226a922c3e1888413827", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "diagnose-vllm-admission-pressure", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json index efc3fbdd..c261a202 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/diffusers-invocation-state.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/SKILL.md", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/metadata.json", @@ -46,7 +46,7 @@ "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/ownership.md": "40688cc44183027efbf2fca8d3548c299cdf2e33fef54f76ab3549353eb9bd1b", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/source-map.md": "10562a75683bd9bd07ec2e37a1cbd0f93f2534d6f85b55a566adb2d97485215f", "src/inferrsi/data/skill_library/frameworks/diffusers/diffusers-invocation-state/references/validation.md": "5a0b854b87d091d7d505b0bdd5c03330052507a851ab6edf35b93a6675f2d4f7", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "diffusers-invocation-state", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json index 527d2952..8a2bd223 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/draft-acceptance-issue.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:draft-acceptance-issue", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/draft-acceptance-issue/SKILL.md": "ce983acfb7d7d3272775e7cf00c92e4ddadd97511b602575a76e5ab7ade01b56" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dwarfstar.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dwarfstar.json index 6e795647..726f84d2 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dwarfstar.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/dwarfstar.json @@ -25,8 +25,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/dwarfstar/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/dwarfstar/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/dwarfstar/LICENSE", "src/inferrsi/data/skill_library/repositories/dwarfstar/SKILL.md", @@ -71,7 +71,7 @@ "src/inferrsi/data/skill_library/repositories/dwarfstar/sub-skills/serving-state/SKILL.md": "71c27212847146376d72e6cc6d22abe2f7eed56402c5917cd7dfcda0b2aa5982", "src/inferrsi/data/skill_library/repositories/dwarfstar/sub-skills/serving-state/references/state-contracts.md": "8f74a07c947021e3069468268f6b5aa2548a17db518c5c0505b84dde73a1f31c", "src/inferrsi/data/skill_library/repositories/dwarfstar/sub-skills/serving-state/references/troubleshooting.md": "c9eebe4109d418c4dfb9bb2425c145ebc1a52da9b665e0556149bc31a442e2fc", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "dwarfstar", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json index da993ef1..df1f15a5 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/evaluate-elastic-serving-placement.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/SKILL.md": "82d0099d3c33706f46c657d4fa7f76d3d486e019b36760d1de001921328a60cc", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/metadata.json": "37379a4d4a058ca46da2b20a920dc01be9ec11e557c32b2332702ec76027f4b5", "src/inferrsi/data/skill_library/methods/evaluate-elastic-serving-placement/references/source-notes.md": "ea416831fd7d0874e06d0a76fb0c7196df53072b717673a0cdf635db6bfd917b", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "evaluate-elastic-serving-placement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json index ca451edb..5269026a 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/generation-cache-lifecycle.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/SKILL.md", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/metadata.json", @@ -48,7 +48,7 @@ "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/generation-batch.md": "f16d3c57d45e63bcaffd3871aa41c76972ee11f7dbf1e12b45d9b170303cad9b", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/source-map.md": "91d26181f246307f2113f94b12ac9587d689b654dcd216e9f14b11cf5ebb650c", "src/inferrsi/data/skill_library/repositories/mlx-lm/generation-cache-lifecycle/references/validation.md": "73b5dd347017baba519ecc85415aead9993c1751d116b9ba4f07689f58c5f783", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "generation-cache-lifecycle", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json index efe15544..1f6b2208 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-memory-management.json @@ -27,8 +27,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/host/host-memory-management/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/metadata.json", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-LICENSE.md": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-native-offload-readset.json": "cc6c2011be746002ba3ff96ccefab1809863748ddd17eb102b75e7b0e134fe55", "src/inferrsi/data/skill_library/hardware/host/host-memory-management/references/vllm-ascend-native-offload.md": "6c2a72b5ba3708a01d229e0576570837a617e6a42dbb0b5312a26a65a6c31542", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "host-memory-management", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json index 42f5448b..6e93c957 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/host-overhead-optimization.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/metadata.json", @@ -42,7 +42,7 @@ "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/SKILL.md": "36ef88826a32ac3147b869001004ded17a8d5a491e25bfe105005ba39ea9d1eb", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/metadata.json": "ae71c389dfdb1a19d267feecb4c6f1fbb4c9afad501ff6d8fab7e38b29bcc37a", "src/inferrsi/data/skill_library/hardware/host/host-overhead-optimization/references/deepinfer-zero-overhead-scheduling.md": "f452bf40132c9195d739f1c86b3aa18857138c7ed0f1861af5853d93b9955924", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "host-overhead-optimization", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json index 1b2a3154..5a3e01dd 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-benchmark-design.json @@ -30,8 +30,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/inference-benchmark-design/SKILL.md", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/metadata.json", @@ -52,7 +52,7 @@ "src/inferrsi/data/skill_library/methods/inference-benchmark-design/metadata.json": "18310402a8ade03fd48ac687f79ba9d447871e90337de84c0e1bc15c0b827306", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/references/benchmark-commands.md": "0898424e0bff3a6246e1eeeda6abd6c5bd974c047fe32f3bbd5ab9d31ce17cd3", "src/inferrsi/data/skill_library/methods/inference-benchmark-design/references/task-benchmark-selection.md": "0d4bb080a754e26846e81680023db0dff5e6a4c96be4327c411c3b72ac4ef8e2", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "inference-benchmark-design", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json index da075890..89a7bbe0 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/inference-optimization-casebook.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/SKILL.md", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/admission-drain-occupancy.json", @@ -55,7 +55,7 @@ "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/qwen-b300-rejected-directions.json": "146ea1564a46ed03092c7dc5796b318fc05b04b1821105ee00eb7fa7fa1333e2", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/cases/qwen-b300-rejected-directions.md": "cce2930f544a0f78f21797fba4d8ded298e4a81f76c34d7977b0e31d361bc738", "src/inferrsi/data/skill_library/methods/inference-optimization-casebook/metadata.json": "fb55067fb45970319787068a3206110641cceaf0ccbabd706be6d0b3d2afc2ed", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "inference-optimization-casebook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json index 85cc9d93..ddfd512e 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kernel-writing-guide.json @@ -27,8 +27,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/metadata.json", @@ -47,7 +47,7 @@ "src/inferrsi/data/skill_library/methods/kernel-writing-guide/SKILL.md": "01fb1712d7eb988c5e412f02340d2e48b4f8564fcf4ab232dc5897869d0d50a0", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/metadata.json": "0189d184337662056fc6952c7beffc1bf6154c4fa173ae3e3e463bd22d70f36c", "src/inferrsi/data/skill_library/methods/kernel-writing-guide/references/akg-affine-tail-guards.md": "113deb2db10b171db3425bb3f1792bee763706b794c8cc2e222b4cc0d0114118", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "kernel-writing-guide", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json index 3efd2ae7..22cd4f94 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/kv-tier-management.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md", "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/SKILL.md": "e4b78f368d70c8abb74a935acb910414015f1aeec1b50f7a295e836822ec4b27", "src/inferrsi/data/skill_library/repositories/lmcache/kv-tier-management/metadata.json": "c221189b8d85fac3bd41ef1c7cd560f1aebc8cfa0381c182d1d571a7169be829", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "kv-tier-management", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json index 5aa1aaec..e175c601 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lazy-evaluation-stream-lifetimes.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/SKILL.md", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/metadata.json", @@ -46,7 +46,7 @@ "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/execution-lifetime.md": "c4bc41e08aca68f661325f61e6f0db1760a079dc362f295c847bdc374fee3bf6", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/source-map.md": "798b9cb89ed6b885eb47464ca9f137d2802a54571b9327e631d7742d3e5abd5d", "src/inferrsi/data/skill_library/frameworks/mlx/lazy-evaluation-stream-lifetimes/references/validation.md": "ebfc00bf7d6ab0a1dc415953ae84d56ccdc713d5614aff85e433c4a843793bff", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "lazy-evaluation-stream-lifetimes", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json new file mode 100644 index 00000000..7e9dbfb6 --- /dev/null +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/lily.json @@ -0,0 +1,217 @@ +{ + "schema_version": 1, + "id": "inferrsi.common.skills.lily", + "title": "lily", + "repo": "inferrsi", + "tier": "contribution", + "backend": "common", + "component": "skills", + "scenario": "skills.discovery", + "status": "imported", + "summary": "Investigate Lily's exact Qwen3.6-35B-A3B MLX-affine-Q4 contract, Metal state and kernels, strict greedy text API, token-prefix session cache and source-qualified validation or benchmark plans.", + "tags": [ + "lily", + "rust", + "metal", + "apple-silicon", + "mlx-affine-q4", + "session-prefix", + "numerical-validation", + "benchmark-provenance" + ], + "origin": [ + "external" + ], + "sources": [ + { + "type": "git", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/lily/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", + "paths": [ + "src/inferrsi/data/skill_library/repositories/lily/LICENSE", + "src/inferrsi/data/skill_library/repositories/lily/NOTICE.md", + "src/inferrsi/data/skill_library/repositories/lily/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/metadata.json", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json", + "src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py", + "src/inferrsi/data/skill_library/skill-index.json" + ], + "content_sha256": "db815674d5d36964902041d310d3df844d00ab2e6bef0ce4b72ed2696ab2b9aa" + } + ], + "index_type": "packaged-skill", + "skill_documents": { + "original": "data/skill_library/repositories/lily/SKILL.md" + }, + "checkout_ref": "checkout:lily", + "source_files": { + "src/inferrsi/data/skill_library/repositories/lily/LICENSE": "b9e2b50a48a09fb39dafa71ab1a11a6e87389addda17faa99d55f5f74a0001ac", + "src/inferrsi/data/skill_library/repositories/lily/NOTICE.md": "7a01e666044fb8aca1fd88c636bca43bcc95b8b1fecbe101dce4c7c80fbb5759", + "src/inferrsi/data/skill_library/repositories/lily/SKILL.md": "db815674d5d36964902041d310d3df844d00ab2e6bef0ce4b72ed2696ab2b9aa", + "src/inferrsi/data/skill_library/repositories/lily/metadata.json": "6d9d54e84f957881cc26894eb82ae666f106cfc6c505924f9a6fb6b35eab457f", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-provenance.md": "96182f6cb3666f89adf1aed6e216c0a84ce3a04a0685a4257e286100ba8ee367", + "src/inferrsi/data/skill_library/repositories/lily/references/repo-routing-metadata.json": "f2f3becb51056e03081c7c4140e19572a6318c3d63015884df56eb49d38a00fc", + "src/inferrsi/data/skill_library/repositories/lily/references/source-identity.json": "4595559c11611c855be150919fca3eeb89e7f96c7a8dd133b9f79a5cd8e05e62", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/SKILL.md": "dc800f07fa0e82213483c7b848dea95d609386296006bfec7a34cbb194a83de6", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/model-and-memory.md": "d5a862303d646ebbaf745818caed8f96c7323cd442cb6d6e2aae00b0361080a1", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/references/troubleshooting.md": "b32fab02b561c3ab4e683abdfa80cd4a8f929c514147709febaa6b6d1df65909", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/model-runtime/scripts/screen_config.py": "5961bb6f31ceca43473683127b37faee268234040a013ae49bbb4898eacb6f04", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/SKILL.md": "0231b50b9bebb68d0fc5f2ce19aa7c6e5ffd498d8eef4cc00d39e82908cbbe91", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/troubleshooting.md": "01607534ce1f09fb046255c78f8c1c436aac61874b93b65a9d62f3eb480496c2", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/references/verification-contract.md": "6934779f67b878bf7cdb5f2cbe461f6716c243c662a29272c6db37f64cb317c7", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/qualification/scripts/audit_benchmark_record.py": "59534f58d46ad438c7bf88886a9b05a8716c922d817f2d9c58ff1b71ae50ee85", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/SKILL.md": "7e062ff9af76125ef08c98b4465e0439c66e9e237f0c39ea0285005cc5496cfb", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/api-and-session.md": "7262bb077c24f2f7549d450473ec7944829940d09cca89db9c12f37ac90d5db0", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/references/troubleshooting.md": "6e2f36d2f7ab9eae665d87a676e34c0ebd2f46f3df6fa5f2e589a306749a87b5", + "src/inferrsi/data/skill_library/repositories/lily/sub-skills/serving-cache/scripts/request_template.py": "d6b00c9f0b38c7fb0a0e52e396993a832542ea0aa6e2456026fabc0c39a4d33a", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" + }, + "skill_metadata": { + "name": "lily", + "description": "Investigate Lily's exact Qwen3.6-35B-A3B MLX-affine-Q4 contract, Metal state and kernels, strict greedy text API, token-prefix session cache and source-qualified validation or benchmark plans.", + "license": "NO_LICENSE", + "disable-model-invocation": true, + "metadata": { + "disco-role": "operating" + }, + "schema_version": 1, + "kind": "skill", + "origin": [ + "external" + ], + "status": "candidate", + "empirical_validation": "not_run", + "tags": [ + "lily", + "rust", + "metal", + "apple-silicon", + "mlx-affine-q4", + "session-prefix", + "numerical-validation", + "benchmark-provenance" + ], + "sources": [ + { + "type": "git", + "url": "https://github.com/perplexityai/pplx-garden", + "commit": "1ed972ed3f0bd5616c997c9507c25616c63394fc", + "paths": [ + "lily/README.md", + "lily/Cargo.toml", + "lily/Cargo.lock", + "lily/rust-toolchain.toml", + "lily/CONTRIBUTING.md", + "lily/LICENSE", + "lily/NOTICE", + "lily/src/lib.rs", + "lily/src/config.rs", + "lily/src/weights.rs", + "lily/src/safetensors.rs", + "lily/src/tensor.rs", + "lily/src/metal.rs", + "lily/src/model.rs", + "lily/src/serve.rs", + "lily/src/serve/session.rs", + "lily/src/chat.rs", + "lily/src/generate.rs", + "lily/src/tokenizer.rs", + "lily/src/kernels/attention.rs", + "lily/src/kernels/gdn.rs", + "lily/src/kernels/gemm.rs", + "lily/src/kernels/skinny.rs", + "lily/src/bin/lily-bench.rs", + "lily/tests/support/cpu_ref.rs", + "lily/tests/test_shader_compile.rs", + "lily/tests/test_e2e_35b.rs", + "lily/tests/test_tokenizer.rs", + "lily/tests/unit/weights.rs", + "lily/tests/unit/serve.rs", + "lily/tests/unit/serve/session.rs", + "lily/tests/unit/generate.rs", + "lily/tests/unit/kernels/gemm.rs", + "lily/tests/unit/kernels/gdn.rs", + "lily/tests/unit/kernels/skinny.rs", + "lily/docs/2026-09-01-performance-mlx-0.31.2.md", + "lily/docs/2026-09-02-performance-mlx-0.32.2.md", + "lily/benchmarks/run_matrix.py", + "lily/benchmarks/bench_mlx.py", + "lily/benchmarks/requirements.txt" + ], + "license": "Apache-2.0", + "scope": "Lily subtree only; independent lily/LICENSE and NOTICE retained.", + "readset": "references/source-identity.json" + }, + { + "type": "git", + "url": "https://github.com/VectorSpaceLab/AREX-Skill", + "commit": "ac3fe1afa80fb9a09775ecfb2b6cc3ba850a2db6", + "paths": [ + "cli/packages/coding-agent/src/disco/skills/create-repo-skill", + "cli/packages/coding-agent/src/disco/skills/prepare-repo-skill-env", + "cli/packages/coding-agent/src/disco/skills/workflow-authoring", + "cli/packages/coding-agent/src/disco/skills/verify-repo-skill" + ], + "scope": "Portable native Rust/Metal adaptation executed by a compatible agent; not a DisCo CLI/model run." + } + ], + "construction": { + "anchor_kind": "source", + "distillation_form": "repository-operating-graph", + "strategy": "arex-portable-meta-skills", + "status": "partial-candidate", + "native_import": "not-run", + "method": "User-approved native Rust/Metal and partial drafting adaptation; stable-ID lanes, integrated source graph and assertion/helper verification. Missing compiler/backend/checkpoint remains explicit." + }, + "applicability": { + "scope": "Exact Lily source/checkpoint/layout/API/cache/qualification investigation; common catalog classification is not CPU inference or cross-device support." + }, + "limitations": [ + "Cargo/Rust1.92, supported M5/macOS26/Metal and model resources are unavailable; native evidence remains BLOCKED_REQUIRED_BACKEND.", + "Offline Python helper checks are not Rust serde/loader/tokenizer, native kernel/state/cache, model quality, service or performance validation.", + "Current benchmark source and later report have distinct package/harness identities; negative long-context prefill observations remain author-reported.", + "Only selected source bodies are mined; complete kernel/format/platform/failure coverage and behavioral skill efficacy remain unverified.", + "NO_LICENSE is the actual unauthenticated GitHub CLI fallback, not a legal conclusion; lily Apache-2.0 LICENSE and NOTICE are independently retained." + ], + "provenance_readsets": [ + "references/repo-provenance.md", + "references/source-identity.json" + ], + "consumption_mode": "packaged" + }, + "applicability": { + "scope": "Exact Lily source/checkpoint/layout/API/cache/qualification investigation; common catalog classification is not CPU inference or cross-device support." + }, + "recommendations": [ + "Read the pinned SKILL.md and its prerequisites before choosing this procedure.", + "Read the packaged references and owner-local cases alongside the procedure." + ], + "limitations": [ + "This generated abstract points to the complete packaged skill; external evidence and upstream repositories remain source links.", + "The imported status describes this index, not the original skill; its declared status is candidate.", + "Reading or indexing does not authorize execution, validate efficacy, promote a candidate or grant a license.", + "The backend categorizes the procedure's hardware dependency; it does not certify compatibility, and skills.discovery is a discovery scenario.", + "Cargo/Rust1.92, supported M5/macOS26/Metal and model resources are unavailable; native evidence remains BLOCKED_REQUIRED_BACKEND.", + "Offline Python helper checks are not Rust serde/loader/tokenizer, native kernel/state/cache, model quality, service or performance validation.", + "Current benchmark source and later report have distinct package/harness identities; negative long-context prefill observations remain author-reported.", + "Only selected source bodies are mined; complete kernel/format/platform/failure coverage and behavioral skill efficacy remain unverified.", + "NO_LICENSE is the actual unauthenticated GitHub CLI fallback, not a legal conclusion; lily Apache-2.0 LICENSE and NOTICE are independently retained." + ], + "verification": { + "locally_verified": false, + "evidence_level": "guidance" + } +} diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json index b18f7481..6fa0ca87 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/npu-skill-factory.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md", @@ -54,7 +54,7 @@ }, "checkout_ref": "checkout:npu-skill-factory", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/SKILL.md": "74cd863df2e80dc2bda1713d24207809173a3116f30325e3487e1e3517cfec1e", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/metadata.json": "12fc9272bd5fbf02dd9b897d8ca40984b72ae54f20492ace5304711bbc4d71c3", "src/inferrsi/data/skill_library/workflows/npu-skill-factory/references/papers-20261015/COMPARISON.md": "38587678a96581f5c2dc697d982127343565504bffa191352811dffcc165aa23", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json index 5690ec34..98e5eb75 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/optimization-search-policy.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/optimization-search-policy/SKILL.md", "src/inferrsi/data/skill_library/methods/optimization-search-policy/metadata.json", @@ -51,7 +51,7 @@ "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/knowledge/adaptation-interfaces.md": "5e761957cb5ecd93926e6ffc13deee7c830c6e8f0ee3c3846e9dd3b50dc74446", "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/references/source-notes.md": "54d83c3713045d59a48821bcf93598374ba4a630e3891ad39498f919317c4fb8", "src/inferrsi/data/skill_library/methods/optimization-search-policy/references/papers-20261015/updates/optimization-search-policy.md": "d3db44fa9a6831b86a02c638b323ed943e69fe256866213f10d68c72d762879e", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "optimization-search-policy", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json index 30c6092d..c25fad80 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/os-process-placement.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/metadata.json", @@ -44,7 +44,7 @@ "src/inferrsi/data/skill_library/hardware/host/os-process-placement/SKILL.md": "2003492e4d89fde0443b180d74933e764bd1979435e109c8d26e20eb8f6e5053", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/metadata.json": "ec02995c075f0a540921f57b4846f2cafe334eb90f44389f17c3c50457c3e9c5", "src/inferrsi/data/skill_library/hardware/host/os-process-placement/references/llama-numa-thread-readset.md": "748b254b3b043a5ddb0f480eb4a566854d27eedd7b111499863e9bf0a5a6951e", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "os-process-placement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json index d163e41d..81d6d1f6 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/performance-ceiling-analysis.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/SKILL.md", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/metadata.json", @@ -78,7 +78,7 @@ "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/references/roofline-contract.md": "419ec4bcaec45ac579a133bce083d4f48779f26e664d7a86f720fa65f343b1d1", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/references/roofline-example.json": "597cd3205df043cff3ae9d15924c77934e8d8eb300c00c4840f6bb2921f90faf", "src/inferrsi/data/skill_library/methods/performance-ceiling-analysis/scripts/roofline.py": "524de48a6764401695fe1444f1fa3d38f363069b0cd2fba4715a86ca4b28a5d4", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "performance-ceiling-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json index 8c45f5a2..2ee37f30 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/plan-activation-residency.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md", "src/inferrsi/data/skill_library/methods/plan-activation-residency/metadata.json", @@ -36,7 +36,7 @@ "src/inferrsi/data/skill_library/methods/plan-activation-residency/SKILL.md": "542d8a1e6963f5019986e1fbd79d3a247a045a51487c09313026087ac457c15e", "src/inferrsi/data/skill_library/methods/plan-activation-residency/metadata.json": "c6acae57d70190cea0e18c71c79127962181e58169e011df75d8635b3db4daa7", "src/inferrsi/data/skill_library/methods/plan-activation-residency/references/source-notes.md": "5ff52655cfd06fcf970ed2a7d4d4fe1c31115b102af2d41497de0c74848ed2b3", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "plan-activation-residency", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json index 5df05ca1..1a6df5b3 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/repository-evolution-analysis.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/metadata.json", @@ -41,7 +41,7 @@ "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/SKILL.md": "7e20d3390f2501263e5e298e026c47cac16c234f2397833131e15ae5d34c0b97", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/metadata.json": "d0e4d6950250e4cec43d82e23324c9301a925d4c22be30b4d2713d790cb6504b", "src/inferrsi/data/skill_library/methods/repository-evolution-analysis/references/capability-presence-audit.md": "c21eb4a6aabe811a49a6540a34c54dbcfdcf7efae3052a79b54034c7838026a5", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "repository-evolution-analysis", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json index 828702fb..5c3fd982 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/rsi-evidence.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/skill-index.json", "src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md" @@ -31,7 +31,7 @@ }, "checkout_ref": "checkout:rsi-evidence", "source_files": { - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4", + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809", "src/inferrsi/data/skill_library/workflows/rsi-evidence/SKILL.md": "a55610874b658b86a39a1a049efb4e4eab0140f6579ed74dd7718a4ca8cedaca" }, "skill_metadata": { diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json index 977c0ad6..1e70539e 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/skill-evolution-playbook.json @@ -21,8 +21,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md", "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/metadata.json", @@ -39,7 +39,7 @@ "source_files": { "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/SKILL.md": "9cd37f21fe0d862069e4798edca8a04d59f8b840e55d521901594a63dddd9ba3", "src/inferrsi/data/skill_library/methods/skill-evolution-playbook/metadata.json": "92b36338b9257e2e41b95e4370694d7de52ed84bc7971056b3bfced07b0993d8", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "skill-evolution-playbook", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/splash.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/splash.json index 8457e8a0..c21c6091 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/splash.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/splash.json @@ -25,8 +25,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/splash/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/splash/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/splash/LICENSE", "src/inferrsi/data/skill_library/repositories/splash/SKILL.md", @@ -77,7 +77,7 @@ "src/inferrsi/data/skill_library/repositories/splash/sub-skills/serving-cache/SKILL.md": "c16f911498e116ff9b31b5a6f0ddd3ae6517b51c0e9d079c337f36a5bcac1df8", "src/inferrsi/data/skill_library/repositories/splash/sub-skills/serving-cache/references/state-and-api.md": "592603177473ac8e024b7dc19a3d3faedd7c1e0312137eab8bf9a62d2f567be6", "src/inferrsi/data/skill_library/repositories/splash/sub-skills/serving-cache/references/troubleshooting.md": "4fda461042a3de43c109d7a3cec67542c7d61fe68412bf91606220f2e13e576e", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "splash", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json index 1542d258..00624b49 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/storage-io-measurement.json @@ -24,8 +24,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md", "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/metadata.json", @@ -42,7 +42,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/SKILL.md": "63b883c10a8d3e7d918abfc7175b72e2b401ff1e02697f94b8382ec1c8f369b7", "src/inferrsi/data/skill_library/hardware/host/storage-io-measurement/metadata.json": "0a41c7b00978332b54ee1e4a7c1ade88ecde3e961128f24d1b4f7708caff5ff5", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "storage-io-measurement", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json index e6f24570..42ab8793 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-input-pipeline.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md", "src/inferrsi/data/skill_library/methods/training-input-pipeline/metadata.json", @@ -43,7 +43,7 @@ "src/inferrsi/data/skill_library/methods/training-input-pipeline/SKILL.md": "64bd2c6b795d966045d1d3cca55976d3d49b08b06df7c7e06a70c2824cf55b7e", "src/inferrsi/data/skill_library/methods/training-input-pipeline/metadata.json": "80659099fce6a6ec05e9084b75452c877a5812e30f60a78f31ef8c7efcdc1bac", "src/inferrsi/data/skill_library/methods/training-input-pipeline/references/sources.md": "60e0f3e88655d8e1d5eb4797f39ca4370deda01614f265b8d2ea4559d8ac020f", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "training-input-pipeline", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json index be0a6a07..2a00bce9 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/training-resource-budget.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/training-resource-budget/SKILL.md", "src/inferrsi/data/skill_library/methods/training-resource-budget/metadata.json", @@ -57,7 +57,7 @@ "src/inferrsi/data/skill_library/methods/training-resource-budget/references/papers-20261015/references/source-readset.md": "2a5c166767f56fa47e7eba7386f1f36da8cb73702e5b5bbe14d6a456ca9ebfae", "src/inferrsi/data/skill_library/methods/training-resource-budget/references/sources.md": "6d248f58af8b350fc66c22898988d6f451ac60d03bcd805cd6e84df5e55174ac", "src/inferrsi/data/skill_library/methods/training-resource-budget/references/stas-decision-notes.md": "f1a993e6c4ca9a035a2effcaf5500081f227b0cc56cc885a6b22fda0041fc744", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "training-resource-budget", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json index e60c40d9..b9ac67f1 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/common/skills/weight-loading-optimization.json @@ -26,8 +26,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/methods/weight-loading-optimization/SKILL.md", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/metadata.json", @@ -48,7 +48,7 @@ "src/inferrsi/data/skill_library/methods/weight-loading-optimization/metadata.json": "798cbff6f10b7c24b188080ebf233b188b0e98ef2c6fdb5e00e1fe3eff727c0f", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/references/fastsafetensors-transfer-readset.md": "5a39f14b102b0cee304541e011aa31e44e6b13527d1bee9987c3f3b66c064d3d", "src/inferrsi/data/skill_library/methods/weight-loading-optimization/references/llama-loading-readset.md": "6c640f28ee3f0253a17b81461c865cb9f947367002cb75bf72550c4572d02e97", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "weight-loading-optimization", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json index 1157020e..f71f934b 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/audit-afd-p2p-exchanges.json @@ -23,8 +23,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/SKILL.md", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/metadata.json", @@ -45,7 +45,7 @@ "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/metadata.json": "4e6100dfb9fc7bc00b19915f4fd38ad509704f2a609c658adf4d632d4e05b6c1", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/references/afd-plugin-LICENSE.md": "0e8566ea362276878e1f38f97da49964dbea301c15d4aa9d727f97a4c39fd943", "src/inferrsi/data/skill_library/repositories/afd-plugin/audit-afd-p2p-exchanges/references/source-notes.md": "5073d87450cb60d1b245308dff8807e73749c07de976d50f2fa26694fad81a72", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "audit-afd-p2p-exchanges", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json index cd5c7bb7..add5a782 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/diagnose-attention-bottlenecks.json @@ -16,8 +16,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/metadata.json", @@ -52,7 +52,7 @@ "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/papers-20261015/cases/partitioning-after-fusion.md": "4d4cabe0991eab554dcfbd4fa9c8199e61fa4767709b0c4cd646e2588bb398a2", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/papers-20261015/knowledge/attention-cost-model-boundaries.md": "5ed8f888443e38ccb72545b6025447aab7b92936f78c151fed680e582126239b", "src/inferrsi/data/skill_library/hardware/cuda/diagnose-attention-bottlenecks/references/sources.md": "53436e0de4e6dda2d29426591bf61f8526378cdc6f9ec7967b88b1bcd4c61e6f", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "diagnose-attention-bottlenecks", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json index b28f213b..0c790b16 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/host-overhead-profiling.json @@ -22,8 +22,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/metadata.json", @@ -40,7 +40,7 @@ "source_files": { "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/SKILL.md": "326e566fbe30d3ba04e4b50c3e87aad9df037f0ac4ad6fe129165ae97dc5f91d", "src/inferrsi/data/skill_library/hardware/cuda/host-overhead-profiling/metadata.json": "76e34c1c64aba473a9e126b032a776417caa0f913f6ac3cf4dba3a5d123b1ee0", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "host-overhead-profiling", diff --git a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json index 138c601f..52e9657f 100644 --- a/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json +++ b/src/inferrsi/data/repo_packs/inferrsi/knowledge/cuda/skills/reason-hopper-kernels.json @@ -36,8 +36,8 @@ "sources": [ { "type": "git", - "url": "https://github.com/InferMatrixLab/InferRSI/blob/99fca181e71fab22c09bb1967335d0653852eff3/src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", - "commit": "99fca181e71fab22c09bb1967335d0653852eff3", + "url": "https://github.com/InferMatrixLab/InferRSI/blob/7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c/src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", + "commit": "7766bcd57817aa80bfab3ffdb9fd1cd12e902c9c", "paths": [ "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/SKILL.md", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/metadata.json", @@ -72,7 +72,7 @@ "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/source-inventory.json": "1dc09c895c970a0c9708158bcc6dd65cdb736274fd2c35d44542c70407d3849d", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/sources.md": "6b74b9e774f2a80db0860510d9e6940d36284430f29c1e124f115a9eaf25833d", "src/inferrsi/data/skill_library/hardware/cuda/reason-hopper-kernels/references/synchronization.md": "4322f6b3c0e4368bf8c192b4ec752529767f50d19c0c38dad8fdf9cd781e41d9", - "src/inferrsi/data/skill_library/skill-index.json": "027d1e77cd0145135abc65b67efb3aa799f6f88c4e3a16db74314cbb9a08acc4" + "src/inferrsi/data/skill_library/skill-index.json": "82701425f9ac2a1e75dbb75185ab38d905b5a75a6f66e69e774c6d2c48fa1809" }, "skill_metadata": { "name": "reason-hopper-kernels",