science-suite

Plugin science-suite from marketplace scientific-computing-workflows in imewei/MyClaude. Commands read from the repo's manifest — 26 days ago.

Skills (149)

• active-matter

  Model active matter including self-propelled particles, flocking, pattern formation, and collective behavior. Use when simulating ABPs, Vicsek model, MIPS, reaction-diffusion systems, or designing bio-inspired materials.

• advanced-ml-systems

  Build advanced deep learning with PyTorch 2.x, TensorFlow, JAX including architectures (CNNs, Transformers, GANs), distributed training (DDP, FSDP, DeepSpeed), hyperparameter optimization (Optuna, Ray Tune), and model optimization (quantization, pruning, distillation). Use when training scripts, cus

• advanced-optimization

  Solve complex optimization problems with convex optimization (CVXPY), integer programming, constraint satisfaction, Bayesian optimization, and surrogate-based methods. Use when formulating optimization problems, implementing convex programs, or building surrogate models for expensive objective funct

• advanced-simulations

  Hub for advanced simulation workflows that combine MD setup, ML force fields, multiscale modeling, trajectory analysis, and non-equilibrium transport. Use when setting up molecular dynamics, choosing or training force fields, bridging atomistic-to-mesoscale models, analyzing trajectories, or computi

• auditing-julia-package-practices

  Use when you review an existing or in-progress Julia package against the Julia package practices in science-suite and want prioritized, evidence-based findings and concrete remediation suggestions

• bayesian-inference

  Meta-orchestrator for Bayesian inference and probabilistic programming. Routes to NumPyro, Turing.jl, Pigeons consensus MCMC, Bayesian UDE workflows, Bayesian PINNs, point-process / Hawkes inference, variational inference, and MCMC diagnostics skills. Use when building probabilistic models with NumP

• bayesian-pinn

  Put posterior uncertainty on PINN / neural-ODE solutions using NeuralPDE.jl's BNNODE (ODEs) and BayesianPINN (PDEs) discretizers. Use when you need credible intervals on a learned PDE solution, an inverse problem with uncertainty on the physical parameters, or HMC sampling over neural-network weight

• bayesian-sindy-workflow

  Build Bayesian SINDy workflows with horseshoe priors, ensemble SINDy, and UQ-SINDy. Use when you need credible intervals on SINDy coefficients, inclusion probabilities for library terms, noise-robust sparse regression, or Bayesian model comparison between candidate dynamical systems. Use proactively

• bayesian-ude-jax

  Build Bayesian Universal Differential Equations end-to-end in JAX with Diffrax + Equinox + NumPyro + Optax. Use when the surrounding training loop is already JAX, when GPU vmap-parallel chain sampling dominates wall-clock, when tight integration with Optax schedulers / HuggingFace models matters mor

• bayesian-ude-workflow

  Build end-to-end Bayesian Universal Differential Equation (UDE) workflows in Julia. Use when fitting neural ODEs with posterior uncertainty, embedding Lux neural networks inside Turing @model blocks with DiffEq solves, warm-starting MCMC from a deterministic optimum, or composing UDE training with S

• bifurcation-analysis

  Numerical continuation and bifurcation analysis. Covers codimension-1 (saddle-node, Hopf, pitchfork, period-doubling) and codimension-2 (Bogdanov-Takens, cusp, Bautin) bifurcations, normal forms, branch switching, and periodic orbit continuation. BifurcationKit.jl is blocked on Julia 1.12 (MiniQhull

• bioinformatics

  Implement bioinformatics workflows including sequence alignment (BLAST, Smith-Waterman), genomics pipelines, phylogenetic analysis, protein structure prediction, and biological data visualization with Biopython. Use when analyzing biological sequences, building genomics pipelines, or processing bioi

• catalyst-reactions

  Model chemical reaction networks with Catalyst.jl for deterministic and stochastic simulations. Use when modeling biochemical pathways, chemical kinetics, gene regulatory networks, enzyme kinetics, or metabolic networks. Also use when defining reaction stoichiometry with @reaction_network, convertin

• chaos-attractors

  Chaos characterization and attractor analysis with DynamicalSystems.jl (Julia) and JAX. Covers Lyapunov exponents (variational, QR), attractor reconstruction (Takens embedding), fractal dimension (correlation, Kaplan-Yorke), recurrence analysis, and Poincare sections. Use JAX vmap for parallel Lyapu

• ci-cd-patterns

  Master GitHub Actions for Julia packages with test matrices, CompatHelper, TagBot, and documentation deployment. Use when setting up CI workflows for Julia packages. Also use when configuring multi-platform test matrices, adding code coverage with Codecov, auto-deploying Documenter.jl docs, or autom

• compiler-patterns

  Create system images and standalone executables with PackageCompiler.jl. Use when reducing startup time or deploying Julia applications without requiring Julia installation. Also use when building Docker images for Julia services, writing precompile scripts, bundling apps with artifacts, troubleshoo

• computer-vision

  Implement computer vision pipelines with OpenCV, torchvision, and Hugging Face Vision Transformers including object detection (YOLO, DETR), image segmentation, feature extraction, and video analysis. Use when building CV models, processing images, or implementing detection/segmentation pipelines.

• consensus-mcmc-pigeons

  Sample multimodal posteriors with Pigeons.jl non-reversible parallel tempering. Use when NUTS chains fail to mix across modes, R-hat stays elevated, or the posterior is multimodal by construction (mixtures, weakly identified UDEs, label-switching). Also use when scaling MCMC across MPI ranks or thre

• constitutive-equations

  Constitutive modeling — linear elasticity, hyperelasticity (Neo-Hookean, Mooney-Rivlin, Ogden), and viscoelasticity (Maxwell, Kelvin-Voigt, generalized Maxwell/Prony series). Use when selecting or fitting a stress-strain relation, choosing between hyperelastic strain-energy functions, or fitting a P

• continuum-mechanics-and-rheology

  Meta-orchestrator for continuum mechanics, FEM/FEA, constitutive modeling, rheology/DMA, transient networks, and nanocomposites. Use when formulating finite element models, fitting viscoelastic/hyperelastic constitutive laws, interpreting DMA or rheology data, modeling covalent adaptable networks (v

• control-theory

  Design control systems with python-control and Julia ControlSystems.jl including PID tuning, state-space models, transfer functions, Bode/Nyquist analysis, stability analysis, and optimal control (LQR/MPC). Use when designing controllers, analyzing system stability, or implementing feedback control

• core-julia-patterns

  Master multiple dispatch, type system, parametric types, type stability, and metaprogramming for high-performance Julia. Use when designing type hierarchies, debugging @code_warntype issues, optimizing with @inbounds/@simd/StaticArrays, or writing macros and generated functions. Also use when learni

• correlation-analysis

  Meta-orchestrator for correlation function analysis. Routes to mathematical foundations, physical systems, computational methods, and experimental data interpretation skills. Use when computing correlation functions, analyzing DLS/SAXS/XPCS data, implementing FFT-based correlators, or connecting mic

• correlation-computational-methods

  Implement efficient correlation algorithms including FFT-based O(N log N) autocorrelation (50,000× speedup), multi-tau correlators for wide dynamic ranges, KD-tree spatial correlations, JAX-accelerated GPU computation (200× speedup), and statistical validation (bootstrap, convergence). Use when opti

• correlation-experimental-data

  Interpret experimental correlation data from DLS (g₂(τ), Siegert relation, Stokes-Einstein), SAXS/SANS (S(q), g(r), Guinier/Porod analysis), XPCS (two-time correlation, aging), FCS (diffusion time, binding kinetics), and rheology (Green-Kubo, microrheology). Extract physical parameters, perform Baye

• correlation-math-foundations

  Mathematical foundations of correlation functions including two-point C(r), higher-order χ₄(t), cumulants, Fourier/Laplace/wavelet transforms, Wiener-Khinchin theorem, Ornstein-Zernike equations, fluctuation-dissipation theorem, and Green's functions. Use when developing correlation theory or connec

• correlation-physical-systems

  Map correlation functions to physical systems including condensed matter (spin correlations, critical exponents ξ ~ |T-Tc|^(-ν)), soft matter (polymer Rouse/Zimm dynamics, colloidal g(r), glass χ₄), biological systems (protein folding, membrane fluctuations), and non-equilibrium (active matter, tran

• creating-julia-app

  Use when you create a command-line application or MCP server in Julia — a package with a `@main` entry point and an `[apps]` table in `Project.toml`, installed with `Pkg.Apps` and run by name from the shell

• data-analysis

  Reference patterns for analyzing experimental correlation data from DLS, SAXS/SANS, rheology, and microscopy using Green-Kubo relations, Bayesian inference (MCMC), and model validation. Provides domain knowledge for the /analyze-data command. Use when interpreting scattering data, validating non-equ

• data-wrangling-communication

  Comprehensive data wrangling, cleaning, feature engineering, and visualization workflows using pandas, NumPy, Matplotlib, Seaborn, and Plotly. Use when cleaning messy datasets, handling missing values, dealing with outliers, engineering features, performing EDA, creating statistical visualizations,

• debugging-julia

  Use when Julia code errors, throws an exception, produces wrong results, or crashes and you need to find the cause from the command line: capturing and reading stack traces, locating the failing method with @which/@code_warntype/@code_typed, finding potential runtime errors with JET.jl, and narrowin

• deep-learning-experimentation

  Design systematic deep learning experiments with hyperparameter optimization, ablation studies, and reproducible workflows. Use when tuning hyperparameters, conducting ablations, setting up experiment tracking (W&B, TensorBoard, MLflow), or managing reproducibility.

• deep-learning-hub

  Meta-orchestrator for deep learning. Routes to architecture design, mathematical foundations, training diagnostics, experimentation, and advanced systems skills. Use when designing neural architectures, deriving backpropagation, diagnosing training failures (loss divergence, gradient explosion/vanis

• deep-learning

  Core deep-learning implementation skill for standard neural networks, training loops, regularization, loss selection, and framework-neutral PyTorch/JAX/TensorFlow patterns. Use when building baseline models, implementing custom layers or losses, validating data/shape flow, or explaining feedforward/

• developing-julia-package

  Use when you implement or edit code inside an existing Julia package: module/`include` layout, multiple dispatch, type annotations and stability, formatting, and docstrings

• devops-ml-infrastructure

  DevOps for ML with GitHub Actions pipelines, Terraform IaC, Docker/Kubernetes, and cloud ML platforms (SageMaker, Azure ML, Vertex AI). Use when automating training, deploying models, or provisioning ML infrastructure.

• differential-equations

  Solve ODE/SDE/PDE with DifferentialEquations.jl. Use when defining differential equation systems, selecting solvers, implementing callbacks, or creating ensemble simulations. Also use when choosing between Tsit5/Vern7/Rodas5 for stiff vs non-stiff problems, adding event handling, running Monte Carlo

• dma-rheology

  Dynamic Mechanical Analysis (DMA) and rheology — storage/loss modulus interpretation, tan delta, oscillatory shear rheology, and shear/extensional flow curves. Use when interpreting DMA or rheometer output, identifying the linear viscoelastic regime, or distinguishing shear from extensional rheologi

• documenting-julia-package

  Use when you add, build, or publish documentation for a Julia package with Documenter.jl: the `docs/` layout, `docs/Project.toml`, `makedocs`/`deploydocs`, `@docs` and docstring blocks, doctests, and GitHub Pages deployment

• dspy-basics

  Build programmatic prompt pipelines with DSPy — Signatures, Modules, ChainOfThought, ReAct, Retrieve, and optimizers (MIPROv2, BootstrapFewShot, COPRO, BetterTogether). Use when hand-tuning prompts is eating dev time, when you need a labelled-metric-driven optimizer to improve prompts, when the pipe

• ecosystem-selection

  Select optimal scientific computing ecosystems and manage multi-language workflows. Use when evaluating Python vs Julia for performance-critical numerical computing, implementing hybrid PyJulia/PyCall.jl interoperability, or setting up reproducible toolchains with Conda or Pkg.jl.

• equation-discovery

  Data-driven equation discovery with SINDy (Sparse Identification of Nonlinear Dynamics) using DataDrivenDiffEq.jl (Julia) and PySINDy (Python). Covers library construction, sparse regression (STLSQ, SR3), implicit SINDy, weak-form / integral SINDy, physics-constrained SINDy (conservation-law penalti

• experiment-tracking

  Track ML experiments with MLflow, Weights & Biases, and DVC including metric logging, artifact management, model registry, hyperparameter sweeps, and experiment comparison. Use when setting up experiment tracking, comparing model runs, or managing ML artifacts and model versions.

• extreme-value-statistics

  Fit extreme-value distributions to tail data with block-maxima GEV (Gumbel / Fréchet / Weibull) and peaks-over-threshold GPD models. Covers maximum-likelihood, L-moments, Hill, Pickands, and moment estimators for the tail index; return-level and return-period computation; threshold selection via mea

• federated-learning

  Build federated learning systems with Flower and PySyft including privacy-preserving training, differential privacy, secure aggregation, cross-silo/cross-device FL, and communication efficiency. Use when training models across distributed data sources, implementing privacy-preserving ML, or designin

• fem-fea

  Finite Element Modeling/Analysis — weak-form formulation, mesh strategy, element selection, and convergence verification. Use when setting up a FEM simulation, choosing element types, diagnosing mesh-convergence or locking issues, or picking between FEniCS, scikit-fem, Gridap.jl, or Ferrite.jl.

• fixing-julia-exports

  Use when a Julia package exports too much — internal helpers exported only so `Pkg.test` can reach them, unused or stale exports, or namespace pollution and name collisions — or when you need to audit and trim a package's public API. Covers finding `export` statements, classifying public vs internal

• generating-julia-package

  Use when you create a new Julia package or project environment — choosing the layout, writing `Project.toml`/`src`, generating a UUID, adding dependencies — or prepare a package for registration

• glass-and-collective-dynamics

  Glass physics, jamming, and collective phenomena in disordered/soft-matter systems — random landscapes, aging, cooperative dynamics, and percolation theory. Use when analyzing glassy relaxation, jamming transitions, aging dynamics, cooperative/collective particle motion, or percolation thresholds in

• gpu-acceleration

  Implement GPU acceleration using CUDA/CuPy (Python) and CUDA.jl (Julia) with kernel optimization and memory management. Use when offloading computations to GPU, writing custom kernels, or optimizing multi-GPU workflows.

• graph-theory

  Graph theory foundations — spectral graph theory, graph algorithms, and network topology metrics. Use when the task requires reasoning about a graph/network structure itself (spectral properties, centrality, connectivity, community structure) rather than a specific application domain (GNNs, coupled

• harmonic-response-superposition

  Harmonic response analysis and time-temperature superposition (TTS) — complex modulus under sinusoidal loading, WLF equation, and master curve construction. Use when building a master curve from multi-temperature frequency sweeps, applying the WLF equation, or analyzing steady-state harmonic loading

• interop-patterns

  Master cross-language integration with PythonCall.jl, RCall.jl, and CxxWrap.jl. Use when calling Python/R libraries from Julia or minimizing data transfer overhead. Also use when importing NumPy/pandas/scikit-learn into Julia, calling ggplot2 or R statistical functions, wrapping C++ code, or optimiz

• jax-bayesian-pro

  This skill should be used when the user asks to "write Bayesian models in JAX", "use NumPyro or Blackjax", "implement custom MCMC samplers", "tune HMC mass matrix", "debug NUTS divergences", "run parallel MCMC chains", "integrate Diffrax with Bayesian inference", "build neural surrogate models for S

• jax-computing

  Meta-orchestrator for JAX scientific computing. Routes to core JAX, optimization, Bayesian inference, differential equations, and physics application skills. Use when writing JAX code, optimizing JIT compilation, implementing Bayesian models with NumPyro, solving ODEs with Diffrax, or running physic

• jax-core-programming

  Master JAX functional transformations (jit, vmap, pmap, grad), Flax NNX neural networks, Optax optimizers, Orbax checkpointing, and NumPyro Bayesian inference. Use when writing JAX code, building training loops, optimizing XLA compilation, debugging tracer errors, or scaling to multi-device GPU/TPU.

• jax-diffeq-pro

  This skill should be used when the user asks to "solve ODEs in JAX", "use Diffrax", "implement stiff solvers", "choose implicit vs explicit solvers", "backpropagate through ODEs", "use adjoint methods", "implement RecursiveCheckpointAdjoint", "solve SDEs", "use VirtualBrownianTree", "handle ODE even

• jax-julia-interop

  Bridge JAX (Python) and Julia SciML ecosystems using PythonCall.jl and juliacall. Use when combining Julia continuation/DiffEq solvers with JAX vmap, calling Julia solvers from Python, or exchanging arrays between ecosystems. Note: the BifurcationKit examples below are blocked on Julia 1.12 (MiniQhu

• jax-mastery

  Master JAX for high-performance scientific computing. Covers functional transformations (JIT, vmap, pmap, grad), neural networks (Flax NNX), and specialized optimization (NLSQ, NumPyro). Use when writing JAX code, debugging JIT compilation, vectorizing computations with vmap, or building Flax models

• jax-optimization-pro

  This skill should be used when the user asks to "optimize JAX code for production", "write JAX-first code", "debug ConcretizationError", "analyze XLA/HLO output", "implement SPMD parallelism", "use jax.sharding for TPU pods", "write Pallas/Triton kernels", "fix tracer errors", "optimize GPU/TPU memo

• jax-physics-applications

  Physics simulations using JAX-based libraries (JAX-MD, JAX-CFD, PINNs). Use when implementing molecular dynamics, computational fluid dynamics, physics-informed neural networks with PDE constraints, quantum computing algorithms (VQE, QAOA), multi-physics coupling, or differentiable physics for gradi

• julia-ad-backends

  Select and debug automatic differentiation backends in Julia. Covers Zygote.jl (source-to-source reverse-mode), Enzyme.jl (LLVM-level forward/reverse), ForwardDiff.jl (forward-mode dual numbers), and AbstractDifferentiation.jl for backend-agnostic code. Includes custom adjoint rules (ChainRulesCore.

• julia-gpu-kernels

  Write high-performance GPU code in Julia with CUDA.jl and KernelAbstractions.jl. Covers custom kernel writing, shared memory optimization, multi-GPU data parallelism, memory management (unified/pinned), profiling with NVTX.jl, and portable kernels across CUDA/ROCm/oneAPI/Metal backends. Use when wri

• julia-graph-neural-networks
• julia-hpc-distributed
• julia-language
• julia-mastery
• julia-ml-and-dl
• julia-ml-pipelines
• julia-model-deployment
• julia-neural-architectures
• julia-neural-networks
• julia-reinforcement-learning
• julia-testing-patterns
• julia-training-diagnostics
• jump-optimization
• langchain-architecture
• llm-and-ai
• llm-application-dev
• llm-evaluation
• machine-learning
• mcmc-diagnostics
• md-simulation-setup
• ml-and-data-science
• ml-deployment
• ml-engineering-production
• ml-force-fields
• ml-pipeline-workflow
• model-deployment-serving
• model-optimization-deployment
• modeling-toolkit
• modern-concurrency
• multiscale-modeling
• nanocomposites-and-adaptive-materials
• network-coupled-dynamics
• neural-architecture-patterns
• neural-network-mathematics
• neural-pde
• nlp-fundamentals
• nlsq-core-mastery
• non-equilibrium-theory
• nonlinear-dynamics
• numerical-methods-implementation
• numpyro-core-mastery
• optimization-patterns
• package-development-workflow
• package-management
• parallel-computing
• pattern-formation
• performance-tuning
• physical-learning-systems
• point-processes
• precompiling-julia-package
• profiling-julia-performance
• python-development
• python-packaging-advanced
• quantum-computing
• rag-implementation
• rare-events-sampling
• reinforcement-learning
• research-and-domains
• rlaif-training
• robust-testing
• rust-extensions
• science-hub
• scientific-visualization
• sciml-and-diffeq
• sciml-ecosystem
• sciml-modern-stack
• self-improving-ai
• signal-processing
• simulation-and-hpc
• statistical-analysis-fundamentals
• statistical-physics-hub
• statistical-physics
• stochastic-dynamics
• symbolic-math
• testing-julia-package
• time-series-analysis
• training-diagnostics
• trajectory-analysis
• transient-networks-and-can
• turing-model-design
• type-driven-design
• using-juliacheck
• variational-inference-patterns
• visualization-patterns
• web-development-julia
• zarr-cloud-arrays

Slash commands (4)

• /science-suite:analyze-data

  Interactive workflow to analyze data files with statistical tests, visualization, and reproducible reporting

• /science-suite:benchmark

  Profile JAX/Julia/HPC code — wall time, memory, GPU utilization, JIT compilation overhead — and suggest optimizations.

• /science-suite:md-sim

  Set up and run a molecular dynamics simulation — topology prep, force field selection, equilibration protocol, and trajectory analysis.

• /science-suite:run-experiment

  Design and execute a reproducible scientific experiment with proper controls, logging, and analysis

Subagents (13)

• continuum-mechanics-engineer

  Use this agent for continuum mechanics and finite element work on deformable and viscoelastic materials. Typical triggers include fitting or deriving a constitutive model, interpreting DMA or rheology data, modeling transient polymer networks such as CAN or vitrimers, and predicting nanocomposite me

• jax-pro

  Use this agent for JAX-specific numerical work in Python, including Flax and Equinox. Typical triggers include jit, vmap, pmap, and sharding questions, custom VJP/JVP or autodiff debugging, XLA/HLO performance analysis, and building with Optax, Diffrax, Pallas, or NumPyro. Delegates molecular dynami

• julia-implementer

  Use this agent when building, maintaining, or auditing a Julia package or app, on request or proactively after substantial edits to one. Typical triggers include scaffolding a package, setting up tests, CI, Documenter docs, or exports, diagnosing slow loads, slow code, or wrong results, and read-onl

• julia-ml-hpc

  Use this agent for Julia machine learning and high-performance computing. Typical triggers include building Lux, Flux, or MLJ models, writing CUDA.jl or KernelAbstractions GPU kernels, scaling with MPI, Distributed, or SLURM, and graph neural networks with GNNLux. SciML and differential-equation wor

• julia-pro

  Use this agent for Julia language and SciML work. Typical triggers include dispatch design and type-stability tuning, DifferentialEquations.jl or ModelingToolkit modeling, sensitivity analysis and universal differential equations, and Bayesian or optimization work with Turing, Optimization.jl, or Ju

• ml-expert

  Use this agent for classical machine learning and MLOps. Typical triggers include scikit-learn or gradient-boosting modeling, feature engineering and cross-validation design, hyperparameter search with Optuna and interpretability with SHAP, and experiment tracking or model serving with MLflow or W&B

• neural-network-master

  Use this agent for deep learning architecture and training theory. Typical triggers include choosing or designing an architecture such as a Transformer, CNN, GNN, or diffusion model, diagnosing a training failure like divergence or collapse, deriving or debugging a loss function, and reasoning about

• nonlinear-dynamics-expert

  Use this agent for nonlinear dynamical systems analysis. Typical triggers include bifurcation and stability analysis, quantifying chaos through Lyapunov spectra or attractor reconstruction, discovering governing equations with SINDy, and studying coupled oscillators, synchronization, chimera states,

• pinn-engineer

  Use this agent for physics-informed machine learning. Typical triggers include building a PINN with NeuralPDE.jl or DeepXDE, enforcing boundary or conservation constraints in a loss, training neural operators such as FNO or DeepONet, and solving inverse PDE or parameter-identification problems.

• python-pro

  Use this agent for scientific Python engineering outside JAX semantics. Typical triggers include designing typed numerical APIs, setting up uv, ruff, and mypy tooling, writing PyO3/Rust extensions or optimizing hot Python paths, and asyncio concurrency, NumPy-to-JAX glue code, and Zarr/HDF5 conversi

• sci-workflow-engineer

  Use this agent for LLM-assisted scientific workflow engineering. Typical triggers include writing codegen prompts that produce correct JAX or Julia, templating reproducible experiments, building retrieval over scientific literature or internal results, and designing evaluations for an LLM-in-the-loo

• simulation-expert

  Use this agent for molecular simulation and HPC execution. Typical triggers include setting up or debugging a GROMACS, OpenMM, LAMMPS, or JAX-MD run, designing Monte Carlo or rare-event sampling, analyzing trajectories, and training or deploying machine-learned force fields on GPU or multi-node hard

• statistical-physicist

  Use this agent for statistical-mechanics theory. Typical triggers include analyzing a phase transition or critical behavior, working with Langevin or Fokker-Planck descriptions of stochastic dynamics, applying fluctuation theorems and correlation-function analysis, and reasoning about rare-event the

Hooks (5)

• SessionStart

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/session_start.py"

• UserPromptSubmit

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/user_prompt_submit.py"

• PostToolUse

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_use.py"

• SessionEnd

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/session_end.py"

• SubagentStop

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/subagent_stop.py"

Similar plugins