From 558a5db77cb7374c9408d9e042b59b0fb02d1fcc Mon Sep 17 00:00:00 2001
From: Jeremy Hoover <jeremyhoover@microsoft.com>
Date: Wed, 18 Feb 2026 15:57:43 +0200
Subject: [PATCH 1/3] feat: Reorganize AI assets into .ai-assets folder

BREAKING CHANGE: Moved and restructured AI documentation

Changes:
- Add new .ai-assets/ folder with organized structure:
  - context/: Tool-specific instructions (Copilot, Claude, Cursor)
  - modes/: Custom agent definitions (fab.agent.md)
  - prompts/: 6 reusable prompt templates
  - skills/: 6 skill definitions with 16 Python scripts
- Add AGENTS.md to repo root for AI agent guidance
- Remove deprecated docs/agent-docs/ folder
- Move and update .github/copilot-instructions.md to .ai-assets/context/
- Update context files to be user-focused (not contributor-focused)

Skills included:
- fabric-cli-core: Core CLI operations and safety rules
- fabric-cli-cicd: CI/CD pipelines and deployments
- fabric-cli-powerbi: Semantic models, reports, refresh
- fabric-cli-governance: Permissions, ACLs, domains
- fabric-cli-dataengineering: Lakehouses, medallion, shortcuts
- fabric-cli-realtime: Eventhouses, KQL, eventstreams
---
 .ai-assets/README.md                          |  69 ++
 .ai-assets/context/CLAUDE.md                  | 121 +++
 .ai-assets/context/README.md                  |  56 ++
 .ai-assets/context/copilot-instructions.md    | 151 ++++
 .ai-assets/context/cursorrules.md             | 121 +++
 .ai-assets/modes/README.md                    |  47 ++
 .ai-assets/modes/fab.agent.md                 | 105 +++
 .ai-assets/prompts/README.md                  |  34 +
 .../prompts/analyze-semantic-model.prompt.md  |  61 ++
 .../create-lakehouse-pipeline.prompt.md       |  91 +++
 .../prompts/deploy-to-workspace.prompt.md     |  52 ++
 .ai-assets/prompts/migrate-items.prompt.md    | 108 +++
 .../prompts/troubleshoot-refresh.prompt.md    |  70 ++
 .ai-assets/prompts/workspace-audit.prompt.md  | 102 +++
 .ai-assets/skills/README.md                   |  37 +
 .ai-assets/skills/fabric-cli-cicd/README.md   |  52 ++
 .ai-assets/skills/fabric-cli-cicd/SKILL.md    | 267 +++++++
 .../references/automation-patterns.md         | 519 +++++++++++++
 .../references/azure-pipelines.md             | 403 ++++++++++
 .../references/environment-promotion.md       | 344 +++++++++
 .../references/git-integration.md             | 366 ++++++++++
 .../references/github-actions.md              | 362 +++++++++
 .../skills/fabric-cli-cicd/scripts/deploy.py  | 380 ++++++++++
 .../scripts/diff_definitions.py               | 394 ++++++++++
 .../scripts/export_workspace.py               | 372 ++++++++++
 .ai-assets/skills/fabric-cli-core/README.md   |  33 +
 .ai-assets/skills/fabric-cli-core/SKILL.md    | 153 ++++
 .../references/create-workspaces.md           |   0
 .../fabric-cli-core}/references/fab-api.md    |   0
 .../fabric-cli-core}/references/notebooks.md  |   0
 .../references/querying-data.md               |   0
 .../fabric-cli-core}/references/quickstart.md |   0
 .../fabric-cli-core}/references/reference.md  |   0
 .../fabric-cli-core}/references/reports.md    |   0
 .../references/semantic-models.md             |   0
 .../fabric-cli-core}/references/workspaces.md |   0
 .../fabric-cli-core/scripts/health_check.py   | 251 +++++++
 .../fabric-cli-dataengineering/README.md      |  77 ++
 .../fabric-cli-dataengineering/SKILL.md       | 535 ++++++++++++++
 .../references/lakehouse-patterns.md          | 315 ++++++++
 .../references/medallion-architecture.md      | 365 ++++++++++
 .../references/shortcuts.md                   | 353 +++++++++
 .../references/spark-configuration.md         | 398 ++++++++++
 .../references/table-optimization.md          | 341 +++++++++
 .../scripts/optimize_tables.py                | 413 +++++++++++
 .../scripts/setup_medallion.py                | 376 ++++++++++
 .../scripts/validate_shortcuts.py             | 424 +++++++++++
 .../skills/fabric-cli-governance/README.md    |  75 ++
 .../skills/fabric-cli-governance/SKILL.md     | 474 ++++++++++++
 .../references/audit-patterns.md              | 282 +++++++
 .../references/capacity-operations.md         | 253 +++++++
 .../references/domain-management.md           | 277 +++++++
 .../references/sensitivity-labels.md          | 249 +++++++
 .../references/workspace-permissions.md       | 249 +++++++
 .../scripts/audit_workspace.py                | 299 ++++++++
 .../scripts/bulk_permissions.py               | 379 ++++++++++
 .../scripts/validate_governance.py            | 688 ++++++++++++++++++
 .../skills/fabric-cli-powerbi/README.md       |  39 +
 .ai-assets/skills/fabric-cli-powerbi/SKILL.md | 379 ++++++++++
 .../references/dax-queries.md                 | 208 ++++++
 .../fabric-cli-powerbi/references/gateways.md | 182 +++++
 .../fabric-cli-powerbi/references/refresh.md  | 233 ++++++
 .../fabric-cli-powerbi/references/reports.md  | 222 ++++++
 .../references/semantic-models.md             | 196 +++++
 .../scripts/list_refresh_history.py           | 375 ++++++++++
 .../scripts/rebind_report.py                  | 382 ++++++++++
 .../scripts/refresh_model.py                  | 391 ++++++++++
 .../skills/fabric-cli-realtime/README.md      |  56 ++
 .../skills/fabric-cli-realtime/SKILL.md       | 259 +++++++
 .../references/activator-alerts.md            | 463 ++++++++++++
 .../references/eventhouse-operations.md       | 371 ++++++++++
 .../references/eventstream-patterns.md        | 450 ++++++++++++
 .../references/kql-queries.md                 | 399 ++++++++++
 .../references/streaming-patterns.md          | 502 +++++++++++++
 .../fabric-cli-realtime/scripts/kql_query.py  | 382 ++++++++++
 .../scripts/monitor_eventstream.py            | 523 +++++++++++++
 .../scripts/setup_streaming.py                | 489 +++++++++++++
 .github/copilot-instructions.md               | 326 ---------
 AGENTS.md                                     | 177 +++++
 docs/agent-docs/SKILL.md                      | 437 -----------
 80 files changed, 18621 insertions(+), 763 deletions(-)
 create mode 100644 .ai-assets/README.md
 create mode 100644 .ai-assets/context/CLAUDE.md
 create mode 100644 .ai-assets/context/README.md
 create mode 100644 .ai-assets/context/copilot-instructions.md
 create mode 100644 .ai-assets/context/cursorrules.md
 create mode 100644 .ai-assets/modes/README.md
 create mode 100644 .ai-assets/modes/fab.agent.md
 create mode 100644 .ai-assets/prompts/README.md
 create mode 100644 .ai-assets/prompts/analyze-semantic-model.prompt.md
 create mode 100644 .ai-assets/prompts/create-lakehouse-pipeline.prompt.md
 create mode 100644 .ai-assets/prompts/deploy-to-workspace.prompt.md
 create mode 100644 .ai-assets/prompts/migrate-items.prompt.md
 create mode 100644 .ai-assets/prompts/troubleshoot-refresh.prompt.md
 create mode 100644 .ai-assets/prompts/workspace-audit.prompt.md
 create mode 100644 .ai-assets/skills/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/SKILL.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/references/git-integration.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/references/github-actions.md
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
 create mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
 create mode 100644 .ai-assets/skills/fabric-cli-core/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-core/SKILL.md
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/create-workspaces.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/fab-api.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/notebooks.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/querying-data.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/quickstart.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/reference.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/reports.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/semantic-models.md (100%)
 rename {docs/agent-docs => .ai-assets/skills/fabric-cli-core}/references/workspaces.md (100%)
 create mode 100644 .ai-assets/skills/fabric-cli-core/scripts/health_check.py
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/SKILL.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
 create mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
 create mode 100644 .ai-assets/skills/fabric-cli-governance/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/SKILL.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/references/domain-management.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
 create mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
 create mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
 create mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/SKILL.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/references/dax-queries.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/references/gateways.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/references/refresh.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/references/reports.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/references/semantic-models.md
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/scripts/list_refresh_history.py
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/scripts/rebind_report.py
 create mode 100644 .ai-assets/skills/fabric-cli-powerbi/scripts/refresh_model.py
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/README.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/SKILL.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
 create mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py
 delete mode 100644 .github/copilot-instructions.md
 create mode 100644 AGENTS.md
 delete mode 100644 docs/agent-docs/SKILL.md

diff --git a/.ai-assets/README.md b/.ai-assets/README.md
new file mode 100644
index 000000000..daa025c4b
--- /dev/null
+++ b/.ai-assets/README.md
@@ -0,0 +1,69 @@
+# AI Assets for Microsoft Fabric CLI
+
+This folder contains AI-related resources for agents working with the Fabric CLI.
+
+## Folder Structure
+
+| Folder | Purpose |
+|--------|---------|
+| `context/` | Background context and contributor instructions for different AI tools |
+| `modes/` | Custom agents (chat modes) for VS Code Copilot |
+| `prompts/` | Reusable prompt templates |
+| `skills/` | Task-specific skill definitions |
+
+## Skills
+
+| Skill | Location | Description |
+|-------|----------|-------------|
+| `fabric-cli-core` | `skills/fabric-cli-core/SKILL.md` | Core CLI operations, auth, paths, safety rules |
+| `fabric-cli-cicd` | `skills/fabric-cli-cicd/SKILL.md` | CI/CD pipelines, deployments, Git integration |
+| `fabric-cli-powerbi` | `skills/fabric-cli-powerbi/SKILL.md` | Power BI — semantic models, reports, refresh, DAX, gateways |
+| `fabric-cli-governance` | `skills/fabric-cli-governance/SKILL.md` | Governance — ACLs, permissions, domains, capacity, audit |
+| `fabric-cli-dataengineering` | `skills/fabric-cli-dataengineering/SKILL.md` | Data engineering — lakehouses, medallion, shortcuts, Spark |
+| `fabric-cli-realtime` | `skills/fabric-cli-realtime/SKILL.md` | Real-time — eventhouses, eventstreams, KQL, Activator |
+
+### Skill Scripts
+
+Each skill includes automation scripts for common tasks:
+
+| Skill | Scripts |
+|-------|---------|
+| `fabric-cli-core` | `health_check.py` |
+| `fabric-cli-cicd` | `deploy.py`, `export_workspace.py`, `diff_definitions.py` |
+| `fabric-cli-powerbi` | `refresh_model.py`, `list_refresh_history.py`, `rebind_report.py` |
+| `fabric-cli-governance` | `audit_workspace.py`, `bulk_permissions.py`, `validate_governance.py` |
+| `fabric-cli-dataengineering` | `setup_medallion.py`, `optimize_tables.py`, `validate_shortcuts.py` |
+| `fabric-cli-realtime` | `setup_streaming.py`, `kql_query.py`, `monitor_eventstream.py` |
+
+Scripts are located in each skill's `scripts/` folder. Run with `python scripts/<script>.py --help` for usage.
+
+## Modes (Custom Agents)
+
+Custom agents appear in the VS Code Copilot dropdown. See `modes/README.md` for setup.
+
+| Mode | File | Deploy Location |
+|------|------|-----------------|
+| **Fab** | `modes/fab.agent.md` | `.github/agents/fab.agent.md` |
+
+## Prompts
+
+Reusable prompt templates for common Fabric CLI tasks. See `prompts/README.md` for details.
+
+| Prompt | Description |
+|--------|-------------|
+| `deploy-to-workspace` | Deploy items from source to target workspace |
+| `analyze-semantic-model` | Analyze semantic model structure, tables, measures |
+| `troubleshoot-refresh` | Diagnose and fix refresh failures |
+| `create-lakehouse-pipeline` | Create a data pipeline to load a Lakehouse |
+| `workspace-audit` | Audit workspace items, permissions, capacity |
+| `migrate-items` | Migrate items between workspaces with validation |
+
+## Context Files
+
+Context files provide project instructions for different AI coding assistants. See `context/README.md` for setup instructions.
+
+| File | Target Tool | Deploy Location |
+|------|-------------|-----------------|
+| `context/copilot-instructions.md` | GitHub Copilot | `.github/copilot-instructions.md` |
+| `context/CLAUDE.md` | Claude Code | `CLAUDE.md` or `.claude/CLAUDE.md` |
+| `context/cursorrules.md` | Cursor | `.cursorrules` (no extension) |
\ No newline at end of file
diff --git a/.ai-assets/context/CLAUDE.md b/.ai-assets/context/CLAUDE.md
new file mode 100644
index 000000000..7d68b2c3e
--- /dev/null
+++ b/.ai-assets/context/CLAUDE.md
@@ -0,0 +1,121 @@
+# CLAUDE.md — Microsoft Fabric CLI
+
+Context for Claude Code helping users work with the Fabric CLI. Copy or symlink to `CLAUDE.md` or `.claude/CLAUDE.md`.
+
+## What is Fabric CLI?
+
+**Fabric CLI** (`fab`) is a command-line tool for **Microsoft Fabric** with interactive (REPL) and command-line modes.
+
+- **Install**: `pip install ms-fabric-cli`
+- **Python**: 3.10, 3.11, 3.12, 3.13
+- **Platforms**: Windows, Linux, macOS
+
+## Core Design Pattern
+
+Filesystem-like hierarchy with dot entity suffixes:
+
+```
+/Workspace1.Workspace/Notebook1.Notebook
+/Workspace1.Workspace/FolderA.Folder/SemanticModel1.SemanticModel
+/Prod.Workspace/Lakehouse1.Lakehouse/Tables/customers
+```
+
+## Hierarchy Structure
+
+- **Tenant** → top-level container
+- **Workspace** → personal or team workspace
+- **Folder** → organizes items (up to ~10 levels)
+- **Item** → individual resource (Notebook, SemanticModel, Lakehouse, etc.)
+- **OneLakeItem** → storage within Lakehouse (Tables, Files)
+
+## Modes
+
+- **Interactive mode**: REPL environment, commands without `fab` prefix
+- **Command-line mode**: Single command execution, best for scripts
+
+Switch: `fab config set mode interactive` or `fab config set mode cli`
+
+## Common Commands
+
+```bash
+# Authentication
+fab auth login                    # Interactive login
+fab auth status                   # Check auth status
+
+# Navigation
+fab ls                            # List items in current location
+fab ls -a                         # Include hidden entities
+fab cd /Workspace1.Workspace      # Change directory
+
+# Item operations
+fab get MyNotebook.Notebook       # Get item details
+fab cp source.Notebook dest.Notebook  # Copy item
+fab rm OldItem.Report             # Delete item
+
+# Workspace operations
+fab ls /                          # List all workspaces
+fab mkdir /NewWorkspace.Workspace # Create workspace
+```
+
+## Authentication
+
+1. **Interactive user**: `fab auth login` (browser/WAM)
+2. **Service principal (secret)**:
+   ```bash
+   export FAB_SPN_TENANT_ID="<tenant>"
+   export FAB_SPN_CLIENT_ID="<client>"
+   export FAB_SPN_CLIENT_SECRET="<secret>"
+   fab auth login --service-principal
+   ```
+3. **Federated credential**: `FAB_SPN_FEDERATED_TOKEN` environment variable
+4. **Managed identity**: For Azure-hosted workloads
+
+## Hidden Entities
+
+Dot-prefixed, not shown by default. Use `ls -a` to view.
+
+- **Tenant-level**: `.capacities`, `.gateways`, `.connections`, `.domains`
+- **Workspace-level**: `.managedidentities`, `.sparkpools`, `.externaldatashares`
+
+## Common Item Types
+
+| Suffix | Type |
+|--------|------|
+| `.Workspace` | Workspace |
+| `.Folder` | Folder |
+| `.Notebook` | Notebook |
+| `.SemanticModel` | Power BI dataset |
+| `.Report` | Power BI report |
+| `.Lakehouse` | Lakehouse |
+| `.DataPipeline` | Data pipeline |
+| `.Warehouse` | Data warehouse |
+| `.Eventhouse` | Eventhouse (real-time) |
+| `.KQLDatabase` | KQL Database |
+
+## File Storage Locations
+
+Config files in `~/.config/fab/`:
+- `cache.bin` - encrypted token cache
+- `config.json` - CLI settings
+- `auth.json` - auth info (non-sensitive)
+
+Debug logs:
+- **Windows**: `%AppData%/fabcli_debug.log`
+- **macOS**: `~/Library/Logs/fabcli_debug.log`
+- **Linux**: `~/.local/state/fabcli_debug.log`
+
+## Best Practices
+
+1. Always verify paths before destructive operations
+2. Use `--dry-run` when available for preview
+3. Check auth status with `fab auth status` if commands fail
+4. Use relative paths when working within a workspace
+5. Prefer `fab get --output json` for scripting
+
+## Getting Help
+
+```bash
+fab --help              # General help
+fab <command> --help    # Command-specific help
+fab docs                # Open documentation
+```
\ No newline at end of file
diff --git a/.ai-assets/context/README.md b/.ai-assets/context/README.md
new file mode 100644
index 000000000..0fcf1d58c
--- /dev/null
+++ b/.ai-assets/context/README.md
@@ -0,0 +1,56 @@
+# Context Files
+
+This folder contains context/instruction files for different AI coding assistants. Each file provides the same core project information, formatted for the specific tool.
+
+## Available Files
+
+| File | Target Tool | Usage |
+|------|-------------|-------|
+| `copilot-instructions.md` | GitHub Copilot | Copy to `.github/copilot-instructions.md` |
+| `CLAUDE.md` | Claude Code | Copy to repo root as `CLAUDE.md` or `.claude/CLAUDE.md` |
+| `cursorrules.md` | Cursor | Copy content to `.cursorrules` in repo root (no extension) |
+
+## Setup Instructions
+
+### GitHub Copilot
+
+```bash
+# From repo root
+cp .ai-assets/context/copilot-instructions.md .github/copilot-instructions.md
+```
+
+Copilot automatically loads `.github/copilot-instructions.md` for all chat and code generation requests.
+
+### Claude Code
+
+```bash
+# From repo root
+cp .ai-assets/context/CLAUDE.md ./CLAUDE.md
+# Or use .claude directory
+mkdir -p .claude && cp .ai-assets/context/CLAUDE.md .claude/CLAUDE.md
+```
+
+Claude Code automatically loads `CLAUDE.md` at session start.
+
+### Cursor
+
+```bash
+# From repo root - note: no file extension
+cp .ai-assets/context/cursorrules.md .cursorrules
+```
+
+Cursor automatically loads `.cursorrules` for all AI interactions.
+
+## Content Differences
+
+All files contain the same core information about:
+- Project overview and design patterns
+- Code structure and layout
+- Build/test commands
+- Error handling patterns
+- Code standards and security rules
+
+The main differences are:
+- **Copilot**: Full detailed instructions optimized for chat and code review
+- **Claude Code**: Concise format optimized for Claude's memory system (first 200 lines loaded)
+- **Cursor**: Compact rules format for Cursor's context window
\ No newline at end of file
diff --git a/.ai-assets/context/copilot-instructions.md b/.ai-assets/context/copilot-instructions.md
new file mode 100644
index 000000000..914cef857
--- /dev/null
+++ b/.ai-assets/context/copilot-instructions.md
@@ -0,0 +1,151 @@
+# GitHub Copilot Instructions - Microsoft Fabric CLI
+
+Context for GitHub Copilot helping users work with the Fabric CLI. Copy or symlink to `.github/copilot-instructions.md`.
+
+---
+
+## What is Fabric CLI?
+
+**Fabric CLI** (`fab`) is a command-line tool for **Microsoft Fabric** with interactive (REPL) and command-line modes.
+
+- **Install**: `pip install ms-fabric-cli`
+- **Python**: 3.10, 3.11, 3.12, 3.13
+- **Platforms**: Windows, Linux, macOS
+- **Shells**: PowerShell, Bash, Zsh, cmd
+
+---
+
+## Core Design Pattern
+
+The CLI models Fabric as a **filesystem-like hierarchy** with **dot entity suffixes**:
+
+```
+/Workspace1.Workspace/Notebook1.Notebook
+/Workspace1.Workspace/FolderA.Folder/SemanticModel1.SemanticModel
+/Prod.Workspace/Lakehouse1.Lakehouse/Tables/customers
+```
+
+---
+
+## Hierarchy Structure
+
+- **Tenant** → top-level container
+- **Workspace** → personal or team workspace
+- **Folder** → organizes items (up to ~10 levels)
+- **Item** → individual resource (Notebook, SemanticModel, Lakehouse, etc.)
+- **OneLakeItem** → storage within Lakehouse (Tables, Files)
+
+---
+
+## Modes
+
+- **Interactive mode**: REPL environment, commands without `fab` prefix
+- **Command-line mode**: Single command execution, best for scripts
+
+Switch modes with `fab config set mode interactive` or `fab config set mode cli`.
+
+---
+
+## Common Commands
+
+```bash
+# Authentication
+fab auth login                    # Interactive login
+fab auth status                   # Check auth status
+
+# Navigation
+fab ls                            # List items in current location
+fab ls -a                         # Include hidden entities
+fab cd /Workspace1.Workspace      # Change directory
+
+# Item operations
+fab get MyNotebook.Notebook       # Get item details
+fab cp source.Notebook dest.Notebook  # Copy item
+fab rm OldItem.Report             # Delete item
+
+# Workspace operations
+fab ls /                          # List all workspaces
+fab mkdir /NewWorkspace.Workspace # Create workspace
+```
+
+---
+
+## Authentication
+
+Supported patterns:
+
+1. **Interactive user**: `fab auth login` (browser/WAM)
+2. **Service principal (secret)**:
+   ```bash
+   export FAB_SPN_TENANT_ID="<tenant>"
+   export FAB_SPN_CLIENT_ID="<client>"
+   export FAB_SPN_CLIENT_SECRET="<secret>"
+   fab auth login --service-principal
+   ```
+3. **Federated credential**: `FAB_SPN_FEDERATED_TOKEN` environment variable
+4. **Managed identity**: For Azure-hosted workloads
+
+---
+
+## Hidden Entities
+
+Dot-prefixed entities not shown by default. Use `ls -a` to view.
+
+- **Tenant-level**: `.capacities`, `.gateways`, `.connections`, `.domains`
+- **Workspace-level**: `.managedidentities`, `.sparkpools`, `.externaldatashares`
+
+```bash
+fab ls .capacities
+fab ls ws1.Workspace/.sparkpools
+```
+
+---
+
+## Common Item Types
+
+| Suffix | Type |
+|--------|------|
+| `.Workspace` | Workspace |
+| `.Folder` | Folder |
+| `.Notebook` | Notebook |
+| `.SemanticModel` | Power BI dataset |
+| `.Report` | Power BI report |
+| `.Lakehouse` | Lakehouse |
+| `.DataPipeline` | Data pipeline |
+| `.Warehouse` | Data warehouse |
+| `.Eventhouse` | Eventhouse (real-time) |
+| `.KQLDatabase` | KQL Database |
+
+---
+
+## File Storage Locations
+
+Config files in `~/.config/fab/`:
+- `cache.bin` - encrypted token cache
+- `config.json` - CLI settings
+- `auth.json` - auth info (non-sensitive)
+
+Debug logs:
+- **Windows**: `%AppData%/fabcli_debug.log`
+- **macOS**: `~/Library/Logs/fabcli_debug.log`
+- **Linux**: `~/.local/state/fabcli_debug.log`
+
+---
+
+## Best Practices
+
+1. **Always verify paths** before destructive operations
+2. **Use `--dry-run`** when available for preview
+3. **Check auth status** with `fab auth status` if commands fail
+4. **Use relative paths** when working within a workspace
+5. **Prefer `fab get --output json`** for scripting
+
+---
+
+## Getting Help
+
+```bash
+fab --help              # General help
+fab <command> --help    # Command-specific help
+fab docs                # Open documentation
+```
diff --git a/.ai-assets/context/cursorrules.md b/.ai-assets/context/cursorrules.md
new file mode 100644
index 000000000..94f3a636c
--- /dev/null
+++ b/.ai-assets/context/cursorrules.md
@@ -0,0 +1,121 @@
+# Cursor Rules — Microsoft Fabric CLI
+
+Context for Cursor helping users work with the Fabric CLI. Copy to `.cursorrules` in the repository root (no file extension).
+
+## What is Fabric CLI?
+
+**Fabric CLI** (`fab`) is a command-line tool for **Microsoft Fabric** with interactive (REPL) and command-line modes.
+
+- **Install**: `pip install ms-fabric-cli`
+- **Python**: 3.10, 3.11, 3.12, 3.13
+- **Platforms**: Windows, Linux, macOS
+
+## Core Design Pattern
+
+Filesystem-like hierarchy with dot entity suffixes:
+
+```
+/Workspace1.Workspace/Notebook1.Notebook
+/Workspace1.Workspace/FolderA.Folder/SemanticModel1.SemanticModel
+/Prod.Workspace/Lakehouse1.Lakehouse/Tables/customers
+```
+
+## Hierarchy Structure
+
+- **Tenant** → top-level container
+- **Workspace** → personal or team workspace
+- **Folder** → organizes items (up to ~10 levels)
+- **Item** → individual resource (Notebook, SemanticModel, Lakehouse, etc.)
+- **OneLakeItem** → storage within Lakehouse (Tables, Files)
+
+## Modes
+
+- **Interactive mode**: REPL environment, commands without `fab` prefix
+- **Command-line mode**: Single command execution, best for scripts
+
+Switch: `fab config set mode interactive` or `fab config set mode cli`
+
+## Common Commands
+
+```bash
+# Authentication
+fab auth login                    # Interactive login
+fab auth status                   # Check auth status
+
+# Navigation
+fab ls                            # List items in current location
+fab ls -a                         # Include hidden entities
+fab cd /Workspace1.Workspace      # Change directory
+
+# Item operations
+fab get MyNotebook.Notebook       # Get item details
+fab cp source.Notebook dest.Notebook  # Copy item
+fab rm OldItem.Report             # Delete item
+
+# Workspace operations
+fab ls /                          # List all workspaces
+fab mkdir /NewWorkspace.Workspace # Create workspace
+```
+
+## Authentication
+
+1. **Interactive user**: `fab auth login` (browser/WAM)
+2. **Service principal (secret)**:
+   ```bash
+   export FAB_SPN_TENANT_ID="<tenant>"
+   export FAB_SPN_CLIENT_ID="<client>"
+   export FAB_SPN_CLIENT_SECRET="<secret>"
+   fab auth login --service-principal
+   ```
+3. **Federated credential**: `FAB_SPN_FEDERATED_TOKEN` environment variable
+4. **Managed identity**: For Azure-hosted workloads
+
+## Hidden Entities
+
+Dot-prefixed, not shown by default. Use `ls -a` to view.
+
+- **Tenant-level**: `.capacities`, `.gateways`, `.connections`, `.domains`
+- **Workspace-level**: `.managedidentities`, `.sparkpools`, `.externaldatashares`
+
+## Common Item Types
+
+| Suffix | Type |
+|--------|------|
+| `.Workspace` | Workspace |
+| `.Folder` | Folder |
+| `.Notebook` | Notebook |
+| `.SemanticModel` | Power BI dataset |
+| `.Report` | Power BI report |
+| `.Lakehouse` | Lakehouse |
+| `.DataPipeline` | Data pipeline |
+| `.Warehouse` | Data warehouse |
+| `.Eventhouse` | Eventhouse (real-time) |
+| `.KQLDatabase` | KQL Database |
+
+## File Storage Locations
+
+Config files in `~/.config/fab/`:
+- `cache.bin` - encrypted token cache
+- `config.json` - CLI settings
+- `auth.json` - auth info (non-sensitive)
+
+Debug logs:
+- **Windows**: `%AppData%/fabcli_debug.log`
+- **macOS**: `~/Library/Logs/fabcli_debug.log`
+- **Linux**: `~/.local/state/fabcli_debug.log`
+
+## Best Practices
+
+1. Always verify paths before destructive operations
+2. Use `--dry-run` when available for preview
+3. Check auth status with `fab auth status` if commands fail
+4. Use relative paths when working within a workspace
+5. Prefer `fab get --output json` for scripting
+
+## Getting Help
+
+```bash
+fab --help              # General help
+fab <command> --help    # Command-specific help
+fab docs                # Open documentation
+```
\ No newline at end of file
diff --git a/.ai-assets/modes/README.md b/.ai-assets/modes/README.md
new file mode 100644
index 000000000..99da26a2d
--- /dev/null
+++ b/.ai-assets/modes/README.md
@@ -0,0 +1,47 @@
+# Modes (Custom Agents)
+
+Custom agents (formerly "chat modes") configure AI behavior for specific tasks. When activated, they appear in the VS Code Copilot dropdown alongside Agent, Ask, and Edit.
+
+## Available Modes
+
+| Mode | File | Description |
+|------|------|-------------|
+| **Fab** | `fab.agent.md` | Operate Microsoft Fabric using the fab CLI |
+
+## Setup
+
+Copy the agent file to `.github/agents/` in any workspace where you want to use it:
+
+```bash
+# From repo root
+mkdir -p .github/agents
+cp .ai-assets/modes/fab.agent.md .github/agents/
+```
+
+Once installed, **Fab** appears in the Copilot mode dropdown (Ctrl+Shift+I → dropdown).
+
+## What Fab Mode Provides
+
+When you switch to Fab mode, the AI:
+
+- **Knows the Fabric hierarchy** — Tenant → Workspace → Folder → Item → OneLakeItem
+- **Uses dot suffixes correctly** — `.Workspace`, `.Notebook`, `.SemanticModel`
+- **Runs fab commands** — Has terminal access to execute commands
+- **Follows safety rules** — Confirms before destructive operations
+- **Understands hidden entities** — `.capacities`, `.gateways`, `.sparkpools`
+
+## File Format
+
+Agent files use `.agent.md` extension with YAML frontmatter:
+
+```markdown
+---
+name: Agent Name
+description: Brief description shown in chat input
+tools: ['runInTerminal', 'search', 'fetch']
+---
+
+# Instructions in Markdown
+```
+
+See [VS Code Custom Agents docs](https://code.visualstudio.com/docs/copilot/customization/custom-agents) for full specification.
\ No newline at end of file
diff --git a/.ai-assets/modes/fab.agent.md b/.ai-assets/modes/fab.agent.md
new file mode 100644
index 000000000..cac85a902
--- /dev/null
+++ b/.ai-assets/modes/fab.agent.md
@@ -0,0 +1,105 @@
+---
+name: Fab
+description: Operate Microsoft Fabric using the fab CLI
+argument-hint: Ask me to list workspaces, run notebooks, manage items, or automate Fabric tasks
+tools: ['runInTerminal', 'terminalLastCommand', 'search', 'fetch', 'read_file']
+---
+
+# Fab — Microsoft Fabric CLI Agent
+
+You are an expert at operating Microsoft Fabric using the `fab` command-line interface. Help users navigate, manage, and automate their Fabric environment.
+
+## Mental Model
+
+Fabric is a **filesystem-like hierarchy** with **dot entity suffixes**:
+
+```
+Tenant
+└── Workspace.Workspace
+    └── Folder.Folder
+        └── Item.<ItemType>
+            └── OneLakeItem (tables, files)
+```
+
+**Example paths:**
+- `/Sales.Workspace/Reports.Folder/Revenue.Report`
+- `/Dev.Workspace/ETL.Notebook`
+- `/Prod.Workspace/Lakehouse1.Lakehouse/Tables/customers`
+
+## Common Item Types
+
+| Suffix | Description |
+|--------|-------------|
+| `.Workspace` | Workspace container |
+| `.Folder` | Folder within workspace |
+| `.Notebook` | Fabric notebook |
+| `.SemanticModel` | Power BI dataset |
+| `.Report` | Power BI report |
+| `.Lakehouse` | Lakehouse |
+| `.Warehouse` | Data warehouse |
+| `.DataPipeline` | Data pipeline |
+
+## Before Running Commands
+
+1. **Check authentication first:**
+   ```bash
+   fab auth status
+   ```
+   If not authenticated, guide user to run `fab auth login`
+
+2. **Use `--help` when unsure:**
+   ```bash
+   fab <command> --help
+   ```
+
+3. **Verify paths with `fab ls` or `fab exists` before acting**
+
+## Hidden Entities
+
+Use `ls -a` to see hidden resources. Access with dot-prefix:
+
+- **Tenant level:** `.capacities`, `.gateways`, `.connections`, `.domains`
+- **Workspace level:** `.managedidentities`, `.sparkpools`, `.externaldatashares`
+
+```bash
+fab ls .capacities
+fab ls MyWorkspace.Workspace/.sparkpools
+```
+
+## Safety Rules
+
+- **Ask before destructive operations** (delete, overwrite, permission changes)
+- **Never log or display tokens, secrets, or credentials**
+- **Validate paths before executing** — use `fab exists <path>` to verify
+- **Use `-f` flag** for non-interactive/scripted execution when appropriate
+
+## Command Patterns
+
+**Navigation:**
+```bash
+fab ls                           # List current location
+fab ls /Workspace.Workspace      # List workspace contents
+fab cd /Workspace.Workspace      # Change directory
+fab get <path>                   # Get item details
+```
+
+**Operations:**
+```bash
+fab export <path> -o ./output/   # Export item definition
+fab import <path> -i ./input/    # Import item definition
+fab job run <path>               # Run notebook/pipeline
+fab job run-status <path>        # Check job status
+```
+
+**Discovery:**
+```bash
+fab desc .<ItemType>             # Describe item type schema
+fab --help                       # CLI help
+```
+
+## Modes
+
+- **Interactive mode:** REPL environment, commands without `fab` prefix
+- **Command-line mode:** Single command execution, best for scripts
+
+When providing instructions, show commands in **command-line mode** (with `fab` prefix) unless user specifies they're in interactive mode.
diff --git a/.ai-assets/prompts/README.md b/.ai-assets/prompts/README.md
new file mode 100644
index 000000000..1b9691d64
--- /dev/null
+++ b/.ai-assets/prompts/README.md
@@ -0,0 +1,34 @@
+# Fabric CLI Prompts
+
+Reusable prompt templates for common Fabric CLI tasks. Use these with any AI coding assistant.
+
+## Available Prompts
+
+| Prompt | Description |
+|--------|-------------|
+| [deploy-to-workspace](deploy-to-workspace.prompt.md) | Deploy Fabric items from source to target workspace |
+| [analyze-semantic-model](analyze-semantic-model.prompt.md) | Analyze a semantic model's structure, tables, and measures |
+| [troubleshoot-refresh](troubleshoot-refresh.prompt.md) | Diagnose and fix refresh failures |
+| [create-lakehouse-pipeline](create-lakehouse-pipeline.prompt.md) | Create a data pipeline to load a Lakehouse |
+| [workspace-audit](workspace-audit.prompt.md) | Audit workspace items, permissions, and capacity |
+| [migrate-items](migrate-items.prompt.md) | Migrate items between workspaces with validation |
+
+## Usage
+
+Copy the prompt content into your AI assistant, or reference the file directly. Each prompt includes:
+
+- Step-by-step instructions
+- Relevant `fab` CLI commands
+- Safety guidelines and best practices
+- Validation steps
+
+## Customization
+
+Adapt prompts to your needs:
+- Replace `{workspaceName}` placeholders with actual values
+- Add organization-specific policies
+- Include environment-specific defaults
+
+## References
+
+- [fabric-cli Documentation](https://microsoft.github.io/fabric-cli/)
diff --git a/.ai-assets/prompts/analyze-semantic-model.prompt.md b/.ai-assets/prompts/analyze-semantic-model.prompt.md
new file mode 100644
index 000000000..ea14b4ed6
--- /dev/null
+++ b/.ai-assets/prompts/analyze-semantic-model.prompt.md
@@ -0,0 +1,61 @@
+# Analyze Semantic Model
+
+Analyze the semantic model **${input:semanticModelName}** in workspace **${input:workspaceName}**.
+
+## Analysis Steps
+
+### 1. Basic Information
+Get the semantic model's metadata:
+```
+fab get {workspaceName}.Workspace/{semanticModelName}.SemanticModel
+```
+
+### 2. Model Definition
+Export and inspect the full model definition:
+```
+fab export {workspaceName}.Workspace/{semanticModelName}.SemanticModel -o ./analysis -f
+```
+
+### 3. Table Schema
+View the exported TMDL files to inspect tables and columns:
+```
+# Tables are in: ./analysis/{semanticModelName}.SemanticModel/definition/tables/
+```
+
+### 4. Measures
+Review measure definitions in the TMDL:
+```
+# Measures are defined within table TMDL files or a dedicated measures table
+```
+
+### 5. Refresh History
+Check recent refresh status:
+```
+fab jobs ls {workspaceName}.Workspace --item-name {semanticModelName}
+```
+
+## What to Look For
+
+### Data Quality Issues
+- Tables with no relationships (orphaned)
+- Missing or incorrect data types
+- Large tables that may need partitioning
+
+### Performance Concerns
+- Complex calculated columns (consider measures instead)
+- Many-to-many relationships
+- Large cardinality columns
+
+### Best Practice Violations
+- Measures not in a dedicated measures table
+- Inconsistent naming conventions
+- Missing descriptions on tables/columns
+
+## Output Format
+
+Provide a summary including:
+1. **Overview** - Model name, size, table count
+2. **Schema** - Tables, columns, data types
+3. **Calculations** - Measures with complexity assessment
+4. **Relationships** - Diagram description
+5. **Recommendations** - Optimization suggestions
diff --git a/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md b/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md
new file mode 100644
index 000000000..fc136c9f7
--- /dev/null
+++ b/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md
@@ -0,0 +1,91 @@
+# Create Lakehouse Pipeline
+
+Create a data pipeline to load data into lakehouse **${input:lakehouseName}** in workspace **${input:workspaceName}**.
+
+## Prerequisites Check
+
+### 1. Verify Lakehouse Exists
+```
+fab exists {workspaceName}.Workspace/{lakehouseName}.Lakehouse
+```
+
+If lakehouse doesn't exist, create it via API:
+```
+fab api POST workspaces/{workspaceId}/items -b '{"type": "Lakehouse", "displayName": "{lakehouseName}"}'
+```
+
+### 2. Verify Workspace Context
+```
+fab cd {workspaceName}.Workspace
+fab ls
+```
+
+## Pipeline Creation Options
+
+### Option A: Create Pipeline via API
+
+Create a new Data Pipeline:
+```
+fab api POST workspaces/{workspaceId}/items -b '{
+  "type": "DataPipeline", 
+  "displayName": "{pipelineName}",
+  "description": "Pipeline to load {lakehouseName}"
+}'
+```
+
+### Option B: Import Existing Pipeline Definition
+
+If you have a pipeline definition file:
+```
+fab import {workspaceName}.Workspace/{pipelineName}.DataPipeline -i ./pipeline-definition -f
+```
+
+## Common Pipeline Patterns
+
+### Pattern 1: Copy Activity (Source → Lakehouse)
+- Use Copy activity to move data from external source
+- Configure source connection (SQL, Azure Blob, etc.)
+- Set destination to Lakehouse Tables folder
+
+### Pattern 2: Dataflow Gen2
+- Create Dataflow Gen2 for transformations
+- Output to Lakehouse tables
+- Schedule via Pipeline
+
+### Pattern 3: Notebook Activity
+- Use Notebook activity for Spark transformations
+- Read from Files, write to Tables
+- Pass parameters from Pipeline
+
+## Data Loading Best Practices
+
+1. **Use Delta format** - Lakehouse tables use Delta Lake
+2. **Partition large tables** - By date or key columns
+3. **Incremental loads** - Use watermarks for efficiency
+4. **Error handling** - Configure retry policies
+
+## Shortcuts for External Data
+
+Create shortcuts to external data without copying:
+```
+fab ln {externalPath} {workspaceName}.Workspace/{lakehouseName}.Lakehouse/Files/{shortcutName}
+```
+
+## Verify Pipeline
+
+Get pipeline details:
+```
+fab get {workspaceName}.Workspace/{pipelineName}.DataPipeline
+```
+
+## Run and Monitor
+
+Trigger pipeline run:
+```
+fab job run {workspaceName}.Workspace/{pipelineName}.DataPipeline
+```
+
+Monitor execution:
+```
+fab job run-list {workspaceName}.Workspace/{pipelineName}.DataPipeline
+```
diff --git a/.ai-assets/prompts/deploy-to-workspace.prompt.md b/.ai-assets/prompts/deploy-to-workspace.prompt.md
new file mode 100644
index 000000000..c292e9742
--- /dev/null
+++ b/.ai-assets/prompts/deploy-to-workspace.prompt.md
@@ -0,0 +1,52 @@
+# Deploy Items to Target Workspace
+
+Deploy Fabric items from **${input:sourceWorkspace}** to **${input:targetWorkspace}**.
+
+## Pre-Deployment Checklist
+
+Before deploying, verify:
+
+1. **Authentication** - Confirm `fab auth status` shows valid credentials
+2. **Source exists** - List items in source workspace to confirm what to deploy
+3. **Target access** - Verify write permissions on target workspace
+4. **Item conflicts** - Check if items already exist in target (will be overwritten)
+
+## Deployment Steps
+
+1. First, list items in the source workspace:
+   ```
+   fab ls {sourceWorkspace}.Workspace
+   ```
+
+2. For each item to deploy, use copy command:
+   ```
+   fab cp {sourceWorkspace}.Workspace/{itemName}.{ItemType} {targetWorkspace}.Workspace/ -f
+   ```
+
+3. Verify deployment by listing target workspace:
+   ```
+   fab ls {targetWorkspace}.Workspace
+   ```
+
+## Safety Guidelines
+
+- **Never deploy to production without testing first**
+- Copy commands OVERWRITE existing items with same name
+- Use `-f` flag for non-interactive execution
+- For large deployments, deploy in batches and verify each
+
+## Common Item Types
+
+- `.SemanticModel` - Power BI datasets
+- `.Report` - Power BI reports  
+- `.Notebook` - Spark notebooks
+- `.Lakehouse` - Lakehouse definitions
+- `.DataPipeline` - Data pipelines
+- `.Warehouse` - SQL warehouses
+
+## Rollback Strategy
+
+If deployment fails:
+1. Check item status with `fab get {targetWorkspace}.Workspace/{itemName}.{ItemType}`
+2. Items can be re-deployed from source
+3. Consider keeping backups via `fab export` before deployment
diff --git a/.ai-assets/prompts/migrate-items.prompt.md b/.ai-assets/prompts/migrate-items.prompt.md
new file mode 100644
index 000000000..fbd9969da
--- /dev/null
+++ b/.ai-assets/prompts/migrate-items.prompt.md
@@ -0,0 +1,108 @@
+# Migrate Items Between Workspaces
+
+Migrate items from **${input:sourceWorkspace}** to **${input:targetWorkspace}**.
+
+## Pre-Migration Assessment
+
+### 1. Verify Source Items
+```
+fab ls {sourceWorkspace}.Workspace
+```
+
+### 2. Check Target Workspace
+```
+fab ls {targetWorkspace}.Workspace
+```
+
+### 3. Verify Permissions
+Source (need read):
+```
+fab acls ls {sourceWorkspace}.Workspace
+```
+
+Target (need write):
+```
+fab acls ls {targetWorkspace}.Workspace
+```
+
+## Migration Strategy
+
+### Option 1: Item-by-Item Migration
+Copy individual items:
+```
+fab cp {sourceWorkspace}.Workspace/{itemName}.{ItemType} {targetWorkspace}.Workspace/ -f
+```
+
+### Option 2: Export/Import Pattern
+Export from source, then import to target:
+```
+# Export
+fab export {sourceWorkspace}.Workspace/{itemName}.{ItemType} -o ./migration -f
+
+# Import
+fab import {targetWorkspace}.Workspace/{itemName}.{ItemType} -i ./migration/{itemName}.{ItemType} -f
+```
+
+## Migration Order (Dependencies)
+
+Follow this order to maintain dependencies:
+
+1. **Lakehouses** - Data foundation
+2. **Semantic Models** - Depend on Lakehouses
+3. **Reports** - Depend on Semantic Models
+4. **Pipelines** - May reference other items
+5. **Notebooks** - Usually independent
+
+## Post-Migration Validation
+
+### 1. Verify Items Copied
+```
+fab ls {targetWorkspace}.Workspace
+```
+
+### 2. Compare Source and Target
+List both workspaces and compare item counts manually:
+```
+fab ls {sourceWorkspace}.Workspace
+fab ls {targetWorkspace}.Workspace
+```
+
+### 3. Test Key Items
+Get details of critical items to verify:
+```
+fab get {targetWorkspace}.Workspace/{keyModel}.SemanticModel
+```
+
+### 4. Test Refresh
+Trigger refresh on migrated items:
+```
+fab job run {targetWorkspace}.Workspace/{keyModel}.SemanticModel
+```
+
+## Connection Updates
+
+After migration, update data source connections if needed:
+- Lakehouses may need shortcut updates
+- Semantic Models may need connection rebinding
+- Pipelines may need parameter updates
+
+## Rollback Plan
+
+If migration fails:
+1. Document which items successfully migrated
+2. Delete failed items in target: `fab rm {targetWorkspace}.Workspace/{itemName}.{ItemType} -f`
+3. Re-attempt migration for failed items
+4. Source workspace remains unchanged (copy doesn't delete)
+
+## Migration Checklist
+
+- [ ] Backup target workspace inventory (if items exist)
+- [ ] Verify source access
+- [ ] Verify target access
+- [ ] Copy items in dependency order
+- [ ] Validate item counts match
+- [ ] Test refresh on semantic models
+- [ ] Test reports open correctly
+- [ ] Update connections if needed
+- [ ] Update ACLs if needed
+- [ ] Notify users of new workspace location
diff --git a/.ai-assets/prompts/troubleshoot-refresh.prompt.md b/.ai-assets/prompts/troubleshoot-refresh.prompt.md
new file mode 100644
index 000000000..8a0862921
--- /dev/null
+++ b/.ai-assets/prompts/troubleshoot-refresh.prompt.md
@@ -0,0 +1,70 @@
+# Troubleshoot Refresh Failure
+
+Diagnose refresh issues for **${input:itemName}** in workspace **${input:workspaceName}**.
+
+## Step 1: Get Recent Job History
+
+List recent job runs for the item:
+```
+fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
+```
+
+## Step 2: Get Failed Job Details
+
+Get details of a specific job run:
+```
+fab job run-status {workspaceName}.Workspace/{itemName}.{ItemType} --id {jobId}
+```
+
+## Step 3: Common Failure Patterns
+
+### Data Source Connectivity
+- **Symptoms**: "Cannot connect to data source", timeout errors
+- **Check**: Credentials, gateway status, network connectivity
+- **Fix**: `fab auth` to refresh credentials, check gateway logs
+
+### Memory/Capacity Issues
+- **Symptoms**: "Out of memory", "Capacity throttled"
+- **Check**: Workspace capacity utilization
+- **Fix**: Scale capacity, optimize model, schedule during off-peak
+
+### Data Source Changes
+- **Symptoms**: "Column not found", "Table not found"
+- **Check**: Source schema hasn't changed
+- **Fix**: Update model schema, re-map columns
+
+### Credential Expiration
+- **Symptoms**: "Authentication failed", "Token expired"
+- **Check**: Data source credentials
+- **Fix**: Update credentials in workspace settings
+
+### Gateway Issues
+- **Symptoms**: "Gateway unreachable", "Gateway timeout"
+- **Check**: Gateway online status, version
+- **Fix**: Restart gateway, update gateway version
+
+## Step 4: Trigger Manual Refresh
+
+After fixing the issue, trigger a new refresh:
+```
+fab job run {workspaceName}.Workspace/{itemName}.{ItemType}
+```
+
+Monitor the job:
+```
+fab job run-status {workspaceName}.Workspace/{itemName}.{ItemType} --id {newJobId}
+```
+
+## Step 5: Verify Success
+
+Confirm the refresh completed by listing job runs:
+```
+fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
+```
+
+## Escalation
+
+If issue persists:
+1. Check Fabric service health at status.cloud.microsoft
+2. Export detailed logs via `fab api` for support ticket
+3. Contact workspace administrator for capacity issues
diff --git a/.ai-assets/prompts/workspace-audit.prompt.md b/.ai-assets/prompts/workspace-audit.prompt.md
new file mode 100644
index 000000000..60b6b47ec
--- /dev/null
+++ b/.ai-assets/prompts/workspace-audit.prompt.md
@@ -0,0 +1,102 @@
+# Workspace Audit
+
+Perform a comprehensive audit of workspace **${input:workspaceName}**.
+
+## 1. Workspace Overview
+
+### Get Workspace Details
+```
+fab get {workspaceName}.Workspace
+```
+
+### List All Items
+```
+fab ls {workspaceName}.Workspace
+```
+
+## 2. Item Inventory
+
+List items in the workspace (note: filter by type in output, not via flag):
+```
+fab ls {workspaceName}.Workspace
+```
+
+Identify items by their suffixes:
+- `.SemanticModel` - Power BI datasets
+- `.Report` - Power BI reports
+- `.Lakehouse` - Lakehouses
+- `.Notebook` - Notebooks
+- `.DataPipeline` - Pipelines
+
+## 3. Capacity & Usage
+
+### Check Workspace Capacity
+```
+fab get {workspaceName}.Workspace
+```
+
+### Recent Jobs
+For each item that supports jobs, check run history:
+```
+fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
+```
+
+## 4. Security Review
+
+### Workspace Role Assignments
+```
+fab acls ls {workspaceName}.Workspace
+```
+
+### Item-Level Permissions
+For sensitive items, check individual permissions:
+```
+fab acls ls {workspaceName}.Workspace/{itemName}.{ItemType}
+```
+
+## 5. Data Lineage
+
+### Check Shortcuts
+List items and look for shortcuts in Lakehouse paths:
+```
+fab ls {workspaceName}.Workspace/{lakehouseName}.Lakehouse/Files
+```
+
+## Audit Report Template
+
+### Executive Summary
+- Workspace: {workspaceName}
+- Audit Date: {date}
+- Total Items: {count}
+- Active Users: {users}
+
+### Item Inventory
+| Type | Count | Last Modified |
+|------|-------|---------------|
+| Semantic Models | | |
+| Reports | | |
+| Lakehouses | | |
+| Notebooks | | |
+| Pipelines | | |
+
+### Health Status
+- Failed Jobs (Last 7 days): 
+- Stale Items (No refresh > 30 days):
+- Orphaned Items (No owner):
+
+### Security Findings
+- Over-permissioned items:
+- External sharing:
+- Guest access:
+
+### Recommendations
+1. 
+2. 
+3. 
+
+## Export Audit Data
+
+Export workspace listing to JSON:
+```
+fab ls {workspaceName}.Workspace -o json > audit-{workspaceName}.json
+```
diff --git a/.ai-assets/skills/README.md b/.ai-assets/skills/README.md
new file mode 100644
index 000000000..ad0b65c4b
--- /dev/null
+++ b/.ai-assets/skills/README.md
@@ -0,0 +1,37 @@
+# Skills
+
+Skills are task-specific instruction sets that guide AI agents when helping users with Microsoft Fabric CLI operations.
+
+## Available Skills
+
+| Skill | Description |
+|-------|-------------|
+| [fabric-cli-core](./fabric-cli-core/) | Core CLI operations — paths, auth, safety rules, item types |
+| [fabric-cli-cicd](./fabric-cli-cicd/) | CI/CD pipelines — deployments, Git integration, automation |
+| [fabric-cli-powerbi](./fabric-cli-powerbi/) | Power BI operations — semantic models, reports, refresh, DAX, gateways |
+| [fabric-cli-governance](./fabric-cli-governance/) | Governance — ACLs, permissions, domains, capacity, sensitivity labels, audit |
+| [fabric-cli-dataengineering](./fabric-cli-dataengineering/) | Data engineering — lakehouses, medallion architecture, shortcuts, Spark |
+| [fabric-cli-realtime](./fabric-cli-realtime/) | Real-time intelligence — eventhouses, eventstreams, KQL, Activator alerts |
+
+## Usage
+
+Load skills based on the user's task:
+
+- **Always load `fabric-cli-core` first** — Provides foundational guidance for all CLI operations
+- **Load `fabric-cli-cicd`** when working with pipelines, deployments, or automation
+- **Load `fabric-cli-powerbi`** when working with semantic models, reports, DAX queries, or gateways
+- **Load `fabric-cli-governance`** when working with permissions, ACLs, domains, capacity, or compliance
+- **Load `fabric-cli-dataengineering`** when working with lakehouses, medallion architecture, shortcuts, or Spark
+- **Load `fabric-cli-realtime`** when working with eventhouses, eventstreams, KQL queries, or real-time alerts
+
+## Skill Structure
+
+Each skill folder contains:
+
+```
+<skill-name>/
+├── SKILL.md           # Main skill definition (load this)
+├── README.md          # Human-readable overview
+├── references/        # Detailed reference docs and examples
+└── scripts/           # Python automation scripts
+```
\ No newline at end of file
diff --git a/.ai-assets/skills/fabric-cli-cicd/README.md b/.ai-assets/skills/fabric-cli-cicd/README.md
new file mode 100644
index 000000000..4fa8d43a1
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/README.md
@@ -0,0 +1,52 @@
+# fabric-cli-cicd
+
+CI/CD skill for automating Microsoft Fabric deployments. Load after `fabric-cli-core`.
+
+## What This Skill Provides
+
+- GitHub Actions and Azure Pipelines examples
+- Environment promotion strategies (dev → test → prod)
+- Export/import automation patterns
+- Git integration for Fabric items
+- Error handling and rollback strategies
+- Secrets management guidance
+
+## When to Use
+
+Activate when tasks involve:
+
+- Setting up deployment pipelines
+- Environment promotion (dev → test → prod)
+- Automating Fabric item exports/imports
+- Git-based source control for Fabric definitions
+- Service principal authentication for automation
+
+## Prerequisites
+
+Load [`fabric-cli-core`](../fabric-cli-core/) first for foundational guidance.
+
+## Entry Point
+
+Load [`SKILL.md`](./SKILL.md) to activate this skill.
+
+## Scripts
+
+Automation scripts for CI/CD tasks:
+
+| Script | Description | Usage |
+|--------|-------------|-------|
+| `deploy.py` | Deploy items from local folder to workspace | `python scripts/deploy.py <source> <target-ws> [--dry-run]` |
+| `export_workspace.py` | Export all workspace items for version control | `python scripts/export_workspace.py <workspace> -o <dir>` |
+| `diff_definitions.py` | Compare item definitions between environments | `python scripts/diff_definitions.py <item1> <item2>` |
+
+## References
+
+Detailed documentation in the `references/` folder:
+
+| Reference | Description |
+|-----------|-------------|
+| [github-actions.md](./references/github-actions.md) | Complete GitHub Actions workflow examples |
+| [azure-pipelines.md](./references/azure-pipelines.md) | Azure Pipelines YAML templates |
+| [environment-promotion.md](./references/environment-promotion.md) | Dev/test/prod promotion strategies |
+| [git-integration.md](./references/git-integration.md) | Source control patterns |
+| [automation-patterns.md](./references/automation-patterns.md) | Scripts and error handling |
diff --git a/.ai-assets/skills/fabric-cli-cicd/SKILL.md b/.ai-assets/skills/fabric-cli-cicd/SKILL.md
new file mode 100644
index 000000000..9f0620854
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/SKILL.md
@@ -0,0 +1,267 @@
+---
+name: fabric-cli-cicd
+description: Use for CI/CD pipelines, deployment automation, environment promotion, and Git integration with Microsoft Fabric CLI. Activate when deploying Fabric items, setting up GitHub Actions or Azure Pipelines, or automating environment migrations.
+---
+
+# Fabric CLI CI/CD Operations
+
+Expert guidance for automating Microsoft Fabric deployments using the `fab` CLI in CI/CD pipelines.
+
+## When to Use This Skill
+
+Activate automatically when tasks involve:
+
+- Setting up deployment pipelines (GitHub Actions, Azure Pipelines)
+- Environment promotion (dev → test → prod)
+- Automating Fabric item exports/imports
+- Git-based source control for Fabric definitions
+- Scheduling and orchestrating Fabric operations
+- Service principal authentication for automation
+
+## Prerequisites
+
+- Load `fabric-cli-core` skill first for foundational guidance
+- User must have appropriate workspace permissions in target environments
+- Service principal with Fabric API permissions recommended for automation
+- `fab` CLI installed in pipeline environment (`pip install ms-fabric-cli`)
+
+## Automation Scripts
+
+Ready-to-use Python scripts for CI/CD automation. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `deploy.py` | Deploy items from local folder to workspace | `python scripts/deploy.py <source> <target-ws> [--dry-run]` |
+| `export_workspace.py` | Export all workspace items for version control | `python scripts/export_workspace.py <workspace> -o <dir>` |
+| `diff_definitions.py` | Compare item definitions between environments | `python scripts/diff_definitions.py <item1> <item2>` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+## 1 - Authentication for CI/CD
+
+### Service Principal Setup (Recommended)
+
+Use environment variables for secure, non-interactive authentication:
+
+```bash
+# Required environment variables
+export FAB_SPN_TENANT_ID="<tenant-id>"
+export FAB_SPN_CLIENT_ID="<client-id>"
+export FAB_SPN_CLIENT_SECRET="<client-secret>"  # Or use certificate/federated
+
+# Authenticate
+fab auth login --service-principal
+
+# Verify
+fab auth status
+```
+
+### Authentication Methods by Priority
+
+| Method | Use Case | Security |
+|--------|----------|----------|
+| Federated credential | GitHub Actions, Azure Pipelines | Best (no secrets) |
+| Certificate | Long-running automation | Good |
+| Client secret | Simple automation | Rotate regularly |
+| Managed identity | Azure-hosted runners | Best (no credentials) |
+
+### Federated Credential (GitHub Actions)
+
+```bash
+export FAB_SPN_TENANT_ID="<tenant-id>"
+export FAB_SPN_CLIENT_ID="<client-id>"
+export FAB_SPN_FEDERATED_TOKEN="$ACTIONS_ID_TOKEN"
+
+fab auth login --service-principal --federated
+```
+
+## 2 - Export/Import Patterns
+
+### Export Items for Version Control
+
+```bash
+# Export single item
+fab export "Dev.Workspace/Pipeline.DataPipeline" -o ./fabric-items/ -f
+
+# Export entire workspace
+fab export "Dev.Workspace" -o ./fabric-items/ -a -f
+
+# Export with specific format
+fab get "Dev.Workspace/Model.SemanticModel" -q "definition" > ./definitions/model.json
+```
+
+### Import Items to Target Environment
+
+```bash
+# Import single item (create or update)
+fab import "Prod.Workspace/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+
+# Import with new name
+fab import "Prod.Workspace/Pipeline-v2.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+```
+
+### Critical Flags for Automation
+
+| Flag | Purpose | Always Use? |
+|------|---------|-------------|
+| `-f` | Force (skip prompts) | Yes in CI/CD |
+| `-a` | All items (export) | When exporting workspace |
+| `-o` | Output directory | For exports |
+| `-i` | Input file/directory | For imports |
+
+## 3 - Environment Promotion Strategy
+
+### Recommended Folder Structure
+
+```
+repo/
+├── .github/
+│   └── workflows/
+│       └── deploy-fabric.yml
+├── fabric-items/
+│   ├── pipelines/
+│   │   └── ETL.DataPipeline/
+│   ├── notebooks/
+│   │   └── Transform.Notebook/
+│   └── semantic-models/
+│       └── Sales.SemanticModel/
+└── config/
+    ├── dev.env
+    ├── test.env
+    └── prod.env
+```
+
+### Promotion Workflow
+
+```bash
+# 1. Export from source environment
+fab export "Dev.Workspace" -o ./fabric-items/ -a -f
+
+# 2. Commit to Git (manual or automated)
+git add ./fabric-items/
+git commit -m "Export from Dev"
+
+# 3. Import to target environment (in pipeline)
+fab import "Test.Workspace/Pipeline.DataPipeline" -i ./fabric-items/pipelines/ETL.DataPipeline -f
+fab import "Test.Workspace/Notebook.Notebook" -i ./fabric-items/notebooks/Transform.Notebook -f
+```
+
+### Environment-Specific Configuration
+
+```bash
+# Use different workspaces per environment
+DEV_WORKSPACE="Dev.Workspace"
+TEST_WORKSPACE="Test.Workspace"
+PROD_WORKSPACE="Prod.Workspace"
+
+# Parameterize deployment
+TARGET_WORKSPACE="${ENV}.Workspace"
+fab import "$TARGET_WORKSPACE/Item.Type" -i ./fabric-items/Item.Type -f
+```
+
+## 4 - Error Handling in Pipelines
+
+### Verify Before Deploy
+
+```bash
+# Check target exists
+fab exists "$TARGET_WORKSPACE" || { echo "Workspace not found"; exit 1; }
+
+# Check auth is valid
+fab auth status || { echo "Not authenticated"; exit 1; }
+
+# Check item exists before update
+fab exists "$TARGET_WORKSPACE/$ITEM_NAME" && echo "Will update existing item"
+```
+
+### Capture and Log Errors
+
+```bash
+# Bash pattern with error capture
+if ! fab import "$TARGET/Item.Type" -i ./Item.Type -f 2>&1 | tee deploy.log; then
+    echo "::error::Deployment failed. See deploy.log"
+    exit 1
+fi
+```
+
+### Rollback Strategy
+
+```bash
+# Before deployment, backup current state
+fab export "$PROD_WORKSPACE/$ITEM" -o ./backup/ -f
+
+# If deployment fails, restore from backup
+fab import "$PROD_WORKSPACE/$ITEM" -i ./backup/$ITEM -f
+```
+
+## 5 - Secrets Management
+
+### GitHub Actions Secrets
+
+```yaml
+env:
+  FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+  FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+  FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+```
+
+### Azure Pipelines Variable Groups
+
+```yaml
+variables:
+  - group: fabric-credentials  # Contains TENANT_ID, CLIENT_ID, CLIENT_SECRET
+```
+
+### Never Do This
+
+- Do not hardcode secrets in scripts
+- Do not echo/print secrets in logs
+- Do not commit secrets to Git
+- Do not use secrets in item names or paths
+
+## 6 - Common CI/CD Tasks
+
+### Deploy Changed Items Only
+
+```bash
+# Get list of changed files from Git
+CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/)
+
+for ITEM_PATH in $CHANGED; do
+    ITEM_NAME=$(basename "$ITEM_PATH")
+    fab import "$TARGET_WORKSPACE/$ITEM_NAME" -i "$ITEM_PATH" -f
+done
+```
+
+### Run Post-Deployment Jobs
+
+```bash
+# Trigger notebook after deployment
+fab job run "$TARGET_WORKSPACE/PostDeploy.Notebook" --timeout 600
+
+# Refresh semantic model
+WS_ID=$(fab get "$TARGET_WORKSPACE" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "$TARGET_WORKSPACE/Model.SemanticModel" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+```
+
+### Validate Deployment
+
+```bash
+# Verify item exists after import
+fab exists "$TARGET_WORKSPACE/$ITEM" || { echo "Deployment verification failed"; exit 1; }
+
+# Check job completed successfully
+STATUS=$(fab job run-status "$TARGET_WORKSPACE/Notebook.Notebook" --id "$JOB_ID" -q "status")
+[[ "$STATUS" == "Completed" ]] || exit 1
+```
+
+## 7 - References
+
+For detailed examples and patterns, see:
+
+- [GitHub Actions](./references/github-actions.md) — Complete workflow examples
+- [Azure Pipelines](./references/azure-pipelines.md) — Pipeline YAML templates
+- [Environment Promotion](./references/environment-promotion.md) — Dev/test/prod strategies
+- [Git Integration](./references/git-integration.md) — Source control patterns
+- [Automation Patterns](./references/automation-patterns.md) — Scripts and error handling
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md b/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
new file mode 100644
index 000000000..0a4683d58
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
@@ -0,0 +1,519 @@
+# Automation Patterns for Fabric CLI
+
+Scripts, error handling, and scheduling patterns for automating Fabric operations.
+
+## Shell Script Templates
+
+### Bash Template with Error Handling
+
+```bash
+#!/bin/bash
+set -euo pipefail  # Exit on error, undefined vars, pipe failures
+
+# Configuration
+WORKSPACE="${TARGET_WORKSPACE:-Dev.Workspace}"
+LOG_FILE="./fabric-deploy-$(date +%Y%m%d_%H%M%S).log"
+
+# Logging function
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
+}
+
+# Error handler
+error_exit() {
+    log "ERROR: $1"
+    exit 1
+}
+
+# Cleanup on exit
+cleanup() {
+    log "Cleaning up temporary files..."
+    rm -rf ./temp-export/ 2>/dev/null || true
+}
+trap cleanup EXIT
+
+# Main script
+main() {
+    log "Starting deployment to $WORKSPACE"
+    
+    # Verify authentication
+    fab auth status || error_exit "Not authenticated. Run 'fab auth login' first."
+    
+    # Verify workspace exists
+    fab exists "$WORKSPACE" || error_exit "Workspace $WORKSPACE not found"
+    
+    # Deploy items
+    log "Deploying items..."
+    fab import "$WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f \
+        || error_exit "Failed to deploy Pipeline"
+    
+    log "Deployment complete"
+}
+
+main "$@"
+```
+
+### PowerShell Template
+
+```powershell
+#Requires -Version 7.0
+$ErrorActionPreference = "Stop"
+
+# Configuration
+$Workspace = $env:TARGET_WORKSPACE ?? "Dev.Workspace"
+$LogFile = "./fabric-deploy-$(Get-Date -Format 'yyyyMMdd_HHmmss').log"
+
+function Write-Log {
+    param([string]$Message)
+    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    "[$timestamp] $Message" | Tee-Object -FilePath $LogFile -Append
+}
+
+function Test-FabAuth {
+    $result = fab auth status 2>&1
+    return $LASTEXITCODE -eq 0
+}
+
+try {
+    Write-Log "Starting deployment to $Workspace"
+    
+    # Verify authentication
+    if (-not (Test-FabAuth)) {
+        throw "Not authenticated. Run 'fab auth login' first."
+    }
+    
+    # Verify workspace
+    $exists = fab exists $Workspace
+    if ($exists -notmatch "true") {
+        throw "Workspace $Workspace not found"
+    }
+    
+    # Deploy items
+    Write-Log "Deploying items..."
+    fab import "$Workspace/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+    if ($LASTEXITCODE -ne 0) { throw "Failed to deploy Pipeline" }
+    
+    Write-Log "Deployment complete"
+}
+catch {
+    Write-Log "ERROR: $_"
+    exit 1
+}
+finally {
+    # Cleanup
+    Remove-Item -Path ./temp-export -Recurse -Force -ErrorAction SilentlyContinue
+}
+```
+
+## Error Handling Patterns
+
+### Retry Logic (Bash)
+
+```bash
+#!/bin/bash
+
+# Retry function with exponential backoff
+retry() {
+    local max_attempts=$1
+    local delay=$2
+    local command="${@:3}"
+    local attempt=1
+    
+    while [ $attempt -le $max_attempts ]; do
+        echo "Attempt $attempt of $max_attempts: $command"
+        
+        if eval "$command"; then
+            return 0
+        fi
+        
+        if [ $attempt -lt $max_attempts ]; then
+            echo "Failed. Retrying in ${delay}s..."
+            sleep $delay
+            delay=$((delay * 2))  # Exponential backoff
+        fi
+        
+        attempt=$((attempt + 1))
+    done
+    
+    echo "All $max_attempts attempts failed"
+    return 1
+}
+
+# Usage
+retry 3 5 fab import "Prod.Workspace/Item.Type" -i ./Item.Type -f
+```
+
+### Retry Logic (PowerShell)
+
+```powershell
+function Invoke-WithRetry {
+    param(
+        [scriptblock]$ScriptBlock,
+        [int]$MaxAttempts = 3,
+        [int]$DelaySeconds = 5
+    )
+    
+    $attempt = 1
+    while ($attempt -le $MaxAttempts) {
+        try {
+            Write-Host "Attempt $attempt of $MaxAttempts"
+            & $ScriptBlock
+            return
+        }
+        catch {
+            if ($attempt -eq $MaxAttempts) {
+                throw "All $MaxAttempts attempts failed: $_"
+            }
+            Write-Host "Failed. Retrying in ${DelaySeconds}s..."
+            Start-Sleep -Seconds $DelaySeconds
+            $DelaySeconds *= 2  # Exponential backoff
+            $attempt++
+        }
+    }
+}
+
+# Usage
+Invoke-WithRetry -ScriptBlock {
+    fab import "Prod.Workspace/Item.Type" -i ./Item.Type -f
+    if ($LASTEXITCODE -ne 0) { throw "Import failed" }
+}
+```
+
+### Graceful Degradation
+
+```bash
+#!/bin/bash
+
+# Deploy multiple items, continue on failure
+ITEMS=(
+    "Pipeline1.DataPipeline"
+    "Pipeline2.DataPipeline"
+    "Notebook1.Notebook"
+)
+
+FAILED=()
+SUCCEEDED=()
+
+for ITEM in "${ITEMS[@]}"; do
+    echo "Deploying $ITEM..."
+    if fab import "$WORKSPACE/$ITEM" -i "./fabric-items/$ITEM" -f; then
+        SUCCEEDED+=("$ITEM")
+    else
+        echo "WARNING: Failed to deploy $ITEM"
+        FAILED+=("$ITEM")
+    fi
+done
+
+# Report
+echo ""
+echo "=== Deployment Summary ==="
+echo "Succeeded: ${#SUCCEEDED[@]}"
+echo "Failed: ${#FAILED[@]}"
+
+if [ ${#FAILED[@]} -gt 0 ]; then
+    echo ""
+    echo "Failed items:"
+    printf '  - %s\n' "${FAILED[@]}"
+    exit 1
+fi
+```
+
+## Scheduling Patterns
+
+### Cron Schedule Reference
+
+```bash
+# ┌───────────── minute (0-59)
+# │ ┌───────────── hour (0-23)
+# │ │ ┌───────────── day of month (1-31)
+# │ │ │ ┌───────────── month (1-12)
+# │ │ │ │ ┌───────────── day of week (0-6, Sunday=0)
+# │ │ │ │ │
+# * * * * *
+
+# Examples:
+# 0 6 * * *     Daily at 6 AM
+# 0 */4 * * *   Every 4 hours
+# 0 9 * * 1-5   Weekdays at 9 AM
+# 0 0 1 * *     First of month at midnight
+```
+
+### Scheduled Refresh Script
+
+```bash
+#!/bin/bash
+# refresh-models.sh - Run as cron job
+
+LOG_DIR="/var/log/fabric"
+LOG_FILE="$LOG_DIR/refresh-$(date +%Y%m%d).log"
+mkdir -p "$LOG_DIR"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
+}
+
+# Authenticate (using stored credentials)
+export FAB_SPN_TENANT_ID="$FABRIC_TENANT_ID"
+export FAB_SPN_CLIENT_ID="$FABRIC_CLIENT_ID"
+export FAB_SPN_CLIENT_SECRET="$FABRIC_CLIENT_SECRET"
+
+fab auth login --service-principal >> "$LOG_FILE" 2>&1
+
+# Get IDs
+WS_ID=$(fab get "Prod.Workspace" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "Prod.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
+
+# Trigger refresh
+log "Triggering refresh for Sales model"
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post \
+    -i '{"type":"Full"}' >> "$LOG_FILE" 2>&1
+
+if [ $? -eq 0 ]; then
+    log "Refresh triggered successfully"
+else
+    log "ERROR: Failed to trigger refresh"
+    exit 1
+fi
+```
+
+### Windows Task Scheduler Script
+
+```powershell
+# refresh-models.ps1
+# Schedule with: schtasks /create /tn "FabricRefresh" /tr "powershell.exe -File C:\scripts\refresh-models.ps1" /sc daily /st 06:00
+
+$LogPath = "C:\Logs\Fabric"
+$LogFile = Join-Path $LogPath "refresh-$(Get-Date -Format 'yyyyMMdd').log"
+New-Item -ItemType Directory -Path $LogPath -Force | Out-Null
+
+function Write-Log {
+    param([string]$Message)
+    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    "[$timestamp] $Message" | Add-Content -Path $LogFile
+}
+
+# Set credentials from secure storage
+$env:FAB_SPN_TENANT_ID = Get-Secret -Name FabricTenantId -AsPlainText
+$env:FAB_SPN_CLIENT_ID = Get-Secret -Name FabricClientId -AsPlainText
+$env:FAB_SPN_CLIENT_SECRET = Get-Secret -Name FabricClientSecret -AsPlainText
+
+fab auth login --service-principal
+
+# Trigger refresh
+Write-Log "Triggering model refresh"
+$wsId = (fab get "Prod.Workspace" -q "id") -replace '"', ''
+$modelId = (fab get "Prod.Workspace/Sales.SemanticModel" -q "id") -replace '"', ''
+
+fab api -A powerbi "groups/$wsId/datasets/$modelId/refreshes" -X post -i '{"type":"Full"}'
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Log "Refresh triggered successfully"
+} else {
+    Write-Log "ERROR: Failed to trigger refresh"
+    exit 1
+}
+```
+
+## Parallel Execution
+
+### Bash Parallel Deployment
+
+```bash
+#!/bin/bash
+# parallel-deploy.sh
+
+WORKSPACE="Prod.Workspace"
+MAX_PARALLEL=4
+
+# Deploy function
+deploy_item() {
+    local item=$1
+    echo "Deploying $item..."
+    fab import "$WORKSPACE/$item" -i "./fabric-items/$item" -f
+    echo "Completed $item"
+}
+
+export -f deploy_item
+export WORKSPACE
+
+# Find all items and deploy in parallel
+find ./fabric-items -maxdepth 1 -type d -name "*.DataPipeline" -o -name "*.Notebook" | \
+    xargs -P $MAX_PARALLEL -I {} basename {} | \
+    xargs -P $MAX_PARALLEL -I {} bash -c 'deploy_item "$@"' _ {}
+```
+
+### PowerShell Parallel Deployment
+
+```powershell
+$Workspace = "Prod.Workspace"
+$Items = Get-ChildItem ./fabric-items -Directory | Select-Object -ExpandProperty Name
+
+$Items | ForEach-Object -ThrottleLimit 4 -Parallel {
+    $item = $_
+    $ws = $using:Workspace
+    Write-Host "Deploying $item..."
+    fab import "$ws/$item" -i "./fabric-items/$item" -f
+    Write-Host "Completed $item"
+}
+```
+
+## Monitoring and Alerting
+
+### Check Job Status Script
+
+```bash
+#!/bin/bash
+# monitor-jobs.sh
+
+WORKSPACE="Prod.Workspace"
+NOTEBOOK="ETL.Notebook"
+MAX_WAIT=3600  # 1 hour
+CHECK_INTERVAL=30
+
+# Start job
+JOB_OUTPUT=$(fab job start "$WORKSPACE/$NOTEBOOK")
+JOB_ID=$(echo "$JOB_OUTPUT" | grep -oP 'id["\s:]+\K[a-f0-9-]+')
+
+echo "Started job: $JOB_ID"
+
+# Monitor until complete or timeout
+ELAPSED=0
+while [ $ELAPSED -lt $MAX_WAIT ]; do
+    STATUS=$(fab job run-status "$WORKSPACE/$NOTEBOOK" --id "$JOB_ID" -q "status" | tr -d '"')
+    
+    case "$STATUS" in
+        "Completed")
+            echo "Job completed successfully"
+            exit 0
+            ;;
+        "Failed"|"Cancelled")
+            echo "Job $STATUS"
+            # Send alert
+            curl -X POST "$SLACK_WEBHOOK" -d "{\"text\":\"Fabric job failed: $NOTEBOOK\"}"
+            exit 1
+            ;;
+        *)
+            echo "Status: $STATUS (${ELAPSED}s elapsed)"
+            ;;
+    esac
+    
+    sleep $CHECK_INTERVAL
+    ELAPSED=$((ELAPSED + CHECK_INTERVAL))
+done
+
+echo "Timeout waiting for job"
+exit 1
+```
+
+### Health Check Script
+
+```bash
+#!/bin/bash
+# health-check.sh
+
+WORKSPACE="Prod.Workspace"
+ITEMS_TO_CHECK=(
+    "Sales.SemanticModel"
+    "ETL.DataPipeline"
+    "Transform.Notebook"
+)
+
+HEALTHY=0
+UNHEALTHY=0
+
+echo "=== Fabric Health Check ==="
+echo "Workspace: $WORKSPACE"
+echo ""
+
+# Check auth
+if fab auth status >/dev/null 2>&1; then
+    echo "[OK] Authentication: OK"
+else
+    echo "[FAILED] Authentication: FAILED"
+    exit 1
+fi
+
+# Check workspace
+if fab exists "$WORKSPACE" >/dev/null 2>&1; then
+    echo "[OK] Workspace: Accessible"
+else
+    echo "[FAILED] Workspace: Not accessible"
+    exit 1
+fi
+
+# Check items
+echo ""
+echo "Items:"
+for ITEM in "${ITEMS_TO_CHECK[@]}"; do
+    if fab exists "$WORKSPACE/$ITEM" >/dev/null 2>&1; then
+        echo "  [OK] $ITEM"
+        HEALTHY=$((HEALTHY + 1))
+    else
+        echo "  [FAILED] $ITEM (not found)"
+        UNHEALTHY=$((UNHEALTHY + 1))
+    fi
+done
+
+echo ""
+echo "Summary: $HEALTHY healthy, $UNHEALTHY unhealthy"
+
+[ $UNHEALTHY -eq 0 ] && exit 0 || exit 1
+```
+
+## Environment Variable Management
+
+### Using .env Files
+
+```bash
+#!/bin/bash
+# Load environment-specific config
+
+ENV=${1:-dev}
+ENV_FILE="./config/$ENV.env"
+
+if [ ! -f "$ENV_FILE" ]; then
+    echo "Error: $ENV_FILE not found"
+    exit 1
+fi
+
+# Load variables (without export for security)
+set -a
+source "$ENV_FILE"
+set +a
+
+echo "Loaded config for: $ENV"
+echo "Target workspace: $TARGET_WORKSPACE"
+```
+
+### Secure Credential Handling
+
+```bash
+#!/bin/bash
+# Never echo credentials, use env vars
+
+# Bad - exposes secrets in logs
+# echo "Using secret: $FAB_SPN_CLIENT_SECRET"
+
+# Good - validate without exposing
+if [ -z "$FAB_SPN_CLIENT_SECRET" ]; then
+    echo "Error: FAB_SPN_CLIENT_SECRET not set"
+    exit 1
+fi
+echo "Credentials configured"
+
+# Good - mask in CI logs
+echo "::add-mask::$FAB_SPN_CLIENT_SECRET"
+```
+
+## Best Practices Summary
+
+| Practice | Description |
+|----------|-------------|
+| Use `set -euo pipefail` | Exit on errors in bash scripts |
+| Implement retry logic | Handle transient failures |
+| Log everything | Timestamp and persist logs |
+| Use cleanup traps | Clean temp files on exit |
+| Validate before acting | Check auth and existence first |
+| Parameterize scripts | Use env vars for flexibility |
+| Never log secrets | Mask sensitive values |
+| Monitor long-running jobs | Set timeouts, send alerts |
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md b/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
new file mode 100644
index 000000000..f273fa270
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
@@ -0,0 +1,403 @@
+# Azure Pipelines for Fabric CLI
+
+Complete pipeline examples for deploying Microsoft Fabric items using Azure DevOps.
+
+## Basic Deployment Pipeline
+
+```yaml
+trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - fabric-items/**
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  pythonVersion: '3.11'
+
+stages:
+  - stage: Deploy
+    displayName: 'Deploy to Fabric'
+    jobs:
+      - job: DeployItems
+        displayName: 'Deploy Fabric Items'
+        steps:
+          - task: UsePythonVersion@0
+            inputs:
+              versionSpec: '$(pythonVersion)'
+            displayName: 'Use Python $(pythonVersion)'
+
+          - script: pip install ms-fabric-cli
+            displayName: 'Install Fabric CLI'
+
+          - script: |
+              fab auth login --service-principal
+              fab auth status
+            displayName: 'Authenticate'
+            env:
+              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+              FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+
+          - script: |
+              fab import "$(TARGET_WORKSPACE)/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+              fab import "$(TARGET_WORKSPACE)/Notebook.Notebook" -i ./fabric-items/Notebook.Notebook -f
+            displayName: 'Deploy items'
+```
+
+## Multi-Stage Pipeline (Dev → Test → Prod)
+
+```yaml
+trigger:
+  branches:
+    include:
+      - main
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: fabric-credentials  # Contains shared credentials
+
+stages:
+  # Development
+  - stage: Dev
+    displayName: 'Deploy to Dev'
+    variables:
+      TARGET_WORKSPACE: 'Development.Workspace'
+    jobs:
+      - template: templates/deploy-job.yml
+        parameters:
+          environment: 'dev'
+          workspace: '$(TARGET_WORKSPACE)'
+
+  # Test (requires approval)
+  - stage: Test
+    displayName: 'Deploy to Test'
+    dependsOn: Dev
+    variables:
+      TARGET_WORKSPACE: 'Testing.Workspace'
+    jobs:
+      - deployment: DeployTest
+        environment: 'test'
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - template: templates/deploy-steps.yml
+                  parameters:
+                    workspace: '$(TARGET_WORKSPACE)'
+
+  # Production (requires approval)
+  - stage: Prod
+    displayName: 'Deploy to Prod'
+    dependsOn: Test
+    variables:
+      TARGET_WORKSPACE: 'Production.Workspace'
+    jobs:
+      - deployment: DeployProd
+        environment: 'production'
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - template: templates/deploy-steps.yml
+                  parameters:
+                    workspace: '$(TARGET_WORKSPACE)'
+```
+
+## Reusable Template: deploy-steps.yml
+
+```yaml
+# templates/deploy-steps.yml
+parameters:
+  - name: workspace
+    type: string
+
+steps:
+  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '3.11'
+
+  - script: pip install ms-fabric-cli
+    displayName: 'Install Fabric CLI'
+
+  - script: |
+      fab auth login --service-principal
+      fab auth status
+    displayName: 'Authenticate'
+    env:
+      FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+      FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+      FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+
+  - script: |
+      echo "Deploying to ${{ parameters.workspace }}"
+      for ITEM in ./fabric-items/*; do
+        ITEM_NAME=$(basename "$ITEM")
+        fab import "${{ parameters.workspace }}/$ITEM_NAME" -i "$ITEM" -f
+      done
+    displayName: 'Deploy items to ${{ parameters.workspace }}'
+
+  - script: |
+      fab exists "${{ parameters.workspace }}" || exit 1
+      echo "Deployment verified"
+    displayName: 'Validate deployment'
+```
+
+## Service Connection with Federated Credential
+
+```yaml
+trigger:
+  - main
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+stages:
+  - stage: Deploy
+    jobs:
+      - job: DeployWithFederated
+        steps:
+          - task: UsePythonVersion@0
+            inputs:
+              versionSpec: '3.11'
+
+          - script: pip install ms-fabric-cli
+            displayName: 'Install Fabric CLI'
+
+          - task: AzureCLI@2
+            displayName: 'Authenticate with Federated Credential'
+            inputs:
+              azureSubscription: 'fabric-service-connection'  # Service connection name
+              scriptType: 'bash'
+              scriptLocation: 'inlineScript'
+              inlineScript: |
+                # Get token for Fabric API
+                TOKEN=$(az account get-access-token --resource https://analysis.windows.net/powerbi/api --query accessToken -o tsv)
+                echo "##vso[task.setvariable variable=FAB_TOKEN;issecret=true]$TOKEN"
+
+          - script: |
+              export FAB_SPN_FEDERATED_TOKEN=$(FAB_TOKEN)
+              fab auth login --service-principal --federated
+              fab auth status
+            displayName: 'Login to Fabric CLI'
+            env:
+              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+
+          - script: |
+              fab import "$(TARGET_WORKSPACE)/Item.Type" -i ./fabric-items/Item.Type -f
+            displayName: 'Deploy items'
+```
+
+## Deploy Changed Items Only
+
+```yaml
+trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - fabric-items/**
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+jobs:
+  - job: DeployChanges
+    steps:
+      - checkout: self
+        fetchDepth: 2  # Need for git diff
+
+      - task: UsePythonVersion@0
+        inputs:
+          versionSpec: '3.11'
+
+      - script: pip install ms-fabric-cli
+        displayName: 'Install Fabric CLI'
+
+      - script: |
+          fab auth login --service-principal
+        displayName: 'Authenticate'
+        env:
+          FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+          FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+          FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+
+      - script: |
+          # Get changed item directories
+          CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/ | xargs -I {} dirname {} | sort -u)
+          
+          if [ -z "$CHANGED" ]; then
+            echo "No items changed"
+            exit 0
+          fi
+          
+          for ITEM_PATH in $CHANGED; do
+            if [ -d "$ITEM_PATH" ]; then
+              ITEM_NAME=$(basename "$ITEM_PATH")
+              echo "Deploying $ITEM_NAME..."
+              fab import "$(TARGET_WORKSPACE)/$ITEM_NAME" -i "$ITEM_PATH" -f
+            fi
+          done
+        displayName: 'Deploy changed items'
+```
+
+## Scheduled Export Pipeline
+
+```yaml
+trigger: none
+
+schedules:
+  - cron: '0 6 * * *'  # Daily at 6 AM UTC
+    displayName: 'Daily export'
+    branches:
+      include:
+        - main
+    always: true
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+jobs:
+  - job: ExportItems
+    steps:
+      - checkout: self
+        persistCredentials: true
+
+      - task: UsePythonVersion@0
+        inputs:
+          versionSpec: '3.11'
+
+      - script: pip install ms-fabric-cli
+        displayName: 'Install Fabric CLI'
+
+      - script: |
+          fab auth login --service-principal
+        displayName: 'Authenticate'
+        env:
+          FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+          FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+          FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+
+      - script: |
+          fab export "$(SOURCE_WORKSPACE)" -o ./fabric-items/ -a -f
+        displayName: 'Export workspace items'
+
+      - script: |
+          git config user.name "Azure Pipelines"
+          git config user.email "azuredevops@microsoft.com"
+          git add ./fabric-items/
+          if git diff --staged --quiet; then
+            echo "No changes to commit"
+          else
+            git commit -m "Auto-export Fabric items $(date +%Y-%m-%d)"
+            git push origin HEAD:main
+          fi
+        displayName: 'Commit and push changes'
+```
+
+## Pipeline with Rollback Support
+
+```yaml
+trigger:
+  - main
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: fabric-credentials
+
+stages:
+  - stage: Backup
+    jobs:
+      - job: BackupCurrent
+        steps:
+          - script: |
+              pip install ms-fabric-cli
+              fab auth login --service-principal
+              fab export "$(TARGET_WORKSPACE)" -o $(Build.ArtifactStagingDirectory)/backup -a -f
+            env:
+              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+              FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+          
+          - publish: $(Build.ArtifactStagingDirectory)/backup
+            artifact: backup
+            displayName: 'Publish backup artifact'
+
+  - stage: Deploy
+    dependsOn: Backup
+    jobs:
+      - deployment: DeployProd
+        environment: 'production'
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - script: |
+                    pip install ms-fabric-cli
+                    fab auth login --service-principal
+                    fab import "$(TARGET_WORKSPACE)/Item.Type" -i ./fabric-items/Item.Type -f
+                  env:
+                    FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+                    FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+                    FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+            
+            on:
+              failure:
+                steps:
+                  - download: current
+                    artifact: backup
+                  
+                  - script: |
+                      pip install ms-fabric-cli
+                      fab auth login --service-principal
+                      fab import "$(TARGET_WORKSPACE)/Item.Type" -i $(Pipeline.Workspace)/backup/Item.Type -f
+                      echo "##vso[task.logissue type=warning]Rolled back to previous version"
+                    env:
+                      FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
+                      FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
+                      FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
+                    displayName: 'Rollback on failure'
+```
+
+## Variable Groups Setup
+
+Create these variable groups in Azure DevOps:
+
+### fabric-credentials (Linked to Key Vault recommended)
+
+| Variable | Description | Secret? |
+|----------|-------------|---------|
+| `FABRIC_TENANT_ID` | Azure AD tenant ID | No |
+| `FABRIC_CLIENT_ID` | Service principal client ID | No |
+| `FABRIC_CLIENT_SECRET` | Service principal secret | Yes |
+
+### fabric-environments-dev
+
+| Variable | Value |
+|----------|-------|
+| `TARGET_WORKSPACE` | `Development.Workspace` |
+
+### fabric-environments-prod
+
+| Variable | Value |
+|----------|-------|
+| `TARGET_WORKSPACE` | `Production.Workspace` |
+
+## Environment Approvals
+
+Configure environment approvals in Azure DevOps:
+
+1. Go to **Pipelines** → **Environments**
+2. Create environments: `dev`, `test`, `production`
+3. Add approvers for `test` and `production`
+4. Configure branch policies if needed
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md b/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
new file mode 100644
index 000000000..62a2f70c2
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
@@ -0,0 +1,344 @@
+# Environment Promotion Strategies
+
+Patterns for promoting Fabric items across development, test, and production environments.
+
+## Environment Architecture
+
+### Recommended Setup
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│  Development    │───▶│     Testing     │───▶│   Production    │
+│   .Workspace    │    │   .Workspace    │    │   .Workspace    │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+       │                       │                       │
+       ▼                       ▼                       ▼
+   Dev Capacity           Test Capacity          Prod Capacity
+```
+
+### Workspace Naming Convention
+
+| Environment | Workspace Name | Purpose |
+|-------------|----------------|---------|
+| Development | `ProjectName-Dev.Workspace` | Active development |
+| Testing | `ProjectName-Test.Workspace` | QA and validation |
+| Production | `ProjectName-Prod.Workspace` | Live workloads |
+
+## Full Workspace Promotion
+
+### Export Entire Workspace
+
+```bash
+# Export all items from source
+fab export "Dev.Workspace" -o ./export/ -a -f
+
+# Directory structure created:
+# ./export/
+# ├── Pipeline1.DataPipeline/
+# ├── Pipeline2.DataPipeline/
+# ├── Notebook1.Notebook/
+# ├── Model1.SemanticModel/
+# └── Report1.Report/
+```
+
+### Import to Target Workspace
+
+```bash
+# Import each item type
+for ITEM in ./export/*; do
+    ITEM_NAME=$(basename "$ITEM")
+    fab import "Test.Workspace/$ITEM_NAME" -i "$ITEM" -f
+done
+```
+
+### Selective Promotion
+
+```bash
+# Promote only specific items
+ITEMS_TO_PROMOTE=(
+    "ETL-Pipeline.DataPipeline"
+    "Transform.Notebook"
+    "Sales-Model.SemanticModel"
+)
+
+for ITEM in "${ITEMS_TO_PROMOTE[@]}"; do
+    fab import "Test.Workspace/$ITEM" -i "./export/$ITEM" -f
+done
+```
+
+## Parameterized Deployments
+
+### Environment Configuration Files
+
+```bash
+# config/dev.env
+WORKSPACE_NAME="Dev.Workspace"
+LAKEHOUSE_NAME="DevLakehouse"
+CONNECTION_STRING="dev-connection"
+
+# config/prod.env
+WORKSPACE_NAME="Prod.Workspace"
+LAKEHOUSE_NAME="ProdLakehouse"
+CONNECTION_STRING="prod-connection"
+```
+
+### Load Environment Config
+
+```bash
+#!/bin/bash
+# deploy.sh
+
+ENV=${1:-dev}
+source "./config/$ENV.env"
+
+echo "Deploying to $WORKSPACE_NAME"
+
+fab import "$WORKSPACE_NAME/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+```
+
+### Parameter Substitution in Definitions
+
+For items with environment-specific settings:
+
+```bash
+# Export definition
+fab get "Dev.Workspace/Pipeline.DataPipeline" -q "definition" > pipeline-def.json
+
+# Substitute parameters (using jq or sed)
+cat pipeline-def.json | \
+    sed "s/DevLakehouse/$TARGET_LAKEHOUSE/g" | \
+    sed "s/dev-connection/$TARGET_CONNECTION/g" \
+    > pipeline-def-updated.json
+
+# Import with updated definition
+fab set "Prod.Workspace/Pipeline.DataPipeline" -q definition -i pipeline-def-updated.json
+```
+
+## Promotion Workflows
+
+### Manual Promotion Script
+
+```bash
+#!/bin/bash
+# promote.sh - Promote items from one environment to another
+
+SOURCE_ENV=$1
+TARGET_ENV=$2
+
+if [ -z "$SOURCE_ENV" ] || [ -z "$TARGET_ENV" ]; then
+    echo "Usage: ./promote.sh <source-env> <target-env>"
+    echo "Example: ./promote.sh dev test"
+    exit 1
+fi
+
+SOURCE_WS="${SOURCE_ENV^}.Workspace"  # Capitalize
+TARGET_WS="${TARGET_ENV^}.Workspace"
+
+echo "Promoting from $SOURCE_WS to $TARGET_WS"
+
+# Create temp directory
+EXPORT_DIR=$(mktemp -d)
+
+# Export from source
+echo "Exporting from $SOURCE_WS..."
+fab export "$SOURCE_WS" -o "$EXPORT_DIR" -a -f
+
+# Import to target
+echo "Importing to $TARGET_WS..."
+for ITEM in "$EXPORT_DIR"/*; do
+    ITEM_NAME=$(basename "$ITEM")
+    echo "  - $ITEM_NAME"
+    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
+done
+
+# Cleanup
+rm -rf "$EXPORT_DIR"
+
+echo "Promotion complete"
+```
+
+### Promotion with Approval Gate
+
+```bash
+#!/bin/bash
+# promote-with-approval.sh
+
+SOURCE_WS="Test.Workspace"
+TARGET_WS="Prod.Workspace"
+
+# List items to promote
+echo "Items to promote from $SOURCE_WS:"
+fab ls "$SOURCE_WS" -l
+
+# Prompt for approval
+read -p "Proceed with promotion to $TARGET_WS? (yes/no): " APPROVAL
+
+if [ "$APPROVAL" != "yes" ]; then
+    echo "Promotion cancelled"
+    exit 0
+fi
+
+# Backup current production
+echo "Creating backup of $TARGET_WS..."
+fab export "$TARGET_WS" -o "./backup/$(date +%Y%m%d)" -a -f
+
+# Perform promotion
+echo "Promoting items..."
+fab export "$SOURCE_WS" -o ./temp-export -a -f
+
+for ITEM in ./temp-export/*; do
+    ITEM_NAME=$(basename "$ITEM")
+    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
+done
+
+rm -rf ./temp-export
+echo "Promotion complete"
+```
+
+## Dependency-Aware Promotion
+
+### Order of Deployment
+
+Deploy items in dependency order:
+
+```bash
+# 1. Data stores first (lakehouses, warehouses)
+fab import "$TARGET/DataLakehouse.Lakehouse" -i ./items/DataLakehouse.Lakehouse -f
+
+# 2. Semantic models (depend on data stores)
+fab import "$TARGET/SalesModel.SemanticModel" -i ./items/SalesModel.SemanticModel -f
+
+# 3. Reports (depend on semantic models)
+fab import "$TARGET/SalesReport.Report" -i ./items/SalesReport.Report -f
+
+# 4. Pipelines and notebooks (may depend on any above)
+fab import "$TARGET/ETL.DataPipeline" -i ./items/ETL.DataPipeline -f
+fab import "$TARGET/Transform.Notebook" -i ./items/Transform.Notebook -f
+```
+
+### Dependency Mapping File
+
+```yaml
+# dependencies.yml
+items:
+  - name: DataLakehouse.Lakehouse
+    depends_on: []
+    
+  - name: SalesModel.SemanticModel
+    depends_on:
+      - DataLakehouse.Lakehouse
+      
+  - name: SalesReport.Report
+    depends_on:
+      - SalesModel.SemanticModel
+      
+  - name: ETL.DataPipeline
+    depends_on:
+      - DataLakehouse.Lakehouse
+```
+
+## Rollback Strategies
+
+### Immediate Rollback
+
+```bash
+#!/bin/bash
+# rollback.sh
+
+BACKUP_DIR=$1
+TARGET_WS=$2
+
+if [ -z "$BACKUP_DIR" ] || [ -z "$TARGET_WS" ]; then
+    echo "Usage: ./rollback.sh <backup-dir> <target-workspace>"
+    exit 1
+fi
+
+echo "Rolling back $TARGET_WS from $BACKUP_DIR"
+
+for ITEM in "$BACKUP_DIR"/*; do
+    ITEM_NAME=$(basename "$ITEM")
+    echo "Restoring $ITEM_NAME..."
+    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
+done
+
+echo "Rollback complete"
+```
+
+### Versioned Backups
+
+```bash
+# Create timestamped backup before each deployment
+BACKUP_DIR="./backups/$(date +%Y%m%d_%H%M%S)"
+fab export "$PROD_WS" -o "$BACKUP_DIR" -a -f
+
+# Keep last N backups
+ls -dt ./backups/*/ | tail -n +6 | xargs rm -rf
+```
+
+## Validation After Promotion
+
+### Verify Items Exist
+
+```bash
+#!/bin/bash
+# validate-deployment.sh
+
+TARGET_WS=$1
+EXPECTED_ITEMS=(
+    "ETL.DataPipeline"
+    "Transform.Notebook"
+    "SalesModel.SemanticModel"
+    "SalesReport.Report"
+)
+
+FAILED=0
+
+for ITEM in "${EXPECTED_ITEMS[@]}"; do
+    if fab exists "$TARGET_WS/$ITEM"; then
+        echo "[OK] $ITEM exists"
+    else
+        echo "[FAILED] $ITEM NOT FOUND"
+        FAILED=1
+    fi
+done
+
+exit $FAILED
+```
+
+### Run Smoke Tests
+
+```bash
+# Run validation notebook
+fab job run "$TARGET_WS/ValidationTests.Notebook" --timeout 300
+
+# Check semantic model refresh
+WS_ID=$(fab get "$TARGET_WS" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "$TARGET_WS/SalesModel.SemanticModel" -q "id" | tr -d '"')
+
+# Trigger test refresh
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+
+# Wait and check status
+sleep 60
+STATUS=$(fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0].status")
+echo "Refresh status: $STATUS"
+```
+
+## Best Practices
+
+### Do's
+
+- Always backup before promoting to production
+- Use consistent naming across environments
+- Validate deployments with automated tests
+- Keep promotion scripts in version control
+- Use environment-specific configuration files
+- Deploy in dependency order
+
+### Don'ts
+
+- Do not promote directly from dev to prod (skip test)
+- Do not promote without backups
+- Do not hardcode environment-specific values in items
+- Do not ignore failed deployments
+- Do not promote during business hours (for prod)
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md b/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md
new file mode 100644
index 000000000..0ab13b650
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md
@@ -0,0 +1,366 @@
+# Git Integration for Fabric Items
+
+Patterns for storing and managing Fabric item definitions in Git repositories.
+
+## Repository Structure
+
+### Recommended Layout
+
+```
+fabric-repo/
+├── .github/
+│   └── workflows/
+│       └── deploy.yml
+├── fabric-items/
+│   ├── pipelines/
+│   │   ├── ETL-Daily.DataPipeline/
+│   │   │   └── pipeline-content.json
+│   │   └── ETL-Weekly.DataPipeline/
+│   │       └── pipeline-content.json
+│   ├── notebooks/
+│   │   ├── Transform.Notebook/
+│   │   │   └── notebook-content.py
+│   │   └── Validation.Notebook/
+│   │       └── notebook-content.py
+│   ├── semantic-models/
+│   │   └── Sales.SemanticModel/
+│   │       ├── model.tmdl
+│   │       ├── tables/
+│   │       └── relationships/
+│   └── reports/
+│       └── SalesDashboard.Report/
+│           └── report.json
+├── config/
+│   ├── dev.env
+│   ├── test.env
+│   └── prod.env
+└── README.md
+```
+
+## Exporting Items for Git
+
+### Export Single Item
+
+```bash
+# Export a data pipeline
+fab export "Dev.Workspace/ETL-Daily.DataPipeline" -o ./fabric-items/pipelines/ -f
+
+# Export a notebook
+fab export "Dev.Workspace/Transform.Notebook" -o ./fabric-items/notebooks/ -f
+
+# Export a semantic model (TMDL format)
+fab export "Dev.Workspace/Sales.SemanticModel" -o ./fabric-items/semantic-models/ -f
+```
+
+### Export Full Workspace
+
+```bash
+# Export all items
+fab export "Dev.Workspace" -o ./fabric-items/ -a -f
+
+# Organize by type (post-export script)
+mkdir -p fabric-items/{pipelines,notebooks,semantic-models,reports}
+
+for ITEM in fabric-items/*.*; do
+    case "$ITEM" in
+        *.DataPipeline) mv "$ITEM" fabric-items/pipelines/ ;;
+        *.Notebook) mv "$ITEM" fabric-items/notebooks/ ;;
+        *.SemanticModel) mv "$ITEM" fabric-items/semantic-models/ ;;
+        *.Report) mv "$ITEM" fabric-items/reports/ ;;
+    esac
+done
+```
+
+### Export Definitions Only
+
+```bash
+# Get raw definition (useful for semantic models)
+fab get "Dev.Workspace/Sales.SemanticModel" -q "definition" > ./fabric-items/semantic-models/Sales.SemanticModel/definition.json
+```
+
+## Git Workflow
+
+### Initial Setup
+
+```bash
+# Clone/create repo
+git clone https://github.com/org/fabric-repo.git
+cd fabric-repo
+
+# Export current state
+fab auth login
+fab export "Dev.Workspace" -o ./fabric-items/ -a -f
+
+# Initial commit
+git add .
+git commit -m "Initial export of Fabric items"
+git push
+```
+
+### Feature Branch Workflow
+
+```bash
+# Create feature branch
+git checkout -b feature/new-pipeline
+
+# Make changes in Fabric UI or export updated items
+fab export "Dev.Workspace/NewPipeline.DataPipeline" -o ./fabric-items/pipelines/ -f
+
+# Commit changes
+git add fabric-items/pipelines/NewPipeline.DataPipeline/
+git commit -m "Add new ETL pipeline"
+
+# Push and create PR
+git push -u origin feature/new-pipeline
+```
+
+### Syncing Changes from Fabric
+
+```bash
+# Pull latest from Git
+git pull origin main
+
+# Export current Fabric state
+fab export "Dev.Workspace" -o ./temp-export/ -a -f
+
+# Compare with Git (visual diff)
+diff -r ./fabric-items/ ./temp-export/
+
+# Update Git with changes
+cp -r ./temp-export/* ./fabric-items/
+git add .
+git commit -m "Sync changes from Fabric"
+```
+
+## Semantic Model (TMDL) in Git
+
+### TMDL Structure
+
+```
+Sales.SemanticModel/
+├── definition.tmdl
+├── model.tmdl
+├── tables/
+│   ├── Sales.tmdl
+│   ├── Products.tmdl
+│   └── Date.tmdl
+├── relationships/
+│   └── relationships.tmdl
+├── roles/
+│   └── roles.tmdl
+└── expressions/
+    └── expressions.tmdl
+```
+
+### Export TMDL
+
+```bash
+# Export semantic model (automatically creates TMDL structure)
+fab export "Dev.Workspace/Sales.SemanticModel" -o ./fabric-items/semantic-models/ -f
+```
+
+### Track TMDL Changes
+
+```bash
+# See what tables changed
+git diff fabric-items/semantic-models/Sales.SemanticModel/tables/
+
+# See measure changes
+git diff fabric-items/semantic-models/Sales.SemanticModel/model.tmdl
+```
+
+## Notebook Source Control
+
+### Notebook Format
+
+```
+Transform.Notebook/
+├── notebook-content.py     # Main code
+└── .platform               # Metadata
+```
+
+### Export Notebook
+
+```bash
+fab export "Dev.Workspace/Transform.Notebook" -o ./fabric-items/notebooks/ -f
+```
+
+### Edit Notebooks Locally
+
+You can edit the `.py` file directly and re-import:
+
+```bash
+# Edit locally
+code ./fabric-items/notebooks/Transform.Notebook/notebook-content.py
+
+# Import changes
+fab import "Dev.Workspace/Transform.Notebook" -i ./fabric-items/notebooks/Transform.Notebook -f
+```
+
+## Data Pipeline Source Control
+
+### Pipeline Format
+
+```
+ETL-Daily.DataPipeline/
+├── pipeline-content.json   # Pipeline definition
+└── .platform               # Metadata
+```
+
+### Export and Track
+
+```bash
+# Export
+fab export "Dev.Workspace/ETL-Daily.DataPipeline" -o ./fabric-items/pipelines/ -f
+
+# View changes
+git diff fabric-items/pipelines/ETL-Daily.DataPipeline/pipeline-content.json
+```
+
+## .gitignore Configuration
+
+```gitignore
+# Fabric CLI
+.config/fab/
+*.log
+
+# Temporary exports
+temp-export/
+backup/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+
+# Don't ignore Fabric items
+!fabric-items/
+```
+
+## Branching Strategy
+
+### GitFlow for Fabric
+
+```
+main (production)
+  │
+  ├── develop (integration)
+  │     │
+  │     ├── feature/new-report
+  │     ├── feature/update-model
+  │     └── bugfix/pipeline-fix
+  │
+  └── release/v1.2
+```
+
+### Branch Protection Rules
+
+For `main` branch:
+- Require pull request reviews
+- Require status checks (deployment validation)
+- No direct pushes
+
+## Automated Sync Workflow
+
+### GitHub Action: Daily Sync from Fabric
+
+```yaml
+name: Sync from Fabric
+
+on:
+  schedule:
+    - cron: '0 6 * * *'  # Daily at 6 AM
+  workflow_dispatch:
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup
+        run: pip install ms-fabric-cli
+
+      - name: Authenticate
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: fab auth login --service-principal
+
+      - name: Export from Fabric
+        run: fab export "Dev.Workspace" -o ./fabric-items/ -a -f
+
+      - name: Commit changes
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add ./fabric-items/
+          if git diff --staged --quiet; then
+            echo "No changes"
+          else
+            git commit -m "Sync from Fabric $(date +%Y-%m-%d)"
+            git push
+          fi
+```
+
+## Conflict Resolution
+
+### When Git and Fabric Diverge
+
+```bash
+# 1. Export current Fabric state
+fab export "Dev.Workspace" -o ./fabric-export/ -a -f
+
+# 2. Compare with Git
+diff -r ./fabric-items/ ./fabric-export/
+
+# 3. Decide which version to keep
+# Option A: Keep Git version (deploy to Fabric)
+fab import "Dev.Workspace/Item.Type" -i ./fabric-items/Item.Type -f
+
+# Option B: Keep Fabric version (update Git)
+cp -r ./fabric-export/Item.Type ./fabric-items/
+git add ./fabric-items/Item.Type
+git commit -m "Update from Fabric"
+```
+
+### Merge Conflicts in TMDL
+
+When merging branches with TMDL changes:
+
+```bash
+# Pull with rebase
+git pull --rebase origin main
+
+# If conflicts in .tmdl files:
+# 1. Open conflicted file
+# 2. Choose correct version (usually keep both measures/columns)
+# 3. Validate syntax
+
+# After resolving
+git add .
+git rebase --continue
+```
+
+## Best Practices
+
+### Do's
+
+- Export items after significant changes
+- Use meaningful commit messages
+- Review TMDL changes in PRs
+- Keep Git as source of truth for production
+- Use branches for new features
+- Automate sync with scheduled exports
+
+### Don'ts
+
+- Do not edit production items directly (bypass Git)
+- Do not commit secrets or connection strings
+- Do not force push to main branch
+- Do not ignore merge conflicts
+- Do not mix multiple unrelated changes in one commit
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md b/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md
new file mode 100644
index 000000000..7b4415c0b
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md
@@ -0,0 +1,362 @@
+# GitHub Actions for Fabric CLI
+
+Complete workflow examples for deploying Microsoft Fabric items using GitHub Actions.
+
+## Basic Deployment Workflow
+
+```yaml
+name: Deploy Fabric Items
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'fabric-items/**'
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Target environment'
+        required: true
+        default: 'dev'
+        type: choice
+        options:
+          - dev
+          - test
+          - prod
+
+env:
+  PYTHON_VERSION: '3.11'
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment: ${{ github.event.inputs.environment || 'dev' }}
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Install Fabric CLI
+        run: pip install ms-fabric-cli
+
+      - name: Authenticate with Service Principal
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: |
+          fab auth login --service-principal
+          fab auth status
+
+      - name: Deploy items
+        env:
+          TARGET_WORKSPACE: ${{ vars.FABRIC_WORKSPACE }}
+        run: |
+          fab import "$TARGET_WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+          fab import "$TARGET_WORKSPACE/Notebook.Notebook" -i ./fabric-items/Notebook.Notebook -f
+```
+
+## Federated Credential Workflow (No Secrets)
+
+```yaml
+name: Deploy with Federated Credential
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  id-token: write  # Required for federated credential
+  contents: read
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment: production
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Fabric CLI
+        run: pip install ms-fabric-cli
+
+      - name: Azure Login with OIDC
+        uses: azure/login@v2
+        with:
+          client-id: ${{ secrets.AZURE_CLIENT_ID }}
+          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
+          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+
+      - name: Get Federated Token
+        run: |
+          TOKEN=$(az account get-access-token --resource https://analysis.windows.net/powerbi/api --query accessToken -o tsv)
+          echo "FAB_SPN_FEDERATED_TOKEN=$TOKEN" >> $GITHUB_ENV
+
+      - name: Authenticate Fabric CLI
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+        run: |
+          fab auth login --service-principal --federated
+          fab auth status
+
+      - name: Deploy
+        run: |
+          fab import "Prod.Workspace/Item.Type" -i ./fabric-items/Item.Type -f
+```
+
+## Multi-Environment Deployment
+
+```yaml
+name: Multi-Environment Deploy
+
+on:
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Target environment'
+        required: true
+        type: choice
+        options:
+          - dev
+          - test
+          - prod
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment: ${{ github.event.inputs.environment }}
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Setup
+        run: |
+          pip install ms-fabric-cli
+          
+      - name: Authenticate
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: fab auth login --service-principal
+
+      - name: Set workspace based on environment
+        run: |
+          case "${{ github.event.inputs.environment }}" in
+            dev)  echo "WORKSPACE=Development.Workspace" >> $GITHUB_ENV ;;
+            test) echo "WORKSPACE=Testing.Workspace" >> $GITHUB_ENV ;;
+            prod) echo "WORKSPACE=Production.Workspace" >> $GITHUB_ENV ;;
+          esac
+
+      - name: Deploy to ${{ github.event.inputs.environment }}
+        run: |
+          echo "Deploying to $WORKSPACE"
+          fab import "$WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
+```
+
+## Deploy Changed Items Only
+
+```yaml
+name: Deploy Changed Items
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'fabric-items/**'
+
+jobs:
+  deploy-changes:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2  # Need previous commit for diff
+
+      - name: Setup Fabric CLI
+        run: pip install ms-fabric-cli
+
+      - name: Authenticate
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: fab auth login --service-principal
+
+      - name: Get changed items
+        id: changes
+        run: |
+          CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/ | grep -E '\.(DataPipeline|Notebook|SemanticModel)/' | xargs -I {} dirname {} | sort -u)
+          echo "changed=$CHANGED" >> $GITHUB_OUTPUT
+          echo "Changed items: $CHANGED"
+
+      - name: Deploy changed items
+        env:
+          TARGET_WORKSPACE: ${{ vars.FABRIC_WORKSPACE }}
+        run: |
+          for ITEM_PATH in ${{ steps.changes.outputs.changed }}; do
+            ITEM_NAME=$(basename "$ITEM_PATH")
+            echo "Deploying $ITEM_NAME..."
+            fab import "$TARGET_WORKSPACE/$ITEM_NAME" -i "$ITEM_PATH" -f
+          done
+```
+
+## Matrix Deployment (Multiple Workspaces)
+
+```yaml
+name: Matrix Deploy
+
+on:
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        workspace:
+          - name: Sales
+            path: sales-items
+          - name: Marketing
+            path: marketing-items
+          - name: Finance
+            path: finance-items
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup and Auth
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: |
+          pip install ms-fabric-cli
+          fab auth login --service-principal
+
+      - name: Deploy to ${{ matrix.workspace.name }}
+        run: |
+          for ITEM in ./fabric-items/${{ matrix.workspace.path }}/*; do
+            ITEM_NAME=$(basename "$ITEM")
+            fab import "${{ matrix.workspace.name }}.Workspace/$ITEM_NAME" -i "$ITEM" -f
+          done
+```
+
+## Export and Commit Workflow
+
+```yaml
+name: Export Fabric Items
+
+on:
+  schedule:
+    - cron: '0 6 * * *'  # Daily at 6 AM UTC
+  workflow_dispatch:
+
+jobs:
+  export:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: |
+          pip install ms-fabric-cli
+          fab auth login --service-principal
+
+      - name: Export workspace items
+        run: |
+          fab export "Production.Workspace" -o ./fabric-items/ -a -f
+
+      - name: Commit changes
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add ./fabric-items/
+          if git diff --staged --quiet; then
+            echo "No changes to commit"
+          else
+            git commit -m "Auto-export Fabric items $(date +%Y-%m-%d)"
+            git push
+          fi
+```
+
+## Post-Deployment Validation
+
+```yaml
+name: Deploy with Validation
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup and Auth
+        env:
+          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
+          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
+          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
+        run: |
+          pip install ms-fabric-cli
+          fab auth login --service-principal
+
+      - name: Deploy items
+        run: |
+          fab import "Prod.Workspace/ETL.DataPipeline" -i ./fabric-items/ETL.DataPipeline -f
+
+      - name: Validate deployment
+        run: |
+          # Verify item exists
+          fab exists "Prod.Workspace/ETL.DataPipeline" || exit 1
+          
+          # Run post-deployment test
+          fab job run "Prod.Workspace/Validation.Notebook" --timeout 300
+          
+          echo "Deployment validated successfully"
+
+      - name: Notify on failure
+        if: failure()
+        run: |
+          echo "::error::Deployment validation failed"
+```
+
+## Required Secrets Configuration
+
+Set these secrets in your repository settings:
+
+| Secret Name | Description |
+|-------------|-------------|
+| `FABRIC_TENANT_ID` | Azure AD tenant ID |
+| `FABRIC_CLIENT_ID` | Service principal client ID |
+| `FABRIC_CLIENT_SECRET` | Service principal secret |
+
+## Required Variables Configuration
+
+Set these variables per environment:
+
+| Variable Name | Description | Example |
+|---------------|-------------|---------|
+| `FABRIC_WORKSPACE` | Target workspace name | `Production.Workspace` |
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py b/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
new file mode 100644
index 000000000..d78df7424
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
@@ -0,0 +1,380 @@
+#!/usr/bin/env python3
+"""
+deploy.py - Deploy items from local folder to workspace
+
+This script deploys Fabric items from a local filesystem (typically an export directory)
+to a target workspace. It supports creating new items and updating existing ones.
+
+Usage:
+    python deploy.py <source> <target-ws> [--dry-run]
+    python deploy.py ./fabric-items/ Production.Workspace
+    python deploy.py ./fabric-items/ Production.Workspace --dry-run
+
+Exit codes:
+    0 - Deployment completed successfully
+    1 - Deployment failed or had errors
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+
+# Supported item types that can be imported
+IMPORTABLE_ITEM_TYPES = [
+    "Notebook", "SparkJobDefinition", "DataPipeline",
+    "Report", "SemanticModel",
+    "KQLDatabase", "KQLDashboard", "KQLQueryset",
+    "Eventhouse", "Eventstream", "MirroredDatabase",
+    "Reflex", "MountedDataFactory", "CopyJob", "VariableLibrary"
+]
+
+
+def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def check_workspace_exists(workspace: str) -> bool:
+    """Check if workspace exists."""
+    exit_code, _, _ = run_fab_command(["exists", workspace])
+    return exit_code == 0
+
+
+def check_item_exists(item_path: str) -> bool:
+    """Check if an item exists."""
+    exit_code, _, _ = run_fab_command(["exists", item_path])
+    return exit_code == 0
+
+
+def discover_items(source_dir: str) -> List[Dict[str, Any]]:
+    """Discover Fabric items in the source directory."""
+    items = []
+    source_path = Path(source_dir)
+    
+    if not source_path.exists():
+        return items
+    
+    # Look for item directories with type suffixes
+    for entry in source_path.iterdir():
+        if entry.is_dir():
+            # Check if directory name ends with a known item type
+            name = entry.name
+            for item_type in IMPORTABLE_ITEM_TYPES:
+                if name.endswith(f".{item_type}"):
+                    item_name = name[:-len(f".{item_type}")]
+                    items.append({
+                        "name": item_name,
+                        "type": item_type,
+                        "full_name": name,
+                        "source_path": str(entry),
+                        "has_definition": (entry / ".platform").exists() or any(entry.glob("*.json"))
+                    })
+                    break
+    
+    return items
+
+
+def import_item(source_path: str, target_path: str, force: bool = True) -> Dict[str, Any]:
+    """Import an item from local source to target workspace."""
+    result = {
+        "source": source_path,
+        "target": target_path,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Build import command
+    cmd = ["import", target_path, "-i", source_path]
+    if force:
+        cmd.append("-f")
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = "Item imported successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "Import failed"
+    
+    return result
+
+
+def create_item(workspace: str, item_name: str, item_type: str) -> Dict[str, Any]:
+    """Create a new item in the workspace."""
+    item_path = f"{workspace}/{item_name}.{item_type}"
+    
+    result = {
+        "path": item_path,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["message"] = f"Item '{item_name}.{item_type}' created"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create item"
+    
+    return result
+
+
+def deploy_items(
+    source_dir: str,
+    target_workspace: str,
+    dry_run: bool = False,
+    ignore_errors: bool = False
+) -> Dict[str, Any]:
+    """Deploy items from source directory to target workspace."""
+    
+    target_workspace = ensure_workspace_suffix(target_workspace)
+    
+    report = {
+        "source_directory": source_dir,
+        "target_workspace": target_workspace,
+        "dry_run": dry_run,
+        "items_discovered": [],
+        "deployment_results": [],
+        "summary": {
+            "total_items": 0,
+            "created": 0,
+            "updated": 0,
+            "skipped": 0,
+            "failed": 0
+        }
+    }
+    
+    # Discover items in source directory
+    print(f"\nDiscovering items in: {source_dir}")
+    items = discover_items(source_dir)
+    report["items_discovered"] = items
+    report["summary"]["total_items"] = len(items)
+    
+    if not items:
+        print("No deployable items found in source directory.")
+        print(f"\nExpected format: <item_name>.<ItemType>/ directories")
+        print(f"Supported types: {', '.join(IMPORTABLE_ITEM_TYPES)}")
+        return report
+    
+    print(f"Found {len(items)} item(s) to deploy:")
+    for item in items:
+        print(f"  - {item['full_name']}")
+    
+    if dry_run:
+        print(f"\n[DRY RUN] Would deploy to: {target_workspace}")
+        for item in items:
+            item_path = f"{target_workspace}/{item['full_name']}"
+            exists = check_item_exists(item_path)
+            action = "UPDATE" if exists else "CREATE"
+            print(f"  [{action}] {item['full_name']}")
+        return report
+    
+    # Check workspace exists
+    print(f"\nVerifying workspace: {target_workspace}")
+    if not check_workspace_exists(target_workspace):
+        print(f"Error: Workspace '{target_workspace}' does not exist or is not accessible")
+        sys.exit(1)
+    
+    # Deploy each item
+    print(f"\nDeploying items...")
+    for item in items:
+        item_name = item["name"]
+        item_type = item["type"]
+        full_name = item["full_name"]
+        source_path = item["source_path"]
+        target_path = f"{target_workspace}/{full_name}"
+        
+        print(f"\n  Deploying {full_name}...")
+        
+        deployment_result = {
+            "item": full_name,
+            "source": source_path,
+            "target": target_path,
+            "action": "unknown",
+            "status": "unknown",
+            "message": ""
+        }
+        
+        # Check if item exists
+        exists = check_item_exists(target_path)
+        
+        if exists:
+            # Update existing item via import
+            deployment_result["action"] = "update"
+            print(f"    Item exists, updating...")
+            result = import_item(source_path, target_path)
+            deployment_result["status"] = result["status"]
+            deployment_result["message"] = result["message"]
+            
+            if result["status"] == "success":
+                report["summary"]["updated"] += 1
+                print(f"    ✓ Updated successfully")
+            else:
+                report["summary"]["failed"] += 1
+                print(f"    ✗ Update failed: {result['message']}")
+                if not ignore_errors:
+                    report["deployment_results"].append(deployment_result)
+                    return report
+        else:
+            # Create new item and import definition
+            deployment_result["action"] = "create"
+            print(f"    Creating new item...")
+            
+            # First create the item
+            create_result = create_item(target_workspace, item_name, item_type)
+            
+            if create_result["status"] == "created":
+                # Then import the definition
+                print(f"    Importing definition...")
+                import_result = import_item(source_path, target_path)
+                
+                if import_result["status"] == "success":
+                    deployment_result["status"] = "success"
+                    deployment_result["message"] = "Created and imported successfully"
+                    report["summary"]["created"] += 1
+                    print(f"    ✓ Created and imported successfully")
+                else:
+                    deployment_result["status"] = "partial"
+                    deployment_result["message"] = f"Created but import failed: {import_result['message']}"
+                    report["summary"]["created"] += 1
+                    print(f"    ⚠ Created but import failed: {import_result['message']}")
+            else:
+                deployment_result["status"] = "failed"
+                deployment_result["message"] = create_result["message"]
+                report["summary"]["failed"] += 1
+                print(f"    ✗ Creation failed: {create_result['message']}")
+                
+                if not ignore_errors:
+                    report["deployment_results"].append(deployment_result)
+                    return report
+        
+        report["deployment_results"].append(deployment_result)
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Deploy Fabric items from local folder to workspace",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python deploy.py ./fabric-items/ Production.Workspace
+    python deploy.py ./exports/ Dev.Workspace --dry-run
+    python deploy.py ./fabric-items/ "My Workspace" --ignore-errors
+
+Source Directory Structure:
+    The source directory should contain item folders with type suffixes:
+    
+    ./fabric-items/
+    ├── MyNotebook.Notebook/
+    │   ├── .platform
+    │   └── notebook-content.json
+    ├── SalesReport.Report/
+    │   ├── .platform
+    │   └── definition.pbir
+    └── DataModel.SemanticModel/
+        ├── .platform
+        └── model.bim
+
+Supported Item Types:
+    Notebook, SparkJobDefinition, DataPipeline, Report, SemanticModel,
+    KQLDatabase, KQLDashboard, KQLQueryset, Eventhouse, Eventstream,
+    MirroredDatabase, Reflex, MountedDataFactory, CopyJob, VariableLibrary
+        """
+    )
+    parser.add_argument(
+        "source",
+        help="Source directory containing item exports"
+    )
+    parser.add_argument(
+        "target",
+        help="Target workspace name or path"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview deployment without making changes"
+    )
+    parser.add_argument(
+        "--ignore-errors",
+        action="store_true",
+        help="Continue deployment even if individual items fail"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate source directory
+    if not os.path.isdir(args.source):
+        print(f"Error: Source directory '{args.source}' does not exist", file=sys.stderr)
+        sys.exit(1)
+    
+    try:
+        report = deploy_items(
+            source_dir=args.source,
+            target_workspace=args.target,
+            dry_run=args.dry_run,
+            ignore_errors=args.ignore_errors
+        )
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("DEPLOYMENT SUMMARY")
+        print("=" * 50)
+        print(f"Source: {report['source_directory']}")
+        print(f"Target: {report['target_workspace']}")
+        print(f"Dry Run: {report['dry_run']}")
+        print(f"\nResults:")
+        print(f"  Total Items: {report['summary']['total_items']}")
+        print(f"  Created: {report['summary']['created']}")
+        print(f"  Updated: {report['summary']['updated']}")
+        print(f"  Skipped: {report['summary']['skipped']}")
+        print(f"  Failed: {report['summary']['failed']}")
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        # Exit code based on failures
+        sys.exit(0 if report['summary']['failed'] == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py b/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
new file mode 100644
index 000000000..f802353db
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+diff_definitions.py - Compare item definitions between environments
+
+This script compares Fabric item definitions between two sources (workspaces or
+local exports) and outputs the differences.
+
+Usage:
+    python diff_definitions.py <item1> <item2>
+    python diff_definitions.py Dev.Workspace/Model.SemanticModel Prod.Workspace/Model.SemanticModel
+    python diff_definitions.py ./local-export/Model.SemanticModel Prod.Workspace/Model.SemanticModel
+
+Exit codes:
+    0 - Items are identical
+    1 - Items are different or error occurred
+"""
+
+import argparse
+import difflib
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Tuple
+
+
+def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def is_local_path(path: str) -> bool:
+    """Check if path is a local filesystem path."""
+    # Local paths start with . or / or drive letter
+    return path.startswith((".", "/", "\\")) or (len(path) > 1 and path[1] == ":")
+
+
+def get_item_type_from_path(path: str) -> Optional[str]:
+    """Extract item type from path."""
+    item_types = [
+        "Workspace", "Lakehouse", "Warehouse", "SemanticModel", "Report",
+        "Notebook", "SparkJobDefinition", "DataPipeline", "KQLDatabase",
+        "KQLDashboard", "KQLQueryset", "Eventhouse", "Eventstream",
+        "MirroredDatabase", "Reflex", "MountedDataFactory", "CopyJob"
+    ]
+    
+    for item_type in item_types:
+        if path.endswith(f".{item_type}"):
+            return item_type
+        if f".{item_type}/" in path or f".{item_type}\\" in path:
+            return item_type
+    
+    return None
+
+
+def export_item_definition(item_path: str, output_dir: str) -> Tuple[bool, str]:
+    """Export item definition from Fabric to local directory."""
+    exit_code, stdout, stderr = run_fab_command([
+        "export", item_path, "-d", output_dir, "-f", "json"
+    ])
+    
+    if exit_code == 0:
+        return True, output_dir
+    return False, stderr
+
+
+def load_local_definition(local_path: str) -> Dict[str, Any]:
+    """Load item definition from local path."""
+    result = {
+        "path": local_path,
+        "files": {},
+        "metadata": {}
+    }
+    
+    path = Path(local_path)
+    
+    if not path.exists():
+        return {"error": f"Path does not exist: {local_path}"}
+    
+    if path.is_file():
+        # Single file comparison
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+        result["files"][path.name] = content
+        return result
+    
+    # Directory - load all relevant files
+    for file_path in path.rglob("*"):
+        if file_path.is_file():
+            rel_path = str(file_path.relative_to(path))
+            
+            # Skip certain files
+            if any(skip in rel_path for skip in [".git", "__pycache__", ".DS_Store"]):
+                continue
+            
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                result["files"][rel_path] = content
+            except UnicodeDecodeError:
+                # Binary file - store hash or skip
+                result["files"][rel_path] = f"<binary file: {file_path.stat().st_size} bytes>"
+    
+    # Load metadata if exists
+    platform_file = path / ".platform"
+    if platform_file.exists():
+        try:
+            with open(platform_file, "r", encoding="utf-8") as f:
+                result["metadata"]["platform"] = json.load(f)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            pass
+    
+    return result
+
+
+def get_definition(source: str, temp_dir: str) -> Tuple[Dict[str, Any], str]:
+    """Get item definition from source (local path or Fabric path)."""
+    if is_local_path(source):
+        definition = load_local_definition(source)
+        return definition, source
+    else:
+        # Export from Fabric to temp directory
+        item_name = source.split("/")[-1] if "/" in source else source
+        export_path = os.path.join(temp_dir, item_name.replace(".", "_"))
+        
+        success, result = export_item_definition(source, export_path)
+        if success:
+            definition = load_local_definition(export_path)
+            return definition, export_path
+        else:
+            return {"error": result}, ""
+
+
+def normalize_json_content(content: str) -> str:
+    """Normalize JSON content for comparison (sort keys, consistent formatting)."""
+    try:
+        data = json.loads(content)
+        # Remove volatile fields
+        volatile_fields = ["lastModifiedTime", "modifiedDateTime", "createdDateTime", "id"]
+        
+        def remove_volatile(obj):
+            if isinstance(obj, dict):
+                return {k: remove_volatile(v) for k, v in obj.items() if k not in volatile_fields}
+            elif isinstance(obj, list):
+                return [remove_volatile(item) for item in obj]
+            return obj
+        
+        cleaned = remove_volatile(data)
+        return json.dumps(cleaned, indent=2, sort_keys=True)
+    except json.JSONDecodeError:
+        return content
+
+
+def compare_definitions(def1: Dict[str, Any], def2: Dict[str, Any], 
+                       ignore_metadata: bool = False) -> Dict[str, Any]:
+    """Compare two item definitions."""
+    result = {
+        "identical": True,
+        "differences": [],
+        "only_in_source1": [],
+        "only_in_source2": [],
+        "modified_files": []
+    }
+    
+    if "error" in def1:
+        return {"error": f"Source 1 error: {def1['error']}"}
+    if "error" in def2:
+        return {"error": f"Source 2 error: {def2['error']}"}
+    
+    files1 = def1.get("files", {})
+    files2 = def2.get("files", {})
+    
+    all_files = set(files1.keys()) | set(files2.keys())
+    
+    for file_name in sorted(all_files):
+        # Skip metadata files if requested
+        if ignore_metadata and file_name in [".platform", "item.metadata.json"]:
+            continue
+        
+        content1 = files1.get(file_name)
+        content2 = files2.get(file_name)
+        
+        if content1 is None:
+            result["only_in_source2"].append(file_name)
+            result["identical"] = False
+        elif content2 is None:
+            result["only_in_source1"].append(file_name)
+            result["identical"] = False
+        else:
+            # Normalize JSON files for comparison
+            if file_name.endswith(".json"):
+                content1_normalized = normalize_json_content(content1)
+                content2_normalized = normalize_json_content(content2)
+            else:
+                content1_normalized = content1
+                content2_normalized = content2
+            
+            if content1_normalized != content2_normalized:
+                result["identical"] = False
+                result["modified_files"].append(file_name)
+                
+                # Generate diff
+                diff = list(difflib.unified_diff(
+                    content1_normalized.splitlines(keepends=True),
+                    content2_normalized.splitlines(keepends=True),
+                    fromfile=f"source1/{file_name}",
+                    tofile=f"source2/{file_name}",
+                    lineterm=""
+                ))
+                
+                result["differences"].append({
+                    "file": file_name,
+                    "diff": "".join(diff)
+                })
+    
+    return result
+
+
+def print_comparison_report(result: Dict[str, Any], source1: str, source2: str,
+                           output_format: str, output_file: Optional[str] = None):
+    """Print comparison report."""
+    if output_format == "json":
+        report = {
+            "source1": source1,
+            "source2": source2,
+            **result
+        }
+        output = json.dumps(report, indent=2)
+    else:
+        # Text format
+        lines = []
+        lines.append("=" * 70)
+        lines.append("ITEM DEFINITION COMPARISON")
+        lines.append("=" * 70)
+        lines.append(f"Source 1: {source1}")
+        lines.append(f"Source 2: {source2}")
+        lines.append("")
+        
+        if "error" in result:
+            lines.append(f"ERROR: {result['error']}")
+        else:
+            if result["identical"]:
+                lines.append("RESULT: Items are IDENTICAL")
+            else:
+                lines.append("RESULT: Items are DIFFERENT")
+                lines.append("")
+                
+                if result["only_in_source1"]:
+                    lines.append("Files only in source 1:")
+                    for f in result["only_in_source1"]:
+                        lines.append(f"  - {f}")
+                    lines.append("")
+                
+                if result["only_in_source2"]:
+                    lines.append("Files only in source 2:")
+                    for f in result["only_in_source2"]:
+                        lines.append(f"  + {f}")
+                    lines.append("")
+                
+                if result["modified_files"]:
+                    lines.append("Modified files:")
+                    for f in result["modified_files"]:
+                        lines.append(f"  ~ {f}")
+                    lines.append("")
+                
+                if result["differences"]:
+                    lines.append("-" * 70)
+                    lines.append("DETAILED DIFFERENCES:")
+                    lines.append("-" * 70)
+                    for diff_info in result["differences"]:
+                        lines.append(f"\n{diff_info['file']}:")
+                        lines.append(diff_info["diff"])
+        
+        lines.append("")
+        lines.append("=" * 70)
+        output = "\n".join(lines)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Report written to: {output_file}", file=sys.stderr)
+    else:
+        print(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compare item definitions between environments",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Compare items between workspaces
+    python diff_definitions.py Dev.Workspace/Model.SemanticModel Prod.Workspace/Model.SemanticModel
+    
+    # Compare local export to workspace
+    python diff_definitions.py ./exports/Model.SemanticModel Production.Workspace/Model.SemanticModel
+    
+    # Compare two local exports
+    python diff_definitions.py ./dev-export/Model.SemanticModel ./prod-export/Model.SemanticModel
+    
+    # Output as JSON
+    python diff_definitions.py Dev.Workspace/Model Prod.Workspace/Model -f json -o diff.json
+        """
+    )
+    
+    parser.add_argument(
+        "source1",
+        help="First item path (workspace path or local directory)"
+    )
+    
+    parser.add_argument(
+        "source2",
+        help="Second item path (workspace path or local directory)"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "--ignore-metadata",
+        action="store_true",
+        help="Ignore metadata files (.platform, item.metadata.json) in comparison"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    args = parser.parse_args()
+    
+    # Create temp directory for exports
+    with tempfile.TemporaryDirectory() as temp_dir:
+        if args.verbose:
+            print(f"Using temp directory: {temp_dir}", file=sys.stderr)
+        
+        # Get definitions
+        if args.verbose:
+            print(f"Loading source 1: {args.source1}", file=sys.stderr)
+        def1, path1 = get_definition(args.source1, os.path.join(temp_dir, "source1"))
+        
+        if args.verbose:
+            print(f"Loading source 2: {args.source2}", file=sys.stderr)
+        def2, path2 = get_definition(args.source2, os.path.join(temp_dir, "source2"))
+        
+        # Compare
+        if args.verbose:
+            print("Comparing definitions...", file=sys.stderr)
+        comparison = compare_definitions(def1, def2, ignore_metadata=args.ignore_metadata)
+        
+        # Output report
+        print_comparison_report(comparison, args.source1, args.source2, args.format, args.output)
+        
+        # Return exit code
+        if "error" in comparison:
+            return 1
+        return 0 if comparison.get("identical", False) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py b/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
new file mode 100644
index 000000000..371e7cc19
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
@@ -0,0 +1,372 @@
+#!/usr/bin/env python3
+"""
+export_workspace.py - Export all workspace items for version control
+
+This script exports all items from a Microsoft Fabric workspace to a local directory
+in a format suitable for Git version control.
+
+Usage:
+    python export_workspace.py <workspace> -o <dir>
+    python export_workspace.py Dev.Workspace -o ./fabric-exports/
+
+Exit codes:
+    0 - Export completed successfully
+    1 - Export failed or had errors
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List
+
+
+# Item types that support export
+EXPORTABLE_ITEM_TYPES = [
+    "Notebook", "SparkJobDefinition", "DataPipeline",
+    "Report", "SemanticModel", "PaginatedReport",
+    "KQLDatabase", "KQLDashboard", "KQLQueryset",
+    "Eventhouse", "Eventstream", "MirroredDatabase",
+    "Reflex", "MountedDataFactory", "CopyJob", "VariableLibrary",
+    "Environment", "MLModel", "MLExperiment"
+]
+
+
+def run_fab_command(args: list[str], timeout: int = 300) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def check_workspace_exists(workspace: str) -> bool:
+    """Check if workspace exists."""
+    exit_code, _, _ = run_fab_command(["exists", workspace])
+    return exit_code == 0
+
+
+def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
+    """Get all items in the workspace."""
+    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        try:
+            result = json.loads(stdout.strip())
+            if isinstance(result, list):
+                return result
+        except json.JSONDecodeError:
+            pass
+    
+    return []
+
+
+def get_workspace_details(workspace: str) -> Dict[str, Any]:
+    """Get workspace metadata."""
+    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        try:
+            return json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            pass
+    
+    return {}
+
+
+def export_item(item_path: str, output_dir: str) -> Dict[str, Any]:
+    """Export a single item to the output directory."""
+    result = {
+        "item": item_path,
+        "output_dir": output_dir,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Build export command
+    cmd = ["export", item_path, "-o", output_dir, "-f"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = "Exported successfully"
+    else:
+        # Check if export is not supported for this item type
+        if "not supported" in stderr.lower() or "cannot export" in stderr.lower():
+            result["status"] = "skipped"
+            result["message"] = "Export not supported for this item type"
+        else:
+            result["status"] = "failed"
+            result["message"] = stderr.strip() or "Export failed"
+    
+    return result
+
+
+def generate_manifest(
+    workspace: str,
+    workspace_details: Dict[str, Any],
+    items: List[Dict[str, Any]],
+    export_results: List[Dict[str, Any]]
+) -> Dict[str, Any]:
+    """Generate manifest.json with workspace metadata."""
+    
+    successful_exports = [r for r in export_results if r["status"] == "success"]
+    
+    manifest = {
+        "manifest_version": "1.0.0",
+        "export_metadata": {
+            "exported_at": datetime.utcnow().isoformat() + "Z",
+            "source_workspace": workspace,
+            "workspace_id": workspace_details.get("id"),
+            "capacity_id": workspace_details.get("capacityId"),
+            "total_items": len(items),
+            "exported_items": len(successful_exports)
+        },
+        "workspace_info": {
+            "name": workspace_details.get("displayName", workspace.replace(".Workspace", "")),
+            "id": workspace_details.get("id"),
+            "description": workspace_details.get("description", ""),
+            "type": workspace_details.get("type")
+        },
+        "items": []
+    }
+    
+    for result in export_results:
+        if result["status"] == "success":
+            manifest["items"].append({
+                "path": result["item"],
+                "name": result.get("name", ""),
+                "type": result.get("type", ""),
+                "status": "exported"
+            })
+    
+    return manifest
+
+
+def export_workspace(
+    workspace: str,
+    output_dir: str,
+    include_unsupported: bool = False
+) -> Dict[str, Any]:
+    """Export all workspace items to the output directory."""
+    
+    workspace = ensure_workspace_suffix(workspace)
+    
+    report = {
+        "workspace": workspace,
+        "output_directory": output_dir,
+        "items_found": [],
+        "export_results": [],
+        "summary": {
+            "total_items": 0,
+            "exported": 0,
+            "skipped": 0,
+            "failed": 0,
+            "not_supported": 0
+        }
+    }
+    
+    # Verify workspace exists
+    print(f"\nVerifying workspace: {workspace}")
+    if not check_workspace_exists(workspace):
+        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
+        return report
+    print("  Workspace found")
+    
+    # Get workspace details
+    print("\nFetching workspace details...")
+    workspace_details = get_workspace_details(workspace)
+    
+    # Get all items
+    print("Fetching workspace items...")
+    items = get_workspace_items(workspace)
+    report["items_found"] = items
+    report["summary"]["total_items"] = len(items)
+    
+    if not items:
+        print("No items found in workspace")
+        return report
+    
+    print(f"  Found {len(items)} item(s)")
+    
+    # Group items by type for display
+    items_by_type = {}
+    for item in items:
+        item_type = item.get("type", "Unknown")
+        if item_type not in items_by_type:
+            items_by_type[item_type] = []
+        items_by_type[item_type].append(item)
+    
+    print("\n  Items by type:")
+    for item_type, type_items in sorted(items_by_type.items()):
+        print(f"    {item_type}: {len(type_items)}")
+    
+    # Create output directory
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    print(f"\nExporting to: {output_dir}")
+    
+    # Export each item
+    print("\nExporting items...")
+    for item in items:
+        item_name = item.get("displayName", item.get("name", "Unknown"))
+        item_type = item.get("type", "Unknown")
+        item_id = item.get("id", "")
+        full_name = f"{item_name}.{item_type}"
+        item_path = f"{workspace}/{full_name}"
+        
+        export_result = {
+            "item": item_path,
+            "name": item_name,
+            "type": item_type,
+            "id": item_id,
+            "status": "unknown",
+            "message": ""
+        }
+        
+        # Check if item type is exportable
+        if item_type not in EXPORTABLE_ITEM_TYPES and not include_unsupported:
+            export_result["status"] = "not_supported"
+            export_result["message"] = f"Item type '{item_type}' export not supported"
+            report["export_results"].append(export_result)
+            report["summary"]["not_supported"] += 1
+            print(f"  [{item_type}] {item_name}: skipped (not supported)")
+            continue
+        
+        print(f"  [{item_type}] {item_name}...")
+        
+        result = export_item(item_path, output_dir)
+        export_result["status"] = result["status"]
+        export_result["message"] = result["message"]
+        report["export_results"].append(export_result)
+        
+        if result["status"] == "success":
+            report["summary"]["exported"] += 1
+            print(f"    ✓ Exported")
+        elif result["status"] == "skipped":
+            report["summary"]["skipped"] += 1
+            print(f"    - Skipped: {result['message']}")
+        else:
+            report["summary"]["failed"] += 1
+            print(f"    ✗ Failed: {result['message']}")
+    
+    # Generate manifest
+    print("\nGenerating manifest.json...")
+    manifest = generate_manifest(workspace, workspace_details, items, report["export_results"])
+    manifest_path = output_path / "manifest.json"
+    
+    with open(manifest_path, "w", encoding="utf-8") as f:
+        json.dump(manifest, f, indent=2)
+    
+    print(f"  Manifest saved: {manifest_path}")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export all workspace items for version control",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python export_workspace.py Dev.Workspace -o ./fabric-exports/
+    python export_workspace.py Production.Workspace -o ./exports/prod/
+    python export_workspace.py "My Workspace" -o ./my-workspace-export/
+
+Output Structure:
+    <output-dir>/
+    ├── manifest.json           # Export metadata and item list
+    ├── MyNotebook.Notebook/    # Exported item folders
+    │   ├── .platform
+    │   └── notebook-content.json
+    ├── SalesReport.Report/
+    │   ├── .platform
+    │   └── definition.pbir
+    └── DataModel.SemanticModel/
+        ├── .platform
+        └── model.bim
+
+Supported Item Types:
+    Notebook, SparkJobDefinition, DataPipeline, Report, SemanticModel,
+    PaginatedReport, KQLDatabase, KQLDashboard, KQLQueryset, Eventhouse,
+    Eventstream, MirroredDatabase, Reflex, MountedDataFactory, CopyJob,
+    VariableLibrary, Environment, MLModel, MLExperiment
+        """
+    )
+    parser.add_argument(
+        "workspace",
+        help="Workspace name or path to export"
+    )
+    parser.add_argument(
+        "-o", "--output",
+        required=True,
+        help="Output directory for exported items"
+    )
+    parser.add_argument(
+        "--include-unsupported",
+        action="store_true",
+        help="Attempt to export items even if type is not officially supported"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = export_workspace(
+            workspace=args.workspace,
+            output_dir=args.output,
+            include_unsupported=args.include_unsupported
+        )
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("EXPORT SUMMARY")
+        print("=" * 50)
+        print(f"Workspace: {report['workspace']}")
+        print(f"Output Directory: {report['output_directory']}")
+        print(f"\nResults:")
+        print(f"  Total Items: {report['summary']['total_items']}")
+        print(f"  Exported: {report['summary']['exported']}")
+        print(f"  Skipped: {report['summary']['skipped']}")
+        print(f"  Failed: {report['summary']['failed']}")
+        print(f"  Not Supported: {report['summary']['not_supported']}")
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        # Exit code based on failures
+        sys.exit(0 if report['summary']['failed'] == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-core/README.md b/.ai-assets/skills/fabric-cli-core/README.md
new file mode 100644
index 000000000..0319fbe7c
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-core/README.md
@@ -0,0 +1,33 @@
+# fabric-cli-core
+
+Core skill for Microsoft Fabric CLI operations. **Load this skill first** for any Fabric CLI task.
+
+## What This Skill Provides
+
+- Fabric hierarchy mental model (Tenant → Workspace → Folder → Item → OneLakeItem)
+- Path conventions with dot entity suffixes (e.g., `.Workspace`, `.Notebook`)
+- Authentication patterns (interactive, SPN, managed identity)
+- Hidden entity discovery (`ls -a`)
+- Security and sensitive data handling rules
+- Critical operational rules
+- Common item types reference
+
+## Entry Point
+
+Load [`SKILL.md`](./SKILL.md) to activate this skill.
+
+## References
+
+Detailed documentation in the `references/` folder:
+
+| Reference | Description |
+|-----------|-------------|
+| [quickstart.md](./references/quickstart.md) | Copy-paste examples for common tasks |
+| [reference.md](./references/reference.md) | All commands with flags and patterns |
+| [semantic-models.md](./references/semantic-models.md) | TMDL, DAX queries, refresh, storage modes |
+| [notebooks.md](./references/notebooks.md) | Job execution, parameters, scheduling |
+| [reports.md](./references/reports.md) | Export, import, rebind to models |
+| [workspaces.md](./references/workspaces.md) | Create, manage, permissions |
+| [querying-data.md](./references/querying-data.md) | DAX and lakehouse table queries |
+| [fab-api.md](./references/fab-api.md) | Direct REST API access patterns |
+| [create-workspaces.md](./references/create-workspaces.md) | Workspace creation workflows |
diff --git a/.ai-assets/skills/fabric-cli-core/SKILL.md b/.ai-assets/skills/fabric-cli-core/SKILL.md
new file mode 100644
index 000000000..d29b89a3d
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-core/SKILL.md
@@ -0,0 +1,153 @@
+---
+name: fabric-cli-core
+description: Use Microsoft Fabric CLI (fab) to manage workspaces, semantic models, reports, notebooks, and Fabric resources. Activate when users mention fab, Fabric CLI, or need to automate Fabric operations.
+---
+
+# Fabric CLI Core
+
+This skill defines safe, consistent defaults for an AI agent helping users operate **Microsoft Fabric** via the **Fabric CLI (`fab`)**.
+
+## 1 - Fabric CLI mental model (paths and entities)
+
+### Automation Scripts
+
+Ready-to-use Python scripts for core CLI tasks. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `health_check.py` | Verify CLI installation, auth status, and connectivity | `python scripts/health_check.py [--workspace WS]` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+### Paths and Entities
+
+- Treat Fabric as a **filesystem-like hierarchy** with consistent **dot (.) entity suffixes** in paths (e.g., `.Workspace`, `.Folder`, `.SemanticModel`).
+- The hierarchy structure is:
+  - **Tenant**: The top-level container for everything.
+  - **Workspace**: Personal or team workspace holding folders, items, and workspace-level elements.
+  - **Folder**: Container for organizing items within a workspace (supports ~10 levels of nesting).
+  - **Item**: Individual resource within a workspace or folder (e.g., Notebook, SemanticModel, Lakehouse).
+  - **OneLakeItem**: OneLake storage item residing within a Lakehouse (tables, files, etc.).
+- Prefer and generate paths like:
+  - `/Workspace1.Workspace/Notebook1.Notebook`
+  - `/Workspace1.Workspace/FolderA.Folder/SemanticModel1.SemanticModel`
+  - `/Workspace1.Workspace/FolderA.Folder/lh1.Lakehouse/Tables` (OneLakeItem)
+- When a user provides an ambiguous identifier, ask for the full path (or infer with stated assumptions).
+
+## 2 - Modes (interactive vs command line)
+- Be explicit about which mode a user is in:
+  - **Interactive mode** behaves like a REPL and runs commands without the `fab` prefix.
+  - **Command line mode** runs one command per invocation and is best for scripts/automation.
+- The selected mode is **preserved between sessions**. If a user exits and logs back in, the CLI resumes in the same mode last used.
+- When you provide instructions, show commands in **command line mode** unless the user says they're in interactive mode.
+
+## 3 - Authentication (public-safe guidance)
+- Prefer these auth patterns and do not invent new flows:
+  1) **Interactive user**: `fab auth login` (browser/WAM where supported).
+  2) **Service principal (secret/cert)**: use environment variables / secure mechanisms; avoid embedding secrets in files.
+  3) **Service principal (federated credential)**: use the federated token environment variable (`FAB_SPN_FEDERATED_TOKEN`) and **do not persist the raw token**.
+  4) **Managed identity**: supported for Azure-hosted workloads; no credentials required.
+- Never ask users to paste secrets into chat or print them back.
+
+## 4 - Sensitive data handling (strict)
+- Never log or output tokens, passwords, client secrets, or raw federated tokens.
+- Validate all user inputs that could affect security:
+  - **Paths**: Sanitize file paths and API parameters.
+  - **GUIDs**: Validate resource identifiers before use.
+  - **JSON**: Validate JSON inputs for proper format.
+- If a user shares sensitive strings, advise rotating/regenerating them and moving to secure storage.
+
+## 5 - Hidden entities and discovery
+- Hidden entities are special resources not normally visible, following a **dot-prefixed naming convention** (similar to UNIX hidden files).
+- **Tenant-level hidden entities** (accessed from root):
+  - `.capacities` — `fab ls .capacities` / `fab get .capacities/<name>.Capacity`
+  - `.gateways` — `fab ls .gateways` / `fab get .gateways/<name>.Gateway`
+  - `.connections` — `fab ls .connections` / `fab get .connections/<name>.Connection`
+  - `.domains` — `fab ls .domains` / `fab get .domains/<name>.Domain`
+- **Workspace-level hidden entities** (accessed within a workspace):
+  - `.managedidentities` — `fab ls ws1.Workspace/.managedidentities`
+  - `.managedprivateendpoints` — `fab ls ws1.Workspace/.managedprivateendpoints`
+  - `.externaldatashares` — `fab ls ws1.Workspace/.externaldatashares`
+  - `.sparkpools` — `fab ls ws1.Workspace/.sparkpools`
+- To show hidden resources, recommend `ls -a` / `ls --all`.
+
+## 6 - Errors and troubleshooting guidance
+- When describing failures, include:
+  - What the command was trying to do
+  - The likely cause
+  - The next actionable step
+- If the CLI surfaces an error code/message, keep it intact and do not paraphrase away the key identifiers. (Fabric CLI emphasizes stable error codes/messages.)
+- Include request IDs for API errors to aid debugging when available.
+
+## 7 - Output conventions for the agent
+- Default to concise, runnable steps.
+- When recommending commands, include:
+  - Preconditions (auth, correct workspace/path)
+  - Expected result
+  - How to verify (e.g., follow-up `fab ls` / `fab get`)
+
+## 8 - Safety defaults
+- Ask before suggesting commands that delete, overwrite, or change access/permissions.
+- If the user explicitly confirms, proceed with a clear rollback note when possible.
+
+## 9 - Platform and troubleshooting reference
+- **Supported platforms**: Windows, Linux, macOS.
+- **Supported shells**: zsh, bash, PowerShell, cmd (Windows command prompt).
+- **Python versions**: 3.10, 3.11, 3.12, 3.13.
+- **CLI file storage** (useful for troubleshooting):
+  - Config files are stored in `~/.config/fab/`:
+    - `cache.bin` — encrypted auth token cache
+    - `config.json` — non-sensitive CLI settings
+    - `auth.json` — non-sensitive auth info
+    - `context-<session_id>` — path context for command-line mode sessions
+  - Debug logs are written to:
+    - Windows: `%AppData%/fabcli_debug.log`
+    - macOS: `~/Library/Logs/fabcli_debug.log`
+    - Linux: `~/.local/state/fabcli_debug.log`
+
+## 10 - Critical operational rules
+- **First run**: Always run `fab auth status` to verify authentication before executing commands. If not authenticated, ask the user to run `fab auth login`.
+- **Learn before executing**: Always use `fab --help` and `fab <command> --help` the first time you use a command to understand its syntax.
+- **Start simple**: Try the basic `fab` command alone first before piping or chaining.
+- **Non-interactive mode**: Use `fab` in command-line mode when working with coding agents. Interactive mode doesn't work with automation.
+- **Force flag**: Use `-f` when executing commands if the flag is available to run non-interactively (skips confirmation prompts).
+- **Verify before acting**: If workspace or item name is unclear, ask the user first, then verify with `fab ls` or `fab exists` before proceeding.
+- **Permission errors**: If a command is blocked by permissions, stop and ask the user for clarification; never try to circumvent it.
+
+## 11 - Common item types
+
+| Extension | Description |
+|-----------|-------------|
+| `.Workspace` | Workspace container |
+| `.Folder` | Folder within workspace |
+| `.SemanticModel` | Power BI dataset/semantic model |
+| `.Report` | Power BI report |
+| `.Dashboard` | Power BI dashboard |
+| `.Notebook` | Fabric notebook |
+| `.Lakehouse` | Lakehouse |
+| `.Warehouse` | Data warehouse |
+| `.DataPipeline` | Data pipeline |
+| `.SparkJobDefinition` | Spark job definition |
+| `.Eventstream` | Real-time event stream |
+| `.KQLDatabase` | KQL database |
+| `.MLModel` | ML model |
+| `.MLExperiment` | ML experiment |
+| `.Capacity` | Fabric capacity (hidden) |
+| `.Gateway` | Data gateway (hidden) |
+| `.Connection` | Connection (hidden) |
+
+Use `fab desc .<ItemType>` to explore any item type.
+
+## 12 - Command references
+
+For detailed command syntax and working examples, see:
+
+- [Quick Start Guide](./references/quickstart.md) — Copy-paste examples for common tasks
+- [Full Command Reference](./references/reference.md) — All commands with flags and patterns
+- [Semantic Models](./references/semantic-models.md) — TMDL, DAX queries, refresh, storage modes
+- [Notebooks](./references/notebooks.md) — Job execution, parameters, scheduling
+- [Reports](./references/reports.md) — Export, import, rebind to models
+- [Workspaces](./references/workspaces.md) — Create, manage, permissions
+- [Querying Data](./references/querying-data.md) — DAX and lakehouse table queries
+- [API Reference](./references/fab-api.md) — Direct REST API access patterns
+- [Create Workspaces](./references/create-workspaces.md) — Workspace creation workflows
diff --git a/docs/agent-docs/references/create-workspaces.md b/.ai-assets/skills/fabric-cli-core/references/create-workspaces.md
similarity index 100%
rename from docs/agent-docs/references/create-workspaces.md
rename to .ai-assets/skills/fabric-cli-core/references/create-workspaces.md
diff --git a/docs/agent-docs/references/fab-api.md b/.ai-assets/skills/fabric-cli-core/references/fab-api.md
similarity index 100%
rename from docs/agent-docs/references/fab-api.md
rename to .ai-assets/skills/fabric-cli-core/references/fab-api.md
diff --git a/docs/agent-docs/references/notebooks.md b/.ai-assets/skills/fabric-cli-core/references/notebooks.md
similarity index 100%
rename from docs/agent-docs/references/notebooks.md
rename to .ai-assets/skills/fabric-cli-core/references/notebooks.md
diff --git a/docs/agent-docs/references/querying-data.md b/.ai-assets/skills/fabric-cli-core/references/querying-data.md
similarity index 100%
rename from docs/agent-docs/references/querying-data.md
rename to .ai-assets/skills/fabric-cli-core/references/querying-data.md
diff --git a/docs/agent-docs/references/quickstart.md b/.ai-assets/skills/fabric-cli-core/references/quickstart.md
similarity index 100%
rename from docs/agent-docs/references/quickstart.md
rename to .ai-assets/skills/fabric-cli-core/references/quickstart.md
diff --git a/docs/agent-docs/references/reference.md b/.ai-assets/skills/fabric-cli-core/references/reference.md
similarity index 100%
rename from docs/agent-docs/references/reference.md
rename to .ai-assets/skills/fabric-cli-core/references/reference.md
diff --git a/docs/agent-docs/references/reports.md b/.ai-assets/skills/fabric-cli-core/references/reports.md
similarity index 100%
rename from docs/agent-docs/references/reports.md
rename to .ai-assets/skills/fabric-cli-core/references/reports.md
diff --git a/docs/agent-docs/references/semantic-models.md b/.ai-assets/skills/fabric-cli-core/references/semantic-models.md
similarity index 100%
rename from docs/agent-docs/references/semantic-models.md
rename to .ai-assets/skills/fabric-cli-core/references/semantic-models.md
diff --git a/docs/agent-docs/references/workspaces.md b/.ai-assets/skills/fabric-cli-core/references/workspaces.md
similarity index 100%
rename from docs/agent-docs/references/workspaces.md
rename to .ai-assets/skills/fabric-cli-core/references/workspaces.md
diff --git a/.ai-assets/skills/fabric-cli-core/scripts/health_check.py b/.ai-assets/skills/fabric-cli-core/scripts/health_check.py
new file mode 100644
index 000000000..16d04aa8d
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-core/scripts/health_check.py
@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+health_check.py - Verify CLI installation, auth status, and connectivity
+
+This script performs comprehensive health checks for the Fabric CLI environment:
+- Verifies fab CLI is installed and accessible
+- Checks authentication status
+- Validates workspace connectivity
+- Optionally verifies specific workspace access
+
+Usage:
+    python health_check.py [--workspace WS] [--json]
+
+Exit codes:
+    0 - All checks passed (healthy)
+    1 - One or more checks failed (issues found)
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Dict, Any, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 30) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def check_cli_installed() -> Dict[str, Any]:
+    """Check if fab CLI is installed and accessible."""
+    check = {
+        "check": "cli_installed",
+        "description": "Verify fab CLI is installed and accessible",
+        "status": "unknown",
+        "details": {}
+    }
+    
+    exit_code, stdout, stderr = run_fab_command(["--version"])
+    
+    if exit_code == 0:
+        check["status"] = "pass"
+        check["details"]["version"] = stdout.strip()
+    elif exit_code == -1:
+        check["status"] = "fail"
+        check["details"]["error"] = "fab CLI not found in PATH. Please install the Fabric CLI."
+    else:
+        check["status"] = "fail"
+        check["details"]["error"] = stderr or "Unable to determine CLI version"
+    
+    return check
+
+
+def check_auth_status() -> Dict[str, Any]:
+    """Check authentication status with Fabric."""
+    check = {
+        "check": "auth_status",
+        "description": "Verify authentication to Microsoft Fabric",
+        "status": "unknown",
+        "details": {}
+    }
+    
+    exit_code, stdout, stderr = run_fab_command(["auth", "status"])
+    
+    if exit_code == 0:
+        check["status"] = "pass"
+        # Parse auth status output
+        lines = stdout.strip().split("\n")
+        for line in lines:
+            if ":" in line:
+                key, value = line.split(":", 1)
+                check["details"][key.strip().lower().replace(" ", "_")] = value.strip()
+    else:
+        check["status"] = "fail"
+        check["details"]["error"] = stderr.strip() or "Not authenticated. Run 'fab auth login' to authenticate."
+    
+    return check
+
+
+def check_workspace_connectivity() -> Dict[str, Any]:
+    """Check if we can list at least one workspace."""
+    check = {
+        "check": "workspace_connectivity",
+        "description": "Verify ability to list workspaces",
+        "status": "unknown",
+        "details": {}
+    }
+    
+    # Try to list workspaces (limit to 1 for quick check)
+    exit_code, stdout, stderr = run_fab_command(["ls", "/", "-q", "[0].name"])
+    
+    if exit_code == 0 and stdout.strip():
+        check["status"] = "pass"
+        check["details"]["sample_workspace"] = stdout.strip().strip('"')
+        check["details"]["message"] = "Successfully retrieved workspace list"
+    elif exit_code == 0:
+        check["status"] = "warn"
+        check["details"]["message"] = "No workspaces found. You may not have access to any workspaces."
+    else:
+        check["status"] = "fail"
+        check["details"]["error"] = stderr.strip() or "Unable to list workspaces"
+    
+    return check
+
+
+def check_specific_workspace(workspace: str) -> Dict[str, Any]:
+    """Check access to a specific workspace."""
+    check = {
+        "check": "specific_workspace",
+        "description": f"Verify access to workspace: {workspace}",
+        "status": "unknown",
+        "details": {"workspace": workspace}
+    }
+    
+    # Ensure workspace has .Workspace suffix
+    if not workspace.endswith(".Workspace"):
+        workspace = f"{workspace}.Workspace"
+    
+    exit_code, stdout, stderr = run_fab_command(["exists", workspace])
+    
+    if exit_code == 0:
+        check["status"] = "pass"
+        check["details"]["message"] = f"Workspace '{workspace}' is accessible"
+    else:
+        check["status"] = "fail"
+        check["details"]["error"] = stderr.strip() or f"Unable to access workspace '{workspace}'"
+    
+    return check
+
+
+def run_health_checks(workspace: Optional[str] = None) -> Dict[str, Any]:
+    """Run all health checks and return results."""
+    results = {
+        "overall_status": "healthy",
+        "checks": []
+    }
+    
+    # Required checks
+    cli_check = check_cli_installed()
+    results["checks"].append(cli_check)
+    
+    # Only proceed with other checks if CLI is installed
+    if cli_check["status"] == "pass":
+        auth_check = check_auth_status()
+        results["checks"].append(auth_check)
+        
+        # Only check connectivity if authenticated
+        if auth_check["status"] == "pass":
+            connectivity_check = check_workspace_connectivity()
+            results["checks"].append(connectivity_check)
+            
+            # Check specific workspace if provided
+            if workspace:
+                workspace_check = check_specific_workspace(workspace)
+                results["checks"].append(workspace_check)
+    
+    # Determine overall status
+    statuses = [c["status"] for c in results["checks"]]
+    if "fail" in statuses:
+        results["overall_status"] = "unhealthy"
+    elif "warn" in statuses:
+        results["overall_status"] = "degraded"
+    
+    return results
+
+
+def print_human_readable(results: Dict[str, Any]) -> None:
+    """Print results in human-readable format."""
+    status_symbols = {
+        "pass": "✓",
+        "fail": "✗",
+        "warn": "⚠",
+        "unknown": "?"
+    }
+    
+    print("\n" + "=" * 60)
+    print("FABRIC CLI HEALTH CHECK")
+    print("=" * 60)
+    
+    for check in results["checks"]:
+        symbol = status_symbols.get(check["status"], "?")
+        status_color = {
+            "pass": "",
+            "fail": "",
+            "warn": "",
+            "unknown": ""
+        }.get(check["status"], "")
+        
+        print(f"\n{symbol} {check['description']}")
+        print(f"  Status: {check['status'].upper()}")
+        
+        for key, value in check["details"].items():
+            print(f"  {key}: {value}")
+    
+    print("\n" + "-" * 60)
+    overall = results["overall_status"].upper()
+    print(f"OVERALL STATUS: {overall}")
+    print("=" * 60 + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Verify Fabric CLI installation, authentication, and connectivity",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python health_check.py
+    python health_check.py --workspace Production
+    python health_check.py --json
+    python health_check.py --workspace Production.Workspace --json
+        """
+    )
+    parser.add_argument(
+        "--workspace", "-w",
+        help="Specific workspace to verify access (optional)"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    results = run_health_checks(workspace=args.workspace)
+    
+    if args.json:
+        print(json.dumps(results, indent=2))
+    else:
+        print_human_readable(results)
+    
+    # Exit with appropriate code
+    sys.exit(0 if results["overall_status"] == "healthy" else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/README.md b/.ai-assets/skills/fabric-cli-dataengineering/README.md
new file mode 100644
index 000000000..abf2d55f2
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/README.md
@@ -0,0 +1,77 @@
+# Fabric CLI Data Engineering Skill
+
+Task-specific instructions for AI agents helping users with Microsoft Fabric data engineering operations.
+
+## Overview
+
+This skill provides guidance for:
+
+- **Lakehouse & Warehouse** — Creating and managing data stores
+- **Table Operations** — Load, optimize, vacuum Delta tables
+- **Shortcuts** — Data federation with OneLake, ADLS, S3
+- **Medallion Architecture** — Bronze/silver/gold layer patterns
+- **Spark Jobs** — Notebook and pipeline execution
+
+## When to Load
+
+Load this skill when the user's task involves:
+
+- Creating lakehouses or warehouses
+- Managing files in OneLake
+- Loading data into Delta tables
+- Optimizing table performance
+- Creating data shortcuts
+- Running Spark notebooks or jobs
+- Building ETL/ELT pipelines
+- Implementing medallion architecture
+
+## Files
+
+| File | Description |
+|------|-------------|
+| [SKILL.md](./SKILL.md) | Main skill definition (load this) |
+| [references/](./references/) | Detailed reference documentation |
+
+## Scripts
+
+Automation scripts for data engineering tasks:
+
+| Script | Description | Usage |
+|--------|-------------|-------|
+| `setup_medallion.py` | Create medallion architecture (bronze/silver/gold) | `python scripts/setup_medallion.py <workspace> [--prefix NAME]` |
+| `optimize_tables.py` | Run optimization on lakehouse tables | `python scripts/optimize_tables.py <lakehouse> [--vorder]` |
+| `validate_shortcuts.py` | Verify all shortcuts are accessible | `python scripts/validate_shortcuts.py <lakehouse>` |
+
+## Quick Reference
+
+### Common Commands
+
+```bash
+# Create lakehouse
+fab mkdir "Workspace.Workspace/DataLake.Lakehouse"
+
+# Upload files
+fab cp ./data.csv "Workspace.Workspace/LH.Lakehouse/Files/raw/"
+
+# Load table
+fab table load "Workspace.Workspace/LH.Lakehouse/Tables/customers" \
+  --file "Workspace.Workspace/LH.Lakehouse/Files/raw/customers"
+
+# Optimize table
+fab table optimize "Workspace.Workspace/LH.Lakehouse/Tables/sales" --vorder
+
+# Run notebook
+fab job run "Workspace.Workspace/ETL.Notebook" --timeout 600
+```
+
+## Dependencies
+
+- Requires `fabric-cli-core` skill loaded first
+- Contributor or higher role for data operations
+- Appropriate capacity for Spark workloads
+
+## References
+
+- [Lakehouse Overview](https://learn.microsoft.com/fabric/data-engineering/lakehouse-overview)
+- [Delta Lake in Fabric](https://learn.microsoft.com/fabric/data-engineering/delta-lake-interoperability)
+- [OneLake Shortcuts](https://learn.microsoft.com/fabric/onelake/onelake-shortcuts)
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md b/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md
new file mode 100644
index 000000000..02444d14f
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md
@@ -0,0 +1,535 @@
+---
+name: fabric-cli-dataengineering
+description: Use Fabric CLI for data engineering — lakehouses, warehouses, shortcuts, table optimization, medallion architecture, and Spark jobs. Activate when users work with data storage, ETL patterns, Delta tables, or data pipeline orchestration.
+---
+
+# Fabric CLI Data Engineering
+
+Expert guidance for data engineering operations in Microsoft Fabric using the `fab` CLI.
+
+## When to Use This Skill
+
+Activate automatically when tasks involve:
+
+- Creating and managing Lakehouses or Warehouses
+- Building medallion architecture (bronze/silver/gold layers)
+- Creating and managing OneLake shortcuts
+- Table operations (load, optimize, vacuum)
+- Spark job configuration and execution
+- Data pipeline orchestration
+- Delta table management
+
+## Prerequisites
+
+- Load `fabric-cli-core` skill first for foundational CLI guidance
+- User must be authenticated: `fab auth status`
+- Contributor or higher role for data operations
+
+## Automation Scripts
+
+Ready-to-use Python scripts for data engineering tasks. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `setup_medallion.py` | Create medallion architecture (bronze/silver/gold) | `python scripts/setup_medallion.py <workspace> [--prefix NAME]` |
+| `optimize_tables.py` | Run optimization on lakehouse tables | `python scripts/optimize_tables.py <lakehouse> [--vorder]` |
+| `validate_shortcuts.py` | Verify all shortcuts are accessible | `python scripts/validate_shortcuts.py <lakehouse>` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+## 1 - Lakehouse Operations
+
+### Create Lakehouse
+
+```bash
+# Create basic lakehouse
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse"
+
+# Create with schema support (preview)
+fab mkdir "DataPlatform.Workspace/SchemaSilver.Lakehouse" -P enableSchemas=true
+
+# Check available parameters
+fab mkdir "Item.Lakehouse" -P
+```
+
+### Lakehouse Structure
+
+```
+Lakehouse/
+├── Tables/           # Delta tables (managed)
+│   ├── dbo/         # Default schema
+│   │   ├── customers
+│   │   └── orders
+│   └── staging/     # Custom schema (if enabled)
+└── Files/           # Unmanaged files
+    ├── raw/
+    ├── staging/
+    └── exports/
+```
+
+### List Lakehouse Contents
+
+```bash
+# List lakehouse root
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse"
+
+# List tables
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables"
+
+# List tables in schema
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo"
+
+# List files
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files"
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw" -l
+```
+
+### Get Lakehouse Properties
+
+```bash
+# Get lakehouse details
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -v
+
+# Get SQL endpoint connection string
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties"
+
+# Get OneLake path
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeFilesPath"
+```
+
+## 2 - Warehouse Operations
+
+### Create Warehouse
+
+```bash
+# Create basic warehouse
+fab mkdir "DataPlatform.Workspace/SalesDW.Warehouse"
+
+# Create with case-insensitive collation
+fab mkdir "DataPlatform.Workspace/AnalyticsDW.Warehouse" -P enableCaseInsensitive=true
+```
+
+### Warehouse vs Lakehouse
+
+| Feature | Lakehouse | Warehouse |
+|---------|-----------|-----------|
+| Query Engine | Spark + SQL | T-SQL |
+| Best For | Data engineering | BI/Analytics |
+| Storage Format | Delta | Delta |
+| Schema Support | Optional | Built-in |
+| Direct Lake | Yes | Yes |
+
+## 3 - File Operations
+
+### Upload Files to Lakehouse
+
+```bash
+# Upload single file
+fab cp ./data/sales.csv "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales.csv"
+
+# Upload directory
+fab cp ./data/customers/ "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers/"
+
+# Upload with force (overwrite)
+fab cp ./data/daily.parquet "DataPlatform.Workspace/Bronze.Lakehouse/Files/staging/daily.parquet" -f
+```
+
+### Download Files
+
+```bash
+# Download single file
+fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/exports/report.csv" ./downloads/
+
+# Download directory
+fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" ./backup/raw/
+```
+
+### Move and Delete Files
+
+```bash
+# Move file
+fab mv "DataPlatform.Workspace/Bronze.Lakehouse/Files/staging/data.parquet" \
+       "DataPlatform.Workspace/Bronze.Lakehouse/Files/processed/"
+
+# Delete file
+fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/temp/old-data.csv" -f
+
+# Delete directory
+fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/" -f
+```
+
+## 4 - Table Operations
+
+### View Table Schema
+
+```bash
+# Get table schema
+fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo/customers"
+
+# View warehouse table schema
+fab table schema "DataPlatform.Workspace/SalesDW.Warehouse/Tables/sales/orders"
+```
+
+### Load Data into Table
+
+```bash
+# Load CSV files into table
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers"
+
+# Load with append mode
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/daily_sales.csv" \
+  --mode append
+
+# Load with overwrite
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dim_date" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/dimensions/date.parquet" \
+  --mode overwrite
+
+# Load with custom CSV format
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/products" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/csv/products" \
+  --format "format=csv,header=true,delimiter=|"
+
+# Load Parquet files
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/events" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/parquet/" \
+  --format format=parquet
+```
+
+### Optimize Table
+
+```bash
+# Basic optimization (compaction)
+fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions"
+
+# V-Order optimization (better compression)
+fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales" --vorder
+
+# Z-Order optimization (query performance)
+fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
+  --vorder --zorder customer_id,region
+
+# Optimize with multiple Z-Order columns
+fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/orders" \
+  --vorder --zorder order_date,customer_id,product_id
+```
+
+### Vacuum Table
+
+```bash
+# Vacuum with default retention (7 days)
+fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions"
+
+# Vacuum with custom retention (48 hours)
+fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/temp_data" \
+  --retain_n_hours 48
+
+# Vacuum with minimum retention (for testing)
+fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dev_table" \
+  --retain_n_hours 0
+```
+
+## 5 - Shortcuts (Data Federation)
+
+### Create Shortcuts
+
+Shortcuts enable data federation without copying data.
+
+```bash
+# List existing shortcuts
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/shortcuts"
+
+# Create shortcut to another lakehouse
+fab ln "Source.Workspace/SourceLH.Lakehouse/Tables/customers" \
+       "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers_ref"
+```
+
+### Shortcut Types
+
+| Source | Use Case |
+|--------|----------|
+| OneLake (another lakehouse) | Cross-workspace data sharing |
+| ADLS Gen2 | Azure Data Lake integration |
+| Amazon S3 | AWS data federation |
+| Google Cloud Storage | GCP data federation |
+| Dataverse | Power Platform integration |
+
+### Create ADLS Shortcut via API
+
+```bash
+WS_ID=$(fab get "DataPlatform.Workspace" -q "id" | tr -d '"')
+LH_ID=$(fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "external-data",
+  "path": "Files/external",
+  "target": {
+    "type": "AdlsGen2",
+    "adlsGen2": {
+      "location": "https://storageaccount.dfs.core.windows.net/container/path",
+      "subpath": "/data"
+    }
+  }
+}'
+```
+
+### List Shortcuts
+
+```bash
+# List all shortcuts in lakehouse
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts"
+```
+
+### Delete Shortcut
+
+```bash
+fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut-name"
+```
+
+## 6 - Medallion Architecture
+
+### Standard Structure
+
+```
+Workspace/
+├── Bronze.Lakehouse       # Raw data
+│   ├── Tables/
+│   │   └── raw_customers
+│   │   └── raw_orders
+│   └── Files/
+│       └── landing/
+├── Silver.Lakehouse       # Cleansed/conformed
+│   └── Tables/
+│       └── dim_customers
+│       └── fact_orders
+└── Gold.Lakehouse         # Business-ready
+    └── Tables/
+        └── sales_summary
+        └── customer_360
+```
+
+### Create Medallion Layers
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform"
+
+# Create workspace
+fab mkdir "$WORKSPACE.Workspace" -P capacityname=FabricProd
+
+# Create medallion lakehouses
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse"
+fab mkdir "$WORKSPACE.Workspace/Silver.Lakehouse"
+fab mkdir "$WORKSPACE.Workspace/Gold.Lakehouse"
+
+# Create file landing zone in Bronze
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/landing"
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/archive"
+
+echo "Medallion architecture created"
+```
+
+### Cross-Layer Shortcuts
+
+```bash
+# Create shortcut from Gold to Silver for lineage
+fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_customers" \
+       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_customers"
+```
+
+## 7 - Spark Job Execution
+
+### Run Notebook
+
+```bash
+# Run notebook synchronously
+fab job run "DataPlatform.Workspace/ETL.Notebook" --timeout 600
+
+# Run with parameters
+fab job run "DataPlatform.Workspace/ETL.Notebook" \
+  -P source_date:string=2024-01-15,batch_size:int=10000
+
+# Run with Spark configuration
+fab job run "DataPlatform.Workspace/LargeETL.Notebook" \
+  -C '{"conf": {"spark.executor.memory": "8g", "spark.executor.cores": "4"}}'
+
+# Run with specific lakehouse
+fab job run "DataPlatform.Workspace/Transform.Notebook" \
+  -C '{"defaultLakehouse": {"name": "Silver", "id": "<lakehouse-id>"}}'
+```
+
+### Run Spark Job Definition
+
+```bash
+# Run Spark job
+fab job run "DataPlatform.Workspace/DailyETL.SparkJobDefinition" --timeout 1800
+
+# Run with parameters
+fab job run "DataPlatform.Workspace/DailyETL.SparkJobDefinition" \
+  -P input_path:string=/data/raw,output_path:string=/data/processed
+```
+
+### Run Pipeline
+
+```bash
+# Run data pipeline
+fab job run "DataPlatform.Workspace/MasterPipeline.DataPipeline"
+
+# Run with complex parameters
+fab job run "DataPlatform.Workspace/ETLPipeline.DataPipeline" \
+  -P 'config:object={"source":"sql","target":"lakehouse"},tables:array=["customers","orders"]'
+```
+
+## 8 - Lakehouse Maintenance
+
+### Run Lakehouse Maintenance
+
+```bash
+# Trigger maintenance job (optimize + vacuum)
+fab job run "DataPlatform.Workspace/Bronze.Lakehouse" --timeout 1200
+```
+
+### Automated Maintenance Script
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform.Workspace"
+LAKEHOUSES=("Bronze" "Silver" "Gold")
+
+for LH in "${LAKEHOUSES[@]}"; do
+  echo "Optimizing $LH..."
+  
+  # Get all tables
+  TABLES=$(fab ls "$WORKSPACE/$LH.Lakehouse/Tables/dbo" -q "value[].name")
+  
+  for TABLE in $TABLES; do
+    echo "  Optimizing table: $TABLE"
+    fab table optimize "$WORKSPACE/$LH.Lakehouse/Tables/dbo/$TABLE" --vorder
+    fab table vacuum "$WORKSPACE/$LH.Lakehouse/Tables/dbo/$TABLE"
+  done
+done
+```
+
+## 9 - Environment Management
+
+### Spark Pool Configuration
+
+```bash
+# List workspace spark pools
+fab ls "DataPlatform.Workspace/.sparkpools"
+
+# Get spark pool details
+fab get "DataPlatform.Workspace/.sparkpools/HighMemory.SparkPool"
+```
+
+### Run Job with Workspace Pool
+
+```bash
+fab job run "DataPlatform.Workspace/HeavyETL.Notebook" \
+  -C '{"useStarterPool": false, "useWorkspacePool": "HighMemoryPool"}'
+```
+
+### Environment Configuration
+
+```bash
+# Get workspace environment settings
+fab get "DataPlatform.Workspace" -q "sparkSettings"
+
+# Update default Spark runtime
+fab set "DataPlatform.Workspace" -q sparkSettings.environment.runtimeVersion -i 1.3
+```
+
+## 10 - Data Pipeline Patterns
+
+### Daily ETL Pattern
+
+```bash
+#!/bin/bash
+DATE=$(date +%Y-%m-%d)
+WORKSPACE="DataPlatform.Workspace"
+
+# 1. Load raw data
+fab cp ./daily-data/$DATE/ "$WORKSPACE/Bronze.Lakehouse/Files/landing/$DATE/"
+
+# 2. Run bronze to silver transformation
+fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
+  -P process_date:string=$DATE --timeout 600
+
+# 3. Run silver to gold aggregation
+fab job run "$WORKSPACE/SilverToGold.Notebook" \
+  -P process_date:string=$DATE --timeout 300
+
+# 4. Optimize tables
+fab table optimize "$WORKSPACE/Gold.Lakehouse/Tables/daily_summary" --vorder
+
+echo "Daily ETL completed for $DATE"
+```
+
+### Incremental Load Pattern
+
+```bash
+#!/bin/bash
+# Get last processed watermark
+WATERMARK=$(fab api "workspaces/$WS_ID/lakehouses/$LH_ID/metadata" \
+  -q "properties.lastWatermark" | tr -d '"')
+
+# Run incremental notebook
+fab job run "DataPlatform.Workspace/IncrementalLoad.Notebook" \
+  -P watermark:string=$WATERMARK --timeout 600
+
+# Update watermark after success
+NEW_WATERMARK=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+# Store new watermark for next run
+```
+
+## 11 - Best Practices
+
+### Table Optimization Guidelines
+
+| Scenario | Recommendation |
+|----------|---------------|
+| Frequent small writes | V-Order optimization |
+| Point lookups | Z-Order on lookup columns |
+| Time-series data | Z-Order on date + partition columns |
+| Large aggregations | V-Order for compression |
+
+### File Organization
+
+```bash
+# Recommended file structure
+Bronze.Lakehouse/
+├── Files/
+│   ├── landing/          # Incoming raw data
+│   │   └── YYYY-MM-DD/   # Date partitioned
+│   ├── processing/       # In-progress transformations
+│   ├── archive/          # Processed files (compressed)
+│   └── error/            # Failed processing
+└── Tables/
+    └── raw_*             # Delta tables from loaded data
+```
+
+### Naming Conventions
+
+```bash
+# Lakehouses: Function-based
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse"
+fab mkdir "DataPlatform.Workspace/Silver.Lakehouse"
+fab mkdir "DataPlatform.Workspace/Gold.Lakehouse"
+
+# Tables: Prefix with layer
+# bronze: raw_customers, raw_orders
+# silver: dim_customers, fact_orders
+# gold: agg_sales, rpt_customer_summary
+```
+
+## 12 - References
+
+For detailed patterns, see:
+
+- [references/lakehouse-patterns.md](./references/lakehouse-patterns.md) — Lakehouse management
+- [references/medallion-architecture.md](./references/medallion-architecture.md) — Layer design patterns
+- [references/shortcuts.md](./references/shortcuts.md) — Data federation
+- [references/table-optimization.md](./references/table-optimization.md) — Performance tuning
+- [references/spark-configuration.md](./references/spark-configuration.md) — Spark settings
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md b/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
new file mode 100644
index 000000000..03ee9a6ab
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
@@ -0,0 +1,315 @@
+# Lakehouse Patterns Reference
+
+Comprehensive guide to lakehouse creation, management, and best practices.
+
+## Creating Lakehouses
+
+### Basic Creation
+
+```bash
+# Create lakehouse
+fab mkdir "DataPlatform.Workspace/Analytics.Lakehouse"
+
+# Verify creation
+fab exists "DataPlatform.Workspace/Analytics.Lakehouse"
+fab get "DataPlatform.Workspace/Analytics.Lakehouse" -v
+```
+
+### Schema-Enabled Lakehouse
+
+```bash
+# Enable schemas for better organization (preview)
+fab mkdir "DataPlatform.Workspace/Enterprise.Lakehouse" -P enableSchemas=true
+
+# With schemas, you can organize tables:
+# Tables/sales/orders
+# Tables/sales/customers
+# Tables/finance/invoices
+```
+
+### Check Creation Parameters
+
+```bash
+# See available parameters
+fab mkdir "Item.Lakehouse" -P
+```
+
+## Lakehouse Structure
+
+### Default Layout
+
+```
+Lakehouse/
+├── Tables/           # Delta tables
+│   └── dbo/         # Default schema
+│       ├── customers
+│       └── orders
+└── Files/           # Raw/unmanaged files
+    ├── raw/
+    ├── staging/
+    └── processed/
+```
+
+### With Schemas Enabled
+
+```
+Lakehouse/
+├── Tables/
+│   ├── sales/
+│   │   ├── customers
+│   │   └── orders
+│   ├── finance/
+│   │   ├── invoices
+│   │   └── payments
+│   └── staging/
+│       └── temp_data
+└── Files/
+```
+
+## File Operations
+
+### Upload Files
+
+```bash
+# Single file
+fab cp ./data/customers.csv "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers.csv"
+
+# Directory (recursive)
+fab cp ./data/sales/ "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales/"
+
+# Overwrite existing
+fab cp ./data/updated.parquet "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/data.parquet" -f
+```
+
+### Download Files
+
+```bash
+# Download single file
+fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/exports/report.csv" ./local/
+
+# Download directory
+fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" ./backup/
+```
+
+### List Files
+
+```bash
+# List lakehouse root
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse"
+
+# List files with details
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files" -l
+
+# List nested directory
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales" -l
+```
+
+### Organize Files
+
+```bash
+# Create directory structure
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/landing"
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/processing"
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive"
+fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/error"
+
+# Move processed files
+fab mv "DataPlatform.Workspace/Bronze.Lakehouse/Files/landing/2024-01-15/" \
+       "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/"
+
+# Delete old files
+fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/2023-*" -f
+```
+
+## Table Management
+
+### List Tables
+
+```bash
+# List all tables
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables"
+
+# List tables in schema
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo"
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales"
+```
+
+### Get Table Schema
+
+```bash
+# View table columns and types
+fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo/customers"
+```
+
+### Load Data into Tables
+
+```bash
+# From CSV folder
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers"
+
+# From Parquet files
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/events" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/events" \
+  --format format=parquet
+
+# Append mode
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/daily/2024-01-15.parquet" \
+  --mode append
+
+# Overwrite mode
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dim_date" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/dimensions/date.csv" \
+  --mode overwrite
+
+# Custom CSV format
+fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/legacy_data" \
+  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/legacy/" \
+  --format "format=csv,header=false,delimiter=|,encoding=UTF-8"
+```
+
+## SQL Analytics Endpoint
+
+### Get Connection Info
+
+```bash
+# Get SQL endpoint details
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties"
+
+# Get connection string
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.connectionString"
+```
+
+### Query via API
+
+```bash
+WS_ID=$(fab get "DataPlatform.Workspace" -q "id" | tr -d '"')
+LH_ID=$(fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "id" | tr -d '"')
+
+# Execute SQL query
+fab api -X post "workspaces/$WS_ID/lakehouses/$LH_ID/jobs/instances?jobType=TableMaintenance" -i '{}'
+```
+
+## Lakehouse Properties
+
+### Get All Properties
+
+```bash
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -v
+```
+
+### Important Properties
+
+```bash
+# OneLake paths
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeFilesPath"
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeTablesPath"
+
+# SQL endpoint
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.id"
+
+# Default schema
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.defaultSchema"
+```
+
+## Cross-Lakehouse Operations
+
+### Copy Between Lakehouses
+
+```bash
+# Copy file
+fab cp "Source.Workspace/SourceLH.Lakehouse/Files/data.parquet" \
+       "Target.Workspace/TargetLH.Lakehouse/Files/imported/"
+
+# Note: For tables, use export/import or shortcuts
+```
+
+### Export Lakehouse
+
+```bash
+# Export lakehouse definition
+fab export "DataPlatform.Workspace/Bronze.Lakehouse" -o ./backup/ -f
+```
+
+## Best Practices
+
+### File Organization
+
+```bash
+# Recommended structure
+Files/
+├── landing/              # Incoming raw data
+│   └── source_system/
+│       └── YYYY-MM-DD/
+├── processing/           # Active transformation work
+├── staging/              # Intermediate results
+├── archive/              # Processed files (compressed)
+│   └── YYYY/
+│       └── MM/
+└── error/                # Failed processing
+```
+
+### Table Naming
+
+```bash
+# Use consistent prefixes
+# raw_* for raw data tables
+# stg_* for staging tables
+# dim_* for dimension tables
+# fact_* for fact tables
+# agg_* for aggregated tables
+```
+
+### Maintenance Schedule
+
+```bash
+#!/bin/bash
+# Weekly maintenance script
+WORKSPACE="DataPlatform.Workspace"
+LAKEHOUSE="Bronze.Lakehouse"
+
+# Optimize all tables
+for TABLE in $(fab ls "$WORKSPACE/$LAKEHOUSE/Tables/dbo" -q "value[].name"); do
+  echo "Maintaining $TABLE..."
+  fab table optimize "$WORKSPACE/$LAKEHOUSE/Tables/dbo/$TABLE" --vorder
+  fab table vacuum "$WORKSPACE/$LAKEHOUSE/Tables/dbo/$TABLE" --retain_n_hours 168
+done
+
+# Archive old files
+ARCHIVE_DATE=$(date -d "30 days ago" +%Y-%m-%d)
+fab mv "$WORKSPACE/$LAKEHOUSE/Files/processed/*" \
+       "$WORKSPACE/$LAKEHOUSE/Files/archive/"
+```
+
+## Troubleshooting
+
+### Table Load Failures
+
+```bash
+# Check file format matches expected
+fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" -l
+
+# Verify file is accessible
+fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/test.csv" ./test.csv
+
+# Check for schema conflicts
+fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/target"
+```
+
+### Permission Issues
+
+```bash
+# Verify workspace access
+fab acl get "DataPlatform.Workspace"
+
+# Need Contributor role for write operations
+```
+
+### SQL Endpoint Not Available
+
+```bash
+# SQL endpoint may take time to provision
+# Check status
+fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.provisioningStatus"
+```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md b/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
new file mode 100644
index 000000000..ab4764699
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
@@ -0,0 +1,365 @@
+# Medallion Architecture Reference
+
+Guide to implementing bronze/silver/gold data layers using the Fabric CLI.
+
+## Architecture Overview
+
+```
+┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+│   BRONZE    │ -> │   SILVER    │ -> │    GOLD     │
+│  Raw Data   │    │  Cleansed   │    │  Business   │
+│  As-Is     │    │  Conformed  │    │   Ready     │
+└─────────────┘    └─────────────┘    └─────────────┘
+```
+
+### Layer Purposes
+
+| Layer | Purpose | Data Quality | Consumers |
+|-------|---------|--------------|-----------|
+| Bronze | Raw ingestion | As-is from source | Data engineers |
+| Silver | Cleansed, validated | Standardized types, deduped | Data scientists, analysts |
+| Gold | Business-ready | Aggregated, denormalized | Business users, reports |
+
+## Creating the Architecture
+
+### Full Setup Script
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform"
+CAPACITY="FabricProd"
+
+# Create workspace on capacity
+fab mkdir "$WORKSPACE.Workspace" -P capacityname=$CAPACITY
+
+# Create medallion lakehouses
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse"
+fab mkdir "$WORKSPACE.Workspace/Silver.Lakehouse"
+fab mkdir "$WORKSPACE.Workspace/Gold.Lakehouse"
+
+# Create file landing zones in Bronze
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/landing"
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/processing"
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/archive"
+fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/error"
+
+# Optionally create staging area
+fab mkdir "$WORKSPACE.Workspace/Staging.Lakehouse"
+
+# Create warehouse for SQL-based gold access
+fab mkdir "$WORKSPACE.Workspace/Analytics.Warehouse"
+
+echo "Medallion architecture created in $WORKSPACE"
+```
+
+## Bronze Layer Patterns
+
+### Purpose
+
+- Store raw data exactly as received
+- Preserve original schema and format
+- Enable data replay/reprocessing
+- Audit trail of source data
+
+### Structure
+
+```
+Bronze.Lakehouse/
+├── Tables/
+│   └── dbo/
+│       ├── raw_customers       # CDC from source
+│       ├── raw_orders          # Daily extract
+│       ├── raw_products        # API feed
+│       └── raw_events          # Streaming data
+└── Files/
+    ├── landing/
+    │   ├── crm/               # Source system folders
+    │   │   └── 2024-01-15/
+    │   ├── erp/
+    │   └── web/
+    ├── processing/            # Active work
+    ├── archive/               # Processed files
+    └── error/                 # Failed files
+```
+
+### Bronze Ingestion Pattern
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform.Workspace"
+DATE=$(date +%Y-%m-%d)
+SOURCE="crm"
+
+# 1. Upload raw files to landing
+fab cp ./incoming/$SOURCE/* \
+  "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/"
+
+# 2. Load into raw table (append)
+fab table load "$WORKSPACE/Bronze.Lakehouse/Tables/raw_customers" \
+  --file "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/" \
+  --mode append \
+  --format format=parquet
+
+# 3. Archive processed files
+fab mv "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/" \
+       "$WORKSPACE/Bronze.Lakehouse/Files/archive/$SOURCE/$DATE/"
+
+echo "Bronze ingestion complete for $SOURCE on $DATE"
+```
+
+### Bronze Table Naming
+
+```bash
+# Prefix: raw_
+# Include source system if multiple
+raw_crm_customers
+raw_erp_orders
+raw_web_events
+raw_api_products
+```
+
+## Silver Layer Patterns
+
+### Purpose
+
+- Clean and validate data
+- Apply business rules
+- Standardize data types
+- Deduplicate records
+- Create conformed dimensions
+
+### Structure
+
+```
+Silver.Lakehouse/
+├── Tables/
+│   └── dbo/
+│       ├── dim_customer       # Cleansed dimension
+│       ├── dim_product
+│       ├── dim_date
+│       ├── fact_orders        # Validated facts
+│       └── fact_inventory
+└── Files/
+    └── temp/                  # Processing workspace
+```
+
+### Bronze to Silver Transformation
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform.Workspace"
+
+# Run transformation notebook
+fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
+  -P source_table:string=raw_customers,target_table:string=dim_customer \
+  --timeout 600
+
+# Optimize silver table
+fab table optimize "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" --vorder
+```
+
+### Silver Table Naming
+
+```bash
+# Dimensions: dim_
+dim_customer
+dim_product
+dim_date
+dim_location
+
+# Facts: fact_
+fact_orders
+fact_inventory
+fact_shipments
+
+# Staging: stg_
+stg_customer_dedup
+stg_orders_validated
+```
+
+## Gold Layer Patterns
+
+### Purpose
+
+- Business-ready aggregations
+- Denormalized for reporting
+- Pre-computed metrics
+- Domain-specific views
+
+### Structure
+
+```
+Gold.Lakehouse/
+└── Tables/
+    └── dbo/
+        ├── sales_summary          # Daily/weekly aggregates
+        ├── customer_360           # Customer analytics
+        ├── product_performance    # Product metrics
+        └── executive_dashboard    # KPI aggregates
+```
+
+### Silver to Gold Aggregation
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform.Workspace"
+
+# Run aggregation notebook
+fab job run "$WORKSPACE/SilverToGold.Notebook" --timeout 300
+
+# Optimize gold tables for queries
+fab table optimize "$WORKSPACE/Gold.Lakehouse/Tables/sales_summary" \
+  --vorder --zorder report_date,region
+```
+
+### Gold Table Naming
+
+```bash
+# Aggregated: agg_
+agg_daily_sales
+agg_monthly_revenue
+
+# Reports: rpt_
+rpt_customer_summary
+rpt_product_performance
+
+# Analytics: anlyt_
+anlyt_customer_360
+anlyt_churn_prediction
+```
+
+## Cross-Layer Data Flow
+
+### Using Shortcuts for Reference
+
+```bash
+# Share silver dimensions with gold layer
+fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" \
+       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_customer"
+
+fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_product" \
+       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_product"
+
+fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_date" \
+       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_date"
+```
+
+### End-to-End Pipeline
+
+```bash
+#!/bin/bash
+WORKSPACE="DataPlatform.Workspace"
+DATE=$(date +%Y-%m-%d)
+
+echo "=== Starting ETL Pipeline for $DATE ==="
+
+# Step 1: Ingest to Bronze
+echo "Step 1: Bronze Ingestion"
+fab job run "$WORKSPACE/IngestToBronze.DataPipeline" \
+  -P process_date:string=$DATE --timeout 600
+echo "Bronze complete"
+
+# Step 2: Transform to Silver
+echo "Step 2: Silver Transformation"
+fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
+  -P process_date:string=$DATE --timeout 900
+echo "Silver complete"
+
+# Step 3: Aggregate to Gold
+echo "Step 3: Gold Aggregation"
+fab job run "$WORKSPACE/SilverToGold.Notebook" \
+  -P process_date:string=$DATE --timeout 300
+echo "Gold complete"
+
+# Step 4: Optimize tables
+echo "Step 4: Table Optimization"
+for LAYER in Bronze Silver Gold; do
+  fab job run "$WORKSPACE/$LAYER.Lakehouse" --timeout 600
+done
+echo "Optimization complete"
+
+echo "=== ETL Pipeline Complete ==="
+```
+
+## Best Practices
+
+### Layer Isolation
+
+```bash
+# Separate permissions per layer
+# Bronze: Data Engineers only
+fab acl set "$WORKSPACE/Bronze.Lakehouse" -P principal=DataEngineers@company.com,role=Contributor
+
+# Silver: Data Engineers + Scientists
+fab acl set "$WORKSPACE/Silver.Lakehouse" -P principal=DataScientists@company.com,role=Viewer
+
+# Gold: All analysts
+fab acl set "$WORKSPACE/Gold.Lakehouse" -P principal=AllAnalysts@company.com,role=Viewer
+```
+
+### Data Quality Checkpoints
+
+```bash
+# Add validation between layers
+# Run quality checks notebook
+fab job run "$WORKSPACE/DataQuality.Notebook" \
+  -P layer:string=bronze,tables:array=["raw_customers","raw_orders"]
+```
+
+### Retention Policies
+
+```bash
+# Bronze: Keep all data (history)
+# No vacuum or aggressive retention
+
+# Silver: Moderate retention
+fab table vacuum "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" \
+  --retain_n_hours 720  # 30 days
+
+# Gold: Short retention (current data)
+fab table vacuum "$WORKSPACE/Gold.Lakehouse/Tables/agg_daily_sales" \
+  --retain_n_hours 168  # 7 days
+```
+
+## Multi-Workspace Pattern
+
+For large organizations, consider separate workspaces:
+
+```bash
+# Create workspace per layer
+fab mkdir "DataPlatform-Bronze.Workspace" -P capacityname=FabricProd
+fab mkdir "DataPlatform-Silver.Workspace" -P capacityname=FabricProd
+fab mkdir "DataPlatform-Gold.Workspace" -P capacityname=FabricProd
+
+# Create lakehouses in each
+fab mkdir "DataPlatform-Bronze.Workspace/Bronze.Lakehouse"
+fab mkdir "DataPlatform-Silver.Workspace/Silver.Lakehouse"
+fab mkdir "DataPlatform-Gold.Workspace/Gold.Lakehouse"
+
+# Use shortcuts for cross-workspace access
+fab ln "DataPlatform-Silver.Workspace/Silver.Lakehouse/Tables/dbo/dim_customer" \
+       "DataPlatform-Gold.Workspace/Gold.Lakehouse/Tables/dbo/dim_customer"
+```
+
+## Troubleshooting
+
+### Data Freshness Issues
+
+```bash
+# Check last load time for tables
+fab get "$WORKSPACE/Silver.Lakehouse" -q "properties.lastModifiedDateTime"
+
+# Check job history
+fab job run-list "$WORKSPACE/BronzeToSilver.Notebook"
+```
+
+### Schema Drift
+
+```bash
+# Compare schemas between layers
+fab table schema "$WORKSPACE/Bronze.Lakehouse/Tables/raw_customers"
+fab table schema "$WORKSPACE/Silver.Lakehouse/Tables/dim_customer"
+
+# Run schema evolution notebook
+fab job run "$WORKSPACE/SchemaEvolution.Notebook" -P table:string=customers
+```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md b/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
new file mode 100644
index 000000000..327990cc5
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
@@ -0,0 +1,353 @@
+# Shortcuts Reference
+
+Guide to creating and managing OneLake shortcuts for data federation.
+
+## Understanding Shortcuts
+
+Shortcuts provide virtualized access to data without copying:
+
+- **Zero data movement** — Reference data in place
+- **Real-time access** — Always see current data
+- **Cross-cloud** — Connect ADLS, S3, GCS
+- **Cross-workspace** — Share data across Fabric
+
+## Shortcut Types
+
+| Source | Type | Use Case |
+|--------|------|----------|
+| OneLake | Internal | Cross-workspace sharing |
+| ADLS Gen2 | External | Azure Data Lake integration |
+| Amazon S3 | External | AWS data federation |
+| Google Cloud Storage | External | GCP data federation |
+| Dataverse | External | Power Platform data |
+| On-premises | Via Gateway | Legacy systems |
+
+## Creating Shortcuts
+
+### OneLake Shortcut (CLI)
+
+```bash
+# Create shortcut to another lakehouse table
+fab ln "Source.Workspace/SourceLH.Lakehouse/Tables/customers" \
+       "Target.Workspace/TargetLH.Lakehouse/Tables/customers_ref"
+
+# Create shortcut to files
+fab ln "Source.Workspace/SourceLH.Lakehouse/Files/data" \
+       "Target.Workspace/TargetLH.Lakehouse/Files/external_data"
+```
+
+### OneLake Shortcut (API)
+
+```bash
+WS_ID=$(fab get "Target.Workspace" -q "id" | tr -d '"')
+LH_ID=$(fab get "Target.Workspace/Target.Lakehouse" -q "id" | tr -d '"')
+
+# Get source IDs
+SOURCE_WS_ID=$(fab get "Source.Workspace" -q "id" | tr -d '"')
+SOURCE_LH_ID=$(fab get "Source.Workspace/Source.Lakehouse" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i "{
+  \"name\": \"customer_data\",
+  \"path\": \"Tables/customer_data\",
+  \"target\": {
+    \"type\": \"OneLake\",
+    \"oneLake\": {
+      \"workspaceId\": \"$SOURCE_WS_ID\",
+      \"itemId\": \"$SOURCE_LH_ID\",
+      \"path\": \"Tables/customers\"
+    }
+  }
+}"
+```
+
+### ADLS Gen2 Shortcut
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "azure_storage",
+  "path": "Files/azure_data",
+  "target": {
+    "type": "AdlsGen2",
+    "adlsGen2": {
+      "location": "https://mystorageaccount.dfs.core.windows.net/container",
+      "subpath": "/data/sales",
+      "connectionId": "<connection-id>"
+    }
+  }
+}'
+```
+
+### Amazon S3 Shortcut
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "s3_data",
+  "path": "Files/aws_data",
+  "target": {
+    "type": "AmazonS3",
+    "amazonS3": {
+      "location": "https://mybucket.s3.amazonaws.com",
+      "subpath": "/data/analytics",
+      "connectionId": "<s3-connection-id>"
+    }
+  }
+}'
+```
+
+### Google Cloud Storage Shortcut
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "gcs_data",
+  "path": "Files/gcp_data",
+  "target": {
+    "type": "GoogleCloudStorage",
+    "googleCloudStorage": {
+      "location": "https://storage.cloud.google.com/my-bucket",
+      "subpath": "/data",
+      "connectionId": "<gcs-connection-id>"
+    }
+  }
+}'
+```
+
+## Managing Shortcuts
+
+### List Shortcuts
+
+```bash
+# List all shortcuts in lakehouse
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts"
+
+# List with details
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts" -q "value[].{name: name, path: path, type: target.type}"
+```
+
+### Get Shortcut Details
+
+```bash
+# Get specific shortcut
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/customer_data"
+```
+
+### Delete Shortcut
+
+```bash
+# Delete by name
+fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/customer_data"
+```
+
+### Update Shortcut
+
+```bash
+# Shortcuts cannot be updated - delete and recreate
+fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/old_shortcut"
+
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "new_shortcut",
+  "path": "...",
+  "target": {...}
+}'
+```
+
+## Connection Management
+
+### List Connections
+
+```bash
+# List all connections (for shortcut targets)
+fab ls .connections -l
+
+# Get connection details
+fab get ".connections/AzureStorageConn.Connection"
+
+# Get connection ID for shortcut
+CONNECTION_ID=$(fab get ".connections/AzureStorageConn.Connection" -q "id" | tr -d '"')
+```
+
+### Create Connection for ADLS
+
+```bash
+fab api -X post "connections" -i '{
+  "displayName": "AzureStorageConn",
+  "connectionDetails": {
+    "type": "AzureDataLakeStorageGen2",
+    "parameters": {
+      "server": "mystorageaccount.dfs.core.windows.net",
+      "path": "container"
+    }
+  },
+  "credentialDetails": {
+    "credentialType": "ManagedIdentity"
+  }
+}'
+```
+
+## Use Cases
+
+### Cross-Workspace Data Sharing
+
+```bash
+#!/bin/bash
+# Share gold layer tables with consumer workspaces
+
+SOURCE_WS="DataPlatform.Workspace"
+SOURCE_LH="Gold.Lakehouse"
+
+# Consumer workspace setup
+for CONSUMER in "Marketing" "Sales" "Finance"; do
+  TARGET_WS="$CONSUMER.Workspace"
+  TARGET_LH="Analytics.Lakehouse"
+  
+  WS_ID=$(fab get "$TARGET_WS" -q "id" | tr -d '"')
+  LH_ID=$(fab get "$TARGET_WS/$TARGET_LH" -q "id" | tr -d '"')
+  SOURCE_WS_ID=$(fab get "$SOURCE_WS" -q "id" | tr -d '"')
+  SOURCE_LH_ID=$(fab get "$SOURCE_WS/$SOURCE_LH" -q "id" | tr -d '"')
+  
+  # Create shortcuts to gold tables
+  for TABLE in "sales_summary" "customer_360" "product_metrics"; do
+    fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i "{
+      \"name\": \"$TABLE\",
+      \"path\": \"Tables/$TABLE\",
+      \"target\": {
+        \"type\": \"OneLake\",
+        \"oneLake\": {
+          \"workspaceId\": \"$SOURCE_WS_ID\",
+          \"itemId\": \"$SOURCE_LH_ID\",
+          \"path\": \"Tables/$TABLE\"
+        }
+      }
+    }"
+    echo "Created shortcut to $TABLE in $CONSUMER workspace"
+  done
+done
+```
+
+### Multi-Cloud Data Lake
+
+```bash
+#!/bin/bash
+# Federate data from multiple clouds
+
+WS_ID=$(fab get "DataHub.Workspace" -q "id" | tr -d '"')
+LH_ID=$(fab get "DataHub.Workspace/Federation.Lakehouse" -q "id" | tr -d '"')
+
+# Azure Data Lake
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "azure_data",
+  "path": "Files/azure",
+  "target": {
+    "type": "AdlsGen2",
+    "adlsGen2": {
+      "location": "https://azurestorage.dfs.core.windows.net/datalake",
+      "subpath": "/production",
+      "connectionId": "<azure-conn-id>"
+    }
+  }
+}'
+
+# AWS S3
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "aws_data",
+  "path": "Files/aws",
+  "target": {
+    "type": "AmazonS3",
+    "amazonS3": {
+      "location": "https://company-bucket.s3.amazonaws.com",
+      "subpath": "/analytics",
+      "connectionId": "<s3-conn-id>"
+    }
+  }
+}'
+
+# Google Cloud Storage
+fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
+  "name": "gcp_data",
+  "path": "Files/gcp",
+  "target": {
+    "type": "GoogleCloudStorage",
+    "googleCloudStorage": {
+      "location": "https://storage.cloud.google.com/company-bucket",
+      "subpath": "/data",
+      "connectionId": "<gcs-conn-id>"
+    }
+  }
+}'
+```
+
+### Medallion Layer References
+
+```bash
+# Silver layer references bronze shortcuts for lineage
+fab ln "DataPlatform.Workspace/Bronze.Lakehouse/Tables/raw_customers" \
+       "DataPlatform.Workspace/Silver.Lakehouse/Tables/source_customers"
+
+# Gold layer references silver dimensions
+fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_customer" \
+       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_customer"
+
+fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_product" \
+       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_product"
+```
+
+## Best Practices
+
+### Naming Conventions
+
+```bash
+# Prefix by source type
+ext_azure_sales       # External Azure shortcut
+ext_s3_events         # External S3 shortcut
+ref_silver_customers  # Reference to silver layer
+shared_gold_summary   # Shared from gold layer
+```
+
+### Security Considerations
+
+- Shortcuts inherit permissions from target
+- Users need both shortcut and target access
+- Use workspace roles for access control
+- Connection credentials are managed separately
+
+### Performance Tips
+
+- Shortcuts add minimal latency
+- External shortcuts depend on network
+- Use OneLake shortcuts for best performance
+- Consider data locality for external sources
+
+## Troubleshooting
+
+### Shortcut Not Accessible
+
+```bash
+# Check shortcut exists
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut_name"
+
+# Verify connection is valid
+fab get ".connections/ConnectionName.Connection"
+
+# Check permissions on source
+fab acl get "Source.Workspace/Source.Lakehouse"
+```
+
+### Data Not Visible
+
+```bash
+# Verify source path exists
+fab ls "Source.Workspace/Source.Lakehouse/Tables/tablename"
+
+# Check shortcut path
+fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut_name" -q "target.path"
+```
+
+### External Source Errors
+
+```bash
+# Verify connection credentials
+fab get ".connections/AzureConn.Connection" -q "credentialDetails"
+
+# Check network connectivity
+# For ADLS: Verify storage account firewall settings
+# For S3: Verify IAM permissions and bucket policy
+```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md b/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
new file mode 100644
index 000000000..f9a7b667f
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
@@ -0,0 +1,398 @@
+# Spark Configuration Reference
+
+Guide to managing Spark pools, environments, and configurations in Fabric.
+
+## Spark Pools Overview
+
+Fabric Spark pools provide managed compute for notebooks and jobs:
+
+| Pool Type | Use Case | Configuration |
+|-----------|----------|---------------|
+| Starter Pool | Development | Pre-warmed, shared |
+| Custom Pool | Production | Dedicated, configurable |
+| High Concurrency | Multi-user | Session sharing |
+
+## Managing Spark Pools
+
+### List Spark Pools
+
+```bash
+# List all Spark pools in workspace
+fab ls "Workspace/.sparkpools"
+
+# List with details
+fab ls "Workspace/.sparkpools" -l
+
+# Get pool configuration
+fab get "Workspace/.sparkpools/MyPool.SparkPool"
+```
+
+### Create Spark Pool (via API)
+
+```bash
+WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/sparkPools" -i '{
+  "name": "DataEngineeringPool",
+  "nodeFamily": "MemoryOptimized",
+  "nodeSize": "Large",
+  "autoScale": {
+    "enabled": true,
+    "minNodeCount": 1,
+    "maxNodeCount": 10
+  },
+  "dynamicExecutorAllocation": {
+    "enabled": true,
+    "minExecutors": 1,
+    "maxExecutors": 8
+  }
+}'
+```
+
+### Update Spark Pool
+
+```bash
+# Get pool ID
+POOL_ID=$(fab get "Workspace/.sparkpools/MyPool.SparkPool" -q "id" | tr -d '"')
+
+# Update auto-scale settings
+fab api -X patch "workspaces/$WS_ID/sparkPools/$POOL_ID" -i '{
+  "autoScale": {
+    "enabled": true,
+    "minNodeCount": 2,
+    "maxNodeCount": 20
+  }
+}'
+```
+
+### Delete Spark Pool
+
+```bash
+fab api -X delete "workspaces/$WS_ID/sparkPools/$POOL_ID"
+```
+
+## Spark Environments
+
+### List Environments
+
+```bash
+# List all environments
+fab ls "Workspace/.environments"
+
+# Get environment details
+fab get "Workspace/.environments/DataEng.SparkEnvironment"
+```
+
+### Create Environment
+
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "DataEngEnvironment",
+  "type": "SparkEnvironment"
+}'
+```
+
+### Configure Environment Libraries
+
+```bash
+# Get environment ID
+ENV_ID=$(fab get "Workspace/.environments/DataEng.SparkEnvironment" -q "id" | tr -d '"')
+
+# Add Python libraries via staging
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
+  "pythonLibraries": {
+    "packages": [
+      {"name": "pandas", "version": "2.0.0"},
+      {"name": "pyarrow", "version": "14.0.0"},
+      {"name": "great-expectations", "version": "0.17.0"}
+    ]
+  }
+}'
+
+# Publish environment changes
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/publish"
+```
+
+## Spark Configuration Properties
+
+### Session-Level Configuration
+
+```python
+# Configure Spark session in notebook
+spark.conf.set("spark.sql.shuffle.partitions", "200")
+spark.conf.set("spark.sql.files.maxPartitionBytes", "134217728")
+spark.conf.set("spark.databricks.delta.optimizeWrite.enabled", "true")
+spark.conf.set("spark.databricks.delta.autoCompact.enabled", "true")
+```
+
+### Common Configuration Properties
+
+| Property | Default | Description |
+|----------|---------|-------------|
+| `spark.sql.shuffle.partitions` | 200 | Shuffle partition count |
+| `spark.sql.files.maxPartitionBytes` | 128 MB | Max partition size |
+| `spark.databricks.delta.optimizeWrite.enabled` | false | Auto-optimize writes |
+| `spark.databricks.delta.autoCompact.enabled` | false | Auto-compact small files |
+| `spark.sql.adaptive.enabled` | true | Adaptive query execution |
+
+### Environment-Level Configuration
+
+```bash
+# Add Spark properties to environment
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/sparkSettings" -i '{
+  "sparkProperties": {
+    "spark.sql.shuffle.partitions": "400",
+    "spark.sql.files.maxPartitionBytes": "268435456",
+    "spark.databricks.delta.optimizeWrite.enabled": "true"
+  }
+}'
+
+# Publish changes
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/publish"
+```
+
+## Pool Sizing Guidelines
+
+### Node Sizes
+
+| Size | Memory | Cores | Use Case |
+|------|--------|-------|----------|
+| Small | 8 GB | 4 | Development |
+| Medium | 16 GB | 8 | Standard workloads |
+| Large | 32 GB | 16 | Large datasets |
+| X-Large | 64 GB | 32 | Heavy processing |
+| XX-Large | 128 GB | 64 | Memory-intensive |
+
+### Right-Sizing Recommendations
+
+```bash
+# Check job history for sizing insights
+fab job list "Workspace/Notebook" -l
+
+# Review execution metrics
+NOTEBOOK_ID=$(fab get "Workspace/Notebook" -q "id" | tr -d '"')
+fab api "workspaces/$WS_ID/items/$NOTEBOOK_ID/jobs" -q "value[0].executionData"
+```
+
+## Attaching Pools and Environments
+
+### Set Default Pool
+
+```bash
+# Update workspace default compute
+fab api -X patch "workspaces/$WS_ID/sparkSettings" -i '{
+  "defaultPool": {
+    "type": "Workspace",
+    "name": "DataEngineeringPool"
+  }
+}'
+```
+
+### Attach Environment to Notebook
+
+```bash
+# Via notebook definition update
+NB_ID=$(fab get "Workspace/Notebook" -q "id" | tr -d '"')
+
+fab api -X patch "workspaces/$WS_ID/items/$NB_ID" -i '{
+  "definition": {
+    "environmentId": "<env-id>"
+  }
+}'
+```
+
+## Dynamic Resource Allocation
+
+### Enable Dynamic Allocation
+
+```python
+# In notebook
+spark.conf.set("spark.dynamicAllocation.enabled", "true")
+spark.conf.set("spark.dynamicAllocation.minExecutors", "1")
+spark.conf.set("spark.dynamicAllocation.maxExecutors", "10")
+spark.conf.set("spark.dynamicAllocation.initialExecutors", "2")
+```
+
+### Auto-Scale Configuration
+
+```bash
+# Create pool with auto-scale
+fab api -X post "workspaces/$WS_ID/sparkPools" -i '{
+  "name": "AutoScalePool",
+  "nodeSize": "Medium",
+  "autoScale": {
+    "enabled": true,
+    "minNodeCount": 1,
+    "maxNodeCount": 50
+  }
+}'
+```
+
+## Library Management
+
+### Python Libraries
+
+```bash
+# Add PyPI packages
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
+  "pythonLibraries": {
+    "packages": [
+      {"name": "delta-spark", "version": "3.0.0"},
+      {"name": "azure-storage-blob"},
+      {"name": "pyspark-test"}
+    ]
+  }
+}'
+```
+
+### Custom Wheels
+
+```bash
+# Upload custom wheel first
+fab cp "./custom_lib-1.0.0-py3-none-any.whl" \
+       "Workspace/.environments/MyEnv.SparkEnvironment/libraries/"
+
+# Add to environment
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
+  "pythonLibraries": {
+    "wheelFiles": [
+      {"path": "abfss://.../.environments/MyEnv/libraries/custom_lib-1.0.0-py3-none-any.whl"}
+    ]
+  }
+}'
+```
+
+### JAR Libraries
+
+```bash
+# Add Spark/Scala libraries
+fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
+  "jarLibraries": [
+    {"path": "abfss://.../.environments/MyEnv/libraries/custom-udf.jar"}
+  ]
+}'
+```
+
+## Performance Optimization
+
+### Adaptive Query Execution
+
+```python
+# Enable AQE features
+spark.conf.set("spark.sql.adaptive.enabled", "true")
+spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")
+spark.conf.set("spark.sql.adaptive.skewJoin.enabled", "true")
+spark.conf.set("spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes", "256MB")
+```
+
+### Broadcast Join Optimization
+
+```python
+# Configure broadcast threshold
+spark.conf.set("spark.sql.autoBroadcastJoinThreshold", "104857600")  # 100 MB
+
+# Force broadcast hint
+df = spark.sql("""
+    SELECT /*+ BROADCAST(dim_customer) */ 
+           f.*, d.customer_name
+    FROM fact_sales f
+    JOIN dim_customer d ON f.customer_id = d.customer_id
+""")
+```
+
+### Delta Lake Optimizations
+
+```python
+# Enable Delta optimizations
+spark.conf.set("spark.databricks.delta.optimizeWrite.enabled", "true")
+spark.conf.set("spark.databricks.delta.autoCompact.enabled", "true")
+spark.conf.set("spark.databricks.delta.properties.defaults.enableChangeDataFeed", "true")
+```
+
+## Monitoring and Diagnostics
+
+### View Spark UI Metrics
+
+```bash
+# Get active sessions
+fab api "workspaces/$WS_ID/sparkPools/$POOL_ID/sparkSessions"
+
+# Get session details
+fab api "workspaces/$WS_ID/sparkPools/$POOL_ID/sparkSessions/$SESSION_ID/statements"
+```
+
+### Job Execution History
+
+```bash
+# List recent job runs
+fab job list "Workspace/Notebook" -q "[].{status: status, start: startTime, end: endTime}"
+
+# Get specific job details
+fab job get "Workspace/Notebook" "<job-id>"
+```
+
+## Best Practices
+
+### Development vs Production
+
+| Setting | Development | Production |
+|---------|-------------|------------|
+| Pool Size | Small/Medium | Large/X-Large |
+| Auto-Scale Min | 1 | 2-3 |
+| Auto-Scale Max | 5 | 20-50 |
+| Shuffle Partitions | 200 | 400-800 |
+| Dynamic Allocation | Enabled | Enabled |
+
+### Cost Optimization
+
+- Use starter pools for development
+- Enable auto-scale with appropriate min/max
+- Configure session timeouts
+- Use appropriate node sizes for workload
+- Monitor and right-size based on utilization
+
+### Environment Management
+
+- Separate environments by workload type
+- Version control environment definitions
+- Test library updates in dev first
+- Document required dependencies
+- Use consistent library versions across environments
+
+## Troubleshooting
+
+### Out of Memory Errors
+
+```python
+# Increase driver memory (if available)
+spark.conf.set("spark.driver.memory", "16g")
+
+# Reduce partition size
+spark.conf.set("spark.sql.files.maxPartitionBytes", "67108864")  # 64 MB
+
+# Increase shuffle partitions
+spark.conf.set("spark.sql.shuffle.partitions", "400")
+```
+
+### Slow Job Execution
+
+```python
+# Check execution plan
+df.explain(extended=True)
+
+# Enable AQE if not already
+spark.conf.set("spark.sql.adaptive.enabled", "true")
+
+# Check for data skew
+df.groupBy("potential_skew_column").count().orderBy(desc("count")).show(10)
+```
+
+### Library Conflicts
+
+```bash
+# List current environment libraries
+fab api "workspaces/$WS_ID/environments/$ENV_ID" -q "properties.libraries"
+
+# Check for conflicts
+fab api "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries/conflicts"
+```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md b/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
new file mode 100644
index 000000000..3da60afb4
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
@@ -0,0 +1,341 @@
+# Table Optimization Reference
+
+Guide to Delta Lake table optimization in Fabric using CLI.
+
+## Optimization Fundamentals
+
+Delta Lake tables in Fabric support advanced optimization:
+
+| Feature | Purpose | When to Use |
+|---------|---------|-------------|
+| OPTIMIZE | Compact small files | After many small writes |
+| V-Order | Read optimization | Always for analytics |
+| Z-Order | Cluster by columns | Multi-column filtering |
+| VACUUM | Remove old versions | After maintenance windows |
+
+## Running Table Maintenance
+
+### Via Notebook Jobs
+
+```bash
+# Trigger optimization via Spark notebook
+NOTEBOOK_ID=$(fab get "Workspace/Maintenance.Notebook" -q "id" | tr -d '"')
+
+fab job run "Workspace/Maintenance.Notebook" --timeout 3600
+```
+
+### Notebook Content for Optimization
+
+```python
+# Maintenance notebook template
+from delta.tables import DeltaTable
+
+def optimize_table(lakehouse_name, table_name, z_order_cols=None):
+    """Run OPTIMIZE with optional Z-Order"""
+    spark.sql(f"USE {lakehouse_name}")
+    
+    if z_order_cols:
+        cols = ", ".join(z_order_cols)
+        spark.sql(f"OPTIMIZE {table_name} ZORDER BY ({cols})")
+    else:
+        spark.sql(f"OPTIMIZE {table_name}")
+    
+    print(f"Optimized {table_name}")
+
+def vacuum_table(lakehouse_name, table_name, hours=168):
+    """Remove old versions (default 7 days)"""
+    spark.sql(f"USE {lakehouse_name}")
+    spark.sql(f"VACUUM {table_name} RETAIN {hours} HOURS")
+    print(f"Vacuumed {table_name}")
+
+# Execute maintenance
+tables = [
+    ("Bronze_LH", "raw_orders", None),
+    ("Silver_LH", "clean_orders", ["order_date"]),
+    ("Gold_LH", "sales_summary", ["region", "order_date"])
+]
+
+for lh, table, z_cols in tables:
+    optimize_table(lh, table, z_cols)
+    vacuum_table(lh, table)
+```
+
+## V-Order Optimization
+
+V-Order is Fabric's default write optimization:
+
+### Enable V-Order (Default)
+
+V-Order is enabled by default in Fabric lakehouses:
+
+```python
+# V-Order is automatic for Delta writes
+df.write.format("delta").mode("overwrite").save("Tables/optimized_table")
+
+# Check V-Order status in table properties
+spark.sql("DESCRIBE EXTENDED table_name").filter("col_name == 'Table Properties'").show(truncate=False)
+```
+
+### V-Order Benefits
+
+- 15% average compression improvement
+- Up to 50% faster reads for Power BI
+- Automatic during write operations
+- No additional configuration needed
+
+## Z-Order Optimization
+
+### Single Column Z-Order
+
+```python
+# Z-Order by frequently filtered column
+spark.sql("""
+    OPTIMIZE Gold_LH.fact_sales
+    ZORDER BY (order_date)
+""")
+```
+
+### Multi-Column Z-Order
+
+```python
+# Z-Order by multiple columns (max 4 recommended)
+spark.sql("""
+    OPTIMIZE Gold_LH.fact_sales
+    ZORDER BY (region, order_date)
+""")
+```
+
+### When to Use Z-Order
+
+| Use Z-Order When | Avoid Z-Order When |
+|------------------|-------------------|
+| Point lookups on columns | Full table scans |
+| Range queries | Few distinct values |
+| Join key columns | Frequently changing data |
+| Filter predicates | High cardinality only |
+
+## File Compaction
+
+### Standard Compaction
+
+```python
+# Compact small files
+spark.sql("OPTIMIZE lakehouse.table_name")
+
+# View file statistics before/after
+spark.sql("""
+    DESCRIBE DETAIL lakehouse.table_name
+""").select("numFiles", "sizeInBytes").show()
+```
+
+### Partition-Level Compaction
+
+```python
+# Optimize specific partition
+spark.sql("""
+    OPTIMIZE lakehouse.fact_sales
+    WHERE order_date >= '2024-01-01'
+""")
+```
+
+## VACUUM Operations
+
+### Standard VACUUM
+
+```python
+# Remove files older than 7 days (default)
+spark.sql("VACUUM lakehouse.table_name")
+
+# Specify retention period
+spark.sql("VACUUM lakehouse.table_name RETAIN 168 HOURS")
+```
+
+### Dry Run VACUUM
+
+```python
+# Preview files to be deleted
+spark.sql("VACUUM lakehouse.table_name DRY RUN")
+```
+
+### VACUUM Considerations
+
+- Default retention: 7 days (168 hours)
+- Minimum retention: 0 hours (not recommended)
+- Time travel disabled after VACUUM
+- Run during low-activity periods
+
+## Automated Maintenance
+
+### Schedule via Pipeline
+
+```bash
+# Create pipeline with maintenance activities
+fab import -p "Workspace" \
+  -d ".ai-assets/templates/maintenance_pipeline.json" \
+  -t Pipeline
+
+# Schedule the pipeline
+fab api -X post "workspaces/$WS_ID/items/$PIPE_ID/schedules" -i '{
+  "enabled": true,
+  "configuration": {
+    "type": "Daily",
+    "startTime": "2024-01-01T02:00:00",
+    "timeZone": "UTC",
+    "weekdays": ["Sunday"]
+  }
+}'
+```
+
+### Maintenance Script
+
+```bash
+#!/bin/bash
+# Weekly table maintenance automation
+
+WORKSPACE="DataPlatform.Workspace"
+MAINTENANCE_NOTEBOOK="Maintenance.Notebook"
+
+# Run maintenance notebook
+echo "Starting weekly maintenance..."
+fab job run "$WORKSPACE/$MAINTENANCE_NOTEBOOK" --timeout 7200
+
+# Monitor job completion
+JOB_ID=$(fab job list "$WORKSPACE/$MAINTENANCE_NOTEBOOK" -q "[0].id" | tr -d '"')
+STATUS=$(fab job get "$WORKSPACE/$MAINTENANCE_NOTEBOOK" "$JOB_ID" -q "status")
+
+while [[ "$STATUS" == "InProgress" || "$STATUS" == "NotStarted" ]]; do
+  sleep 60
+  STATUS=$(fab job get "$WORKSPACE/$MAINTENANCE_NOTEBOOK" "$JOB_ID" -q "status")
+  echo "Status: $STATUS"
+done
+
+echo "Maintenance completed with status: $STATUS"
+```
+
+## Table Statistics
+
+### Analyze Table Statistics
+
+```python
+# Update table statistics
+spark.sql("ANALYZE TABLE lakehouse.table_name COMPUTE STATISTICS")
+
+# Update statistics for specific columns
+spark.sql("""
+    ANALYZE TABLE lakehouse.table_name
+    COMPUTE STATISTICS FOR COLUMNS col1, col2, col3
+""")
+```
+
+### View Statistics
+
+```python
+# View table details including statistics
+spark.sql("DESCRIBE EXTENDED lakehouse.table_name").show(truncate=False)
+
+# View column statistics
+spark.sql("DESCRIBE EXTENDED lakehouse.table_name column_name").show()
+```
+
+## Best Practices
+
+### Optimization Schedule
+
+| Layer | Frequency | Operations |
+|-------|-----------|------------|
+| Bronze | Weekly | OPTIMIZE, VACUUM |
+| Silver | Weekly | OPTIMIZE, VACUUM |
+| Gold | Daily | OPTIMIZE, VACUUM |
+| Aggregate | Daily | OPTIMIZE |
+
+### File Size Targets
+
+- Target file size: 128 MB - 1 GB
+- Small file threshold: < 64 MB
+- Large file threshold: > 2 GB
+- Compaction reduces file count
+
+### Z-Order Selection
+
+```python
+# Profile queries to identify Z-Order candidates
+# Good candidates: frequently filtered columns
+z_order_candidates = {
+    "fact_sales": ["customer_id", "order_date"],
+    "fact_inventory": ["product_id", "warehouse_id"],
+    "dim_customer": ["customer_segment", "region"]
+}
+```
+
+## Monitoring Table Health
+
+### Check File Distribution
+
+```python
+# View file statistics
+df = spark.sql("DESCRIBE DETAIL lakehouse.table_name")
+df.select(
+    "name",
+    "numFiles",
+    "sizeInBytes",
+    "lastModified"
+).show()
+
+# Calculate average file size
+df.selectExpr(
+    "numFiles",
+    "sizeInBytes",
+    "sizeInBytes / numFiles as avgFileSize"
+).show()
+```
+
+### History and Auditing
+
+```python
+# View table history
+spark.sql("DESCRIBE HISTORY lakehouse.table_name LIMIT 20").show(truncate=False)
+
+# View operations timeline
+spark.sql("""
+    DESCRIBE HISTORY lakehouse.table_name
+""").select("version", "timestamp", "operation", "operationMetrics").show()
+```
+
+## Troubleshooting
+
+### Small File Problem
+
+```python
+# Identify small file issue
+stats = spark.sql("DESCRIBE DETAIL lakehouse.table_name")
+avg_size = stats.select("sizeInBytes").first()[0] / stats.select("numFiles").first()[0]
+
+if avg_size < 64 * 1024 * 1024:  # < 64 MB
+    print("Small file issue detected - run OPTIMIZE")
+    spark.sql("OPTIMIZE lakehouse.table_name")
+```
+
+### Slow Queries After VACUUM
+
+```python
+# Rebuild statistics after VACUUM
+spark.sql("ANALYZE TABLE lakehouse.table_name COMPUTE STATISTICS")
+
+# Re-optimize if needed
+spark.sql("OPTIMIZE lakehouse.table_name")
+```
+
+### Z-Order Not Effective
+
+```python
+# Check if Z-Order columns match query patterns
+# Verify column cardinality
+spark.sql("""
+    SELECT 
+        COUNT(DISTINCT z_order_col) as cardinality,
+        COUNT(*) as total_rows
+    FROM lakehouse.table_name
+""").show()
+
+# High cardinality (>1000 distinct) benefits more from Z-Order
+```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
new file mode 100644
index 000000000..7ea6009f3
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""
+optimize_tables.py - Run optimization on lakehouse tables
+
+This script runs V-Order and/or Z-Order optimization on lakehouse tables
+to improve query performance.
+
+Usage:
+    python optimize_tables.py <lakehouse> [--vorder] [--zorder COL]
+    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder
+    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales --zorder customer_id,date
+
+Exit codes:
+    0 - Optimization completed successfully
+    1 - Optimization failed or had errors
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 600) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def parse_lakehouse_path(path: str) -> Dict[str, Optional[str]]:
+    """Parse lakehouse path into components."""
+    result = {
+        "workspace": None,
+        "lakehouse": None,
+        "table": None,
+        "full_path": path
+    }
+    
+    parts = path.split("/")
+    
+    for i, part in enumerate(parts):
+        if part.endswith(".Workspace"):
+            result["workspace"] = part
+        elif part.endswith(".Lakehouse"):
+            result["lakehouse"] = part
+            if result["workspace"]:
+                result["lakehouse_path"] = f"{result['workspace']}/{part}"
+        elif part == "Tables" and i < len(parts) - 1:
+            result["table"] = parts[i + 1]
+    
+    return result
+
+
+def get_lakehouse_tables(lakehouse_path: str) -> List[Dict[str, Any]]:
+    """Get all tables in a lakehouse."""
+    tables_path = f"{lakehouse_path}/Tables"
+    exit_code, stdout, stderr = run_fab_command(["ls", tables_path, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        try:
+            result = json.loads(stdout.strip())
+            if isinstance(result, list):
+                return result
+        except json.JSONDecodeError:
+            pass
+    
+    return []
+
+
+def optimize_table_vorder(table_path: str) -> Dict[str, Any]:
+    """Run V-Order optimization on a table."""
+    result = {
+        "table": table_path,
+        "optimization": "vorder",
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Run OPTIMIZE command with VORDER
+    cmd = ["tables", "optimize", table_path, "--vorder", "-f", "json"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd, timeout=1800)  # 30 min timeout for large tables
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = "V-Order optimization completed"
+        try:
+            result["details"] = json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            result["details"] = {"output": stdout.strip()}
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "V-Order optimization failed"
+    
+    return result
+
+
+def optimize_table_zorder(table_path: str, columns: List[str]) -> Dict[str, Any]:
+    """Run Z-Order optimization on a table."""
+    result = {
+        "table": table_path,
+        "optimization": "zorder",
+        "columns": columns,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Run OPTIMIZE command with ZORDER
+    columns_str = ",".join(columns)
+    cmd = ["tables", "optimize", table_path, "--zorder", columns_str, "-f", "json"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd, timeout=1800)  # 30 min timeout for large tables
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = f"Z-Order optimization completed on columns: {columns_str}"
+        try:
+            result["details"] = json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            result["details"] = {"output": stdout.strip()}
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "Z-Order optimization failed"
+    
+    return result
+
+
+def get_table_stats(table_path: str) -> Dict[str, Any]:
+    """Get table statistics."""
+    exit_code, stdout, stderr = run_fab_command(["tables", "get", table_path, "-f", "json"])
+    
+    if exit_code == 0:
+        try:
+            return json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            pass
+    
+    return {}
+
+
+def optimize_tables(
+    path: str,
+    vorder: bool = False,
+    zorder_columns: Optional[List[str]] = None,
+    table_filter: Optional[str] = None,
+    dry_run: bool = False
+) -> Dict[str, Any]:
+    """Optimize tables in a lakehouse."""
+    
+    report = {
+        "path": path,
+        "vorder": vorder,
+        "zorder_columns": zorder_columns,
+        "dry_run": dry_run,
+        "tables_found": [],
+        "optimization_results": [],
+        "summary": {
+            "total_tables": 0,
+            "optimized": 0,
+            "failed": 0,
+            "skipped": 0
+        }
+    }
+    
+    # Parse the path
+    parsed = parse_lakehouse_path(path)
+    
+    # Verify path exists
+    print(f"\nVerifying path: {path}")
+    if not check_path_exists(path):
+        print(f"Error: Path '{path}' does not exist or is not accessible")
+        return report
+    print("  Path found")
+    
+    # Determine if we're optimizing a single table or all tables in a lakehouse
+    tables_to_optimize = []
+    
+    if parsed.get("table"):
+        # Single table specified
+        tables_to_optimize = [{
+            "name": parsed["table"],
+            "path": path
+        }]
+        print(f"\nTarget: Single table '{parsed['table']}'")
+    else:
+        # Get all tables in lakehouse
+        print("\nFetching lakehouse tables...")
+        
+        lakehouse_path = path
+        tables = get_lakehouse_tables(lakehouse_path)
+        
+        for table in tables:
+            table_name = table.get("displayName", table.get("name", "Unknown"))
+            table_path = f"{lakehouse_path}/Tables/{table_name}"
+            
+            if table_filter and table_filter.lower() not in table_name.lower():
+                continue
+            
+            tables_to_optimize.append({
+                "name": table_name,
+                "path": table_path,
+                "metadata": table
+            })
+        
+        print(f"  Found {len(tables_to_optimize)} table(s)")
+    
+    report["tables_found"] = [t["name"] for t in tables_to_optimize]
+    report["summary"]["total_tables"] = len(tables_to_optimize)
+    
+    if not tables_to_optimize:
+        print("No tables found to optimize")
+        return report
+    
+    # Validate optimization options
+    if not vorder and not zorder_columns:
+        print("\nError: Must specify --vorder and/or --zorder columns")
+        print("  Use --vorder for V-Order optimization")
+        print("  Use --zorder col1,col2 for Z-Order optimization")
+        return report
+    
+    if dry_run:
+        print(f"\n[DRY RUN] Would optimize the following tables:")
+        for table in tables_to_optimize:
+            print(f"  - {table['name']}")
+            if vorder:
+                print(f"      V-Order: Yes")
+            if zorder_columns:
+                print(f"      Z-Order columns: {', '.join(zorder_columns)}")
+        return report
+    
+    # Optimize each table
+    print("\nOptimizing tables...")
+    for table in tables_to_optimize:
+        table_name = table["name"]
+        table_path = table["path"]
+        
+        print(f"\n  Optimizing: {table_name}")
+        
+        table_result = {
+            "table": table_name,
+            "path": table_path,
+            "optimizations": []
+        }
+        
+        # V-Order optimization
+        if vorder:
+            print(f"    Running V-Order...")
+            vorder_result = optimize_table_vorder(table_path)
+            table_result["optimizations"].append(vorder_result)
+            
+            if vorder_result["status"] == "success":
+                print(f"      ✓ V-Order completed")
+            else:
+                print(f"      ✗ V-Order failed: {vorder_result['message']}")
+        
+        # Z-Order optimization
+        if zorder_columns:
+            print(f"    Running Z-Order on: {', '.join(zorder_columns)}")
+            zorder_result = optimize_table_zorder(table_path, zorder_columns)
+            table_result["optimizations"].append(zorder_result)
+            
+            if zorder_result["status"] == "success":
+                print(f"      ✓ Z-Order completed")
+            else:
+                print(f"      ✗ Z-Order failed: {zorder_result['message']}")
+        
+        # Determine overall status for this table
+        all_success = all(opt["status"] == "success" for opt in table_result["optimizations"])
+        any_success = any(opt["status"] == "success" for opt in table_result["optimizations"])
+        
+        if all_success:
+            table_result["overall_status"] = "success"
+            report["summary"]["optimized"] += 1
+        elif any_success:
+            table_result["overall_status"] = "partial"
+            report["summary"]["optimized"] += 1
+        else:
+            table_result["overall_status"] = "failed"
+            report["summary"]["failed"] += 1
+        
+        report["optimization_results"].append(table_result)
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run optimization on lakehouse tables",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # V-Order all tables in a lakehouse
+    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder
+
+    # Z-Order a specific table
+    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales --zorder customer_id,date
+
+    # Both V-Order and Z-Order
+    python optimize_tables.py DataPlatform.Workspace/Silver.Lakehouse --vorder --zorder date,region
+
+    # Preview what would be optimized
+    python optimize_tables.py DataPlatform.Workspace/Gold.Lakehouse --vorder --dry-run
+
+    # Filter tables by name pattern
+    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder --filter sales
+
+Optimization Types:
+    V-Order (--vorder):
+        Optimizes data layout for read performance.
+        Applies write-time sorting for faster queries.
+        Recommended for tables with frequent analytical queries.
+
+    Z-Order (--zorder col1,col2):
+        Colocates related information in the same files.
+        Improves filtering on specified columns.
+        Best for columns commonly used in WHERE clauses.
+        """
+    )
+    parser.add_argument(
+        "path",
+        help="Lakehouse or table path to optimize"
+    )
+    parser.add_argument(
+        "--vorder",
+        action="store_true",
+        help="Apply V-Order optimization"
+    )
+    parser.add_argument(
+        "--zorder",
+        help="Comma-separated list of columns for Z-Order optimization"
+    )
+    parser.add_argument(
+        "--filter",
+        help="Filter tables by name pattern (case-insensitive)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview optimization without executing"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    # Parse Z-Order columns
+    zorder_columns = None
+    if args.zorder:
+        zorder_columns = [col.strip() for col in args.zorder.split(",") if col.strip()]
+    
+    # Validate that at least one optimization is specified
+    if not args.vorder and not zorder_columns:
+        parser.error("Must specify --vorder and/or --zorder columns")
+    
+    try:
+        report = optimize_tables(
+            path=args.path,
+            vorder=args.vorder,
+            zorder_columns=zorder_columns,
+            table_filter=args.filter,
+            dry_run=args.dry_run
+        )
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("OPTIMIZATION SUMMARY")
+        print("=" * 50)
+        print(f"Path: {report['path']}")
+        print(f"V-Order: {report['vorder']}")
+        print(f"Z-Order Columns: {', '.join(report['zorder_columns']) if report['zorder_columns'] else 'None'}")
+        print(f"Dry Run: {report['dry_run']}")
+        print(f"\nResults:")
+        print(f"  Total Tables: {report['summary']['total_tables']}")
+        print(f"  Optimized: {report['summary']['optimized']}")
+        print(f"  Failed: {report['summary']['failed']}")
+        print(f"  Skipped: {report['summary']['skipped']}")
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        # Exit code based on failures
+        sys.exit(0 if report['summary']['failed'] == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
new file mode 100644
index 000000000..555a7c587
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+"""
+setup_medallion.py - Create medallion architecture (bronze/silver/gold)
+
+This script creates a standard medallion architecture in a Microsoft Fabric workspace,
+including Bronze, Silver, and Gold lakehouses with standard folder structures.
+
+Usage:
+    python setup_medallion.py <workspace> [--prefix NAME]
+    python setup_medallion.py DataPlatform.Workspace
+    python setup_medallion.py DataPlatform.Workspace --prefix Sales
+
+Exit codes:
+    0 - Medallion architecture created successfully
+    1 - Error during creation
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def check_workspace_exists(workspace: str) -> bool:
+    """Check if workspace exists."""
+    exit_code, _, _ = run_fab_command(["exists", workspace])
+    return exit_code == 0
+
+
+def check_item_exists(item_path: str) -> bool:
+    """Check if an item exists."""
+    exit_code, _, _ = run_fab_command(["exists", item_path])
+    return exit_code == 0
+
+
+def create_lakehouse(workspace: str, name: str, enable_schemas: bool = False) -> Dict[str, Any]:
+    """Create a lakehouse in the workspace."""
+    lakehouse_path = f"{workspace}/{name}.Lakehouse"
+    
+    result = {
+        "name": name,
+        "path": lakehouse_path,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(lakehouse_path):
+        result["status"] = "exists"
+        result["message"] = f"Lakehouse '{name}' already exists"
+        return result
+    
+    # Create the lakehouse
+    cmd = ["create", lakehouse_path, "-f"]
+    if enable_schemas:
+        cmd.extend(["-P", "enableSchemas=true"])
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["message"] = f"Lakehouse '{name}' created successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create lakehouse '{name}'"
+    
+    return result
+
+
+def create_folder(lakehouse_path: str, folder_path: str) -> Dict[str, Any]:
+    """Create a folder in a lakehouse."""
+    full_path = f"{lakehouse_path}/{folder_path}"
+    
+    result = {
+        "path": full_path,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    exit_code, stdout, stderr = run_fab_command(["mkdir", full_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["message"] = f"Folder '{folder_path}' created"
+    elif "already exists" in stderr.lower():
+        result["status"] = "exists"
+        result["message"] = f"Folder '{folder_path}' already exists"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create folder '{folder_path}'"
+    
+    return result
+
+
+def create_shortcut(source_lakehouse: str, target_lakehouse: str, shortcut_name: str, target_folder: str) -> Dict[str, Any]:
+    """Create a shortcut between lakehouses."""
+    shortcut_path = f"{source_lakehouse}/Files/{shortcut_name}.Shortcut"
+    target_path = f"{target_lakehouse}/Files/{target_folder}"
+    
+    result = {
+        "shortcut": shortcut_path,
+        "target": target_path,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Check if shortcut already exists
+    if check_item_exists(shortcut_path):
+        result["status"] = "exists"
+        result["message"] = f"Shortcut '{shortcut_name}' already exists"
+        return result
+    
+    exit_code, stdout, stderr = run_fab_command([
+        "ln", shortcut_path, 
+        "--type", "oneLake",
+        "--target", target_path,
+        "-f"
+    ])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["message"] = f"Shortcut '{shortcut_name}' created"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create shortcut '{shortcut_name}'"
+    
+    return result
+
+
+def setup_medallion_architecture(
+    workspace: str, 
+    prefix: Optional[str] = None,
+    enable_schemas: bool = False,
+    create_shortcuts: bool = False,
+    dry_run: bool = False
+) -> Dict[str, Any]:
+    """Set up complete medallion architecture."""
+    
+    workspace = ensure_workspace_suffix(workspace)
+    
+    # Define lakehouse names
+    bronze_name = f"{prefix}_Bronze" if prefix else "Bronze"
+    silver_name = f"{prefix}_Silver" if prefix else "Silver"
+    gold_name = f"{prefix}_Gold" if prefix else "Gold"
+    
+    # Standard folder structure for each layer
+    bronze_folders = ["Files/raw", "Files/landing", "Files/archive"]
+    silver_folders = ["Files/cleansed", "Files/enriched", "Files/validated"]
+    gold_folders = ["Files/curated", "Files/aggregated", "Files/published"]
+    
+    report = {
+        "workspace": workspace,
+        "prefix": prefix,
+        "dry_run": dry_run,
+        "lakehouses": [],
+        "folders": [],
+        "shortcuts": [],
+        "summary": {
+            "lakehouses_created": 0,
+            "lakehouses_existed": 0,
+            "folders_created": 0,
+            "shortcuts_created": 0,
+            "errors": 0
+        }
+    }
+    
+    if dry_run:
+        print("\n[DRY RUN] The following resources would be created:\n")
+        print(f"Workspace: {workspace}")
+        print(f"\nLakehouses:")
+        print(f"  - {bronze_name}.Lakehouse")
+        print(f"  - {silver_name}.Lakehouse")
+        print(f"  - {gold_name}.Lakehouse")
+        print(f"\nFolders in each lakehouse:")
+        for folder in bronze_folders:
+            print(f"  - Bronze: {folder}")
+        for folder in silver_folders:
+            print(f"  - Silver: {folder}")
+        for folder in gold_folders:
+            print(f"  - Gold: {folder}")
+        if create_shortcuts:
+            print(f"\nShortcuts:")
+            print(f"  - Silver -> Bronze (bronze_source)")
+            print(f"  - Gold -> Silver (silver_source)")
+        return report
+    
+    # Check workspace exists
+    print(f"\nSetting up medallion architecture in: {workspace}")
+    if not check_workspace_exists(workspace):
+        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
+        sys.exit(1)
+    
+    # Create lakehouses
+    print("\n1. Creating Lakehouses...")
+    lakehouses = [
+        (bronze_name, bronze_folders),
+        (silver_name, silver_folders),
+        (gold_name, gold_folders)
+    ]
+    
+    for lh_name, folders in lakehouses:
+        print(f"   Creating {lh_name}.Lakehouse...")
+        result = create_lakehouse(workspace, lh_name, enable_schemas)
+        report["lakehouses"].append(result)
+        
+        if result["status"] == "created":
+            report["summary"]["lakehouses_created"] += 1
+            print(f"   ✓ {result['message']}")
+        elif result["status"] == "exists":
+            report["summary"]["lakehouses_existed"] += 1
+            print(f"   • {result['message']}")
+        else:
+            report["summary"]["errors"] += 1
+            print(f"   ✗ {result['message']}")
+    
+    # Create folder structures
+    print("\n2. Creating folder structures...")
+    for lh_name, folders in lakehouses:
+        lakehouse_path = f"{workspace}/{lh_name}.Lakehouse"
+        print(f"   {lh_name}:")
+        for folder in folders:
+            result = create_folder(lakehouse_path, folder)
+            report["folders"].append(result)
+            
+            if result["status"] == "created":
+                report["summary"]["folders_created"] += 1
+                print(f"     ✓ {folder}")
+            elif result["status"] == "exists":
+                print(f"     • {folder} (exists)")
+            else:
+                report["summary"]["errors"] += 1
+                print(f"     ✗ {folder}: {result['message']}")
+    
+    # Create shortcuts between layers (optional)
+    if create_shortcuts:
+        print("\n3. Creating shortcuts between layers...")
+        
+        # Silver -> Bronze shortcut
+        silver_path = f"{workspace}/{silver_name}.Lakehouse"
+        bronze_path = f"{workspace}/{bronze_name}.Lakehouse"
+        gold_path = f"{workspace}/{gold_name}.Lakehouse"
+        
+        result = create_shortcut(silver_path, bronze_path, "bronze_source", "cleansed")
+        report["shortcuts"].append(result)
+        if result["status"] == "created":
+            report["summary"]["shortcuts_created"] += 1
+            print(f"   ✓ Silver -> Bronze shortcut created")
+        else:
+            print(f"   • {result['message']}")
+        
+        # Gold -> Silver shortcut
+        result = create_shortcut(gold_path, silver_path, "silver_source", "enriched")
+        report["shortcuts"].append(result)
+        if result["status"] == "created":
+            report["summary"]["shortcuts_created"] += 1
+            print(f"   ✓ Gold -> Silver shortcut created")
+        else:
+            print(f"   • {result['message']}")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create medallion architecture (Bronze/Silver/Gold lakehouses)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python setup_medallion.py DataPlatform.Workspace
+    python setup_medallion.py DataPlatform.Workspace --prefix Sales
+    python setup_medallion.py "My Workspace" --prefix Analytics --with-shortcuts
+    python setup_medallion.py Dev.Workspace --dry-run
+
+Medallion Architecture:
+    Bronze: Raw data ingestion layer
+    Silver: Cleansed and validated data
+    Gold: Curated business-ready data
+        """
+    )
+    parser.add_argument(
+        "workspace",
+        help="Workspace name or path where medallion architecture will be created"
+    )
+    parser.add_argument(
+        "--prefix", "-p",
+        help="Prefix for lakehouse names (e.g., 'Sales' creates Sales_Bronze, Sales_Silver, Sales_Gold)"
+    )
+    parser.add_argument(
+        "--enable-schemas",
+        action="store_true",
+        help="Enable schema support for lakehouses"
+    )
+    parser.add_argument(
+        "--with-shortcuts",
+        action="store_true",
+        help="Create shortcuts between layers (Silver->Bronze, Gold->Silver)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview what would be created without making changes"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = setup_medallion_architecture(
+            workspace=args.workspace,
+            prefix=args.prefix,
+            enable_schemas=args.enable_schemas,
+            create_shortcuts=args.with_shortcuts,
+            dry_run=args.dry_run
+        )
+        
+        if args.dry_run:
+            sys.exit(0)
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("MEDALLION ARCHITECTURE SETUP COMPLETE")
+        print("=" * 50)
+        print(f"Workspace: {report['workspace']}")
+        if report['prefix']:
+            print(f"Prefix: {report['prefix']}")
+        print(f"\nSummary:")
+        print(f"  Lakehouses created: {report['summary']['lakehouses_created']}")
+        print(f"  Lakehouses existed: {report['summary']['lakehouses_existed']}")
+        print(f"  Folders created: {report['summary']['folders_created']}")
+        if args.with_shortcuts:
+            print(f"  Shortcuts created: {report['summary']['shortcuts_created']}")
+        print(f"  Errors: {report['summary']['errors']}")
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        sys.exit(0 if report['summary']['errors'] == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
new file mode 100644
index 000000000..1d18d110b
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""
+validate_shortcuts.py - Verify all shortcuts are accessible
+
+This script validates all shortcuts in a lakehouse, checking that targets exist
+and are accessible.
+
+Usage:
+    python validate_shortcuts.py <lakehouse>
+    python validate_shortcuts.py DataPlatform.Workspace/Silver.Lakehouse
+
+Exit codes:
+    0 - All shortcuts are valid and accessible
+    1 - One or more shortcuts have issues
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def ensure_lakehouse_suffix(path: str) -> str:
+    """Ensure path has .Lakehouse suffix if needed."""
+    if "/" not in path:
+        return path
+    
+    parts = path.split("/")
+    for i, part in enumerate(parts):
+        if "." in part:
+            continue
+        # Check if this looks like a lakehouse name
+        if i > 0 and parts[i-1].endswith(".Workspace"):
+            parts[i] = f"{part}.Lakehouse"
+            break
+    
+    return "/".join(parts)
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def parse_lakehouse_path(path: str) -> Dict[str, Optional[str]]:
+    """Parse lakehouse path into components."""
+    result = {
+        "workspace": None,
+        "lakehouse": None,
+        "full_path": path
+    }
+    
+    parts = path.split("/")
+    
+    for part in parts:
+        if part.endswith(".Workspace"):
+            result["workspace"] = part
+        elif part.endswith(".Lakehouse"):
+            result["lakehouse"] = part
+            if result["workspace"]:
+                result["lakehouse_path"] = f"{result['workspace']}/{part}"
+    
+    return result
+
+
+def list_shortcuts(lakehouse_path: str) -> List[Dict[str, Any]]:
+    """List all shortcuts in a lakehouse."""
+    shortcuts = []
+    
+    # Check Tables folder
+    tables_path = f"{lakehouse_path}/Tables"
+    exit_code, stdout, stderr = run_fab_command(["ls", tables_path, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        items = parse_json_output(stdout) or []
+        for item in items:
+            if item.get("type") == "Shortcut":
+                item["location"] = "Tables"
+                item["full_path"] = f"{tables_path}/{item.get('name', '')}"
+                shortcuts.append(item)
+    
+    # Check Files folder
+    files_path = f"{lakehouse_path}/Files"
+    exit_code, stdout, stderr = run_fab_command(["ls", files_path, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        items = parse_json_output(stdout) or []
+        for item in items:
+            if item.get("type") == "Shortcut":
+                item["location"] = "Files"
+                item["full_path"] = f"{files_path}/{item.get('name', '')}"
+                shortcuts.append(item)
+    
+    # Also check for shortcuts using the shortcut-specific command
+    exit_code, stdout, stderr = run_fab_command(["ln", "list", lakehouse_path, "-f", "json"])
+    
+    if exit_code == 0:
+        ln_shortcuts = parse_json_output(stdout) or []
+        # Merge with existing list, avoiding duplicates
+        existing_names = {s.get("name") for s in shortcuts}
+        for s in ln_shortcuts:
+            if s.get("name") not in existing_names:
+                shortcuts.append(s)
+    
+    return shortcuts
+
+
+def get_shortcut_details(shortcut_path: str) -> Dict[str, Any]:
+    """Get detailed information about a shortcut."""
+    exit_code, stdout, stderr = run_fab_command(["get", shortcut_path, "-f", "json"])
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {}
+    return {"error": stderr}
+
+
+def validate_shortcut(shortcut: Dict[str, Any], verbose: bool = False) -> Dict[str, Any]:
+    """Validate a single shortcut."""
+    result = {
+        "name": shortcut.get("name", "Unknown"),
+        "location": shortcut.get("location", "Unknown"),
+        "path": shortcut.get("full_path", ""),
+        "status": "unknown",
+        "target": None,
+        "target_type": None,
+        "checks": []
+    }
+    
+    # Get shortcut target information
+    shortcut_path = shortcut.get("full_path", "")
+    if shortcut_path:
+        details = get_shortcut_details(shortcut_path)
+        
+        if "error" in details:
+            result["status"] = "error"
+            result["checks"].append({
+                "check": "get_details",
+                "passed": False,
+                "message": f"Failed to get shortcut details: {details['error']}"
+            })
+            return result
+        
+        # Extract target information
+        target = details.get("target") or details.get("targetPath")
+        target_type = details.get("targetType") or details.get("type", "")
+        
+        result["target"] = target
+        result["target_type"] = target_type
+        
+        # Check 1: Target path is defined
+        if target:
+            result["checks"].append({
+                "check": "target_defined",
+                "passed": True,
+                "message": f"Target is defined: {target}"
+            })
+        else:
+            result["status"] = "invalid"
+            result["checks"].append({
+                "check": "target_defined",
+                "passed": False,
+                "message": "No target path defined for shortcut"
+            })
+            return result
+        
+        # Check 2: Target exists (for internal shortcuts)
+        if target_type in ["OneLake", "Internal", "Lakehouse", "Warehouse"]:
+            if verbose:
+                print(f"  Checking if target exists: {target}", file=sys.stderr)
+            
+            target_exists = check_path_exists(target)
+            if target_exists:
+                result["checks"].append({
+                    "check": "target_exists",
+                    "passed": True,
+                    "message": f"Target exists: {target}"
+                })
+            else:
+                result["status"] = "broken"
+                result["checks"].append({
+                    "check": "target_exists",
+                    "passed": False,
+                    "message": f"Target does not exist: {target}"
+                })
+                return result
+        
+        # Check 3: Try to list contents (verify access)
+        if verbose:
+            print(f"  Checking shortcut accessibility...", file=sys.stderr)
+        
+        exit_code, stdout, stderr = run_fab_command(["ls", shortcut_path, "-f", "json"], timeout=30)
+        
+        if exit_code == 0:
+            result["checks"].append({
+                "check": "accessible",
+                "passed": True,
+                "message": "Shortcut content is accessible"
+            })
+        else:
+            # Could be permission issue or broken shortcut
+            result["status"] = "inaccessible"
+            result["checks"].append({
+                "check": "accessible",
+                "passed": False,
+                "message": f"Cannot access shortcut content: {stderr.strip()}"
+            })
+            return result
+        
+        # All checks passed
+        result["status"] = "valid"
+    
+    return result
+
+
+def print_validation_report(results: Dict[str, Any], output_format: str, 
+                           output_file: Optional[str] = None):
+    """Print validation report."""
+    if output_format == "json":
+        output = json.dumps(results, indent=2)
+    else:
+        # Text format
+        lines = []
+        lines.append("=" * 70)
+        lines.append("SHORTCUT VALIDATION REPORT")
+        lines.append("=" * 70)
+        lines.append(f"Lakehouse: {results['lakehouse']}")
+        lines.append("")
+        
+        summary = results.get("summary", {})
+        lines.append(f"Total shortcuts: {summary.get('total', 0)}")
+        lines.append(f"Valid: {summary.get('valid', 0)}")
+        lines.append(f"Broken: {summary.get('broken', 0)}")
+        lines.append(f"Inaccessible: {summary.get('inaccessible', 0)}")
+        lines.append(f"Invalid: {summary.get('invalid', 0)}")
+        lines.append(f"Errors: {summary.get('errors', 0)}")
+        lines.append("")
+        
+        # Group by status
+        shortcuts = results.get("shortcuts", [])
+        
+        valid_shortcuts = [s for s in shortcuts if s["status"] == "valid"]
+        problem_shortcuts = [s for s in shortcuts if s["status"] != "valid"]
+        
+        if valid_shortcuts:
+            lines.append("VALID SHORTCUTS:")
+            for s in valid_shortcuts:
+                target_info = f" -> {s['target']}" if s.get('target') else ""
+                lines.append(f"  ✓ {s['name']} ({s['location']}){target_info}")
+            lines.append("")
+        
+        if problem_shortcuts:
+            lines.append("PROBLEM SHORTCUTS:")
+            for s in problem_shortcuts:
+                status_icon = {
+                    "broken": "✗",
+                    "inaccessible": "⚠",
+                    "invalid": "?",
+                    "error": "!"
+                }.get(s["status"], "?")
+                
+                lines.append(f"  {status_icon} {s['name']} ({s['location']}) - {s['status'].upper()}")
+                
+                # Show failed checks
+                for check in s.get("checks", []):
+                    if not check["passed"]:
+                        lines.append(f"      └─ {check['message']}")
+            lines.append("")
+        
+        if not shortcuts:
+            lines.append("No shortcuts found in this lakehouse.")
+            lines.append("")
+        
+        # Overall status
+        lines.append("-" * 70)
+        if summary.get("broken", 0) > 0 or summary.get("invalid", 0) > 0:
+            lines.append("STATUS: FAILED - Some shortcuts have issues that need attention")
+        elif summary.get("inaccessible", 0) > 0:
+            lines.append("STATUS: WARNING - Some shortcuts may have access issues")
+        elif summary.get("total", 0) == 0:
+            lines.append("STATUS: OK - No shortcuts to validate")
+        else:
+            lines.append("STATUS: PASSED - All shortcuts are valid and accessible")
+        lines.append("=" * 70)
+        
+        output = "\n".join(lines)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Report written to: {output_file}", file=sys.stderr)
+    else:
+        print(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Verify all shortcuts in a lakehouse are accessible",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python validate_shortcuts.py DataPlatform.Workspace/Silver.Lakehouse
+    python validate_shortcuts.py MyWorkspace.Workspace/Bronze.Lakehouse -f json
+    python validate_shortcuts.py Production.Workspace/Gold.Lakehouse -o report.json
+        """
+    )
+    
+    parser.add_argument(
+        "lakehouse",
+        help="Lakehouse path (e.g., 'MyWorkspace.Workspace/MyLakehouse.Lakehouse')"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    args = parser.parse_args()
+    
+    # Parse and validate lakehouse path
+    lakehouse_path = ensure_lakehouse_suffix(args.lakehouse)
+    path_info = parse_lakehouse_path(lakehouse_path)
+    
+    if not path_info.get("lakehouse_path"):
+        print(f"Error: Invalid lakehouse path: {args.lakehouse}", file=sys.stderr)
+        print("Expected format: Workspace.Workspace/Lakehouse.Lakehouse", file=sys.stderr)
+        return 1
+    
+    lakehouse_full_path = path_info["lakehouse_path"]
+    
+    if args.verbose:
+        print(f"Validating shortcuts in: {lakehouse_full_path}", file=sys.stderr)
+    
+    # Check lakehouse exists
+    if not check_path_exists(lakehouse_full_path):
+        print(f"Error: Lakehouse does not exist: {lakehouse_full_path}", file=sys.stderr)
+        return 1
+    
+    # List all shortcuts
+    if args.verbose:
+        print("Discovering shortcuts...", file=sys.stderr)
+    
+    shortcuts = list_shortcuts(lakehouse_full_path)
+    
+    if args.verbose:
+        print(f"Found {len(shortcuts)} shortcuts", file=sys.stderr)
+    
+    # Validate each shortcut
+    validation_results = []
+    for shortcut in shortcuts:
+        if args.verbose:
+            print(f"Validating: {shortcut.get('name', 'Unknown')}", file=sys.stderr)
+        
+        result = validate_shortcut(shortcut, verbose=args.verbose)
+        validation_results.append(result)
+    
+    # Build summary
+    summary = {
+        "total": len(validation_results),
+        "valid": sum(1 for r in validation_results if r["status"] == "valid"),
+        "broken": sum(1 for r in validation_results if r["status"] == "broken"),
+        "inaccessible": sum(1 for r in validation_results if r["status"] == "inaccessible"),
+        "invalid": sum(1 for r in validation_results if r["status"] == "invalid"),
+        "errors": sum(1 for r in validation_results if r["status"] == "error")
+    }
+    
+    # Build report
+    report = {
+        "lakehouse": lakehouse_full_path,
+        "summary": summary,
+        "shortcuts": validation_results
+    }
+    
+    # Output report
+    print_validation_report(report, args.format, args.output)
+    
+    # Return exit code
+    if summary["broken"] > 0 or summary["invalid"] > 0 or summary["errors"] > 0:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-governance/README.md b/.ai-assets/skills/fabric-cli-governance/README.md
new file mode 100644
index 000000000..cc9fdac79
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/README.md
@@ -0,0 +1,75 @@
+# Fabric CLI Governance Skill
+
+Task-specific instructions for AI agents helping users with Microsoft Fabric governance, security, and administration operations.
+
+## Overview
+
+This skill provides guidance for:
+
+- **Access Control** — Workspace roles, item permissions, ACL management
+- **Domain Management** — Creating and organizing domains, workspace assignment
+- **Capacity Operations** — Capacity assignment, monitoring, SKU management
+- **Sensitivity Labels** — Classifying and protecting data
+- **Audit & Compliance** — Activity monitoring, permission audits
+
+## When to Load
+
+Load this skill when the user's task involves:
+
+- Managing workspace or item permissions
+- Setting up domains or organizational structures
+- Assigning workspaces to capacities
+- Applying sensitivity labels
+- Auditing access or activities
+- Configuring security policies (RLS, CLS, OLS)
+- Managing connections or gateways
+
+## Files
+
+| File | Description |
+|------|-------------|
+| [SKILL.md](./SKILL.md) | Main skill definition (load this) |
+| [references/](./references/) | Detailed reference documentation |
+
+## Scripts
+
+Automation scripts for governance tasks:
+
+| Script | Description | Usage |
+|--------|-------------|-------|
+| `audit_workspace.py` | Generate comprehensive workspace audit report | `python scripts/audit_workspace.py <workspace> -o report.json` |
+| `bulk_permissions.py` | Apply permissions from CSV/JSON file | `python scripts/bulk_permissions.py <workspace> -i perms.csv` |
+| `validate_governance.py` | Check workspace against governance rules | `python scripts/validate_governance.py <workspace> --rules rules.json` |
+
+## Quick Reference
+
+### Common Commands
+
+```bash
+# View workspace permissions
+fab acl get "Workspace.Workspace"
+
+# Add user to workspace
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
+
+# List domains
+fab ls .domains -l
+
+# List capacities
+fab ls .capacities -l
+
+# Assign workspace to capacity
+fab assign "Workspace.Workspace" -P capacityId=<capacity-id>
+```
+
+## Dependencies
+
+- Requires `fabric-cli-core` skill loaded first
+- Admin or Member workspace role for permission management
+- Fabric Admin role for tenant-level operations
+
+## References
+
+- [Fabric Permission Model](https://learn.microsoft.com/fabric/security/permission-model)
+- [Workspace Roles](https://learn.microsoft.com/fabric/fundamentals/roles-workspaces)
+- [Governance Overview](https://learn.microsoft.com/fabric/governance/governance-compliance-overview)
diff --git a/.ai-assets/skills/fabric-cli-governance/SKILL.md b/.ai-assets/skills/fabric-cli-governance/SKILL.md
new file mode 100644
index 000000000..b5f8dbae4
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/SKILL.md
@@ -0,0 +1,474 @@
+---
+name: fabric-cli-governance
+description: Use Fabric CLI for governance, security, and administration — workspace permissions, domains, capacities, sensitivity labels, and audit. Activate when users need to manage access control, configure governance policies, monitor usage, or troubleshoot permissions.
+---
+
+# Fabric CLI Governance & Administration
+
+Expert guidance for managing Microsoft Fabric security, governance, and administration using the `fab` CLI.
+
+## When to Use This Skill
+
+Activate automatically when tasks involve:
+
+- Managing workspace permissions and access control (ACLs)
+- Configuring and managing domains
+- Capacity assignment and monitoring
+- Applying sensitivity labels to items
+- Auditing user activities and access patterns
+- Setting up row-level security (RLS), column-level security (CLS), or object-level security (OLS)
+- Workspace identity and managed identity configuration
+
+## Prerequisites
+
+- Load `fabric-cli-core` skill first for foundational CLI guidance
+- User must be authenticated: `fab auth status`
+- Admin or Member role required for most governance operations
+- Fabric Admin role required for tenant-level operations
+
+## Automation Scripts
+
+Ready-to-use Python scripts for governance tasks. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `audit_workspace.py` | Generate comprehensive workspace audit report | `python scripts/audit_workspace.py <workspace> -o report.json` |
+| `bulk_permissions.py` | Apply permissions from CSV/JSON file | `python scripts/bulk_permissions.py <workspace> -i perms.csv` |
+| `validate_governance.py` | Check workspace against governance rules | `python scripts/validate_governance.py <workspace> --rules rules.json` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+## 1 - Workspace Roles and Permissions
+
+### Workspace Role Hierarchy
+
+| Role | Capabilities |
+|------|-------------|
+| **Admin** | Full control: delete workspace, manage all permissions, all Member capabilities |
+| **Member** | Create/modify/share items, add Contributors and Viewers |
+| **Contributor** | Create/modify items, cannot share or manage permissions |
+| **Viewer** | Read-only access to all items |
+
+### View Workspace Permissions
+
+```bash
+# List all workspace permissions
+fab acl get "Production.Workspace"
+
+# Get permissions in detailed format
+fab acl get "Production.Workspace" -l
+
+# Query specific permission details
+fab acl get "Production.Workspace" -q "value[?role=='Admin']"
+```
+
+### Manage Workspace Permissions
+
+```bash
+# Add user as Contributor
+fab acl set "Production.Workspace" -P principal=user@company.com,role=Contributor
+
+# Add security group as Viewer
+fab acl set "Production.Workspace" -P principal=DataAnalysts@company.com,role=Viewer,principalType=Group
+
+# Add service principal as Member
+fab acl set "Production.Workspace" -P principal=<app-id>,role=Member,principalType=App
+
+# Remove user from workspace
+fab acl del "Production.Workspace" -P principal=user@company.com
+```
+
+### Bulk Permission Management
+
+```bash
+#!/bin/bash
+# Add multiple users to workspace
+WORKSPACE="Production.Workspace"
+USERS=("analyst1@company.com" "analyst2@company.com" "analyst3@company.com")
+
+for USER in "${USERS[@]}"; do
+  fab acl set "$WORKSPACE" -P principal=$USER,role=Viewer -f
+  echo "Added $USER as Viewer"
+done
+```
+
+## 2 - Item-Level Permissions
+
+### View Item Permissions
+
+```bash
+# Get permissions for specific item
+fab acl get "Production.Workspace/Sales.SemanticModel"
+
+# List all shared items in workspace
+fab api "workspaces/<ws-id>/items" -q "value[?permissions]"
+```
+
+### Share Items
+
+```bash
+# Share semantic model with read access
+fab acl set "Production.Workspace/Sales.SemanticModel" -P principal=user@company.com,role=Read
+
+# Share with build permission (for semantic models)
+fab acl set "Production.Workspace/Sales.SemanticModel" -P principal=user@company.com,role=Build
+
+# Share report
+fab acl set "Production.Workspace/SalesReport.Report" -P principal=user@company.com,role=Read
+```
+
+### Item Permission Types
+
+| Item Type | Available Permissions |
+|-----------|----------------------|
+| Semantic Model | Read, Build, Write |
+| Report | Read, Write |
+| Lakehouse | Read, ReadAll, Write |
+| Warehouse | Read, ReadData, Write |
+| Notebook | Read, Write |
+
+## 3 - Domain Management
+
+Domains organize workspaces into logical groupings for governance.
+
+### List Domains
+
+```bash
+# List all domains (hidden entity)
+fab ls .domains -l
+
+# Get domain details
+fab get ".domains/Finance.Domain"
+```
+
+### Create and Configure Domains
+
+```bash
+# Create a new domain
+fab mkdir ".domains/Analytics.Domain"
+
+# Create domain with description
+fab api -X post "admin/domains" -i '{
+  "displayName": "Analytics",
+  "description": "Analytics team workspaces"
+}'
+```
+
+### Assign Workspaces to Domains
+
+```bash
+# Get domain ID
+DOMAIN_ID=$(fab get ".domains/Analytics.Domain" -q "id" | tr -d '"')
+
+# Assign workspace to domain
+fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i '{
+  "workspacesIds": ["<workspace-id-1>", "<workspace-id-2>"]
+}'
+
+# List workspaces in domain
+fab api "admin/domains/$DOMAIN_ID/workspaces"
+```
+
+### Domain Admins
+
+```bash
+# Add domain admin
+fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
+  "principals": [{"id": "<user-id>", "type": "User"}],
+  "role": "Admins"
+}'
+
+# List domain admins
+fab api "admin/domains/$DOMAIN_ID/roleAssignments"
+```
+
+## 4 - Capacity Management
+
+### List Capacities
+
+```bash
+# List all capacities (hidden entity)
+fab ls .capacities -l
+
+# Get capacity details
+fab get ".capacities/FabricCapacity1.Capacity"
+
+# Get capacity ID
+CAPACITY_ID=$(fab get ".capacities/FabricCapacity1.Capacity" -q "id" | tr -d '"')
+```
+
+### Assign Workspace to Capacity
+
+```bash
+# Assign workspace to capacity
+fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID
+
+# Unassign workspace from capacity (moves to shared capacity)
+fab unassign "Production.Workspace"
+
+# Create workspace on specific capacity
+fab mkdir "NewWorkspace.Workspace" -P capacityname=FabricCapacity1
+```
+
+### Monitor Capacity Usage
+
+```bash
+# Get capacity metrics via Azure API
+SUBSCRIPTION_ID="<subscription-id>"
+RESOURCE_GROUP="<resource-group>"
+CAPACITY_NAME="<capacity-name>"
+
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01"
+
+# List all Fabric capacities in subscription
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+```
+
+### Capacity SKUs
+
+```bash
+# Get available SKUs
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
+```
+
+## 5 - Sensitivity Labels
+
+### List Available Labels
+
+```bash
+# Get sensitivity labels from Purview
+fab api "admin/labels"
+
+# Query label details
+fab api "admin/labels" -q "value[?name=='Confidential']"
+```
+
+### Apply Labels to Items
+
+```bash
+# Get workspace and item IDs
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+ITEM_ID=$(fab get "Production.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
+LABEL_ID="<label-id>"
+
+# Apply label via API
+fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
+  \"labelId\": \"$LABEL_ID\"
+}"
+```
+
+### Bulk Label Application
+
+```bash
+#!/bin/bash
+# Apply label to all semantic models in workspace
+WORKSPACE="Production.Workspace"
+LABEL_ID="<confidential-label-id>"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Get all semantic models
+MODELS=$(fab api "workspaces/$WS_ID/items" -q "value[?type=='SemanticModel'].id")
+
+for MODEL_ID in $MODELS; do
+  fab api -X post "workspaces/$WS_ID/items/$MODEL_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
+  echo "Applied label to $MODEL_ID"
+done
+```
+
+## 6 - Audit and Monitoring
+
+### Access Audit Logs
+
+Fabric audit logs are available through Microsoft Purview or Office 365 Management API.
+
+```bash
+# Query activities via Admin API
+fab api "admin/activityEvents" -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z
+
+# Filter by activity type
+fab api "admin/activityEvents" -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z,activityType=ViewReport
+```
+
+### Common Audit Queries
+
+```bash
+# Get all workspace access events
+fab api "admin/activityEvents" -P activityType=GetWorkspaces
+
+# Get all export events
+fab api "admin/activityEvents" -P activityType=ExportReport
+
+# Get all sharing events
+fab api "admin/activityEvents" -P activityType=ShareReport
+```
+
+### Workspace Inventory
+
+```bash
+#!/bin/bash
+# Generate workspace inventory report
+echo "Workspace,ItemCount,Capacity,Domain" > inventory.csv
+
+WORKSPACES=$(fab api workspaces -q "value[].{name: displayName, id: id}")
+
+echo "$WORKSPACES" | jq -r '.[] | [.name, .id] | @tsv' | while IFS=$'\t' read -r NAME ID; do
+  ITEM_COUNT=$(fab api "workspaces/$ID/items" -q "value | length")
+  # Get capacity and domain info
+  WS_INFO=$(fab get "$NAME.Workspace" -v)
+  echo "$NAME,$ITEM_COUNT,..." >> inventory.csv
+done
+```
+
+## 7 - Managed Identities
+
+### List Workspace Managed Identities
+
+```bash
+# List managed identities (hidden entity)
+fab ls "Production.Workspace/.managedidentities"
+
+# Get managed identity details
+fab get "Production.Workspace/.managedidentities/default.ManagedIdentity"
+```
+
+### Configure Workspace Identity
+
+```bash
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+
+# Create workspace identity
+fab api -X post "workspaces/$WS_ID/assignToCapacity" -i '{
+  "identityType": "SystemAssigned"
+}'
+```
+
+## 8 - Connections and Gateways
+
+### List Connections
+
+```bash
+# List all connections (hidden entity)
+fab ls .connections -l
+
+# Get connection details
+fab get ".connections/SQLServerConnection.Connection"
+```
+
+### List Gateways
+
+```bash
+# List all gateways (hidden entity)
+fab ls .gateways -l
+
+# Get gateway details
+fab get ".gateways/OnPremGateway.Gateway"
+
+# List data sources on gateway
+GATEWAY_ID=$(fab get ".gateways/OnPremGateway.Gateway" -q "id" | tr -d '"')
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources"
+```
+
+## 9 - Security Patterns
+
+### Row-Level Security (RLS)
+
+RLS is configured within semantic models. Use CLI to manage model definitions:
+
+```bash
+# Export model with RLS configuration
+fab export "Production.Workspace/Sales.SemanticModel" -o ./model-backup -f
+
+# The TMDL definition contains RLS roles
+# Edit definition/roles/*.tmdl files
+
+# Re-import updated model
+fab import "Production.Workspace/Sales.SemanticModel" -i ./model-backup/Sales.SemanticModel -f
+```
+
+### OneLake Security
+
+```bash
+# Configure OneLake data access roles via API
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+LH_ID=$(fab get "Production.Workspace/Sales.Lakehouse" -q "id" | tr -d '"')
+
+# Get current data access roles
+fab api "workspaces/$WS_ID/lakehouses/$LH_ID/dataAccessRoles"
+```
+
+## 10 - Governance Best Practices
+
+### Permission Audit Checklist
+
+```bash
+#!/bin/bash
+# Audit script for workspace permissions
+
+WORKSPACE="Production.Workspace"
+
+echo "=== Permission Audit for $WORKSPACE ==="
+
+# List all permissions
+echo "Current Permissions:"
+fab acl get "$WORKSPACE" -l
+
+# Check for overly permissive access
+echo "Users with Admin role:"
+fab acl get "$WORKSPACE" -q "value[?role=='Admin']"
+
+# Check service principals
+echo "Service Principals with access:"
+fab acl get "$WORKSPACE" -q "value[?principalType=='App']"
+```
+
+### Security Recommendations
+
+1. **Principle of least privilege** - Grant minimum required permissions
+2. **Use security groups** - Manage permissions via groups, not individuals
+3. **Regular audits** - Review permissions quarterly
+4. **Service principal rotation** - Rotate credentials regularly
+5. **Sensitivity labels** - Apply labels to classify data
+6. **Domain organization** - Group workspaces by business function
+7. **Capacity isolation** - Separate dev/prod workloads
+
+## 11 - Common Governance Tasks
+
+### Offboard User
+
+```bash
+#!/bin/bash
+# Remove user from all workspaces
+USER="departing.user@company.com"
+
+WORKSPACES=$(fab api workspaces -q "value[].displayName")
+
+for WS in $WORKSPACES; do
+  fab acl del "$WS.Workspace" -P principal=$USER -f 2>/dev/null && \
+    echo "Removed from $WS" || echo "Not in $WS"
+done
+```
+
+### Transfer Ownership
+
+```bash
+# Transfer workspace admin
+OLD_ADMIN="old.admin@company.com"
+NEW_ADMIN="new.admin@company.com"
+WORKSPACE="Production.Workspace"
+
+# Add new admin first
+fab acl set "$WORKSPACE" -P principal=$NEW_ADMIN,role=Admin -f
+
+# Then remove old admin
+fab acl del "$WORKSPACE" -P principal=$OLD_ADMIN -f
+```
+
+## 12 - References
+
+For detailed governance patterns, see:
+
+- [references/workspace-permissions.md](./references/workspace-permissions.md) — ACL patterns and examples
+- [references/domain-management.md](./references/domain-management.md) — Domain configuration
+- [references/capacity-operations.md](./references/capacity-operations.md) — Capacity management
+- [references/sensitivity-labels.md](./references/sensitivity-labels.md) — Label application
+- [references/audit-patterns.md](./references/audit-patterns.md) — Audit and monitoring
diff --git a/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md b/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
new file mode 100644
index 000000000..9efe0cdf8
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
@@ -0,0 +1,282 @@
+# Audit Patterns Reference
+
+Guide to auditing and monitoring Fabric activities using the CLI.
+
+## Understanding Fabric Audit
+
+Fabric audit logs capture:
+- User activities (view, create, delete, share)
+- Admin operations (permission changes, capacity assignment)
+- API access and authentication events
+- Data access patterns
+
+Audit logs are available through:
+- Microsoft Purview Audit
+- Office 365 Management API
+- Fabric Admin API (limited)
+
+## Querying Activity Events
+
+### Basic Activity Query
+
+```bash
+# Get activities for date range
+fab api "admin/activityEvents" \
+  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z
+```
+
+### Filter by Activity Type
+
+```bash
+# View report activities
+fab api "admin/activityEvents" \
+  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z,activityType=ViewReport
+
+# Export activities
+fab api "admin/activityEvents" \
+  -P activityType=ExportReport
+
+# Share activities
+fab api "admin/activityEvents" \
+  -P activityType=ShareReport
+```
+
+### Common Activity Types
+
+| Activity Type | Description |
+|--------------|-------------|
+| `ViewReport` | Report viewed |
+| `ExportReport` | Report exported |
+| `ShareReport` | Report shared |
+| `CreateWorkspace` | Workspace created |
+| `DeleteWorkspace` | Workspace deleted |
+| `AddWorkspaceUser` | User added to workspace |
+| `DeleteWorkspaceUser` | User removed from workspace |
+| `RefreshDataset` | Dataset refreshed |
+| `GetDatasources` | Data sources queried |
+
+## Workspace Activity Audit
+
+### Audit Workspace Access
+
+```bash
+#!/bin/bash
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+
+# Get all activities for workspace
+fab api "admin/activityEvents" \
+  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-31T23:59:59Z \
+  -q "value[?workspaceId=='$WS_ID']"
+```
+
+### Permission Change Audit
+
+```bash
+# Track permission changes
+fab api "admin/activityEvents" \
+  -P activityType=AddWorkspaceUser
+
+fab api "admin/activityEvents" \
+  -P activityType=DeleteWorkspaceUser
+```
+
+## User Activity Audit
+
+### Query User Activities
+
+```bash
+# Get all activities by specific user
+fab api "admin/activityEvents" \
+  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-31T23:59:59Z \
+  -q "value[?userId=='user@company.com']"
+```
+
+### Login/Authentication Events
+
+```bash
+# Track authentication
+fab api "admin/activityEvents" \
+  -P activityType=GetWorkspaces
+```
+
+## Data Access Audit
+
+### Report View Tracking
+
+```bash
+#!/bin/bash
+# Track who viewed specific report
+REPORT_NAME="SalesReport"
+
+fab api "admin/activityEvents" \
+  -P activityType=ViewReport \
+  -q "value[?artifactName=='$REPORT_NAME']"
+```
+
+### Data Export Tracking
+
+```bash
+# Track data exports (potential data exfiltration)
+fab api "admin/activityEvents" \
+  -P activityType=ExportReport
+
+fab api "admin/activityEvents" \
+  -P activityType=ExportArtifact
+```
+
+## Automated Audit Reports
+
+### Daily Activity Summary
+
+```bash
+#!/bin/bash
+# Generate daily activity summary
+YESTERDAY=$(date -d "yesterday" +%Y-%m-%dT00:00:00Z)
+TODAY=$(date +%Y-%m-%dT00:00:00Z)
+
+echo "=== Fabric Activity Summary ===" > daily-audit.txt
+echo "Period: $YESTERDAY to $TODAY" >> daily-audit.txt
+echo "" >> daily-audit.txt
+
+# Count by activity type
+echo "Activity Counts:" >> daily-audit.txt
+fab api "admin/activityEvents" \
+  -P startDateTime=$YESTERDAY,endDateTime=$TODAY \
+  -q "value | group_by(@, &Activity) | {type: keys(@), count: values(@) | map(&length(@), @)}" >> daily-audit.txt
+```
+
+### Weekly Security Audit
+
+```bash
+#!/bin/bash
+WEEK_AGO=$(date -d "7 days ago" +%Y-%m-%dT00:00:00Z)
+NOW=$(date +%Y-%m-%dT23:59:59Z)
+
+echo "=== Weekly Security Audit ===" > security-audit.txt
+
+# Permission changes
+echo "Permission Changes:" >> security-audit.txt
+fab api "admin/activityEvents" \
+  -P startDateTime=$WEEK_AGO,endDateTime=$NOW,activityType=AddWorkspaceUser >> security-audit.txt
+
+# Exports
+echo "Data Exports:" >> security-audit.txt
+fab api "admin/activityEvents" \
+  -P startDateTime=$WEEK_AGO,endDateTime=$NOW,activityType=ExportReport >> security-audit.txt
+
+# Failed authentications
+echo "Authentication Issues:" >> security-audit.txt
+fab api "admin/activityEvents" \
+  -P startDateTime=$WEEK_AGO,endDateTime=$NOW \
+  -q "value[?contains(Activity, 'Failed')]" >> security-audit.txt
+```
+
+### Compliance Report
+
+```bash
+#!/bin/bash
+# Generate compliance report for sensitive workspaces
+WORKSPACE="Financial-Prod.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+START_DATE="2024-01-01T00:00:00Z"
+END_DATE="2024-01-31T23:59:59Z"
+
+echo "Compliance Report: $WORKSPACE" > compliance-report.csv
+echo "Date Range: $START_DATE to $END_DATE" >> compliance-report.csv
+echo "" >> compliance-report.csv
+echo "Timestamp,User,Activity,Artifact" >> compliance-report.csv
+
+fab api "admin/activityEvents" \
+  -P startDateTime=$START_DATE,endDateTime=$END_DATE \
+  -q "value[?workspaceId=='$WS_ID']" | \
+  jq -r '.[] | [.CreationTime, .UserId, .Activity, .ArtifactName] | @csv' >> compliance-report.csv
+```
+
+## Real-Time Monitoring
+
+### Alert on Sensitive Operations
+
+```bash
+#!/bin/bash
+# Monitor for sensitive operations (run periodically)
+LAST_HOUR=$(date -d "1 hour ago" +%Y-%m-%dT%H:%M:%SZ)
+NOW=$(date +%Y-%m-%dT%H:%M:%SZ)
+
+# Check for bulk exports
+EXPORTS=$(fab api "admin/activityEvents" \
+  -P startDateTime=$LAST_HOUR,endDateTime=$NOW,activityType=ExportReport \
+  -q "value | length")
+
+if [ "$EXPORTS" -gt 10 ]; then
+  echo "ALERT: High export activity detected: $EXPORTS exports in last hour"
+  # Send alert notification
+fi
+
+# Check for permission escalations
+ADMIN_ADDS=$(fab api "admin/activityEvents" \
+  -P startDateTime=$LAST_HOUR,endDateTime=$NOW,activityType=AddWorkspaceUser \
+  -q "value[?contains(AdditionalData, 'Admin')] | length")
+
+if [ "$ADMIN_ADDS" -gt 0 ]; then
+  echo "ALERT: Admin permission granted: $ADMIN_ADDS new admins"
+fi
+```
+
+## Audit Log Retention
+
+### Export Logs for Long-Term Storage
+
+```bash
+#!/bin/bash
+# Export audit logs to storage
+MONTH=$(date +%Y-%m)
+START_DATE="${MONTH}-01T00:00:00Z"
+END_DATE=$(date -d "${MONTH}-01 +1 month -1 day" +%Y-%m-%dT23:59:59Z)
+
+# Get all activities for month
+fab api "admin/activityEvents" \
+  -P startDateTime=$START_DATE,endDateTime=$END_DATE \
+  -o /archive/audit-logs-$MONTH.json
+
+# Upload to lakehouse for analysis
+fab cp /archive/audit-logs-$MONTH.json "Audit.Workspace/AuditLogs.Lakehouse/Files/logs/"
+```
+
+## Purview Integration
+
+### Query Purview Audit Logs
+
+For comprehensive audit, use Microsoft Purview:
+
+```bash
+# Purview audit logs provide:
+# - 90+ days retention
+# - Advanced filtering
+# - Search across Microsoft 365
+
+# Access via Purview portal or API
+# https://compliance.microsoft.com/auditlogsearch
+```
+
+## Troubleshooting
+
+### No Activity Events Returned
+
+- Check date range format (ISO 8601 with Z suffix)
+- Verify you have Fabric Admin role
+- Events may have 15-30 minute delay
+
+### Activity Type Not Found
+
+```bash
+# List available activity types
+fab api "admin/activityEvents" \
+  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z \
+  -q "value[].Activity | unique(@)"
+```
+
+### Rate Limiting
+
+- Audit API has rate limits
+- For large queries, paginate with continuation token
+- Consider exporting to lakehouse for analysis
diff --git a/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md b/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
new file mode 100644
index 000000000..52852f81b
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
@@ -0,0 +1,253 @@
+# Capacity Operations Reference
+
+Guide to managing Fabric capacities, workspace assignment, and capacity monitoring.
+
+## Understanding Capacities
+
+Fabric capacities are compute resources that power your workloads. Types include:
+
+| Capacity Type | Description | SKUs |
+|--------------|-------------|------|
+| Fabric Capacity | Full Fabric features | F2, F4, F8, F16, F32, F64, F128, F256, F512, F1024, F2048 |
+| Power BI Premium | Power BI focused | P1, P2, P3, P4, P5 |
+| Power BI Embedded | Embedding scenarios | A1-A6, EM1-EM3 |
+
+## Listing Capacities
+
+```bash
+# List all capacities (hidden entity)
+fab ls .capacities
+
+# List with details
+fab ls .capacities -l
+
+# Get specific capacity
+fab get ".capacities/FabricProd.Capacity"
+
+# Get capacity ID
+CAPACITY_ID=$(fab get ".capacities/FabricProd.Capacity" -q "id" | tr -d '"')
+```
+
+## Workspace Assignment
+
+### Assign Workspace to Capacity
+
+```bash
+# Assign using capacity ID
+CAPACITY_ID=$(fab get ".capacities/FabricProd.Capacity" -q "id" | tr -d '"')
+fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID
+
+# Force assignment (skip confirmation)
+fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID -f
+```
+
+### Assign During Workspace Creation
+
+```bash
+# Create workspace on specific capacity (by name)
+fab mkdir "NewWorkspace.Workspace" -P capacityname=FabricProd
+
+# Create workspace with no capacity (shared)
+fab mkdir "NewWorkspace.Workspace" -P capacityname=none
+```
+
+### Unassign from Capacity
+
+```bash
+# Move workspace to shared capacity
+fab unassign "Production.Workspace"
+
+# Force unassignment
+fab unassign "Production.Workspace" -f
+```
+
+### Check Workspace Capacity Assignment
+
+```bash
+# Get workspace details including capacity
+fab get "Production.Workspace" -v
+
+# Query capacity assignment
+fab get "Production.Workspace" -q "capacityId"
+```
+
+## Capacity Administration via Azure
+
+### List Capacities in Subscription
+
+```bash
+SUBSCRIPTION_ID="<subscription-id>"
+
+# List all Fabric capacities
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+
+# Filter by resource group
+RESOURCE_GROUP="<resource-group>"
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
+```
+
+### Get Capacity Details
+
+```bash
+CAPACITY_NAME="fabricprod"
+
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01"
+```
+
+### Available SKUs
+
+```bash
+# List all available Fabric SKUs
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
+
+# List SKUs available in specific location
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/locations/eastus/skus?api-version=2023-11-01"
+```
+
+## Capacity Operations
+
+### Pause Capacity
+
+```bash
+# Pause capacity (stops billing)
+fab api -A azure -X post "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/suspend?api-version=2023-11-01"
+```
+
+### Resume Capacity
+
+```bash
+# Resume paused capacity
+fab api -A azure -X post "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/resume?api-version=2023-11-01"
+```
+
+### Scale Capacity
+
+```bash
+# Scale to different SKU
+fab api -A azure -X patch "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01" -i '{
+  "sku": {
+    "name": "F64",
+    "tier": "Fabric"
+  }
+}'
+```
+
+## Capacity Monitoring
+
+### Get Capacity Metrics
+
+```bash
+# Query capacity utilization metrics
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/providers/microsoft.insights/metrics?api-version=2023-10-01&metricnames=CapacityUtilization"
+```
+
+### Capacity Admin Portal
+
+```bash
+# Get capacity settings via admin API
+fab api "admin/capacities"
+
+# Get specific capacity
+fab api "admin/capacities/$CAPACITY_ID"
+
+# Get workspaces on capacity
+fab api "admin/capacities/$CAPACITY_ID/workspaces"
+```
+
+## Bulk Capacity Operations
+
+### Move Multiple Workspaces
+
+```bash
+#!/bin/bash
+CAPACITY_ID="<target-capacity-id>"
+WORKSPACES=("Dev.Workspace" "Test.Workspace" "Staging.Workspace")
+
+for WS in "${WORKSPACES[@]}"; do
+  fab assign "$WS" -P capacityId=$CAPACITY_ID -f
+  echo "Moved $WS to capacity"
+done
+```
+
+### Capacity Inventory
+
+```bash
+#!/bin/bash
+echo "Capacity,SKU,WorkspaceCount,State" > capacity-report.csv
+
+# Get all capacities
+for CAP in $(fab ls .capacities -q "value[].displayName"); do
+  CAP_ID=$(fab get ".capacities/$CAP.Capacity" -q "id" | tr -d '"')
+  SKU=$(fab get ".capacities/$CAP.Capacity" -q "sku.name")
+  STATE=$(fab get ".capacities/$CAP.Capacity" -q "state")
+  WS_COUNT=$(fab api "admin/capacities/$CAP_ID/workspaces" -q "value | length" 2>/dev/null || echo "0")
+  echo "$CAP,$SKU,$WS_COUNT,$STATE" >> capacity-report.csv
+done
+```
+
+### Evacuate Capacity (Move All Workspaces)
+
+```bash
+#!/bin/bash
+SOURCE_CAPACITY="OldCapacity"
+TARGET_CAPACITY_ID="<new-capacity-id>"
+
+SOURCE_ID=$(fab get ".capacities/$SOURCE_CAPACITY.Capacity" -q "id" | tr -d '"')
+
+# Get all workspaces on source capacity
+WORKSPACES=$(fab api "admin/capacities/$SOURCE_ID/workspaces" -q "value[].name")
+
+for WS in $WORKSPACES; do
+  fab assign "$WS.Workspace" -P capacityId=$TARGET_CAPACITY_ID -f
+  echo "Moved $WS"
+done
+```
+
+## Capacity Planning
+
+### SKU Comparison
+
+| SKU | CU/s | Memory | Best For |
+|-----|------|--------|----------|
+| F2 | 2 | 3 GB | Dev/test |
+| F4 | 4 | 6 GB | Small teams |
+| F8 | 8 | 12 GB | Medium workloads |
+| F16 | 16 | 24 GB | Production |
+| F32 | 32 | 48 GB | Large workloads |
+| F64+ | 64+ | 96 GB+ | Enterprise |
+
+### Check Capacity Availability
+
+```bash
+# Check if capacity has available resources
+fab get ".capacities/FabricProd.Capacity" -q "state"
+
+# Should return "Active" for healthy capacity
+```
+
+## Troubleshooting
+
+### Workspace Won't Assign
+
+```bash
+# Check capacity state
+fab get ".capacities/TargetCapacity.Capacity" -q "state"
+
+# Verify you have capacity admin rights
+fab api "admin/capacities/$CAPACITY_ID" -q "admins"
+```
+
+### Capacity at Limit
+
+```bash
+# Check current utilization
+fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/providers/microsoft.insights/metrics?api-version=2023-10-01&metricnames=CapacityUtilization"
+
+# Consider scaling up or moving workspaces
+```
+
+### Permission Errors
+
+- Capacity assignment requires workspace Admin role
+- Capacity administration requires Capacity Admin role
+- Azure operations require appropriate RBAC permissions
diff --git a/.ai-assets/skills/fabric-cli-governance/references/domain-management.md b/.ai-assets/skills/fabric-cli-governance/references/domain-management.md
new file mode 100644
index 000000000..e804d29d2
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/references/domain-management.md
@@ -0,0 +1,277 @@
+# Domain Management Reference
+
+Guide to creating and managing domains for organizing Fabric workspaces.
+
+## Understanding Domains
+
+Domains are logical containers that group workspaces by business function, department, or project. They enable:
+
+- Centralized governance policies
+- Delegated administration
+- Organized workspace discovery
+- Consistent security settings
+
+## Listing Domains
+
+```bash
+# List all domains (hidden entity)
+fab ls .domains
+
+# List with details
+fab ls .domains -l
+
+# Get specific domain
+fab get ".domains/Finance.Domain"
+
+# Get domain ID
+DOMAIN_ID=$(fab get ".domains/Finance.Domain" -q "id" | tr -d '"')
+```
+
+## Creating Domains
+
+### Basic Domain Creation
+
+```bash
+# Create domain via CLI
+fab mkdir ".domains/Analytics.Domain"
+
+# Create via API with description
+fab api -X post "admin/domains" -i '{
+  "displayName": "Analytics",
+  "description": "Analytics and BI team workspaces"
+}'
+```
+
+### Domain with Parent
+
+```bash
+# Create sub-domain
+fab api -X post "admin/domains" -i '{
+  "displayName": "Sales Analytics",
+  "description": "Sales team analytics",
+  "parentDomainId": "<parent-domain-id>"
+}'
+```
+
+## Managing Domain Workspaces
+
+### Assign Workspaces to Domain
+
+```bash
+# Get domain ID
+DOMAIN_ID=$(fab get ".domains/Analytics.Domain" -q "id" | tr -d '"')
+
+# Assign single workspace
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i "{
+  \"workspacesIds\": [\"$WS_ID\"]
+}"
+
+# Assign multiple workspaces
+fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i '{
+  "workspacesIds": ["<ws-id-1>", "<ws-id-2>", "<ws-id-3>"]
+}'
+```
+
+### List Workspaces in Domain
+
+```bash
+# Get all workspaces assigned to domain
+fab api "admin/domains/$DOMAIN_ID/workspaces"
+
+# Count workspaces
+fab api "admin/domains/$DOMAIN_ID/workspaces" -q "value | length"
+```
+
+### Unassign Workspace from Domain
+
+```bash
+fab api -X post "admin/domains/$DOMAIN_ID/unassignWorkspaces" -i "{
+  \"workspacesIds\": [\"$WS_ID\"]
+}"
+```
+
+## Domain Roles
+
+### Domain Admin Role
+
+Domain admins can:
+- Manage workspaces assigned to the domain
+- Assign domain roles to others
+- View all items in domain workspaces
+
+```bash
+# Add domain admin
+fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
+  "principals": [
+    {"id": "<user-object-id>", "type": "User"}
+  ],
+  "role": "Admins"
+}'
+
+# Add group as domain admin
+fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
+  "principals": [
+    {"id": "<group-object-id>", "type": "Group"}
+  ],
+  "role": "Admins"
+}'
+```
+
+### Domain Contributor Role
+
+Domain contributors can:
+- Create workspaces in the domain
+- View domain workspaces
+
+```bash
+fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
+  "principals": [
+    {"id": "<user-object-id>", "type": "User"}
+  ],
+  "role": "Contributors"
+}'
+```
+
+### List Domain Role Assignments
+
+```bash
+# Get all role assignments
+fab api "admin/domains/$DOMAIN_ID/roleAssignments"
+
+# Get admins only
+fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?role=='Admins']"
+```
+
+### Remove Domain Role
+
+```bash
+# Get role assignment ID first
+ASSIGNMENT_ID=$(fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?principals[?id=='<user-id>']].id | [0]" | tr -d '"')
+
+# Remove role assignment
+fab api -X delete "admin/domains/$DOMAIN_ID/roleAssignments/$ASSIGNMENT_ID"
+```
+
+## Domain Configuration
+
+### Update Domain
+
+```bash
+# Update domain name and description
+fab api -X patch "admin/domains/$DOMAIN_ID" -i '{
+  "displayName": "Updated Name",
+  "description": "Updated description"
+}'
+```
+
+### Delete Domain
+
+```bash
+# Delete domain (workspaces become unassigned)
+fab api -X delete "admin/domains/$DOMAIN_ID"
+```
+
+## Domain Governance Patterns
+
+### Organize by Business Function
+
+```bash
+# Create department domains
+fab mkdir ".domains/Finance.Domain"
+fab mkdir ".domains/Marketing.Domain"
+fab mkdir ".domains/Sales.Domain"
+fab mkdir ".domains/Engineering.Domain"
+
+# Assign workspaces by department
+# Finance workspaces
+fab api -X post "admin/domains/<finance-domain-id>/assignWorkspaces" -i '{
+  "workspacesIds": ["<finance-ws-1>", "<finance-ws-2>"]
+}'
+```
+
+### Organize by Environment
+
+```bash
+# Create environment domains
+fab mkdir ".domains/Development.Domain"
+fab mkdir ".domains/Testing.Domain"
+fab mkdir ".domains/Production.Domain"
+```
+
+### Hierarchical Domain Structure
+
+```bash
+# Parent domain for division
+fab api -X post "admin/domains" -i '{
+  "displayName": "Data Platform"
+}'
+
+# Get parent domain ID
+PARENT_ID=$(fab get ".domains/DataPlatform.Domain" -q "id" | tr -d '"')
+
+# Child domains for teams
+fab api -X post "admin/domains" -i "{
+  \"displayName\": \"Data Engineering\",
+  \"parentDomainId\": \"$PARENT_ID\"
+}"
+
+fab api -X post "admin/domains" -i "{
+  \"displayName\": \"Data Science\",
+  \"parentDomainId\": \"$PARENT_ID\"
+}"
+```
+
+## Bulk Domain Operations
+
+### Assign All Team Workspaces
+
+```bash
+#!/bin/bash
+DOMAIN_ID="<domain-id>"
+TEAM_PREFIX="Analytics"
+
+# Find all workspaces starting with team prefix
+WS_IDS=$(fab api workspaces -q "value[?starts_with(displayName, '$TEAM_PREFIX')].id")
+
+# Convert to JSON array and assign
+echo "{\"workspacesIds\": $WS_IDS}" > /tmp/assign.json
+fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i /tmp/assign.json
+```
+
+### Domain Inventory Report
+
+```bash
+#!/bin/bash
+echo "Domain,WorkspaceCount,Admins" > domain-report.csv
+
+for DOMAIN in $(fab ls .domains -q "value[].displayName"); do
+  DOMAIN_ID=$(fab get ".domains/$DOMAIN.Domain" -q "id" | tr -d '"')
+  WS_COUNT=$(fab api "admin/domains/$DOMAIN_ID/workspaces" -q "value | length")
+  ADMIN_COUNT=$(fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?role=='Admins'] | length")
+  echo "$DOMAIN,$WS_COUNT,$ADMIN_COUNT" >> domain-report.csv
+done
+```
+
+## Troubleshooting
+
+### Cannot Create Domain
+
+- Verify you have Fabric Admin role
+- Check tenant settings for domain creation
+
+### Cannot Assign Workspace
+
+- Verify workspace exists
+- Check if workspace is already assigned to another domain
+- Ensure you have domain admin role
+
+### Domain Not Visible
+
+```bash
+# Domains are hidden entities, use .domains prefix
+fab ls .domains -l
+
+# Or use admin API
+fab api "admin/domains"
+```
diff --git a/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md b/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
new file mode 100644
index 000000000..aa47cf004
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
@@ -0,0 +1,249 @@
+# Sensitivity Labels Reference
+
+Guide to applying and managing Microsoft Purview sensitivity labels in Fabric.
+
+## Understanding Sensitivity Labels
+
+Sensitivity labels classify and protect data based on organizational policies:
+
+- **Public** — No restrictions
+- **Internal** — Organization-internal only
+- **Confidential** — Limited access
+- **Highly Confidential** — Strict access controls
+
+## Prerequisites
+
+- Sensitivity labels must be configured in Microsoft Purview
+- Labels must be published to users
+- User needs appropriate Fabric permissions
+
+## Listing Available Labels
+
+```bash
+# Get all available sensitivity labels
+fab api "admin/labels"
+
+# Query specific label
+fab api "admin/labels" -q "value[?name=='Confidential']"
+
+# Get label ID
+LABEL_ID=$(fab api "admin/labels" -q "value[?name=='Confidential'].id | [0]" | tr -d '"')
+```
+
+## Applying Labels
+
+### Apply Label to Item
+
+```bash
+# Get IDs
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+ITEM_ID=$(fab get "Production.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
+LABEL_ID="<label-id>"
+
+# Apply label
+fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
+  \"labelId\": \"$LABEL_ID\"
+}"
+```
+
+### Apply Label with Justification
+
+```bash
+# When downgrading label, justification may be required
+fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
+  \"labelId\": \"$LABEL_ID\",
+  \"assignmentMethod\": \"Standard\",
+  \"justificationText\": \"Data has been declassified per policy\"
+}"
+```
+
+### Remove Label
+
+```bash
+# Remove label from item
+fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/removeLabel" -i '{}'
+```
+
+## Viewing Item Labels
+
+### Check Item Label
+
+```bash
+# Get item details including label
+fab get "Production.Workspace/Sales.SemanticModel" -v
+
+# Query label specifically
+fab get "Production.Workspace/Sales.SemanticModel" -q "sensitivityLabel"
+```
+
+### List Labeled Items in Workspace
+
+```bash
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+
+# Get all items with their labels
+fab api "workspaces/$WS_ID/items" -q "value[].{name: displayName, type: type, label: sensitivityLabel}"
+```
+
+## Bulk Label Operations
+
+### Apply Label to All Items
+
+```bash
+#!/bin/bash
+WORKSPACE="Production.Workspace"
+LABEL_ID="<confidential-label-id>"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Get all items
+ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[].id")
+
+for ITEM_ID in $ITEMS; do
+  ITEM_ID=$(echo $ITEM_ID | tr -d '"')
+  fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}" 2>/dev/null && \
+    echo "Labeled item $ITEM_ID" || echo "Failed to label $ITEM_ID"
+done
+```
+
+### Apply Label by Item Type
+
+```bash
+#!/bin/bash
+WORKSPACE="Production.Workspace"
+LABEL_ID="<label-id>"
+ITEM_TYPE="SemanticModel"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Get items of specific type
+ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[?type=='$ITEM_TYPE'].id")
+
+for ITEM_ID in $ITEMS; do
+  ITEM_ID=$(echo $ITEM_ID | tr -d '"')
+  fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
+  echo "Applied label to $ITEM_ID"
+done
+```
+
+### Label Audit Report
+
+```bash
+#!/bin/bash
+echo "Workspace,Item,Type,Label" > label-audit.csv
+
+for WS in $(fab ls -q "value[].displayName"); do
+  WS_ID=$(fab get "$WS.Workspace" -q "id" | tr -d '"')
+  
+  fab api "workspaces/$WS_ID/items" -q "value[]" | \
+  jq -r ".[] | [\"$WS\", .displayName, .type, (.sensitivityLabel.labelId // \"none\")] | @csv" >> label-audit.csv
+done
+```
+
+## Label Policies
+
+### Mandatory Labeling
+
+When mandatory labeling is enabled:
+
+```bash
+# All new items must have labels
+# Use --label parameter when creating (if supported)
+# Or apply immediately after creation
+
+# Create item
+fab mkdir "Production.Workspace/NewModel.SemanticModel"
+
+# Apply label
+WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
+ITEM_ID=$(fab get "Production.Workspace/NewModel.SemanticModel" -q "id" | tr -d '"')
+fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
+```
+
+### Label Inheritance
+
+Labels can be inherited from:
+- Parent workspace
+- Source item (when copying)
+- Data source
+
+```bash
+# When copying items, label may be inherited
+fab cp "Source.Workspace/LabeledModel.SemanticModel" "Target.Workspace"
+
+# Verify label was inherited
+fab get "Target.Workspace/LabeledModel.SemanticModel" -q "sensitivityLabel"
+```
+
+## Label Encryption
+
+### Encrypted Labels
+
+Some labels apply encryption:
+
+```bash
+# Items with encrypted labels have restricted access
+# Verify label encryption settings
+fab api "admin/labels" -q "value[?name=='HighlyConfidential'].encryptionEnabled"
+```
+
+### Impact on Operations
+
+- Encrypted items may require additional permissions
+- Export operations may be blocked
+- Sharing may be restricted
+
+## Compliance Scenarios
+
+### Financial Data Classification
+
+```bash
+#!/bin/bash
+# Apply financial data labels
+FINANCIAL_LABEL=$(fab api "admin/labels" -q "value[?name=='Financial-Confidential'].id | [0]" | tr -d '"')
+
+# Label all financial workspaces
+for WS in Finance-Prod Finance-Dev Finance-Reports; do
+  WS_ID=$(fab get "$WS.Workspace" -q "id" | tr -d '"')
+  ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[].id")
+  
+  for ITEM_ID in $ITEMS; do
+    fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$FINANCIAL_LABEL\"}" 2>/dev/null
+  done
+done
+```
+
+### PII Data Protection
+
+```bash
+# Find items potentially containing PII
+# Apply appropriate label
+PII_LABEL=$(fab api "admin/labels" -q "value[?name=='PII-Restricted'].id | [0]" | tr -d '"')
+
+# Apply to customer data items
+fab api -X post "workspaces/$WS_ID/items/$CUSTOMER_DATA_ID/applyLabel" -i "{\"labelId\": \"$PII_LABEL\"}"
+```
+
+## Troubleshooting
+
+### Label Not Available
+
+```bash
+# Check if label is published to you
+fab api "admin/labels"
+
+# Contact Purview admin if label not visible
+```
+
+### Cannot Apply Label
+
+- Verify you have Write permission on item
+- Check if downgrade requires justification
+- Ensure label is in your scope
+
+### Label Conflicts
+
+```bash
+# When importing items with different labels
+# The import may fail or require resolution
+# Check current label before import
+fab get "Target.Workspace/ExistingItem.SemanticModel" -q "sensitivityLabel"
+```
diff --git a/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md b/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
new file mode 100644
index 000000000..65f2ff441
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
@@ -0,0 +1,249 @@
+# Workspace Permissions Reference
+
+Comprehensive guide to managing workspace and item permissions with the Fabric CLI.
+
+## Workspace Role Capabilities
+
+### Admin Role
+
+```bash
+# Full capabilities:
+# - Delete workspace
+# - Add/remove all roles
+# - Manage permissions
+# - All Member capabilities
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Admin
+```
+
+### Member Role
+
+```bash
+# Capabilities:
+# - Create/modify/delete items
+# - Share items with others
+# - Add Contributors and Viewers
+# - Cannot add Admins or Members
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Member
+```
+
+### Contributor Role
+
+```bash
+# Capabilities:
+# - Create/modify/delete items
+# - Cannot share items
+# - Cannot manage permissions
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
+```
+
+### Viewer Role
+
+```bash
+# Capabilities:
+# - View all items
+# - Run queries (SQL/DAX)
+# - Cannot modify items
+# - Cannot access OneLake directly
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Viewer
+```
+
+## Principal Types
+
+### User Principals
+
+```bash
+# Add individual user
+fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
+
+# Using object ID
+fab acl set "Workspace.Workspace" -P principal=<user-object-id>,role=Contributor,principalType=User
+```
+
+### Security Groups
+
+```bash
+# Add security group (recommended for scale)
+fab acl set "Workspace.Workspace" -P principal=DataEngineers@company.com,role=Contributor,principalType=Group
+
+# Using group object ID
+fab acl set "Workspace.Workspace" -P principal=<group-object-id>,role=Viewer,principalType=Group
+```
+
+### Service Principals
+
+```bash
+# Add service principal (for automation)
+fab acl set "Workspace.Workspace" -P principal=<app-id>,role=Contributor,principalType=App
+
+# Service principal for CI/CD
+fab acl set "Production.Workspace" -P principal=<cicd-app-id>,role=Member,principalType=App
+```
+
+## Viewing Permissions
+
+### List All Permissions
+
+```bash
+# Basic listing
+fab acl get "Workspace.Workspace"
+
+# Detailed output
+fab acl get "Workspace.Workspace" -l
+
+# JSON output for parsing
+fab acl get "Workspace.Workspace" -o json
+```
+
+### Filter Permissions
+
+```bash
+# Get admins only
+fab acl get "Workspace.Workspace" -q "value[?role=='Admin']"
+
+# Get service principals
+fab acl get "Workspace.Workspace" -q "value[?principalType=='App']"
+
+# Get specific user
+fab acl get "Workspace.Workspace" -q "value[?principal=='user@company.com']"
+```
+
+## Removing Permissions
+
+```bash
+# Remove user
+fab acl del "Workspace.Workspace" -P principal=user@company.com
+
+# Remove with force (no confirmation)
+fab acl del "Workspace.Workspace" -P principal=user@company.com -f
+
+# Remove service principal
+fab acl del "Workspace.Workspace" -P principal=<app-id>
+```
+
+## Item-Level Permissions
+
+### Share Semantic Model
+
+```bash
+# Read permission (view only)
+fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Read
+
+# Build permission (connect and create reports)
+fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Build
+
+# Write permission (full access)
+fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Write
+```
+
+### Share Report
+
+```bash
+# Share report for viewing
+fab acl set "Workspace.Workspace/Report.Report" -P principal=user@company.com,role=Read
+
+# Share with edit permission
+fab acl set "Workspace.Workspace/Report.Report" -P principal=user@company.com,role=Write
+```
+
+### Share Lakehouse
+
+```bash
+# Read access
+fab acl set "Workspace.Workspace/LH.Lakehouse" -P principal=user@company.com,role=Read
+
+# Full data access
+fab acl set "Workspace.Workspace/LH.Lakehouse" -P principal=user@company.com,role=ReadAll
+```
+
+## Bulk Operations
+
+### Add Multiple Users
+
+```bash
+#!/bin/bash
+WORKSPACE="Production.Workspace"
+ROLE="Viewer"
+
+# Users file: one email per line
+while read USER; do
+  fab acl set "$WORKSPACE" -P principal=$USER,role=$ROLE -f
+  echo "Added $USER as $ROLE"
+done < users.txt
+```
+
+### Clone Permissions Between Workspaces
+
+```bash
+#!/bin/bash
+SOURCE_WS="Dev.Workspace"
+TARGET_WS="Test.Workspace"
+
+# Export source permissions
+fab acl get "$SOURCE_WS" -o json > /tmp/permissions.json
+
+# Apply to target (parse and apply each)
+jq -r '.value[] | [.principal, .role, .principalType] | @tsv' /tmp/permissions.json | \
+while IFS=$'\t' read -r PRINCIPAL ROLE TYPE; do
+  fab acl set "$TARGET_WS" -P principal=$PRINCIPAL,role=$ROLE,principalType=$TYPE -f
+done
+```
+
+### Audit All Workspace Permissions
+
+```bash
+#!/bin/bash
+# Generate permission report across all workspaces
+echo "Workspace,Principal,Role,Type" > permissions-audit.csv
+
+for WS in $(fab ls -q "value[].displayName"); do
+  fab acl get "$WS.Workspace" -o json | \
+  jq -r ".value[] | [\"$WS\", .principal, .role, .principalType] | @csv" >> permissions-audit.csv
+done
+```
+
+## Permission Inheritance
+
+### Workspace to Item
+
+- Workspace Admins/Members/Contributors → Full item access
+- Workspace Viewers → Read-only item access
+- Item-level permissions can extend (not restrict) workspace permissions
+
+### Sharing with External Users
+
+```bash
+# External sharing must be enabled by admin
+# Then share with external user
+fab acl set "Workspace.Workspace/Report.Report" -P principal=external@partner.com,role=Read
+```
+
+## Troubleshooting
+
+### Permission Denied Errors
+
+```bash
+# Check your current permissions
+fab acl get "Workspace.Workspace" -q "value[?principal=='<your-email>']"
+
+# Verify authentication
+fab auth status
+```
+
+### Cannot Add Permissions
+
+```bash
+# Verify you have Admin or Member role
+fab acl get "Workspace.Workspace" -l
+
+# Check if user exists in tenant
+# Contact Azure AD admin if user not found
+```
+
+### Service Principal Access Issues
+
+```bash
+# Verify SPN has Fabric API permissions in Azure AD
+# Check tenant admin settings for SPN access to Fabric
+# Ensure SPN is added with correct principalType=App
+fab acl set "Workspace.Workspace" -P principal=<app-id>,role=Contributor,principalType=App
+```
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py b/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
new file mode 100644
index 000000000..2b80ecca3
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+audit_workspace.py - Generate comprehensive workspace audit report
+
+This script generates a comprehensive audit report for a Microsoft Fabric workspace,
+including permissions, item inventory, capacity assignment, and more.
+
+Usage:
+    python audit_workspace.py <workspace> -o <report.json>
+    python audit_workspace.py Production.Workspace -o audit_report.json
+
+Exit codes:
+    0 - Audit completed successfully
+    1 - Error during audit
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI, handling potential formatting issues."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def get_workspace_details(workspace: str) -> Dict[str, Any]:
+    """Get workspace metadata."""
+    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {"error": "Failed to parse workspace details"}
+    return {"error": stderr.strip() or "Failed to get workspace details"}
+
+
+def get_workspace_permissions(workspace: str) -> List[Dict[str, Any]]:
+    """Get all workspace permissions."""
+    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, list):
+            return result
+        return []
+    return []
+
+
+def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
+    """Get all items in the workspace."""
+    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, list):
+            return result
+        return []
+    return []
+
+
+def get_item_type_summary(items: List[Dict[str, Any]]) -> Dict[str, int]:
+    """Summarize items by type."""
+    type_counts = {}
+    for item in items:
+        item_type = item.get("type", "Unknown")
+        type_counts[item_type] = type_counts.get(item_type, 0) + 1
+    return type_counts
+
+
+def get_capacity_info(workspace_details: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract capacity information from workspace details."""
+    capacity_info = {
+        "capacity_id": workspace_details.get("capacityId"),
+        "capacity_assigned": workspace_details.get("capacityId") is not None
+    }
+    return capacity_info
+
+
+def check_item_labels(workspace: str, items: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Check sensitivity labels on items."""
+    labeled_items = []
+    unlabeled_items = []
+    
+    for item in items:
+        item_name = item.get("name", "Unknown")
+        item_type = item.get("type", "Unknown")
+        item_path = f"{workspace}/{item_name}.{item_type}"
+        
+        # Try to get label info (this may not be available for all items)
+        exit_code, stdout, stderr = run_fab_command(["get", item_path, "-q", "sensitivityLabel", "-f", "json"])
+        
+        if exit_code == 0 and stdout.strip() and stdout.strip() != "null":
+            labeled_items.append({
+                "name": item_name,
+                "type": item_type,
+                "label": parse_json_output(stdout)
+            })
+        else:
+            unlabeled_items.append({
+                "name": item_name,
+                "type": item_type
+            })
+    
+    return {
+        "total_items": len(items),
+        "labeled_count": len(labeled_items),
+        "unlabeled_count": len(unlabeled_items),
+        "labeled_items": labeled_items,
+        "unlabeled_items": unlabeled_items
+    }
+
+
+def generate_audit_report(workspace: str, check_labels: bool = False) -> Dict[str, Any]:
+    """Generate comprehensive audit report for workspace."""
+    workspace = ensure_workspace_suffix(workspace)
+    
+    report = {
+        "audit_metadata": {
+            "workspace": workspace,
+            "generated_at": datetime.utcnow().isoformat() + "Z",
+            "audit_version": "1.0.0"
+        },
+        "workspace_details": {},
+        "permissions": {
+            "summary": {},
+            "details": []
+        },
+        "items": {
+            "summary": {},
+            "by_type": {},
+            "details": []
+        },
+        "capacity": {},
+        "labels": {},
+        "issues": []
+    }
+    
+    print(f"Auditing workspace: {workspace}")
+    
+    # Get workspace details
+    print("  Fetching workspace details...")
+    workspace_details = get_workspace_details(workspace)
+    if "error" in workspace_details:
+        report["issues"].append({
+            "severity": "high",
+            "message": f"Failed to get workspace details: {workspace_details['error']}"
+        })
+        report["workspace_details"] = {"error": workspace_details["error"]}
+    else:
+        report["workspace_details"] = workspace_details
+        report["capacity"] = get_capacity_info(workspace_details)
+    
+    # Get permissions
+    print("  Fetching permissions...")
+    permissions = get_workspace_permissions(workspace)
+    report["permissions"]["details"] = permissions
+    report["permissions"]["summary"] = {
+        "total_principals": len(permissions),
+        "by_role": {}
+    }
+    
+    for perm in permissions:
+        role = perm.get("role", "Unknown")
+        report["permissions"]["summary"]["by_role"][role] = \
+            report["permissions"]["summary"]["by_role"].get(role, 0) + 1
+    
+    # Get items
+    print("  Fetching items...")
+    items = get_workspace_items(workspace)
+    report["items"]["details"] = items
+    report["items"]["summary"]["total_items"] = len(items)
+    report["items"]["by_type"] = get_item_type_summary(items)
+    
+    # Check labels (optional - can be slow)
+    if check_labels:
+        print("  Checking sensitivity labels...")
+        report["labels"] = check_item_labels(workspace, items)
+    else:
+        report["labels"] = {"note": "Label check skipped. Use --check-labels to include."}
+    
+    # Check for potential issues
+    if not report["capacity"].get("capacity_assigned"):
+        report["issues"].append({
+            "severity": "medium",
+            "message": "Workspace is not assigned to a capacity"
+        })
+    
+    if report["permissions"]["summary"]["total_principals"] == 0:
+        report["issues"].append({
+            "severity": "high",
+            "message": "No permissions found for workspace"
+        })
+    
+    print(f"  Audit complete. Found {len(report['issues'])} issue(s).")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate comprehensive workspace audit report",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python audit_workspace.py Production.Workspace -o audit_report.json
+    python audit_workspace.py Dev.Workspace -o audit.json --check-labels
+    python audit_workspace.py "My Workspace" -o report.json
+        """
+    )
+    parser.add_argument(
+        "workspace",
+        help="Workspace name or path to audit"
+    )
+    parser.add_argument(
+        "-o", "--output",
+        required=True,
+        help="Output file path for the audit report (JSON)"
+    )
+    parser.add_argument(
+        "--check-labels",
+        action="store_true",
+        help="Include sensitivity label check (can be slow for large workspaces)"
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Print report to stdout in addition to file"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = generate_audit_report(args.workspace, check_labels=args.check_labels)
+        
+        # Write to file
+        with open(args.output, "w", encoding="utf-8") as f:
+            json.dump(report, f, indent=2)
+        
+        print(f"\nAudit report saved to: {args.output}")
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("AUDIT SUMMARY")
+        print("=" * 50)
+        print(f"Workspace: {report['audit_metadata']['workspace']}")
+        print(f"Total Items: {report['items']['summary'].get('total_items', 0)}")
+        print(f"Total Principals: {report['permissions']['summary'].get('total_principals', 0)}")
+        print(f"Capacity Assigned: {report['capacity'].get('capacity_assigned', 'Unknown')}")
+        print(f"Issues Found: {len(report['issues'])}")
+        
+        if report["issues"]:
+            print("\nIssues:")
+            for issue in report["issues"]:
+                print(f"  [{issue['severity'].upper()}] {issue['message']}")
+        
+        print("=" * 50)
+        
+        sys.exit(0 if len(report["issues"]) == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py b/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
new file mode 100644
index 000000000..a47bb9fde
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+bulk_permissions.py - Apply permissions from CSV/JSON file
+
+This script applies workspace permissions in bulk from a structured input file.
+It supports CSV and JSON formats and provides dry-run capability.
+
+Usage:
+    python bulk_permissions.py <workspace> -i <perms.csv>
+    python bulk_permissions.py Production.Workspace -i permissions.csv --dry-run
+
+Input CSV format:
+    principal,role,principalType
+    user@company.com,Contributor,User
+    DataTeam@company.com,Viewer,Group
+
+Input JSON format:
+    [
+        {"principal": "user@company.com", "role": "Contributor", "principalType": "User"},
+        {"principal": "DataTeam@company.com", "role": "Viewer", "principalType": "Group"}
+    ]
+
+Exit codes:
+    0 - All permissions applied successfully
+    1 - Some permissions failed to apply
+"""
+
+import argparse
+import csv
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Any, List
+
+
+# Valid roles for workspace permissions
+VALID_ROLES = ["Admin", "Member", "Contributor", "Viewer"]
+
+# Valid principal types
+VALID_PRINCIPAL_TYPES = ["User", "Group", "ServicePrincipal"]
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def check_workspace_exists(workspace: str) -> bool:
+    """Check if workspace exists."""
+    exit_code, _, _ = run_fab_command(["exists", workspace])
+    return exit_code == 0
+
+
+def load_permissions_csv(file_path: str) -> List[Dict[str, str]]:
+    """Load permissions from CSV file."""
+    permissions = []
+    with open(file_path, "r", encoding="utf-8-sig") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            # Normalize column names (handle case variations)
+            normalized = {}
+            for key, value in row.items():
+                key_lower = key.lower().strip()
+                if key_lower in ["principal", "principalid", "principal_id"]:
+                    normalized["principal"] = value.strip()
+                elif key_lower in ["role", "rolename", "role_name"]:
+                    normalized["role"] = value.strip()
+                elif key_lower in ["principaltype", "principal_type", "type"]:
+                    normalized["principalType"] = value.strip()
+            
+            if normalized.get("principal") and normalized.get("role"):
+                permissions.append(normalized)
+    
+    return permissions
+
+
+def load_permissions_json(file_path: str) -> List[Dict[str, str]]:
+    """Load permissions from JSON file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    
+    if isinstance(data, list):
+        return data
+    elif isinstance(data, dict) and "permissions" in data:
+        return data["permissions"]
+    else:
+        raise ValueError("JSON must be an array or object with 'permissions' array")
+
+
+def load_permissions(file_path: str) -> List[Dict[str, str]]:
+    """Load permissions from file (auto-detect format)."""
+    path = Path(file_path)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    
+    suffix = path.suffix.lower()
+    
+    if suffix == ".csv":
+        return load_permissions_csv(file_path)
+    elif suffix == ".json":
+        return load_permissions_json(file_path)
+    else:
+        # Try JSON first, then CSV
+        try:
+            return load_permissions_json(file_path)
+        except (json.JSONDecodeError, ValueError):
+            return load_permissions_csv(file_path)
+
+
+def validate_permission(perm: Dict[str, str], index: int) -> List[str]:
+    """Validate a permission entry. Returns list of errors."""
+    errors = []
+    
+    if not perm.get("principal"):
+        errors.append(f"Row {index + 1}: Missing 'principal' field")
+    
+    if not perm.get("role"):
+        errors.append(f"Row {index + 1}: Missing 'role' field")
+    elif perm["role"] not in VALID_ROLES:
+        errors.append(f"Row {index + 1}: Invalid role '{perm['role']}'. Valid roles: {', '.join(VALID_ROLES)}")
+    
+    principal_type = perm.get("principalType", "User")
+    if principal_type not in VALID_PRINCIPAL_TYPES:
+        errors.append(f"Row {index + 1}: Invalid principalType '{principal_type}'. Valid types: {', '.join(VALID_PRINCIPAL_TYPES)}")
+    
+    return errors
+
+
+def get_current_permissions(workspace: str) -> List[Dict[str, Any]]:
+    """Get current workspace permissions."""
+    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        try:
+            result = json.loads(stdout.strip())
+            if isinstance(result, list):
+                return result
+        except json.JSONDecodeError:
+            pass
+    
+    return []
+
+
+def apply_permission(workspace: str, principal: str, role: str, principal_type: str = "User") -> Dict[str, Any]:
+    """Apply a single permission to the workspace."""
+    result = {
+        "principal": principal,
+        "role": role,
+        "principalType": principal_type,
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Build the acl set command
+    cmd = ["acl", "set", workspace, "-p", principal, "-r", role, "-t", principal_type, "-f"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = f"Permission set: {principal} -> {role}"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "Failed to set permission"
+    
+    return result
+
+
+def bulk_apply_permissions(
+    workspace: str,
+    permissions: List[Dict[str, str]],
+    dry_run: bool = False,
+    skip_validation: bool = False
+) -> Dict[str, Any]:
+    """Apply permissions in bulk to the workspace."""
+    
+    workspace = ensure_workspace_suffix(workspace)
+    
+    report = {
+        "workspace": workspace,
+        "dry_run": dry_run,
+        "total_permissions": len(permissions),
+        "validation_errors": [],
+        "results": [],
+        "summary": {
+            "success": 0,
+            "failed": 0,
+            "skipped": 0
+        }
+    }
+    
+    # Validate all permissions first
+    if not skip_validation:
+        print("Validating permissions...")
+        for i, perm in enumerate(permissions):
+            errors = validate_permission(perm, i)
+            report["validation_errors"].extend(errors)
+        
+        if report["validation_errors"]:
+            print(f"  Found {len(report['validation_errors'])} validation error(s)")
+            for error in report["validation_errors"]:
+                print(f"    - {error}")
+            return report
+        
+        print(f"  All {len(permissions)} permission(s) validated successfully")
+    
+    # Check workspace exists
+    print(f"\nVerifying workspace: {workspace}")
+    if not check_workspace_exists(workspace):
+        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
+        report["validation_errors"].append(f"Workspace not found: {workspace}")
+        return report
+    print("  Workspace found")
+    
+    # Get current permissions for comparison
+    current_perms = get_current_permissions(workspace)
+    current_lookup = {p.get("principal", {}).get("id", ""): p.get("role") for p in current_perms}
+    
+    if dry_run:
+        print(f"\n[DRY RUN] Would apply the following permissions:")
+        for perm in permissions:
+            principal = perm["principal"]
+            role = perm["role"]
+            principal_type = perm.get("principalType", "User")
+            print(f"  {principal} ({principal_type}) -> {role}")
+        return report
+    
+    # Apply each permission
+    print(f"\nApplying {len(permissions)} permission(s)...")
+    for perm in permissions:
+        principal = perm["principal"]
+        role = perm["role"]
+        principal_type = perm.get("principalType", "User")
+        
+        print(f"\n  Setting permission: {principal} -> {role}")
+        result = apply_permission(workspace, principal, role, principal_type)
+        report["results"].append(result)
+        
+        if result["status"] == "success":
+            report["summary"]["success"] += 1
+            print(f"    ✓ {result['message']}")
+        else:
+            report["summary"]["failed"] += 1
+            print(f"    ✗ {result['message']}")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Apply permissions from CSV/JSON file to a workspace",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python bulk_permissions.py Production.Workspace -i permissions.csv
+    python bulk_permissions.py Production.Workspace -i permissions.json --dry-run
+    python bulk_permissions.py "My Workspace" -i perms.csv
+
+Input CSV format:
+    principal,role,principalType
+    user@company.com,Contributor,User
+    DataTeam@company.com,Viewer,Group
+    12345678-1234-1234-1234-123456789abc,Admin,ServicePrincipal
+
+Input JSON format:
+    [
+        {"principal": "user@company.com", "role": "Contributor", "principalType": "User"},
+        {"principal": "DataTeam@company.com", "role": "Viewer", "principalType": "Group"}
+    ]
+
+Valid Roles:
+    Admin, Member, Contributor, Viewer
+
+Valid Principal Types:
+    User, Group, ServicePrincipal
+        """
+    )
+    parser.add_argument(
+        "workspace",
+        help="Workspace name or path to apply permissions to"
+    )
+    parser.add_argument(
+        "-i", "--input",
+        required=True,
+        help="Input file path (CSV or JSON)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview changes without applying them"
+    )
+    parser.add_argument(
+        "--skip-validation",
+        action="store_true",
+        help="Skip validation of permission entries"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        # Load permissions from file
+        print(f"Loading permissions from: {args.input}")
+        permissions = load_permissions(args.input)
+        print(f"  Loaded {len(permissions)} permission(s)")
+        
+        if not permissions:
+            print("No permissions found in input file")
+            sys.exit(1)
+        
+        # Apply permissions
+        report = bulk_apply_permissions(
+            workspace=args.workspace,
+            permissions=permissions,
+            dry_run=args.dry_run,
+            skip_validation=args.skip_validation
+        )
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("BULK PERMISSIONS SUMMARY")
+        print("=" * 50)
+        print(f"Workspace: {report['workspace']}")
+        print(f"Dry Run: {report['dry_run']}")
+        print(f"Total Permissions: {report['total_permissions']}")
+        
+        if report["validation_errors"]:
+            print(f"Validation Errors: {len(report['validation_errors'])}")
+        else:
+            print(f"\nResults:")
+            print(f"  Success: {report['summary']['success']}")
+            print(f"  Failed: {report['summary']['failed']}")
+            print(f"  Skipped: {report['summary']['skipped']}")
+        
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        # Exit code based on failures
+        has_errors = len(report["validation_errors"]) > 0 or report["summary"]["failed"] > 0
+        sys.exit(1 if has_errors else 0)
+        
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py b/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
new file mode 100644
index 000000000..a9f53d6f2
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
@@ -0,0 +1,688 @@
+#!/usr/bin/env python3
+"""
+validate_governance.py - Check workspace against governance rules
+
+This script validates a Microsoft Fabric workspace against a set of governance rules
+defined in a JSON configuration file.
+
+Usage:
+    python validate_governance.py <workspace> --rules <rules.json>
+    python validate_governance.py Production.Workspace --rules company-rules.json
+
+Exit codes:
+    0 - All governance checks passed
+    1 - Governance violations found or error occurred
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI, handling potential formatting issues."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def load_rules(rules_file: str) -> Dict[str, Any]:
+    """Load governance rules from JSON file."""
+    path = Path(rules_file)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"Rules file not found: {rules_file}")
+    
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def get_workspace_details(workspace: str) -> Dict[str, Any]:
+    """Get workspace metadata."""
+    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {"error": "Failed to parse workspace details"}
+    return {"error": stderr.strip() or "Failed to get workspace details"}
+
+
+def get_workspace_permissions(workspace: str) -> List[Dict[str, Any]]:
+    """Get all workspace permissions."""
+    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, list):
+            return result
+        return []
+    return []
+
+
+def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
+    """Get all items in the workspace."""
+    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, list):
+            return result
+        return []
+    return []
+
+
+def get_item_labels(workspace: str) -> List[Dict[str, Any]]:
+    """Get sensitivity labels for items in workspace."""
+    exit_code, stdout, stderr = run_fab_command(["labels", "list", workspace, "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, list):
+            return result
+        return []
+    return []
+
+
+class GovernanceValidator:
+    """Validates workspace against governance rules."""
+    
+    def __init__(self, workspace: str, rules: Dict[str, Any], verbose: bool = False):
+        self.workspace = ensure_workspace_suffix(workspace)
+        self.rules = rules
+        self.verbose = verbose
+        self.violations: List[Dict[str, Any]] = []
+        self.warnings: List[Dict[str, Any]] = []
+        self.passed_checks: List[str] = []
+        
+        # Cached data
+        self.workspace_details: Optional[Dict[str, Any]] = None
+        self.permissions: Optional[List[Dict[str, Any]]] = None
+        self.items: Optional[List[Dict[str, Any]]] = None
+        self.labels: Optional[List[Dict[str, Any]]] = None
+    
+    def log(self, message: str):
+        """Print message if verbose mode is enabled."""
+        if self.verbose:
+            print(message, file=sys.stderr)
+    
+    def add_violation(self, rule: str, message: str, severity: str = "error", details: Any = None):
+        """Add a governance violation."""
+        self.violations.append({
+            "rule": rule,
+            "message": message,
+            "severity": severity,
+            "details": details
+        })
+    
+    def add_warning(self, rule: str, message: str, details: Any = None):
+        """Add a governance warning."""
+        self.warnings.append({
+            "rule": rule,
+            "message": message,
+            "details": details
+        })
+    
+    def add_passed(self, rule: str):
+        """Mark a rule as passed."""
+        self.passed_checks.append(rule)
+    
+    def load_workspace_data(self) -> bool:
+        """Load all workspace data needed for validation."""
+        self.log(f"Loading workspace data for: {self.workspace}")
+        
+        # Get workspace details
+        self.log("  Fetching workspace details...")
+        self.workspace_details = get_workspace_details(self.workspace)
+        if "error" in self.workspace_details:
+            print(f"Error: Failed to get workspace details: {self.workspace_details['error']}", file=sys.stderr)
+            return False
+        
+        # Get permissions
+        self.log("  Fetching permissions...")
+        self.permissions = get_workspace_permissions(self.workspace)
+        
+        # Get items
+        self.log("  Fetching items...")
+        self.items = get_workspace_items(self.workspace)
+        
+        # Get labels (optional - may not be available)
+        self.log("  Fetching labels...")
+        self.labels = get_item_labels(self.workspace)
+        
+        return True
+    
+    def validate_capacity_assignment(self):
+        """Check if workspace has required capacity assignment."""
+        rule_name = "capacity_assignment"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        capacity_id = self.workspace_details.get("capacityId")
+        
+        if rule_config.get("required", False) and not capacity_id:
+            self.add_violation(
+                rule_name,
+                "Workspace must be assigned to a capacity",
+                severity="error"
+            )
+            return
+        
+        allowed_capacities = rule_config.get("allowed_capacities", [])
+        if allowed_capacities and capacity_id not in allowed_capacities:
+            self.add_violation(
+                rule_name,
+                f"Workspace capacity '{capacity_id}' not in allowed list",
+                severity="error",
+                details={"current": capacity_id, "allowed": allowed_capacities}
+            )
+            return
+        
+        self.add_passed(rule_name)
+    
+    def validate_naming_conventions(self):
+        """Check workspace and item naming conventions."""
+        rule_name = "naming_conventions"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        violations_found = False
+        
+        # Check workspace name pattern
+        workspace_pattern = rule_config.get("workspace_pattern")
+        if workspace_pattern:
+            workspace_name = self.workspace.replace(".Workspace", "")
+            if not re.match(workspace_pattern, workspace_name):
+                self.add_violation(
+                    rule_name,
+                    f"Workspace name '{workspace_name}' does not match pattern '{workspace_pattern}'",
+                    severity="error"
+                )
+                violations_found = True
+        
+        # Check item name patterns
+        item_patterns = rule_config.get("item_patterns", {})
+        for item in self.items or []:
+            item_type = item.get("type", "")
+            item_name = item.get("name", "")
+            
+            # Check type-specific pattern
+            pattern = item_patterns.get(item_type) or item_patterns.get("default")
+            if pattern and not re.match(pattern, item_name):
+                self.add_violation(
+                    rule_name,
+                    f"Item '{item_name}' ({item_type}) does not match naming pattern '{pattern}'",
+                    severity="warning",
+                    details={"item": item_name, "type": item_type, "pattern": pattern}
+                )
+                violations_found = True
+        
+        if not violations_found:
+            self.add_passed(rule_name)
+    
+    def validate_sensitivity_labels(self):
+        """Check that items have required sensitivity labels."""
+        rule_name = "sensitivity_labels"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        required = rule_config.get("required", False)
+        required_types = rule_config.get("required_item_types", [])
+        allowed_labels = rule_config.get("allowed_labels", [])
+        
+        violations_found = False
+        
+        # Build a map of items with labels
+        labeled_items = {}
+        for label_info in self.labels or []:
+            item_name = label_info.get("itemName", "")
+            labeled_items[item_name] = label_info.get("label", "")
+        
+        for item in self.items or []:
+            item_name = item.get("name", "")
+            item_type = item.get("type", "")
+            
+            # Check if this type requires labels
+            if required_types and item_type not in required_types:
+                continue
+            
+            item_label = labeled_items.get(item_name)
+            
+            # Check if label is required
+            if required and not item_label:
+                self.add_violation(
+                    rule_name,
+                    f"Item '{item_name}' ({item_type}) is missing required sensitivity label",
+                    severity="error",
+                    details={"item": item_name, "type": item_type}
+                )
+                violations_found = True
+            # Check if label is in allowed list
+            elif item_label and allowed_labels and item_label not in allowed_labels:
+                self.add_violation(
+                    rule_name,
+                    f"Item '{item_name}' has label '{item_label}' not in allowed list",
+                    severity="warning",
+                    details={"item": item_name, "label": item_label, "allowed": allowed_labels}
+                )
+                violations_found = True
+        
+        if not violations_found:
+            self.add_passed(rule_name)
+    
+    def validate_allowed_item_types(self):
+        """Check that workspace only contains allowed item types."""
+        rule_name = "allowed_item_types"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        allowed_types = rule_config.get("types", [])
+        blocked_types = rule_config.get("blocked_types", [])
+        
+        violations_found = False
+        
+        for item in self.items or []:
+            item_type = item.get("type", "")
+            item_name = item.get("name", "")
+            
+            # Check allowed list
+            if allowed_types and item_type not in allowed_types:
+                self.add_violation(
+                    rule_name,
+                    f"Item '{item_name}' has type '{item_type}' not in allowed types",
+                    severity="error",
+                    details={"item": item_name, "type": item_type, "allowed": allowed_types}
+                )
+                violations_found = True
+            
+            # Check blocked list
+            if item_type in blocked_types:
+                self.add_violation(
+                    rule_name,
+                    f"Item '{item_name}' has blocked type '{item_type}'",
+                    severity="error",
+                    details={"item": item_name, "type": item_type}
+                )
+                violations_found = True
+        
+        if not violations_found:
+            self.add_passed(rule_name)
+    
+    def validate_required_permissions(self):
+        """Check that required permissions are configured."""
+        rule_name = "required_permissions"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        required_principals = rule_config.get("required_principals", [])
+        max_admins = rule_config.get("max_admins")
+        require_group_access = rule_config.get("require_group_access", False)
+        
+        violations_found = False
+        
+        # Build permission map
+        current_permissions = {}
+        admin_count = 0
+        has_group_access = False
+        
+        for perm in self.permissions or []:
+            principal = perm.get("principal", {})
+            principal_id = principal.get("id", "")
+            principal_type = principal.get("type", "")
+            role = perm.get("role", "")
+            
+            current_permissions[principal_id] = role
+            
+            if role == "Admin":
+                admin_count += 1
+            
+            if principal_type == "Group":
+                has_group_access = True
+        
+        # Check required principals
+        for required in required_principals:
+            principal_id = required.get("principal_id")
+            required_role = required.get("role")
+            
+            current_role = current_permissions.get(principal_id)
+            if not current_role:
+                self.add_violation(
+                    rule_name,
+                    f"Required principal '{principal_id}' is not assigned to workspace",
+                    severity="error",
+                    details=required
+                )
+                violations_found = True
+            elif required_role and current_role != required_role:
+                self.add_warning(
+                    rule_name,
+                    f"Principal '{principal_id}' has role '{current_role}' but '{required_role}' is required",
+                    details={"principal": principal_id, "current": current_role, "required": required_role}
+                )
+        
+        # Check max admins
+        if max_admins is not None and admin_count > max_admins:
+            self.add_violation(
+                rule_name,
+                f"Workspace has {admin_count} admins, maximum allowed is {max_admins}",
+                severity="warning",
+                details={"current": admin_count, "max": max_admins}
+            )
+            violations_found = True
+        
+        # Check group access requirement
+        if require_group_access and not has_group_access:
+            self.add_violation(
+                rule_name,
+                "Workspace must have at least one group with access (no direct user access only)",
+                severity="warning"
+            )
+            violations_found = True
+        
+        if not violations_found:
+            self.add_passed(rule_name)
+    
+    def validate_domain_membership(self):
+        """Check workspace domain membership."""
+        rule_name = "domain_membership"
+        rule_config = self.rules.get(rule_name, {})
+        
+        if not rule_config.get("enabled", False):
+            return
+        
+        self.log(f"Checking rule: {rule_name}")
+        
+        required = rule_config.get("required", False)
+        allowed_domains = rule_config.get("allowed_domains", [])
+        
+        domain_id = self.workspace_details.get("domainId")
+        
+        if required and not domain_id:
+            self.add_violation(
+                rule_name,
+                "Workspace must be assigned to a domain",
+                severity="error"
+            )
+            return
+        
+        if allowed_domains and domain_id and domain_id not in allowed_domains:
+            self.add_violation(
+                rule_name,
+                f"Workspace domain '{domain_id}' not in allowed list",
+                severity="error",
+                details={"current": domain_id, "allowed": allowed_domains}
+            )
+            return
+        
+        self.add_passed(rule_name)
+    
+    def validate_all(self) -> Dict[str, Any]:
+        """Run all governance validations."""
+        if not self.load_workspace_data():
+            return {
+                "workspace": self.workspace,
+                "status": "error",
+                "message": "Failed to load workspace data"
+            }
+        
+        # Run all validators
+        self.validate_capacity_assignment()
+        self.validate_naming_conventions()
+        self.validate_sensitivity_labels()
+        self.validate_allowed_item_types()
+        self.validate_required_permissions()
+        self.validate_domain_membership()
+        
+        # Determine overall status
+        has_errors = any(v["severity"] == "error" for v in self.violations)
+        status = "fail" if has_errors else ("pass_with_warnings" if self.violations else "pass")
+        
+        return {
+            "workspace": self.workspace,
+            "status": status,
+            "rules_file": self.rules.get("_source", "unknown"),
+            "summary": {
+                "passed": len(self.passed_checks),
+                "violations": len(self.violations),
+                "warnings": len(self.warnings)
+            },
+            "passed_checks": self.passed_checks,
+            "violations": self.violations,
+            "warnings": self.warnings
+        }
+
+
+def create_sample_rules() -> Dict[str, Any]:
+    """Create a sample governance rules file."""
+    return {
+        "_description": "Sample Fabric governance rules configuration",
+        "_version": "1.0",
+        "capacity_assignment": {
+            "enabled": True,
+            "required": True,
+            "allowed_capacities": []
+        },
+        "naming_conventions": {
+            "enabled": True,
+            "workspace_pattern": "^[A-Z][a-zA-Z0-9_-]+$",
+            "item_patterns": {
+                "default": "^[A-Za-z][A-Za-z0-9_-]*$",
+                "SemanticModel": "^[A-Z][a-zA-Z0-9_-]+$",
+                "Report": "^[A-Z][a-zA-Z0-9_-]+Report$"
+            }
+        },
+        "sensitivity_labels": {
+            "enabled": True,
+            "required": False,
+            "required_item_types": ["SemanticModel", "Report"],
+            "allowed_labels": []
+        },
+        "allowed_item_types": {
+            "enabled": False,
+            "types": [],
+            "blocked_types": []
+        },
+        "required_permissions": {
+            "enabled": True,
+            "required_principals": [],
+            "max_admins": 5,
+            "require_group_access": False
+        },
+        "domain_membership": {
+            "enabled": False,
+            "required": False,
+            "allowed_domains": []
+        }
+    }
+
+
+def print_report(result: Dict[str, Any], output_format: str, output_file: Optional[str] = None):
+    """Print validation report."""
+    if output_format == "json":
+        output = json.dumps(result, indent=2)
+    else:
+        # Text format
+        lines = []
+        lines.append("=" * 60)
+        lines.append("GOVERNANCE VALIDATION REPORT")
+        lines.append("=" * 60)
+        lines.append(f"Workspace: {result['workspace']}")
+        lines.append(f"Status: {result['status'].upper()}")
+        lines.append("")
+        
+        summary = result.get("summary", {})
+        lines.append(f"Passed: {summary.get('passed', 0)}")
+        lines.append(f"Violations: {summary.get('violations', 0)}")
+        lines.append(f"Warnings: {summary.get('warnings', 0)}")
+        lines.append("")
+        
+        if result.get("passed_checks"):
+            lines.append("PASSED CHECKS:")
+            for check in result["passed_checks"]:
+                lines.append(f"  ✓ {check}")
+            lines.append("")
+        
+        if result.get("violations"):
+            lines.append("VIOLATIONS:")
+            for v in result["violations"]:
+                severity_icon = "✗" if v["severity"] == "error" else "⚠"
+                lines.append(f"  {severity_icon} [{v['rule']}] {v['message']}")
+            lines.append("")
+        
+        if result.get("warnings"):
+            lines.append("WARNINGS:")
+            for w in result["warnings"]:
+                lines.append(f"  ⚠ [{w['rule']}] {w['message']}")
+            lines.append("")
+        
+        lines.append("=" * 60)
+        output = "\n".join(lines)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Report written to: {output_file}", file=sys.stderr)
+    else:
+        print(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Validate workspace against governance rules",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python validate_governance.py Production.Workspace --rules company-rules.json
+    python validate_governance.py MyWorkspace --rules rules.json -f json
+    python validate_governance.py Production.Workspace --rules rules.json -o report.json
+    python validate_governance.py --create-sample-rules > sample-rules.json
+        """
+    )
+    
+    parser.add_argument(
+        "workspace",
+        nargs="?",
+        help="Workspace name or path (e.g., 'MyWorkspace' or 'MyWorkspace.Workspace')"
+    )
+    
+    parser.add_argument(
+        "--rules",
+        required=False,
+        help="Path to governance rules JSON file"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    parser.add_argument(
+        "--create-sample-rules",
+        action="store_true",
+        help="Output a sample governance rules file"
+    )
+    
+    args = parser.parse_args()
+    
+    # Handle sample rules generation
+    if args.create_sample_rules:
+        print(json.dumps(create_sample_rules(), indent=2))
+        return 0
+    
+    # Validate required arguments
+    if not args.workspace:
+        parser.error("workspace is required unless --create-sample-rules is specified")
+    
+    if not args.rules:
+        parser.error("--rules is required")
+    
+    # Load rules
+    try:
+        rules = load_rules(args.rules)
+        rules["_source"] = args.rules
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in rules file: {e}", file=sys.stderr)
+        return 1
+    
+    # Run validation
+    validator = GovernanceValidator(args.workspace, rules, verbose=args.verbose)
+    result = validator.validate_all()
+    
+    # Output report
+    print_report(result, args.format, args.output)
+    
+    # Return exit code based on status
+    if result["status"] == "error":
+        return 1
+    elif result["status"] == "fail":
+        return 1
+    else:
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-powerbi/README.md b/.ai-assets/skills/fabric-cli-powerbi/README.md
new file mode 100644
index 000000000..40b9ad824
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/README.md
@@ -0,0 +1,39 @@
+# Fabric CLI Power BI Skill
+
+Skill for working with Power BI items (semantic models, reports, dashboards) using the Fabric CLI.
+
+## When to Load
+
+Load this skill when:
+- Working with semantic models (datasets) — refresh, DAX, TMDL
+- Managing Power BI reports — export, rebind, clone
+- Querying data via DAX
+- Managing gateways and data sources
+- Troubleshooting refresh failures
+
+## Prerequisites
+
+- Load `fabric-cli-core` skill first
+- User authenticated via `fab auth login`
+- Access to workspace containing Power BI items
+
+## Contents
+
+| File | Description |
+|------|-------------|
+| [SKILL.md](./SKILL.md) | Main skill definition |
+| [references/semantic-models.md](./references/semantic-models.md) | Semantic model operations |
+| [references/reports.md](./references/reports.md) | Report operations |
+| [references/refresh.md](./references/refresh.md) | Refresh operations and troubleshooting |
+| [references/dax-queries.md](./references/dax-queries.md) | DAX query execution |
+| [references/gateways.md](./references/gateways.md) | Gateway and data source management |
+
+## Scripts
+
+Automation scripts for Power BI tasks:
+
+| Script | Description | Usage |
+|--------|-------------|-------|
+| `refresh_model.py` | Trigger and monitor semantic model refresh | `python scripts/refresh_model.py <model> [--wait]` |
+| `list_refresh_history.py` | Show refresh history and failure details | `python scripts/list_refresh_history.py <model> [--last N]` |
+| `rebind_report.py` | Rebind report to different semantic model | `python scripts/rebind_report.py <report> --model <new-model>` |
diff --git a/.ai-assets/skills/fabric-cli-powerbi/SKILL.md b/.ai-assets/skills/fabric-cli-powerbi/SKILL.md
new file mode 100644
index 000000000..71d0037c0
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/SKILL.md
@@ -0,0 +1,379 @@
+---
+name: fabric-cli-powerbi
+description: Use Fabric CLI for Power BI operations — semantic models, reports, DAX queries, refresh, gateways. Activate when users work with Power BI items, need to refresh datasets, execute DAX, manage reports, or troubleshoot refresh failures.
+---
+
+# Fabric CLI Power BI Operations
+
+Expert guidance for working with Power BI items (semantic models, reports, dashboards) using the `fab` CLI.
+
+## When to Use This Skill
+
+Activate automatically when tasks involve:
+
+- Semantic model (dataset) operations — get, export, refresh, update
+- Report management — export, clone, rebind to different model
+- Executing DAX queries against semantic models
+- Managing refresh schedules and troubleshooting failures
+- Gateway and data source configuration
+- TMDL (Tabular Model Definition Language) operations
+
+## Prerequisites
+
+- Load `fabric-cli-core` skill first for foundational CLI guidance
+- User must be authenticated: `fab auth status`
+- Appropriate workspace permissions for target items
+
+## Automation Scripts
+
+Ready-to-use Python scripts for Power BI tasks. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `refresh_model.py` | Trigger and monitor semantic model refresh | `python scripts/refresh_model.py <model> [--wait] [--timeout 300]` |
+| `list_refresh_history.py` | Show refresh history and failure details | `python scripts/list_refresh_history.py <model> [--last N]` |
+| `rebind_report.py` | Rebind report to different semantic model | `python scripts/rebind_report.py <report> --model <new-model>` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+## 1 - Power BI Item Types
+
+| Entity Suffix | Type | Description |
+|---------------|------|-------------|
+| `.SemanticModel` | Semantic Model | Power BI dataset (tabular model) |
+| `.Report` | Report | Power BI report (visualizations) |
+| `.Dashboard` | Dashboard | Power BI dashboard (pinned tiles) |
+| `.Dataflow` | Dataflow | Power Query dataflow |
+| `.PaginatedReport` | Paginated Report | RDL-based paginated report |
+
+### Path Examples
+
+```
+# Semantic model
+Production.Workspace/Sales.SemanticModel
+
+# Report connected to model
+Production.Workspace/SalesReport.Report
+
+# Dashboard
+Production.Workspace/ExecutiveDash.Dashboard
+```
+
+## 2 - Semantic Model Operations
+
+### Get Model Information
+
+```bash
+# Check if model exists
+fab exists "ws.Workspace/Model.SemanticModel"
+
+# Get model properties
+fab get "ws.Workspace/Model.SemanticModel"
+
+# Get model ID (needed for Power BI API calls)
+fab get "ws.Workspace/Model.SemanticModel" -q "id"
+
+# Get full definition (TMDL)
+fab get "ws.Workspace/Model.SemanticModel" -q "definition"
+```
+
+### Export Model
+
+```bash
+# Export to local directory (PBIP format with TMDL)
+fab export "ws.Workspace/Model.SemanticModel" -o ./exports -f
+```
+
+Creates folder structure:
+```
+Model.SemanticModel/
+├── .platform
+├── definition.pbism
+└── definition/
+    ├── model.tmdl
+    ├── tables/
+    │   ├── Sales.tmdl
+    │   └── Date.tmdl
+    └── relationships.tmdl
+```
+
+### Import/Update Model
+
+```bash
+# Import from PBIP folder
+fab import "ws.Workspace/Model.SemanticModel" -i ./exports/Model.SemanticModel -f
+
+# Copy between workspaces
+fab cp "Dev.Workspace/Model.SemanticModel" "Prod.Workspace/Model.SemanticModel" -f
+```
+
+## 3 - Refresh Operations
+
+### Trigger Refresh
+
+```bash
+# Get IDs
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+
+# Trigger full refresh
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+
+# Check refresh status
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1"
+```
+
+### Enhanced Refresh (Partition-Level)
+
+```bash
+# Refresh specific tables
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "commitMode": "transactional",
+  "objects": [
+    {"table": "Sales"},
+    {"table": "Inventory"}
+  ]
+}'
+
+# Refresh with retry
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "retryCount": 3
+}'
+```
+
+### Refresh Schedule
+
+```bash
+# Get current schedule
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule"
+
+# Set daily refresh at 6 AM UTC
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule" -X patch -i '{
+  "enabled": true,
+  "days": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
+  "times": ["06:00"],
+  "localTimeZoneId": "UTC"
+}'
+```
+
+### Troubleshoot Refresh Failures
+
+```bash
+# Get refresh history
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes"
+
+# Common failure patterns:
+# - "credentials" → Update data source credentials
+# - "gateway" → Check gateway status
+# - "timeout" → Use enhanced refresh with smaller batches
+# - "memory" → Optimize model or use incremental refresh
+```
+
+## 4 - DAX Query Execution
+
+Execute DAX queries against semantic models:
+
+```bash
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+
+# Simple query
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE VALUES(Date[Year])"}]
+}'
+
+# Aggregation query
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE SUMMARIZECOLUMNS(Date[Year], \"Total\", SUM(Sales[Amount]))"
+  }]
+}'
+
+# TOPN query
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE TOPN(10, Product, [Total Sales], DESC)"
+  }]
+}'
+
+# Query with parameters
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE FILTER(Sales, Sales[Year] = @Year)",
+    "parameters": [{"name": "@Year", "value": "2024"}]
+  }]
+}'
+```
+
+## 5 - Report Operations
+
+### Get Report Info
+
+```bash
+# Check exists
+fab exists "ws.Workspace/Report.Report"
+
+# Get properties
+fab get "ws.Workspace/Report.Report"
+
+# Get connected model
+fab get "ws.Workspace/Report.Report" -q "definition.parts[?contains(path, 'definition.pbir')].payload | [0]"
+```
+
+### Export Report
+
+```bash
+# Export to PBIP format
+fab export "ws.Workspace/Report.Report" -o ./exports -f
+```
+
+### Clone Report
+
+```bash
+# Copy within workspace
+fab cp "ws.Workspace/Report.Report" "ws.Workspace/ReportCopy.Report" -f
+
+# Copy to another workspace
+fab cp "Dev.Workspace/Report.Report" "Prod.Workspace/Report.Report" -f
+```
+
+### Rebind Report to Different Model
+
+```bash
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+REPORT_ID=$(fab get "ws.Workspace/Report.Report" -q "id" | tr -d '"')
+NEW_MODEL_ID=$(fab get "ws.Workspace/NewModel.SemanticModel" -q "id" | tr -d '"')
+
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Rebind" -X post -i "{
+  \"datasetId\": \"$NEW_MODEL_ID\"
+}"
+```
+
+### Export Report to File (PDF/PPTX)
+
+```bash
+# Export to PDF
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PDF"
+}'
+
+# Poll for completion, then download
+```
+
+## 6 - Gateway Operations
+
+### List Gateways
+
+```bash
+# Tenant-level gateways (hidden entity)
+fab ls .gateways
+
+# Get gateway details
+fab get ".gateways/MyGateway.Gateway"
+```
+
+### Data Source Management
+
+```bash
+GATEWAY_ID=$(fab get ".gateways/MyGateway.Gateway" -q "id" | tr -d '"')
+
+# List data sources on gateway
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources"
+
+# Get data source status
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID"
+```
+
+### Update Data Source Credentials
+
+```bash
+# Update credentials (basic auth example)
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID" -X patch -i '{
+  "credentialDetails": {
+    "credentialType": "Basic",
+    "credentials": "{\"credentialData\":[{\"name\":\"username\",\"value\":\"user\"},{\"name\":\"password\",\"value\":\"pass\"}]}",
+    "encryptedConnection": "Encrypted",
+    "encryptionAlgorithm": "None",
+    "privacyLevel": "Organizational"
+  }
+}'
+```
+
+## 7 - Take Over Ownership
+
+When a semantic model owner leaves the organization:
+
+```bash
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+
+# Take over semantic model ownership
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.TakeOver" -X post
+```
+
+## 8 - Common Patterns
+
+### Dev to Production Deployment
+
+```bash
+#!/bin/bash
+DEV_WS="Dev.Workspace"
+PROD_WS="Prod.Workspace"
+
+# 1. Export from dev
+fab export "$DEV_WS/Sales.SemanticModel" -o ./deploy -f
+fab export "$DEV_WS/SalesReport.Report" -o ./deploy -f
+
+# 2. Import to prod
+fab import "$PROD_WS/Sales.SemanticModel" -i ./deploy/Sales.SemanticModel -f
+fab import "$PROD_WS/SalesReport.Report" -i ./deploy/SalesReport.Report -f
+
+# 3. Trigger refresh
+PROD_WS_ID=$(fab get "$PROD_WS" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "$PROD_WS/Sales.SemanticModel" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$PROD_WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+
+# 4. Verify
+fab api -A powerbi "groups/$PROD_WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0].status"
+```
+
+### Backup Semantic Model
+
+```bash
+# Export definition for version control
+fab export "Prod.Workspace/Model.SemanticModel" -o ./backups/$(date +%Y%m%d) -f
+git add ./backups/
+git commit -m "Backup Model $(date +%Y-%m-%d)"
+```
+
+### Incremental Refresh Setup
+
+For large models, use incremental refresh:
+
+1. Configure in Power BI Desktop with RangeStart/RangeEnd parameters
+2. Publish to workspace
+3. First refresh creates partitions:
+
+```bash
+# Monitor partition creation
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=5"
+```
+
+## 9 - Safety Guidelines
+
+- **Always verify workspace context** before refresh operations
+- **Test in dev first** — never refresh production without testing
+- **Monitor refresh duration** — set appropriate timeouts
+- **Backup before major changes** — export definition before updates
+- **Use enhanced refresh** for large models to avoid timeouts
+
+## 10 - References
+
+For detailed patterns, see:
+
+- [references/semantic-models.md](./references/semantic-models.md) — Full TMDL operations
+- [references/reports.md](./references/reports.md) — Report management
+- [references/refresh.md](./references/refresh.md) — Refresh troubleshooting
+- [references/dax-queries.md](./references/dax-queries.md) — Advanced DAX patterns
+- [references/gateways.md](./references/gateways.md) — Gateway configuration
diff --git a/.ai-assets/skills/fabric-cli-powerbi/references/dax-queries.md b/.ai-assets/skills/fabric-cli-powerbi/references/dax-queries.md
new file mode 100644
index 000000000..427fa91c4
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/references/dax-queries.md
@@ -0,0 +1,208 @@
+# DAX Query Execution
+
+Execute DAX queries against semantic models using the Power BI REST API via Fabric CLI.
+
+## Prerequisites
+
+```bash
+# Get model ID
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+```
+
+## Basic Queries
+
+### Simple EVALUATE
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE VALUES(Date[Year])"}]
+}'
+```
+
+### Table Preview
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE TOPN(100, Sales)"}]
+}'
+```
+
+### Multiple Queries
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [
+    {"query": "EVALUATE VALUES(Date[Year])"},
+    {"query": "EVALUATE VALUES(Product[Category])"}
+  ]
+}'
+```
+
+## Aggregation Queries
+
+### SUMMARIZE
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE SUMMARIZE(Sales, Date[Year], \"Total\", SUM(Sales[Amount]))"
+  }]
+}'
+```
+
+### SUMMARIZECOLUMNS
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE SUMMARIZECOLUMNS(Date[Year], Product[Category], \"Revenue\", SUM(Sales[Amount]), \"Qty\", SUM(Sales[Quantity]))"
+  }]
+}'
+```
+
+### ADDCOLUMNS
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE ADDCOLUMNS(VALUES(Product[Category]), \"Total\", CALCULATE(SUM(Sales[Amount])))"
+  }]
+}'
+```
+
+## Filter Queries
+
+### FILTER
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE FILTER(Sales, Sales[Amount] > 1000)"
+  }]
+}'
+```
+
+### CALCULATETABLE
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE CALCULATETABLE(VALUES(Product[Name]), Sales[Year] = 2024)"
+  }]
+}'
+```
+
+### TOPN with Filter
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE TOPN(10, FILTER(Product, Product[Category] = \"Electronics\"), [Total Sales], DESC)"
+  }]
+}'
+```
+
+## Parameterized Queries
+
+### Single Parameter
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE FILTER(Sales, Sales[Year] = @Year)",
+    "parameters": [{"name": "@Year", "value": "2024"}]
+  }]
+}'
+```
+
+### Multiple Parameters
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE FILTER(Sales, Sales[Year] >= @StartYear && Sales[Year] <= @EndYear)",
+    "parameters": [
+      {"name": "@StartYear", "value": "2022"},
+      {"name": "@EndYear", "value": "2024"}
+    ]
+  }]
+}'
+```
+
+## Advanced Patterns
+
+### Time Intelligence
+
+```bash
+# Year-over-Year comparison
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE ADDCOLUMNS(VALUES(Date[Year]), \"Current\", CALCULATE(SUM(Sales[Amount])), \"Previous\", CALCULATE(SUM(Sales[Amount]), SAMEPERIODLASTYEAR(Date[Date])))"
+  }]
+}'
+```
+
+### Running Total
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE ADDCOLUMNS(VALUES(Date[Month]), \"RunningTotal\", CALCULATE(SUM(Sales[Amount]), FILTER(ALL(Date[Month]), Date[Month] <= EARLIER(Date[Month]))))"
+  }]
+}'
+```
+
+### Distinct Count
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{
+    "query": "EVALUATE ROW(\"UniqueCustomers\", DISTINCTCOUNT(Sales[CustomerID]))"
+  }]
+}'
+```
+
+## Query Options
+
+### Include Nulls
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE VALUES(Customer[Region])"}],
+  "serializerSettings": {"includeNulls": true}
+}'
+```
+
+### Impersonation (RLS Testing)
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE Sales"}],
+  "impersonatedUserName": "user@contoso.com"
+}'
+```
+
+## Output Processing
+
+### Extract to CSV
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE SUMMARIZECOLUMNS(Date[Year], \"Total\", SUM(Sales[Amount]))"}]
+}' | jq -r '.results[0].tables[0].rows[] | [.[]] | @csv'
+```
+
+### Extract to JSON file
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/executeQueries" -X post -i '{
+  "queries": [{"query": "EVALUATE Sales"}]
+}' -o /tmp/query-results.json
+```
+
+## Limitations
+
+- Maximum query timeout varies by capacity
+- Large result sets may be truncated
+- Complex queries may hit memory limits
+- Some DAX functions not available via REST API
diff --git a/.ai-assets/skills/fabric-cli-powerbi/references/gateways.md b/.ai-assets/skills/fabric-cli-powerbi/references/gateways.md
new file mode 100644
index 000000000..41b5f8a43
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/references/gateways.md
@@ -0,0 +1,182 @@
+# Gateway Operations
+
+Manage on-premises data gateways and data sources using Fabric CLI.
+
+## List Gateways
+
+Gateways are tenant-level hidden entities.
+
+```bash
+# List all gateways (requires admin or gateway permissions)
+fab ls .gateways
+
+# List with details
+fab ls .gateways -v
+```
+
+## Get Gateway Info
+
+```bash
+# Get gateway by name
+fab get ".gateways/MyGateway.Gateway"
+
+# Get gateway ID
+GATEWAY_ID=$(fab get ".gateways/MyGateway.Gateway" -q "id" | tr -d '"')
+
+# Get gateway via API
+fab api -A powerbi "gateways/$GATEWAY_ID"
+```
+
+## Gateway Cluster Status
+
+```bash
+# Check gateway cluster members
+fab api -A powerbi "gateways/$GATEWAY_ID" -q "gatewayAnnotation"
+
+# Parse status
+fab api -A powerbi "gateways/$GATEWAY_ID" | jq '.gatewayStatus'
+```
+
+## Data Sources
+
+### List Data Sources on Gateway
+
+```bash
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources"
+```
+
+### Get Data Source Details
+
+```bash
+DATASOURCE_ID="<datasource-id>"
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID"
+```
+
+### Create Data Source
+
+```bash
+# SQL Server example
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources" -X post -i '{
+  "dataSourceType": "Sql",
+  "connectionDetails": "{\"server\":\"myserver.database.windows.net\",\"database\":\"mydb\"}",
+  "datasourceName": "MyDatabase",
+  "credentialDetails": {
+    "credentialType": "Basic",
+    "credentials": "{\"credentialData\":[{\"name\":\"username\",\"value\":\"user\"},{\"name\":\"password\",\"value\":\"pass\"}]}",
+    "encryptedConnection": "Encrypted",
+    "encryptionAlgorithm": "None",
+    "privacyLevel": "Organizational"
+  }
+}'
+```
+
+### Update Data Source Credentials
+
+```bash
+# Update with basic auth
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID" -X patch -i '{
+  "credentialDetails": {
+    "credentialType": "Basic",
+    "credentials": "{\"credentialData\":[{\"name\":\"username\",\"value\":\"newuser\"},{\"name\":\"password\",\"value\":\"newpass\"}]}",
+    "encryptedConnection": "Encrypted",
+    "encryptionAlgorithm": "None",
+    "privacyLevel": "Organizational"
+  }
+}'
+
+# Update with OAuth2
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID" -X patch -i '{
+  "credentialDetails": {
+    "credentialType": "OAuth2",
+    "credentials": "{\"credentialData\":[{\"name\":\"accessToken\",\"value\":\"<token>\"}]}",
+    "encryptedConnection": "Encrypted",
+    "encryptionAlgorithm": "None",
+    "privacyLevel": "Organizational"
+  }
+}'
+```
+
+### Delete Data Source
+
+```bash
+fab api -A powerbi "gateways/$GATEWAY_ID/datasources/$DATASOURCE_ID" -X delete
+```
+
+## Semantic Model Data Sources
+
+### Get Bound Data Sources
+
+```bash
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+
+# Get data sources bound to model
+fab api -A powerbi "datasets/$MODEL_ID/Default.GetBoundGatewayDatasources"
+```
+
+### Bind to Gateway
+
+```bash
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.BindToGateway" -X post -i '{
+  "gatewayObjectId": "<gateway-id>",
+  "datasourceObjectIds": ["<datasource-id-1>", "<datasource-id-2>"]
+}'
+```
+
+### Take Over Data Source
+
+When original owner leaves:
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.TakeOver" -X post
+```
+
+## Gateway Users
+
+### List Gateway Users
+
+```bash
+fab api -A powerbi "gateways/$GATEWAY_ID/users"
+```
+
+### Add Gateway User
+
+```bash
+fab api -A powerbi "gateways/$GATEWAY_ID/users" -X post -i '{
+  "emailAddress": "user@contoso.com",
+  "datasourceAccessRight": "Read"
+}'
+```
+
+### Remove Gateway User
+
+```bash
+fab api -A powerbi "gateways/$GATEWAY_ID/users/$USER_ID" -X delete
+```
+
+## Troubleshooting
+
+### Gateway Not Reachable
+
+1. Check gateway service is running on gateway machine
+2. Verify network connectivity
+3. Check firewall rules
+4. Review gateway logs
+
+### Data Source Connection Failed
+
+1. Test connection string manually
+2. Verify credentials are current
+3. Check if source database is accessible from gateway machine
+4. Review gateway data source configuration
+
+### Gateway Commands Summary
+
+| Operation | Command |
+|-----------|---------|
+| List gateways | `fab ls .gateways` |
+| Get gateway | `fab api -A powerbi "gateways/$GW_ID"` |
+| List data sources | `fab api -A powerbi "gateways/$GW_ID/datasources"` |
+| Update credentials | `fab api -A powerbi "gateways/$GW_ID/datasources/$DS_ID" -X patch -i '...'` |
+| Bind model to gateway | `fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.BindToGateway" -X post -i '...'` |
diff --git a/.ai-assets/skills/fabric-cli-powerbi/references/refresh.md b/.ai-assets/skills/fabric-cli-powerbi/references/refresh.md
new file mode 100644
index 000000000..678de12ca
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/references/refresh.md
@@ -0,0 +1,233 @@
+# Refresh Operations
+
+Comprehensive guide for managing semantic model refresh operations using Fabric CLI.
+
+## Basic Refresh
+
+### Get Required IDs
+
+```bash
+# Workspace ID
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+
+# Model ID
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+```
+
+### Trigger Full Refresh
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+```
+
+### Check Refresh Status
+
+```bash
+# Latest refresh
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1"
+
+# Refresh history
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes"
+```
+
+## Enhanced Refresh
+
+Enhanced refresh provides more control for large models.
+
+### Table-Level Refresh
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "commitMode": "transactional",
+  "objects": [
+    {"table": "Sales"},
+    {"table": "Products"}
+  ]
+}'
+```
+
+### Partition-Level Refresh
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "commitMode": "transactional",
+  "objects": [
+    {"table": "Sales", "partition": "Sales-2024-Q1"},
+    {"table": "Sales", "partition": "Sales-2024-Q2"}
+  ]
+}'
+```
+
+### Refresh with Retry
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "retryCount": 3,
+  "maxParallelism": 4
+}'
+```
+
+### Apply Incremental Refresh Policy
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{
+  "type": "Full",
+  "applyRefreshPolicy": true
+}'
+```
+
+## Refresh Scheduling
+
+### Get Current Schedule
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule"
+```
+
+### Set Daily Schedule
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule" -X patch -i '{
+  "enabled": true,
+  "days": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
+  "times": ["06:00", "18:00"],
+  "localTimeZoneId": "UTC"
+}'
+```
+
+### Set Weekly Schedule
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule" -X patch -i '{
+  "enabled": true,
+  "days": ["Sunday"],
+  "times": ["02:00"],
+  "localTimeZoneId": "Pacific Standard Time"
+}'
+```
+
+### Disable Schedule
+
+```bash
+fab api -A powerbi "datasets/$MODEL_ID/refreshSchedule" -X patch -i '{
+  "enabled": false
+}'
+```
+
+## Troubleshooting Refresh Failures
+
+### Common Error Patterns
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `InvalidCredentials` | Data source credentials expired | Update credentials in gateway settings |
+| `GatewayNotReachable` | Gateway offline | Check gateway server, restart service |
+| `DataSourceNotFound` | Connection string changed | Update data source configuration |
+| `OutOfMemory` | Model too large | Use incremental refresh, optimize model |
+| `Timeout` | Refresh exceeded limit | Use enhanced refresh with smaller batches |
+| `QueryTimeout` | Source query too slow | Optimize source queries, add indexes |
+
+### Get Detailed Error Info
+
+```bash
+# Get failed refresh details
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=10" | \
+  jq '.value[] | select(.status == "Failed") | {startTime, endTime, status, serviceExceptionJson}'
+```
+
+### Check Data Source Status
+
+```bash
+# List bound gateways
+fab api -A powerbi "datasets/$MODEL_ID/Default.GetBoundGatewayDatasources"
+
+# Check gateway status
+GATEWAY_ID="<gateway-id>"
+fab api -A powerbi "gateways/$GATEWAY_ID"
+```
+
+### Cancel Running Refresh
+
+```bash
+REFRESH_ID="<refresh-request-id>"
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes/$REFRESH_ID" -X delete
+```
+
+## Monitoring Patterns
+
+### Script: Monitor Refresh Until Complete
+
+```bash
+#!/bin/bash
+WS_ID=$1
+MODEL_ID=$2
+
+# Trigger refresh
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+
+# Poll until complete
+while true; do
+  STATUS=$(fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0].status")
+  echo "Status: $STATUS"
+  
+  case $STATUS in
+    "Completed") echo "Refresh successful"; exit 0 ;;
+    "Failed") echo "Refresh failed"; exit 1 ;;
+    "Cancelled") echo "Refresh cancelled"; exit 2 ;;
+    *) sleep 30 ;;
+  esac
+done
+```
+
+### Script: Refresh with Notification
+
+```bash
+#!/bin/bash
+WS_ID=$1
+MODEL_ID=$2
+EMAIL=$3
+
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
+
+# Wait and check
+sleep 300  # Wait 5 minutes
+STATUS=$(fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0].status")
+
+if [ "$STATUS" != "Completed" ]; then
+  echo "Refresh status: $STATUS - sending alert"
+  # Add notification logic here
+fi
+```
+
+## Incremental Refresh
+
+For large historical tables, use incremental refresh.
+
+### Prerequisites
+
+1. Model must have `RangeStart` and `RangeEnd` date parameters
+2. Source query must filter on date column using these parameters
+3. Configure refresh policy in Power BI Desktop before publishing
+
+### How It Works
+
+- Historical partitions: Loaded once, not refreshed
+- Rolling window: Configurable period always refreshed
+- Current partition: Contains most recent data
+
+### Monitor Partition Creation
+
+```bash
+# After first refresh, check partitions were created
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0]"
+```
+
+### Override Incremental Policy (XMLA)
+
+For advanced scenarios, use XMLA endpoint to:
+- Refresh specific historical partitions
+- Bootstrap large initial loads
+- Bypass refresh policy for one-time operations
diff --git a/.ai-assets/skills/fabric-cli-powerbi/references/reports.md b/.ai-assets/skills/fabric-cli-powerbi/references/reports.md
new file mode 100644
index 000000000..bfa061c45
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/references/reports.md
@@ -0,0 +1,222 @@
+# Reports Reference
+
+Working with Power BI reports via Fabric CLI.
+
+## Item Type
+
+Use `.Report` suffix when referencing reports:
+
+```bash
+# Reference format
+ws.Workspace/ReportName.Report
+```
+
+## List Reports
+
+```bash
+# List in current workspace
+fab ls . -t Report
+
+# List in specific workspace
+fab ls "ws.Workspace" -t Report
+
+# List with details
+fab ls "ws.Workspace" -t Report -v
+```
+
+## Get Report Details
+
+```bash
+# Get report metadata
+fab get "ws.Workspace/SalesReport.Report"
+
+# Get specific property
+fab get "ws.Workspace/SalesReport.Report" -q "id"
+
+# Get report via API
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+REPORT_ID=$(fab get "ws.Workspace/SalesReport.Report" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID"
+```
+
+## Export Reports
+
+### Export as PBIX
+
+```bash
+fab export "ws.Workspace/SalesReport.Report" -d ./exports
+```
+
+### Export to File Format
+
+```bash
+# Export to PDF
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PDF"
+}' -o report.pdf
+
+# Export to PNG
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PNG",
+  "powerBIReportConfiguration": {
+    "pages": [{"pageName": "Page1"}]
+  }
+}' -o report.png
+
+# Export to PPTX (PowerPoint)
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PPTX"
+}' -o report.pptx
+```
+
+### Export Paginated Report
+
+```bash
+# Export to PDF with parameters
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PDF",
+  "paginatedReportConfiguration": {
+    "parameterValues": [
+      {"name": "Year", "value": "2024"},
+      {"name": "Region", "value": "West"}
+    ]
+  }
+}'
+```
+
+### Async Export (Large Reports)
+
+```bash
+# Start export job
+EXPORT_RESULT=$(fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{
+  "format": "PDF"
+}')
+EXPORT_ID=$(echo $EXPORT_RESULT | jq -r '.id')
+
+# Poll for completion
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/exports/$EXPORT_ID"
+
+# Download when complete
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/exports/$EXPORT_ID/file" -o report.pdf
+```
+
+## Import Reports
+
+### Import PBIX (Contains Report)
+
+```bash
+fab import ./report.pbix -d "ws.Workspace"
+
+# Skip creating new dataset (rebind to existing)
+fab import ./report.pbix -d "ws.Workspace" -c CreateOrOverwrite
+```
+
+## Clone Report
+
+```bash
+# Clone within same workspace
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Clone" -X post -i '{
+  "name": "SalesReport_Copy"
+}'
+
+# Clone to different workspace
+TARGET_WS_ID=$(fab get "target.Workspace" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Clone" -X post -i '{
+  "name": "SalesReport_Copy",
+  "targetWorkspaceId": "'"$TARGET_WS_ID"'"
+}'
+
+# Clone and rebind to different dataset
+TARGET_MODEL_ID=$(fab get "target.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Clone" -X post -i '{
+  "name": "SalesReport_Copy",
+  "targetWorkspaceId": "'"$TARGET_WS_ID"'",
+  "targetModelId": "'"$TARGET_MODEL_ID"'"
+}'
+```
+
+## Rebind Report
+
+Change the semantic model a report connects to:
+
+```bash
+# Get current binding
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID"
+
+# Rebind to new dataset in same workspace
+NEW_MODEL_ID=$(fab get "ws.Workspace/NewModel.SemanticModel" -q "id" | tr -d '"')
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Rebind" -X post -i '{
+  "datasetId": "'"$NEW_MODEL_ID"'"
+}'
+```
+
+## Report Pages
+
+### Get Pages
+
+```bash
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/pages"
+```
+
+### Get Single Page
+
+```bash
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/pages/Page1"
+```
+
+## Update Report
+
+### Update Report Content
+
+```bash
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/UpdateReportContent" -X post -i '{
+  "sourceReport": {
+    "sourceReportId": "'"$SOURCE_REPORT_ID"'",
+    "sourceWorkspaceId": "'"$SOURCE_WS_ID"'"
+  },
+  "sourceType": "ExistingReport"
+}'
+```
+
+## Delete Report
+
+```bash
+# Delete via fab
+fab rm "ws.Workspace/SalesReport.Report"
+
+# Delete via API
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID" -X delete
+```
+
+## Report Permissions
+
+### Get Report Users
+
+```bash
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/users"
+```
+
+## Subscriptions
+
+### Get Report Subscriptions
+
+```bash
+fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/subscriptions"
+```
+
+## Quick Reference
+
+| Operation | Command |
+|-----------|---------|
+| List reports | `fab ls "ws.Workspace" -t Report` |
+| Get report | `fab get "ws.Workspace/Report.Report"` |
+| Export PBIX | `fab export "ws.Workspace/Report.Report" -d ./` |
+| Export PDF | `fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/ExportTo" -X post -i '{"format":"PDF"}'` |
+| Clone report | `fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Clone" -X post -i '{...}'` |
+| Rebind dataset | `fab api -A powerbi "groups/$WS_ID/reports/$REPORT_ID/Rebind" -X post -i '{...}'` |
+| Delete report | `fab rm "ws.Workspace/Report.Report"` |
+
+## See Also
+
+- [Semantic Models](./semantic-models.md) - Manage underlying data
+- [Refresh Operations](./refresh.md) - Refresh data
diff --git a/.ai-assets/skills/fabric-cli-powerbi/references/semantic-models.md b/.ai-assets/skills/fabric-cli-powerbi/references/semantic-models.md
new file mode 100644
index 000000000..d29656129
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/references/semantic-models.md
@@ -0,0 +1,196 @@
+# Semantic Models Reference
+
+Working with Power BI semantic models (formerly datasets) via Fabric CLI.
+
+## Item Type
+
+Use `.SemanticModel` suffix when referencing semantic models:
+
+```bash
+# Reference format
+ws.Workspace/ModelName.SemanticModel
+```
+
+## List Semantic Models
+
+```bash
+# List in current workspace
+fab ls . -t SemanticModel
+
+# List in specific workspace
+fab ls "ws.Workspace" -t SemanticModel
+
+# List with verbose details
+fab ls "ws.Workspace" -t SemanticModel -v
+```
+
+## Get Model Details
+
+```bash
+# Get model metadata
+fab get "ws.Workspace/Model.SemanticModel"
+
+# Get specific property
+fab get "ws.Workspace/Model.SemanticModel" -q "id"
+
+# Store ID for API calls
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+```
+
+## Export Semantic Model
+
+### Export as PBIX (Power BI Desktop)
+
+```bash
+fab export "ws.Workspace/Model.SemanticModel" -d ./exports
+```
+
+### Export via API
+
+```bash
+WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
+MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+
+# Start export
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.Export" -X post -o model.pbix
+```
+
+## Import Semantic Model
+
+### Import PBIX
+
+```bash
+fab import ./model.pbix -d "ws.Workspace"
+
+# With conflict handling (CreateOrOverwrite)
+fab import ./model.pbix -d "ws.Workspace" -c CreateOrOverwrite
+```
+
+### Import via Large Upload API
+
+For files >1GB:
+
+```bash
+# Create upload session
+fab api -A powerbi "groups/$WS_ID/imports/createUploadSession" -X post -i '{
+  "nameConflict": "CreateOrOverwrite",
+  "name": "LargeModel"
+}'
+```
+
+## Clone Semantic Model
+
+```bash
+# Get source model details
+SOURCE_WS_ID=$(fab get "source.Workspace" -q "id" | tr -d '"')
+SOURCE_MODEL_ID=$(fab get "source.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
+TARGET_WS_ID=$(fab get "target.Workspace" -q "id" | tr -d '"')
+
+# Clone to target workspace
+fab api -A powerbi "groups/$SOURCE_WS_ID/datasets/$SOURCE_MODEL_ID/Default.Clone" -X post -i '{
+  "targetWorkspaceId": "'"$TARGET_WS_ID"'",
+  "targetModelName": "ModelCopy"
+}'
+```
+
+## Model Configuration
+
+### Get Model Parameters
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/parameters"
+```
+
+### Update Parameters
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.UpdateParameters" -X post -i '{
+  "updateDetails": [
+    {
+      "name": "ServerName",
+      "newValue": "newserver.database.windows.net"
+    },
+    {
+      "name": "DatabaseName", 
+      "newValue": "newdatabase"
+    }
+  ]
+}'
+```
+
+### Get Data Sources
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/datasources"
+```
+
+### Update Data Sources
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.UpdateDatasources" -X post -i '{
+  "updateDetails": [
+    {
+      "datasourceSelector": {
+        "datasourceType": "Sql",
+        "connectionDetails": {
+          "server": "oldserver.database.windows.net",
+          "database": "olddb"
+        }
+      },
+      "connectionDetails": {
+        "server": "newserver.database.windows.net",
+        "database": "newdb"
+      }
+    }
+  ]
+}'
+```
+
+## Model Permissions
+
+### Take Over Ownership
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.TakeOver" -X post
+```
+
+### Get Model Users
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/users"
+```
+
+### Add Model User
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/users" -X post -i '{
+  "identifier": "user@contoso.com",
+  "principalType": "User",
+  "datasetUserAccessRight": "Read"
+}'
+```
+
+## Model Lineage
+
+### Get Upstream Datasets
+
+```bash
+fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/upstreamDatasets"
+```
+
+## Quick Reference
+
+| Operation | Command |
+|-----------|---------|
+| List models | `fab ls "ws.Workspace" -t SemanticModel` |
+| Get model | `fab get "ws.Workspace/Model.SemanticModel"` |
+| Export PBIX | `fab export "ws.Workspace/Model.SemanticModel" -d ./` |
+| Import PBIX | `fab import ./model.pbix -d "ws.Workspace"` |
+| Get parameters | `fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/parameters"` |
+| Take over | `fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/Default.TakeOver" -X post` |
+
+## See Also
+
+- [Refresh Operations](./refresh.md) - Refresh semantic models
+- [DAX Queries](./dax-queries.md) - Query semantic model data
+- [Gateways](./gateways.md) - Gateway binding
diff --git a/.ai-assets/skills/fabric-cli-powerbi/scripts/list_refresh_history.py b/.ai-assets/skills/fabric-cli-powerbi/scripts/list_refresh_history.py
new file mode 100644
index 000000000..1d2397c3d
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/scripts/list_refresh_history.py
@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+list_refresh_history.py - Show refresh history and failure details
+
+This script displays the refresh history for a semantic model, including
+duration, status, and error details.
+
+Usage:
+    python list_refresh_history.py <model> [--last N]
+    python list_refresh_history.py Production.Workspace/Sales.SemanticModel --last 10
+
+Exit codes:
+    0 - History retrieved successfully
+    1 - Failed to retrieve history
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_semantic_model_suffix(path: str) -> str:
+    """Ensure path has .SemanticModel suffix if it's just a model path."""
+    # If it already ends with a type suffix, return as is
+    known_suffixes = [".SemanticModel", ".Dataset", ".Workspace"]
+    for suffix in known_suffixes:
+        if path.endswith(suffix):
+            return path
+    
+    # If path contains a workspace but no model type, add SemanticModel
+    if "/" in path and not path.split("/")[-1].count("."):
+        return f"{path}.SemanticModel"
+    
+    return path
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def get_refresh_history(model_path: str, limit: int = 10) -> List[Dict[str, Any]]:
+    """Get refresh history for a semantic model."""
+    # Use the jobs list command to get refresh history
+    cmd = ["jobs", "list", model_path, "-t", "Refresh", "-l", str(limit), "-f", "json"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        try:
+            result = json.loads(stdout.strip())
+            if isinstance(result, list):
+                return result
+        except json.JSONDecodeError:
+            pass
+    
+    return []
+
+
+def get_job_details(job_id: str, model_path: str) -> Dict[str, Any]:
+    """Get detailed information about a specific job."""
+    cmd = ["jobs", "get", model_path, "-j", job_id, "-f", "json"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd)
+    
+    if exit_code == 0:
+        try:
+            return json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            pass
+    
+    return {}
+
+
+def format_duration(start_time: str, end_time: str) -> str:
+    """Format duration between two ISO timestamps."""
+    try:
+        start = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+        end = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        duration = end - start
+        
+        total_seconds = int(duration.total_seconds())
+        hours, remainder = divmod(total_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        
+        if hours > 0:
+            return f"{hours}h {minutes}m {seconds}s"
+        elif minutes > 0:
+            return f"{minutes}m {seconds}s"
+        else:
+            return f"{seconds}s"
+    except:
+        return "N/A"
+
+
+def format_timestamp(timestamp: str) -> str:
+    """Format ISO timestamp for display."""
+    try:
+        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
+    except:
+        return timestamp
+
+
+def analyze_failure_patterns(history: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Analyze refresh history for failure patterns."""
+    analysis = {
+        "total_refreshes": len(history),
+        "successful": 0,
+        "failed": 0,
+        "cancelled": 0,
+        "in_progress": 0,
+        "success_rate": 0.0,
+        "avg_duration_seconds": 0,
+        "common_errors": {},
+        "recent_failures": []
+    }
+    
+    durations = []
+    
+    for refresh in history:
+        status = refresh.get("status", "").lower()
+        
+        if status in ["completed", "succeeded", "success"]:
+            analysis["successful"] += 1
+            
+            # Calculate duration for successful refreshes
+            start = refresh.get("startTime", refresh.get("startDateTime"))
+            end = refresh.get("endTime", refresh.get("endDateTime"))
+            if start and end:
+                try:
+                    start_dt = datetime.fromisoformat(start.replace("Z", "+00:00"))
+                    end_dt = datetime.fromisoformat(end.replace("Z", "+00:00"))
+                    durations.append((end_dt - start_dt).total_seconds())
+                except:
+                    pass
+                    
+        elif status in ["failed", "error"]:
+            analysis["failed"] += 1
+            
+            # Track error messages
+            error_msg = refresh.get("error", refresh.get("errorMessage", "Unknown error"))
+            if error_msg:
+                analysis["common_errors"][error_msg] = analysis["common_errors"].get(error_msg, 0) + 1
+            
+            # Track recent failures
+            if len(analysis["recent_failures"]) < 5:
+                analysis["recent_failures"].append({
+                    "time": refresh.get("startTime", refresh.get("startDateTime", "Unknown")),
+                    "error": error_msg
+                })
+                
+        elif status in ["cancelled", "canceled"]:
+            analysis["cancelled"] += 1
+            
+        elif status in ["running", "in_progress", "inprogress"]:
+            analysis["in_progress"] += 1
+    
+    # Calculate success rate
+    completed = analysis["successful"] + analysis["failed"]
+    if completed > 0:
+        analysis["success_rate"] = round(analysis["successful"] / completed * 100, 1)
+    
+    # Calculate average duration
+    if durations:
+        analysis["avg_duration_seconds"] = round(sum(durations) / len(durations), 1)
+    
+    return analysis
+
+
+def print_refresh_table(history: List[Dict[str, Any]]):
+    """Print refresh history in a formatted table."""
+    if not history:
+        print("No refresh history found.")
+        return
+    
+    # Table header
+    print("\n{:<6} {:<22} {:<12} {:<12} {}".format(
+        "#", "Started", "Duration", "Status", "Details"
+    ))
+    print("-" * 80)
+    
+    for i, refresh in enumerate(history, 1):
+        # Extract fields
+        start_time = refresh.get("startTime", refresh.get("startDateTime", "N/A"))
+        end_time = refresh.get("endTime", refresh.get("endDateTime", ""))
+        status = refresh.get("status", "Unknown")
+        error = refresh.get("error", refresh.get("errorMessage", ""))
+        
+        # Format values
+        start_formatted = format_timestamp(start_time)[:22] if start_time != "N/A" else "N/A"
+        duration = format_duration(start_time, end_time) if end_time else "Running"
+        
+        # Status emoji
+        status_display = status
+        if status.lower() in ["completed", "succeeded", "success"]:
+            status_display = "✓ Success"
+        elif status.lower() in ["failed", "error"]:
+            status_display = "✗ Failed"
+        elif status.lower() in ["running", "in_progress"]:
+            status_display = "⟳ Running"
+        elif status.lower() in ["cancelled", "canceled"]:
+            status_display = "⊘ Cancelled"
+        
+        # Details (truncate if too long)
+        details = error[:30] + "..." if len(error) > 30 else error
+        
+        print("{:<6} {:<22} {:<12} {:<12} {}".format(
+            i, start_formatted, duration, status_display, details
+        ))
+
+
+def list_refresh_history(
+    model_path: str,
+    limit: int = 10,
+    show_details: bool = False
+) -> Dict[str, Any]:
+    """List refresh history for a semantic model."""
+    
+    model_path = ensure_semantic_model_suffix(model_path)
+    
+    report = {
+        "model": model_path,
+        "limit": limit,
+        "history": [],
+        "analysis": {}
+    }
+    
+    # Verify model exists
+    print(f"\nVerifying model: {model_path}")
+    if not check_path_exists(model_path):
+        print(f"Error: Model '{model_path}' does not exist or is not accessible")
+        return report
+    print("  Model found")
+    
+    # Get refresh history
+    print(f"\nFetching refresh history (last {limit})...")
+    history = get_refresh_history(model_path, limit)
+    report["history"] = history
+    
+    if not history:
+        print("  No refresh history found")
+        return report
+    
+    print(f"  Found {len(history)} refresh record(s)")
+    
+    # Get additional details if requested
+    if show_details:
+        print("\nFetching detailed information...")
+        for i, refresh in enumerate(history):
+            job_id = refresh.get("id", refresh.get("jobId"))
+            if job_id:
+                details = get_job_details(job_id, model_path)
+                if details:
+                    history[i].update(details)
+    
+    # Print table
+    print_refresh_table(history)
+    
+    # Analyze patterns
+    print("\nAnalyzing refresh patterns...")
+    analysis = analyze_failure_patterns(history)
+    report["analysis"] = analysis
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Show refresh history and failure details for a semantic model",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python list_refresh_history.py Production.Workspace/Sales.SemanticModel
+    python list_refresh_history.py Production.Workspace/Sales.SemanticModel --last 20
+    python list_refresh_history.py "My Workspace/Revenue Model" --last 5 --details
+
+Output includes:
+    - Refresh start time
+    - Duration
+    - Status (Success, Failed, Running, Cancelled)
+    - Error details for failed refreshes
+    - Success rate analysis
+    - Common error patterns
+        """
+    )
+    parser.add_argument(
+        "model",
+        help="Semantic model path (Workspace/Model.SemanticModel)"
+    )
+    parser.add_argument(
+        "--last", "-n",
+        type=int,
+        default=10,
+        help="Number of recent refreshes to show (default: 10)"
+    )
+    parser.add_argument(
+        "--details", "-d",
+        action="store_true",
+        help="Fetch detailed information for each refresh"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = list_refresh_history(
+            model_path=args.model,
+            limit=args.last,
+            show_details=args.details
+        )
+        
+        # Print analysis summary
+        if report["analysis"]:
+            analysis = report["analysis"]
+            print("\n" + "=" * 50)
+            print("REFRESH ANALYSIS")
+            print("=" * 50)
+            print(f"Total Refreshes: {analysis['total_refreshes']}")
+            print(f"  Successful: {analysis['successful']}")
+            print(f"  Failed: {analysis['failed']}")
+            print(f"  Cancelled: {analysis['cancelled']}")
+            print(f"  In Progress: {analysis['in_progress']}")
+            print(f"\nSuccess Rate: {analysis['success_rate']}%")
+            
+            if analysis['avg_duration_seconds'] > 0:
+                avg_mins = analysis['avg_duration_seconds'] / 60
+                print(f"Avg Duration: {avg_mins:.1f} minutes")
+            
+            if analysis['common_errors']:
+                print("\nCommon Errors:")
+                for error, count in sorted(analysis['common_errors'].items(), key=lambda x: -x[1])[:3]:
+                    print(f"  [{count}x] {error[:60]}...")
+            
+            print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2, default=str))
+        
+        # Exit code: 0 if we got history, 1 if not
+        sys.exit(0 if report['history'] else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-powerbi/scripts/rebind_report.py b/.ai-assets/skills/fabric-cli-powerbi/scripts/rebind_report.py
new file mode 100644
index 000000000..f27d502a6
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/scripts/rebind_report.py
@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+"""
+rebind_report.py - Rebind report to different semantic model
+
+This script changes the semantic model connection for a Power BI report in
+Microsoft Fabric.
+
+Usage:
+    python rebind_report.py <report> --model <new-model>
+    python rebind_report.py Production.Workspace/SalesReport.Report --model Production.Workspace/NewSales.SemanticModel
+
+Exit codes:
+    0 - Report successfully rebound to new model
+    1 - Rebind failed or error occurred
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+from typing import Dict, Any, Optional, Tuple
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def parse_item_path(path: str, item_type: str) -> Tuple[Optional[str], Optional[str]]:
+    """Parse workspace and item name from path."""
+    parts = path.split("/")
+    if len(parts) != 2:
+        return None, None
+    
+    workspace = parts[0]
+    item = parts[1]
+    
+    # Ensure workspace suffix
+    if not workspace.endswith(".Workspace"):
+        workspace = f"{workspace}.Workspace"
+    
+    # Ensure item suffix
+    suffix = f".{item_type}"
+    if not item.endswith(suffix):
+        item = f"{item}{suffix}"
+    
+    return workspace, item
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def get_item_details(path: str) -> Dict[str, Any]:
+    """Get item details."""
+    exit_code, stdout, stderr = run_fab_command(["get", path, "-f", "json"])
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {"error": "Failed to parse item details"}
+    return {"error": stderr.strip() or "Failed to get item details"}
+
+
+def get_item_id(path: str) -> Optional[str]:
+    """Get item ID from path."""
+    exit_code, stdout, stderr = run_fab_command(["get", path, "-q", "id", "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, str):
+            return result.strip('"')
+        return result
+    return None
+
+
+def get_report_datasource(report_path: str) -> Dict[str, Any]:
+    """Get the current datasource configuration for a report."""
+    exit_code, stdout, stderr = run_fab_command(["get", report_path, "-f", "json"])
+    
+    if exit_code == 0:
+        details = parse_json_output(stdout) or {}
+        return {
+            "current_model": details.get("semanticModelId") or details.get("datasetId"),
+            "workspace_id": details.get("workspaceId"),
+            "details": details
+        }
+    return {"error": stderr}
+
+
+def rebind_report(workspace_id: str, report_id: str, new_model_id: str, 
+                  new_model_workspace_id: Optional[str] = None) -> Dict[str, Any]:
+    """Rebind report to a new semantic model using the API."""
+    
+    result = {
+        "status": "unknown",
+        "message": "",
+        "report_id": report_id,
+        "new_model_id": new_model_id
+    }
+    
+    # Build the API request body
+    request_body = {
+        "datasetId": new_model_id
+    }
+    
+    # If model is in different workspace, include workspace ID
+    if new_model_workspace_id and new_model_workspace_id != workspace_id:
+        request_body["datasetWorkspaceId"] = new_model_workspace_id
+    
+    # Use the API command to rebind
+    # POST /groups/{workspaceId}/reports/{reportId}/Rebind
+    api_path = f"/groups/{workspace_id}/reports/{report_id}/Rebind"
+    
+    exit_code, stdout, stderr = run_fab_command([
+        "api", "post", api_path,
+        "-b", json.dumps(request_body),
+        "--api-version", "v1.0",
+        "-f", "json"
+    ], timeout=60)
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = "Report successfully rebound to new semantic model"
+    else:
+        # Check for specific error conditions
+        if "already bound" in stderr.lower() or "same dataset" in stderr.lower():
+            result["status"] = "success"
+            result["message"] = "Report is already bound to the specified model"
+        else:
+            result["status"] = "failed"
+            result["message"] = stderr.strip() or "Failed to rebind report"
+    
+    return result
+
+
+def verify_rebind(report_path: str, expected_model_id: str) -> bool:
+    """Verify that rebind was successful."""
+    time.sleep(2)  # Give it a moment to propagate
+    
+    datasource = get_report_datasource(report_path)
+    current_model = datasource.get("current_model")
+    
+    return current_model == expected_model_id
+
+
+def print_result(result: Dict[str, Any], output_format: str, output_file: Optional[str] = None):
+    """Print rebind result."""
+    if output_format == "json":
+        output = json.dumps(result, indent=2)
+    else:
+        # Text format
+        lines = []
+        lines.append("=" * 60)
+        lines.append("REPORT REBIND RESULT")
+        lines.append("=" * 60)
+        lines.append(f"Report: {result.get('report_path', 'Unknown')}")
+        lines.append(f"Target Model: {result.get('model_path', 'Unknown')}")
+        lines.append("")
+        
+        status = result.get("status", "unknown")
+        if status == "success":
+            lines.append("✓ REBIND SUCCESSFUL")
+            lines.append(f"  {result.get('message', '')}")
+        else:
+            lines.append("✗ REBIND FAILED")
+            lines.append(f"  {result.get('message', 'Unknown error')}")
+        
+        if result.get("verified"):
+            lines.append("")
+            lines.append("✓ Verification: Report is now connected to the new model")
+        elif result.get("verified") is False:
+            lines.append("")
+            lines.append("⚠ Verification: Could not confirm rebind (may need time to propagate)")
+        
+        if result.get("previous_model"):
+            lines.append("")
+            lines.append(f"Previous Model ID: {result['previous_model']}")
+        
+        lines.append("")
+        lines.append("=" * 60)
+        output = "\n".join(lines)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Result written to: {output_file}", file=sys.stderr)
+    else:
+        print(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Rebind report to different semantic model",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python rebind_report.py Production.Workspace/SalesReport.Report --model Production.Workspace/NewSales.SemanticModel
+    python rebind_report.py MyWorkspace/Report --model MyWorkspace/Model -f json
+    python rebind_report.py Dev.Workspace/TestReport.Report --model Prod.Workspace/ProdModel.SemanticModel --verify
+        """
+    )
+    
+    parser.add_argument(
+        "report",
+        help="Report path (e.g., 'MyWorkspace.Workspace/MyReport.Report')"
+    )
+    
+    parser.add_argument(
+        "--model",
+        required=True,
+        help="New semantic model path (e.g., 'MyWorkspace.Workspace/MyModel.SemanticModel')"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "--verify",
+        action="store_true",
+        help="Verify rebind was successful after operation"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without making changes"
+    )
+    
+    args = parser.parse_args()
+    
+    # Parse report path
+    report_workspace, report_name = parse_item_path(args.report, "Report")
+    if not report_workspace or not report_name:
+        print(f"Error: Invalid report path: {args.report}", file=sys.stderr)
+        print("Expected format: Workspace.Workspace/Report.Report", file=sys.stderr)
+        return 1
+    
+    report_path = f"{report_workspace}/{report_name}"
+    
+    # Parse model path
+    model_workspace, model_name = parse_item_path(args.model, "SemanticModel")
+    if not model_workspace or not model_name:
+        print(f"Error: Invalid model path: {args.model}", file=sys.stderr)
+        print("Expected format: Workspace.Workspace/Model.SemanticModel", file=sys.stderr)
+        return 1
+    
+    model_path = f"{model_workspace}/{model_name}"
+    
+    if args.verbose:
+        print(f"Report: {report_path}", file=sys.stderr)
+        print(f"Target Model: {model_path}", file=sys.stderr)
+    
+    # Check report exists
+    if not check_path_exists(report_path):
+        print(f"Error: Report does not exist: {report_path}", file=sys.stderr)
+        return 1
+    
+    # Check model exists
+    if not check_path_exists(model_path):
+        print(f"Error: Semantic model does not exist: {model_path}", file=sys.stderr)
+        return 1
+    
+    # Get current datasource info
+    if args.verbose:
+        print("Getting current report configuration...", file=sys.stderr)
+    
+    current_datasource = get_report_datasource(report_path)
+    if "error" in current_datasource:
+        print(f"Warning: Could not get current datasource: {current_datasource['error']}", file=sys.stderr)
+    
+    # Get IDs
+    if args.verbose:
+        print("Getting item IDs...", file=sys.stderr)
+    
+    # Get report workspace ID and report ID
+    report_workspace_id = get_item_id(report_workspace)
+    report_id = get_item_id(report_path)
+    
+    if not report_workspace_id or not report_id:
+        print("Error: Could not get report workspace or report ID", file=sys.stderr)
+        return 1
+    
+    # Get model workspace ID and model ID
+    model_workspace_id = get_item_id(model_workspace)
+    model_id = get_item_id(model_path)
+    
+    if not model_workspace_id or not model_id:
+        print("Error: Could not get model workspace or model ID", file=sys.stderr)
+        return 1
+    
+    if args.verbose:
+        print(f"Report Workspace ID: {report_workspace_id}", file=sys.stderr)
+        print(f"Report ID: {report_id}", file=sys.stderr)
+        print(f"Model Workspace ID: {model_workspace_id}", file=sys.stderr)
+        print(f"Model ID: {model_id}", file=sys.stderr)
+    
+    result = {
+        "report_path": report_path,
+        "model_path": model_path,
+        "report_id": report_id,
+        "model_id": model_id,
+        "previous_model": current_datasource.get("current_model"),
+        "status": "unknown",
+        "message": ""
+    }
+    
+    # Dry run mode
+    if args.dry_run:
+        result["status"] = "dry_run"
+        result["message"] = "Would rebind report to specified model (dry run, no changes made)"
+        print_result(result, args.format, args.output)
+        return 0
+    
+    # Perform rebind
+    if args.verbose:
+        print("Rebinding report to new model...", file=sys.stderr)
+    
+    rebind_result = rebind_report(
+        report_workspace_id, 
+        report_id, 
+        model_id,
+        model_workspace_id if model_workspace_id != report_workspace_id else None
+    )
+    
+    result["status"] = rebind_result["status"]
+    result["message"] = rebind_result["message"]
+    
+    # Verify if requested
+    if args.verify and rebind_result["status"] == "success":
+        if args.verbose:
+            print("Verifying rebind...", file=sys.stderr)
+        
+        verified = verify_rebind(report_path, model_id)
+        result["verified"] = verified
+    
+    # Output result
+    print_result(result, args.format, args.output)
+    
+    # Return exit code
+    return 0 if result["status"] == "success" else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-powerbi/scripts/refresh_model.py b/.ai-assets/skills/fabric-cli-powerbi/scripts/refresh_model.py
new file mode 100644
index 000000000..85bd45f25
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-powerbi/scripts/refresh_model.py
@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+refresh_model.py - Trigger and monitor semantic model refresh
+
+This script triggers a semantic model refresh in Microsoft Fabric and optionally
+waits for completion with configurable timeout.
+
+Usage:
+    python refresh_model.py <model> [--wait] [--timeout 300]
+    python refresh_model.py Production.Workspace/Sales.SemanticModel --wait --timeout 600
+
+Exit codes:
+    0 - Refresh completed successfully (or triggered successfully without --wait)
+    1 - Refresh failed or error occurred
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import time
+from typing import Dict, Any, Optional, Tuple
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def parse_model_path(model_path: str) -> Tuple[Optional[str], Optional[str]]:
+    """Parse workspace and model name from path."""
+    # Handle format: Workspace.Workspace/Model.SemanticModel or Workspace/Model.SemanticModel
+    parts = model_path.split("/")
+    if len(parts) != 2:
+        return None, None
+    
+    workspace = parts[0]
+    model = parts[1]
+    
+    # Ensure suffixes
+    if not workspace.endswith(".Workspace"):
+        workspace = f"{workspace}.Workspace"
+    if not model.endswith(".SemanticModel"):
+        model = f"{model}.SemanticModel"
+    
+    return workspace, model
+
+
+def get_ids_from_path(workspace: str, model: str) -> Tuple[Optional[str], Optional[str]]:
+    """Get workspace ID and model ID from names."""
+    # Get workspace ID
+    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-q", "id", "-f", "json"])
+    if exit_code != 0:
+        print(f"Error: Failed to get workspace ID: {stderr}", file=sys.stderr)
+        return None, None
+    
+    workspace_id = parse_json_output(stdout)
+    if not workspace_id:
+        print(f"Error: Could not parse workspace ID", file=sys.stderr)
+        return None, None
+    
+    # Get model ID
+    model_path = f"{workspace}/{model}"
+    exit_code, stdout, stderr = run_fab_command(["get", model_path, "-q", "id", "-f", "json"])
+    if exit_code != 0:
+        print(f"Error: Failed to get model ID: {stderr}", file=sys.stderr)
+        return None, None
+    
+    model_id = parse_json_output(stdout)
+    if not model_id:
+        print(f"Error: Could not parse model ID", file=sys.stderr)
+        return None, None
+    
+    return workspace_id.strip('"'), model_id.strip('"')
+
+
+def trigger_refresh(workspace_id: str, model_id: str, retry_count: int = 1) -> Dict[str, Any]:
+    """Trigger semantic model refresh via Power BI API."""
+    result = {
+        "status": "unknown",
+        "refresh_id": None,
+        "polling_endpoint": None,
+        "message": ""
+    }
+    
+    # Build request body
+    request_body = json.dumps({"retryCount": str(retry_count)})
+    
+    # Trigger refresh using fab api command
+    api_path = f"groups/{workspace_id}/datasets/{model_id}/refreshes"
+    exit_code, stdout, stderr = run_fab_command([
+        "api", "-A", "powerbi", "-X", "post", api_path,
+        "--show_headers", "-i", request_body
+    ])
+    
+    if exit_code != 0:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "Failed to trigger refresh"
+        return result
+    
+    # Parse response
+    response = parse_json_output(stdout)
+    if not response:
+        result["status"] = "failed"
+        result["message"] = "Failed to parse API response"
+        return result
+    
+    status_code = response.get("status_code")
+    if status_code != 202:
+        result["status"] = "failed"
+        result["message"] = f"Unexpected status code: {status_code}"
+        return result
+    
+    # Extract polling endpoint from Location header
+    headers = response.get("headers", {})
+    location = headers.get("Location", "")
+    
+    if location:
+        # Extract the API path from the full URL
+        match = re.search(r'https?://[^/]+/v1\.0/myorg/(.+)', location)
+        if match:
+            result["polling_endpoint"] = match.group(1).strip()
+    
+    # Fallback to RequestId header
+    if not result["polling_endpoint"]:
+        request_id = headers.get("RequestId")
+        if request_id:
+            result["polling_endpoint"] = f"groups/{workspace_id}/datasets/{model_id}/refreshes/{request_id}"
+            result["refresh_id"] = request_id
+    
+    result["status"] = "triggered"
+    result["message"] = "Refresh triggered successfully"
+    
+    return result
+
+
+def poll_refresh_status(polling_endpoint: str, timeout: int = 300, poll_interval: int = 10) -> Dict[str, Any]:
+    """Poll refresh status until completion or timeout."""
+    result = {
+        "status": "unknown",
+        "final_status": None,
+        "duration_seconds": 0,
+        "message": ""
+    }
+    
+    start_time = time.time()
+    
+    print(f"\nPolling refresh status (timeout: {timeout}s)...")
+    
+    while True:
+        elapsed = time.time() - start_time
+        
+        if elapsed > timeout:
+            result["status"] = "timeout"
+            result["duration_seconds"] = int(elapsed)
+            result["message"] = f"Refresh timed out after {timeout} seconds"
+            return result
+        
+        # Get refresh status
+        exit_code, stdout, stderr = run_fab_command([
+            "api", "-A", "powerbi", polling_endpoint, "--show_headers"
+        ])
+        
+        if exit_code != 0:
+            result["status"] = "error"
+            result["message"] = stderr.strip() or "Failed to get refresh status"
+            return result
+        
+        response = parse_json_output(stdout)
+        if not response:
+            result["status"] = "error"
+            result["message"] = "Failed to parse status response"
+            return result
+        
+        status_code = response.get("status_code")
+        if status_code not in [200, 202]:
+            result["status"] = "error"
+            result["message"] = f"Unexpected status code: {status_code}"
+            return result
+        
+        # Parse the status text
+        status_text = response.get("text", {})
+        if isinstance(status_text, str):
+            status_text = parse_json_output(status_text) or {}
+        
+        refresh_status = status_text.get("extendedStatus") or status_text.get("status", "Unknown")
+        
+        print(f"  Status: {refresh_status} (elapsed: {int(elapsed)}s)")
+        
+        # Check for completion states
+        if refresh_status == "Completed":
+            result["status"] = "completed"
+            result["final_status"] = refresh_status
+            result["duration_seconds"] = int(time.time() - start_time)
+            result["message"] = "Refresh completed successfully"
+            return result
+        
+        if refresh_status in ["Failed", "Cancelled", "Disabled", "TimedOut"]:
+            result["status"] = "failed"
+            result["final_status"] = refresh_status
+            result["duration_seconds"] = int(time.time() - start_time)
+            result["message"] = f"Refresh ended with status: {refresh_status}"
+            
+            # Try to get error details
+            if "error" in status_text:
+                result["error_details"] = status_text["error"]
+            
+            return result
+        
+        # Still in progress, wait and poll again
+        time.sleep(poll_interval)
+
+
+def refresh_model(
+    model_path: str,
+    wait: bool = False,
+    timeout: int = 300,
+    retry_count: int = 1
+) -> Dict[str, Any]:
+    """Main function to refresh a semantic model."""
+    
+    result = {
+        "model_path": model_path,
+        "wait": wait,
+        "timeout": timeout,
+        "trigger_result": None,
+        "poll_result": None,
+        "overall_status": "unknown"
+    }
+    
+    # Parse model path
+    workspace, model = parse_model_path(model_path)
+    if not workspace or not model:
+        result["overall_status"] = "error"
+        result["message"] = f"Invalid model path: {model_path}. Expected format: Workspace/Model.SemanticModel"
+        return result
+    
+    print(f"\nModel: {workspace}/{model}")
+    
+    # Get IDs
+    print("Resolving workspace and model IDs...")
+    workspace_id, model_id = get_ids_from_path(workspace, model)
+    if not workspace_id or not model_id:
+        result["overall_status"] = "error"
+        result["message"] = "Failed to resolve workspace or model ID"
+        return result
+    
+    result["workspace_id"] = workspace_id
+    result["model_id"] = model_id
+    
+    # Trigger refresh
+    print("Triggering refresh...")
+    trigger_result = trigger_refresh(workspace_id, model_id, retry_count)
+    result["trigger_result"] = trigger_result
+    
+    if trigger_result["status"] != "triggered":
+        result["overall_status"] = "failed"
+        result["message"] = trigger_result["message"]
+        return result
+    
+    print(f"✓ {trigger_result['message']}")
+    
+    if not wait:
+        result["overall_status"] = "triggered"
+        result["message"] = "Refresh triggered. Use --wait to monitor completion."
+        return result
+    
+    # Poll for completion
+    if not trigger_result.get("polling_endpoint"):
+        result["overall_status"] = "warning"
+        result["message"] = "Refresh triggered but no polling endpoint available"
+        return result
+    
+    poll_result = poll_refresh_status(
+        trigger_result["polling_endpoint"],
+        timeout=timeout
+    )
+    result["poll_result"] = poll_result
+    
+    if poll_result["status"] == "completed":
+        result["overall_status"] = "completed"
+        result["message"] = f"Refresh completed in {poll_result['duration_seconds']} seconds"
+    else:
+        result["overall_status"] = "failed"
+        result["message"] = poll_result["message"]
+    
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Trigger and monitor semantic model refresh",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python refresh_model.py Production.Workspace/Sales.SemanticModel
+    python refresh_model.py Production/Sales.SemanticModel --wait
+    python refresh_model.py Dev.Workspace/Model.SemanticModel --wait --timeout 600
+    python refresh_model.py "My Workspace/My Model.SemanticModel" --wait --json
+
+Note:
+    Without --wait, the script triggers the refresh and exits immediately.
+    With --wait, the script polls until completion or timeout.
+        """
+    )
+    parser.add_argument(
+        "model",
+        help="Semantic model path (format: Workspace/Model.SemanticModel)"
+    )
+    parser.add_argument(
+        "--wait", "-w",
+        action="store_true",
+        help="Wait for refresh to complete"
+    )
+    parser.add_argument(
+        "--timeout", "-t",
+        type=int,
+        default=300,
+        help="Timeout in seconds when waiting (default: 300)"
+    )
+    parser.add_argument(
+        "--retry-count", "-r",
+        type=int,
+        default=1,
+        help="Number of retries for the refresh operation (default: 1)"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        result = refresh_model(
+            model_path=args.model,
+            wait=args.wait,
+            timeout=args.timeout,
+            retry_count=args.retry_count
+        )
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("REFRESH RESULT")
+        print("=" * 50)
+        print(f"Model: {result['model_path']}")
+        print(f"Status: {result['overall_status'].upper()}")
+        print(f"Message: {result.get('message', 'N/A')}")
+        
+        if result.get("poll_result"):
+            print(f"Duration: {result['poll_result'].get('duration_seconds', 'N/A')} seconds")
+        
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(result, indent=2))
+        
+        # Exit code based on status
+        success_statuses = ["completed", "triggered"]
+        sys.exit(0 if result["overall_status"] in success_statuses else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-realtime/README.md b/.ai-assets/skills/fabric-cli-realtime/README.md
new file mode 100644
index 000000000..10c844183
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/README.md
@@ -0,0 +1,56 @@
+# Fabric CLI Real-Time Intelligence Skill
+
+This skill provides comprehensive guidance for managing real-time analytics in Microsoft Fabric using the Fabric CLI.
+
+## Overview
+
+Real-time intelligence in Fabric enables streaming data analytics through:
+- **Eventhouses** — Optimized streaming data stores
+- **Eventstreams** — Stream ingestion and routing
+- **KQL Databases** — Time-series analytics
+- **Activator** — Alert triggers and actions
+
+## Contents
+
+### Main Skill File
+- `SKILL.md` — Core skill definition and patterns
+
+### Reference Files
+
+| File | Description |
+|------|-------------|
+| `references/eventhouse-operations.md` | Eventhouse creation, configuration, and management |
+| `references/eventstream-patterns.md` | Eventstream sources, destinations, and routing |
+| `references/kql-queries.md` | KQL query patterns and CLI execution |
+| `references/activator-alerts.md` | Alert triggers, conditions, and actions |
+| `references/streaming-patterns.md` | End-to-end streaming architecture patterns |
+
+### Scripts
+
+Automation scripts for real-time intelligence tasks:
+
+| Script | Description | Usage |
+|--------|-------------|-------|
+| `setup_streaming.py` | Create complete streaming pipeline | `python scripts/setup_streaming.py <workspace> --name <pipeline>` |
+| `kql_query.py` | Execute KQL query and return results | `python scripts/kql_query.py <database> --query <kql-file>` |
+| `monitor_eventstream.py` | Check eventstream health and throughput | `python scripts/monitor_eventstream.py <eventstream>` |
+
+## Quick Start
+
+```bash
+# List all real-time items
+fab ls "Workspace/*.Eventhouse"
+fab ls "Workspace/*.Eventstream"
+fab ls "Workspace/*.KQLDatabase"
+
+# Get item details
+fab get "Workspace/MyEventhouse.Eventhouse"
+```
+
+## When to Use This Skill
+
+- Building real-time analytics solutions
+- Setting up streaming data pipelines
+- Configuring KQL-based analytics
+- Creating automated alerts and triggers
+- Managing time-series data stores
diff --git a/.ai-assets/skills/fabric-cli-realtime/SKILL.md b/.ai-assets/skills/fabric-cli-realtime/SKILL.md
new file mode 100644
index 000000000..aaaf52a78
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/SKILL.md
@@ -0,0 +1,259 @@
+---
+name: fabric-cli-realtime
+description: Use Fabric CLI for real-time intelligence — eventhouses, eventstreams, KQL databases, and Activator alerts. Activate when users work with streaming data, real-time analytics, or time-series data.
+---
+
+# Fabric CLI Real-Time Intelligence Skill
+
+Comprehensive skill for managing real-time analytics in Microsoft Fabric using the Fabric CLI.
+
+## Skill Overview
+
+Real-time intelligence in Fabric enables streaming analytics with eventhouses, eventstreams, KQL databases, and Activator alerts. This skill covers CLI operations for building and managing real-time data pipelines.
+
+## Prerequisites
+
+- Fabric CLI installed and authenticated (`fab auth login`)
+- Workspace with Eventhouse capability
+- Understanding of streaming data concepts
+- Familiarity with KQL (Kusto Query Language)
+
+## Automation Scripts
+
+Ready-to-use Python scripts for real-time intelligence tasks. Run any script with `--help` for full options.
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `setup_streaming.py` | Create complete streaming pipeline | `python scripts/setup_streaming.py <workspace> --name <pipeline>` |
+| `kql_query.py` | Execute KQL query and return results | `python scripts/kql_query.py <database> --query <kql-file>` |
+| `monitor_eventstream.py` | Check eventstream health and throughput | `python scripts/monitor_eventstream.py <eventstream>` |
+
+Scripts are located in the `scripts/` folder of this skill.
+
+## Core Capabilities
+
+### 1. Eventhouse Operations
+
+Eventhouses are optimized for streaming data ingestion and analytics.
+
+**Create Eventhouse:**
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "TelemetryEventhouse",
+  "type": "Eventhouse"
+}'
+```
+
+**List Eventhouses:**
+```bash
+fab ls "Workspace/*.Eventhouse"
+fab ls "Workspace" -q "[?type=='Eventhouse']"
+```
+
+**Get Eventhouse Details:**
+```bash
+fab get "Workspace/TelemetryEventhouse.Eventhouse"
+fab get "Workspace/TelemetryEventhouse.Eventhouse" -q "properties"
+```
+
+### 2. KQL Database Management
+
+KQL databases within eventhouses store streaming data.
+
+**Create KQL Database:**
+```bash
+EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"SensorData\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+  }
+}"
+```
+
+**List KQL Databases:**
+```bash
+fab ls "Workspace/*.KQLDatabase"
+```
+
+### 3. Eventstream Configuration
+
+Eventstreams capture and route streaming data.
+
+**Create Eventstream:**
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "IoTEventStream",
+  "type": "Eventstream"
+}'
+```
+
+**List Eventstreams:**
+```bash
+fab ls "Workspace/*.Eventstream"
+```
+
+### 4. KQL Queryset Operations
+
+**Create KQL Queryset:**
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorAnalytics",
+  "type": "KQLQueryset"
+}'
+```
+
+### 5. Activator (Reflex) Alerts
+
+**Create Activator:**
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AnomalyAlerts",
+  "type": "Reflex"
+}'
+```
+
+## Common Patterns
+
+### Real-Time Pipeline Setup
+
+```bash
+#!/bin/bash
+# Set up complete real-time analytics pipeline
+
+WORKSPACE="RealTime.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create Eventhouse
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "TelemetryHub",
+  "type": "Eventhouse"
+}'
+
+# 2. Create KQL Database
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"SensorDB\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+  }
+}"
+
+# 3. Create Eventstream
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorStream",
+  "type": "Eventstream"
+}'
+
+# 4. Create KQL Queryset
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorQueries",
+  "type": "KQLQueryset"
+}'
+
+# 5. Create Activator for alerts
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorAlerts",
+  "type": "Reflex"
+}'
+```
+
+### Streaming Data Ingestion
+
+Configure eventstream sources:
+
+```bash
+# Get eventstream for configuration
+EVENTSTREAM_ID=$(fab get "$WORKSPACE/SensorStream.Eventstream" -q "id" | tr -d '"')
+
+# View eventstream definition
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
+```
+
+### KQL Query Execution
+
+```bash
+# Execute KQL query via API
+KQL_DB_ID=$(fab get "$WORKSPACE/SensorDB.KQLDatabase" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorData | where timestamp > ago(1h) | summarize count() by bin(timestamp, 5m)"
+}'
+```
+
+## Item Types Reference
+
+| Item Type | CLI Type | Purpose |
+|-----------|----------|---------|
+| Eventhouse | `.Eventhouse` | Streaming data store |
+| KQL Database | `.KQLDatabase` | Time-series database |
+| Eventstream | `.Eventstream` | Stream ingestion/routing |
+| KQL Queryset | `.KQLQueryset` | Saved KQL queries |
+| Activator | `.Reflex` | Alert triggers |
+
+## Best Practices
+
+1. **Workspace Organization**
+   - Dedicate workspaces to real-time workloads
+   - Separate dev/test/prod eventhouses
+   - Use clear naming conventions
+
+2. **Data Architecture**
+   - Design for high-velocity ingestion
+   - Partition by time for query performance
+   - Set appropriate retention policies
+
+3. **Monitoring**
+   - Set up alerts for ingestion lag
+   - Monitor query performance
+   - Track storage consumption
+
+4. **Security**
+   - Use workspace permissions for access control
+   - Implement row-level security where needed
+   - Audit query access patterns
+
+## Reference Files
+
+- `references/eventhouse-operations.md` — Eventhouse creation and management
+- `references/eventstream-patterns.md` — Eventstream configuration patterns
+- `references/kql-queries.md` — KQL query examples and CLI execution
+- `references/activator-alerts.md` — Alert configuration and management
+- `references/streaming-patterns.md` — End-to-end streaming architectures
+
+## Related Skills
+
+- **fabric-cli-core** — Foundation CLI operations
+- **fabric-cli-dataengineering** — Lakehouse integration patterns
+- **fabric-cli-governance** — Security and compliance
+
+## Troubleshooting
+
+### Eventhouse Creation Fails
+```bash
+# Check workspace capacity supports Eventhouse
+fab get "Workspace" -q "properties.capacityId"
+```
+
+### Eventstream Not Ingesting
+```bash
+# Check eventstream status
+fab get "Workspace/MyStream.Eventstream" -q "properties"
+
+# Verify source connection
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
+```
+
+### KQL Query Timeout
+```bash
+# Add timeout parameter
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "...",
+  "requestProperties": {
+    "queryTimeout": "5m"
+  }
+}'
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md b/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
new file mode 100644
index 000000000..c3f7fc265
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
@@ -0,0 +1,463 @@
+# Activator Alerts Reference
+
+Guide to creating and managing Activator (Reflex) alerts in Fabric.
+
+## Understanding Activator
+
+Activator (formerly known as Reflex) provides real-time alerting:
+
+- **Event-driven** — Trigger on data conditions
+- **No-code** — Visual alert configuration
+- **Actions** — Email, Teams, Power Automate, custom
+- **Integration** — Works with Eventstreams, KQL, Power BI
+
+## Creating Activators
+
+### Basic Creation
+
+```bash
+WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorAlerts",
+  "type": "Reflex",
+  "description": "Real-time sensor anomaly alerts"
+}'
+```
+
+### Verify Creation
+
+```bash
+# List activators
+fab ls "Workspace/*.Reflex"
+
+# Get details
+fab get "Workspace/SensorAlerts.Reflex"
+```
+
+## Managing Activators
+
+### List All Activators
+
+```bash
+# In workspace
+fab ls "Workspace/*.Reflex" -l
+
+# Across workspaces
+fab ls -R "*.Reflex"
+```
+
+### Get Activator Properties
+
+```bash
+REFLEX_ID=$(fab get "Workspace/SensorAlerts.Reflex" -q "id" | tr -d '"')
+
+# Full details
+fab api "workspaces/$WS_ID/items/$REFLEX_ID"
+
+# Get definition
+fab api "workspaces/$WS_ID/items/$REFLEX_ID/getDefinition"
+```
+
+### Update Activator
+
+```bash
+# Update name/description
+fab api -X patch "workspaces/$WS_ID/items/$REFLEX_ID" -i '{
+  "displayName": "RenamedAlerts",
+  "description": "Updated description"
+}'
+```
+
+### Delete Activator
+
+```bash
+fab rm "Workspace/OldAlerts.Reflex"
+
+# Or via API
+fab api -X delete "workspaces/$WS_ID/items/$REFLEX_ID"
+```
+
+## Alert Configuration Patterns
+
+### Temperature Alert
+
+Configure alert for temperature threshold:
+
+```bash
+# 1. Create Activator
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "HighTempAlert",
+  "type": "Reflex"
+}'
+
+# 2. Configure in UI:
+# - Data source: Eventstream or KQL Database
+# - Condition: temperature > 100
+# - Action: Send email/Teams message
+```
+
+### Anomaly Detection Alert
+
+```bash
+# 1. Create Activator for anomalies
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AnomalyDetector",
+  "type": "Reflex",
+  "description": "Alerts on statistical anomalies"
+}'
+
+# 2. Connect to KQL database with anomaly detection query
+# 3. Configure threshold for anomaly scores
+```
+
+### Error Rate Alert
+
+```bash
+# 1. Create Activator
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "ErrorRateAlert",
+  "type": "Reflex"
+}'
+
+# 2. Connect to Eventstream
+# 3. Configure condition: error_rate > 5%
+# 4. Set action: Teams channel notification
+```
+
+## Data Sources
+
+### Connect to Eventstream
+
+```bash
+# Create Activator connected to Eventstream
+# 1. Create the Activator
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "StreamAlerts",
+  "type": "Reflex"
+}'
+
+# 2. In Eventstream, add Activator as destination
+EVENTSTREAM_ID=$(fab get "Workspace/MyStream.Eventstream" -q "id" | tr -d '"')
+# Add Reflex destination via Eventstream configuration
+```
+
+### Connect to KQL Database
+
+```bash
+# Activator can query KQL database for conditions
+# Configure data source pointing to KQL database
+# Set up scheduled query evaluation
+```
+
+### Connect to Power BI
+
+```bash
+# Activator can monitor Power BI datasets
+# Configure connection to semantic model
+# Set up measure-based conditions
+```
+
+## Action Types
+
+### Email Notification
+
+```bash
+# Configure email action
+{
+  "actions": [{
+    "type": "Email",
+    "recipients": ["alerts@company.com"],
+    "subject": "Alert: {{alertName}}",
+    "body": "Value: {{value}}, Threshold: {{threshold}}"
+  }]
+}
+```
+
+### Teams Notification
+
+```bash
+# Configure Teams action
+{
+  "actions": [{
+    "type": "Teams",
+    "channelId": "<channel-id>",
+    "message": "🚨 Alert triggered: {{alertName}}"
+  }]
+}
+```
+
+### Power Automate Flow
+
+```bash
+# Trigger Power Automate flow
+{
+  "actions": [{
+    "type": "PowerAutomate",
+    "flowId": "<flow-id>",
+    "parameters": {
+      "alertName": "{{alertName}}",
+      "value": "{{value}}"
+    }
+  }]
+}
+```
+
+### Custom Webhook
+
+```bash
+# Call custom webhook
+{
+  "actions": [{
+    "type": "Webhook",
+    "url": "https://api.company.com/alerts",
+    "method": "POST",
+    "body": {
+      "alert": "{{alertName}}",
+      "timestamp": "{{timestamp}}",
+      "value": "{{value}}"
+    }
+  }]
+}
+```
+
+## Automation Scripts
+
+### Complete Alert Pipeline
+
+```bash
+#!/bin/bash
+# Set up complete alerting infrastructure
+
+WORKSPACE="Monitoring.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create Eventhouse for real-time data
+echo "Creating Eventhouse..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "MonitoringHub",
+  "type": "Eventhouse"
+}'
+
+sleep 10
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/MonitoringHub.Eventhouse" -q "id" | tr -d '"')
+
+# 2. Create KQL Database
+echo "Creating KQL Database..."
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"AlertsDB\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+  }
+}"
+
+sleep 10
+
+# 3. Create Eventstream
+echo "Creating Eventstream..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "MonitoringStream",
+  "type": "Eventstream"
+}'
+
+# 4. Create multiple Activators for different conditions
+ALERT_TYPES=("HighTemperature" "ErrorRate" "Latency" "Availability")
+
+for ALERT in "${ALERT_TYPES[@]}"; do
+  echo "Creating ${ALERT}Alert..."
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${ALERT}Alert\",
+    \"type\": \"Reflex\",
+    \"description\": \"Alert for $ALERT conditions\"
+  }"
+done
+
+echo "Alert infrastructure created. Configure conditions in UI."
+```
+
+### Multi-Environment Alerting
+
+```bash
+#!/bin/bash
+# Deploy alerts across environments
+
+ENVIRONMENTS=("Dev" "Staging" "Prod")
+ALERTS=("CriticalErrors" "PerformanceDegraded" "SecurityEvents")
+
+for ENV in "${ENVIRONMENTS[@]}"; do
+  WORKSPACE="${ENV}Monitoring.Workspace"
+  WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+  
+  echo "Deploying to $ENV..."
+  
+  for ALERT in "${ALERTS[@]}"; do
+    fab api -X post "workspaces/$WS_ID/items" -i "{
+      \"displayName\": \"${ALERT}_${ENV}\",
+      \"type\": \"Reflex\",
+      \"description\": \"$ALERT monitoring for $ENV environment\"
+    }"
+  done
+done
+
+echo "Alerts deployed to all environments"
+```
+
+## Monitoring Activators
+
+### Check Alert Status
+
+```bash
+# Get Activator state
+fab get "Workspace/SensorAlerts.Reflex" -q "properties"
+
+# List all Activators with status
+fab ls "Workspace/*.Reflex" -l
+```
+
+### View Alert History
+
+```bash
+# Alert history is typically viewed in UI
+# Or query from connected KQL database if logging enabled
+```
+
+### Enable/Disable Alerts
+
+```bash
+# Activator enable/disable typically done via UI
+# Can export/import definitions for version control
+
+# Export current state
+fab export "Workspace/SensorAlerts.Reflex" -d "./backup/"
+
+# To disable: delete and recreate when needed
+```
+
+## Best Practices
+
+### Alert Design
+
+| Principle | Description |
+|-----------|-------------|
+| Specific conditions | Avoid overly broad alerts |
+| Actionable | Each alert should prompt action |
+| Deduplication | Prevent alert storms |
+| Severity levels | Differentiate critical vs warning |
+| Clear naming | Descriptive alert names |
+
+### Condition Configuration
+
+- Set realistic thresholds based on historical data
+- Use time windows to avoid false positives
+- Consider business hours for non-critical alerts
+- Test conditions before production deployment
+
+### Action Configuration
+
+- Verify notification channels work
+- Set up escalation paths
+- Include context in alert messages
+- Consider rate limiting for high-volume alerts
+
+### Naming Conventions
+
+| Component | Convention | Example |
+|-----------|------------|---------|
+| Activator | `<Condition><Severity>Alert` | `HighTempCriticalAlert` |
+| Alert groups | `<System>Alerts` | `ProductionAlerts` |
+
+## Integration Patterns
+
+### Eventstream to Activator
+
+```bash
+#!/bin/bash
+# Set up Eventstream -> Activator flow
+
+WORKSPACE="Alerts.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Create Eventstream
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AlertDataStream",
+  "type": "Eventstream"
+}'
+
+# Create Activator
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "StreamBasedAlerts",
+  "type": "Reflex"
+}'
+
+echo "Configure Eventstream to route to Activator in UI"
+```
+
+### KQL Query to Activator
+
+```bash
+#!/bin/bash
+# Set up KQL-based alerting
+
+WORKSPACE="Analytics.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "$WORKSPACE/AnalyticsDB.KQLDatabase" -q "id" | tr -d '"')
+
+# Create alert query (stored as function)
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create function AlertCondition() { Events | where timestamp > ago(5m) | summarize errorCount=countif(eventType==\"error\") | where errorCount > 100 }"
+}'
+
+# Create Activator
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "KQLBasedAlert",
+  "type": "Reflex"
+}'
+
+echo "Configure Activator to use KQL query in UI"
+```
+
+## Troubleshooting
+
+### Alerts Not Firing
+
+```bash
+# Check Activator exists
+fab ls "Workspace/*.Reflex" -l
+
+# Verify data source connection
+fab get "Workspace/MyAlert.Reflex" -q "properties"
+
+# Check condition - manually query the data
+# to verify condition should be met
+```
+
+### Too Many Alerts
+
+```bash
+# Review alert conditions
+# - Add time windows
+# - Increase thresholds
+# - Add deduplication logic
+# - Consider aggregated alerts
+```
+
+### Action Not Executing
+
+```bash
+# Verify action configuration
+# - Check email addresses
+# - Verify Teams channel access
+# - Test webhook endpoint manually
+# - Check Power Automate flow status
+```
+
+### Performance Issues
+
+```bash
+# If Activator causing performance issues:
+# - Reduce query frequency
+# - Optimize underlying KQL queries
+# - Consider sampling for high-volume streams
+# - Use materialized views for complex conditions
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md b/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
new file mode 100644
index 000000000..e9a248437
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
@@ -0,0 +1,371 @@
+# Eventhouse Operations Reference
+
+Complete guide to managing Eventhouses in Microsoft Fabric using CLI.
+
+## Understanding Eventhouses
+
+Eventhouses are optimized storage for high-velocity streaming data:
+
+- **High throughput** — Millions of events per second
+- **Time-series optimized** — Built for temporal queries
+- **Auto-scaling** — Adapts to ingestion volume
+- **Integrated** — Works with Eventstreams, KQL, Activator
+
+## Creating Eventhouses
+
+### Basic Creation
+
+```bash
+WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "TelemetryEventhouse",
+  "type": "Eventhouse",
+  "description": "Central telemetry data store"
+}'
+```
+
+### Verify Creation
+
+```bash
+# List eventhouses
+fab ls "Workspace/*.Eventhouse"
+
+# Get details
+fab get "Workspace/TelemetryEventhouse.Eventhouse"
+```
+
+## Managing Eventhouses
+
+### List All Eventhouses
+
+```bash
+# In current workspace
+fab ls "Workspace/*.Eventhouse" -l
+
+# Across all workspaces (admin)
+fab ls -R "*.Eventhouse"
+
+# With specific details
+fab api "workspaces/$WS_ID/items" -q "value[?type=='Eventhouse'].{name: displayName, id: id}"
+```
+
+### Get Eventhouse Properties
+
+```bash
+EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
+
+# Full properties
+fab api "workspaces/$WS_ID/items/$EVENTHOUSE_ID"
+
+# Specific property
+fab get "Workspace/MyEventhouse.Eventhouse" -q "properties.state"
+```
+
+### Update Eventhouse
+
+```bash
+# Update display name
+fab api -X patch "workspaces/$WS_ID/items/$EVENTHOUSE_ID" -i '{
+  "displayName": "RenamedEventhouse"
+}'
+
+# Update description
+fab api -X patch "workspaces/$WS_ID/items/$EVENTHOUSE_ID" -i '{
+  "description": "Updated description for telemetry eventhouse"
+}'
+```
+
+### Delete Eventhouse
+
+```bash
+# Delete by path
+fab rm "Workspace/OldEventhouse.Eventhouse"
+
+# Delete by ID
+fab api -X delete "workspaces/$WS_ID/items/$EVENTHOUSE_ID"
+```
+
+## KQL Database Management
+
+Each eventhouse can contain multiple KQL databases.
+
+### Create KQL Database
+
+```bash
+EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"SensorData\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\",
+    \"configuration\": {
+      \"kind\": \"ReadWrite\"
+    }
+  }
+}"
+```
+
+### List KQL Databases
+
+```bash
+# All KQL databases in workspace
+fab ls "Workspace/*.KQLDatabase"
+
+# Get parent eventhouse
+fab get "Workspace/SensorData.KQLDatabase" -q "properties.parentEventhouseId"
+```
+
+### Shortcut Database (Read-Only)
+
+Create a read-only reference to another KQL database:
+
+```bash
+# Create shortcut database
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SharedSensorData",
+  "type": "KQLDatabase",
+  "properties": {
+    "parentEventhouseId": "<local-eventhouse-id>",
+    "configuration": {
+      "kind": "ReadOnly",
+      "sourceKqlDatabaseId": "<source-kql-db-id>"
+    }
+  }
+}'
+```
+
+## Table Operations
+
+### Create Table via KQL
+
+```bash
+KQL_DB_ID=$(fab get "Workspace/SensorData.KQLDatabase" -q "id" | tr -d '"')
+
+# Execute table creation command
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table SensorReadings (timestamp: datetime, deviceId: string, temperature: real, humidity: real)"
+}'
+```
+
+### Create Table with Mapping
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table SensorReadings ingestion json mapping \"SensorMapping\" \"[{\"column\":\"timestamp\",\"path\":\"$.ts\"},{\"column\":\"deviceId\",\"path\":\"$.device\"},{\"column\":\"temperature\",\"path\":\"$.temp\"},{\"column\":\"humidity\",\"path\":\"$.humid\"}]\""
+}'
+```
+
+### List Tables
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show tables"
+}'
+```
+
+### Drop Table
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".drop table SensorReadings"
+}'
+```
+
+## Configuration Options
+
+### Data Retention
+
+```bash
+# Set retention policy
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter-merge table SensorReadings policy retention softdelete = 30d recoverability = enabled"
+}'
+```
+
+### Caching Policy
+
+```bash
+# Configure hot cache period
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter table SensorReadings policy caching hot = 7d"
+}'
+```
+
+### Ingestion Batching
+
+```bash
+# Configure batching for ingestion
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter table SensorReadings policy ingestionbatching @\"{ \\\"MaximumBatchingTimeSpan\\\": \\\"00:00:30\\\", \\\"MaximumNumberOfItems\\\": 500, \\\"MaximumRawDataSizeMB\\\": 100 }\""
+}'
+```
+
+## Automation Scripts
+
+### Complete Eventhouse Setup
+
+```bash
+#!/bin/bash
+# Create complete eventhouse with KQL database and tables
+
+WORKSPACE="RealTime.Workspace"
+EVENTHOUSE_NAME="TelemetryHub"
+DATABASE_NAME="DeviceData"
+
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create Eventhouse
+echo "Creating eventhouse..."
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"$EVENTHOUSE_NAME\",
+  \"type\": \"Eventhouse\"
+}"
+
+sleep 10
+
+# 2. Get Eventhouse ID
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/$EVENTHOUSE_NAME.Eventhouse" -q "id" | tr -d '"')
+echo "Eventhouse ID: $EVENTHOUSE_ID"
+
+# 3. Create KQL Database
+echo "Creating KQL database..."
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"$DATABASE_NAME\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+  }
+}"
+
+sleep 10
+
+# 4. Get Database ID
+KQL_DB_ID=$(fab get "$WORKSPACE/$DATABASE_NAME.KQLDatabase" -q "id" | tr -d '"')
+echo "KQL Database ID: $KQL_DB_ID"
+
+# 5. Create tables
+echo "Creating tables..."
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table DeviceReadings (timestamp: datetime, deviceId: string, metric: string, value: real)"
+}'
+
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table DeviceEvents (timestamp: datetime, deviceId: string, eventType: string, details: dynamic)"
+}'
+
+# 6. Set retention policies
+echo "Configuring policies..."
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter-merge table DeviceReadings policy retention softdelete = 90d"
+}'
+
+echo "Eventhouse setup complete!"
+```
+
+### Multi-Environment Deployment
+
+```bash
+#!/bin/bash
+# Deploy eventhouse across environments
+
+ENVIRONMENTS=("Dev" "Test" "Prod")
+BASE_NAME="TelemetryHub"
+
+for ENV in "${ENVIRONMENTS[@]}"; do
+  WORKSPACE="${ENV}RealTime.Workspace"
+  WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+  
+  echo "Deploying to $ENV environment..."
+  
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${BASE_NAME}_${ENV}\",
+    \"type\": \"Eventhouse\",
+    \"description\": \"$ENV environment eventhouse\"
+  }"
+  
+  echo "Created $BASE_NAME in $ENV"
+done
+```
+
+## Monitoring
+
+### Check Eventhouse Status
+
+```bash
+# Get eventhouse state
+fab get "Workspace/MyEventhouse.Eventhouse" -q "properties"
+
+# Check all eventhouses in workspace
+fab ls "Workspace/*.Eventhouse" -l -q "[].{name: displayName, state: properties.state}"
+```
+
+### Ingestion Metrics
+
+```bash
+# Query ingestion statistics
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show ingestion failures | where FailedOn > ago(1h)"
+}'
+
+# Recent ingestion volume
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show commands | where StartedOn > ago(1h) | where CommandType == \"DataIngestPull\" | summarize count() by bin(StartedOn, 5m)"
+}'
+```
+
+## Best Practices
+
+### Naming Conventions
+
+| Component | Convention | Example |
+|-----------|------------|---------|
+| Eventhouse | `<Domain>Eventhouse` | `TelemetryEventhouse` |
+| KQL Database | `<DataDomain>DB` | `SensorDataDB` |
+| Tables | `<Entity><Type>` | `DeviceReadings`, `SystemEvents` |
+
+### Capacity Planning
+
+- Monitor ingestion rate trends
+- Set appropriate retention based on query patterns
+- Use caching policies for frequently queried data
+- Consider partitioning for large tables
+
+### Security
+
+- Use workspace roles for access control
+- Configure row-level security for multi-tenant scenarios
+- Audit data access patterns
+
+## Troubleshooting
+
+### Eventhouse Creation Timeout
+
+```bash
+# Check workspace capacity
+fab get "Workspace" -q "properties.capacityId"
+
+# Verify capacity supports Eventhouse
+fab api "capacities/<capacity-id>" -q "properties.sku"
+```
+
+### KQL Database Connection Issues
+
+```bash
+# Verify database state
+fab get "Workspace/MyDB.KQLDatabase" -q "properties.state"
+
+# Check parent eventhouse
+PARENT_ID=$(fab get "Workspace/MyDB.KQLDatabase" -q "properties.parentEventhouseId" | tr -d '"')
+fab api "workspaces/$WS_ID/items/$PARENT_ID"
+```
+
+### Ingestion Failures
+
+```bash
+# View recent failures
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show ingestion failures | where FailedOn > ago(1h) | project FailedOn, FailureKind, Details | take 50"
+}'
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md b/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
new file mode 100644
index 000000000..3e5087b9d
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
@@ -0,0 +1,450 @@
+# Eventstream Patterns Reference
+
+Guide to configuring Eventstreams for streaming data pipelines in Fabric.
+
+## Understanding Eventstreams
+
+Eventstreams provide no-code stream processing:
+
+- **Sources** — Ingest from Event Hubs, IoT Hub, custom apps
+- **Destinations** — Route to KQL databases, lakehouses, reflexes
+- **Transformations** — Filter, aggregate, enrich in-flight
+- **Real-time** — Sub-second latency processing
+
+## Creating Eventstreams
+
+### Basic Creation
+
+```bash
+WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorEventStream",
+  "type": "Eventstream",
+  "description": "IoT sensor data ingestion"
+}'
+```
+
+### Verify Creation
+
+```bash
+# List eventstreams
+fab ls "Workspace/*.Eventstream"
+
+# Get details
+fab get "Workspace/SensorEventStream.Eventstream"
+```
+
+## Managing Eventstreams
+
+### List Eventstreams
+
+```bash
+# All eventstreams in workspace
+fab ls "Workspace/*.Eventstream" -l
+
+# With filtering
+fab api "workspaces/$WS_ID/items" -q "value[?type=='Eventstream']"
+```
+
+### Get Eventstream Definition
+
+```bash
+EVENTSTREAM_ID=$(fab get "Workspace/MyStream.Eventstream" -q "id" | tr -d '"')
+
+# Get full definition
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
+
+# Get specific configuration
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.parts"
+```
+
+### Update Eventstream Definition
+
+```bash
+# Get current definition
+DEFINITION=$(fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition")
+
+# Update definition (after modifying)
+fab api -X post "workspaces/$WS_ID/items/$EVENTSTREAM_ID/updateDefinition" -i '{
+  "definition": {
+    "parts": [...]
+  }
+}'
+```
+
+### Delete Eventstream
+
+```bash
+fab rm "Workspace/OldStream.Eventstream"
+
+# Or via API
+fab api -X delete "workspaces/$WS_ID/items/$EVENTSTREAM_ID"
+```
+
+## Source Configuration
+
+### Event Hub Source
+
+```bash
+# Configure Event Hub as source
+# (Typically done via UI, definition shown for reference)
+{
+  "sources": [{
+    "type": "EventHub",
+    "eventHubNamespaceName": "my-namespace",
+    "eventHubName": "sensor-data",
+    "consumerGroup": "$Default",
+    "connectionId": "<connection-id>"
+  }]
+}
+```
+
+### IoT Hub Source
+
+```bash
+# IoT Hub configuration
+{
+  "sources": [{
+    "type": "IoTHub",
+    "iotHubName": "my-iothub",
+    "consumerGroup": "$Default",
+    "connectionId": "<connection-id>"
+  }]
+}
+```
+
+### Custom Endpoint Source
+
+```bash
+# Get custom endpoint for API ingestion
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.sources[?type=='CustomEndpoint'].endpoint"
+```
+
+### Sample Data Source
+
+```bash
+# Useful for testing
+{
+  "sources": [{
+    "type": "SampleData",
+    "datasetName": "StockTrades"
+  }]
+}
+```
+
+## Destination Configuration
+
+### KQL Database Destination
+
+```bash
+# Route to KQL database
+{
+  "destinations": [{
+    "type": "KQLDatabase",
+    "kqlDatabaseId": "<kql-db-id>",
+    "tableName": "SensorReadings",
+    "inputDataFormat": "Json",
+    "mappingRuleName": "SensorMapping"
+  }]
+}
+```
+
+### Lakehouse Destination
+
+```bash
+# Route to lakehouse table
+{
+  "destinations": [{
+    "type": "Lakehouse",
+    "lakehouseId": "<lakehouse-id>",
+    "tableName": "streaming_data",
+    "inputDataFormat": "Json"
+  }]
+}
+```
+
+### Reflex (Activator) Destination
+
+```bash
+# Route to Activator for alerting
+{
+  "destinations": [{
+    "type": "Reflex",
+    "reflexId": "<reflex-id>"
+  }]
+}
+```
+
+## Transformation Patterns
+
+### Filter Transformation
+
+Filter events based on conditions:
+
+```bash
+# Filter definition
+{
+  "transformations": [{
+    "type": "Filter",
+    "condition": "temperature > 100"
+  }]
+}
+```
+
+### Aggregate Transformation
+
+Windowed aggregations:
+
+```bash
+# Tumbling window aggregation
+{
+  "transformations": [{
+    "type": "Aggregate",
+    "windowType": "Tumbling",
+    "windowSize": "PT5M",
+    "groupBy": ["deviceId"],
+    "aggregates": [
+      {"function": "Avg", "column": "temperature", "alias": "avgTemp"},
+      {"function": "Max", "column": "temperature", "alias": "maxTemp"}
+    ]
+  }]
+}
+```
+
+### Derived Column
+
+Add computed columns:
+
+```bash
+{
+  "transformations": [{
+    "type": "DerivedColumn",
+    "columns": [{
+      "name": "processed_time",
+      "expression": "CURRENT_TIMESTAMP()"
+    }]
+  }]
+}
+```
+
+## End-to-End Patterns
+
+### IoT Telemetry Pipeline
+
+```bash
+#!/bin/bash
+# Set up IoT telemetry streaming pipeline
+
+WORKSPACE="IoT.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create Eventstream
+echo "Creating eventstream..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "IoTTelemetryStream",
+  "type": "Eventstream"
+}'
+
+# 2. Get eventhouse and KQL database IDs
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "$WORKSPACE/DeviceData.KQLDatabase" -q "id" | tr -d '"')
+
+# 3. Create connection for Event Hub
+echo "Setting up Event Hub connection..."
+fab api -X post "connections" -i '{
+  "displayName": "IoTEventHubConnection",
+  "connectionDetails": {
+    "type": "EventHub",
+    "parameters": {
+      "server": "my-namespace.servicebus.windows.net",
+      "eventHub": "telemetry"
+    }
+  },
+  "credentialDetails": {
+    "credentialType": "SharedAccessKey"
+  }
+}'
+
+echo "Eventstream created. Configure sources and destinations in UI."
+```
+
+### Multi-Destination Routing
+
+Route same stream to multiple destinations:
+
+```bash
+#!/bin/bash
+# Configure eventstream for multi-destination routing
+
+WORKSPACE="Analytics.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Create eventstream
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "MultiRouteStream",
+  "type": "Eventstream",
+  "description": "Routes to KQL, Lakehouse, and Activator"
+}'
+
+echo "Configure in UI:"
+echo "1. Add source (Event Hub/IoT Hub/Custom Endpoint)"
+echo "2. Add KQL Database destination for real-time queries"
+echo "3. Add Lakehouse destination for historical analysis"
+echo "4. Add Activator destination for alerting"
+```
+
+### Stream Processing with Aggregation
+
+```bash
+#!/bin/bash
+# Set up aggregation stream
+
+WORKSPACE="Metrics.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Create raw eventstream
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "RawMetricsStream",
+  "type": "Eventstream"
+}'
+
+# Create aggregated eventstream
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AggregatedMetricsStream",
+  "type": "Eventstream",
+  "description": "5-minute aggregated metrics"
+}'
+
+echo "Configure aggregation:"
+echo "1. RawMetricsStream: Source -> Lakehouse (raw data)"
+echo "2. AggregatedMetricsStream: Derived from raw with 5-min tumbling window -> KQL"
+```
+
+## Connection Management
+
+### List Streaming Connections
+
+```bash
+# List all connections
+fab ls ".connections" -l
+
+# Filter for Event Hub connections
+fab ls ".connections/*.Connection" -q "[?type=='EventHub']"
+```
+
+### Create Event Hub Connection
+
+```bash
+fab api -X post "connections" -i '{
+  "displayName": "EventHubConn",
+  "connectionDetails": {
+    "type": "EventHub",
+    "parameters": {
+      "server": "namespace.servicebus.windows.net",
+      "eventHub": "eventhub-name"
+    }
+  },
+  "credentialDetails": {
+    "credentialType": "SharedAccessKey",
+    "sharedAccessKey": {
+      "keyName": "RootManageSharedAccessKey",
+      "key": "<key-value>"
+    }
+  }
+}'
+```
+
+### Create IoT Hub Connection
+
+```bash
+fab api -X post "connections" -i '{
+  "displayName": "IoTHubConn",
+  "connectionDetails": {
+    "type": "IoTHub",
+    "parameters": {
+      "server": "iothub-name.azure-devices.net"
+    }
+  },
+  "credentialDetails": {
+    "credentialType": "SharedAccessKey"
+  }
+}'
+```
+
+## Monitoring Eventstreams
+
+### Check Stream Status
+
+```bash
+# Get eventstream properties
+fab get "Workspace/MyStream.Eventstream" -q "properties"
+
+# Check for errors in definition
+fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.errors"
+```
+
+### View Metrics (via KQL)
+
+If routing to KQL database, query ingestion metrics:
+
+```bash
+# Query events processed
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "TableName | where ingestion_time() > ago(1h) | summarize count() by bin(ingestion_time(), 5m)"
+}'
+```
+
+## Best Practices
+
+### Design Principles
+
+1. **Single Responsibility** — One eventstream per data domain
+2. **Schema Evolution** — Design for schema changes
+3. **Error Handling** — Configure dead-letter destinations
+4. **Monitoring** — Route subset to monitoring tables
+
+### Naming Conventions
+
+| Component | Convention | Example |
+|-----------|------------|---------|
+| Eventstream | `<Source><Domain>Stream` | `IoTSensorStream` |
+| Connections | `<Service>Conn` | `EventHubConn` |
+
+### Performance Tips
+
+- Use appropriate partitioning at source
+- Configure batching for destinations
+- Filter early in the pipeline
+- Monitor for backpressure
+
+## Troubleshooting
+
+### Stream Not Receiving Data
+
+```bash
+# Check eventstream status
+fab get "Workspace/MyStream.Eventstream"
+
+# Verify source connection
+fab ls ".connections" -l
+
+# Check connection credentials
+fab get ".connections/EventHubConn.Connection" -q "credentialDetails"
+```
+
+### High Latency
+
+```bash
+# Check destination configuration
+# Ensure batching is appropriate for use case
+# Monitor Event Hub/IoT Hub consumer lag
+```
+
+### Data Loss
+
+```bash
+# Verify checkpointing is enabled
+# Check consumer group offset
+# Review dead-letter queue if configured
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md b/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
new file mode 100644
index 000000000..6c2c18cf8
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
@@ -0,0 +1,399 @@
+# KQL Queries Reference
+
+Guide to executing KQL queries using Fabric CLI.
+
+## KQL Query Fundamentals
+
+Kusto Query Language (KQL) is optimized for log and time-series data:
+
+- **Read-optimized** — Fast analytical queries
+- **Pipe syntax** — Chain operators sequentially
+- **Built-in functions** — Time-series, ML, geospatial
+- **Real-time** — Sub-second query response
+
+## Executing Queries via CLI
+
+### Basic Query Execution
+
+```bash
+WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "Workspace/MyDatabase.KQLDatabase" -q "id" | tr -d '"')
+
+# Simple query
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | take 10"
+}'
+```
+
+### Query with JMESPath Filter
+
+```bash
+# Extract specific columns from results
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | take 10"
+}' -q "results[].{device: deviceId, temp: temperature}"
+```
+
+### Query with Timeout
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "LargeTable | summarize count() by bin(timestamp, 1h)",
+  "requestProperties": {
+    "queryTimeout": "PT5M"
+  }
+}'
+```
+
+## Common Query Patterns
+
+### Time-Based Filtering
+
+```bash
+# Events from last hour
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | where timestamp > ago(1h)"
+}'
+
+# Events in time range
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | where timestamp between (datetime(2024-01-01) .. datetime(2024-01-31))"
+}'
+
+# Events from specific date
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | where timestamp > startofday(now())"
+}'
+```
+
+### Aggregations
+
+```bash
+# Count by time bucket
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | summarize count() by bin(timestamp, 5m)"
+}'
+
+# Statistics by group
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | summarize avg(temperature), max(temperature), min(temperature) by deviceId"
+}'
+
+# Top N
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | summarize count() by eventType | top 10 by count_"
+}'
+```
+
+### Filtering and Projection
+
+```bash
+# Filter with multiple conditions
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | where temperature > 100 and deviceId startswith \"sensor-\" | project timestamp, deviceId, temperature"
+}'
+
+# Text search
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Logs | where message contains \"error\" | take 100"
+}'
+
+# Regex matching
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Logs | where message matches regex \"Error: [A-Z]{3}[0-9]{4}\""
+}'
+```
+
+### Joins
+
+```bash
+# Inner join
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | join kind=inner (Devices | project deviceId, deviceName) on deviceId"
+}'
+
+# Left outer join
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | join kind=leftouter (Alerts | where severity == \"High\") on deviceId"
+}'
+```
+
+### Time Series Analysis
+
+```bash
+# Moving average
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 5m | extend movingAvg=series_fir(avgTemp, repeat(1, 3))"
+}'
+
+# Anomaly detection
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 5m | extend anomalies=series_decompose_anomalies(avgTemp)"
+}'
+
+# Forecasting
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 1h | extend forecast=series_decompose_forecast(avgTemp, 24)"
+}'
+```
+
+## Management Commands
+
+### Show Tables
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show tables"
+}'
+```
+
+### Show Table Schema
+
+```bash
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table SensorReadings schema"
+}'
+
+# Columns only
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | getschema"
+}'
+```
+
+### Show Table Statistics
+
+```bash
+# Row count and size
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table SensorReadings details"
+}'
+
+# Data statistics
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "SensorReadings | summarize count(), min(timestamp), max(timestamp), dcount(deviceId)"
+}'
+```
+
+### Show Policies
+
+```bash
+# Retention policy
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table SensorReadings policy retention"
+}'
+
+# Caching policy
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table SensorReadings policy caching"
+}'
+
+# All policies
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table SensorReadings policies"
+}'
+```
+
+## Query Automation
+
+### Scheduled Query Script
+
+```bash
+#!/bin/bash
+# Run daily analytics query and export results
+
+WORKSPACE="Analytics.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "$WORKSPACE/AnalyticsDB.KQLDatabase" -q "id" | tr -d '"')
+
+# Daily summary query
+QUERY='
+Events 
+| where timestamp > ago(1d) 
+| summarize 
+    totalEvents=count(), 
+    uniqueDevices=dcount(deviceId),
+    errorCount=countif(eventType == "error")
+  by bin(timestamp, 1h)
+| order by timestamp asc
+'
+
+# Execute and save results
+RESULTS=$(fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i "{
+  \"query\": \"$QUERY\"
+}")
+
+echo "$RESULTS" > daily_summary_$(date +%Y%m%d).json
+echo "Daily summary exported"
+```
+
+### Alert Query Script
+
+```bash
+#!/bin/bash
+# Check for anomalies and alert
+
+WORKSPACE="Monitoring.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "$WORKSPACE/MonitoringDB.KQLDatabase" -q "id" | tr -d '"')
+
+# Check for high error rate
+ERRORS=$(fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "Events | where timestamp > ago(5m) | summarize errorRate=countif(eventType==\"error\") * 100.0 / count()"
+}' -q "results[0].errorRate")
+
+if (( $(echo "$ERRORS > 10" | bc -l) )); then
+  echo "ALERT: Error rate is $ERRORS%"
+  # Send notification...
+fi
+```
+
+### Batch Query Runner
+
+```bash
+#!/bin/bash
+# Run multiple queries and compile report
+
+WORKSPACE="Reports.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+KQL_DB_ID=$(fab get "$WORKSPACE/ReportsDB.KQLDatabase" -q "id" | tr -d '"')
+
+QUERIES=(
+  "Events | where timestamp > ago(1d) | count"
+  "Events | where timestamp > ago(1d) | summarize count() by eventType"
+  "SensorReadings | where timestamp > ago(1d) | summarize avg(temperature) by deviceId"
+)
+
+for i in "${!QUERIES[@]}"; do
+  echo "Running query $((i+1))..."
+  fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i "{
+    \"query\": \"${QUERIES[$i]}\"
+  }" > "query_${i}_results.json"
+done
+
+echo "All queries completed"
+```
+
+## KQL Querysets
+
+### Create KQL Queryset
+
+```bash
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AnalyticsQueries",
+  "type": "KQLQueryset"
+}'
+```
+
+### List Querysets
+
+```bash
+fab ls "Workspace/*.KQLQueryset"
+```
+
+### Export Queryset
+
+```bash
+fab export "Workspace/AnalyticsQueries.KQLQueryset" -d "./exports/"
+```
+
+### Import Queryset
+
+```bash
+fab import -p "Workspace" -d "./querysets/analytics.json" -t KQLQueryset
+```
+
+## Performance Optimization
+
+### Query Best Practices
+
+```kql
+// Use time filters early
+Events
+| where timestamp > ago(1h)  // Filter first
+| where eventType == "error"
+| summarize count() by deviceId
+
+// Avoid wildcards at start
+Events
+| where message startswith "Error"  // Good
+// | where message contains "Error"  // Less efficient
+
+// Project only needed columns
+Events
+| project timestamp, deviceId, eventType  // Early projection
+| where eventType == "error"
+```
+
+### Materialized Views
+
+```bash
+# Create materialized view for common aggregations
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create materialized-view HourlySummary on table Events { Events | summarize count() by bin(timestamp, 1h), eventType }"
+}'
+
+# Query materialized view
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "HourlySummary | where timestamp > ago(7d)"
+}'
+```
+
+### Functions
+
+```bash
+# Create stored function
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create function GetRecentErrors(hours: int = 1) { Events | where timestamp > ago(hours * 1h) | where eventType == \"error\" }"
+}'
+
+# Call function
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "GetRecentErrors(24)"
+}'
+```
+
+## Troubleshooting
+
+### Query Timeout
+
+```bash
+# Increase timeout
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "LargeQuery...",
+  "requestProperties": {
+    "queryTimeout": "PT10M"
+  }
+}'
+
+# Simplify query - add early filters
+# Use summarize to reduce data volume
+```
+
+### No Results
+
+```bash
+# Check table has data
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "TableName | count"
+}'
+
+# Check time range
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "TableName | summarize min(timestamp), max(timestamp)"
+}'
+
+# Verify column names
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "TableName | getschema"
+}'
+```
+
+### Permission Errors
+
+```bash
+# Verify database access
+fab acl get "Workspace/MyDatabase.KQLDatabase"
+
+# Check workspace role
+fab acl get "Workspace"
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md b/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
new file mode 100644
index 000000000..0cd59d9ea
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
@@ -0,0 +1,502 @@
+# Streaming Patterns Reference
+
+End-to-end streaming architecture patterns for Microsoft Fabric.
+
+## Architecture Overview
+
+Fabric real-time intelligence provides a complete streaming platform:
+
+```
+Sources                    Processing                Storage/Analysis           Consumption
+─────────                  ──────────                ────────────────           ───────────
+Event Hub    ─┐                                      ┌─ KQL Database ──── KQL Queries
+IoT Hub      ─┼─► Eventstream ─► Transform ─────────┼─ Lakehouse ─────── Notebooks
+Custom API   ─┤                                      └─ Activator ─────── Alerts
+Kafka        ─┘
+```
+
+## Pattern 1: IoT Telemetry Pipeline
+
+### Use Case
+Process millions of IoT sensor readings with real-time analytics and alerting.
+
+### Architecture
+
+```bash
+#!/bin/bash
+# IoT Telemetry Pipeline Setup
+
+WORKSPACE="IoTAnalytics.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create Eventhouse for time-series data
+echo "Creating Eventhouse..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "TelemetryHub",
+  "type": "Eventhouse"
+}'
+
+sleep 15
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
+
+# 2. Create KQL Database for hot data
+echo "Creating KQL Database..."
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"SensorDataDB\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+  }
+}"
+
+sleep 10
+KQL_DB_ID=$(fab get "$WORKSPACE/SensorDataDB.KQLDatabase" -q "id" | tr -d '"')
+
+# 3. Create tables with optimized schema
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table SensorReadings (timestamp: datetime, deviceId: string, sensorType: string, value: real, unit: string)"
+}'
+
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table DeviceEvents (timestamp: datetime, deviceId: string, eventType: string, details: dynamic)"
+}'
+
+# 4. Set retention and caching policies
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter-merge table SensorReadings policy retention softdelete = 30d"
+}'
+
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".alter table SensorReadings policy caching hot = 7d"
+}'
+
+# 5. Create Eventstream for ingestion
+echo "Creating Eventstream..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "IoTDataStream",
+  "type": "Eventstream"
+}'
+
+# 6. Create Lakehouse for cold storage
+echo "Creating Lakehouse for archive..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "TelemetryArchive",
+  "type": "Lakehouse"
+}'
+
+# 7. Create Activator for alerts
+echo "Creating alerting..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SensorAlerts",
+  "type": "Reflex"
+}'
+
+echo "IoT Pipeline infrastructure created!"
+echo "Next steps:"
+echo "1. Configure IoT Hub connection for Eventstream"
+echo "2. Add KQL Database and Lakehouse as Eventstream destinations"
+echo "3. Configure Activator alert conditions"
+```
+
+### Data Flow
+
+1. **Ingestion**: IoT Hub → Eventstream
+2. **Real-time Processing**: Eventstream transforms (filter, enrich)
+3. **Hot Storage**: KQL Database (7-day cache, 30-day retention)
+4. **Cold Storage**: Lakehouse (historical archive)
+5. **Alerting**: Activator monitors thresholds
+
+## Pattern 2: Event-Driven Architecture
+
+### Use Case
+Process business events with immediate notifications and analytics.
+
+### Architecture
+
+```bash
+#!/bin/bash
+# Event-Driven Architecture Setup
+
+WORKSPACE="EventDriven.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Domain-specific Eventstreams
+DOMAINS=("Orders" "Inventory" "Payments" "Shipping")
+
+for DOMAIN in "${DOMAINS[@]}"; do
+  echo "Creating ${DOMAIN}Stream..."
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${DOMAIN}Stream\",
+    \"type\": \"Eventstream\"
+  }"
+done
+
+# 2. Unified Eventhouse
+echo "Creating EventHub..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "BusinessEventsHub",
+  "type": "Eventhouse"
+}'
+
+sleep 15
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/BusinessEventsHub.Eventhouse" -q "id" | tr -d '"')
+
+# 3. Domain-specific KQL databases
+for DOMAIN in "${DOMAINS[@]}"; do
+  echo "Creating ${DOMAIN}DB..."
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${DOMAIN}DB\",
+    \"type\": \"KQLDatabase\",
+    \"properties\": {
+      \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+    }
+  }"
+done
+
+# 4. Create aggregation views
+sleep 10
+KQL_DB_ID=$(fab get "$WORKSPACE/OrdersDB.KQLDatabase" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".create table Orders (timestamp: datetime, orderId: string, customerId: string, status: string, amount: real)"
+}'
+
+# 5. Alerting per domain
+for DOMAIN in "${DOMAINS[@]}"; do
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${DOMAIN}Alerts\",
+    \"type\": \"Reflex\"
+  }"
+done
+
+echo "Event-Driven Architecture created!"
+```
+
+### Event Flow
+
+1. **Domain Events**: Separate Eventstreams per domain
+2. **Event Store**: KQL databases for queryable event history
+3. **Event Processing**: Real-time aggregations
+4. **Reactions**: Domain-specific Activators for business rules
+
+## Pattern 3: Lambda Architecture
+
+### Use Case
+Combine real-time and batch processing for complete analytics.
+
+### Architecture
+
+```bash
+#!/bin/bash
+# Lambda Architecture Setup
+
+WORKSPACE="Lambda.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# Speed Layer (Real-time)
+echo "Creating Speed Layer..."
+
+# Eventhouse for real-time queries
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SpeedLayerHub",
+  "type": "Eventhouse"
+}'
+
+sleep 15
+SPEED_EH_ID=$(fab get "$WORKSPACE/SpeedLayerHub.Eventhouse" -q "id" | tr -d '"')
+
+fab api -X post "workspaces/$WS_ID/items" -i "{
+  \"displayName\": \"RealtimeDB\",
+  \"type\": \"KQLDatabase\",
+  \"properties\": {
+    \"parentEventhouseId\": \"$SPEED_EH_ID\"
+  }
+}"
+
+# Eventstream for ingestion
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "IngestionStream",
+  "type": "Eventstream"
+}'
+
+# Batch Layer (Historical)
+echo "Creating Batch Layer..."
+
+# Bronze Lakehouse
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "BronzeLakehouse",
+  "type": "Lakehouse"
+}'
+
+# Silver Lakehouse
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "SilverLakehouse",
+  "type": "Lakehouse"
+}'
+
+# Gold Lakehouse
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "GoldLakehouse",
+  "type": "Lakehouse"
+}'
+
+# Serving Layer
+echo "Creating Serving Layer..."
+
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "AnalyticsModel",
+  "type": "SemanticModel"
+}'
+
+echo "Lambda Architecture created!"
+echo ""
+echo "Architecture:"
+echo "┌─────────────────────────────────────────────┐"
+echo "│           Data Sources                       │"
+echo "└─────────────────┬───────────────────────────┘"
+echo "                  │"
+echo "         ┌────────┴────────┐"
+echo "         ▼                 ▼"
+echo "  ┌─────────────┐   ┌──────────────┐"
+echo "  │ Speed Layer │   │ Batch Layer  │"
+echo "  │  (KQL DB)   │   │ (Lakehouse)  │"
+echo "  └──────┬──────┘   └───────┬──────┘"
+echo "         │                  │"
+echo "         └────────┬─────────┘"
+echo "                  ▼"
+echo "         ┌──────────────┐"
+echo "         │Serving Layer │"
+echo "         │(Semantic Mdl)│"
+echo "         └──────────────┘"
+```
+
+### Data Flow
+
+1. **Speed Layer**: Eventstream → KQL Database (real-time, ~hours retention)
+2. **Batch Layer**: Eventstream → Lakehouse (medallion architecture, historical)
+3. **Serving Layer**: Combined queries via Semantic Model
+
+## Pattern 4: Stream-to-Lakehouse
+
+### Use Case
+Stream data directly to Delta Lake for unified batch and streaming.
+
+### Architecture
+
+```bash
+#!/bin/bash
+# Stream-to-Lakehouse Pattern
+
+WORKSPACE="StreamLake.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Create streaming Lakehouse
+echo "Creating streaming Lakehouse..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "StreamingLakehouse",
+  "type": "Lakehouse"
+}'
+
+# 2. Create Eventstream
+echo "Creating Eventstream..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "LakehouseStream",
+  "type": "Eventstream"
+}'
+
+# 3. Create Notebook for streaming queries
+echo "Creating streaming notebook..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "StreamingQueries",
+  "type": "Notebook"
+}'
+
+echo "Stream-to-Lakehouse infrastructure created!"
+echo ""
+echo "Configuration steps:"
+echo "1. Configure Eventstream source (Event Hub, IoT Hub, etc.)"
+echo "2. Add Lakehouse as Eventstream destination"
+echo "3. Configure table and partitioning in Lakehouse destination"
+echo "4. Use Notebook for streaming DataFrame queries"
+```
+
+### Streaming Query Example
+
+```python
+# In Notebook: Query streaming table
+from pyspark.sql.functions import *
+
+# Read from streaming table
+df = spark.readStream \
+    .format("delta") \
+    .table("StreamingLakehouse.streaming_events")
+
+# Real-time aggregation
+agg_df = df \
+    .withWatermark("timestamp", "10 minutes") \
+    .groupBy(
+        window("timestamp", "5 minutes"),
+        "eventType"
+    ) \
+    .count()
+
+# Write to output table
+agg_df.writeStream \
+    .format("delta") \
+    .outputMode("append") \
+    .option("checkpointLocation", "Tables/_checkpoints/agg") \
+    .toTable("StreamingLakehouse.event_aggregates")
+```
+
+## Pattern 5: Real-Time Monitoring
+
+### Use Case
+System health monitoring with immediate alerting.
+
+### Architecture
+
+```bash
+#!/bin/bash
+# Real-Time Monitoring Setup
+
+WORKSPACE="Monitoring.Workspace"
+WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
+
+# 1. Metrics Eventhouse
+echo "Creating Metrics Hub..."
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "MetricsHub",
+  "type": "Eventhouse"
+}'
+
+sleep 15
+EVENTHOUSE_ID=$(fab get "$WORKSPACE/MetricsHub.Eventhouse" -q "id" | tr -d '"')
+
+# 2. Specialized databases
+METRIC_TYPES=("Infrastructure" "Application" "Business")
+
+for TYPE in "${METRIC_TYPES[@]}"; do
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${TYPE}MetricsDB\",
+    \"type\": \"KQLDatabase\",
+    \"properties\": {
+      \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
+    }
+  }"
+done
+
+# 3. Ingestion Eventstreams
+for TYPE in "${METRIC_TYPES[@]}"; do
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${TYPE}MetricsStream\",
+    \"type\": \"Eventstream\"
+  }"
+done
+
+# 4. Alert Activators
+ALERT_TYPES=(
+  "CriticalInfrastructure"
+  "ApplicationErrors"
+  "SLAViolation"
+  "SecurityAnomaly"
+)
+
+for ALERT in "${ALERT_TYPES[@]}"; do
+  fab api -X post "workspaces/$WS_ID/items" -i "{
+    \"displayName\": \"${ALERT}Alert\",
+    \"type\": \"Reflex\"
+  }"
+done
+
+# 5. Dashboard Queryset
+fab api -X post "workspaces/$WS_ID/items" -i '{
+  "displayName": "MonitoringDashboardQueries",
+  "type": "KQLQueryset"
+}'
+
+echo "Monitoring infrastructure created!"
+```
+
+### Monitoring Queries
+
+```bash
+# Infrastructure health
+fab api -X post "workspaces/$WS_ID/items/$INFRA_DB_ID/query" -i '{
+  "query": "Metrics | where timestamp > ago(5m) | summarize avgCPU=avg(cpu_percent), avgMemory=avg(memory_percent) by bin(timestamp, 1m), hostName"
+}'
+
+# Error rates
+fab api -X post "workspaces/$WS_ID/items/$APP_DB_ID/query" -i '{
+  "query": "Logs | where timestamp > ago(5m) | summarize errorRate=countif(level==\"ERROR\") * 100.0 / count() by bin(timestamp, 1m)"
+}'
+
+# SLA tracking
+fab api -X post "workspaces/$WS_ID/items/$BIZ_DB_ID/query" -i '{
+  "query": "Transactions | where timestamp > ago(1h) | summarize p99_latency=percentile(latency_ms, 99), success_rate=countif(status==\"success\") * 100.0 / count() by bin(timestamp, 5m)"
+}'
+```
+
+## Best Practices
+
+### Design Principles
+
+| Principle | Description |
+|-----------|-------------|
+| Schema design | Design for query patterns, not ingestion |
+| Partitioning | Partition by time for efficient querying |
+| Retention | Match retention to use case |
+| Deduplication | Handle duplicates at ingestion |
+
+### Performance Optimization
+
+- Use appropriate time windows for aggregations
+- Enable caching for frequently queried data
+- Create materialized views for common aggregations
+- Optimize KQL queries for time-series patterns
+
+### Operational Considerations
+
+- Monitor ingestion lag and throughput
+- Set up alerts for data freshness
+- Implement dead-letter handling
+- Plan for schema evolution
+
+## Troubleshooting Common Issues
+
+### Data Latency
+
+```bash
+# Check Eventstream lag
+fab get "Workspace/MyStream.Eventstream" -q "properties"
+
+# Query ingestion delay in KQL
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": "TableName | summarize max(ingestion_time() - timestamp)"
+}'
+```
+
+### Missing Data
+
+```bash
+# Check for ingestion failures
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show ingestion failures | where FailedOn > ago(1h)"
+}'
+
+# Verify source connectivity
+fab ls ".connections" -l
+```
+
+### Query Performance
+
+```bash
+# Analyze slow queries
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show queries | where StartedOn > ago(1h) | where Duration > 30s | project StartedOn, Duration, Text"
+}'
+
+# Check table statistics
+fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
+  "query": ".show table TableName extents | summarize count(), sum(OriginalSize), sum(CompressedSize)"
+}'
+```
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py b/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
new file mode 100644
index 000000000..2404bda3e
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+"""
+kql_query.py - Execute KQL query and return results
+
+This script executes Kusto Query Language (KQL) queries against a KQL database
+and returns the results.
+
+Usage:
+    python kql_query.py <database> --query <kql-file>
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --query queries/anomalies.kql
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "SensorData | take 10"
+
+Exit codes:
+    0 - Query executed successfully
+    1 - Query execution failed
+"""
+
+import argparse
+import csv
+import json
+import subprocess
+import sys
+from io import StringIO
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 300) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def ensure_database_suffix(path: str) -> str:
+    """Ensure path has .KQLDatabase suffix if needed."""
+    known_suffixes = [".KQLDatabase", ".Workspace"]
+    for suffix in known_suffixes:
+        if path.endswith(suffix):
+            return path
+    
+    # If path contains a workspace but no database type, add KQLDatabase
+    if "/" in path and not path.split("/")[-1].count("."):
+        return f"{path}.KQLDatabase"
+    
+    return path
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def load_query_from_file(file_path: str) -> str:
+    """Load KQL query from a file."""
+    path = Path(file_path)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"Query file not found: {file_path}")
+    
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read().strip()
+
+
+def execute_kql_query(
+    database_path: str,
+    query: str,
+    timeout: int = 300,
+    limit: Optional[int] = None
+) -> Dict[str, Any]:
+    """Execute a KQL query against a database."""
+    
+    result = {
+        "database": database_path,
+        "query": query,
+        "status": "unknown",
+        "message": "",
+        "rows": [],
+        "columns": [],
+        "row_count": 0,
+        "execution_time_ms": None
+    }
+    
+    # Apply limit if specified and not already in query
+    if limit and "| take" not in query.lower() and "| limit" not in query.lower():
+        query = f"{query} | take {limit}"
+        result["query"] = query
+    
+    # Build the query command
+    cmd = ["tables", "query", database_path, "-q", query, "-f", "json"]
+    
+    exit_code, stdout, stderr = run_fab_command(cmd, timeout=timeout)
+    
+    if exit_code == 0:
+        result["status"] = "success"
+        result["message"] = "Query executed successfully"
+        
+        # Parse the JSON results
+        try:
+            query_result = json.loads(stdout.strip())
+            
+            # Handle different result formats
+            if isinstance(query_result, list):
+                result["rows"] = query_result
+                result["row_count"] = len(query_result)
+                if query_result:
+                    result["columns"] = list(query_result[0].keys())
+            elif isinstance(query_result, dict):
+                if "rows" in query_result:
+                    result["rows"] = query_result["rows"]
+                    result["row_count"] = len(query_result["rows"])
+                if "columns" in query_result:
+                    result["columns"] = query_result["columns"]
+                if "statistics" in query_result:
+                    stats = query_result["statistics"]
+                    if "executionTime" in stats:
+                        result["execution_time_ms"] = stats["executionTime"]
+                        
+        except json.JSONDecodeError:
+            # Output might be in table format
+            result["raw_output"] = stdout.strip()
+            result["message"] = "Query executed but output is not JSON"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or "Query execution failed"
+    
+    return result
+
+
+def format_table_output(rows: List[Dict[str, Any]], columns: List[str], max_width: int = 120):
+    """Format results as a readable table."""
+    if not rows:
+        print("No results returned.")
+        return
+    
+    if not columns:
+        columns = list(rows[0].keys())
+    
+    # Calculate column widths
+    widths = {}
+    for col in columns:
+        col_values = [str(row.get(col, ""))[:50] for row in rows]
+        widths[col] = max(len(col), max(len(v) for v in col_values) if col_values else 0)
+    
+    # Adjust widths if total is too wide
+    total_width = sum(widths.values()) + len(columns) * 3
+    if total_width > max_width:
+        scale = max_width / total_width
+        widths = {k: max(5, int(v * scale)) for k, v in widths.items()}
+    
+    # Print header
+    header = " | ".join(col[:widths[col]].ljust(widths[col]) for col in columns)
+    print(header)
+    print("-" * len(header))
+    
+    # Print rows
+    for row in rows:
+        row_str = " | ".join(
+            str(row.get(col, ""))[:widths[col]].ljust(widths[col]) 
+            for col in columns
+        )
+        print(row_str)
+
+
+def format_csv_output(rows: List[Dict[str, Any]], columns: List[str]):
+    """Format results as CSV."""
+    if not rows:
+        return
+    
+    if not columns:
+        columns = list(rows[0].keys())
+    
+    output = StringIO()
+    writer = csv.DictWriter(output, fieldnames=columns, extrasaction='ignore')
+    writer.writeheader()
+    writer.writerows(rows)
+    print(output.getvalue())
+
+
+def execute_query(
+    database: str,
+    query: Optional[str] = None,
+    query_file: Optional[str] = None,
+    inline: Optional[str] = None,
+    timeout: int = 300,
+    limit: Optional[int] = None
+) -> Dict[str, Any]:
+    """Execute KQL query from file or inline."""
+    
+    database = ensure_database_suffix(database)
+    
+    report = {
+        "database": database,
+        "query_source": None,
+        "query": None,
+        "result": {}
+    }
+    
+    # Verify database exists
+    print(f"\nVerifying database: {database}")
+    if not check_path_exists(database):
+        print(f"Error: Database '{database}' does not exist or is not accessible")
+        return report
+    print("  Database found")
+    
+    # Determine query source
+    if query_file:
+        print(f"\nLoading query from file: {query_file}")
+        try:
+            kql_query = load_query_from_file(query_file)
+            report["query_source"] = f"file:{query_file}"
+        except FileNotFoundError as e:
+            print(f"Error: {e}")
+            return report
+    elif inline:
+        kql_query = inline
+        report["query_source"] = "inline"
+    elif query:
+        kql_query = query
+        report["query_source"] = "argument"
+    else:
+        print("Error: Must provide --query, --file, or --inline")
+        return report
+    
+    report["query"] = kql_query
+    
+    # Display query
+    print("\nExecuting query:")
+    query_lines = kql_query.split("\n")
+    for line in query_lines[:5]:
+        print(f"  {line}")
+    if len(query_lines) > 5:
+        print(f"  ... ({len(query_lines) - 5} more lines)")
+    
+    if limit:
+        print(f"\nRow limit: {limit}")
+    
+    # Execute query
+    print("\nRunning query...")
+    result = execute_kql_query(database, kql_query, timeout=timeout, limit=limit)
+    report["result"] = result
+    
+    if result["status"] == "success":
+        print(f"  ✓ Query completed: {result['row_count']} row(s) returned")
+        if result.get("execution_time_ms"):
+            print(f"  Execution time: {result['execution_time_ms']}ms")
+    else:
+        print(f"  ✗ Query failed: {result['message']}")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Execute KQL query and return results",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Query from file
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --file queries/anomalies.kql
+
+    # Inline query
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "SensorData | take 10"
+
+    # Query with row limit
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "Logs | where Level == 'Error'" --limit 100
+
+    # Output as CSV
+    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --file query.kql --format csv
+
+KQL Query Examples:
+    # Simple table scan
+    SensorData | take 100
+
+    # Filter and project
+    Logs 
+    | where Timestamp > ago(1h)
+    | where Level == "Error"
+    | project Timestamp, Message
+
+    # Aggregation
+    Metrics
+    | summarize avg(Value), max(Value) by bin(Timestamp, 1h), DeviceId
+
+    # Time series
+    SensorData
+    | where Timestamp > ago(24h)
+    | summarize avg(Temperature) by bin(Timestamp, 1h)
+    | render timechart
+        """
+    )
+    parser.add_argument(
+        "database",
+        help="KQL database path (Workspace/Database.KQLDatabase)"
+    )
+    
+    # Query source (mutually exclusive)
+    query_group = parser.add_mutually_exclusive_group(required=True)
+    query_group.add_argument(
+        "--file", "-f",
+        dest="query_file",
+        help="Path to KQL query file"
+    )
+    query_group.add_argument(
+        "--inline", "-i",
+        help="Inline KQL query string"
+    )
+    query_group.add_argument(
+        "--query", "-q",
+        help="KQL query string"
+    )
+    
+    parser.add_argument(
+        "--limit", "-l",
+        type=int,
+        help="Maximum number of rows to return"
+    )
+    parser.add_argument(
+        "--timeout", "-t",
+        type=int,
+        default=300,
+        help="Query timeout in seconds (default: 300)"
+    )
+    parser.add_argument(
+        "--format",
+        choices=["table", "json", "csv"],
+        default="table",
+        help="Output format (default: table)"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = execute_query(
+            database=args.database,
+            query=args.query,
+            query_file=args.query_file,
+            inline=args.inline,
+            timeout=args.timeout,
+            limit=args.limit
+        )
+        
+        result = report.get("result", {})
+        
+        # Print results in requested format
+        if result.get("status") == "success" and result.get("rows"):
+            print("\n" + "=" * 50)
+            print("QUERY RESULTS")
+            print("=" * 50)
+            
+            if args.format == "json":
+                print(json.dumps(result["rows"], indent=2, default=str))
+            elif args.format == "csv":
+                format_csv_output(result["rows"], result.get("columns", []))
+            else:  # table
+                format_table_output(result["rows"], result.get("columns", []))
+            
+            print("=" * 50)
+            print(f"Rows: {result['row_count']}")
+        
+        # Exit code based on query status
+        sys.exit(0 if result.get("status") == "success" else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py b/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
new file mode 100644
index 000000000..58babf2c2
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
@@ -0,0 +1,523 @@
+#!/usr/bin/env python3
+"""
+monitor_eventstream.py - Check eventstream health and throughput
+
+This script monitors the health and performance of an eventstream in Microsoft Fabric,
+checking status, throughput metrics, and error counts.
+
+Usage:
+    python monitor_eventstream.py <eventstream>
+    python monitor_eventstream.py RealTime.Workspace/SensorStream.Eventstream
+
+Exit codes:
+    0 - Eventstream is healthy
+    1 - Eventstream has issues or error occurred
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime
+from typing import Dict, Any, List, Optional, Tuple
+
+
+def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def parse_eventstream_path(path: str) -> Tuple[Optional[str], Optional[str]]:
+    """Parse workspace and eventstream name from path."""
+    parts = path.split("/")
+    if len(parts) != 2:
+        return None, None
+    
+    workspace = parts[0]
+    eventstream = parts[1]
+    
+    # Ensure workspace suffix
+    if not workspace.endswith(".Workspace"):
+        workspace = f"{workspace}.Workspace"
+    
+    # Ensure eventstream suffix
+    if not eventstream.endswith(".Eventstream"):
+        eventstream = f"{eventstream}.Eventstream"
+    
+    return workspace, eventstream
+
+
+def check_path_exists(path: str) -> bool:
+    """Check if path exists."""
+    exit_code, _, _ = run_fab_command(["exists", path])
+    return exit_code == 0
+
+
+def get_item_details(path: str) -> Dict[str, Any]:
+    """Get item details."""
+    exit_code, stdout, stderr = run_fab_command(["get", path, "-f", "json"])
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {"error": "Failed to parse item details"}
+    return {"error": stderr.strip() or "Failed to get item details"}
+
+
+def get_item_id(path: str) -> Optional[str]:
+    """Get item ID from path."""
+    exit_code, stdout, stderr = run_fab_command(["get", path, "-q", "id", "-f", "json"])
+    
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if isinstance(result, str):
+            return result.strip('"')
+        return result
+    return None
+
+
+def get_eventstream_status(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
+    """Get eventstream status via API."""
+    
+    # Try to get eventstream details from the API
+    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}"
+    
+    exit_code, stdout, stderr = run_fab_command([
+        "api", "get", api_path,
+        "-f", "json"
+    ], timeout=30)
+    
+    if exit_code == 0:
+        return parse_json_output(stdout) or {"error": "Failed to parse response"}
+    return {"error": stderr}
+
+
+def get_eventstream_metrics(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
+    """Get eventstream metrics if available."""
+    
+    metrics = {
+        "input_events": None,
+        "output_events": None,
+        "errors": None,
+        "lag": None,
+        "last_updated": None
+    }
+    
+    # Try to get metrics from monitoring API
+    # Note: This is a placeholder - actual API may differ
+    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}/metrics"
+    
+    exit_code, stdout, stderr = run_fab_command([
+        "api", "get", api_path,
+        "-f", "json"
+    ], timeout=30)
+    
+    if exit_code == 0:
+        data = parse_json_output(stdout)
+        if data:
+            metrics["input_events"] = data.get("inputEventsTotal") or data.get("inputEvents")
+            metrics["output_events"] = data.get("outputEventsTotal") or data.get("outputEvents")
+            metrics["errors"] = data.get("errorCount") or data.get("errors")
+            metrics["lag"] = data.get("lagMs") or data.get("lag")
+            metrics["last_updated"] = datetime.now().isoformat()
+    
+    return metrics
+
+
+def get_eventstream_sources_sinks(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
+    """Get eventstream sources and sinks configuration."""
+    
+    result = {
+        "sources": [],
+        "sinks": []
+    }
+    
+    # Try to get source/sink configuration
+    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}/configuration"
+    
+    exit_code, stdout, stderr = run_fab_command([
+        "api", "get", api_path,
+        "-f", "json"
+    ], timeout=30)
+    
+    if exit_code == 0:
+        data = parse_json_output(stdout)
+        if data:
+            result["sources"] = data.get("sources", [])
+            result["sinks"] = data.get("sinks", []) or data.get("destinations", [])
+    
+    return result
+
+
+def analyze_health(details: Dict[str, Any], metrics: Dict[str, Any], 
+                   config: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze eventstream health based on collected data."""
+    
+    health = {
+        "status": "unknown",
+        "score": 0,
+        "checks": [],
+        "warnings": [],
+        "recommendations": []
+    }
+    
+    max_score = 0
+    actual_score = 0
+    
+    # Check 1: Eventstream exists and has basic info
+    max_score += 20
+    if details and "error" not in details:
+        actual_score += 20
+        health["checks"].append({
+            "name": "eventstream_accessible",
+            "passed": True,
+            "message": "Eventstream is accessible"
+        })
+    else:
+        health["checks"].append({
+            "name": "eventstream_accessible",
+            "passed": False,
+            "message": f"Could not access eventstream: {details.get('error', 'Unknown')}"
+        })
+    
+    # Check 2: Has configured sources
+    max_score += 20
+    sources = config.get("sources", [])
+    if sources:
+        actual_score += 20
+        health["checks"].append({
+            "name": "has_sources",
+            "passed": True,
+            "message": f"Eventstream has {len(sources)} configured source(s)"
+        })
+    else:
+        health["checks"].append({
+            "name": "has_sources",
+            "passed": False,
+            "message": "No sources configured"
+        })
+        health["recommendations"].append("Configure at least one data source for the eventstream")
+    
+    # Check 3: Has configured sinks
+    max_score += 20
+    sinks = config.get("sinks", [])
+    if sinks:
+        actual_score += 20
+        health["checks"].append({
+            "name": "has_sinks",
+            "passed": True,
+            "message": f"Eventstream has {len(sinks)} configured sink(s)"
+        })
+    else:
+        health["warnings"].append("No sinks/destinations configured")
+        health["checks"].append({
+            "name": "has_sinks",
+            "passed": False,
+            "message": "No sinks configured"
+        })
+        health["recommendations"].append("Configure at least one destination for the eventstream")
+    
+    # Check 4: Error rate
+    max_score += 20
+    error_count = metrics.get("errors")
+    if error_count is not None:
+        if error_count == 0:
+            actual_score += 20
+            health["checks"].append({
+                "name": "no_errors",
+                "passed": True,
+                "message": "No errors detected"
+            })
+        else:
+            # Partial score based on error severity
+            health["checks"].append({
+                "name": "no_errors",
+                "passed": False,
+                "message": f"Detected {error_count} error(s)"
+            })
+            health["warnings"].append(f"Eventstream has {error_count} errors")
+            health["recommendations"].append("Review eventstream error logs to identify and fix issues")
+    else:
+        actual_score += 10  # Neutral if we can't check
+        health["checks"].append({
+            "name": "no_errors",
+            "passed": True,
+            "message": "Error metrics not available"
+        })
+    
+    # Check 5: Throughput/Activity
+    max_score += 20
+    input_events = metrics.get("input_events")
+    output_events = metrics.get("output_events")
+    
+    if input_events is not None:
+        if input_events > 0:
+            actual_score += 20
+            health["checks"].append({
+                "name": "has_throughput",
+                "passed": True,
+                "message": f"Processing events (input: {input_events}, output: {output_events or 'N/A'})"
+            })
+        else:
+            health["checks"].append({
+                "name": "has_throughput",
+                "passed": False,
+                "message": "No events being processed"
+            })
+            health["warnings"].append("Eventstream shows no event activity")
+            health["recommendations"].append("Verify that sources are sending data")
+    else:
+        actual_score += 10  # Neutral if we can't check
+        health["checks"].append({
+            "name": "has_throughput",
+            "passed": True,
+            "message": "Throughput metrics not available"
+        })
+    
+    # Calculate overall score
+    health["score"] = int((actual_score / max_score) * 100) if max_score > 0 else 0
+    
+    # Determine status
+    if health["score"] >= 80:
+        health["status"] = "healthy"
+    elif health["score"] >= 60:
+        health["status"] = "warning"
+    else:
+        health["status"] = "unhealthy"
+    
+    return health
+
+
+def print_monitoring_report(result: Dict[str, Any], output_format: str, 
+                           output_file: Optional[str] = None):
+    """Print monitoring report."""
+    if output_format == "json":
+        output = json.dumps(result, indent=2)
+    else:
+        # Text format
+        lines = []
+        lines.append("=" * 70)
+        lines.append("EVENTSTREAM MONITORING REPORT")
+        lines.append("=" * 70)
+        lines.append(f"Eventstream: {result['eventstream']}")
+        lines.append(f"Timestamp: {result.get('timestamp', 'Unknown')}")
+        lines.append("")
+        
+        health = result.get("health", {})
+        status = health.get("status", "unknown").upper()
+        score = health.get("score", 0)
+        
+        status_icon = {
+            "HEALTHY": "✓",
+            "WARNING": "⚠",
+            "UNHEALTHY": "✗",
+            "UNKNOWN": "?"
+        }.get(status, "?")
+        
+        lines.append(f"STATUS: {status_icon} {status} (Health Score: {score}%)")
+        lines.append("")
+        
+        # Health checks
+        lines.append("HEALTH CHECKS:")
+        for check in health.get("checks", []):
+            icon = "✓" if check["passed"] else "✗"
+            lines.append(f"  {icon} {check['name']}: {check['message']}")
+        lines.append("")
+        
+        # Metrics
+        metrics = result.get("metrics", {})
+        if any(v is not None for v in metrics.values()):
+            lines.append("METRICS:")
+            if metrics.get("input_events") is not None:
+                lines.append(f"  Input Events: {metrics['input_events']}")
+            if metrics.get("output_events") is not None:
+                lines.append(f"  Output Events: {metrics['output_events']}")
+            if metrics.get("errors") is not None:
+                lines.append(f"  Errors: {metrics['errors']}")
+            if metrics.get("lag") is not None:
+                lines.append(f"  Lag: {metrics['lag']} ms")
+            lines.append("")
+        
+        # Configuration
+        config = result.get("configuration", {})
+        sources = config.get("sources", [])
+        sinks = config.get("sinks", [])
+        
+        lines.append("CONFIGURATION:")
+        lines.append(f"  Sources: {len(sources)}")
+        for src in sources[:5]:  # Show first 5
+            name = src.get("name") or src.get("type", "Unknown")
+            lines.append(f"    - {name}")
+        if len(sources) > 5:
+            lines.append(f"    ... and {len(sources) - 5} more")
+        
+        lines.append(f"  Sinks/Destinations: {len(sinks)}")
+        for sink in sinks[:5]:  # Show first 5
+            name = sink.get("name") or sink.get("type", "Unknown")
+            lines.append(f"    - {name}")
+        if len(sinks) > 5:
+            lines.append(f"    ... and {len(sinks) - 5} more")
+        lines.append("")
+        
+        # Warnings
+        if health.get("warnings"):
+            lines.append("WARNINGS:")
+            for warning in health["warnings"]:
+                lines.append(f"  ⚠ {warning}")
+            lines.append("")
+        
+        # Recommendations
+        if health.get("recommendations"):
+            lines.append("RECOMMENDATIONS:")
+            for rec in health["recommendations"]:
+                lines.append(f"  → {rec}")
+            lines.append("")
+        
+        lines.append("=" * 70)
+        output = "\n".join(lines)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Report written to: {output_file}", file=sys.stderr)
+    else:
+        print(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Check eventstream health and throughput",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python monitor_eventstream.py RealTime.Workspace/SensorStream.Eventstream
+    python monitor_eventstream.py MyWorkspace/MyEventstream -f json
+    python monitor_eventstream.py Production.Workspace/TelemetryStream.Eventstream -o report.json
+        """
+    )
+    
+    parser.add_argument(
+        "eventstream",
+        help="Eventstream path (e.g., 'MyWorkspace.Workspace/MyEventstream.Eventstream')"
+    )
+    
+    parser.add_argument(
+        "-f", "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)"
+    )
+    
+    parser.add_argument(
+        "-o", "--output",
+        help="Output file path (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    args = parser.parse_args()
+    
+    # Parse eventstream path
+    workspace, eventstream = parse_eventstream_path(args.eventstream)
+    if not workspace or not eventstream:
+        print(f"Error: Invalid eventstream path: {args.eventstream}", file=sys.stderr)
+        print("Expected format: Workspace.Workspace/Eventstream.Eventstream", file=sys.stderr)
+        return 1
+    
+    eventstream_path = f"{workspace}/{eventstream}"
+    
+    if args.verbose:
+        print(f"Monitoring eventstream: {eventstream_path}", file=sys.stderr)
+    
+    # Check eventstream exists
+    if not check_path_exists(eventstream_path):
+        print(f"Error: Eventstream does not exist: {eventstream_path}", file=sys.stderr)
+        return 1
+    
+    # Get IDs
+    if args.verbose:
+        print("Getting item IDs...", file=sys.stderr)
+    
+    workspace_id = get_item_id(workspace)
+    eventstream_id = get_item_id(eventstream_path)
+    
+    if not workspace_id or not eventstream_id:
+        print("Error: Could not get workspace or eventstream ID", file=sys.stderr)
+        return 1
+    
+    # Get eventstream details
+    if args.verbose:
+        print("Getting eventstream details...", file=sys.stderr)
+    
+    details = get_item_details(eventstream_path)
+    
+    # Get status
+    if args.verbose:
+        print("Getting eventstream status...", file=sys.stderr)
+    
+    status = get_eventstream_status(workspace_id, eventstream_id)
+    
+    # Get metrics
+    if args.verbose:
+        print("Getting metrics...", file=sys.stderr)
+    
+    metrics = get_eventstream_metrics(workspace_id, eventstream_id)
+    
+    # Get configuration
+    if args.verbose:
+        print("Getting configuration...", file=sys.stderr)
+    
+    config = get_eventstream_sources_sinks(workspace_id, eventstream_id)
+    
+    # Analyze health
+    if args.verbose:
+        print("Analyzing health...", file=sys.stderr)
+    
+    health = analyze_health(details, metrics, config)
+    
+    # Build result
+    result = {
+        "eventstream": eventstream_path,
+        "timestamp": datetime.now().isoformat(),
+        "workspace_id": workspace_id,
+        "eventstream_id": eventstream_id,
+        "details": details if "error" not in details else None,
+        "metrics": metrics,
+        "configuration": config,
+        "health": health
+    }
+    
+    # Output report
+    print_monitoring_report(result, args.format, args.output)
+    
+    # Return exit code based on health status
+    if health["status"] == "unhealthy":
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py b/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py
new file mode 100644
index 000000000..8410e0f0c
--- /dev/null
+++ b/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py
@@ -0,0 +1,489 @@
+#!/usr/bin/env python3
+"""
+setup_streaming.py - Create complete streaming pipeline
+
+This script creates a complete real-time analytics pipeline in Microsoft Fabric,
+including Eventhouse, KQL Database, Eventstream, KQL Queryset, and optionally an Activator.
+
+Usage:
+    python setup_streaming.py <workspace> --name <pipeline>
+    python setup_streaming.py RealTime.Workspace --name IoTTelemetry
+    python setup_streaming.py RealTime.Workspace --name IoTTelemetry --with-alerts
+
+Exit codes:
+    0 - Streaming pipeline created successfully
+    1 - Error during creation
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Dict, Any, List, Optional
+
+
+def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
+    """Execute a fab CLI command and return exit code, stdout, stderr."""
+    try:
+        result = subprocess.run(
+            ["fab"] + args,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return -1, "", "fab CLI not found in PATH"
+    except subprocess.TimeoutExpired:
+        return -2, "", f"Command timed out after {timeout} seconds"
+    except Exception as e:
+        return -3, "", str(e)
+
+
+def parse_json_output(output: str) -> Any:
+    """Parse JSON output from fab CLI."""
+    try:
+        return json.loads(output.strip())
+    except json.JSONDecodeError:
+        return None
+
+
+def ensure_workspace_suffix(workspace: str) -> str:
+    """Ensure workspace name has .Workspace suffix."""
+    if not workspace.endswith(".Workspace"):
+        return f"{workspace}.Workspace"
+    return workspace
+
+
+def check_workspace_exists(workspace: str) -> bool:
+    """Check if workspace exists."""
+    exit_code, _, _ = run_fab_command(["exists", workspace])
+    return exit_code == 0
+
+
+def check_item_exists(item_path: str) -> bool:
+    """Check if an item exists."""
+    exit_code, _, _ = run_fab_command(["exists", item_path])
+    return exit_code == 0
+
+
+def get_item_id(item_path: str) -> Optional[str]:
+    """Get the ID of an item."""
+    exit_code, stdout, stderr = run_fab_command(["get", item_path, "-q", "id", "-f", "json"])
+    if exit_code == 0:
+        result = parse_json_output(stdout)
+        if result:
+            return result.strip('"') if isinstance(result, str) else result
+    return None
+
+
+def create_eventhouse(workspace: str, name: str) -> Dict[str, Any]:
+    """Create an Eventhouse in the workspace."""
+    item_path = f"{workspace}/{name}.Eventhouse"
+    
+    result = {
+        "name": name,
+        "type": "Eventhouse",
+        "path": item_path,
+        "status": "unknown",
+        "id": None,
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(item_path):
+        result["status"] = "exists"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Eventhouse '{name}' already exists"
+        return result
+    
+    # Create the eventhouse
+    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Eventhouse '{name}' created successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create eventhouse '{name}'"
+    
+    return result
+
+
+def create_kql_database(workspace: str, name: str, eventhouse_id: str) -> Dict[str, Any]:
+    """Create a KQL Database linked to an Eventhouse."""
+    item_path = f"{workspace}/{name}.KQLDatabase"
+    
+    result = {
+        "name": name,
+        "type": "KQLDatabase",
+        "path": item_path,
+        "status": "unknown",
+        "id": None,
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(item_path):
+        result["status"] = "exists"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"KQL Database '{name}' already exists"
+        return result
+    
+    # Create the KQL database with eventhouse linkage
+    exit_code, stdout, stderr = run_fab_command([
+        "create", item_path, "-f",
+        "-P", f"dbtype=ReadWrite",
+        "-P", f"eventhouseId={eventhouse_id}"
+    ])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"KQL Database '{name}' created and linked to Eventhouse"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create KQL Database '{name}'"
+    
+    return result
+
+
+def create_eventstream(workspace: str, name: str) -> Dict[str, Any]:
+    """Create an Eventstream in the workspace."""
+    item_path = f"{workspace}/{name}.Eventstream"
+    
+    result = {
+        "name": name,
+        "type": "Eventstream",
+        "path": item_path,
+        "status": "unknown",
+        "id": None,
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(item_path):
+        result["status"] = "exists"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Eventstream '{name}' already exists"
+        return result
+    
+    # Create the eventstream
+    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Eventstream '{name}' created successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create eventstream '{name}'"
+    
+    return result
+
+
+def create_kql_queryset(workspace: str, name: str) -> Dict[str, Any]:
+    """Create a KQL Queryset in the workspace."""
+    item_path = f"{workspace}/{name}.KQLQueryset"
+    
+    result = {
+        "name": name,
+        "type": "KQLQueryset",
+        "path": item_path,
+        "status": "unknown",
+        "id": None,
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(item_path):
+        result["status"] = "exists"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"KQL Queryset '{name}' already exists"
+        return result
+    
+    # Create the KQL queryset
+    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"KQL Queryset '{name}' created successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create KQL Queryset '{name}'"
+    
+    return result
+
+
+def create_activator(workspace: str, name: str) -> Dict[str, Any]:
+    """Create an Activator (Reflex) in the workspace."""
+    item_path = f"{workspace}/{name}.Reflex"
+    
+    result = {
+        "name": name,
+        "type": "Reflex (Activator)",
+        "path": item_path,
+        "status": "unknown",
+        "id": None,
+        "message": ""
+    }
+    
+    # Check if already exists
+    if check_item_exists(item_path):
+        result["status"] = "exists"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Activator '{name}' already exists"
+        return result
+    
+    # Create the activator (Reflex)
+    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
+    
+    if exit_code == 0:
+        result["status"] = "created"
+        result["id"] = get_item_id(item_path)
+        result["message"] = f"Activator '{name}' created successfully"
+    else:
+        result["status"] = "failed"
+        result["message"] = stderr.strip() or f"Failed to create Activator '{name}'"
+    
+    return result
+
+
+def setup_streaming_pipeline(
+    workspace: str,
+    name: str,
+    with_alerts: bool = False,
+    dry_run: bool = False
+) -> Dict[str, Any]:
+    """Set up complete streaming pipeline."""
+    
+    workspace = ensure_workspace_suffix(workspace)
+    
+    # Define component names
+    eventhouse_name = f"{name}_Eventhouse"
+    database_name = f"{name}_DB"
+    eventstream_name = f"{name}_Stream"
+    queryset_name = f"{name}_Queries"
+    activator_name = f"{name}_Alerts"
+    
+    report = {
+        "workspace": workspace,
+        "pipeline_name": name,
+        "with_alerts": with_alerts,
+        "dry_run": dry_run,
+        "components": [],
+        "summary": {
+            "total_components": 0,
+            "created": 0,
+            "existed": 0,
+            "failed": 0
+        }
+    }
+    
+    # Calculate total components
+    total = 4  # Eventhouse, KQLDatabase, Eventstream, KQLQueryset
+    if with_alerts:
+        total += 1  # Activator
+    report["summary"]["total_components"] = total
+    
+    if dry_run:
+        print(f"\n[DRY RUN] The following components would be created:\n")
+        print(f"Workspace: {workspace}")
+        print(f"Pipeline Name: {name}")
+        print(f"\nComponents:")
+        print(f"  1. {eventhouse_name}.Eventhouse")
+        print(f"  2. {database_name}.KQLDatabase (linked to Eventhouse)")
+        print(f"  3. {eventstream_name}.Eventstream")
+        print(f"  4. {queryset_name}.KQLQueryset")
+        if with_alerts:
+            print(f"  5. {activator_name}.Reflex (Activator)")
+        return report
+    
+    # Check workspace exists
+    print(f"\nSetting up streaming pipeline '{name}' in: {workspace}")
+    if not check_workspace_exists(workspace):
+        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
+        sys.exit(1)
+    
+    # Create components in order
+    print("\n1. Creating Eventhouse...")
+    eventhouse_result = create_eventhouse(workspace, eventhouse_name)
+    report["components"].append(eventhouse_result)
+    
+    if eventhouse_result["status"] == "created":
+        report["summary"]["created"] += 1
+        print(f"   ✓ {eventhouse_result['message']}")
+    elif eventhouse_result["status"] == "exists":
+        report["summary"]["existed"] += 1
+        print(f"   • {eventhouse_result['message']}")
+    else:
+        report["summary"]["failed"] += 1
+        print(f"   ✗ {eventhouse_result['message']}")
+        return report  # Can't continue without eventhouse
+    
+    # Create KQL Database (needs eventhouse ID)
+    print("\n2. Creating KQL Database...")
+    eventhouse_id = eventhouse_result.get("id")
+    if not eventhouse_id:
+        print("   ✗ Cannot create KQL Database: Eventhouse ID not available")
+        report["summary"]["failed"] += 1
+        return report
+    
+    database_result = create_kql_database(workspace, database_name, eventhouse_id)
+    report["components"].append(database_result)
+    
+    if database_result["status"] == "created":
+        report["summary"]["created"] += 1
+        print(f"   ✓ {database_result['message']}")
+    elif database_result["status"] == "exists":
+        report["summary"]["existed"] += 1
+        print(f"   • {database_result['message']}")
+    else:
+        report["summary"]["failed"] += 1
+        print(f"   ✗ {database_result['message']}")
+    
+    # Create Eventstream
+    print("\n3. Creating Eventstream...")
+    eventstream_result = create_eventstream(workspace, eventstream_name)
+    report["components"].append(eventstream_result)
+    
+    if eventstream_result["status"] == "created":
+        report["summary"]["created"] += 1
+        print(f"   ✓ {eventstream_result['message']}")
+    elif eventstream_result["status"] == "exists":
+        report["summary"]["existed"] += 1
+        print(f"   • {eventstream_result['message']}")
+    else:
+        report["summary"]["failed"] += 1
+        print(f"   ✗ {eventstream_result['message']}")
+    
+    # Create KQL Queryset
+    print("\n4. Creating KQL Queryset...")
+    queryset_result = create_kql_queryset(workspace, queryset_name)
+    report["components"].append(queryset_result)
+    
+    if queryset_result["status"] == "created":
+        report["summary"]["created"] += 1
+        print(f"   ✓ {queryset_result['message']}")
+    elif queryset_result["status"] == "exists":
+        report["summary"]["existed"] += 1
+        print(f"   • {queryset_result['message']}")
+    else:
+        report["summary"]["failed"] += 1
+        print(f"   ✗ {queryset_result['message']}")
+    
+    # Create Activator if requested
+    if with_alerts:
+        print("\n5. Creating Activator...")
+        activator_result = create_activator(workspace, activator_name)
+        report["components"].append(activator_result)
+        
+        if activator_result["status"] == "created":
+            report["summary"]["created"] += 1
+            print(f"   ✓ {activator_result['message']}")
+        elif activator_result["status"] == "exists":
+            report["summary"]["existed"] += 1
+            print(f"   • {activator_result['message']}")
+        else:
+            report["summary"]["failed"] += 1
+            print(f"   ✗ {activator_result['message']}")
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create complete streaming pipeline (Eventhouse, KQL Database, Eventstream, etc.)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python setup_streaming.py RealTime.Workspace --name IoTTelemetry
+    python setup_streaming.py RealTime.Workspace --name SensorData --with-alerts
+    python setup_streaming.py "My Workspace" --name Analytics --dry-run
+
+Created Components:
+    1. Eventhouse - Storage for real-time data
+    2. KQL Database - Query engine linked to Eventhouse
+    3. Eventstream - Data ingestion pipeline
+    4. KQL Queryset - Saved queries for analysis
+    5. Activator (optional) - Alert rules and triggers
+
+Next Steps After Creation:
+    1. Configure Eventstream sources (Event Hub, Kafka, etc.)
+    2. Add Eventstream destinations (KQL Database)
+    3. Create tables in KQL Database
+    4. Add queries to KQL Queryset
+    5. Configure alert rules in Activator
+        """
+    )
+    parser.add_argument(
+        "workspace",
+        help="Workspace name or path where streaming pipeline will be created"
+    )
+    parser.add_argument(
+        "--name", "-n",
+        required=True,
+        help="Base name for the streaming pipeline components"
+    )
+    parser.add_argument(
+        "--with-alerts",
+        action="store_true",
+        help="Also create an Activator for alert rules"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview what would be created without making changes"
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        report = setup_streaming_pipeline(
+            workspace=args.workspace,
+            name=args.name,
+            with_alerts=args.with_alerts,
+            dry_run=args.dry_run
+        )
+        
+        if args.dry_run:
+            sys.exit(0)
+        
+        # Print summary
+        print("\n" + "=" * 50)
+        print("STREAMING PIPELINE SETUP COMPLETE")
+        print("=" * 50)
+        print(f"Workspace: {report['workspace']}")
+        print(f"Pipeline Name: {report['pipeline_name']}")
+        print(f"\nSummary:")
+        print(f"  Total Components: {report['summary']['total_components']}")
+        print(f"  Created: {report['summary']['created']}")
+        print(f"  Already Existed: {report['summary']['existed']}")
+        print(f"  Failed: {report['summary']['failed']}")
+        
+        print("\nComponents:")
+        for comp in report["components"]:
+            status_icon = "✓" if comp["status"] in ["created", "exists"] else "✗"
+            print(f"  {status_icon} {comp['path']}")
+        
+        print("=" * 50)
+        
+        if args.json:
+            print("\n" + json.dumps(report, indent=2))
+        
+        sys.exit(0 if report['summary']['failed'] == 0 else 1)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
deleted file mode 100644
index 8d370eddc..000000000
--- a/.github/copilot-instructions.md
+++ /dev/null
@@ -1,326 +0,0 @@
-# Copilot Context — Microsoft Fabric CLI
-
-This file gives AI coding assistants the **ground truth** for this repository: what the CLI is, how it’s designed, the patterns to follow, and the constraints to respect.
-
----
-
-## What this repo is
-
-**Fabric CLI** (`fab`) is a Python-based command-line client for **Microsoft Fabric** that works in both **interactive** (equivalent to REPL environment) and **non‑interactive** (regular command line) modes. Users install it with `pip install ms-fabric-cli`, then authenticate via interactive browser, service principal (secret/cert/**federated credential**), or managed identity, and run commands to list, navigate, and operate Fabric resources. [1](https://learn.microsoft.com/en-us/fabric/admin/fabric-command-line-interface)
-**Key design principle:** The CLI models Fabric as a **filesystem-like hierarchy** with a consistent **dot (.) entity suffix** (e.g., `.Workspace`, `.Folder`, `.SemanticModel`), supports nested folders (up to ~10 levels), and produces intuitive paths like:
-
-- `/Workspace1.Workspace/Notebook1.Notebook`  
-- `/Workspace1.Workspace/FolderA.Folder/SemanticModel1.SemanticModel`
----
-
-## High-level architecture & code layout
-
-- **Language & framework:** Python 3.10-3.13 with `argparse` for command parsing. When adding commands, define prompts under the appropriate parser module and follow the parser conventions.
-- **Representative paths in the codebase:**  
-  - Commands: `src/fabric_cli/commands/...`  
-  - Core utils/UI: `src/fabric_cli/utils/...`  
-  - Entry points / main: `src/fabric_cli/main.py`  
-  - Tests: `tests/...`  
-  (For example changes in `fab_api_request.py` and `fab_ui.py`, and tests in `tests/test_utils/test_fab_ui.py` have appeared in recent PRs.)
-- **Hierarchy structure**:
-    - **Tenant**: The top-level container for everything.
-    - **Workspace**: The personal or team's workspace, holding folders, items, and workspace level elements. (e.g., `fab get /Workspace1.Workspace/`)
-    - **Folder**: The container for organizing items within a workspace. (e.g., `fab get /Workspace1.Workspace/FolderA.Folder/`)
-    - **Item**: The individual resource within a workspace or a folder. (e.g., `fab get /Workspace1.Workspace/FolderA.Folder/Item1.<ItemType>`)
-    - **OneLakeItem**: A OneLake storage item, resides within a Lakehouse item. Could be a table, file, etc. (e.g., `fab get /Workspace1.Workspace/FolderA.Folder/lh1.Lakehouse/Tables`)
-    - **Hidden entities**: Special resources not normally visible to users. (e.g., `.capacities`, `.sparkpools`, etc. See hidden entities section below)
-
----
-
-## Authentication
-
-Copilot should prefer these patterns and avoid inventing new ones:
-
-1) **Interactive user** — `fab auth login` (Web Account Manager on supported platforms or browser flow).  
-2) **Service principal (secret/cert)** — env vars and secure storage.  
-3) **Service principal (federated credential)** — use the **MSAL Python** confidential client with the federated token (`FAB_SPN_FEDERATED_TOKEN`); do **not** persist the raw token. 
-4) Never log or print sensitive information (tokens, passwords, secrets)
-5) Use secure token storage mechanisms provided by `FabAuth` class
-6) Validate all user inputs that could affect security (paths, GUIDs, etc.)
-7) Ensure proper scope handling for different authentication types
-
----
-
-## Modes
-
-The Fabric CLI supports two primary modes to accommodate a variety of workflows: command line and interactive. The selected mode is preserved between sessions. If you exit and login to the CLI later, it will resume in the same mode you last used.
-
-- **Interactive mode**: Provides a REPL-like environment in which you can run Fabric CLI commands directly without the `fab` prefix.
-- **Command line mode**: Executes commands in a single process. Best suited for scripted tasks, automation, or when you prefer running single commands without a prompt.
-
----
-
-## Error handling
-
-- Raise **`FabricCLIError`** with stable **error codes** and user‑friendly messages.  
-- New messages go under `/errors/<module>.py`; new codes belong in `constants.py` under the error codes region; first try to **reuse** existing messages/codes.  
-- Command wrappers render error *message + code* consistently.
-
----
-
-## File storage
-
-The Fabric CLI maintains several files in the user's home directory under .config/fab/:
-
-- **cache.bin**	stores sensitive authentication data and is encrypted by default on supported platforms (Windows, MacOS, and Linux)
-- **config.json** contains non-sensitive CLI configuration settings and preferences.
-- **auth.json**	maintains CLI authentication non-sensitive information
-- **context-<session_id>**: stores the CLI path context for each session; used exclusively in command_line mode.
-
-Additionally, Fabric CLI writes debug logs to a file named fabcli_debug.log, stored in the following locations by platform:
-
-- Windows: %AppData%
-- macOS: ~/Library/Logs
-- Linux: ~/.local/state
-
----
-
-## Caching
-
-- **Token Caching** managed via Microsoft Authentication Library (MSAL) extensions. By default, tokens are securely encrypted and stored in the user's home directory under .config/fab/cache.bin.
-- **HTTP Response Caching** in interactive mode, certain endpoints are cached by default to diminish network traffic and improve overall responsiveness.
-
----
-
-## Hidden entities
-
-- In Fabric CLI, a hidden entity refers to any entity that is not a primary focus of the CLI. The primary focus of the CLI includes Workspaces, Items, or Folders. The rest of the entities considered as hidden entities and follow a UNIX-style convention similar to hidden files and directories, meaning they are not shown by default, require explicit navigation or path specification to access (e.g., using cd or ls with the full path).
-- Hidden entities include tenant-level entities (such as connections, capacities, gateways, and domains) and workspace-level entities (such as managed identities, managed private endpoints, external data shares, and spark pools). They are identified by a dot-prefixed naming convention. To view hidden resources, users must use the `ls -a` or `ls --all` command, which displays all resources, including these hidden, dot-prefixed collections.
-
-```sh
-# List all capacities
-fab ls .capacities
-
-# Get a capacity
-fab get .capacities/<capacity-name>.Capacity
-
-# List all gateways
-fab ls .gateways
-
-# Get a gateway
-fab get .gateways/<gateway-name>.Gateway
-
-# List all connections
-fab ls .connections
-
-# Get a connection
-fab get .connections/<connection-name>.Connection
-
-# List all domains
-fab ls .domains
-
-# Get a domain
-fab get .domains/<domain-name>.Domain
-
-# List all managed identities
-fab ls ws1.Workspace/.managedidentities
-
-# Get a managed identity
-fab get ws1.Workspace/.managedidentities/<managed-identity-name>.ManagedIdentity
-
-# List all managed private endpoints
-fab ls ws1.Workspace/.managedprivateendpoints
-
-# Get a managed private endpoint
-fab get ws1.Workspace/.managedprivateendpoints/<managed-private-endpoint-name>.ManagedPrivateEndpoint
-
-# List all external data shares
-fab ls ws1.Workspace/.externaldatashares
-
-# Get external data share
-fab get ws1.Workspace/.externaldatashares/<external-data-share-name>.ExternalDataShare
-
-# List all spark pools
-fab ls ws1.Workspace/.sparkpools
-
-# Get spark pool
-fab get ws1.Workspace/.sparkpools/<spark-pool-name>.SparkPool
-
-```
-
----
-
-## Limitations
-
-- Python supported version are 3.10, 3.11, 3.12 and 3.13 (>3.13 not supported per releases).
-- Supported platforms are: Windows, Linux and MacOS.
-- Supported shells are: zsh, bash, PowerShell and cmd (command prompt in Windows).
-
----
-
-## Prompting patterns for Copilot Chat (examples)
-
-- “Create a new `fab` subcommand to **list semantic models** under a workspace path. Parse `--workspace-path`, validate the dot‑suffix, call the existing list APIs, and print via `print_output_format`. Add unit tests for parsing and happy/sad paths.” 
-- “Refactor error handling in `X` to raise `FabricCLIError` with a **reused code** where possible; add a new message in `errors/<module>.py` only if needed. Update tests.” 
-- “Add **service principal federated credential** login support in the auth parser; accept a `--federated-token` arg or `FAB_SPN_FEDERATED_TOKEN`. Use MSAL confidential client and do not persist raw tokens.”
-
----
-
-## Pull Request Review and Coding Guidelines
-
-When reviewing Pull Requests for fabric-cli, or developing new features, or fixing bugs, focus on these critical areas to ensure code quality, security, and maintainability.
-
-### Code Style and Standards
-
-**Required Standards**:
-
-- **Type Hints**: All functions must include proper type annotations using `typing` module
-  ```python
-  from typing import Any, Optional, List, Dict
-  def process_item(item: Dict[str, Any], timeout: Optional[int] = None) -> List[str]:
-  ```
-- **Import Organization**: Group imports in standard order (stdlib, third-party, local)
-- **Naming Conventions**: Use `snake_case` for functions/variables, `PascalCase` for classes
-- **Copyright Headers**: All new files must include Microsoft copyright header
-- **Code Formatting**: Must pass `black src/ tests/` formatting check
-- **Documentation**: Public functions require docstrings with parameter and return type descriptions
-
-**Check for**:
-
-- Consistent indentation and formatting (use `black --check` to validate)
-- Proper error handling with appropriate exception types
-- Clear variable and function names that express intent
-- No unused imports or variables (use `mypy` to catch these)
-- No hardcoded strings or magic numbers; use constants from `fab_constant`
-- No circular imports
-
-### Error Handling and Error Codes
-
-**Error Class Usage** - All errors must use structured error classes:
-- **`FabricCLIError`**: Base exception with message and optional status_code
-- **`FabricAPIError`**: For Fabric REST API errors with errorCode, message, moreDetails
-- **`OnelakeAPIError`**: For Data Lake Storage API errors  
-- **`AzureAPIError`**: For Azure REST API errors
-
-**Error Message Standards**:
-
-- Use error message classes from `src/fabric_cli/errors/` directory:
-  ```python
-  from fabric_cli.errors.common import CommonErrors
-  from fabric_cli.errors.auth import AuthErrors
-
-  # Good
-  raise FabricCLIError(
-      CommonErrors.invalid_path(path),
-      fab_constant.ERROR_INVALID_INPUT
-  )
-
-  # Bad - hardcoded message
-  raise FabricCLIError("Invalid path provided")
-  ```
-- Include specific error codes from `fab_constant` (e.g., `ERROR_INVALID_INPUT`, `ERROR_SPN_AUTH_MISSING`)
-- Provide actionable error messages that guide users toward solutions
-- Include request IDs for API errors to aid debugging
-
-**Error Handling Patterns**:
-
-- Catch specific exceptions rather than broad `except Exception`
-- Use proper error propagation - don't swallow exceptions silently
-- Include context information in error messages (file paths, resource names, etc.)
-- Validate inputs early and provide clear validation error messages
-
-### Security Aspects
-
-**Authentication and Authorization**:
-
-- Never log or print sensitive information (tokens, passwords, secrets)
-- Use secure token storage mechanisms provided by `FabAuth` class
-- Validate all user inputs that could affect security (paths, GUIDs, etc.)
-- Ensure proper scope handling for different authentication types
-- Implement proper session cleanup (`Context().cleanup_context_files()`)
-
-**Input Validation**:
-
-- Sanitize all user inputs, especially file paths and API parameters
-- Use GUID validation for resource identifiers: `CommonErrors.invalid_guid(parameter_name)`
-- Validate JSON inputs: `CommonErrors.invalid_json_format()`
-- Check file permissions before operations: `CommonErrors.file_not_accessible(file_path)`
-
-**Data Protection**:
-
-- Never commit secrets, tokens, or credentials to code
-- Use environment variables for sensitive configuration
-- Ensure temporary files are properly cleaned up
-- Validate certificate paths and formats for SPN authentication
-
-### Performance Considerations
-
-**Resource Management**:
-
-- Clear caches appropriately using `utils_mem_store.clear_caches()`
-- Implement proper cleanup in finally blocks or context managers
-- Avoid memory leaks in long-running operations
-- Use pagination for large data sets
-
-**API Efficiency**:
-
-- Minimize API calls by batching operations where possible
-- Use VCR.py recordings for tests (`--playback` flag) to avoid live API calls
-- Implement proper retry logic with exponential backoff
-- Set appropriate timeouts for network operations
-
-**File Operations**:
-
-- Stream large files rather than loading entirely into memory
-- Use appropriate buffer sizes for I/O operations
-- Check file sizes before processing to prevent resource exhaustion
-- Implement progress indicators for long-running operations
-
-### Code Correctness
-
-**Testing Requirements**:
-
-- All new functionality must include corresponding tests
-- Use existing test patterns in `tests/test_commands/` with VCR.py recordings
-- Verify error paths are tested, not just happy paths
-- Run full test suite: `python3 -m pytest tests/test_commands --playback`
-
-**Logic Validation**:
-
-- Check for proper null/None handling throughout the code
-- Validate edge cases (empty inputs, maximum values, etc.)
-- Ensure proper handling of optional parameters
-- Verify correct return types match function signatures
-
-**Integration Points**:
-
-- Ensure commands work correctly with different authentication modes
-- Test output formatters work with all supported formats (JSON, table, etc.)
-- Validate CLI argument parsing and help text accuracy
-- Check context switching and workspace operations
-
-### Review Checklist
-
-Before approving any PR, verify:
-
-1. **Pre-commit Validation Passed**:
-   - [ ] `black src/ tests/` (formatting)
-   - [ ] `mypy src/ tests/ --ignore-missing-imports` (type checking)
-   - [ ] `python3 -m pytest tests/test_core tests/test_utils` (unit tests)
-   - [ ] `python3 -m pytest tests/test_commands --playback` (integration tests)
-
-2. **Code Quality**:
-   - [ ] Proper error handling with structured error classes
-   - [ ] Type hints on all new functions and methods
-   - [ ] No security vulnerabilities or credential exposure
-   - [ ] Performance considerations addressed
-   - [ ] Test coverage for new functionality
-
-3. **Documentation**:
-   - [ ] Function docstrings for public APIs
-   - [ ] Updated help text for new commands or options
-   - [ ] README updates if new functionality affects user workflows
-
-**Rejection Criteria** - Reject PRs that:
-
-- Bypass structured error handling patterns
-- Include hardcoded credentials or secrets
-- Lack proper type annotations
-- Don't include tests for new functionality
-- Fail any of the pre-commit validation steps
-- Introduce performance regressions without justification
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 000000000..0995528c2
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,177 @@
+# AGENTS.md — AI Agent Guide for Microsoft Fabric CLI
+
+This document provides guidance for AI agents assisting with the [Microsoft Fabric CLI](https://github.com/microsoft/fabric-cli) (`fab`) — a Python-based command-line interface for Microsoft Fabric.
+
+---
+
+## About Microsoft Fabric CLI
+
+The Fabric CLI is a file-system-inspired command-line interface that lets users explore, automate, and script their Microsoft Fabric environment. Key characteristics:
+
+- **Installation**: `pip install ms-fabric-cli`
+- **Python versions**: 3.10, 3.11, 3.12, 3.13
+- **Platforms**: Windows, macOS, Linux
+- **Shells**: PowerShell, Bash, Zsh, cmd
+- **Modes**: Interactive (REPL) and command-line (scripting)
+
+**Repository**: https://github.com/microsoft/fabric-cli
+
+---
+
+## AI Assets
+
+All AI-related resources (skills, context, prompts, modes) are organized in the `.ai-assets/` folder. See [`.ai-assets/README.md`](.ai-assets/README.md) for a complete catalog of available resources.
+
+### Key Resources
+
+| Resource | Location |
+|----------|----------|
+| AI Assets Overview | `.ai-assets/README.md` |
+| Skills (Usage) | `.ai-assets/skills/` |
+| Prompts (Templates) | `.ai-assets/prompts/` |
+| Modes (Agents) | `.ai-assets/modes/` |
+| Context (Contributor) | `.ai-assets/context/` |
+
+### External Documentation
+
+| Resource | URL |
+|----------|-----|
+| Documentation | https://microsoft.github.io/fabric-cli/ |
+| Command Reference | https://microsoft.github.io/fabric-cli/commands/ |
+| Usage Examples | https://microsoft.github.io/fabric-cli/examples/ |
+
+---
+
+## For AI Agents Helping Users (Operating Fabric CLI)
+
+When assisting users who want to **use the CLI** (not develop it), load skills from `.ai-assets/skills/`:
+
+### Available Skills
+
+| Skill | When to Load |
+|-------|--------------|
+| `fabric-cli-core` | **Always load first** — paths, auth, safety, item types |
+| `fabric-cli-cicd` | Deploying, CI/CD pipelines, automation |
+| `fabric-cli-powerbi` | Semantic models, reports, DAX, refresh |
+| `fabric-cli-governance` | Permissions, ACLs, domains, capacity |
+| `fabric-cli-dataengineering` | Lakehouses, tables, shortcuts, Spark |
+| `fabric-cli-realtime` | Eventhouses, KQL, eventstreams |
+
+### Quick Start Commands
+
+```bash
+# Check authentication
+fab auth status
+
+# List workspaces
+fab ls
+
+# List items in workspace
+fab ls "MyWorkspace.Workspace"
+
+# Get help for any command
+fab --help
+fab ls --help
+```
+
+### Critical Operational Rules
+
+1. **First run** — Always verify auth with `fab auth status`
+2. **Learn before executing** — Use `fab <command> --help` to understand syntax
+3. **Verify before acting** — Use `fab exists` or `fab ls` to confirm paths
+4. **Non-interactive mode** — Use `-f` flag for automation
+5. **Safety first** — Confirm before destructive operations
+
+---
+
+## For AI Agents Helping Contributors (Developing the CLI)
+
+When assisting with **code contributions** to this repository (adding features, fixing bugs, writing tests), refer to the contributor context in `.ai-assets/context/`.
+
+### Forking and Setting Up
+
+Guide users through the contribution workflow:
+
+1. **Fork the repository**: https://github.com/microsoft/fabric-cli/fork
+2. **Clone locally**:
+   ```bash
+   git clone https://github.com/<username>/fabric-cli.git
+   cd fabric-cli
+   ```
+3. **Set up development environment** (dev container recommended)
+4. **Create a feature branch**:
+   ```bash
+   git checkout -b feature/my-change
+   ```
+
+### Contribution Process
+
+All PRs must follow this process:
+
+1. **Find or create an issue** — Search [GitHub Issues](https://github.com/microsoft/fabric-cli/issues) first
+2. **Look for `help-wanted` label** — Required before starting work
+3. **Comment on the issue** — Describe your planned approach and wait for acknowledgment
+4. **Link PR to issue** — Start PR description with `- Resolves #issue-number`
+5. **Add changie entry** — Run `changie new` and select the appropriate change type
+
+### Code Standards to Enforce
+
+When reviewing or generating code, ensure:
+
+| Requirement | Details |
+|-------------|---------|
+| **Type hints** | All functions must have proper type annotations |
+| **Formatting** | Must pass `black src/ tests/` |
+| **Type checking** | Must pass `mypy src/ tests/ --ignore-missing-imports` |
+| **Naming** | `snake_case` for functions/variables, `PascalCase` for classes |
+| **Imports** | Grouped: stdlib → third-party → local |
+| **Copyright** | All new files need Microsoft copyright header |
+| **Docstrings** | Required for public functions |
+
+### Error Handling Pattern
+
+Always use structured error classes:
+
+```python
+from fabric_cli.errors.common import CommonErrors
+from fabric_cli import fab_constant
+
+# Good
+raise FabricCLIError(
+    CommonErrors.invalid_path(path),
+    fab_constant.ERROR_INVALID_INPUT
+)
+
+# Bad — hardcoded message
+raise FabricCLIError("Invalid path provided")
+```
+
+### Testing Requirements
+
+All new functionality must include tests:
+
+```bash
+# Unit tests
+python3 -m pytest tests/test_core tests/test_utils
+
+# Integration tests (with VCR playback)
+python3 -m pytest tests/test_commands --playback
+```
+
+### Restricted Areas
+
+Warn contributors that these areas require team involvement:
+
+- **Authentication module** — Security implications require Fabric CLI team review
+- **Core infrastructure** — Major architectural changes need team discussion
+
+---
+
+## Quick Reference Links
+
+- **Repository**: https://github.com/microsoft/fabric-cli
+- **Issues**: https://github.com/microsoft/fabric-cli/issues
+- **Discussions**: https://github.com/microsoft/fabric-cli/discussions
+- **Wiki (Engineering Guidelines)**: https://github.com/microsoft/fabric-cli/wiki
+- **Contributing Guide**: https://github.com/microsoft/fabric-cli/blob/main/CONTRIBUTING.md
+- **Documentation**: https://microsoft.github.io/fabric-cli/
diff --git a/docs/agent-docs/SKILL.md b/docs/agent-docs/SKILL.md
deleted file mode 100644
index 4b01362cc..000000000
--- a/docs/agent-docs/SKILL.md
+++ /dev/null
@@ -1,437 +0,0 @@
----
-name: fabric-cli
-description: Use Microsoft Fabric CLI (fab) to manage workspaces, semantic models, reports, notebooks, lakehouses, and other Fabric resources via file-system metaphor and commands. Use when deploying Fabric items, running jobs, querying data, managing OneLake files, or automating Fabric operations. Invoke this skill automatically whenever a user mentions the Fabric CLI, fab, or Fabric.
----
-
-# Microsoft Fabric CLI Operations
-
-> **Note:** If you have access to a Bash tool (e.g., Claude Code), execute `fab` commands directly via Bash rather than using an MCP server.
-
-Expert guidance for using the `fab` CLI to programmatically manage Fabric
-
-## When to Use This Skill
-
-Activate automatically when tasks involve:
-
-- Mention of the Fabric CLI, Fabric items, Power BI, `fab`, or `fab` commands
-- Managing workspaces, items, or resources
-- Deploying or migrating semantic models, reports, notebooks, pipelines
-- Running or scheduling jobs (notebooks, pipelines, Spark)
-- Working with lakehouse/warehouse tables and data
-- Using the Fabric, Power BI, or OneLake APIs
-- Automating Fabric operations in scripts
-
-## Critical
-
-- If workspace or item name is unclear, ask the user first, then verify with `fab ls` or `fab exists` before proceeding
-- The first time you use `fab` run `fab auth status` to make sure the user is authenticated. If not, ask the user to run `fab auth login` to login
-- Always use `fab --help` and `fab <command> --help` the first time you use a command to understand its syntax, first
-- Always try the simple `fab` command alone, first before piping it
-- Always use `-f` when executing command if the flag is available to do so non-interactively
-- Ensure that you avoid removing or moving items, workspaces, or definitions, or changing properties without explicit user direction
-- If a command is blocked in your permissions and you try to use it, stop and ask the user for clarification; never try to circumvent it
-- Use `fab` in non-interactive mode. Interactive mode doesn't work with coding agents
-
-## First Run
-
-```bash
-fab auth login          # Authenticate (opens browser)
-fab auth status         # Verify authentication
-fab ls                  # List your workspaces
-fab ls "Name.Workspace" # List items in a workspace
-```
-
-## Variable Extraction Pattern
-
-Most workflows need IDs. Extract them like this:
-
-```bash
-WS_ID=$(fab get "ws.Workspace" -q "id" | tr -d '"')
-MODEL_ID=$(fab get "ws.Workspace/Model.SemanticModel" -q "id" | tr -d '"')
-
-# Then use in API calls
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
-```
-
-## Quick Start
-
-**New to Fabric CLI?** Here are some references you can read:
-
-- [Quick Start Guide](./references/quickstart.md) - Copy-paste examples
-- [Querying Data](./references/querying-data.md) - Query semantic models and lakehouse tables
-- [Semantic Models](./references/semantic-models.md) - TMDL, DAX, refresh, storage mode
-- [Reports](./references/reports.md) - Export, import, visuals, fields
-- [Notebooks](./references/notebooks.md) - Job execution, parameters
-- [Workspaces](./references/workspaces.md) - Create, manage, permissions
-- [Full Command Reference](./references/reference.md) - All commands detailed
-- [Command Reference Table](#command-reference) - At-a-glance command syntax
-
-### Command Reference
-
-| Command | Purpose | Example |
-|---------|---------|---------|
-| **Finding Items** |||
-| `fab ls` | List items | `fab ls "Sales.Workspace"` |
-| `fab ls -l` | List with details | `fab ls "Sales.Workspace" -l` |
-| `fab exists` | Check if exists | `fab exists "Sales.Workspace/Model.SemanticModel"` |
-| `fab get` | Get item details | `fab get "Sales.Workspace/Model.SemanticModel"` |
-| `fab get -q` | Query specific field | `fab get "Sales.Workspace" -q "id"` |
-| **Definitions** |||
-| `fab get -q "definition"` | Get full definition | `fab get "ws.Workspace/Model.SemanticModel" -q "definition"` |
-| `fab export` | Export to local | `fab export "ws.Workspace/Nb.Notebook" -o ./backup` |
-| `fab import` | Import from local | `fab import "ws.Workspace/Nb.Notebook" -i ./backup/Nb.Notebook` |
-| **Running Jobs** |||
-| `fab job run` | Run synchronously | `fab job run "ws.Workspace/ETL.Notebook"` |
-| `fab job start` | Run asynchronously | `fab job start "ws.Workspace/ETL.Notebook"` |
-| `fab job run -P` | Run with params | `fab job run "ws.Workspace/Nb.Notebook" -P date:string=2025-01-01` |
-| `fab job run-list` | List executions | `fab job run-list "ws.Workspace/Nb.Notebook"` |
-| `fab job run-status` | Check status | `fab job run-status "ws.Workspace/Nb.Notebook" --id <job-id>` |
-| **Refreshing Models** |||
-| `fab api -A powerbi` | Trigger refresh | `fab api -A powerbi "groups/<ws-id>/datasets/<model-id>/refreshes" -X post -i '{"type":"Full"}'` |
-| `fab api -A powerbi` | Check refresh status | `fab api -A powerbi "groups/<ws-id>/datasets/<model-id>/refreshes?\$top=1"` |
-| **DAX Queries** |||
-| `fab get -q "definition"` | Get model schema first | `fab get "ws.Workspace/Model.SemanticModel" -q "definition"` |
-| `fab api -A powerbi` | Execute DAX | `fab api -A powerbi "groups/<ws-id>/datasets/<model-id>/executeQueries" -X post -i '{"queries":[{"query":"EVALUATE..."}]}'` |
-| **Lakehouse** |||
-| `fab ls` | Browse files/tables | `fab ls "ws.Workspace/LH.Lakehouse/Files"` |
-| `fab table schema` | Get table schema | `fab table schema "ws.Workspace/LH.Lakehouse/Tables/sales"` |
-| `fab cp` | Upload/download | `fab cp ./local.csv "ws.Workspace/LH.Lakehouse/Files/"` |
-| **Management** |||
-| `fab cp` | Copy items | `fab cp "dev.Workspace/Item.Type" "prod.Workspace" -f` |
-| `fab set` | Update properties | `fab set "ws.Workspace/Item.Type" -q displayName -i "New Name"` |
-| `fab rm` | Delete item | `fab rm "ws.Workspace/Item.Type" -f` |
-
-## Core Concepts
-
-### Path Format
-
-Fabric uses filesystem-like paths with type extensions:
-
-`/WorkspaceName.Workspace/ItemName.ItemType`
-
-For lakehouses this is extended into files and tables:
-
-`/WorkspaceName.Workspace/LakehouseName.Lakehouse/Files/FileName.extension` or `/WorkspaceName.Workspace/LakehouseName.Lakehouse/Tables/TableName`
-
-For Fabric capacities you have to use `fab ls .capacities`
-
-Examples:
-
-- `"/Production.Workspace/Sales Model.SemanticModel"`
-- `/Data.Workspace/MainLH.Lakehouse/Files/data.csv`
-- `/Data.Workspace/MainLH.Lakehouse/Tables/dbo/customers`
-
-### Common Item Types
-
-- `.Workspace` - Workspaces
-- `.SemanticModel` - Power BI datasets
-- `.Report` - Power BI reports
-- `.Notebook` - Fabric notebooks
-- `.DataPipeline` - Data pipelines
-- `.Lakehouse` / `.Warehouse` - Data stores
-- `.SparkJobDefinition` - Spark jobs
-
-Full list: 35+ types. Use `fab desc .<ItemType>` to explore.
-
-## Essential Commands
-
-### Navigation & Discovery
-
-```bash
-# List resources
-fab ls                                    # List workspaces
-fab ls "Production.Workspace"             # List items in workspace
-fab ls "Production.Workspace" -l          # Detailed listing
-fab ls "Data.Workspace/LH.Lakehouse"      # List lakehouse contents
-
-# Check existence
-fab exists "Production.Workspace/Sales.SemanticModel"
-
-# Get details
-fab get "Production.Workspace/Sales.Report"
-fab get "Production.Workspace" -q "id"    # Query with JMESPath
-```
-
-### Creating & Managing Resources
-
-```bash
-# Create workspace after using `fab ls .capacities` to check capacities
-fab mkdir "NewWorkspace.Workspace" -P capacityname=MyCapacity
-
-# Create items
-fab mkdir "Production.Workspace/NewLakehouse.Lakehouse"
-fab mkdir "Production.Workspace/Pipeline.DataPipeline"
-
-# Update properties
-fab set "Production.Workspace/Item.Notebook" -q displayName -i "New Name"
-fab set "Production.Workspace" -q description -i "Production environment"
-```
-
-### Copy, Move, Export, Import
-
-```bash
-# Copy between workspaces
-fab cp "Dev.Workspace/Pipeline.DataPipeline" "Production.Workspace"
-fab cp "Dev.Workspace/Report.Report" "Production.Workspace/ProdReport.Report"
-
-# Export to local
-fab export "Production.Workspace/Model.SemanticModel" -o /tmp/exports
-fab export "Production.Workspace" -o /tmp/backup -a  # Export all items
-
-# Import from local
-fab import "Production.Workspace/Pipeline.DataPipeline" -i /tmp/exports/Pipeline.DataPipeline -f
-
-# IMPORTANT: Use -f flag for non-interactive execution
-# Without -f, import/export operations expect an interactive terminal for confirmation
-# This will fail in scripts, automation, or when stdin is not a terminal
-fab import "ws.Workspace/Item.Type" -i ./Item.Type -f  # Required for scripts
-```
-
-### API Operations
-
-Direct REST API access with automatic authentication.
-
-**Audiences:**
-
-- `fabric` (default) - Fabric REST API
-- `powerbi` - Power BI REST API
-- `storage` - OneLake Storage API
-- `azure` - Azure Resource Manager
-
-```bash
-# Fabric API (default)
-fab api workspaces
-fab api workspaces -q "value[?type=='Workspace']"
-fab api "workspaces/<workspace-id>/items"
-
-# Power BI API (for DAX queries, dataset operations)
-fab api -A powerbi groups
-fab api -A powerbi "datasets/<model-id>/executeQueries" -X post -i '{"queries": [{"query": "EVALUATE VALUES(Date[Year])"}]}'
-
-# POST/PUT/DELETE
-fab api -X post "workspaces/<ws-id>/items" -i '{"displayName": "New Item", "type": "Lakehouse"}'
-fab api -X put "workspaces/<ws-id>/items/<item-id>" -i /tmp/config.json
-fab api -X delete "workspaces/<ws-id>/items/<item-id>"
-
-# OneLake Storage API
-fab api -A storage "WorkspaceName.Workspace/LH.Lakehouse/Files" -P resource=filesystem,recursive=false
-```
-
-### Job Management
-
-```bash
-# Run synchronously (wait for completion)
-fab job run "Production.Workspace/ETL.Notebook"
-fab job run "Production.Workspace/Pipeline.DataPipeline" --timeout 300
-
-# Run with parameters
-fab job run "Production.Workspace/ETL.Notebook" -P date:string=2024-01-01,batch:int=1000,debug:bool=false
-
-# Start asynchronously
-fab job start "Production.Workspace/LongProcess.Notebook"
-
-# Monitor
-fab job run-list "Production.Workspace/ETL.Notebook"
-fab job run-status "Production.Workspace/ETL.Notebook" --id <job-id>
-
-# Schedule
-fab job run-sch "Production.Workspace/Pipeline.DataPipeline" --type daily --interval 10:00,16:00 --start 2024-11-15T09:00:00 --enable
-fab job run-sch "Production.Workspace/Pipeline.DataPipeline" --type weekly --interval 10:00 --days Monday,Friday --enable
-
-# Cancel
-fab job run-cancel "Production.Workspace/ETL.Notebook" --id <job-id>
-```
-
-### Table Operations
-
-```bash
-# View schema
-fab table schema "Data.Workspace/LH.Lakehouse/Tables/dbo/customers"
-
-# Load data (non-schema lakehouses only)
-fab table load "Data.Workspace/LH.Lakehouse/Tables/sales" --file "Data.Workspace/LH.Lakehouse/Files/daily_sales.csv" --mode append
-
-# Optimize (lakehouses only)
-fab table optimize "Data.Workspace/LH.Lakehouse/Tables/transactions" --vorder --zorder customer_id,region
-
-# Vacuum (lakehouses only)
-fab table vacuum "Data.Workspace/LH.Lakehouse/Tables/temp_data" --retain_n_hours 48
-```
-
-## Common Workflows
-
-### Semantic Model Management
-
-```bash
-# Find models
-fab ls "ws.Workspace" | grep ".SemanticModel"
-
-# Get definition
-fab get "ws.Workspace/Model.SemanticModel" -q definition
-
-# Trigger refresh
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
-
-# Check refresh status
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1"
-```
-
-**Execute DAX:**
-
-```bash
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/executeQueries" -X post \
-  -i '{"queries":[{"query":"EVALUATE TOPN(5, '\''TableName'\'')"}]}'
-```
-
-**DAX rules:** EVALUATE required, single quotes around tables (`'Sales'`), qualify columns (`'Sales'[Amount]`).
-
-For full details: [semantic-models.md](./references/semantic-models.md) | [querying-data.md](./references/querying-data.md)
-
-### Report Operations
-
-```bash
-# Get report definition
-fab get "ws.Workspace/Report.Report" -q definition
-
-# Export to local
-fab export "ws.Workspace/Report.Report" -o /tmp/exports -f
-
-# Import from local
-fab import "ws.Workspace/Report.Report" -i /tmp/exports/Report.Report -f
-
-# Rebind to different model
-fab set "ws.Workspace/Report.Report" -q semanticModelId -i "<new-model-id>"
-```
-
-For full details: [reports.md](./references/reports.md)
-
-### Lakehouse/Warehouse Operations
-
-```bash
-# Browse contents
-fab ls "Data.Workspace/LH.Lakehouse/Files"
-fab ls "Data.Workspace/LH.Lakehouse/Tables/dbo"
-
-# Upload/download files
-fab cp ./local-data.csv "Data.Workspace/LH.Lakehouse/Files/data.csv"
-fab cp "Data.Workspace/LH.Lakehouse/Files/data.csv" ~/Downloads/
-
-# Load and optimize tables
-fab table load "Data.Workspace/LH.Lakehouse/Tables/sales" --file "Data.Workspace/LH.Lakehouse/Files/sales.csv"
-fab table optimize "Data.Workspace/LH.Lakehouse/Tables/sales" --vorder --zorder customer_id
-```
-
-### Environment Migration
-
-```bash
-# Export from dev
-fab export "Dev.Workspace" -o /tmp/migration -a
-
-# Import to production (item by item)
-fab import "Production.Workspace/Pipeline.DataPipeline" -i /tmp/migration/Pipeline.DataPipeline
-fab import "Production.Workspace/Report.Report" -i /tmp/migration/Report.Report
-```
-
-## Key Patterns
-
-### JMESPath Queries
-
-Filter and transform JSON responses with `-q`:
-
-```bash
-# Get single field
--q "id"
--q "displayName"
-
-# Get nested field
--q "properties.sqlEndpointProperties"
--q "definition.parts[0]"
-
-# Filter arrays
--q "value[?type=='Lakehouse']"
--q "value[?contains(name, 'prod')]"
-
-# Get first element
--q "value[0]"
--q "definition.parts[?path=='model.tmdl'] | [0]"
-```
-
-### Error Handling & Debugging
-
-```bash
-# Show response headers
-fab api workspaces --show_headers
-
-# Verbose output
-fab get "Production.Workspace/Item" -v
-
-# Save responses for debugging
-fab api workspaces -o /tmp/workspaces.json
-```
-
-### Performance Optimization
-
-1. **Use `ls` for fast listing** - Much faster than `get`
-2. **Use `exists` before operations** - Check before get/modify
-3. **Filter with `-q`** - Get only what you need
-4. **Use GUIDs in automation** - More stable than names
-
-## Common Flags
-
-- `-f, --force` - Skip confirmation prompts
-- `-v, --verbose` - Verbose output
-- `-l` - Long format listing
-- `-a` - Show hidden items
-- `-o, --output` - Output file path
-- `-i, --input` - Input file or JSON string
-- `-q, --query` - JMESPath query
-- `-P, --params` - Parameters (key=value)
-- `-X, --method` - HTTP method (get/post/put/delete/patch)
-- `-A, --audience` - API audience (fabric/powerbi/storage/azure)
-- `--show_headers` - Show response headers
-- `--timeout` - Timeout in seconds
-
-## Important Notes
-
-- **All examples assume `fab` is installed and authenticated**
-- **Paths require proper extensions** (`.Workspace`, `.SemanticModel`, etc.)
-- **Quote paths with spaces**: `"My Workspace.Workspace"`
-- **Use `-f` for non-interactive scripts** (skips prompts)
-- **Semantic model updates**: Use Power BI API (`-A powerbi`) for DAX queries and dataset operations
-
-## Need More Details?
-
-For specific item type help:
-
-```bash
-fab desc .<ItemType>
-```
-
-For command help:
-
-```bash
-fab --help
-fab <command> --help
-```
-
-## References
-
-**Skill references:**
-
-- [Querying Data](./references/querying-data.md) - Query semantic models and lakehouse tables
-- [Semantic Models](./references/semantic-models.md) - TMDL, DAX, refresh, storage mode
-- [Reports](./references/reports.md) - Export, import, visuals, fields
-- [Notebooks](./references/notebooks.md) - Job execution, parameters
-- [Workspaces](./references/workspaces.md) - Create, manage, permissions
-- [API Reference](./references/fab-api.md) - Capacities, gateways, pipelines, domains, dataflows, apps, admin
-- [Full Command Reference](./references/reference.md) - All commands detailed
-- [Quick Start Guide](./references/quickstart.md) - Copy-paste examples
-
-**External references** (request markdown when possible):
-
-- fab CLI: [GitHub Source](https://github.com/microsoft/fabric-cli) | [Docs](https://microsoft.github.io/fabric-cli/)
-- Microsoft: [Fabric CLI Learn](https://learn.microsoft.com/en-us/rest/api/fabric/articles/fabric-command-line-interface)
-- APIs: [Fabric API](https://learn.microsoft.com/en-us/rest/api/fabric/articles/) | [Power BI API](https://learn.microsoft.com/en-us/rest/api/power-bi/)
-- DAX: [dax.guide](https://dax.guide/) - use `dax.guide/<function>/` e.g. `dax.guide/addcolumns/`
-- Power Query: [powerquery.guide](https://powerquery.guide/) - use `powerquery.guide/function/<function>`
-- [Power Query Best Practices](https://learn.microsoft.com/en-us/power-query/best-practices)

From e376a42c9b19b0f3045c78465f0e8a434031280e Mon Sep 17 00:00:00 2001
From: Jeremy Hoover <jeremyhoover@microsoft.com>
Date: Sun, 22 Feb 2026 17:22:09 +0200
Subject: [PATCH 2/3] Scope AI assets to core and powerbi skills with
 create-workspace prompt

---
 .ai-assets/README.md                          |  17 +-
 .ai-assets/prompts/README.md                  |   7 +-
 .../prompts/analyze-semantic-model.prompt.md  |  61 --
 .../create-lakehouse-pipeline.prompt.md       |  91 ---
 .ai-assets/prompts/create-workspace.prompt.md | 107 +++
 .../prompts/deploy-to-workspace.prompt.md     |  52 --
 .ai-assets/prompts/migrate-items.prompt.md    | 108 ---
 .../prompts/troubleshoot-refresh.prompt.md    |  70 --
 .ai-assets/prompts/workspace-audit.prompt.md  | 102 ---
 .ai-assets/skills/README.md                   |  14 +-
 .ai-assets/skills/fabric-cli-cicd/README.md   |  52 --
 .ai-assets/skills/fabric-cli-cicd/SKILL.md    | 267 -------
 .../references/automation-patterns.md         | 519 -------------
 .../references/azure-pipelines.md             | 403 ----------
 .../references/environment-promotion.md       | 344 ---------
 .../references/git-integration.md             | 366 ----------
 .../references/github-actions.md              | 362 ---------
 .../skills/fabric-cli-cicd/scripts/deploy.py  | 380 ----------
 .../scripts/diff_definitions.py               | 394 ----------
 .../scripts/export_workspace.py               | 372 ----------
 .../fabric-cli-dataengineering/README.md      |  77 --
 .../fabric-cli-dataengineering/SKILL.md       | 535 --------------
 .../references/lakehouse-patterns.md          | 315 --------
 .../references/medallion-architecture.md      | 365 ----------
 .../references/shortcuts.md                   | 353 ---------
 .../references/spark-configuration.md         | 398 ----------
 .../references/table-optimization.md          | 341 ---------
 .../scripts/optimize_tables.py                | 413 -----------
 .../scripts/setup_medallion.py                | 376 ----------
 .../scripts/validate_shortcuts.py             | 424 -----------
 .../skills/fabric-cli-governance/README.md    |  75 --
 .../skills/fabric-cli-governance/SKILL.md     | 474 ------------
 .../references/audit-patterns.md              | 282 -------
 .../references/capacity-operations.md         | 253 -------
 .../references/domain-management.md           | 277 -------
 .../references/sensitivity-labels.md          | 249 -------
 .../references/workspace-permissions.md       | 249 -------
 .../scripts/audit_workspace.py                | 299 --------
 .../scripts/bulk_permissions.py               | 379 ----------
 .../scripts/validate_governance.py            | 688 ------------------
 .../skills/fabric-cli-realtime/README.md      |  56 --
 .../skills/fabric-cli-realtime/SKILL.md       | 259 -------
 .../references/activator-alerts.md            | 463 ------------
 .../references/eventhouse-operations.md       | 371 ----------
 .../references/eventstream-patterns.md        | 450 ------------
 .../references/kql-queries.md                 | 399 ----------
 .../references/streaming-patterns.md          | 502 -------------
 .../fabric-cli-realtime/scripts/kql_query.py  | 382 ----------
 .../scripts/monitor_eventstream.py            | 523 -------------
 .../scripts/setup_streaming.py                | 489 -------------
 AGENTS.md                                     |  53 +-
 51 files changed, 114 insertions(+), 14743 deletions(-)
 delete mode 100644 .ai-assets/prompts/analyze-semantic-model.prompt.md
 delete mode 100644 .ai-assets/prompts/create-lakehouse-pipeline.prompt.md
 create mode 100644 .ai-assets/prompts/create-workspace.prompt.md
 delete mode 100644 .ai-assets/prompts/deploy-to-workspace.prompt.md
 delete mode 100644 .ai-assets/prompts/migrate-items.prompt.md
 delete mode 100644 .ai-assets/prompts/troubleshoot-refresh.prompt.md
 delete mode 100644 .ai-assets/prompts/workspace-audit.prompt.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/README.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/SKILL.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/references/git-integration.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/references/github-actions.md
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
 delete mode 100644 .ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/README.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/SKILL.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
 delete mode 100644 .ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/README.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/SKILL.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/references/domain-management.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
 delete mode 100644 .ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/README.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/SKILL.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
 delete mode 100644 .ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py

diff --git a/.ai-assets/README.md b/.ai-assets/README.md
index daa025c4b..4698291dc 100644
--- a/.ai-assets/README.md
+++ b/.ai-assets/README.md
@@ -16,11 +16,7 @@ This folder contains AI-related resources for agents working with the Fabric CLI
 | Skill | Location | Description |
 |-------|----------|-------------|
 | `fabric-cli-core` | `skills/fabric-cli-core/SKILL.md` | Core CLI operations, auth, paths, safety rules |
-| `fabric-cli-cicd` | `skills/fabric-cli-cicd/SKILL.md` | CI/CD pipelines, deployments, Git integration |
-| `fabric-cli-powerbi` | `skills/fabric-cli-powerbi/SKILL.md` | Power BI — semantic models, reports, refresh, DAX, gateways |
-| `fabric-cli-governance` | `skills/fabric-cli-governance/SKILL.md` | Governance — ACLs, permissions, domains, capacity, audit |
-| `fabric-cli-dataengineering` | `skills/fabric-cli-dataengineering/SKILL.md` | Data engineering — lakehouses, medallion, shortcuts, Spark |
-| `fabric-cli-realtime` | `skills/fabric-cli-realtime/SKILL.md` | Real-time — eventhouses, eventstreams, KQL, Activator |
+| `fabric-cli-powerbi` | `skills/fabric-cli-powerbi/SKILL.md` | Power BI operations, semantic models, reports, refresh, DAX |
 
 ### Skill Scripts
 
@@ -29,11 +25,7 @@ Each skill includes automation scripts for common tasks:
 | Skill | Scripts |
 |-------|---------|
 | `fabric-cli-core` | `health_check.py` |
-| `fabric-cli-cicd` | `deploy.py`, `export_workspace.py`, `diff_definitions.py` |
 | `fabric-cli-powerbi` | `refresh_model.py`, `list_refresh_history.py`, `rebind_report.py` |
-| `fabric-cli-governance` | `audit_workspace.py`, `bulk_permissions.py`, `validate_governance.py` |
-| `fabric-cli-dataengineering` | `setup_medallion.py`, `optimize_tables.py`, `validate_shortcuts.py` |
-| `fabric-cli-realtime` | `setup_streaming.py`, `kql_query.py`, `monitor_eventstream.py` |
 
 Scripts are located in each skill's `scripts/` folder. Run with `python scripts/<script>.py --help` for usage.
 
@@ -51,12 +43,7 @@ Reusable prompt templates for common Fabric CLI tasks. See `prompts/README.md` f
 
 | Prompt | Description |
 |--------|-------------|
-| `deploy-to-workspace` | Deploy items from source to target workspace |
-| `analyze-semantic-model` | Analyze semantic model structure, tables, measures |
-| `troubleshoot-refresh` | Diagnose and fix refresh failures |
-| `create-lakehouse-pipeline` | Create a data pipeline to load a Lakehouse |
-| `workspace-audit` | Audit workspace items, permissions, capacity |
-| `migrate-items` | Migrate items between workspaces with validation |
+| `create-workspace` | Create a new Microsoft Fabric workspace with configuration |
 
 ## Context Files
 
diff --git a/.ai-assets/prompts/README.md b/.ai-assets/prompts/README.md
index 1b9691d64..cbf825011 100644
--- a/.ai-assets/prompts/README.md
+++ b/.ai-assets/prompts/README.md
@@ -6,12 +6,7 @@ Reusable prompt templates for common Fabric CLI tasks. Use these with any AI cod
 
 | Prompt | Description |
 |--------|-------------|
-| [deploy-to-workspace](deploy-to-workspace.prompt.md) | Deploy Fabric items from source to target workspace |
-| [analyze-semantic-model](analyze-semantic-model.prompt.md) | Analyze a semantic model's structure, tables, and measures |
-| [troubleshoot-refresh](troubleshoot-refresh.prompt.md) | Diagnose and fix refresh failures |
-| [create-lakehouse-pipeline](create-lakehouse-pipeline.prompt.md) | Create a data pipeline to load a Lakehouse |
-| [workspace-audit](workspace-audit.prompt.md) | Audit workspace items, permissions, and capacity |
-| [migrate-items](migrate-items.prompt.md) | Migrate items between workspaces with validation |
+| [create-workspace](create-workspace.prompt.md) | Create a new Microsoft Fabric workspace with configuration |
 
 ## Usage
 
diff --git a/.ai-assets/prompts/analyze-semantic-model.prompt.md b/.ai-assets/prompts/analyze-semantic-model.prompt.md
deleted file mode 100644
index ea14b4ed6..000000000
--- a/.ai-assets/prompts/analyze-semantic-model.prompt.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# Analyze Semantic Model
-
-Analyze the semantic model **${input:semanticModelName}** in workspace **${input:workspaceName}**.
-
-## Analysis Steps
-
-### 1. Basic Information
-Get the semantic model's metadata:
-```
-fab get {workspaceName}.Workspace/{semanticModelName}.SemanticModel
-```
-
-### 2. Model Definition
-Export and inspect the full model definition:
-```
-fab export {workspaceName}.Workspace/{semanticModelName}.SemanticModel -o ./analysis -f
-```
-
-### 3. Table Schema
-View the exported TMDL files to inspect tables and columns:
-```
-# Tables are in: ./analysis/{semanticModelName}.SemanticModel/definition/tables/
-```
-
-### 4. Measures
-Review measure definitions in the TMDL:
-```
-# Measures are defined within table TMDL files or a dedicated measures table
-```
-
-### 5. Refresh History
-Check recent refresh status:
-```
-fab jobs ls {workspaceName}.Workspace --item-name {semanticModelName}
-```
-
-## What to Look For
-
-### Data Quality Issues
-- Tables with no relationships (orphaned)
-- Missing or incorrect data types
-- Large tables that may need partitioning
-
-### Performance Concerns
-- Complex calculated columns (consider measures instead)
-- Many-to-many relationships
-- Large cardinality columns
-
-### Best Practice Violations
-- Measures not in a dedicated measures table
-- Inconsistent naming conventions
-- Missing descriptions on tables/columns
-
-## Output Format
-
-Provide a summary including:
-1. **Overview** - Model name, size, table count
-2. **Schema** - Tables, columns, data types
-3. **Calculations** - Measures with complexity assessment
-4. **Relationships** - Diagram description
-5. **Recommendations** - Optimization suggestions
diff --git a/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md b/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md
deleted file mode 100644
index fc136c9f7..000000000
--- a/.ai-assets/prompts/create-lakehouse-pipeline.prompt.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Create Lakehouse Pipeline
-
-Create a data pipeline to load data into lakehouse **${input:lakehouseName}** in workspace **${input:workspaceName}**.
-
-## Prerequisites Check
-
-### 1. Verify Lakehouse Exists
-```
-fab exists {workspaceName}.Workspace/{lakehouseName}.Lakehouse
-```
-
-If lakehouse doesn't exist, create it via API:
-```
-fab api POST workspaces/{workspaceId}/items -b '{"type": "Lakehouse", "displayName": "{lakehouseName}"}'
-```
-
-### 2. Verify Workspace Context
-```
-fab cd {workspaceName}.Workspace
-fab ls
-```
-
-## Pipeline Creation Options
-
-### Option A: Create Pipeline via API
-
-Create a new Data Pipeline:
-```
-fab api POST workspaces/{workspaceId}/items -b '{
-  "type": "DataPipeline", 
-  "displayName": "{pipelineName}",
-  "description": "Pipeline to load {lakehouseName}"
-}'
-```
-
-### Option B: Import Existing Pipeline Definition
-
-If you have a pipeline definition file:
-```
-fab import {workspaceName}.Workspace/{pipelineName}.DataPipeline -i ./pipeline-definition -f
-```
-
-## Common Pipeline Patterns
-
-### Pattern 1: Copy Activity (Source → Lakehouse)
-- Use Copy activity to move data from external source
-- Configure source connection (SQL, Azure Blob, etc.)
-- Set destination to Lakehouse Tables folder
-
-### Pattern 2: Dataflow Gen2
-- Create Dataflow Gen2 for transformations
-- Output to Lakehouse tables
-- Schedule via Pipeline
-
-### Pattern 3: Notebook Activity
-- Use Notebook activity for Spark transformations
-- Read from Files, write to Tables
-- Pass parameters from Pipeline
-
-## Data Loading Best Practices
-
-1. **Use Delta format** - Lakehouse tables use Delta Lake
-2. **Partition large tables** - By date or key columns
-3. **Incremental loads** - Use watermarks for efficiency
-4. **Error handling** - Configure retry policies
-
-## Shortcuts for External Data
-
-Create shortcuts to external data without copying:
-```
-fab ln {externalPath} {workspaceName}.Workspace/{lakehouseName}.Lakehouse/Files/{shortcutName}
-```
-
-## Verify Pipeline
-
-Get pipeline details:
-```
-fab get {workspaceName}.Workspace/{pipelineName}.DataPipeline
-```
-
-## Run and Monitor
-
-Trigger pipeline run:
-```
-fab job run {workspaceName}.Workspace/{pipelineName}.DataPipeline
-```
-
-Monitor execution:
-```
-fab job run-list {workspaceName}.Workspace/{pipelineName}.DataPipeline
-```
diff --git a/.ai-assets/prompts/create-workspace.prompt.md b/.ai-assets/prompts/create-workspace.prompt.md
new file mode 100644
index 000000000..dcf3e9c22
--- /dev/null
+++ b/.ai-assets/prompts/create-workspace.prompt.md
@@ -0,0 +1,107 @@
+````prompt
+# Create a Fabric Workspace
+
+Create a new Microsoft Fabric workspace with specified configuration.
+
+## Required Information
+
+Before proceeding, confirm the following with the user:
+
+- **Workspace name** - The display name for the workspace
+- **Capacity** - The Fabric capacity to assign (or use default)
+
+If either is missing, ask for clarification before proceeding.
+
+## Pre-Creation Checklist
+
+1. **Verify authentication**
+   ```
+   fab auth status
+   ```
+   If not authenticated, run `fab auth login` first.
+
+2. **List available capacities**
+   ```
+   fab ls .capacities
+   ```
+   Note: Users need capacity access to create workspaces on specific capacities.
+
+3. **Check if workspace name exists**
+   ```
+   fab exists "{workspaceName}.Workspace"
+   ```
+   Workspace names must be unique within the tenant.
+
+## Create the Workspace
+
+### Basic workspace (default capacity)
+
+```
+fab mkdir "{workspaceName}.Workspace"
+```
+
+### Workspace on specific capacity
+
+```
+fab mkdir "{workspaceName}.Workspace" -P capacityName="{capacityName}"
+```
+
+## Post-Creation Validation
+
+1. **Verify workspace was created**
+   ```
+   fab ls
+   ```
+
+2. **Get workspace details**
+   ```
+   fab get "{workspaceName}.Workspace"
+   ```
+
+3. **Retrieve workspace ID** (for further configuration)
+   ```
+   fab get "{workspaceName}.Workspace" -q "id"
+   ```
+
+## Optional Configuration
+
+### Set Large storage format
+
+After creation, configure the workspace to use Large storage format for semantic models:
+
+```
+fab api -A powerbi -X patch "groups/{workspaceId}" -i '{"defaultDatasetStorageFormat":"Large"}'
+```
+
+### Create initial folder structure
+
+```
+fab mkdir "{workspaceName}.Workspace/Development.Folder"
+fab mkdir "{workspaceName}.Workspace/Production.Folder"
+```
+
+## Safety Guidelines
+
+- Workspace names cannot contain special characters: `< > : " / \ | ? *`
+- Workspace names must be unique within the tenant
+- Creating a workspace does not automatically assign permissions to other users
+- Verify capacity has available resources before creation
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Permission denied | Verify you have capacity assignment rights |
+| Name already exists | Choose a different workspace name |
+| Capacity not found | Check capacity name with `fab ls .capacities` |
+| Authentication failed | Run `fab auth login` to re-authenticate |
+
+## Output
+
+After successful creation, provide:
+
+1. Workspace name and ID
+2. Assigned capacity
+3. Verification that workspace is accessible
+
+````
diff --git a/.ai-assets/prompts/deploy-to-workspace.prompt.md b/.ai-assets/prompts/deploy-to-workspace.prompt.md
deleted file mode 100644
index c292e9742..000000000
--- a/.ai-assets/prompts/deploy-to-workspace.prompt.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Deploy Items to Target Workspace
-
-Deploy Fabric items from **${input:sourceWorkspace}** to **${input:targetWorkspace}**.
-
-## Pre-Deployment Checklist
-
-Before deploying, verify:
-
-1. **Authentication** - Confirm `fab auth status` shows valid credentials
-2. **Source exists** - List items in source workspace to confirm what to deploy
-3. **Target access** - Verify write permissions on target workspace
-4. **Item conflicts** - Check if items already exist in target (will be overwritten)
-
-## Deployment Steps
-
-1. First, list items in the source workspace:
-   ```
-   fab ls {sourceWorkspace}.Workspace
-   ```
-
-2. For each item to deploy, use copy command:
-   ```
-   fab cp {sourceWorkspace}.Workspace/{itemName}.{ItemType} {targetWorkspace}.Workspace/ -f
-   ```
-
-3. Verify deployment by listing target workspace:
-   ```
-   fab ls {targetWorkspace}.Workspace
-   ```
-
-## Safety Guidelines
-
-- **Never deploy to production without testing first**
-- Copy commands OVERWRITE existing items with same name
-- Use `-f` flag for non-interactive execution
-- For large deployments, deploy in batches and verify each
-
-## Common Item Types
-
-- `.SemanticModel` - Power BI datasets
-- `.Report` - Power BI reports  
-- `.Notebook` - Spark notebooks
-- `.Lakehouse` - Lakehouse definitions
-- `.DataPipeline` - Data pipelines
-- `.Warehouse` - SQL warehouses
-
-## Rollback Strategy
-
-If deployment fails:
-1. Check item status with `fab get {targetWorkspace}.Workspace/{itemName}.{ItemType}`
-2. Items can be re-deployed from source
-3. Consider keeping backups via `fab export` before deployment
diff --git a/.ai-assets/prompts/migrate-items.prompt.md b/.ai-assets/prompts/migrate-items.prompt.md
deleted file mode 100644
index fbd9969da..000000000
--- a/.ai-assets/prompts/migrate-items.prompt.md
+++ /dev/null
@@ -1,108 +0,0 @@
-# Migrate Items Between Workspaces
-
-Migrate items from **${input:sourceWorkspace}** to **${input:targetWorkspace}**.
-
-## Pre-Migration Assessment
-
-### 1. Verify Source Items
-```
-fab ls {sourceWorkspace}.Workspace
-```
-
-### 2. Check Target Workspace
-```
-fab ls {targetWorkspace}.Workspace
-```
-
-### 3. Verify Permissions
-Source (need read):
-```
-fab acls ls {sourceWorkspace}.Workspace
-```
-
-Target (need write):
-```
-fab acls ls {targetWorkspace}.Workspace
-```
-
-## Migration Strategy
-
-### Option 1: Item-by-Item Migration
-Copy individual items:
-```
-fab cp {sourceWorkspace}.Workspace/{itemName}.{ItemType} {targetWorkspace}.Workspace/ -f
-```
-
-### Option 2: Export/Import Pattern
-Export from source, then import to target:
-```
-# Export
-fab export {sourceWorkspace}.Workspace/{itemName}.{ItemType} -o ./migration -f
-
-# Import
-fab import {targetWorkspace}.Workspace/{itemName}.{ItemType} -i ./migration/{itemName}.{ItemType} -f
-```
-
-## Migration Order (Dependencies)
-
-Follow this order to maintain dependencies:
-
-1. **Lakehouses** - Data foundation
-2. **Semantic Models** - Depend on Lakehouses
-3. **Reports** - Depend on Semantic Models
-4. **Pipelines** - May reference other items
-5. **Notebooks** - Usually independent
-
-## Post-Migration Validation
-
-### 1. Verify Items Copied
-```
-fab ls {targetWorkspace}.Workspace
-```
-
-### 2. Compare Source and Target
-List both workspaces and compare item counts manually:
-```
-fab ls {sourceWorkspace}.Workspace
-fab ls {targetWorkspace}.Workspace
-```
-
-### 3. Test Key Items
-Get details of critical items to verify:
-```
-fab get {targetWorkspace}.Workspace/{keyModel}.SemanticModel
-```
-
-### 4. Test Refresh
-Trigger refresh on migrated items:
-```
-fab job run {targetWorkspace}.Workspace/{keyModel}.SemanticModel
-```
-
-## Connection Updates
-
-After migration, update data source connections if needed:
-- Lakehouses may need shortcut updates
-- Semantic Models may need connection rebinding
-- Pipelines may need parameter updates
-
-## Rollback Plan
-
-If migration fails:
-1. Document which items successfully migrated
-2. Delete failed items in target: `fab rm {targetWorkspace}.Workspace/{itemName}.{ItemType} -f`
-3. Re-attempt migration for failed items
-4. Source workspace remains unchanged (copy doesn't delete)
-
-## Migration Checklist
-
-- [ ] Backup target workspace inventory (if items exist)
-- [ ] Verify source access
-- [ ] Verify target access
-- [ ] Copy items in dependency order
-- [ ] Validate item counts match
-- [ ] Test refresh on semantic models
-- [ ] Test reports open correctly
-- [ ] Update connections if needed
-- [ ] Update ACLs if needed
-- [ ] Notify users of new workspace location
diff --git a/.ai-assets/prompts/troubleshoot-refresh.prompt.md b/.ai-assets/prompts/troubleshoot-refresh.prompt.md
deleted file mode 100644
index 8a0862921..000000000
--- a/.ai-assets/prompts/troubleshoot-refresh.prompt.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Troubleshoot Refresh Failure
-
-Diagnose refresh issues for **${input:itemName}** in workspace **${input:workspaceName}**.
-
-## Step 1: Get Recent Job History
-
-List recent job runs for the item:
-```
-fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
-```
-
-## Step 2: Get Failed Job Details
-
-Get details of a specific job run:
-```
-fab job run-status {workspaceName}.Workspace/{itemName}.{ItemType} --id {jobId}
-```
-
-## Step 3: Common Failure Patterns
-
-### Data Source Connectivity
-- **Symptoms**: "Cannot connect to data source", timeout errors
-- **Check**: Credentials, gateway status, network connectivity
-- **Fix**: `fab auth` to refresh credentials, check gateway logs
-
-### Memory/Capacity Issues
-- **Symptoms**: "Out of memory", "Capacity throttled"
-- **Check**: Workspace capacity utilization
-- **Fix**: Scale capacity, optimize model, schedule during off-peak
-
-### Data Source Changes
-- **Symptoms**: "Column not found", "Table not found"
-- **Check**: Source schema hasn't changed
-- **Fix**: Update model schema, re-map columns
-
-### Credential Expiration
-- **Symptoms**: "Authentication failed", "Token expired"
-- **Check**: Data source credentials
-- **Fix**: Update credentials in workspace settings
-
-### Gateway Issues
-- **Symptoms**: "Gateway unreachable", "Gateway timeout"
-- **Check**: Gateway online status, version
-- **Fix**: Restart gateway, update gateway version
-
-## Step 4: Trigger Manual Refresh
-
-After fixing the issue, trigger a new refresh:
-```
-fab job run {workspaceName}.Workspace/{itemName}.{ItemType}
-```
-
-Monitor the job:
-```
-fab job run-status {workspaceName}.Workspace/{itemName}.{ItemType} --id {newJobId}
-```
-
-## Step 5: Verify Success
-
-Confirm the refresh completed by listing job runs:
-```
-fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
-```
-
-## Escalation
-
-If issue persists:
-1. Check Fabric service health at status.cloud.microsoft
-2. Export detailed logs via `fab api` for support ticket
-3. Contact workspace administrator for capacity issues
diff --git a/.ai-assets/prompts/workspace-audit.prompt.md b/.ai-assets/prompts/workspace-audit.prompt.md
deleted file mode 100644
index 60b6b47ec..000000000
--- a/.ai-assets/prompts/workspace-audit.prompt.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Workspace Audit
-
-Perform a comprehensive audit of workspace **${input:workspaceName}**.
-
-## 1. Workspace Overview
-
-### Get Workspace Details
-```
-fab get {workspaceName}.Workspace
-```
-
-### List All Items
-```
-fab ls {workspaceName}.Workspace
-```
-
-## 2. Item Inventory
-
-List items in the workspace (note: filter by type in output, not via flag):
-```
-fab ls {workspaceName}.Workspace
-```
-
-Identify items by their suffixes:
-- `.SemanticModel` - Power BI datasets
-- `.Report` - Power BI reports
-- `.Lakehouse` - Lakehouses
-- `.Notebook` - Notebooks
-- `.DataPipeline` - Pipelines
-
-## 3. Capacity & Usage
-
-### Check Workspace Capacity
-```
-fab get {workspaceName}.Workspace
-```
-
-### Recent Jobs
-For each item that supports jobs, check run history:
-```
-fab job run-list {workspaceName}.Workspace/{itemName}.{ItemType}
-```
-
-## 4. Security Review
-
-### Workspace Role Assignments
-```
-fab acls ls {workspaceName}.Workspace
-```
-
-### Item-Level Permissions
-For sensitive items, check individual permissions:
-```
-fab acls ls {workspaceName}.Workspace/{itemName}.{ItemType}
-```
-
-## 5. Data Lineage
-
-### Check Shortcuts
-List items and look for shortcuts in Lakehouse paths:
-```
-fab ls {workspaceName}.Workspace/{lakehouseName}.Lakehouse/Files
-```
-
-## Audit Report Template
-
-### Executive Summary
-- Workspace: {workspaceName}
-- Audit Date: {date}
-- Total Items: {count}
-- Active Users: {users}
-
-### Item Inventory
-| Type | Count | Last Modified |
-|------|-------|---------------|
-| Semantic Models | | |
-| Reports | | |
-| Lakehouses | | |
-| Notebooks | | |
-| Pipelines | | |
-
-### Health Status
-- Failed Jobs (Last 7 days): 
-- Stale Items (No refresh > 30 days):
-- Orphaned Items (No owner):
-
-### Security Findings
-- Over-permissioned items:
-- External sharing:
-- Guest access:
-
-### Recommendations
-1. 
-2. 
-3. 
-
-## Export Audit Data
-
-Export workspace listing to JSON:
-```
-fab ls {workspaceName}.Workspace -o json > audit-{workspaceName}.json
-```
diff --git a/.ai-assets/skills/README.md b/.ai-assets/skills/README.md
index ad0b65c4b..5363f4de1 100644
--- a/.ai-assets/skills/README.md
+++ b/.ai-assets/skills/README.md
@@ -6,23 +6,15 @@ Skills are task-specific instruction sets that guide AI agents when helping user
 
 | Skill | Description |
 |-------|-------------|
-| [fabric-cli-core](./fabric-cli-core/) | Core CLI operations — paths, auth, safety rules, item types |
-| [fabric-cli-cicd](./fabric-cli-cicd/) | CI/CD pipelines — deployments, Git integration, automation |
-| [fabric-cli-powerbi](./fabric-cli-powerbi/) | Power BI operations — semantic models, reports, refresh, DAX, gateways |
-| [fabric-cli-governance](./fabric-cli-governance/) | Governance — ACLs, permissions, domains, capacity, sensitivity labels, audit |
-| [fabric-cli-dataengineering](./fabric-cli-dataengineering/) | Data engineering — lakehouses, medallion architecture, shortcuts, Spark |
-| [fabric-cli-realtime](./fabric-cli-realtime/) | Real-time intelligence — eventhouses, eventstreams, KQL, Activator alerts |
+| [fabric-cli-core](./fabric-cli-core/) | Core CLI operations - paths, auth, safety rules, item types |
+| [fabric-cli-powerbi](./fabric-cli-powerbi/) | Power BI operations - semantic models, reports, refresh, DAX |
 
 ## Usage
 
 Load skills based on the user's task:
 
-- **Always load `fabric-cli-core` first** — Provides foundational guidance for all CLI operations
-- **Load `fabric-cli-cicd`** when working with pipelines, deployments, or automation
+- **Always load `fabric-cli-core` first** - Provides foundational guidance for all CLI operations
 - **Load `fabric-cli-powerbi`** when working with semantic models, reports, DAX queries, or gateways
-- **Load `fabric-cli-governance`** when working with permissions, ACLs, domains, capacity, or compliance
-- **Load `fabric-cli-dataengineering`** when working with lakehouses, medallion architecture, shortcuts, or Spark
-- **Load `fabric-cli-realtime`** when working with eventhouses, eventstreams, KQL queries, or real-time alerts
 
 ## Skill Structure
 
diff --git a/.ai-assets/skills/fabric-cli-cicd/README.md b/.ai-assets/skills/fabric-cli-cicd/README.md
deleted file mode 100644
index 4fa8d43a1..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# fabric-cli-cicd
-
-CI/CD skill for automating Microsoft Fabric deployments. Load after `fabric-cli-core`.
-
-## What This Skill Provides
-
-- GitHub Actions and Azure Pipelines examples
-- Environment promotion strategies (dev → test → prod)
-- Export/import automation patterns
-- Git integration for Fabric items
-- Error handling and rollback strategies
-- Secrets management guidance
-
-## When to Use
-
-Activate when tasks involve:
-
-- Setting up deployment pipelines
-- Environment promotion (dev → test → prod)
-- Automating Fabric item exports/imports
-- Git-based source control for Fabric definitions
-- Service principal authentication for automation
-
-## Prerequisites
-
-Load [`fabric-cli-core`](../fabric-cli-core/) first for foundational guidance.
-
-## Entry Point
-
-Load [`SKILL.md`](./SKILL.md) to activate this skill.
-
-## Scripts
-
-Automation scripts for CI/CD tasks:
-
-| Script | Description | Usage |
-|--------|-------------|-------|
-| `deploy.py` | Deploy items from local folder to workspace | `python scripts/deploy.py <source> <target-ws> [--dry-run]` |
-| `export_workspace.py` | Export all workspace items for version control | `python scripts/export_workspace.py <workspace> -o <dir>` |
-| `diff_definitions.py` | Compare item definitions between environments | `python scripts/diff_definitions.py <item1> <item2>` |
-
-## References
-
-Detailed documentation in the `references/` folder:
-
-| Reference | Description |
-|-----------|-------------|
-| [github-actions.md](./references/github-actions.md) | Complete GitHub Actions workflow examples |
-| [azure-pipelines.md](./references/azure-pipelines.md) | Azure Pipelines YAML templates |
-| [environment-promotion.md](./references/environment-promotion.md) | Dev/test/prod promotion strategies |
-| [git-integration.md](./references/git-integration.md) | Source control patterns |
-| [automation-patterns.md](./references/automation-patterns.md) | Scripts and error handling |
diff --git a/.ai-assets/skills/fabric-cli-cicd/SKILL.md b/.ai-assets/skills/fabric-cli-cicd/SKILL.md
deleted file mode 100644
index 9f0620854..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/SKILL.md
+++ /dev/null
@@ -1,267 +0,0 @@
----
-name: fabric-cli-cicd
-description: Use for CI/CD pipelines, deployment automation, environment promotion, and Git integration with Microsoft Fabric CLI. Activate when deploying Fabric items, setting up GitHub Actions or Azure Pipelines, or automating environment migrations.
----
-
-# Fabric CLI CI/CD Operations
-
-Expert guidance for automating Microsoft Fabric deployments using the `fab` CLI in CI/CD pipelines.
-
-## When to Use This Skill
-
-Activate automatically when tasks involve:
-
-- Setting up deployment pipelines (GitHub Actions, Azure Pipelines)
-- Environment promotion (dev → test → prod)
-- Automating Fabric item exports/imports
-- Git-based source control for Fabric definitions
-- Scheduling and orchestrating Fabric operations
-- Service principal authentication for automation
-
-## Prerequisites
-
-- Load `fabric-cli-core` skill first for foundational guidance
-- User must have appropriate workspace permissions in target environments
-- Service principal with Fabric API permissions recommended for automation
-- `fab` CLI installed in pipeline environment (`pip install ms-fabric-cli`)
-
-## Automation Scripts
-
-Ready-to-use Python scripts for CI/CD automation. Run any script with `--help` for full options.
-
-| Script | Purpose | Usage |
-|--------|---------|-------|
-| `deploy.py` | Deploy items from local folder to workspace | `python scripts/deploy.py <source> <target-ws> [--dry-run]` |
-| `export_workspace.py` | Export all workspace items for version control | `python scripts/export_workspace.py <workspace> -o <dir>` |
-| `diff_definitions.py` | Compare item definitions between environments | `python scripts/diff_definitions.py <item1> <item2>` |
-
-Scripts are located in the `scripts/` folder of this skill.
-
-## 1 - Authentication for CI/CD
-
-### Service Principal Setup (Recommended)
-
-Use environment variables for secure, non-interactive authentication:
-
-```bash
-# Required environment variables
-export FAB_SPN_TENANT_ID="<tenant-id>"
-export FAB_SPN_CLIENT_ID="<client-id>"
-export FAB_SPN_CLIENT_SECRET="<client-secret>"  # Or use certificate/federated
-
-# Authenticate
-fab auth login --service-principal
-
-# Verify
-fab auth status
-```
-
-### Authentication Methods by Priority
-
-| Method | Use Case | Security |
-|--------|----------|----------|
-| Federated credential | GitHub Actions, Azure Pipelines | Best (no secrets) |
-| Certificate | Long-running automation | Good |
-| Client secret | Simple automation | Rotate regularly |
-| Managed identity | Azure-hosted runners | Best (no credentials) |
-
-### Federated Credential (GitHub Actions)
-
-```bash
-export FAB_SPN_TENANT_ID="<tenant-id>"
-export FAB_SPN_CLIENT_ID="<client-id>"
-export FAB_SPN_FEDERATED_TOKEN="$ACTIONS_ID_TOKEN"
-
-fab auth login --service-principal --federated
-```
-
-## 2 - Export/Import Patterns
-
-### Export Items for Version Control
-
-```bash
-# Export single item
-fab export "Dev.Workspace/Pipeline.DataPipeline" -o ./fabric-items/ -f
-
-# Export entire workspace
-fab export "Dev.Workspace" -o ./fabric-items/ -a -f
-
-# Export with specific format
-fab get "Dev.Workspace/Model.SemanticModel" -q "definition" > ./definitions/model.json
-```
-
-### Import Items to Target Environment
-
-```bash
-# Import single item (create or update)
-fab import "Prod.Workspace/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-
-# Import with new name
-fab import "Prod.Workspace/Pipeline-v2.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-```
-
-### Critical Flags for Automation
-
-| Flag | Purpose | Always Use? |
-|------|---------|-------------|
-| `-f` | Force (skip prompts) | Yes in CI/CD |
-| `-a` | All items (export) | When exporting workspace |
-| `-o` | Output directory | For exports |
-| `-i` | Input file/directory | For imports |
-
-## 3 - Environment Promotion Strategy
-
-### Recommended Folder Structure
-
-```
-repo/
-├── .github/
-│   └── workflows/
-│       └── deploy-fabric.yml
-├── fabric-items/
-│   ├── pipelines/
-│   │   └── ETL.DataPipeline/
-│   ├── notebooks/
-│   │   └── Transform.Notebook/
-│   └── semantic-models/
-│       └── Sales.SemanticModel/
-└── config/
-    ├── dev.env
-    ├── test.env
-    └── prod.env
-```
-
-### Promotion Workflow
-
-```bash
-# 1. Export from source environment
-fab export "Dev.Workspace" -o ./fabric-items/ -a -f
-
-# 2. Commit to Git (manual or automated)
-git add ./fabric-items/
-git commit -m "Export from Dev"
-
-# 3. Import to target environment (in pipeline)
-fab import "Test.Workspace/Pipeline.DataPipeline" -i ./fabric-items/pipelines/ETL.DataPipeline -f
-fab import "Test.Workspace/Notebook.Notebook" -i ./fabric-items/notebooks/Transform.Notebook -f
-```
-
-### Environment-Specific Configuration
-
-```bash
-# Use different workspaces per environment
-DEV_WORKSPACE="Dev.Workspace"
-TEST_WORKSPACE="Test.Workspace"
-PROD_WORKSPACE="Prod.Workspace"
-
-# Parameterize deployment
-TARGET_WORKSPACE="${ENV}.Workspace"
-fab import "$TARGET_WORKSPACE/Item.Type" -i ./fabric-items/Item.Type -f
-```
-
-## 4 - Error Handling in Pipelines
-
-### Verify Before Deploy
-
-```bash
-# Check target exists
-fab exists "$TARGET_WORKSPACE" || { echo "Workspace not found"; exit 1; }
-
-# Check auth is valid
-fab auth status || { echo "Not authenticated"; exit 1; }
-
-# Check item exists before update
-fab exists "$TARGET_WORKSPACE/$ITEM_NAME" && echo "Will update existing item"
-```
-
-### Capture and Log Errors
-
-```bash
-# Bash pattern with error capture
-if ! fab import "$TARGET/Item.Type" -i ./Item.Type -f 2>&1 | tee deploy.log; then
-    echo "::error::Deployment failed. See deploy.log"
-    exit 1
-fi
-```
-
-### Rollback Strategy
-
-```bash
-# Before deployment, backup current state
-fab export "$PROD_WORKSPACE/$ITEM" -o ./backup/ -f
-
-# If deployment fails, restore from backup
-fab import "$PROD_WORKSPACE/$ITEM" -i ./backup/$ITEM -f
-```
-
-## 5 - Secrets Management
-
-### GitHub Actions Secrets
-
-```yaml
-env:
-  FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-  FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-  FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-```
-
-### Azure Pipelines Variable Groups
-
-```yaml
-variables:
-  - group: fabric-credentials  # Contains TENANT_ID, CLIENT_ID, CLIENT_SECRET
-```
-
-### Never Do This
-
-- Do not hardcode secrets in scripts
-- Do not echo/print secrets in logs
-- Do not commit secrets to Git
-- Do not use secrets in item names or paths
-
-## 6 - Common CI/CD Tasks
-
-### Deploy Changed Items Only
-
-```bash
-# Get list of changed files from Git
-CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/)
-
-for ITEM_PATH in $CHANGED; do
-    ITEM_NAME=$(basename "$ITEM_PATH")
-    fab import "$TARGET_WORKSPACE/$ITEM_NAME" -i "$ITEM_PATH" -f
-done
-```
-
-### Run Post-Deployment Jobs
-
-```bash
-# Trigger notebook after deployment
-fab job run "$TARGET_WORKSPACE/PostDeploy.Notebook" --timeout 600
-
-# Refresh semantic model
-WS_ID=$(fab get "$TARGET_WORKSPACE" -q "id" | tr -d '"')
-MODEL_ID=$(fab get "$TARGET_WORKSPACE/Model.SemanticModel" -q "id" | tr -d '"')
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
-```
-
-### Validate Deployment
-
-```bash
-# Verify item exists after import
-fab exists "$TARGET_WORKSPACE/$ITEM" || { echo "Deployment verification failed"; exit 1; }
-
-# Check job completed successfully
-STATUS=$(fab job run-status "$TARGET_WORKSPACE/Notebook.Notebook" --id "$JOB_ID" -q "status")
-[[ "$STATUS" == "Completed" ]] || exit 1
-```
-
-## 7 - References
-
-For detailed examples and patterns, see:
-
-- [GitHub Actions](./references/github-actions.md) — Complete workflow examples
-- [Azure Pipelines](./references/azure-pipelines.md) — Pipeline YAML templates
-- [Environment Promotion](./references/environment-promotion.md) — Dev/test/prod strategies
-- [Git Integration](./references/git-integration.md) — Source control patterns
-- [Automation Patterns](./references/automation-patterns.md) — Scripts and error handling
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md b/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
deleted file mode 100644
index 0a4683d58..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/references/automation-patterns.md
+++ /dev/null
@@ -1,519 +0,0 @@
-# Automation Patterns for Fabric CLI
-
-Scripts, error handling, and scheduling patterns for automating Fabric operations.
-
-## Shell Script Templates
-
-### Bash Template with Error Handling
-
-```bash
-#!/bin/bash
-set -euo pipefail  # Exit on error, undefined vars, pipe failures
-
-# Configuration
-WORKSPACE="${TARGET_WORKSPACE:-Dev.Workspace}"
-LOG_FILE="./fabric-deploy-$(date +%Y%m%d_%H%M%S).log"
-
-# Logging function
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
-}
-
-# Error handler
-error_exit() {
-    log "ERROR: $1"
-    exit 1
-}
-
-# Cleanup on exit
-cleanup() {
-    log "Cleaning up temporary files..."
-    rm -rf ./temp-export/ 2>/dev/null || true
-}
-trap cleanup EXIT
-
-# Main script
-main() {
-    log "Starting deployment to $WORKSPACE"
-    
-    # Verify authentication
-    fab auth status || error_exit "Not authenticated. Run 'fab auth login' first."
-    
-    # Verify workspace exists
-    fab exists "$WORKSPACE" || error_exit "Workspace $WORKSPACE not found"
-    
-    # Deploy items
-    log "Deploying items..."
-    fab import "$WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f \
-        || error_exit "Failed to deploy Pipeline"
-    
-    log "Deployment complete"
-}
-
-main "$@"
-```
-
-### PowerShell Template
-
-```powershell
-#Requires -Version 7.0
-$ErrorActionPreference = "Stop"
-
-# Configuration
-$Workspace = $env:TARGET_WORKSPACE ?? "Dev.Workspace"
-$LogFile = "./fabric-deploy-$(Get-Date -Format 'yyyyMMdd_HHmmss').log"
-
-function Write-Log {
-    param([string]$Message)
-    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
-    "[$timestamp] $Message" | Tee-Object -FilePath $LogFile -Append
-}
-
-function Test-FabAuth {
-    $result = fab auth status 2>&1
-    return $LASTEXITCODE -eq 0
-}
-
-try {
-    Write-Log "Starting deployment to $Workspace"
-    
-    # Verify authentication
-    if (-not (Test-FabAuth)) {
-        throw "Not authenticated. Run 'fab auth login' first."
-    }
-    
-    # Verify workspace
-    $exists = fab exists $Workspace
-    if ($exists -notmatch "true") {
-        throw "Workspace $Workspace not found"
-    }
-    
-    # Deploy items
-    Write-Log "Deploying items..."
-    fab import "$Workspace/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-    if ($LASTEXITCODE -ne 0) { throw "Failed to deploy Pipeline" }
-    
-    Write-Log "Deployment complete"
-}
-catch {
-    Write-Log "ERROR: $_"
-    exit 1
-}
-finally {
-    # Cleanup
-    Remove-Item -Path ./temp-export -Recurse -Force -ErrorAction SilentlyContinue
-}
-```
-
-## Error Handling Patterns
-
-### Retry Logic (Bash)
-
-```bash
-#!/bin/bash
-
-# Retry function with exponential backoff
-retry() {
-    local max_attempts=$1
-    local delay=$2
-    local command="${@:3}"
-    local attempt=1
-    
-    while [ $attempt -le $max_attempts ]; do
-        echo "Attempt $attempt of $max_attempts: $command"
-        
-        if eval "$command"; then
-            return 0
-        fi
-        
-        if [ $attempt -lt $max_attempts ]; then
-            echo "Failed. Retrying in ${delay}s..."
-            sleep $delay
-            delay=$((delay * 2))  # Exponential backoff
-        fi
-        
-        attempt=$((attempt + 1))
-    done
-    
-    echo "All $max_attempts attempts failed"
-    return 1
-}
-
-# Usage
-retry 3 5 fab import "Prod.Workspace/Item.Type" -i ./Item.Type -f
-```
-
-### Retry Logic (PowerShell)
-
-```powershell
-function Invoke-WithRetry {
-    param(
-        [scriptblock]$ScriptBlock,
-        [int]$MaxAttempts = 3,
-        [int]$DelaySeconds = 5
-    )
-    
-    $attempt = 1
-    while ($attempt -le $MaxAttempts) {
-        try {
-            Write-Host "Attempt $attempt of $MaxAttempts"
-            & $ScriptBlock
-            return
-        }
-        catch {
-            if ($attempt -eq $MaxAttempts) {
-                throw "All $MaxAttempts attempts failed: $_"
-            }
-            Write-Host "Failed. Retrying in ${DelaySeconds}s..."
-            Start-Sleep -Seconds $DelaySeconds
-            $DelaySeconds *= 2  # Exponential backoff
-            $attempt++
-        }
-    }
-}
-
-# Usage
-Invoke-WithRetry -ScriptBlock {
-    fab import "Prod.Workspace/Item.Type" -i ./Item.Type -f
-    if ($LASTEXITCODE -ne 0) { throw "Import failed" }
-}
-```
-
-### Graceful Degradation
-
-```bash
-#!/bin/bash
-
-# Deploy multiple items, continue on failure
-ITEMS=(
-    "Pipeline1.DataPipeline"
-    "Pipeline2.DataPipeline"
-    "Notebook1.Notebook"
-)
-
-FAILED=()
-SUCCEEDED=()
-
-for ITEM in "${ITEMS[@]}"; do
-    echo "Deploying $ITEM..."
-    if fab import "$WORKSPACE/$ITEM" -i "./fabric-items/$ITEM" -f; then
-        SUCCEEDED+=("$ITEM")
-    else
-        echo "WARNING: Failed to deploy $ITEM"
-        FAILED+=("$ITEM")
-    fi
-done
-
-# Report
-echo ""
-echo "=== Deployment Summary ==="
-echo "Succeeded: ${#SUCCEEDED[@]}"
-echo "Failed: ${#FAILED[@]}"
-
-if [ ${#FAILED[@]} -gt 0 ]; then
-    echo ""
-    echo "Failed items:"
-    printf '  - %s\n' "${FAILED[@]}"
-    exit 1
-fi
-```
-
-## Scheduling Patterns
-
-### Cron Schedule Reference
-
-```bash
-# ┌───────────── minute (0-59)
-# │ ┌───────────── hour (0-23)
-# │ │ ┌───────────── day of month (1-31)
-# │ │ │ ┌───────────── month (1-12)
-# │ │ │ │ ┌───────────── day of week (0-6, Sunday=0)
-# │ │ │ │ │
-# * * * * *
-
-# Examples:
-# 0 6 * * *     Daily at 6 AM
-# 0 */4 * * *   Every 4 hours
-# 0 9 * * 1-5   Weekdays at 9 AM
-# 0 0 1 * *     First of month at midnight
-```
-
-### Scheduled Refresh Script
-
-```bash
-#!/bin/bash
-# refresh-models.sh - Run as cron job
-
-LOG_DIR="/var/log/fabric"
-LOG_FILE="$LOG_DIR/refresh-$(date +%Y%m%d).log"
-mkdir -p "$LOG_DIR"
-
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
-}
-
-# Authenticate (using stored credentials)
-export FAB_SPN_TENANT_ID="$FABRIC_TENANT_ID"
-export FAB_SPN_CLIENT_ID="$FABRIC_CLIENT_ID"
-export FAB_SPN_CLIENT_SECRET="$FABRIC_CLIENT_SECRET"
-
-fab auth login --service-principal >> "$LOG_FILE" 2>&1
-
-# Get IDs
-WS_ID=$(fab get "Prod.Workspace" -q "id" | tr -d '"')
-MODEL_ID=$(fab get "Prod.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
-
-# Trigger refresh
-log "Triggering refresh for Sales model"
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post \
-    -i '{"type":"Full"}' >> "$LOG_FILE" 2>&1
-
-if [ $? -eq 0 ]; then
-    log "Refresh triggered successfully"
-else
-    log "ERROR: Failed to trigger refresh"
-    exit 1
-fi
-```
-
-### Windows Task Scheduler Script
-
-```powershell
-# refresh-models.ps1
-# Schedule with: schtasks /create /tn "FabricRefresh" /tr "powershell.exe -File C:\scripts\refresh-models.ps1" /sc daily /st 06:00
-
-$LogPath = "C:\Logs\Fabric"
-$LogFile = Join-Path $LogPath "refresh-$(Get-Date -Format 'yyyyMMdd').log"
-New-Item -ItemType Directory -Path $LogPath -Force | Out-Null
-
-function Write-Log {
-    param([string]$Message)
-    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
-    "[$timestamp] $Message" | Add-Content -Path $LogFile
-}
-
-# Set credentials from secure storage
-$env:FAB_SPN_TENANT_ID = Get-Secret -Name FabricTenantId -AsPlainText
-$env:FAB_SPN_CLIENT_ID = Get-Secret -Name FabricClientId -AsPlainText
-$env:FAB_SPN_CLIENT_SECRET = Get-Secret -Name FabricClientSecret -AsPlainText
-
-fab auth login --service-principal
-
-# Trigger refresh
-Write-Log "Triggering model refresh"
-$wsId = (fab get "Prod.Workspace" -q "id") -replace '"', ''
-$modelId = (fab get "Prod.Workspace/Sales.SemanticModel" -q "id") -replace '"', ''
-
-fab api -A powerbi "groups/$wsId/datasets/$modelId/refreshes" -X post -i '{"type":"Full"}'
-
-if ($LASTEXITCODE -eq 0) {
-    Write-Log "Refresh triggered successfully"
-} else {
-    Write-Log "ERROR: Failed to trigger refresh"
-    exit 1
-}
-```
-
-## Parallel Execution
-
-### Bash Parallel Deployment
-
-```bash
-#!/bin/bash
-# parallel-deploy.sh
-
-WORKSPACE="Prod.Workspace"
-MAX_PARALLEL=4
-
-# Deploy function
-deploy_item() {
-    local item=$1
-    echo "Deploying $item..."
-    fab import "$WORKSPACE/$item" -i "./fabric-items/$item" -f
-    echo "Completed $item"
-}
-
-export -f deploy_item
-export WORKSPACE
-
-# Find all items and deploy in parallel
-find ./fabric-items -maxdepth 1 -type d -name "*.DataPipeline" -o -name "*.Notebook" | \
-    xargs -P $MAX_PARALLEL -I {} basename {} | \
-    xargs -P $MAX_PARALLEL -I {} bash -c 'deploy_item "$@"' _ {}
-```
-
-### PowerShell Parallel Deployment
-
-```powershell
-$Workspace = "Prod.Workspace"
-$Items = Get-ChildItem ./fabric-items -Directory | Select-Object -ExpandProperty Name
-
-$Items | ForEach-Object -ThrottleLimit 4 -Parallel {
-    $item = $_
-    $ws = $using:Workspace
-    Write-Host "Deploying $item..."
-    fab import "$ws/$item" -i "./fabric-items/$item" -f
-    Write-Host "Completed $item"
-}
-```
-
-## Monitoring and Alerting
-
-### Check Job Status Script
-
-```bash
-#!/bin/bash
-# monitor-jobs.sh
-
-WORKSPACE="Prod.Workspace"
-NOTEBOOK="ETL.Notebook"
-MAX_WAIT=3600  # 1 hour
-CHECK_INTERVAL=30
-
-# Start job
-JOB_OUTPUT=$(fab job start "$WORKSPACE/$NOTEBOOK")
-JOB_ID=$(echo "$JOB_OUTPUT" | grep -oP 'id["\s:]+\K[a-f0-9-]+')
-
-echo "Started job: $JOB_ID"
-
-# Monitor until complete or timeout
-ELAPSED=0
-while [ $ELAPSED -lt $MAX_WAIT ]; do
-    STATUS=$(fab job run-status "$WORKSPACE/$NOTEBOOK" --id "$JOB_ID" -q "status" | tr -d '"')
-    
-    case "$STATUS" in
-        "Completed")
-            echo "Job completed successfully"
-            exit 0
-            ;;
-        "Failed"|"Cancelled")
-            echo "Job $STATUS"
-            # Send alert
-            curl -X POST "$SLACK_WEBHOOK" -d "{\"text\":\"Fabric job failed: $NOTEBOOK\"}"
-            exit 1
-            ;;
-        *)
-            echo "Status: $STATUS (${ELAPSED}s elapsed)"
-            ;;
-    esac
-    
-    sleep $CHECK_INTERVAL
-    ELAPSED=$((ELAPSED + CHECK_INTERVAL))
-done
-
-echo "Timeout waiting for job"
-exit 1
-```
-
-### Health Check Script
-
-```bash
-#!/bin/bash
-# health-check.sh
-
-WORKSPACE="Prod.Workspace"
-ITEMS_TO_CHECK=(
-    "Sales.SemanticModel"
-    "ETL.DataPipeline"
-    "Transform.Notebook"
-)
-
-HEALTHY=0
-UNHEALTHY=0
-
-echo "=== Fabric Health Check ==="
-echo "Workspace: $WORKSPACE"
-echo ""
-
-# Check auth
-if fab auth status >/dev/null 2>&1; then
-    echo "[OK] Authentication: OK"
-else
-    echo "[FAILED] Authentication: FAILED"
-    exit 1
-fi
-
-# Check workspace
-if fab exists "$WORKSPACE" >/dev/null 2>&1; then
-    echo "[OK] Workspace: Accessible"
-else
-    echo "[FAILED] Workspace: Not accessible"
-    exit 1
-fi
-
-# Check items
-echo ""
-echo "Items:"
-for ITEM in "${ITEMS_TO_CHECK[@]}"; do
-    if fab exists "$WORKSPACE/$ITEM" >/dev/null 2>&1; then
-        echo "  [OK] $ITEM"
-        HEALTHY=$((HEALTHY + 1))
-    else
-        echo "  [FAILED] $ITEM (not found)"
-        UNHEALTHY=$((UNHEALTHY + 1))
-    fi
-done
-
-echo ""
-echo "Summary: $HEALTHY healthy, $UNHEALTHY unhealthy"
-
-[ $UNHEALTHY -eq 0 ] && exit 0 || exit 1
-```
-
-## Environment Variable Management
-
-### Using .env Files
-
-```bash
-#!/bin/bash
-# Load environment-specific config
-
-ENV=${1:-dev}
-ENV_FILE="./config/$ENV.env"
-
-if [ ! -f "$ENV_FILE" ]; then
-    echo "Error: $ENV_FILE not found"
-    exit 1
-fi
-
-# Load variables (without export for security)
-set -a
-source "$ENV_FILE"
-set +a
-
-echo "Loaded config for: $ENV"
-echo "Target workspace: $TARGET_WORKSPACE"
-```
-
-### Secure Credential Handling
-
-```bash
-#!/bin/bash
-# Never echo credentials, use env vars
-
-# Bad - exposes secrets in logs
-# echo "Using secret: $FAB_SPN_CLIENT_SECRET"
-
-# Good - validate without exposing
-if [ -z "$FAB_SPN_CLIENT_SECRET" ]; then
-    echo "Error: FAB_SPN_CLIENT_SECRET not set"
-    exit 1
-fi
-echo "Credentials configured"
-
-# Good - mask in CI logs
-echo "::add-mask::$FAB_SPN_CLIENT_SECRET"
-```
-
-## Best Practices Summary
-
-| Practice | Description |
-|----------|-------------|
-| Use `set -euo pipefail` | Exit on errors in bash scripts |
-| Implement retry logic | Handle transient failures |
-| Log everything | Timestamp and persist logs |
-| Use cleanup traps | Clean temp files on exit |
-| Validate before acting | Check auth and existence first |
-| Parameterize scripts | Use env vars for flexibility |
-| Never log secrets | Mask sensitive values |
-| Monitor long-running jobs | Set timeouts, send alerts |
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md b/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
deleted file mode 100644
index f273fa270..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/references/azure-pipelines.md
+++ /dev/null
@@ -1,403 +0,0 @@
-# Azure Pipelines for Fabric CLI
-
-Complete pipeline examples for deploying Microsoft Fabric items using Azure DevOps.
-
-## Basic Deployment Pipeline
-
-```yaml
-trigger:
-  branches:
-    include:
-      - main
-  paths:
-    include:
-      - fabric-items/**
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-variables:
-  pythonVersion: '3.11'
-
-stages:
-  - stage: Deploy
-    displayName: 'Deploy to Fabric'
-    jobs:
-      - job: DeployItems
-        displayName: 'Deploy Fabric Items'
-        steps:
-          - task: UsePythonVersion@0
-            inputs:
-              versionSpec: '$(pythonVersion)'
-            displayName: 'Use Python $(pythonVersion)'
-
-          - script: pip install ms-fabric-cli
-            displayName: 'Install Fabric CLI'
-
-          - script: |
-              fab auth login --service-principal
-              fab auth status
-            displayName: 'Authenticate'
-            env:
-              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-              FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-
-          - script: |
-              fab import "$(TARGET_WORKSPACE)/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-              fab import "$(TARGET_WORKSPACE)/Notebook.Notebook" -i ./fabric-items/Notebook.Notebook -f
-            displayName: 'Deploy items'
-```
-
-## Multi-Stage Pipeline (Dev → Test → Prod)
-
-```yaml
-trigger:
-  branches:
-    include:
-      - main
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-variables:
-  - group: fabric-credentials  # Contains shared credentials
-
-stages:
-  # Development
-  - stage: Dev
-    displayName: 'Deploy to Dev'
-    variables:
-      TARGET_WORKSPACE: 'Development.Workspace'
-    jobs:
-      - template: templates/deploy-job.yml
-        parameters:
-          environment: 'dev'
-          workspace: '$(TARGET_WORKSPACE)'
-
-  # Test (requires approval)
-  - stage: Test
-    displayName: 'Deploy to Test'
-    dependsOn: Dev
-    variables:
-      TARGET_WORKSPACE: 'Testing.Workspace'
-    jobs:
-      - deployment: DeployTest
-        environment: 'test'
-        strategy:
-          runOnce:
-            deploy:
-              steps:
-                - template: templates/deploy-steps.yml
-                  parameters:
-                    workspace: '$(TARGET_WORKSPACE)'
-
-  # Production (requires approval)
-  - stage: Prod
-    displayName: 'Deploy to Prod'
-    dependsOn: Test
-    variables:
-      TARGET_WORKSPACE: 'Production.Workspace'
-    jobs:
-      - deployment: DeployProd
-        environment: 'production'
-        strategy:
-          runOnce:
-            deploy:
-              steps:
-                - template: templates/deploy-steps.yml
-                  parameters:
-                    workspace: '$(TARGET_WORKSPACE)'
-```
-
-## Reusable Template: deploy-steps.yml
-
-```yaml
-# templates/deploy-steps.yml
-parameters:
-  - name: workspace
-    type: string
-
-steps:
-  - task: UsePythonVersion@0
-    inputs:
-      versionSpec: '3.11'
-
-  - script: pip install ms-fabric-cli
-    displayName: 'Install Fabric CLI'
-
-  - script: |
-      fab auth login --service-principal
-      fab auth status
-    displayName: 'Authenticate'
-    env:
-      FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-      FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-      FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-
-  - script: |
-      echo "Deploying to ${{ parameters.workspace }}"
-      for ITEM in ./fabric-items/*; do
-        ITEM_NAME=$(basename "$ITEM")
-        fab import "${{ parameters.workspace }}/$ITEM_NAME" -i "$ITEM" -f
-      done
-    displayName: 'Deploy items to ${{ parameters.workspace }}'
-
-  - script: |
-      fab exists "${{ parameters.workspace }}" || exit 1
-      echo "Deployment verified"
-    displayName: 'Validate deployment'
-```
-
-## Service Connection with Federated Credential
-
-```yaml
-trigger:
-  - main
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-stages:
-  - stage: Deploy
-    jobs:
-      - job: DeployWithFederated
-        steps:
-          - task: UsePythonVersion@0
-            inputs:
-              versionSpec: '3.11'
-
-          - script: pip install ms-fabric-cli
-            displayName: 'Install Fabric CLI'
-
-          - task: AzureCLI@2
-            displayName: 'Authenticate with Federated Credential'
-            inputs:
-              azureSubscription: 'fabric-service-connection'  # Service connection name
-              scriptType: 'bash'
-              scriptLocation: 'inlineScript'
-              inlineScript: |
-                # Get token for Fabric API
-                TOKEN=$(az account get-access-token --resource https://analysis.windows.net/powerbi/api --query accessToken -o tsv)
-                echo "##vso[task.setvariable variable=FAB_TOKEN;issecret=true]$TOKEN"
-
-          - script: |
-              export FAB_SPN_FEDERATED_TOKEN=$(FAB_TOKEN)
-              fab auth login --service-principal --federated
-              fab auth status
-            displayName: 'Login to Fabric CLI'
-            env:
-              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-
-          - script: |
-              fab import "$(TARGET_WORKSPACE)/Item.Type" -i ./fabric-items/Item.Type -f
-            displayName: 'Deploy items'
-```
-
-## Deploy Changed Items Only
-
-```yaml
-trigger:
-  branches:
-    include:
-      - main
-  paths:
-    include:
-      - fabric-items/**
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-jobs:
-  - job: DeployChanges
-    steps:
-      - checkout: self
-        fetchDepth: 2  # Need for git diff
-
-      - task: UsePythonVersion@0
-        inputs:
-          versionSpec: '3.11'
-
-      - script: pip install ms-fabric-cli
-        displayName: 'Install Fabric CLI'
-
-      - script: |
-          fab auth login --service-principal
-        displayName: 'Authenticate'
-        env:
-          FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-          FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-          FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-
-      - script: |
-          # Get changed item directories
-          CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/ | xargs -I {} dirname {} | sort -u)
-          
-          if [ -z "$CHANGED" ]; then
-            echo "No items changed"
-            exit 0
-          fi
-          
-          for ITEM_PATH in $CHANGED; do
-            if [ -d "$ITEM_PATH" ]; then
-              ITEM_NAME=$(basename "$ITEM_PATH")
-              echo "Deploying $ITEM_NAME..."
-              fab import "$(TARGET_WORKSPACE)/$ITEM_NAME" -i "$ITEM_PATH" -f
-            fi
-          done
-        displayName: 'Deploy changed items'
-```
-
-## Scheduled Export Pipeline
-
-```yaml
-trigger: none
-
-schedules:
-  - cron: '0 6 * * *'  # Daily at 6 AM UTC
-    displayName: 'Daily export'
-    branches:
-      include:
-        - main
-    always: true
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-jobs:
-  - job: ExportItems
-    steps:
-      - checkout: self
-        persistCredentials: true
-
-      - task: UsePythonVersion@0
-        inputs:
-          versionSpec: '3.11'
-
-      - script: pip install ms-fabric-cli
-        displayName: 'Install Fabric CLI'
-
-      - script: |
-          fab auth login --service-principal
-        displayName: 'Authenticate'
-        env:
-          FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-          FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-          FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-
-      - script: |
-          fab export "$(SOURCE_WORKSPACE)" -o ./fabric-items/ -a -f
-        displayName: 'Export workspace items'
-
-      - script: |
-          git config user.name "Azure Pipelines"
-          git config user.email "azuredevops@microsoft.com"
-          git add ./fabric-items/
-          if git diff --staged --quiet; then
-            echo "No changes to commit"
-          else
-            git commit -m "Auto-export Fabric items $(date +%Y-%m-%d)"
-            git push origin HEAD:main
-          fi
-        displayName: 'Commit and push changes'
-```
-
-## Pipeline with Rollback Support
-
-```yaml
-trigger:
-  - main
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-variables:
-  - group: fabric-credentials
-
-stages:
-  - stage: Backup
-    jobs:
-      - job: BackupCurrent
-        steps:
-          - script: |
-              pip install ms-fabric-cli
-              fab auth login --service-principal
-              fab export "$(TARGET_WORKSPACE)" -o $(Build.ArtifactStagingDirectory)/backup -a -f
-            env:
-              FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-              FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-              FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-          
-          - publish: $(Build.ArtifactStagingDirectory)/backup
-            artifact: backup
-            displayName: 'Publish backup artifact'
-
-  - stage: Deploy
-    dependsOn: Backup
-    jobs:
-      - deployment: DeployProd
-        environment: 'production'
-        strategy:
-          runOnce:
-            deploy:
-              steps:
-                - script: |
-                    pip install ms-fabric-cli
-                    fab auth login --service-principal
-                    fab import "$(TARGET_WORKSPACE)/Item.Type" -i ./fabric-items/Item.Type -f
-                  env:
-                    FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-                    FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-                    FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-            
-            on:
-              failure:
-                steps:
-                  - download: current
-                    artifact: backup
-                  
-                  - script: |
-                      pip install ms-fabric-cli
-                      fab auth login --service-principal
-                      fab import "$(TARGET_WORKSPACE)/Item.Type" -i $(Pipeline.Workspace)/backup/Item.Type -f
-                      echo "##vso[task.logissue type=warning]Rolled back to previous version"
-                    env:
-                      FAB_SPN_TENANT_ID: $(FABRIC_TENANT_ID)
-                      FAB_SPN_CLIENT_ID: $(FABRIC_CLIENT_ID)
-                      FAB_SPN_CLIENT_SECRET: $(FABRIC_CLIENT_SECRET)
-                    displayName: 'Rollback on failure'
-```
-
-## Variable Groups Setup
-
-Create these variable groups in Azure DevOps:
-
-### fabric-credentials (Linked to Key Vault recommended)
-
-| Variable | Description | Secret? |
-|----------|-------------|---------|
-| `FABRIC_TENANT_ID` | Azure AD tenant ID | No |
-| `FABRIC_CLIENT_ID` | Service principal client ID | No |
-| `FABRIC_CLIENT_SECRET` | Service principal secret | Yes |
-
-### fabric-environments-dev
-
-| Variable | Value |
-|----------|-------|
-| `TARGET_WORKSPACE` | `Development.Workspace` |
-
-### fabric-environments-prod
-
-| Variable | Value |
-|----------|-------|
-| `TARGET_WORKSPACE` | `Production.Workspace` |
-
-## Environment Approvals
-
-Configure environment approvals in Azure DevOps:
-
-1. Go to **Pipelines** → **Environments**
-2. Create environments: `dev`, `test`, `production`
-3. Add approvers for `test` and `production`
-4. Configure branch policies if needed
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md b/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
deleted file mode 100644
index 62a2f70c2..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/references/environment-promotion.md
+++ /dev/null
@@ -1,344 +0,0 @@
-# Environment Promotion Strategies
-
-Patterns for promoting Fabric items across development, test, and production environments.
-
-## Environment Architecture
-
-### Recommended Setup
-
-```
-┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
-│  Development    │───▶│     Testing     │───▶│   Production    │
-│   .Workspace    │    │   .Workspace    │    │   .Workspace    │
-└─────────────────┘    └─────────────────┘    └─────────────────┘
-       │                       │                       │
-       ▼                       ▼                       ▼
-   Dev Capacity           Test Capacity          Prod Capacity
-```
-
-### Workspace Naming Convention
-
-| Environment | Workspace Name | Purpose |
-|-------------|----------------|---------|
-| Development | `ProjectName-Dev.Workspace` | Active development |
-| Testing | `ProjectName-Test.Workspace` | QA and validation |
-| Production | `ProjectName-Prod.Workspace` | Live workloads |
-
-## Full Workspace Promotion
-
-### Export Entire Workspace
-
-```bash
-# Export all items from source
-fab export "Dev.Workspace" -o ./export/ -a -f
-
-# Directory structure created:
-# ./export/
-# ├── Pipeline1.DataPipeline/
-# ├── Pipeline2.DataPipeline/
-# ├── Notebook1.Notebook/
-# ├── Model1.SemanticModel/
-# └── Report1.Report/
-```
-
-### Import to Target Workspace
-
-```bash
-# Import each item type
-for ITEM in ./export/*; do
-    ITEM_NAME=$(basename "$ITEM")
-    fab import "Test.Workspace/$ITEM_NAME" -i "$ITEM" -f
-done
-```
-
-### Selective Promotion
-
-```bash
-# Promote only specific items
-ITEMS_TO_PROMOTE=(
-    "ETL-Pipeline.DataPipeline"
-    "Transform.Notebook"
-    "Sales-Model.SemanticModel"
-)
-
-for ITEM in "${ITEMS_TO_PROMOTE[@]}"; do
-    fab import "Test.Workspace/$ITEM" -i "./export/$ITEM" -f
-done
-```
-
-## Parameterized Deployments
-
-### Environment Configuration Files
-
-```bash
-# config/dev.env
-WORKSPACE_NAME="Dev.Workspace"
-LAKEHOUSE_NAME="DevLakehouse"
-CONNECTION_STRING="dev-connection"
-
-# config/prod.env
-WORKSPACE_NAME="Prod.Workspace"
-LAKEHOUSE_NAME="ProdLakehouse"
-CONNECTION_STRING="prod-connection"
-```
-
-### Load Environment Config
-
-```bash
-#!/bin/bash
-# deploy.sh
-
-ENV=${1:-dev}
-source "./config/$ENV.env"
-
-echo "Deploying to $WORKSPACE_NAME"
-
-fab import "$WORKSPACE_NAME/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-```
-
-### Parameter Substitution in Definitions
-
-For items with environment-specific settings:
-
-```bash
-# Export definition
-fab get "Dev.Workspace/Pipeline.DataPipeline" -q "definition" > pipeline-def.json
-
-# Substitute parameters (using jq or sed)
-cat pipeline-def.json | \
-    sed "s/DevLakehouse/$TARGET_LAKEHOUSE/g" | \
-    sed "s/dev-connection/$TARGET_CONNECTION/g" \
-    > pipeline-def-updated.json
-
-# Import with updated definition
-fab set "Prod.Workspace/Pipeline.DataPipeline" -q definition -i pipeline-def-updated.json
-```
-
-## Promotion Workflows
-
-### Manual Promotion Script
-
-```bash
-#!/bin/bash
-# promote.sh - Promote items from one environment to another
-
-SOURCE_ENV=$1
-TARGET_ENV=$2
-
-if [ -z "$SOURCE_ENV" ] || [ -z "$TARGET_ENV" ]; then
-    echo "Usage: ./promote.sh <source-env> <target-env>"
-    echo "Example: ./promote.sh dev test"
-    exit 1
-fi
-
-SOURCE_WS="${SOURCE_ENV^}.Workspace"  # Capitalize
-TARGET_WS="${TARGET_ENV^}.Workspace"
-
-echo "Promoting from $SOURCE_WS to $TARGET_WS"
-
-# Create temp directory
-EXPORT_DIR=$(mktemp -d)
-
-# Export from source
-echo "Exporting from $SOURCE_WS..."
-fab export "$SOURCE_WS" -o "$EXPORT_DIR" -a -f
-
-# Import to target
-echo "Importing to $TARGET_WS..."
-for ITEM in "$EXPORT_DIR"/*; do
-    ITEM_NAME=$(basename "$ITEM")
-    echo "  - $ITEM_NAME"
-    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
-done
-
-# Cleanup
-rm -rf "$EXPORT_DIR"
-
-echo "Promotion complete"
-```
-
-### Promotion with Approval Gate
-
-```bash
-#!/bin/bash
-# promote-with-approval.sh
-
-SOURCE_WS="Test.Workspace"
-TARGET_WS="Prod.Workspace"
-
-# List items to promote
-echo "Items to promote from $SOURCE_WS:"
-fab ls "$SOURCE_WS" -l
-
-# Prompt for approval
-read -p "Proceed with promotion to $TARGET_WS? (yes/no): " APPROVAL
-
-if [ "$APPROVAL" != "yes" ]; then
-    echo "Promotion cancelled"
-    exit 0
-fi
-
-# Backup current production
-echo "Creating backup of $TARGET_WS..."
-fab export "$TARGET_WS" -o "./backup/$(date +%Y%m%d)" -a -f
-
-# Perform promotion
-echo "Promoting items..."
-fab export "$SOURCE_WS" -o ./temp-export -a -f
-
-for ITEM in ./temp-export/*; do
-    ITEM_NAME=$(basename "$ITEM")
-    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
-done
-
-rm -rf ./temp-export
-echo "Promotion complete"
-```
-
-## Dependency-Aware Promotion
-
-### Order of Deployment
-
-Deploy items in dependency order:
-
-```bash
-# 1. Data stores first (lakehouses, warehouses)
-fab import "$TARGET/DataLakehouse.Lakehouse" -i ./items/DataLakehouse.Lakehouse -f
-
-# 2. Semantic models (depend on data stores)
-fab import "$TARGET/SalesModel.SemanticModel" -i ./items/SalesModel.SemanticModel -f
-
-# 3. Reports (depend on semantic models)
-fab import "$TARGET/SalesReport.Report" -i ./items/SalesReport.Report -f
-
-# 4. Pipelines and notebooks (may depend on any above)
-fab import "$TARGET/ETL.DataPipeline" -i ./items/ETL.DataPipeline -f
-fab import "$TARGET/Transform.Notebook" -i ./items/Transform.Notebook -f
-```
-
-### Dependency Mapping File
-
-```yaml
-# dependencies.yml
-items:
-  - name: DataLakehouse.Lakehouse
-    depends_on: []
-    
-  - name: SalesModel.SemanticModel
-    depends_on:
-      - DataLakehouse.Lakehouse
-      
-  - name: SalesReport.Report
-    depends_on:
-      - SalesModel.SemanticModel
-      
-  - name: ETL.DataPipeline
-    depends_on:
-      - DataLakehouse.Lakehouse
-```
-
-## Rollback Strategies
-
-### Immediate Rollback
-
-```bash
-#!/bin/bash
-# rollback.sh
-
-BACKUP_DIR=$1
-TARGET_WS=$2
-
-if [ -z "$BACKUP_DIR" ] || [ -z "$TARGET_WS" ]; then
-    echo "Usage: ./rollback.sh <backup-dir> <target-workspace>"
-    exit 1
-fi
-
-echo "Rolling back $TARGET_WS from $BACKUP_DIR"
-
-for ITEM in "$BACKUP_DIR"/*; do
-    ITEM_NAME=$(basename "$ITEM")
-    echo "Restoring $ITEM_NAME..."
-    fab import "$TARGET_WS/$ITEM_NAME" -i "$ITEM" -f
-done
-
-echo "Rollback complete"
-```
-
-### Versioned Backups
-
-```bash
-# Create timestamped backup before each deployment
-BACKUP_DIR="./backups/$(date +%Y%m%d_%H%M%S)"
-fab export "$PROD_WS" -o "$BACKUP_DIR" -a -f
-
-# Keep last N backups
-ls -dt ./backups/*/ | tail -n +6 | xargs rm -rf
-```
-
-## Validation After Promotion
-
-### Verify Items Exist
-
-```bash
-#!/bin/bash
-# validate-deployment.sh
-
-TARGET_WS=$1
-EXPECTED_ITEMS=(
-    "ETL.DataPipeline"
-    "Transform.Notebook"
-    "SalesModel.SemanticModel"
-    "SalesReport.Report"
-)
-
-FAILED=0
-
-for ITEM in "${EXPECTED_ITEMS[@]}"; do
-    if fab exists "$TARGET_WS/$ITEM"; then
-        echo "[OK] $ITEM exists"
-    else
-        echo "[FAILED] $ITEM NOT FOUND"
-        FAILED=1
-    fi
-done
-
-exit $FAILED
-```
-
-### Run Smoke Tests
-
-```bash
-# Run validation notebook
-fab job run "$TARGET_WS/ValidationTests.Notebook" --timeout 300
-
-# Check semantic model refresh
-WS_ID=$(fab get "$TARGET_WS" -q "id" | tr -d '"')
-MODEL_ID=$(fab get "$TARGET_WS/SalesModel.SemanticModel" -q "id" | tr -d '"')
-
-# Trigger test refresh
-fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes" -X post -i '{"type":"Full"}'
-
-# Wait and check status
-sleep 60
-STATUS=$(fab api -A powerbi "groups/$WS_ID/datasets/$MODEL_ID/refreshes?\$top=1" -q "value[0].status")
-echo "Refresh status: $STATUS"
-```
-
-## Best Practices
-
-### Do's
-
-- Always backup before promoting to production
-- Use consistent naming across environments
-- Validate deployments with automated tests
-- Keep promotion scripts in version control
-- Use environment-specific configuration files
-- Deploy in dependency order
-
-### Don'ts
-
-- Do not promote directly from dev to prod (skip test)
-- Do not promote without backups
-- Do not hardcode environment-specific values in items
-- Do not ignore failed deployments
-- Do not promote during business hours (for prod)
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md b/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md
deleted file mode 100644
index 0ab13b650..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/references/git-integration.md
+++ /dev/null
@@ -1,366 +0,0 @@
-# Git Integration for Fabric Items
-
-Patterns for storing and managing Fabric item definitions in Git repositories.
-
-## Repository Structure
-
-### Recommended Layout
-
-```
-fabric-repo/
-├── .github/
-│   └── workflows/
-│       └── deploy.yml
-├── fabric-items/
-│   ├── pipelines/
-│   │   ├── ETL-Daily.DataPipeline/
-│   │   │   └── pipeline-content.json
-│   │   └── ETL-Weekly.DataPipeline/
-│   │       └── pipeline-content.json
-│   ├── notebooks/
-│   │   ├── Transform.Notebook/
-│   │   │   └── notebook-content.py
-│   │   └── Validation.Notebook/
-│   │       └── notebook-content.py
-│   ├── semantic-models/
-│   │   └── Sales.SemanticModel/
-│   │       ├── model.tmdl
-│   │       ├── tables/
-│   │       └── relationships/
-│   └── reports/
-│       └── SalesDashboard.Report/
-│           └── report.json
-├── config/
-│   ├── dev.env
-│   ├── test.env
-│   └── prod.env
-└── README.md
-```
-
-## Exporting Items for Git
-
-### Export Single Item
-
-```bash
-# Export a data pipeline
-fab export "Dev.Workspace/ETL-Daily.DataPipeline" -o ./fabric-items/pipelines/ -f
-
-# Export a notebook
-fab export "Dev.Workspace/Transform.Notebook" -o ./fabric-items/notebooks/ -f
-
-# Export a semantic model (TMDL format)
-fab export "Dev.Workspace/Sales.SemanticModel" -o ./fabric-items/semantic-models/ -f
-```
-
-### Export Full Workspace
-
-```bash
-# Export all items
-fab export "Dev.Workspace" -o ./fabric-items/ -a -f
-
-# Organize by type (post-export script)
-mkdir -p fabric-items/{pipelines,notebooks,semantic-models,reports}
-
-for ITEM in fabric-items/*.*; do
-    case "$ITEM" in
-        *.DataPipeline) mv "$ITEM" fabric-items/pipelines/ ;;
-        *.Notebook) mv "$ITEM" fabric-items/notebooks/ ;;
-        *.SemanticModel) mv "$ITEM" fabric-items/semantic-models/ ;;
-        *.Report) mv "$ITEM" fabric-items/reports/ ;;
-    esac
-done
-```
-
-### Export Definitions Only
-
-```bash
-# Get raw definition (useful for semantic models)
-fab get "Dev.Workspace/Sales.SemanticModel" -q "definition" > ./fabric-items/semantic-models/Sales.SemanticModel/definition.json
-```
-
-## Git Workflow
-
-### Initial Setup
-
-```bash
-# Clone/create repo
-git clone https://github.com/org/fabric-repo.git
-cd fabric-repo
-
-# Export current state
-fab auth login
-fab export "Dev.Workspace" -o ./fabric-items/ -a -f
-
-# Initial commit
-git add .
-git commit -m "Initial export of Fabric items"
-git push
-```
-
-### Feature Branch Workflow
-
-```bash
-# Create feature branch
-git checkout -b feature/new-pipeline
-
-# Make changes in Fabric UI or export updated items
-fab export "Dev.Workspace/NewPipeline.DataPipeline" -o ./fabric-items/pipelines/ -f
-
-# Commit changes
-git add fabric-items/pipelines/NewPipeline.DataPipeline/
-git commit -m "Add new ETL pipeline"
-
-# Push and create PR
-git push -u origin feature/new-pipeline
-```
-
-### Syncing Changes from Fabric
-
-```bash
-# Pull latest from Git
-git pull origin main
-
-# Export current Fabric state
-fab export "Dev.Workspace" -o ./temp-export/ -a -f
-
-# Compare with Git (visual diff)
-diff -r ./fabric-items/ ./temp-export/
-
-# Update Git with changes
-cp -r ./temp-export/* ./fabric-items/
-git add .
-git commit -m "Sync changes from Fabric"
-```
-
-## Semantic Model (TMDL) in Git
-
-### TMDL Structure
-
-```
-Sales.SemanticModel/
-├── definition.tmdl
-├── model.tmdl
-├── tables/
-│   ├── Sales.tmdl
-│   ├── Products.tmdl
-│   └── Date.tmdl
-├── relationships/
-│   └── relationships.tmdl
-├── roles/
-│   └── roles.tmdl
-└── expressions/
-    └── expressions.tmdl
-```
-
-### Export TMDL
-
-```bash
-# Export semantic model (automatically creates TMDL structure)
-fab export "Dev.Workspace/Sales.SemanticModel" -o ./fabric-items/semantic-models/ -f
-```
-
-### Track TMDL Changes
-
-```bash
-# See what tables changed
-git diff fabric-items/semantic-models/Sales.SemanticModel/tables/
-
-# See measure changes
-git diff fabric-items/semantic-models/Sales.SemanticModel/model.tmdl
-```
-
-## Notebook Source Control
-
-### Notebook Format
-
-```
-Transform.Notebook/
-├── notebook-content.py     # Main code
-└── .platform               # Metadata
-```
-
-### Export Notebook
-
-```bash
-fab export "Dev.Workspace/Transform.Notebook" -o ./fabric-items/notebooks/ -f
-```
-
-### Edit Notebooks Locally
-
-You can edit the `.py` file directly and re-import:
-
-```bash
-# Edit locally
-code ./fabric-items/notebooks/Transform.Notebook/notebook-content.py
-
-# Import changes
-fab import "Dev.Workspace/Transform.Notebook" -i ./fabric-items/notebooks/Transform.Notebook -f
-```
-
-## Data Pipeline Source Control
-
-### Pipeline Format
-
-```
-ETL-Daily.DataPipeline/
-├── pipeline-content.json   # Pipeline definition
-└── .platform               # Metadata
-```
-
-### Export and Track
-
-```bash
-# Export
-fab export "Dev.Workspace/ETL-Daily.DataPipeline" -o ./fabric-items/pipelines/ -f
-
-# View changes
-git diff fabric-items/pipelines/ETL-Daily.DataPipeline/pipeline-content.json
-```
-
-## .gitignore Configuration
-
-```gitignore
-# Fabric CLI
-.config/fab/
-*.log
-
-# Temporary exports
-temp-export/
-backup/
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# IDE
-.vscode/
-.idea/
-
-# Don't ignore Fabric items
-!fabric-items/
-```
-
-## Branching Strategy
-
-### GitFlow for Fabric
-
-```
-main (production)
-  │
-  ├── develop (integration)
-  │     │
-  │     ├── feature/new-report
-  │     ├── feature/update-model
-  │     └── bugfix/pipeline-fix
-  │
-  └── release/v1.2
-```
-
-### Branch Protection Rules
-
-For `main` branch:
-- Require pull request reviews
-- Require status checks (deployment validation)
-- No direct pushes
-
-## Automated Sync Workflow
-
-### GitHub Action: Daily Sync from Fabric
-
-```yaml
-name: Sync from Fabric
-
-on:
-  schedule:
-    - cron: '0 6 * * *'  # Daily at 6 AM
-  workflow_dispatch:
-
-jobs:
-  sync:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup
-        run: pip install ms-fabric-cli
-
-      - name: Authenticate
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: fab auth login --service-principal
-
-      - name: Export from Fabric
-        run: fab export "Dev.Workspace" -o ./fabric-items/ -a -f
-
-      - name: Commit changes
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add ./fabric-items/
-          if git diff --staged --quiet; then
-            echo "No changes"
-          else
-            git commit -m "Sync from Fabric $(date +%Y-%m-%d)"
-            git push
-          fi
-```
-
-## Conflict Resolution
-
-### When Git and Fabric Diverge
-
-```bash
-# 1. Export current Fabric state
-fab export "Dev.Workspace" -o ./fabric-export/ -a -f
-
-# 2. Compare with Git
-diff -r ./fabric-items/ ./fabric-export/
-
-# 3. Decide which version to keep
-# Option A: Keep Git version (deploy to Fabric)
-fab import "Dev.Workspace/Item.Type" -i ./fabric-items/Item.Type -f
-
-# Option B: Keep Fabric version (update Git)
-cp -r ./fabric-export/Item.Type ./fabric-items/
-git add ./fabric-items/Item.Type
-git commit -m "Update from Fabric"
-```
-
-### Merge Conflicts in TMDL
-
-When merging branches with TMDL changes:
-
-```bash
-# Pull with rebase
-git pull --rebase origin main
-
-# If conflicts in .tmdl files:
-# 1. Open conflicted file
-# 2. Choose correct version (usually keep both measures/columns)
-# 3. Validate syntax
-
-# After resolving
-git add .
-git rebase --continue
-```
-
-## Best Practices
-
-### Do's
-
-- Export items after significant changes
-- Use meaningful commit messages
-- Review TMDL changes in PRs
-- Keep Git as source of truth for production
-- Use branches for new features
-- Automate sync with scheduled exports
-
-### Don'ts
-
-- Do not edit production items directly (bypass Git)
-- Do not commit secrets or connection strings
-- Do not force push to main branch
-- Do not ignore merge conflicts
-- Do not mix multiple unrelated changes in one commit
diff --git a/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md b/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md
deleted file mode 100644
index 7b4415c0b..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/references/github-actions.md
+++ /dev/null
@@ -1,362 +0,0 @@
-# GitHub Actions for Fabric CLI
-
-Complete workflow examples for deploying Microsoft Fabric items using GitHub Actions.
-
-## Basic Deployment Workflow
-
-```yaml
-name: Deploy Fabric Items
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'fabric-items/**'
-  workflow_dispatch:
-    inputs:
-      environment:
-        description: 'Target environment'
-        required: true
-        default: 'dev'
-        type: choice
-        options:
-          - dev
-          - test
-          - prod
-
-env:
-  PYTHON_VERSION: '3.11'
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    environment: ${{ github.event.inputs.environment || 'dev' }}
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-
-      - name: Install Fabric CLI
-        run: pip install ms-fabric-cli
-
-      - name: Authenticate with Service Principal
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: |
-          fab auth login --service-principal
-          fab auth status
-
-      - name: Deploy items
-        env:
-          TARGET_WORKSPACE: ${{ vars.FABRIC_WORKSPACE }}
-        run: |
-          fab import "$TARGET_WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-          fab import "$TARGET_WORKSPACE/Notebook.Notebook" -i ./fabric-items/Notebook.Notebook -f
-```
-
-## Federated Credential Workflow (No Secrets)
-
-```yaml
-name: Deploy with Federated Credential
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  id-token: write  # Required for federated credential
-  contents: read
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    environment: production
-    
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Fabric CLI
-        run: pip install ms-fabric-cli
-
-      - name: Azure Login with OIDC
-        uses: azure/login@v2
-        with:
-          client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-      - name: Get Federated Token
-        run: |
-          TOKEN=$(az account get-access-token --resource https://analysis.windows.net/powerbi/api --query accessToken -o tsv)
-          echo "FAB_SPN_FEDERATED_TOKEN=$TOKEN" >> $GITHUB_ENV
-
-      - name: Authenticate Fabric CLI
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-        run: |
-          fab auth login --service-principal --federated
-          fab auth status
-
-      - name: Deploy
-        run: |
-          fab import "Prod.Workspace/Item.Type" -i ./fabric-items/Item.Type -f
-```
-
-## Multi-Environment Deployment
-
-```yaml
-name: Multi-Environment Deploy
-
-on:
-  workflow_dispatch:
-    inputs:
-      environment:
-        description: 'Target environment'
-        required: true
-        type: choice
-        options:
-          - dev
-          - test
-          - prod
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    environment: ${{ github.event.inputs.environment }}
-    
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Setup
-        run: |
-          pip install ms-fabric-cli
-          
-      - name: Authenticate
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: fab auth login --service-principal
-
-      - name: Set workspace based on environment
-        run: |
-          case "${{ github.event.inputs.environment }}" in
-            dev)  echo "WORKSPACE=Development.Workspace" >> $GITHUB_ENV ;;
-            test) echo "WORKSPACE=Testing.Workspace" >> $GITHUB_ENV ;;
-            prod) echo "WORKSPACE=Production.Workspace" >> $GITHUB_ENV ;;
-          esac
-
-      - name: Deploy to ${{ github.event.inputs.environment }}
-        run: |
-          echo "Deploying to $WORKSPACE"
-          fab import "$WORKSPACE/Pipeline.DataPipeline" -i ./fabric-items/Pipeline.DataPipeline -f
-```
-
-## Deploy Changed Items Only
-
-```yaml
-name: Deploy Changed Items
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'fabric-items/**'
-
-jobs:
-  deploy-changes:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 2  # Need previous commit for diff
-
-      - name: Setup Fabric CLI
-        run: pip install ms-fabric-cli
-
-      - name: Authenticate
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: fab auth login --service-principal
-
-      - name: Get changed items
-        id: changes
-        run: |
-          CHANGED=$(git diff --name-only HEAD~1 -- fabric-items/ | grep -E '\.(DataPipeline|Notebook|SemanticModel)/' | xargs -I {} dirname {} | sort -u)
-          echo "changed=$CHANGED" >> $GITHUB_OUTPUT
-          echo "Changed items: $CHANGED"
-
-      - name: Deploy changed items
-        env:
-          TARGET_WORKSPACE: ${{ vars.FABRIC_WORKSPACE }}
-        run: |
-          for ITEM_PATH in ${{ steps.changes.outputs.changed }}; do
-            ITEM_NAME=$(basename "$ITEM_PATH")
-            echo "Deploying $ITEM_NAME..."
-            fab import "$TARGET_WORKSPACE/$ITEM_NAME" -i "$ITEM_PATH" -f
-          done
-```
-
-## Matrix Deployment (Multiple Workspaces)
-
-```yaml
-name: Matrix Deploy
-
-on:
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        workspace:
-          - name: Sales
-            path: sales-items
-          - name: Marketing
-            path: marketing-items
-          - name: Finance
-            path: finance-items
-      fail-fast: false
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup and Auth
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: |
-          pip install ms-fabric-cli
-          fab auth login --service-principal
-
-      - name: Deploy to ${{ matrix.workspace.name }}
-        run: |
-          for ITEM in ./fabric-items/${{ matrix.workspace.path }}/*; do
-            ITEM_NAME=$(basename "$ITEM")
-            fab import "${{ matrix.workspace.name }}.Workspace/$ITEM_NAME" -i "$ITEM" -f
-          done
-```
-
-## Export and Commit Workflow
-
-```yaml
-name: Export Fabric Items
-
-on:
-  schedule:
-    - cron: '0 6 * * *'  # Daily at 6 AM UTC
-  workflow_dispatch:
-
-jobs:
-  export:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: |
-          pip install ms-fabric-cli
-          fab auth login --service-principal
-
-      - name: Export workspace items
-        run: |
-          fab export "Production.Workspace" -o ./fabric-items/ -a -f
-
-      - name: Commit changes
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add ./fabric-items/
-          if git diff --staged --quiet; then
-            echo "No changes to commit"
-          else
-            git commit -m "Auto-export Fabric items $(date +%Y-%m-%d)"
-            git push
-          fi
-```
-
-## Post-Deployment Validation
-
-```yaml
-name: Deploy with Validation
-
-on:
-  push:
-    branches: [main]
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup and Auth
-        env:
-          FAB_SPN_TENANT_ID: ${{ secrets.FABRIC_TENANT_ID }}
-          FAB_SPN_CLIENT_ID: ${{ secrets.FABRIC_CLIENT_ID }}
-          FAB_SPN_CLIENT_SECRET: ${{ secrets.FABRIC_CLIENT_SECRET }}
-        run: |
-          pip install ms-fabric-cli
-          fab auth login --service-principal
-
-      - name: Deploy items
-        run: |
-          fab import "Prod.Workspace/ETL.DataPipeline" -i ./fabric-items/ETL.DataPipeline -f
-
-      - name: Validate deployment
-        run: |
-          # Verify item exists
-          fab exists "Prod.Workspace/ETL.DataPipeline" || exit 1
-          
-          # Run post-deployment test
-          fab job run "Prod.Workspace/Validation.Notebook" --timeout 300
-          
-          echo "Deployment validated successfully"
-
-      - name: Notify on failure
-        if: failure()
-        run: |
-          echo "::error::Deployment validation failed"
-```
-
-## Required Secrets Configuration
-
-Set these secrets in your repository settings:
-
-| Secret Name | Description |
-|-------------|-------------|
-| `FABRIC_TENANT_ID` | Azure AD tenant ID |
-| `FABRIC_CLIENT_ID` | Service principal client ID |
-| `FABRIC_CLIENT_SECRET` | Service principal secret |
-
-## Required Variables Configuration
-
-Set these variables per environment:
-
-| Variable Name | Description | Example |
-|---------------|-------------|---------|
-| `FABRIC_WORKSPACE` | Target workspace name | `Production.Workspace` |
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py b/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
deleted file mode 100644
index d78df7424..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/scripts/deploy.py
+++ /dev/null
@@ -1,380 +0,0 @@
-#!/usr/bin/env python3
-"""
-deploy.py - Deploy items from local folder to workspace
-
-This script deploys Fabric items from a local filesystem (typically an export directory)
-to a target workspace. It supports creating new items and updating existing ones.
-
-Usage:
-    python deploy.py <source> <target-ws> [--dry-run]
-    python deploy.py ./fabric-items/ Production.Workspace
-    python deploy.py ./fabric-items/ Production.Workspace --dry-run
-
-Exit codes:
-    0 - Deployment completed successfully
-    1 - Deployment failed or had errors
-"""
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-
-# Supported item types that can be imported
-IMPORTABLE_ITEM_TYPES = [
-    "Notebook", "SparkJobDefinition", "DataPipeline",
-    "Report", "SemanticModel",
-    "KQLDatabase", "KQLDashboard", "KQLQueryset",
-    "Eventhouse", "Eventstream", "MirroredDatabase",
-    "Reflex", "MountedDataFactory", "CopyJob", "VariableLibrary"
-]
-
-
-def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def check_workspace_exists(workspace: str) -> bool:
-    """Check if workspace exists."""
-    exit_code, _, _ = run_fab_command(["exists", workspace])
-    return exit_code == 0
-
-
-def check_item_exists(item_path: str) -> bool:
-    """Check if an item exists."""
-    exit_code, _, _ = run_fab_command(["exists", item_path])
-    return exit_code == 0
-
-
-def discover_items(source_dir: str) -> List[Dict[str, Any]]:
-    """Discover Fabric items in the source directory."""
-    items = []
-    source_path = Path(source_dir)
-    
-    if not source_path.exists():
-        return items
-    
-    # Look for item directories with type suffixes
-    for entry in source_path.iterdir():
-        if entry.is_dir():
-            # Check if directory name ends with a known item type
-            name = entry.name
-            for item_type in IMPORTABLE_ITEM_TYPES:
-                if name.endswith(f".{item_type}"):
-                    item_name = name[:-len(f".{item_type}")]
-                    items.append({
-                        "name": item_name,
-                        "type": item_type,
-                        "full_name": name,
-                        "source_path": str(entry),
-                        "has_definition": (entry / ".platform").exists() or any(entry.glob("*.json"))
-                    })
-                    break
-    
-    return items
-
-
-def import_item(source_path: str, target_path: str, force: bool = True) -> Dict[str, Any]:
-    """Import an item from local source to target workspace."""
-    result = {
-        "source": source_path,
-        "target": target_path,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Build import command
-    cmd = ["import", target_path, "-i", source_path]
-    if force:
-        cmd.append("-f")
-    
-    exit_code, stdout, stderr = run_fab_command(cmd)
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = "Item imported successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or "Import failed"
-    
-    return result
-
-
-def create_item(workspace: str, item_name: str, item_type: str) -> Dict[str, Any]:
-    """Create a new item in the workspace."""
-    item_path = f"{workspace}/{item_name}.{item_type}"
-    
-    result = {
-        "path": item_path,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["message"] = f"Item '{item_name}.{item_type}' created"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create item"
-    
-    return result
-
-
-def deploy_items(
-    source_dir: str,
-    target_workspace: str,
-    dry_run: bool = False,
-    ignore_errors: bool = False
-) -> Dict[str, Any]:
-    """Deploy items from source directory to target workspace."""
-    
-    target_workspace = ensure_workspace_suffix(target_workspace)
-    
-    report = {
-        "source_directory": source_dir,
-        "target_workspace": target_workspace,
-        "dry_run": dry_run,
-        "items_discovered": [],
-        "deployment_results": [],
-        "summary": {
-            "total_items": 0,
-            "created": 0,
-            "updated": 0,
-            "skipped": 0,
-            "failed": 0
-        }
-    }
-    
-    # Discover items in source directory
-    print(f"\nDiscovering items in: {source_dir}")
-    items = discover_items(source_dir)
-    report["items_discovered"] = items
-    report["summary"]["total_items"] = len(items)
-    
-    if not items:
-        print("No deployable items found in source directory.")
-        print(f"\nExpected format: <item_name>.<ItemType>/ directories")
-        print(f"Supported types: {', '.join(IMPORTABLE_ITEM_TYPES)}")
-        return report
-    
-    print(f"Found {len(items)} item(s) to deploy:")
-    for item in items:
-        print(f"  - {item['full_name']}")
-    
-    if dry_run:
-        print(f"\n[DRY RUN] Would deploy to: {target_workspace}")
-        for item in items:
-            item_path = f"{target_workspace}/{item['full_name']}"
-            exists = check_item_exists(item_path)
-            action = "UPDATE" if exists else "CREATE"
-            print(f"  [{action}] {item['full_name']}")
-        return report
-    
-    # Check workspace exists
-    print(f"\nVerifying workspace: {target_workspace}")
-    if not check_workspace_exists(target_workspace):
-        print(f"Error: Workspace '{target_workspace}' does not exist or is not accessible")
-        sys.exit(1)
-    
-    # Deploy each item
-    print(f"\nDeploying items...")
-    for item in items:
-        item_name = item["name"]
-        item_type = item["type"]
-        full_name = item["full_name"]
-        source_path = item["source_path"]
-        target_path = f"{target_workspace}/{full_name}"
-        
-        print(f"\n  Deploying {full_name}...")
-        
-        deployment_result = {
-            "item": full_name,
-            "source": source_path,
-            "target": target_path,
-            "action": "unknown",
-            "status": "unknown",
-            "message": ""
-        }
-        
-        # Check if item exists
-        exists = check_item_exists(target_path)
-        
-        if exists:
-            # Update existing item via import
-            deployment_result["action"] = "update"
-            print(f"    Item exists, updating...")
-            result = import_item(source_path, target_path)
-            deployment_result["status"] = result["status"]
-            deployment_result["message"] = result["message"]
-            
-            if result["status"] == "success":
-                report["summary"]["updated"] += 1
-                print(f"    ✓ Updated successfully")
-            else:
-                report["summary"]["failed"] += 1
-                print(f"    ✗ Update failed: {result['message']}")
-                if not ignore_errors:
-                    report["deployment_results"].append(deployment_result)
-                    return report
-        else:
-            # Create new item and import definition
-            deployment_result["action"] = "create"
-            print(f"    Creating new item...")
-            
-            # First create the item
-            create_result = create_item(target_workspace, item_name, item_type)
-            
-            if create_result["status"] == "created":
-                # Then import the definition
-                print(f"    Importing definition...")
-                import_result = import_item(source_path, target_path)
-                
-                if import_result["status"] == "success":
-                    deployment_result["status"] = "success"
-                    deployment_result["message"] = "Created and imported successfully"
-                    report["summary"]["created"] += 1
-                    print(f"    ✓ Created and imported successfully")
-                else:
-                    deployment_result["status"] = "partial"
-                    deployment_result["message"] = f"Created but import failed: {import_result['message']}"
-                    report["summary"]["created"] += 1
-                    print(f"    ⚠ Created but import failed: {import_result['message']}")
-            else:
-                deployment_result["status"] = "failed"
-                deployment_result["message"] = create_result["message"]
-                report["summary"]["failed"] += 1
-                print(f"    ✗ Creation failed: {create_result['message']}")
-                
-                if not ignore_errors:
-                    report["deployment_results"].append(deployment_result)
-                    return report
-        
-        report["deployment_results"].append(deployment_result)
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Deploy Fabric items from local folder to workspace",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python deploy.py ./fabric-items/ Production.Workspace
-    python deploy.py ./exports/ Dev.Workspace --dry-run
-    python deploy.py ./fabric-items/ "My Workspace" --ignore-errors
-
-Source Directory Structure:
-    The source directory should contain item folders with type suffixes:
-    
-    ./fabric-items/
-    ├── MyNotebook.Notebook/
-    │   ├── .platform
-    │   └── notebook-content.json
-    ├── SalesReport.Report/
-    │   ├── .platform
-    │   └── definition.pbir
-    └── DataModel.SemanticModel/
-        ├── .platform
-        └── model.bim
-
-Supported Item Types:
-    Notebook, SparkJobDefinition, DataPipeline, Report, SemanticModel,
-    KQLDatabase, KQLDashboard, KQLQueryset, Eventhouse, Eventstream,
-    MirroredDatabase, Reflex, MountedDataFactory, CopyJob, VariableLibrary
-        """
-    )
-    parser.add_argument(
-        "source",
-        help="Source directory containing item exports"
-    )
-    parser.add_argument(
-        "target",
-        help="Target workspace name or path"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview deployment without making changes"
-    )
-    parser.add_argument(
-        "--ignore-errors",
-        action="store_true",
-        help="Continue deployment even if individual items fail"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    # Validate source directory
-    if not os.path.isdir(args.source):
-        print(f"Error: Source directory '{args.source}' does not exist", file=sys.stderr)
-        sys.exit(1)
-    
-    try:
-        report = deploy_items(
-            source_dir=args.source,
-            target_workspace=args.target,
-            dry_run=args.dry_run,
-            ignore_errors=args.ignore_errors
-        )
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("DEPLOYMENT SUMMARY")
-        print("=" * 50)
-        print(f"Source: {report['source_directory']}")
-        print(f"Target: {report['target_workspace']}")
-        print(f"Dry Run: {report['dry_run']}")
-        print(f"\nResults:")
-        print(f"  Total Items: {report['summary']['total_items']}")
-        print(f"  Created: {report['summary']['created']}")
-        print(f"  Updated: {report['summary']['updated']}")
-        print(f"  Skipped: {report['summary']['skipped']}")
-        print(f"  Failed: {report['summary']['failed']}")
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        # Exit code based on failures
-        sys.exit(0 if report['summary']['failed'] == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py b/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
deleted file mode 100644
index f802353db..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/scripts/diff_definitions.py
+++ /dev/null
@@ -1,394 +0,0 @@
-#!/usr/bin/env python3
-"""
-diff_definitions.py - Compare item definitions between environments
-
-This script compares Fabric item definitions between two sources (workspaces or
-local exports) and outputs the differences.
-
-Usage:
-    python diff_definitions.py <item1> <item2>
-    python diff_definitions.py Dev.Workspace/Model.SemanticModel Prod.Workspace/Model.SemanticModel
-    python diff_definitions.py ./local-export/Model.SemanticModel Prod.Workspace/Model.SemanticModel
-
-Exit codes:
-    0 - Items are identical
-    1 - Items are different or error occurred
-"""
-
-import argparse
-import difflib
-import json
-import os
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-from typing import Dict, Any, List, Optional, Tuple
-
-
-def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def is_local_path(path: str) -> bool:
-    """Check if path is a local filesystem path."""
-    # Local paths start with . or / or drive letter
-    return path.startswith((".", "/", "\\")) or (len(path) > 1 and path[1] == ":")
-
-
-def get_item_type_from_path(path: str) -> Optional[str]:
-    """Extract item type from path."""
-    item_types = [
-        "Workspace", "Lakehouse", "Warehouse", "SemanticModel", "Report",
-        "Notebook", "SparkJobDefinition", "DataPipeline", "KQLDatabase",
-        "KQLDashboard", "KQLQueryset", "Eventhouse", "Eventstream",
-        "MirroredDatabase", "Reflex", "MountedDataFactory", "CopyJob"
-    ]
-    
-    for item_type in item_types:
-        if path.endswith(f".{item_type}"):
-            return item_type
-        if f".{item_type}/" in path or f".{item_type}\\" in path:
-            return item_type
-    
-    return None
-
-
-def export_item_definition(item_path: str, output_dir: str) -> Tuple[bool, str]:
-    """Export item definition from Fabric to local directory."""
-    exit_code, stdout, stderr = run_fab_command([
-        "export", item_path, "-d", output_dir, "-f", "json"
-    ])
-    
-    if exit_code == 0:
-        return True, output_dir
-    return False, stderr
-
-
-def load_local_definition(local_path: str) -> Dict[str, Any]:
-    """Load item definition from local path."""
-    result = {
-        "path": local_path,
-        "files": {},
-        "metadata": {}
-    }
-    
-    path = Path(local_path)
-    
-    if not path.exists():
-        return {"error": f"Path does not exist: {local_path}"}
-    
-    if path.is_file():
-        # Single file comparison
-        with open(path, "r", encoding="utf-8") as f:
-            content = f.read()
-        result["files"][path.name] = content
-        return result
-    
-    # Directory - load all relevant files
-    for file_path in path.rglob("*"):
-        if file_path.is_file():
-            rel_path = str(file_path.relative_to(path))
-            
-            # Skip certain files
-            if any(skip in rel_path for skip in [".git", "__pycache__", ".DS_Store"]):
-                continue
-            
-            try:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    content = f.read()
-                result["files"][rel_path] = content
-            except UnicodeDecodeError:
-                # Binary file - store hash or skip
-                result["files"][rel_path] = f"<binary file: {file_path.stat().st_size} bytes>"
-    
-    # Load metadata if exists
-    platform_file = path / ".platform"
-    if platform_file.exists():
-        try:
-            with open(platform_file, "r", encoding="utf-8") as f:
-                result["metadata"]["platform"] = json.load(f)
-        except (json.JSONDecodeError, UnicodeDecodeError):
-            pass
-    
-    return result
-
-
-def get_definition(source: str, temp_dir: str) -> Tuple[Dict[str, Any], str]:
-    """Get item definition from source (local path or Fabric path)."""
-    if is_local_path(source):
-        definition = load_local_definition(source)
-        return definition, source
-    else:
-        # Export from Fabric to temp directory
-        item_name = source.split("/")[-1] if "/" in source else source
-        export_path = os.path.join(temp_dir, item_name.replace(".", "_"))
-        
-        success, result = export_item_definition(source, export_path)
-        if success:
-            definition = load_local_definition(export_path)
-            return definition, export_path
-        else:
-            return {"error": result}, ""
-
-
-def normalize_json_content(content: str) -> str:
-    """Normalize JSON content for comparison (sort keys, consistent formatting)."""
-    try:
-        data = json.loads(content)
-        # Remove volatile fields
-        volatile_fields = ["lastModifiedTime", "modifiedDateTime", "createdDateTime", "id"]
-        
-        def remove_volatile(obj):
-            if isinstance(obj, dict):
-                return {k: remove_volatile(v) for k, v in obj.items() if k not in volatile_fields}
-            elif isinstance(obj, list):
-                return [remove_volatile(item) for item in obj]
-            return obj
-        
-        cleaned = remove_volatile(data)
-        return json.dumps(cleaned, indent=2, sort_keys=True)
-    except json.JSONDecodeError:
-        return content
-
-
-def compare_definitions(def1: Dict[str, Any], def2: Dict[str, Any], 
-                       ignore_metadata: bool = False) -> Dict[str, Any]:
-    """Compare two item definitions."""
-    result = {
-        "identical": True,
-        "differences": [],
-        "only_in_source1": [],
-        "only_in_source2": [],
-        "modified_files": []
-    }
-    
-    if "error" in def1:
-        return {"error": f"Source 1 error: {def1['error']}"}
-    if "error" in def2:
-        return {"error": f"Source 2 error: {def2['error']}"}
-    
-    files1 = def1.get("files", {})
-    files2 = def2.get("files", {})
-    
-    all_files = set(files1.keys()) | set(files2.keys())
-    
-    for file_name in sorted(all_files):
-        # Skip metadata files if requested
-        if ignore_metadata and file_name in [".platform", "item.metadata.json"]:
-            continue
-        
-        content1 = files1.get(file_name)
-        content2 = files2.get(file_name)
-        
-        if content1 is None:
-            result["only_in_source2"].append(file_name)
-            result["identical"] = False
-        elif content2 is None:
-            result["only_in_source1"].append(file_name)
-            result["identical"] = False
-        else:
-            # Normalize JSON files for comparison
-            if file_name.endswith(".json"):
-                content1_normalized = normalize_json_content(content1)
-                content2_normalized = normalize_json_content(content2)
-            else:
-                content1_normalized = content1
-                content2_normalized = content2
-            
-            if content1_normalized != content2_normalized:
-                result["identical"] = False
-                result["modified_files"].append(file_name)
-                
-                # Generate diff
-                diff = list(difflib.unified_diff(
-                    content1_normalized.splitlines(keepends=True),
-                    content2_normalized.splitlines(keepends=True),
-                    fromfile=f"source1/{file_name}",
-                    tofile=f"source2/{file_name}",
-                    lineterm=""
-                ))
-                
-                result["differences"].append({
-                    "file": file_name,
-                    "diff": "".join(diff)
-                })
-    
-    return result
-
-
-def print_comparison_report(result: Dict[str, Any], source1: str, source2: str,
-                           output_format: str, output_file: Optional[str] = None):
-    """Print comparison report."""
-    if output_format == "json":
-        report = {
-            "source1": source1,
-            "source2": source2,
-            **result
-        }
-        output = json.dumps(report, indent=2)
-    else:
-        # Text format
-        lines = []
-        lines.append("=" * 70)
-        lines.append("ITEM DEFINITION COMPARISON")
-        lines.append("=" * 70)
-        lines.append(f"Source 1: {source1}")
-        lines.append(f"Source 2: {source2}")
-        lines.append("")
-        
-        if "error" in result:
-            lines.append(f"ERROR: {result['error']}")
-        else:
-            if result["identical"]:
-                lines.append("RESULT: Items are IDENTICAL")
-            else:
-                lines.append("RESULT: Items are DIFFERENT")
-                lines.append("")
-                
-                if result["only_in_source1"]:
-                    lines.append("Files only in source 1:")
-                    for f in result["only_in_source1"]:
-                        lines.append(f"  - {f}")
-                    lines.append("")
-                
-                if result["only_in_source2"]:
-                    lines.append("Files only in source 2:")
-                    for f in result["only_in_source2"]:
-                        lines.append(f"  + {f}")
-                    lines.append("")
-                
-                if result["modified_files"]:
-                    lines.append("Modified files:")
-                    for f in result["modified_files"]:
-                        lines.append(f"  ~ {f}")
-                    lines.append("")
-                
-                if result["differences"]:
-                    lines.append("-" * 70)
-                    lines.append("DETAILED DIFFERENCES:")
-                    lines.append("-" * 70)
-                    for diff_info in result["differences"]:
-                        lines.append(f"\n{diff_info['file']}:")
-                        lines.append(diff_info["diff"])
-        
-        lines.append("")
-        lines.append("=" * 70)
-        output = "\n".join(lines)
-    
-    if output_file:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.write(output)
-        print(f"Report written to: {output_file}", file=sys.stderr)
-    else:
-        print(output)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Compare item definitions between environments",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    # Compare items between workspaces
-    python diff_definitions.py Dev.Workspace/Model.SemanticModel Prod.Workspace/Model.SemanticModel
-    
-    # Compare local export to workspace
-    python diff_definitions.py ./exports/Model.SemanticModel Production.Workspace/Model.SemanticModel
-    
-    # Compare two local exports
-    python diff_definitions.py ./dev-export/Model.SemanticModel ./prod-export/Model.SemanticModel
-    
-    # Output as JSON
-    python diff_definitions.py Dev.Workspace/Model Prod.Workspace/Model -f json -o diff.json
-        """
-    )
-    
-    parser.add_argument(
-        "source1",
-        help="First item path (workspace path or local directory)"
-    )
-    
-    parser.add_argument(
-        "source2",
-        help="Second item path (workspace path or local directory)"
-    )
-    
-    parser.add_argument(
-        "-f", "--format",
-        choices=["text", "json"],
-        default="text",
-        help="Output format (default: text)"
-    )
-    
-    parser.add_argument(
-        "-o", "--output",
-        help="Output file path (default: stdout)"
-    )
-    
-    parser.add_argument(
-        "--ignore-metadata",
-        action="store_true",
-        help="Ignore metadata files (.platform, item.metadata.json) in comparison"
-    )
-    
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Enable verbose output"
-    )
-    
-    args = parser.parse_args()
-    
-    # Create temp directory for exports
-    with tempfile.TemporaryDirectory() as temp_dir:
-        if args.verbose:
-            print(f"Using temp directory: {temp_dir}", file=sys.stderr)
-        
-        # Get definitions
-        if args.verbose:
-            print(f"Loading source 1: {args.source1}", file=sys.stderr)
-        def1, path1 = get_definition(args.source1, os.path.join(temp_dir, "source1"))
-        
-        if args.verbose:
-            print(f"Loading source 2: {args.source2}", file=sys.stderr)
-        def2, path2 = get_definition(args.source2, os.path.join(temp_dir, "source2"))
-        
-        # Compare
-        if args.verbose:
-            print("Comparing definitions...", file=sys.stderr)
-        comparison = compare_definitions(def1, def2, ignore_metadata=args.ignore_metadata)
-        
-        # Output report
-        print_comparison_report(comparison, args.source1, args.source2, args.format, args.output)
-        
-        # Return exit code
-        if "error" in comparison:
-            return 1
-        return 0 if comparison.get("identical", False) else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py b/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
deleted file mode 100644
index 371e7cc19..000000000
--- a/.ai-assets/skills/fabric-cli-cicd/scripts/export_workspace.py
+++ /dev/null
@@ -1,372 +0,0 @@
-#!/usr/bin/env python3
-"""
-export_workspace.py - Export all workspace items for version control
-
-This script exports all items from a Microsoft Fabric workspace to a local directory
-in a format suitable for Git version control.
-
-Usage:
-    python export_workspace.py <workspace> -o <dir>
-    python export_workspace.py Dev.Workspace -o ./fabric-exports/
-
-Exit codes:
-    0 - Export completed successfully
-    1 - Export failed or had errors
-"""
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, List
-
-
-# Item types that support export
-EXPORTABLE_ITEM_TYPES = [
-    "Notebook", "SparkJobDefinition", "DataPipeline",
-    "Report", "SemanticModel", "PaginatedReport",
-    "KQLDatabase", "KQLDashboard", "KQLQueryset",
-    "Eventhouse", "Eventstream", "MirroredDatabase",
-    "Reflex", "MountedDataFactory", "CopyJob", "VariableLibrary",
-    "Environment", "MLModel", "MLExperiment"
-]
-
-
-def run_fab_command(args: list[str], timeout: int = 300) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def check_workspace_exists(workspace: str) -> bool:
-    """Check if workspace exists."""
-    exit_code, _, _ = run_fab_command(["exists", workspace])
-    return exit_code == 0
-
-
-def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
-    """Get all items in the workspace."""
-    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        try:
-            result = json.loads(stdout.strip())
-            if isinstance(result, list):
-                return result
-        except json.JSONDecodeError:
-            pass
-    
-    return []
-
-
-def get_workspace_details(workspace: str) -> Dict[str, Any]:
-    """Get workspace metadata."""
-    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        try:
-            return json.loads(stdout.strip())
-        except json.JSONDecodeError:
-            pass
-    
-    return {}
-
-
-def export_item(item_path: str, output_dir: str) -> Dict[str, Any]:
-    """Export a single item to the output directory."""
-    result = {
-        "item": item_path,
-        "output_dir": output_dir,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Build export command
-    cmd = ["export", item_path, "-o", output_dir, "-f"]
-    
-    exit_code, stdout, stderr = run_fab_command(cmd)
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = "Exported successfully"
-    else:
-        # Check if export is not supported for this item type
-        if "not supported" in stderr.lower() or "cannot export" in stderr.lower():
-            result["status"] = "skipped"
-            result["message"] = "Export not supported for this item type"
-        else:
-            result["status"] = "failed"
-            result["message"] = stderr.strip() or "Export failed"
-    
-    return result
-
-
-def generate_manifest(
-    workspace: str,
-    workspace_details: Dict[str, Any],
-    items: List[Dict[str, Any]],
-    export_results: List[Dict[str, Any]]
-) -> Dict[str, Any]:
-    """Generate manifest.json with workspace metadata."""
-    
-    successful_exports = [r for r in export_results if r["status"] == "success"]
-    
-    manifest = {
-        "manifest_version": "1.0.0",
-        "export_metadata": {
-            "exported_at": datetime.utcnow().isoformat() + "Z",
-            "source_workspace": workspace,
-            "workspace_id": workspace_details.get("id"),
-            "capacity_id": workspace_details.get("capacityId"),
-            "total_items": len(items),
-            "exported_items": len(successful_exports)
-        },
-        "workspace_info": {
-            "name": workspace_details.get("displayName", workspace.replace(".Workspace", "")),
-            "id": workspace_details.get("id"),
-            "description": workspace_details.get("description", ""),
-            "type": workspace_details.get("type")
-        },
-        "items": []
-    }
-    
-    for result in export_results:
-        if result["status"] == "success":
-            manifest["items"].append({
-                "path": result["item"],
-                "name": result.get("name", ""),
-                "type": result.get("type", ""),
-                "status": "exported"
-            })
-    
-    return manifest
-
-
-def export_workspace(
-    workspace: str,
-    output_dir: str,
-    include_unsupported: bool = False
-) -> Dict[str, Any]:
-    """Export all workspace items to the output directory."""
-    
-    workspace = ensure_workspace_suffix(workspace)
-    
-    report = {
-        "workspace": workspace,
-        "output_directory": output_dir,
-        "items_found": [],
-        "export_results": [],
-        "summary": {
-            "total_items": 0,
-            "exported": 0,
-            "skipped": 0,
-            "failed": 0,
-            "not_supported": 0
-        }
-    }
-    
-    # Verify workspace exists
-    print(f"\nVerifying workspace: {workspace}")
-    if not check_workspace_exists(workspace):
-        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
-        return report
-    print("  Workspace found")
-    
-    # Get workspace details
-    print("\nFetching workspace details...")
-    workspace_details = get_workspace_details(workspace)
-    
-    # Get all items
-    print("Fetching workspace items...")
-    items = get_workspace_items(workspace)
-    report["items_found"] = items
-    report["summary"]["total_items"] = len(items)
-    
-    if not items:
-        print("No items found in workspace")
-        return report
-    
-    print(f"  Found {len(items)} item(s)")
-    
-    # Group items by type for display
-    items_by_type = {}
-    for item in items:
-        item_type = item.get("type", "Unknown")
-        if item_type not in items_by_type:
-            items_by_type[item_type] = []
-        items_by_type[item_type].append(item)
-    
-    print("\n  Items by type:")
-    for item_type, type_items in sorted(items_by_type.items()):
-        print(f"    {item_type}: {len(type_items)}")
-    
-    # Create output directory
-    output_path = Path(output_dir)
-    output_path.mkdir(parents=True, exist_ok=True)
-    print(f"\nExporting to: {output_dir}")
-    
-    # Export each item
-    print("\nExporting items...")
-    for item in items:
-        item_name = item.get("displayName", item.get("name", "Unknown"))
-        item_type = item.get("type", "Unknown")
-        item_id = item.get("id", "")
-        full_name = f"{item_name}.{item_type}"
-        item_path = f"{workspace}/{full_name}"
-        
-        export_result = {
-            "item": item_path,
-            "name": item_name,
-            "type": item_type,
-            "id": item_id,
-            "status": "unknown",
-            "message": ""
-        }
-        
-        # Check if item type is exportable
-        if item_type not in EXPORTABLE_ITEM_TYPES and not include_unsupported:
-            export_result["status"] = "not_supported"
-            export_result["message"] = f"Item type '{item_type}' export not supported"
-            report["export_results"].append(export_result)
-            report["summary"]["not_supported"] += 1
-            print(f"  [{item_type}] {item_name}: skipped (not supported)")
-            continue
-        
-        print(f"  [{item_type}] {item_name}...")
-        
-        result = export_item(item_path, output_dir)
-        export_result["status"] = result["status"]
-        export_result["message"] = result["message"]
-        report["export_results"].append(export_result)
-        
-        if result["status"] == "success":
-            report["summary"]["exported"] += 1
-            print(f"    ✓ Exported")
-        elif result["status"] == "skipped":
-            report["summary"]["skipped"] += 1
-            print(f"    - Skipped: {result['message']}")
-        else:
-            report["summary"]["failed"] += 1
-            print(f"    ✗ Failed: {result['message']}")
-    
-    # Generate manifest
-    print("\nGenerating manifest.json...")
-    manifest = generate_manifest(workspace, workspace_details, items, report["export_results"])
-    manifest_path = output_path / "manifest.json"
-    
-    with open(manifest_path, "w", encoding="utf-8") as f:
-        json.dump(manifest, f, indent=2)
-    
-    print(f"  Manifest saved: {manifest_path}")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Export all workspace items for version control",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python export_workspace.py Dev.Workspace -o ./fabric-exports/
-    python export_workspace.py Production.Workspace -o ./exports/prod/
-    python export_workspace.py "My Workspace" -o ./my-workspace-export/
-
-Output Structure:
-    <output-dir>/
-    ├── manifest.json           # Export metadata and item list
-    ├── MyNotebook.Notebook/    # Exported item folders
-    │   ├── .platform
-    │   └── notebook-content.json
-    ├── SalesReport.Report/
-    │   ├── .platform
-    │   └── definition.pbir
-    └── DataModel.SemanticModel/
-        ├── .platform
-        └── model.bim
-
-Supported Item Types:
-    Notebook, SparkJobDefinition, DataPipeline, Report, SemanticModel,
-    PaginatedReport, KQLDatabase, KQLDashboard, KQLQueryset, Eventhouse,
-    Eventstream, MirroredDatabase, Reflex, MountedDataFactory, CopyJob,
-    VariableLibrary, Environment, MLModel, MLExperiment
-        """
-    )
-    parser.add_argument(
-        "workspace",
-        help="Workspace name or path to export"
-    )
-    parser.add_argument(
-        "-o", "--output",
-        required=True,
-        help="Output directory for exported items"
-    )
-    parser.add_argument(
-        "--include-unsupported",
-        action="store_true",
-        help="Attempt to export items even if type is not officially supported"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        report = export_workspace(
-            workspace=args.workspace,
-            output_dir=args.output,
-            include_unsupported=args.include_unsupported
-        )
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("EXPORT SUMMARY")
-        print("=" * 50)
-        print(f"Workspace: {report['workspace']}")
-        print(f"Output Directory: {report['output_directory']}")
-        print(f"\nResults:")
-        print(f"  Total Items: {report['summary']['total_items']}")
-        print(f"  Exported: {report['summary']['exported']}")
-        print(f"  Skipped: {report['summary']['skipped']}")
-        print(f"  Failed: {report['summary']['failed']}")
-        print(f"  Not Supported: {report['summary']['not_supported']}")
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        # Exit code based on failures
-        sys.exit(0 if report['summary']['failed'] == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/README.md b/.ai-assets/skills/fabric-cli-dataengineering/README.md
deleted file mode 100644
index abf2d55f2..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/README.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# Fabric CLI Data Engineering Skill
-
-Task-specific instructions for AI agents helping users with Microsoft Fabric data engineering operations.
-
-## Overview
-
-This skill provides guidance for:
-
-- **Lakehouse & Warehouse** — Creating and managing data stores
-- **Table Operations** — Load, optimize, vacuum Delta tables
-- **Shortcuts** — Data federation with OneLake, ADLS, S3
-- **Medallion Architecture** — Bronze/silver/gold layer patterns
-- **Spark Jobs** — Notebook and pipeline execution
-
-## When to Load
-
-Load this skill when the user's task involves:
-
-- Creating lakehouses or warehouses
-- Managing files in OneLake
-- Loading data into Delta tables
-- Optimizing table performance
-- Creating data shortcuts
-- Running Spark notebooks or jobs
-- Building ETL/ELT pipelines
-- Implementing medallion architecture
-
-## Files
-
-| File | Description |
-|------|-------------|
-| [SKILL.md](./SKILL.md) | Main skill definition (load this) |
-| [references/](./references/) | Detailed reference documentation |
-
-## Scripts
-
-Automation scripts for data engineering tasks:
-
-| Script | Description | Usage |
-|--------|-------------|-------|
-| `setup_medallion.py` | Create medallion architecture (bronze/silver/gold) | `python scripts/setup_medallion.py <workspace> [--prefix NAME]` |
-| `optimize_tables.py` | Run optimization on lakehouse tables | `python scripts/optimize_tables.py <lakehouse> [--vorder]` |
-| `validate_shortcuts.py` | Verify all shortcuts are accessible | `python scripts/validate_shortcuts.py <lakehouse>` |
-
-## Quick Reference
-
-### Common Commands
-
-```bash
-# Create lakehouse
-fab mkdir "Workspace.Workspace/DataLake.Lakehouse"
-
-# Upload files
-fab cp ./data.csv "Workspace.Workspace/LH.Lakehouse/Files/raw/"
-
-# Load table
-fab table load "Workspace.Workspace/LH.Lakehouse/Tables/customers" \
-  --file "Workspace.Workspace/LH.Lakehouse/Files/raw/customers"
-
-# Optimize table
-fab table optimize "Workspace.Workspace/LH.Lakehouse/Tables/sales" --vorder
-
-# Run notebook
-fab job run "Workspace.Workspace/ETL.Notebook" --timeout 600
-```
-
-## Dependencies
-
-- Requires `fabric-cli-core` skill loaded first
-- Contributor or higher role for data operations
-- Appropriate capacity for Spark workloads
-
-## References
-
-- [Lakehouse Overview](https://learn.microsoft.com/fabric/data-engineering/lakehouse-overview)
-- [Delta Lake in Fabric](https://learn.microsoft.com/fabric/data-engineering/delta-lake-interoperability)
-- [OneLake Shortcuts](https://learn.microsoft.com/fabric/onelake/onelake-shortcuts)
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md b/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md
deleted file mode 100644
index 02444d14f..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/SKILL.md
+++ /dev/null
@@ -1,535 +0,0 @@
----
-name: fabric-cli-dataengineering
-description: Use Fabric CLI for data engineering — lakehouses, warehouses, shortcuts, table optimization, medallion architecture, and Spark jobs. Activate when users work with data storage, ETL patterns, Delta tables, or data pipeline orchestration.
----
-
-# Fabric CLI Data Engineering
-
-Expert guidance for data engineering operations in Microsoft Fabric using the `fab` CLI.
-
-## When to Use This Skill
-
-Activate automatically when tasks involve:
-
-- Creating and managing Lakehouses or Warehouses
-- Building medallion architecture (bronze/silver/gold layers)
-- Creating and managing OneLake shortcuts
-- Table operations (load, optimize, vacuum)
-- Spark job configuration and execution
-- Data pipeline orchestration
-- Delta table management
-
-## Prerequisites
-
-- Load `fabric-cli-core` skill first for foundational CLI guidance
-- User must be authenticated: `fab auth status`
-- Contributor or higher role for data operations
-
-## Automation Scripts
-
-Ready-to-use Python scripts for data engineering tasks. Run any script with `--help` for full options.
-
-| Script | Purpose | Usage |
-|--------|---------|-------|
-| `setup_medallion.py` | Create medallion architecture (bronze/silver/gold) | `python scripts/setup_medallion.py <workspace> [--prefix NAME]` |
-| `optimize_tables.py` | Run optimization on lakehouse tables | `python scripts/optimize_tables.py <lakehouse> [--vorder]` |
-| `validate_shortcuts.py` | Verify all shortcuts are accessible | `python scripts/validate_shortcuts.py <lakehouse>` |
-
-Scripts are located in the `scripts/` folder of this skill.
-
-## 1 - Lakehouse Operations
-
-### Create Lakehouse
-
-```bash
-# Create basic lakehouse
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse"
-
-# Create with schema support (preview)
-fab mkdir "DataPlatform.Workspace/SchemaSilver.Lakehouse" -P enableSchemas=true
-
-# Check available parameters
-fab mkdir "Item.Lakehouse" -P
-```
-
-### Lakehouse Structure
-
-```
-Lakehouse/
-├── Tables/           # Delta tables (managed)
-│   ├── dbo/         # Default schema
-│   │   ├── customers
-│   │   └── orders
-│   └── staging/     # Custom schema (if enabled)
-└── Files/           # Unmanaged files
-    ├── raw/
-    ├── staging/
-    └── exports/
-```
-
-### List Lakehouse Contents
-
-```bash
-# List lakehouse root
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse"
-
-# List tables
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables"
-
-# List tables in schema
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo"
-
-# List files
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files"
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw" -l
-```
-
-### Get Lakehouse Properties
-
-```bash
-# Get lakehouse details
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -v
-
-# Get SQL endpoint connection string
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties"
-
-# Get OneLake path
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeFilesPath"
-```
-
-## 2 - Warehouse Operations
-
-### Create Warehouse
-
-```bash
-# Create basic warehouse
-fab mkdir "DataPlatform.Workspace/SalesDW.Warehouse"
-
-# Create with case-insensitive collation
-fab mkdir "DataPlatform.Workspace/AnalyticsDW.Warehouse" -P enableCaseInsensitive=true
-```
-
-### Warehouse vs Lakehouse
-
-| Feature | Lakehouse | Warehouse |
-|---------|-----------|-----------|
-| Query Engine | Spark + SQL | T-SQL |
-| Best For | Data engineering | BI/Analytics |
-| Storage Format | Delta | Delta |
-| Schema Support | Optional | Built-in |
-| Direct Lake | Yes | Yes |
-
-## 3 - File Operations
-
-### Upload Files to Lakehouse
-
-```bash
-# Upload single file
-fab cp ./data/sales.csv "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales.csv"
-
-# Upload directory
-fab cp ./data/customers/ "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers/"
-
-# Upload with force (overwrite)
-fab cp ./data/daily.parquet "DataPlatform.Workspace/Bronze.Lakehouse/Files/staging/daily.parquet" -f
-```
-
-### Download Files
-
-```bash
-# Download single file
-fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/exports/report.csv" ./downloads/
-
-# Download directory
-fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" ./backup/raw/
-```
-
-### Move and Delete Files
-
-```bash
-# Move file
-fab mv "DataPlatform.Workspace/Bronze.Lakehouse/Files/staging/data.parquet" \
-       "DataPlatform.Workspace/Bronze.Lakehouse/Files/processed/"
-
-# Delete file
-fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/temp/old-data.csv" -f
-
-# Delete directory
-fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/" -f
-```
-
-## 4 - Table Operations
-
-### View Table Schema
-
-```bash
-# Get table schema
-fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo/customers"
-
-# View warehouse table schema
-fab table schema "DataPlatform.Workspace/SalesDW.Warehouse/Tables/sales/orders"
-```
-
-### Load Data into Table
-
-```bash
-# Load CSV files into table
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers"
-
-# Load with append mode
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/daily_sales.csv" \
-  --mode append
-
-# Load with overwrite
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dim_date" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/dimensions/date.parquet" \
-  --mode overwrite
-
-# Load with custom CSV format
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/products" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/csv/products" \
-  --format "format=csv,header=true,delimiter=|"
-
-# Load Parquet files
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/events" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/parquet/" \
-  --format format=parquet
-```
-
-### Optimize Table
-
-```bash
-# Basic optimization (compaction)
-fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions"
-
-# V-Order optimization (better compression)
-fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales" --vorder
-
-# Z-Order optimization (query performance)
-fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
-  --vorder --zorder customer_id,region
-
-# Optimize with multiple Z-Order columns
-fab table optimize "DataPlatform.Workspace/Bronze.Lakehouse/Tables/orders" \
-  --vorder --zorder order_date,customer_id,product_id
-```
-
-### Vacuum Table
-
-```bash
-# Vacuum with default retention (7 days)
-fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions"
-
-# Vacuum with custom retention (48 hours)
-fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/temp_data" \
-  --retain_n_hours 48
-
-# Vacuum with minimum retention (for testing)
-fab table vacuum "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dev_table" \
-  --retain_n_hours 0
-```
-
-## 5 - Shortcuts (Data Federation)
-
-### Create Shortcuts
-
-Shortcuts enable data federation without copying data.
-
-```bash
-# List existing shortcuts
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/shortcuts"
-
-# Create shortcut to another lakehouse
-fab ln "Source.Workspace/SourceLH.Lakehouse/Tables/customers" \
-       "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers_ref"
-```
-
-### Shortcut Types
-
-| Source | Use Case |
-|--------|----------|
-| OneLake (another lakehouse) | Cross-workspace data sharing |
-| ADLS Gen2 | Azure Data Lake integration |
-| Amazon S3 | AWS data federation |
-| Google Cloud Storage | GCP data federation |
-| Dataverse | Power Platform integration |
-
-### Create ADLS Shortcut via API
-
-```bash
-WS_ID=$(fab get "DataPlatform.Workspace" -q "id" | tr -d '"')
-LH_ID=$(fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "external-data",
-  "path": "Files/external",
-  "target": {
-    "type": "AdlsGen2",
-    "adlsGen2": {
-      "location": "https://storageaccount.dfs.core.windows.net/container/path",
-      "subpath": "/data"
-    }
-  }
-}'
-```
-
-### List Shortcuts
-
-```bash
-# List all shortcuts in lakehouse
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts"
-```
-
-### Delete Shortcut
-
-```bash
-fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut-name"
-```
-
-## 6 - Medallion Architecture
-
-### Standard Structure
-
-```
-Workspace/
-├── Bronze.Lakehouse       # Raw data
-│   ├── Tables/
-│   │   └── raw_customers
-│   │   └── raw_orders
-│   └── Files/
-│       └── landing/
-├── Silver.Lakehouse       # Cleansed/conformed
-│   └── Tables/
-│       └── dim_customers
-│       └── fact_orders
-└── Gold.Lakehouse         # Business-ready
-    └── Tables/
-        └── sales_summary
-        └── customer_360
-```
-
-### Create Medallion Layers
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform"
-
-# Create workspace
-fab mkdir "$WORKSPACE.Workspace" -P capacityname=FabricProd
-
-# Create medallion lakehouses
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse"
-fab mkdir "$WORKSPACE.Workspace/Silver.Lakehouse"
-fab mkdir "$WORKSPACE.Workspace/Gold.Lakehouse"
-
-# Create file landing zone in Bronze
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/landing"
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/archive"
-
-echo "Medallion architecture created"
-```
-
-### Cross-Layer Shortcuts
-
-```bash
-# Create shortcut from Gold to Silver for lineage
-fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_customers" \
-       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_customers"
-```
-
-## 7 - Spark Job Execution
-
-### Run Notebook
-
-```bash
-# Run notebook synchronously
-fab job run "DataPlatform.Workspace/ETL.Notebook" --timeout 600
-
-# Run with parameters
-fab job run "DataPlatform.Workspace/ETL.Notebook" \
-  -P source_date:string=2024-01-15,batch_size:int=10000
-
-# Run with Spark configuration
-fab job run "DataPlatform.Workspace/LargeETL.Notebook" \
-  -C '{"conf": {"spark.executor.memory": "8g", "spark.executor.cores": "4"}}'
-
-# Run with specific lakehouse
-fab job run "DataPlatform.Workspace/Transform.Notebook" \
-  -C '{"defaultLakehouse": {"name": "Silver", "id": "<lakehouse-id>"}}'
-```
-
-### Run Spark Job Definition
-
-```bash
-# Run Spark job
-fab job run "DataPlatform.Workspace/DailyETL.SparkJobDefinition" --timeout 1800
-
-# Run with parameters
-fab job run "DataPlatform.Workspace/DailyETL.SparkJobDefinition" \
-  -P input_path:string=/data/raw,output_path:string=/data/processed
-```
-
-### Run Pipeline
-
-```bash
-# Run data pipeline
-fab job run "DataPlatform.Workspace/MasterPipeline.DataPipeline"
-
-# Run with complex parameters
-fab job run "DataPlatform.Workspace/ETLPipeline.DataPipeline" \
-  -P 'config:object={"source":"sql","target":"lakehouse"},tables:array=["customers","orders"]'
-```
-
-## 8 - Lakehouse Maintenance
-
-### Run Lakehouse Maintenance
-
-```bash
-# Trigger maintenance job (optimize + vacuum)
-fab job run "DataPlatform.Workspace/Bronze.Lakehouse" --timeout 1200
-```
-
-### Automated Maintenance Script
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform.Workspace"
-LAKEHOUSES=("Bronze" "Silver" "Gold")
-
-for LH in "${LAKEHOUSES[@]}"; do
-  echo "Optimizing $LH..."
-  
-  # Get all tables
-  TABLES=$(fab ls "$WORKSPACE/$LH.Lakehouse/Tables/dbo" -q "value[].name")
-  
-  for TABLE in $TABLES; do
-    echo "  Optimizing table: $TABLE"
-    fab table optimize "$WORKSPACE/$LH.Lakehouse/Tables/dbo/$TABLE" --vorder
-    fab table vacuum "$WORKSPACE/$LH.Lakehouse/Tables/dbo/$TABLE"
-  done
-done
-```
-
-## 9 - Environment Management
-
-### Spark Pool Configuration
-
-```bash
-# List workspace spark pools
-fab ls "DataPlatform.Workspace/.sparkpools"
-
-# Get spark pool details
-fab get "DataPlatform.Workspace/.sparkpools/HighMemory.SparkPool"
-```
-
-### Run Job with Workspace Pool
-
-```bash
-fab job run "DataPlatform.Workspace/HeavyETL.Notebook" \
-  -C '{"useStarterPool": false, "useWorkspacePool": "HighMemoryPool"}'
-```
-
-### Environment Configuration
-
-```bash
-# Get workspace environment settings
-fab get "DataPlatform.Workspace" -q "sparkSettings"
-
-# Update default Spark runtime
-fab set "DataPlatform.Workspace" -q sparkSettings.environment.runtimeVersion -i 1.3
-```
-
-## 10 - Data Pipeline Patterns
-
-### Daily ETL Pattern
-
-```bash
-#!/bin/bash
-DATE=$(date +%Y-%m-%d)
-WORKSPACE="DataPlatform.Workspace"
-
-# 1. Load raw data
-fab cp ./daily-data/$DATE/ "$WORKSPACE/Bronze.Lakehouse/Files/landing/$DATE/"
-
-# 2. Run bronze to silver transformation
-fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
-  -P process_date:string=$DATE --timeout 600
-
-# 3. Run silver to gold aggregation
-fab job run "$WORKSPACE/SilverToGold.Notebook" \
-  -P process_date:string=$DATE --timeout 300
-
-# 4. Optimize tables
-fab table optimize "$WORKSPACE/Gold.Lakehouse/Tables/daily_summary" --vorder
-
-echo "Daily ETL completed for $DATE"
-```
-
-### Incremental Load Pattern
-
-```bash
-#!/bin/bash
-# Get last processed watermark
-WATERMARK=$(fab api "workspaces/$WS_ID/lakehouses/$LH_ID/metadata" \
-  -q "properties.lastWatermark" | tr -d '"')
-
-# Run incremental notebook
-fab job run "DataPlatform.Workspace/IncrementalLoad.Notebook" \
-  -P watermark:string=$WATERMARK --timeout 600
-
-# Update watermark after success
-NEW_WATERMARK=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-# Store new watermark for next run
-```
-
-## 11 - Best Practices
-
-### Table Optimization Guidelines
-
-| Scenario | Recommendation |
-|----------|---------------|
-| Frequent small writes | V-Order optimization |
-| Point lookups | Z-Order on lookup columns |
-| Time-series data | Z-Order on date + partition columns |
-| Large aggregations | V-Order for compression |
-
-### File Organization
-
-```bash
-# Recommended file structure
-Bronze.Lakehouse/
-├── Files/
-│   ├── landing/          # Incoming raw data
-│   │   └── YYYY-MM-DD/   # Date partitioned
-│   ├── processing/       # In-progress transformations
-│   ├── archive/          # Processed files (compressed)
-│   └── error/            # Failed processing
-└── Tables/
-    └── raw_*             # Delta tables from loaded data
-```
-
-### Naming Conventions
-
-```bash
-# Lakehouses: Function-based
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse"
-fab mkdir "DataPlatform.Workspace/Silver.Lakehouse"
-fab mkdir "DataPlatform.Workspace/Gold.Lakehouse"
-
-# Tables: Prefix with layer
-# bronze: raw_customers, raw_orders
-# silver: dim_customers, fact_orders
-# gold: agg_sales, rpt_customer_summary
-```
-
-## 12 - References
-
-For detailed patterns, see:
-
-- [references/lakehouse-patterns.md](./references/lakehouse-patterns.md) — Lakehouse management
-- [references/medallion-architecture.md](./references/medallion-architecture.md) — Layer design patterns
-- [references/shortcuts.md](./references/shortcuts.md) — Data federation
-- [references/table-optimization.md](./references/table-optimization.md) — Performance tuning
-- [references/spark-configuration.md](./references/spark-configuration.md) — Spark settings
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md b/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
deleted file mode 100644
index 03ee9a6ab..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/references/lakehouse-patterns.md
+++ /dev/null
@@ -1,315 +0,0 @@
-# Lakehouse Patterns Reference
-
-Comprehensive guide to lakehouse creation, management, and best practices.
-
-## Creating Lakehouses
-
-### Basic Creation
-
-```bash
-# Create lakehouse
-fab mkdir "DataPlatform.Workspace/Analytics.Lakehouse"
-
-# Verify creation
-fab exists "DataPlatform.Workspace/Analytics.Lakehouse"
-fab get "DataPlatform.Workspace/Analytics.Lakehouse" -v
-```
-
-### Schema-Enabled Lakehouse
-
-```bash
-# Enable schemas for better organization (preview)
-fab mkdir "DataPlatform.Workspace/Enterprise.Lakehouse" -P enableSchemas=true
-
-# With schemas, you can organize tables:
-# Tables/sales/orders
-# Tables/sales/customers
-# Tables/finance/invoices
-```
-
-### Check Creation Parameters
-
-```bash
-# See available parameters
-fab mkdir "Item.Lakehouse" -P
-```
-
-## Lakehouse Structure
-
-### Default Layout
-
-```
-Lakehouse/
-├── Tables/           # Delta tables
-│   └── dbo/         # Default schema
-│       ├── customers
-│       └── orders
-└── Files/           # Raw/unmanaged files
-    ├── raw/
-    ├── staging/
-    └── processed/
-```
-
-### With Schemas Enabled
-
-```
-Lakehouse/
-├── Tables/
-│   ├── sales/
-│   │   ├── customers
-│   │   └── orders
-│   ├── finance/
-│   │   ├── invoices
-│   │   └── payments
-│   └── staging/
-│       └── temp_data
-└── Files/
-```
-
-## File Operations
-
-### Upload Files
-
-```bash
-# Single file
-fab cp ./data/customers.csv "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers.csv"
-
-# Directory (recursive)
-fab cp ./data/sales/ "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales/"
-
-# Overwrite existing
-fab cp ./data/updated.parquet "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/data.parquet" -f
-```
-
-### Download Files
-
-```bash
-# Download single file
-fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/exports/report.csv" ./local/
-
-# Download directory
-fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" ./backup/
-```
-
-### List Files
-
-```bash
-# List lakehouse root
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse"
-
-# List files with details
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files" -l
-
-# List nested directory
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/sales" -l
-```
-
-### Organize Files
-
-```bash
-# Create directory structure
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/landing"
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/processing"
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive"
-fab mkdir "DataPlatform.Workspace/Bronze.Lakehouse/Files/error"
-
-# Move processed files
-fab mv "DataPlatform.Workspace/Bronze.Lakehouse/Files/landing/2024-01-15/" \
-       "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/"
-
-# Delete old files
-fab rm "DataPlatform.Workspace/Bronze.Lakehouse/Files/archive/2023-*" -f
-```
-
-## Table Management
-
-### List Tables
-
-```bash
-# List all tables
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables"
-
-# List tables in schema
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo"
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales"
-```
-
-### Get Table Schema
-
-```bash
-# View table columns and types
-fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dbo/customers"
-```
-
-### Load Data into Tables
-
-```bash
-# From CSV folder
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/customers" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/customers"
-
-# From Parquet files
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/events" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/events" \
-  --format format=parquet
-
-# Append mode
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/transactions" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/daily/2024-01-15.parquet" \
-  --mode append
-
-# Overwrite mode
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/dim_date" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/dimensions/date.csv" \
-  --mode overwrite
-
-# Custom CSV format
-fab table load "DataPlatform.Workspace/Bronze.Lakehouse/Tables/legacy_data" \
-  --file "DataPlatform.Workspace/Bronze.Lakehouse/Files/legacy/" \
-  --format "format=csv,header=false,delimiter=|,encoding=UTF-8"
-```
-
-## SQL Analytics Endpoint
-
-### Get Connection Info
-
-```bash
-# Get SQL endpoint details
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties"
-
-# Get connection string
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.connectionString"
-```
-
-### Query via API
-
-```bash
-WS_ID=$(fab get "DataPlatform.Workspace" -q "id" | tr -d '"')
-LH_ID=$(fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "id" | tr -d '"')
-
-# Execute SQL query
-fab api -X post "workspaces/$WS_ID/lakehouses/$LH_ID/jobs/instances?jobType=TableMaintenance" -i '{}'
-```
-
-## Lakehouse Properties
-
-### Get All Properties
-
-```bash
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -v
-```
-
-### Important Properties
-
-```bash
-# OneLake paths
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeFilesPath"
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.oneLakeTablesPath"
-
-# SQL endpoint
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.id"
-
-# Default schema
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.defaultSchema"
-```
-
-## Cross-Lakehouse Operations
-
-### Copy Between Lakehouses
-
-```bash
-# Copy file
-fab cp "Source.Workspace/SourceLH.Lakehouse/Files/data.parquet" \
-       "Target.Workspace/TargetLH.Lakehouse/Files/imported/"
-
-# Note: For tables, use export/import or shortcuts
-```
-
-### Export Lakehouse
-
-```bash
-# Export lakehouse definition
-fab export "DataPlatform.Workspace/Bronze.Lakehouse" -o ./backup/ -f
-```
-
-## Best Practices
-
-### File Organization
-
-```bash
-# Recommended structure
-Files/
-├── landing/              # Incoming raw data
-│   └── source_system/
-│       └── YYYY-MM-DD/
-├── processing/           # Active transformation work
-├── staging/              # Intermediate results
-├── archive/              # Processed files (compressed)
-│   └── YYYY/
-│       └── MM/
-└── error/                # Failed processing
-```
-
-### Table Naming
-
-```bash
-# Use consistent prefixes
-# raw_* for raw data tables
-# stg_* for staging tables
-# dim_* for dimension tables
-# fact_* for fact tables
-# agg_* for aggregated tables
-```
-
-### Maintenance Schedule
-
-```bash
-#!/bin/bash
-# Weekly maintenance script
-WORKSPACE="DataPlatform.Workspace"
-LAKEHOUSE="Bronze.Lakehouse"
-
-# Optimize all tables
-for TABLE in $(fab ls "$WORKSPACE/$LAKEHOUSE/Tables/dbo" -q "value[].name"); do
-  echo "Maintaining $TABLE..."
-  fab table optimize "$WORKSPACE/$LAKEHOUSE/Tables/dbo/$TABLE" --vorder
-  fab table vacuum "$WORKSPACE/$LAKEHOUSE/Tables/dbo/$TABLE" --retain_n_hours 168
-done
-
-# Archive old files
-ARCHIVE_DATE=$(date -d "30 days ago" +%Y-%m-%d)
-fab mv "$WORKSPACE/$LAKEHOUSE/Files/processed/*" \
-       "$WORKSPACE/$LAKEHOUSE/Files/archive/"
-```
-
-## Troubleshooting
-
-### Table Load Failures
-
-```bash
-# Check file format matches expected
-fab ls "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/" -l
-
-# Verify file is accessible
-fab cp "DataPlatform.Workspace/Bronze.Lakehouse/Files/raw/test.csv" ./test.csv
-
-# Check for schema conflicts
-fab table schema "DataPlatform.Workspace/Bronze.Lakehouse/Tables/target"
-```
-
-### Permission Issues
-
-```bash
-# Verify workspace access
-fab acl get "DataPlatform.Workspace"
-
-# Need Contributor role for write operations
-```
-
-### SQL Endpoint Not Available
-
-```bash
-# SQL endpoint may take time to provision
-# Check status
-fab get "DataPlatform.Workspace/Bronze.Lakehouse" -q "properties.sqlEndpointProperties.provisioningStatus"
-```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md b/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
deleted file mode 100644
index ab4764699..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/references/medallion-architecture.md
+++ /dev/null
@@ -1,365 +0,0 @@
-# Medallion Architecture Reference
-
-Guide to implementing bronze/silver/gold data layers using the Fabric CLI.
-
-## Architecture Overview
-
-```
-┌─────────────┐    ┌─────────────┐    ┌─────────────┐
-│   BRONZE    │ -> │   SILVER    │ -> │    GOLD     │
-│  Raw Data   │    │  Cleansed   │    │  Business   │
-│  As-Is     │    │  Conformed  │    │   Ready     │
-└─────────────┘    └─────────────┘    └─────────────┘
-```
-
-### Layer Purposes
-
-| Layer | Purpose | Data Quality | Consumers |
-|-------|---------|--------------|-----------|
-| Bronze | Raw ingestion | As-is from source | Data engineers |
-| Silver | Cleansed, validated | Standardized types, deduped | Data scientists, analysts |
-| Gold | Business-ready | Aggregated, denormalized | Business users, reports |
-
-## Creating the Architecture
-
-### Full Setup Script
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform"
-CAPACITY="FabricProd"
-
-# Create workspace on capacity
-fab mkdir "$WORKSPACE.Workspace" -P capacityname=$CAPACITY
-
-# Create medallion lakehouses
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse"
-fab mkdir "$WORKSPACE.Workspace/Silver.Lakehouse"
-fab mkdir "$WORKSPACE.Workspace/Gold.Lakehouse"
-
-# Create file landing zones in Bronze
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/landing"
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/processing"
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/archive"
-fab mkdir "$WORKSPACE.Workspace/Bronze.Lakehouse/Files/error"
-
-# Optionally create staging area
-fab mkdir "$WORKSPACE.Workspace/Staging.Lakehouse"
-
-# Create warehouse for SQL-based gold access
-fab mkdir "$WORKSPACE.Workspace/Analytics.Warehouse"
-
-echo "Medallion architecture created in $WORKSPACE"
-```
-
-## Bronze Layer Patterns
-
-### Purpose
-
-- Store raw data exactly as received
-- Preserve original schema and format
-- Enable data replay/reprocessing
-- Audit trail of source data
-
-### Structure
-
-```
-Bronze.Lakehouse/
-├── Tables/
-│   └── dbo/
-│       ├── raw_customers       # CDC from source
-│       ├── raw_orders          # Daily extract
-│       ├── raw_products        # API feed
-│       └── raw_events          # Streaming data
-└── Files/
-    ├── landing/
-    │   ├── crm/               # Source system folders
-    │   │   └── 2024-01-15/
-    │   ├── erp/
-    │   └── web/
-    ├── processing/            # Active work
-    ├── archive/               # Processed files
-    └── error/                 # Failed files
-```
-
-### Bronze Ingestion Pattern
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform.Workspace"
-DATE=$(date +%Y-%m-%d)
-SOURCE="crm"
-
-# 1. Upload raw files to landing
-fab cp ./incoming/$SOURCE/* \
-  "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/"
-
-# 2. Load into raw table (append)
-fab table load "$WORKSPACE/Bronze.Lakehouse/Tables/raw_customers" \
-  --file "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/" \
-  --mode append \
-  --format format=parquet
-
-# 3. Archive processed files
-fab mv "$WORKSPACE/Bronze.Lakehouse/Files/landing/$SOURCE/$DATE/" \
-       "$WORKSPACE/Bronze.Lakehouse/Files/archive/$SOURCE/$DATE/"
-
-echo "Bronze ingestion complete for $SOURCE on $DATE"
-```
-
-### Bronze Table Naming
-
-```bash
-# Prefix: raw_
-# Include source system if multiple
-raw_crm_customers
-raw_erp_orders
-raw_web_events
-raw_api_products
-```
-
-## Silver Layer Patterns
-
-### Purpose
-
-- Clean and validate data
-- Apply business rules
-- Standardize data types
-- Deduplicate records
-- Create conformed dimensions
-
-### Structure
-
-```
-Silver.Lakehouse/
-├── Tables/
-│   └── dbo/
-│       ├── dim_customer       # Cleansed dimension
-│       ├── dim_product
-│       ├── dim_date
-│       ├── fact_orders        # Validated facts
-│       └── fact_inventory
-└── Files/
-    └── temp/                  # Processing workspace
-```
-
-### Bronze to Silver Transformation
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform.Workspace"
-
-# Run transformation notebook
-fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
-  -P source_table:string=raw_customers,target_table:string=dim_customer \
-  --timeout 600
-
-# Optimize silver table
-fab table optimize "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" --vorder
-```
-
-### Silver Table Naming
-
-```bash
-# Dimensions: dim_
-dim_customer
-dim_product
-dim_date
-dim_location
-
-# Facts: fact_
-fact_orders
-fact_inventory
-fact_shipments
-
-# Staging: stg_
-stg_customer_dedup
-stg_orders_validated
-```
-
-## Gold Layer Patterns
-
-### Purpose
-
-- Business-ready aggregations
-- Denormalized for reporting
-- Pre-computed metrics
-- Domain-specific views
-
-### Structure
-
-```
-Gold.Lakehouse/
-└── Tables/
-    └── dbo/
-        ├── sales_summary          # Daily/weekly aggregates
-        ├── customer_360           # Customer analytics
-        ├── product_performance    # Product metrics
-        └── executive_dashboard    # KPI aggregates
-```
-
-### Silver to Gold Aggregation
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform.Workspace"
-
-# Run aggregation notebook
-fab job run "$WORKSPACE/SilverToGold.Notebook" --timeout 300
-
-# Optimize gold tables for queries
-fab table optimize "$WORKSPACE/Gold.Lakehouse/Tables/sales_summary" \
-  --vorder --zorder report_date,region
-```
-
-### Gold Table Naming
-
-```bash
-# Aggregated: agg_
-agg_daily_sales
-agg_monthly_revenue
-
-# Reports: rpt_
-rpt_customer_summary
-rpt_product_performance
-
-# Analytics: anlyt_
-anlyt_customer_360
-anlyt_churn_prediction
-```
-
-## Cross-Layer Data Flow
-
-### Using Shortcuts for Reference
-
-```bash
-# Share silver dimensions with gold layer
-fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" \
-       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_customer"
-
-fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_product" \
-       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_product"
-
-fab ln "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_date" \
-       "$WORKSPACE/Gold.Lakehouse/Tables/dbo/dim_date"
-```
-
-### End-to-End Pipeline
-
-```bash
-#!/bin/bash
-WORKSPACE="DataPlatform.Workspace"
-DATE=$(date +%Y-%m-%d)
-
-echo "=== Starting ETL Pipeline for $DATE ==="
-
-# Step 1: Ingest to Bronze
-echo "Step 1: Bronze Ingestion"
-fab job run "$WORKSPACE/IngestToBronze.DataPipeline" \
-  -P process_date:string=$DATE --timeout 600
-echo "Bronze complete"
-
-# Step 2: Transform to Silver
-echo "Step 2: Silver Transformation"
-fab job run "$WORKSPACE/BronzeToSilver.Notebook" \
-  -P process_date:string=$DATE --timeout 900
-echo "Silver complete"
-
-# Step 3: Aggregate to Gold
-echo "Step 3: Gold Aggregation"
-fab job run "$WORKSPACE/SilverToGold.Notebook" \
-  -P process_date:string=$DATE --timeout 300
-echo "Gold complete"
-
-# Step 4: Optimize tables
-echo "Step 4: Table Optimization"
-for LAYER in Bronze Silver Gold; do
-  fab job run "$WORKSPACE/$LAYER.Lakehouse" --timeout 600
-done
-echo "Optimization complete"
-
-echo "=== ETL Pipeline Complete ==="
-```
-
-## Best Practices
-
-### Layer Isolation
-
-```bash
-# Separate permissions per layer
-# Bronze: Data Engineers only
-fab acl set "$WORKSPACE/Bronze.Lakehouse" -P principal=DataEngineers@company.com,role=Contributor
-
-# Silver: Data Engineers + Scientists
-fab acl set "$WORKSPACE/Silver.Lakehouse" -P principal=DataScientists@company.com,role=Viewer
-
-# Gold: All analysts
-fab acl set "$WORKSPACE/Gold.Lakehouse" -P principal=AllAnalysts@company.com,role=Viewer
-```
-
-### Data Quality Checkpoints
-
-```bash
-# Add validation between layers
-# Run quality checks notebook
-fab job run "$WORKSPACE/DataQuality.Notebook" \
-  -P layer:string=bronze,tables:array=["raw_customers","raw_orders"]
-```
-
-### Retention Policies
-
-```bash
-# Bronze: Keep all data (history)
-# No vacuum or aggressive retention
-
-# Silver: Moderate retention
-fab table vacuum "$WORKSPACE/Silver.Lakehouse/Tables/dbo/dim_customer" \
-  --retain_n_hours 720  # 30 days
-
-# Gold: Short retention (current data)
-fab table vacuum "$WORKSPACE/Gold.Lakehouse/Tables/agg_daily_sales" \
-  --retain_n_hours 168  # 7 days
-```
-
-## Multi-Workspace Pattern
-
-For large organizations, consider separate workspaces:
-
-```bash
-# Create workspace per layer
-fab mkdir "DataPlatform-Bronze.Workspace" -P capacityname=FabricProd
-fab mkdir "DataPlatform-Silver.Workspace" -P capacityname=FabricProd
-fab mkdir "DataPlatform-Gold.Workspace" -P capacityname=FabricProd
-
-# Create lakehouses in each
-fab mkdir "DataPlatform-Bronze.Workspace/Bronze.Lakehouse"
-fab mkdir "DataPlatform-Silver.Workspace/Silver.Lakehouse"
-fab mkdir "DataPlatform-Gold.Workspace/Gold.Lakehouse"
-
-# Use shortcuts for cross-workspace access
-fab ln "DataPlatform-Silver.Workspace/Silver.Lakehouse/Tables/dbo/dim_customer" \
-       "DataPlatform-Gold.Workspace/Gold.Lakehouse/Tables/dbo/dim_customer"
-```
-
-## Troubleshooting
-
-### Data Freshness Issues
-
-```bash
-# Check last load time for tables
-fab get "$WORKSPACE/Silver.Lakehouse" -q "properties.lastModifiedDateTime"
-
-# Check job history
-fab job run-list "$WORKSPACE/BronzeToSilver.Notebook"
-```
-
-### Schema Drift
-
-```bash
-# Compare schemas between layers
-fab table schema "$WORKSPACE/Bronze.Lakehouse/Tables/raw_customers"
-fab table schema "$WORKSPACE/Silver.Lakehouse/Tables/dim_customer"
-
-# Run schema evolution notebook
-fab job run "$WORKSPACE/SchemaEvolution.Notebook" -P table:string=customers
-```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md b/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
deleted file mode 100644
index 327990cc5..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/references/shortcuts.md
+++ /dev/null
@@ -1,353 +0,0 @@
-# Shortcuts Reference
-
-Guide to creating and managing OneLake shortcuts for data federation.
-
-## Understanding Shortcuts
-
-Shortcuts provide virtualized access to data without copying:
-
-- **Zero data movement** — Reference data in place
-- **Real-time access** — Always see current data
-- **Cross-cloud** — Connect ADLS, S3, GCS
-- **Cross-workspace** — Share data across Fabric
-
-## Shortcut Types
-
-| Source | Type | Use Case |
-|--------|------|----------|
-| OneLake | Internal | Cross-workspace sharing |
-| ADLS Gen2 | External | Azure Data Lake integration |
-| Amazon S3 | External | AWS data federation |
-| Google Cloud Storage | External | GCP data federation |
-| Dataverse | External | Power Platform data |
-| On-premises | Via Gateway | Legacy systems |
-
-## Creating Shortcuts
-
-### OneLake Shortcut (CLI)
-
-```bash
-# Create shortcut to another lakehouse table
-fab ln "Source.Workspace/SourceLH.Lakehouse/Tables/customers" \
-       "Target.Workspace/TargetLH.Lakehouse/Tables/customers_ref"
-
-# Create shortcut to files
-fab ln "Source.Workspace/SourceLH.Lakehouse/Files/data" \
-       "Target.Workspace/TargetLH.Lakehouse/Files/external_data"
-```
-
-### OneLake Shortcut (API)
-
-```bash
-WS_ID=$(fab get "Target.Workspace" -q "id" | tr -d '"')
-LH_ID=$(fab get "Target.Workspace/Target.Lakehouse" -q "id" | tr -d '"')
-
-# Get source IDs
-SOURCE_WS_ID=$(fab get "Source.Workspace" -q "id" | tr -d '"')
-SOURCE_LH_ID=$(fab get "Source.Workspace/Source.Lakehouse" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i "{
-  \"name\": \"customer_data\",
-  \"path\": \"Tables/customer_data\",
-  \"target\": {
-    \"type\": \"OneLake\",
-    \"oneLake\": {
-      \"workspaceId\": \"$SOURCE_WS_ID\",
-      \"itemId\": \"$SOURCE_LH_ID\",
-      \"path\": \"Tables/customers\"
-    }
-  }
-}"
-```
-
-### ADLS Gen2 Shortcut
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "azure_storage",
-  "path": "Files/azure_data",
-  "target": {
-    "type": "AdlsGen2",
-    "adlsGen2": {
-      "location": "https://mystorageaccount.dfs.core.windows.net/container",
-      "subpath": "/data/sales",
-      "connectionId": "<connection-id>"
-    }
-  }
-}'
-```
-
-### Amazon S3 Shortcut
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "s3_data",
-  "path": "Files/aws_data",
-  "target": {
-    "type": "AmazonS3",
-    "amazonS3": {
-      "location": "https://mybucket.s3.amazonaws.com",
-      "subpath": "/data/analytics",
-      "connectionId": "<s3-connection-id>"
-    }
-  }
-}'
-```
-
-### Google Cloud Storage Shortcut
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "gcs_data",
-  "path": "Files/gcp_data",
-  "target": {
-    "type": "GoogleCloudStorage",
-    "googleCloudStorage": {
-      "location": "https://storage.cloud.google.com/my-bucket",
-      "subpath": "/data",
-      "connectionId": "<gcs-connection-id>"
-    }
-  }
-}'
-```
-
-## Managing Shortcuts
-
-### List Shortcuts
-
-```bash
-# List all shortcuts in lakehouse
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts"
-
-# List with details
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts" -q "value[].{name: name, path: path, type: target.type}"
-```
-
-### Get Shortcut Details
-
-```bash
-# Get specific shortcut
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/customer_data"
-```
-
-### Delete Shortcut
-
-```bash
-# Delete by name
-fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/customer_data"
-```
-
-### Update Shortcut
-
-```bash
-# Shortcuts cannot be updated - delete and recreate
-fab api -X delete "workspaces/$WS_ID/items/$LH_ID/shortcuts/old_shortcut"
-
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "new_shortcut",
-  "path": "...",
-  "target": {...}
-}'
-```
-
-## Connection Management
-
-### List Connections
-
-```bash
-# List all connections (for shortcut targets)
-fab ls .connections -l
-
-# Get connection details
-fab get ".connections/AzureStorageConn.Connection"
-
-# Get connection ID for shortcut
-CONNECTION_ID=$(fab get ".connections/AzureStorageConn.Connection" -q "id" | tr -d '"')
-```
-
-### Create Connection for ADLS
-
-```bash
-fab api -X post "connections" -i '{
-  "displayName": "AzureStorageConn",
-  "connectionDetails": {
-    "type": "AzureDataLakeStorageGen2",
-    "parameters": {
-      "server": "mystorageaccount.dfs.core.windows.net",
-      "path": "container"
-    }
-  },
-  "credentialDetails": {
-    "credentialType": "ManagedIdentity"
-  }
-}'
-```
-
-## Use Cases
-
-### Cross-Workspace Data Sharing
-
-```bash
-#!/bin/bash
-# Share gold layer tables with consumer workspaces
-
-SOURCE_WS="DataPlatform.Workspace"
-SOURCE_LH="Gold.Lakehouse"
-
-# Consumer workspace setup
-for CONSUMER in "Marketing" "Sales" "Finance"; do
-  TARGET_WS="$CONSUMER.Workspace"
-  TARGET_LH="Analytics.Lakehouse"
-  
-  WS_ID=$(fab get "$TARGET_WS" -q "id" | tr -d '"')
-  LH_ID=$(fab get "$TARGET_WS/$TARGET_LH" -q "id" | tr -d '"')
-  SOURCE_WS_ID=$(fab get "$SOURCE_WS" -q "id" | tr -d '"')
-  SOURCE_LH_ID=$(fab get "$SOURCE_WS/$SOURCE_LH" -q "id" | tr -d '"')
-  
-  # Create shortcuts to gold tables
-  for TABLE in "sales_summary" "customer_360" "product_metrics"; do
-    fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i "{
-      \"name\": \"$TABLE\",
-      \"path\": \"Tables/$TABLE\",
-      \"target\": {
-        \"type\": \"OneLake\",
-        \"oneLake\": {
-          \"workspaceId\": \"$SOURCE_WS_ID\",
-          \"itemId\": \"$SOURCE_LH_ID\",
-          \"path\": \"Tables/$TABLE\"
-        }
-      }
-    }"
-    echo "Created shortcut to $TABLE in $CONSUMER workspace"
-  done
-done
-```
-
-### Multi-Cloud Data Lake
-
-```bash
-#!/bin/bash
-# Federate data from multiple clouds
-
-WS_ID=$(fab get "DataHub.Workspace" -q "id" | tr -d '"')
-LH_ID=$(fab get "DataHub.Workspace/Federation.Lakehouse" -q "id" | tr -d '"')
-
-# Azure Data Lake
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "azure_data",
-  "path": "Files/azure",
-  "target": {
-    "type": "AdlsGen2",
-    "adlsGen2": {
-      "location": "https://azurestorage.dfs.core.windows.net/datalake",
-      "subpath": "/production",
-      "connectionId": "<azure-conn-id>"
-    }
-  }
-}'
-
-# AWS S3
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "aws_data",
-  "path": "Files/aws",
-  "target": {
-    "type": "AmazonS3",
-    "amazonS3": {
-      "location": "https://company-bucket.s3.amazonaws.com",
-      "subpath": "/analytics",
-      "connectionId": "<s3-conn-id>"
-    }
-  }
-}'
-
-# Google Cloud Storage
-fab api -X post "workspaces/$WS_ID/items/$LH_ID/shortcuts" -i '{
-  "name": "gcp_data",
-  "path": "Files/gcp",
-  "target": {
-    "type": "GoogleCloudStorage",
-    "googleCloudStorage": {
-      "location": "https://storage.cloud.google.com/company-bucket",
-      "subpath": "/data",
-      "connectionId": "<gcs-conn-id>"
-    }
-  }
-}'
-```
-
-### Medallion Layer References
-
-```bash
-# Silver layer references bronze shortcuts for lineage
-fab ln "DataPlatform.Workspace/Bronze.Lakehouse/Tables/raw_customers" \
-       "DataPlatform.Workspace/Silver.Lakehouse/Tables/source_customers"
-
-# Gold layer references silver dimensions
-fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_customer" \
-       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_customer"
-
-fab ln "DataPlatform.Workspace/Silver.Lakehouse/Tables/dim_product" \
-       "DataPlatform.Workspace/Gold.Lakehouse/Tables/dim_product"
-```
-
-## Best Practices
-
-### Naming Conventions
-
-```bash
-# Prefix by source type
-ext_azure_sales       # External Azure shortcut
-ext_s3_events         # External S3 shortcut
-ref_silver_customers  # Reference to silver layer
-shared_gold_summary   # Shared from gold layer
-```
-
-### Security Considerations
-
-- Shortcuts inherit permissions from target
-- Users need both shortcut and target access
-- Use workspace roles for access control
-- Connection credentials are managed separately
-
-### Performance Tips
-
-- Shortcuts add minimal latency
-- External shortcuts depend on network
-- Use OneLake shortcuts for best performance
-- Consider data locality for external sources
-
-## Troubleshooting
-
-### Shortcut Not Accessible
-
-```bash
-# Check shortcut exists
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut_name"
-
-# Verify connection is valid
-fab get ".connections/ConnectionName.Connection"
-
-# Check permissions on source
-fab acl get "Source.Workspace/Source.Lakehouse"
-```
-
-### Data Not Visible
-
-```bash
-# Verify source path exists
-fab ls "Source.Workspace/Source.Lakehouse/Tables/tablename"
-
-# Check shortcut path
-fab api "workspaces/$WS_ID/items/$LH_ID/shortcuts/shortcut_name" -q "target.path"
-```
-
-### External Source Errors
-
-```bash
-# Verify connection credentials
-fab get ".connections/AzureConn.Connection" -q "credentialDetails"
-
-# Check network connectivity
-# For ADLS: Verify storage account firewall settings
-# For S3: Verify IAM permissions and bucket policy
-```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md b/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
deleted file mode 100644
index f9a7b667f..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/references/spark-configuration.md
+++ /dev/null
@@ -1,398 +0,0 @@
-# Spark Configuration Reference
-
-Guide to managing Spark pools, environments, and configurations in Fabric.
-
-## Spark Pools Overview
-
-Fabric Spark pools provide managed compute for notebooks and jobs:
-
-| Pool Type | Use Case | Configuration |
-|-----------|----------|---------------|
-| Starter Pool | Development | Pre-warmed, shared |
-| Custom Pool | Production | Dedicated, configurable |
-| High Concurrency | Multi-user | Session sharing |
-
-## Managing Spark Pools
-
-### List Spark Pools
-
-```bash
-# List all Spark pools in workspace
-fab ls "Workspace/.sparkpools"
-
-# List with details
-fab ls "Workspace/.sparkpools" -l
-
-# Get pool configuration
-fab get "Workspace/.sparkpools/MyPool.SparkPool"
-```
-
-### Create Spark Pool (via API)
-
-```bash
-WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/sparkPools" -i '{
-  "name": "DataEngineeringPool",
-  "nodeFamily": "MemoryOptimized",
-  "nodeSize": "Large",
-  "autoScale": {
-    "enabled": true,
-    "minNodeCount": 1,
-    "maxNodeCount": 10
-  },
-  "dynamicExecutorAllocation": {
-    "enabled": true,
-    "minExecutors": 1,
-    "maxExecutors": 8
-  }
-}'
-```
-
-### Update Spark Pool
-
-```bash
-# Get pool ID
-POOL_ID=$(fab get "Workspace/.sparkpools/MyPool.SparkPool" -q "id" | tr -d '"')
-
-# Update auto-scale settings
-fab api -X patch "workspaces/$WS_ID/sparkPools/$POOL_ID" -i '{
-  "autoScale": {
-    "enabled": true,
-    "minNodeCount": 2,
-    "maxNodeCount": 20
-  }
-}'
-```
-
-### Delete Spark Pool
-
-```bash
-fab api -X delete "workspaces/$WS_ID/sparkPools/$POOL_ID"
-```
-
-## Spark Environments
-
-### List Environments
-
-```bash
-# List all environments
-fab ls "Workspace/.environments"
-
-# Get environment details
-fab get "Workspace/.environments/DataEng.SparkEnvironment"
-```
-
-### Create Environment
-
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "DataEngEnvironment",
-  "type": "SparkEnvironment"
-}'
-```
-
-### Configure Environment Libraries
-
-```bash
-# Get environment ID
-ENV_ID=$(fab get "Workspace/.environments/DataEng.SparkEnvironment" -q "id" | tr -d '"')
-
-# Add Python libraries via staging
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
-  "pythonLibraries": {
-    "packages": [
-      {"name": "pandas", "version": "2.0.0"},
-      {"name": "pyarrow", "version": "14.0.0"},
-      {"name": "great-expectations", "version": "0.17.0"}
-    ]
-  }
-}'
-
-# Publish environment changes
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/publish"
-```
-
-## Spark Configuration Properties
-
-### Session-Level Configuration
-
-```python
-# Configure Spark session in notebook
-spark.conf.set("spark.sql.shuffle.partitions", "200")
-spark.conf.set("spark.sql.files.maxPartitionBytes", "134217728")
-spark.conf.set("spark.databricks.delta.optimizeWrite.enabled", "true")
-spark.conf.set("spark.databricks.delta.autoCompact.enabled", "true")
-```
-
-### Common Configuration Properties
-
-| Property | Default | Description |
-|----------|---------|-------------|
-| `spark.sql.shuffle.partitions` | 200 | Shuffle partition count |
-| `spark.sql.files.maxPartitionBytes` | 128 MB | Max partition size |
-| `spark.databricks.delta.optimizeWrite.enabled` | false | Auto-optimize writes |
-| `spark.databricks.delta.autoCompact.enabled` | false | Auto-compact small files |
-| `spark.sql.adaptive.enabled` | true | Adaptive query execution |
-
-### Environment-Level Configuration
-
-```bash
-# Add Spark properties to environment
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/sparkSettings" -i '{
-  "sparkProperties": {
-    "spark.sql.shuffle.partitions": "400",
-    "spark.sql.files.maxPartitionBytes": "268435456",
-    "spark.databricks.delta.optimizeWrite.enabled": "true"
-  }
-}'
-
-# Publish changes
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/publish"
-```
-
-## Pool Sizing Guidelines
-
-### Node Sizes
-
-| Size | Memory | Cores | Use Case |
-|------|--------|-------|----------|
-| Small | 8 GB | 4 | Development |
-| Medium | 16 GB | 8 | Standard workloads |
-| Large | 32 GB | 16 | Large datasets |
-| X-Large | 64 GB | 32 | Heavy processing |
-| XX-Large | 128 GB | 64 | Memory-intensive |
-
-### Right-Sizing Recommendations
-
-```bash
-# Check job history for sizing insights
-fab job list "Workspace/Notebook" -l
-
-# Review execution metrics
-NOTEBOOK_ID=$(fab get "Workspace/Notebook" -q "id" | tr -d '"')
-fab api "workspaces/$WS_ID/items/$NOTEBOOK_ID/jobs" -q "value[0].executionData"
-```
-
-## Attaching Pools and Environments
-
-### Set Default Pool
-
-```bash
-# Update workspace default compute
-fab api -X patch "workspaces/$WS_ID/sparkSettings" -i '{
-  "defaultPool": {
-    "type": "Workspace",
-    "name": "DataEngineeringPool"
-  }
-}'
-```
-
-### Attach Environment to Notebook
-
-```bash
-# Via notebook definition update
-NB_ID=$(fab get "Workspace/Notebook" -q "id" | tr -d '"')
-
-fab api -X patch "workspaces/$WS_ID/items/$NB_ID" -i '{
-  "definition": {
-    "environmentId": "<env-id>"
-  }
-}'
-```
-
-## Dynamic Resource Allocation
-
-### Enable Dynamic Allocation
-
-```python
-# In notebook
-spark.conf.set("spark.dynamicAllocation.enabled", "true")
-spark.conf.set("spark.dynamicAllocation.minExecutors", "1")
-spark.conf.set("spark.dynamicAllocation.maxExecutors", "10")
-spark.conf.set("spark.dynamicAllocation.initialExecutors", "2")
-```
-
-### Auto-Scale Configuration
-
-```bash
-# Create pool with auto-scale
-fab api -X post "workspaces/$WS_ID/sparkPools" -i '{
-  "name": "AutoScalePool",
-  "nodeSize": "Medium",
-  "autoScale": {
-    "enabled": true,
-    "minNodeCount": 1,
-    "maxNodeCount": 50
-  }
-}'
-```
-
-## Library Management
-
-### Python Libraries
-
-```bash
-# Add PyPI packages
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
-  "pythonLibraries": {
-    "packages": [
-      {"name": "delta-spark", "version": "3.0.0"},
-      {"name": "azure-storage-blob"},
-      {"name": "pyspark-test"}
-    ]
-  }
-}'
-```
-
-### Custom Wheels
-
-```bash
-# Upload custom wheel first
-fab cp "./custom_lib-1.0.0-py3-none-any.whl" \
-       "Workspace/.environments/MyEnv.SparkEnvironment/libraries/"
-
-# Add to environment
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
-  "pythonLibraries": {
-    "wheelFiles": [
-      {"path": "abfss://.../.environments/MyEnv/libraries/custom_lib-1.0.0-py3-none-any.whl"}
-    ]
-  }
-}'
-```
-
-### JAR Libraries
-
-```bash
-# Add Spark/Scala libraries
-fab api -X post "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries" -i '{
-  "jarLibraries": [
-    {"path": "abfss://.../.environments/MyEnv/libraries/custom-udf.jar"}
-  ]
-}'
-```
-
-## Performance Optimization
-
-### Adaptive Query Execution
-
-```python
-# Enable AQE features
-spark.conf.set("spark.sql.adaptive.enabled", "true")
-spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")
-spark.conf.set("spark.sql.adaptive.skewJoin.enabled", "true")
-spark.conf.set("spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes", "256MB")
-```
-
-### Broadcast Join Optimization
-
-```python
-# Configure broadcast threshold
-spark.conf.set("spark.sql.autoBroadcastJoinThreshold", "104857600")  # 100 MB
-
-# Force broadcast hint
-df = spark.sql("""
-    SELECT /*+ BROADCAST(dim_customer) */ 
-           f.*, d.customer_name
-    FROM fact_sales f
-    JOIN dim_customer d ON f.customer_id = d.customer_id
-""")
-```
-
-### Delta Lake Optimizations
-
-```python
-# Enable Delta optimizations
-spark.conf.set("spark.databricks.delta.optimizeWrite.enabled", "true")
-spark.conf.set("spark.databricks.delta.autoCompact.enabled", "true")
-spark.conf.set("spark.databricks.delta.properties.defaults.enableChangeDataFeed", "true")
-```
-
-## Monitoring and Diagnostics
-
-### View Spark UI Metrics
-
-```bash
-# Get active sessions
-fab api "workspaces/$WS_ID/sparkPools/$POOL_ID/sparkSessions"
-
-# Get session details
-fab api "workspaces/$WS_ID/sparkPools/$POOL_ID/sparkSessions/$SESSION_ID/statements"
-```
-
-### Job Execution History
-
-```bash
-# List recent job runs
-fab job list "Workspace/Notebook" -q "[].{status: status, start: startTime, end: endTime}"
-
-# Get specific job details
-fab job get "Workspace/Notebook" "<job-id>"
-```
-
-## Best Practices
-
-### Development vs Production
-
-| Setting | Development | Production |
-|---------|-------------|------------|
-| Pool Size | Small/Medium | Large/X-Large |
-| Auto-Scale Min | 1 | 2-3 |
-| Auto-Scale Max | 5 | 20-50 |
-| Shuffle Partitions | 200 | 400-800 |
-| Dynamic Allocation | Enabled | Enabled |
-
-### Cost Optimization
-
-- Use starter pools for development
-- Enable auto-scale with appropriate min/max
-- Configure session timeouts
-- Use appropriate node sizes for workload
-- Monitor and right-size based on utilization
-
-### Environment Management
-
-- Separate environments by workload type
-- Version control environment definitions
-- Test library updates in dev first
-- Document required dependencies
-- Use consistent library versions across environments
-
-## Troubleshooting
-
-### Out of Memory Errors
-
-```python
-# Increase driver memory (if available)
-spark.conf.set("spark.driver.memory", "16g")
-
-# Reduce partition size
-spark.conf.set("spark.sql.files.maxPartitionBytes", "67108864")  # 64 MB
-
-# Increase shuffle partitions
-spark.conf.set("spark.sql.shuffle.partitions", "400")
-```
-
-### Slow Job Execution
-
-```python
-# Check execution plan
-df.explain(extended=True)
-
-# Enable AQE if not already
-spark.conf.set("spark.sql.adaptive.enabled", "true")
-
-# Check for data skew
-df.groupBy("potential_skew_column").count().orderBy(desc("count")).show(10)
-```
-
-### Library Conflicts
-
-```bash
-# List current environment libraries
-fab api "workspaces/$WS_ID/environments/$ENV_ID" -q "properties.libraries"
-
-# Check for conflicts
-fab api "workspaces/$WS_ID/environments/$ENV_ID/staging/libraries/conflicts"
-```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md b/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
deleted file mode 100644
index 3da60afb4..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/references/table-optimization.md
+++ /dev/null
@@ -1,341 +0,0 @@
-# Table Optimization Reference
-
-Guide to Delta Lake table optimization in Fabric using CLI.
-
-## Optimization Fundamentals
-
-Delta Lake tables in Fabric support advanced optimization:
-
-| Feature | Purpose | When to Use |
-|---------|---------|-------------|
-| OPTIMIZE | Compact small files | After many small writes |
-| V-Order | Read optimization | Always for analytics |
-| Z-Order | Cluster by columns | Multi-column filtering |
-| VACUUM | Remove old versions | After maintenance windows |
-
-## Running Table Maintenance
-
-### Via Notebook Jobs
-
-```bash
-# Trigger optimization via Spark notebook
-NOTEBOOK_ID=$(fab get "Workspace/Maintenance.Notebook" -q "id" | tr -d '"')
-
-fab job run "Workspace/Maintenance.Notebook" --timeout 3600
-```
-
-### Notebook Content for Optimization
-
-```python
-# Maintenance notebook template
-from delta.tables import DeltaTable
-
-def optimize_table(lakehouse_name, table_name, z_order_cols=None):
-    """Run OPTIMIZE with optional Z-Order"""
-    spark.sql(f"USE {lakehouse_name}")
-    
-    if z_order_cols:
-        cols = ", ".join(z_order_cols)
-        spark.sql(f"OPTIMIZE {table_name} ZORDER BY ({cols})")
-    else:
-        spark.sql(f"OPTIMIZE {table_name}")
-    
-    print(f"Optimized {table_name}")
-
-def vacuum_table(lakehouse_name, table_name, hours=168):
-    """Remove old versions (default 7 days)"""
-    spark.sql(f"USE {lakehouse_name}")
-    spark.sql(f"VACUUM {table_name} RETAIN {hours} HOURS")
-    print(f"Vacuumed {table_name}")
-
-# Execute maintenance
-tables = [
-    ("Bronze_LH", "raw_orders", None),
-    ("Silver_LH", "clean_orders", ["order_date"]),
-    ("Gold_LH", "sales_summary", ["region", "order_date"])
-]
-
-for lh, table, z_cols in tables:
-    optimize_table(lh, table, z_cols)
-    vacuum_table(lh, table)
-```
-
-## V-Order Optimization
-
-V-Order is Fabric's default write optimization:
-
-### Enable V-Order (Default)
-
-V-Order is enabled by default in Fabric lakehouses:
-
-```python
-# V-Order is automatic for Delta writes
-df.write.format("delta").mode("overwrite").save("Tables/optimized_table")
-
-# Check V-Order status in table properties
-spark.sql("DESCRIBE EXTENDED table_name").filter("col_name == 'Table Properties'").show(truncate=False)
-```
-
-### V-Order Benefits
-
-- 15% average compression improvement
-- Up to 50% faster reads for Power BI
-- Automatic during write operations
-- No additional configuration needed
-
-## Z-Order Optimization
-
-### Single Column Z-Order
-
-```python
-# Z-Order by frequently filtered column
-spark.sql("""
-    OPTIMIZE Gold_LH.fact_sales
-    ZORDER BY (order_date)
-""")
-```
-
-### Multi-Column Z-Order
-
-```python
-# Z-Order by multiple columns (max 4 recommended)
-spark.sql("""
-    OPTIMIZE Gold_LH.fact_sales
-    ZORDER BY (region, order_date)
-""")
-```
-
-### When to Use Z-Order
-
-| Use Z-Order When | Avoid Z-Order When |
-|------------------|-------------------|
-| Point lookups on columns | Full table scans |
-| Range queries | Few distinct values |
-| Join key columns | Frequently changing data |
-| Filter predicates | High cardinality only |
-
-## File Compaction
-
-### Standard Compaction
-
-```python
-# Compact small files
-spark.sql("OPTIMIZE lakehouse.table_name")
-
-# View file statistics before/after
-spark.sql("""
-    DESCRIBE DETAIL lakehouse.table_name
-""").select("numFiles", "sizeInBytes").show()
-```
-
-### Partition-Level Compaction
-
-```python
-# Optimize specific partition
-spark.sql("""
-    OPTIMIZE lakehouse.fact_sales
-    WHERE order_date >= '2024-01-01'
-""")
-```
-
-## VACUUM Operations
-
-### Standard VACUUM
-
-```python
-# Remove files older than 7 days (default)
-spark.sql("VACUUM lakehouse.table_name")
-
-# Specify retention period
-spark.sql("VACUUM lakehouse.table_name RETAIN 168 HOURS")
-```
-
-### Dry Run VACUUM
-
-```python
-# Preview files to be deleted
-spark.sql("VACUUM lakehouse.table_name DRY RUN")
-```
-
-### VACUUM Considerations
-
-- Default retention: 7 days (168 hours)
-- Minimum retention: 0 hours (not recommended)
-- Time travel disabled after VACUUM
-- Run during low-activity periods
-
-## Automated Maintenance
-
-### Schedule via Pipeline
-
-```bash
-# Create pipeline with maintenance activities
-fab import -p "Workspace" \
-  -d ".ai-assets/templates/maintenance_pipeline.json" \
-  -t Pipeline
-
-# Schedule the pipeline
-fab api -X post "workspaces/$WS_ID/items/$PIPE_ID/schedules" -i '{
-  "enabled": true,
-  "configuration": {
-    "type": "Daily",
-    "startTime": "2024-01-01T02:00:00",
-    "timeZone": "UTC",
-    "weekdays": ["Sunday"]
-  }
-}'
-```
-
-### Maintenance Script
-
-```bash
-#!/bin/bash
-# Weekly table maintenance automation
-
-WORKSPACE="DataPlatform.Workspace"
-MAINTENANCE_NOTEBOOK="Maintenance.Notebook"
-
-# Run maintenance notebook
-echo "Starting weekly maintenance..."
-fab job run "$WORKSPACE/$MAINTENANCE_NOTEBOOK" --timeout 7200
-
-# Monitor job completion
-JOB_ID=$(fab job list "$WORKSPACE/$MAINTENANCE_NOTEBOOK" -q "[0].id" | tr -d '"')
-STATUS=$(fab job get "$WORKSPACE/$MAINTENANCE_NOTEBOOK" "$JOB_ID" -q "status")
-
-while [[ "$STATUS" == "InProgress" || "$STATUS" == "NotStarted" ]]; do
-  sleep 60
-  STATUS=$(fab job get "$WORKSPACE/$MAINTENANCE_NOTEBOOK" "$JOB_ID" -q "status")
-  echo "Status: $STATUS"
-done
-
-echo "Maintenance completed with status: $STATUS"
-```
-
-## Table Statistics
-
-### Analyze Table Statistics
-
-```python
-# Update table statistics
-spark.sql("ANALYZE TABLE lakehouse.table_name COMPUTE STATISTICS")
-
-# Update statistics for specific columns
-spark.sql("""
-    ANALYZE TABLE lakehouse.table_name
-    COMPUTE STATISTICS FOR COLUMNS col1, col2, col3
-""")
-```
-
-### View Statistics
-
-```python
-# View table details including statistics
-spark.sql("DESCRIBE EXTENDED lakehouse.table_name").show(truncate=False)
-
-# View column statistics
-spark.sql("DESCRIBE EXTENDED lakehouse.table_name column_name").show()
-```
-
-## Best Practices
-
-### Optimization Schedule
-
-| Layer | Frequency | Operations |
-|-------|-----------|------------|
-| Bronze | Weekly | OPTIMIZE, VACUUM |
-| Silver | Weekly | OPTIMIZE, VACUUM |
-| Gold | Daily | OPTIMIZE, VACUUM |
-| Aggregate | Daily | OPTIMIZE |
-
-### File Size Targets
-
-- Target file size: 128 MB - 1 GB
-- Small file threshold: < 64 MB
-- Large file threshold: > 2 GB
-- Compaction reduces file count
-
-### Z-Order Selection
-
-```python
-# Profile queries to identify Z-Order candidates
-# Good candidates: frequently filtered columns
-z_order_candidates = {
-    "fact_sales": ["customer_id", "order_date"],
-    "fact_inventory": ["product_id", "warehouse_id"],
-    "dim_customer": ["customer_segment", "region"]
-}
-```
-
-## Monitoring Table Health
-
-### Check File Distribution
-
-```python
-# View file statistics
-df = spark.sql("DESCRIBE DETAIL lakehouse.table_name")
-df.select(
-    "name",
-    "numFiles",
-    "sizeInBytes",
-    "lastModified"
-).show()
-
-# Calculate average file size
-df.selectExpr(
-    "numFiles",
-    "sizeInBytes",
-    "sizeInBytes / numFiles as avgFileSize"
-).show()
-```
-
-### History and Auditing
-
-```python
-# View table history
-spark.sql("DESCRIBE HISTORY lakehouse.table_name LIMIT 20").show(truncate=False)
-
-# View operations timeline
-spark.sql("""
-    DESCRIBE HISTORY lakehouse.table_name
-""").select("version", "timestamp", "operation", "operationMetrics").show()
-```
-
-## Troubleshooting
-
-### Small File Problem
-
-```python
-# Identify small file issue
-stats = spark.sql("DESCRIBE DETAIL lakehouse.table_name")
-avg_size = stats.select("sizeInBytes").first()[0] / stats.select("numFiles").first()[0]
-
-if avg_size < 64 * 1024 * 1024:  # < 64 MB
-    print("Small file issue detected - run OPTIMIZE")
-    spark.sql("OPTIMIZE lakehouse.table_name")
-```
-
-### Slow Queries After VACUUM
-
-```python
-# Rebuild statistics after VACUUM
-spark.sql("ANALYZE TABLE lakehouse.table_name COMPUTE STATISTICS")
-
-# Re-optimize if needed
-spark.sql("OPTIMIZE lakehouse.table_name")
-```
-
-### Z-Order Not Effective
-
-```python
-# Check if Z-Order columns match query patterns
-# Verify column cardinality
-spark.sql("""
-    SELECT 
-        COUNT(DISTINCT z_order_col) as cardinality,
-        COUNT(*) as total_rows
-    FROM lakehouse.table_name
-""").show()
-
-# High cardinality (>1000 distinct) benefits more from Z-Order
-```
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
deleted file mode 100644
index 7ea6009f3..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/scripts/optimize_tables.py
+++ /dev/null
@@ -1,413 +0,0 @@
-#!/usr/bin/env python3
-"""
-optimize_tables.py - Run optimization on lakehouse tables
-
-This script runs V-Order and/or Z-Order optimization on lakehouse tables
-to improve query performance.
-
-Usage:
-    python optimize_tables.py <lakehouse> [--vorder] [--zorder COL]
-    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder
-    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales --zorder customer_id,date
-
-Exit codes:
-    0 - Optimization completed successfully
-    1 - Optimization failed or had errors
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 600) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def check_path_exists(path: str) -> bool:
-    """Check if path exists."""
-    exit_code, _, _ = run_fab_command(["exists", path])
-    return exit_code == 0
-
-
-def parse_lakehouse_path(path: str) -> Dict[str, Optional[str]]:
-    """Parse lakehouse path into components."""
-    result = {
-        "workspace": None,
-        "lakehouse": None,
-        "table": None,
-        "full_path": path
-    }
-    
-    parts = path.split("/")
-    
-    for i, part in enumerate(parts):
-        if part.endswith(".Workspace"):
-            result["workspace"] = part
-        elif part.endswith(".Lakehouse"):
-            result["lakehouse"] = part
-            if result["workspace"]:
-                result["lakehouse_path"] = f"{result['workspace']}/{part}"
-        elif part == "Tables" and i < len(parts) - 1:
-            result["table"] = parts[i + 1]
-    
-    return result
-
-
-def get_lakehouse_tables(lakehouse_path: str) -> List[Dict[str, Any]]:
-    """Get all tables in a lakehouse."""
-    tables_path = f"{lakehouse_path}/Tables"
-    exit_code, stdout, stderr = run_fab_command(["ls", tables_path, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        try:
-            result = json.loads(stdout.strip())
-            if isinstance(result, list):
-                return result
-        except json.JSONDecodeError:
-            pass
-    
-    return []
-
-
-def optimize_table_vorder(table_path: str) -> Dict[str, Any]:
-    """Run V-Order optimization on a table."""
-    result = {
-        "table": table_path,
-        "optimization": "vorder",
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Run OPTIMIZE command with VORDER
-    cmd = ["tables", "optimize", table_path, "--vorder", "-f", "json"]
-    
-    exit_code, stdout, stderr = run_fab_command(cmd, timeout=1800)  # 30 min timeout for large tables
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = "V-Order optimization completed"
-        try:
-            result["details"] = json.loads(stdout.strip())
-        except json.JSONDecodeError:
-            result["details"] = {"output": stdout.strip()}
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or "V-Order optimization failed"
-    
-    return result
-
-
-def optimize_table_zorder(table_path: str, columns: List[str]) -> Dict[str, Any]:
-    """Run Z-Order optimization on a table."""
-    result = {
-        "table": table_path,
-        "optimization": "zorder",
-        "columns": columns,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Run OPTIMIZE command with ZORDER
-    columns_str = ",".join(columns)
-    cmd = ["tables", "optimize", table_path, "--zorder", columns_str, "-f", "json"]
-    
-    exit_code, stdout, stderr = run_fab_command(cmd, timeout=1800)  # 30 min timeout for large tables
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = f"Z-Order optimization completed on columns: {columns_str}"
-        try:
-            result["details"] = json.loads(stdout.strip())
-        except json.JSONDecodeError:
-            result["details"] = {"output": stdout.strip()}
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or "Z-Order optimization failed"
-    
-    return result
-
-
-def get_table_stats(table_path: str) -> Dict[str, Any]:
-    """Get table statistics."""
-    exit_code, stdout, stderr = run_fab_command(["tables", "get", table_path, "-f", "json"])
-    
-    if exit_code == 0:
-        try:
-            return json.loads(stdout.strip())
-        except json.JSONDecodeError:
-            pass
-    
-    return {}
-
-
-def optimize_tables(
-    path: str,
-    vorder: bool = False,
-    zorder_columns: Optional[List[str]] = None,
-    table_filter: Optional[str] = None,
-    dry_run: bool = False
-) -> Dict[str, Any]:
-    """Optimize tables in a lakehouse."""
-    
-    report = {
-        "path": path,
-        "vorder": vorder,
-        "zorder_columns": zorder_columns,
-        "dry_run": dry_run,
-        "tables_found": [],
-        "optimization_results": [],
-        "summary": {
-            "total_tables": 0,
-            "optimized": 0,
-            "failed": 0,
-            "skipped": 0
-        }
-    }
-    
-    # Parse the path
-    parsed = parse_lakehouse_path(path)
-    
-    # Verify path exists
-    print(f"\nVerifying path: {path}")
-    if not check_path_exists(path):
-        print(f"Error: Path '{path}' does not exist or is not accessible")
-        return report
-    print("  Path found")
-    
-    # Determine if we're optimizing a single table or all tables in a lakehouse
-    tables_to_optimize = []
-    
-    if parsed.get("table"):
-        # Single table specified
-        tables_to_optimize = [{
-            "name": parsed["table"],
-            "path": path
-        }]
-        print(f"\nTarget: Single table '{parsed['table']}'")
-    else:
-        # Get all tables in lakehouse
-        print("\nFetching lakehouse tables...")
-        
-        lakehouse_path = path
-        tables = get_lakehouse_tables(lakehouse_path)
-        
-        for table in tables:
-            table_name = table.get("displayName", table.get("name", "Unknown"))
-            table_path = f"{lakehouse_path}/Tables/{table_name}"
-            
-            if table_filter and table_filter.lower() not in table_name.lower():
-                continue
-            
-            tables_to_optimize.append({
-                "name": table_name,
-                "path": table_path,
-                "metadata": table
-            })
-        
-        print(f"  Found {len(tables_to_optimize)} table(s)")
-    
-    report["tables_found"] = [t["name"] for t in tables_to_optimize]
-    report["summary"]["total_tables"] = len(tables_to_optimize)
-    
-    if not tables_to_optimize:
-        print("No tables found to optimize")
-        return report
-    
-    # Validate optimization options
-    if not vorder and not zorder_columns:
-        print("\nError: Must specify --vorder and/or --zorder columns")
-        print("  Use --vorder for V-Order optimization")
-        print("  Use --zorder col1,col2 for Z-Order optimization")
-        return report
-    
-    if dry_run:
-        print(f"\n[DRY RUN] Would optimize the following tables:")
-        for table in tables_to_optimize:
-            print(f"  - {table['name']}")
-            if vorder:
-                print(f"      V-Order: Yes")
-            if zorder_columns:
-                print(f"      Z-Order columns: {', '.join(zorder_columns)}")
-        return report
-    
-    # Optimize each table
-    print("\nOptimizing tables...")
-    for table in tables_to_optimize:
-        table_name = table["name"]
-        table_path = table["path"]
-        
-        print(f"\n  Optimizing: {table_name}")
-        
-        table_result = {
-            "table": table_name,
-            "path": table_path,
-            "optimizations": []
-        }
-        
-        # V-Order optimization
-        if vorder:
-            print(f"    Running V-Order...")
-            vorder_result = optimize_table_vorder(table_path)
-            table_result["optimizations"].append(vorder_result)
-            
-            if vorder_result["status"] == "success":
-                print(f"      ✓ V-Order completed")
-            else:
-                print(f"      ✗ V-Order failed: {vorder_result['message']}")
-        
-        # Z-Order optimization
-        if zorder_columns:
-            print(f"    Running Z-Order on: {', '.join(zorder_columns)}")
-            zorder_result = optimize_table_zorder(table_path, zorder_columns)
-            table_result["optimizations"].append(zorder_result)
-            
-            if zorder_result["status"] == "success":
-                print(f"      ✓ Z-Order completed")
-            else:
-                print(f"      ✗ Z-Order failed: {zorder_result['message']}")
-        
-        # Determine overall status for this table
-        all_success = all(opt["status"] == "success" for opt in table_result["optimizations"])
-        any_success = any(opt["status"] == "success" for opt in table_result["optimizations"])
-        
-        if all_success:
-            table_result["overall_status"] = "success"
-            report["summary"]["optimized"] += 1
-        elif any_success:
-            table_result["overall_status"] = "partial"
-            report["summary"]["optimized"] += 1
-        else:
-            table_result["overall_status"] = "failed"
-            report["summary"]["failed"] += 1
-        
-        report["optimization_results"].append(table_result)
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Run optimization on lakehouse tables",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    # V-Order all tables in a lakehouse
-    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder
-
-    # Z-Order a specific table
-    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse/Tables/sales --zorder customer_id,date
-
-    # Both V-Order and Z-Order
-    python optimize_tables.py DataPlatform.Workspace/Silver.Lakehouse --vorder --zorder date,region
-
-    # Preview what would be optimized
-    python optimize_tables.py DataPlatform.Workspace/Gold.Lakehouse --vorder --dry-run
-
-    # Filter tables by name pattern
-    python optimize_tables.py DataPlatform.Workspace/Bronze.Lakehouse --vorder --filter sales
-
-Optimization Types:
-    V-Order (--vorder):
-        Optimizes data layout for read performance.
-        Applies write-time sorting for faster queries.
-        Recommended for tables with frequent analytical queries.
-
-    Z-Order (--zorder col1,col2):
-        Colocates related information in the same files.
-        Improves filtering on specified columns.
-        Best for columns commonly used in WHERE clauses.
-        """
-    )
-    parser.add_argument(
-        "path",
-        help="Lakehouse or table path to optimize"
-    )
-    parser.add_argument(
-        "--vorder",
-        action="store_true",
-        help="Apply V-Order optimization"
-    )
-    parser.add_argument(
-        "--zorder",
-        help="Comma-separated list of columns for Z-Order optimization"
-    )
-    parser.add_argument(
-        "--filter",
-        help="Filter tables by name pattern (case-insensitive)"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview optimization without executing"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    # Parse Z-Order columns
-    zorder_columns = None
-    if args.zorder:
-        zorder_columns = [col.strip() for col in args.zorder.split(",") if col.strip()]
-    
-    # Validate that at least one optimization is specified
-    if not args.vorder and not zorder_columns:
-        parser.error("Must specify --vorder and/or --zorder columns")
-    
-    try:
-        report = optimize_tables(
-            path=args.path,
-            vorder=args.vorder,
-            zorder_columns=zorder_columns,
-            table_filter=args.filter,
-            dry_run=args.dry_run
-        )
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("OPTIMIZATION SUMMARY")
-        print("=" * 50)
-        print(f"Path: {report['path']}")
-        print(f"V-Order: {report['vorder']}")
-        print(f"Z-Order Columns: {', '.join(report['zorder_columns']) if report['zorder_columns'] else 'None'}")
-        print(f"Dry Run: {report['dry_run']}")
-        print(f"\nResults:")
-        print(f"  Total Tables: {report['summary']['total_tables']}")
-        print(f"  Optimized: {report['summary']['optimized']}")
-        print(f"  Failed: {report['summary']['failed']}")
-        print(f"  Skipped: {report['summary']['skipped']}")
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        # Exit code based on failures
-        sys.exit(0 if report['summary']['failed'] == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
deleted file mode 100644
index 555a7c587..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/scripts/setup_medallion.py
+++ /dev/null
@@ -1,376 +0,0 @@
-#!/usr/bin/env python3
-"""
-setup_medallion.py - Create medallion architecture (bronze/silver/gold)
-
-This script creates a standard medallion architecture in a Microsoft Fabric workspace,
-including Bronze, Silver, and Gold lakehouses with standard folder structures.
-
-Usage:
-    python setup_medallion.py <workspace> [--prefix NAME]
-    python setup_medallion.py DataPlatform.Workspace
-    python setup_medallion.py DataPlatform.Workspace --prefix Sales
-
-Exit codes:
-    0 - Medallion architecture created successfully
-    1 - Error during creation
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def check_workspace_exists(workspace: str) -> bool:
-    """Check if workspace exists."""
-    exit_code, _, _ = run_fab_command(["exists", workspace])
-    return exit_code == 0
-
-
-def check_item_exists(item_path: str) -> bool:
-    """Check if an item exists."""
-    exit_code, _, _ = run_fab_command(["exists", item_path])
-    return exit_code == 0
-
-
-def create_lakehouse(workspace: str, name: str, enable_schemas: bool = False) -> Dict[str, Any]:
-    """Create a lakehouse in the workspace."""
-    lakehouse_path = f"{workspace}/{name}.Lakehouse"
-    
-    result = {
-        "name": name,
-        "path": lakehouse_path,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(lakehouse_path):
-        result["status"] = "exists"
-        result["message"] = f"Lakehouse '{name}' already exists"
-        return result
-    
-    # Create the lakehouse
-    cmd = ["create", lakehouse_path, "-f"]
-    if enable_schemas:
-        cmd.extend(["-P", "enableSchemas=true"])
-    
-    exit_code, stdout, stderr = run_fab_command(cmd)
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["message"] = f"Lakehouse '{name}' created successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create lakehouse '{name}'"
-    
-    return result
-
-
-def create_folder(lakehouse_path: str, folder_path: str) -> Dict[str, Any]:
-    """Create a folder in a lakehouse."""
-    full_path = f"{lakehouse_path}/{folder_path}"
-    
-    result = {
-        "path": full_path,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    exit_code, stdout, stderr = run_fab_command(["mkdir", full_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["message"] = f"Folder '{folder_path}' created"
-    elif "already exists" in stderr.lower():
-        result["status"] = "exists"
-        result["message"] = f"Folder '{folder_path}' already exists"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create folder '{folder_path}'"
-    
-    return result
-
-
-def create_shortcut(source_lakehouse: str, target_lakehouse: str, shortcut_name: str, target_folder: str) -> Dict[str, Any]:
-    """Create a shortcut between lakehouses."""
-    shortcut_path = f"{source_lakehouse}/Files/{shortcut_name}.Shortcut"
-    target_path = f"{target_lakehouse}/Files/{target_folder}"
-    
-    result = {
-        "shortcut": shortcut_path,
-        "target": target_path,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Check if shortcut already exists
-    if check_item_exists(shortcut_path):
-        result["status"] = "exists"
-        result["message"] = f"Shortcut '{shortcut_name}' already exists"
-        return result
-    
-    exit_code, stdout, stderr = run_fab_command([
-        "ln", shortcut_path, 
-        "--type", "oneLake",
-        "--target", target_path,
-        "-f"
-    ])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["message"] = f"Shortcut '{shortcut_name}' created"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create shortcut '{shortcut_name}'"
-    
-    return result
-
-
-def setup_medallion_architecture(
-    workspace: str, 
-    prefix: Optional[str] = None,
-    enable_schemas: bool = False,
-    create_shortcuts: bool = False,
-    dry_run: bool = False
-) -> Dict[str, Any]:
-    """Set up complete medallion architecture."""
-    
-    workspace = ensure_workspace_suffix(workspace)
-    
-    # Define lakehouse names
-    bronze_name = f"{prefix}_Bronze" if prefix else "Bronze"
-    silver_name = f"{prefix}_Silver" if prefix else "Silver"
-    gold_name = f"{prefix}_Gold" if prefix else "Gold"
-    
-    # Standard folder structure for each layer
-    bronze_folders = ["Files/raw", "Files/landing", "Files/archive"]
-    silver_folders = ["Files/cleansed", "Files/enriched", "Files/validated"]
-    gold_folders = ["Files/curated", "Files/aggregated", "Files/published"]
-    
-    report = {
-        "workspace": workspace,
-        "prefix": prefix,
-        "dry_run": dry_run,
-        "lakehouses": [],
-        "folders": [],
-        "shortcuts": [],
-        "summary": {
-            "lakehouses_created": 0,
-            "lakehouses_existed": 0,
-            "folders_created": 0,
-            "shortcuts_created": 0,
-            "errors": 0
-        }
-    }
-    
-    if dry_run:
-        print("\n[DRY RUN] The following resources would be created:\n")
-        print(f"Workspace: {workspace}")
-        print(f"\nLakehouses:")
-        print(f"  - {bronze_name}.Lakehouse")
-        print(f"  - {silver_name}.Lakehouse")
-        print(f"  - {gold_name}.Lakehouse")
-        print(f"\nFolders in each lakehouse:")
-        for folder in bronze_folders:
-            print(f"  - Bronze: {folder}")
-        for folder in silver_folders:
-            print(f"  - Silver: {folder}")
-        for folder in gold_folders:
-            print(f"  - Gold: {folder}")
-        if create_shortcuts:
-            print(f"\nShortcuts:")
-            print(f"  - Silver -> Bronze (bronze_source)")
-            print(f"  - Gold -> Silver (silver_source)")
-        return report
-    
-    # Check workspace exists
-    print(f"\nSetting up medallion architecture in: {workspace}")
-    if not check_workspace_exists(workspace):
-        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
-        sys.exit(1)
-    
-    # Create lakehouses
-    print("\n1. Creating Lakehouses...")
-    lakehouses = [
-        (bronze_name, bronze_folders),
-        (silver_name, silver_folders),
-        (gold_name, gold_folders)
-    ]
-    
-    for lh_name, folders in lakehouses:
-        print(f"   Creating {lh_name}.Lakehouse...")
-        result = create_lakehouse(workspace, lh_name, enable_schemas)
-        report["lakehouses"].append(result)
-        
-        if result["status"] == "created":
-            report["summary"]["lakehouses_created"] += 1
-            print(f"   ✓ {result['message']}")
-        elif result["status"] == "exists":
-            report["summary"]["lakehouses_existed"] += 1
-            print(f"   • {result['message']}")
-        else:
-            report["summary"]["errors"] += 1
-            print(f"   ✗ {result['message']}")
-    
-    # Create folder structures
-    print("\n2. Creating folder structures...")
-    for lh_name, folders in lakehouses:
-        lakehouse_path = f"{workspace}/{lh_name}.Lakehouse"
-        print(f"   {lh_name}:")
-        for folder in folders:
-            result = create_folder(lakehouse_path, folder)
-            report["folders"].append(result)
-            
-            if result["status"] == "created":
-                report["summary"]["folders_created"] += 1
-                print(f"     ✓ {folder}")
-            elif result["status"] == "exists":
-                print(f"     • {folder} (exists)")
-            else:
-                report["summary"]["errors"] += 1
-                print(f"     ✗ {folder}: {result['message']}")
-    
-    # Create shortcuts between layers (optional)
-    if create_shortcuts:
-        print("\n3. Creating shortcuts between layers...")
-        
-        # Silver -> Bronze shortcut
-        silver_path = f"{workspace}/{silver_name}.Lakehouse"
-        bronze_path = f"{workspace}/{bronze_name}.Lakehouse"
-        gold_path = f"{workspace}/{gold_name}.Lakehouse"
-        
-        result = create_shortcut(silver_path, bronze_path, "bronze_source", "cleansed")
-        report["shortcuts"].append(result)
-        if result["status"] == "created":
-            report["summary"]["shortcuts_created"] += 1
-            print(f"   ✓ Silver -> Bronze shortcut created")
-        else:
-            print(f"   • {result['message']}")
-        
-        # Gold -> Silver shortcut
-        result = create_shortcut(gold_path, silver_path, "silver_source", "enriched")
-        report["shortcuts"].append(result)
-        if result["status"] == "created":
-            report["summary"]["shortcuts_created"] += 1
-            print(f"   ✓ Gold -> Silver shortcut created")
-        else:
-            print(f"   • {result['message']}")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Create medallion architecture (Bronze/Silver/Gold lakehouses)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python setup_medallion.py DataPlatform.Workspace
-    python setup_medallion.py DataPlatform.Workspace --prefix Sales
-    python setup_medallion.py "My Workspace" --prefix Analytics --with-shortcuts
-    python setup_medallion.py Dev.Workspace --dry-run
-
-Medallion Architecture:
-    Bronze: Raw data ingestion layer
-    Silver: Cleansed and validated data
-    Gold: Curated business-ready data
-        """
-    )
-    parser.add_argument(
-        "workspace",
-        help="Workspace name or path where medallion architecture will be created"
-    )
-    parser.add_argument(
-        "--prefix", "-p",
-        help="Prefix for lakehouse names (e.g., 'Sales' creates Sales_Bronze, Sales_Silver, Sales_Gold)"
-    )
-    parser.add_argument(
-        "--enable-schemas",
-        action="store_true",
-        help="Enable schema support for lakehouses"
-    )
-    parser.add_argument(
-        "--with-shortcuts",
-        action="store_true",
-        help="Create shortcuts between layers (Silver->Bronze, Gold->Silver)"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview what would be created without making changes"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        report = setup_medallion_architecture(
-            workspace=args.workspace,
-            prefix=args.prefix,
-            enable_schemas=args.enable_schemas,
-            create_shortcuts=args.with_shortcuts,
-            dry_run=args.dry_run
-        )
-        
-        if args.dry_run:
-            sys.exit(0)
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("MEDALLION ARCHITECTURE SETUP COMPLETE")
-        print("=" * 50)
-        print(f"Workspace: {report['workspace']}")
-        if report['prefix']:
-            print(f"Prefix: {report['prefix']}")
-        print(f"\nSummary:")
-        print(f"  Lakehouses created: {report['summary']['lakehouses_created']}")
-        print(f"  Lakehouses existed: {report['summary']['lakehouses_existed']}")
-        print(f"  Folders created: {report['summary']['folders_created']}")
-        if args.with_shortcuts:
-            print(f"  Shortcuts created: {report['summary']['shortcuts_created']}")
-        print(f"  Errors: {report['summary']['errors']}")
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        sys.exit(0 if report['summary']['errors'] == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py b/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
deleted file mode 100644
index 1d18d110b..000000000
--- a/.ai-assets/skills/fabric-cli-dataengineering/scripts/validate_shortcuts.py
+++ /dev/null
@@ -1,424 +0,0 @@
-#!/usr/bin/env python3
-"""
-validate_shortcuts.py - Verify all shortcuts are accessible
-
-This script validates all shortcuts in a lakehouse, checking that targets exist
-and are accessible.
-
-Usage:
-    python validate_shortcuts.py <lakehouse>
-    python validate_shortcuts.py DataPlatform.Workspace/Silver.Lakehouse
-
-Exit codes:
-    0 - All shortcuts are valid and accessible
-    1 - One or more shortcuts have issues
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def ensure_lakehouse_suffix(path: str) -> str:
-    """Ensure path has .Lakehouse suffix if needed."""
-    if "/" not in path:
-        return path
-    
-    parts = path.split("/")
-    for i, part in enumerate(parts):
-        if "." in part:
-            continue
-        # Check if this looks like a lakehouse name
-        if i > 0 and parts[i-1].endswith(".Workspace"):
-            parts[i] = f"{part}.Lakehouse"
-            break
-    
-    return "/".join(parts)
-
-
-def check_path_exists(path: str) -> bool:
-    """Check if path exists."""
-    exit_code, _, _ = run_fab_command(["exists", path])
-    return exit_code == 0
-
-
-def parse_lakehouse_path(path: str) -> Dict[str, Optional[str]]:
-    """Parse lakehouse path into components."""
-    result = {
-        "workspace": None,
-        "lakehouse": None,
-        "full_path": path
-    }
-    
-    parts = path.split("/")
-    
-    for part in parts:
-        if part.endswith(".Workspace"):
-            result["workspace"] = part
-        elif part.endswith(".Lakehouse"):
-            result["lakehouse"] = part
-            if result["workspace"]:
-                result["lakehouse_path"] = f"{result['workspace']}/{part}"
-    
-    return result
-
-
-def list_shortcuts(lakehouse_path: str) -> List[Dict[str, Any]]:
-    """List all shortcuts in a lakehouse."""
-    shortcuts = []
-    
-    # Check Tables folder
-    tables_path = f"{lakehouse_path}/Tables"
-    exit_code, stdout, stderr = run_fab_command(["ls", tables_path, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        items = parse_json_output(stdout) or []
-        for item in items:
-            if item.get("type") == "Shortcut":
-                item["location"] = "Tables"
-                item["full_path"] = f"{tables_path}/{item.get('name', '')}"
-                shortcuts.append(item)
-    
-    # Check Files folder
-    files_path = f"{lakehouse_path}/Files"
-    exit_code, stdout, stderr = run_fab_command(["ls", files_path, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        items = parse_json_output(stdout) or []
-        for item in items:
-            if item.get("type") == "Shortcut":
-                item["location"] = "Files"
-                item["full_path"] = f"{files_path}/{item.get('name', '')}"
-                shortcuts.append(item)
-    
-    # Also check for shortcuts using the shortcut-specific command
-    exit_code, stdout, stderr = run_fab_command(["ln", "list", lakehouse_path, "-f", "json"])
-    
-    if exit_code == 0:
-        ln_shortcuts = parse_json_output(stdout) or []
-        # Merge with existing list, avoiding duplicates
-        existing_names = {s.get("name") for s in shortcuts}
-        for s in ln_shortcuts:
-            if s.get("name") not in existing_names:
-                shortcuts.append(s)
-    
-    return shortcuts
-
-
-def get_shortcut_details(shortcut_path: str) -> Dict[str, Any]:
-    """Get detailed information about a shortcut."""
-    exit_code, stdout, stderr = run_fab_command(["get", shortcut_path, "-f", "json"])
-    
-    if exit_code == 0:
-        return parse_json_output(stdout) or {}
-    return {"error": stderr}
-
-
-def validate_shortcut(shortcut: Dict[str, Any], verbose: bool = False) -> Dict[str, Any]:
-    """Validate a single shortcut."""
-    result = {
-        "name": shortcut.get("name", "Unknown"),
-        "location": shortcut.get("location", "Unknown"),
-        "path": shortcut.get("full_path", ""),
-        "status": "unknown",
-        "target": None,
-        "target_type": None,
-        "checks": []
-    }
-    
-    # Get shortcut target information
-    shortcut_path = shortcut.get("full_path", "")
-    if shortcut_path:
-        details = get_shortcut_details(shortcut_path)
-        
-        if "error" in details:
-            result["status"] = "error"
-            result["checks"].append({
-                "check": "get_details",
-                "passed": False,
-                "message": f"Failed to get shortcut details: {details['error']}"
-            })
-            return result
-        
-        # Extract target information
-        target = details.get("target") or details.get("targetPath")
-        target_type = details.get("targetType") or details.get("type", "")
-        
-        result["target"] = target
-        result["target_type"] = target_type
-        
-        # Check 1: Target path is defined
-        if target:
-            result["checks"].append({
-                "check": "target_defined",
-                "passed": True,
-                "message": f"Target is defined: {target}"
-            })
-        else:
-            result["status"] = "invalid"
-            result["checks"].append({
-                "check": "target_defined",
-                "passed": False,
-                "message": "No target path defined for shortcut"
-            })
-            return result
-        
-        # Check 2: Target exists (for internal shortcuts)
-        if target_type in ["OneLake", "Internal", "Lakehouse", "Warehouse"]:
-            if verbose:
-                print(f"  Checking if target exists: {target}", file=sys.stderr)
-            
-            target_exists = check_path_exists(target)
-            if target_exists:
-                result["checks"].append({
-                    "check": "target_exists",
-                    "passed": True,
-                    "message": f"Target exists: {target}"
-                })
-            else:
-                result["status"] = "broken"
-                result["checks"].append({
-                    "check": "target_exists",
-                    "passed": False,
-                    "message": f"Target does not exist: {target}"
-                })
-                return result
-        
-        # Check 3: Try to list contents (verify access)
-        if verbose:
-            print(f"  Checking shortcut accessibility...", file=sys.stderr)
-        
-        exit_code, stdout, stderr = run_fab_command(["ls", shortcut_path, "-f", "json"], timeout=30)
-        
-        if exit_code == 0:
-            result["checks"].append({
-                "check": "accessible",
-                "passed": True,
-                "message": "Shortcut content is accessible"
-            })
-        else:
-            # Could be permission issue or broken shortcut
-            result["status"] = "inaccessible"
-            result["checks"].append({
-                "check": "accessible",
-                "passed": False,
-                "message": f"Cannot access shortcut content: {stderr.strip()}"
-            })
-            return result
-        
-        # All checks passed
-        result["status"] = "valid"
-    
-    return result
-
-
-def print_validation_report(results: Dict[str, Any], output_format: str, 
-                           output_file: Optional[str] = None):
-    """Print validation report."""
-    if output_format == "json":
-        output = json.dumps(results, indent=2)
-    else:
-        # Text format
-        lines = []
-        lines.append("=" * 70)
-        lines.append("SHORTCUT VALIDATION REPORT")
-        lines.append("=" * 70)
-        lines.append(f"Lakehouse: {results['lakehouse']}")
-        lines.append("")
-        
-        summary = results.get("summary", {})
-        lines.append(f"Total shortcuts: {summary.get('total', 0)}")
-        lines.append(f"Valid: {summary.get('valid', 0)}")
-        lines.append(f"Broken: {summary.get('broken', 0)}")
-        lines.append(f"Inaccessible: {summary.get('inaccessible', 0)}")
-        lines.append(f"Invalid: {summary.get('invalid', 0)}")
-        lines.append(f"Errors: {summary.get('errors', 0)}")
-        lines.append("")
-        
-        # Group by status
-        shortcuts = results.get("shortcuts", [])
-        
-        valid_shortcuts = [s for s in shortcuts if s["status"] == "valid"]
-        problem_shortcuts = [s for s in shortcuts if s["status"] != "valid"]
-        
-        if valid_shortcuts:
-            lines.append("VALID SHORTCUTS:")
-            for s in valid_shortcuts:
-                target_info = f" -> {s['target']}" if s.get('target') else ""
-                lines.append(f"  ✓ {s['name']} ({s['location']}){target_info}")
-            lines.append("")
-        
-        if problem_shortcuts:
-            lines.append("PROBLEM SHORTCUTS:")
-            for s in problem_shortcuts:
-                status_icon = {
-                    "broken": "✗",
-                    "inaccessible": "⚠",
-                    "invalid": "?",
-                    "error": "!"
-                }.get(s["status"], "?")
-                
-                lines.append(f"  {status_icon} {s['name']} ({s['location']}) - {s['status'].upper()}")
-                
-                # Show failed checks
-                for check in s.get("checks", []):
-                    if not check["passed"]:
-                        lines.append(f"      └─ {check['message']}")
-            lines.append("")
-        
-        if not shortcuts:
-            lines.append("No shortcuts found in this lakehouse.")
-            lines.append("")
-        
-        # Overall status
-        lines.append("-" * 70)
-        if summary.get("broken", 0) > 0 or summary.get("invalid", 0) > 0:
-            lines.append("STATUS: FAILED - Some shortcuts have issues that need attention")
-        elif summary.get("inaccessible", 0) > 0:
-            lines.append("STATUS: WARNING - Some shortcuts may have access issues")
-        elif summary.get("total", 0) == 0:
-            lines.append("STATUS: OK - No shortcuts to validate")
-        else:
-            lines.append("STATUS: PASSED - All shortcuts are valid and accessible")
-        lines.append("=" * 70)
-        
-        output = "\n".join(lines)
-    
-    if output_file:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.write(output)
-        print(f"Report written to: {output_file}", file=sys.stderr)
-    else:
-        print(output)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Verify all shortcuts in a lakehouse are accessible",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python validate_shortcuts.py DataPlatform.Workspace/Silver.Lakehouse
-    python validate_shortcuts.py MyWorkspace.Workspace/Bronze.Lakehouse -f json
-    python validate_shortcuts.py Production.Workspace/Gold.Lakehouse -o report.json
-        """
-    )
-    
-    parser.add_argument(
-        "lakehouse",
-        help="Lakehouse path (e.g., 'MyWorkspace.Workspace/MyLakehouse.Lakehouse')"
-    )
-    
-    parser.add_argument(
-        "-f", "--format",
-        choices=["text", "json"],
-        default="text",
-        help="Output format (default: text)"
-    )
-    
-    parser.add_argument(
-        "-o", "--output",
-        help="Output file path (default: stdout)"
-    )
-    
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Enable verbose output"
-    )
-    
-    args = parser.parse_args()
-    
-    # Parse and validate lakehouse path
-    lakehouse_path = ensure_lakehouse_suffix(args.lakehouse)
-    path_info = parse_lakehouse_path(lakehouse_path)
-    
-    if not path_info.get("lakehouse_path"):
-        print(f"Error: Invalid lakehouse path: {args.lakehouse}", file=sys.stderr)
-        print("Expected format: Workspace.Workspace/Lakehouse.Lakehouse", file=sys.stderr)
-        return 1
-    
-    lakehouse_full_path = path_info["lakehouse_path"]
-    
-    if args.verbose:
-        print(f"Validating shortcuts in: {lakehouse_full_path}", file=sys.stderr)
-    
-    # Check lakehouse exists
-    if not check_path_exists(lakehouse_full_path):
-        print(f"Error: Lakehouse does not exist: {lakehouse_full_path}", file=sys.stderr)
-        return 1
-    
-    # List all shortcuts
-    if args.verbose:
-        print("Discovering shortcuts...", file=sys.stderr)
-    
-    shortcuts = list_shortcuts(lakehouse_full_path)
-    
-    if args.verbose:
-        print(f"Found {len(shortcuts)} shortcuts", file=sys.stderr)
-    
-    # Validate each shortcut
-    validation_results = []
-    for shortcut in shortcuts:
-        if args.verbose:
-            print(f"Validating: {shortcut.get('name', 'Unknown')}", file=sys.stderr)
-        
-        result = validate_shortcut(shortcut, verbose=args.verbose)
-        validation_results.append(result)
-    
-    # Build summary
-    summary = {
-        "total": len(validation_results),
-        "valid": sum(1 for r in validation_results if r["status"] == "valid"),
-        "broken": sum(1 for r in validation_results if r["status"] == "broken"),
-        "inaccessible": sum(1 for r in validation_results if r["status"] == "inaccessible"),
-        "invalid": sum(1 for r in validation_results if r["status"] == "invalid"),
-        "errors": sum(1 for r in validation_results if r["status"] == "error")
-    }
-    
-    # Build report
-    report = {
-        "lakehouse": lakehouse_full_path,
-        "summary": summary,
-        "shortcuts": validation_results
-    }
-    
-    # Output report
-    print_validation_report(report, args.format, args.output)
-    
-    # Return exit code
-    if summary["broken"] > 0 or summary["invalid"] > 0 or summary["errors"] > 0:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-governance/README.md b/.ai-assets/skills/fabric-cli-governance/README.md
deleted file mode 100644
index cc9fdac79..000000000
--- a/.ai-assets/skills/fabric-cli-governance/README.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# Fabric CLI Governance Skill
-
-Task-specific instructions for AI agents helping users with Microsoft Fabric governance, security, and administration operations.
-
-## Overview
-
-This skill provides guidance for:
-
-- **Access Control** — Workspace roles, item permissions, ACL management
-- **Domain Management** — Creating and organizing domains, workspace assignment
-- **Capacity Operations** — Capacity assignment, monitoring, SKU management
-- **Sensitivity Labels** — Classifying and protecting data
-- **Audit & Compliance** — Activity monitoring, permission audits
-
-## When to Load
-
-Load this skill when the user's task involves:
-
-- Managing workspace or item permissions
-- Setting up domains or organizational structures
-- Assigning workspaces to capacities
-- Applying sensitivity labels
-- Auditing access or activities
-- Configuring security policies (RLS, CLS, OLS)
-- Managing connections or gateways
-
-## Files
-
-| File | Description |
-|------|-------------|
-| [SKILL.md](./SKILL.md) | Main skill definition (load this) |
-| [references/](./references/) | Detailed reference documentation |
-
-## Scripts
-
-Automation scripts for governance tasks:
-
-| Script | Description | Usage |
-|--------|-------------|-------|
-| `audit_workspace.py` | Generate comprehensive workspace audit report | `python scripts/audit_workspace.py <workspace> -o report.json` |
-| `bulk_permissions.py` | Apply permissions from CSV/JSON file | `python scripts/bulk_permissions.py <workspace> -i perms.csv` |
-| `validate_governance.py` | Check workspace against governance rules | `python scripts/validate_governance.py <workspace> --rules rules.json` |
-
-## Quick Reference
-
-### Common Commands
-
-```bash
-# View workspace permissions
-fab acl get "Workspace.Workspace"
-
-# Add user to workspace
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
-
-# List domains
-fab ls .domains -l
-
-# List capacities
-fab ls .capacities -l
-
-# Assign workspace to capacity
-fab assign "Workspace.Workspace" -P capacityId=<capacity-id>
-```
-
-## Dependencies
-
-- Requires `fabric-cli-core` skill loaded first
-- Admin or Member workspace role for permission management
-- Fabric Admin role for tenant-level operations
-
-## References
-
-- [Fabric Permission Model](https://learn.microsoft.com/fabric/security/permission-model)
-- [Workspace Roles](https://learn.microsoft.com/fabric/fundamentals/roles-workspaces)
-- [Governance Overview](https://learn.microsoft.com/fabric/governance/governance-compliance-overview)
diff --git a/.ai-assets/skills/fabric-cli-governance/SKILL.md b/.ai-assets/skills/fabric-cli-governance/SKILL.md
deleted file mode 100644
index b5f8dbae4..000000000
--- a/.ai-assets/skills/fabric-cli-governance/SKILL.md
+++ /dev/null
@@ -1,474 +0,0 @@
----
-name: fabric-cli-governance
-description: Use Fabric CLI for governance, security, and administration — workspace permissions, domains, capacities, sensitivity labels, and audit. Activate when users need to manage access control, configure governance policies, monitor usage, or troubleshoot permissions.
----
-
-# Fabric CLI Governance & Administration
-
-Expert guidance for managing Microsoft Fabric security, governance, and administration using the `fab` CLI.
-
-## When to Use This Skill
-
-Activate automatically when tasks involve:
-
-- Managing workspace permissions and access control (ACLs)
-- Configuring and managing domains
-- Capacity assignment and monitoring
-- Applying sensitivity labels to items
-- Auditing user activities and access patterns
-- Setting up row-level security (RLS), column-level security (CLS), or object-level security (OLS)
-- Workspace identity and managed identity configuration
-
-## Prerequisites
-
-- Load `fabric-cli-core` skill first for foundational CLI guidance
-- User must be authenticated: `fab auth status`
-- Admin or Member role required for most governance operations
-- Fabric Admin role required for tenant-level operations
-
-## Automation Scripts
-
-Ready-to-use Python scripts for governance tasks. Run any script with `--help` for full options.
-
-| Script | Purpose | Usage |
-|--------|---------|-------|
-| `audit_workspace.py` | Generate comprehensive workspace audit report | `python scripts/audit_workspace.py <workspace> -o report.json` |
-| `bulk_permissions.py` | Apply permissions from CSV/JSON file | `python scripts/bulk_permissions.py <workspace> -i perms.csv` |
-| `validate_governance.py` | Check workspace against governance rules | `python scripts/validate_governance.py <workspace> --rules rules.json` |
-
-Scripts are located in the `scripts/` folder of this skill.
-
-## 1 - Workspace Roles and Permissions
-
-### Workspace Role Hierarchy
-
-| Role | Capabilities |
-|------|-------------|
-| **Admin** | Full control: delete workspace, manage all permissions, all Member capabilities |
-| **Member** | Create/modify/share items, add Contributors and Viewers |
-| **Contributor** | Create/modify items, cannot share or manage permissions |
-| **Viewer** | Read-only access to all items |
-
-### View Workspace Permissions
-
-```bash
-# List all workspace permissions
-fab acl get "Production.Workspace"
-
-# Get permissions in detailed format
-fab acl get "Production.Workspace" -l
-
-# Query specific permission details
-fab acl get "Production.Workspace" -q "value[?role=='Admin']"
-```
-
-### Manage Workspace Permissions
-
-```bash
-# Add user as Contributor
-fab acl set "Production.Workspace" -P principal=user@company.com,role=Contributor
-
-# Add security group as Viewer
-fab acl set "Production.Workspace" -P principal=DataAnalysts@company.com,role=Viewer,principalType=Group
-
-# Add service principal as Member
-fab acl set "Production.Workspace" -P principal=<app-id>,role=Member,principalType=App
-
-# Remove user from workspace
-fab acl del "Production.Workspace" -P principal=user@company.com
-```
-
-### Bulk Permission Management
-
-```bash
-#!/bin/bash
-# Add multiple users to workspace
-WORKSPACE="Production.Workspace"
-USERS=("analyst1@company.com" "analyst2@company.com" "analyst3@company.com")
-
-for USER in "${USERS[@]}"; do
-  fab acl set "$WORKSPACE" -P principal=$USER,role=Viewer -f
-  echo "Added $USER as Viewer"
-done
-```
-
-## 2 - Item-Level Permissions
-
-### View Item Permissions
-
-```bash
-# Get permissions for specific item
-fab acl get "Production.Workspace/Sales.SemanticModel"
-
-# List all shared items in workspace
-fab api "workspaces/<ws-id>/items" -q "value[?permissions]"
-```
-
-### Share Items
-
-```bash
-# Share semantic model with read access
-fab acl set "Production.Workspace/Sales.SemanticModel" -P principal=user@company.com,role=Read
-
-# Share with build permission (for semantic models)
-fab acl set "Production.Workspace/Sales.SemanticModel" -P principal=user@company.com,role=Build
-
-# Share report
-fab acl set "Production.Workspace/SalesReport.Report" -P principal=user@company.com,role=Read
-```
-
-### Item Permission Types
-
-| Item Type | Available Permissions |
-|-----------|----------------------|
-| Semantic Model | Read, Build, Write |
-| Report | Read, Write |
-| Lakehouse | Read, ReadAll, Write |
-| Warehouse | Read, ReadData, Write |
-| Notebook | Read, Write |
-
-## 3 - Domain Management
-
-Domains organize workspaces into logical groupings for governance.
-
-### List Domains
-
-```bash
-# List all domains (hidden entity)
-fab ls .domains -l
-
-# Get domain details
-fab get ".domains/Finance.Domain"
-```
-
-### Create and Configure Domains
-
-```bash
-# Create a new domain
-fab mkdir ".domains/Analytics.Domain"
-
-# Create domain with description
-fab api -X post "admin/domains" -i '{
-  "displayName": "Analytics",
-  "description": "Analytics team workspaces"
-}'
-```
-
-### Assign Workspaces to Domains
-
-```bash
-# Get domain ID
-DOMAIN_ID=$(fab get ".domains/Analytics.Domain" -q "id" | tr -d '"')
-
-# Assign workspace to domain
-fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i '{
-  "workspacesIds": ["<workspace-id-1>", "<workspace-id-2>"]
-}'
-
-# List workspaces in domain
-fab api "admin/domains/$DOMAIN_ID/workspaces"
-```
-
-### Domain Admins
-
-```bash
-# Add domain admin
-fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
-  "principals": [{"id": "<user-id>", "type": "User"}],
-  "role": "Admins"
-}'
-
-# List domain admins
-fab api "admin/domains/$DOMAIN_ID/roleAssignments"
-```
-
-## 4 - Capacity Management
-
-### List Capacities
-
-```bash
-# List all capacities (hidden entity)
-fab ls .capacities -l
-
-# Get capacity details
-fab get ".capacities/FabricCapacity1.Capacity"
-
-# Get capacity ID
-CAPACITY_ID=$(fab get ".capacities/FabricCapacity1.Capacity" -q "id" | tr -d '"')
-```
-
-### Assign Workspace to Capacity
-
-```bash
-# Assign workspace to capacity
-fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID
-
-# Unassign workspace from capacity (moves to shared capacity)
-fab unassign "Production.Workspace"
-
-# Create workspace on specific capacity
-fab mkdir "NewWorkspace.Workspace" -P capacityname=FabricCapacity1
-```
-
-### Monitor Capacity Usage
-
-```bash
-# Get capacity metrics via Azure API
-SUBSCRIPTION_ID="<subscription-id>"
-RESOURCE_GROUP="<resource-group>"
-CAPACITY_NAME="<capacity-name>"
-
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01"
-
-# List all Fabric capacities in subscription
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
-```
-
-### Capacity SKUs
-
-```bash
-# Get available SKUs
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
-```
-
-## 5 - Sensitivity Labels
-
-### List Available Labels
-
-```bash
-# Get sensitivity labels from Purview
-fab api "admin/labels"
-
-# Query label details
-fab api "admin/labels" -q "value[?name=='Confidential']"
-```
-
-### Apply Labels to Items
-
-```bash
-# Get workspace and item IDs
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-ITEM_ID=$(fab get "Production.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
-LABEL_ID="<label-id>"
-
-# Apply label via API
-fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
-  \"labelId\": \"$LABEL_ID\"
-}"
-```
-
-### Bulk Label Application
-
-```bash
-#!/bin/bash
-# Apply label to all semantic models in workspace
-WORKSPACE="Production.Workspace"
-LABEL_ID="<confidential-label-id>"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Get all semantic models
-MODELS=$(fab api "workspaces/$WS_ID/items" -q "value[?type=='SemanticModel'].id")
-
-for MODEL_ID in $MODELS; do
-  fab api -X post "workspaces/$WS_ID/items/$MODEL_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
-  echo "Applied label to $MODEL_ID"
-done
-```
-
-## 6 - Audit and Monitoring
-
-### Access Audit Logs
-
-Fabric audit logs are available through Microsoft Purview or Office 365 Management API.
-
-```bash
-# Query activities via Admin API
-fab api "admin/activityEvents" -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z
-
-# Filter by activity type
-fab api "admin/activityEvents" -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z,activityType=ViewReport
-```
-
-### Common Audit Queries
-
-```bash
-# Get all workspace access events
-fab api "admin/activityEvents" -P activityType=GetWorkspaces
-
-# Get all export events
-fab api "admin/activityEvents" -P activityType=ExportReport
-
-# Get all sharing events
-fab api "admin/activityEvents" -P activityType=ShareReport
-```
-
-### Workspace Inventory
-
-```bash
-#!/bin/bash
-# Generate workspace inventory report
-echo "Workspace,ItemCount,Capacity,Domain" > inventory.csv
-
-WORKSPACES=$(fab api workspaces -q "value[].{name: displayName, id: id}")
-
-echo "$WORKSPACES" | jq -r '.[] | [.name, .id] | @tsv' | while IFS=$'\t' read -r NAME ID; do
-  ITEM_COUNT=$(fab api "workspaces/$ID/items" -q "value | length")
-  # Get capacity and domain info
-  WS_INFO=$(fab get "$NAME.Workspace" -v)
-  echo "$NAME,$ITEM_COUNT,..." >> inventory.csv
-done
-```
-
-## 7 - Managed Identities
-
-### List Workspace Managed Identities
-
-```bash
-# List managed identities (hidden entity)
-fab ls "Production.Workspace/.managedidentities"
-
-# Get managed identity details
-fab get "Production.Workspace/.managedidentities/default.ManagedIdentity"
-```
-
-### Configure Workspace Identity
-
-```bash
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-
-# Create workspace identity
-fab api -X post "workspaces/$WS_ID/assignToCapacity" -i '{
-  "identityType": "SystemAssigned"
-}'
-```
-
-## 8 - Connections and Gateways
-
-### List Connections
-
-```bash
-# List all connections (hidden entity)
-fab ls .connections -l
-
-# Get connection details
-fab get ".connections/SQLServerConnection.Connection"
-```
-
-### List Gateways
-
-```bash
-# List all gateways (hidden entity)
-fab ls .gateways -l
-
-# Get gateway details
-fab get ".gateways/OnPremGateway.Gateway"
-
-# List data sources on gateway
-GATEWAY_ID=$(fab get ".gateways/OnPremGateway.Gateway" -q "id" | tr -d '"')
-fab api -A powerbi "gateways/$GATEWAY_ID/datasources"
-```
-
-## 9 - Security Patterns
-
-### Row-Level Security (RLS)
-
-RLS is configured within semantic models. Use CLI to manage model definitions:
-
-```bash
-# Export model with RLS configuration
-fab export "Production.Workspace/Sales.SemanticModel" -o ./model-backup -f
-
-# The TMDL definition contains RLS roles
-# Edit definition/roles/*.tmdl files
-
-# Re-import updated model
-fab import "Production.Workspace/Sales.SemanticModel" -i ./model-backup/Sales.SemanticModel -f
-```
-
-### OneLake Security
-
-```bash
-# Configure OneLake data access roles via API
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-LH_ID=$(fab get "Production.Workspace/Sales.Lakehouse" -q "id" | tr -d '"')
-
-# Get current data access roles
-fab api "workspaces/$WS_ID/lakehouses/$LH_ID/dataAccessRoles"
-```
-
-## 10 - Governance Best Practices
-
-### Permission Audit Checklist
-
-```bash
-#!/bin/bash
-# Audit script for workspace permissions
-
-WORKSPACE="Production.Workspace"
-
-echo "=== Permission Audit for $WORKSPACE ==="
-
-# List all permissions
-echo "Current Permissions:"
-fab acl get "$WORKSPACE" -l
-
-# Check for overly permissive access
-echo "Users with Admin role:"
-fab acl get "$WORKSPACE" -q "value[?role=='Admin']"
-
-# Check service principals
-echo "Service Principals with access:"
-fab acl get "$WORKSPACE" -q "value[?principalType=='App']"
-```
-
-### Security Recommendations
-
-1. **Principle of least privilege** - Grant minimum required permissions
-2. **Use security groups** - Manage permissions via groups, not individuals
-3. **Regular audits** - Review permissions quarterly
-4. **Service principal rotation** - Rotate credentials regularly
-5. **Sensitivity labels** - Apply labels to classify data
-6. **Domain organization** - Group workspaces by business function
-7. **Capacity isolation** - Separate dev/prod workloads
-
-## 11 - Common Governance Tasks
-
-### Offboard User
-
-```bash
-#!/bin/bash
-# Remove user from all workspaces
-USER="departing.user@company.com"
-
-WORKSPACES=$(fab api workspaces -q "value[].displayName")
-
-for WS in $WORKSPACES; do
-  fab acl del "$WS.Workspace" -P principal=$USER -f 2>/dev/null && \
-    echo "Removed from $WS" || echo "Not in $WS"
-done
-```
-
-### Transfer Ownership
-
-```bash
-# Transfer workspace admin
-OLD_ADMIN="old.admin@company.com"
-NEW_ADMIN="new.admin@company.com"
-WORKSPACE="Production.Workspace"
-
-# Add new admin first
-fab acl set "$WORKSPACE" -P principal=$NEW_ADMIN,role=Admin -f
-
-# Then remove old admin
-fab acl del "$WORKSPACE" -P principal=$OLD_ADMIN -f
-```
-
-## 12 - References
-
-For detailed governance patterns, see:
-
-- [references/workspace-permissions.md](./references/workspace-permissions.md) — ACL patterns and examples
-- [references/domain-management.md](./references/domain-management.md) — Domain configuration
-- [references/capacity-operations.md](./references/capacity-operations.md) — Capacity management
-- [references/sensitivity-labels.md](./references/sensitivity-labels.md) — Label application
-- [references/audit-patterns.md](./references/audit-patterns.md) — Audit and monitoring
diff --git a/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md b/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
deleted file mode 100644
index 9efe0cdf8..000000000
--- a/.ai-assets/skills/fabric-cli-governance/references/audit-patterns.md
+++ /dev/null
@@ -1,282 +0,0 @@
-# Audit Patterns Reference
-
-Guide to auditing and monitoring Fabric activities using the CLI.
-
-## Understanding Fabric Audit
-
-Fabric audit logs capture:
-- User activities (view, create, delete, share)
-- Admin operations (permission changes, capacity assignment)
-- API access and authentication events
-- Data access patterns
-
-Audit logs are available through:
-- Microsoft Purview Audit
-- Office 365 Management API
-- Fabric Admin API (limited)
-
-## Querying Activity Events
-
-### Basic Activity Query
-
-```bash
-# Get activities for date range
-fab api "admin/activityEvents" \
-  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z
-```
-
-### Filter by Activity Type
-
-```bash
-# View report activities
-fab api "admin/activityEvents" \
-  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z,activityType=ViewReport
-
-# Export activities
-fab api "admin/activityEvents" \
-  -P activityType=ExportReport
-
-# Share activities
-fab api "admin/activityEvents" \
-  -P activityType=ShareReport
-```
-
-### Common Activity Types
-
-| Activity Type | Description |
-|--------------|-------------|
-| `ViewReport` | Report viewed |
-| `ExportReport` | Report exported |
-| `ShareReport` | Report shared |
-| `CreateWorkspace` | Workspace created |
-| `DeleteWorkspace` | Workspace deleted |
-| `AddWorkspaceUser` | User added to workspace |
-| `DeleteWorkspaceUser` | User removed from workspace |
-| `RefreshDataset` | Dataset refreshed |
-| `GetDatasources` | Data sources queried |
-
-## Workspace Activity Audit
-
-### Audit Workspace Access
-
-```bash
-#!/bin/bash
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-
-# Get all activities for workspace
-fab api "admin/activityEvents" \
-  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-31T23:59:59Z \
-  -q "value[?workspaceId=='$WS_ID']"
-```
-
-### Permission Change Audit
-
-```bash
-# Track permission changes
-fab api "admin/activityEvents" \
-  -P activityType=AddWorkspaceUser
-
-fab api "admin/activityEvents" \
-  -P activityType=DeleteWorkspaceUser
-```
-
-## User Activity Audit
-
-### Query User Activities
-
-```bash
-# Get all activities by specific user
-fab api "admin/activityEvents" \
-  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-31T23:59:59Z \
-  -q "value[?userId=='user@company.com']"
-```
-
-### Login/Authentication Events
-
-```bash
-# Track authentication
-fab api "admin/activityEvents" \
-  -P activityType=GetWorkspaces
-```
-
-## Data Access Audit
-
-### Report View Tracking
-
-```bash
-#!/bin/bash
-# Track who viewed specific report
-REPORT_NAME="SalesReport"
-
-fab api "admin/activityEvents" \
-  -P activityType=ViewReport \
-  -q "value[?artifactName=='$REPORT_NAME']"
-```
-
-### Data Export Tracking
-
-```bash
-# Track data exports (potential data exfiltration)
-fab api "admin/activityEvents" \
-  -P activityType=ExportReport
-
-fab api "admin/activityEvents" \
-  -P activityType=ExportArtifact
-```
-
-## Automated Audit Reports
-
-### Daily Activity Summary
-
-```bash
-#!/bin/bash
-# Generate daily activity summary
-YESTERDAY=$(date -d "yesterday" +%Y-%m-%dT00:00:00Z)
-TODAY=$(date +%Y-%m-%dT00:00:00Z)
-
-echo "=== Fabric Activity Summary ===" > daily-audit.txt
-echo "Period: $YESTERDAY to $TODAY" >> daily-audit.txt
-echo "" >> daily-audit.txt
-
-# Count by activity type
-echo "Activity Counts:" >> daily-audit.txt
-fab api "admin/activityEvents" \
-  -P startDateTime=$YESTERDAY,endDateTime=$TODAY \
-  -q "value | group_by(@, &Activity) | {type: keys(@), count: values(@) | map(&length(@), @)}" >> daily-audit.txt
-```
-
-### Weekly Security Audit
-
-```bash
-#!/bin/bash
-WEEK_AGO=$(date -d "7 days ago" +%Y-%m-%dT00:00:00Z)
-NOW=$(date +%Y-%m-%dT23:59:59Z)
-
-echo "=== Weekly Security Audit ===" > security-audit.txt
-
-# Permission changes
-echo "Permission Changes:" >> security-audit.txt
-fab api "admin/activityEvents" \
-  -P startDateTime=$WEEK_AGO,endDateTime=$NOW,activityType=AddWorkspaceUser >> security-audit.txt
-
-# Exports
-echo "Data Exports:" >> security-audit.txt
-fab api "admin/activityEvents" \
-  -P startDateTime=$WEEK_AGO,endDateTime=$NOW,activityType=ExportReport >> security-audit.txt
-
-# Failed authentications
-echo "Authentication Issues:" >> security-audit.txt
-fab api "admin/activityEvents" \
-  -P startDateTime=$WEEK_AGO,endDateTime=$NOW \
-  -q "value[?contains(Activity, 'Failed')]" >> security-audit.txt
-```
-
-### Compliance Report
-
-```bash
-#!/bin/bash
-# Generate compliance report for sensitive workspaces
-WORKSPACE="Financial-Prod.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-START_DATE="2024-01-01T00:00:00Z"
-END_DATE="2024-01-31T23:59:59Z"
-
-echo "Compliance Report: $WORKSPACE" > compliance-report.csv
-echo "Date Range: $START_DATE to $END_DATE" >> compliance-report.csv
-echo "" >> compliance-report.csv
-echo "Timestamp,User,Activity,Artifact" >> compliance-report.csv
-
-fab api "admin/activityEvents" \
-  -P startDateTime=$START_DATE,endDateTime=$END_DATE \
-  -q "value[?workspaceId=='$WS_ID']" | \
-  jq -r '.[] | [.CreationTime, .UserId, .Activity, .ArtifactName] | @csv' >> compliance-report.csv
-```
-
-## Real-Time Monitoring
-
-### Alert on Sensitive Operations
-
-```bash
-#!/bin/bash
-# Monitor for sensitive operations (run periodically)
-LAST_HOUR=$(date -d "1 hour ago" +%Y-%m-%dT%H:%M:%SZ)
-NOW=$(date +%Y-%m-%dT%H:%M:%SZ)
-
-# Check for bulk exports
-EXPORTS=$(fab api "admin/activityEvents" \
-  -P startDateTime=$LAST_HOUR,endDateTime=$NOW,activityType=ExportReport \
-  -q "value | length")
-
-if [ "$EXPORTS" -gt 10 ]; then
-  echo "ALERT: High export activity detected: $EXPORTS exports in last hour"
-  # Send alert notification
-fi
-
-# Check for permission escalations
-ADMIN_ADDS=$(fab api "admin/activityEvents" \
-  -P startDateTime=$LAST_HOUR,endDateTime=$NOW,activityType=AddWorkspaceUser \
-  -q "value[?contains(AdditionalData, 'Admin')] | length")
-
-if [ "$ADMIN_ADDS" -gt 0 ]; then
-  echo "ALERT: Admin permission granted: $ADMIN_ADDS new admins"
-fi
-```
-
-## Audit Log Retention
-
-### Export Logs for Long-Term Storage
-
-```bash
-#!/bin/bash
-# Export audit logs to storage
-MONTH=$(date +%Y-%m)
-START_DATE="${MONTH}-01T00:00:00Z"
-END_DATE=$(date -d "${MONTH}-01 +1 month -1 day" +%Y-%m-%dT23:59:59Z)
-
-# Get all activities for month
-fab api "admin/activityEvents" \
-  -P startDateTime=$START_DATE,endDateTime=$END_DATE \
-  -o /archive/audit-logs-$MONTH.json
-
-# Upload to lakehouse for analysis
-fab cp /archive/audit-logs-$MONTH.json "Audit.Workspace/AuditLogs.Lakehouse/Files/logs/"
-```
-
-## Purview Integration
-
-### Query Purview Audit Logs
-
-For comprehensive audit, use Microsoft Purview:
-
-```bash
-# Purview audit logs provide:
-# - 90+ days retention
-# - Advanced filtering
-# - Search across Microsoft 365
-
-# Access via Purview portal or API
-# https://compliance.microsoft.com/auditlogsearch
-```
-
-## Troubleshooting
-
-### No Activity Events Returned
-
-- Check date range format (ISO 8601 with Z suffix)
-- Verify you have Fabric Admin role
-- Events may have 15-30 minute delay
-
-### Activity Type Not Found
-
-```bash
-# List available activity types
-fab api "admin/activityEvents" \
-  -P startDateTime=2024-01-01T00:00:00Z,endDateTime=2024-01-02T00:00:00Z \
-  -q "value[].Activity | unique(@)"
-```
-
-### Rate Limiting
-
-- Audit API has rate limits
-- For large queries, paginate with continuation token
-- Consider exporting to lakehouse for analysis
diff --git a/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md b/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
deleted file mode 100644
index 52852f81b..000000000
--- a/.ai-assets/skills/fabric-cli-governance/references/capacity-operations.md
+++ /dev/null
@@ -1,253 +0,0 @@
-# Capacity Operations Reference
-
-Guide to managing Fabric capacities, workspace assignment, and capacity monitoring.
-
-## Understanding Capacities
-
-Fabric capacities are compute resources that power your workloads. Types include:
-
-| Capacity Type | Description | SKUs |
-|--------------|-------------|------|
-| Fabric Capacity | Full Fabric features | F2, F4, F8, F16, F32, F64, F128, F256, F512, F1024, F2048 |
-| Power BI Premium | Power BI focused | P1, P2, P3, P4, P5 |
-| Power BI Embedded | Embedding scenarios | A1-A6, EM1-EM3 |
-
-## Listing Capacities
-
-```bash
-# List all capacities (hidden entity)
-fab ls .capacities
-
-# List with details
-fab ls .capacities -l
-
-# Get specific capacity
-fab get ".capacities/FabricProd.Capacity"
-
-# Get capacity ID
-CAPACITY_ID=$(fab get ".capacities/FabricProd.Capacity" -q "id" | tr -d '"')
-```
-
-## Workspace Assignment
-
-### Assign Workspace to Capacity
-
-```bash
-# Assign using capacity ID
-CAPACITY_ID=$(fab get ".capacities/FabricProd.Capacity" -q "id" | tr -d '"')
-fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID
-
-# Force assignment (skip confirmation)
-fab assign "Production.Workspace" -P capacityId=$CAPACITY_ID -f
-```
-
-### Assign During Workspace Creation
-
-```bash
-# Create workspace on specific capacity (by name)
-fab mkdir "NewWorkspace.Workspace" -P capacityname=FabricProd
-
-# Create workspace with no capacity (shared)
-fab mkdir "NewWorkspace.Workspace" -P capacityname=none
-```
-
-### Unassign from Capacity
-
-```bash
-# Move workspace to shared capacity
-fab unassign "Production.Workspace"
-
-# Force unassignment
-fab unassign "Production.Workspace" -f
-```
-
-### Check Workspace Capacity Assignment
-
-```bash
-# Get workspace details including capacity
-fab get "Production.Workspace" -v
-
-# Query capacity assignment
-fab get "Production.Workspace" -q "capacityId"
-```
-
-## Capacity Administration via Azure
-
-### List Capacities in Subscription
-
-```bash
-SUBSCRIPTION_ID="<subscription-id>"
-
-# List all Fabric capacities
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
-
-# Filter by resource group
-RESOURCE_GROUP="<resource-group>"
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities?api-version=2023-11-01"
-```
-
-### Get Capacity Details
-
-```bash
-CAPACITY_NAME="fabricprod"
-
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01"
-```
-
-### Available SKUs
-
-```bash
-# List all available Fabric SKUs
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/skus?api-version=2023-11-01"
-
-# List SKUs available in specific location
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Fabric/locations/eastus/skus?api-version=2023-11-01"
-```
-
-## Capacity Operations
-
-### Pause Capacity
-
-```bash
-# Pause capacity (stops billing)
-fab api -A azure -X post "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/suspend?api-version=2023-11-01"
-```
-
-### Resume Capacity
-
-```bash
-# Resume paused capacity
-fab api -A azure -X post "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/resume?api-version=2023-11-01"
-```
-
-### Scale Capacity
-
-```bash
-# Scale to different SKU
-fab api -A azure -X patch "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME?api-version=2023-11-01" -i '{
-  "sku": {
-    "name": "F64",
-    "tier": "Fabric"
-  }
-}'
-```
-
-## Capacity Monitoring
-
-### Get Capacity Metrics
-
-```bash
-# Query capacity utilization metrics
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/providers/microsoft.insights/metrics?api-version=2023-10-01&metricnames=CapacityUtilization"
-```
-
-### Capacity Admin Portal
-
-```bash
-# Get capacity settings via admin API
-fab api "admin/capacities"
-
-# Get specific capacity
-fab api "admin/capacities/$CAPACITY_ID"
-
-# Get workspaces on capacity
-fab api "admin/capacities/$CAPACITY_ID/workspaces"
-```
-
-## Bulk Capacity Operations
-
-### Move Multiple Workspaces
-
-```bash
-#!/bin/bash
-CAPACITY_ID="<target-capacity-id>"
-WORKSPACES=("Dev.Workspace" "Test.Workspace" "Staging.Workspace")
-
-for WS in "${WORKSPACES[@]}"; do
-  fab assign "$WS" -P capacityId=$CAPACITY_ID -f
-  echo "Moved $WS to capacity"
-done
-```
-
-### Capacity Inventory
-
-```bash
-#!/bin/bash
-echo "Capacity,SKU,WorkspaceCount,State" > capacity-report.csv
-
-# Get all capacities
-for CAP in $(fab ls .capacities -q "value[].displayName"); do
-  CAP_ID=$(fab get ".capacities/$CAP.Capacity" -q "id" | tr -d '"')
-  SKU=$(fab get ".capacities/$CAP.Capacity" -q "sku.name")
-  STATE=$(fab get ".capacities/$CAP.Capacity" -q "state")
-  WS_COUNT=$(fab api "admin/capacities/$CAP_ID/workspaces" -q "value | length" 2>/dev/null || echo "0")
-  echo "$CAP,$SKU,$WS_COUNT,$STATE" >> capacity-report.csv
-done
-```
-
-### Evacuate Capacity (Move All Workspaces)
-
-```bash
-#!/bin/bash
-SOURCE_CAPACITY="OldCapacity"
-TARGET_CAPACITY_ID="<new-capacity-id>"
-
-SOURCE_ID=$(fab get ".capacities/$SOURCE_CAPACITY.Capacity" -q "id" | tr -d '"')
-
-# Get all workspaces on source capacity
-WORKSPACES=$(fab api "admin/capacities/$SOURCE_ID/workspaces" -q "value[].name")
-
-for WS in $WORKSPACES; do
-  fab assign "$WS.Workspace" -P capacityId=$TARGET_CAPACITY_ID -f
-  echo "Moved $WS"
-done
-```
-
-## Capacity Planning
-
-### SKU Comparison
-
-| SKU | CU/s | Memory | Best For |
-|-----|------|--------|----------|
-| F2 | 2 | 3 GB | Dev/test |
-| F4 | 4 | 6 GB | Small teams |
-| F8 | 8 | 12 GB | Medium workloads |
-| F16 | 16 | 24 GB | Production |
-| F32 | 32 | 48 GB | Large workloads |
-| F64+ | 64+ | 96 GB+ | Enterprise |
-
-### Check Capacity Availability
-
-```bash
-# Check if capacity has available resources
-fab get ".capacities/FabricProd.Capacity" -q "state"
-
-# Should return "Active" for healthy capacity
-```
-
-## Troubleshooting
-
-### Workspace Won't Assign
-
-```bash
-# Check capacity state
-fab get ".capacities/TargetCapacity.Capacity" -q "state"
-
-# Verify you have capacity admin rights
-fab api "admin/capacities/$CAPACITY_ID" -q "admins"
-```
-
-### Capacity at Limit
-
-```bash
-# Check current utilization
-fab api -A azure "subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Fabric/capacities/$CAPACITY_NAME/providers/microsoft.insights/metrics?api-version=2023-10-01&metricnames=CapacityUtilization"
-
-# Consider scaling up or moving workspaces
-```
-
-### Permission Errors
-
-- Capacity assignment requires workspace Admin role
-- Capacity administration requires Capacity Admin role
-- Azure operations require appropriate RBAC permissions
diff --git a/.ai-assets/skills/fabric-cli-governance/references/domain-management.md b/.ai-assets/skills/fabric-cli-governance/references/domain-management.md
deleted file mode 100644
index e804d29d2..000000000
--- a/.ai-assets/skills/fabric-cli-governance/references/domain-management.md
+++ /dev/null
@@ -1,277 +0,0 @@
-# Domain Management Reference
-
-Guide to creating and managing domains for organizing Fabric workspaces.
-
-## Understanding Domains
-
-Domains are logical containers that group workspaces by business function, department, or project. They enable:
-
-- Centralized governance policies
-- Delegated administration
-- Organized workspace discovery
-- Consistent security settings
-
-## Listing Domains
-
-```bash
-# List all domains (hidden entity)
-fab ls .domains
-
-# List with details
-fab ls .domains -l
-
-# Get specific domain
-fab get ".domains/Finance.Domain"
-
-# Get domain ID
-DOMAIN_ID=$(fab get ".domains/Finance.Domain" -q "id" | tr -d '"')
-```
-
-## Creating Domains
-
-### Basic Domain Creation
-
-```bash
-# Create domain via CLI
-fab mkdir ".domains/Analytics.Domain"
-
-# Create via API with description
-fab api -X post "admin/domains" -i '{
-  "displayName": "Analytics",
-  "description": "Analytics and BI team workspaces"
-}'
-```
-
-### Domain with Parent
-
-```bash
-# Create sub-domain
-fab api -X post "admin/domains" -i '{
-  "displayName": "Sales Analytics",
-  "description": "Sales team analytics",
-  "parentDomainId": "<parent-domain-id>"
-}'
-```
-
-## Managing Domain Workspaces
-
-### Assign Workspaces to Domain
-
-```bash
-# Get domain ID
-DOMAIN_ID=$(fab get ".domains/Analytics.Domain" -q "id" | tr -d '"')
-
-# Assign single workspace
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i "{
-  \"workspacesIds\": [\"$WS_ID\"]
-}"
-
-# Assign multiple workspaces
-fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i '{
-  "workspacesIds": ["<ws-id-1>", "<ws-id-2>", "<ws-id-3>"]
-}'
-```
-
-### List Workspaces in Domain
-
-```bash
-# Get all workspaces assigned to domain
-fab api "admin/domains/$DOMAIN_ID/workspaces"
-
-# Count workspaces
-fab api "admin/domains/$DOMAIN_ID/workspaces" -q "value | length"
-```
-
-### Unassign Workspace from Domain
-
-```bash
-fab api -X post "admin/domains/$DOMAIN_ID/unassignWorkspaces" -i "{
-  \"workspacesIds\": [\"$WS_ID\"]
-}"
-```
-
-## Domain Roles
-
-### Domain Admin Role
-
-Domain admins can:
-- Manage workspaces assigned to the domain
-- Assign domain roles to others
-- View all items in domain workspaces
-
-```bash
-# Add domain admin
-fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
-  "principals": [
-    {"id": "<user-object-id>", "type": "User"}
-  ],
-  "role": "Admins"
-}'
-
-# Add group as domain admin
-fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
-  "principals": [
-    {"id": "<group-object-id>", "type": "Group"}
-  ],
-  "role": "Admins"
-}'
-```
-
-### Domain Contributor Role
-
-Domain contributors can:
-- Create workspaces in the domain
-- View domain workspaces
-
-```bash
-fab api -X post "admin/domains/$DOMAIN_ID/roleAssignments" -i '{
-  "principals": [
-    {"id": "<user-object-id>", "type": "User"}
-  ],
-  "role": "Contributors"
-}'
-```
-
-### List Domain Role Assignments
-
-```bash
-# Get all role assignments
-fab api "admin/domains/$DOMAIN_ID/roleAssignments"
-
-# Get admins only
-fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?role=='Admins']"
-```
-
-### Remove Domain Role
-
-```bash
-# Get role assignment ID first
-ASSIGNMENT_ID=$(fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?principals[?id=='<user-id>']].id | [0]" | tr -d '"')
-
-# Remove role assignment
-fab api -X delete "admin/domains/$DOMAIN_ID/roleAssignments/$ASSIGNMENT_ID"
-```
-
-## Domain Configuration
-
-### Update Domain
-
-```bash
-# Update domain name and description
-fab api -X patch "admin/domains/$DOMAIN_ID" -i '{
-  "displayName": "Updated Name",
-  "description": "Updated description"
-}'
-```
-
-### Delete Domain
-
-```bash
-# Delete domain (workspaces become unassigned)
-fab api -X delete "admin/domains/$DOMAIN_ID"
-```
-
-## Domain Governance Patterns
-
-### Organize by Business Function
-
-```bash
-# Create department domains
-fab mkdir ".domains/Finance.Domain"
-fab mkdir ".domains/Marketing.Domain"
-fab mkdir ".domains/Sales.Domain"
-fab mkdir ".domains/Engineering.Domain"
-
-# Assign workspaces by department
-# Finance workspaces
-fab api -X post "admin/domains/<finance-domain-id>/assignWorkspaces" -i '{
-  "workspacesIds": ["<finance-ws-1>", "<finance-ws-2>"]
-}'
-```
-
-### Organize by Environment
-
-```bash
-# Create environment domains
-fab mkdir ".domains/Development.Domain"
-fab mkdir ".domains/Testing.Domain"
-fab mkdir ".domains/Production.Domain"
-```
-
-### Hierarchical Domain Structure
-
-```bash
-# Parent domain for division
-fab api -X post "admin/domains" -i '{
-  "displayName": "Data Platform"
-}'
-
-# Get parent domain ID
-PARENT_ID=$(fab get ".domains/DataPlatform.Domain" -q "id" | tr -d '"')
-
-# Child domains for teams
-fab api -X post "admin/domains" -i "{
-  \"displayName\": \"Data Engineering\",
-  \"parentDomainId\": \"$PARENT_ID\"
-}"
-
-fab api -X post "admin/domains" -i "{
-  \"displayName\": \"Data Science\",
-  \"parentDomainId\": \"$PARENT_ID\"
-}"
-```
-
-## Bulk Domain Operations
-
-### Assign All Team Workspaces
-
-```bash
-#!/bin/bash
-DOMAIN_ID="<domain-id>"
-TEAM_PREFIX="Analytics"
-
-# Find all workspaces starting with team prefix
-WS_IDS=$(fab api workspaces -q "value[?starts_with(displayName, '$TEAM_PREFIX')].id")
-
-# Convert to JSON array and assign
-echo "{\"workspacesIds\": $WS_IDS}" > /tmp/assign.json
-fab api -X post "admin/domains/$DOMAIN_ID/assignWorkspaces" -i /tmp/assign.json
-```
-
-### Domain Inventory Report
-
-```bash
-#!/bin/bash
-echo "Domain,WorkspaceCount,Admins" > domain-report.csv
-
-for DOMAIN in $(fab ls .domains -q "value[].displayName"); do
-  DOMAIN_ID=$(fab get ".domains/$DOMAIN.Domain" -q "id" | tr -d '"')
-  WS_COUNT=$(fab api "admin/domains/$DOMAIN_ID/workspaces" -q "value | length")
-  ADMIN_COUNT=$(fab api "admin/domains/$DOMAIN_ID/roleAssignments" -q "value[?role=='Admins'] | length")
-  echo "$DOMAIN,$WS_COUNT,$ADMIN_COUNT" >> domain-report.csv
-done
-```
-
-## Troubleshooting
-
-### Cannot Create Domain
-
-- Verify you have Fabric Admin role
-- Check tenant settings for domain creation
-
-### Cannot Assign Workspace
-
-- Verify workspace exists
-- Check if workspace is already assigned to another domain
-- Ensure you have domain admin role
-
-### Domain Not Visible
-
-```bash
-# Domains are hidden entities, use .domains prefix
-fab ls .domains -l
-
-# Or use admin API
-fab api "admin/domains"
-```
diff --git a/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md b/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
deleted file mode 100644
index aa47cf004..000000000
--- a/.ai-assets/skills/fabric-cli-governance/references/sensitivity-labels.md
+++ /dev/null
@@ -1,249 +0,0 @@
-# Sensitivity Labels Reference
-
-Guide to applying and managing Microsoft Purview sensitivity labels in Fabric.
-
-## Understanding Sensitivity Labels
-
-Sensitivity labels classify and protect data based on organizational policies:
-
-- **Public** — No restrictions
-- **Internal** — Organization-internal only
-- **Confidential** — Limited access
-- **Highly Confidential** — Strict access controls
-
-## Prerequisites
-
-- Sensitivity labels must be configured in Microsoft Purview
-- Labels must be published to users
-- User needs appropriate Fabric permissions
-
-## Listing Available Labels
-
-```bash
-# Get all available sensitivity labels
-fab api "admin/labels"
-
-# Query specific label
-fab api "admin/labels" -q "value[?name=='Confidential']"
-
-# Get label ID
-LABEL_ID=$(fab api "admin/labels" -q "value[?name=='Confidential'].id | [0]" | tr -d '"')
-```
-
-## Applying Labels
-
-### Apply Label to Item
-
-```bash
-# Get IDs
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-ITEM_ID=$(fab get "Production.Workspace/Sales.SemanticModel" -q "id" | tr -d '"')
-LABEL_ID="<label-id>"
-
-# Apply label
-fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
-  \"labelId\": \"$LABEL_ID\"
-}"
-```
-
-### Apply Label with Justification
-
-```bash
-# When downgrading label, justification may be required
-fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{
-  \"labelId\": \"$LABEL_ID\",
-  \"assignmentMethod\": \"Standard\",
-  \"justificationText\": \"Data has been declassified per policy\"
-}"
-```
-
-### Remove Label
-
-```bash
-# Remove label from item
-fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/removeLabel" -i '{}'
-```
-
-## Viewing Item Labels
-
-### Check Item Label
-
-```bash
-# Get item details including label
-fab get "Production.Workspace/Sales.SemanticModel" -v
-
-# Query label specifically
-fab get "Production.Workspace/Sales.SemanticModel" -q "sensitivityLabel"
-```
-
-### List Labeled Items in Workspace
-
-```bash
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-
-# Get all items with their labels
-fab api "workspaces/$WS_ID/items" -q "value[].{name: displayName, type: type, label: sensitivityLabel}"
-```
-
-## Bulk Label Operations
-
-### Apply Label to All Items
-
-```bash
-#!/bin/bash
-WORKSPACE="Production.Workspace"
-LABEL_ID="<confidential-label-id>"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Get all items
-ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[].id")
-
-for ITEM_ID in $ITEMS; do
-  ITEM_ID=$(echo $ITEM_ID | tr -d '"')
-  fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}" 2>/dev/null && \
-    echo "Labeled item $ITEM_ID" || echo "Failed to label $ITEM_ID"
-done
-```
-
-### Apply Label by Item Type
-
-```bash
-#!/bin/bash
-WORKSPACE="Production.Workspace"
-LABEL_ID="<label-id>"
-ITEM_TYPE="SemanticModel"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Get items of specific type
-ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[?type=='$ITEM_TYPE'].id")
-
-for ITEM_ID in $ITEMS; do
-  ITEM_ID=$(echo $ITEM_ID | tr -d '"')
-  fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
-  echo "Applied label to $ITEM_ID"
-done
-```
-
-### Label Audit Report
-
-```bash
-#!/bin/bash
-echo "Workspace,Item,Type,Label" > label-audit.csv
-
-for WS in $(fab ls -q "value[].displayName"); do
-  WS_ID=$(fab get "$WS.Workspace" -q "id" | tr -d '"')
-  
-  fab api "workspaces/$WS_ID/items" -q "value[]" | \
-  jq -r ".[] | [\"$WS\", .displayName, .type, (.sensitivityLabel.labelId // \"none\")] | @csv" >> label-audit.csv
-done
-```
-
-## Label Policies
-
-### Mandatory Labeling
-
-When mandatory labeling is enabled:
-
-```bash
-# All new items must have labels
-# Use --label parameter when creating (if supported)
-# Or apply immediately after creation
-
-# Create item
-fab mkdir "Production.Workspace/NewModel.SemanticModel"
-
-# Apply label
-WS_ID=$(fab get "Production.Workspace" -q "id" | tr -d '"')
-ITEM_ID=$(fab get "Production.Workspace/NewModel.SemanticModel" -q "id" | tr -d '"')
-fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$LABEL_ID\"}"
-```
-
-### Label Inheritance
-
-Labels can be inherited from:
-- Parent workspace
-- Source item (when copying)
-- Data source
-
-```bash
-# When copying items, label may be inherited
-fab cp "Source.Workspace/LabeledModel.SemanticModel" "Target.Workspace"
-
-# Verify label was inherited
-fab get "Target.Workspace/LabeledModel.SemanticModel" -q "sensitivityLabel"
-```
-
-## Label Encryption
-
-### Encrypted Labels
-
-Some labels apply encryption:
-
-```bash
-# Items with encrypted labels have restricted access
-# Verify label encryption settings
-fab api "admin/labels" -q "value[?name=='HighlyConfidential'].encryptionEnabled"
-```
-
-### Impact on Operations
-
-- Encrypted items may require additional permissions
-- Export operations may be blocked
-- Sharing may be restricted
-
-## Compliance Scenarios
-
-### Financial Data Classification
-
-```bash
-#!/bin/bash
-# Apply financial data labels
-FINANCIAL_LABEL=$(fab api "admin/labels" -q "value[?name=='Financial-Confidential'].id | [0]" | tr -d '"')
-
-# Label all financial workspaces
-for WS in Finance-Prod Finance-Dev Finance-Reports; do
-  WS_ID=$(fab get "$WS.Workspace" -q "id" | tr -d '"')
-  ITEMS=$(fab api "workspaces/$WS_ID/items" -q "value[].id")
-  
-  for ITEM_ID in $ITEMS; do
-    fab api -X post "workspaces/$WS_ID/items/$ITEM_ID/applyLabel" -i "{\"labelId\": \"$FINANCIAL_LABEL\"}" 2>/dev/null
-  done
-done
-```
-
-### PII Data Protection
-
-```bash
-# Find items potentially containing PII
-# Apply appropriate label
-PII_LABEL=$(fab api "admin/labels" -q "value[?name=='PII-Restricted'].id | [0]" | tr -d '"')
-
-# Apply to customer data items
-fab api -X post "workspaces/$WS_ID/items/$CUSTOMER_DATA_ID/applyLabel" -i "{\"labelId\": \"$PII_LABEL\"}"
-```
-
-## Troubleshooting
-
-### Label Not Available
-
-```bash
-# Check if label is published to you
-fab api "admin/labels"
-
-# Contact Purview admin if label not visible
-```
-
-### Cannot Apply Label
-
-- Verify you have Write permission on item
-- Check if downgrade requires justification
-- Ensure label is in your scope
-
-### Label Conflicts
-
-```bash
-# When importing items with different labels
-# The import may fail or require resolution
-# Check current label before import
-fab get "Target.Workspace/ExistingItem.SemanticModel" -q "sensitivityLabel"
-```
diff --git a/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md b/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
deleted file mode 100644
index 65f2ff441..000000000
--- a/.ai-assets/skills/fabric-cli-governance/references/workspace-permissions.md
+++ /dev/null
@@ -1,249 +0,0 @@
-# Workspace Permissions Reference
-
-Comprehensive guide to managing workspace and item permissions with the Fabric CLI.
-
-## Workspace Role Capabilities
-
-### Admin Role
-
-```bash
-# Full capabilities:
-# - Delete workspace
-# - Add/remove all roles
-# - Manage permissions
-# - All Member capabilities
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Admin
-```
-
-### Member Role
-
-```bash
-# Capabilities:
-# - Create/modify/delete items
-# - Share items with others
-# - Add Contributors and Viewers
-# - Cannot add Admins or Members
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Member
-```
-
-### Contributor Role
-
-```bash
-# Capabilities:
-# - Create/modify/delete items
-# - Cannot share items
-# - Cannot manage permissions
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
-```
-
-### Viewer Role
-
-```bash
-# Capabilities:
-# - View all items
-# - Run queries (SQL/DAX)
-# - Cannot modify items
-# - Cannot access OneLake directly
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Viewer
-```
-
-## Principal Types
-
-### User Principals
-
-```bash
-# Add individual user
-fab acl set "Workspace.Workspace" -P principal=user@company.com,role=Contributor
-
-# Using object ID
-fab acl set "Workspace.Workspace" -P principal=<user-object-id>,role=Contributor,principalType=User
-```
-
-### Security Groups
-
-```bash
-# Add security group (recommended for scale)
-fab acl set "Workspace.Workspace" -P principal=DataEngineers@company.com,role=Contributor,principalType=Group
-
-# Using group object ID
-fab acl set "Workspace.Workspace" -P principal=<group-object-id>,role=Viewer,principalType=Group
-```
-
-### Service Principals
-
-```bash
-# Add service principal (for automation)
-fab acl set "Workspace.Workspace" -P principal=<app-id>,role=Contributor,principalType=App
-
-# Service principal for CI/CD
-fab acl set "Production.Workspace" -P principal=<cicd-app-id>,role=Member,principalType=App
-```
-
-## Viewing Permissions
-
-### List All Permissions
-
-```bash
-# Basic listing
-fab acl get "Workspace.Workspace"
-
-# Detailed output
-fab acl get "Workspace.Workspace" -l
-
-# JSON output for parsing
-fab acl get "Workspace.Workspace" -o json
-```
-
-### Filter Permissions
-
-```bash
-# Get admins only
-fab acl get "Workspace.Workspace" -q "value[?role=='Admin']"
-
-# Get service principals
-fab acl get "Workspace.Workspace" -q "value[?principalType=='App']"
-
-# Get specific user
-fab acl get "Workspace.Workspace" -q "value[?principal=='user@company.com']"
-```
-
-## Removing Permissions
-
-```bash
-# Remove user
-fab acl del "Workspace.Workspace" -P principal=user@company.com
-
-# Remove with force (no confirmation)
-fab acl del "Workspace.Workspace" -P principal=user@company.com -f
-
-# Remove service principal
-fab acl del "Workspace.Workspace" -P principal=<app-id>
-```
-
-## Item-Level Permissions
-
-### Share Semantic Model
-
-```bash
-# Read permission (view only)
-fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Read
-
-# Build permission (connect and create reports)
-fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Build
-
-# Write permission (full access)
-fab acl set "Workspace.Workspace/Model.SemanticModel" -P principal=user@company.com,role=Write
-```
-
-### Share Report
-
-```bash
-# Share report for viewing
-fab acl set "Workspace.Workspace/Report.Report" -P principal=user@company.com,role=Read
-
-# Share with edit permission
-fab acl set "Workspace.Workspace/Report.Report" -P principal=user@company.com,role=Write
-```
-
-### Share Lakehouse
-
-```bash
-# Read access
-fab acl set "Workspace.Workspace/LH.Lakehouse" -P principal=user@company.com,role=Read
-
-# Full data access
-fab acl set "Workspace.Workspace/LH.Lakehouse" -P principal=user@company.com,role=ReadAll
-```
-
-## Bulk Operations
-
-### Add Multiple Users
-
-```bash
-#!/bin/bash
-WORKSPACE="Production.Workspace"
-ROLE="Viewer"
-
-# Users file: one email per line
-while read USER; do
-  fab acl set "$WORKSPACE" -P principal=$USER,role=$ROLE -f
-  echo "Added $USER as $ROLE"
-done < users.txt
-```
-
-### Clone Permissions Between Workspaces
-
-```bash
-#!/bin/bash
-SOURCE_WS="Dev.Workspace"
-TARGET_WS="Test.Workspace"
-
-# Export source permissions
-fab acl get "$SOURCE_WS" -o json > /tmp/permissions.json
-
-# Apply to target (parse and apply each)
-jq -r '.value[] | [.principal, .role, .principalType] | @tsv' /tmp/permissions.json | \
-while IFS=$'\t' read -r PRINCIPAL ROLE TYPE; do
-  fab acl set "$TARGET_WS" -P principal=$PRINCIPAL,role=$ROLE,principalType=$TYPE -f
-done
-```
-
-### Audit All Workspace Permissions
-
-```bash
-#!/bin/bash
-# Generate permission report across all workspaces
-echo "Workspace,Principal,Role,Type" > permissions-audit.csv
-
-for WS in $(fab ls -q "value[].displayName"); do
-  fab acl get "$WS.Workspace" -o json | \
-  jq -r ".value[] | [\"$WS\", .principal, .role, .principalType] | @csv" >> permissions-audit.csv
-done
-```
-
-## Permission Inheritance
-
-### Workspace to Item
-
-- Workspace Admins/Members/Contributors → Full item access
-- Workspace Viewers → Read-only item access
-- Item-level permissions can extend (not restrict) workspace permissions
-
-### Sharing with External Users
-
-```bash
-# External sharing must be enabled by admin
-# Then share with external user
-fab acl set "Workspace.Workspace/Report.Report" -P principal=external@partner.com,role=Read
-```
-
-## Troubleshooting
-
-### Permission Denied Errors
-
-```bash
-# Check your current permissions
-fab acl get "Workspace.Workspace" -q "value[?principal=='<your-email>']"
-
-# Verify authentication
-fab auth status
-```
-
-### Cannot Add Permissions
-
-```bash
-# Verify you have Admin or Member role
-fab acl get "Workspace.Workspace" -l
-
-# Check if user exists in tenant
-# Contact Azure AD admin if user not found
-```
-
-### Service Principal Access Issues
-
-```bash
-# Verify SPN has Fabric API permissions in Azure AD
-# Check tenant admin settings for SPN access to Fabric
-# Ensure SPN is added with correct principalType=App
-fab acl set "Workspace.Workspace" -P principal=<app-id>,role=Contributor,principalType=App
-```
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py b/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
deleted file mode 100644
index 2b80ecca3..000000000
--- a/.ai-assets/skills/fabric-cli-governance/scripts/audit_workspace.py
+++ /dev/null
@@ -1,299 +0,0 @@
-#!/usr/bin/env python3
-"""
-audit_workspace.py - Generate comprehensive workspace audit report
-
-This script generates a comprehensive audit report for a Microsoft Fabric workspace,
-including permissions, item inventory, capacity assignment, and more.
-
-Usage:
-    python audit_workspace.py <workspace> -o <report.json>
-    python audit_workspace.py Production.Workspace -o audit_report.json
-
-Exit codes:
-    0 - Audit completed successfully
-    1 - Error during audit
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from datetime import datetime
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI, handling potential formatting issues."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def get_workspace_details(workspace: str) -> Dict[str, Any]:
-    """Get workspace metadata."""
-    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        return parse_json_output(stdout) or {"error": "Failed to parse workspace details"}
-    return {"error": stderr.strip() or "Failed to get workspace details"}
-
-
-def get_workspace_permissions(workspace: str) -> List[Dict[str, Any]]:
-    """Get all workspace permissions."""
-    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, list):
-            return result
-        return []
-    return []
-
-
-def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
-    """Get all items in the workspace."""
-    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, list):
-            return result
-        return []
-    return []
-
-
-def get_item_type_summary(items: List[Dict[str, Any]]) -> Dict[str, int]:
-    """Summarize items by type."""
-    type_counts = {}
-    for item in items:
-        item_type = item.get("type", "Unknown")
-        type_counts[item_type] = type_counts.get(item_type, 0) + 1
-    return type_counts
-
-
-def get_capacity_info(workspace_details: Dict[str, Any]) -> Dict[str, Any]:
-    """Extract capacity information from workspace details."""
-    capacity_info = {
-        "capacity_id": workspace_details.get("capacityId"),
-        "capacity_assigned": workspace_details.get("capacityId") is not None
-    }
-    return capacity_info
-
-
-def check_item_labels(workspace: str, items: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Check sensitivity labels on items."""
-    labeled_items = []
-    unlabeled_items = []
-    
-    for item in items:
-        item_name = item.get("name", "Unknown")
-        item_type = item.get("type", "Unknown")
-        item_path = f"{workspace}/{item_name}.{item_type}"
-        
-        # Try to get label info (this may not be available for all items)
-        exit_code, stdout, stderr = run_fab_command(["get", item_path, "-q", "sensitivityLabel", "-f", "json"])
-        
-        if exit_code == 0 and stdout.strip() and stdout.strip() != "null":
-            labeled_items.append({
-                "name": item_name,
-                "type": item_type,
-                "label": parse_json_output(stdout)
-            })
-        else:
-            unlabeled_items.append({
-                "name": item_name,
-                "type": item_type
-            })
-    
-    return {
-        "total_items": len(items),
-        "labeled_count": len(labeled_items),
-        "unlabeled_count": len(unlabeled_items),
-        "labeled_items": labeled_items,
-        "unlabeled_items": unlabeled_items
-    }
-
-
-def generate_audit_report(workspace: str, check_labels: bool = False) -> Dict[str, Any]:
-    """Generate comprehensive audit report for workspace."""
-    workspace = ensure_workspace_suffix(workspace)
-    
-    report = {
-        "audit_metadata": {
-            "workspace": workspace,
-            "generated_at": datetime.utcnow().isoformat() + "Z",
-            "audit_version": "1.0.0"
-        },
-        "workspace_details": {},
-        "permissions": {
-            "summary": {},
-            "details": []
-        },
-        "items": {
-            "summary": {},
-            "by_type": {},
-            "details": []
-        },
-        "capacity": {},
-        "labels": {},
-        "issues": []
-    }
-    
-    print(f"Auditing workspace: {workspace}")
-    
-    # Get workspace details
-    print("  Fetching workspace details...")
-    workspace_details = get_workspace_details(workspace)
-    if "error" in workspace_details:
-        report["issues"].append({
-            "severity": "high",
-            "message": f"Failed to get workspace details: {workspace_details['error']}"
-        })
-        report["workspace_details"] = {"error": workspace_details["error"]}
-    else:
-        report["workspace_details"] = workspace_details
-        report["capacity"] = get_capacity_info(workspace_details)
-    
-    # Get permissions
-    print("  Fetching permissions...")
-    permissions = get_workspace_permissions(workspace)
-    report["permissions"]["details"] = permissions
-    report["permissions"]["summary"] = {
-        "total_principals": len(permissions),
-        "by_role": {}
-    }
-    
-    for perm in permissions:
-        role = perm.get("role", "Unknown")
-        report["permissions"]["summary"]["by_role"][role] = \
-            report["permissions"]["summary"]["by_role"].get(role, 0) + 1
-    
-    # Get items
-    print("  Fetching items...")
-    items = get_workspace_items(workspace)
-    report["items"]["details"] = items
-    report["items"]["summary"]["total_items"] = len(items)
-    report["items"]["by_type"] = get_item_type_summary(items)
-    
-    # Check labels (optional - can be slow)
-    if check_labels:
-        print("  Checking sensitivity labels...")
-        report["labels"] = check_item_labels(workspace, items)
-    else:
-        report["labels"] = {"note": "Label check skipped. Use --check-labels to include."}
-    
-    # Check for potential issues
-    if not report["capacity"].get("capacity_assigned"):
-        report["issues"].append({
-            "severity": "medium",
-            "message": "Workspace is not assigned to a capacity"
-        })
-    
-    if report["permissions"]["summary"]["total_principals"] == 0:
-        report["issues"].append({
-            "severity": "high",
-            "message": "No permissions found for workspace"
-        })
-    
-    print(f"  Audit complete. Found {len(report['issues'])} issue(s).")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Generate comprehensive workspace audit report",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python audit_workspace.py Production.Workspace -o audit_report.json
-    python audit_workspace.py Dev.Workspace -o audit.json --check-labels
-    python audit_workspace.py "My Workspace" -o report.json
-        """
-    )
-    parser.add_argument(
-        "workspace",
-        help="Workspace name or path to audit"
-    )
-    parser.add_argument(
-        "-o", "--output",
-        required=True,
-        help="Output file path for the audit report (JSON)"
-    )
-    parser.add_argument(
-        "--check-labels",
-        action="store_true",
-        help="Include sensitivity label check (can be slow for large workspaces)"
-    )
-    parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Print report to stdout in addition to file"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        report = generate_audit_report(args.workspace, check_labels=args.check_labels)
-        
-        # Write to file
-        with open(args.output, "w", encoding="utf-8") as f:
-            json.dump(report, f, indent=2)
-        
-        print(f"\nAudit report saved to: {args.output}")
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("AUDIT SUMMARY")
-        print("=" * 50)
-        print(f"Workspace: {report['audit_metadata']['workspace']}")
-        print(f"Total Items: {report['items']['summary'].get('total_items', 0)}")
-        print(f"Total Principals: {report['permissions']['summary'].get('total_principals', 0)}")
-        print(f"Capacity Assigned: {report['capacity'].get('capacity_assigned', 'Unknown')}")
-        print(f"Issues Found: {len(report['issues'])}")
-        
-        if report["issues"]:
-            print("\nIssues:")
-            for issue in report["issues"]:
-                print(f"  [{issue['severity'].upper()}] {issue['message']}")
-        
-        print("=" * 50)
-        
-        sys.exit(0 if len(report["issues"]) == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py b/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
deleted file mode 100644
index a47bb9fde..000000000
--- a/.ai-assets/skills/fabric-cli-governance/scripts/bulk_permissions.py
+++ /dev/null
@@ -1,379 +0,0 @@
-#!/usr/bin/env python3
-"""
-bulk_permissions.py - Apply permissions from CSV/JSON file
-
-This script applies workspace permissions in bulk from a structured input file.
-It supports CSV and JSON formats and provides dry-run capability.
-
-Usage:
-    python bulk_permissions.py <workspace> -i <perms.csv>
-    python bulk_permissions.py Production.Workspace -i permissions.csv --dry-run
-
-Input CSV format:
-    principal,role,principalType
-    user@company.com,Contributor,User
-    DataTeam@company.com,Viewer,Group
-
-Input JSON format:
-    [
-        {"principal": "user@company.com", "role": "Contributor", "principalType": "User"},
-        {"principal": "DataTeam@company.com", "role": "Viewer", "principalType": "Group"}
-    ]
-
-Exit codes:
-    0 - All permissions applied successfully
-    1 - Some permissions failed to apply
-"""
-
-import argparse
-import csv
-import json
-import subprocess
-import sys
-from pathlib import Path
-from typing import Dict, Any, List
-
-
-# Valid roles for workspace permissions
-VALID_ROLES = ["Admin", "Member", "Contributor", "Viewer"]
-
-# Valid principal types
-VALID_PRINCIPAL_TYPES = ["User", "Group", "ServicePrincipal"]
-
-
-def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def check_workspace_exists(workspace: str) -> bool:
-    """Check if workspace exists."""
-    exit_code, _, _ = run_fab_command(["exists", workspace])
-    return exit_code == 0
-
-
-def load_permissions_csv(file_path: str) -> List[Dict[str, str]]:
-    """Load permissions from CSV file."""
-    permissions = []
-    with open(file_path, "r", encoding="utf-8-sig") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            # Normalize column names (handle case variations)
-            normalized = {}
-            for key, value in row.items():
-                key_lower = key.lower().strip()
-                if key_lower in ["principal", "principalid", "principal_id"]:
-                    normalized["principal"] = value.strip()
-                elif key_lower in ["role", "rolename", "role_name"]:
-                    normalized["role"] = value.strip()
-                elif key_lower in ["principaltype", "principal_type", "type"]:
-                    normalized["principalType"] = value.strip()
-            
-            if normalized.get("principal") and normalized.get("role"):
-                permissions.append(normalized)
-    
-    return permissions
-
-
-def load_permissions_json(file_path: str) -> List[Dict[str, str]]:
-    """Load permissions from JSON file."""
-    with open(file_path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    
-    if isinstance(data, list):
-        return data
-    elif isinstance(data, dict) and "permissions" in data:
-        return data["permissions"]
-    else:
-        raise ValueError("JSON must be an array or object with 'permissions' array")
-
-
-def load_permissions(file_path: str) -> List[Dict[str, str]]:
-    """Load permissions from file (auto-detect format)."""
-    path = Path(file_path)
-    
-    if not path.exists():
-        raise FileNotFoundError(f"File not found: {file_path}")
-    
-    suffix = path.suffix.lower()
-    
-    if suffix == ".csv":
-        return load_permissions_csv(file_path)
-    elif suffix == ".json":
-        return load_permissions_json(file_path)
-    else:
-        # Try JSON first, then CSV
-        try:
-            return load_permissions_json(file_path)
-        except (json.JSONDecodeError, ValueError):
-            return load_permissions_csv(file_path)
-
-
-def validate_permission(perm: Dict[str, str], index: int) -> List[str]:
-    """Validate a permission entry. Returns list of errors."""
-    errors = []
-    
-    if not perm.get("principal"):
-        errors.append(f"Row {index + 1}: Missing 'principal' field")
-    
-    if not perm.get("role"):
-        errors.append(f"Row {index + 1}: Missing 'role' field")
-    elif perm["role"] not in VALID_ROLES:
-        errors.append(f"Row {index + 1}: Invalid role '{perm['role']}'. Valid roles: {', '.join(VALID_ROLES)}")
-    
-    principal_type = perm.get("principalType", "User")
-    if principal_type not in VALID_PRINCIPAL_TYPES:
-        errors.append(f"Row {index + 1}: Invalid principalType '{principal_type}'. Valid types: {', '.join(VALID_PRINCIPAL_TYPES)}")
-    
-    return errors
-
-
-def get_current_permissions(workspace: str) -> List[Dict[str, Any]]:
-    """Get current workspace permissions."""
-    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        try:
-            result = json.loads(stdout.strip())
-            if isinstance(result, list):
-                return result
-        except json.JSONDecodeError:
-            pass
-    
-    return []
-
-
-def apply_permission(workspace: str, principal: str, role: str, principal_type: str = "User") -> Dict[str, Any]:
-    """Apply a single permission to the workspace."""
-    result = {
-        "principal": principal,
-        "role": role,
-        "principalType": principal_type,
-        "status": "unknown",
-        "message": ""
-    }
-    
-    # Build the acl set command
-    cmd = ["acl", "set", workspace, "-p", principal, "-r", role, "-t", principal_type, "-f"]
-    
-    exit_code, stdout, stderr = run_fab_command(cmd)
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = f"Permission set: {principal} -> {role}"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or "Failed to set permission"
-    
-    return result
-
-
-def bulk_apply_permissions(
-    workspace: str,
-    permissions: List[Dict[str, str]],
-    dry_run: bool = False,
-    skip_validation: bool = False
-) -> Dict[str, Any]:
-    """Apply permissions in bulk to the workspace."""
-    
-    workspace = ensure_workspace_suffix(workspace)
-    
-    report = {
-        "workspace": workspace,
-        "dry_run": dry_run,
-        "total_permissions": len(permissions),
-        "validation_errors": [],
-        "results": [],
-        "summary": {
-            "success": 0,
-            "failed": 0,
-            "skipped": 0
-        }
-    }
-    
-    # Validate all permissions first
-    if not skip_validation:
-        print("Validating permissions...")
-        for i, perm in enumerate(permissions):
-            errors = validate_permission(perm, i)
-            report["validation_errors"].extend(errors)
-        
-        if report["validation_errors"]:
-            print(f"  Found {len(report['validation_errors'])} validation error(s)")
-            for error in report["validation_errors"]:
-                print(f"    - {error}")
-            return report
-        
-        print(f"  All {len(permissions)} permission(s) validated successfully")
-    
-    # Check workspace exists
-    print(f"\nVerifying workspace: {workspace}")
-    if not check_workspace_exists(workspace):
-        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
-        report["validation_errors"].append(f"Workspace not found: {workspace}")
-        return report
-    print("  Workspace found")
-    
-    # Get current permissions for comparison
-    current_perms = get_current_permissions(workspace)
-    current_lookup = {p.get("principal", {}).get("id", ""): p.get("role") for p in current_perms}
-    
-    if dry_run:
-        print(f"\n[DRY RUN] Would apply the following permissions:")
-        for perm in permissions:
-            principal = perm["principal"]
-            role = perm["role"]
-            principal_type = perm.get("principalType", "User")
-            print(f"  {principal} ({principal_type}) -> {role}")
-        return report
-    
-    # Apply each permission
-    print(f"\nApplying {len(permissions)} permission(s)...")
-    for perm in permissions:
-        principal = perm["principal"]
-        role = perm["role"]
-        principal_type = perm.get("principalType", "User")
-        
-        print(f"\n  Setting permission: {principal} -> {role}")
-        result = apply_permission(workspace, principal, role, principal_type)
-        report["results"].append(result)
-        
-        if result["status"] == "success":
-            report["summary"]["success"] += 1
-            print(f"    ✓ {result['message']}")
-        else:
-            report["summary"]["failed"] += 1
-            print(f"    ✗ {result['message']}")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Apply permissions from CSV/JSON file to a workspace",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python bulk_permissions.py Production.Workspace -i permissions.csv
-    python bulk_permissions.py Production.Workspace -i permissions.json --dry-run
-    python bulk_permissions.py "My Workspace" -i perms.csv
-
-Input CSV format:
-    principal,role,principalType
-    user@company.com,Contributor,User
-    DataTeam@company.com,Viewer,Group
-    12345678-1234-1234-1234-123456789abc,Admin,ServicePrincipal
-
-Input JSON format:
-    [
-        {"principal": "user@company.com", "role": "Contributor", "principalType": "User"},
-        {"principal": "DataTeam@company.com", "role": "Viewer", "principalType": "Group"}
-    ]
-
-Valid Roles:
-    Admin, Member, Contributor, Viewer
-
-Valid Principal Types:
-    User, Group, ServicePrincipal
-        """
-    )
-    parser.add_argument(
-        "workspace",
-        help="Workspace name or path to apply permissions to"
-    )
-    parser.add_argument(
-        "-i", "--input",
-        required=True,
-        help="Input file path (CSV or JSON)"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview changes without applying them"
-    )
-    parser.add_argument(
-        "--skip-validation",
-        action="store_true",
-        help="Skip validation of permission entries"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        # Load permissions from file
-        print(f"Loading permissions from: {args.input}")
-        permissions = load_permissions(args.input)
-        print(f"  Loaded {len(permissions)} permission(s)")
-        
-        if not permissions:
-            print("No permissions found in input file")
-            sys.exit(1)
-        
-        # Apply permissions
-        report = bulk_apply_permissions(
-            workspace=args.workspace,
-            permissions=permissions,
-            dry_run=args.dry_run,
-            skip_validation=args.skip_validation
-        )
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("BULK PERMISSIONS SUMMARY")
-        print("=" * 50)
-        print(f"Workspace: {report['workspace']}")
-        print(f"Dry Run: {report['dry_run']}")
-        print(f"Total Permissions: {report['total_permissions']}")
-        
-        if report["validation_errors"]:
-            print(f"Validation Errors: {len(report['validation_errors'])}")
-        else:
-            print(f"\nResults:")
-            print(f"  Success: {report['summary']['success']}")
-            print(f"  Failed: {report['summary']['failed']}")
-            print(f"  Skipped: {report['summary']['skipped']}")
-        
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        # Exit code based on failures
-        has_errors = len(report["validation_errors"]) > 0 or report["summary"]["failed"] > 0
-        sys.exit(1 if has_errors else 0)
-        
-    except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py b/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
deleted file mode 100644
index a9f53d6f2..000000000
--- a/.ai-assets/skills/fabric-cli-governance/scripts/validate_governance.py
+++ /dev/null
@@ -1,688 +0,0 @@
-#!/usr/bin/env python3
-"""
-validate_governance.py - Check workspace against governance rules
-
-This script validates a Microsoft Fabric workspace against a set of governance rules
-defined in a JSON configuration file.
-
-Usage:
-    python validate_governance.py <workspace> --rules <rules.json>
-    python validate_governance.py Production.Workspace --rules company-rules.json
-
-Exit codes:
-    0 - All governance checks passed
-    1 - Governance violations found or error occurred
-"""
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI, handling potential formatting issues."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def load_rules(rules_file: str) -> Dict[str, Any]:
-    """Load governance rules from JSON file."""
-    path = Path(rules_file)
-    
-    if not path.exists():
-        raise FileNotFoundError(f"Rules file not found: {rules_file}")
-    
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def get_workspace_details(workspace: str) -> Dict[str, Any]:
-    """Get workspace metadata."""
-    exit_code, stdout, stderr = run_fab_command(["get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        return parse_json_output(stdout) or {"error": "Failed to parse workspace details"}
-    return {"error": stderr.strip() or "Failed to get workspace details"}
-
-
-def get_workspace_permissions(workspace: str) -> List[Dict[str, Any]]:
-    """Get all workspace permissions."""
-    exit_code, stdout, stderr = run_fab_command(["acl", "get", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, list):
-            return result
-        return []
-    return []
-
-
-def get_workspace_items(workspace: str) -> List[Dict[str, Any]]:
-    """Get all items in the workspace."""
-    exit_code, stdout, stderr = run_fab_command(["ls", workspace, "-l", "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, list):
-            return result
-        return []
-    return []
-
-
-def get_item_labels(workspace: str) -> List[Dict[str, Any]]:
-    """Get sensitivity labels for items in workspace."""
-    exit_code, stdout, stderr = run_fab_command(["labels", "list", workspace, "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, list):
-            return result
-        return []
-    return []
-
-
-class GovernanceValidator:
-    """Validates workspace against governance rules."""
-    
-    def __init__(self, workspace: str, rules: Dict[str, Any], verbose: bool = False):
-        self.workspace = ensure_workspace_suffix(workspace)
-        self.rules = rules
-        self.verbose = verbose
-        self.violations: List[Dict[str, Any]] = []
-        self.warnings: List[Dict[str, Any]] = []
-        self.passed_checks: List[str] = []
-        
-        # Cached data
-        self.workspace_details: Optional[Dict[str, Any]] = None
-        self.permissions: Optional[List[Dict[str, Any]]] = None
-        self.items: Optional[List[Dict[str, Any]]] = None
-        self.labels: Optional[List[Dict[str, Any]]] = None
-    
-    def log(self, message: str):
-        """Print message if verbose mode is enabled."""
-        if self.verbose:
-            print(message, file=sys.stderr)
-    
-    def add_violation(self, rule: str, message: str, severity: str = "error", details: Any = None):
-        """Add a governance violation."""
-        self.violations.append({
-            "rule": rule,
-            "message": message,
-            "severity": severity,
-            "details": details
-        })
-    
-    def add_warning(self, rule: str, message: str, details: Any = None):
-        """Add a governance warning."""
-        self.warnings.append({
-            "rule": rule,
-            "message": message,
-            "details": details
-        })
-    
-    def add_passed(self, rule: str):
-        """Mark a rule as passed."""
-        self.passed_checks.append(rule)
-    
-    def load_workspace_data(self) -> bool:
-        """Load all workspace data needed for validation."""
-        self.log(f"Loading workspace data for: {self.workspace}")
-        
-        # Get workspace details
-        self.log("  Fetching workspace details...")
-        self.workspace_details = get_workspace_details(self.workspace)
-        if "error" in self.workspace_details:
-            print(f"Error: Failed to get workspace details: {self.workspace_details['error']}", file=sys.stderr)
-            return False
-        
-        # Get permissions
-        self.log("  Fetching permissions...")
-        self.permissions = get_workspace_permissions(self.workspace)
-        
-        # Get items
-        self.log("  Fetching items...")
-        self.items = get_workspace_items(self.workspace)
-        
-        # Get labels (optional - may not be available)
-        self.log("  Fetching labels...")
-        self.labels = get_item_labels(self.workspace)
-        
-        return True
-    
-    def validate_capacity_assignment(self):
-        """Check if workspace has required capacity assignment."""
-        rule_name = "capacity_assignment"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        capacity_id = self.workspace_details.get("capacityId")
-        
-        if rule_config.get("required", False) and not capacity_id:
-            self.add_violation(
-                rule_name,
-                "Workspace must be assigned to a capacity",
-                severity="error"
-            )
-            return
-        
-        allowed_capacities = rule_config.get("allowed_capacities", [])
-        if allowed_capacities and capacity_id not in allowed_capacities:
-            self.add_violation(
-                rule_name,
-                f"Workspace capacity '{capacity_id}' not in allowed list",
-                severity="error",
-                details={"current": capacity_id, "allowed": allowed_capacities}
-            )
-            return
-        
-        self.add_passed(rule_name)
-    
-    def validate_naming_conventions(self):
-        """Check workspace and item naming conventions."""
-        rule_name = "naming_conventions"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        violations_found = False
-        
-        # Check workspace name pattern
-        workspace_pattern = rule_config.get("workspace_pattern")
-        if workspace_pattern:
-            workspace_name = self.workspace.replace(".Workspace", "")
-            if not re.match(workspace_pattern, workspace_name):
-                self.add_violation(
-                    rule_name,
-                    f"Workspace name '{workspace_name}' does not match pattern '{workspace_pattern}'",
-                    severity="error"
-                )
-                violations_found = True
-        
-        # Check item name patterns
-        item_patterns = rule_config.get("item_patterns", {})
-        for item in self.items or []:
-            item_type = item.get("type", "")
-            item_name = item.get("name", "")
-            
-            # Check type-specific pattern
-            pattern = item_patterns.get(item_type) or item_patterns.get("default")
-            if pattern and not re.match(pattern, item_name):
-                self.add_violation(
-                    rule_name,
-                    f"Item '{item_name}' ({item_type}) does not match naming pattern '{pattern}'",
-                    severity="warning",
-                    details={"item": item_name, "type": item_type, "pattern": pattern}
-                )
-                violations_found = True
-        
-        if not violations_found:
-            self.add_passed(rule_name)
-    
-    def validate_sensitivity_labels(self):
-        """Check that items have required sensitivity labels."""
-        rule_name = "sensitivity_labels"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        required = rule_config.get("required", False)
-        required_types = rule_config.get("required_item_types", [])
-        allowed_labels = rule_config.get("allowed_labels", [])
-        
-        violations_found = False
-        
-        # Build a map of items with labels
-        labeled_items = {}
-        for label_info in self.labels or []:
-            item_name = label_info.get("itemName", "")
-            labeled_items[item_name] = label_info.get("label", "")
-        
-        for item in self.items or []:
-            item_name = item.get("name", "")
-            item_type = item.get("type", "")
-            
-            # Check if this type requires labels
-            if required_types and item_type not in required_types:
-                continue
-            
-            item_label = labeled_items.get(item_name)
-            
-            # Check if label is required
-            if required and not item_label:
-                self.add_violation(
-                    rule_name,
-                    f"Item '{item_name}' ({item_type}) is missing required sensitivity label",
-                    severity="error",
-                    details={"item": item_name, "type": item_type}
-                )
-                violations_found = True
-            # Check if label is in allowed list
-            elif item_label and allowed_labels and item_label not in allowed_labels:
-                self.add_violation(
-                    rule_name,
-                    f"Item '{item_name}' has label '{item_label}' not in allowed list",
-                    severity="warning",
-                    details={"item": item_name, "label": item_label, "allowed": allowed_labels}
-                )
-                violations_found = True
-        
-        if not violations_found:
-            self.add_passed(rule_name)
-    
-    def validate_allowed_item_types(self):
-        """Check that workspace only contains allowed item types."""
-        rule_name = "allowed_item_types"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        allowed_types = rule_config.get("types", [])
-        blocked_types = rule_config.get("blocked_types", [])
-        
-        violations_found = False
-        
-        for item in self.items or []:
-            item_type = item.get("type", "")
-            item_name = item.get("name", "")
-            
-            # Check allowed list
-            if allowed_types and item_type not in allowed_types:
-                self.add_violation(
-                    rule_name,
-                    f"Item '{item_name}' has type '{item_type}' not in allowed types",
-                    severity="error",
-                    details={"item": item_name, "type": item_type, "allowed": allowed_types}
-                )
-                violations_found = True
-            
-            # Check blocked list
-            if item_type in blocked_types:
-                self.add_violation(
-                    rule_name,
-                    f"Item '{item_name}' has blocked type '{item_type}'",
-                    severity="error",
-                    details={"item": item_name, "type": item_type}
-                )
-                violations_found = True
-        
-        if not violations_found:
-            self.add_passed(rule_name)
-    
-    def validate_required_permissions(self):
-        """Check that required permissions are configured."""
-        rule_name = "required_permissions"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        required_principals = rule_config.get("required_principals", [])
-        max_admins = rule_config.get("max_admins")
-        require_group_access = rule_config.get("require_group_access", False)
-        
-        violations_found = False
-        
-        # Build permission map
-        current_permissions = {}
-        admin_count = 0
-        has_group_access = False
-        
-        for perm in self.permissions or []:
-            principal = perm.get("principal", {})
-            principal_id = principal.get("id", "")
-            principal_type = principal.get("type", "")
-            role = perm.get("role", "")
-            
-            current_permissions[principal_id] = role
-            
-            if role == "Admin":
-                admin_count += 1
-            
-            if principal_type == "Group":
-                has_group_access = True
-        
-        # Check required principals
-        for required in required_principals:
-            principal_id = required.get("principal_id")
-            required_role = required.get("role")
-            
-            current_role = current_permissions.get(principal_id)
-            if not current_role:
-                self.add_violation(
-                    rule_name,
-                    f"Required principal '{principal_id}' is not assigned to workspace",
-                    severity="error",
-                    details=required
-                )
-                violations_found = True
-            elif required_role and current_role != required_role:
-                self.add_warning(
-                    rule_name,
-                    f"Principal '{principal_id}' has role '{current_role}' but '{required_role}' is required",
-                    details={"principal": principal_id, "current": current_role, "required": required_role}
-                )
-        
-        # Check max admins
-        if max_admins is not None and admin_count > max_admins:
-            self.add_violation(
-                rule_name,
-                f"Workspace has {admin_count} admins, maximum allowed is {max_admins}",
-                severity="warning",
-                details={"current": admin_count, "max": max_admins}
-            )
-            violations_found = True
-        
-        # Check group access requirement
-        if require_group_access and not has_group_access:
-            self.add_violation(
-                rule_name,
-                "Workspace must have at least one group with access (no direct user access only)",
-                severity="warning"
-            )
-            violations_found = True
-        
-        if not violations_found:
-            self.add_passed(rule_name)
-    
-    def validate_domain_membership(self):
-        """Check workspace domain membership."""
-        rule_name = "domain_membership"
-        rule_config = self.rules.get(rule_name, {})
-        
-        if not rule_config.get("enabled", False):
-            return
-        
-        self.log(f"Checking rule: {rule_name}")
-        
-        required = rule_config.get("required", False)
-        allowed_domains = rule_config.get("allowed_domains", [])
-        
-        domain_id = self.workspace_details.get("domainId")
-        
-        if required and not domain_id:
-            self.add_violation(
-                rule_name,
-                "Workspace must be assigned to a domain",
-                severity="error"
-            )
-            return
-        
-        if allowed_domains and domain_id and domain_id not in allowed_domains:
-            self.add_violation(
-                rule_name,
-                f"Workspace domain '{domain_id}' not in allowed list",
-                severity="error",
-                details={"current": domain_id, "allowed": allowed_domains}
-            )
-            return
-        
-        self.add_passed(rule_name)
-    
-    def validate_all(self) -> Dict[str, Any]:
-        """Run all governance validations."""
-        if not self.load_workspace_data():
-            return {
-                "workspace": self.workspace,
-                "status": "error",
-                "message": "Failed to load workspace data"
-            }
-        
-        # Run all validators
-        self.validate_capacity_assignment()
-        self.validate_naming_conventions()
-        self.validate_sensitivity_labels()
-        self.validate_allowed_item_types()
-        self.validate_required_permissions()
-        self.validate_domain_membership()
-        
-        # Determine overall status
-        has_errors = any(v["severity"] == "error" for v in self.violations)
-        status = "fail" if has_errors else ("pass_with_warnings" if self.violations else "pass")
-        
-        return {
-            "workspace": self.workspace,
-            "status": status,
-            "rules_file": self.rules.get("_source", "unknown"),
-            "summary": {
-                "passed": len(self.passed_checks),
-                "violations": len(self.violations),
-                "warnings": len(self.warnings)
-            },
-            "passed_checks": self.passed_checks,
-            "violations": self.violations,
-            "warnings": self.warnings
-        }
-
-
-def create_sample_rules() -> Dict[str, Any]:
-    """Create a sample governance rules file."""
-    return {
-        "_description": "Sample Fabric governance rules configuration",
-        "_version": "1.0",
-        "capacity_assignment": {
-            "enabled": True,
-            "required": True,
-            "allowed_capacities": []
-        },
-        "naming_conventions": {
-            "enabled": True,
-            "workspace_pattern": "^[A-Z][a-zA-Z0-9_-]+$",
-            "item_patterns": {
-                "default": "^[A-Za-z][A-Za-z0-9_-]*$",
-                "SemanticModel": "^[A-Z][a-zA-Z0-9_-]+$",
-                "Report": "^[A-Z][a-zA-Z0-9_-]+Report$"
-            }
-        },
-        "sensitivity_labels": {
-            "enabled": True,
-            "required": False,
-            "required_item_types": ["SemanticModel", "Report"],
-            "allowed_labels": []
-        },
-        "allowed_item_types": {
-            "enabled": False,
-            "types": [],
-            "blocked_types": []
-        },
-        "required_permissions": {
-            "enabled": True,
-            "required_principals": [],
-            "max_admins": 5,
-            "require_group_access": False
-        },
-        "domain_membership": {
-            "enabled": False,
-            "required": False,
-            "allowed_domains": []
-        }
-    }
-
-
-def print_report(result: Dict[str, Any], output_format: str, output_file: Optional[str] = None):
-    """Print validation report."""
-    if output_format == "json":
-        output = json.dumps(result, indent=2)
-    else:
-        # Text format
-        lines = []
-        lines.append("=" * 60)
-        lines.append("GOVERNANCE VALIDATION REPORT")
-        lines.append("=" * 60)
-        lines.append(f"Workspace: {result['workspace']}")
-        lines.append(f"Status: {result['status'].upper()}")
-        lines.append("")
-        
-        summary = result.get("summary", {})
-        lines.append(f"Passed: {summary.get('passed', 0)}")
-        lines.append(f"Violations: {summary.get('violations', 0)}")
-        lines.append(f"Warnings: {summary.get('warnings', 0)}")
-        lines.append("")
-        
-        if result.get("passed_checks"):
-            lines.append("PASSED CHECKS:")
-            for check in result["passed_checks"]:
-                lines.append(f"  ✓ {check}")
-            lines.append("")
-        
-        if result.get("violations"):
-            lines.append("VIOLATIONS:")
-            for v in result["violations"]:
-                severity_icon = "✗" if v["severity"] == "error" else "⚠"
-                lines.append(f"  {severity_icon} [{v['rule']}] {v['message']}")
-            lines.append("")
-        
-        if result.get("warnings"):
-            lines.append("WARNINGS:")
-            for w in result["warnings"]:
-                lines.append(f"  ⚠ [{w['rule']}] {w['message']}")
-            lines.append("")
-        
-        lines.append("=" * 60)
-        output = "\n".join(lines)
-    
-    if output_file:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.write(output)
-        print(f"Report written to: {output_file}", file=sys.stderr)
-    else:
-        print(output)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Validate workspace against governance rules",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python validate_governance.py Production.Workspace --rules company-rules.json
-    python validate_governance.py MyWorkspace --rules rules.json -f json
-    python validate_governance.py Production.Workspace --rules rules.json -o report.json
-    python validate_governance.py --create-sample-rules > sample-rules.json
-        """
-    )
-    
-    parser.add_argument(
-        "workspace",
-        nargs="?",
-        help="Workspace name or path (e.g., 'MyWorkspace' or 'MyWorkspace.Workspace')"
-    )
-    
-    parser.add_argument(
-        "--rules",
-        required=False,
-        help="Path to governance rules JSON file"
-    )
-    
-    parser.add_argument(
-        "-f", "--format",
-        choices=["text", "json"],
-        default="text",
-        help="Output format (default: text)"
-    )
-    
-    parser.add_argument(
-        "-o", "--output",
-        help="Output file path (default: stdout)"
-    )
-    
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Enable verbose output"
-    )
-    
-    parser.add_argument(
-        "--create-sample-rules",
-        action="store_true",
-        help="Output a sample governance rules file"
-    )
-    
-    args = parser.parse_args()
-    
-    # Handle sample rules generation
-    if args.create_sample_rules:
-        print(json.dumps(create_sample_rules(), indent=2))
-        return 0
-    
-    # Validate required arguments
-    if not args.workspace:
-        parser.error("workspace is required unless --create-sample-rules is specified")
-    
-    if not args.rules:
-        parser.error("--rules is required")
-    
-    # Load rules
-    try:
-        rules = load_rules(args.rules)
-        rules["_source"] = args.rules
-    except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        return 1
-    except json.JSONDecodeError as e:
-        print(f"Error: Invalid JSON in rules file: {e}", file=sys.stderr)
-        return 1
-    
-    # Run validation
-    validator = GovernanceValidator(args.workspace, rules, verbose=args.verbose)
-    result = validator.validate_all()
-    
-    # Output report
-    print_report(result, args.format, args.output)
-    
-    # Return exit code based on status
-    if result["status"] == "error":
-        return 1
-    elif result["status"] == "fail":
-        return 1
-    else:
-        return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-realtime/README.md b/.ai-assets/skills/fabric-cli-realtime/README.md
deleted file mode 100644
index 10c844183..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/README.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# Fabric CLI Real-Time Intelligence Skill
-
-This skill provides comprehensive guidance for managing real-time analytics in Microsoft Fabric using the Fabric CLI.
-
-## Overview
-
-Real-time intelligence in Fabric enables streaming data analytics through:
-- **Eventhouses** — Optimized streaming data stores
-- **Eventstreams** — Stream ingestion and routing
-- **KQL Databases** — Time-series analytics
-- **Activator** — Alert triggers and actions
-
-## Contents
-
-### Main Skill File
-- `SKILL.md` — Core skill definition and patterns
-
-### Reference Files
-
-| File | Description |
-|------|-------------|
-| `references/eventhouse-operations.md` | Eventhouse creation, configuration, and management |
-| `references/eventstream-patterns.md` | Eventstream sources, destinations, and routing |
-| `references/kql-queries.md` | KQL query patterns and CLI execution |
-| `references/activator-alerts.md` | Alert triggers, conditions, and actions |
-| `references/streaming-patterns.md` | End-to-end streaming architecture patterns |
-
-### Scripts
-
-Automation scripts for real-time intelligence tasks:
-
-| Script | Description | Usage |
-|--------|-------------|-------|
-| `setup_streaming.py` | Create complete streaming pipeline | `python scripts/setup_streaming.py <workspace> --name <pipeline>` |
-| `kql_query.py` | Execute KQL query and return results | `python scripts/kql_query.py <database> --query <kql-file>` |
-| `monitor_eventstream.py` | Check eventstream health and throughput | `python scripts/monitor_eventstream.py <eventstream>` |
-
-## Quick Start
-
-```bash
-# List all real-time items
-fab ls "Workspace/*.Eventhouse"
-fab ls "Workspace/*.Eventstream"
-fab ls "Workspace/*.KQLDatabase"
-
-# Get item details
-fab get "Workspace/MyEventhouse.Eventhouse"
-```
-
-## When to Use This Skill
-
-- Building real-time analytics solutions
-- Setting up streaming data pipelines
-- Configuring KQL-based analytics
-- Creating automated alerts and triggers
-- Managing time-series data stores
diff --git a/.ai-assets/skills/fabric-cli-realtime/SKILL.md b/.ai-assets/skills/fabric-cli-realtime/SKILL.md
deleted file mode 100644
index aaaf52a78..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/SKILL.md
+++ /dev/null
@@ -1,259 +0,0 @@
----
-name: fabric-cli-realtime
-description: Use Fabric CLI for real-time intelligence — eventhouses, eventstreams, KQL databases, and Activator alerts. Activate when users work with streaming data, real-time analytics, or time-series data.
----
-
-# Fabric CLI Real-Time Intelligence Skill
-
-Comprehensive skill for managing real-time analytics in Microsoft Fabric using the Fabric CLI.
-
-## Skill Overview
-
-Real-time intelligence in Fabric enables streaming analytics with eventhouses, eventstreams, KQL databases, and Activator alerts. This skill covers CLI operations for building and managing real-time data pipelines.
-
-## Prerequisites
-
-- Fabric CLI installed and authenticated (`fab auth login`)
-- Workspace with Eventhouse capability
-- Understanding of streaming data concepts
-- Familiarity with KQL (Kusto Query Language)
-
-## Automation Scripts
-
-Ready-to-use Python scripts for real-time intelligence tasks. Run any script with `--help` for full options.
-
-| Script | Purpose | Usage |
-|--------|---------|-------|
-| `setup_streaming.py` | Create complete streaming pipeline | `python scripts/setup_streaming.py <workspace> --name <pipeline>` |
-| `kql_query.py` | Execute KQL query and return results | `python scripts/kql_query.py <database> --query <kql-file>` |
-| `monitor_eventstream.py` | Check eventstream health and throughput | `python scripts/monitor_eventstream.py <eventstream>` |
-
-Scripts are located in the `scripts/` folder of this skill.
-
-## Core Capabilities
-
-### 1. Eventhouse Operations
-
-Eventhouses are optimized for streaming data ingestion and analytics.
-
-**Create Eventhouse:**
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "TelemetryEventhouse",
-  "type": "Eventhouse"
-}'
-```
-
-**List Eventhouses:**
-```bash
-fab ls "Workspace/*.Eventhouse"
-fab ls "Workspace" -q "[?type=='Eventhouse']"
-```
-
-**Get Eventhouse Details:**
-```bash
-fab get "Workspace/TelemetryEventhouse.Eventhouse"
-fab get "Workspace/TelemetryEventhouse.Eventhouse" -q "properties"
-```
-
-### 2. KQL Database Management
-
-KQL databases within eventhouses store streaming data.
-
-**Create KQL Database:**
-```bash
-EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"SensorData\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-  }
-}"
-```
-
-**List KQL Databases:**
-```bash
-fab ls "Workspace/*.KQLDatabase"
-```
-
-### 3. Eventstream Configuration
-
-Eventstreams capture and route streaming data.
-
-**Create Eventstream:**
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "IoTEventStream",
-  "type": "Eventstream"
-}'
-```
-
-**List Eventstreams:**
-```bash
-fab ls "Workspace/*.Eventstream"
-```
-
-### 4. KQL Queryset Operations
-
-**Create KQL Queryset:**
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorAnalytics",
-  "type": "KQLQueryset"
-}'
-```
-
-### 5. Activator (Reflex) Alerts
-
-**Create Activator:**
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AnomalyAlerts",
-  "type": "Reflex"
-}'
-```
-
-## Common Patterns
-
-### Real-Time Pipeline Setup
-
-```bash
-#!/bin/bash
-# Set up complete real-time analytics pipeline
-
-WORKSPACE="RealTime.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create Eventhouse
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "TelemetryHub",
-  "type": "Eventhouse"
-}'
-
-# 2. Create KQL Database
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"SensorDB\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-  }
-}"
-
-# 3. Create Eventstream
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorStream",
-  "type": "Eventstream"
-}'
-
-# 4. Create KQL Queryset
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorQueries",
-  "type": "KQLQueryset"
-}'
-
-# 5. Create Activator for alerts
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorAlerts",
-  "type": "Reflex"
-}'
-```
-
-### Streaming Data Ingestion
-
-Configure eventstream sources:
-
-```bash
-# Get eventstream for configuration
-EVENTSTREAM_ID=$(fab get "$WORKSPACE/SensorStream.Eventstream" -q "id" | tr -d '"')
-
-# View eventstream definition
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
-```
-
-### KQL Query Execution
-
-```bash
-# Execute KQL query via API
-KQL_DB_ID=$(fab get "$WORKSPACE/SensorDB.KQLDatabase" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorData | where timestamp > ago(1h) | summarize count() by bin(timestamp, 5m)"
-}'
-```
-
-## Item Types Reference
-
-| Item Type | CLI Type | Purpose |
-|-----------|----------|---------|
-| Eventhouse | `.Eventhouse` | Streaming data store |
-| KQL Database | `.KQLDatabase` | Time-series database |
-| Eventstream | `.Eventstream` | Stream ingestion/routing |
-| KQL Queryset | `.KQLQueryset` | Saved KQL queries |
-| Activator | `.Reflex` | Alert triggers |
-
-## Best Practices
-
-1. **Workspace Organization**
-   - Dedicate workspaces to real-time workloads
-   - Separate dev/test/prod eventhouses
-   - Use clear naming conventions
-
-2. **Data Architecture**
-   - Design for high-velocity ingestion
-   - Partition by time for query performance
-   - Set appropriate retention policies
-
-3. **Monitoring**
-   - Set up alerts for ingestion lag
-   - Monitor query performance
-   - Track storage consumption
-
-4. **Security**
-   - Use workspace permissions for access control
-   - Implement row-level security where needed
-   - Audit query access patterns
-
-## Reference Files
-
-- `references/eventhouse-operations.md` — Eventhouse creation and management
-- `references/eventstream-patterns.md` — Eventstream configuration patterns
-- `references/kql-queries.md` — KQL query examples and CLI execution
-- `references/activator-alerts.md` — Alert configuration and management
-- `references/streaming-patterns.md` — End-to-end streaming architectures
-
-## Related Skills
-
-- **fabric-cli-core** — Foundation CLI operations
-- **fabric-cli-dataengineering** — Lakehouse integration patterns
-- **fabric-cli-governance** — Security and compliance
-
-## Troubleshooting
-
-### Eventhouse Creation Fails
-```bash
-# Check workspace capacity supports Eventhouse
-fab get "Workspace" -q "properties.capacityId"
-```
-
-### Eventstream Not Ingesting
-```bash
-# Check eventstream status
-fab get "Workspace/MyStream.Eventstream" -q "properties"
-
-# Verify source connection
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
-```
-
-### KQL Query Timeout
-```bash
-# Add timeout parameter
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "...",
-  "requestProperties": {
-    "queryTimeout": "5m"
-  }
-}'
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md b/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
deleted file mode 100644
index c3f7fc265..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/references/activator-alerts.md
+++ /dev/null
@@ -1,463 +0,0 @@
-# Activator Alerts Reference
-
-Guide to creating and managing Activator (Reflex) alerts in Fabric.
-
-## Understanding Activator
-
-Activator (formerly known as Reflex) provides real-time alerting:
-
-- **Event-driven** — Trigger on data conditions
-- **No-code** — Visual alert configuration
-- **Actions** — Email, Teams, Power Automate, custom
-- **Integration** — Works with Eventstreams, KQL, Power BI
-
-## Creating Activators
-
-### Basic Creation
-
-```bash
-WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorAlerts",
-  "type": "Reflex",
-  "description": "Real-time sensor anomaly alerts"
-}'
-```
-
-### Verify Creation
-
-```bash
-# List activators
-fab ls "Workspace/*.Reflex"
-
-# Get details
-fab get "Workspace/SensorAlerts.Reflex"
-```
-
-## Managing Activators
-
-### List All Activators
-
-```bash
-# In workspace
-fab ls "Workspace/*.Reflex" -l
-
-# Across workspaces
-fab ls -R "*.Reflex"
-```
-
-### Get Activator Properties
-
-```bash
-REFLEX_ID=$(fab get "Workspace/SensorAlerts.Reflex" -q "id" | tr -d '"')
-
-# Full details
-fab api "workspaces/$WS_ID/items/$REFLEX_ID"
-
-# Get definition
-fab api "workspaces/$WS_ID/items/$REFLEX_ID/getDefinition"
-```
-
-### Update Activator
-
-```bash
-# Update name/description
-fab api -X patch "workspaces/$WS_ID/items/$REFLEX_ID" -i '{
-  "displayName": "RenamedAlerts",
-  "description": "Updated description"
-}'
-```
-
-### Delete Activator
-
-```bash
-fab rm "Workspace/OldAlerts.Reflex"
-
-# Or via API
-fab api -X delete "workspaces/$WS_ID/items/$REFLEX_ID"
-```
-
-## Alert Configuration Patterns
-
-### Temperature Alert
-
-Configure alert for temperature threshold:
-
-```bash
-# 1. Create Activator
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "HighTempAlert",
-  "type": "Reflex"
-}'
-
-# 2. Configure in UI:
-# - Data source: Eventstream or KQL Database
-# - Condition: temperature > 100
-# - Action: Send email/Teams message
-```
-
-### Anomaly Detection Alert
-
-```bash
-# 1. Create Activator for anomalies
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AnomalyDetector",
-  "type": "Reflex",
-  "description": "Alerts on statistical anomalies"
-}'
-
-# 2. Connect to KQL database with anomaly detection query
-# 3. Configure threshold for anomaly scores
-```
-
-### Error Rate Alert
-
-```bash
-# 1. Create Activator
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "ErrorRateAlert",
-  "type": "Reflex"
-}'
-
-# 2. Connect to Eventstream
-# 3. Configure condition: error_rate > 5%
-# 4. Set action: Teams channel notification
-```
-
-## Data Sources
-
-### Connect to Eventstream
-
-```bash
-# Create Activator connected to Eventstream
-# 1. Create the Activator
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "StreamAlerts",
-  "type": "Reflex"
-}'
-
-# 2. In Eventstream, add Activator as destination
-EVENTSTREAM_ID=$(fab get "Workspace/MyStream.Eventstream" -q "id" | tr -d '"')
-# Add Reflex destination via Eventstream configuration
-```
-
-### Connect to KQL Database
-
-```bash
-# Activator can query KQL database for conditions
-# Configure data source pointing to KQL database
-# Set up scheduled query evaluation
-```
-
-### Connect to Power BI
-
-```bash
-# Activator can monitor Power BI datasets
-# Configure connection to semantic model
-# Set up measure-based conditions
-```
-
-## Action Types
-
-### Email Notification
-
-```bash
-# Configure email action
-{
-  "actions": [{
-    "type": "Email",
-    "recipients": ["alerts@company.com"],
-    "subject": "Alert: {{alertName}}",
-    "body": "Value: {{value}}, Threshold: {{threshold}}"
-  }]
-}
-```
-
-### Teams Notification
-
-```bash
-# Configure Teams action
-{
-  "actions": [{
-    "type": "Teams",
-    "channelId": "<channel-id>",
-    "message": "🚨 Alert triggered: {{alertName}}"
-  }]
-}
-```
-
-### Power Automate Flow
-
-```bash
-# Trigger Power Automate flow
-{
-  "actions": [{
-    "type": "PowerAutomate",
-    "flowId": "<flow-id>",
-    "parameters": {
-      "alertName": "{{alertName}}",
-      "value": "{{value}}"
-    }
-  }]
-}
-```
-
-### Custom Webhook
-
-```bash
-# Call custom webhook
-{
-  "actions": [{
-    "type": "Webhook",
-    "url": "https://api.company.com/alerts",
-    "method": "POST",
-    "body": {
-      "alert": "{{alertName}}",
-      "timestamp": "{{timestamp}}",
-      "value": "{{value}}"
-    }
-  }]
-}
-```
-
-## Automation Scripts
-
-### Complete Alert Pipeline
-
-```bash
-#!/bin/bash
-# Set up complete alerting infrastructure
-
-WORKSPACE="Monitoring.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create Eventhouse for real-time data
-echo "Creating Eventhouse..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "MonitoringHub",
-  "type": "Eventhouse"
-}'
-
-sleep 10
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/MonitoringHub.Eventhouse" -q "id" | tr -d '"')
-
-# 2. Create KQL Database
-echo "Creating KQL Database..."
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"AlertsDB\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-  }
-}"
-
-sleep 10
-
-# 3. Create Eventstream
-echo "Creating Eventstream..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "MonitoringStream",
-  "type": "Eventstream"
-}'
-
-# 4. Create multiple Activators for different conditions
-ALERT_TYPES=("HighTemperature" "ErrorRate" "Latency" "Availability")
-
-for ALERT in "${ALERT_TYPES[@]}"; do
-  echo "Creating ${ALERT}Alert..."
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${ALERT}Alert\",
-    \"type\": \"Reflex\",
-    \"description\": \"Alert for $ALERT conditions\"
-  }"
-done
-
-echo "Alert infrastructure created. Configure conditions in UI."
-```
-
-### Multi-Environment Alerting
-
-```bash
-#!/bin/bash
-# Deploy alerts across environments
-
-ENVIRONMENTS=("Dev" "Staging" "Prod")
-ALERTS=("CriticalErrors" "PerformanceDegraded" "SecurityEvents")
-
-for ENV in "${ENVIRONMENTS[@]}"; do
-  WORKSPACE="${ENV}Monitoring.Workspace"
-  WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-  
-  echo "Deploying to $ENV..."
-  
-  for ALERT in "${ALERTS[@]}"; do
-    fab api -X post "workspaces/$WS_ID/items" -i "{
-      \"displayName\": \"${ALERT}_${ENV}\",
-      \"type\": \"Reflex\",
-      \"description\": \"$ALERT monitoring for $ENV environment\"
-    }"
-  done
-done
-
-echo "Alerts deployed to all environments"
-```
-
-## Monitoring Activators
-
-### Check Alert Status
-
-```bash
-# Get Activator state
-fab get "Workspace/SensorAlerts.Reflex" -q "properties"
-
-# List all Activators with status
-fab ls "Workspace/*.Reflex" -l
-```
-
-### View Alert History
-
-```bash
-# Alert history is typically viewed in UI
-# Or query from connected KQL database if logging enabled
-```
-
-### Enable/Disable Alerts
-
-```bash
-# Activator enable/disable typically done via UI
-# Can export/import definitions for version control
-
-# Export current state
-fab export "Workspace/SensorAlerts.Reflex" -d "./backup/"
-
-# To disable: delete and recreate when needed
-```
-
-## Best Practices
-
-### Alert Design
-
-| Principle | Description |
-|-----------|-------------|
-| Specific conditions | Avoid overly broad alerts |
-| Actionable | Each alert should prompt action |
-| Deduplication | Prevent alert storms |
-| Severity levels | Differentiate critical vs warning |
-| Clear naming | Descriptive alert names |
-
-### Condition Configuration
-
-- Set realistic thresholds based on historical data
-- Use time windows to avoid false positives
-- Consider business hours for non-critical alerts
-- Test conditions before production deployment
-
-### Action Configuration
-
-- Verify notification channels work
-- Set up escalation paths
-- Include context in alert messages
-- Consider rate limiting for high-volume alerts
-
-### Naming Conventions
-
-| Component | Convention | Example |
-|-----------|------------|---------|
-| Activator | `<Condition><Severity>Alert` | `HighTempCriticalAlert` |
-| Alert groups | `<System>Alerts` | `ProductionAlerts` |
-
-## Integration Patterns
-
-### Eventstream to Activator
-
-```bash
-#!/bin/bash
-# Set up Eventstream -> Activator flow
-
-WORKSPACE="Alerts.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Create Eventstream
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AlertDataStream",
-  "type": "Eventstream"
-}'
-
-# Create Activator
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "StreamBasedAlerts",
-  "type": "Reflex"
-}'
-
-echo "Configure Eventstream to route to Activator in UI"
-```
-
-### KQL Query to Activator
-
-```bash
-#!/bin/bash
-# Set up KQL-based alerting
-
-WORKSPACE="Analytics.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "$WORKSPACE/AnalyticsDB.KQLDatabase" -q "id" | tr -d '"')
-
-# Create alert query (stored as function)
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create function AlertCondition() { Events | where timestamp > ago(5m) | summarize errorCount=countif(eventType==\"error\") | where errorCount > 100 }"
-}'
-
-# Create Activator
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "KQLBasedAlert",
-  "type": "Reflex"
-}'
-
-echo "Configure Activator to use KQL query in UI"
-```
-
-## Troubleshooting
-
-### Alerts Not Firing
-
-```bash
-# Check Activator exists
-fab ls "Workspace/*.Reflex" -l
-
-# Verify data source connection
-fab get "Workspace/MyAlert.Reflex" -q "properties"
-
-# Check condition - manually query the data
-# to verify condition should be met
-```
-
-### Too Many Alerts
-
-```bash
-# Review alert conditions
-# - Add time windows
-# - Increase thresholds
-# - Add deduplication logic
-# - Consider aggregated alerts
-```
-
-### Action Not Executing
-
-```bash
-# Verify action configuration
-# - Check email addresses
-# - Verify Teams channel access
-# - Test webhook endpoint manually
-# - Check Power Automate flow status
-```
-
-### Performance Issues
-
-```bash
-# If Activator causing performance issues:
-# - Reduce query frequency
-# - Optimize underlying KQL queries
-# - Consider sampling for high-volume streams
-# - Use materialized views for complex conditions
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md b/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
deleted file mode 100644
index e9a248437..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/references/eventhouse-operations.md
+++ /dev/null
@@ -1,371 +0,0 @@
-# Eventhouse Operations Reference
-
-Complete guide to managing Eventhouses in Microsoft Fabric using CLI.
-
-## Understanding Eventhouses
-
-Eventhouses are optimized storage for high-velocity streaming data:
-
-- **High throughput** — Millions of events per second
-- **Time-series optimized** — Built for temporal queries
-- **Auto-scaling** — Adapts to ingestion volume
-- **Integrated** — Works with Eventstreams, KQL, Activator
-
-## Creating Eventhouses
-
-### Basic Creation
-
-```bash
-WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "TelemetryEventhouse",
-  "type": "Eventhouse",
-  "description": "Central telemetry data store"
-}'
-```
-
-### Verify Creation
-
-```bash
-# List eventhouses
-fab ls "Workspace/*.Eventhouse"
-
-# Get details
-fab get "Workspace/TelemetryEventhouse.Eventhouse"
-```
-
-## Managing Eventhouses
-
-### List All Eventhouses
-
-```bash
-# In current workspace
-fab ls "Workspace/*.Eventhouse" -l
-
-# Across all workspaces (admin)
-fab ls -R "*.Eventhouse"
-
-# With specific details
-fab api "workspaces/$WS_ID/items" -q "value[?type=='Eventhouse'].{name: displayName, id: id}"
-```
-
-### Get Eventhouse Properties
-
-```bash
-EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
-
-# Full properties
-fab api "workspaces/$WS_ID/items/$EVENTHOUSE_ID"
-
-# Specific property
-fab get "Workspace/MyEventhouse.Eventhouse" -q "properties.state"
-```
-
-### Update Eventhouse
-
-```bash
-# Update display name
-fab api -X patch "workspaces/$WS_ID/items/$EVENTHOUSE_ID" -i '{
-  "displayName": "RenamedEventhouse"
-}'
-
-# Update description
-fab api -X patch "workspaces/$WS_ID/items/$EVENTHOUSE_ID" -i '{
-  "description": "Updated description for telemetry eventhouse"
-}'
-```
-
-### Delete Eventhouse
-
-```bash
-# Delete by path
-fab rm "Workspace/OldEventhouse.Eventhouse"
-
-# Delete by ID
-fab api -X delete "workspaces/$WS_ID/items/$EVENTHOUSE_ID"
-```
-
-## KQL Database Management
-
-Each eventhouse can contain multiple KQL databases.
-
-### Create KQL Database
-
-```bash
-EVENTHOUSE_ID=$(fab get "Workspace/MyEventhouse.Eventhouse" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"SensorData\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\",
-    \"configuration\": {
-      \"kind\": \"ReadWrite\"
-    }
-  }
-}"
-```
-
-### List KQL Databases
-
-```bash
-# All KQL databases in workspace
-fab ls "Workspace/*.KQLDatabase"
-
-# Get parent eventhouse
-fab get "Workspace/SensorData.KQLDatabase" -q "properties.parentEventhouseId"
-```
-
-### Shortcut Database (Read-Only)
-
-Create a read-only reference to another KQL database:
-
-```bash
-# Create shortcut database
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SharedSensorData",
-  "type": "KQLDatabase",
-  "properties": {
-    "parentEventhouseId": "<local-eventhouse-id>",
-    "configuration": {
-      "kind": "ReadOnly",
-      "sourceKqlDatabaseId": "<source-kql-db-id>"
-    }
-  }
-}'
-```
-
-## Table Operations
-
-### Create Table via KQL
-
-```bash
-KQL_DB_ID=$(fab get "Workspace/SensorData.KQLDatabase" -q "id" | tr -d '"')
-
-# Execute table creation command
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table SensorReadings (timestamp: datetime, deviceId: string, temperature: real, humidity: real)"
-}'
-```
-
-### Create Table with Mapping
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table SensorReadings ingestion json mapping \"SensorMapping\" \"[{\"column\":\"timestamp\",\"path\":\"$.ts\"},{\"column\":\"deviceId\",\"path\":\"$.device\"},{\"column\":\"temperature\",\"path\":\"$.temp\"},{\"column\":\"humidity\",\"path\":\"$.humid\"}]\""
-}'
-```
-
-### List Tables
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show tables"
-}'
-```
-
-### Drop Table
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".drop table SensorReadings"
-}'
-```
-
-## Configuration Options
-
-### Data Retention
-
-```bash
-# Set retention policy
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter-merge table SensorReadings policy retention softdelete = 30d recoverability = enabled"
-}'
-```
-
-### Caching Policy
-
-```bash
-# Configure hot cache period
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter table SensorReadings policy caching hot = 7d"
-}'
-```
-
-### Ingestion Batching
-
-```bash
-# Configure batching for ingestion
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter table SensorReadings policy ingestionbatching @\"{ \\\"MaximumBatchingTimeSpan\\\": \\\"00:00:30\\\", \\\"MaximumNumberOfItems\\\": 500, \\\"MaximumRawDataSizeMB\\\": 100 }\""
-}'
-```
-
-## Automation Scripts
-
-### Complete Eventhouse Setup
-
-```bash
-#!/bin/bash
-# Create complete eventhouse with KQL database and tables
-
-WORKSPACE="RealTime.Workspace"
-EVENTHOUSE_NAME="TelemetryHub"
-DATABASE_NAME="DeviceData"
-
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create Eventhouse
-echo "Creating eventhouse..."
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"$EVENTHOUSE_NAME\",
-  \"type\": \"Eventhouse\"
-}"
-
-sleep 10
-
-# 2. Get Eventhouse ID
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/$EVENTHOUSE_NAME.Eventhouse" -q "id" | tr -d '"')
-echo "Eventhouse ID: $EVENTHOUSE_ID"
-
-# 3. Create KQL Database
-echo "Creating KQL database..."
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"$DATABASE_NAME\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-  }
-}"
-
-sleep 10
-
-# 4. Get Database ID
-KQL_DB_ID=$(fab get "$WORKSPACE/$DATABASE_NAME.KQLDatabase" -q "id" | tr -d '"')
-echo "KQL Database ID: $KQL_DB_ID"
-
-# 5. Create tables
-echo "Creating tables..."
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table DeviceReadings (timestamp: datetime, deviceId: string, metric: string, value: real)"
-}'
-
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table DeviceEvents (timestamp: datetime, deviceId: string, eventType: string, details: dynamic)"
-}'
-
-# 6. Set retention policies
-echo "Configuring policies..."
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter-merge table DeviceReadings policy retention softdelete = 90d"
-}'
-
-echo "Eventhouse setup complete!"
-```
-
-### Multi-Environment Deployment
-
-```bash
-#!/bin/bash
-# Deploy eventhouse across environments
-
-ENVIRONMENTS=("Dev" "Test" "Prod")
-BASE_NAME="TelemetryHub"
-
-for ENV in "${ENVIRONMENTS[@]}"; do
-  WORKSPACE="${ENV}RealTime.Workspace"
-  WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-  
-  echo "Deploying to $ENV environment..."
-  
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${BASE_NAME}_${ENV}\",
-    \"type\": \"Eventhouse\",
-    \"description\": \"$ENV environment eventhouse\"
-  }"
-  
-  echo "Created $BASE_NAME in $ENV"
-done
-```
-
-## Monitoring
-
-### Check Eventhouse Status
-
-```bash
-# Get eventhouse state
-fab get "Workspace/MyEventhouse.Eventhouse" -q "properties"
-
-# Check all eventhouses in workspace
-fab ls "Workspace/*.Eventhouse" -l -q "[].{name: displayName, state: properties.state}"
-```
-
-### Ingestion Metrics
-
-```bash
-# Query ingestion statistics
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show ingestion failures | where FailedOn > ago(1h)"
-}'
-
-# Recent ingestion volume
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show commands | where StartedOn > ago(1h) | where CommandType == \"DataIngestPull\" | summarize count() by bin(StartedOn, 5m)"
-}'
-```
-
-## Best Practices
-
-### Naming Conventions
-
-| Component | Convention | Example |
-|-----------|------------|---------|
-| Eventhouse | `<Domain>Eventhouse` | `TelemetryEventhouse` |
-| KQL Database | `<DataDomain>DB` | `SensorDataDB` |
-| Tables | `<Entity><Type>` | `DeviceReadings`, `SystemEvents` |
-
-### Capacity Planning
-
-- Monitor ingestion rate trends
-- Set appropriate retention based on query patterns
-- Use caching policies for frequently queried data
-- Consider partitioning for large tables
-
-### Security
-
-- Use workspace roles for access control
-- Configure row-level security for multi-tenant scenarios
-- Audit data access patterns
-
-## Troubleshooting
-
-### Eventhouse Creation Timeout
-
-```bash
-# Check workspace capacity
-fab get "Workspace" -q "properties.capacityId"
-
-# Verify capacity supports Eventhouse
-fab api "capacities/<capacity-id>" -q "properties.sku"
-```
-
-### KQL Database Connection Issues
-
-```bash
-# Verify database state
-fab get "Workspace/MyDB.KQLDatabase" -q "properties.state"
-
-# Check parent eventhouse
-PARENT_ID=$(fab get "Workspace/MyDB.KQLDatabase" -q "properties.parentEventhouseId" | tr -d '"')
-fab api "workspaces/$WS_ID/items/$PARENT_ID"
-```
-
-### Ingestion Failures
-
-```bash
-# View recent failures
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show ingestion failures | where FailedOn > ago(1h) | project FailedOn, FailureKind, Details | take 50"
-}'
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md b/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
deleted file mode 100644
index 3e5087b9d..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/references/eventstream-patterns.md
+++ /dev/null
@@ -1,450 +0,0 @@
-# Eventstream Patterns Reference
-
-Guide to configuring Eventstreams for streaming data pipelines in Fabric.
-
-## Understanding Eventstreams
-
-Eventstreams provide no-code stream processing:
-
-- **Sources** — Ingest from Event Hubs, IoT Hub, custom apps
-- **Destinations** — Route to KQL databases, lakehouses, reflexes
-- **Transformations** — Filter, aggregate, enrich in-flight
-- **Real-time** — Sub-second latency processing
-
-## Creating Eventstreams
-
-### Basic Creation
-
-```bash
-WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorEventStream",
-  "type": "Eventstream",
-  "description": "IoT sensor data ingestion"
-}'
-```
-
-### Verify Creation
-
-```bash
-# List eventstreams
-fab ls "Workspace/*.Eventstream"
-
-# Get details
-fab get "Workspace/SensorEventStream.Eventstream"
-```
-
-## Managing Eventstreams
-
-### List Eventstreams
-
-```bash
-# All eventstreams in workspace
-fab ls "Workspace/*.Eventstream" -l
-
-# With filtering
-fab api "workspaces/$WS_ID/items" -q "value[?type=='Eventstream']"
-```
-
-### Get Eventstream Definition
-
-```bash
-EVENTSTREAM_ID=$(fab get "Workspace/MyStream.Eventstream" -q "id" | tr -d '"')
-
-# Get full definition
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition"
-
-# Get specific configuration
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.parts"
-```
-
-### Update Eventstream Definition
-
-```bash
-# Get current definition
-DEFINITION=$(fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition")
-
-# Update definition (after modifying)
-fab api -X post "workspaces/$WS_ID/items/$EVENTSTREAM_ID/updateDefinition" -i '{
-  "definition": {
-    "parts": [...]
-  }
-}'
-```
-
-### Delete Eventstream
-
-```bash
-fab rm "Workspace/OldStream.Eventstream"
-
-# Or via API
-fab api -X delete "workspaces/$WS_ID/items/$EVENTSTREAM_ID"
-```
-
-## Source Configuration
-
-### Event Hub Source
-
-```bash
-# Configure Event Hub as source
-# (Typically done via UI, definition shown for reference)
-{
-  "sources": [{
-    "type": "EventHub",
-    "eventHubNamespaceName": "my-namespace",
-    "eventHubName": "sensor-data",
-    "consumerGroup": "$Default",
-    "connectionId": "<connection-id>"
-  }]
-}
-```
-
-### IoT Hub Source
-
-```bash
-# IoT Hub configuration
-{
-  "sources": [{
-    "type": "IoTHub",
-    "iotHubName": "my-iothub",
-    "consumerGroup": "$Default",
-    "connectionId": "<connection-id>"
-  }]
-}
-```
-
-### Custom Endpoint Source
-
-```bash
-# Get custom endpoint for API ingestion
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.sources[?type=='CustomEndpoint'].endpoint"
-```
-
-### Sample Data Source
-
-```bash
-# Useful for testing
-{
-  "sources": [{
-    "type": "SampleData",
-    "datasetName": "StockTrades"
-  }]
-}
-```
-
-## Destination Configuration
-
-### KQL Database Destination
-
-```bash
-# Route to KQL database
-{
-  "destinations": [{
-    "type": "KQLDatabase",
-    "kqlDatabaseId": "<kql-db-id>",
-    "tableName": "SensorReadings",
-    "inputDataFormat": "Json",
-    "mappingRuleName": "SensorMapping"
-  }]
-}
-```
-
-### Lakehouse Destination
-
-```bash
-# Route to lakehouse table
-{
-  "destinations": [{
-    "type": "Lakehouse",
-    "lakehouseId": "<lakehouse-id>",
-    "tableName": "streaming_data",
-    "inputDataFormat": "Json"
-  }]
-}
-```
-
-### Reflex (Activator) Destination
-
-```bash
-# Route to Activator for alerting
-{
-  "destinations": [{
-    "type": "Reflex",
-    "reflexId": "<reflex-id>"
-  }]
-}
-```
-
-## Transformation Patterns
-
-### Filter Transformation
-
-Filter events based on conditions:
-
-```bash
-# Filter definition
-{
-  "transformations": [{
-    "type": "Filter",
-    "condition": "temperature > 100"
-  }]
-}
-```
-
-### Aggregate Transformation
-
-Windowed aggregations:
-
-```bash
-# Tumbling window aggregation
-{
-  "transformations": [{
-    "type": "Aggregate",
-    "windowType": "Tumbling",
-    "windowSize": "PT5M",
-    "groupBy": ["deviceId"],
-    "aggregates": [
-      {"function": "Avg", "column": "temperature", "alias": "avgTemp"},
-      {"function": "Max", "column": "temperature", "alias": "maxTemp"}
-    ]
-  }]
-}
-```
-
-### Derived Column
-
-Add computed columns:
-
-```bash
-{
-  "transformations": [{
-    "type": "DerivedColumn",
-    "columns": [{
-      "name": "processed_time",
-      "expression": "CURRENT_TIMESTAMP()"
-    }]
-  }]
-}
-```
-
-## End-to-End Patterns
-
-### IoT Telemetry Pipeline
-
-```bash
-#!/bin/bash
-# Set up IoT telemetry streaming pipeline
-
-WORKSPACE="IoT.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create Eventstream
-echo "Creating eventstream..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "IoTTelemetryStream",
-  "type": "Eventstream"
-}'
-
-# 2. Get eventhouse and KQL database IDs
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "$WORKSPACE/DeviceData.KQLDatabase" -q "id" | tr -d '"')
-
-# 3. Create connection for Event Hub
-echo "Setting up Event Hub connection..."
-fab api -X post "connections" -i '{
-  "displayName": "IoTEventHubConnection",
-  "connectionDetails": {
-    "type": "EventHub",
-    "parameters": {
-      "server": "my-namespace.servicebus.windows.net",
-      "eventHub": "telemetry"
-    }
-  },
-  "credentialDetails": {
-    "credentialType": "SharedAccessKey"
-  }
-}'
-
-echo "Eventstream created. Configure sources and destinations in UI."
-```
-
-### Multi-Destination Routing
-
-Route same stream to multiple destinations:
-
-```bash
-#!/bin/bash
-# Configure eventstream for multi-destination routing
-
-WORKSPACE="Analytics.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Create eventstream
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "MultiRouteStream",
-  "type": "Eventstream",
-  "description": "Routes to KQL, Lakehouse, and Activator"
-}'
-
-echo "Configure in UI:"
-echo "1. Add source (Event Hub/IoT Hub/Custom Endpoint)"
-echo "2. Add KQL Database destination for real-time queries"
-echo "3. Add Lakehouse destination for historical analysis"
-echo "4. Add Activator destination for alerting"
-```
-
-### Stream Processing with Aggregation
-
-```bash
-#!/bin/bash
-# Set up aggregation stream
-
-WORKSPACE="Metrics.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Create raw eventstream
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "RawMetricsStream",
-  "type": "Eventstream"
-}'
-
-# Create aggregated eventstream
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AggregatedMetricsStream",
-  "type": "Eventstream",
-  "description": "5-minute aggregated metrics"
-}'
-
-echo "Configure aggregation:"
-echo "1. RawMetricsStream: Source -> Lakehouse (raw data)"
-echo "2. AggregatedMetricsStream: Derived from raw with 5-min tumbling window -> KQL"
-```
-
-## Connection Management
-
-### List Streaming Connections
-
-```bash
-# List all connections
-fab ls ".connections" -l
-
-# Filter for Event Hub connections
-fab ls ".connections/*.Connection" -q "[?type=='EventHub']"
-```
-
-### Create Event Hub Connection
-
-```bash
-fab api -X post "connections" -i '{
-  "displayName": "EventHubConn",
-  "connectionDetails": {
-    "type": "EventHub",
-    "parameters": {
-      "server": "namespace.servicebus.windows.net",
-      "eventHub": "eventhub-name"
-    }
-  },
-  "credentialDetails": {
-    "credentialType": "SharedAccessKey",
-    "sharedAccessKey": {
-      "keyName": "RootManageSharedAccessKey",
-      "key": "<key-value>"
-    }
-  }
-}'
-```
-
-### Create IoT Hub Connection
-
-```bash
-fab api -X post "connections" -i '{
-  "displayName": "IoTHubConn",
-  "connectionDetails": {
-    "type": "IoTHub",
-    "parameters": {
-      "server": "iothub-name.azure-devices.net"
-    }
-  },
-  "credentialDetails": {
-    "credentialType": "SharedAccessKey"
-  }
-}'
-```
-
-## Monitoring Eventstreams
-
-### Check Stream Status
-
-```bash
-# Get eventstream properties
-fab get "Workspace/MyStream.Eventstream" -q "properties"
-
-# Check for errors in definition
-fab api "workspaces/$WS_ID/items/$EVENTSTREAM_ID/getDefinition" -q "definition.errors"
-```
-
-### View Metrics (via KQL)
-
-If routing to KQL database, query ingestion metrics:
-
-```bash
-# Query events processed
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "TableName | where ingestion_time() > ago(1h) | summarize count() by bin(ingestion_time(), 5m)"
-}'
-```
-
-## Best Practices
-
-### Design Principles
-
-1. **Single Responsibility** — One eventstream per data domain
-2. **Schema Evolution** — Design for schema changes
-3. **Error Handling** — Configure dead-letter destinations
-4. **Monitoring** — Route subset to monitoring tables
-
-### Naming Conventions
-
-| Component | Convention | Example |
-|-----------|------------|---------|
-| Eventstream | `<Source><Domain>Stream` | `IoTSensorStream` |
-| Connections | `<Service>Conn` | `EventHubConn` |
-
-### Performance Tips
-
-- Use appropriate partitioning at source
-- Configure batching for destinations
-- Filter early in the pipeline
-- Monitor for backpressure
-
-## Troubleshooting
-
-### Stream Not Receiving Data
-
-```bash
-# Check eventstream status
-fab get "Workspace/MyStream.Eventstream"
-
-# Verify source connection
-fab ls ".connections" -l
-
-# Check connection credentials
-fab get ".connections/EventHubConn.Connection" -q "credentialDetails"
-```
-
-### High Latency
-
-```bash
-# Check destination configuration
-# Ensure batching is appropriate for use case
-# Monitor Event Hub/IoT Hub consumer lag
-```
-
-### Data Loss
-
-```bash
-# Verify checkpointing is enabled
-# Check consumer group offset
-# Review dead-letter queue if configured
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md b/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
deleted file mode 100644
index 6c2c18cf8..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/references/kql-queries.md
+++ /dev/null
@@ -1,399 +0,0 @@
-# KQL Queries Reference
-
-Guide to executing KQL queries using Fabric CLI.
-
-## KQL Query Fundamentals
-
-Kusto Query Language (KQL) is optimized for log and time-series data:
-
-- **Read-optimized** — Fast analytical queries
-- **Pipe syntax** — Chain operators sequentially
-- **Built-in functions** — Time-series, ML, geospatial
-- **Real-time** — Sub-second query response
-
-## Executing Queries via CLI
-
-### Basic Query Execution
-
-```bash
-WS_ID=$(fab get "Workspace" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "Workspace/MyDatabase.KQLDatabase" -q "id" | tr -d '"')
-
-# Simple query
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | take 10"
-}'
-```
-
-### Query with JMESPath Filter
-
-```bash
-# Extract specific columns from results
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | take 10"
-}' -q "results[].{device: deviceId, temp: temperature}"
-```
-
-### Query with Timeout
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "LargeTable | summarize count() by bin(timestamp, 1h)",
-  "requestProperties": {
-    "queryTimeout": "PT5M"
-  }
-}'
-```
-
-## Common Query Patterns
-
-### Time-Based Filtering
-
-```bash
-# Events from last hour
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | where timestamp > ago(1h)"
-}'
-
-# Events in time range
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | where timestamp between (datetime(2024-01-01) .. datetime(2024-01-31))"
-}'
-
-# Events from specific date
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | where timestamp > startofday(now())"
-}'
-```
-
-### Aggregations
-
-```bash
-# Count by time bucket
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | summarize count() by bin(timestamp, 5m)"
-}'
-
-# Statistics by group
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | summarize avg(temperature), max(temperature), min(temperature) by deviceId"
-}'
-
-# Top N
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | summarize count() by eventType | top 10 by count_"
-}'
-```
-
-### Filtering and Projection
-
-```bash
-# Filter with multiple conditions
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | where temperature > 100 and deviceId startswith \"sensor-\" | project timestamp, deviceId, temperature"
-}'
-
-# Text search
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Logs | where message contains \"error\" | take 100"
-}'
-
-# Regex matching
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Logs | where message matches regex \"Error: [A-Z]{3}[0-9]{4}\""
-}'
-```
-
-### Joins
-
-```bash
-# Inner join
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | join kind=inner (Devices | project deviceId, deviceName) on deviceId"
-}'
-
-# Left outer join
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | join kind=leftouter (Alerts | where severity == \"High\") on deviceId"
-}'
-```
-
-### Time Series Analysis
-
-```bash
-# Moving average
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 5m | extend movingAvg=series_fir(avgTemp, repeat(1, 3))"
-}'
-
-# Anomaly detection
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 5m | extend anomalies=series_decompose_anomalies(avgTemp)"
-}'
-
-# Forecasting
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | make-series avgTemp=avg(temperature) on timestamp step 1h | extend forecast=series_decompose_forecast(avgTemp, 24)"
-}'
-```
-
-## Management Commands
-
-### Show Tables
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show tables"
-}'
-```
-
-### Show Table Schema
-
-```bash
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table SensorReadings schema"
-}'
-
-# Columns only
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | getschema"
-}'
-```
-
-### Show Table Statistics
-
-```bash
-# Row count and size
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table SensorReadings details"
-}'
-
-# Data statistics
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "SensorReadings | summarize count(), min(timestamp), max(timestamp), dcount(deviceId)"
-}'
-```
-
-### Show Policies
-
-```bash
-# Retention policy
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table SensorReadings policy retention"
-}'
-
-# Caching policy
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table SensorReadings policy caching"
-}'
-
-# All policies
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table SensorReadings policies"
-}'
-```
-
-## Query Automation
-
-### Scheduled Query Script
-
-```bash
-#!/bin/bash
-# Run daily analytics query and export results
-
-WORKSPACE="Analytics.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "$WORKSPACE/AnalyticsDB.KQLDatabase" -q "id" | tr -d '"')
-
-# Daily summary query
-QUERY='
-Events 
-| where timestamp > ago(1d) 
-| summarize 
-    totalEvents=count(), 
-    uniqueDevices=dcount(deviceId),
-    errorCount=countif(eventType == "error")
-  by bin(timestamp, 1h)
-| order by timestamp asc
-'
-
-# Execute and save results
-RESULTS=$(fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i "{
-  \"query\": \"$QUERY\"
-}")
-
-echo "$RESULTS" > daily_summary_$(date +%Y%m%d).json
-echo "Daily summary exported"
-```
-
-### Alert Query Script
-
-```bash
-#!/bin/bash
-# Check for anomalies and alert
-
-WORKSPACE="Monitoring.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "$WORKSPACE/MonitoringDB.KQLDatabase" -q "id" | tr -d '"')
-
-# Check for high error rate
-ERRORS=$(fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "Events | where timestamp > ago(5m) | summarize errorRate=countif(eventType==\"error\") * 100.0 / count()"
-}' -q "results[0].errorRate")
-
-if (( $(echo "$ERRORS > 10" | bc -l) )); then
-  echo "ALERT: Error rate is $ERRORS%"
-  # Send notification...
-fi
-```
-
-### Batch Query Runner
-
-```bash
-#!/bin/bash
-# Run multiple queries and compile report
-
-WORKSPACE="Reports.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-KQL_DB_ID=$(fab get "$WORKSPACE/ReportsDB.KQLDatabase" -q "id" | tr -d '"')
-
-QUERIES=(
-  "Events | where timestamp > ago(1d) | count"
-  "Events | where timestamp > ago(1d) | summarize count() by eventType"
-  "SensorReadings | where timestamp > ago(1d) | summarize avg(temperature) by deviceId"
-)
-
-for i in "${!QUERIES[@]}"; do
-  echo "Running query $((i+1))..."
-  fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i "{
-    \"query\": \"${QUERIES[$i]}\"
-  }" > "query_${i}_results.json"
-done
-
-echo "All queries completed"
-```
-
-## KQL Querysets
-
-### Create KQL Queryset
-
-```bash
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AnalyticsQueries",
-  "type": "KQLQueryset"
-}'
-```
-
-### List Querysets
-
-```bash
-fab ls "Workspace/*.KQLQueryset"
-```
-
-### Export Queryset
-
-```bash
-fab export "Workspace/AnalyticsQueries.KQLQueryset" -d "./exports/"
-```
-
-### Import Queryset
-
-```bash
-fab import -p "Workspace" -d "./querysets/analytics.json" -t KQLQueryset
-```
-
-## Performance Optimization
-
-### Query Best Practices
-
-```kql
-// Use time filters early
-Events
-| where timestamp > ago(1h)  // Filter first
-| where eventType == "error"
-| summarize count() by deviceId
-
-// Avoid wildcards at start
-Events
-| where message startswith "Error"  // Good
-// | where message contains "Error"  // Less efficient
-
-// Project only needed columns
-Events
-| project timestamp, deviceId, eventType  // Early projection
-| where eventType == "error"
-```
-
-### Materialized Views
-
-```bash
-# Create materialized view for common aggregations
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create materialized-view HourlySummary on table Events { Events | summarize count() by bin(timestamp, 1h), eventType }"
-}'
-
-# Query materialized view
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "HourlySummary | where timestamp > ago(7d)"
-}'
-```
-
-### Functions
-
-```bash
-# Create stored function
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create function GetRecentErrors(hours: int = 1) { Events | where timestamp > ago(hours * 1h) | where eventType == \"error\" }"
-}'
-
-# Call function
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "GetRecentErrors(24)"
-}'
-```
-
-## Troubleshooting
-
-### Query Timeout
-
-```bash
-# Increase timeout
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "LargeQuery...",
-  "requestProperties": {
-    "queryTimeout": "PT10M"
-  }
-}'
-
-# Simplify query - add early filters
-# Use summarize to reduce data volume
-```
-
-### No Results
-
-```bash
-# Check table has data
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "TableName | count"
-}'
-
-# Check time range
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "TableName | summarize min(timestamp), max(timestamp)"
-}'
-
-# Verify column names
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "TableName | getschema"
-}'
-```
-
-### Permission Errors
-
-```bash
-# Verify database access
-fab acl get "Workspace/MyDatabase.KQLDatabase"
-
-# Check workspace role
-fab acl get "Workspace"
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md b/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
deleted file mode 100644
index 0cd59d9ea..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/references/streaming-patterns.md
+++ /dev/null
@@ -1,502 +0,0 @@
-# Streaming Patterns Reference
-
-End-to-end streaming architecture patterns for Microsoft Fabric.
-
-## Architecture Overview
-
-Fabric real-time intelligence provides a complete streaming platform:
-
-```
-Sources                    Processing                Storage/Analysis           Consumption
-─────────                  ──────────                ────────────────           ───────────
-Event Hub    ─┐                                      ┌─ KQL Database ──── KQL Queries
-IoT Hub      ─┼─► Eventstream ─► Transform ─────────┼─ Lakehouse ─────── Notebooks
-Custom API   ─┤                                      └─ Activator ─────── Alerts
-Kafka        ─┘
-```
-
-## Pattern 1: IoT Telemetry Pipeline
-
-### Use Case
-Process millions of IoT sensor readings with real-time analytics and alerting.
-
-### Architecture
-
-```bash
-#!/bin/bash
-# IoT Telemetry Pipeline Setup
-
-WORKSPACE="IoTAnalytics.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create Eventhouse for time-series data
-echo "Creating Eventhouse..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "TelemetryHub",
-  "type": "Eventhouse"
-}'
-
-sleep 15
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/TelemetryHub.Eventhouse" -q "id" | tr -d '"')
-
-# 2. Create KQL Database for hot data
-echo "Creating KQL Database..."
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"SensorDataDB\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-  }
-}"
-
-sleep 10
-KQL_DB_ID=$(fab get "$WORKSPACE/SensorDataDB.KQLDatabase" -q "id" | tr -d '"')
-
-# 3. Create tables with optimized schema
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table SensorReadings (timestamp: datetime, deviceId: string, sensorType: string, value: real, unit: string)"
-}'
-
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table DeviceEvents (timestamp: datetime, deviceId: string, eventType: string, details: dynamic)"
-}'
-
-# 4. Set retention and caching policies
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter-merge table SensorReadings policy retention softdelete = 30d"
-}'
-
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".alter table SensorReadings policy caching hot = 7d"
-}'
-
-# 5. Create Eventstream for ingestion
-echo "Creating Eventstream..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "IoTDataStream",
-  "type": "Eventstream"
-}'
-
-# 6. Create Lakehouse for cold storage
-echo "Creating Lakehouse for archive..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "TelemetryArchive",
-  "type": "Lakehouse"
-}'
-
-# 7. Create Activator for alerts
-echo "Creating alerting..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SensorAlerts",
-  "type": "Reflex"
-}'
-
-echo "IoT Pipeline infrastructure created!"
-echo "Next steps:"
-echo "1. Configure IoT Hub connection for Eventstream"
-echo "2. Add KQL Database and Lakehouse as Eventstream destinations"
-echo "3. Configure Activator alert conditions"
-```
-
-### Data Flow
-
-1. **Ingestion**: IoT Hub → Eventstream
-2. **Real-time Processing**: Eventstream transforms (filter, enrich)
-3. **Hot Storage**: KQL Database (7-day cache, 30-day retention)
-4. **Cold Storage**: Lakehouse (historical archive)
-5. **Alerting**: Activator monitors thresholds
-
-## Pattern 2: Event-Driven Architecture
-
-### Use Case
-Process business events with immediate notifications and analytics.
-
-### Architecture
-
-```bash
-#!/bin/bash
-# Event-Driven Architecture Setup
-
-WORKSPACE="EventDriven.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Domain-specific Eventstreams
-DOMAINS=("Orders" "Inventory" "Payments" "Shipping")
-
-for DOMAIN in "${DOMAINS[@]}"; do
-  echo "Creating ${DOMAIN}Stream..."
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${DOMAIN}Stream\",
-    \"type\": \"Eventstream\"
-  }"
-done
-
-# 2. Unified Eventhouse
-echo "Creating EventHub..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "BusinessEventsHub",
-  "type": "Eventhouse"
-}'
-
-sleep 15
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/BusinessEventsHub.Eventhouse" -q "id" | tr -d '"')
-
-# 3. Domain-specific KQL databases
-for DOMAIN in "${DOMAINS[@]}"; do
-  echo "Creating ${DOMAIN}DB..."
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${DOMAIN}DB\",
-    \"type\": \"KQLDatabase\",
-    \"properties\": {
-      \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-    }
-  }"
-done
-
-# 4. Create aggregation views
-sleep 10
-KQL_DB_ID=$(fab get "$WORKSPACE/OrdersDB.KQLDatabase" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".create table Orders (timestamp: datetime, orderId: string, customerId: string, status: string, amount: real)"
-}'
-
-# 5. Alerting per domain
-for DOMAIN in "${DOMAINS[@]}"; do
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${DOMAIN}Alerts\",
-    \"type\": \"Reflex\"
-  }"
-done
-
-echo "Event-Driven Architecture created!"
-```
-
-### Event Flow
-
-1. **Domain Events**: Separate Eventstreams per domain
-2. **Event Store**: KQL databases for queryable event history
-3. **Event Processing**: Real-time aggregations
-4. **Reactions**: Domain-specific Activators for business rules
-
-## Pattern 3: Lambda Architecture
-
-### Use Case
-Combine real-time and batch processing for complete analytics.
-
-### Architecture
-
-```bash
-#!/bin/bash
-# Lambda Architecture Setup
-
-WORKSPACE="Lambda.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# Speed Layer (Real-time)
-echo "Creating Speed Layer..."
-
-# Eventhouse for real-time queries
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SpeedLayerHub",
-  "type": "Eventhouse"
-}'
-
-sleep 15
-SPEED_EH_ID=$(fab get "$WORKSPACE/SpeedLayerHub.Eventhouse" -q "id" | tr -d '"')
-
-fab api -X post "workspaces/$WS_ID/items" -i "{
-  \"displayName\": \"RealtimeDB\",
-  \"type\": \"KQLDatabase\",
-  \"properties\": {
-    \"parentEventhouseId\": \"$SPEED_EH_ID\"
-  }
-}"
-
-# Eventstream for ingestion
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "IngestionStream",
-  "type": "Eventstream"
-}'
-
-# Batch Layer (Historical)
-echo "Creating Batch Layer..."
-
-# Bronze Lakehouse
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "BronzeLakehouse",
-  "type": "Lakehouse"
-}'
-
-# Silver Lakehouse
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "SilverLakehouse",
-  "type": "Lakehouse"
-}'
-
-# Gold Lakehouse
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "GoldLakehouse",
-  "type": "Lakehouse"
-}'
-
-# Serving Layer
-echo "Creating Serving Layer..."
-
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "AnalyticsModel",
-  "type": "SemanticModel"
-}'
-
-echo "Lambda Architecture created!"
-echo ""
-echo "Architecture:"
-echo "┌─────────────────────────────────────────────┐"
-echo "│           Data Sources                       │"
-echo "└─────────────────┬───────────────────────────┘"
-echo "                  │"
-echo "         ┌────────┴────────┐"
-echo "         ▼                 ▼"
-echo "  ┌─────────────┐   ┌──────────────┐"
-echo "  │ Speed Layer │   │ Batch Layer  │"
-echo "  │  (KQL DB)   │   │ (Lakehouse)  │"
-echo "  └──────┬──────┘   └───────┬──────┘"
-echo "         │                  │"
-echo "         └────────┬─────────┘"
-echo "                  ▼"
-echo "         ┌──────────────┐"
-echo "         │Serving Layer │"
-echo "         │(Semantic Mdl)│"
-echo "         └──────────────┘"
-```
-
-### Data Flow
-
-1. **Speed Layer**: Eventstream → KQL Database (real-time, ~hours retention)
-2. **Batch Layer**: Eventstream → Lakehouse (medallion architecture, historical)
-3. **Serving Layer**: Combined queries via Semantic Model
-
-## Pattern 4: Stream-to-Lakehouse
-
-### Use Case
-Stream data directly to Delta Lake for unified batch and streaming.
-
-### Architecture
-
-```bash
-#!/bin/bash
-# Stream-to-Lakehouse Pattern
-
-WORKSPACE="StreamLake.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Create streaming Lakehouse
-echo "Creating streaming Lakehouse..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "StreamingLakehouse",
-  "type": "Lakehouse"
-}'
-
-# 2. Create Eventstream
-echo "Creating Eventstream..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "LakehouseStream",
-  "type": "Eventstream"
-}'
-
-# 3. Create Notebook for streaming queries
-echo "Creating streaming notebook..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "StreamingQueries",
-  "type": "Notebook"
-}'
-
-echo "Stream-to-Lakehouse infrastructure created!"
-echo ""
-echo "Configuration steps:"
-echo "1. Configure Eventstream source (Event Hub, IoT Hub, etc.)"
-echo "2. Add Lakehouse as Eventstream destination"
-echo "3. Configure table and partitioning in Lakehouse destination"
-echo "4. Use Notebook for streaming DataFrame queries"
-```
-
-### Streaming Query Example
-
-```python
-# In Notebook: Query streaming table
-from pyspark.sql.functions import *
-
-# Read from streaming table
-df = spark.readStream \
-    .format("delta") \
-    .table("StreamingLakehouse.streaming_events")
-
-# Real-time aggregation
-agg_df = df \
-    .withWatermark("timestamp", "10 minutes") \
-    .groupBy(
-        window("timestamp", "5 minutes"),
-        "eventType"
-    ) \
-    .count()
-
-# Write to output table
-agg_df.writeStream \
-    .format("delta") \
-    .outputMode("append") \
-    .option("checkpointLocation", "Tables/_checkpoints/agg") \
-    .toTable("StreamingLakehouse.event_aggregates")
-```
-
-## Pattern 5: Real-Time Monitoring
-
-### Use Case
-System health monitoring with immediate alerting.
-
-### Architecture
-
-```bash
-#!/bin/bash
-# Real-Time Monitoring Setup
-
-WORKSPACE="Monitoring.Workspace"
-WS_ID=$(fab get "$WORKSPACE" -q "id" | tr -d '"')
-
-# 1. Metrics Eventhouse
-echo "Creating Metrics Hub..."
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "MetricsHub",
-  "type": "Eventhouse"
-}'
-
-sleep 15
-EVENTHOUSE_ID=$(fab get "$WORKSPACE/MetricsHub.Eventhouse" -q "id" | tr -d '"')
-
-# 2. Specialized databases
-METRIC_TYPES=("Infrastructure" "Application" "Business")
-
-for TYPE in "${METRIC_TYPES[@]}"; do
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${TYPE}MetricsDB\",
-    \"type\": \"KQLDatabase\",
-    \"properties\": {
-      \"parentEventhouseId\": \"$EVENTHOUSE_ID\"
-    }
-  }"
-done
-
-# 3. Ingestion Eventstreams
-for TYPE in "${METRIC_TYPES[@]}"; do
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${TYPE}MetricsStream\",
-    \"type\": \"Eventstream\"
-  }"
-done
-
-# 4. Alert Activators
-ALERT_TYPES=(
-  "CriticalInfrastructure"
-  "ApplicationErrors"
-  "SLAViolation"
-  "SecurityAnomaly"
-)
-
-for ALERT in "${ALERT_TYPES[@]}"; do
-  fab api -X post "workspaces/$WS_ID/items" -i "{
-    \"displayName\": \"${ALERT}Alert\",
-    \"type\": \"Reflex\"
-  }"
-done
-
-# 5. Dashboard Queryset
-fab api -X post "workspaces/$WS_ID/items" -i '{
-  "displayName": "MonitoringDashboardQueries",
-  "type": "KQLQueryset"
-}'
-
-echo "Monitoring infrastructure created!"
-```
-
-### Monitoring Queries
-
-```bash
-# Infrastructure health
-fab api -X post "workspaces/$WS_ID/items/$INFRA_DB_ID/query" -i '{
-  "query": "Metrics | where timestamp > ago(5m) | summarize avgCPU=avg(cpu_percent), avgMemory=avg(memory_percent) by bin(timestamp, 1m), hostName"
-}'
-
-# Error rates
-fab api -X post "workspaces/$WS_ID/items/$APP_DB_ID/query" -i '{
-  "query": "Logs | where timestamp > ago(5m) | summarize errorRate=countif(level==\"ERROR\") * 100.0 / count() by bin(timestamp, 1m)"
-}'
-
-# SLA tracking
-fab api -X post "workspaces/$WS_ID/items/$BIZ_DB_ID/query" -i '{
-  "query": "Transactions | where timestamp > ago(1h) | summarize p99_latency=percentile(latency_ms, 99), success_rate=countif(status==\"success\") * 100.0 / count() by bin(timestamp, 5m)"
-}'
-```
-
-## Best Practices
-
-### Design Principles
-
-| Principle | Description |
-|-----------|-------------|
-| Schema design | Design for query patterns, not ingestion |
-| Partitioning | Partition by time for efficient querying |
-| Retention | Match retention to use case |
-| Deduplication | Handle duplicates at ingestion |
-
-### Performance Optimization
-
-- Use appropriate time windows for aggregations
-- Enable caching for frequently queried data
-- Create materialized views for common aggregations
-- Optimize KQL queries for time-series patterns
-
-### Operational Considerations
-
-- Monitor ingestion lag and throughput
-- Set up alerts for data freshness
-- Implement dead-letter handling
-- Plan for schema evolution
-
-## Troubleshooting Common Issues
-
-### Data Latency
-
-```bash
-# Check Eventstream lag
-fab get "Workspace/MyStream.Eventstream" -q "properties"
-
-# Query ingestion delay in KQL
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": "TableName | summarize max(ingestion_time() - timestamp)"
-}'
-```
-
-### Missing Data
-
-```bash
-# Check for ingestion failures
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show ingestion failures | where FailedOn > ago(1h)"
-}'
-
-# Verify source connectivity
-fab ls ".connections" -l
-```
-
-### Query Performance
-
-```bash
-# Analyze slow queries
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show queries | where StartedOn > ago(1h) | where Duration > 30s | project StartedOn, Duration, Text"
-}'
-
-# Check table statistics
-fab api -X post "workspaces/$WS_ID/items/$KQL_DB_ID/query" -i '{
-  "query": ".show table TableName extents | summarize count(), sum(OriginalSize), sum(CompressedSize)"
-}'
-```
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py b/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
deleted file mode 100644
index 2404bda3e..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/scripts/kql_query.py
+++ /dev/null
@@ -1,382 +0,0 @@
-#!/usr/bin/env python3
-"""
-kql_query.py - Execute KQL query and return results
-
-This script executes Kusto Query Language (KQL) queries against a KQL database
-and returns the results.
-
-Usage:
-    python kql_query.py <database> --query <kql-file>
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --query queries/anomalies.kql
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "SensorData | take 10"
-
-Exit codes:
-    0 - Query executed successfully
-    1 - Query execution failed
-"""
-
-import argparse
-import csv
-import json
-import subprocess
-import sys
-from io import StringIO
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 300) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def ensure_database_suffix(path: str) -> str:
-    """Ensure path has .KQLDatabase suffix if needed."""
-    known_suffixes = [".KQLDatabase", ".Workspace"]
-    for suffix in known_suffixes:
-        if path.endswith(suffix):
-            return path
-    
-    # If path contains a workspace but no database type, add KQLDatabase
-    if "/" in path and not path.split("/")[-1].count("."):
-        return f"{path}.KQLDatabase"
-    
-    return path
-
-
-def check_path_exists(path: str) -> bool:
-    """Check if path exists."""
-    exit_code, _, _ = run_fab_command(["exists", path])
-    return exit_code == 0
-
-
-def load_query_from_file(file_path: str) -> str:
-    """Load KQL query from a file."""
-    path = Path(file_path)
-    
-    if not path.exists():
-        raise FileNotFoundError(f"Query file not found: {file_path}")
-    
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read().strip()
-
-
-def execute_kql_query(
-    database_path: str,
-    query: str,
-    timeout: int = 300,
-    limit: Optional[int] = None
-) -> Dict[str, Any]:
-    """Execute a KQL query against a database."""
-    
-    result = {
-        "database": database_path,
-        "query": query,
-        "status": "unknown",
-        "message": "",
-        "rows": [],
-        "columns": [],
-        "row_count": 0,
-        "execution_time_ms": None
-    }
-    
-    # Apply limit if specified and not already in query
-    if limit and "| take" not in query.lower() and "| limit" not in query.lower():
-        query = f"{query} | take {limit}"
-        result["query"] = query
-    
-    # Build the query command
-    cmd = ["tables", "query", database_path, "-q", query, "-f", "json"]
-    
-    exit_code, stdout, stderr = run_fab_command(cmd, timeout=timeout)
-    
-    if exit_code == 0:
-        result["status"] = "success"
-        result["message"] = "Query executed successfully"
-        
-        # Parse the JSON results
-        try:
-            query_result = json.loads(stdout.strip())
-            
-            # Handle different result formats
-            if isinstance(query_result, list):
-                result["rows"] = query_result
-                result["row_count"] = len(query_result)
-                if query_result:
-                    result["columns"] = list(query_result[0].keys())
-            elif isinstance(query_result, dict):
-                if "rows" in query_result:
-                    result["rows"] = query_result["rows"]
-                    result["row_count"] = len(query_result["rows"])
-                if "columns" in query_result:
-                    result["columns"] = query_result["columns"]
-                if "statistics" in query_result:
-                    stats = query_result["statistics"]
-                    if "executionTime" in stats:
-                        result["execution_time_ms"] = stats["executionTime"]
-                        
-        except json.JSONDecodeError:
-            # Output might be in table format
-            result["raw_output"] = stdout.strip()
-            result["message"] = "Query executed but output is not JSON"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or "Query execution failed"
-    
-    return result
-
-
-def format_table_output(rows: List[Dict[str, Any]], columns: List[str], max_width: int = 120):
-    """Format results as a readable table."""
-    if not rows:
-        print("No results returned.")
-        return
-    
-    if not columns:
-        columns = list(rows[0].keys())
-    
-    # Calculate column widths
-    widths = {}
-    for col in columns:
-        col_values = [str(row.get(col, ""))[:50] for row in rows]
-        widths[col] = max(len(col), max(len(v) for v in col_values) if col_values else 0)
-    
-    # Adjust widths if total is too wide
-    total_width = sum(widths.values()) + len(columns) * 3
-    if total_width > max_width:
-        scale = max_width / total_width
-        widths = {k: max(5, int(v * scale)) for k, v in widths.items()}
-    
-    # Print header
-    header = " | ".join(col[:widths[col]].ljust(widths[col]) for col in columns)
-    print(header)
-    print("-" * len(header))
-    
-    # Print rows
-    for row in rows:
-        row_str = " | ".join(
-            str(row.get(col, ""))[:widths[col]].ljust(widths[col]) 
-            for col in columns
-        )
-        print(row_str)
-
-
-def format_csv_output(rows: List[Dict[str, Any]], columns: List[str]):
-    """Format results as CSV."""
-    if not rows:
-        return
-    
-    if not columns:
-        columns = list(rows[0].keys())
-    
-    output = StringIO()
-    writer = csv.DictWriter(output, fieldnames=columns, extrasaction='ignore')
-    writer.writeheader()
-    writer.writerows(rows)
-    print(output.getvalue())
-
-
-def execute_query(
-    database: str,
-    query: Optional[str] = None,
-    query_file: Optional[str] = None,
-    inline: Optional[str] = None,
-    timeout: int = 300,
-    limit: Optional[int] = None
-) -> Dict[str, Any]:
-    """Execute KQL query from file or inline."""
-    
-    database = ensure_database_suffix(database)
-    
-    report = {
-        "database": database,
-        "query_source": None,
-        "query": None,
-        "result": {}
-    }
-    
-    # Verify database exists
-    print(f"\nVerifying database: {database}")
-    if not check_path_exists(database):
-        print(f"Error: Database '{database}' does not exist or is not accessible")
-        return report
-    print("  Database found")
-    
-    # Determine query source
-    if query_file:
-        print(f"\nLoading query from file: {query_file}")
-        try:
-            kql_query = load_query_from_file(query_file)
-            report["query_source"] = f"file:{query_file}"
-        except FileNotFoundError as e:
-            print(f"Error: {e}")
-            return report
-    elif inline:
-        kql_query = inline
-        report["query_source"] = "inline"
-    elif query:
-        kql_query = query
-        report["query_source"] = "argument"
-    else:
-        print("Error: Must provide --query, --file, or --inline")
-        return report
-    
-    report["query"] = kql_query
-    
-    # Display query
-    print("\nExecuting query:")
-    query_lines = kql_query.split("\n")
-    for line in query_lines[:5]:
-        print(f"  {line}")
-    if len(query_lines) > 5:
-        print(f"  ... ({len(query_lines) - 5} more lines)")
-    
-    if limit:
-        print(f"\nRow limit: {limit}")
-    
-    # Execute query
-    print("\nRunning query...")
-    result = execute_kql_query(database, kql_query, timeout=timeout, limit=limit)
-    report["result"] = result
-    
-    if result["status"] == "success":
-        print(f"  ✓ Query completed: {result['row_count']} row(s) returned")
-        if result.get("execution_time_ms"):
-            print(f"  Execution time: {result['execution_time_ms']}ms")
-    else:
-        print(f"  ✗ Query failed: {result['message']}")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Execute KQL query and return results",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    # Query from file
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --file queries/anomalies.kql
-
-    # Inline query
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "SensorData | take 10"
-
-    # Query with row limit
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --inline "Logs | where Level == 'Error'" --limit 100
-
-    # Output as CSV
-    python kql_query.py RealTime.Workspace/SensorDB.KQLDatabase --file query.kql --format csv
-
-KQL Query Examples:
-    # Simple table scan
-    SensorData | take 100
-
-    # Filter and project
-    Logs 
-    | where Timestamp > ago(1h)
-    | where Level == "Error"
-    | project Timestamp, Message
-
-    # Aggregation
-    Metrics
-    | summarize avg(Value), max(Value) by bin(Timestamp, 1h), DeviceId
-
-    # Time series
-    SensorData
-    | where Timestamp > ago(24h)
-    | summarize avg(Temperature) by bin(Timestamp, 1h)
-    | render timechart
-        """
-    )
-    parser.add_argument(
-        "database",
-        help="KQL database path (Workspace/Database.KQLDatabase)"
-    )
-    
-    # Query source (mutually exclusive)
-    query_group = parser.add_mutually_exclusive_group(required=True)
-    query_group.add_argument(
-        "--file", "-f",
-        dest="query_file",
-        help="Path to KQL query file"
-    )
-    query_group.add_argument(
-        "--inline", "-i",
-        help="Inline KQL query string"
-    )
-    query_group.add_argument(
-        "--query", "-q",
-        help="KQL query string"
-    )
-    
-    parser.add_argument(
-        "--limit", "-l",
-        type=int,
-        help="Maximum number of rows to return"
-    )
-    parser.add_argument(
-        "--timeout", "-t",
-        type=int,
-        default=300,
-        help="Query timeout in seconds (default: 300)"
-    )
-    parser.add_argument(
-        "--format",
-        choices=["table", "json", "csv"],
-        default="table",
-        help="Output format (default: table)"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        report = execute_query(
-            database=args.database,
-            query=args.query,
-            query_file=args.query_file,
-            inline=args.inline,
-            timeout=args.timeout,
-            limit=args.limit
-        )
-        
-        result = report.get("result", {})
-        
-        # Print results in requested format
-        if result.get("status") == "success" and result.get("rows"):
-            print("\n" + "=" * 50)
-            print("QUERY RESULTS")
-            print("=" * 50)
-            
-            if args.format == "json":
-                print(json.dumps(result["rows"], indent=2, default=str))
-            elif args.format == "csv":
-                format_csv_output(result["rows"], result.get("columns", []))
-            else:  # table
-                format_table_output(result["rows"], result.get("columns", []))
-            
-            print("=" * 50)
-            print(f"Rows: {result['row_count']}")
-        
-        # Exit code based on query status
-        sys.exit(0 if result.get("status") == "success" else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py b/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
deleted file mode 100644
index 58babf2c2..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/scripts/monitor_eventstream.py
+++ /dev/null
@@ -1,523 +0,0 @@
-#!/usr/bin/env python3
-"""
-monitor_eventstream.py - Check eventstream health and throughput
-
-This script monitors the health and performance of an eventstream in Microsoft Fabric,
-checking status, throughput metrics, and error counts.
-
-Usage:
-    python monitor_eventstream.py <eventstream>
-    python monitor_eventstream.py RealTime.Workspace/SensorStream.Eventstream
-
-Exit codes:
-    0 - Eventstream is healthy
-    1 - Eventstream has issues or error occurred
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from datetime import datetime
-from typing import Dict, Any, List, Optional, Tuple
-
-
-def run_fab_command(args: list[str], timeout: int = 60) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def parse_eventstream_path(path: str) -> Tuple[Optional[str], Optional[str]]:
-    """Parse workspace and eventstream name from path."""
-    parts = path.split("/")
-    if len(parts) != 2:
-        return None, None
-    
-    workspace = parts[0]
-    eventstream = parts[1]
-    
-    # Ensure workspace suffix
-    if not workspace.endswith(".Workspace"):
-        workspace = f"{workspace}.Workspace"
-    
-    # Ensure eventstream suffix
-    if not eventstream.endswith(".Eventstream"):
-        eventstream = f"{eventstream}.Eventstream"
-    
-    return workspace, eventstream
-
-
-def check_path_exists(path: str) -> bool:
-    """Check if path exists."""
-    exit_code, _, _ = run_fab_command(["exists", path])
-    return exit_code == 0
-
-
-def get_item_details(path: str) -> Dict[str, Any]:
-    """Get item details."""
-    exit_code, stdout, stderr = run_fab_command(["get", path, "-f", "json"])
-    
-    if exit_code == 0:
-        return parse_json_output(stdout) or {"error": "Failed to parse item details"}
-    return {"error": stderr.strip() or "Failed to get item details"}
-
-
-def get_item_id(path: str) -> Optional[str]:
-    """Get item ID from path."""
-    exit_code, stdout, stderr = run_fab_command(["get", path, "-q", "id", "-f", "json"])
-    
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if isinstance(result, str):
-            return result.strip('"')
-        return result
-    return None
-
-
-def get_eventstream_status(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
-    """Get eventstream status via API."""
-    
-    # Try to get eventstream details from the API
-    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}"
-    
-    exit_code, stdout, stderr = run_fab_command([
-        "api", "get", api_path,
-        "-f", "json"
-    ], timeout=30)
-    
-    if exit_code == 0:
-        return parse_json_output(stdout) or {"error": "Failed to parse response"}
-    return {"error": stderr}
-
-
-def get_eventstream_metrics(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
-    """Get eventstream metrics if available."""
-    
-    metrics = {
-        "input_events": None,
-        "output_events": None,
-        "errors": None,
-        "lag": None,
-        "last_updated": None
-    }
-    
-    # Try to get metrics from monitoring API
-    # Note: This is a placeholder - actual API may differ
-    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}/metrics"
-    
-    exit_code, stdout, stderr = run_fab_command([
-        "api", "get", api_path,
-        "-f", "json"
-    ], timeout=30)
-    
-    if exit_code == 0:
-        data = parse_json_output(stdout)
-        if data:
-            metrics["input_events"] = data.get("inputEventsTotal") or data.get("inputEvents")
-            metrics["output_events"] = data.get("outputEventsTotal") or data.get("outputEvents")
-            metrics["errors"] = data.get("errorCount") or data.get("errors")
-            metrics["lag"] = data.get("lagMs") or data.get("lag")
-            metrics["last_updated"] = datetime.now().isoformat()
-    
-    return metrics
-
-
-def get_eventstream_sources_sinks(workspace_id: str, eventstream_id: str) -> Dict[str, Any]:
-    """Get eventstream sources and sinks configuration."""
-    
-    result = {
-        "sources": [],
-        "sinks": []
-    }
-    
-    # Try to get source/sink configuration
-    api_path = f"/workspaces/{workspace_id}/eventstreams/{eventstream_id}/configuration"
-    
-    exit_code, stdout, stderr = run_fab_command([
-        "api", "get", api_path,
-        "-f", "json"
-    ], timeout=30)
-    
-    if exit_code == 0:
-        data = parse_json_output(stdout)
-        if data:
-            result["sources"] = data.get("sources", [])
-            result["sinks"] = data.get("sinks", []) or data.get("destinations", [])
-    
-    return result
-
-
-def analyze_health(details: Dict[str, Any], metrics: Dict[str, Any], 
-                   config: Dict[str, Any]) -> Dict[str, Any]:
-    """Analyze eventstream health based on collected data."""
-    
-    health = {
-        "status": "unknown",
-        "score": 0,
-        "checks": [],
-        "warnings": [],
-        "recommendations": []
-    }
-    
-    max_score = 0
-    actual_score = 0
-    
-    # Check 1: Eventstream exists and has basic info
-    max_score += 20
-    if details and "error" not in details:
-        actual_score += 20
-        health["checks"].append({
-            "name": "eventstream_accessible",
-            "passed": True,
-            "message": "Eventstream is accessible"
-        })
-    else:
-        health["checks"].append({
-            "name": "eventstream_accessible",
-            "passed": False,
-            "message": f"Could not access eventstream: {details.get('error', 'Unknown')}"
-        })
-    
-    # Check 2: Has configured sources
-    max_score += 20
-    sources = config.get("sources", [])
-    if sources:
-        actual_score += 20
-        health["checks"].append({
-            "name": "has_sources",
-            "passed": True,
-            "message": f"Eventstream has {len(sources)} configured source(s)"
-        })
-    else:
-        health["checks"].append({
-            "name": "has_sources",
-            "passed": False,
-            "message": "No sources configured"
-        })
-        health["recommendations"].append("Configure at least one data source for the eventstream")
-    
-    # Check 3: Has configured sinks
-    max_score += 20
-    sinks = config.get("sinks", [])
-    if sinks:
-        actual_score += 20
-        health["checks"].append({
-            "name": "has_sinks",
-            "passed": True,
-            "message": f"Eventstream has {len(sinks)} configured sink(s)"
-        })
-    else:
-        health["warnings"].append("No sinks/destinations configured")
-        health["checks"].append({
-            "name": "has_sinks",
-            "passed": False,
-            "message": "No sinks configured"
-        })
-        health["recommendations"].append("Configure at least one destination for the eventstream")
-    
-    # Check 4: Error rate
-    max_score += 20
-    error_count = metrics.get("errors")
-    if error_count is not None:
-        if error_count == 0:
-            actual_score += 20
-            health["checks"].append({
-                "name": "no_errors",
-                "passed": True,
-                "message": "No errors detected"
-            })
-        else:
-            # Partial score based on error severity
-            health["checks"].append({
-                "name": "no_errors",
-                "passed": False,
-                "message": f"Detected {error_count} error(s)"
-            })
-            health["warnings"].append(f"Eventstream has {error_count} errors")
-            health["recommendations"].append("Review eventstream error logs to identify and fix issues")
-    else:
-        actual_score += 10  # Neutral if we can't check
-        health["checks"].append({
-            "name": "no_errors",
-            "passed": True,
-            "message": "Error metrics not available"
-        })
-    
-    # Check 5: Throughput/Activity
-    max_score += 20
-    input_events = metrics.get("input_events")
-    output_events = metrics.get("output_events")
-    
-    if input_events is not None:
-        if input_events > 0:
-            actual_score += 20
-            health["checks"].append({
-                "name": "has_throughput",
-                "passed": True,
-                "message": f"Processing events (input: {input_events}, output: {output_events or 'N/A'})"
-            })
-        else:
-            health["checks"].append({
-                "name": "has_throughput",
-                "passed": False,
-                "message": "No events being processed"
-            })
-            health["warnings"].append("Eventstream shows no event activity")
-            health["recommendations"].append("Verify that sources are sending data")
-    else:
-        actual_score += 10  # Neutral if we can't check
-        health["checks"].append({
-            "name": "has_throughput",
-            "passed": True,
-            "message": "Throughput metrics not available"
-        })
-    
-    # Calculate overall score
-    health["score"] = int((actual_score / max_score) * 100) if max_score > 0 else 0
-    
-    # Determine status
-    if health["score"] >= 80:
-        health["status"] = "healthy"
-    elif health["score"] >= 60:
-        health["status"] = "warning"
-    else:
-        health["status"] = "unhealthy"
-    
-    return health
-
-
-def print_monitoring_report(result: Dict[str, Any], output_format: str, 
-                           output_file: Optional[str] = None):
-    """Print monitoring report."""
-    if output_format == "json":
-        output = json.dumps(result, indent=2)
-    else:
-        # Text format
-        lines = []
-        lines.append("=" * 70)
-        lines.append("EVENTSTREAM MONITORING REPORT")
-        lines.append("=" * 70)
-        lines.append(f"Eventstream: {result['eventstream']}")
-        lines.append(f"Timestamp: {result.get('timestamp', 'Unknown')}")
-        lines.append("")
-        
-        health = result.get("health", {})
-        status = health.get("status", "unknown").upper()
-        score = health.get("score", 0)
-        
-        status_icon = {
-            "HEALTHY": "✓",
-            "WARNING": "⚠",
-            "UNHEALTHY": "✗",
-            "UNKNOWN": "?"
-        }.get(status, "?")
-        
-        lines.append(f"STATUS: {status_icon} {status} (Health Score: {score}%)")
-        lines.append("")
-        
-        # Health checks
-        lines.append("HEALTH CHECKS:")
-        for check in health.get("checks", []):
-            icon = "✓" if check["passed"] else "✗"
-            lines.append(f"  {icon} {check['name']}: {check['message']}")
-        lines.append("")
-        
-        # Metrics
-        metrics = result.get("metrics", {})
-        if any(v is not None for v in metrics.values()):
-            lines.append("METRICS:")
-            if metrics.get("input_events") is not None:
-                lines.append(f"  Input Events: {metrics['input_events']}")
-            if metrics.get("output_events") is not None:
-                lines.append(f"  Output Events: {metrics['output_events']}")
-            if metrics.get("errors") is not None:
-                lines.append(f"  Errors: {metrics['errors']}")
-            if metrics.get("lag") is not None:
-                lines.append(f"  Lag: {metrics['lag']} ms")
-            lines.append("")
-        
-        # Configuration
-        config = result.get("configuration", {})
-        sources = config.get("sources", [])
-        sinks = config.get("sinks", [])
-        
-        lines.append("CONFIGURATION:")
-        lines.append(f"  Sources: {len(sources)}")
-        for src in sources[:5]:  # Show first 5
-            name = src.get("name") or src.get("type", "Unknown")
-            lines.append(f"    - {name}")
-        if len(sources) > 5:
-            lines.append(f"    ... and {len(sources) - 5} more")
-        
-        lines.append(f"  Sinks/Destinations: {len(sinks)}")
-        for sink in sinks[:5]:  # Show first 5
-            name = sink.get("name") or sink.get("type", "Unknown")
-            lines.append(f"    - {name}")
-        if len(sinks) > 5:
-            lines.append(f"    ... and {len(sinks) - 5} more")
-        lines.append("")
-        
-        # Warnings
-        if health.get("warnings"):
-            lines.append("WARNINGS:")
-            for warning in health["warnings"]:
-                lines.append(f"  ⚠ {warning}")
-            lines.append("")
-        
-        # Recommendations
-        if health.get("recommendations"):
-            lines.append("RECOMMENDATIONS:")
-            for rec in health["recommendations"]:
-                lines.append(f"  → {rec}")
-            lines.append("")
-        
-        lines.append("=" * 70)
-        output = "\n".join(lines)
-    
-    if output_file:
-        with open(output_file, "w", encoding="utf-8") as f:
-            f.write(output)
-        print(f"Report written to: {output_file}", file=sys.stderr)
-    else:
-        print(output)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Check eventstream health and throughput",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python monitor_eventstream.py RealTime.Workspace/SensorStream.Eventstream
-    python monitor_eventstream.py MyWorkspace/MyEventstream -f json
-    python monitor_eventstream.py Production.Workspace/TelemetryStream.Eventstream -o report.json
-        """
-    )
-    
-    parser.add_argument(
-        "eventstream",
-        help="Eventstream path (e.g., 'MyWorkspace.Workspace/MyEventstream.Eventstream')"
-    )
-    
-    parser.add_argument(
-        "-f", "--format",
-        choices=["text", "json"],
-        default="text",
-        help="Output format (default: text)"
-    )
-    
-    parser.add_argument(
-        "-o", "--output",
-        help="Output file path (default: stdout)"
-    )
-    
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Enable verbose output"
-    )
-    
-    args = parser.parse_args()
-    
-    # Parse eventstream path
-    workspace, eventstream = parse_eventstream_path(args.eventstream)
-    if not workspace or not eventstream:
-        print(f"Error: Invalid eventstream path: {args.eventstream}", file=sys.stderr)
-        print("Expected format: Workspace.Workspace/Eventstream.Eventstream", file=sys.stderr)
-        return 1
-    
-    eventstream_path = f"{workspace}/{eventstream}"
-    
-    if args.verbose:
-        print(f"Monitoring eventstream: {eventstream_path}", file=sys.stderr)
-    
-    # Check eventstream exists
-    if not check_path_exists(eventstream_path):
-        print(f"Error: Eventstream does not exist: {eventstream_path}", file=sys.stderr)
-        return 1
-    
-    # Get IDs
-    if args.verbose:
-        print("Getting item IDs...", file=sys.stderr)
-    
-    workspace_id = get_item_id(workspace)
-    eventstream_id = get_item_id(eventstream_path)
-    
-    if not workspace_id or not eventstream_id:
-        print("Error: Could not get workspace or eventstream ID", file=sys.stderr)
-        return 1
-    
-    # Get eventstream details
-    if args.verbose:
-        print("Getting eventstream details...", file=sys.stderr)
-    
-    details = get_item_details(eventstream_path)
-    
-    # Get status
-    if args.verbose:
-        print("Getting eventstream status...", file=sys.stderr)
-    
-    status = get_eventstream_status(workspace_id, eventstream_id)
-    
-    # Get metrics
-    if args.verbose:
-        print("Getting metrics...", file=sys.stderr)
-    
-    metrics = get_eventstream_metrics(workspace_id, eventstream_id)
-    
-    # Get configuration
-    if args.verbose:
-        print("Getting configuration...", file=sys.stderr)
-    
-    config = get_eventstream_sources_sinks(workspace_id, eventstream_id)
-    
-    # Analyze health
-    if args.verbose:
-        print("Analyzing health...", file=sys.stderr)
-    
-    health = analyze_health(details, metrics, config)
-    
-    # Build result
-    result = {
-        "eventstream": eventstream_path,
-        "timestamp": datetime.now().isoformat(),
-        "workspace_id": workspace_id,
-        "eventstream_id": eventstream_id,
-        "details": details if "error" not in details else None,
-        "metrics": metrics,
-        "configuration": config,
-        "health": health
-    }
-    
-    # Output report
-    print_monitoring_report(result, args.format, args.output)
-    
-    # Return exit code based on health status
-    if health["status"] == "unhealthy":
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py b/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py
deleted file mode 100644
index 8410e0f0c..000000000
--- a/.ai-assets/skills/fabric-cli-realtime/scripts/setup_streaming.py
+++ /dev/null
@@ -1,489 +0,0 @@
-#!/usr/bin/env python3
-"""
-setup_streaming.py - Create complete streaming pipeline
-
-This script creates a complete real-time analytics pipeline in Microsoft Fabric,
-including Eventhouse, KQL Database, Eventstream, KQL Queryset, and optionally an Activator.
-
-Usage:
-    python setup_streaming.py <workspace> --name <pipeline>
-    python setup_streaming.py RealTime.Workspace --name IoTTelemetry
-    python setup_streaming.py RealTime.Workspace --name IoTTelemetry --with-alerts
-
-Exit codes:
-    0 - Streaming pipeline created successfully
-    1 - Error during creation
-"""
-
-import argparse
-import json
-import subprocess
-import sys
-from typing import Dict, Any, List, Optional
-
-
-def run_fab_command(args: list[str], timeout: int = 120) -> tuple[int, str, str]:
-    """Execute a fab CLI command and return exit code, stdout, stderr."""
-    try:
-        result = subprocess.run(
-            ["fab"] + args,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except FileNotFoundError:
-        return -1, "", "fab CLI not found in PATH"
-    except subprocess.TimeoutExpired:
-        return -2, "", f"Command timed out after {timeout} seconds"
-    except Exception as e:
-        return -3, "", str(e)
-
-
-def parse_json_output(output: str) -> Any:
-    """Parse JSON output from fab CLI."""
-    try:
-        return json.loads(output.strip())
-    except json.JSONDecodeError:
-        return None
-
-
-def ensure_workspace_suffix(workspace: str) -> str:
-    """Ensure workspace name has .Workspace suffix."""
-    if not workspace.endswith(".Workspace"):
-        return f"{workspace}.Workspace"
-    return workspace
-
-
-def check_workspace_exists(workspace: str) -> bool:
-    """Check if workspace exists."""
-    exit_code, _, _ = run_fab_command(["exists", workspace])
-    return exit_code == 0
-
-
-def check_item_exists(item_path: str) -> bool:
-    """Check if an item exists."""
-    exit_code, _, _ = run_fab_command(["exists", item_path])
-    return exit_code == 0
-
-
-def get_item_id(item_path: str) -> Optional[str]:
-    """Get the ID of an item."""
-    exit_code, stdout, stderr = run_fab_command(["get", item_path, "-q", "id", "-f", "json"])
-    if exit_code == 0:
-        result = parse_json_output(stdout)
-        if result:
-            return result.strip('"') if isinstance(result, str) else result
-    return None
-
-
-def create_eventhouse(workspace: str, name: str) -> Dict[str, Any]:
-    """Create an Eventhouse in the workspace."""
-    item_path = f"{workspace}/{name}.Eventhouse"
-    
-    result = {
-        "name": name,
-        "type": "Eventhouse",
-        "path": item_path,
-        "status": "unknown",
-        "id": None,
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(item_path):
-        result["status"] = "exists"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Eventhouse '{name}' already exists"
-        return result
-    
-    # Create the eventhouse
-    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Eventhouse '{name}' created successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create eventhouse '{name}'"
-    
-    return result
-
-
-def create_kql_database(workspace: str, name: str, eventhouse_id: str) -> Dict[str, Any]:
-    """Create a KQL Database linked to an Eventhouse."""
-    item_path = f"{workspace}/{name}.KQLDatabase"
-    
-    result = {
-        "name": name,
-        "type": "KQLDatabase",
-        "path": item_path,
-        "status": "unknown",
-        "id": None,
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(item_path):
-        result["status"] = "exists"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"KQL Database '{name}' already exists"
-        return result
-    
-    # Create the KQL database with eventhouse linkage
-    exit_code, stdout, stderr = run_fab_command([
-        "create", item_path, "-f",
-        "-P", f"dbtype=ReadWrite",
-        "-P", f"eventhouseId={eventhouse_id}"
-    ])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"KQL Database '{name}' created and linked to Eventhouse"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create KQL Database '{name}'"
-    
-    return result
-
-
-def create_eventstream(workspace: str, name: str) -> Dict[str, Any]:
-    """Create an Eventstream in the workspace."""
-    item_path = f"{workspace}/{name}.Eventstream"
-    
-    result = {
-        "name": name,
-        "type": "Eventstream",
-        "path": item_path,
-        "status": "unknown",
-        "id": None,
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(item_path):
-        result["status"] = "exists"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Eventstream '{name}' already exists"
-        return result
-    
-    # Create the eventstream
-    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Eventstream '{name}' created successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create eventstream '{name}'"
-    
-    return result
-
-
-def create_kql_queryset(workspace: str, name: str) -> Dict[str, Any]:
-    """Create a KQL Queryset in the workspace."""
-    item_path = f"{workspace}/{name}.KQLQueryset"
-    
-    result = {
-        "name": name,
-        "type": "KQLQueryset",
-        "path": item_path,
-        "status": "unknown",
-        "id": None,
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(item_path):
-        result["status"] = "exists"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"KQL Queryset '{name}' already exists"
-        return result
-    
-    # Create the KQL queryset
-    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"KQL Queryset '{name}' created successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create KQL Queryset '{name}'"
-    
-    return result
-
-
-def create_activator(workspace: str, name: str) -> Dict[str, Any]:
-    """Create an Activator (Reflex) in the workspace."""
-    item_path = f"{workspace}/{name}.Reflex"
-    
-    result = {
-        "name": name,
-        "type": "Reflex (Activator)",
-        "path": item_path,
-        "status": "unknown",
-        "id": None,
-        "message": ""
-    }
-    
-    # Check if already exists
-    if check_item_exists(item_path):
-        result["status"] = "exists"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Activator '{name}' already exists"
-        return result
-    
-    # Create the activator (Reflex)
-    exit_code, stdout, stderr = run_fab_command(["create", item_path, "-f"])
-    
-    if exit_code == 0:
-        result["status"] = "created"
-        result["id"] = get_item_id(item_path)
-        result["message"] = f"Activator '{name}' created successfully"
-    else:
-        result["status"] = "failed"
-        result["message"] = stderr.strip() or f"Failed to create Activator '{name}'"
-    
-    return result
-
-
-def setup_streaming_pipeline(
-    workspace: str,
-    name: str,
-    with_alerts: bool = False,
-    dry_run: bool = False
-) -> Dict[str, Any]:
-    """Set up complete streaming pipeline."""
-    
-    workspace = ensure_workspace_suffix(workspace)
-    
-    # Define component names
-    eventhouse_name = f"{name}_Eventhouse"
-    database_name = f"{name}_DB"
-    eventstream_name = f"{name}_Stream"
-    queryset_name = f"{name}_Queries"
-    activator_name = f"{name}_Alerts"
-    
-    report = {
-        "workspace": workspace,
-        "pipeline_name": name,
-        "with_alerts": with_alerts,
-        "dry_run": dry_run,
-        "components": [],
-        "summary": {
-            "total_components": 0,
-            "created": 0,
-            "existed": 0,
-            "failed": 0
-        }
-    }
-    
-    # Calculate total components
-    total = 4  # Eventhouse, KQLDatabase, Eventstream, KQLQueryset
-    if with_alerts:
-        total += 1  # Activator
-    report["summary"]["total_components"] = total
-    
-    if dry_run:
-        print(f"\n[DRY RUN] The following components would be created:\n")
-        print(f"Workspace: {workspace}")
-        print(f"Pipeline Name: {name}")
-        print(f"\nComponents:")
-        print(f"  1. {eventhouse_name}.Eventhouse")
-        print(f"  2. {database_name}.KQLDatabase (linked to Eventhouse)")
-        print(f"  3. {eventstream_name}.Eventstream")
-        print(f"  4. {queryset_name}.KQLQueryset")
-        if with_alerts:
-            print(f"  5. {activator_name}.Reflex (Activator)")
-        return report
-    
-    # Check workspace exists
-    print(f"\nSetting up streaming pipeline '{name}' in: {workspace}")
-    if not check_workspace_exists(workspace):
-        print(f"Error: Workspace '{workspace}' does not exist or is not accessible")
-        sys.exit(1)
-    
-    # Create components in order
-    print("\n1. Creating Eventhouse...")
-    eventhouse_result = create_eventhouse(workspace, eventhouse_name)
-    report["components"].append(eventhouse_result)
-    
-    if eventhouse_result["status"] == "created":
-        report["summary"]["created"] += 1
-        print(f"   ✓ {eventhouse_result['message']}")
-    elif eventhouse_result["status"] == "exists":
-        report["summary"]["existed"] += 1
-        print(f"   • {eventhouse_result['message']}")
-    else:
-        report["summary"]["failed"] += 1
-        print(f"   ✗ {eventhouse_result['message']}")
-        return report  # Can't continue without eventhouse
-    
-    # Create KQL Database (needs eventhouse ID)
-    print("\n2. Creating KQL Database...")
-    eventhouse_id = eventhouse_result.get("id")
-    if not eventhouse_id:
-        print("   ✗ Cannot create KQL Database: Eventhouse ID not available")
-        report["summary"]["failed"] += 1
-        return report
-    
-    database_result = create_kql_database(workspace, database_name, eventhouse_id)
-    report["components"].append(database_result)
-    
-    if database_result["status"] == "created":
-        report["summary"]["created"] += 1
-        print(f"   ✓ {database_result['message']}")
-    elif database_result["status"] == "exists":
-        report["summary"]["existed"] += 1
-        print(f"   • {database_result['message']}")
-    else:
-        report["summary"]["failed"] += 1
-        print(f"   ✗ {database_result['message']}")
-    
-    # Create Eventstream
-    print("\n3. Creating Eventstream...")
-    eventstream_result = create_eventstream(workspace, eventstream_name)
-    report["components"].append(eventstream_result)
-    
-    if eventstream_result["status"] == "created":
-        report["summary"]["created"] += 1
-        print(f"   ✓ {eventstream_result['message']}")
-    elif eventstream_result["status"] == "exists":
-        report["summary"]["existed"] += 1
-        print(f"   • {eventstream_result['message']}")
-    else:
-        report["summary"]["failed"] += 1
-        print(f"   ✗ {eventstream_result['message']}")
-    
-    # Create KQL Queryset
-    print("\n4. Creating KQL Queryset...")
-    queryset_result = create_kql_queryset(workspace, queryset_name)
-    report["components"].append(queryset_result)
-    
-    if queryset_result["status"] == "created":
-        report["summary"]["created"] += 1
-        print(f"   ✓ {queryset_result['message']}")
-    elif queryset_result["status"] == "exists":
-        report["summary"]["existed"] += 1
-        print(f"   • {queryset_result['message']}")
-    else:
-        report["summary"]["failed"] += 1
-        print(f"   ✗ {queryset_result['message']}")
-    
-    # Create Activator if requested
-    if with_alerts:
-        print("\n5. Creating Activator...")
-        activator_result = create_activator(workspace, activator_name)
-        report["components"].append(activator_result)
-        
-        if activator_result["status"] == "created":
-            report["summary"]["created"] += 1
-            print(f"   ✓ {activator_result['message']}")
-        elif activator_result["status"] == "exists":
-            report["summary"]["existed"] += 1
-            print(f"   • {activator_result['message']}")
-        else:
-            report["summary"]["failed"] += 1
-            print(f"   ✗ {activator_result['message']}")
-    
-    return report
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Create complete streaming pipeline (Eventhouse, KQL Database, Eventstream, etc.)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    python setup_streaming.py RealTime.Workspace --name IoTTelemetry
-    python setup_streaming.py RealTime.Workspace --name SensorData --with-alerts
-    python setup_streaming.py "My Workspace" --name Analytics --dry-run
-
-Created Components:
-    1. Eventhouse - Storage for real-time data
-    2. KQL Database - Query engine linked to Eventhouse
-    3. Eventstream - Data ingestion pipeline
-    4. KQL Queryset - Saved queries for analysis
-    5. Activator (optional) - Alert rules and triggers
-
-Next Steps After Creation:
-    1. Configure Eventstream sources (Event Hub, Kafka, etc.)
-    2. Add Eventstream destinations (KQL Database)
-    3. Create tables in KQL Database
-    4. Add queries to KQL Queryset
-    5. Configure alert rules in Activator
-        """
-    )
-    parser.add_argument(
-        "workspace",
-        help="Workspace name or path where streaming pipeline will be created"
-    )
-    parser.add_argument(
-        "--name", "-n",
-        required=True,
-        help="Base name for the streaming pipeline components"
-    )
-    parser.add_argument(
-        "--with-alerts",
-        action="store_true",
-        help="Also create an Activator for alert rules"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview what would be created without making changes"
-    )
-    parser.add_argument(
-        "--json", "-j",
-        action="store_true",
-        help="Output results in JSON format"
-    )
-    
-    args = parser.parse_args()
-    
-    try:
-        report = setup_streaming_pipeline(
-            workspace=args.workspace,
-            name=args.name,
-            with_alerts=args.with_alerts,
-            dry_run=args.dry_run
-        )
-        
-        if args.dry_run:
-            sys.exit(0)
-        
-        # Print summary
-        print("\n" + "=" * 50)
-        print("STREAMING PIPELINE SETUP COMPLETE")
-        print("=" * 50)
-        print(f"Workspace: {report['workspace']}")
-        print(f"Pipeline Name: {report['pipeline_name']}")
-        print(f"\nSummary:")
-        print(f"  Total Components: {report['summary']['total_components']}")
-        print(f"  Created: {report['summary']['created']}")
-        print(f"  Already Existed: {report['summary']['existed']}")
-        print(f"  Failed: {report['summary']['failed']}")
-        
-        print("\nComponents:")
-        for comp in report["components"]:
-            status_icon = "✓" if comp["status"] in ["created", "exists"] else "✗"
-            print(f"  {status_icon} {comp['path']}")
-        
-        print("=" * 50)
-        
-        if args.json:
-            print("\n" + json.dumps(report, indent=2))
-        
-        sys.exit(0 if report['summary']['failed'] == 0 else 1)
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/AGENTS.md b/AGENTS.md
index 0995528c2..2baad5bb3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,66 +24,15 @@ All AI-related resources (skills, context, prompts, modes) are organized in the
 
 ### Key Resources
 
-| Resource | Location |
-|----------|----------|
-| AI Assets Overview | `.ai-assets/README.md` |
-| Skills (Usage) | `.ai-assets/skills/` |
-| Prompts (Templates) | `.ai-assets/prompts/` |
-| Modes (Agents) | `.ai-assets/modes/` |
-| Context (Contributor) | `.ai-assets/context/` |
-
-### External Documentation
-
 | Resource | URL |
 |----------|-----|
+| AI Assets | `.ai-assets/README.md` |
 | Documentation | https://microsoft.github.io/fabric-cli/ |
 | Command Reference | https://microsoft.github.io/fabric-cli/commands/ |
 | Usage Examples | https://microsoft.github.io/fabric-cli/examples/ |
 
 ---
 
-## For AI Agents Helping Users (Operating Fabric CLI)
-
-When assisting users who want to **use the CLI** (not develop it), load skills from `.ai-assets/skills/`:
-
-### Available Skills
-
-| Skill | When to Load |
-|-------|--------------|
-| `fabric-cli-core` | **Always load first** — paths, auth, safety, item types |
-| `fabric-cli-cicd` | Deploying, CI/CD pipelines, automation |
-| `fabric-cli-powerbi` | Semantic models, reports, DAX, refresh |
-| `fabric-cli-governance` | Permissions, ACLs, domains, capacity |
-| `fabric-cli-dataengineering` | Lakehouses, tables, shortcuts, Spark |
-| `fabric-cli-realtime` | Eventhouses, KQL, eventstreams |
-
-### Quick Start Commands
-
-```bash
-# Check authentication
-fab auth status
-
-# List workspaces
-fab ls
-
-# List items in workspace
-fab ls "MyWorkspace.Workspace"
-
-# Get help for any command
-fab --help
-fab ls --help
-```
-
-### Critical Operational Rules
-
-1. **First run** — Always verify auth with `fab auth status`
-2. **Learn before executing** — Use `fab <command> --help` to understand syntax
-3. **Verify before acting** — Use `fab exists` or `fab ls` to confirm paths
-4. **Non-interactive mode** — Use `-f` flag for automation
-5. **Safety first** — Confirm before destructive operations
-
----
-
 ## For AI Agents Helping Contributors (Developing the CLI)
 
 When assisting with **code contributions** to this repository (adding features, fixing bugs, writing tests), refer to the contributor context in `.ai-assets/context/`.

From d2c3064216ceb9eae864de200cf74ff7dbe60bb5 Mon Sep 17 00:00:00 2001
From: Jeremy Hoover <jeremyhoover@microsoft.com>
Date: Mon, 23 Feb 2026 12:21:11 +0200
Subject: [PATCH 3/3] Add changie entry for AI assets documentation

---
 .changes/unreleased/docs-20260223-100000.yaml | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 .changes/unreleased/docs-20260223-100000.yaml

diff --git a/.changes/unreleased/docs-20260223-100000.yaml b/.changes/unreleased/docs-20260223-100000.yaml
new file mode 100644
index 000000000..7104a9117
--- /dev/null
+++ b/.changes/unreleased/docs-20260223-100000.yaml
@@ -0,0 +1,6 @@
+kind: docs
+body: Add AI assets for agent-assisted CLI usage including core and Power BI skills, workspace creation prompt, and context files for GitHub Copilot, Claude, and Cursor
+time: 2026-02-23T10:00:00.000000000Z
+custom:
+    Author: jeremyhoover
+    AuthorLink: https://github.com/jeremyhoover