Default Pipeline Guide¶

This guide catalogs all five default pipelines, explains when to choose default over enterprise, and specifies the attribution contract that flows through default artifacts.

Overview¶

RaiSE ships two skillsets:

Skillset	Ceremony	When to use
Default	≤40% of enterprise	Fast turnaround, AI-consumer artifacts, known scope
Enterprise	Full	Human reviewers, compliance, governance audit trail required

Default-skillset pipelines share the same engine as enterprise pipelines (same pipeline_start / pipeline_advance MCP tools, same SQLite run tracking), but they execute a reduced phase set. The governance trail (story.md, scope.md, plan.md, artifacts in SQLite) is always produced — default means fewer ceremony phases, not fewer artifacts.

When you run rai pipeline start bugfix (or any pipeline without a -enterprise suffix), the engine selects the default skillset automatically. No flag needed.

Use /rai-pipeline-run as the orchestrator for all five default-skillset pipelines. It dispatches phases as forked agents and never reads work files directly.

The 5 Default Pipelines¶

bugfix¶

Purpose: Diagnose, fix, and close a bug in a single default cycle.

Phases: start → diagnose → fix → verify → close

Opción A vs B: - Opción A (AI-only implement): diagnose + fix phases run as forked agents. Opción A directive injected at fix phase. - Opción B (human fix): developer edits the fix directly; skill wraps with scope + commit.

When to use: Bugs with known root cause, no cross-cutting concerns, fix fits in a single PR. Choose enterprise bugfix-enterprise pipeline when the bug is production-critical (incident route), requires a post-incident review, or touches three or more subsystems.

story¶

Purpose: Deliver a feature story with minimal ceremony — plan → implement → close.

Phases: start → plan → implement → verify → close

Opción A vs B: - Opción A (AI-only implement): implement phase runs as a forked agent with an Opción A directive prompt. The orchestrator injects pipeline={pipeline}, phase=implement attribution. - Opción B (human implement): developer implements; skill wraps with tasks, commit, and gate check.

When to use: Stories ≤ S (≤4 tasks), all tasks are SDET-ready, scope is fully known. Choose enterprise story-enterprise pipeline when the story requires a design document reviewed by a human, touches an ADR, or is part of a compliance-sensitive initiative.

spike¶

Purpose: Time-box a research spike and emit a verdict artifact.

Phases: start → research → close

Opción A vs B: - Opción A: research phase runs as a forked agent using rai-spike-journal skill. - Opción B: developer journals the spike; skill closes with verdict emission.

When to use: Spikes with a clear question, ≤2 days timeboxed, verdict is a go/no-go or a concrete recommendation. Choose enterprise spike-enterprise when the research will feed an ADR or requires cross-team review.

epic¶

Purpose: Initialize and close a default epic (logical container) without the full enterprise epic ceremony.

Phases: start → close

Opción A vs B: - Opción A: both phases run as forked agents with minimal context. - Opción B: human drives epic direction; skill handles tracking only.

When to use: Small epics (3–5 stories) with fully mapped scope, no new ADRs, no cross-team coordination required. Choose enterprise epic-enterprise pipeline when the epic introduces a new architectural component, requires PMO sign-off, or spans multiple release milestones.

initiative¶

Purpose: Open and close a default initiative (Theme → Initiative container) tracking a strategic objective.

Phases: start → design → close

Opción A vs B: - Opción A: design phase runs as forked agent using portfolio context from raise_graph_context. - Opción B: human designs initiative scope; skill handles Jira initiative creation + tracking.

When to use: Initiatives within an established theme, scope fits one release cycle, no new capability pillars. Choose enterprise initiative-enterprise pipeline when the initiative requires stakeholder alignment review, involves capacity planning, or introduces a new theme.

Selection Heuristics¶

Use this decision tree to choose default vs enterprise skillset for each work type:

1. Is the scope fully known?          No  → enterprise
2. Does it need human review gates?   Yes → enterprise
3. Does it touch a compliance ADR?    Yes → enterprise
4. Is ceremony ≤40% needed?           No  → enterprise
5. All checks above → default

Examples by work type¶

Work type	Default when	Enterprise when
Bugfix	Root cause clear, single subsystem	Incident/production, post-incident review needed
Story	≤4 tasks, SDET-ready, no new ADR	Design doc needed, human reviewer, compliance
Spike	Clear question, ≤2d timebox	ADR input, cross-team review required
Epic	3–5 stories, no new components	New architecture, cross-team, multi-release
Initiative	One release cycle, established theme	New theme, capacity planning, stakeholder gates

Attribution Contract¶

Every default pipeline phase emits attribution through two mechanisms:

1. Signal emission (automatic)¶

Skills emit rai signal emit-work on phase start and complete. The orchestrator (rai-pipeline-run) injects pipeline, phase, skill, and issue_id into each phase signal automatically. No manual signal emission is needed in skill code.

2. Outcome block (required in work artifacts)¶

Every default phase must close with a fenced outcome: YAML block written into the work artifact (story.md, bugfix.md, spike.md, etc.). This block is the machine-readable record of what the phase produced.

ADR-135 format — every default artifact must use the ### Human / ### Machine split:

### Human

Plain-language summary written by the developer or AI agent. Explains what was done,
decisions taken, and blockers encountered.

### Machine

```yaml
outcome:
  verdict: pass          # pass | fail | blocked
  route: review          # next phase or route hint
  blocked_reason: null   # free text or null
  phase: implement       # which phase produced this block
  pipeline: story        # which pipeline was running
  skill: rai-story-implement  # which skill ran
  issue_id: RAISE-XXXXX  # Jira key

**verdict values:**
- `pass` — phase completed successfully; pipeline advances
- `fail` — phase detected a defect; pipeline retries or halts
- `blocked` — phase cannot proceed; escalate to human

**route values** depend on pipeline type:
- bugfix: `close`, `verify`, `fix`
- story: `close`, `review`, `implement`
- spike: `close`, `escalate`
- epic: `close`
- initiative: `close`, `design`

### 3. Engine auto-injection

When a skill runs inside a default pipeline, `rai-pipeline-run` auto-injects:
- `pipeline` = pipeline name (e.g. `story`)
- `phase` = current phase id (e.g. `implement`)
- `skill` = skill name (e.g. `rai-story-implement`)
- `issue_id` = Jira key (e.g. `RAISE-14772`)

These values are available in the phase prompt as template variables. Skills do not need to derive them — they are injected by the orchestrator.

---

## Switching to Enterprise Skillset

Enterprise skills ship under the `-enterprise` suffix (e.g., `rai-bugfix-start-enterprise`, `rai-story-start-enterprise`). A named skillset manifest packages all 8 enterprise variants so they can be discovered as a unit.

### Available skillsets

| Skillset | Skills | When to use |
|----------|--------|-------------|
| **default** | rai-bugfix-start/fix/close, rai-story-start/close, rai-epic-start/design/close | AI-consumer artifacts, known scope, no human reviewer |
| **enterprise** | rai-bugfix-start/fix/close-enterprise, rai-story-start/close-enterprise, rai-epic-start/design/close-enterprise | Human review gates, compliance audit trail, ADR-gated decisions |

### Installing the enterprise skillset

The enterprise skillset manifest lives at `.raise/skillsets/enterprise.yaml`. To activate enterprise skills, copy them into your active skill set using `rai skill set create`:

```bash
# Create a new skill set seeded from builtins (includes all enterprise skills)
rai skill set create enterprise

# Verify the skills are present
rai skill list | grep enterprise

Note: rai skill set install enterprise is not yet implemented — only create, list, and diff exist (see rai skill set --help). The manifest file at .raise/skillsets/enterprise.yaml is the authoritative list of enterprise skills. A future install subcommand will activate skillset manifests in one step (tracked separately).

When to use enterprise¶

Use the enterprise skillset when any of the following apply:

Human review gates required — story or epic needs sign-off before advancing phases
Compliance audit trail — regulated environment (SOC 2, ISO 27001, EU AI Act traceability)
ADR documentation — the work introduces or amends an Architecture Decision Record
Post-incident review — production incident requiring a formal PIR artifact
Cross-team coordination — multiple teams or stakeholders must approve before close

Use the default skillset for everything else. Default is not "less rigorous" — it produces the same governance artifacts (story.md, scope.md, plan.md, SQLite run record) with fewer manual checkpoints.

Cross-references¶

Orchestrator skill: /rai-pipeline-run (dispatches all 5 default-skillset pipelines)
Enterprise skillset manifest: .raise/skillsets/enterprise.yaml
ADR-134: Lean Methodology — ceremony reduction rules
ADR-135: Human + Machine artifact format
ADR-136: Attribution contract design in progress (not yet approved/committed)
Pipeline quickstart: See rai pipeline start --help and rai skill list for available pipelines
Customizing pipelines: Phases are defined in .raise/pipelines/ YAML files; edit there to add or remove phases