[upstream-sync] skills/setup-uspto-downloader-remote-tool/agents/openai.yaml from mims-harvard/ToolUniverse@1aaaf00d [prompt]

upstream/mims-harvard-ToolUniverse/catalogue/skills/host-and-share-remote-tool/SKILL.md

@@ -0,0 +1,141 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/host-and-share-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: host-and-share-remote-tool
+description: Host, validate, and privately share a user's own model, Python function, workflow, or existing Streamable HTTP MCP endpoint through ToolUniverse Platform. Use when turning a local CPU/GPU workload or lab endpoint into a stable TU remote tool, diagnosing its setup, or preparing it for controlled sharing.
+---
+
+# Host and share a remote tool
+
+Use this workflow for user-owned code and infrastructure. Keep the workload on the user's computer or lab server; ToolUniverse Platform receives only the MCP tool manifest and relayed calls.
+
+## Choose the shortest path
+
+- Python function, model, database query, or workflow: wrap only the callable with `@remote_tool`, then use `tu serve ... --share`.
+- Existing Streamable HTTP MCP server: keep it running on loopback and use `tuplatform-relay --forward ...`.
+- One of ToolUniverse's 30 reviewed scientific implementations: use its implementation-specific `setup-<name>-remote-tool` skill and `tu remote share <name>` instead.
+
+Do not treat an arbitrary REST endpoint as MCP. Wrap it in a typed Python function first, or put a reviewed MCP adapter in front of it.
+
+## 1. Install the reviewed clients
+
+Open ToolUniverse Connect, go to **My Computers → Connect a computer**, choose the Python or existing-MCP path, and copy the immutable install command shown there. Run it in a new Python 3.12 virtual environment. The command pins both the ToolUniverse and relay sources; do not replace the pins with a moving branch.
+
+Confirm the expected commands exist:
+
+~~~bash
+tu --help
+tuplatform-relay --help
+~~~
+
+Stop if installation or source access fails. A locally working model does not prove that sharing works.
+
+## 2A. Wrap a Python model or function
+
+Create `my_tool.py`. Load fixed model artifacts from provider-owned configuration; do not accept arbitrary caller-controlled filesystem paths or model identifiers.
+
+~~~python
+from tooluniverse import remote_tool
+
+@remote_tool
+def predict(sequence: str, threshold: float = 0.5) -> dict:
+    """Score one sequence with the locally hosted model."""
+    if not isinstance(sequence, str) or not 1 <= len(sequence) <= 10_000:
+        raise ValueError("sequence must contain 1 to 10,000 characters")
+    score = min(len(sequence) / 100.0, 1.0)  # replace with the real model call
+    return {"score": score, "passes": score >= threshold}
+~~~
+
+Use bounded, JSON-serializable inputs and outputs. Return stable field names and sanitized errors; never return secrets, local paths, stack traces, raw model objects, or unbounded tensors/files.
+
+For a GPU model, verify the actual provider environment before launch:
+
+~~~bash
+python -c 'import torch; assert torch.cuda.is_available(); x=torch.arange(8, device="cuda"); print(torch.cuda.get_device_name(0), x.sum().item())'
+~~~
+
+This proves only CUDA tensor execution. Run a small, real inference below before claiming the model works.
+
+## 2B. Use an existing MCP endpoint
+
+Start the Streamable HTTP MCP server on loopback, for example `http://127.0.0.1:8080/mcp`. Confirm it implements MCP initialization, `tools/list`, and `tools/call`; a health endpoint alone is insufficient.
+
+Do not forward a public endpoint containing embedded credentials. Keep provider API keys in the provider process and use the relay only for MCP traffic.
+
+## 3. Validate locally before sharing
+
+For Python mode, start without `--share`:
+
+~~~bash
+tu serve my_tool.py --host 127.0.0.1 --port 8080
+~~~
+
+From a second terminal, perform exact discovery and one semantic call:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8080/mcp") as client:
+        tools = await client.list_tools()
+        print([tool.name for tool in tools])
+        result = await client.call_tool("predict", {"sequence": "ACGT", "threshold": 0.01})
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Check the exact tool name and schema, meaningful finite output, invalid-input behavior, latency, and the absence of secrets or local paths. For a real ML model, record evidence that the model loaded and executed on the intended CPU/GPU; discovery alone is not model validation.
+
+## 4. Share privately with browser authorization
+
+Stop the local-only command, then use one foreground command.
+
+Python path:
+
+~~~bash
+tu serve my_tool.py --share --name "My Model" --service https://tooluniverse-backend.onrender.com
+~~~
+
+Existing MCP path:
+
+~~~bash
+tuplatform-relay --forward http://127.0.0.1:8080 --name "My Server" --service https://tooluniverse-backend.onrender.com
+~~~
+
+When no valid key is stored, the CLI opens a browser authorization link. Approve the matching computer name and code. No copy/paste is required; the computer-only key is verified and stored in a local `0600` file without being displayed. On a headless server add `--no-browser` and open the printed link elsewhere. If the first request expires, the CLI creates one replacement link automatically.
+
+An explicit invalid `TOOLUNIVERSE_SERVICE_KEY` and all non-interactive jobs fail fast. Fix or unset the environment value; do not silently replace production secrets. Use protected secret injection only for unattended service accounts.
+
+## 5. Verify through TU Platform
+
+Wait until **My Computers** shows the server online. As its owner, import or open the remote tool and make one small semantic call through TU Platform. Confirm the platform result matches the local result. Record local discovery, local call, online status, platform discovery, platform call, model/device evidence, and timestamps separately.
+
+Keep the connection private by default. Public marketplace publication, another user's authorization/isolation, load behavior, and long-running supervision are separate validations; do not claim them from an owner-only smoke test.
+
+## 6. Stabilize and operate
+
+- Start with one relay worker for GPU or stateful workloads. Increase only after measuring cold start, warm latency, RAM/VRAM, queueing, timeouts, cancellation, and recovery at parallel levels 1, 2, 4, and 8.
+- Load the model once per provider process and bound input size, response size, download size, runtime, and concurrency.
+- Bind locally to loopback. The relay is outbound; no public IP or firewall change is needed.
+- Keep model weights, data, caches, and credentials outside Git. Pin dependencies and document licenses.
+- Stop foreground sharing with Ctrl-C. For persistent operation, use the `tuplatform-service install` command shown by the website, then verify its user service and logs.
+
+Remove only the local login with `tu remote logout`. Revoke the computer-only platform connection and then remove the local copy with:
+
+~~~bash
+tu remote logout --revoke
+~~~
+
+For an SDK-only existing-MCP setup, use `tuplatform-auth logout --revoke`. Revocation intentionally leaves the server record offline for owner inspection; delete that record separately in **My Computers** if desired.
+
+## Failure reporting
+
+Classify outcomes precisely: installation blocked, provider dependency blocked, GPU unavailable, credential rejected, local discovery passed, real inference passed, relay passed, or platform semantic call passed. Never convert a blocked or discovery-only result into "working."

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-boltz-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-boltz-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-boltz-remote-tool
+description: Set up, launch, validate, and troubleshoot the Boltz-2 ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Boltz-2 as a remote tool
+
+> Validation status (2026-08-16): Boltz 2.2.1 and the official checkpoints ran on the NVIDIA GB10 in one repaired direct MCP call and three authenticated Platform calls, each returning six finite affinity values in 63.6-66.5 seconds. The upstream MSA service timed out during validation, so those successful calls explicitly used bounded single-sequence mode. Missing, oversized, malformed, or non-finite affinity artifacts now fail closed. Public publication, cross-user isolation, broad concurrency, recovery, biological accuracy, and the live MSA path remain unvalidated; keep this deployment private.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CUDA GPU strongly recommended; CPU is not a practical production target.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation boltz
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/boltz
+. .venvs/boltz/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install fastmcp boltz
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Keep Boltz/model caches below caches/boltz. `use_msa_server=true` needs the upstream MSA service. Use `false` only when lower-quality single-sequence inference is acceptable. Review Boltz model/code and ligand-data licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share boltz
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share boltz --name my-boltz-remote --workers 1
+~~~
+
+Use `tu remote check boltz` for a non-sharing readiness check and
+`tu remote run boltz` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/boltz runs/boltz
+python -m tooluniverse.remote.boltz.boltz_mcp_server
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8080/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8080/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains boltz2_docking; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8080/mcp --json
+tu serve --share --forward http://127.0.0.1:8080/mcp --name validation-boltz --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: boltz2_docking
+
+~~~json
+{"sequence":"ACDEFGHIKLMNPQRSTVWY","ligands":[{"id":"L1","smiles":"CCO"}],"sampling_steps":20,"recycling_steps":1,"use_msa_server":false}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sequence":"ACDEFGHIKLMNPQRSTVWY","ligands":[{"id":"L1","smiles":"CCO"}],"sampling_steps":20,"recycling_steps":1,"use_msa_server":false}''')
+    async with Client("http://127.0.0.1:8080/mcp") as client:
+        result = await client.call_tool("boltz2_docking", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: `msa_mode` plus an `affinity_prediction` object containing finite values, and optionally a bounded CIF structure. If Boltz exits without the affinity artifact, treat the sanitized error as a failure rather than a partial success. Check scientific meaning, output bounds, invalid-input behavior, and absence of paths, secrets, and traces.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-boltz`.
+- Revoke temporary keys. After confirmation, remove only .venvs/boltz, caches/boltz, and runs/boltz; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-borzoi-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-borzoi-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-borzoi-remote-tool
+description: Set up, launch, validate, and troubleshoot the Borzoi ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Borzoi as a remote tool
+
+> Validation status (2026-08-16): a fresh Python 3.12 service environment resolved borzoi-pytorch 0.4.4 with its supported Transformers 4.50.3 dependency, loaded official weights on the GB10, and returned bounded finite prediction and variant-effect results through a strict loopback TOU endpoint. Four concurrent fixture calls also passed with serialized model access. NVIDIA's aarch64 cusparselt wheel still reports incompatible platform metadata in `uv pip check`; public publication, cross-user isolation, saturation, recovery, and biological accuracy remain incomplete, so keep this private. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended; CPU only for small checks.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation borzoi
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/borzoi
+. .venvs/borzoi/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/borzoi/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Keep HF_HOME and TORCH_HOME below caches/borzoi. The provider selects the model; review model/output licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share borzoi
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share borzoi --name my-borzoi-remote --workers 1
+~~~
+
+Use `tu remote check borzoi` for a non-sharing readiness check and
+`tu remote run borzoi` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/borzoi runs/borzoi
+python -m tooluniverse.remote.borzoi.borzoi_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8012/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8012/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_borzoi_predict; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8012/mcp --json
+tu serve --share --forward http://127.0.0.1:8012/mcp --name validation-borzoi --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_borzoi_predict
+
+~~~json
+{"sequence":"ACGTACGT","top_n":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sequence":"ACGTACGT","top_n":1}''')
+    async with Client("http://127.0.0.1:8012/mcp") as client:
+        result = await client.call_tool("run_borzoi_predict", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, organism, n_tracks, and a bounded tracks array. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-borzoi`.
+- Revoke temporary keys. After confirmation, remove only .venvs/borzoi, caches/borzoi, and runs/borzoi; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-cell2location-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-cell2location-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-cell2location-remote-tool
+description: Set up, launch, validate, and troubleshoot the cell2location ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up cell2location as a remote tool
+
+> Validation status (2026-08-16): the scientific environment, GB10 execution, loopback discovery, and a bounded synthetic single-cell/spatial deconvolution call passed with finite abundance output. Public publication, cross-user isolation, representative accuracy, broad concurrency, and recovery remain incomplete; keep this deployment private. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended for production posterior fitting; CPU only for tiny tests.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation cell2location
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/cell2location
+. .venvs/cell2location/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/cell2location/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT to provider-owned reference/spatial H5AD files; use only relative paths. Verify dataset rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share cell2location
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share cell2location --name my-cell2location-remote --workers 1
+~~~
+
+Use `tu remote check cell2location` for a non-sharing readiness check and
+`tu remote run cell2location` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/cell2location runs/cell2location
+python -m tooluniverse.remote.cell2location.cell2location_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8019/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8019/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_cell2location_deconvolution; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8019/mcp --json
+tu serve --share --forward http://127.0.0.1:8019/mcp --name validation-cell2location --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_cell2location_deconvolution
+
+~~~json
+{"sc_path":"reference.h5ad","sp_path":"spatial.h5ad","cluster_label":"cell_type","ref_epochs":1,"sp_epochs":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sc_path":"reference.h5ad","sp_path":"spatial.h5ad","cluster_label":"cell_type","ref_epochs":1,"sp_epochs":1}''')
+    async with Client("http://127.0.0.1:8019/mcp") as client:
+        result = await client.call_tool("run_cell2location_deconvolution", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: n_spots, cell_types, and bounded mean_abundance. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-cell2location`.
+- Revoke temporary keys. After confirmation, remove only .venvs/cell2location, caches/cell2location, and runs/cell2location; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-cellrank-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-cellrank-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-cellrank-remote-tool
+description: Set up, launch, validate, and troubleshoot the CellRank ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up CellRank as a remote tool
+
+> Validation status (2026-08-16): CellRank dependencies, loopback discovery, and a bounded deterministic pseudotime-kernel fate call passed with aligned finite probabilities. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete; keep this deployment private. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU is acceptable for a tiny graph; GPU is optional.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation cellrank
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/cellrank
+. .venvs/cellrank/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/cellrank/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT to the provider-owned H5AD root. Verify input annotations and dataset rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share cellrank
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share cellrank --name my-cellrank-remote --workers 1
+~~~
+
+Use `tu remote check cellrank` for a non-sharing readiness check and
+`tu remote run cellrank` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/cellrank runs/cellrank
+python -m tooluniverse.remote.cellrank.cellrank_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8028/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8028/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_cellrank_fate; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8028/mcp --json
+tu serve --share --forward http://127.0.0.1:8028/mcp --name validation-cellrank --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_cellrank_fate
+
+~~~json
+{"adata_path":"tiny.h5ad","kernel":"connectivity","n_states":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","kernel":"connectivity","n_states":2}''')
+    async with Client("http://127.0.0.1:8028/mcp") as client:
+        result = await client.call_tool("run_cellrank_fate", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: terminal_states, state counts, and bounded fate probabilities. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-cellrank`.
+- Revoke temporary keys. After confirmation, remove only .venvs/cellrank, caches/cellrank, and runs/cellrank; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-celltypist-remote-tool/SKILL.md

@@ -0,0 +1,201 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-celltypist-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-celltypist-remote-tool
+description: Set up, launch, validate, and troubleshoot the CellTypist ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up CellTypist as a remote tool
+
+> Validation status (2026-08-16): working CPU deployment. The live MCP call annotated 80 cells from the official CellTypist sample and completed majority voting. A converted data-only model produced the same 80 labels and probabilities as the digest-pinned upstream model (maximum probability delta 0.0). This is runtime equivalence evidence, not an annotation-accuracy benchmark. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU is sufficient for the validated model and sample.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation celltypist
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/celltypist
+. .venvs/celltypist/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/celltypist/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain data and provision a safe model
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT to the provider-owned directory containing normalized `.h5ad` inputs.
+- Download the model only from the official CellTypist host and verify its digest independently. The validated `Immune_All_Low.pkl` v2 digest is `290874d35dac039d4c9218c343fde4aac1077709b72a331ce7266f6828c36502`.
+- In an isolated provisioning environment only, convert the reviewed pickle into a data-only archive:
+
+~~~bash
+python src/tooluniverse/remote/celltypist/convert_pickle_model.py \
+  caches/celltypist/source/Immune_All_Low.pkl \
+  caches/celltypist/safe-models/Immune_All_Low.npz \
+  --expected-sha256 290874d35dac039d4c9218c343fde4aac1077709b72a331ce7266f6828c36502
+export CELLTYPIST_SAFE_MODEL_DIR="$PWD/caches/celltypist/safe-models"
+~~~
+
+The remotely callable server must never invoke the converter, `Model.load`, or model download helpers. It opens only the data-only NPZ with `allow_pickle=False`.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share celltypist
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share celltypist --name my-celltypist-remote --workers 1
+~~~
+
+Use `tu remote check celltypist` for a non-sharing readiness check and
+`tu remote run celltypist` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/celltypist runs/celltypist/runtime/celltypist \
+  runs/celltypist/runtime/matplotlib runs/celltypist/runtime/cache
+export CELLTYPIST_SAFE_MODEL_DIR="$PWD/caches/celltypist/safe-models"
+export CELLTYPIST_FOLDER="$PWD/runs/celltypist/runtime/celltypist"
+export MPLCONFIGDIR="$PWD/runs/celltypist/runtime/matplotlib"
+export TOOLUNIVERSE_CACHE_DIR="$PWD/runs/celltypist/runtime/cache"
+python -m tooluniverse.remote.celltypist.celltypist_tool
+~~~
+
+The runtime directories must be writable by the service account. CellTypist,
+Matplotlib, and ToolUniverse otherwise default to home-directory caches, which
+break startup or persistence when the deployment has a read-only home.
+
+The Streamable HTTP endpoint is http://127.0.0.1:8014/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8014/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_celltypist_annotate; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8014/mcp --json
+tu serve --share --forward http://127.0.0.1:8014/mcp --name validation-celltypist --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_celltypist_annotate
+
+~~~json
+{"adata_path":"celltypist_official_sample_80.h5ad","model":"Immune_All_Low.pkl","majority_voting":true}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"celltypist_official_sample_80.h5ad","model":"Immune_All_Low.pkl","majority_voting":true}''')
+    async with Client("http://127.0.0.1:8014/mcp") as client:
+        result = await client.call_tool("run_celltypist_annotate", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: `artifact_format=celltypist-safe-npz-v1`, the pinned `source_sha256`, `n_cells`, aligned `cell_ids`/`predicted_labels`, and `label_counts` summing to `n_cells`. The validated call returned 80 labels with `majority_voting=true`. Check scientific meaning, output bounds, invalid-input behavior, and absence of paths, secrets, and traces; no biological-accuracy claim follows from a successful run.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Read-only home/cache failure: verify `CELLTYPIST_FOLDER`, `MPLCONFIGDIR`, and `TOOLUNIVERSE_CACHE_DIR` all name writable provider directories.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-celltypist`.
+- Revoke temporary keys. After confirmation, remove only .venvs/celltypist, caches/celltypist, and runs/celltypist; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-chrombpnet-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-chrombpnet-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-chrombpnet-remote-tool
+description: Set up, launch, validate, and troubleshoot the ChromBPNet ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up ChromBPNet as a remote tool
+
+> Validation status (2026-08-16): TensorFlow safely loaded a generated Keras-v3 fixture; loopback prediction and variant-effect calls returned bounded finite contract results. No reviewed trained ChromBPNet artifact was available, so scientific inference, public publication, cross-user isolation, and production performance remain unvalidated. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended; CPU only for small checks.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation chrombpnet
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/chrombpnet
+. .venvs/chrombpnet/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/chrombpnet/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set CHROMBPNET_MODEL_PATH to one administrator-reviewed Keras v3 .keras artifact. Caller paths and legacy .h5 loading are rejected; verify provenance/license.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share chrombpnet
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share chrombpnet --name my-chrombpnet-remote --workers 1
+~~~
+
+Use `tu remote check chrombpnet` for a non-sharing readiness check and
+`tu remote run chrombpnet` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/chrombpnet runs/chrombpnet
+python -m tooluniverse.remote.chrombpnet.chrombpnet_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8032/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8032/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_chrombpnet_predict; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8032/mcp --json
+tu serve --share --forward http://127.0.0.1:8032/mcp --name validation-chrombpnet --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_chrombpnet_predict
+
+~~~json
+{"sequence":"ACGTACGT"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sequence":"ACGTACGT"}''')
+    async with Client("http://127.0.0.1:8032/mcp") as client:
+        result = await client.call_tool("run_chrombpnet_predict", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, total_counts, and a bounded profile. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-chrombpnet`.
+- Revoke temporary keys. After confirmation, remove only .venvs/chrombpnet, caches/chrombpnet, and runs/chrombpnet; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-depmap-24q2-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-depmap-24q2-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-depmap-24q2-remote-tool
+description: Set up, launch, validate, and troubleshoot the DepMap 24Q2 ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up DepMap 24Q2 as a remote tool
+
+> Validation status (2026-08-16): loopback discovery and correlation retrieval passed against a deterministic safe artifact fixture with finite bounded output. Production DepMap 24Q2 data, public publication, cross-user isolation, scale, and scientific-value validation remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; size RAM for the provider dataset.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation depmap-24q2
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/depmap-24q2
+. .venvs/depmap-24q2/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/depmap_24q2/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set DEPMAP_DATA_PATH to the reviewed provider artifact; it initializes once per process. Confirm DepMap data-use terms.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share depmap-24q2
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share depmap-24q2 --name my-depmap-24q2-remote --workers 1
+~~~
+
+Use `tu remote check depmap-24q2` for a non-sharing readiness check and
+`tu remote run depmap-24q2` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/depmap-24q2 runs/depmap-24q2
+python -m tooluniverse.remote.depmap_24q2.depmap_24q2_mcp_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:7002/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:7002/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains compute_depmap24q2_gene_correlations; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:7002/mcp --json
+tu serve --share --forward http://127.0.0.1:7002/mcp --name validation-depmap-24q2 --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: compute_depmap24q2_gene_correlations
+
+~~~json
+{"gene_a":"BRAF","gene_b":"MAPK1"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"gene_a":"BRAF","gene_b":"MAPK1"}''')
+    async with Client("http://127.0.0.1:7002/mcp") as client:
+        result = await client.call_tool("compute_depmap24q2_gene_correlations", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: correlation_data with bounded gene-correlation records. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-depmap-24q2`.
+- Revoke temporary keys. After confirmation, remove only .venvs/depmap-24q2, caches/depmap-24q2, and runs/depmap-24q2; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-enformer-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-enformer-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-enformer-remote-tool
+description: Set up, launch, validate, and troubleshoot the Enformer ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Enformer as a remote tool
+
+> Validation status (2026-08-16): official Enformer weights loaded on the GB10; live loopback prediction and variant-effect calls returned bounded finite track results. Public publication, cross-user isolation, broad concurrency, recovery, and biological accuracy remain incomplete; keep this deployment private. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended; CPU inference is slow.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation enformer
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/enformer
+. .venvs/enformer/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/enformer/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Keep HF_HOME and TORCH_HOME below caches/enformer. The provider controls model acquisition; review model/output licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share enformer
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share enformer --name my-enformer-remote --workers 1
+~~~
+
+Use `tu remote check enformer` for a non-sharing readiness check and
+`tu remote run enformer` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/enformer runs/enformer
+python -m tooluniverse.remote.enformer.enformer_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8011/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8011/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_enformer_predict; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8011/mcp --json
+tu serve --share --forward http://127.0.0.1:8011/mcp --name validation-enformer --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_enformer_predict
+
+~~~json
+{"sequence":"ACGTACGT","organism":"human","top_n":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sequence":"ACGTACGT","organism":"human","top_n":1}''')
+    async with Client("http://127.0.0.1:8011/mcp") as client:
+        result = await client.call_tool("run_enformer_predict", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, organism, n_tracks, and a bounded tracks array. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-enformer`.
+- Revoke temporary keys. After confirmation, remove only .venvs/enformer, caches/enformer, and runs/enformer; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-esm-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-esm-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-esm-remote-tool
+description: Set up, launch, validate, and troubleshoot the ESM ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up ESM as a remote tool
+
+> Validation status (2026-08-16): the pinned official ESM source and esmc_300m checkpoint loaded on the GB10; a live loopback call returned a finite 960-dimensional embedding. Public publication, cross-user isolation, broad concurrency, recovery, and embedding-quality validation remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended for larger proteins; CPU can validate short sequences.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation esm
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/esm
+. .venvs/esm/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/esm/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Keep HF_HOME and TORCH_HOME below caches/esm. Model access may require provider network; review the selected ESM license.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share esm
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share esm --name my-esm-remote --workers 1
+~~~
+
+Use `tu remote check esm` for a non-sharing readiness check and
+`tu remote run esm` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/esm runs/esm
+python -m tooluniverse.remote.esm.esm_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8008/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8008/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains esm_embed_sequence; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8008/mcp --json
+tu serve --share --forward http://127.0.0.1:8008/mcp --name validation-esm --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: esm_embed_sequence
+
+~~~json
+{"sequence":"MKT"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sequence":"MKT"}''')
+    async with Client("http://127.0.0.1:8008/mcp") as client:
+        result = await client.call_tool("esm_embed_sequence", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: a finite bounded embedding plus sequence/model metadata. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-esm`.
+- Revoke temporary keys. After confirmation, remove only .venvs/esm, caches/esm, and runs/esm; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-expert-feedback-remote-tool/SKILL.md

@@ -0,0 +1,181 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-expert-feedback-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-expert-feedback-remote-tool
+description: Set up, launch, validate, and troubleshoot the Human expert feedback ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Human expert feedback as a remote tool
+
+> Validation status (2026-08-16): a clean Python 3.12.3 dependency install, loopback discovery of all five MCP tools, a complete two-client synthetic request/response lifecycle, and the Flask companion health endpoint passed. Public publication, independent-identity authorization, production WSGI deployment, retention/consent procedures, concurrency, and resource measurements remain incomplete; keep this deployment private until they pass. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; requires a staffed human-review workflow.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation expert-feedback
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/expert-feedback
+. .venvs/expert-feedback/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install fastmcp flask requests
+~~~
+
+The clean-install commands passed in the validation workspace; rerun them on the deployment host and retain the resulting lock/install evidence.
+
+## Obtain credentials, data, and model weights
+
+- For non-loopback MCP/API/web binding set TOOLUNIVERSE_API_TOKEN and forward the bearer token internally. Define retention, consent, access-control, and operator procedures.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share expert-feedback
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share expert-feedback --name my-expert-feedback-remote --workers 2
+~~~
+
+Use `tu remote check expert-feedback` for a non-sharing readiness check and
+`tu remote run expert-feedback` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/expert-feedback runs/expert-feedback
+python -m tooluniverse.remote.expert_feedback.human_expert_mcp_tools --start-server --port 9876
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:9876/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:9876/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains consult_human_expert; stop on empty, duplicate, or schema-drifted discovery.
+Also require `curl --fail http://127.0.0.1:9877/health`; `/api/health` is not a
+valid route.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:9876/mcp --json
+tu serve --share --forward http://127.0.0.1:9876/mcp --name validation-expert-feedback --workers 2
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 2.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: consult_human_expert
+
+~~~json
+{"question":"Review this synthetic result.","context":"No private or patient data."}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"question":"Review this synthetic result.","context":"No private or patient data."}''')
+    async with Client("http://127.0.0.1:9876/mcp") as client:
+        result = await client.call_tool("consult_human_expert", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: a request identifier and queued/pending lifecycle status, followed by a completed response after expert submission. The validation fixture completed this lifecycle between two same-host MCP clients; it did not establish independent-user authorization. Check output bounds, invalid-input behavior, retention policy, and absence of paths, secrets, and traces.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-expert-feedback`.
+- Revoke temporary keys. After confirmation, remove only .venvs/expert-feedback, caches/expert-feedback, and runs/expert-feedback; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-harmony-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-harmony-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-harmony-remote-tool
+description: Set up, launch, validate, and troubleshoot the Harmony ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Harmony as a remote tool
+
+> Validation status (2026-08-16): Harmony 2.0, loopback discovery/call, and invalid-input checks passed; the current deterministic two-batch call returned an aligned finite 240 x 10 embedding. Public publication, cross-user isolation, representative correction accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU is normally sufficient; size RAM for the expression matrix.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation harmony
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/harmony
+. .venvs/harmony/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/harmony/requirements.txt
+~~~
+
+The clean-install commands passed in the validation workspace; rerun them on the deployment host and retain the resulting lock/install evidence.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. batch_key must exist in obs; verify dataset rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share harmony
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share harmony --name my-harmony-remote --workers 1
+~~~
+
+Use `tu remote check harmony` for a non-sharing readiness check and
+`tu remote run harmony` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/harmony runs/harmony
+python -m tooluniverse.remote.harmony.harmony_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8026/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8026/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_harmony_integrate; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8026/mcp --json
+tu serve --share --forward http://127.0.0.1:8026/mcp --name validation-harmony --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_harmony_integrate
+
+~~~json
+{"adata_path":"tiny.h5ad","batch_key":"batch","n_pcs":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","batch_key":"batch","n_pcs":2}''')
+    async with Client("http://127.0.0.1:8026/mcp") as client:
+        result = await client.call_tool("run_harmony_integrate", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: n_cells, n_pcs, batch metadata, and a bounded corrected_embedding. The validation fixture returned a finite 300 x 10 embedding across two batches; treat this as runtime/transport evidence, not representative batch-correction accuracy. Check scientific meaning, output bounds, invalid-input behavior, and absence of paths, secrets, and traces on deployment data.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-harmony`.
+- Revoke temporary keys. After confirmation, remove only .venvs/harmony, caches/harmony, and runs/harmony; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-immune-compass-remote-tool/SKILL.md

@@ -0,0 +1,193 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-immune-compass-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-immune-compass-remote-tool
+description: Set up, launch, validate, and troubleshoot the immune COMPASS ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up immune COMPASS as a remote tool
+
+> Validation status (2026-08-16): working CPU deployment. The live MCP call ran the official all-cohort COMPASS checkpoint, converted to safetensors plus data-only preprocessing, on the official GIDE sample. In the pinned `torch==2.10.0` environment, the safe artifact and upstream checkpoint had zero difference in both class probabilities and all 44 concept scores. This is execution-equivalence evidence, not a clinical-accuracy benchmark. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- The validated deployment uses CPU. GPU availability alone does not justify changing the device without a separate equivalence and resource test.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation immune-compass
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/immune-compass
+. .venvs/immune-compass/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/immune_compass/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain data and provision safe model weights
+
+- Obtain the official COMPASS source/checkpoint and confirm model/data terms. The validated source revision is `0e5c87665247e3a300f28282c8bbcc14e26973bd`; `example/model/finetuner_pft_all.pt` has SHA-256 `fc83d7b5eac3697bcd9d117acefa35b56cf4c4c3c5880de367c85a870aef4b0b`.
+- In an isolated provisioning environment only, convert that reviewed whole-object checkpoint:
+
+~~~bash
+python src/tooluniverse/remote/immune_compass/convert_checkpoint.py \
+  caches/compass/source/finetuner_pft_all.pt \
+  caches/compass/safe-model \
+  --expected-sha256 fc83d7b5eac3697bcd9d117acefa35b56cf4c4c3c5880de367c85a870aef4b0b \
+  --upstream-revision 0e5c87665247e3a300f28282c8bbcc14e26973bd
+export COMPASS_SAFE_MODEL_DIR="$PWD/caches/compass/safe-model"
+~~~
+
+The live server must never call `torch.load` or `loadcompass`. It verifies the emitted digests and loads only safetensors, JSON metadata, and an `allow_pickle=False` preprocessing NPZ.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share immune-compass
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share immune-compass --name my-immune-compass-remote --workers 1
+~~~
+
+Use `tu remote check immune-compass` for a non-sharing readiness check and
+`tu remote run immune-compass` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/immune-compass runs/immune-compass
+export COMPASS_SAFE_MODEL_DIR="$PWD/caches/compass/safe-model"
+export COMPASS_DEVICE=cpu
+python -m tooluniverse.remote.immune_compass.compass_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:7003/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:7003/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_compass_prediction; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:7003/mcp --json
+tu serve --share --forward http://127.0.0.1:7003/mcp --name validation-immune-compass --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_compass_prediction
+
+~~~json
+{"gene_expression_data_path":"compass_gide_official_sample_1.tsv","threshold":0.5}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"gene_expression_data_path":"compass_gide_official_sample_1.tsv","threshold":0.5}''')
+    async with Client("http://127.0.0.1:7003/mcp") as client:
+        result = await client.call_tool("run_compass_prediction", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: a finite `responder_probability`, the applied `threshold`, `is_responder`, at most 44 finite ranked `top_concepts`, and model provenance containing `artifact_format=compass-safe-v1`, the pinned source digest/revision, and device. The validated official sample returned a non-responder probability of approximately `1.2848061e-20` and ranked `Mast` first. This is not a clinical-validity claim.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-immune-compass`.
+- Revoke temporary keys. After confirmation, remove only .venvs/immune-compass, caches/immune-compass, and runs/immune-compass; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-ldsc-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-ldsc-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-ldsc-remote-tool
+description: Set up, launch, validate, and troubleshoot the LDSC ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up LDSC as a remote tool
+
+> Validation status (2026-08-16): CBIIT LDSC and its official simulation ran through live loopback MCP; heritability and genetic-correlation calls returned finite parsed statistics. Real population panels, public publication, cross-user isolation, broad concurrency, and biological validation remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; size RAM/disk for LD-score panels.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation ldsc
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/ldsc
+. .venvs/ldsc/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/ldsc/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT, LDSC_DIR, and LDSC_REF_DIR to reviewed provider resources. Verify cohort/panel/output licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share ldsc
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share ldsc --name my-ldsc-remote --workers 1
+~~~
+
+Use `tu remote check ldsc` for a non-sharing readiness check and
+`tu remote run ldsc` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/ldsc runs/ldsc
+python -m tooluniverse.remote.ldsc.ldsc_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8013/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8013/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_ldsc_heritability; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8013/mcp --json
+tu serve --share --forward http://127.0.0.1:8013/mcp --name validation-ldsc --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_ldsc_heritability
+
+~~~json
+{"sumstats_path":"tiny.sumstats.gz"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sumstats_path":"tiny.sumstats.gz"}''')
+    async with Client("http://127.0.0.1:8013/mcp") as client:
+        result = await client.call_tool("run_ldsc_heritability", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, analysis, and finite heritability statistics. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-ldsc`.
+- Revoke temporary keys. After confirmation, remove only .venvs/ldsc, caches/ldsc, and runs/ldsc; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-liana-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-liana-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-liana-remote-tool
+description: Set up, launch, validate, and troubleshoot the LIANA ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up LIANA as a remote tool
+
+> Validation status (2026-08-16): LIANA dependencies, loopback discovery, and a deterministic CellPhoneDB-method call passed with ten bounded interactions. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU sufficient for small data; size RAM for AnnData.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation liana
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/liana
+. .venvs/liana/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/liana/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. Input should be log1p-normalized and cluster_key must exist; verify data/resource licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share liana
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share liana --name my-liana-remote --workers 1
+~~~
+
+Use `tu remote check liana` for a non-sharing readiness check and
+`tu remote run liana` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/liana runs/liana
+python -m tooluniverse.remote.liana.liana_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8017/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8017/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_liana_cellphonedb; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8017/mcp --json
+tu serve --share --forward http://127.0.0.1:8017/mcp --name validation-liana --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_liana_cellphonedb
+
+~~~json
+{"adata_path":"tiny.h5ad","cluster_key":"cell_type","top_n":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","cluster_key":"cell_type","top_n":2}''')
+    async with Client("http://127.0.0.1:8017/mcp") as client:
+        result = await client.call_tool("run_liana_cellphonedb", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: method, cluster_key, n_interactions, and bounded records. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-liana`.
+- Revoke temporary keys. After confirmation, remove only .venvs/liana, caches/liana, and runs/liana; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-macs3-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-macs3-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-macs3-remote-tool
+description: Set up, launch, validate, and troubleshoot the MACS3 ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up MACS3 as a remote tool
+
+> Validation status (2026-08-16): compiled MACS3 3.0.4, loopback discovery/call, and provider-root rejection passed; the current documented no-model/fixed-extension synthetic BED call returned three peaks. Public publication, cross-user isolation, representative accuracy, broad concurrency, cancellation, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; allocate temporary disk for alignment files.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation macs3
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/macs3
+. .venvs/macs3/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/macs3/requirements.txt
+~~~
+
+The clean install passed with a workspace-local CPython distribution containing development headers. On ARM64 hosts without MACS3 wheels, ensure Python development headers are available before building, and retain the resulting install evidence.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT for provider-owned BED/BAM files. Only approved relative treatment/control paths are accepted; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share macs3
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share macs3 --name my-macs3-remote --workers 1
+~~~
+
+Use `tu remote check macs3` for a non-sharing readiness check and
+`tu remote run macs3` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/macs3 runs/macs3
+python -m tooluniverse.remote.macs3.macs3_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8021/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8021/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_macs3_callpeak; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8021/mcp --json
+tu serve --share --forward http://127.0.0.1:8021/mcp --name validation-macs3 --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_macs3_callpeak
+
+~~~json
+{"treatment":"tiny.bed","format":"BED","genome_size":"hs","top_n":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"treatment":"tiny.bed","format":"BED","genome_size":"hs","top_n":2}''')
+    async with Client("http://127.0.0.1:8021/mcp") as client:
+        result = await client.call_tool("run_macs3_callpeak", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: n_peaks, bounded top_peaks, summary, and run parameters. The validation fixture returned three peaks and finite bounded summaries; treat this as subprocess/parser/transport evidence, not representative peak-calling accuracy. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces on deployment data.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-macs3`.
+- Revoke temporary keys. After confirmation, remove only .venvs/macs3, caches/macs3, and runs/macs3; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-milo-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-milo-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-milo-remote-tool
+description: Set up, launch, validate, and troubleshoot the Milo ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Milo as a remote tool
+
+> Validation status (2026-08-16): pertpy/Milo dependencies, loopback discovery, and a deterministic two-condition call passed with 21 neighborhoods and finite bounded statistics. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU sufficient for small data; size RAM for graph/count matrices.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation milo
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/milo
+. .venvs/milo/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/milo/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. sample_col/condition_col must exist and represent a suitable design; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share milo
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share milo --name my-milo-remote --workers 1
+~~~
+
+Use `tu remote check milo` for a non-sharing readiness check and
+`tu remote run milo` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/milo runs/milo
+python -m tooluniverse.remote.milo.milo_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8023/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8023/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_milo_differential_abundance; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8023/mcp --json
+tu serve --share --forward http://127.0.0.1:8023/mcp --name validation-milo --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_milo_differential_abundance
+
+~~~json
+{"adata_path":"tiny.h5ad","sample_col":"sample","condition_col":"condition","n_neighbors":5}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","sample_col":"sample","condition_col":"condition","n_neighbors":5}''')
+    async with Client("http://127.0.0.1:8023/mcp") as client:
+        result = await client.call_tool("run_milo_differential_abundance", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: neighborhood counts and a bounded differential-abundance summary. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-milo`.
+- Revoke temporary keys. After confirmation, remove only .venvs/milo, caches/milo, and runs/milo; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-mofa-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-mofa-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-mofa-remote-tool
+description: Set up, launch, validate, and troubleshoot the MOFA+ ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up MOFA+ as a remote tool
+
+> Validation status (2026-08-16): MOFA+ 0.7.4, loopback discovery/call, and non-finite-input rejection passed; the current 30-sample/two-view fixture returned two non-degenerate factors and variance components. Public publication, cross-user isolation, representative multi-omics accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU sufficient for minimal input; GPU support is backend-dependent.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation mofa
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/mofa
+. .venvs/mofa/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/mofa/requirements.txt
+~~~
+
+The clean-install commands passed in the validation workspace; rerun them on the deployment host and retain the resulting lock/install evidence.
+
+## Obtain credentials, data, and model weights
+
+- No credential is needed for synthetic inline views. Do not send private matrices to shared deployments; review input and MOFA+ licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share mofa
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share mofa --name my-mofa-remote --workers 1
+~~~
+
+Use `tu remote check mofa` for a non-sharing readiness check and
+`tu remote run mofa` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/mofa runs/mofa
+python -m tooluniverse.remote.mofa.mofa_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8024/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8024/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_mofa_factors; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8024/mcp --json
+tu serve --share --forward http://127.0.0.1:8024/mcp --name validation-mofa --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_mofa_factors
+
+~~~json
+{"views":{"rna":{"g1":[1,2],"g2":[3,4]},"protein":{"p1":[2,1],"p2":[4,3]}},"n_factors":1,"n_iter":10}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"views":{"rna":{"g1":[1,2],"g2":[3,4]},"protein":{"p1":[2,1],"p2":[4,3]}},"n_factors":1,"n_iter":10}''')
+    async with Client("http://127.0.0.1:8024/mcp") as client:
+        result = await client.call_tool("run_mofa_factors", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: sample/view/factor counts, finite variance_explained, and bounded factors. The validation fixture returned finite 24 x 2 factors and variance summaries, but its small feature counts are not biologically meaningful. Check scientific meaning, output bounds, convergence, invalid-input behavior, and absence of paths, secrets, and traces on representative deployment data.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-mofa`.
+- Revoke temporary keys. After confirmation, remove only .venvs/mofa, caches/mofa, and runs/mofa; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-monocle3-remote-tool/SKILL.md

@@ -0,0 +1,180 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-monocle3-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-monocle3-remote-tool
+description: Set up, launch, validate, and troubleshoot the Monocle 3 ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Monocle 3 as a remote tool
+
+> Validation status (2026-08-16): R 4.4.3/Monocle3 1.4.27, loopback discovery, and two deterministic 240-cell calls passed with finite pseudotime for all cells; both disclosed the acyclic fallback after the upstream loop-closing bug. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; R spatial dependencies can require substantial RAM.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation monocle3
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/monocle3
+. .venvs/monocle3/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/monocle3/requirements.txt
+Rscript -e 'install.packages(c("BiocManager","remotes","Matrix","jsonlite")); BiocManager::install(c("SingleCellExperiment","batchelor","leidenbase","ggrastr")); remotes::install_github("cole-trapnell-lab/monocle3")'
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT and optionally RSCRIPT_BIN. Choose defensible roots; verify input/dependency licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share monocle3
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share monocle3 --name my-monocle3-remote --workers 1
+~~~
+
+Use `tu remote check monocle3` for a non-sharing readiness check and
+`tu remote run monocle3` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/monocle3 runs/monocle3
+python -m tooluniverse.remote.monocle3.monocle3_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8031/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8031/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_monocle3_pseudotime; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8031/mcp --json
+tu serve --share --forward http://127.0.0.1:8031/mcp --name validation-monocle3 --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_monocle3_pseudotime
+
+~~~json
+{"adata_path":"tiny.h5ad","root_cells":["cell-1"],"num_dim":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","root_cells":["cell-1"],"num_dim":2}''')
+    async with Client("http://127.0.0.1:8031/mcp") as client:
+        result = await client.call_tool("run_monocle3_pseudotime", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, cell count, `graph_learning` (`default` or the disclosed `close_loop_false_fallback`), and bounded aligned pseudotime values. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-monocle3`.
+- Revoke temporary keys. After confirmation, remove only .venvs/monocle3, caches/monocle3, and runs/monocle3; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-paga-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-paga-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-paga-remote-tool
+description: Set up, launch, validate, and troubleshoot the PAGA ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up PAGA as a remote tool
+
+> Validation status (2026-08-16): Scanpy/PAGA, loopback discovery/call, and invalid-cluster rejection passed on connected deterministic trajectories, including the current finite 3 x 3 matrix. A fully disconnected fixture still triggers a sanitized upstream failure. Public publication, cross-user isolation, representative accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU sufficient for small datasets.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation paga
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/paga
+. .venvs/paga/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/paga/requirements.txt
+~~~
+
+The clean-install commands passed in the validation workspace; rerun them on the deployment host and retain the resulting lock/install evidence.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. cluster_key must contain bounded valid categories; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share paga
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share paga --name my-paga-remote --workers 1
+~~~
+
+Use `tu remote check paga` for a non-sharing readiness check and
+`tu remote run paga` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/paga runs/paga
+python -m tooluniverse.remote.paga.paga_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8022/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8022/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_paga_trajectory; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8022/mcp --json
+tu serve --share --forward http://127.0.0.1:8022/mcp --name validation-paga --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_paga_trajectory
+
+~~~json
+{"adata_path":"tiny.h5ad","cluster_key":"cluster","threshold":0.1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","cluster_key":"cluster","threshold":0.1}''')
+    async with Client("http://127.0.0.1:8022/mcp") as client:
+        result = await client.call_tool("run_paga_trajectory", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: clusters, a finite connectivity_matrix, and bounded edges. The connected validation fixture returned a finite symmetric 3 x 3 matrix; treat this as runtime/transport evidence, not representative trajectory accuracy. Also test a disconnected graph against the exact deployed Scanpy/igraph versions. Check scientific meaning, output bounds, invalid-input behavior, and absence of paths, secrets, and traces.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-paga`.
+- Revoke temporary keys. After confirmation, remove only .venvs/paga, caches/paga, and runs/paga; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-pinnacle-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-pinnacle-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-pinnacle-remote-tool
+description: Set up, launch, validate, and troubleshoot the PINNACLE ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up PINNACLE as a remote tool
+
+> Validation status (2026-08-16): loopback discovery and retrieval passed against a deterministic safe weights-only fixture with three bounded embeddings. Production PINNACLE artifacts, public publication, cross-user isolation, scale, and scientific-value validation remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only for retrieval; size RAM for embeddings.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation pinnacle
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/pinnacle
+. .venvs/pinnacle/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/pinnacle/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set PINNACLE_DATA_PATH to the reviewed provider artifact; it initializes once per process. Confirm provenance/redistribution terms.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share pinnacle
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share pinnacle --name my-pinnacle-remote --workers 1
+~~~
+
+Use `tu remote check pinnacle` for a non-sharing readiness check and
+`tu remote run pinnacle` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/pinnacle runs/pinnacle
+python -m tooluniverse.remote.pinnacle.pinnacle_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:7001/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:7001/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_pinnacle_ppi_retrieval; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:7001/mcp --json
+tu serve --share --forward http://127.0.0.1:7001/mcp --name validation-pinnacle --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_pinnacle_ppi_retrieval
+
+~~~json
+{"cell_type":"B cell","max_proteins":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"cell_type":"B cell","max_proteins":2}''')
+    async with Client("http://127.0.0.1:7001/mcp") as client:
+        result = await client.call_tool("run_pinnacle_ppi_retrieval", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: bounded protein/embedding retrieval metadata. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-pinnacle`.
+- Revoke temporary keys. After confirmation, remove only .venvs/pinnacle, caches/pinnacle, and runs/pinnacle; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-scanvi-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scanvi-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-scanvi-remote-tool
+description: Set up, launch, validate, and troubleshoot the scANVI ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up scANVI as a remote tool
+
+> Validation status (2026-08-16): scANVI dependencies, GB10 execution, loopback discovery, and a bounded labeled/unlabeled annotation call passed with aligned predictions. Public publication, cross-user isolation, representative accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended for training; CPU only for tiny tests.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation scanvi
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/scanvi
+. .venvs/scanvi/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/scanvi/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. labels_key/unlabeled_category must match obs; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share scanvi
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share scanvi --name my-scanvi-remote --workers 1
+~~~
+
+Use `tu remote check scanvi` for a non-sharing readiness check and
+`tu remote run scanvi` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/scanvi runs/scanvi
+python -m tooluniverse.remote.scanvi.scanvi_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8027/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8027/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_scanvi_annotate; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8027/mcp --json
+tu serve --share --forward http://127.0.0.1:8027/mcp --name validation-scanvi --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_scanvi_annotate
+
+~~~json
+{"adata_path":"tiny.h5ad","labels_key":"label","unlabeled_category":"Unknown","scvi_epochs":1,"scanvi_epochs":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","labels_key":"label","unlabeled_category":"Unknown","scvi_epochs":1,"scanvi_epochs":1}''')
+    async with Client("http://127.0.0.1:8027/mcp") as client:
+        result = await client.call_tool("run_scanvi_annotate", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: cell counts, bounded label_counts, and optional bounded predictions. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-scanvi`.
+- Revoke temporary keys. After confirmation, remove only .venvs/scanvi, caches/scanvi, and runs/scanvi; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-scrublet-remote-tool/SKILL.md

@@ -0,0 +1,180 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scrublet-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-scrublet-remote-tool
+description: Set up, launch, validate, and troubleshoot the Scrublet ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Scrublet as a remote tool
+
+> Validation status (2026-08-16): installation, direct/live MCP calls, traversal rejection, and prior same-host concurrency levels 1, 2, and 4 passed. Two current 500-cell calls returned finite aligned results and 429 synthetic predictions; that 85.8% fixture rate is not an accuracy result. Public publication, cross-user isolation, representative accuracy, cancellation, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; size RAM for count matrices.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation scrublet
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/scrublet
+. .venvs/scrublet/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/scrublet/requirements.txt
+~~~
+
+The clean-install commands passed in the validation workspace; rerun them on the deployment host and retain the resulting lock/install evidence.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. Input must contain suitable raw counts; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share scrublet
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share scrublet --name my-scrublet-remote --workers 1
+~~~
+
+Use `tu remote check scrublet` for a non-sharing readiness check and
+`tu remote run scrublet` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/scrublet runs/scrublet
+python -m tooluniverse.remote.scrublet.scrublet_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8015/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8015/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_scrublet_doublets; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8015/mcp --json
+tu serve --share --forward http://127.0.0.1:8015/mcp --name validation-scrublet --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_scrublet_doublets
+
+~~~json
+{"adata_path":"tiny.h5ad","expected_doublet_rate":0.06}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","expected_doublet_rate":0.06}''')
+    async with Client("http://127.0.0.1:8015/mcp") as client:
+        result = await client.call_tool("run_scrublet_doublets", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: n_doublets, n_cells, doublet_rate, and per-cell arrays only below the cap. The validation fixture returned 500 finite scores/predictions and 81 predicted doublets; treat this as transport/runtime evidence, not biological-accuracy evidence. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces on deployment data.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- The validation host completed two warmups and concurrency levels 1, 2, and 4 without errors; level 4 took 0.512 seconds wall time for four identical 500-cell calls. Peak RAM and production saturation were not measured.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-scrublet`.
+- Revoke temporary keys. After confirmation, remove only .venvs/scrublet, caches/scrublet, and runs/scrublet; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-scvelo-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scvelo-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-scvelo-remote-tool
+description: Set up, launch, validate, and troubleshoot the scVelo ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up scVelo as a remote tool
+
+> Validation status (2026-08-16): scVelo dependencies, loopback discovery, and deterministic-mode execution passed on the upstream simulation with aligned finite pseudotime/confidence for 300 cells. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU sufficient for small stochastic runs; GPU not required.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation scvelo
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/scvelo
+. .venvs/scvelo/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/scvelo/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. Input needs appropriate spliced/unspliced layers; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share scvelo
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share scvelo --name my-scvelo-remote --workers 1
+~~~
+
+Use `tu remote check scvelo` for a non-sharing readiness check and
+`tu remote run scvelo` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/scvelo runs/scvelo
+python -m tooluniverse.remote.scvelo.scvelo_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8025/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8025/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_scvelo_velocity; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8025/mcp --json
+tu serve --share --forward http://127.0.0.1:8025/mcp --name validation-scvelo --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_scvelo_velocity
+
+~~~json
+{"adata_path":"tiny.h5ad","mode":"stochastic"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","mode":"stochastic"}''')
+    async with Client("http://127.0.0.1:8025/mcp") as client:
+        result = await client.call_tool("run_scvelo_velocity", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: cell count plus finite bounded velocity/pseudotime summaries. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-scvelo`.
+- Revoke temporary keys. After confirmation, remove only .venvs/scvelo, caches/scvelo, and runs/scvelo; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-scvi-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scvi-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-scvi-remote-tool
+description: Set up, launch, validate, and troubleshoot the scVI ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up scVI as a remote tool
+
+> Validation status (2026-08-16): scVI dependencies, GB10 execution, loopback discovery, integration, and differential-expression calls passed on a bounded deterministic fixture with aligned finite output. Public publication, cross-user isolation, representative accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended for training; CPU only for tiny tests.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation scvi
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/scvi
+. .venvs/scvi/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/scvi/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. Input should contain counts and valid batch/group annotations; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share scvi
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share scvi --name my-scvi-remote --workers 1
+~~~
+
+Use `tu remote check scvi` for a non-sharing readiness check and
+`tu remote run scvi` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/scvi runs/scvi
+python -m tooluniverse.remote.scvi.scvi_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8010/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8010/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_scvi_integration; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8010/mcp --json
+tu serve --share --forward http://127.0.0.1:8010/mcp --name validation-scvi --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_scvi_integration
+
+~~~json
+{"adata_path":"tiny.h5ad","n_latent":2,"max_epochs":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","n_latent":2,"max_epochs":1}''')
+    async with Client("http://127.0.0.1:8010/mcp") as client:
+        result = await client.call_tool("run_scvi_integration", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model metadata and a finite latent representation or bounded summary. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-scvi`.
+- Revoke temporary keys. After confirmation, remove only .venvs/scvi, caches/scvi, and runs/scvi; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-singler-remote-tool/SKILL.md

@@ -0,0 +1,180 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-singler-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-singler-remote-tool
+description: Set up, launch, validate, and troubleshoot the SingleR ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up SingleR as a remote tool
+
+> Validation status (2026-08-16): R 4.4.3/SingleR 2.8.0, loopback discovery, and a deterministic query/reference call passed with 240 aligned labels. Public publication, cross-user isolation, representative reference/accuracy validation, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; size RAM for test/reference matrices.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation singler
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/singler
+. .venvs/singler/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/singler/requirements.txt
+Rscript -e 'if (!requireNamespace("BiocManager", quietly=TRUE)) install.packages("BiocManager"); BiocManager::install(c("SingleR","celldex","Matrix","jsonlite"))'
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT and optionally RSCRIPT_BIN. Use only approved built-in/relative references; verify licenses.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share singler
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share singler --name my-singler-remote --workers 1
+~~~
+
+Use `tu remote check singler` for a non-sharing readiness check and
+`tu remote run singler` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/singler runs/singler
+python -m tooluniverse.remote.singler.singler_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8029/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8029/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_singler_annotate; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8029/mcp --json
+tu serve --share --forward http://127.0.0.1:8029/mcp --name validation-singler --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_singler_annotate
+
+~~~json
+{"adata_path":"tiny.h5ad","celldex_ref":"HumanPrimaryCellAtlasData","ref_label_field":"label.main"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","celldex_ref":"HumanPrimaryCellAtlasData","ref_label_field":"label.main"}''')
+    async with Client("http://127.0.0.1:8029/mcp") as client:
+        result = await client.call_tool("run_singler_annotate", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: reference metadata, label counts, and bounded predicted labels. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-singler`.
+- Revoke temporary keys. After confirmation, remove only .venvs/singler, caches/singler, and runs/singler; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-slingshot-remote-tool/SKILL.md

@@ -0,0 +1,180 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-slingshot-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-slingshot-remote-tool
+description: Set up, launch, validate, and troubleshoot the Slingshot ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Slingshot as a remote tool
+
+> Validation status (2026-08-16): R 4.4.3/Slingshot 2.14.0, loopback discovery, and a deterministic call passed with two lineages and bounded aligned pseudotime for 240 cells. Public publication, cross-user isolation, representative biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; size RAM for embeddings/R objects.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation slingshot
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/slingshot
+. .venvs/slingshot/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/slingshot/requirements.txt
+Rscript -e 'if (!requireNamespace("BiocManager", quietly=TRUE)) install.packages("BiocManager"); BiocManager::install(c("slingshot","Matrix","jsonlite"))'
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT and optionally RSCRIPT_BIN. Required obs/obsm keys must exist; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share slingshot
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share slingshot --name my-slingshot-remote --workers 1
+~~~
+
+Use `tu remote check slingshot` for a non-sharing readiness check and
+`tu remote run slingshot` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/slingshot runs/slingshot
+python -m tooluniverse.remote.slingshot.slingshot_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8030/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8030/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_slingshot_trajectory; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8030/mcp --json
+tu serve --share --forward http://127.0.0.1:8030/mcp --name validation-slingshot --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_slingshot_trajectory
+
+~~~json
+{"adata_path":"tiny.h5ad","cluster_key":"cluster","embedding_key":"X_umap"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","cluster_key":"cluster","embedding_key":"X_umap"}''')
+    async with Client("http://127.0.0.1:8030/mcp") as client:
+        result = await client.call_tool("run_slingshot_trajectory", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: model, lineages, cell count, and bounded aligned pseudotime. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-slingshot`.
+- Revoke temporary keys. After confirmation, remove only .venvs/slingshot, caches/slingshot, and runs/slingshot; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-squidpy-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-squidpy-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-squidpy-remote-tool
+description: Set up, launch, validate, and troubleshoot the Squidpy ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Squidpy as a remote tool
+
+> Validation status (2026-08-16): Squidpy dependencies, loopback discovery, and a bounded 72-spot neighborhood-enrichment call passed with a finite 3 x 3 z-score matrix. Public publication, cross-user isolation, representative spatial biology, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only here; neighborhood enrichment forces one job.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation squidpy
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/squidpy
+. .venvs/squidpy/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/squidpy/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT. Input needs spatial coordinates and cluster_key; verify data rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share squidpy
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share squidpy --name my-squidpy-remote --workers 1
+~~~
+
+Use `tu remote check squidpy` for a non-sharing readiness check and
+`tu remote run squidpy` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/squidpy runs/squidpy
+python -m tooluniverse.remote.squidpy.squidpy_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8016/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8016/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_squidpy_nhood_enrichment; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8016/mcp --json
+tu serve --share --forward http://127.0.0.1:8016/mcp --name validation-squidpy --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_squidpy_nhood_enrichment
+
+~~~json
+{"adata_path":"tiny.h5ad","cluster_key":"cluster","n_neighs":2}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"adata_path":"tiny.h5ad","cluster_key":"cluster","n_neighs":2}''')
+    async with Client("http://127.0.0.1:8016/mcp") as client:
+        result = await client.call_tool("run_squidpy_nhood_enrichment", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: categories and a finite bounded category-by-category zscore_matrix. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-squidpy`.
+- Revoke temporary keys. After confirmation, remove only .venvs/squidpy, caches/squidpy, and runs/squidpy; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-tangram-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-tangram-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-tangram-remote-tool
+description: Set up, launch, validate, and troubleshoot the Tangram ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up Tangram as a remote tool
+
+> Validation status (2026-08-16): Tangram dependencies, loopback discovery, and a bounded five-epoch single-cell/spatial mapping call passed with normalized proportions across 72 spots. Public publication, cross-user isolation, production epochs, representative accuracy, broad concurrency, and recovery remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- GPU recommended for training; CPU only for tiny tests.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation tangram
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/tangram
+. .venvs/tangram/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/tangram/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TOOLUNIVERSE_REMOTE_DATA_ROOT for provider-owned H5AD files. Use relative paths and valid cluster_label; verify rights.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share tangram
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share tangram --name my-tangram-remote --workers 1
+~~~
+
+Use `tu remote check tangram` for a non-sharing readiness check and
+`tu remote run tangram` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/tangram runs/tangram
+python -m tooluniverse.remote.tangram.tangram_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8018/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8018/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_tangram_deconvolution; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8018/mcp --json
+tu serve --share --forward http://127.0.0.1:8018/mcp --name validation-tangram --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_tangram_deconvolution
+
+~~~json
+{"sc_path":"reference.h5ad","sp_path":"spatial.h5ad","cluster_label":"cell_type","num_epochs":1}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"sc_path":"reference.h5ad","sp_path":"spatial.h5ad","cluster_label":"cell_type","num_epochs":1}''')
+    async with Client("http://127.0.0.1:8018/mcp") as client:
+        result = await client.call_tool("run_tangram_deconvolution", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: cell-type proportions and a bounded spot matrix or compact summary. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-tangram`.
+- Revoke temporary keys. After confirmation, remove only .venvs/tangram, caches/tangram, and runs/tangram; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-transcriptformer-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-transcriptformer-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-transcriptformer-remote-tool
+description: Set up, launch, validate, and troubleshoot the TranscriptFormer ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up TranscriptFormer as a remote tool
+
+> Validation status (2026-08-16): loopback discovery and retrieval passed against deterministic safe metadata/embedding fixtures with bounded TP53 and EGFR output. Production TranscriptFormer artifacts, public publication, cross-user isolation, scale, and scientific-value validation remain incomplete. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only for retrieval; size RAM for embeddings.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation transcriptformer
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/transcriptformer
+. .venvs/transcriptformer/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install -r src/tooluniverse/remote/transcriptformer/requirements.txt
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set TRANSCRIPTFORMER_DATA_PATH to a reviewed artifact; it initializes once per process. Confirm atlas/artifact provenance and redistribution terms.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share transcriptformer
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share transcriptformer --name my-transcriptformer-remote --workers 1
+~~~
+
+Use `tu remote check transcriptformer` for a non-sharing readiness check and
+`tu remote run transcriptformer` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/transcriptformer runs/transcriptformer
+python -m tooluniverse.remote.transcriptformer.transcriptformer_tool
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:7000/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:7000/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains run_transcriptformer_embedding_retrieval; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:7000/mcp --json
+tu serve --share --forward http://127.0.0.1:7000/mcp --name validation-transcriptformer --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: run_transcriptformer_embedding_retrieval
+
+~~~json
+{"state":"control","cell_type":"b_cell","gene_names":["BRAF"],"disease":"breast_cancer"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"state":"control","cell_type":"b_cell","gene_names":["BRAF"],"disease":"breast_cancer"}''')
+    async with Client("http://127.0.0.1:7000/mcp") as client:
+        result = await client.call_tool("run_transcriptformer_embedding_retrieval", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: bounded contextual embedding records and query metadata. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-transcriptformer`.
+- Revoke temporary keys. After confirmation, remove only .venvs/transcriptformer, caches/transcriptformer, and runs/transcriptformer; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/catalogue/skills/setup-uspto-downloader-remote-tool/SKILL.md

@@ -0,0 +1,179 @@
+---
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-uspto-downloader-remote-tool/SKILL.md
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: unknown
+upstream_changes: accepted
+name: setup-uspto-downloader-remote-tool
+description: Set up, launch, validate, and troubleshoot the USPTO downloader ToolUniverse remote tool and optionally relay it through ToolUniverse Connect. Use when deploying or auditing this implementation.
+---
+
+# Set up USPTO downloader as a remote tool
+
+> Validation status (2026-08-16): boundary/parser tests and live loopback discovery passed; all three current calls reached USPTO and received HTTP 403 for an invalid validation key. No patent content was retrieved, so functional content retrieval, public publication, cross-user isolation, and extraction/load behavior remain blocked by credentials or unmeasured. Authenticated private Platform import and owner testing passed on 2026-08-16; public publication and independent-caller authorization/isolation remain untested.
+
+## Prerequisites
+
+- Run from the ToolUniverse repository root on Linux with Python 3.12.3.
+- CPU only; OCR requires bounded temporary RAM/disk.
+- Keep provider data, weights, caches, and credentials outside Git.
+- Bind to loopback. A non-loopback bind requires TOOLUNIVERSE_API_TOKEN; never put it in arguments or results.
+
+Run the standard-library contract check before downloading large dependencies:
+
+~~~bash
+python scripts/remote_validation/setup_skill_preflight.py --implementation uspto-downloader
+~~~
+
+After exporting provider resources, add `--check-provider-env`. After the
+server starts, add `--live` to verify the exact MCP tool set without running
+the model. Before sharing, add `--check-connect-prereqs`; this reports only
+whether a key is set and never prints its value.
+
+## Create an isolated environment
+
+~~~bash
+python3 -m venv .venvs/uspto-downloader
+. .venvs/uspto-downloader/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python -m pip install fastmcp requests pymupdf easyocr python-docx Pillow
+~~~
+
+Package/network-dependent commands must be rerun in a clean environment before marking this skill complete.
+
+## Obtain credentials, data, and model weights
+
+- Set USPTO_API_KEY only in the provider. Keep OCR caches below caches/uspto-downloader. Only approved USPTO HTTPS hosts are fetched; verify document reuse terms.
+
+## Authorize once, then share with one short command
+
+After installing dependencies, exporting the provider resources above, and
+installing the pinned relay SDK described under Connect below, run from the
+repository root. Log in only once per machine (and again after key
+rotation):
+
+~~~bash
+tu remote login
+# Or import an existing protected 0600 file without sourcing it:
+tu remote login --env-file /path/to/tooluniverse-service.env
+~~~
+
+Then each private share is one short command:
+
+~~~bash
+tu remote share uspto-downloader
+~~~
+
+By default, `tu remote login` requests a short-lived device code, opens the
+TU Platform approval page, and polls until the signed-in user approves. No key
+copy/paste is required. On a headless machine, add `--no-browser` and open the
+printed link elsewhere. The CLI exchanges the approval for a computer-only key,
+verifies `/remote-servers/preflight`, stores it in a local 0600 config file, and
+never displays it.
+
+The share command runs environment and TU Platform preflights, starts or reuses
+the exact loopback endpoint, validates discovery, and keeps the relay in the
+foreground until Ctrl-C. It automatically uses the reviewed Python, name,
+and worker count. Override them only when needed:
+
+~~~bash
+tu remote share uspto-downloader --name my-uspto-downloader-remote --workers 1
+~~~
+
+Use `tu remote check uspto-downloader` for a non-sharing readiness check and
+`tu remote run uspto-downloader` for a local-only foreground server.
+
+In an interactive terminal, sharing automatically starts the same browser flow
+when the key is missing, expired, or revoked. A malformed or revoked explicit
+`TOOLUNIVERSE_SERVICE_KEY` fails fast instead of being silently replaced; unset
+or correct it, then run `tu remote login`. Non-interactive jobs also fail fast.
+Use `tu remote logout` to remove only the local copy. Use `tu remote logout --revoke` to revoke the computer-only platform connection first; the server record remains offline for owner inspection.
+
+## Start and verify locally
+
+~~~bash
+mkdir -p caches/uspto-downloader runs/uspto-downloader
+python -m tooluniverse.remote.uspto_downloader.uspto_downloader_mcp_server
+~~~
+
+The Streamable HTTP endpoint is http://127.0.0.1:8081/mcp. In a second activated shell run:
+
+~~~bash
+python - <<'PY'
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://127.0.0.1:8081/mcp") as client:
+        print([tool.name for tool in await client.list_tools()])
+
+asyncio.run(main())
+PY
+~~~
+
+Confirm discovery contains get_abstract_from_patent_app_number; stop on empty, duplicate, or schema-drifted discovery.
+
+## Connect to ToolUniverse Connect
+
+The `tuplatform-connect` relay is not yet published on PyPI. Install the reviewed public wheel below; its SHA-256 is pinned. Interactive sharing uses browser device authorization, so no key copy/paste or GitHub access is required.
+
+~~~bash
+python -m pip install fastmcp pyyaml "tuplatform-connect @ https://connect.aiscientist.tools/downloads/tuplatform_connect-0.3.0-py3-none-any.whl#sha256=3fad5eee5ecf7887a693d93ccd1aa112dc0955617a885d1fc3daded0030f9ae0"
+tu doctor --forward http://127.0.0.1:8081/mcp --json
+tu serve --share --forward http://127.0.0.1:8081/mcp --name validation-uspto-downloader --workers 1
+~~~
+
+Prefer browser device authorization. For CI or migration, supply
+`TOOLUNIVERSE_SERVICE_KEY` only through a protected environment or use
+`tu remote login --manual-key`; never put a key in shell arguments.
+
+The authenticated 2026-08-16 Platform matrix found all 30 private owner relays online and all 41 operations discoverable. All imports remained unpublished owner drafts and were invoked through `/expert-sessions/{id}/test`. This implementation's draft(s) used a 120-second timeout and remote max concurrency 1.
+
+Across the set, 38 unique operations passed return-schema and semantic validation; the three USPTO operations returned exact provider HTTP 403 and remain credential-blocked. Public publication, independent-caller authorization/isolation, broad saturation, and persistent supervision were not tested.
+
+## Run a verified example
+
+Operation: get_abstract_from_patent_app_number
+
+~~~json
+{"applicationNumberText":"12345678"}
+~~~
+
+Invoke the example through the live local MCP endpoint:
+
+~~~bash
+python - <<'PY'
+import asyncio
+import json
+from fastmcp import Client
+
+async def main():
+    arguments = json.loads('''{"applicationNumberText":"12345678"}''')
+    async with Client("http://127.0.0.1:8081/mcp") as client:
+        result = await client.call_tool("get_abstract_from_patent_app_number", arguments)
+        print(result)
+
+asyncio.run(main())
+PY
+~~~
+
+Expected success shape: result text, document_chars, and a truncation indicator. Check scientific meaning, finite values, output bounds, invalid-input behavior, and absence of paths, secrets, and traces. The success path is source-checked but not runtime-verified here unless the status note explicitly says otherwise.
+
+## Tune GPU and concurrency
+
+- Use one worker as a conservative, unmeasured default.
+- Measure cold start, two warm calls, then parallel levels 1, 2, 4, 8, and only 16 if memory permits.
+- Record successes/errors, p50/p95, peak RAM/VRAM, utilization, queueing, cancellation cleanup, and recovery.
+- Increase workers only after single-flight initialization and sanitized recoverable OOM/timeout behavior are proven.
+
+## Troubleshoot and clean up
+
+- Import/executable failure: reactivate the isolated environment and reinstall its requirements.
+- Missing artifact: inspect provider-only environment variables and approved relative files; never accept arbitrary caller model paths.
+- 401/403 on deliberate network binding: configure matching TOOLUNIVERSE_API_TOKEN bearer auth; prefer loopback plus relay.
+- Stop server/relay with Ctrl-C. If installed, run `tuplatform-service uninstall --name validation-uspto-downloader`.
+- Revoke temporary keys. After confirmation, remove only .venvs/uspto-downloader, caches/uspto-downloader, and runs/uspto-downloader; never use a broad recursive target.
+
+Use only official upstream documentation linked by the implementation README; do not substitute third-party model mirrors.

upstream/mims-harvard-ToolUniverse/skills/host-and-share-remote-tool/agents/openai.yaml

@@ -0,0 +1,17 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/host-and-share-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Host and share a remote tool"
+  short_description: "Host and share a private model or MCP endpoint."
+  default_prompt: "Set up, validate, and privately share my own model, Python function, or MCP endpoint through ToolUniverse Platform."

upstream/mims-harvard-ToolUniverse/skills/setup-boltz-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-boltz-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Boltz Remote Tool"
+  short_description: "Help with Setup Boltz Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-borzoi-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-borzoi-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Borzoi Remote Tool"
+  short_description: "Help with Setup Borzoi Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-cell2location-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-cell2location-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Cell2location Remote Tool"
+  short_description: "Help with Setup Cell2location Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-cellrank-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-cellrank-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Cellrank Remote Tool"
+  short_description: "Help with Setup Cellrank Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-celltypist-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-celltypist-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Celltypist Remote Tool"
+  short_description: "Help with Setup Celltypist Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-chrombpnet-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-chrombpnet-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Chrombpnet Remote Tool"
+  short_description: "Help with Setup Chrombpnet Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-depmap-24q2-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-depmap-24q2-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Depmap 24q2 Remote Tool"
+  short_description: "Help with Setup Depmap 24q2 Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-enformer-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-enformer-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Enformer Remote Tool"
+  short_description: "Help with Setup Enformer Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-esm-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-esm-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Esm Remote Tool"
+  short_description: "Help with Setup Esm Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-expert-feedback-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-expert-feedback-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Expert Feedback Remote Tool"
+  short_description: "Help with Setup Expert Feedback Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-harmony-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-harmony-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Harmony Remote Tool"
+  short_description: "Help with Setup Harmony Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-immune-compass-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-immune-compass-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Immune Compass Remote Tool"
+  short_description: "Help with Setup Immune Compass Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-ldsc-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-ldsc-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Ldsc Remote Tool"
+  short_description: "Help with Setup Ldsc Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-liana-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-liana-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Liana Remote Tool"
+  short_description: "Help with Setup Liana Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-macs3-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-macs3-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Macs3 Remote Tool"
+  short_description: "Help with Setup Macs3 Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-milo-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-milo-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Milo Remote Tool"
+  short_description: "Help with Setup Milo Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-mofa-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-mofa-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Mofa Remote Tool"
+  short_description: "Help with Setup Mofa Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-monocle3-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-monocle3-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Monocle3 Remote Tool"
+  short_description: "Help with Setup Monocle3 Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-paga-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-paga-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Paga Remote Tool"
+  short_description: "Help with Setup Paga Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-pinnacle-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-pinnacle-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Pinnacle Remote Tool"
+  short_description: "Help with Setup Pinnacle Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-scanvi-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scanvi-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Scanvi Remote Tool"
+  short_description: "Help with Setup Scanvi Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-scrublet-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scrublet-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Scrublet Remote Tool"
+  short_description: "Help with Setup Scrublet Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-scvelo-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scvelo-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Scvelo Remote Tool"
+  short_description: "Help with Setup Scvelo Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-scvi-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-scvi-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Scvi Remote Tool"
+  short_description: "Help with Setup Scvi Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-singler-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-singler-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Singler Remote Tool"
+  short_description: "Help with Setup Singler Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-slingshot-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-slingshot-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Slingshot Remote Tool"
+  short_description: "Help with Setup Slingshot Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-squidpy-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-squidpy-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Squidpy Remote Tool"
+  short_description: "Help with Setup Squidpy Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-tangram-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-tangram-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Tangram Remote Tool"
+  short_description: "Help with Setup Tangram Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-transcriptformer-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-transcriptformer-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Transcriptformer Remote Tool"
+  short_description: "Help with Setup Transcriptformer Remote Tool tasks"

upstream/mims-harvard-ToolUniverse/skills/setup-uspto-downloader-remote-tool/agents/openai.yaml

@@ -0,0 +1,16 @@
+---
+title: "Openai"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/mims-harvard/ToolUniverse/blob/1aaaf00d/skills/setup-uspto-downloader-remote-tool/agents/openai.yaml
+upstream_sha: 1aaaf00d
+imported_at: 2026-08-20
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+interface:
+  display_name: "Setup Uspto Downloader Remote Tool"
+  short_description: "Help with Setup Uspto Downloader Remote Tool tasks"