skillweave-releasechain

name	skillweave-releasechain
description	Ralph Loop-powered development pipeline for autonomous AI development. Handles review, testing, iteration with completion promises, memory systems, and multi-agent execution.
argument-hint	inputs="[JSON with prd/tasks]" target="[humanize/machinize/mixed]" mode="[simple/manual/attended/overnight]" risk_mode="[conservative/medium/unicorn]"

/skillweave-releasechain

Ralph Loop-powered autonomous development pipeline.
Execute PRD tasks with completion promises, memory systems, and multi-agent coordination for overnight builds.

Mandatory Pre-Flight: SkillWeave Sandboxing

Before generating any output, you MUST verify and enforce the SkillWeave sandbox. This applies to every skill invocation without exception:

1. Enforce .skillweave/ Directory Structure

If .skillweave/ does not exist in the project root, create it:

.skillweave/
.skillweave/tracking-log/
.skillweave/templates/
.skillweave/sequences/

2. Route All Outputs Into .skillweave/

All release plans, task lists, completion promises, memory snapshots, and execution logs MUST be saved exclusively within .skillweave/ or its sub-folders. Never dump artifacts into the repository root.

3. Git Isolation

Check .gitignore — if .skillweave/ is not listed, append it. AI-generated pipeline files are excluded from source control.

4. Default Config

If .skillweave/config.yaml does not exist, create it with:

mode: medium
checklist: true
design_thinking: true
community_knowhow: true
modular_templates: true

Proceed with core skill logic only AFTER these four criteria are met.

Usage:

/skillweave-releasechain inputs="[JSON with prd/tasks]" target="[humanize/machinize/mixed]" mode="[manual/attended/overnight]"

Parameters:

• inputs (required): JSON containing PRD (prd.json) and task list, or direct build outputs
• target (optional): Target audience - humanize (human readable), machinize (machine optimized), mixed (default: mixed)
• mode (optional): Execution mode - simple (REX-style), manual (Level 1), attended (Level 2), overnight (Level 3) (default: attended)
• risk_mode (optional): conservative, medium, unicorn - overrides environment variable and config files
• repo_path (optional): Path to git repository (default: current directory)
• max_iterations (optional): Maximum iterations for Ralph Loop (default: 30)
• completion_promise (optional): Completion promise format (default: SkillWeave standard)
• auto_confirm (optional): Automatically confirm safe operations (default: false)

Skill Boundaries: This skill handles the Release lifecycle phase (order 5). It does NOT handle orchestration (promptchain-execute) or launch/rollout (launch skill). See .skillweave/release/skill-boundaries.yaml.

Ralph Loop Pipeline Architecture:

Next Level Features

Intelligent Guidance (v0.5.5)

SkillWeave v0.5.5 introduces intelligent prompt analysis and onboarding flows that help ensure you're using the right skill with the right parameters.

How It Works

When this skill is invoked, you should first use the SkillIntegrationHelper to analyze the user's prompt and validate the request:

from skillweave.intelligent_detection import integrate_with_skill
import os

# Determine project root (current directory or parent containing .skillweave/)
project_root = os.getcwd()
if not os.path.exists(os.path.join(project_root, ".skillweave")):
    # Try parent directory
    parent = os.path.dirname(project_root)
    if os.path.exists(os.path.join(parent, ".skillweave")):
        project_root = parent

result = integrate_with_skill(
    user_prompt=user_prompt,  # The original user prompt
    current_skill="skillweave-releasechain",  # This skill's name
    project_root=project_root
)

Handling the Result

The integrate_with_skill function returns a dictionary with an action key:

1. action: "proceed" - Skill selection is appropriate, parameters are valid

   • Continue with normal skill execution
   • Use result["validated_parameters"] for parameter values
   • Apply result["mode_override"] if present (risk mode from CLI/env)

2. action: "gather_parameters" - Missing or invalid parameters detected

   • Show result["missing_parameters"] to the user
   • Ask for each missing parameter using result["parameter_prompts"]
   • Use interactive Q&A to gather all required information
   • After gathering, re-run integrate_with_skill with updated parameters

3. action: "switch_skill" - Different skill might be more appropriate

   • Consider switching to result["recommended_skill"]
   • Show explanation: result["switch_reason"]
   • Ask user for confirmation before switching
   • If confirmed, load the recommended skill instead

4. action: "onboarding_flow" - User needs guided onboarding

   • Follow the interactive onboarding flow
   • Use result["onboarding_steps"] for guidance
   • Gather information step by step
   • Complete onboarding before skill execution

Benefits

• Skill Validation: Ensures this skill is appropriate for the task
• Parameter Completeness: Checks all required parameters are provided
• Intelligent Routing: Suggests better-suited skills when applicable
• Guided Onboarding: Helps new users through step-by-step setup
• Learning System: Improves recommendations based on user feedback

Integration with Existing Features

The intelligent guidance system works alongside existing Next Level features:

• Respects risk mode overrides from CLI, environment, or config
• Uses the same project root and configuration
• Integrates with checklist tracking and design thinking
• Maintains backward compatibility

Example Workflow

# 1. Analyze user prompt
result = integrate_with_skill(user_prompt, "skillweave-blueprint", project_root)

# 2. Handle result
if result["action"] == "proceed":
    # Extract validated parameters
    params = result["validated_parameters"]
    # Apply risk mode override if present
    if "mode_override" in result:
        set_risk_mode(result["mode_override"])
    # Execute skill with validated parameters
    execute_skill(params)
    
elif result["action"] == "gather_parameters":
    # Interactive parameter gathering
    for param in result["missing_parameters"]:
        prompt = result["parameter_prompts"].get(param, f"Enter value for {param}:")
        value = ask_user(prompt)
        # Update parameters and re-validate
        # (In practice, you'd collect all then re-validate)
        
elif result["action"] == "switch_skill":
    # Suggest skill switch
    if confirm_switch(result["recommended_skill"], result["switch_reason"]):
        load_skill(result["recommended_skill"])

Always use intelligent guidance when executing this skill to provide the best user experience and ensure successful outcomes.

SkillWeave Next Level provides advanced capabilities that can enhance the release chain pipeline. These features are controlled by .skillweave/config.yaml and can be accessed via the SkillWeaveNextLevel class.

Risk Mode Integration

SkillWeave v0.5.5 introduces a hierarchical override system for risk mode. The effective risk mode is determined by the following precedence order (highest to lowest):

1. CLI parameter: risk_mode="conservative/medium/unicorn" (if provided)
2. Environment variable: SKILLWEAVE_RISK_MODE (if set)
3. Project config: .skillweave/config.yaml mode setting
4. Global config: ~/.skillweave/config.yaml mode setting
5. Default: medium

Use the RiskModeResolver class from skillweave.risk_mode_resolver to resolve the effective risk mode programmatically.

Command-line utilities:

• skillweave-risk-mode - shows effective risk mode given current context. Use skillweave-risk-mode --cli-risk-mode=conservative --verbose to see precedence resolution.
• skillweave-interactive-mode - interactive risk mode selection with project analysis and persistence options (temporary, project config, global config).

Adjust pipeline behavior according to the effective risk mode:

• Conservative: Extra validation, explicit approvals, strict safety checks, detailed memory logs
• Medium: Balanced approach with standard validation
• Unicorn: Optimistic assumptions, minimal confirmations, maximum speed, concise outputs

Checklist-Based Execution

If checklist: true is set in the config, the skill will:

• Parse markdown checklists (- [ ] and - [x]) from PRD inputs
• Track checklist item completion across pipeline iterations using .skillweave/tracking-log/
• Loop until all checklist items are marked complete
• Provide progress reports and remaining items

Design-Thinking Lens

If design_thinking: true is set in the config, apply these cognitive ergonomics principles to pipeline outputs:

1. Value ≥ Noise: Ensure every pipeline output provides clear user value
2. Scan Before Read: Structure progress reports for quick scanning with clear headings
3. Hierarchy of Needs: Address functional needs before advanced features
4. Progressive Disclosure: Reveal complexity gradually as needed
5. Recognition Over Recall: Use consistent patterns and familiar formats
6. Error Tolerance: Design for mistakes with clear recovery paths

Community Know-How

If community_knowhow: true is set, the skill will:

• Extract patterns from .skillweave/tracking-log/ across projects
• Provide repository cleanup recommendations based on common issues
• Suggest optimizations and best practices from community patterns

Modular Templates

If modular_templates: true is set, the skill can:

• Load and combine templates from .skillweave/templates/ for pipeline stages
• Use template inheritance for consistent pipeline structures
• Generate custom pipeline sections from reusable components

Using Next Level Features

from skillweave.next_level import SkillWeaveNextLevel

# Initialize with project root
next_level = SkillWeaveNextLevel("/path/to/project")

# Check feature availability
if next_level.is_checklist_enabled():
    checklist = next_level.parse_checklist(markdown_content)
    # Track progress, loop until completion

if next_level.is_design_thinking_enabled():
    lens = next_level.get_design_thinking_lens()
    lens.apply_to_output(your_content)

# Access other features similarly

Adjust your pipeline execution based on enabled features to provide enhanced results while maintaining backward compatibility.

Core Components

1. Completion Promise System

   • Standardized completion signaling: <skillweave-complete>
   • Verification before promise issuance
   • Multi-agent compatible format
   • Automatic loop termination on success

2. Memory System

   • Short-term: progress-structured.yaml - Iteration tracking
   • Long-term: agents-enhanced.md - Knowledge accumulation
   • Cross-project: Organization-wide pattern sharing
   • Structured format for AI readability

3. Task Execution Engine

   • Atomic task execution (one iteration per task)
   • Dependency-aware scheduling
   • Multi-agent routing based on capabilities
   • Automatic retry with learning

4. Verification Feedback Loops

   • Multi-level verification (code, functional, system, business)
   • Automated testing integration
   • Quality gates before task completion
   • Continuous improvement from failures

Agent-Agnostic Execution

ReleaseChain is agent-agnostic – it works with any AI coding agent, not just specific ones. Instead of hardcoding agent names, it uses capability-based routing:

1. Capability Definitions: Tasks specify required capabilities (planning, code_generation, testing, review, etc.)
2. Agent Registry: Available agents declare their capabilities at runtime
3. Intelligent Routing: Tasks are routed to agents that best match required capabilities
4. Fallback Strategies: Automatic fallback if preferred agents are unavailable

Capability Mapping Examples:

• planning: Strategic thinking, architecture design
• code_generation: Writing and modifying code
• testing: Creating and running tests
• review: Code review and quality assessment
• research: Information gathering and analysis
• automation: Scripting and workflow automation
• infrastructure: System setup and configuration

Benefits:

• Future-Proof: Works with new agents as they emerge
• Flexible: Can use different agents for different tasks
• Resilient: Continues working even if specific agents are unavailable
• Optimized: Routes tasks to best-suited agents automatically

Execution Levels

Level 0: Simple (REX-style)

• Direct execution for 1-3 simple tasks
• Plan → Implement → Review workflow
• Minimal memory system (basic progress tracking)
• Quick feedback loop with optional revisions
• Best for: Quick fixes, small features, proofs of concept

Level 1: Manual (Learning)

• Single task execution with observation
• Manual verification and approval
• Agent behavior understanding
• Task sizing validation

Level 2: Attended (Confidence)

• Multiple tasks in sequence
• Periodic human check-ins
• Semi-automated verification
• Error recovery testing

Level 3: Overnight (Production)

• Full autonomous execution
• Comprehensive verification
• Notification system
• Morning review process

Simple Mode (REX-style) Workflow

For simple tasks (1-3 tasks, <60 minutes), ReleaseChain uses a streamlined workflow:

1. Task Analysis → 2. Planning → 3. Implementation → 4. Review → 5. Completion
       ↑                                                              ↓
       └─────────────────── Revision Loop ────────────────────────────┘

Components:

• Planning: Quick analysis and implementation plan
• Implementation: Direct execution with agent best suited for task
• Review: Automated verification + optional human review
• Revision: Loop back if issues found (max 2 revisions)

Memory System: Basic progress tracking (progress-simple.txt) Verification: Lightweight checks (type checking, basic tests) Output: Human-readable summary with machine-readable status

Pipeline Stages with Ralph Loop Integration

1. PRD & Task Analysis

   • Load and validate prd.json
   • Build dependency graph
   • Identify parallel execution opportunities
   • Route tasks to appropriate agents

2. Ralph Loop Execution

   • Iteration Cycle: Task → Implementation → Verification → Promise
   • Memory Updates: progress-structured.yaml after each iteration
   • Learning Capture: agents-enhanced.md for patterns
   • Completion Check: All tasks passes: true

3. Multi-Agent Coordination

   • Agent capability matching
   • Parallel task execution
   • Resource management
   • Fallback strategies

4. Verification & Quality Gates

   • Code Level: Type checking, linting, static analysis
   • Functional Level: Unit tests, integration tests
   • System Level: E2E tests, performance tests
   • Business Level: Acceptance criteria validation

5. Version Control Integration — Git Flow

   • Atomic commits per successful task
   • Descriptive commit messages
   • Tag creation for milestones
   • Git Flow enforcement (see below)

   Branch Model:

   Branch	Purpose	Protected
   main	Release-ready, tagged with vX.Y.Z	Yes — no direct commits
   dev	Integration branch, CI must be green	Yes — only via PR
   feature/<id>-<slug>	New functionality, branched from dev	No
   fix/<id>-<slug>	Bug fixes, branched from dev	No
   chore/<slug>	Maintenance, docs, CI changes	No

   Preflight checks before any commit:

   1. Does dev exist? If not, recommend creating it from main.
   2. Is the current branch main? Warn and recommend branching.
   3. Is there an existing branch for this task? Offer to continue on it.
   4. Is dev up to date with main? Recommend rebase/merge if behind.

   Merge flow (enforced by releasechain):

   feature/FEAT-001-auth  →  PR to dev  →  PR to main  →  tag vX.Y.Z
   

   • Feature branch → dev: After build gates pass, tests green. Create PR.
   • dev → main: Release PR. Requires integration tests, changelog, version bump.
   • Tag on main: After merge, created by releasechain or launch skill.

   Configuration in .skillweave/config.yaml:

   git_flow:
     enabled: true
     branches:
       production: main
       integration: dev
     branch_prefix:
       feature: feature/
       fix: fix/
       chore: chore/
     require_pr: true
     auto_create_dev: false
   

   If git_flow.enabled is false or missing, skip enforcement but still warn on direct main commits.

6. Collaboration & Review

   • Automated PR creation (feature → dev, then dev → main for releases)
   • Code review facilitation
   • Change documentation
   • Stakeholder notification

7. Release Management

   • Semantic versioning
   • Changelog generation
   • Release note creation
   • Asset packaging
   • Release naming convention (enforced): Title must be exactly SkillWeave vX.Y.Z — no additional text. Regex: ^SkillWeave v[0-9]+\.[0-9]+\.[0-9]+$. Descriptive text goes into release notes body only. Block release creation if convention is violated.
   • Release merge path (enforced): Release PRs merge dev → main, never feature branches directly to main. Tag vX.Y.Z is created on main after merge.

8. Deployment Readiness

   • Build artifact creation
   • Environment configuration
   • Rollback planning
   • Monitoring setup

Output Adaptation:

• Humanize: Progress reports, executive summaries, documentation, human-readable completion reports
• Machinize: Structured data (YAML/JSON), API responses, automation scripts, machine-readable status
• Mixed: Combined human and machine outputs with clear separation, ideal for CI/CD integration

Ralph Loop Pattern Support:

1. Feature Builder: Complete feature development from PRD
2. Test-Until-Green: Automated test coverage improvement
3. Multi-Persona Review: Comprehensive code quality review
4. Proof of Concept Validator: Rapid prototyping and validation
5. Infrastructure as Code: Automated infrastructure setup

Integration with SkillWeave Workflow:

Complete development chain: Blueprint → PromptChain → ReleaseChain

1. Blueprint Integration: Uses prd.json from /skillweave-blueprint
2. PromptChain Integration: Executes sequences from /skillweave-promptchain-execute
3. Execute Skill Integration: Called automatically for build components with parallel execution
4. Standalone Mode: Direct PRD execution without intermediate steps

Examples:

Complete PRD Execution (Overnight Mode):

/skillweave-releasechain inputs='{"prd": "prd.json"}' mode="overnight" max_iterations=50

Runs full PRD overnight, emails completion report in morning

Attended Development (Level 2):

/skillweave-releasechain inputs='{"tasks": ["API-001", "UI-001", "TEST-001"]}' mode="attended" target="mixed"

Executes specific tasks with human checkpoints

Test-Until-Green Pattern:

/skillweave-releasechain inputs='{"pattern": "test-until-green", "coverage_target": 80}' mode="attended"

Improves test coverage to target percentage

Multi-Persona Review:

/skillweave-releasechain inputs='{"pattern": "multi-persona-review", "cycles": 2}' mode="manual"

Comprehensive code review with security, performance, accessibility personas

Simple Mode (REX-style) Execution:

/skillweave-releasechain inputs='{"tasks": ["BUG-001"]}' mode="simple" target="humanize"

Quick bug fix with plan-implement-review workflow, minimal overhead

From Blueprint Output:

# After creating blueprint
/skillweave-blueprint idea="Task management API" domain="saas"
# Then execute PRD
/skillweave-releasechain inputs='{"prd": "generated/prd.json"}' mode="attended"

Integration with Execute Skill:

# Execute skill runs parallel execution
/skillweave-promptchain-execute sequence="..." inputs="..."
# When build work completes successfully, execute skill
# hands off to releasechain for release-phase tasks.
# See: .skillweave/release/skill-boundaries.yaml

Safety Features:

• Confirmation required for destructive operations
• Dry-run mode available
• Rollback capability
• Audit logging
• Configuration validation