jumpstart-mode 1.1.13 → 1.1.14

package/.jumpstart/skills/python-developer/templates/sqlmodel_model.py

@@ -0,0 +1,40 @@
+"""SQLModel ORM model template with UUID PK, content hash, soft delete."""
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+
+class DocumentBase(SQLModel):
+    """Shared fields for request/response schemas and ORM model."""
+    title: str = Field(min_length=1, max_length=500)
+    content: str = Field(min_length=1)
+    source_id: str | None = None
+    source_url: str | None = None
+
+
+class Document(DocumentBase, table=True):
+    """ORM model — stored in `documents` table."""
+    __tablename__ = "documents"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        primary_key=True,
+    )
+    content_hash: str = Field(index=True)  # SHA-256 of content for dedup
+    created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
+    updated_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
+    deleted_at: Optional[datetime] = Field(default=None, nullable=True)
+
+    class Config:
+        # Prevent accidental mutation through schema instances
+        populate_by_name = True
+
+
+def compute_content_hash(content: str) -> str:
+    """Compute SHA-256 hash of document content for deduplication."""
+    import hashlib
+    return hashlib.sha256(content.encode()).hexdigest()

package/.jumpstart/skills/python-developer/templates/typer_cli.py

@@ -0,0 +1,93 @@
+"""Typer CLI scaffold for AI Innovation Pod scripts."""
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(
+    name="aipod",
+    help="AI Innovation Pod CLI utilities.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+
+@app.command()
+def ingest(
+    source_path: str = typer.Argument(..., help="Path to documents folder or file"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="List files without ingesting"),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+) -> None:
+    """Ingest documents from a local folder into the vector store."""
+    from pathlib import Path
+
+    path = Path(source_path)
+    if not path.exists():
+        console.print(f"[red]Error:[/red] {source_path} does not exist.")
+        raise typer.Exit(code=1)
+
+    files = list(path.rglob("*.pdf")) + list(path.rglob("*.docx")) if path.is_dir() else [path]
+
+    if dry_run:
+        console.print(f"[yellow]Dry run[/yellow] — would ingest {len(files)} file(s):")
+        for f in files:
+            console.print(f"  {f}")
+        return
+
+    if verbose:
+        console.print(f"Ingesting {len(files)} file(s)...")
+
+    # TODO: call ingestion service
+    console.print(f"[green]✓[/green] Ingested {len(files)} document(s).")
+
+
+@app.command()
+def evaluate(
+    dataset: str = typer.Option("evals/golden_dataset.json", "--dataset", "-d"),
+    output: str = typer.Option("eval_results.json", "--output", "-o"),
+    top_k: int = typer.Option(5, "--top-k"),
+) -> None:
+    """Run evaluation against the golden question/answer dataset."""
+    from pathlib import Path
+
+    if not Path(dataset).exists():
+        console.print(f"[red]Error:[/red] Dataset not found: {dataset}")
+        raise typer.Exit(code=1)
+
+    console.print(f"Running evaluation from [bold]{dataset}[/bold]...")
+    # TODO: run eval loop
+    console.print(f"[green]✓[/green] Results saved to {output}")
+
+
+@app.command()
+def validate_env() -> None:
+    """Validate all required environment variables are set."""
+    try:
+        from app.core.config import Settings
+        Settings()
+        console.print("[green]✓[/green] All environment variables are valid.")
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def status() -> None:
+    """Show service configuration and connectivity status."""
+    from app.core.config import settings
+
+    table = Table(title="Service Status", show_header=True)
+    table.add_column("Setting", style="bold")
+    table.add_column("Value")
+
+    table.add_row("App Name", settings.app_name)
+    table.add_row("Version", settings.app_version)
+    table.add_row("Environment", settings.environment)
+    table.add_row("Log Level", settings.log_level)
+    table.add_row("DB URL", settings.database_url[:50] + "...")
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

package/.jumpstart/skills/rag-architecture-designer/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: rag-architecture-designer
+description: 'Design a defensible Retrieval Augmented Generation (RAG) architecture for a Jump Start or AI Innovation Pod build, covering corpus shape, chunking, embeddings, retrieval, reranking, generation, evaluation, and guardrails — with explicit tradeoffs. Use this whenever the user is shaping a knowledge assistant, search-grounded agent, document Q&A, policy or contract copilot, or any solution where the answer must be grounded in a controlled corpus, even when phrased as "build a chatbot over our docs", "make Copilot answer using our SharePoint", "search our knowledge base with AI", or "ground the model in our data".'
+argument-hint: 'Provide the use case, corpus characteristics (volume, formats, sensitivity, refresh), users, latency target, and any platform or governance constraints.'
+---
+
+# RAG Architecture Designer
+
+## Positioning
+
+RAG is the default pattern for grounding generative answers in a controlled corpus. It is also the pattern most often built badly. Use this skill to produce a pattern-first design that names the corpus, the retrieval strategy, the eval approach, and the guardrails before any code is written. The output should let a Pod team commit to a build path, a seller defend the scope, and a sponsor see where the risk lives.
+
+A good RAG design is judged by whether it answers four questions:
+
+1. What corpus is in scope, and how does it change?
+2. How are we going to retrieve the right context, and how do we know it is right?
+3. How will we measure faithfulness, groundedness, and task success before we go live?
+4. What guardrails sit between the retrieval layer and the user, and what are we explicitly choosing not to do?
+
+## When To Use This
+
+- Sizing a Jump Start, Pod MVP, or pilot that includes a knowledge assistant, document Q&A, or grounded agent.
+- A client says "we want ChatGPT over our data" and the team needs to translate that into a real architecture.
+- A previous RAG prototype is hallucinating, retrieving the wrong content, or losing fidelity at scale, and the team needs a redesign.
+- A scope or SOW is being drafted and the retrieval, eval, and guardrail commitments must be explicit before pricing.
+
+## When Not To Use This
+
+- Do not use this when the right answer is fine-tuning, structured search, or workflow automation. Run [`fine-tuning-vs-rag-decider`](../fine-tuning-vs-rag-decider/SKILL.md) first if the pattern is not yet decided.
+- Do not use this for agentic workflows where retrieval is a small tool call inside a larger orchestration. Pair with [`multi-agent-topology-designer`](../multi-agent-topology-designer/SKILL.md) and [`agent-tool-catalog-designer`](../agent-tool-catalog-designer/SKILL.md) instead.
+- Do not use this as a substitute for [`data-readiness-assessor`](../data-readiness-assessor/SKILL.md). RAG will not fix unfit data.
+
+## Required Inputs
+
+- Use case in one or two sentences, including the user, the decision or task the AI will support, and the kind of answer expected (extractive citation, synthesized summary, action recommendation).
+- Corpus inventory: sources, formats, volume, refresh cadence, sensitivity, ownership, and access pattern.
+- Latency, cost, and quality targets — even rough ones.
+- Platform and governance constraints: cloud, region, identity, allowable processors, audit requirements.
+
+If any are missing, draft the design with hypotheses clearly labeled and list the gaps that close the biggest unknowns.
+
+## The Seven Layers
+
+Design every RAG architecture in these layers. Each layer has tradeoffs; name them.
+
+1. **Corpus and ingestion** — what is in, what is out, how it lands, how it refreshes, how deletions and access controls propagate.
+2. **Chunking and enrichment** — how documents are split, what metadata travels with each chunk, how tables, images, and code are handled.
+3. **Indexing and embeddings** — embedding model choice, vector store choice, hybrid (keyword + vector) vs. pure vector, filters, ACL propagation.
+4. **Retrieval** — query rewriting, multi-query, hybrid scoring, recency bias, top-k, filter strategy, ACL enforcement at query time.
+5. **Reranking and assembly** — reranker choice, context window budget, deduplication, citation packaging.
+6. **Generation** — model choice, prompt architecture, citation contract, refusal behavior, structured output where useful.
+7. **Evaluation and guardrails** — eval set, faithfulness/groundedness/task-success metrics, red-team checks, PII and prompt-injection defenses, observability hooks.
+
+See [references/pattern-catalog.md](./references/pattern-catalog.md) for canonical patterns and tradeoffs at each layer.
+
+## Workflow
+
+1. Anchor the use case and the answer contract (extractive, synthesized, action). The contract drives every downstream choice.
+2. Inventory the corpus and classify it for sensitivity, access control, and refresh. Flag anything that should be excluded.
+3. Pick the pattern at each of the seven layers. Name the alternative considered and why it lost.
+4. Draft the eval plan with [templates/rag-eval-plan.md](./templates/rag-eval-plan.md). No design ships without a path to measurable groundedness and task success.
+5. Add the guardrails: ACL at retrieval, prompt-injection defense, refusal behavior, citation requirement, output filters, observability.
+6. Capture the architecture in [templates/rag-architecture-spec.md](./templates/rag-architecture-spec.md), including a Mermaid diagram, the eval plan, and the explicit out-of-scope list.
+7. State assumptions, risks, and the next validation step.
+
+## Output Structure
+
+1. Use case and answer contract.
+2. Corpus and ingestion design.
+3. Chunking and enrichment plan.
+4. Indexing and embedding choices.
+5. Retrieval and reranking plan.
+6. Generation and prompt contract.
+7. Evaluation plan (datasets, metrics, CI gates).
+8. Guardrails (ACL, injection defense, refusal, citation, observability).
+9. Tradeoffs considered and rejected.
+10. Risks, assumptions, and next validation step.
+
+A worked output is in [examples/example-policy-copilot.md](./examples/example-policy-copilot.md).
+
+## Common Pitfalls
+
+- **Skipping the answer contract.** "Answer questions" is not a contract. Decide whether the user gets an extractive citation, a synthesized summary, or an action — the rest of the design depends on it.
+- **Pure vector search by default.** Hybrid (BM25 + vector) plus a reranker beats pure vector on almost every enterprise corpus. Default to hybrid; justify pure vector if you choose it.
+- **ACL bolted on at the end.** Access control must be enforced at retrieval time, not by post-filtering generated answers. Design it into the index.
+- **No eval plan in the design.** A RAG design without faithfulness and groundedness measurement is a demo, not a system. Wire the eval plan into the architecture.
+- **Treating prompt injection as a model problem.** Injection lives in the corpus. Defend at ingestion (sanitize, label untrusted regions) and at generation (instruction hierarchy, allow-listed tools).
+- **Refresh as an afterthought.** Stale or never-deleted content is the most common production RAG failure. Design refresh, deletion, and ACL change propagation up front.
+
+## Quality Bar
+
+- The seven layers are each addressed with a named pattern and a rejected alternative.
+- The eval plan names datasets, metrics, and a CI gate.
+- ACLs and injection defense are designed into the architecture, not appended.
+- The out-of-scope list is explicit.
+
+## Related Skills
+
+- `fine-tuning-vs-rag-decider` — run first if the pattern is not yet committed.
+- `data-readiness-assessor` — score the corpus before designing the index.
+- `evaluation-harness-designer` — deepen the eval plan into a CI-runnable harness.
+- `observability-design-for-ai` — wire tracing and eval logging into production.
+- `red-team-playbook-builder` — adversarial testing of the retrieval and generation layers.
+- `agent-tool-catalog-designer` — when retrieval is one tool inside a larger agent.

package/.jumpstart/skills/rag-architecture-designer/evals/evals.json

@@ -0,0 +1,32 @@
+{
+  "skill_name": "rag-architecture-designer",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We want to ground Copilot Studio answers in our SharePoint policy library (~1,200 docs across HR, finance, and procurement) for an internal employee assistant on Teams. About 12k users globally, multi-country ACLs. Need it live in 8 weeks. Design the RAG architecture and the eval plan we should commit to in the SOW.",
+      "expected_output": "A complete seven-layer RAG architecture spec with eval plan, ACL design, and explicit out-of-scope.",
+      "expectations": [
+        "Names an explicit answer contract (extractive vs. synthesized; refusal behavior; citation requirement).",
+        "Specifies hybrid retrieval (BM25 + vector) with a reranker and justifies that choice.",
+        "Designs ACL enforcement at query time using the caller's identity (Entra/SharePoint groups) rather than post-filtering.",
+        "Includes refresh, deletion, and ACL-change propagation across the corpus.",
+        "Includes a concrete eval plan with faithfulness, groundedness, refusal correctness, and a CI gate with thresholds.",
+        "Calls out prompt-injection defense at ingestion and at generation.",
+        "Lists explicit out-of-scope items and rejected alternatives with rationale."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Our claims-handling RAG pilot is hallucinating amounts and citing the wrong policies. Corpus is ~50k claim adjudication memos plus ~3k policy PDFs. Currently pure vector with k=5 and no reranker. Redesign the retrieval, reranking, and eval layers and tell us what to change first.",
+      "expected_output": "A redesign focused on retrieval/reranking/eval with prioritized changes and tradeoffs.",
+      "expectations": [
+        "Recommends moving from pure vector to hybrid retrieval with a cross-encoder reranker, with rationale.",
+        "Recommends structure-aware or table-aware chunking for adjudication memos and policy PDFs and explains why fixed-size chunking causes amount hallucinations.",
+        "Adds a citation-required answer contract and a refusal path for low-confidence retrievals.",
+        "Specifies an eval set with faithfulness, citation correctness, and a slice for amount-specific claims.",
+        "Sequences the changes by expected impact (retrieval first, eval gate second, prompt last) and names tradeoffs.",
+        "Flags governance and audit concerns specific to claims (PII, regulator-readable citations)."
+      ]
+    }
+  ]
+}

package/.jumpstart/skills/rag-architecture-designer/examples/example-policy-copilot.md

@@ -0,0 +1,75 @@
+# Example: HR Policy Copilot RAG Architecture
+
+## 1. Use case and answer contract
+- Users: ~12k employees globally; managers asking benefits, leave, conduct, and policy questions in Teams.
+- Job to be done: get a correct, cited answer for a policy question in under 5 seconds, with explicit refusal when policy does not cover the case.
+- Answer type: extractive citation with a one-paragraph synthesis. Every claim must cite a policy section.
+- Refusal: "I cannot find this in the published policies. Please contact HR Direct." when retrieval confidence below threshold or no relevant chunks.
+- Latency: p50 ≤ 3s, p95 ≤ 6s.
+- Cost ceiling: < $0.02/answer.
+
+## 2. Corpus and ingestion
+- In scope: HR policy library on SharePoint (~1,200 docs, ~80MB), benefits PDFs from Workday, country-specific addenda.
+- Out of scope: employee files, ServiceNow tickets, internal HR Slack channels (sensitivity).
+- Refresh: nightly pull via Microsoft Graph; soft-delete propagation within 24h.
+- ACL: country and business-unit ACL groups inherited from SharePoint to index filter fields.
+- Sensitivity exclusions: any doc labeled "HR Internal Only" is excluded from the employee-facing index.
+
+## 3. Chunking and enrichment
+- Structure-aware chunking on H1/H2 headings; ~800 tokens with 100-token overlap; tables extracted with Azure Document Intelligence and re-flowed with surrounding section context.
+- Metadata: doc_id, section_path, country, business_unit, last_modified, sensitivity_label, source_url, owner.
+
+## 4. Indexing and embeddings
+- Azure AI Search hybrid index: BM25 + vector with semantic ranker.
+- Embedding model: text-embedding-3-large (Azure OpenAI), tenant region East US 2.
+- Filters: country, business_unit, sensitivity_label, last_modified.
+- Single tenant index with ACL filter at query time; per-tenant index rejected (ops overhead, ~1 tenant).
+
+## 5. Retrieval
+- Query rewrite: lightweight rewrite to expand acronyms (PTO, LOA) and add country if user profile implies it.
+- Top-k: 25 pre-rerank, 6 post-rerank.
+- Filter-first on country and ACL groups derived from caller's Entra identity.
+- Recency bias on `last_modified` for "current policy" questions.
+
+## 6. Reranking and assembly
+- Azure AI Search semantic ranker as first reranker; Cohere Rerank v3 considered, deferred (procurement).
+- Deduplicate chunks within the same section.
+- Citations packaged as `[Policy Name §Section]` with deep link.
+
+## 7. Generation
+- Model: GPT-4o-mini for default path; GPT-4o for refusal-or-summary slice flagged by router.
+- Structured output: `{answer, citations[], refused, refusal_reason}` JSON schema.
+- Refusal contract enforced in system prompt and validated in output guardrail.
+
+## 8. Evaluation plan
+- 120 labeled Q/A pairs from HR Direct ticket history; 30 negative (no-answer) cases; 15 injection cases.
+- Metrics with pass bars: faithfulness ≥ 0.92, groundedness ≥ 0.85, answer correctness ≥ 0.80, refusal correctness ≥ 0.95, p95 latency ≤ 6s, cost ≤ $0.02.
+- Ragas + Azure AI Foundry evaluation in GitHub Actions; block merge on regression > 3% on any metric.
+- Owner: Pod tech lead.
+
+## 9. Guardrails
+- ACL filter on every query against caller's Entra group membership.
+- Corpus sanitization at ingestion strips inline `system:` instructions.
+- Output guardrail: rejects answers without at least one valid citation; rejects answers with PII patterns from non-HR docs.
+- Observability: Application Insights traces every retrieval (filters, top-k, scores) and every generation (prompt hash, tokens, latency); eval logs to Foundry.
+- Red-team: monthly injection sweep, quarterly social-engineering script.
+
+## 10. Architecture diagram
+(See spec template.)
+
+## 11. Tradeoffs considered and rejected
+- Pure vector index — rejected, hybrid + semantic ranker materially better on policy IDs and acronyms in pilot eval.
+- Per-country index — rejected, single index with country filter is simpler at this scale.
+- Cohere Rerank — deferred, procurement timeline does not fit Jump Start window.
+- Fine-tuned model — rejected, corpus changes monthly; RAG keeps the answer current without retraining.
+
+## 12. Risks, assumptions, next validation step
+- Risk: SharePoint ACLs are inconsistent in two business units; remediation owner = HR IT.
+- Assumption: Workday benefits PDFs export nightly via existing connector.
+- Next validation step: run a 30-question retrieval-only eval against a frozen index snapshot before locking the prompt.
+
+## 13. Out of scope
+- Generating new policies.
+- Personal employee file lookup.
+- Manager performance or comp questions.
+- Multilingual answers in the Jump Start window (English only; Spanish/French in a follow-on motion).

package/.jumpstart/skills/rag-architecture-designer/references/pattern-catalog.md

@@ -0,0 +1,82 @@
+# RAG Pattern Catalog
+
+Canonical patterns at each of the seven layers, with tradeoffs. Use as a menu, not a checklist.
+
+## 1. Corpus and ingestion
+
+| Pattern | When it fits | Tradeoff |
+|---|---|---|
+| Pull from system of record (API, DB) | Source is authoritative and refresh is frequent | Higher integration effort, ACL pass-through complexity |
+| Snapshot to object store, then index | Source is read-mostly, refresh nightly is fine | Stale risk; deletion propagation must be explicit |
+| Connector platforms (Graph, Glean, Copilot Studio knowledge) | SharePoint, Drive, Confluence, OneDrive corpora | Limited control over chunking and ACL granularity |
+| Mixed (system of record + connectors) | Most enterprises | Two refresh paths to monitor |
+
+Key decisions: refresh cadence, deletion propagation, ACL inheritance, sensitivity exclusion list, multi-tenant boundary.
+
+## 2. Chunking and enrichment
+
+| Pattern | When it fits | Tradeoff |
+|---|---|---|
+| Fixed-size token chunks with overlap | Generic prose, fast bootstrap | Loses structure; bad for tables and code |
+| Semantic / structure-aware (headings, sections) | Policy, contracts, technical docs | More ingestion code; better recall |
+| Sentence + parent-document retrieval | Long-form docs where citation needs paragraph but context needs section | Two-stage retrieval; index size grows |
+| Table-aware extraction | Spreadsheets, regulatory filings | Requires layout-aware parser (Azure Document Intelligence, Unstructured) |
+| Late chunking on long-context embeddings | Modern long-context models, dense docs | Higher embedding cost per doc |
+
+Always attach metadata: source, owner, last-modified, sensitivity label, section path, ACL group.
+
+## 3. Indexing and embeddings
+
+| Pattern | When it fits | Tradeoff |
+|---|---|---|
+| Hybrid (BM25 + vector) with RRF fusion | Default for enterprise corpora | Two indexes to maintain |
+| Pure vector | Semantic-heavy, low-jargon corpora | Misses exact terms, IDs, codes |
+| Multi-vector (ColBERT-style) | High-precision retrieval needed | Index size and latency cost |
+| Per-tenant or per-ACL-group index | Strong isolation requirements | Operational overhead |
+
+Embedding model: prefer the platform-native model that supports your tenant region and matches your reranker. Re-embed when you change models.
+
+## 4. Retrieval
+
+- **Query rewriting / HyDE** — rewrite or hypothesize an answer to retrieve against. Helps short queries, hurts already-precise ones.
+- **Multi-query expansion** — issue N reformulations, fuse results. Improves recall, costs latency and tokens.
+- **Filter-first** — push metadata filters (tenant, sensitivity, recency, doc type) before scoring. Always do this where ACL applies.
+- **Top-k tuning** — start k=20 pre-rerank, 4–8 post-rerank. Measure on the eval set, do not guess.
+- **Recency bias** — boost newer chunks for time-sensitive corpora (incidents, news, policy updates).
+
+ACL enforcement must happen at query time, against the calling user's identity, not post-filtered after generation.
+
+## 5. Reranking and assembly
+
+- Use a cross-encoder reranker (Cohere Rerank, BGE-reranker, Voyage rerank) for any production system. The lift is consistent and large.
+- Deduplicate near-identical chunks before assembly.
+- Pack the context with citations the model can return verbatim. Citations are part of the answer contract.
+- Respect the context window budget; reserve headroom for the system prompt and the answer.
+
+## 6. Generation
+
+- Define the answer contract in the system prompt: extractive vs. synthesized, citation format, refusal behavior, tone.
+- Force citations or refusal. A model that answers without citing is a model that hallucinates.
+- Use structured output (JSON schema) when downstream consumers need it.
+- Pick the smallest model that passes the eval bar at the latency target. Reserve frontier models for hard slices.
+
+## 7. Evaluation and guardrails
+
+- **Faithfulness** — does every claim trace to retrieved context?
+- **Groundedness** — did the retriever surface enough context to answer correctly?
+- **Task success** — did the user's job get done?
+- **Refusal correctness** — does the system refuse when context is missing?
+- **Latency and cost** — measure p50/p95 and per-call cost in the eval run.
+- **Prompt-injection resistance** — adversarial corpus tests with embedded instructions.
+- **PII / sensitivity leakage** — outputs scanned for class violations.
+
+Wire the eval set into CI. Block deploys on regressions.
+
+## Reference platforms
+
+- Azure: Azure AI Search (hybrid + semantic ranker), Azure OpenAI, Azure Document Intelligence, Foundry evaluation.
+- AWS: OpenSearch / Kendra, Bedrock Knowledge Bases, Bedrock Guardrails.
+- GCP: Vertex AI Search, Vertex RAG Engine.
+- OSS: pgvector, Qdrant, Weaviate, LanceDB; LlamaIndex / LangChain for orchestration; Ragas / TruLens / promptfoo for eval.
+
+The pattern matters more than the platform. Choose the platform that fits the client's identity, residency, and procurement posture.

package/.jumpstart/skills/rag-architecture-designer/templates/rag-architecture-spec.md

@@ -0,0 +1,93 @@
+# RAG Architecture Spec
+
+## 1. Use case and answer contract
+- Users:
+- Job to be done:
+- Answer type: extractive citation | synthesized summary | action recommendation
+- Refusal behavior:
+- Latency target (p50/p95):
+- Cost ceiling per answer:
+
+## 2. Corpus and ingestion
+- Sources in scope:
+- Sources out of scope (and why):
+- Refresh cadence per source:
+- Deletion propagation:
+- ACL inheritance:
+- Sensitivity exclusions:
+
+## 3. Chunking and enrichment
+- Strategy:
+- Chunk size / overlap:
+- Special handling (tables, code, images):
+- Metadata attached to each chunk:
+
+## 4. Indexing and embeddings
+- Vector store:
+- Embedding model:
+- Hybrid? (BM25 + vector):
+- Filters and ACL fields:
+- Per-tenant vs. shared index:
+
+## 5. Retrieval
+- Query rewriting:
+- Top-k pre-rerank / post-rerank:
+- Filter-first fields:
+- Recency bias:
+- ACL enforcement:
+
+## 6. Reranking and assembly
+- Reranker:
+- Deduplication:
+- Citation format:
+- Context budget:
+
+## 7. Generation
+- Model:
+- Prompt architecture (link to prompt spec):
+- Structured output schema (if any):
+- Citation contract:
+- Refusal contract:
+
+## 8. Evaluation plan
+- Eval dataset (size, source, labeling):
+- Metrics: faithfulness, groundedness, task success, refusal correctness, latency, cost
+- CI gate: thresholds and behavior on regression
+- Owner:
+
+## 9. Guardrails
+- ACL at retrieval:
+- Prompt-injection defense (corpus sanitization, instruction hierarchy):
+- Output filters (PII, toxicity, brand):
+- Observability (tracing, eval logging, drift, cost):
+- Red-team coverage (link):
+
+## 10. Architecture diagram
+
+```mermaid
+flowchart LR
+  U[User] --> APP[App / Copilot]
+  APP --> RW[Query rewrite]
+  RW --> R[Hybrid retrieval]
+  R --> RR[Reranker]
+  RR --> ASM[Context assembly]
+  ASM --> GEN[Generator LLM]
+  GEN --> GR[Output guardrails]
+  GR --> APP
+  ING[Ingestion + chunking + embed] --> IDX[(Vector + keyword index)]
+  IDX --> R
+  ACL[Identity / ACL] --> R
+  OBS[Tracing + eval logs] -.-> R
+  OBS -.-> GEN
+```
+
+## 11. Tradeoffs considered and rejected
+- (Pattern, why considered, why rejected)
+
+## 12. Risks, assumptions, next validation step
+- Risks:
+- Assumptions:
+- Next validation step (eval slice, sample retrieval, sponsor confirmation):
+
+## 13. Out of scope (explicit)
+- 

package/.jumpstart/skills/rag-architecture-designer/templates/rag-eval-plan.md

@@ -0,0 +1,38 @@
+# RAG Eval Plan
+
+## Dataset
+
+- Size: aim for 50–150 labeled question/answer pairs for a Jump Start; 300–1000 for production.
+- Source: real user questions if available; otherwise synthesize from the corpus and have a domain SME label them.
+- Slices: by document type, by tenant, by sensitivity class, by question difficulty (factoid, multi-hop, summarization, refusal-required).
+- Negative cases: questions whose answer is NOT in the corpus, to measure refusal correctness.
+- Adversarial cases: documents containing prompt-injection payloads.
+
+## Metrics
+
+| Metric | Definition | Pass bar (example) |
+|---|---|---|
+| Faithfulness | Each claim traces to retrieved context | ≥ 0.9 |
+| Groundedness / context recall | Retriever surfaced sufficient context | ≥ 0.85 |
+| Answer correctness | Answer matches gold | ≥ 0.8 |
+| Refusal correctness | Refuses when no answer in corpus | ≥ 0.95 |
+| Citation correctness | Cited chunks actually support claim | ≥ 0.9 |
+| p95 latency | End-to-end | within target |
+| Cost per answer | Tokens × price | within target |
+| Injection resistance | Adversarial cases handled | ≥ 0.95 |
+
+## Tooling
+
+- Ragas, TruLens, promptfoo, Azure AI Foundry evaluation, or hand-rolled with an LLM-as-judge plus human spot-check.
+- LLM-as-judge: pin model and prompt; recalibrate with human labels every iteration.
+
+## CI gate
+
+- Run full eval on every prompt, model, retriever, or chunking change.
+- Block merge on regression > X% on any pass-bar metric.
+- Owner: named individual.
+
+## Drift watch (post-go-live)
+
+- Sample N% of production traffic into a labeling queue.
+- Re-run eval weekly; alert on metric drift.

package/.jumpstart/skills/react-design-md-auditor/README.md

@@ -0,0 +1,39 @@
+# react-design-md-auditor
+
+Audit a React TSX implementation against a DESIGN.md contract and produce severity-ranked compliance findings with concrete remediation guidance.
+
+## What this skill does
+
+- Reads DESIGN.md and maps its rules to eight audit dimensions.
+- Evaluates React files, routes, or PR diffs for drift.
+- Produces a structured findings table with severity levels.
+- Outputs a quick-win and structural-fix backlog.
+
+## When to invoke
+
+- Before a client demo to catch visible design drift.
+- During PR review to enforce frontend design standards.
+- After AI-assisted or vibe-coded component generation to validate quality.
+- As a pre-delivery gate on any AI Innovation Pod React frontend.
+
+## Related skills
+
+- `design-md-auditor` — Framework-agnostic design audit.
+- `react-developer` — Full React development workflow.
+- `design-md-creator` — Generate DESIGN.md if none exists.
+- `design-token-sync` — Propagate DESIGN.md tokens to Tailwind and theme objects.
+
+## Asset map
+
+```
+SKILL.md
+README.md
+references/
+  audit-rubric.md
+  severity-model.md
+  react-specific-checks.md
+templates/
+  compliance-report-template.md
+evals/
+  eval-cases.md
+```