Pr Implement

# Executable spec for the /pr-implement skill — fork-based OSS contribution (driving-adapter).
# /pr-implement executes a contribution plan on a fork branch with a MANDATORY isolation check
# before and during implementation, keeping the PR clean and scoped. Hexagon: driving-adapter;
# consumes crank; produces git-changes; customer-of crank. (soc-qk4b)

Feature: PR-implement executes a scoped contribution on a fork with isolation
  As the fork-based OSS implementation step
  I want a contribution plan executed on a fork branch under isolation checks
  So that the resulting PR is clean, focused, and free of unrelated changes

  Scenario: a contribution plan is implemented on a fork branch
    Given a plan artifact from /plan (after /pr-research) or a repo URL
    When /pr-implement runs
    Then it produces the code changes on a fork branch

  Scenario: the isolation check is mandatory before and during
    When /pr-implement implements the change
    Then it runs an isolation check before and during implementation
    And changes outside the contribution's scope are kept out of the PR

  Scenario: the output stays focused
    When implementation completes
    Then the fork branch contains only the scoped contribution, not unrelated edits


#!/bin/bash
# Validate pr-implement skill
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"

ERRORS=0
CHECKS=0

check_pattern() {
    local desc="$1"
    local file="$2"
    local pattern="$3"

    CHECKS=$((CHECKS + 1))
    if grep -qiE "$pattern" "$file" 2>/dev/null; then
        echo "✓ $desc"
    else
        echo "✗ $desc (pattern '$pattern' not found in $file)"
        ERRORS=$((ERRORS + 1))
    fi
}

echo "=== PR Implement Skill Validation ==="
echo ""

check_pattern "SKILL.md has isolation pre-check" "$SKILL_DIR/SKILL.md" "[Ii]solation[[:space:]]+[Pp]re-[Cc]heck"
check_pattern "SKILL.md has isolation post-check" "$SKILL_DIR/SKILL.md" "[Ii]solation[[:space:]]+[Pp]ost-[Cc]heck"
check_pattern "SKILL.md has implementation phase" "$SKILL_DIR/SKILL.md" "Phase[[:space:]]+[0-9]+:?[[:space:]]+[Ii]mplementation"
check_pattern "SKILL.md has Examples section" "$SKILL_DIR/SKILL.md" "^## Examples"
check_pattern "SKILL.md has Troubleshooting section" "$SKILL_DIR/SKILL.md" "^## Troubleshooting"

echo ""
echo "=== Results ==="
echo "Checks: $CHECKS"
echo "Errors: $ERRORS"

if [ $ERRORS -gt 0 ]; then
    echo ""
    echo "FAIL: pr-implement skill validation failed"
    exit 1
else
    echo ""
    echo "PASS: pr-implement skill validation passed"
    exit 0
fi


---
name: pr-implement
description: Implement a scoped OSS PR.
practices:
- continuous-delivery
- xp
- pragmatic-programmer
hexagonal_role: driving-adapter
consumes:
- crank
produces:
- git-changes
context_rel:
- kind: customer-of
  with: crank
skill_api_version: 1
context:
  window: fork
  intent:
    mode: task
  sections:
    exclude:
    - HISTORY
  intel_scope: topic
license: MIT
compatibility: Requires git, gh CLI
metadata:
  author: AI Platform Team
  version: 1.0.0
  tier: contribute
  internal: false
allowed-tools: Read, Write, Edit, Bash, Grep, Glob
output_contract: code changes on fork branch
---
# PR Implement Skill

Fork-based implementation for open source contributions with mandatory isolation check.

## Overview

Execute a contribution plan with fork isolation. Ensures PRs are clean
and focused by running isolation checks before and during implementation.

**Input**: Plan artifact from `$plan` (after `$pr-research`) or repo URL

**When to Use**:
- Implementing a planned OSS contribution
- Need isolation enforcement for clean PRs
- After completing `$pr-research` and `$plan`

**When NOT to Use**:
- Internal project work (use `$implement`)
- Haven't planned yet (run `$pr-research` then `$plan` first)

---

## Workflow

```
-1. Prior Work Check      -> BLOCKING: Check for competing PRs
0.  Input Discovery       -> Find plan artifact or repo
1.  Fork Setup