github-release-management

Simple Release Flow

```bash

# Plan and create a release

gh release create v2.0.0 \

--draft \

--generate-notes \

--title "Release v2.0.0"

# Orchestrate with swarm

npx claude-flow github release-create \

--version "2.0.0" \

--build-artifacts \

--deploy-targets "npm,docker,github"

```

Full Automated Release

```bash

# Initialize release swarm

npx claude-flow swarm init --topology hierarchical

# Execute complete release pipeline

npx claude-flow sparc pipeline "Release v2.0.0 with full validation"

```

---

1. Release Planning & Version Management

• Semantic version analysis and suggestion
• Breaking change detection from commits
• Release timeline generation
• Multi-package version coordination

2. Automated Testing & Validation

• Multi-stage test orchestration
• Cross-platform compatibility testing
• Performance regression detection
• Security vulnerability scanning

3. Build & Deployment Orchestration

• Multi-platform build coordination
• Parallel artifact generation
• Progressive deployment strategies
• Automated rollback mechanisms

4. Documentation & Communication

• Automated changelog generation
• Release notes with categorization
• Migration guide creation
• Stakeholder notification

---

Essential Release Commands

#### Create Release Draft

```bash

# Get last release tag

LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')

# Generate changelog from commits

CHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \

--jq '.commits[].commit.message')

# Create draft release

gh release create v2.0.0 \

--draft \

--title "Release v2.0.0" \

--notes "$CHANGELOG" \

--target main

```

#### Basic Version Bump

```bash

# Update package.json version

npm version patch # or minor, major

# Push version tag

git push --follow-tags

```

#### Simple Deployment

```bash

# Build and publish npm package

npm run build

npm publish

# Create GitHub release

gh release create $(npm pkg get version) \

--generate-notes

```

Quick Integration Example

```javascript

// Simple release preparation in Claude Code

[Single Message]:

// Update version files

Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })

// Generate changelog

Bash("gh api repos/:owner/:repo/compare/v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")

// Create release branch

Bash("git checkout -b release/v2.0.0")

Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")

// Create PR

Bash("gh pr create --title 'Release v2.0.0' --body 'Automated release preparation'")

```

---

AI Swarm Release Orchestration

#### Initialize Release Swarm

```javascript

// Set up coordinated release team

[Single Message - Swarm Initialization]:

mcp__claude-flow__swarm_init {

topology: "hierarchical",

maxAgents: 6,

strategy: "balanced"

}

// Spawn specialized agents

mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }

mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }

mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }

mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }

mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }

mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }

```

#### Coordinated Release Workflow

```javascript

[Single Message - Full Release Coordination]:

// Create release branch

Bash("gh api repos/:owner/:repo/git/refs --method POST -f ref='refs/heads/release/v2.0.0' -f sha=$(gh api repos/:owner/:repo/git/refs/heads/main --jq '.object.sha')")

// Orchestrate release preparation

mcp__claude-flow__task_orchestrate {

task: "Prepare release v2.0.0 with comprehensive testing and validation",

strategy: "sequential",

priority: "critical",

maxAgents: 6

}

// Update all release files

Write("package.json", "[updated version]")

Write("CHANGELOG.md", "[release changelog]")

Write("RELEASE_NOTES.md", "[detailed notes]")

// Run comprehensive validation

Bash("npm install && npm test && npm run lint && npm run build")

// Create release PR

Bash(`gh pr create \

--title "Release v2.0.0: Feature Set and Improvements" \

--head "release/v2.0.0" \

--base "main" \

--body "$(cat RELEASE_NOTES.md)"`)

// Track progress

TodoWrite { todos: [

{ content: "Prepare release branch", status: "completed", priority: "critical" },

{ content: "Run validation suite", status: "completed", priority: "high" },

{ content: "Create release PR", status: "completed", priority: "high" },

{ content: "Code review approval", status: "pending", priority: "high" },

{ content: "Merge and deploy", status: "pending", priority: "critical" }

]}

// Store release state

mcp__claude-flow__memory_usage {

action: "store",

key: "release/v2.0.0/status",

value: JSON.stringify({

version: "2.0.0",

stage: "validation_complete",

timestamp: Date.now(),

ready_for_review: true

})

}

```

Release Agent Specializations

#### Changelog Agent

```bash

# Get merged PRs between versions

PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \

--jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")

# Get commit history

COMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \

--jq '.commits[].commit.message')

# Generate categorized changelog

npx claude-flow github changelog \

--prs "$PRS" \

--commits "$COMMITS" \

--from v1.0.0 \

--to HEAD \

--categorize \

--add-migration-guide

```

Capabilities:

• Semantic commit analysis
• Breaking change detection
• Contributor attribution
• Migration guide generation
• Multi-language support

#### Version Agent

```bash

# Intelligent version suggestion

npx claude-flow github version-suggest \

--current v1.2.3 \

--analyze-commits \

--check-compatibility \

--suggest-pre-release

```

Logic:

• Analyzes commit messages and PR labels
• Detects breaking changes via keywords
• Suggests appropriate version bump
• Handles pre-release versioning
• Validates version constraints

#### Build Agent

```bash

# Multi-platform build coordination

npx claude-flow github release-build \

--platforms "linux,macos,windows" \

--architectures "x64,arm64" \

--parallel \

--optimize-size

```

Features:

• Cross-platform compilation
• Parallel build execution
• Artifact optimization and compression
• Dependency bundling
• Build caching and reuse

#### Test Agent

```bash

# Comprehensive pre-release testing

npx claude-flow github release-test \

--suites "unit,integration,e2e,performance" \

--environments "node:16,node:18,node:20" \

--fail-fast false \

--generate-report

```

#### Deploy Agent

```bash

# Multi-target deployment orchestration

npx claude-flow github release-deploy \

--targets "npm,docker,github,s3" \

--staged-rollout \

--monitor-metrics \

--auto-rollback

```

---

Multi-Package Release Coordination

#### Monorepo Release Strategy

```javascript

[Single Message - Multi-Package Release]:

// Initialize mesh topology for cross-package coordination

mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 8 }

// Spawn package-specific agents

Task("Package A Manager", "Coordinate claude-flow package release v1.0.72", "coder")

Task("Package B Manager", "Coordinate ruv-swarm package release v1.0.12", "coder")

Task("Integration Tester", "Validate cross-package compatibility", "tester")

Task("Version Coordinator", "Align dependencies and versions", "coordinator")

// Update all packages simultaneously

Write("packages/claude-flow/package.json", "[v1.0.72 content]")

Write("packages/ruv-swarm/package.json", "[v1.0.12 content]")

Write("CHANGELOG.md", "[consolidated changelog]")

// Run cross-package validation

Bash("cd packages/claude-flow && npm install && npm test")

Bash("cd packages/ruv-swarm && npm install && npm test")

Bash("npm run test:integration")

// Create unified release PR

Bash(`gh pr create \

--title "Release: claude-flow v1.0.72, ruv-swarm v1.0.12" \

--body "Multi-package coordinated release with cross-compatibility validation"`)

```

Progressive Deployment Strategy

#### Staged Rollout Configuration

```yaml

# .github/release-deployment.yml

deployment:

strategy: progressive

stages:

- name: canary

percentage: 5

duration: 1h

metrics:

- error-rate < 0.1%

- latency-p99 < 200ms

auto-advance: true

- name: partial

percentage: 25

duration: 4h

validation: automated-tests

approval: qa-team

- name: rollout

percentage: 50

duration: 8h

monitor: true

- name: full

percentage: 100

approval: release-manager

rollback-enabled: true

```

#### Execute Staged Deployment

```bash

# Deploy with progressive rollout

npx claude-flow github release-deploy \

--version v2.0.0 \

--strategy progressive \

--config .github/release-deployment.yml \

--monitor-metrics \

--auto-rollback-on-error

```

Multi-Repository Coordination

#### Coordinated Multi-Repo Release

```bash

# Synchronize releases across repositories

npx claude-flow github multi-release \

--repos "frontend:v2.0.0,backend:v2.1.0,cli:v1.5.0" \

--ensure-compatibility \

--atomic-release \

--synchronized \

--rollback-all-on-failure

```

#### Cross-Repo Dependency Management

```javascript

[Single Message - Cross-Repo Release]:

// Initialize star topology for centralized coordination

mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }

// Spawn repo-specific coordinators

Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")

Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")

Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")

Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")

// Coordinate version updates across repos

Bash("gh api repos/org/frontend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")

Bash("gh api repos/org/backend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")

Bash("gh api repos/org/cli/dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")

// Monitor all releases

mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }

```

Hotfix Emergency Procedures

#### Emergency Hotfix Workflow

```bash

# Fast-track critical bug fix

npx claude-flow github emergency-release \

--issue 789 \

--severity critical \

--target-version v1.2.4 \

--cherry-pick-commits \

--bypass-checks security-only \

--fast-track \

--notify-all

```

#### Automated Hotfix Process

```javascript

[Single Message - Emergency Hotfix]:

// Create hotfix branch from last stable release

Bash("git checkout -b hotfix/v1.2.4 v1.2.3")

// Cherry-pick critical fixes

Bash("git cherry-pick abc123def")

// Fast validation

Bash("npm run test:critical && npm run build")

// Create emergency release

Bash(`gh release create v1.2.4 \

--title "HOTFIX v1.2.4: Critical Security Patch" \

--notes "Emergency release addressing CVE-2024-XXXX" \

--prerelease=false`)

// Immediate deployment

Bash("npm publish --tag hotfix")

// Notify stakeholders

Bash(`gh issue create \

--title "🚨 HOTFIX v1.2.4 Deployed" \

--body "Critical security patch deployed. Please update immediately." \

--label "critical,security,hotfix"`)

```

---

Release Configuration Management

#### Comprehensive Release Config

```yaml

# .github/release-swarm.yml

version: 2.0.0

release:

versioning:

strategy: semantic

breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]

feature-keywords: ["feat", "feature"]

fix-keywords: ["fix", "bugfix"]

changelog:

sections:

- title: "🚀 Features"

labels: ["feature", "enhancement"]

emoji: true

- title: "🐛 Bug Fixes"

labels: ["bug", "fix"]

- title: "💥 Breaking Changes"

labels: ["breaking"]

highlight: true

- title: "📚 Documentation"

labels: ["docs", "documentation"]

- title: "⚡ Performance"

labels: ["performance", "optimization"]

- title: "🔒 Security"

labels: ["security"]

priority: critical

artifacts:

- name: npm-package

build: npm run build

test: npm run test:all

publish: npm publish

registry: https://registry.npmjs.org

- name: docker-image

build: docker build -t app:$VERSION .

test: docker run app:$VERSION npm test

publish: docker push app:$VERSION

platforms: [linux/amd64, linux/arm64]

- name: binaries

build: ./scripts/build-binaries.sh

platforms: [linux, macos, windows]

architectures: [x64, arm64]

upload: github-release

sign: true

validation:

pre-release:

- lint: npm run lint

- typecheck: npm run typecheck

- unit-tests: npm run test:unit

- integration-tests: npm run test:integration

- security-scan: npm audit

- license-check: npm run license-check

post-release:

- smoke-tests: npm run test:smoke

- deployment-validation: ./scripts/validate-deployment.sh

- performance-baseline: npm run benchmark

deployment:

environments:

- name: staging

auto-deploy: true

validation: npm run test:e2e

approval: false

- name: production

auto-deploy: false

approval-required: true

approvers: ["release-manager", "tech-lead"]

rollback-enabled: true

health-checks:

- endpoint: /health

expected: 200

timeout: 30s

monitoring:

metrics:

- error-rate: <1%

- latency-p95: <500ms

- availability: >99.9%

- memory-usage: <80%

alerts:

- type: slack

channel: releases

on: [deploy, rollback, error]

- type: email

recipients: ["team@company.com"]

on: [critical-error, rollback]

- type: pagerduty

service: production-releases

on: [critical-error]

rollback:

auto-rollback:

triggers:

- error-rate > 5%

- latency-p99 > 2000ms

- availability < 99%

grace-period: 5m

manual-rollback:

preserve-data: true

notify-users: true

create-incident: true

```

Advanced Testing Strategies

#### Comprehensive Validation Suite

```bash

# Pre-release validation with all checks

npx claude-flow github release-validate \

--checks "

version-conflicts,

dependency-compatibility,

api-breaking-changes,

security-vulnerabilities,

performance-regression,

documentation-completeness,

license-compliance,

backwards-compatibility

" \

--block-on-failure \

--generate-report \

--upload-results

```

#### Backward Compatibility Testing

```bash

# Test against previous versions

npx claude-flow github compat-test \

--previous-versions "v1.0,v1.1,v1.2" \

--api-contracts \

--data-migrations \

--integration-tests \

--generate-report

```

#### Performance Regression Detection

```bash

# Benchmark against baseline

npx claude-flow github performance-test \

--baseline v1.9.0 \

--candidate v2.0.0 \

--metrics "throughput,latency,memory,cpu" \

--threshold 5% \

--fail-on-regression

```

Release Monitoring & Analytics

#### Real-Time Release Monitoring

```bash

# Monitor release health post-deployment

npx claude-flow github release-monitor \

--version v2.0.0 \

--metrics "error-rate,latency,throughput,adoption" \

--alert-thresholds \

--duration 24h \

--export-dashboard

```

#### Release Analytics & Insights

```bash

# Analyze release performance and adoption

npx claude-flow github release-analytics \

--version v2.0.0 \

--compare-with v1.9.0 \

--metrics "adoption,performance,stability,feedback" \

--generate-insights \

--export-report

```

#### Automated Rollback Configuration

```bash

# Configure intelligent auto-rollback

npx claude-flow github rollback-config \

--triggers '{

"error-rate": ">5%",

"latency-p99": ">1000ms",

"availability": "<99.9%",

"failed-health-checks": ">3"

}' \

--grace-period 5m \

--notify-on-rollback \

--preserve-metrics

```

Security & Compliance

#### Security Scanning

```bash

# Comprehensive security validation

npx claude-flow github release-security \

--scan-dependencies \

--check-secrets \

--audit-permissions \

--sign-artifacts \

--sbom-generation \

--vulnerability-report

```

#### Compliance Validation

```bash

# Ensure regulatory compliance

npx claude-flow github release-compliance \

--standards "SOC2,GDPR,HIPAA" \

--license-audit \

--data-governance \

--audit-trail \

--generate-attestation

```

---

Complete Release Workflow

```yaml

# .github/workflows/release.yml

name: Intelligent Release Workflow

on:

push:

tags: ['v*']

jobs:

release-orchestration:

runs-on: ubuntu-latest

permissions:

contents: write

packages: write

issues: write

steps:

- name: Checkout Repository

uses: actions/checkout@v3

with:

fetch-depth: 0

- name: Setup Node.js

uses: actions/setup-node@v3

with:

node-version: '20'

cache: 'npm'

- name: Authenticate GitHub CLI

run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token

- name: Initialize Release Swarm

run: |

# Extract version from tag

RELEASE_TAG=${{ github.ref_name }}

PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')

# Get merged PRs for changelog

PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \

--jq ".[] | select(.mergedAt > \"$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)\")")

# Get commit history

COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \

--jq '.commits[].commit.message')

# Initialize swarm coordination

npx claude-flow@alpha swarm init --topology hierarchical

# Store release context

echo "$PRS" > /tmp/release-prs.json

echo "$COMMITS" > /tmp/release-commits.txt

- name: Generate Release Changelog

run: |

# Generate intelligent changelog

CHANGELOG=$(npx claude-flow@alpha github changelog \

--prs "$(cat /tmp/release-prs.json)" \

--commits "$(cat /tmp/release-commits.txt)" \

--from $PREV_TAG \

--to $RELEASE_TAG \

--categorize \

--add-migration-guide \

--format markdown)

echo "$CHANGELOG" > RELEASE_CHANGELOG.md

- name: Build Release Artifacts

run: |

# Install dependencies

npm ci

# Run comprehensive validation

npm run lint

npm run typecheck

npm run test:all

npm run build

# Build platform-specific binaries

npx claude-flow@alpha github release-build \

--platforms "linux,macos,windows" \

--architectures "x64,arm64" \

--parallel

- name: Security Scan

run: |

# Run security validation

npm audit --audit-level=moderate

npx claude-flow@alpha github release-security \

--scan-dependencies \

--check-secrets \

--sign-artifacts

- name: Create GitHub Release

run: |

# Update release with generated changelog

gh release edit ${{ github.ref_name }} \

--notes "$(cat RELEASE_CHANGELOG.md)" \

--draft=false

# Upload all artifacts

for file in dist/*; do

gh release upload ${{ github.ref_name }} "$file"

done

- name: Deploy to Package Registries

run: |

# Publish to npm

echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc

npm publish

# Build and push Docker images

docker build -t ${{ github.repository }}:${{ github.ref_name }} .

docker push ${{ github.repository }}:${{ github.ref_name }}

- name: Post-Release Validation

run: |

# Run smoke tests

npm run test:smoke

# Validate deployment

npx claude-flow@alpha github release-validate \

--version ${{ github.ref_name }} \

--smoke-tests \

--health-checks

- name: Create Release Announcement

run: |

# Create announcement issue

gh issue create \

--title "🎉 Released ${{ github.ref_name }}" \

--body "$(cat RELEASE_CHANGELOG.md)" \

--label "announcement,release"

# Notify via discussion

gh api repos/${{ github.repository }}/discussions \

--method POST \

-f title="Release ${{ github.ref_name }} Now Available" \

-f body="$(cat RELEASE_CHANGELOG.md)" \

-f category_id="$(gh api repos/${{ github.repository }}/discussions/categories --jq '.[] | select(.slug=="announcements") | .id')"

- name: Monitor Release

run: |

# Start release monitoring

npx claude-flow@alpha github release-monitor \

--version ${{ github.ref_name }} \

--duration 1h \

--alert-on-errors &

```

Hotfix Workflow

```yaml

# .github/workflows/hotfix.yml

name: Emergency Hotfix Workflow

on:

issues:

types: [labeled]

jobs:

emergency-hotfix:

if: contains(github.event.issue.labels.*.name, 'critical-hotfix')

runs-on: ubuntu-latest

steps:

- name: Create Hotfix Branch

run: |

LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')

HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')

git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE

- name: Fast-Track Testing

run: |

npm ci

npm run test:critical

npm run build

- name: Emergency Release

run: |

npx claude-flow@alpha github emergency-release \

--issue ${{ github.event.issue.number }} \

--severity critical \

--fast-track \

--notify-all

```

---

Release Planning Guidelines

#### 1. Regular Release Cadence

• Weekly: Patch releases with bug fixes
• Bi-weekly: Minor releases with features
• Quarterly: Major releases with breaking changes
• On-demand: Hotfixes for critical issues

#### 2. Feature Freeze Strategy

• Code freeze 3 days before release
• Only critical bug fixes allowed
• Beta testing period for major releases
• Stakeholder communication plan

#### 3. Version Management Rules

• Strict semantic versioning compliance
• Breaking changes only in major versions
• Deprecation warnings one minor version ahead
• Cross-package version synchronization

Automation Recommendations

#### 1. Comprehensive CI/CD Pipeline

• Automated testing at every stage
• Security scanning before release
• Performance benchmarking
• Documentation generation

#### 2. Progressive Deployment

• Canary releases for early detection
• Staged rollouts with monitoring
• Automated health checks
• Quick rollback mechanisms

#### 3. Monitoring & Observability

• Real-time error tracking
• Performance metrics collection
• User adoption analytics
• Feedback collection automation

Documentation Standards

#### 1. Changelog Requirements

• Categorized changes by type
• Breaking changes highlighted
• Migration guides for major versions
• Contributor attribution

#### 2. Release Notes Content

• High-level feature summaries
• Detailed technical changes
• Upgrade instructions
• Known issues and limitations

#### 3. API Documentation

• Automated API doc generation
• Example code updates
• Deprecation notices
• Version compatibility matrix

---

Issue: Failed Release Build

```bash

# Debug build failures

npx claude-flow@alpha diagnostic-run \

--component build \

--verbose

# Retry with isolated environment

docker run --rm -v $(pwd):/app node:20 \

bash -c "cd /app && npm ci && npm run build"

```

Issue: Test Failures in CI

```bash

# Run tests with detailed output

npm run test -- --verbose --coverage

# Check for environment-specific issues

npm run test:ci

# Compare local vs CI environment

npx claude-flow@alpha github compat-test \

--environments "local,ci" \

--compare

```

Issue: Deployment Rollback Needed

```bash

# Immediate rollback to previous version

npx claude-flow@alpha github rollback \

--to-version v1.9.9 \

--reason "Critical bug in v2.0.0" \

--preserve-data \

--notify-users

# Investigate rollback cause

npx claude-flow@alpha github release-analytics \

--version v2.0.0 \

--identify-issues

```

Issue: Version Conflicts

```bash

# Check and resolve version conflicts

npx claude-flow@alpha github release-validate \

--checks version-conflicts \

--auto-resolve

# Align multi-package versions

npx claude-flow@alpha github version-sync \

--packages "package-a,package-b" \

--strategy semantic

```

---

Expected Performance

• Release Planning: < 2 minutes
• Build Process: 3-8 minutes (varies by project)
• Test Execution: 5-15 minutes
• Deployment: 2-5 minutes per target
• Complete Pipeline: 15-30 minutes

Optimization Tips

1. Parallel Execution: Use swarm coordination for concurrent tasks
2. Caching: Enable build and dependency caching
3. Incremental Builds: Only rebuild changed components
4. Test Optimization: Run critical tests first, full suite in parallel

Success Metrics

• Release Frequency: Target weekly minor releases
• Lead Time: < 2 hours from commit to production
• Failure Rate: < 2% of releases require rollback
• MTTR: < 30 minutes for critical hotfixes

---

Documentation

• [GitHub CLI Documentation](https://cli.github.com/manual/)
• [Semantic Versioning Spec](https://semver.org/)
• [Claude Flow SPARC Guide](../../docs/sparc-methodology.md)
• [Swarm Coordination Patterns](../../docs/swarm-patterns.md)

Related Skills

• github-pr-management: PR review and merge automation
• github-workflow-automation: CI/CD workflow orchestration
• multi-repo-coordination: Cross-repository synchronization
• deployment-orchestration: Advanced deployment strategies

Support & Community

• Issues: https://github.com/ruvnet/claude-flow/issues
• Discussions: https://github.com/ruvnet/claude-flow/discussions
• Documentation: https://claude-flow.dev/docs

---

Pre-Release Checklist

• [ ] Version numbers updated across all packages
• [ ] Changelog generated and reviewed
• [ ] Breaking changes documented with migration guide
• [ ] All tests passing (unit, integration, e2e)
• [ ] Security scan completed with no critical issues
• [ ] Performance benchmarks within acceptable range
• [ ] Documentation updated (API docs, README, examples)
• [ ] Release notes drafted and reviewed
• [ ] Stakeholders notified of upcoming release
• [ ] Deployment plan reviewed and approved

Release Checklist

• [ ] Release branch created and validated
• [ ] CI/CD pipeline completed successfully
• [ ] Artifacts built and verified
• [ ] GitHub release created with proper notes
• [ ] Packages published to registries
• [ ] Docker images pushed to container registry
• [ ] Deployment to staging successful
• [ ] Smoke tests passing in staging
• [ ] Production deployment completed
• [ ] Health checks passing

Post-Release Checklist

• [ ] Release announcement published
• [ ] Monitoring dashboards reviewed
• [ ] Error rates within normal range
• [ ] Performance metrics stable
• [ ] User feedback collected
• [ ] Documentation links verified
• [ ] Release retrospective scheduled
• [ ] Next release planning initiated

---

Version: 2.0.0

Last Updated: 2025-10-19

Maintained By: Claude Flow Team