@fluentcommerce/ai-skills 0.1.0 → 0.3.0

package/README.md

@@ -1,622 +1,866 @@
-# @fluentcommerce/ai-skills
-
-[![npm version](https://img.shields.io/npm/v/@fluentcommerce/ai-skills.svg)](https://www.npmjs.com/package/@fluentcommerce/ai-skills)
-[![license](https://img.shields.io/npm/l/@fluentcommerce/ai-skills.svg)](https://opensource.org/licenses/MIT)
-[![node](https://img.shields.io/node/v/@fluentcommerce/ai-skills.svg)](https://nodejs.org/)
-
-> **Alpha** — This package is under active development. Skill content, CLI options, and supported targets may change between releases without notice. Use in non-production environments and pin to a specific version if stability matters.
-
-Modular [Fluent Commerce](https://fluentcommerce.com) AI skill packs for coding assistants.
-Install all groups, or only what each project needs.
-
-**What this does:** AI coding assistants (Claude Code, Cursor, Copilot, etc.) are general-purpose — they don't know Fluent Commerce. This package injects Fluent-specific domain knowledge (workflows, events, rules, GraphQL patterns, CLI commands, deployment procedures) into your assistant so it can analyze workflows, scaffold rules, run E2E tests, debug failed events, and manage settings — all through natural language.
-
-**New here?** See [What Can You Do With Fluent AI Skills?](docs/USE_CASES.md) for scenario-based examples — from debugging stuck orders to building new workflows to go-live readiness checks.
-
-**What is a "skill"?** A skill is a structured instruction file that teaches the AI how to perform a specific Fluent task. For example, `/fluent-workflow-analyzer` teaches the AI how to read workflow JSON, map status graphs, detect orphaned rulesets, and generate Mermaid diagrams. Skills are installed into your assistant's native format (Claude agents/skills, Cursor rules, Copilot instructions, etc.).
-
-## What Can You Do?
-
-| Persona | Example prompt | What happens |
-|---------|---------------|-------------|
-| New developer | "Explain how Home Delivery works" | Feature Architecture Document with diagrams, rules, settings |
-| Debugging | "Why is order HD-001 stuck?" | Event forensics, NO_MATCH analysis, remediation options |
-| Building | "Build an ORDER::RETURN workflow" | Plan mode → state machine → rulesets → deploy → E2E test |
-| Pre-go-live | "Run a Ready For Launch assessment" | Scored report across workflows, rules, settings, integrations |
-| Ops | "Show event failure rates for the last hour" | Metrics anomaly detection with threshold alerts |
-
-See [full scenario guide](docs/USE_CASES.md) for 11 detailed walkthroughs.
-
-## Quick Start
-
-```bash
-# Install all skill groups (default target: Claude Code)
-npx @fluentcommerce/ai-skills install
-
-# Configure MCP server entries for your project
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
-
-# Verify what's installed
-npx @fluentcommerce/ai-skills status
-```
-
-### Quick Start by Target
-
-Run from your project root:
-
-Primary target is **Claude**. The adapters below are **beta**.
-
-```bash
-# Cursor
-npx @fluentcommerce/ai-skills install --target cursor
-npx @fluentcommerce/ai-skills status --target cursor
-
-# VS Code (Copilot instructions format)
-npx @fluentcommerce/ai-skills install --target vscode
-npx @fluentcommerce/ai-skills status --target vscode
-
-# GitHub Copilot
-npx @fluentcommerce/ai-skills install --target copilot
-npx @fluentcommerce/ai-skills status --target copilot
-
-# Windsurf
-npx @fluentcommerce/ai-skills install --target windsurf
-npx @fluentcommerce/ai-skills status --target windsurf
-
-# Codex
-npx @fluentcommerce/ai-skills install --target codex
-npx @fluentcommerce/ai-skills status --target codex
-
-# Gemini CLI
-npx @fluentcommerce/ai-skills install --target gemini
-npx @fluentcommerce/ai-skills status --target gemini
-```
-
-Tip: to keep instruction size lighter, install only needed groups (for example `npx @fluentcommerce/ai-skills install --target cursor cli mcp-extn`).
-
-## Requirements
-
-- Node.js 18+
-- Fluent CLI (`npm i -g @fluentcommerce/cli`) — needed for official MCP server
-
-## Supported Targets
-
-Skills install into your coding assistant's native format:
-
-| Target | Output location | Scope | Status |
-|---|---|---|---|
-| `claude` (default) | `~/.claude/agents/` + `~/.claude/skills/` | Global (shared across projects) | **Primary** |
-| `cursor` | `.cursor/rules/*.mdc` | Project | Beta |
-| `copilot` | `.github/copilot-instructions.md` | Project | Beta |
-| `vscode` | `.github/copilot-instructions.md` (alias of `copilot`) | Project | Beta |
-| `windsurf` | `.windsurfrules` | Project | Beta |
-| `codex` | `AGENTS.md` | Project | Beta |
-| `gemini` | `GEMINI.md` | Project | Beta |
-
-> Claude Code is the primary target with full support (agents, skills, slash commands, MCP integration). Other targets receive the same domain knowledge as merged instruction content and are tested where possible, but may have limited functionality compared to Claude Code.
-
-```bash
-# Install for a specific target
-npx @fluentcommerce/ai-skills install --target cursor
-
-# Install specific groups only
-npx @fluentcommerce/ai-skills install --target copilot cli mcp-extn
-```
-
-For non-Claude targets, the installer writes a managed block (`<!-- fluent-ai-skills:start --> ... <!-- fluent-ai-skills:end -->`). Uninstall removes only managed content and preserves anything else in the file.
-
-## Available Groups
-
-| Group | What it provides | Claude Code slash commands |
-|---|---|---|
-| `cli` | Fluent CLI command-family coverage (index routing, reference, account connect, profile, retailer, settings, modules, workflows, MCP/CI-CD, bootstrap) | `/fluent-cli-index` `/fluent-cli-reference` `/fluent-connect` `/fluent-cli-mcp-cicd` `/fluent-bootstrap` `/fluent-cli-retailer` `/fluent-cli-settings` `/fluent-module-deploy` `/fluent-profile` `/fluent-workflow` |
-| `mcp-official` | Official Fluent CLI MCP server operations | `/fluent-mcp-core` |
-| `mcp-extn` | Extension MCP tools (events, transitions, GraphQL, metrics, batch) | `/fluent-mcp-tools` |
-| `rfl` | Ready For Launch assessments | `/fluent-rfl-assess` |
-| `dev` | Feature planning (with universal NEW/EXISTING/MODIFIED/REUSED/OOTB classification), workflow builder, workflow deploy, analyzer, connection analysis (with `--validate` static-vs-dynamic comparison and cross-entity event tracing), custom code analysis, transition API, rule scaffold, module scaffold, data module scaffold, source onboarding, module validation, build, version management, trace, event API (model + causality analysis), system monitoring, batch ingestion, E2E, test data, settings (with Phase 2B value format validation and cascading scope resolution), environment setup, pre-deploy checks, session summary, session audit export, scope decomposition, feature explanation, Mermaid diagram validation | `/fluent-feature-plan` `/fluent-workflow-builder` `/fluent-workflow-deploy` `/fluent-workflow-analyzer` `/fluent-connection-analysis` `/fluent-custom-code` `/fluent-transition-api` `/fluent-rule-scaffold` `/fluent-module-scaffold` `/fluent-data-module-scaffold` `/fluent-source-onboard` `/fluent-module-validate` `/fluent-build` `/fluent-version-manage` `/fluent-trace` `/fluent-event-api` `/fluent-system-monitoring` `/fluent-job-batch` `/fluent-e2e-test` `/fluent-test-data` `/fluent-settings` `/fluent-retailer-config` `/fluent-session-summary` `/fluent-scope-decompose` `/fluent-pre-deploy-check` `/fluent-session-audit-export` `/fluent-feature-explain` |
-
-> Slash commands are Claude Code specific. Other targets receive the same knowledge as merged instruction content.
-
-For detailed command-family and guide-section coverage status (`full/partial/missing`), see [docs/CLI_COVERAGE.md](docs/CLI_COVERAGE.md).
-
-### Group Aliases
-
-| Alias | Resolves to |
-|---|---|
-| `mcp` | `mcp-extn` |
-| `extn` | `mcp-extn` |
-| `extension` | `mcp-extn` |
-| `mcp-core` | `mcp-official` |
-| `official` | `mcp-official` |
-
-## Autonomous Development Workflow
-
-The `dev` skill group enables AI agents to run a full closed-loop development lifecycle with a mandatory planning gate:
-
-```
-ANALYZE → EXPLAIN (if requested) or PLAN → [USER APPROVAL] → IMPLEMENT → BUILD → DEPLOY → TEST → DIAGNOSE → FIX → (loop back)
-```
-
-After analysis, the agent presents a structured implementation plan (workflow changes, settings, rules, Mermaid diagrams, risk assessment, test plan) and waits for explicit user approval before making changes. The agent then continues iterating until all E2E tests pass or an unresolvable blocker is hit.
-
-Event API source docs are curated into skills via selective extraction; they are not mirrored wholesale.
-
-| Phase | Skill / Command | What the agent does |
-|-------|----------------|---------------------|
-| Analyze | `/fluent-workflow-analyzer`, `/fluent-connection-analysis` | Map status graphs, trace event chains, detect orphans, verify connectivity; `--validate` mode compares static workflow paths with runtime events, traces cross-entity propagation, and produces timing analysis |
-| Custom code analysis | `/fluent-custom-code` | Scan custom source, generate reusable analysis artifacts (source-map, workflow-rule-map, constraints, behavior-map, extension-plan) |
-| Discover | `/fluent-transition-api` | Query available user actions at each status, map required attributes |
-| Scope decomposition | `/fluent-scope-decompose` | Parse scope documents into ordered task lists with dependency DAG, skill mappings, and ambiguity detection |
-| Feature plan | `/fluent-feature-plan` | Produce comprehensive implementation plan with universal source classification (NEW/EXISTING/MODIFIED/REUSED/OOTB) across all artifacts — rules, workflows, settings, webhooks, cross-entity flows, deployment sequence |
-| Plan & Approve | *(check gate)* | Present structured implementation plan (workflows, settings, rules, Mermaid diagrams, risks, test plan). **Wait for user approval.** |
-| Implement | `/fluent-workflow-builder`, `/fluent-rule-scaffold` | Edit workflow JSON, scaffold Java rules, update settings |
-| Scaffold module | `/fluent-module-scaffold` | Generate complete Maven module skeleton (POMs, module.json, rule classes, build scripts) |
-| Onboard source | `/fluent-source-onboard` | Restructure existing Java source (loose files, decompiled JARs, non-standard layouts) into proper Fluent module format; validate and build |
-| Validate | `/fluent-module-validate` | Check module structure, version consistency, rule wiring, test coverage; cached report with content hash |
-| Version | `/fluent-version-manage` | Read, bump, sync, and tag versions across POM files, module.json, and CHANGELOG |
-| Build | `/fluent-build` | Version bump, Maven compile, ZIP packaging |
-| Pre-deploy | `/fluent-pre-deploy-check` | 26 quality gates across 8 phases (env, module, workflow, connections, settings, target, risk, completeness) |
-| Deploy module | `/fluent-module-deploy` or `flow-run` | Module install via CLI |
-| Deploy workflow | `/fluent-workflow-deploy` | Workflow upload via MCP tool, REST API fallback, CLI last resort |
-| Test | `/fluent-e2e-test` | Create entities, fire events, poll states, assert transitions |
-| Test data | `/fluent-test-data` | Discover retailer environment and generate valid test entity payloads |
-| Settings | `/fluent-settings` | Manage retailer settings — discover, audit (with Phase 2B value format validation), create/update, migrate; cascading scope resolution (RETAILER -> ACCOUNT) for module-installed settings |
-| Environment | `/fluent-retailer-config` | Configure retailer environments — locations, networks, catalogues, inventory, carriers |
-| Diagnose | `/fluent-trace`, `/fluent-event-api` | Trace failed events, correlate with rulesets, and build causality chains across parent/child events |
-| Fix | (routes back to Implement/Build/Deploy) | Apply fix based on diagnosis, re-test |
-| Explain | `/fluent-feature-explain` | Reverse-engineer existing feature into a Feature Architecture Document with Mermaid diagrams, data flow, and runtime evidence; tiered analysis (plugin.list → decompiled JAR / source code → runtime), auto-discovers entities, JAR decompilation fallback, Analysis Confidence section; saved to `accounts/<PROFILE>/analysis/features/` |
-| Audit | `/fluent-session-summary`, `/fluent-session-audit-export` | Track all changes made during session; export machine-readable JSON audit trail |
-
-Artifacts from custom code analysis are written to `accounts/<PROFILE>/analysis/custom-code/` and reused by other skills (workflow-analyzer, trace, rule-scaffold, etc.). A `fingerprint.json` file is used to detect input changes and skip re-parsing when nothing changed. Module validation reports are written to `accounts/<PROFILE>/analysis/module-validate/` with a content hash — re-validation is skipped when the module source is unchanged.
-
-Account workspace convention — see [Workspace Setup](#workspace-setup) for the full guide.
-
-### Settings Update Quick Recipe
-
-For safe setting updates, use this exact flow with `/fluent-settings`:
-
-1. Resolve by `name` + `context/contextId` to fetch `id`, `valueType`, and current value.
-2. Update by `id` (never guessed) using:
-   - `value` for `STRING`/`BOOLEAN`
-   - `lobValue` for `LOB`/`JSON`
-3. Re-query the same `name` + scope and confirm the value changed.
-4. If no setting exists, create it with the same scope (upsert behavior).
-
-See [docs/DEV_WORKFLOW.md](docs/DEV_WORKFLOW.md) for the complete orchestration protocol with decision trees, tool chains, and error recovery patterns.
-
-### Deep Analysis Fallback (Vague Ruleset/Rule Intent)
-
-When workflow/ruleset descriptions are too generic to explain behavior confidently, the skills escalate evidence in this order:
-
-1. Ask focused clarification questions (trigger, expected state, actual outcome).
-2. Request source (`module.json` + Java rule classes).
-3. If source is unavailable, first check for JAR/ZIP already present under `accounts/<PROFILE>/SOURCE/`, then decompile targeted rule classes.
-4. Correlate decompiled logic with workflow props and runtime event/log evidence.
-
-This keeps end-to-end analysis grounded in executable rule logic rather than names/descriptions only.
-
-## Workspace Setup
-
-Skills expect implementation source code, workflows, and analysis artifacts to be organized under an `accounts/` directory in your workspace root, keyed by Fluent CLI profile name.
-
-### Directory Structure
-
-```
-accounts/
-  <PROFILE>/                           # matches your FLUENT_PROFILE name
-    SOURCE/                            # account-level, shared across retailers
-      <repo-name>/                     # git-cloned custom plugin repo
-        resources/module.json
-        pom.xml
-        src/main/java/...
-      <reference-module>/              # reference module package (module.json + JAR)
-        module.json
-        assets/rules/*.jar
-      .decompiled/<jar-basename>/      # auto-generated from JAR decompilation
-        DECOMPILED.md                  # marker with source JAR, date, decompiler
-        com/fluentcommerce/...         # decompiled Java classes
-    workflows/                         # retailer-scoped workflow definitions
-      <RETAILER_REF>/
-        ORDER__HD.json
-        FULFILMENT__HD_WH.json
-        workflow-context.json          # download metadata
-    analysis/                          # generated analysis artifacts
-      custom-code/source-map.json
-      module-validate/*.report.json
-    plans/                             # persisted implementation plans (audit trail)
-      2026-02-23-rule-scaffold-curbside-pickup.md
-      2026-02-23-workflow-builder-order-hd-returns.md
-    workspace-state.json               # cached state for idempotent re-runs
-  workspace-index.json                 # cross-profile index
-```
-
-**Why this layout:**
-- `SOURCE/` is at the profile (account) level because plugin code is deployed per-account and shared across retailers.
-- `workflows/` are scoped by retailer ref inside subdirectories because workflow definitions can differ per retailer.
-- `analysis/` holds generated artifacts that other skills reuse (source maps, module validation reports, etc.).
-- `plans/` stores implementation plans created by the Planning Gate. Each plan is a markdown file with status tracking (`PENDING` → `APPROVED`/`REJECTED`), Mermaid diagrams, file lists, environment impact, tasks, risks, and test plans. Plans persist across sessions for audit trail and re-use.
-
-### Guided Onboarding (`/fluent-connect`)
-
-The fastest way to set up a workspace is the guided connect wizard. In Claude Code:
-
-```
-/fluent-connect
-```
-
-Or with explicit arguments to skip interactive selection:
-
-```
-/fluent-connect --profile MYPROFILE --retailer MY_RETAILER
-```
-
-The wizard runs through 5 phases:
-
-1. **Profile Discovery** — scans `~/.fluentcommerce/` for CLI profiles, presents a table with account name and environment tier
-2. **Retailer Selection** — reads retailer files for the selected profile, asks which retailer to target
-3. **MCP Wiring** — runs `mcp-setup`, verifies `.mcp.json`, prompts IDE reload, validates connectivity
-4. **Workspace Readiness** — creates directories, downloads workflows, scans source repos, decompiles JARs if needed, builds a deployed rule inventory by cross-referencing `plugin.list` with local source
-5. **Persist & Report** — writes `workspace-state.json` (with content hash for caching), updates `workspace-index.json`, prints a readiness report with next-step suggestions
-
-Re-running `/fluent-connect` is safe and instant if nothing changed (content hash match). Use `--force` to re-run full discovery.
-
-### Adding Source Code
-
-Clone your custom plugin repositories into `accounts/<PROFILE>/SOURCE/`:
-
-```bash
-cd accounts/MYPROFILE/SOURCE
-git clone https://bitbucket.org/yourorg/fc-module-extensions.git
-git clone https://bitbucket.org/yourorg/fc-module-returns.git
-```
-
-Each repo should contain at minimum:
-- `resources/module.json` — module metadata and rule registrations
-- `pom.xml` — Maven build configuration
-- `src/main/java/` — Java rule classes
-
-Skills automatically detect repos by searching recursively for `module.json`, `pom.xml`, or `src/main/java/`. Nested directory structures (including double-nested git clone artifacts like `repo/repo/`) are handled.
-
-### Adding JAR Files
-
-When original source code is not available, place compiled module JARs directly in `SOURCE/`:
-
-```bash
-cp fc-module-extensions-1.2.3.jar accounts/MYPROFILE/SOURCE/
-```
-
-Skills will:
-1. Auto-detect JAR files during workspace setup
-2. Decompile them (using CFR or Fernflower if available) into `SOURCE/.decompiled/<jar-basename>/`
-3. Extract `module.json` from the JAR if present
-4. Create a `DECOMPILED.md` marker noting the source JAR, date, and confidence level
-
-**Decompiled source is read-only.** Skills can analyze it for rule discovery, behavior explanation, and workflow-rule mapping, but will never suggest editing decompiled files. To modify code, provide original source or scaffold a new module.
-
-### Reference Modules
-
-Reference (OOTB) modules that ship as a `module.json` + JAR package can also be placed in `SOURCE/`:
-
-```bash
-cp -r fluent-module-order/ accounts/MYPROFILE/SOURCE/
-# Contains: module.json + assets/rules/*.jar
-```
-
-Skills read rule names, descriptions, and version directly from `module.json` — no decompilation needed for metadata. Decompilation is only triggered if deep analysis of rule implementation logic is requested.
-
-### Adding a New Account
-
-```bash
-# Create the directory structure
-mkdir -p accounts/NEW_PROFILE/SOURCE
-mkdir -p accounts/NEW_PROFILE/workflows
-mkdir -p accounts/NEW_PROFILE/analysis
-
-# Clone plugin repos
-cd accounts/NEW_PROFILE/SOURCE
-git clone <repo-url>
-
-# Download workflows (after setting up profile)
-fluent workflow download -p NEW_PROFILE -r RETAILER_REF -w all \
-  -o accounts/NEW_PROFILE/workflows/RETAILER_REF/
-```
-
-Or let `/fluent-connect` do all of this interactively.
-
-### How Analysis Works
-
-Once the workspace is populated, skills build a holistic view of what's deployed:
-
-1. **Live environment** — `plugin.list` queries all registered orchestration rules
-2. **Local source** — repos with full Java source (modifiable, buildable)
-3. **Local JARs** — decompiled bytecode (analyzable, read-only)
-4. **Workflow definitions** — downloaded JSON files
-
-Cross-referencing these produces a **deployed rule inventory**:
-
-| Status | Meaning | What you can do |
-|--------|---------|-----------------|
-| Full source | Rule class found in a git repo | Analyze, modify, build, redeploy |
-| Decompiled | Rule class found in decompiled JAR | Analyze behavior, cannot modify |
-| Missing | Deployed rule with no local source or JAR | Blind spot — provide source or JAR |
-
-This inventory is persisted in `workspace-state.json` and powers downstream skills like `/fluent-custom-code`, `/fluent-workflow-analyzer`, and `/fluent-rfl-assess`.
-
-### .gitignore
-
-The `accounts/` directory should be in `.gitignore` — it may contain credentials (via profile references), downloaded workflows, and customer-specific source code:
-
-```gitignore
-accounts/
-```
-
-## Setup Guide
-
-### Option A — Fastest (no source clone)
-
-```bash
-npx @fluentcommerce/ai-skills install
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
-
-# Multi-retailer profile (retailer ref for extension server)
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
-```
-
-When `--profile` is provided, both MCP servers are wired with `FLUENT_PROFILE` automatically.
-You can run immediately with profile auth, or override with explicit OAuth/token env vars.
-
-For explicit env auth in `.mcp.json`, fill:
-
-- `FLUENT_BASE_URL` — your tenant API URL
-- `FLUENT_RETAILER_ID` — target retailer ID
-- `FLUENT_CLIENT_ID` / `FLUENT_CLIENT_SECRET` — OAuth credentials
-- `FLUENT_USERNAME` / `FLUENT_PASSWORD` — user credentials (if using password grant)
-- `FLUENT_PROFILE_RETAILER` — optional retailer ref for profile-scoped user overrides
-
-Restart your IDE after editing `.mcp.json`.
-
-### Option B — Extension source clone + local build
-
-```bash
-npx @fluentcommerce/ai-skills mcp-setup --install-extn-source --profile YOUR_PROFILE
-```
-
-This clones the `fluent-mcp-extn` source into your project, builds it, and wires `.mcp.json` to the local build. Use this if you want to debug or customize the extension server.
-
-### Option C — Install from tarball
-
-```bash
-# Create tarball
-cd fluent-ai-skills && npm pack
-
-# Install from tarball on any machine
-npx ./fluentcommerce-ai-skills-0.0.1.tgz install
-```
-
-## End-to-End Validation (Recommended)
-
-Validate the full setup path (skills bootstrap -> MCP config -> extension runtime smoke):
-
-```bash
-# 1) Install skills + generate MCP config
-npx @fluentcommerce/ai-skills install
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
-
-# 2) Verify generated env in .mcp.json (extension server)
-#    FLUENT_PROFILE=YOUR_PROFILE
-#    FLUENT_PROFILE_RETAILER=YOUR_RETAILER_REF
-
-# 3) Run extension end-to-end smoke
-cd fluent-mcp-extn
-npm install
-npm run build
-npm test
-npm run e2e:smoke -- --wizard
-npm run e2e:smoke -- --profile YOUR_PROFILE
-npm run e2e:smoke -- --profile YOUR_PROFILE --retailer YOUR_RETAILER_REF_OR_ID
-
-# 4) Optional: run one smoke cycle per profile retailer
-npm run e2e:smoke -- --profile YOUR_PROFILE --all-retailers
-```
-
-This verifies both MCP servers are configured and that `fluent-mcp-extn` can execute real API smoke checks in profile mode.
-
-Notes:
-- `--wizard` is for interactive local runs (guided profile/account + retailer selection).
-- `--retailer` accepts retailer ID or retailer ref.
-- CI/non-interactive runs should use explicit flags (`--profile <name> --retailer <id|ref>` or `--profile <name> --all-retailers`).
-- `flow-run` is diagnostics + optional guarded deploy; use `fluent-mcp-extn` smoke for runtime E2E checks.
-
-## CLI Reference
-
-```
-npx @fluentcommerce/ai-skills <command> [--target <target>] [groups...]
-```
-
-| Command | Description |
-|---|---|
-| `install [groups...]` | Install all groups (default) or selected groups |
-| `uninstall [groups...]` | Uninstall all groups or selected groups |
-| `status [groups...]` | Show install status |
-| `list` | List available groups |
-| `mcp-setup [options]` | Generate `.mcp.json` for official + extension MCP servers |
-| `flow-run [options]` | Run diagnostics and optional guarded module deploy |
-| `--version` | Show package version |
-| `--help` | Show help |
-
-### `mcp-setup` Options
-
-```bash
-# Basic — generates .mcp.json with both servers
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
-
-# Profile + retailer ref (for fluent-mcp-extn profile-scoped user overrides)
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
-
-# Clone and build extension source locally
-npx @fluentcommerce/ai-skills mcp-setup --install-extn-source --profile YOUR_PROFILE
-
-# Custom source location and repo
-npx @fluentcommerce/ai-skills mcp-setup \
-  --install-extn-source \
-  --extn-dir tools/fluent-mcp-extn \
-  --extn-repo https://bitbucket.org/fluentcommerce/fluent-mcp-extn.git
-
-# Custom server names
-npx @fluentcommerce/ai-skills mcp-setup \
-  --official-server-name fluent-mcp \
-  --extn-server-name fluent-mcp-extn
-```
-
-`--profile-retailer` expects a retailer **ref** (for example `RETAILER_REF`), not retailer ID.
-
-### `flow-run` Options
-
-`flow-run` runs pre-deploy diagnostics and optionally deploys a module:
-
-```bash
-# Diagnostics only (no deploy)
-npx @fluentcommerce/ai-skills flow-run \
-  --profile YOUR_PROFILE \
-  --retailer YOUR_RETAILER \
-  --module dist/module.zip \
-  --config config/module.config.json
-
-# Diagnostics + guarded deploy
-npx @fluentcommerce/ai-skills flow-run \
-  --profile YOUR_PROFILE \
-  --retailer YOUR_RETAILER \
-  --module dist/module.zip \
-  --config config/module.config.json \
-  --deploy --yes --exclude-workflows
-```
-
-Steps executed: config checks, CLI preflight, module/workflow listing, optional deploy, JSON report.
-
-Report output: `./.fluent-ai-skills/flow-run-report-<timestamp>.json`
-
-## Usage Examples
-
-### Claude Code — full install + MCP
-
-```bash
-npx @fluentcommerce/ai-skills install
-npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
-npx @fluentcommerce/ai-skills status
-```
-
-### Cursor — operations focused
-
-```bash
-cd your-project
-npx @fluentcommerce/ai-skills install --target cursor cli mcp-extn
-npx @fluentcommerce/ai-skills status --target cursor
-```
-
-### GitHub Copilot — shared repo instructions
-
-```bash
-cd your-project
-npx @fluentcommerce/ai-skills install --target copilot cli rfl
-```
-
-### Uninstall
-
-```bash
-# Uninstall all groups from default target
-npx @fluentcommerce/ai-skills uninstall
-
-# Uninstall specific groups from specific target
-npx @fluentcommerce/ai-skills uninstall --target windsurf cli
-```
-
-## Size Guidance
-
-Single-file targets (`copilot`, `vscode`, `windsurf`, `codex`, `gemini`) concatenate all content into one file. If prompt size becomes a concern, install only the groups you need:
-
-```bash
-npx @fluentcommerce/ai-skills install --target codex cli mcp-extn
-```
-
-## Advanced
-
-### Override install location
-
-For Claude target, override the default `~/.claude/` location:
-
-```bash
-FLUENT_AI_SKILLS_HOME=/custom/path npx @fluentcommerce/ai-skills install
-```
-
-```powershell
-# PowerShell
-$env:FLUENT_AI_SKILLS_HOME = "C:\custom\path"; npx @fluentcommerce/ai-skills install
-```
-
-```cmd
-# Windows CMD
-set FLUENT_AI_SKILLS_HOME=C:\custom\path && npx @fluentcommerce/ai-skills install
-```
-
-### MCP config locations by client
-
-| Client | Where to put `.mcp.json` |
-|---|---|
-| Claude Code | Workspace root `.mcp.json` |
-| Cursor | Workspace root `.mcp.json` or `.cursor/mcp.json` |
-| VS Code Copilot | `.vscode/mcp.json` |
-| Windsurf | Workspace/app MCP settings |
-
-## Diagrams
-
-### Install Flow
-
-```mermaid
-flowchart TD
-    A["npx @fluentcommerce/ai-skills install"] --> B{"--target"}
-    B -->|"claude (default)"| C["~/.claude/agents + ~/.claude/skills"]
-    B -->|"cursor"| D[".cursor/rules/*.mdc"]
-    B -->|"copilot"| E[".github/copilot-instructions.md"]
-    B -->|"vscode"| F[".github/copilot-instructions.md"]
-    B -->|"windsurf"| G[".windsurfrules"]
-    B -->|"codex"| H["AGENTS.md"]
-    B -->|"gemini"| I["GEMINI.md"]
-    A --> J{"groups specified?"}
-    J -->|"no"| K["install all groups"]
-    J -->|"yes"| L["install selected groups only"]
-```
-
-### flow-run Execution
-
-```mermaid
-flowchart LR
-    subgraph Local
-      A["Check .mcp.json"]
-      B["Scan config placeholders"]
-    end
-    subgraph CLI
-      C["fluent --version"]
-      D["fluent profile active"]
-      E["fluent module describe/list"]
-      F["fluent workflow list"]
-    end
-    subgraph Deploy
-      G{"--deploy --yes?"}
-      H["fluent module install"]
-      I["post-deploy verify"]
-    end
-    A --> B --> C --> D --> E --> F --> G
-    G -->|"yes"| H --> I
-    G -->|"no"| J["write diagnostics report only"]
-```
-
-## Companion Packages
-
-| Package | Purpose |
-|---|---|
-| [`@fluentcommerce/fluent-mcp-extn`](https://www.npmjs.com/package/@fluentcommerce/fluent-mcp-extn) | MCP extension server (events, transitions, GraphQL, metrics, batch, webhooks) |
-| Fluent CLI (`@fluentcommerce/cli`) | Official CLI and built-in MCP server |
-
-## License
-
-MIT
+# @fluentcommerce/ai-skills
+
+> **Alpha** — This package is under active development. Skill content, CLI options, and supported targets may change between releases without notice. Use in non-production environments and pin to a specific version if stability matters.
+
+Modular [Fluent Commerce](https://fluentcommerce.com) AI skill packs for coding assistants.
+Install all groups, or only what each project needs.
+
+**What this does:** AI coding assistants (Claude Code, Cursor, Copilot, etc.) are general-purpose — they don't know Fluent Commerce. This package injects Fluent-specific domain knowledge (workflows, events, rules, GraphQL patterns, CLI commands, deployment procedures) into your assistant so it can analyze workflows, scaffold rules, run E2E tests, debug failed events, and manage settings — all through natural language.
+
+**New here?** Start with the [Getting Started Guide](docs/GETTING_STARTED.md) for a hands-on walkthrough, then see [What Can You Do?](docs/USE_CASES.md) for 21 scenario-based examples.
+
+**Need release guidance?** Use the [Deployment and Promotion Runbook](docs/DEPLOYMENT_PROMOTION_RUNBOOK.md) for end-user, step-by-step promotion commands, artifacts created, verification gates, and rollback steps.
+
+**What is a "skill"?** A skill is a structured instruction file that teaches the AI how to perform a specific Fluent task. For example, `/fluent-workflow-analyzer` teaches the AI how to read workflow JSON, map status graphs, detect orphaned rulesets, and generate Mermaid diagrams. Skills are installed into your assistant's native format (Claude agents/skills, Cursor rules, Copilot instructions, etc.).
+
+## What Can You Do?
+
+| Persona | Example prompt | What happens |
+|---------|---------------|-------------|
+| New developer | "Explain how Home Delivery works" | Feature Architecture Document with diagrams, rules, settings |
+| Debugging | "Why is order HD-001 stuck?" | Event forensics, NO_MATCH analysis, remediation options |
+| Building | "Build an ORDER::RETURN workflow" | Plan mode → state machine → rulesets → deploy → E2E test |
+| Frontend | "Build a manifest page for order details" | Compose OOTB Mystique components, validate manifest, deploy to UX App |
+| UI building | "Build an order tracking page" | Manifest builder → component composition → validation → deploy |
+| Pre-go-live | "Run a Ready For Launch assessment" | Scored report across workflows, rules, settings, integrations |
+| Ops | "Show event failure rates for the last hour" | Metrics anomaly detection with threshold alerts |
+
+See [full scenario guide](docs/USE_CASES.md) for 21 detailed walkthroughs.
+
+## Quick Start
+
+```bash
+# Install all skill groups (default target: Claude Code)
+npx @fluentcommerce/ai-skills install
+
+# Configure MCP server entries for your project
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
+
+# Verify what's installed
+npx @fluentcommerce/ai-skills status
+```
+
+### Quick Start by Target
+
+Run from your project root:
+
+Primary target is **Claude**. The adapters below are **beta**.
+
+```bash
+# Cursor
+npx @fluentcommerce/ai-skills install --target cursor
+npx @fluentcommerce/ai-skills status --target cursor
+
+# VS Code (Copilot instructions format)
+npx @fluentcommerce/ai-skills install --target vscode
+npx @fluentcommerce/ai-skills status --target vscode
+
+# GitHub Copilot
+npx @fluentcommerce/ai-skills install --target copilot
+npx @fluentcommerce/ai-skills status --target copilot
+
+# Windsurf
+npx @fluentcommerce/ai-skills install --target windsurf
+npx @fluentcommerce/ai-skills status --target windsurf
+
+# Codex
+npx @fluentcommerce/ai-skills install --target codex
+npx @fluentcommerce/ai-skills status --target codex
+
+# Gemini CLI
+npx @fluentcommerce/ai-skills install --target gemini
+npx @fluentcommerce/ai-skills status --target gemini
+```
+
+Tip: to keep instruction size lighter, install only needed groups (for example `npx @fluentcommerce/ai-skills install --target cursor cli mcp-extn`).
+
+## Requirements
+
+- Node.js 18+
+- Fluent CLI (`npm i -g @fluentcommerce/cli`) — needed for official MCP server
+
+## Supported Targets
+
+Skills install into your coding assistant's native format:
+
+| Target | Output location | Scope | Status |
+|---|---|---|---|
+| `claude` (default) | `~/.claude/agents/` + `~/.claude/skills/` | Global (shared across projects) | **Primary** |
+| `cursor` | `.cursor/rules/*.mdc` | Project | Beta |
+| `copilot` | `.github/copilot-instructions.md` | Project | Beta |
+| `vscode` | `.github/copilot-instructions.md` (alias of `copilot`) | Project | Beta |
+| `windsurf` | `.windsurfrules` | Project | Beta |
+| `codex` | `AGENTS.md` | Project | Beta |
+| `gemini` | `GEMINI.md` | Project | Beta |
+
+> Claude Code is the primary target with full support (agents, skills, slash commands, MCP integration). Other targets receive the same domain knowledge as merged instruction content and are tested where possible, but may have limited functionality compared to Claude Code.
+
+```bash
+# Install for a specific target
+npx @fluentcommerce/ai-skills install --target cursor
+
+# Install specific groups only
+npx @fluentcommerce/ai-skills install --target copilot cli mcp-extn
+```
+
+For non-Claude targets, the installer writes a managed block (`<!-- fluent-ai-skills:start --> ... <!-- fluent-ai-skills:end -->`). Uninstall removes only managed content and preserves anything else in the file.
+
+## Available Groups
+
+| Group | What it provides | Claude Code slash commands |
+|---|---|---|
+| `cli` | Fluent CLI command-family coverage (index routing, reference, account connect, profile, retailer, settings, modules, workflows, MCP/CI-CD, bootstrap) | `/fluent-cli-index` `/fluent-cli-reference` `/fluent-connect` `/fluent-cli-mcp-cicd` `/fluent-bootstrap` `/fluent-cli-retailer` `/fluent-cli-settings` `/fluent-module-deploy` `/fluent-profile` `/fluent-workflow` |
+| `mcp-official` | Official Fluent CLI MCP server operations | `/fluent-mcp-core` |
+| `mcp-extn` | Extension MCP tools (events, transitions, GraphQL, metrics, batch) | `/fluent-mcp-tools` |
+| `rfl` | Ready For Launch assessments | `/fluent-rfl-assess` |
+| `dev` | **Backend:** workflow builder, analyzer, connection analysis (with `--validate` static-vs-dynamic comparison), custom code analysis, transition API, rule scaffold, module scaffold, source onboarding, module validation, build, version management, trace, event API (model + causality analysis), system monitoring, batch ingestion, settings (with Phase 2B value format validation and cascading scope resolution), environment setup, deploy, pre-deploy checks, workflow deploy. **Frontend (Mystique):** manifest validation (73 OOTB components, 49 rules), manifest builder (6 operations, 7 composition patterns), SDK component scaffolding, manifest analysis (complexity scoring, Mermaid diagrams). **Cross-cutting:** feature planning (with universal NEW/EXISTING/MODIFIED/REUSED/OOTB classification), feature status dashboard, feature archival, deployment rollback, implementation mapping, E2E test, test data, session summary, session audit export, scope decomposition (with batch feature stubbing), feature explanation, sourcing framework reference | `/fluent-feature-plan` `/fluent-feature-status` `/fluent-implementation-map` `/fluent-archive` `/fluent-rollback` `/fluent-workflow-builder` `/fluent-workflow-analyzer` `/fluent-connection-analysis` `/fluent-custom-code` `/fluent-transition-api` `/fluent-rule-scaffold` `/fluent-module-scaffold` `/fluent-source-onboard` `/fluent-module-validate` `/fluent-build` `/fluent-version-manage` `/fluent-trace` `/fluent-event-api` `/fluent-system-monitoring` `/fluent-job-batch` `/fluent-e2e-test` `/fluent-test-data` `/fluent-settings` `/fluent-retailer-config` `/fluent-session-summary` `/fluent-scope-decompose` `/fluent-pre-deploy-check` `/fluent-session-audit-export` `/fluent-feature-explain` `/fluent-sourcing` `/fluent-use-case-discover` `/fluent-data-module-scaffold` `/fluent-mermaid-validate` `/fluent-workflow-deploy` `/fluent-workspace-tree` `/fluent-mystique-validate` `/fluent-mystique-builder` `/fluent-mystique-scaffold` `/fluent-mystique-analyze` |
+
+> Slash commands are Claude Code specific. Other targets receive the same knowledge as merged instruction content.
+
+For detailed command-family and guide-section coverage status (`full/partial/missing`), see [docs/CLI_COVERAGE.md](docs/CLI_COVERAGE.md).
+
+### Agent Architecture
+
+The `dev` group uses a three-agent architecture for clear separation of concerns:
+
+| Agent | Role | Skills |
+|-------|------|--------|
+| `fluent-dev` | Lightweight orchestrator — routes requests to backend or frontend agents; owns cross-cutting skills (feature planning, implementation mapping, E2E testing, session tracking) | Cross-cutting: `/fluent-feature-plan`, `/fluent-feature-status`, `/fluent-implementation-map`, `/fluent-use-case-discover`, `/fluent-scope-decompose`, `/fluent-archive`, `/fluent-session-summary`, `/fluent-pre-deploy-check`, `/fluent-e2e-test`, `/fluent-workspace-tree` |
+| `fluent-backend-dev` | Backend specialist — Java rules, Maven modules, workflow JSON, settings, events, deployment | 24 skills including `/fluent-workflow-builder`, `/fluent-rule-scaffold`, `/fluent-module-scaffold`, `/fluent-build`, `/fluent-trace`, `/fluent-settings` |
+| `fluent-frontend-dev` | Frontend specialist — Mystique manifest building, validation, SDK component scaffolding, manifest analysis | `/fluent-mystique-builder`, `/fluent-mystique-validate`, `/fluent-mystique-scaffold`, `/fluent-mystique-analyze` |
+
+Routing is automatic — mention "workflow", "rule", "module", "event", "settings" for backend; mention "manifest", "page", "component", "UI", "Mystique" for frontend. Cross-domain features use the orchestrator's unified planning gate.
+
+### Group Aliases
+
+| Alias | Resolves to |
+|---|---|
+| `mcp` | `mcp-extn` |
+| `extn` | `mcp-extn` |
+| `extension` | `mcp-extn` |
+| `mcp-core` | `mcp-official` |
+| `official` | `mcp-official` |
+
+## Autonomous Development Workflow
+
+The `dev` skill group enables AI agents to run a full closed-loop development lifecycle with a mandatory planning gate:
+
+```
+ANALYZE → EXPLAIN (if requested) or PLAN → [USER APPROVAL] → IMPLEMENT → BUILD → DEPLOY → TEST → DIAGNOSE → FIX → (loop back)
+```
+
+After analysis, the agent presents a structured implementation plan (workflow changes, settings, rules, Mermaid diagrams, risk assessment, test plan) and waits for explicit user approval before making changes. The agent then continues iterating until all E2E tests pass or an unresolvable blocker is hit.
+
+Event API source docs are curated into skills via selective extraction; they are not mirrored wholesale.
+
+| Phase | Skill / Command | What the agent does |
+|-------|----------------|---------------------|
+| Analyze | `/fluent-workflow-analyzer`, `/fluent-connection-analysis` | Map status graphs, trace event chains, detect orphans, verify connectivity; `--validate` mode compares static workflow paths with runtime events, traces cross-entity propagation, and produces timing analysis |
+| Custom code analysis | `/fluent-custom-code` | Scan custom source, generate reusable analysis artifacts (source-map, workflow-rule-map, constraints, behavior-map, extension-plan) |
+| Discover | `/fluent-transition-api` | Query available user actions at each status, map required attributes |
+| Scope decomposition | `/fluent-scope-decompose` | Parse scope documents into ordered task lists with dependency DAG, skill mappings, and ambiguity detection |
+| Feature plan | `/fluent-feature-plan` | Produce comprehensive implementation plan with universal source classification (NEW/EXISTING/MODIFIED/REUSED/OOTB) across all artifacts — rules, workflows, settings, webhooks, cross-entity flows, deployment sequence |
+| Plan & Approve | *(check gate)* | Present structured implementation plan (workflows, settings, rules, Mermaid diagrams, risks, test plan). **Wait for user approval.** |
+| Implement | `/fluent-workflow-builder`, `/fluent-rule-scaffold` | Edit workflow JSON, scaffold Java rules, update settings |
+| Scaffold module | `/fluent-module-scaffold` | Generate complete Maven module skeleton (POMs, module.json, rule classes, build scripts) |
+| Onboard source | `/fluent-source-onboard` | Restructure existing Java source (loose files, decompiled JARs, non-standard layouts) into proper Fluent module format; validate and build |
+| Validate | `/fluent-module-validate` | Check module structure, version consistency, rule wiring, test coverage; cached report with content hash |
+| Version | `/fluent-version-manage` | Read, bump, sync, and tag versions across POM files, module.json, and CHANGELOG |
+| Build | `/fluent-build` | Version bump, Maven compile, ZIP packaging |
+| Pre-deploy | `/fluent-pre-deploy-check` | 26 quality gates across 8 phases (env, module, workflow, connections, settings, target, risk, completeness) |
+| Deploy | `/fluent-module-deploy` or `flow-run` | Module install or REST workflow upload |
+| Test | `/fluent-e2e-test` | Create entities, fire events, poll states, assert transitions |
+| Test data | `/fluent-test-data` | Discover retailer environment and generate valid test entity payloads |
+| Settings | `/fluent-settings` | Manage retailer settings — discover, audit (with Phase 2B value format validation), create/update, migrate; cascading scope resolution (RETAILER -> ACCOUNT) for module-installed settings |
+| Environment | `/fluent-retailer-config` | Configure retailer environments — locations, networks, catalogues, inventory, carriers |
+| Diagnose | `/fluent-trace`, `/fluent-event-api` | Trace failed events, correlate with rulesets, and build causality chains across parent/child events |
+| Fix | (routes back to Implement/Build/Deploy) | Apply fix based on diagnosis, re-test |
+| Explain | `/fluent-feature-explain` | Reverse-engineer existing feature into a Feature Architecture Document with Mermaid diagrams, data flow, and runtime evidence; tiered analysis (plugin.list → decompiled JAR / source code → runtime), auto-discovers entities, JAR decompilation fallback, Analysis Confidence section; saved to `accounts/<PROFILE>/features/<slug>/architecture.md` |
+| Implementation Map | `/fluent-implementation-map` | Reverse-engineer entire implementation into feature inventory with end-to-end flow diagrams, cross-feature dependency maps, customisation scoring, and gap analysis |
+| Sourcing | `/fluent-sourcing` | Reference for sourcing profiles, strategies, conditions, criteria, scoring algorithms, permutation search, custom extensions, and GraphQL patterns |
+| Audit | `/fluent-session-summary`, `/fluent-session-audit-export` | Track all changes, skill invocations, MCP tool calls, and gate decisions; export machine-readable JSON audit trail with decision chain reconstruction |
+| Dashboard | `/fluent-feature-status` | Scan all features and show lifecycle status table — highlights stale features, next steps, and attention items across profiles |
+| Workspace | `/fluent-workspace-tree` | Annotated workspace tree showing all artifacts by category with counts and status overlays |
+| Rollback | `/fluent-rollback` | Roll back deployments — re-upload previous workflow versions, restore settings snapshots, document irreversible entity changes |
+| Manifest build | `/fluent-mystique-builder` | Create manifest pages, routes, component trees, data queries; compose OOTB `fc.*` components before resorting to custom |
+| Manifest validate | `/fluent-mystique-validate` | Schema validation (49 rules, 6 phases), component resolution against 73 OOTB aliases, prop checking, i18n, data queries |
+| Manifest analyze | `/fluent-mystique-analyze` | Complexity scoring (weighted 0-100), component census, pattern detection (15 patterns), Mermaid diagrams |
+| SDK scaffold | `/fluent-mystique-scaffold` | Scaffold Mystique SDK component project (webpack, TypeScript, Storybook, Jest, component registration) when OOTB components cannot meet the requirement |
+| Archive | `/fluent-archive` | Transition features to ARCHIVED status with cleanup and audit trail |
+
+**Progress visualization:** Multi-phase skills emit an ASCII progress block (`✓/→/○`) at each phase transition, so you always see where the AI is in the process. Available on the 10 most-used skills.
+
+Artifacts from custom code analysis are written to `accounts/<PROFILE>/analysis/code/` and reused by other skills (workflow-analyzer, trace, rule-scaffold, etc.). A `fingerprint.json` file is used to detect input changes and skip re-parsing when nothing changed. Module validation reports are written to `accounts/<PROFILE>/reports/module-validate/` with a content hash — re-validation is skipped when the module source is unchanged. Persistent module inventory (rule registrations, version history) is stored in `accounts/<PROFILE>/analysis/modules/`.
+
+Account workspace convention — see [Workspace Setup](#workspace-setup) for the full guide.
+
+### Settings Update Quick Recipe
+
+For safe setting updates, use this exact flow with `/fluent-settings`:
+
+1. Resolve by `name` + `context/contextId` to fetch `id`, `valueType`, and current value.
+2. Update by `id` (never guessed) using:
+   - `value` for `STRING`/`BOOLEAN`
+   - `lobValue` for `LOB`/`JSON`
+3. Re-query the same `name` + scope and confirm the value changed.
+4. If no setting exists, create it with the same scope (upsert behavior).
+
+See [docs/DEV_WORKFLOW.md](docs/DEV_WORKFLOW.md) for the complete orchestration protocol with decision trees, tool chains, and error recovery patterns.
+
+### Deep Analysis Fallback (Vague Ruleset/Rule Intent)
+
+When workflow/ruleset descriptions are too generic to explain behavior confidently, the skills escalate evidence in this order:
+
+1. Ask focused clarification questions (trigger, expected state, actual outcome).
+2. Request source (`module.json` + Java rule classes).
+3. If source is unavailable, first check for JAR/ZIP already present under `accounts/<PROFILE>/SOURCE/`, then decompile targeted rule classes.
+4. Correlate decompiled logic with workflow props and runtime event/log evidence.
+
+This keeps end-to-end analysis grounded in executable rule logic rather than names/descriptions only.
+
+## Workspace Setup
+
+Skills expect implementation source code, workflows, and analysis artifacts to be organized under an `accounts/` directory in your workspace root, keyed by Fluent CLI profile name.
+
+### Directory Structure
+
+```
+accounts/
+  <PROFILE>/                           # matches your FLUENT_PROFILE name
+    SOURCE/                            # account-level, shared across retailers
+      <repo-name>/                     # git-cloned custom plugin repo
+        resources/module.json
+        pom.xml
+        src/main/java/...
+      <reference-module>/              # reference module package (module.json + JAR)
+        module.json
+        assets/rules/*.jar
+      .decompiled/<jar-basename>/      # auto-generated from JAR decompilation
+        DECOMPILED.md                  # marker with source JAR, date, decompiler
+        com/fluentcommerce/...         # decompiled Java classes
+    workflows/                         # retailer-scoped workflow definitions
+      <RETAILER_REF>/
+        ORDER__HD.json
+        FULFILMENT__HD_WH.json
+        workflow-context.json          # download metadata
+    features/                          # feature-axis: one dir per feature
+      curbside-pickup/
+        spec.md                        # business spec (from use-case-discover)
+        plan.md                        # implementation plan (from feature-plan)
+        architecture.md                # feature architecture doc (from feature-explain)
+        status.json                    # machine-readable lifecycle state
+    analysis/                          # generated analysis artifacts
+      code/source-map.json
+      modules/                         # persistent module inventory
+    reports/                           # ephemeral reports
+      module-validate/*.report.json
+    tasks/                             # operational task plans (non-feature)
+      2026-02-23-rule-scaffold-curbside-pickup.md
+    workspace-state.json               # cached state for idempotent re-runs
+  workspace-index.json                 # cross-profile index
+```
+
+**Why this layout:**
+- `SOURCE/` is at the profile (account) level because plugin code is deployed per-account and shared across retailers.
+- `workflows/` are scoped by retailer ref inside subdirectories because workflow definitions can differ per retailer.
+- `analysis/` holds generated artifacts that other skills reuse (source maps, module validation reports, etc.).
+- `features/` stores per-feature artifacts (spec, plan, architecture, status.json). Each feature gets its own directory with a machine-readable `status.json` tracking lifecycle state.
+- `tasks/` stores operational task plans (non-feature) created by the Planning Gate. Each plan is a markdown file with status tracking.
+
+### Feature Lifecycle
+
+Every feature goes through a structured lifecycle. The AI follows this chain automatically — you just need to prompt at each stage and approve when asked.
+
+#### Lifecycle states
+
+```
+DISCOVERY → PLANNING → APPROVED → IN_PROGRESS → VERIFIED → ARCHIVED
+```
+
+| State | What's happening | How you enter it |
+|-------|-----------------|------------------|
+| `DISCOVERY` | Requirements are being gathered | You ask the AI to discover use cases |
+| `PLANNING` | Implementation plan is being written | AI starts planning after spec is approved |
+| `APPROVED` | Plan is approved, ready to build | You explicitly approve the plan |
+| `IN_PROGRESS` | Rules, workflows, settings are being built/deployed/tested | Any implementation skill starts |
+| `VERIFIED` | All E2E tests passed, feature is complete | E2E test suite passes |
+| `ARCHIVED` | Feature retained for reference, no longer active | You run `/fluent-archive` or ask the AI to archive it |
+
+#### Step-by-step: Building a feature from scratch
+
+Here's exactly what happens at each stage, what you say, and what artifacts are created.
+
+**Step 1: Discover requirements** (creates `spec.md`, status → `DISCOVERY`)
+
+```
+"Help me define the use cases for curbside pickup"
+```
+
+The `/fluent-use-case-discover` wizard runs through 10 phases interactively — scope, actors, use cases, entity model, status lifecycles, business rules, integrations, settings, and gap analysis. It queries your live environment if a profile is connected.
+
+**What's created:**
+```
+features/curbside-pickup/
+  spec.md          ← structured Business Specification with completeness score
+  status.json      ← { "status": "DISCOVERY", "spec": "DRAFT", "plan": null }
+```
+
+You review the spec. When satisfied, tell the AI "approve the spec" → `spec` field changes to `"APPROVED"`.
+
+**Step 2: Plan the feature** (creates `plan.md`, status → `PLANNING`)
+
+```
+"Plan the curbside pickup feature"
+```
+
+The `/fluent-feature-plan` skill checks that the spec is approved (>= 75% completeness), then produces an 18-section implementation plan:
+
+- Architecture diagrams (Mermaid state machines + sequence diagrams)
+- Workflow changes with before/after diffs
+- Rules inventory — NEW rules get pseudo-logic contracts, OOTB rules get prop configuration
+- Every artifact tagged as NEW / EXISTING / MODIFIED / REUSED / OOTB
+- Settings, webhooks, cross-entity impacts
+- Deployment sequence, risk assessment, test plan
+
+**What's created:**
+```
+features/curbside-pickup/
+  spec.md          ← unchanged
+  plan.md          ← comprehensive 18-section implementation plan
+  status.json      ← { "status": "PLANNING", "spec": "APPROVED", "plan": "DRAFT" }
+```
+
+The AI presents the plan and **waits for your explicit approval**. You can ask questions, request changes, or reject it. Nothing is built until you say "approved" or "go ahead".
+
+**Step 3: Approve the plan** (status → `APPROVED`)
+
+```
+"Looks good, approved"
+```
+
+**What changes:**
+```
+  status.json      ← { "status": "APPROVED", "plan": "APPROVED", "planRevision": 1,
+                        "next": "/fluent-rule-scaffold" }
+```
+
+The `next` field tells the AI (and you) which skill to run first. The AI follows the implementation chain from the plan automatically.
+
+**Step 4: Build** (status → `IN_PROGRESS`)
+
+The AI now executes the plan in order. You can let it run or prompt each step manually:
+
+```
+"Create the rules from the plan"          → /fluent-rule-scaffold
+"Build the workflow from the plan"         → /fluent-workflow-builder
+"Build the module"                         → /fluent-build
+"Run pre-deploy checks"                    → /fluent-pre-deploy-check
+"Deploy everything to MY_RETAILER"         → /fluent-module-deploy + /fluent-workflow-deploy
+"Run the E2E test from the plan"           → /fluent-e2e-test
+```
+
+**What's created at each sub-step:**
+
+| Sub-step | Skill | Artifacts created |
+|----------|-------|-------------------|
+| Scaffold rules | `/fluent-rule-scaffold` | `SOURCE/<repo>/src/main/java/.../RuleName.java` + test class + `module.json` updated |
+| Build workflow | `/fluent-workflow-builder` | Modified workflow JSON in `workflows/<RETAILER>/` |
+| Validate | `/fluent-workflow-analyzer` | Structural analysis (runs automatically after workflow edits) |
+| Compile module | `/fluent-build` | `SOURCE/<repo>/dist/<module>.zip` + report in `reports/build/` |
+| Pre-deploy gate | `/fluent-pre-deploy-check` | Report in `reports/pre-deploy/` (READY or BLOCKED) |
+| Deploy module | `/fluent-module-deploy` | Module installed on live environment |
+| Deploy workflow | `/fluent-workflow-deploy` | Workflow uploaded to live environment |
+| E2E test | `/fluent-e2e-test` | Test results in `reports/e2e-test/`, entities created on live env |
+
+During this phase:
+```
+  status.json      ← { "status": "IN_PROGRESS", "next": "/fluent-build" }
+                      (next updates as each step completes)
+```
+
+If a test fails, the AI diagnoses the issue, applies a fix, rebuilds, redeploys, and re-tests automatically — looping until all tests pass or an unresolvable blocker is hit.
+
+**Step 5: Verified** (status → `VERIFIED`)
+
+When all E2E tests pass:
+
+```
+  status.json      ← { "status": "VERIFIED", "next": null }
+```
+
+The feature is complete. The AI offers a session summary showing everything that was changed.
+
+#### Explaining an existing feature (creates `architecture.md`)
+
+Not building — just understanding? Use feature-explain instead:
+
+```
+"Explain how Home Delivery works end-to-end"
+```
+
+The `/fluent-feature-explain` skill reverse-engineers the live environment:
+
+**What's created:**
+```
+features/home-delivery/
+  architecture.md  ← Feature Architecture Document with:
+                      - State machine diagrams (Mermaid)
+                      - Cross-entity sequence diagrams
+                      - Rules & logic tables
+                      - Settings dependencies
+                      - Integration points
+                      - Analysis Confidence levels (HIGH/MEDIUM/LOW per rule)
+  status.json      ← { "architecture": true }
+```
+
+This is read-only — no plan or implementation needed.
+
+#### status.json reference
+
+Every feature directory has a `status.json` that the AI reads to know where things stand:
+
+```json
+{
+  "$schema": "feature-status-v1",
+  "feature": "curbside-pickup",
+  "retailers": ["Module Test"],
+  "status": "APPROVED",
+  "created": "2026-02-23",
+  "updated": "2026-02-24",
+  "spec": "APPROVED",
+  "plan": "APPROVED",
+  "planRevision": 2,
+  "architecture": true,
+  "next": "/fluent-rule-scaffold",
+  "basedOn": null,
+  "archivedOn": null,
+  "sessions": []
+}
+```
+
+| Field | What it means |
+|-------|--------------|
+| `status` | Overall lifecycle state (DISCOVERY → PLANNING → APPROVED → IN_PROGRESS → VERIFIED → ARCHIVED) |
+| `retailers` | Target retailer ref(s) — array for multi-retailer features (accepts singular `retailer` for backward compat) |
+| `spec` | `"DRAFT"` / `"APPROVED"` / `null` (no spec) |
+| `plan` | `"DRAFT"` / `"APPROVED"` / `null` (no plan) |
+| `planRevision` | Current approved plan revision (increments on re-approval) |
+| `architecture` | `true` if an architecture doc exists |
+| `next` | Which skill should run next (advisory — the AI follows this automatically) |
+| `basedOn` | Slug of parent feature whose architecture.md this feature builds on |
+| `archivedOn` | Date the feature was archived (null if not archived) |
+| `sessions` | Links to audit trail exports (populated by `/fluent-session-audit-export`) |
+
+#### Resuming work across sessions
+
+When you start a new session, the AI checks `features/*/status.json` to find in-progress work:
+
+```
+"What features are in progress?"
+```
+
+Or resume a specific feature:
+
+```
+"Continue working on curbside pickup"
+```
+
+The AI reads `status.json`, sees `"status": "IN_PROGRESS"` and `"next": "/fluent-build"`, and picks up where it left off.
+
+#### Revision tracking
+
+When a plan or spec is re-approved (major changes), the AI:
+1. Snapshots the current version to `features/<slug>/history/plan.v1.md`
+2. Overwrites `plan.md` with the new version
+3. Increments `planRevision` in `status.json`
+
+```
+features/curbside-pickup/
+  plan.md                  ← current (revision 2)
+  spec.md                  ← current
+  history/
+    plan.v1.md             ← snapshot of revision 1
+```
+
+### Guided Onboarding (`/fluent-connect`)
+
+The fastest way to set up a workspace is the guided connect wizard. In Claude Code:
+
+```
+/fluent-connect
+```
+
+Or with explicit arguments to skip interactive selection:
+
+```
+/fluent-connect --profile MYPROFILE --retailer MY_RETAILER
+```
+
+The wizard runs through 5 phases:
+
+1. **Profile Discovery** — scans `~/.fluentcommerce/` for CLI profiles, presents a table with account name and environment tier
+2. **Retailer Selection** — reads retailer files for the selected profile, asks which retailer to target
+3. **MCP Wiring** — runs `mcp-setup`, verifies `.mcp.json`, prompts IDE reload, validates connectivity
+4. **Workspace Readiness** — creates directories, downloads workflows, scans source repos, decompiles JARs if needed, builds a deployed rule inventory by cross-referencing `plugin.list` with local source
+5. **Persist & Report** — writes `workspace-state.json` (with content hash for caching), updates `workspace-index.json`, prints a readiness report with next-step suggestions
+
+Re-running `/fluent-connect` is safe and instant if nothing changed (content hash match). Use `--force` to re-run full discovery.
+
+### Adding Source Code
+
+Clone your custom plugin repositories into `accounts/<PROFILE>/SOURCE/`:
+
+```bash
+cd accounts/MYPROFILE/SOURCE
+git clone https://bitbucket.org/yourorg/fc-module-extensions.git
+git clone https://bitbucket.org/yourorg/fc-module-returns.git
+```
+
+Each repo should contain at minimum:
+- `resources/module.json` — module metadata and rule registrations
+- `pom.xml` — Maven build configuration
+- `src/main/java/` — Java rule classes
+
+Skills automatically detect repos by searching recursively for `module.json`, `pom.xml`, or `src/main/java/`. Nested directory structures (including double-nested git clone artifacts like `repo/repo/`) are handled.
+
+### Adding JAR Files
+
+When original source code is not available, place compiled module JARs directly in `SOURCE/`:
+
+```bash
+cp fc-module-extensions-1.2.3.jar accounts/MYPROFILE/SOURCE/
+```
+
+Skills will:
+1. Auto-detect JAR files during workspace setup
+2. Decompile them (using CFR or Fernflower if available) into `SOURCE/.decompiled/<jar-basename>/`
+3. Extract `module.json` from the JAR if present
+4. Create a `DECOMPILED.md` marker noting the source JAR, date, and confidence level
+
+**Decompiled source is read-only.** Skills can analyze it for rule discovery, behavior explanation, and workflow-rule mapping, but will never suggest editing decompiled files. To modify code, provide original source or scaffold a new module.
+
+### Reference Modules
+
+Reference (OOTB) modules that ship as a `module.json` + JAR package can also be placed in `SOURCE/`:
+
+```bash
+cp -r fluent-module-order/ accounts/MYPROFILE/SOURCE/
+# Contains: module.json + assets/rules/*.jar
+```
+
+Skills read rule names, descriptions, and version directly from `module.json` — no decompilation needed for metadata. Decompilation is only triggered if deep analysis of rule implementation logic is requested.
+
+### Adding a New Account
+
+```bash
+# Create the directory structure
+mkdir -p accounts/NEW_PROFILE/SOURCE
+mkdir -p accounts/NEW_PROFILE/workflows
+mkdir -p accounts/NEW_PROFILE/analysis
+
+# Clone plugin repos
+cd accounts/NEW_PROFILE/SOURCE
+git clone <repo-url>
+
+# Download workflows (after setting up profile)
+fluent workflow download -p NEW_PROFILE -r RETAILER_REF -w all \
+  -o accounts/NEW_PROFILE/workflows/RETAILER_REF/
+```
+
+Or let `/fluent-connect` do all of this interactively.
+
+### How Analysis Works
+
+Once the workspace is populated, skills build a holistic view of what's deployed:
+
+1. **Live environment** — `plugin.list` queries all registered orchestration rules
+2. **Local source** — repos with full Java source (modifiable, buildable)
+3. **Local JARs** — decompiled bytecode (analyzable, read-only)
+4. **Workflow definitions** — downloaded JSON files
+
+Cross-referencing these produces a **deployed rule inventory**:
+
+| Status | Meaning | What you can do |
+|--------|---------|-----------------|
+| Full source | Rule class found in a git repo | Analyze, modify, build, redeploy |
+| Decompiled | Rule class found in decompiled JAR | Analyze behavior, cannot modify |
+| Missing | Deployed rule with no local source or JAR | Blind spot — provide source or JAR |
+
+This inventory is persisted in `workspace-state.json` and powers downstream skills like `/fluent-custom-code`, `/fluent-workflow-analyzer`, and `/fluent-rfl-assess`.
+
+### .gitignore
+
+The `accounts/` directory should be in `.gitignore` — it may contain credentials (via profile references), downloaded workflows, and customer-specific source code:
+
+```gitignore
+accounts/
+```
+
+## Setup Guide
+
+### Option A — Fastest (no source clone)
+
+```bash
+npx @fluentcommerce/ai-skills install
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
+
+# Multi-retailer profile (retailer ref for extension server)
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
+```
+
+When `--profile` is provided, both MCP servers are wired with `FLUENT_PROFILE` automatically.
+You can run immediately with profile auth, or override with explicit OAuth/token env vars.
+
+For explicit env auth in `.mcp.json`, fill:
+
+- `FLUENT_BASE_URL` — your tenant API URL
+- `FLUENT_RETAILER_ID` — target retailer ID
+- `FLUENT_CLIENT_ID` / `FLUENT_CLIENT_SECRET` — OAuth credentials
+- `FLUENT_USERNAME` / `FLUENT_PASSWORD` — user credentials (if using password grant)
+- `FLUENT_PROFILE_RETAILER` — optional retailer ref for profile-scoped user overrides
+
+Restart your IDE after editing `.mcp.json`.
+
+### Option B — Extension source clone + local build
+
+```bash
+npx @fluentcommerce/ai-skills mcp-setup --install-extn-source --profile YOUR_PROFILE
+```
+
+This clones the `fluent-mcp-extn` source into your project, builds it, and wires `.mcp.json` to the local build. Use this if you want to debug or customize the extension server.
+
+### Option C — Install from tarball
+
+```bash
+# Create tarball
+cd fluent-ai-skills && npm pack
+
+# Install from tarball on any machine
+npx ./fluentcommerce-ai-skills-0.2.0.tgz install
+```
+
+## End-to-End Validation (Recommended)
+
+Validate the full setup path (skills bootstrap -> MCP config -> extension runtime smoke):
+
+```bash
+# 1) Install skills + generate MCP config
+npx @fluentcommerce/ai-skills install
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
+
+# 2) Verify generated env in .mcp.json (extension server)
+#    FLUENT_PROFILE=YOUR_PROFILE
+#    FLUENT_PROFILE_RETAILER=YOUR_RETAILER_REF
+
+# 3) Run extension end-to-end smoke
+cd fluent-mcp-extn
+npm install
+npm run build
+npm test
+npm run e2e:smoke -- --wizard
+npm run e2e:smoke -- --profile YOUR_PROFILE
+npm run e2e:smoke -- --profile YOUR_PROFILE --retailer YOUR_RETAILER_REF_OR_ID
+
+# 4) Optional: run one smoke cycle per profile retailer
+npm run e2e:smoke -- --profile YOUR_PROFILE --all-retailers
+```
+
+This verifies both MCP servers are configured and that `fluent-mcp-extn` can execute real API smoke checks in profile mode.
+
+Notes:
+- `--wizard` is for interactive local runs (guided profile/account + retailer selection).
+- `--retailer` accepts retailer ID or retailer ref.
+- CI/non-interactive runs should use explicit flags (`--profile <name> --retailer <id|ref>` or `--profile <name> --all-retailers`).
+- `flow-run` is diagnostics + optional guarded deploy; use `fluent-mcp-extn` smoke for runtime E2E checks.
+
+## CLI Reference
+
+```
+npx @fluentcommerce/ai-skills <command> [--target <target>] [groups...]
+```
+
+| Command | Description |
+|---|---|
+| `install [groups...]` | Install all groups (default) or selected groups |
+| `uninstall [groups...]` | Uninstall all groups or selected groups |
+| `status [groups...]` | Show install status |
+| `list` | List available groups |
+| `mcp-setup [options]` | Generate `.mcp.json` for official + extension MCP servers |
+| `flow-run [options]` | Run diagnostics and optional guarded module deploy |
+| `--version` | Show package version |
+| `--help` | Show help |
+
+### `mcp-setup` Options
+
+```bash
+# Basic — generates .mcp.json with both servers
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
+
+# Profile + retailer ref (for fluent-mcp-extn profile-scoped user overrides)
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE --profile-retailer YOUR_RETAILER_REF
+
+# Clone and build extension source locally
+npx @fluentcommerce/ai-skills mcp-setup --install-extn-source --profile YOUR_PROFILE
+
+# Custom source location and repo
+npx @fluentcommerce/ai-skills mcp-setup \
+  --install-extn-source \
+  --extn-dir tools/fluent-mcp-extn \
+  --extn-repo https://bitbucket.org/fluentcommerce/fluent-mcp-extn.git
+
+# Custom server names
+npx @fluentcommerce/ai-skills mcp-setup \
+  --official-server-name fluent-mcp \
+  --extn-server-name fluent-mcp-extn
+```
+
+`--profile-retailer` expects a retailer **ref** (for example `RETAILER_REF`), not retailer ID.
+
+### `flow-run` Options
+
+`flow-run` runs pre-deploy diagnostics and optionally deploys a module:
+
+```bash
+# Diagnostics only (no deploy)
+npx @fluentcommerce/ai-skills flow-run \
+  --profile YOUR_PROFILE \
+  --retailer YOUR_RETAILER \
+  --module dist/module.zip \
+  --config config/module.config.json
+
+# Diagnostics + guarded deploy
+npx @fluentcommerce/ai-skills flow-run \
+  --profile YOUR_PROFILE \
+  --retailer YOUR_RETAILER \
+  --module dist/module.zip \
+  --config config/module.config.json \
+  --deploy --yes --exclude-workflows
+```
+
+Steps executed: config checks, CLI preflight, module/workflow listing, optional deploy, JSON report.
+
+Report output: `./.fluent-ai-skills/flow-run-report-<timestamp>.json`
+
+## Usage Examples
+
+### Claude Code — full install + MCP
+
+```bash
+npx @fluentcommerce/ai-skills install
+npx @fluentcommerce/ai-skills mcp-setup --profile YOUR_PROFILE
+npx @fluentcommerce/ai-skills status
+```
+
+### Cursor — operations focused
+
+```bash
+cd your-project
+npx @fluentcommerce/ai-skills install --target cursor cli mcp-extn
+npx @fluentcommerce/ai-skills status --target cursor
+```
+
+### GitHub Copilot — shared repo instructions
+
+```bash
+cd your-project
+npx @fluentcommerce/ai-skills install --target copilot cli rfl
+```
+
+### Uninstall
+
+```bash
+# Uninstall all groups from default target
+npx @fluentcommerce/ai-skills uninstall
+
+# Uninstall specific groups from specific target
+npx @fluentcommerce/ai-skills uninstall --target windsurf cli
+```
+
+## Size Guidance
+
+Single-file targets (`copilot`, `vscode`, `windsurf`, `codex`, `gemini`) concatenate all content into one file. If prompt size becomes a concern, install only the groups you need:
+
+```bash
+npx @fluentcommerce/ai-skills install --target codex cli mcp-extn
+```
+
+## Advanced
+
+### Override install location
+
+For Claude target, override the default `~/.claude/` location:
+
+```bash
+FLUENT_AI_SKILLS_HOME=/custom/path npx @fluentcommerce/ai-skills install
+```
+
+```powershell
+# PowerShell
+$env:FLUENT_AI_SKILLS_HOME = "C:\custom\path"; npx @fluentcommerce/ai-skills install
+```
+
+```cmd
+# Windows CMD
+set FLUENT_AI_SKILLS_HOME=C:\custom\path && npx @fluentcommerce/ai-skills install
+```
+
+### MCP config locations by client
+
+| Client | Where to put `.mcp.json` |
+|---|---|
+| Claude Code | Workspace root `.mcp.json` |
+| Cursor | Workspace root `.mcp.json` or `.cursor/mcp.json` |
+| VS Code Copilot | `.vscode/mcp.json` |
+| Windsurf | Workspace/app MCP settings |
+
+## Diagrams
+
+### Install Flow
+
+```mermaid
+flowchart TD
+    A["npx @fluentcommerce/ai-skills install"] --> B{"--target"}
+    B -->|"claude (default)"| C["~/.claude/agents + ~/.claude/skills"]
+    B -->|"cursor"| D[".cursor/rules/*.mdc"]
+    B -->|"copilot"| E[".github/copilot-instructions.md"]
+    B -->|"windsurf"| F[".windsurfrules"]
+    B -->|"codex"| G["AGENTS.md"]
+    A --> H{"groups specified?"}
+    H -->|"no"| I["install all groups"]
+    H -->|"yes"| J["install selected groups only"]
+```
+
+### flow-run Execution
+
+```mermaid
+flowchart LR
+    subgraph Local
+      A["Check .mcp.json"]
+      B["Scan config placeholders"]
+    end
+    subgraph CLI
+      C["fluent --version"]
+      D["fluent profile active"]
+      E["fluent module describe/list"]
+      F["fluent workflow list"]
+    end
+    subgraph Deploy
+      G{"--deploy --yes?"}
+      H["fluent module install"]
+      I["post-deploy verify"]
+    end
+    A --> B --> C --> D --> E --> F --> G
+    G -->|"yes"| H --> I
+    G -->|"no"| J["write diagnostics report only"]
+```
+
+## Companion Packages
+
+| Package | Purpose |
+|---|---|
+| [`@fluentcommerce/fluent-mcp-extn`](https://www.npmjs.com/package/@fluentcommerce/fluent-mcp-extn) | MCP extension server (events, transitions, GraphQL, metrics, batch, webhooks) |
+| Fluent CLI (`@fluentcommerce/cli`) | Official CLI and built-in MCP server |
+
+## License
+
+MIT