diff --git a/.ai-assets/README.md b/.ai-assets/README.md
new file mode 100644
index 00000000..4698291d
--- /dev/null
+++ b/.ai-assets/README.md
@@ -0,0 +1,56 @@
+# 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-powerbi` | `skills/fabric-cli-powerbi/SKILL.md` | Power BI operations, semantic models, reports, refresh, DAX |
+
+### Skill Scripts
+
+Each skill includes automation scripts for common tasks:
+
+| Skill | Scripts |
+|-------|---------|
+| `fabric-cli-core` | `health_check.py` |
+| `fabric-cli-powerbi` | `refresh_model.py`, `list_refresh_history.py`, `rebind_report.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 |
+|--------|-------------|
+| `create-workspace` | Create a new Microsoft Fabric workspace with configuration |
+
+## 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 00000000..7d68b2c3
--- /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 00000000..0fcf1d58
--- /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 00000000..914cef85
--- /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 00000000..94f3a636
--- /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 00000000..99da26a2
--- /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 00000000..cac85a90
--- /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 00000000..cbf82501
--- /dev/null
+++ b/.ai-assets/prompts/README.md
@@ -0,0 +1,29 @@
+# Fabric CLI Prompts
+
+Reusable prompt templates for common Fabric CLI tasks. Use these with any AI coding assistant.
+
+## Available Prompts
+
+| Prompt | Description |
+|--------|-------------|
+| [create-workspace](create-workspace.prompt.md) | Create a new Microsoft Fabric workspace with configuration |
+
+## 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/create-workspace.prompt.md b/.ai-assets/prompts/create-workspace.prompt.md
new file mode 100644
index 00000000..dcf3e9c2
--- /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/skills/README.md b/.ai-assets/skills/README.md
new file mode 100644
index 00000000..5363f4de
--- /dev/null
+++ b/.ai-assets/skills/README.md
@@ -0,0 +1,29 @@
+# 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-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-powerbi`** when working with semantic models, reports, DAX queries, or gateways
+
+## 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-core/README.md b/.ai-assets/skills/fabric-cli-core/README.md
new file mode 100644
index 00000000..0319fbe7
--- /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 00000000..d29b89a3
--- /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 00000000..16d04aa8
--- /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-powerbi/README.md b/.ai-assets/skills/fabric-cli-powerbi/README.md
new file mode 100644
index 00000000..40b9ad82
--- /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 00000000..71d0037c
--- /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 00000000..427fa91c
--- /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 00000000..41b5f8a4
--- /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 00000000..678de12c
--- /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 00000000..bfa061c4
--- /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 00000000..d2965612
--- /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 00000000..1d2397c3
--- /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 00000000..f27d502a
--- /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 00000000..85bd45f2
--- /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/.changes/unreleased/docs-20260223-100000.yaml b/.changes/unreleased/docs-20260223-100000.yaml
new file mode 100644
index 00000000..7104a911
--- /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
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
deleted file mode 100644
index 8d370edd..00000000
--- 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 00000000..2baad5bb
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,126 @@
+# 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 | 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 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 4b01362c..00000000
--- 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)