@fluentcommerce/ai-skills 0.1.0

package/docs/FLOW_RUN.md

@@ -0,0 +1,142 @@
+# flow-run Command Reference
+
+`flow-run` provides a structured execution pipeline for Fluent Commerce diagnostics and optional module deployment.
+
+It is designed as a practical first step toward autonomous operations:
+
+- run deterministic preflight checks
+- validate local config readiness
+- verify Fluent CLI context and environment access
+- optionally deploy a module with explicit confirmation
+- output a JSON report for auditing and automation
+
+## Behavior Summary
+
+By default, `flow-run` performs **read-only diagnostics**.
+
+Write operations occur only when both flags are present:
+
+- `--deploy`
+- `--yes`
+
+## Prerequisites
+
+- Node.js 18+
+- Fluent CLI installed and available on `PATH`
+- active Fluent profile/session configured (or explicit profile provided)
+- optional: `.mcp.json` in the project root if MCP readiness checks are required
+
+## Usage
+
+```bash
+npx @fluentcommerce/ai-skills flow-run [options]
+```
+
+## Options
+
+| Option | Description |
+|---|---|
+| `--profile <name>` | Fluent profile used for module/workflow checks |
+| `--retailer <ref>` | Retailer ref used for workflow checks and deploy |
+| `--module <name-or-path>` | Module package path/name for describe/install |
+| `--config <file>` | Config file to scan for unresolved `[[...]]` placeholders |
+| `--deploy` | Enables `fluent module install` step |
+| `--yes` | Mandatory confirmation with `--deploy` |
+| `--exclude-workflows` | Adds `--exclude workflows` to deploy command |
+| `--force` | Adds `--force` to deploy command |
+| `--report <path>` | Custom JSON report output path |
+| `--official-server-name <n>` | MCP official server key in `.mcp.json` (default `fluent-mcp`) |
+| `--extn-server-name <n>` | MCP extension server key in `.mcp.json` (default `fluent-mcp-extn`) |
+| `--skip-mcp-check` | Skip `.mcp.json` validation |
+| `--help` | Show command help |
+
+## Examples
+
+Diagnostics-only run:
+
+```bash
+npx @fluentcommerce/ai-skills flow-run \
+  --profile YOUR_PROFILE \
+  --retailer YOUR_RETAILER_REF \
+  --module dist/your-module.zip \
+  --config config/module.config.YOUR_RETAILER_REF.json
+```
+
+Deploy run with explicit confirmation:
+
+```bash
+npx @fluentcommerce/ai-skills flow-run \
+  --profile YOUR_PROFILE \
+  --retailer YOUR_RETAILER_REF \
+  --module dist/your-module.zip \
+  --config config/module.config.YOUR_RETAILER_REF.json \
+  --deploy \
+  --yes
+```
+
+Deploy while protecting workflows:
+
+```bash
+npx @fluentcommerce/ai-skills flow-run \
+  --profile YOUR_PROFILE \
+  --retailer YOUR_RETAILER_REF \
+  --module dist/module.zip \
+  --deploy \
+  --yes \
+  --exclude-workflows
+```
+
+## What Gets Checked
+
+Local checks:
+
+- `.mcp.json` presence and server key validation
+- unresolved placeholder detection in MCP env values (`YOUR_*`, `your-*`, `[[...]]`)
+- unresolved placeholder detection in module config (`[[...]]`)
+
+Fluent CLI checks:
+
+- `fluent --version`
+- `fluent profile active`
+- optional `fluent module describe <module>`
+- optional `fluent module list -p <profile>`
+- optional `fluent workflow list -p <profile> -r <retailer>`
+
+Optional deploy checks:
+
+- `fluent module install ...`
+- post-deploy module/workflow list verification
+
+## Report Output
+
+Default report path:
+
+```text
+./.fluent-ai-skills/flow-run-report-<timestamp>.json
+```
+
+Each report includes:
+
+- command metadata (`cwd`, timestamp, package version, options)
+- check-by-check status (`passed`, `warning`, `failed`, `skipped`)
+- command execution details (exit code, duration, sanitized stdout/stderr)
+- summary totals and overall outcome
+- recommendations
+
+## Exit Behavior
+
+- exits `0` when no failing checks remain
+- exits non-zero when any **failed** checks are present
+- warnings do not fail the process
+
+## Current Limits
+
+`flow-run` currently orchestrates deterministic CLI and config checks, but it does not yet:
+
+- auto-generate/repair workflow JSON or rulesets
+- run MCP GraphQL/event tools directly end-to-end
+- auto-classify root cause from workflowlog/error payloads
+- auto-create version bump commits or publish artifacts
+- execute environment-specific business smoke tests autonomously
+
+Use this command as a stable baseline for guarded execution and structured evidence collection.

package/docs/USE_CASES.md

@@ -0,0 +1,404 @@
+# What Can You Do With Fluent AI Skills?
+
+A scenario-based guide to everything your AI assistant can do after installing `@fluentcommerce/ai-skills`. Each scenario shows what to say (natural language or slash command), what happens, and what you get back.
+
+> **Prerequisites:** Skills installed (`npx @fluentcommerce/ai-skills install`), MCP servers configured (`mcp-setup --profile YOUR_PROFILE`), and workspace connected (`/fluent-connect`).
+
+---
+
+## Quick Reference: "I want to..."
+
+| I want to... | Say this | Skill |
+|---|---|---|
+| Understand how a feature works | "Explain how Home Delivery works" | `/fluent-feature-explain` |
+| Debug why an order is stuck | "Why is order HD-001 stuck in BOOKED?" | `/fluent-trace` |
+| Build a new workflow from scratch | "Build an ORDER::RETURNS workflow" | `/fluent-workflow-builder` |
+| Run an end-to-end test | "Run an E2E test of the HD order flow" | `/fluent-e2e-test` |
+| Check if we're ready for go-live | "Run an RFL assessment" | `/fluent-rfl-assess` |
+| Create test data | "Create a test HD order" | `/fluent-test-data` |
+| Scaffold a new Java rule | "Create a new rule called ValidateReturnWindow" | `/fluent-rule-scaffold` |
+| Deploy a module | "Deploy my extension module to HM_TEST" | `/fluent-module-deploy` |
+| Audit settings | "What settings are missing for ORDER::HD?" | `/fluent-settings` |
+| Monitor event health | "Show me event failure rates for the last hour" | `/fluent-system-monitoring` |
+| Set up a new account | "Bootstrap a new Fluent account" | `/fluent-bootstrap` |
+| Analyze workflow structure | "Analyze ORDER::HD for orphaned rulesets" | `/fluent-workflow-analyzer` |
+| See what actions are available | "What actions can I take on an ORDER in BOOKED status?" | `/fluent-transition-api` |
+| Understand the event model | "How does event routing work in Fluent?" | `/fluent-event-api` |
+| Create a location or network | "Set up a warehouse location for testing" | `/fluent-retailer-config` |
+| Check module health | "What modules are deployed? Are they valid?" | `/fluent-module-validate` |
+| Plan a multi-artifact feature | "Plan the curbside pickup feature" | `/fluent-feature-plan` |
+| Onboard existing source into module format | "Refactor this code into a Fluent module" | `/fluent-source-onboard` |
+| Deploy a workflow to an environment | "Deploy the updated ORDER::HD workflow" | `/fluent-workflow-deploy` |
+| Create a data-only module (no Java) | "Scaffold a data module for locations and settings" | `/fluent-data-module-scaffold` |
+
+---
+
+## Scenario 1: "I just joined the project — help me understand what's built"
+
+**Situation:** You're a new developer onboarding onto an existing Fluent Commerce implementation. You need to understand the workflows, rules, and integrations before making changes.
+
+**Step 1: Connect to the account**
+```
+/fluent-connect
+```
+The wizard discovers your CLI profiles, selects the retailer, downloads all workflows, scans for source code, decompiles any JARs, and reports what's available.
+
+**Step 2: Explain the main feature**
+```
+Explain how the Home Delivery order flow works end-to-end
+```
+This produces a **Feature Architecture Document** with:
+- State machine diagrams (Mermaid) for every entity (ORDER, FULFILMENT_CHOICE, FULFILMENT)
+- Cross-entity sequence diagram showing event propagation
+- Rules & logic table explaining what each ruleset does
+- Settings dependencies with current values
+- Integration points (webhooks, scheduled events)
+- Analysis confidence levels (HIGH/MEDIUM/LOW per rule)
+
+Output saved to `accounts/<PROFILE>/analysis/features/Home_Delivery.md`.
+
+**Step 3: Analyze specific workflows**
+```
+Analyze ORDER::HD for orphaned rulesets and trigger coverage
+```
+Returns a status graph, event chains, process flow classification, and any structural issues.
+
+**Step 4: Understand custom code**
+```
+Analyze the custom code for this account
+```
+Scans `accounts/<PROFILE>/SOURCE/`, maps rules to workflow rulesets, generates behavior descriptions, and flags any deployed rules without local source.
+
+---
+
+## Scenario 2: "An order is stuck — help me debug it"
+
+**Situation:** A production order `HD-12345` has been in BOOKED status for hours and should have progressed to FULFILLED.
+
+**Step 1: Trace the order**
+```
+Why is order HD-12345 stuck in BOOKED?
+```
+Runs `event.flowInspect` on the order, analyzing all orchestration events to find:
+- Which events fired and which NO_MATCHed
+- Failed webhook deliveries
+- Rulesets that should have triggered but didn't
+- Timeline of every status change
+
+**Step 2: Check available actions**
+```
+What actions can I take on this order right now?
+```
+Queries the Transition API for user actions available at the current status — shows event names, required attributes, and button labels.
+
+**Step 3: Fire a remediation event**
+```
+Send a RetryFulfilmentAllocation event to order HD-12345
+```
+Builds and sends the event (with dry-run preview first), then monitors the result.
+
+---
+
+## Scenario 3: "Build a new workflow for Returns"
+
+**Situation:** You need to implement a Return Order flow that doesn't exist yet.
+
+**Step 1: Plan the workflow**
+```
+Build an ORDER::RETURN workflow with states: CREATED, APPROVED, ITEMS_RECEIVED, REFUNDED, COMPLETE, CANCELLED
+```
+The agent enters **plan mode** — presents:
+- State machine diagram (Mermaid `stateDiagram-v2`)
+- Ruleset inventory (what triggers each transition)
+- Settings dependencies
+- Cross-entity interactions
+- Risk assessment
+
+**Waits for your approval** before writing any JSON.
+
+**Step 2: Scaffold custom rules**
+```
+Create a rule called ValidateReturnWindow that checks if the return is within 30 days
+```
+Generates:
+- Java rule class with Fluent SDK boilerplate
+- Test class skeleton
+- Wires the rule into `module.json`
+
+**Step 3: Build and deploy**
+```
+Build the module and deploy to HM_TEST
+```
+Runs Maven compile, packages the module ZIP, validates structure, and deploys.
+
+**Step 4: Test it**
+```
+Run an E2E test: create a return order, approve it, receive items, process refund
+```
+Creates test entities dynamically, fires events at each step, polls for status transitions, and reports pass/fail per step.
+
+---
+
+## Scenario 4: "We're going live next week — are we ready?"
+
+**Situation:** Pre-production readiness check before go-live.
+
+**Step 1: Run RFL assessment**
+```
+Run a Ready For Launch assessment
+```
+Analyzes:
+- All deployed workflows (structure, orphaned rulesets, trigger coverage)
+- Custom rules (code quality, test coverage, GraphQL usage)
+- Settings (missing keys, invalid values)
+- Integration points (webhook configuration)
+- Architecture (entity relationships, cross-workflow dependencies)
+
+Produces a scored report with risk ratings and prioritized recommendations.
+
+**Step 2: Audit settings**
+```
+Audit all settings for ORDER::HD — find any gaps
+```
+Cross-references workflow rule parameters against deployed settings. Flags missing settings, wrong value formats, and cascading scope issues.
+
+**Step 3: Check event health**
+```
+Show me event failure rates and NO_MATCH events for the last 24 hours
+```
+Queries Prometheus metrics or Event API, runs anomaly detection, and reports:
+- Failure rate (threshold: >5%)
+- NO_MATCH events (any = critical — means workflow gaps)
+- PENDING queue buildup
+- Single-event dominance (possible runaway loops)
+
+---
+
+## Scenario 5: "Set up a fresh environment for testing"
+
+**Situation:** You need a clean retailer environment with locations, networks, inventory, and test data.
+
+**Step 1: Bootstrap (new account)**
+```
+Bootstrap a new Fluent account from scratch
+```
+Walks through: profile creation, retailer setup, reference module installation, sample data.
+
+**Or configure an existing retailer:**
+```
+Set up a warehouse location called "Sydney DC" with 24/7 hours
+```
+Creates the location via GraphQL with proper `openingSchedule`.
+
+**Step 2: Create test data**
+```
+Create a test HD order with 2 items
+```
+Auto-discovers available products, locations, and customers from the live environment. Generates a valid order payload — no hardcoded refs.
+
+**Step 3: Run smoke test**
+```
+Run an E2E test of the full HD order flow
+```
+Creates order → fires events through each status → asserts transitions → reports results. On failure, automatically runs event forensics to show exactly where it broke.
+
+---
+
+## Scenario 6: "Monitor production event processing"
+
+**Situation:** Ongoing operational monitoring of event health.
+
+**Quick health check:**
+```
+Run a health check on event processing
+```
+Single call that checks failure rates, NO_MATCH events, pending queues, and event dominance.
+
+**Detailed metrics:**
+```
+Show me the top 20 events by volume in the last 6 hours
+```
+Aggregates events by name + entity type + status, ranks by volume, shows failure rates per event.
+
+**SLO report:**
+```
+Generate an SLO report for the last 24 hours
+```
+Computes event volume, failure/NO_MATCH/pending rates, p95 runtime and inflight latency. Flags any threshold breaches.
+
+**Deep dive on failures:**
+```
+What are the top failing events? Show me details
+```
+Lists top failing events with counts, then drills into specific failures with `event.flowInspect`.
+
+---
+
+## Scenario 7: "I need to understand the event model"
+
+**Situation:** You're new to Fluent's event-driven architecture and need to understand how events work.
+
+```
+How does event routing work in Fluent? What are the event types and statuses?
+```
+Explains:
+- Event types (ORCHESTRATION, API, ORCHESTRATION_AUDIT)
+- Event categories (GENERAL, ACTION, CUSTOMER)
+- Event statuses (SUCCESS, FAILED, NO_MATCH, PENDING, SCHEDULED)
+- The routing model (how events match to workflow rulesets via triggers)
+- Run-once workflows and scheduled events
+- How to query and filter events for debugging
+
+---
+
+## Scenario 8: "Deploy a workflow change safely"
+
+**Situation:** You've modified a workflow and need to deploy it without breaking production.
+
+**Step 1: Diff the changes**
+```
+Compare the current ORDER::HD workflow with my modified version
+```
+Shows added/removed/modified rulesets, risk assessment (removing rulesets = HIGH risk), and before/after state diagrams.
+
+**Step 2: Validate connections**
+```
+Run connection analysis on ORDER::HD — check for broken cross-entity links
+```
+Maps all internal, cross-entity, and cross-workflow connections. Flags any rulesets that emit events with no matching triggers.
+
+**Step 3: Deploy**
+```
+Deploy the updated ORDER::HD workflow
+```
+Uses `/fluent-workflow-deploy` — validates structure, uploads via MCP `workflow.upload` tool (with dry-run first), falls back to REST API if needed, returns new version number.
+
+**Step 4: Verify**
+```
+Run an E2E test of the HD flow to verify the deployment
+```
+Exercises the deployed workflow end-to-end and reports pass/fail.
+
+---
+
+## Scenario 9: "Batch ingest inventory data"
+
+**Situation:** You need to load inventory positions in bulk.
+
+```
+Create a batch ingestion job for inventory positions
+```
+Walks through: creating the job, sending records in batches, polling status, and checking per-record results.
+
+---
+
+## Scenario 10: "Decompose a scope document into tasks"
+
+**Situation:** You have a structured scope document (ADD format) and need an executable task plan.
+
+```
+Decompose this scope document into tasks with dependencies
+```
+Parses the scope, generates an ordered task list with:
+- Dependency DAG (which tasks block which)
+- Skill mappings (which skill handles each task)
+- Ambiguity flags (where the scope is unclear)
+- SCAFFOLD vs EXTEND vs SOURCE_ONBOARD decisions
+
+---
+
+## Scenario 11: "Onboard existing source into a proper module"
+
+**Situation:** You have Java rule classes from another team or a decompiled JAR, but they're not in Fluent Commerce module format. You need a buildable, deployable module.
+
+**Step 1: Onboard the source**
+```
+Refactor this code into a Fluent module: accounts/HMDEV/SOURCE/.decompiled/fc-module-ext/
+```
+Or for loose Java files:
+```
+/fluent-source-onboard ./my-rules/ --module-name hm-returns
+```
+
+The skill:
+1. **Analyzes** the existing layout (decompiled JAR? loose files? Gradle project? partial module?)
+2. **Discovers** all rule classes (by `@RuleInfo`, `BaseRule` extension, `run()` methods)
+3. **Plans** the target Maven multi-module structure with a full file operations table
+4. **Waits for your approval** before changing anything
+
+**Step 2: Review the plan**
+
+The plan shows exactly what will happen:
+- Which files move where
+- What code changes are needed (package renames, base class fixes, missing annotations)
+- Risk assessment (package renames breaking imports, decompiled artifacts, key conflicts)
+
+**Step 3: Execute and validate**
+
+After approval:
+- Creates the Maven multi-module directory structure
+- Moves and repackages Java files
+- Fixes structural issues (wrong base class, missing `@RuleInfo`, etc.)
+- Generates `module.json` with all rule registrations
+- Generates build scripts, POMs, `.gitignore`
+- Generates test skeletons for untested rules
+- Runs `/fluent-module-validate` to verify structure
+- Attempts a Maven build to verify compilation
+- Cross-references against deployed rules
+
+**Supports these input types:**
+- Decompiled JAR output (`.decompiled/` directories)
+- Loose Java files (no build system)
+- Non-standard Maven projects
+- Gradle projects (converted to Maven)
+- Existing modules with structural issues (repair mode)
+
+---
+
+## What Happens Behind the Scenes
+
+When you ask your AI assistant to perform these tasks, it doesn't just generate text — it **executes real operations** against your Fluent environment:
+
+| Layer | What it does |
+|-------|-------------|
+| **AI Skills** (knowledge layer) | Teach the AI *how* to do Fluent tasks — patterns, decision trees, best practices |
+| **MCP Extension Server** (execution layer) | 36 tools for real API operations — GraphQL queries, event dispatch, metrics, batch ingestion |
+| **Official MCP Server** (CLI layer) | Workflow listing, downloading, GraphQL validation via the Fluent CLI |
+| **Fluent Commerce API** (platform) | The actual REST/GraphQL endpoints being called |
+
+The AI plans its approach, calls the right tools in the right order, handles errors, and reports results — all through natural conversation.
+
+---
+
+## Evidence and Confidence
+
+Analysis outputs include confidence levels based on available evidence:
+
+| Evidence available | Confidence | What you get |
+|---|---|---|
+| Workflow JSON + `plugin.list` only | LOW-MEDIUM | Structure is accurate; rule behavior is inferred from descriptions |
+| + Decompiled JAR (bytecode) | MEDIUM-HIGH | Implementation logic visible but variable names may be synthetic |
+| + Original source code | HIGH | Full logic, test coverage, and prop validation |
+| + Runtime evidence (real entity trace) | HIGHEST | Static analysis validated against actual execution |
+
+When evidence is incomplete, the AI flags it explicitly and recommends how to get higher confidence (provide source, run a test entity, etc.).
+
+---
+
+## Known Limitations
+
+| Capability | Status | Workaround |
+|-----------|--------|-----------|
+| Refactor loose source into module format | **Supported** via `/fluent-source-onboard` | Analyzes, plans, restructures, validates, and builds in one flow (see Scenario 11) |
+| Live log tailing / real-time event streaming | Not supported | Use `event.list` with time filters for polling |
+| Multi-retailer operations in single command | Not supported | Switch retailer context between operations |
+
+---
+
+## Further Reading
+
+- [README.md](../README.md) — Installation, setup, CLI reference
+- [DEV_WORKFLOW.md](DEV_WORKFLOW.md) — Full development lifecycle with all phases
+- [CAPABILITY_MAP.md](CAPABILITY_MAP.md) — Skill ownership and routing rules
+- [FLOW_RUN.md](FLOW_RUN.md) — Diagnostics and deployment flow details
+- [CLI_COVERAGE.md](CLI_COVERAGE.md) — Fluent CLI command coverage matrix

package/metadata.json

@@ -0,0 +1,156 @@
+{
+  "version": "0.0.1",
+  "organization": "Fluent Commerce",
+  "date": "February 2026",
+  "package": "@fluentcommerce/ai-skills",
+  "abstract": "Fluent Commerce skill packs with modular groups for CLI operations, official MCP core, MCP extension tools, Ready For Launch assessments, and development lifecycle automation.",
+  "groups": {
+    "cli": {
+      "name": "Fluent CLI",
+      "path": "content/cli",
+      "description": "Profile management, module deployment, workflow operations, and account bootstrap",
+      "agents": [
+        "fluent-cli.md",
+        "fluent-cli"
+      ],
+      "skills": [
+        "fluent-cli-reference",
+        "fluent-cli-index",
+        "fluent-cli-mcp-cicd",
+        "fluent-bootstrap",
+        "fluent-cli-retailer",
+        "fluent-cli-settings",
+        "fluent-module-deploy",
+        "fluent-profile",
+        "fluent-workflow",
+        "fluent-connect"
+      ],
+      "commands": [
+        "/fluent-cli-reference",
+        "/fluent-cli-index",
+        "/fluent-cli-mcp-cicd",
+        "/fluent-bootstrap",
+        "/fluent-cli-retailer",
+        "/fluent-cli-settings",
+        "/fluent-module-deploy",
+        "/fluent-profile",
+        "/fluent-workflow",
+        "/fluent-connect"
+      ]
+    },
+    "mcp-official": {
+      "name": "Fluent MCP Official",
+      "path": "content/mcp-official",
+      "description": "Official Fluent CLI MCP server setup, profile context checks, and core MCP diagnostics",
+      "agents": [
+        "fluent-mcp-core.md"
+      ],
+      "skills": [
+        "fluent-mcp-core"
+      ],
+      "commands": [
+        "/fluent-mcp-core"
+      ]
+    },
+    "mcp-extn": {
+      "name": "Fluent MCP Extension",
+      "path": "content/mcp-extn",
+      "description": "Event dispatch, GraphQL operations, batch ingestion, and webhook validation via MCP extension server",
+      "agents": [
+        "fluent-mcp.md"
+      ],
+      "skills": [
+        "fluent-mcp-tools"
+      ],
+      "commands": [
+        "/fluent-mcp-tools"
+      ]
+    },
+    "rfl": {
+      "name": "Fluent RFL",
+      "path": "content/rfl",
+      "description": "Ready For Launch assessments - workflow analysis, rules review, configuration audit",
+      "agents": [
+        "fluent-rfl.md"
+      ],
+      "skills": [
+        "fluent-rfl-assess"
+      ],
+      "commands": [
+        "/fluent-rfl-assess"
+      ]
+    },
+    "dev": {
+      "name": "Fluent Dev",
+      "path": "content/dev",
+      "description": "Development lifecycle - workflow building, custom code analysis, rule scaffolding, module builds, event tracing, and E2E testing",
+      "agents": [
+        "fluent-dev.md",
+        "fluent-dev"
+      ],
+      "skills": [
+        "fluent-workflow-builder",
+        "fluent-workflow-analyzer",
+        "fluent-workflow-deploy",
+        "fluent-custom-code",
+        "fluent-transition-api",
+        "fluent-rule-scaffold",
+        "fluent-module-validate",
+        "fluent-module-scaffold",
+        "fluent-data-module-scaffold",
+        "fluent-build",
+        "fluent-trace",
+        "fluent-event-api",
+        "fluent-system-monitoring",
+        "fluent-e2e-test",
+        "fluent-test-data",
+        "fluent-settings",
+        "fluent-retailer-config",
+        "fluent-connection-analysis",
+        "fluent-job-batch",
+        "fluent-session-summary",
+        "fluent-scope-decompose",
+        "fluent-version-manage",
+        "fluent-pre-deploy-check",
+        "fluent-session-audit-export",
+        "fluent-feature-explain",
+        "fluent-feature-plan",
+        "fluent-source-onboard",
+        "fluent-mermaid-validate"
+      ],
+      "commands": [
+        "/fluent-workflow-builder",
+        "/fluent-workflow-analyzer",
+        "/fluent-workflow-deploy",
+        "/fluent-custom-code",
+        "/fluent-transition-api",
+        "/fluent-rule-scaffold",
+        "/fluent-module-validate",
+        "/fluent-module-scaffold",
+        "/fluent-data-module-scaffold",
+        "/fluent-build",
+        "/fluent-trace",
+        "/fluent-event-api",
+        "/fluent-system-monitoring",
+        "/fluent-e2e-test",
+        "/fluent-test-data",
+        "/fluent-settings",
+        "/fluent-retailer-config",
+        "/fluent-connection-analysis",
+        "/fluent-job-batch",
+        "/fluent-session-summary",
+        "/fluent-scope-decompose",
+        "/fluent-version-manage",
+        "/fluent-pre-deploy-check",
+        "/fluent-session-audit-export",
+        "/fluent-feature-explain",
+        "/fluent-feature-plan",
+        "/fluent-source-onboard"
+      ]
+    }
+  },
+  "references": [
+    "https://docs.fluentcommerce.com",
+    "https://docs.fluentcommerce.com/docs/cli-overview"
+  ]
+}