Skillweave Releasechain

---
facade: true
experimental: true
name: skillweave-releasechain
description: "Validate, version, package, sign, and publish immutable release artifacts through binary release gates."
argument-hint: inputs="[JSON with prd/tasks]" target="[humanize/machinize/mixed]" mode="[simple/manual/attended/overnight]" risk_mode="[conservative/medium/unicorn]"
---

# /skillweave-releasechain

**Validate, version, package, sign, and publish immutable release artifacts.**

ReleaseChain receives completed build outputs from `skillweave-promptchain-execute` and produces publishable, verifiable release artifacts. It validates readiness, bumps versions, generates changelogs, packages distributions, signs artifacts, and gates each step on binary pass/fail checks.

Execution (Ralph Loop, lane scheduling, batch planning) belongs to `skillweave-promptchain-execute`. Deployment and go-live belong to `skillweave-launch`.

## 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:
```yaml
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

Invoke the skill by its name with arguments. The skill is
host-neutral; no executable prefix is required — route it through any host on
any supported transport (Markdown or MCP).

```
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 receives completed build outputs from `skillweave-promptchain-execute` and produces immutable release artifacts. It does NOT execute build tasks, manage Ralph Loops, or deploy to environments. See `.skillweave/release/skill-boundaries.yaml`.

## 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:

```python
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

```python
# 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
```python
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.



## Release Pipeline

ReleaseChain produces versioned, signed release artifacts. It does not execute build tasks.

### 1. Readiness Assessment

Before any release step, assess whether the build is ready:
- All tests pass (see `_step_verify_tests`)
- Required artifacts exist
- Changelog is current
- Version has been bumped

### 2. Packaging

Build distributable artifacts:
- Python: `python3 -m build` (sdist + wheel)
- Capacium integration for artifact integrity

### 3. Release Notes

Generate changelog entries and release notes:
- Parse `CHANGELOG.md`
- Enforce naming convention: `SkillWeave vX.Y.Z`

### 4. Artifact Signing and Publishing

Sign and publish immutable release artifacts:
- Sign artifacts with Capacium
- Publish to package registry
- Gate each step on binary pass/fail

### 5. Release Gates

Each step is gated:
- `PROMOTE`: step passed, advance to next
- `HOLD`: non-critical issue, record and continue
- `BLOCK`: critical failure, stop the release

## Version Control — Git Flow for Releases

ReleaseChain manages the `dev → main` merge path and tag creation.

**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 |

**Merge flow (enforced by releasechain):**
```
feature/FEAT-001-auth  →  PR to dev  →  PR to main  →  tag vX.Y.Z
```
- The `dev → main` PR is the release PR — requires integration tests, changelog, version bump
- Tag on `main`: Created by releasechain after merge

**Configuration** in `.skillweave/config.yaml`:
```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
```

## Release Naming Convention

Release titles 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. Block release creation if violated.

## Workflow with Execute and Launch

ReleaseChain receives completed build outputs from `skillweave-promptchain-execute` and produces immutable release artifacts.

| Phase | Skill | Responsibility |
|-------|-------|---------------|
| Build / Execute | `skillweave-promptchain-execute` | Lane scheduling, Ralph Loop, batch execution |
| Release | `skillweave-releasechain` | Validate, version, package, sign, publish |
| Launch | `skillweave-launch` | Deploy artifact, communicate, observe go-live |

## Safety Features

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