[Proposal] dotnet-ai plugin: AI and ML skills for .NET

## Summary

This proposal introduces a new `dotnet-ai` plugin to the dotnet/skills repository containing a set of discrete, composable AI and ML skills for .NET developers.

The .NET AI/ML ecosystem has grown significantly — Microsoft.Extensions.AI, Microsoft.Agents.AI, ML.NET's deep learning support (TorchSharp), ONNX Runtime, vector data connectors, and the GitHub Copilot SDK all provide powerful capabilities. But developers face a real problem: **knowing which library to use when, and how to wire them together correctly.** These skills encode that expert knowledge.

## Design Philosophy

Each skill follows the [agent skills philosophy](https://agentskills.io/):

- **Purposeful** — solves a real, repeatable .NET AI/ML problem
- **Concise** — encodes decisions, not options
- **Scoped** — small enough to explain in one or two sentences
- **Composable** — designed to be reused as part of larger workflows (e.g., RAG pipeline composes embeddings + vector search + ingestion + chat)
- **Validated** — each skill has an eval.yaml with concrete scenarios

## Layering Model

The skills are organized around the .NET AI stack:

| Layer | Technology | Skill(s) |
|---|---|---|
| **Harness** | GitHub Copilot SDK | `copilot-sdk-integration` |
| **Runtime** | Microsoft Agent Framework (MAF) | `agentic-workflow` |
| **Framework** | Microsoft.Extensions.AI (MEAI) | `meai-chat-integration`, `meai-embeddings` |
| **Classical ML** | ML.NET + TorchSharp | `mlnet` |
| **Inference** | ONNX Runtime, Ollama, Foundry Local | `onnx-runtime-inference`, `local-llm-inference` |
| **Data** | VectorData, DataIngestion | `vector-data-search`, `data-ingestion-pipeline` |
| **Composition** | RAG = chat + embeddings + vector + ingestion | `rag-pipeline` |
| **Router** | Decision tree across all skills | `technology-selection` |

## Proposed Skills

| # | Skill | Scope | Reference Files |
|---|---|---|---|
| 1 | `meai-chat-integration` | IChatClient setup, middleware pipeline, streaming, structured output, retry/resilience, model pinning, token counting | `tokenizers.md` |
| 2 | `meai-embeddings` | IEmbeddingGenerator setup, batch generation, dimension selection | — |
| 3 | `mlnet` | Classical ML (classification, regression, clustering, etc.) + deep learning (image classification, object detection, NER, QA, text classification via TorchSharp). Full train, evaluate, deploy lifecycle | `custom-transforms.md`, `dataframe.md`, `torchsharp.md` |
| 4 | `vector-data-search` | Microsoft.Extensions.VectorData abstractions, connector selection, hybrid search | — |
| 5 | `data-ingestion-pipeline` | Microsoft.Extensions.DataIngestion pipeline, chunking strategies, enrichers | — |
| 6 | `onnx-runtime-inference` | ONNX Runtime inference in .NET, standalone and via ML.NET, execution providers (CPU/GPU/DirectML) | `tensors.md` |
| 7 | `local-llm-inference` | Running LLMs locally via Ollama and Foundry Local through IChatClient | — |
| 8 | `agentic-workflow` | Microsoft Agent Framework: AIAgent, AgentSession, AsAIFunction multi-agent composition, durable agents, A2A protocol | — |
| 9 | `copilot-sdk-integration` | GitHub Copilot SDK three dimensions: LLM backend (zero-config auth, BYOK), agent harness (sessions, MCP, safe outputs), platform extensions. Includes Bridge Pattern (prototype with Copilot, deploy with Azure) | — |
| 10 | `rag-pipeline` | End-to-end retrieval-augmented generation composing ingestion + embeddings + vector search + chat | — |
| 11 | `technology-selection` | Meta/router skill: decision tree that routes developers to the correct skill based on their task | — |

## Description Size Budget

Per the discussion in #222, description sizes are within proposed limits:

- **Largest single description**: 692 chars (`mlnet`)
- **Plugin aggregate**: 4,918 chars across 11 skills (avg 447)

## Relationship to Existing Work

Issue #31 describes the need for .NET Agent Framework authoring guidance. This proposal decomposes that and adjacent AI/ML scenarios into discrete composable skills — `agentic-workflow` covers the MAF agent authoring piece, while the other skills handle the broader AI/ML landscape.

## Plugin Structure

```
plugins/dotnet-ai/
plugin.json
agents/
skills/
meai-chat-integration/
SKILL.md
references/
tokenizers.md
meai-embeddings/SKILL.md
mlnet/
SKILL.md
references/
custom-transforms.md
dataframe.md
torchsharp.md
vector-data-search/SKILL.md
data-ingestion-pipeline/SKILL.md
onnx-runtime-inference/
SKILL.md
references/
tensors.md
local-llm-inference/SKILL.md
agentic-workflow/SKILL.md
copilot-sdk-integration/SKILL.md
rag-pipeline/SKILL.md
technology-selection/SKILL.md
tests/dotnet-ai/

```

## Suggested Merge Order

Skills have a dependency graph for cross-references. Suggested order:

1. **Plugin scaffold** — plugin.json, empty dirs, CODEOWNERS, marketplace.json
2. **Foundation skills** (any order): meai-chat-integration, meai-embeddings, mlnet, vector-data-search + data-ingestion-pipeline, onnx-runtime-inference + local-llm-inference
3. **Agent stack**: agentic-workflow + copilot-sdk-integration (Bridge Pattern links them)
4. **RAG pipeline** — composes foundation skills
5. **Technology selection** — router, references all skills; lands last

## Sub-Issues

Each deliverable unit has its own sub-issue with detailed scope, linked below.

- [ ] #226 Plugin scaffold
- [ ] #227 MEAI chat integration
- [ ] #228 MEAI embeddings
- [ ] #229 ML.NET training & deployment
- [ ] #230 Vector data search + data ingestion pipeline
- [ ] #231 ONNX Runtime + local LLM inference
- [ ] #232 Agent stack (agentic-workflow + copilot-sdk-integration)
- [ ] #233 RAG pipeline
- [ ] #234 Technology selection (router)

## Open Questions

- Does `dotnet-ai` as a plugin name work, or is there a preferred naming convention?
- Any skills the team wants to defer, cut, or combine?
- Ownership: who should be listed in CODEOWNERS?