/swe-feature-onboard              # Full interactive wizard
/swe-feature-onboard MYAPP        # Start with key pre-filled
/swe-feature-onboard MYAPP --quick # Quick mode (30 sec, minimal)

Quick Mode vs Full Mode

Aspect	Quick Mode	Full Mode
Time	~30 sec	2-5 min
Swarm analysis	No	Optional (10 agents)
DOM_* memories	No	Yes (if domains found)
SYS_* memories	No	Yes (if systems found)
Layer detection	Basic	Detailed
Best for	Small features, prototyping	Large codebases

Stage 1: Basic Info

Use AskUserQuestion for feature information (skip if provided via args):

AskUserQuestion({
  questions: [
    {
      question: "What is the Feature Key? (Short identifier used in memory names, e.g., BACKEND, AUTH, BLOCKS)",
      header: "Feature Key",
      options: [
        { label: "BACKEND", description: "For backend/API features" },
        { label: "FRONTEND", description: "For UI/client features" },
        { label: "AUTH", description: "For authentication features" }
      ],
      multiSelect: false
    },
    {
      question: "What type of codebase is this feature?",
      header: "Type",
      options: [
        { label: "web_app", description: "Web application" },
        { label: "wordpress_theme", description: "WordPress theme" },
        { label: "wordpress_plugin", description: "WordPress plugin" },
        { label: "api", description: "API/Backend service" }
      ],
      multiSelect: false
    }
  ]
})

Then ask for paths:

AskUserQuestion({
  questions: [
    {
      question: "Where is the code located? (Root path for this feature)",
      header: "Root Path",
      options: [
        { label: "src/", description: "Standard source directory" },
        { label: "wp-content/themes/", description: "WordPress themes" },
        { label: "wp-content/plugins/", description: "WordPress plugins" }
      ],
      multiSelect: false
    }
  ]
})

Validation:

Key: UPPERCASE, underscores allowed, 2-20 chars
Path: Must exist in project

Stage 2: Tech Stack

Use AskUserQuestion for technology selection:

AskUserQuestion({
  questions: [
    {
      question: "What is the primary programming language?",
      header: "Language",
      options: [
        { label: "php", description: "PHP (WordPress, Laravel, etc.)" },
        { label: "typescript", description: "TypeScript/JavaScript" },
        { label: "python", description: "Python" }
      ],
      multiSelect: false
    },
    {
      question: "What framework is used (if any)?",
      header: "Framework",
      options: [
        { label: "wordpress", description: "WordPress CMS" },
        { label: "react", description: "React.js" },
        { label: "nextjs", description: "Next.js" },
        { label: "none", description: "No framework / vanilla" }
      ],
      multiSelect: false
    }
  ]
})

Auto-detection: Scan root path for:

package.json → Node/TypeScript
composer.json → PHP
Cargo.toml → Rust
go.mod → Go
style.css with Theme Name: → WordPress theme

Stage 3: Analysis Mode

Skip in quick mode - go directly to Stage 5.

Use AskUserQuestion for analysis mode selection:

AskUserQuestion({
  questions: [
    {
      question: "How should I analyze the codebase?",
      header: "Analysis",
      options: [
        {
          label: "Full DAA Swarm (Recommended)",
          description: "10 agents analyze in parallel, creates DOM_*/SYS_* memories (2-5 min)"
        },
        {
          label: "Quick Scan",
          description: "Basic directory structure and layer detection (~30 sec)"
        },
        {
          label: "Manual Configuration",
          description: "You describe the architecture, I create memories from your input"
        }
      ],
      multiSelect: false
    }
  ]
})

If "Full DAA Swarm" selected:

⚠️ MANDATORY: Load swarm coordination context first:

mcp__plugin_swe_serena__read_memory("feature/FEATURE_SWARM")

This loads swarm patterns, agent definitions, and coordination protocols needed for DAA orchestration. Without it, swarm agents lack the project's coordination standards.

mcp__ruv-swarm__daa_init({ enableLearning: true })

mcp__ruv-swarm__task_orchestrate({
  task: "Analyze feature architecture",
  agents: [
    "config-analyzer",    // Parse config files
    "architecture-mapper", // Detect layers
    "pattern-detector",   // Find conventions
    "domain-extractor",   // Extract domains
    "system-finder",      // Identify systems
    "test-analyzer",      // Test patterns
    "import-tracer",      // Dependency graph
    "convention-learner", // Style detection
    "file-indexer",       // File inventory
    "synthesizer"         // Compile results
  ],
  context: { featureKey: "[KEY]", rootPath: "[PATH]" }
})

Stage 4: Architecture Confirmation

Skip in quick mode.

Present detected architecture and confirm with AskUserQuestion:

// First, display the detected architecture in text:
// "I detected the following architecture for [FEATURE_NAME]:
//  Layers: [table]
//  Data Flow: [diagram]
//  Dependencies: [list]"

AskUserQuestion({
  questions: [
    {
      question: "Is the detected architecture correct?",
      header: "Confirm",
      options: [
        {
          label: "Yes, correct",
          description: "Proceed with memory creation using this architecture"
        },
        {
          label: "No, needs changes",
          description: "I'll provide corrections to the architecture"
        },
        {
          label: "Start over",
          description: "Re-run analysis with different settings"
        }
      ],
      multiSelect: false
    }
  ]
})

If user selects "No, needs changes", gather corrections manually.

Stage 5: Memory Creation

Create FEATURE_[KEY].md

# FEATURE_[KEY] - [Name]

## Feature Overview

| Property      | Value                 |
| ------------- | --------------------- |
| **Name**      | [Feature Name]        |
| **Key**       | [KEY]                 |
| **Type**      | [type]                |
| **Language**  | [language]            |
| **Framework** | [framework or "none"] |

## Scope Definition

### Primary Directories

| Directory | Purpose   |
| --------- | --------- |
| [dir]     | [purpose] |

## Architecture Layers

[ASCII diagram or table of layers]

## Key Files

| File   | Purpose   |
| ------ | --------- |
| [file] | [purpose] |

## Related Memories

| Memory        | Content           |
| ------------- | ----------------- |
| dom/DOM_[KEY]_*   | Domain behaviors  |
| sys/SYS_[KEY]_*   | System references |
| index/INDEX_[KEY]_* | Indexes           |

## Testing

| Suite   | File   | Focus   |
| ------- | ------ | ------- |
| [suite] | [file] | [focus] |

Create via Serena:

mcp__plugin_swe_serena__write_memory("FEATURE_[KEY]", "<content>")

Additional memories (full mode only):

If domains detected:

mcp__plugin_swe_serena__write_memory("dom/DOM_[KEY]_[DOMAIN]", "<content>")

If systems detected:

mcp__plugin_swe_serena__write_memory("sys/SYS_[KEY]_[SYSTEM]", "<content>")

Stage 6: Symbol Index (Related Docs)

After creating FEATURE_[KEY] and any DOM__/SYS__ memories, generate the Related Docs table.

Invoke the /swe-symbol-index skill:

/swe-symbol-index [KEY]

This will:

Read all linked memories listed in FEATURE_[KEY]'s Related Memories section
Extract heading symbols from each via get_symbols_overview
Build a summary table and insert it as ## Related Docs after Feature Overview

Skip if no Related Memories were created (e.g., quick mode with no DOM__/SYS__).

Stage 7: Index Update

Update INDEX_FEATURES.md:

mcp__plugin_swe_serena__edit_memory(
  "INDEX_FEATURES",
  "## Registered Features",
  "## Registered Features\n\n| [KEY] | [Name] | [Type] | [Language] | Active |",
  "literal"
)

Skill Return

## Skill Return

- **Skill**: swe-feature-onboard
- **Status**: success
- **Feature Key**: [KEY]
- **Mode**: [full|quick]
- **Memories Created**: FEATURE_[KEY], [DOM__, SYS__ if applicable]
- **Next Step Hint**: [WF_SWARM_ORCHESTRATE if DAA swarm was used, WF_START otherwise]

Routing after onboarding:

If DAA swarm analysis was used → WF_SWARM_ORCHESTRATE (swarm context is already loaded)
If quick mode or manual → WF_START (normal entry)

Exit

> **Skill /swe-feature-onboard complete** - Feature [KEY] registered

Troubleshooting

Swarm MCP unavailable

Fall back to quick mode or manual configuration.

Path doesn't exist

ls -la [path]

Ask user to correct.

INDEX_FEATURES.md missing

Create it first:

mcp__plugin_swe_serena__write_memory("INDEX_FEATURES", "# INDEX_FEATURES\n\n## Registered Features\n\n| Key | Name | Type | Language | Status |\n|-----|------|------|----------|--------|\n")

swe-feature-onboard

⚠️ WORKFLOW INITIALIZATION

/swe-feature-onboard [KEY] [--quick]

Usage