diff --git a/.claude/00_START_HERE.md b/.claude/00_START_HERE.md
new file mode 100644
index 0000000000..accee92b48
--- /dev/null
+++ b/.claude/00_START_HERE.md
@@ -0,0 +1,7 @@
+# MCO QE Tooling - Start Here
+
+**New to this tooling?** Read [README.md](README.md) - complete guide in one file.
+
+**Quick setup**: Run `./scripts/setup.sh --verify` and follow § Setup in README.
+
+That's it!
diff --git a/.claude/JIRA_INTEGRATION.md b/.claude/JIRA_INTEGRATION.md
new file mode 100644
index 0000000000..1c587291b6
--- /dev/null
+++ b/.claude/JIRA_INTEGRATION.md
@@ -0,0 +1,405 @@
+# Jira Integration Guide
+
+## Overview
+
+Fetch Jira issues from redhat.atlassian.net and use for Polarion TC creation.
+
+**No MCP required** - uses direct Atlassian REST API.
+
+## Setup
+
+### Get Jira API Token
+
+1. Go to: https://id.atlassian.com/manage-profile/security/api-tokens
+2. Create API token
+3. Copy token
+
+### Configure .env
+
+```bash
+# Edit .env at repo root
+JIRA_URL=https://redhat.atlassian.net
+JIRA_EMAIL=you@redhat.com
+JIRA_TOKEN=your_api_token_here
+```
+
+**Note**: Atlassian Cloud requires Basic authentication with email:token credentials.
+
+### Verify
+
+```bash
+python3 .claude/scripts/fetch_jira.py MCO-2221
+```
+
+## Fetch Jira Issue
+
+### Basic Usage
+
+```bash
+python3 .claude/scripts/fetch_jira.py OCPBUGS-74223
+```
+
+**Output**:
+- `/tmp/test-specs/jira/OCPBUGS-74223.json` (draft format)
+- JSON to stdout
+
+### What Gets Fetched
+
+| Field | Jira Source | Draft Field |
+|---|---|---|
+| Summary | issue.fields.summary | title (with [MCO][KEY] prefix) |
+| Description | issue.fields.description | description |
+| Fix Versions | issue.fields.fixVersions[0] | version (X.Y from X.Y.Z) |
+| Acceptance Criteria | customfield_12311140 | metadata.acceptance_criteria |
+| Issue Type | issue.fields.issuetype.name | metadata.jira_type |
+| Labels | issue.fields.labels | metadata.labels |
+
+### Draft Format
+
+```json
+{
+  "title": "[MCO][OCPBUGS-74223] Add support for X feature",
+  "description": "This feature adds support for...",
+  "component": "Machine Config Operator",
+  "sub_team": "MCO",
+  "products": "OCP",
+  "test_type": "Functional",
+  "version": "4.18",
+  "trello_jira": "OCPBUGS-74223",
+  "test_steps": [],
+  "metadata": {
+    "source_jira": "OCPBUGS-74223",
+    "jira_type": "Bug",
+    "labels": ["qe-test-coverage"],
+    "acceptance_criteria": "Verify that feature X works correctly..."
+  }
+}
+```
+
+## Use Cases
+
+### Use Case 1: Jira Only
+
+Create TC from Jira metadata, add steps manually later.
+
+```bash
+# Fetch
+python3 scripts/fetch_jira.py OCPBUGS-74223
+
+# Validate (will warn about empty test_steps)
+python3 scripts/validate_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+
+# Create (empty steps - add later)
+python3 scripts/create_polarion_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+```
+
+**When to use**:
+- Jira has good description and acceptance criteria
+- Test steps not yet defined
+- Want to create TC placeholder early
+
+### Use Case 2: Jira + GitHub PR (Hybrid)
+
+**Best approach** - Jira metadata + GitHub test steps.
+
+```bash
+# Hybrid creation
+python3 scripts/create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691 --comment 4054832254
+```
+
+**Workflow**:
+1. Fetches Jira issue → metadata
+2. Fetches GitHub PR comment → test steps
+3. Merges drafts
+4. Validates
+5. Creates complete TC
+
+**When to use**:
+- Jira has fix versions and acceptance criteria
+- GitHub PR has QE test steps
+- Want accurate metadata + executable steps
+
+### Use Case 3: Manual Draft with Jira Reference
+
+```bash
+# Fetch Jira for reference
+python3 scripts/fetch_jira.py OCPBUGS-74223
+
+# Copy values to manual draft
+cat /tmp/test-specs/jira/OCPBUGS-74223.json | jq '.version, .metadata.acceptance_criteria'
+
+# Create manual draft with copied values
+vim /tmp/test-specs/drafts/my_tc.json
+```
+
+## Hybrid Mode (Jira + PR)
+
+### Why Hybrid?
+
+**Jira strengths**:
+- ✓ Accurate fix versions
+- ✓ Acceptance criteria
+- ✓ Issue type (Bug, Feature, etc.)
+- ✓ Labels
+
+**GitHub PR strengths**:
+- ✓ Executable test steps
+- ✓ Commands with expected output
+- ✓ Environment details
+
+**Hybrid = Best of both**
+
+### Hybrid Workflow
+
+```bash
+python3 scripts/create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691
+```
+
+**Merge logic**:
+- Title: `[MCO][OCPBUGS-74223] <Jira summary>`
+- Version: From Jira fix versions
+- Description: Jira description + acceptance criteria
+- Test steps: From GitHub PR comment
+- Jira ID: From Jira (obviously)
+
+**Output**: `/tmp/test-specs/drafts/OCPBUGS-74223-pr5691.json`
+
+### Example
+
+**Jira OCPBUGS-74223**:
+- Summary: "Add support for feature X"
+- Fix Version: 4.18.0
+- Acceptance Criteria: "Verify X works in Y scenarios"
+- Description: "Feature X allows..."
+
+**GitHub PR 5691 QE Comment**:
+```markdown
+## Test Steps
+
+- Create MachineConfig with feature X
+  ```bash
+  oc create -f mc.yaml
+  ```
+
+- Verify feature X applied
+  ```bash
+  $ oc get mc | grep feature-x
+  feature-x   3.2.0   15s
+  ```
+```
+
+**Merged Draft**:
+```json
+{
+  "title": "[MCO][OCPBUGS-74223] Add support for feature X",
+  "description": "Feature X allows...\n\nAcceptance Criteria:\nVerify X works in Y scenarios",
+  "version": "4.18",
+  "trello_jira": "OCPBUGS-74223",
+  "test_steps": [
+    {
+      "step": "Create MachineConfig with feature X",
+      "expected_result": "oc create -f mc.yaml"
+    },
+    {
+      "step": "Verify feature X applied",
+      "expected_result": "$ oc get mc | grep feature-x\nfeature-x   3.2.0   15s"
+    }
+  ]
+}
+```
+
+## Jira API Details
+
+### Authentication
+
+Uses Atlassian REST API with Bearer token:
+```
+Authorization: Bearer <JIRA_TOKEN>
+```
+
+**Not** Red Hat SSO - this is Atlassian's API token system.
+
+### Endpoint
+
+```
+GET https://redhat.atlassian.net/rest/api/3/issue/{issue-key}
+```
+
+### ADF Format
+
+Jira returns description in ADF (Atlassian Document Format):
+
+```json
+{
+  "type": "doc",
+  "content": [
+    {
+      "type": "paragraph",
+      "content": [
+        {"type": "text", "text": "This is a description"}
+      ]
+    }
+  ]
+}
+```
+
+Script extracts plain text automatically.
+
+### Custom Fields
+
+Acceptance Criteria field name varies by project:
+- Try: `customfield_12311140`
+- Try: `customfield_12315140`
+- Try: `acceptanceCriteria`
+
+Script attempts common field names.
+
+### Fix Versions
+
+Extract X.Y from X.Y.Z:
+- Jira: "4.18.0" → Draft: "4.18"
+- Jira: "4.22" → Draft: "4.22"
+
+## Integration with Other Tools
+
+### With validate_tc.py
+
+```bash
+python3 scripts/fetch_jira.py OCPBUGS-74223
+python3 scripts/validate_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+```
+
+**Expected warnings**:
+- "No test steps defined" (unless using hybrid mode)
+
+### With create_polarion_tc.py
+
+```bash
+python3 scripts/fetch_jira.py OCPBUGS-74223
+python3 scripts/create_polarion_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+```
+
+Creates TC with metadata, empty test steps.
+
+### With update_polarion_tc.py
+
+```bash
+# Create from Jira (empty steps)
+python3 scripts/create_polarion_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+# Returns: OCP-88999
+
+# Add test steps later
+python3 scripts/update_polarion_tc.py OCP-88999 \
+  --steps-file /tmp/test-specs/steps/feature-x.json
+```
+
+## Troubleshooting
+
+### Error: "Authentication failed"
+
+**Fix**:
+```bash
+# Regenerate token at:
+# https://id.atlassian.com/manage-profile/security/api-tokens
+
+# Update .env
+JIRA_TOKEN=new_token_here
+```
+
+### Error: "Jira issue not found"
+
+**Fix**:
+- Verify issue exists: https://redhat.atlassian.net/browse/OCPBUGS-74223
+- Check issue key format: `OCPBUGS-74223` (not `ocpbugs-74223`)
+- Ensure you have access to the issue
+
+### Warning: "Acceptance Criteria: Not Found"
+
+**Not critical** - means the custom field wasn't found.
+
+**Fix**:
+- Check Jira issue has acceptance criteria field
+- Field name may vary by project
+- Can add manually to draft if needed
+
+### Version not found
+
+**Symptom**: `version` field is empty
+
+**Fix**:
+```bash
+# Set manually in draft or during creation
+python3 scripts/update_polarion_tc.py OCP-88999 --version 4.18
+```
+
+## Command Reference
+
+```bash
+# Fetch Jira only
+python3 scripts/fetch_jira.py OCPBUGS-74223
+
+# Hybrid (Jira + PR)
+python3 scripts/create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691
+
+# Via Claude Code
+/mco-create-tc-from-jira https://redhat.atlassian.net/browse/OCPBUGS-74223
+/mco-create-tc-from-pr https://github.com/openshift/machine-config-operator/pull/5691
+```
+
+## Comparison: Sources
+
+| Source | Title/Version | Description | Test Steps |
+|---|---|---|---|
+| GitHub PR only | From PR (extract Jira) | From PR | ✓ From QE comment |
+| Jira only | ✓ From Jira | ✓ From Jira | ✗ Empty |
+| Hybrid (Jira+PR) | ✓ From Jira | ✓ From Jira | ✓ From PR |
+
+**Recommendation**: Use hybrid mode for best results.
+
+## Example Workflow
+
+```bash
+# 1. Find Jira issue
+# https://redhat.atlassian.net/browse/OCPBUGS-74223
+
+# 2. Find PR with QE test
+# https://github.com/openshift/machine-config-operator/pull/5691
+
+# 3. Create hybrid TC
+python3 .claude/scripts/create_tc_hybrid.py OCPBUGS-74223 \
+  --from-pr 5691 \
+  --comment 4054832254
+
+# Output:
+# [1/5] Fetching Jira issue: OCPBUGS-74223...
+#       ✓ Title: [MCO][OCPBUGS-74223] Add support for feature X
+#       ✓ Version: 4.18
+#
+# [2/5] Fetching GitHub PR #5691...
+#       ✓ Test Steps: 5
+#
+# [3/5] Merging Jira + PR data...
+#       ✓ Merged draft: /tmp/test-specs/drafts/OCPBUGS-74223-pr5691.json
+#
+# [4/5] Validating draft...
+#       ✓ Validation passed
+#
+# [5/5] Creating Polarion TC...
+#       ✓ Created: OCP-88999
+#       URL: https://polarion.engineering.redhat.com/polarion/#/project/OSE/workitem?id=OCP-88999
+```
+
+## Limitations
+
+1. **Acceptance Criteria field**: Custom field name varies by project
+2. **ADF parsing**: Complex formatting may not convert perfectly
+3. **Authentication**: Requires Atlassian API token (not Red Hat SSO)
+4. **Access**: Must have access to Jira issue
+
+## Next Steps
+
+After fetching Jira:
+1. Review draft metadata
+2. If missing test steps, use hybrid mode or add manually
+3. Validate and create TC
+4. Verify in Polarion
diff --git a/.claude/PILOT_PR5691.md b/.claude/PILOT_PR5691.md
new file mode 100644
index 0000000000..e514d8d060
--- /dev/null
+++ b/.claude/PILOT_PR5691.md
@@ -0,0 +1,245 @@
+# Pilot Test: PR 5691 → Create Polarion TC
+
+## Objective
+
+Test full workflow: GitHub PR QE comment → validate → create Polarion TC.
+
+**Target PR**: openshift/machine-config-operator#5691  
+**Comment ID**: 4054832254 (QE pre-merge testing)
+
+## Prerequisites
+
+1. POLARION_TOKEN configured in `.env`
+2. GITHUB_TOKEN configured (optional, for rate limits)
+3. Setup verified: `./scripts/setup.sh --verify`
+
+## Workflow Steps
+
+### Step 1: Fetch PR Comment
+
+```bash
+cd .claude
+python3 scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr 5691 \
+  --comment 4054832254
+```
+
+**Expected**:
+- ✓ Draft saved to: `/tmp/test-specs/drafts/pr-5691.json`
+- Title extracted from PR (with `[MCO][JIRA-ID]` prefix if Jira found)
+- Environment parsed (version, platform)
+- Test steps parsed (bullets → step, code → expected_result)
+
+**Verify**:
+```bash
+cat /tmp/test-specs/drafts/pr-5691.json | jq '.title, .trello_jira, .version, (.test_steps | length)'
+```
+
+### Step 2: Validate Draft
+
+```bash
+python3 scripts/validate_tc.py /tmp/test-specs/drafts/pr-5691.json
+```
+
+**Expected**:
+- ✓ VALIDATION PASSED (or specific errors to fix)
+- Title matches `^\[MCO\]\[.+\] .+`
+- All required fields present
+- Test steps have commands (not narrative-only)
+
+**If validation fails**:
+1. Review errors
+2. Edit `/tmp/test-specs/drafts/pr-5691.json`
+3. Re-validate
+4. Do NOT proceed until valid
+
+### Step 3: Review Draft
+
+```bash
+cat /tmp/test-specs/drafts/pr-5691.json | jq '.'
+```
+
+**Check**:
+- [ ] Title: `[MCO][JIRA-ID] ...`
+- [ ] Component: `Machine Config Operator`
+- [ ] Sub Team: `MCO`
+- [ ] Products: `OCP`
+- [ ] Test Type: `Functional` (or appropriate)
+- [ ] Version: (from PR comment or set manually)
+- [ ] Trello/Jira: (from PR title)
+- [ ] Test Steps: Each step has:
+  - Non-empty `step` field
+  - `expected_result` with commands/YAML
+
+### Step 4: Dry Run
+
+```bash
+python3 scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-5691.json --dry-run
+```
+
+**Expected**:
+```
+Validating draft...
+✓ Validation passed
+
+================================================================================
+TEST CASE SUMMARY
+================================================================================
+Title: [MCO][OCPBUGS-xxxxx] ...
+Component: Machine Config Operator
+Sub Team: MCO
+Products: OCP
+Test Type: Functional
+Version: 4.22
+Jira: OCPBUGS-xxxxx
+Test Steps: 5
+================================================================================
+
+✓ DRY RUN: Draft is valid and ready for creation
+```
+
+### Step 5: Create Test Case
+
+```bash
+python3 scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-5691.json
+```
+
+**Expected workflow**:
+1. Creating test case...
+   ✓ Created: OCP-xxxxx
+
+2. Patching custom fields...
+   ✓ Patched 6 custom fields
+
+3. Adding X test steps...
+   ✓ Added X test steps
+
+**Expected output**:
+```
+================================================================================
+✓ TEST CASE CREATED SUCCESSFULLY
+================================================================================
+ID: OCP-xxxxx
+URL: https://polarion.engineering.redhat.com/polarion/#/project/OSE/workitem?id=OCP-xxxxx
+================================================================================
+```
+
+### Step 6: Verify in Polarion
+
+1. Open URL: `https://polarion.engineering.redhat.com/polarion/#/project/OSE/workitem?id=OCP-xxxxx`
+
+2. **Verify metadata**:
+   - [ ] Title: `[MCO][JIRA-ID] ...`
+   - [ ] Status: Draft
+   - [ ] Component: Machine Config Operator
+   - [ ] Sub Team: MCO
+   - [ ] Products: OCP
+   - [ ] Test Type: Functional
+   - [ ] Version: 4.22
+   - [ ] Trello/Jira: OCPBUGS-xxxxx
+
+3. **Verify test steps**:
+   - [ ] All steps present
+   - [ ] Step column has action descriptions
+   - [ ] Expected Result column has commands/output
+   - [ ] No HTML tags visible
+   - [ ] YAML/code formatting preserved
+
+4. **Compare with good format** (OCP-88122.pdf):
+   - [ ] Title structure matches
+   - [ ] All required fields filled
+   - [ ] Test steps have real commands
+
+## Expected Challenges
+
+### Challenge 1: Jira ID Not Found
+
+**Symptom**: `trello_jira` field empty
+
+**Fix**:
+```bash
+# Edit draft
+vim /tmp/test-specs/drafts/pr-5691.json
+# Set: "trello_jira": "OCPBUGS-xxxxx"
+
+# Re-validate
+python3 scripts/validate_tc.py /tmp/test-specs/drafts/pr-5691.json
+```
+
+### Challenge 2: Version Not Parsed
+
+**Symptom**: `version` field empty
+
+**Fix**:
+```bash
+# Edit draft
+vim /tmp/test-specs/drafts/pr-5691.json
+# Set: "version": "4.22"
+
+# Re-validate
+```
+
+### Challenge 3: Test Steps Narrative-Only
+
+**Symptom**: Validation warns "Expected result appears to be narrative-only"
+
+**Fix**:
+```bash
+# Edit draft expected_result to include commands
+# Before: "The feature is applied"
+# After: "$ oc get mc | grep feature\nfeature   3.2.0   15s"
+```
+
+### Challenge 4: API Error During Creation
+
+**Symptom**: "Failed to create test case: ..."
+
+**Fix**:
+1. Check POLARION_TOKEN validity
+2. Verify network connection
+3. Check Polarion API status
+4. Review error message for field issues
+5. Draft file preserved - can retry after fix
+
+## Success Criteria
+
+- [ ] Draft fetched from PR comment
+- [ ] Validation passes
+- [ ] All required fields populated
+- [ ] Test steps have commands
+- [ ] Dry run shows correct summary
+- [ ] Test case created successfully
+- [ ] OCP-xxxxx URL returned
+- [ ] Polarion shows complete TC
+- [ ] Format matches OCP-88122.pdf (good)
+- [ ] No empty fields like wrong.pdf (OCP-88941)
+
+## Comparison Matrix
+
+| Field | wrong.pdf (bad) | PR 5691 (expected good) |
+|---|---|---|
+| Title prefix | ❌ Missing | ✓ [MCO][JIRA-ID] |
+| Component | ❌ Empty | ✓ Machine Config Operator |
+| Sub Team | ❌ Empty | ✓ MCO |
+| Products | ❌ Empty | ✓ OCP |
+| Test Type | ❌ Empty | ✓ Functional |
+| Version | ❌ Empty | ✓ 4.22 |
+| Trello/Jira | ❌ Empty | ✓ OCPBUGS-xxxxx |
+| Expected Results | ❌ Narrative | ✓ Commands |
+
+## Next Steps After Pilot
+
+If pilot succeeds:
+1. Document actual PR 5691 comment format
+2. Update fetch_github_pr.py parsing if needed
+3. Add more test cases from different PR formats
+4. Integrate into /mco-create-tc-from-pr command
+5. Add to CI/automation workflow
+
+## Notes
+
+- Comment ID 4054832254 format may vary from typical QE comments
+- Parser may need adjustment based on actual comment structure
+- Jira ID extraction regex: `(OCPBUGS-\d+|MCO-\d+)`
+- Environment parsing regex: flexible for variations
diff --git a/.claude/QUICKSTART.md b/.claude/QUICKSTART.md
new file mode 100644
index 0000000000..2ef29ed3e7
--- /dev/null
+++ b/.claude/QUICKSTART.md
@@ -0,0 +1,170 @@
+# MCO QE Tooling - Quick Start
+
+Get started in 5 minutes.
+
+## 1. Setup (One-time)
+
+```bash
+cd .claude
+./scripts/setup.sh
+```
+
+## 2. Configure Tokens
+
+Edit `.env` at repo root:
+
+```bash
+# Required
+POLARION_TOKEN=your_token_here
+
+# Optional (for GitHub)
+GITHUB_TOKEN=your_github_token
+
+# Optional (for Jira)
+JIRA_TOKEN=your_jira_token
+
+# Optional (for updating test steps)
+POLARION_USERNAME=your_username
+POLARION_PASSWORD=your_password
+```
+
+**Get tokens**:
+- Polarion: https://polarion.engineering.redhat.com/polarion/#/user/me
+- GitHub: https://github.com/settings/tokens
+- Jira: https://id.atlassian.com/manage-profile/security/api-tokens
+
+## 3. Verify
+
+```bash
+cd .claude
+./scripts/setup.sh --verify
+```
+
+Should see:
+```
+✓ Python 3.14.5 found
+✓ requests already installed
+✓ POLARION_TOKEN configured
+✓ Polarion connection successful (HTTP 200)
+  Project: OpenShift (OSE)
+```
+
+## 4. Try It Out
+
+### Create TC from GitHub PR
+
+```bash
+# Fetch PR comment
+python3 scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr 5691 \
+  --comment 4054832254
+
+# Validate
+python3 scripts/validate_tc.py /tmp/test-specs/drafts/pr-5691.json
+
+# Create (dry run first)
+python3 scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-5691.json --dry-run
+
+# Create (for real)
+python3 scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-5691.json
+```
+
+### Create TC from Jira + GitHub (Hybrid)
+
+```bash
+# One command - combines Jira metadata + PR test steps
+python3 scripts/create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691
+```
+
+### Fix Existing TC (wrong.pdf scenario)
+
+```bash
+# Fix empty metadata fields
+python3 scripts/update_polarion_tc.py OCP-88941 --fix-metadata \
+  --version 4.18 \
+  --trello-jira OCPBUGS-83830
+
+# Fix title
+python3 scripts/update_polarion_tc.py OCP-88941 \
+  --title "[MCO][OCPBUGS-83830] Verify MCD password behavior"
+```
+
+### Fetch Polarion TC for Automation
+
+```bash
+# Fetch TC
+python3 scripts/fetch_polarion.py OCP-88122
+
+# Use with /automate-test
+/automate-test OCP-88122 "mco osstream" disruptive
+```
+
+## Common Workflows
+
+### Workflow 1: PR → Polarion
+
+1. Find PR with QE comment
+2. Get PR number and comment ID
+3. Run: `python3 scripts/create_tc_hybrid.py JIRA-KEY --from-pr PR-NUM`
+4. Get OCP-xxxxx URL
+
+### Workflow 2: Jira Only
+
+1. Find Jira issue
+2. Run: `python3 scripts/fetch_jira.py JIRA-KEY`
+3. Create: `python3 scripts/create_polarion_tc.py /tmp/test-specs/jira/JIRA-KEY.json`
+4. Add steps later
+
+### Workflow 3: Fix Bad TC
+
+1. Identify TC with empty fields
+2. Run: `python3 scripts/update_polarion_tc.py OCP-ID --fix-metadata`
+3. Verify in Polarion
+
+## File Locations
+
+- **Config**: `.env` (repo root)
+- **Scripts**: `.claude/scripts/`
+- **Output**: `/tmp/test-specs/`
+- **Docs**: `.claude/*.md`
+
+## Quick Reference
+
+| Task | Command |
+|---|---|
+| Setup | `./scripts/setup.sh --verify` |
+| Fetch TC | `python3 scripts/fetch_polarion.py OCP-88122` |
+| Fetch PR | `python3 scripts/fetch_github_pr.py --repo org/repo --pr NUM` |
+| Fetch Jira | `python3 scripts/fetch_jira.py JIRA-KEY` |
+| Validate | `python3 scripts/validate_tc.py draft.json` |
+| Create | `python3 scripts/create_polarion_tc.py draft.json` |
+| Hybrid | `python3 scripts/create_tc_hybrid.py JIRA-KEY --from-pr NUM` |
+| Update | `python3 scripts/update_polarion_tc.py OCP-ID --fix-metadata` |
+
+## Next Steps
+
+1. Read `.claude/README.md` for full workflows
+2. Try pilot test: `.claude/PILOT_PR5691.md`
+3. See complete guide: `.claude/COMPLETE_WORKFLOW.md`
+
+## Troubleshooting
+
+**"POLARION_TOKEN not configured"**
+→ Add token to `.env`, run `./scripts/setup.sh --verify`
+
+**"Validation failed"**
+→ Review errors, edit draft, re-validate
+
+**"SOAP API requires username and password"**
+→ Add POLARION_USERNAME/PASSWORD to `.env` (only for test step updates)
+
+## Help
+
+- Full docs: `.claude/README.md`
+- Fetch guide: `.claude/FETCH_USAGE.md`
+- Create guide: `.claude/CREATE_TC_USAGE.md`
+- Update guide: `.claude/UPDATE_TC_USAGE.md`
+- Jira guide: `.claude/JIRA_INTEGRATION.md`
+- Complete workflow: `.claude/COMPLETE_WORKFLOW.md`
+- Final summary: `.claude/FINAL_SUMMARY.md`
diff --git a/.claude/README.md b/.claude/README.md
new file mode 100644
index 0000000000..ac5e1e3486
--- /dev/null
+++ b/.claude/README.md
@@ -0,0 +1,630 @@
+# MCO QE Tooling
+
+Automation scripts for Machine Config Operator quality engineering workflows: fetch, create, and update Polarion test cases from multiple sources.
+
+**Quick start**: New user? Run `./scripts/setup.sh --verify` and see § Setup below.
+
+---
+
+## Table of Contents
+
+1. [Setup](#setup)
+2. [Commands](#commands)
+3. [Workflows](#workflows)
+4. [TC Format](#tc-format-good-vs-bad)
+5. [Scripts Reference](#scripts-reference)
+6. [Troubleshooting](#troubleshooting)
+7. [Claude Code Examples](#claude-code-examples)
+
+---
+
+## Setup
+
+### Prerequisites
+
+- Python 3.9+
+- `requests` library: `pip install requests`
+- Polarion API token
+- Optional: GitHub token, Jira token
+
+### Initial Setup
+
+**1. Run setup script**:
+```bash
+cd .claude
+./scripts/setup.sh
+```
+
+Creates `/tmp/test-specs/` directory structure.
+
+**2. Configure tokens**:
+
+Create `.env` at **repo root** (gitignored):
+```bash
+# Required for Polarion
+POLARION_URL=https://polarion.engineering.redhat.com
+POLARION_TOKEN=your_personal_access_token_here
+
+# Optional: For updating test steps on existing TCs (SOAP API)
+POLARION_USERNAME=your_username
+POLARION_PASSWORD=your_password
+
+# Optional: For GitHub (public repos work without token)
+GITHUB_TOKEN=your_github_token_here
+
+# Optional: For Jira integration
+JIRA_URL=https://redhat.atlassian.net
+JIRA_EMAIL=you@redhat.com
+JIRA_TOKEN=your_jira_api_token_here
+```
+
+**Get tokens**:
+- **Polarion**: https://polarion.engineering.redhat.com/polarion/#/user/me → Personal Access Tokens
+- **GitHub**: https://github.com/settings/tokens → Generate new token (public_repo scope)
+- **Jira**: https://id.atlassian.com/manage-profile/security/api-tokens → Create API token
+
+**3. Verify setup**:
+```bash
+./scripts/setup.sh --verify
+```
+
+Expected output:
+```
+✓ Python 3.14.5 found
+✓ requests already installed
+✓ POLARION_TOKEN configured
+✓ Polarion connection successful (HTTP 200)
+  Project: OpenShift (OSE)
+```
+
+---
+
+## Commands
+
+Active commands (use via Claude Code or call scripts directly):
+
+### /mco-fetch
+
+Fetch test cases from Polarion, GitHub PRs, or Jira.
+
+```bash
+# Fetch Polarion TC
+python3 scripts/fetch_polarion.py OCP-88122
+
+# Fetch GitHub PR comment
+python3 scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr 5691 \
+  --comment 4054832254
+
+# Fetch Jira issue
+python3 scripts/fetch_jira.py OCPBUGS-74223
+```
+
+**Output**: JSON draft in `/tmp/test-specs/drafts/` or `/tmp/test-specs/jira/`
+
+### /mco-create-tc-from-pr
+
+Create Polarion test case from a GitHub PR QE comment or review.
+
+```bash
+# From PR comment (specific anchor)
+/mco-create-tc-from-pr https://github.com/openshift/machine-config-operator/pull/5691#issuecomment-4054832254
+
+# From PR (scans all comments/reviews for QE content)
+/mco-create-tc-from-pr https://github.com/openshift/machine-config-operator/pull/5691
+```
+
+**Output**: OCP-xxxxx URL
+
+### /mco-create-tc-from-jira
+
+Create Polarion test case from a Jira issue or QE comment.
+
+```bash
+# From Jira issue (scans comments for QE verification)
+/mco-create-tc-from-jira https://redhat.atlassian.net/browse/OCPBUGS-86695
+
+# From specific Jira comment
+/mco-create-tc-from-jira https://redhat.atlassian.net/browse/OCPBUGS-86695?focusedCommentId=17167775
+```
+
+**Output**: OCP-xxxxx URL
+
+### /mco-update-tc *(future scope — MCO-2220)*
+
+> **TODO**: Standalone update command not yet active. Use `update_polarion_tc.py` directly in the meantime (called automatically by the create workflow).
+>
+> ```bash
+> python3 scripts/update_polarion_tc.py OCP-88941 --fix-metadata --version 4.18 --trello-jira OCPBUGS-83830
+> python3 scripts/update_polarion_tc.py OCP-88122 --title "[MCO][MCO-2136] New title"
+> python3 scripts/update_polarion_tc.py OCP-88122 --steps-file /tmp/test-specs/steps/new-steps.json
+> ```
+
+### /automate-test
+
+Generate Go e2e test from Polarion test case.
+
+```bash
+# Fetch TC and generate test
+/automate-test OCP-88122 "mco osstream" disruptive
+```
+
+**Workflow**:
+1. Fetches OCP-88122 from Polarion → `/tmp/test-specs/OCP-88122.txt`
+2. Reads test steps from .txt file
+3. Generates `test/extended-priv/mco_osstream.go`
+4. Builds with `make machine-config-tests-ext`
+
+---
+
+## Workflows
+
+### Workflow 1: Create TC from GitHub PR
+
+**Use when**: PR has QE "Pre-merge testing" comment with test steps.
+
+```bash
+# 1. Fetch PR comment
+python3 scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr 5691 \
+  --comment 4054832254
+
+# 2. Validate
+python3 scripts/validate_tc.py /tmp/test-specs/drafts/pr-5691.json
+
+# 3. Review draft
+cat /tmp/test-specs/drafts/pr-5691.json | jq .
+
+# 4. Create (dry run first)
+python3 scripts/create_polarion_tc.py \
+  /tmp/test-specs/drafts/pr-5691.json \
+  --dry-run
+
+# 5. Create for real
+python3 scripts/create_polarion_tc.py \
+  /tmp/test-specs/drafts/pr-5691.json
+```
+
+**Result**: OCP-xxxxx created with title, metadata (6 fields), and test steps.
+
+### Workflow 2: Create TC from Jira
+
+**Use when**: Jira issue has acceptance criteria, no PR test steps yet.
+
+```bash
+# 1. Fetch Jira
+python3 scripts/fetch_jira.py OCPBUGS-74223
+
+# 2. Validate (will warn about empty test_steps)
+python3 scripts/validate_tc.py /tmp/test-specs/jira/OCPBUGS-74223.json
+
+# 3. Create TC with metadata only
+python3 scripts/create_polarion_tc.py \
+  /tmp/test-specs/jira/OCPBUGS-74223.json
+```
+
+**Result**: TC created with metadata from Jira, empty test steps (add later manually or via update).
+
+**Jira fields extracted**:
+- Summary → title (with `[MCO][JIRA-ID]` prefix)
+- Fix Versions → version (extracts `4.18` from `4.18.0`)
+- Description + Acceptance Criteria → description
+- Issue Type, Labels → metadata
+
+### Workflow 3: Hybrid (Jira + GitHub PR) - **RECOMMENDED**
+
+**Use when**: Jira has metadata, GitHub PR has test steps. Best of both worlds.
+
+```bash
+# One command - fetches both, merges, validates, creates
+python3 scripts/create_tc_hybrid.py OCPBUGS-74223 \
+  --from-pr 5691 \
+  --comment 4054832254
+```
+
+**What it does**:
+1. Fetches Jira OCPBUGS-74223 → version, description, acceptance criteria
+2. Fetches GitHub PR 5691 comment → test steps with commands
+3. Merges: Jira metadata + PR steps
+4. Validates merged draft
+5. Shows summary and confirmation prompt
+6. Creates TC in Polarion
+
+**Result**: Complete TC with accurate metadata and executable test steps.
+
+**Merge logic**:
+- Title: `[MCO][JIRA-ID] <Jira summary>`
+- Version: From Jira fix versions
+- Description: Jira description + acceptance criteria
+- Test steps: From GitHub PR QE comment
+- Jira ID: From Jira issue key
+
+### Workflow 4: Fix Existing TC (wrong.pdf scenario)
+
+**Use when**: TC has empty required fields (Component, Sub Team, etc.).
+
+See `wrong.pdf` in repo root for bad example vs `OCP-88122.pdf` for good format.
+
+```bash
+# Fix metadata
+python3 scripts/update_polarion_tc.py OCP-88941 \
+  --fix-metadata \
+  --version 4.18 \
+  --trello-jira OCPBUGS-83830
+
+# Verify changes
+python3 scripts/fetch_polarion.py OCP-88941
+```
+
+**`--fix-metadata` sets defaults**:
+- Component: Machine Config Operator
+- Sub Team: MCO
+- Products: OCP
+- Test Type: Functional
+- Version: (from --version flag)
+- Trello/Jira: (from --trello-jira flag)
+
+### Workflow 5: Polarion TC → Go Test
+
+**Use when**: Polarion TC exists, need to generate automated Go test.
+
+```bash
+# 1. Fetch TC from Polarion
+python3 scripts/fetch_polarion.py OCP-88122
+# Creates /tmp/test-specs/OCP-88122.txt
+
+# 2. Generate Go test (via Claude Code)
+/automate-test OCP-88122 "mco osstream" disruptive
+
+# 3. Build
+make machine-config-tests-ext
+
+# 4. Verify test appears
+./_output/linux/amd64/machine-config-tests-ext list | grep OCP-88122
+```
+
+**Result**: `test/extended-priv/mco_osstream.go` with test implementation.
+
+---
+
+## TC Format (Good vs Bad)
+
+### Good Format: OCP-88122.pdf
+
+See `OCP-88122.pdf` in repo root.
+
+**Characteristics**:
+- ✓ Title: `[MCO][MCO-2136] Validate osImageStream inheritance...`
+- ✓ Component: Machine Config Operator
+- ✓ Sub Team: MCO
+- ✓ Products: OCP
+- ✓ Test Type: Functional
+- ✓ Version: 4.22
+- ✓ Trello/Jira: MCO-2136
+- ✓ Test Steps: Commands in Expected Result column (not narrative)
+
+**Example step**:
+```
+Step: Check the osstream
+Expected Result:
+$ oc get mcp rhel9 -ojsonpath='{.status.osImageStream.name}'
+rhel9
+```
+
+### Bad Format: wrong.pdf (OCP-88941)
+
+See `wrong.pdf` in repo root.
+
+**Problems**:
+- ❌ Component: (empty)
+- ❌ Sub Team: (empty)
+- ❌ Products: (empty)
+- ❌ Test Type: (empty)
+- ❌ Version: (empty)
+- ❌ Trello/Jira: (empty)
+- ❌ Test Steps: Narrative only, no commands
+
+**How this happened**: Created without validation, or metadata not set during creation.
+
+**How to fix**: Use `update_polarion_tc.py --fix-metadata`
+
+### Validation Rules
+
+Scripts enforce these rules:
+
+1. **Title format**: Must match `^\[MCO\]\[.+\] .+`
+   - Good: `[MCO][OCPBUGS-74223] Add feature X`
+   - Bad: `Add feature X` (missing prefix)
+
+2. **Required fields** (all 6 must be non-empty):
+   - component
+   - sub_team
+   - products
+   - test_type
+   - version
+   - trello_jira
+
+3. **Test steps quality**:
+   - Each step must have non-empty `step` field
+   - Expected results should have commands (not narrative-only)
+   - Warning if expected result has no `oc`, `kubectl`, code syntax
+
+Run validation before creating:
+```bash
+python3 scripts/validate_tc.py /tmp/test-specs/drafts/pr-5691.json
+```
+
+---
+
+## Scripts Reference
+
+| Script | Purpose | Input | Output |
+|---|---|---|---|
+| `setup.sh` | Environment setup + verification | - | Status messages |
+| `validate_tc.py` | Validate draft JSON | Draft JSON path or `-` (stdin) | Validation result |
+| `fetch_polarion.py` | Fetch Polarion TC | OCP-88122 | JSON (stdout) + `/tmp/test-specs/OCP-88122.txt` |
+| `fetch_github_pr.py` | Parse GitHub PR QE comment | `--repo org/repo --pr NUM --comment ID` | `/tmp/test-specs/drafts/pr-NUM.json` |
+| `fetch_jira.py` | Fetch Jira issue | OCPBUGS-12345 | `/tmp/test-specs/jira/OCPBUGS-12345.json` |
+| `create_polarion_tc.py` | Create TC from draft | Draft JSON path | OCP-xxxxx URL |
+| `create_tc_hybrid.py` | Merge Jira + PR, create TC | `JIRA-KEY --from-pr NUM` | OCP-xxxxx URL |
+| `update_polarion_tc.py` | Update existing TC | OCP-xxxxx + flags | Updated field count |
+| `polarion_client.py` | REST/SOAP API client | (library) | - |
+
+### Common Flags
+
+**validate_tc.py**:
+- `--strict`: Fail on warnings
+- `--sample`: Show validation examples
+
+**create_polarion_tc.py**:
+- `--dry-run`: Show summary, don't create
+- `--project OSE`: Override project (default: OSE)
+
+**update_polarion_tc.py**:
+- `--fix-metadata`: Set all required fields to defaults
+- `--title TEXT`: Update title
+- `--status STATUS`: Update status (draft, approved, etc.)
+- `--version VERSION`: Update version
+- `--trello-jira KEY`: Update Jira ID
+- `--steps-file PATH`: Update test steps (requires SOAP API)
+- `--dry-run`: Preview changes
+
+**fetch_github_pr.py**:
+- `--repo ORG/REPO`: Repository (required)
+- `--pr NUM`: PR number (required)
+- `--comment ID`: Comment ID (optional - finds QE comment if omitted)
+- `--output PATH`: Custom output path
+
+**create_tc_hybrid.py**:
+- `--from-pr NUM`: GitHub PR number (required)
+- `--comment ID`: Comment ID (optional)
+- `--repo ORG/REPO`: Repository (default: openshift/machine-config-operator)
+- `--dry-run`: Preview without creating
+
+---
+
+## Troubleshooting
+
+### "POLARION_TOKEN not configured"
+
+**Cause**: Token missing or placeholder value in `.env`
+
+**Fix**:
+1. Generate token: https://polarion.engineering.redhat.com/polarion/#/user/me
+2. Add to `.env` at repo root
+3. Verify: `./scripts/setup.sh --verify`
+
+### "Validation failed: Required field 'version' is empty"
+
+**Cause**: Draft missing required field
+
+**Fix**:
+```bash
+# Edit draft manually
+vim /tmp/test-specs/drafts/pr-5691.json
+
+# Or set during creation
+python3 scripts/create_tc_hybrid.py JIRA-KEY --from-pr NUM
+# (hybrid mode auto-fills from Jira)
+```
+
+### "SOAP API requires username and password"
+
+**Cause**: Trying to update test steps on existing TC without SOAP credentials
+
+**Context**: Polarion REST API can only POST test steps to NEW TCs. For existing TCs, must use SOAP API.
+
+**Fix**:
+```bash
+# Add to .env
+POLARION_USERNAME=your_username
+POLARION_PASSWORD=your_password
+
+# Then retry
+python3 scripts/update_polarion_tc.py OCP-88122 \
+  --steps-file /tmp/test-specs/steps/new-steps.json
+```
+
+### "GitHub API error: 401 Unauthorized"
+
+**Cause**: Invalid or missing GitHub token
+
+**Fix**:
+- For public repos: Script auto-retries without token
+- For private repos or to avoid rate limits: Add GITHUB_TOKEN to `.env`
+- Generate token: https://github.com/settings/tokens (public_repo scope)
+
+### "Jira authentication failed"
+
+**Cause**: Invalid token or missing email
+
+**Fix**:
+```bash
+# Jira (Atlassian Cloud) requires email + token
+JIRA_EMAIL=you@redhat.com
+JIRA_TOKEN=your_token
+```
+
+Generate token: https://id.atlassian.com/manage-profile/security/api-tokens
+
+### Test steps narrative-only (no commands)
+
+**Symptom**: Validation warns "Expected result appears to be narrative-only"
+
+**Fix**: Edit draft to add commands:
+```json
+{
+  "step": "Verify feature applied",
+  "expected_result": "$ oc get mc | grep feature\nfeature   3.2.0   15s"
+}
+```
+
+---
+
+## Claude Code Examples
+
+If using Claude Code assistant:
+
+### Fetch and create from PR
+```
+/mco-create-tc-from-pr https://github.com/openshift/machine-config-operator/pull/5691#issuecomment-4054832254
+```
+
+### Create TC from Jira
+```
+/mco-create-tc-from-jira https://redhat.atlassian.net/browse/OCPBUGS-74223
+```
+
+### Fix bad TC *(direct script — /mco-update-tc is future scope)*
+```bash
+python3 .claude/scripts/update_polarion_tc.py OCP-88941 --fix-metadata --version 4.18 --trello-jira OCPBUGS-83830
+```
+
+### Fetch TC and generate test
+```
+/mco-fetch tc OCP-88122
+/automate-test OCP-88122 "mco osstream" disruptive
+```
+
+### Migrate test from OTP3
+```
+/migrate-tests mco_ocb.go --dry-run
+```
+
+---
+
+## Output Locations
+
+- **Drafts**: `/tmp/test-specs/drafts/pr-*.json`
+- **Jira**: `/tmp/test-specs/jira/*.json`
+- **Polarion TCs** (txt format): `/tmp/test-specs/OCP-*.txt`
+- **Test steps**: `/tmp/test-specs/steps/*.json`
+
+All output goes to `/tmp/` (not in repo).
+
+---
+
+## Architecture Notes
+
+### REST vs SOAP API
+
+**REST API** (Bearer token):
+- Fetch test cases
+- Create new test cases
+- Update fields (title, description, status, custom fields)
+- **Limitation**: Can only POST test steps to NEW TCs
+
+**SOAP API** (username/password):
+- Update test steps on EXISTING TCs
+- Script auto-falls back from REST to SOAP when updating steps
+
+**Why both?** Polarion REST API doesn't support updating test steps on existing TCs. This is a known Polarion limitation.
+
+### Test Step Format for SOAP API
+
+When updating test steps via SOAP, use this JSON format:
+```json
+[
+  {
+    "step": "Do something",
+    "expected_result": "$ oc get nodes\nNAME   STATUS\nnode1  Ready"
+  }
+]
+```
+
+### Jira Integration (No MCP)
+
+Uses direct Atlassian REST API v3. Authentication is Basic Auth with email:token (not Red Hat SSO).
+
+**Why email + token?** Atlassian Cloud requires this authentication method.
+
+---
+
+## Pilot Test
+
+Want to verify the workflow end-to-end? See pilot test checklist in appendix:
+
+```bash
+# Run full pilot (PR 5691 → Create TC → Verify)
+# See PILOT_PR5691.md for step-by-step checklist
+```
+
+Or test fetch verification:
+
+```bash
+# Verify OCP-88122 fetch matches PDF
+# See TEST_FETCH.md for verification checklist
+```
+
+---
+
+## Documentation Files
+
+- **README.md** (this file) - Complete guide
+- **TESTING.md** - Test plan for reviewers
+- **PILOT_PR5691.md** - Pilot test checklist (PR 5691 → TC creation)
+- **TEST_FETCH.md** - Fetch verification (OCP-88122)
+
+---
+
+## Help & Support
+
+**For script help**:
+```bash
+python3 scripts/<script>.py --help
+```
+
+**For Claude Code help**:
+```
+/help
+```
+
+**Issues**: Report at https://github.com/openshift/machine-config-operator/issues
+
+---
+
+## Cleanup
+
+### Remove Obsolete /tmp Files
+
+After migrating scripts to use repo `test-specs/` directory, old `/tmp` files are no longer needed:
+
+```bash
+# Remove old test-specs cache
+rm -rf /tmp/test-specs
+
+# Remove old draft files
+rm -f /tmp/ocp88122.json /tmp/test.json
+
+# Remove other temp files from early testing
+rm -f /tmp/pr5691_comment.txt /tmp/parsing_gaps.md /tmp/ocp88122_analysis.md
+```
+
+**Note**: Current scripts still use `/tmp/test-specs/` for output. This cleanup is only for obsolete files from migration testing.
+
+---
+
+**Version**: 1.0  
+**Last Updated**: 2026-06-04
diff --git a/.claude/TESTING.md b/.claude/TESTING.md
new file mode 100644
index 0000000000..00e7970e2f
--- /dev/null
+++ b/.claude/TESTING.md
@@ -0,0 +1,195 @@
+# Test Plan for Reviewers
+
+## Pre-Review Checklist
+
+### Security & Secrets
+- [ ] Verify `.env` is in `.gitignore`
+- [ ] Verify `.claude/.env` is in `.gitignore`
+- [ ] Verify `.claude/settings.local.json` is in `.gitignore`
+- [ ] No secrets or tokens in committed code
+- [ ] `.env.example` uses placeholder values only
+
+### Documentation
+- [ ] README.md is accurate (no references to non-existent scripts)
+- [ ] QUICKSTART.md provides working 5-minute setup
+- [ ] All script paths in docs match actual file locations
+- [ ] Examples use real script names (not `polarion_cli.py`, etc.)
+
+### Scripts Functionality
+- [ ] All `.py` scripts are executable (`chmod +x`)
+- [ ] All scripts have valid shebang: `#!/usr/bin/env python3`
+- [ ] `--help` flag works for all scripts (except `polarion_client.py`)
+- [ ] Scripts gracefully handle missing `.env` file
+
+## Functional Testing (Optional - Requires Credentials)
+
+**Note**: These tests require Polarion/GitHub/Jira credentials. Reviewers may skip this section.
+
+### Setup Verification
+```bash
+cd .claude
+./scripts/setup.sh --verify
+```
+**Expected**: Shows Python version, checks dependencies, verifies `/tmp/test-specs/` structure
+
+### Validation (No Credentials Required)
+```bash
+# Use sample from docs
+cat > /tmp/test.json << 'EOF'
+{
+  "title": "[MCO][OCPBUGS-12345] Test title",
+  "component": "Machine Config Operator",
+  "sub_team": "MCO",
+  "products": "OCP",
+  "test_type": "Functional",
+  "version": "4.22",
+  "trello_jira": "OCPBUGS-12345",
+  "test_steps": [
+    {"step": "Do something", "expected_result": "oc get nodes"}
+  ]
+}
+EOF
+
+python3 scripts/validate_tc.py /tmp/test.json
+```
+**Expected**: `✓ VALIDATION PASSED`
+
+### Fetch Polarion (Requires POLARION_TOKEN)
+```bash
+python3 scripts/fetch_polarion.py OCP-88122
+```
+**Expected**:
+- JSON output to stdout
+- File created: `/tmp/test-specs/OCP-88122.txt`
+- No errors about missing token (if configured)
+
+### Fetch GitHub PR (No Token Required - Public Repo)
+```bash
+python3 scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr 5691 \
+  --comment 4054832254
+```
+**Expected**:
+- Draft saved: `/tmp/test-specs/drafts/pr-5691.json`
+- Title extracted with `[MCO][JIRA-ID]` prefix
+- Version extracted from environment section
+- Test steps parsed
+
+### Create Test Case (Requires POLARION_TOKEN)
+```bash
+# Dry run - no actual creation
+python3 scripts/create_polarion_tc.py \
+  /tmp/test-specs/drafts/pr-5691.json \
+  --dry-run
+```
+**Expected**: Summary shown, no actual Polarion API call
+
+## Code Structure Review
+
+### Python Code Quality
+- [ ] No hardcoded credentials
+- [ ] Environment variables loaded from `.env`
+- [ ] Error messages are helpful (show next steps)
+- [ ] Scripts can run from any directory (use `__file__` for relative paths)
+
+### File Organization
+- [ ] Scripts in `.claude/scripts/`
+- [ ] Commands in `.claude/commands/`
+- [ ] Skills in `.claude/skills/`
+- [ ] Docs in `.claude/` root
+- [ ] No orphaned files
+
+### Integration Points
+- [ ] Does not modify MCO production code
+- [ ] Does not modify existing tests
+- [ ] Only adds files in `.claude/` directory
+- [ ] Output goes to `/tmp/test-specs/` (not in repo)
+
+## Documentation Accuracy
+
+### README.md Verification
+- [ ] "Setup" section has correct script paths
+- [ ] "Workflows" section references real scripts
+- [ ] "Command Reference" table has valid commands
+- [ ] No broken internal links
+- [ ] Examples are copy-pasteable
+
+### QUICKSTART.md Verification
+- [ ] Setup steps work end-to-end
+- [ ] Script paths are correct
+- [ ] Example commands succeed (or fail gracefully without credentials)
+
+## Edge Cases
+
+### Missing Dependencies
+```bash
+# Simulate missing requests library
+python3 -c "import sys; sys.path = [p for p in sys.path if 'site-packages' not in p]; exec(open('.claude/scripts/fetch_polarion.py').read())"
+```
+**Expected**: Clear error about missing `requests` library
+
+### Invalid Input
+```bash
+# Invalid TC ID format
+python3 scripts/fetch_polarion.py INVALID-FORMAT
+```
+**Expected**: Error message with valid format example
+
+### No .env File
+```bash
+# Run without .env
+mv .env .env.bak 2>/dev/null
+python3 scripts/fetch_polarion.py OCP-88122
+```
+**Expected**: "Error: POLARION_TOKEN not configured in .env"
+
+## Reviewer Quick Test (2 minutes)
+
+**Minimal verification without credentials**:
+
+1. Check gitignore:
+   ```bash
+   grep -E "\.env|settings.local.json" .gitignore
+   ```
+
+2. Run setup verification:
+   ```bash
+   cd .claude && ./scripts/setup.sh --verify
+   ```
+
+3. Test validation:
+   ```bash
+   echo '{"title":"[MCO][TEST-1] Test","component":"Machine Config Operator","sub_team":"MCO","products":"OCP","test_type":"Functional","version":"4.22","trello_jira":"TEST-1","test_steps":[{"step":"test","expected_result":"oc get nodes"}]}' | python3 scripts/validate_tc.py -
+   ```
+
+4. Check --help works:
+   ```bash
+   python3 scripts/fetch_polarion.py --help
+   python3 scripts/create_polarion_tc.py --help
+   ```
+
+**All 4 should complete without errors.**
+
+## Success Criteria
+
+- [ ] No secrets in committed files
+- [ ] Scripts are executable and have --help
+- [ ] Documentation is accurate (no phantom scripts)
+- [ ] Quick test passes (4 commands above)
+- [ ] Only `.claude/` directory added (no changes to MCO code)
+- [ ] `.gitignore` protects secrets
+
+## Known Limitations
+
+- **Polarion REST API limitation**: Cannot update test steps on existing TCs via REST. Script auto-falls back to SOAP API (requires username/password).
+- **GitHub rate limits**: Public repos work without token but have lower rate limits (60 req/hour).
+- **Jira authentication**: Requires email + API token for Atlassian Cloud (Basic Auth).
+
+## Future Enhancements
+
+- Add unit tests for parsers
+- Add integration tests (mock Polarion API)
+- Add CI workflow to verify scripts on PR
+- Add more robust HTML→text conversion
+- Support Polarion rich text formatting in test steps
diff --git a/.claude/TEST_FETCH.md b/.claude/TEST_FETCH.md
new file mode 100644
index 0000000000..f626296d86
--- /dev/null
+++ b/.claude/TEST_FETCH.md
@@ -0,0 +1,173 @@
+# Test: Fetch OCP-88122
+
+Verify `fetch_polarion.py` against PDF saved from Polarion.
+
+## Test Run: 2026-06-04
+
+**Status**: ⚠️ CANNOT RUN - POLARION_TOKEN not configured  
+**Action Required**: User must add real token to `.env`
+
+### Pre-Flight Check
+- [x] `.env` exists at repo root
+- [x] `.env` has POLARION_TOKEN line
+- [ ] **FAIL**: Token is placeholder value `your_personal_access_token_here`
+
+**Blocker**: Cannot fetch from Polarion API without valid token.
+
+## Parsing Gaps Identified (Code Review vs PDF)
+
+**Reference**: OCP-88122.pdf in repo root
+
+### ❌ Gap 1: HTML to Text Conversion
+**File**: fetch_polarion.py:98-114  
+**Issue**: Basic regex doesn't preserve code blocks or YAML structure  
+**Impact**: Test steps with `<< EOF` heredocs will lose formatting  
+**Fix Applied**: ✅ Enhanced html_to_text() to preserve `<pre>`, `<code>`, lists, paragraphs
+
+### ❌ Gap 2: Test Steps HTML Content
+**File**: fetch_polarion.py:80-93  
+**Issue**: Extracted values not passed through html_to_text()  
+**Impact**: HTML tags in "Expected Result" column remain raw  
+**Fix Applied**: ✅ Call html_to_text() on both step and expected_result values
+
+### ❌ Gap 3: Linked Work Items Parsing  
+**File**: fetch_polarion.py:130-145 (custom fields)  
+**Issue**: `linkedworkitems` may return array of objects, need to extract ID  
+**Impact**: Trello/Jira field shows object instead of "MCO-2136"  
+**Fix Applied**: ✅ Extract work item ID/key from object array, join multiple with comma
+
+### ❌ Gap 4: Version Field Array Handling
+**File**: fetch_polarion.py:130-145  
+**Issue**: `plannedin` may be array `['4.22', '4.23']`  
+**Impact**: Version field shows array instead of single value  
+**Fix Applied**: ✅ Take first version from array
+
+## Expected Results (from PDF)
+
+### Title
+Expected: `[MCO][MCO-2136] Validate osImageStream inheritance for custom MachineConfigPools`
+
+### Metadata (6 required fields)
+- Component: Machine Config Operator
+- Sub Team: MCO
+- Products: OCP
+- Test Type: Functional
+- Version: 4.22
+- Trello/Jira: MCO-2136
+
+### Test Steps Structure
+**PDF shows**: Table with "Step" and "Expected Result" columns
+
+**Case1 Expected Result contains**:
+```
+oc create -f - << EOF
+apiVersion: machineconfiguration.openshift.io/v1
+kind: MachineConfigPool
+metadata:
+  name: rhel9
+spec:
+  machineConfigSelector:
+    matchExpressions:
+    - {key: machineconfiguration.openshift.io/role, operator: In, values: [worker,rhel9]}
+  nodeSelector:
+    matchLabels:
+      node-role.kubernetes.io/rhel9: ""
+EOF
+```
+
+Plus commands:
+- `oc get mcp rhel9 -ojsonpath='{.status.osImageStream.name}'`
+- `oc debug node/ip-10-0-13-255.us-east-2.compute.internal -- chroot /host`
+- `rpm-ostree status` output showing version
+
+### Description
+Multi-paragraph text with:
+- Case1: Worker MCP on rhel-9, custom MCPs inherit/override
+- Case2: Patch worker to rhel-10, infra pool inherits
+- Case3: Worker on rhel-10, custom MCPs with different streams
+
+## Verification Checklist (Post-Fetch)
+
+**Once token is configured, verify**:
+
+### Title
+- [ ] Matches `[MCO][MCO-2136] Validate osImageStream...`
+
+### Metadata (all 6 fields present)
+- [ ] Component: Machine Config Operator
+- [ ] Sub Team: MCO
+- [ ] Products: OCP
+- [ ] Test Type: Functional
+- [ ] Version: 4.22 (not array, single value)
+- [ ] Trello/Jira: MCO-2136 (not object, just key)
+
+### Test Steps Quality
+- [ ] Step 1 contains: "Applied below custom MCP..."
+- [ ] Expected Result 1 contains: `oc create -f - << EOF`
+- [ ] Expected Result 1 contains: full MachineConfigPool YAML (readable, not HTML-mangled)
+- [ ] Expected Result contains: `oc get mcp rhel9 -ojsonpath='{.status.osImageStream.name}'`
+- [ ] Expected Result contains: `oc debug node/...` command
+- [ ] Multi-line commands preserve newlines
+- [ ] YAML indentation preserved
+- [ ] No HTML tags like `<br/>` or `<div>` in output
+
+### Description
+- [ ] Contains "Case1:" heading
+- [ ] Contains "Case2:" section  
+- [ ] Contains "Case3" section
+- [ ] Multi-paragraph structure preserved (not flat wall of text)
+- [ ] Bullet points converted to `- ` prefix
+
+### Output Files
+- [ ] `/tmp/ocp88122.json` has valid JSON
+- [ ] `/tmp/test-specs/OCP-88122.txt` exists
+- [ ] `.txt` format suitable for /automate-test command
+
+## Run Test Commands
+
+```bash
+# From machine-config-operator repo root
+cd /home/ptalgulk/VSCode/mco/machine-config-operator
+
+# 1. Verify setup
+./.claude/scripts/setup.sh --verify
+
+# 2. Fetch test case (requires valid token in .env)
+python3 .claude/scripts/fetch_polarion.py OCP-88122 | tee /tmp/ocp88122.json
+
+# 3. Check text output
+cat /tmp/test-specs/OCP-88122.txt
+
+# 4. Compare to PDF
+# Manual review: check title, all 6 fields, test steps formatting
+```
+
+## Fixes Applied
+
+**File**: `.claude/scripts/fetch_polarion.py`
+
+1. ✅ **Enhanced html_to_text()** (line 98):
+   - Preserve `<pre>` and `<code>` blocks
+   - Convert `<p>` to double newlines
+   - Convert `<li>` to bullet points
+   - Clean up max 2 consecutive newlines
+
+2. ✅ **Apply html_to_text to test steps** (line 80-93):
+   - Call html_to_text() on step value
+   - Call html_to_text() on expected_result value
+
+3. ✅ **Fix linkedworkitems parsing** (line 130):
+   - Extract work item ID/key from object array
+   - Join multiple with comma
+   - Return string, not object
+
+4. ✅ **Fix version array handling** (line 130):
+   - Take first version if array
+   - Return single value "4.22" not ["4.22"]
+
+## Status Summary
+
+**Code Review**: ✅ COMPLETE - 4 parsing gaps identified and fixed  
+**Live Test**: ⚠️ BLOCKED - waiting for valid POLARION_TOKEN
+
+**Next Step**: User must configure real token in `.env`, then re-run test to verify fixes work with live Polarion API.
diff --git a/.claude/commands/automate-test.md b/.claude/commands/automate-test.md
index 86c8f5b5dc..8a10c0914d 100644
--- a/.claude/commands/automate-test.md
+++ b/.claude/commands/automate-test.md
@@ -9,11 +9,15 @@ Use the conventions in `.claude/skills/mco-automate-test-workflow.md` for all te
 
 **Input modes** (determined by `<spec-source>` format):
 - **Text file**: a file path containing the test specification
-- **Polarion ID** (future, MCO-2220): a numeric ID like `OCP-12345`
+- **Polarion ID**: a numeric ID like `OCP-12345` → fetches via `fetch_polarion.py`, uses `/tmp/test-specs/OCP-12345.txt`
 - **Jira ID** (future, MCO-2221): a Jira key like `MCO-1234`
 
 **Workflow:**
-1. Parse arguments. Read the spec file and extract test case ID, title, preconditions, steps, expected results, and tags. Derive target file from suite name (`"mco security"` -> `mco_security.go`).
+1. **Parse arguments**:
+   - If `<spec-source>` matches `OCP-\d+` or `OSE-\d+` → run `python3 .claude/scripts/fetch_polarion.py <id>` to fetch test case
+   - If `<spec-source>` is a file path → read the spec file directly
+   - Extract test case ID, title, preconditions, steps, expected results, and tags
+   - Derive target file from suite name (`"mco security"` -> `mco_security.go`).
 2. Learn from previous code reviews — check memory (`review_patterns_mco.md`), fetch new patterns from merged PRs via `gh api` on `openshift/machine-config-operator`.
 3. Read existing tests and utilities in `test/extended-priv/` to understand available helpers and patterns.
 4. Generate the test code following all conventions from the workflow skill.
diff --git a/.claude/commands/mco-create-tc-from-jira.md b/.claude/commands/mco-create-tc-from-jira.md
new file mode 100644
index 0000000000..4b57cf50e2
--- /dev/null
+++ b/.claude/commands/mco-create-tc-from-jira.md
@@ -0,0 +1,154 @@
+---
+name: mco-create-tc-from-jira
+description: Create Polarion test case from Jira comment
+---
+
+# Create Polarion TC from Jira
+
+## Usage
+
+```
+/mco-create-tc-from-jira <JIRA-URL>
+```
+
+Supported URL formats:
+- `https://redhat.atlassian.net/browse/OCPBUGS-86695` — scan all comments for QE verification
+- `https://redhat.atlassian.net/browse/OCPBUGS-86695?focusedCommentId=17167775` — specific comment
+
+## Instructions
+
+### Step 1: Parse URL and fetch content
+
+Extract issue key (e.g., `OCPBUGS-86695`) and optional comment ID from URL.
+
+**Fetch Jira issue:**
+```python
+# Use Atlassian MCP tools
+from mcp_tools import mcp__atlassian__getJiraIssue
+
+issue = mcp__atlassian__getJiraIssue(
+    cloudId="redhat.atlassian.net",
+    issueIdOrKey="OCPBUGS-86695"
+)
+```
+
+**If comment ID provided** — fetch specific comment:
+```python
+# Jira API doesn't have direct comment-by-id fetch via MCP
+# Need to get all comments and filter
+import requests
+import os
+
+jira_email = os.getenv('JIRA_EMAIL')
+jira_token = os.getenv('JIRA_TOKEN')
+
+url = f"https://redhat.atlassian.net/rest/api/3/issue/OCPBUGS-86695/comment/17167775"
+response = requests.get(
+    url,
+    auth=(jira_email, jira_token),
+    headers={"Accept": "application/json"}
+)
+comment = response.json()
+```
+
+**If no comment ID** — fetch all comments and find QE verification:
+```python
+# Look for comments containing:
+# - "Pre-merge verification"
+# - "Post Merge"
+# - "Steps Performed"
+# - Author: ptalgulk@redhat.com, hpatil@redhat.com
+```
+
+### Step 2: Extract metadata
+
+- **Title**: From Jira summary, ensure `[MCO][TICKET-ID]` format (add if missing)
+- **Jira**: Issue key from URL (e.g., `OCPBUGS-86695`)
+- **Version**: From Jira "Fix Version" field or comment text
+- **Description**: From Jira description or comment summary
+- **Defaults**: Component=`Machine Config Operator`, Sub Team=`MCO`, Products=`OCP`, Test Type=`Functional`
+
+### Step 3: Extract test steps — STRICT RULES
+
+**Rule 1 — Verbatim code blocks**: Copy every code block EXACTLY as written. Do NOT:
+- Abbreviate log lines with `...`
+- Summarize output
+- Add explanations
+- Shorten long lines
+
+**Rule 2 — No heredoc syntax**: Replace `cat <<EOF | oc apply -f -` with:
+```
+# filename.yaml
+<yaml content>
+
+oc apply -f filename.yaml
+<output>
+```
+
+**Rule 3 — Step vs Expected Result**:
+- **Step** column: plain-text description of action
+- **Expected Result** column: code blocks verbatim
+
+### Step 4: Create draft JSON
+
+Save to `/tmp/test-specs/drafts/jira-<ISSUE-KEY>.json`:
+```json
+{
+  "title": "[MCO][OCPBUGS-86695] Description",
+  "description": "...",
+  "component": "Machine Config Operator",
+  "sub_team": "MCO",
+  "products": "OCP",
+  "test_type": "Functional",
+  "version": "4.19",
+  "trello_jira": "OCPBUGS-86695",
+  "test_steps": [
+    {
+      "step": "Action description",
+      "expected_result": "exact output from code block"
+    }
+  ]
+}
+```
+
+### Step 5: Validate and show summary
+
+```bash
+python3 .claude/scripts/validate_tc.py /tmp/test-specs/drafts/jira-OCPBUGS-86695.json
+```
+
+Show full summary and **wait for confirmation** before creating.
+
+### Step 6: Create TC
+
+```bash
+python3 .claude/scripts/create_polarion_tc.py /tmp/test-specs/drafts/jira-OCPBUGS-86695.json
+```
+
+Note the TC ID (e.g. `OCP-89248`). The initial creation's custom field PATCH often fails silently.
+
+### Step 7: Always patch fields + steps separately
+
+Even if creation reports success, always run:
+```bash
+python3 .claude/scripts/update_polarion_tc.py OCP-XXXXX \
+  --component "Machine Config Operator" \
+  --sub-team "MCO" \
+  --products "OCP" \
+  --test-type "Functional" \
+  --version "<VERSION>" \
+  --trello-jira "<JIRA>"
+```
+
+> **Known issue**: The creation PATCH for custom fields (Component, Sub Team, Products, Test Type, Version, Trello/Jira) often fails silently. Always run Step 7 to patch fields separately and verify them in the Polarion UI. If any field is still missing after patching, set it manually in Polarion.
+
+## Key Points
+
+- Use Atlassian MCP tools or direct Jira REST API
+- Comment format same as GitHub (code blocks, plain text)
+- Same draft JSON structure
+- Same create + update workflow
+- **Verbatim logs**: full lines, no abbreviation
+- **Heredoc → file pattern**: never use `<<EOF`
+- **Always run update_polarion_tc.py** after creation — creation PATCH fails silently; fields may be empty in Polarion even if the script reported success
+
diff --git a/.claude/commands/mco-create-tc-from-pr.md b/.claude/commands/mco-create-tc-from-pr.md
new file mode 100644
index 0000000000..bb85ac9044
--- /dev/null
+++ b/.claude/commands/mco-create-tc-from-pr.md
@@ -0,0 +1,182 @@
+---
+name: mco-create-tc-from-pr
+description: Create Polarion test case from GitHub PR comments
+---
+
+# Create Polarion TC from PR
+
+## Usage
+
+```
+/mco-create-tc-from-pr <PR-URL>
+```
+
+Supported URL formats:
+- `https://github.com/openshift/machine-config-operator/pull/6097` — scan all comments + reviews
+- `https://github.com/openshift/machine-config-operator/pull/6097#issuecomment-XXXXXXXX` — specific issue comment
+- `https://github.com/openshift/machine-config-operator/pull/6097#pullrequestreview-XXXXXXXX` — specific PR review
+
+## Instructions
+
+### Step 1: Parse URL and fetch content
+
+Extract PR number and optional anchor from URL.
+
+**If anchor is `#issuecomment-<id>`** — fetch via script:
+```bash
+python3 .claude/scripts/fetch_github_pr.py \
+  --repo openshift/machine-config-operator \
+  --pr <NUMBER> --comment <ID>
+```
+
+**If anchor is `#pullrequestreview-<id>`** — the script does NOT cover reviews; fetch via GitHub API:
+```python
+import urllib.request, json
+
+def fetch(url):
+    req = urllib.request.Request(url, headers={
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "mco-tc-script"
+    })
+    return json.loads(urllib.request.urlopen(req).read())
+
+# PR metadata
+pr = fetch("https://api.github.com/repos/openshift/machine-config-operator/pulls/<NUMBER>")
+
+# All reviews — find the one matching the anchor ID
+reviews = fetch("https://api.github.com/repos/openshift/machine-config-operator/pulls/<NUMBER>/reviews")
+review = next(r for r in reviews if r['id'] == <REVIEW_ID>)
+print(review['body'])
+```
+
+**If no anchor** — fetch both issue comments and PR reviews, then find the QE verification comment:
+```python
+# Issue comments
+comments = fetch("https://api.github.com/repos/openshift/machine-config-operator/issues/<NUMBER>/comments")
+
+# PR reviews
+reviews = fetch("https://api.github.com/repos/openshift/machine-config-operator/pulls/<NUMBER>/reviews")
+```
+Scan both for QE content (authored by ptalgulk, ptalgulk01, HarshwardhanPatil07, or containing "Pre-merge", "Post Merge", "Steps Performed", "/label qe-approved").
+
+### Step 2: Extract metadata
+
+- **Title**: PR title, strip `[release-X.YY]` prefix if present
+- **Jira**: extract `OCPBUGS-XXXXX` or `MCO-XXXX` from title
+- **Version**: from target branch (`release-4.19` → `4.19`) or cluster version in comment
+- **Defaults**: Component=`Machine Config Operator`, Sub Team=`MCO`, Products=`OCP`, Test Type=`Functional`
+
+### Step 3: Extract test steps — STRICT RULES
+
+**Rule 1 — Verbatim code blocks**: Copy every code block EXACTLY as written in the PR comment. Do NOT:
+- Abbreviate log lines with `...`
+- Summarize output
+- Add comments or explanations inside the expected result
+- Shorten long lines
+
+**Rule 2 — No heredoc syntax**: If the original uses `cat <<EOF | oc apply -f -`, replace with:
+```
+# filename.yaml
+<yaml content here>
+
+oc apply -f filename.yaml
+<output>
+```
+Heredoc causes Polarion to split the YAML out of the expected result cell and render it above the table.
+
+**Rule 3 — Step vs Expected Result**:
+- **Step** column: plain-text description of the action (what to do)
+- **Expected Result** column: the code blocks from the comment, verbatim
+
+### Step 4: Create draft JSON
+
+Save to `/tmp/test-specs/drafts/pr-<NUMBER>.json`:
+```json
+{
+  "title": "[MCO][TICKET] Description",
+  "description": "...",
+  "component": "Machine Config Operator",
+  "sub_team": "MCO",
+  "products": "OCP",
+  "test_type": "Functional",
+  "version": "4.19",
+  "trello_jira": "OCPBUGS-XXXXX",
+  "test_steps": [
+    {
+      "step": "Action description",
+      "expected_result": "exact output from code block"
+    }
+  ]
+}
+```
+
+### Step 5: Validate and show summary
+
+```bash
+python3 .claude/scripts/validate_tc.py /tmp/test-specs/drafts/pr-<NUMBER>.json
+```
+
+Show full summary and **wait for confirmation** before creating.
+
+### Step 6: Create TC
+
+```bash
+python3 .claude/scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-<NUMBER>.json
+```
+
+Note the TC ID (e.g. `OCP-89248`). The initial creation's custom field PATCH often fails silently.
+
+### Step 7: Always patch fields + steps separately
+
+Even if creation reports success, always run:
+```bash
+python3 .claude/scripts/update_polarion_tc.py OCP-XXXXX \
+  --component "Machine Config Operator" \
+  --sub-team "MCO" \
+  --products "OCP" \
+  --test-type "Functional" \
+  --version "<VERSION>" \
+  --trello-jira "<JIRA>" \
+  --steps-file /tmp/test-specs/drafts/pr-<NUMBER>.json
+```
+
+> **Known issue**: The creation PATCH for custom fields (Component, Sub Team, Products, Test Type, Version, Trello/Jira) often fails silently. Always run Step 7 to patch fields separately and verify them in the Polarion UI. If any field is still missing after patching, set it manually in Polarion.
+
+### Step 8: Re-uploading steps (if steps already exist)
+
+When steps already exist, the client falls back to SOAP which fails with "Not authorized." Must delete all existing steps first:
+
+```python
+import sys, time
+sys.path.insert(0, '.claude/scripts')
+from polarion_client import PolarionClient
+# ... init client ...
+
+# Loop-delete until empty (Polarion re-indexes after each delete)
+for attempt in range(10):
+    result = client._make_request("GET", f"projects/OSE/workitems/{TC_ID}/teststeps")
+    remaining = result.get("data", [])
+    if not remaining:
+        break
+    for s in remaining:
+        sid = s.get('id', '').split('/')[-1]
+        client._make_request("DELETE", f"projects/OSE/workitems/{TC_ID}/teststeps/{sid}")
+    time.sleep(0.5)
+```
+
+Then re-run Step 7 to POST fresh steps via REST.
+
+## Key Points
+
+- **PR reviews** (`#pullrequestreview-`) need the `/pulls/{pr}/reviews` API, not the script
+- **Heredoc → file pattern**: never use `<<EOF` in expected results
+- **Verbatim logs**: full `I0603 05:28:15...` lines, no `...` abbreviation
+- **Always run update_polarion_tc.py** after creation to ensure fields + steps are set
+- **Step re-upload**: delete loop first, then REST POST
+
+## Common Issues
+
+**Fields not showing in Polarion** (Trello/Jira, Version, Sub Team empty):
+- Creation PATCH often fails silently
+- **Always run Step 7** to patch fields separately
+- Verify fields in Polarion UI before marking TC complete
diff --git a/.claude/commands/mco-fetch.md b/.claude/commands/mco-fetch.md
new file mode 100644
index 0000000000..ab28951ef3
--- /dev/null
+++ b/.claude/commands/mco-fetch.md
@@ -0,0 +1,51 @@
+---
+name: mco-fetch
+description: Fetch Polarion test case, GitHub PR, or Jira issue
+skill: mco-fetch-workflow
+---
+
+# mco-fetch
+
+Fetch test artifacts from Polarion, GitHub PR, or Jira.
+
+## Usage
+
+```
+/mco-fetch tc OCP-88122
+/mco-fetch pr 5691 [comment-id]
+/mco-fetch jira OCPBUGS-74223
+```
+
+## What it does
+
+- **Polarion TC**: Fetches test case details and saves to `/tmp/test-specs/<id>.txt` (for /automate-test)
+- **GitHub PR**: Fetches PR QE pre-merge testing comment, parses test steps
+- **Jira Issue**: Fetches issue metadata (summary, description, fix versions, acceptance criteria)
+
+## Direct Script Usage
+
+### Polarion
+```bash
+python3 .claude/scripts/fetch_polarion.py OCP-88122
+```
+
+### GitHub PR
+```bash
+python3 .claude/scripts/fetch_github_pr.py --repo openshift/machine-config-operator --pr 5691 [--comment <id>]
+```
+
+### Jira
+```bash
+python3 .claude/scripts/fetch_jira.py OCPBUGS-74223
+```
+
+## Output
+
+- **Polarion**: JSON to stdout + `/tmp/test-specs/<id>.txt` (for /automate-test)
+- **GitHub PR**: `/tmp/test-specs/drafts/pr-<number>.json`
+- **Jira**: `/tmp/test-specs/jira/<issue-key>.json`
+
+## See Also
+
+- `.claude/README.md` - Full workflow documentation
+- `.claude/skills/mco-fetch-workflow.md` - Implementation details
diff --git a/.claude/scripts/create_polarion_tc.py b/.claude/scripts/create_polarion_tc.py
new file mode 100755
index 0000000000..d47a36e1f1
--- /dev/null
+++ b/.claude/scripts/create_polarion_tc.py
@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""
+Create Polarion test case from validated draft JSON.
+
+Usage:
+    python3 create_polarion_tc.py <draft.json> [--dry-run]
+
+Workflow:
+1. Validate draft (must pass validate_tc.py)
+2. POST testcase (basic fields)
+3. PATCH custom fields
+4. POST teststeps (blank slate strategy)
+5. Return OCP-xxxxx URL
+"""
+
+import json
+import os
+import sys
+from typing import Dict, Any
+from polarion_client import PolarionClient
+
+
+def load_env():
+    """Load .env file from repo root"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(os.path.dirname(script_dir))
+    env_file = os.path.join(repo_root, '.env')
+
+    if not os.path.exists(env_file):
+        print(f"Error: .env not found at {env_file}", file=sys.stderr)
+        print("Run: ./scripts/setup.sh", file=sys.stderr)
+        sys.exit(1)
+
+    env_vars = {}
+    with open(env_file) as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith('#') and '=' in line:
+                key, value = line.split('=', 1)
+                env_vars[key] = value
+
+    return env_vars
+
+
+def validate_draft(draft: Dict) -> bool:
+    """Run validation checks (same as validate_tc.py)"""
+    import re
+
+    errors = []
+
+    # Check title format
+    if not re.match(r'^\[MCO\]\[.+\] .+', draft.get('title', '')):
+        errors.append(f"Title must match [MCO][TICKET-ID] Description: {draft.get('title', '')}")
+
+    # Check required fields
+    required = ['component', 'sub_team', 'products', 'test_type', 'version', 'trello_jira']
+    for field in required:
+        if not draft.get(field):
+            errors.append(f"Required field '{field}' is empty")
+
+    # Check test steps
+    if not draft.get('test_steps'):
+        errors.append("No test steps defined")
+
+    if errors:
+        print("❌ VALIDATION FAILED\n", file=sys.stderr)
+        for err in errors:
+            print(f"  - {err}", file=sys.stderr)
+        return False
+
+    return True
+
+
+def create_test_case(
+    client: PolarionClient,
+    draft: Dict,
+    project: str = 'OSE'
+) -> Dict[str, Any]:
+    """Create test case with full workflow"""
+
+    # Step 1: Create base test case
+    print("Creating test case...", file=sys.stderr)
+
+    workitem_data = {
+        "data": [{
+            "type": "workitems",
+            "attributes": {
+                "type": "testcase",
+                "title": draft['title'],
+                "description": {
+                    "type": "text/html",
+                    "value": draft.get('description', '').replace("\n", "<br/>")
+                },
+                "status": "draft"
+            }
+        }]
+    }
+
+    result = client._make_request(
+        "POST",
+        f"projects/{project}/workitems",
+        data=workitem_data
+    )
+
+    if "error" in result:
+        return {
+            "status": "failed",
+            "error": f"Failed to create test case: {result['error']}"
+        }
+
+    test_case_data = result.get("data", [{}])[0] if isinstance(result.get("data"), list) else result.get("data", {})
+    test_case_id = test_case_data.get("id", "unknown")
+
+    print(f"✓ Created: {test_case_id}", file=sys.stderr)
+
+    # Step 2: PATCH custom fields
+    print("Patching custom fields...", file=sys.stderr)
+
+    # Build custom fields with correct types
+    # plannedin expects array, others expect strings
+    custom_fields = {}
+
+    if draft.get('component'):
+        custom_fields["casecomponent"] = draft.get('component')
+    if draft.get('sub_team'):
+        custom_fields["subteam2"] = draft.get('sub_team')
+    if draft.get('products'):
+        custom_fields["mcoproducts"] = draft.get('products')
+    if draft.get('test_type'):
+        custom_fields["casetesttype"] = draft.get('test_type')
+    if draft.get('version'):
+        custom_fields["plannedin"] = [draft.get('version')]  # Array format
+    if draft.get('trello_jira'):
+        custom_fields["linkedworkitems"] = draft.get('trello_jira')  # String format
+
+    if custom_fields:
+        patch_data = {
+            "data": {
+                "type": "workitems",
+                "id": f"{project}/{test_case_id}",
+                "attributes": custom_fields
+            }
+        }
+
+        patch_result = client._make_request(
+            "PATCH",
+            f"projects/{project}/workitems/{test_case_id}",
+            data=patch_data
+        )
+
+        if "error" in patch_result:
+            print(f"⚠️  Warning: Failed to patch custom fields: {patch_result['error']}", file=sys.stderr)
+        else:
+            print(f"✓ Patched {len(custom_fields)} custom fields", file=sys.stderr)
+
+    # Step 3: POST test steps (blank slate strategy)
+    test_steps = draft.get('test_steps', [])
+    if test_steps:
+        print(f"Adding {len(test_steps)} test steps...", file=sys.stderr)
+
+        steps_data = []
+        for step in test_steps:
+            step_obj = {
+                "type": "teststeps",
+                "attributes": {
+                    "keys": ["step", "expectedResult"],
+                    "values": [
+                        {
+                            "type": "text/html",
+                            "value": step.get("step", "").replace("\n", "<br/>")
+                        },
+                        {
+                            "type": "text/html",
+                            "value": step.get("expected_result", "").replace("\n", "<br/>")
+                        }
+                    ]
+                }
+            }
+            steps_data.append(step_obj)
+
+        steps_result = client._make_request(
+            "POST",
+            f"projects/{project}/workitems/{test_case_id}/teststeps",
+            data={"data": steps_data}
+        )
+
+        if "error" in steps_result:
+            print(f"⚠️  Warning: Failed to add test steps: {steps_result['error']}", file=sys.stderr)
+        else:
+            created_steps = steps_result.get("data", [])
+            print(f"✓ Added {len(created_steps)} test steps", file=sys.stderr)
+
+    # Success
+    return {
+        "status": "success",
+        "test_case_id": test_case_id,
+        "title": draft['title'],
+        "project": project,
+        "url": f"{client.url}/polarion/#/project/{project}/workitem?id={test_case_id}"
+    }
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Create Polarion test case from validated draft')
+    parser.add_argument('draft_file', help='Path to draft JSON file')
+    parser.add_argument('--project', default='OSE', help='Polarion project ID (default: OSE)')
+    parser.add_argument('--dry-run', action='store_true', help='Validate only, do not create')
+
+    args = parser.parse_args()
+
+    # Load draft
+    try:
+        with open(args.draft_file) as f:
+            draft = json.load(f)
+    except FileNotFoundError:
+        print(f"Error: File not found: {args.draft_file}", file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Validate
+    print("Validating draft...", file=sys.stderr)
+    if not validate_draft(draft):
+        print("\nFix validation errors and try again.", file=sys.stderr)
+        sys.exit(1)
+
+    print("✓ Validation passed\n", file=sys.stderr)
+
+    # Show summary
+    print("=" * 80, file=sys.stderr)
+    print("TEST CASE SUMMARY", file=sys.stderr)
+    print("=" * 80, file=sys.stderr)
+    print(f"Title: {draft['title']}", file=sys.stderr)
+    print(f"Component: {draft.get('component', 'NOT SET')}", file=sys.stderr)
+    print(f"Sub Team: {draft.get('sub_team', 'NOT SET')}", file=sys.stderr)
+    print(f"Products: {draft.get('products', 'NOT SET')}", file=sys.stderr)
+    print(f"Test Type: {draft.get('test_type', 'NOT SET')}", file=sys.stderr)
+    print(f"Version: {draft.get('version', 'NOT SET')}", file=sys.stderr)
+    print(f"Jira: {draft.get('trello_jira', 'NOT SET')}", file=sys.stderr)
+    print(f"Test Steps: {len(draft.get('test_steps', []))}", file=sys.stderr)
+    print("=" * 80, file=sys.stderr)
+    print()
+
+    if args.dry_run:
+        print("✓ DRY RUN: Draft is valid and ready for creation", file=sys.stderr)
+        sys.exit(0)
+
+    # Load environment
+    env = load_env()
+    polarion_url = env.get('POLARION_URL', 'https://polarion.engineering.redhat.com')
+    polarion_token = env.get('POLARION_TOKEN', '')
+
+    if not polarion_token or polarion_token == 'your_personal_access_token_here':
+        print("Error: POLARION_TOKEN not configured in .env", file=sys.stderr)
+        print("Generate token at: https://polarion.engineering.redhat.com/polarion/#/user/me", file=sys.stderr)
+        sys.exit(1)
+
+    # Create client
+    client = PolarionClient(
+        url=polarion_url,
+        token=polarion_token,
+        verify_ssl=True
+    )
+
+    # Create test case
+    result = create_test_case(client, draft, args.project)
+
+    if result['status'] == 'failed':
+        print(f"\n❌ Error: {result['error']}", file=sys.stderr)
+        sys.exit(1)
+
+    # Success
+    print("\n" + "=" * 80, file=sys.stderr)
+    print("✓ TEST CASE CREATED SUCCESSFULLY", file=sys.stderr)
+    print("=" * 80, file=sys.stderr)
+    print(f"ID: {result['test_case_id']}", file=sys.stderr)
+    print(f"URL: {result['url']}", file=sys.stderr)
+    print("=" * 80, file=sys.stderr)
+
+    # Output JSON result to stdout
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/create_tc_hybrid.py b/.claude/scripts/create_tc_hybrid.py
new file mode 100755
index 0000000000..796ed2a8e4
--- /dev/null
+++ b/.claude/scripts/create_tc_hybrid.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+Create Polarion TC from Jira issue + GitHub PR (hybrid mode).
+
+Usage:
+    python3 create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691 --comment 4054832254
+    python3 create_tc_hybrid.py MCO-2221 --from-pr 5691
+
+Workflow:
+1. Fetch Jira issue (summary, description, version, acceptance criteria)
+2. Fetch GitHub PR comment (test steps)
+3. Merge into draft
+4. Validate
+5. Create Polarion TC
+"""
+
+import json
+import os
+import sys
+import subprocess
+
+
+def run_script(script_name: str, args: list) -> dict:
+    """Run another script and capture JSON output"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    script_path = os.path.join(script_dir, script_name)
+
+    cmd = ['python3', script_path] + args
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        # Parse JSON from stdout
+        return json.loads(result.stdout)
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error running {script_name}:", file=sys.stderr)
+        print(e.stderr, file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing JSON from {script_name}:", file=sys.stderr)
+        print(e, file=sys.stderr)
+        sys.exit(1)
+
+
+def merge_jira_pr_drafts(jira_draft: dict, pr_draft: dict) -> dict:
+    """
+    Merge Jira and PR drafts.
+
+    Priority:
+    - Metadata (title, version, jira): From Jira
+    - Description: From Jira
+    - Test steps: From PR
+    - Acceptance criteria: From Jira (append to description)
+    """
+
+    # Start with Jira draft
+    merged = jira_draft.copy()
+
+    # Override test steps from PR
+    if pr_draft.get('test_steps'):
+        merged['test_steps'] = pr_draft['test_steps']
+
+    # Merge metadata
+    if 'metadata' not in merged:
+        merged['metadata'] = {}
+
+    merged['metadata']['source_jira'] = jira_draft.get('trello_jira', '')
+    merged['metadata']['source_pr'] = pr_draft.get('metadata', {}).get('source_pr', '')
+
+    # Append acceptance criteria to description
+    ac = jira_draft.get('metadata', {}).get('acceptance_criteria', '')
+    if ac:
+        merged['description'] = f"{merged.get('description', '')}\n\nAcceptance Criteria:\n{ac}"
+
+    return merged
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='Create Polarion TC from Jira + GitHub PR (hybrid)',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Example:
+  python3 create_tc_hybrid.py OCPBUGS-74223 --from-pr 5691 --comment 4054832254
+
+Workflow:
+  1. Fetch Jira issue (metadata, acceptance criteria)
+  2. Fetch GitHub PR comment (test steps)
+  3. Merge drafts
+  4. Validate
+  5. Create Polarion TC
+
+Output:
+  OCP-xxxxx URL
+        """
+    )
+
+    parser.add_argument('jira_key', help='Jira issue key (e.g., OCPBUGS-74223, MCO-2221)')
+    parser.add_argument('--from-pr', dest='pr_number', type=int, required=True,
+                       help='GitHub PR number')
+    parser.add_argument('--comment', type=int,
+                       help='GitHub comment ID (optional - will find QE comment)')
+    parser.add_argument('--repo', default='openshift/machine-config-operator',
+                       help='GitHub repository (default: openshift/machine-config-operator)')
+    parser.add_argument('--dry-run', action='store_true',
+                       help='Validate and show summary without creating')
+
+    args = parser.parse_args()
+
+    print(f"=== Hybrid TC Creation: {args.jira_key} + PR #{args.pr_number} ===", file=sys.stderr)
+    print()
+
+    # Step 1: Fetch Jira issue
+    print(f"[1/5] Fetching Jira issue: {args.jira_key}...", file=sys.stderr)
+    jira_draft = run_script('fetch_jira.py', [args.jira_key])
+    print(f"      ✓ Title: {jira_draft['title']}", file=sys.stderr)
+    print(f"      ✓ Version: {jira_draft.get('version', 'NOT SET')}", file=sys.stderr)
+    print()
+
+    # Step 2: Fetch GitHub PR comment
+    print(f"[2/5] Fetching GitHub PR #{args.pr_number}...", file=sys.stderr)
+    pr_args = ['--repo', args.repo, '--pr', str(args.pr_number)]
+    if args.comment:
+        pr_args.extend(['--comment', str(args.comment)])
+
+    pr_draft = run_script('fetch_github_pr.py', pr_args)
+    print(f"      ✓ Test Steps: {len(pr_draft.get('test_steps', []))}", file=sys.stderr)
+    print()
+
+    # Step 3: Merge drafts
+    print("[3/5] Merging Jira + PR data...", file=sys.stderr)
+    merged_draft = merge_jira_pr_drafts(jira_draft, pr_draft)
+
+    # Save merged draft
+    output_dir = '/tmp/test-specs/drafts'
+    os.makedirs(output_dir, exist_ok=True)
+    draft_file = os.path.join(output_dir, f"{args.jira_key}-pr{args.pr_number}.json")
+
+    with open(draft_file, 'w') as f:
+        json.dump(merged_draft, f, indent=2)
+
+    print(f"      ✓ Merged draft: {draft_file}", file=sys.stderr)
+    print()
+
+    # Step 4: Validate
+    print("[4/5] Validating draft...", file=sys.stderr)
+    validate_result = subprocess.run(
+        ['python3', 'validate_tc.py', draft_file],
+        cwd=os.path.dirname(os.path.abspath(__file__)),
+        capture_output=True,
+        text=True
+    )
+
+    if validate_result.returncode != 0:
+        print("      ❌ Validation failed:", file=sys.stderr)
+        print(validate_result.stderr, file=sys.stderr)
+        sys.exit(1)
+
+    print("      ✓ Validation passed", file=sys.stderr)
+    print()
+
+    # Step 5: Create (or dry-run)
+    if args.dry_run:
+        print("[5/5] DRY RUN - Showing summary...", file=sys.stderr)
+        print()
+        subprocess.run(
+            ['python3', 'create_polarion_tc.py', draft_file, '--dry-run'],
+            cwd=os.path.dirname(os.path.abspath(__file__))
+        )
+    else:
+        print("[5/5] Creating Polarion TC...", file=sys.stderr)
+        print()
+        result = subprocess.run(
+            ['python3', 'create_polarion_tc.py', draft_file],
+            cwd=os.path.dirname(os.path.abspath(__file__))
+        )
+        sys.exit(result.returncode)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/fetch_github_pr.py b/.claude/scripts/fetch_github_pr.py
new file mode 100755
index 0000000000..0fea9f4c4c
--- /dev/null
+++ b/.claude/scripts/fetch_github_pr.py
@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""
+Fetch GitHub PR and parse QE Pre-merge testing comment.
+
+Usage:
+    python3 fetch_github_pr.py --repo openshift/machine-config-operator --pr 5691 --comment 4054832254
+    python3 fetch_github_pr.py --repo openshift/machine-config-operator --pr 5691  # fetch all comments
+
+Output:
+    /tmp/test-specs/drafts/pr-<number>.json
+"""
+
+import json
+import os
+import re
+import sys
+from typing import Dict, Any, List, Optional
+import requests
+
+
+def load_env():
+    """Load .env file from repo root"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(os.path.dirname(script_dir))
+    env_file = os.path.join(repo_root, '.env')
+
+    env_vars = {}
+    if os.path.exists(env_file):
+        with open(env_file) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    env_vars[key] = value
+
+    return env_vars
+
+
+def fetch_pr_details(repo: str, pr_number: int, github_token: Optional[str] = None) -> Dict:
+    """Fetch PR details from GitHub API"""
+    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
+    headers = {"Accept": "application/vnd.github.v3+json"}
+
+    if github_token and github_token != 'your_github_token_here':
+        headers["Authorization"] = f"token {github_token}"
+
+    try:
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 401 and github_token:
+            # Token invalid, try without auth for public repo
+            print(f"Warning: GitHub token invalid, trying without authentication...", file=sys.stderr)
+            headers.pop("Authorization", None)
+            response = requests.get(url, headers=headers, timeout=30)
+            response.raise_for_status()
+            return response.json()
+        raise
+
+
+def fetch_pr_comments(repo: str, pr_number: int, github_token: Optional[str] = None) -> List[Dict]:
+    """Fetch PR comments from GitHub API"""
+    url = f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments"
+    headers = {"Accept": "application/vnd.github.v3+json"}
+
+    if github_token and github_token != 'your_github_token_here':
+        headers["Authorization"] = f"token {github_token}"
+
+    try:
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 401 and github_token:
+            # Token invalid, try without auth for public repo
+            print(f"Warning: GitHub token invalid, trying without authentication...", file=sys.stderr)
+            headers.pop("Authorization", None)
+            response = requests.get(url, headers=headers, timeout=30)
+            response.raise_for_status()
+            return response.json()
+        raise
+
+
+def extract_jira_id(text: str) -> Optional[str]:
+    """Extract Jira ID from PR title or body"""
+    # Match OCPBUGS-12345 or MCO-1234
+    match = re.search(r'(OCPBUGS-\d+|MCO-\d+)', text, re.IGNORECASE)
+    if match:
+        return match.group(1).upper()
+    return None
+
+
+def parse_environment_setup(content: str) -> Dict[str, str]:
+    """Parse Environment Setup section"""
+    env_data = {}
+
+    # Find Environment Setup section (with or without ##)
+    env_match = re.search(r'(?:##\s*)?Environment Setup:\s*\n(.*?)(?=\n(?:##\s*)?\w+:|\Z)', content, re.DOTALL | re.IGNORECASE)
+    if not env_match:
+        # Try with ## header only
+        env_match = re.search(r'##\s*Environment Setup\s*\n(.*?)(?=\n##|\Z)', content, re.DOTALL | re.IGNORECASE)
+
+    if not env_match:
+        return env_data
+
+    env_section = env_match.group(1)
+
+    # Parse key-value pairs
+    patterns = {
+        'version': r'(?:OCP\s+)?[Vv]ersion[:\s]+([0-9.-]+)',  # Allow dashes for extended versions
+        'platform': r'[Pp]latform[:\s]+(\w+)',
+        'cluster_type': r'[Cc]luster\s+[Tt]ype[:\s]+(.+)',
+        'nodes': r'[Nn]odes?[:\s]+(\d+)',
+    }
+
+    for key, pattern in patterns.items():
+        match = re.search(pattern, env_section)
+        if match:
+            value = match.group(1).strip()
+            # For version, extract base version (4.22) from extended format
+            if key == 'version':
+                base_version = re.match(r'(\d+\.\d+)', value)
+                if base_version:
+                    env_data[key] = base_version.group(1)
+                else:
+                    env_data[key] = value
+            else:
+                env_data[key] = value
+
+    return env_data
+
+
+def parse_test_steps(content: str) -> List[Dict[str, str]]:
+    """
+    Parse test steps from QE comment format:
+    - Bullet points → step column
+    - ``` code blocks → expected_result column
+    """
+    steps = []
+
+    # Find Test Steps or Testing Steps section (with or without ##)
+    steps_match = re.search(
+        r'(?:##\s*)?(?:Test(?:ing)?\s+)?Steps:\s*\n(.*?)(?=\n##|\n[A-Z][a-z]+:|\Z)',
+        content,
+        re.DOTALL | re.IGNORECASE
+    )
+
+    if not steps_match:
+        # Try standard ## header format
+        steps_match = re.search(
+            r'##\s*(?:Test(?:ing)?\s+Steps|Steps)\s*\n(.*?)(?=\n##|\Z)',
+            content,
+            re.DOTALL | re.IGNORECASE
+        )
+
+    if not steps_match:
+        return steps
+
+    steps_section = steps_match.group(1)
+
+    # Split by bullets
+    bullet_pattern = r'^[-*]\s+(.+?)(?=^[-*]\s+|\Z)'
+    bullets = re.findall(bullet_pattern, steps_section, re.MULTILINE | re.DOTALL)
+
+    for bullet_content in bullets:
+        # Extract step text (before code block)
+        # Extract code block as expected result
+        step_text = bullet_content.strip()
+        expected_result = ''
+
+        # Find code blocks (handle both ``` and inline code)
+        code_blocks = re.findall(r'```(?:\w+)?\s*\n(.*?)```', bullet_content, re.DOTALL)
+        if code_blocks:
+            # Concatenate all code blocks for this step
+            expected_result = '\n\n'.join(block.strip() for block in code_blocks)
+
+            # Remove code blocks from step text
+            step_text = re.sub(r'```(?:\w+)?\s*\n.*?```', '', bullet_content, flags=re.DOTALL).strip()
+        else:
+            # No code block found - split at newline to see if there's prose after the bullet
+            lines = bullet_content.strip().split('\n', 1)
+            step_text = lines[0].strip()
+            if len(lines) > 1:
+                # Use remaining lines as expected result
+                expected_result = lines[1].strip()
+
+        # Clean up step text (remove extra whitespace)
+        step_text = re.sub(r'\s+', ' ', step_text).strip()
+
+        if step_text:
+            steps.append({
+                'step': step_text,
+                'expected_result': expected_result
+            })
+
+    return steps
+
+
+def find_qe_comment(comments: List[Dict]) -> Optional[Dict]:
+    """Find QE pre-merge testing comment"""
+    for comment in comments:
+        body = comment.get('body', '')
+        if re.search(r'pre-?merge\s+test(?:ing)?', body, re.IGNORECASE):
+            return comment
+
+        # Also check for "Test Steps" or "Environment Setup" headers
+        if re.search(r'##\s*(?:Test(?:ing)?\s+Steps|Environment Setup)', body, re.IGNORECASE):
+            return comment
+
+    return None
+
+
+def parse_qe_comment(comment_body: str, pr_title: str, pr_body: str) -> Dict:
+    """Parse QE comment into test case draft"""
+    # Extract Jira ID from PR title or body
+    jira_id = extract_jira_id(pr_title) or extract_jira_id(pr_body or '')
+
+    # Create title
+    title = pr_title
+    if jira_id and not title.startswith('[MCO]'):
+        title = f"[MCO][{jira_id}] {title}"
+
+    # Parse environment
+    env_data = parse_environment_setup(comment_body)
+
+    # Parse test steps
+    test_steps = parse_test_steps(comment_body)
+
+    # Extract description from comment (before ## sections)
+    description_match = re.search(r'^(.*?)(?=\n##|\Z)', comment_body, re.DOTALL)
+    description = description_match.group(1).strip() if description_match else ''
+
+    # Build draft
+    draft = {
+        'title': title,
+        'description': description or pr_title,
+        'component': 'Machine Config Operator',
+        'sub_team': 'MCO',
+        'products': 'OCP',
+        'test_type': 'Functional',
+        'version': env_data.get('version', ''),
+        'trello_jira': jira_id or '',
+        'test_steps': test_steps,
+        'metadata': {
+            'source_pr': pr_title,
+            'environment': env_data
+        }
+    }
+
+    return draft
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Fetch GitHub PR and parse QE testing comment')
+    parser.add_argument('--repo', required=True, help='Repository (e.g., openshift/machine-config-operator)')
+    parser.add_argument('--pr', type=int, required=True, help='PR number')
+    parser.add_argument('--comment', type=int, help='Comment ID (optional - will find QE comment if not provided)')
+    parser.add_argument('--output', help='Output file (default: /tmp/test-specs/drafts/pr-<number>.json)')
+
+    args = parser.parse_args()
+
+    # Load environment
+    env = load_env()
+    github_token = env.get('GITHUB_TOKEN')
+
+    if not github_token:
+        print("Warning: GITHUB_TOKEN not found in .env (rate limits may apply)", file=sys.stderr)
+
+    try:
+        # Fetch PR details
+        print(f"Fetching PR #{args.pr} from {args.repo}...", file=sys.stderr)
+        pr_data = fetch_pr_details(args.repo, args.pr, github_token)
+        pr_title = pr_data['title']
+        pr_body = pr_data.get('body', '')
+
+        print(f"PR Title: {pr_title}", file=sys.stderr)
+
+        # Fetch comments
+        print("Fetching comments...", file=sys.stderr)
+        comments = fetch_pr_comments(args.repo, args.pr, github_token)
+
+        # Find target comment
+        target_comment = None
+        if args.comment:
+            # Find specific comment by ID
+            for comment in comments:
+                if comment['id'] == args.comment:
+                    target_comment = comment
+                    break
+
+            if not target_comment:
+                print(f"Error: Comment {args.comment} not found", file=sys.stderr)
+                sys.exit(1)
+        else:
+            # Find QE comment
+            target_comment = find_qe_comment(comments)
+            if not target_comment:
+                print("Error: No QE pre-merge testing comment found", file=sys.stderr)
+                print("Use --comment <id> to specify a specific comment", file=sys.stderr)
+                sys.exit(1)
+
+        comment_body = target_comment['body']
+        comment_id = target_comment['id']
+
+        print(f"Found comment {comment_id}", file=sys.stderr)
+
+        # Parse comment
+        draft = parse_qe_comment(comment_body, pr_title, pr_body)
+
+        # Output
+        if args.output:
+            output_file = args.output
+        else:
+            output_dir = '/tmp/test-specs/drafts'
+            os.makedirs(output_dir, exist_ok=True)
+            output_file = os.path.join(output_dir, f"pr-{args.pr}.json")
+
+        # Write draft
+        with open(output_file, 'w') as f:
+            json.dump(draft, f, indent=2)
+
+        print(f"\n✓ Draft saved to: {output_file}", file=sys.stderr)
+        print(f"  Title: {draft['title']}", file=sys.stderr)
+        print(f"  Jira: {draft.get('trello_jira', 'NOT FOUND')}", file=sys.stderr)
+        print(f"  Version: {draft.get('version', 'NOT FOUND')}", file=sys.stderr)
+        print(f"  Test Steps: {len(draft['test_steps'])}", file=sys.stderr)
+
+        # Also output JSON to stdout
+        print(json.dumps(draft, indent=2))
+
+    except requests.HTTPError as e:
+        print(f"GitHub API error: {e}", file=sys.stderr)
+        print(f"Response: {e.response.text if hasattr(e, 'response') else 'N/A'}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/fetch_jira.py b/.claude/scripts/fetch_jira.py
new file mode 100755
index 0000000000..ddc536008d
--- /dev/null
+++ b/.claude/scripts/fetch_jira.py
@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+Fetch Jira issue from redhat.atlassian.net.
+
+Usage:
+    python3 fetch_jira.py MCO-2221
+    python3 fetch_jira.py OCPBUGS-74223
+
+Output:
+    - /tmp/test-specs/jira/<issue-key>.json (draft format)
+    - JSON to stdout (summary, description, fix versions, acceptance criteria)
+
+No MCP required - uses direct Atlassian REST API.
+"""
+
+import json
+import os
+import sys
+import re
+from typing import Dict, Any, Optional
+import requests
+
+
+def load_env():
+    """Load .env file from repo root"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(os.path.dirname(script_dir))
+    env_file = os.path.join(repo_root, '.env')
+
+    env_vars = {}
+    if os.path.exists(env_file):
+        with open(env_file) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    env_vars[key] = value
+
+    return env_vars
+
+
+def fetch_jira_issue(issue_key: str, jira_url: str, jira_token: Optional[str] = None, jira_email: Optional[str] = None) -> Dict[str, Any]:
+    """Fetch Jira issue from Atlassian REST API"""
+
+    # Build URL
+    api_url = f"{jira_url}/rest/api/3/issue/{issue_key}"
+
+    # Headers
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json"
+    }
+
+    # Auth: Try Bearer token first, fall back to Basic auth (email:token)
+    if jira_token:
+        if jira_email:
+            # Basic Auth with email:token (Atlassian Cloud requires this)
+            import base64
+            credentials = base64.b64encode(f"{jira_email}:{jira_token}".encode()).decode()
+            headers["Authorization"] = f"Basic {credentials}"
+        else:
+            # Try Bearer token (may not work for all Atlassian instances)
+            headers["Authorization"] = f"Bearer {jira_token}"
+
+    try:
+        response = requests.get(api_url, headers=headers, timeout=30)
+        response.raise_for_status()
+
+        return response.json()
+
+    except requests.HTTPError as e:
+        if e.response.status_code == 401:
+            raise Exception("Authentication failed. Check JIRA_TOKEN in .env")
+        elif e.response.status_code == 404:
+            raise Exception(f"Jira issue not found: {issue_key}")
+        else:
+            raise Exception(f"Jira API error: {e.response.status_code} - {e.response.text}")
+    except Exception as e:
+        raise Exception(f"Failed to fetch Jira issue: {e}")
+
+
+def parse_jira_to_draft(issue_data: Dict, issue_key: str) -> Dict[str, Any]:
+    """Parse Jira issue data to Polarion draft format"""
+
+    fields = issue_data.get('fields', {})
+
+    # Summary
+    summary = fields.get('summary', '')
+
+    # Description (may be in ADF or plain text)
+    description_obj = fields.get('description', {})
+    description = ''
+
+    if isinstance(description_obj, dict):
+        # ADF format
+        if description_obj.get('type') == 'doc':
+            # Extract text from ADF content
+            description = extract_text_from_adf(description_obj)
+        elif 'content' in description_obj:
+            description = str(description_obj.get('content', ''))
+    elif isinstance(description_obj, str):
+        description = description_obj
+
+    # Fix Versions
+    fix_versions = fields.get('fixVersions', [])
+    version = ''
+    if fix_versions:
+        # Take first version, extract version number (e.g., "4.18.0" -> "4.18")
+        version_name = fix_versions[0].get('name', '')
+        # Extract X.Y from X.Y.Z
+        version_match = re.match(r'(\d+\.\d+)', version_name)
+        if version_match:
+            version = version_match.group(1)
+        else:
+            version = version_name
+
+    # Acceptance Criteria (custom field - may vary by project)
+    # Common field names: customfield_12311140, acceptanceCriteria
+    acceptance_criteria = ''
+
+    # Try common acceptance criteria field names
+    for field_name in ['customfield_12311140', 'customfield_12315140', 'acceptanceCriteria']:
+        if field_name in fields:
+            ac_value = fields[field_name]
+            if isinstance(ac_value, str):
+                acceptance_criteria = ac_value
+            elif isinstance(ac_value, dict):
+                # ADF format
+                acceptance_criteria = extract_text_from_adf(ac_value)
+            break
+
+    # Issue Type
+    issue_type = fields.get('issuetype', {}).get('name', '')
+
+    # Labels
+    labels = fields.get('labels', [])
+
+    # Build draft
+    # Title format: [MCO][ISSUE-KEY] Summary
+    title = f"[MCO][{issue_key}] {summary}"
+
+    draft = {
+        'title': title,
+        'description': description or summary,
+        'component': 'Machine Config Operator',
+        'sub_team': 'MCO',
+        'products': 'OCP',
+        'test_type': 'Functional',  # Default, can be overridden
+        'version': version,
+        'trello_jira': issue_key,
+        'test_steps': [],  # To be filled from PR or manually
+        'metadata': {
+            'source_jira': issue_key,
+            'jira_type': issue_type,
+            'labels': labels,
+            'acceptance_criteria': acceptance_criteria
+        }
+    }
+
+    return draft
+
+
+def extract_text_from_adf(adf: Dict) -> str:
+    """Extract plain text from Atlassian Document Format (ADF)"""
+    if not isinstance(adf, dict):
+        return str(adf)
+
+    text_parts = []
+
+    def extract_recursive(node):
+        if isinstance(node, dict):
+            # Text node
+            if node.get('type') == 'text':
+                text_parts.append(node.get('text', ''))
+
+            # Paragraph, heading, etc.
+            if 'content' in node:
+                for child in node['content']:
+                    extract_recursive(child)
+
+        elif isinstance(node, list):
+            for item in node:
+                extract_recursive(item)
+
+    extract_recursive(adf)
+
+    return '\n'.join(text_parts).strip()
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='Fetch Jira issue and convert to Polarion draft',
+        epilog="""
+Examples:
+  python3 fetch_jira.py MCO-2221
+  python3 fetch_jira.py OCPBUGS-74223
+  python3 fetch_jira.py MCO-2221 --output /tmp/custom.json
+
+Requires:
+  JIRA_URL in .env (default: https://redhat.atlassian.net)
+  JIRA_EMAIL in .env (your Red Hat email)
+  JIRA_TOKEN in .env (Atlassian API token)
+        """
+    )
+
+    parser.add_argument('issue_key', help='Jira issue key (e.g., MCO-2221, OCPBUGS-74223)')
+    parser.add_argument('--output', help='Output file path (default: /tmp/test-specs/jira/<issue-key>.json)')
+
+    args = parser.parse_args()
+
+    # Load environment
+    env = load_env()
+    jira_url = env.get('JIRA_URL', 'https://redhat.atlassian.net')
+    jira_token = env.get('JIRA_TOKEN')
+    jira_email = env.get('JIRA_EMAIL')
+
+    if not jira_token:
+        print("Warning: JIRA_TOKEN not found in .env (may fail with auth error)", file=sys.stderr)
+        print("Generate token at: https://id.atlassian.com/manage-profile/security/api-tokens", file=sys.stderr)
+        print()
+
+    if jira_token and not jira_email:
+        print("Warning: JIRA_EMAIL not found in .env (Basic auth may not work)", file=sys.stderr)
+        print("Set JIRA_EMAIL=you@redhat.com in .env for Atlassian Cloud authentication", file=sys.stderr)
+        print()
+
+    try:
+        # Fetch Jira issue
+        print(f"Fetching Jira issue: {args.issue_key} from {jira_url}", file=sys.stderr)
+        issue_data = fetch_jira_issue(args.issue_key, jira_url, jira_token, jira_email)
+
+        # Parse to draft
+        draft = parse_jira_to_draft(issue_data, args.issue_key)
+
+        # Output file
+        if args.output:
+            output_file = args.output
+        else:
+            output_dir = '/tmp/test-specs/jira'
+            os.makedirs(output_dir, exist_ok=True)
+            output_file = os.path.join(output_dir, f"{args.issue_key}.json")
+
+        # Write draft
+        with open(output_file, 'w') as f:
+            json.dump(draft, f, indent=2)
+
+        print(f"\n✓ Draft saved to: {output_file}", file=sys.stderr)
+        print(f"  Title: {draft['title']}", file=sys.stderr)
+        print(f"  Version: {draft.get('version', 'NOT FOUND')}", file=sys.stderr)
+        print(f"  Jira Type: {draft['metadata'].get('jira_type', 'Unknown')}", file=sys.stderr)
+
+        if draft['metadata'].get('acceptance_criteria'):
+            print(f"  Acceptance Criteria: Found", file=sys.stderr)
+
+        # Output JSON to stdout
+        print(json.dumps(draft, indent=2))
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/fetch_polarion.py b/.claude/scripts/fetch_polarion.py
new file mode 100755
index 0000000000..0ce2cae0ad
--- /dev/null
+++ b/.claude/scripts/fetch_polarion.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+Fetch Polarion test case and output in multiple formats.
+
+Usage:
+    python3 fetch_polarion.py OCP-88122
+    python3 fetch_polarion.py OSE-12345 --project OSE
+
+Output:
+    - /tmp/test-specs/OCP-88122.txt (format for /automate-test)
+    - JSON to stdout (title, steps, custom fields)
+"""
+
+import json
+import os
+import sys
+import re
+from typing import Dict, Any, List
+from polarion_client import PolarionClient
+
+
+def load_env():
+    """Load .env file from repo root"""
+    # Assume script is in .claude/scripts/, so repo root is ../..
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(os.path.dirname(script_dir))
+    env_file = os.path.join(repo_root, '.env')
+
+    if not os.path.exists(env_file):
+        print(f"Error: .env not found at {env_file}", file=sys.stderr)
+        print("Run: ./scripts/setup.sh", file=sys.stderr)
+        sys.exit(1)
+
+    env_vars = {}
+    with open(env_file) as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith('#') and '=' in line:
+                key, value = line.split('=', 1)
+                env_vars[key] = value
+
+    return env_vars
+
+
+def parse_test_case_id(tc_id: str) -> tuple:
+    """Parse test case ID to extract project and ID"""
+    # Format: OCP-88122 or OSE-12345
+    match = re.match(r'^([A-Z]+)-(\d+)$', tc_id)
+    if not match:
+        raise ValueError(f"Invalid test case ID format: {tc_id}")
+
+    prefix = match.group(1)
+    number = match.group(2)
+
+    # Map prefix to project
+    project_map = {
+        'OCP': 'OSE',  # OpenShift project in Polarion is OSE
+        'OSE': 'OSE',
+    }
+
+    project = project_map.get(prefix, 'OSE')
+    return project, tc_id
+
+
+def extract_test_steps(data: Dict) -> List[Dict[str, str]]:
+    """Extract test steps from Polarion response"""
+    steps = []
+
+    # Test steps are in included section
+    included = data.get('included', [])
+    for item in included:
+        if item.get('type') == 'teststeps':
+            attrs = item.get('attributes', {})
+            values = attrs.get('values', [])
+
+            # Values array typically has [step, expectedResult]
+            step_text = ''
+            expected_text = ''
+
+            if len(values) >= 1:
+                step_value = values[0]
+                if isinstance(step_value, dict):
+                    step_text = html_to_text(step_value.get('value', ''))
+
+            if len(values) >= 2:
+                expected_value = values[1]
+                if isinstance(expected_value, dict):
+                    expected_text = html_to_text(expected_value.get('value', ''))
+
+            steps.append({
+                'step': step_text,
+                'expected_result': expected_text
+            })
+
+    return steps
+
+
+def html_to_text(html: str) -> str:
+    """Convert HTML to plain text, preserving structure"""
+    if not html:
+        return ''
+
+    text = html
+
+    # Preserve preformatted blocks (code, commands)
+    # Replace <pre> and <code> with placeholders to preserve content
+    text = re.sub(r'<pre[^>]*>(.*?)</pre>', r'\n\1\n', text, flags=re.IGNORECASE | re.DOTALL)
+    text = re.sub(r'<code[^>]*>(.*?)</code>', r'\1', text, flags=re.IGNORECASE | re.DOTALL)
+
+    # Convert paragraphs and divs to double newlines
+    text = re.sub(r'</?p[^>]*>', '\n\n', text, flags=re.IGNORECASE)
+    text = re.sub(r'</?div[^>]*>', '\n', text, flags=re.IGNORECASE)
+
+    # Convert lists
+    text = re.sub(r'<li[^>]*>', '\n- ', text, flags=re.IGNORECASE)
+    text = re.sub(r'</li>', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'</?[ou]l[^>]*>', '\n', text, flags=re.IGNORECASE)
+
+    # Convert line breaks
+    text = re.sub(r'<br\s*/?>', '\n', text, flags=re.IGNORECASE)
+
+    # Remove remaining HTML tags
+    text = re.sub(r'<[^>]+>', '', text)
+
+    # Decode HTML entities
+    text = text.replace('&amp;', '&')
+    text = text.replace('&lt;', '<')
+    text = text.replace('&gt;', '>')
+    text = text.replace('&quot;', '"')
+    text = text.replace('&#39;', "'")
+    text = text.replace('&nbsp;', ' ')
+
+    # Clean up excessive newlines (max 2 consecutive)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+
+    return text.strip()
+
+
+def extract_custom_fields(attrs: Dict) -> Dict[str, Any]:
+    """Extract custom fields from work item attributes"""
+    custom_fields = {}
+
+    # Map of custom field keys to friendly names
+    field_map = {
+        'casecomponent': 'component',
+        'subteam2': 'sub_team',
+        'mcoproducts': 'products',
+        'casetesttype': 'test_type',
+        'plannedin': 'version',
+        'linkedworkitems': 'trello_jira',
+    }
+
+    for polarion_key, friendly_key in field_map.items():
+        value = attrs.get(polarion_key)
+        if value:
+            # Handle different value types
+            if isinstance(value, dict):
+                # EnumOption or similar
+                custom_fields[friendly_key] = value.get('id') or value.get('label', '')
+            elif isinstance(value, list):
+                # Special handling for linkedworkitems (extract work item IDs)
+                if polarion_key == 'linkedworkitems':
+                    # Extract work item keys/IDs from array of work item objects
+                    work_items = []
+                    for v in value:
+                        if isinstance(v, dict):
+                            # Try to get work item ID/key
+                            item_id = v.get('id') or v.get('workItemId') or v.get('key', '')
+                            if item_id:
+                                work_items.append(item_id)
+                        elif isinstance(v, str):
+                            work_items.append(v)
+                    # Join multiple work items with comma, or return first one
+                    custom_fields[friendly_key] = ', '.join(work_items) if work_items else ''
+                elif polarion_key == 'plannedin':
+                    # Version field - take first version if array
+                    versions = []
+                    for v in value:
+                        if isinstance(v, dict):
+                            versions.append(v.get('id') or v.get('label', ''))
+                        else:
+                            versions.append(str(v))
+                    custom_fields[friendly_key] = versions[0] if versions else ''
+                else:
+                    # Other arrays - extract IDs/labels
+                    custom_fields[friendly_key] = [
+                        v.get('id', v) if isinstance(v, dict) else v
+                        for v in value
+                    ]
+            else:
+                custom_fields[friendly_key] = value
+
+    return custom_fields
+
+
+def format_for_automate_test(tc_data: Dict) -> str:
+    """Format test case for /automate-test command"""
+    lines = []
+
+    # Title and metadata
+    lines.append(f"Test Case: {tc_data['id']}")
+    lines.append(f"Title: {tc_data['title']}")
+    lines.append("")
+
+    # Description
+    if tc_data.get('description'):
+        lines.append("Description:")
+        lines.append(tc_data['description'])
+        lines.append("")
+
+    # Custom fields
+    fields = tc_data.get('custom_fields', {})
+    if fields:
+        lines.append("Metadata:")
+        for key, value in fields.items():
+            if value:
+                lines.append(f"  {key}: {value}")
+        lines.append("")
+
+    # Test steps
+    steps = tc_data.get('test_steps', [])
+    if steps:
+        lines.append("Test Steps:")
+        lines.append("")
+        for i, step in enumerate(steps, 1):
+            lines.append(f"Step {i}:")
+            lines.append(step['step'])
+            lines.append("")
+            lines.append("Expected Result:")
+            lines.append(step['expected_result'])
+            lines.append("")
+            lines.append("-" * 80)
+            lines.append("")
+
+    return '\n'.join(lines)
+
+
+def fetch_test_case(tc_id: str, project: str = None) -> Dict:
+    """Fetch test case from Polarion"""
+    env = load_env()
+
+    polarion_url = env.get('POLARION_URL', 'https://polarion.engineering.redhat.com')
+    polarion_token = env.get('POLARION_TOKEN', '')
+
+    if not polarion_token or polarion_token == 'your_personal_access_token_here':
+        print("Error: POLARION_TOKEN not configured in .env", file=sys.stderr)
+        print("Generate token at: https://polarion.engineering.redhat.com/polarion/#/user/me", file=sys.stderr)
+        sys.exit(1)
+
+    # Parse project from TC ID if not provided
+    if not project:
+        project, tc_id = parse_test_case_id(tc_id)
+
+    # Create client
+    client = PolarionClient(
+        url=polarion_url,
+        token=polarion_token,
+        verify_ssl=True
+    )
+
+    # Fetch test case with steps
+    result = client.get_test_case(tc_id, project, include_test_steps=True)
+
+    if result['status'] == 'failed':
+        print(f"Error fetching test case: {result['error']}", file=sys.stderr)
+        sys.exit(1)
+
+    data = result['data']
+    work_item = data.get('data', {})
+    attrs = work_item.get('attributes', {})
+
+    # Extract basic fields
+    tc_data = {
+        'id': tc_id,
+        'project': project,
+        'title': attrs.get('title', ''),
+        'description': html_to_text(attrs.get('description', {}).get('value', '')),
+        'status': attrs.get('status', ''),
+        'type': attrs.get('type', ''),
+    }
+
+    # Extract test steps from REST API
+    tc_data['test_steps'] = extract_test_steps(data)
+
+    # If no test steps from REST API, try SOAP API as fallback
+    if not tc_data['test_steps']:
+        soap_result = client._soap_get_test_steps(tc_id, project)
+        if soap_result['status'] == 'success':
+            tc_data['test_steps'] = soap_result['steps']
+
+    # Fetch custom fields (need separate call for full attributes)
+    custom_result = client.get_workitem_custom_fields(tc_id, project)
+    if custom_result['status'] == 'success':
+        custom_data = custom_result['data']
+        custom_attrs = custom_data.get('data', {}).get('attributes', {})
+        tc_data['custom_fields'] = extract_custom_fields(custom_attrs)
+    else:
+        tc_data['custom_fields'] = {}
+
+    return tc_data
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 fetch_polarion.py <test-case-id> [--project <project>]")
+        print()
+        print("Examples:")
+        print("  python3 fetch_polarion.py OCP-88122")
+        print("  python3 fetch_polarion.py OSE-12345 --project OSE")
+        sys.exit(1)
+
+    tc_id = sys.argv[1]
+    project = None
+
+    # Parse optional --project flag
+    if '--project' in sys.argv:
+        idx = sys.argv.index('--project')
+        if idx + 1 < len(sys.argv):
+            project = sys.argv[idx + 1]
+
+    # Fetch test case
+    tc_data = fetch_test_case(tc_id, project)
+
+    # Output JSON to stdout
+    print(json.dumps(tc_data, indent=2))
+
+    # Write text format for /automate-test
+    output_dir = '/tmp/test-specs'
+    os.makedirs(output_dir, exist_ok=True)
+
+    txt_file = os.path.join(output_dir, f"{tc_id}.txt")
+    txt_content = format_for_automate_test(tc_data)
+
+    with open(txt_file, 'w') as f:
+        f.write(txt_content)
+
+    print(f"\n✓ Test case saved to: {txt_file}", file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/polarion_client.py b/.claude/scripts/polarion_client.py
new file mode 100755
index 0000000000..f70bfe793c
--- /dev/null
+++ b/.claude/scripts/polarion_client.py
@@ -0,0 +1,395 @@
+"""
+Polarion REST API Client
+Adapted from ~/VSCode/polarion-mcp-server/polarion_client.py
+"""
+
+import os
+import requests
+import base64
+from typing import Optional, Dict, Any, List
+
+
+class PolarionClient:
+    """Client for Polarion REST API operations with SOAP fallback"""
+
+    def __init__(
+        self,
+        url: str,
+        token: str,
+        verify_ssl: bool = True,
+        username: Optional[str] = None,
+        password: Optional[str] = None
+    ):
+        self.url = url
+        self.token = token
+        self.verify_ssl = verify_ssl
+        self.base_url = f"{url}/polarion/rest/v1"
+        self.username = username
+        self.password = password
+        self.soap_url = f"{url}/polarion/ws/services/TestManagementWebService"
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Make authenticated request to Polarion REST API"""
+
+        url = f"{self.base_url}/{endpoint}"
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+        }
+
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=data,
+                params=params,
+                timeout=30,
+                verify=self.verify_ssl
+            )
+
+            if response.status_code == 401:
+                return {
+                    "error": "Authentication failed. Check POLARION_TOKEN.",
+                    "status": 401
+                }
+
+            if response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    return {
+                        "error": error_data.get("errors", [{}])[0].get("detail", "Unknown error"),
+                        "status": response.status_code,
+                        "response": error_data
+                    }
+                except:
+                    return {
+                        "error": response.text,
+                        "status": response.status_code
+                    }
+
+            return response.json() if response.content else {"success": True}
+
+        except Exception as e:
+            return {"error": str(e), "status": 0}
+
+    def get_test_case(
+        self,
+        test_case_id: str,
+        project_id: str,
+        include_test_steps: bool = True
+    ) -> Dict[str, Any]:
+        """Get test case details with test steps"""
+
+        params = {
+            "fields[workitems]": "title,description,status,type"
+        }
+        if include_test_steps:
+            params["include"] = "testSteps"
+            params["fields[teststeps]"] = "values"
+
+        result = self._make_request(
+            "GET",
+            f"projects/{project_id}/workitems/{test_case_id}",
+            params=params
+        )
+
+        if "error" in result:
+            return {
+                "status": "failed",
+                "error": result["error"]
+            }
+
+        return {
+            "status": "success",
+            "data": result
+        }
+
+    def get_workitem_custom_fields(
+        self,
+        test_case_id: str,
+        project_id: str
+    ) -> Dict[str, Any]:
+        """Get work item with all custom fields"""
+
+        # Get full work item to access custom fields
+        result = self._make_request(
+            "GET",
+            f"projects/{project_id}/workitems/{test_case_id}",
+            params={}
+        )
+
+        if "error" in result:
+            return {
+                "status": "failed",
+                "error": result["error"]
+            }
+
+        return {
+            "status": "success",
+            "data": result
+        }
+
+    def _soap_get_test_steps(
+        self,
+        test_case_id: str,
+        project_id: str
+    ) -> Dict[str, Any]:
+        """Get test steps using SOAP API (requires username/password)"""
+
+        if not self.username or not self.password:
+            return {
+                "status": "failed",
+                "error": "SOAP API requires username and password. Set POLARION_USERNAME and POLARION_PASSWORD in .env"
+            }
+
+        # Build SOAP request to get test steps
+        work_item_uri = f"subterra:data-service:objects:/default/{project_id}${{WorkItem}}{test_case_id}"
+
+        soap_request = f"""<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+                  xmlns:tes="http://ws.polarion.com/TestManagementWebService">
+   <soapenv:Header/>
+   <soapenv:Body>
+      <tes:getTestSteps>
+         <tes:workItemURI>{work_item_uri}</tes:workItemURI>
+      </tes:getTestSteps>
+   </soapenv:Body>
+</soapenv:Envelope>"""
+
+        # Make SOAP request with Basic Auth
+        auth = base64.b64encode(f"{self.username}:{self.password}".encode()).decode()
+        headers = {
+            "Content-Type": "text/xml; charset=utf-8",
+            "SOAPAction": "",
+            "Authorization": f"Basic {auth}"
+        }
+
+        try:
+            response = requests.post(
+                self.soap_url,
+                data=soap_request,
+                headers=headers,
+                verify=self.verify_ssl,
+                timeout=30
+            )
+
+            if response.status_code == 200:
+                # Parse SOAP response to extract test steps
+                import xml.etree.ElementTree as ET
+
+                root = ET.fromstring(response.text)
+                steps = []
+
+                # Find all step elements in the response
+                for step_elem in root.findall(".//{http://ws.polarion.com/TestManagementWebService}steps"):
+                    values = step_elem.findall(".//{http://ws.polarion.com/TestManagementWebService}values")
+
+                    step_text = ""
+                    expected_text = ""
+
+                    if len(values) >= 1:
+                        content = values[0].find(".//{http://ws.polarion.com/TestManagementWebService}content")
+                        if content is not None and content.text:
+                            step_text = content.text
+
+                    if len(values) >= 2:
+                        content = values[1].find(".//{http://ws.polarion.com/TestManagementWebService}content")
+                        if content is not None and content.text:
+                            expected_text = content.text
+
+                    steps.append({
+                        'step': step_text,
+                        'expected_result': expected_text
+                    })
+
+                return {
+                    "status": "success",
+                    "steps": steps
+                }
+            else:
+                return {
+                    "status": "failed",
+                    "error": f"SOAP request failed: {response.status_code}"
+                }
+
+        except Exception as e:
+            return {
+                "status": "failed",
+                "error": f"SOAP API error: {str(e)}"
+            }
+
+    def _soap_set_test_steps(
+        self,
+        test_case_id: str,
+        test_steps: List[Dict[str, str]],
+        project_id: str
+    ) -> Dict[str, Any]:
+        """Set test steps using SOAP API (requires username/password)"""
+
+        if not self.username or not self.password:
+            return {
+                "status": "failed",
+                "error": "SOAP API requires username and password. Set POLARION_USERNAME and POLARION_PASSWORD in .env"
+            }
+
+        # Build SOAP request
+        work_item_uri = f"subterra:data-service:objects:/default/{project_id}${{WorkItem}}{test_case_id}"
+
+        steps_xml = ""
+        for idx, step in enumerate(test_steps):
+            steps_xml += f"""
+            <steps>
+                <index>{idx}</index>
+                <values>
+                    <Text>
+                        <type>text/html</type>
+                        <content>{step.get('step', '').replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')}</content>
+                        <contentLossy>false</contentLossy>
+                    </Text>
+                    <Text>
+                        <type>text/html</type>
+                        <content>{step.get('expected_result', '').replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')}</content>
+                        <contentLossy>false</contentLossy>
+                    </Text>
+                </values>
+            </steps>"""
+
+        soap_request = f"""<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+                  xmlns:tes="http://ws.polarion.com/TestManagementWebService">
+   <soapenv:Header/>
+   <soapenv:Body>
+      <tes:setTestSteps>
+         <tes:workItemURI>{work_item_uri}</tes:workItemURI>
+         <tes:testSteps>
+            <tes:keys>step</tes:keys>
+            <tes:keys>expectedResult</tes:keys>
+            {steps_xml}
+         </tes:testSteps>
+      </tes:setTestSteps>
+   </soapenv:Body>
+</soapenv:Envelope>"""
+
+        # Make SOAP request with Basic Auth
+        auth = base64.b64encode(f"{self.username}:{self.password}".encode()).decode()
+        headers = {
+            "Content-Type": "text/xml; charset=utf-8",
+            "SOAPAction": "",
+            "Authorization": f"Basic {auth}"
+        }
+
+        try:
+            response = requests.post(
+                self.soap_url,
+                data=soap_request,
+                headers=headers,
+                verify=self.verify_ssl,
+                timeout=30
+            )
+
+            if response.status_code == 200:
+                return {
+                    "status": "success",
+                    "message": f"Updated {len(test_steps)} test steps via SOAP API",
+                    "test_case_id": test_case_id,
+                    "steps_added": len(test_steps),
+                    "method": "SOAP"
+                }
+            else:
+                return {
+                    "status": "failed",
+                    "error": f"SOAP request failed: {response.status_code} - {response.text}"
+                }
+
+        except Exception as e:
+            return {
+                "status": "failed",
+                "error": f"SOAP API error: {str(e)}"
+            }
+
+    def add_test_steps(
+        self,
+        test_case_id: str,
+        test_steps: List[Dict[str, str]],
+        project_id: str,
+        force_soap: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Add/update test steps.
+
+        REST API Limitation:
+        - Can only POST steps to NEW test cases (blank slate)
+        - For EXISTING test cases with steps: MUST use SOAP API
+
+        Strategies:
+        1. If force_soap=True: Use SOAP API directly
+        2. Otherwise: Try REST API first, fall back to SOAP if needed
+        """
+
+        # Force SOAP if requested
+        if force_soap:
+            return self._soap_set_test_steps(test_case_id, test_steps, project_id)
+
+        try:
+            # Check if test steps already exist
+            check_url = f"projects/{project_id}/workitems/{test_case_id}/relationships/testSteps"
+            existing = self._make_request("GET", check_url)
+
+            has_existing_steps = (
+                "error" not in existing and
+                len(existing.get("data", [])) > 0
+            )
+
+            # If steps exist, must use SOAP API
+            if has_existing_steps:
+                return self._soap_set_test_steps(test_case_id, test_steps, project_id)
+
+            # No existing steps - try REST API
+            steps_data = []
+            for step in test_steps:
+                step_obj = {
+                    "type": "teststeps",
+                    "attributes": {
+                        "keys": ["step", "expectedResult"],
+                        "values": [
+                            {"type": "text/html", "value": step.get("step", "").replace("\n", "<br/>")},
+                            {"type": "text/html", "value": step.get("expected_result", "").replace("\n", "<br/>")}
+                        ]
+                    }
+                }
+                steps_data.append(step_obj)
+
+            # POST test steps via REST API
+            result = self._make_request(
+                "POST",
+                f"projects/{project_id}/workitems/{test_case_id}/teststeps",
+                data={"data": steps_data}
+            )
+
+            if "error" in result:
+                # REST failed, try SOAP fallback
+                return self._soap_set_test_steps(test_case_id, test_steps, project_id)
+
+            created_steps = result.get("data", [])
+
+            return {
+                "status": "success",
+                "message": f"Added {len(created_steps)} test steps via REST API",
+                "test_case_id": test_case_id,
+                "steps_added": len(created_steps),
+                "method": "REST"
+            }
+
+        except Exception as e:
+            return {
+                "status": "failed",
+                "error": str(e)
+            }
diff --git a/.claude/scripts/setup.sh b/.claude/scripts/setup.sh
new file mode 100755
index 0000000000..64115f9e81
--- /dev/null
+++ b/.claude/scripts/setup.sh
@@ -0,0 +1,200 @@
+#!/bin/bash
+# MCO QE Tooling Setup Script
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLAUDE_DIR="$(dirname "$SCRIPT_DIR")"
+REPO_ROOT="$(dirname "$CLAUDE_DIR")"
+
+VERIFY_MODE=false
+if [[ "$1" == "--verify" ]]; then
+    VERIFY_MODE=true
+fi
+
+echo "=== MCO QE Tooling Setup ==="
+echo
+
+# Check Python version
+echo "Checking Python version..."
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python 3 not found. Please install Python 3.9 or higher."
+    exit 1
+fi
+
+PYTHON_VERSION=$(python3 --version | awk '{print $2}')
+PYTHON_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
+PYTHON_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)
+
+if [[ "$PYTHON_MAJOR" -lt 3 ]] || [[ "$PYTHON_MAJOR" -eq 3 && "$PYTHON_MINOR" -lt 9 ]]; then
+    echo "❌ Python 3.9+ required (found $PYTHON_VERSION)"
+    exit 1
+fi
+
+echo "✓ Python $PYTHON_VERSION found"
+echo
+
+# Check/install requests library
+echo "Checking Python dependencies..."
+if ! python3 -c "import requests" 2>/dev/null; then
+    if [[ "$VERIFY_MODE" == true ]]; then
+        echo "❌ requests library not installed"
+        exit 1
+    fi
+    echo "Installing requests library..."
+    python3 -m pip install --user requests
+    echo "✓ requests installed"
+else
+    echo "✓ requests already installed"
+fi
+echo
+
+# Check gh CLI
+echo "Checking gh CLI..."
+if ! command -v gh &> /dev/null; then
+    echo "⚠️  gh CLI not found (optional for GitHub integration)"
+    if [[ "$VERIFY_MODE" == true ]]; then
+        echo "   Install: https://cli.github.com/"
+    fi
+else
+    GH_VERSION=$(gh version 2>&1 | head -n1 | awk '{print $3}')
+    echo "✓ gh CLI $GH_VERSION found"
+
+    # Check gh auth status
+    if gh auth status &> /dev/null; then
+        GH_USER=$(gh api user --jq .login 2>/dev/null || echo "unknown")
+        echo "✓ gh authenticated as $GH_USER"
+    else
+        echo "⚠️  gh not authenticated (optional)"
+        if [[ "$VERIFY_MODE" == true ]]; then
+            echo "   Run: gh auth login"
+        fi
+    fi
+fi
+echo
+
+# Create /tmp/test-specs directory structure
+echo "Creating /tmp/test-specs directory structure..."
+mkdir -p /tmp/test-specs/{polarion,github,jira,steps}
+echo "✓ Created /tmp/test-specs/"
+echo "  - /tmp/test-specs/polarion/  (fetched Polarion TCs)"
+echo "  - /tmp/test-specs/github/    (fetched GitHub issues)"
+echo "  - /tmp/test-specs/jira/      (fetched Jira tickets)"
+echo "  - /tmp/test-specs/steps/     (test step definitions)"
+echo
+
+# Check if .env exists at repo root
+if [ ! -f "$REPO_ROOT/.env" ]; then
+    if [[ "$VERIFY_MODE" == true ]]; then
+        echo "❌ .env not found at repo root"
+        echo "   Copy from: cp .env.example .env"
+        exit 1
+    fi
+    echo "Creating .env from template..."
+    if [ -f "$REPO_ROOT/.env.example" ]; then
+        cp "$REPO_ROOT/.env.example" "$REPO_ROOT/.env"
+        echo "✓ Created .env (please edit with your credentials)"
+    else
+        echo "❌ .env.example not found at repo root"
+        exit 1
+    fi
+    echo
+    echo "⚠️  NEXT STEPS:"
+    echo "   1. Edit .env and add your POLARION_TOKEN"
+    echo "   2. Generate token at: https://polarion.engineering.redhat.com/polarion/#/user/me"
+    echo "   3. Run: ./scripts/setup.sh --verify"
+else
+    echo "✓ .env exists at repo root"
+
+    # Verify POLARION_TOKEN is set
+    if grep -q "^POLARION_TOKEN=your_personal_access_token_here" "$REPO_ROOT/.env" 2>/dev/null || \
+       ! grep -q "^POLARION_TOKEN=..*" "$REPO_ROOT/.env" 2>/dev/null; then
+        echo "⚠️  POLARION_TOKEN not configured in .env"
+        if [[ "$VERIFY_MODE" == true ]]; then
+            echo "❌ Setup incomplete - configure POLARION_TOKEN"
+            exit 1
+        fi
+    else
+        echo "✓ POLARION_TOKEN configured"
+
+        # Ping Polarion in verify mode
+        if [[ "$VERIFY_MODE" == true ]]; then
+            echo
+            echo "Testing Polarion connection..."
+
+            # Load .env
+            set -a
+            source "$REPO_ROOT/.env"
+            set +a
+
+            POLARION_URL=${POLARION_URL:-https://polarion.engineering.redhat.com}
+            POLARION_PROJECT=${POLARION_PROJECT:-OSE}
+
+            # Test connection with curl
+            HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
+                -H "Authorization: Bearer $POLARION_TOKEN" \
+                -H "Accept: application/json" \
+                "$POLARION_URL/polarion/rest/v1/projects/$POLARION_PROJECT" 2>/dev/null || echo "000")
+
+            if [[ "$HTTP_CODE" == "200" ]]; then
+                echo "✓ Polarion connection successful (HTTP 200)"
+
+                # Get project name
+                PROJECT_NAME=$(curl -s \
+                    -H "Authorization: Bearer $POLARION_TOKEN" \
+                    -H "Accept: application/json" \
+                    "$POLARION_URL/polarion/rest/v1/projects/$POLARION_PROJECT" 2>/dev/null | \
+                    python3 -c "import sys, json; print(json.load(sys.stdin)['data']['attributes']['name'])" 2>/dev/null || echo "")
+
+                if [[ -n "$PROJECT_NAME" ]]; then
+                    echo "  Project: $PROJECT_NAME ($POLARION_PROJECT)"
+                fi
+            elif [[ "$HTTP_CODE" == "401" ]]; then
+                echo "❌ Polarion authentication failed (HTTP 401)"
+                echo "   Check POLARION_TOKEN in .env"
+                exit 1
+            elif [[ "$HTTP_CODE" == "000" ]]; then
+                echo "❌ Cannot reach Polarion server"
+                echo "   Check network connection and POLARION_URL"
+                exit 1
+            else
+                echo "❌ Polarion returned HTTP $HTTP_CODE"
+                exit 1
+            fi
+        fi
+    fi
+fi
+echo
+
+# Update .gitignore
+echo "Updating .gitignore..."
+if ! grep -q "^\.env$" "$REPO_ROOT/.gitignore" 2>/dev/null; then
+    echo "
+# MCO QE Tooling
+.env
+.claude/.env" >> "$REPO_ROOT/.gitignore"
+    echo "✓ Added .env to .gitignore"
+else
+    echo "✓ .gitignore already configured"
+fi
+echo
+
+# Make scripts executable
+echo "Making scripts executable..."
+chmod +x "$SCRIPT_DIR"/*.sh
+chmod +x "$SCRIPT_DIR"/*.py 2>/dev/null || true
+echo "✓ Scripts are executable"
+echo
+
+if [[ "$VERIFY_MODE" == true ]]; then
+    echo "=== Verification Complete ==="
+    echo "✓ All checks passed"
+else
+    echo "=== Setup Complete ==="
+    echo
+    echo "Next steps:"
+    echo "1. Edit .env with your Polarion token"
+    echo "2. Run verification: ./scripts/setup.sh --verify"
+    echo "3. See .claude/README.md for usage examples"
+fi
+echo
diff --git a/.claude/scripts/update_polarion_tc.py b/.claude/scripts/update_polarion_tc.py
new file mode 100755
index 0000000000..2b040e7dbb
--- /dev/null
+++ b/.claude/scripts/update_polarion_tc.py
@@ -0,0 +1,460 @@
+#!/usr/bin/env python3
+"""
+Update existing Polarion test case.
+
+Usage:
+    python3 update_polarion_tc.py OCP-88941 --title "New title"
+    python3 update_polarion_tc.py OCP-88941 --fix-metadata --component "Machine Config Operator"
+    python3 update_polarion_tc.py OCP-88941 --steps-file /tmp/test-specs/steps/OCP-88941.json
+
+Fields that can be updated via REST API (token auth):
+- title, description, status, severity
+- Custom fields: component, sub_team, products, test_type, version, trello_jira
+
+Test steps:
+- REST API limitation: Can only POST steps to NEW test cases (blank slate)
+- For EXISTING test cases: Requires SOAP API with username/password
+- Set POLARION_USERNAME and POLARION_PASSWORD in .env for test step updates
+"""
+
+import json
+import os
+import sys
+from typing import Dict, Any, Optional
+from polarion_client import PolarionClient
+
+
+def load_env():
+    """Load .env file from repo root"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(os.path.dirname(script_dir))
+    env_file = os.path.join(repo_root, '.env')
+
+    if not os.path.exists(env_file):
+        print(f"Error: .env not found at {env_file}", file=sys.stderr)
+        print("Run: ./scripts/setup.sh", file=sys.stderr)
+        sys.exit(1)
+
+    env_vars = {}
+    with open(env_file) as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith('#') and '=' in line:
+                key, value = line.split('=', 1)
+                env_vars[key] = value
+
+    return env_vars
+
+
+def parse_test_case_id(tc_id: str) -> tuple:
+    """Parse test case ID to extract project and ID"""
+    import re
+    match = re.match(r'^([A-Z]+)-(\d+)$', tc_id)
+    if not match:
+        raise ValueError(f"Invalid test case ID format: {tc_id}")
+
+    prefix = match.group(1)
+    project_map = {
+        'OCP': 'OSE',
+        'OSE': 'OSE',
+    }
+
+    project = project_map.get(prefix, 'OSE')
+    return project, tc_id
+
+
+def update_test_case_fields(
+    client: PolarionClient,
+    tc_id: str,
+    project: str,
+    **kwargs
+) -> Dict[str, Any]:
+    """
+    Update test case fields via REST API.
+
+    Supported fields:
+    - title, description, status, severity (basic fields)
+    - component, sub_team, products, test_type, version, trello_jira (custom fields)
+    """
+
+    # Build attributes dict
+    attributes = {}
+
+    # Basic fields
+    if kwargs.get('title'):
+        attributes['title'] = kwargs['title']
+
+    if kwargs.get('description'):
+        attributes['description'] = {
+            'type': 'text/html',
+            'value': kwargs['description'].replace('\n', '<br/>')
+        }
+
+    if kwargs.get('status'):
+        attributes['status'] = kwargs['status']
+
+    if kwargs.get('severity'):
+        attributes['severity'] = kwargs['severity']
+
+    # Custom fields (map friendly names to Polarion field names)
+    custom_field_map = {
+        'component': 'casecomponent',
+        'sub_team': 'subteam2',
+        'products': 'mcoproducts',
+        'test_type': 'casetesttype',
+        'version': 'plannedin',
+        'trello_jira': 'linkedworkitems',
+    }
+
+    for friendly_name, polarion_name in custom_field_map.items():
+        if kwargs.get(friendly_name):
+            # plannedin expects array, others expect strings
+            if polarion_name == 'plannedin':
+                attributes[polarion_name] = [kwargs[friendly_name]]
+            else:
+                attributes[polarion_name] = kwargs[friendly_name]
+
+    if not attributes:
+        return {
+            'status': 'failed',
+            'error': 'No fields provided to update'
+        }
+
+    # Build PATCH request
+    update_data = {
+        'data': {
+            'type': 'workitems',
+            'id': f'{project}/{tc_id}',
+            'attributes': attributes
+        }
+    }
+
+    result = client._make_request(
+        'PATCH',
+        f'projects/{project}/workitems/{tc_id}',
+        data=update_data
+    )
+
+    if 'error' in result:
+        return {
+            'status': 'failed',
+            'error': result['error']
+        }
+
+    return {
+        'status': 'success',
+        'message': f'Updated {len(attributes)} field(s)',
+        'updated_fields': list(attributes.keys())
+    }
+
+
+def update_test_steps(
+    client: PolarionClient,
+    tc_id: str,
+    project: str,
+    steps_file: str,
+    force_soap: bool = False
+) -> Dict[str, Any]:
+    """
+    Update test steps.
+
+    REST API Limitation:
+    - Can only POST steps to NEW test cases (blank slate)
+    - For EXISTING test cases with steps: MUST use SOAP API
+
+    SOAP API Requirements:
+    - POLARION_USERNAME and POLARION_PASSWORD must be set in .env
+    - Uses Basic Auth instead of token
+    """
+
+    # Load steps from file
+    try:
+        with open(steps_file) as f:
+            steps_data = json.load(f)
+    except FileNotFoundError:
+        return {
+            'status': 'failed',
+            'error': f'Steps file not found: {steps_file}'
+        }
+    except json.JSONDecodeError as e:
+        return {
+            'status': 'failed',
+            'error': f'Invalid JSON in steps file: {e}'
+        }
+
+    # Ensure steps is a list
+    if isinstance(steps_data, dict):
+        steps = steps_data.get('test_steps', [])
+    elif isinstance(steps_data, list):
+        steps = steps_data
+    else:
+        return {
+            'status': 'failed',
+            'error': 'Steps file must contain array or object with test_steps key'
+        }
+
+    # Use add_test_steps from PolarionClient (handles REST vs SOAP logic)
+    # Note: For existing TCs, this will attempt REST first, then fall back to SOAP
+    result = client.add_test_steps(tc_id, steps, project, force_soap=force_soap)
+
+    return result
+
+
+def fix_metadata_fields(
+    client: PolarionClient,
+    tc_id: str,
+    project: str,
+    component: Optional[str] = None,
+    sub_team: Optional[str] = None,
+    products: Optional[str] = None,
+    test_type: Optional[str] = None,
+    version: Optional[str] = None,
+    trello_jira: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Fix empty metadata fields (like wrong.pdf - OCP-88941).
+
+    Use case: Batch update all required fields at once.
+    """
+
+    # Default values for MCO TCs
+    defaults = {
+        'component': component or 'Machine Config Operator',
+        'sub_team': sub_team or 'MCO',
+        'products': products or 'OCP',
+        'test_type': test_type or 'Functional',
+        'version': version,  # No default - should be specified
+        'trello_jira': trello_jira,  # No default - should be specified
+    }
+
+    # Filter out None values
+    updates = {k: v for k, v in defaults.items() if v is not None}
+
+    return update_test_case_fields(client, tc_id, project, **updates)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='Update existing Polarion test case',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Update title
+  python3 update_polarion_tc.py OCP-88941 --title "[MCO][OCPBUGS-83830] New title"
+
+  # Fix metadata fields
+  python3 update_polarion_tc.py OCP-88941 --fix-metadata --version 4.22 --trello-jira OCPBUGS-83830
+
+  # Update test steps (requires SOAP credentials for existing TC)
+  python3 update_polarion_tc.py OCP-88941 --steps-file /tmp/test-specs/steps/OCP-88941.json
+
+  # Update multiple fields
+  python3 update_polarion_tc.py OCP-88941 \\
+    --title "New title" \\
+    --status approved \\
+    --component "Machine Config Operator"
+
+REST API Limitation for Test Steps:
+  - Can only add steps to NEW test cases (blank slate)
+  - For EXISTING test cases: Requires SOAP API with username/password
+  - Set POLARION_USERNAME and POLARION_PASSWORD in .env
+        """
+    )
+
+    parser.add_argument('tc_id', help='Test case ID (e.g., OCP-88941)')
+    parser.add_argument('--project', default='OSE', help='Polarion project (default: OSE)')
+
+    # Basic fields
+    parser.add_argument('--title', help='Update title')
+    parser.add_argument('--description', help='Update description')
+    parser.add_argument('--status', help='Update status (draft, approved, etc.)')
+    parser.add_argument('--severity', help='Update severity')
+
+    # Custom fields
+    parser.add_argument('--component', help='Update component')
+    parser.add_argument('--sub-team', dest='sub_team', help='Update sub team')
+    parser.add_argument('--products', help='Update products')
+    parser.add_argument('--test-type', dest='test_type', help='Update test type')
+    parser.add_argument('--version', help='Update version')
+    parser.add_argument('--trello-jira', dest='trello_jira', help='Update Trello/Jira')
+
+    # Batch fix
+    parser.add_argument('--fix-metadata', action='store_true',
+                       help='Fix all empty metadata fields with defaults')
+
+    # Test steps
+    parser.add_argument('--steps-file', help='Update test steps from JSON file')
+    parser.add_argument('--force-soap', action='store_true',
+                       help='Force SOAP API for test steps (requires credentials)')
+
+    # Dry run
+    parser.add_argument('--dry-run', action='store_true',
+                       help='Show what would be updated without making changes')
+
+    args = parser.parse_args()
+
+    # Parse project from TC ID
+    try:
+        project, tc_id = parse_test_case_id(args.tc_id)
+        if args.project != 'OSE':
+            project = args.project
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Load environment
+    env = load_env()
+    polarion_url = env.get('POLARION_URL', 'https://polarion.engineering.redhat.com')
+    polarion_token = env.get('POLARION_TOKEN', '')
+    polarion_username = env.get('POLARION_USERNAME')
+    polarion_password = env.get('POLARION_PASSWORD')
+
+    if not polarion_token or polarion_token == 'your_personal_access_token_here':
+        print("Error: POLARION_TOKEN not configured in .env", file=sys.stderr)
+        print("Generate token at: https://polarion.engineering.redhat.com/polarion/#/user/me", file=sys.stderr)
+        sys.exit(1)
+
+    # Create client
+    client = PolarionClient(
+        url=polarion_url,
+        token=polarion_token,
+        verify_ssl=True,
+        username=polarion_username,
+        password=polarion_password
+    )
+
+    print(f"Updating test case: {tc_id} (project: {project})", file=sys.stderr)
+    print()
+
+    # Collect updates
+    updates_made = False
+
+    # Fix metadata
+    if args.fix_metadata:
+        print("Fixing metadata fields...", file=sys.stderr)
+
+        if args.dry_run:
+            print("DRY RUN: Would update metadata fields:", file=sys.stderr)
+            print(f"  component: {args.component or 'Machine Config Operator'}", file=sys.stderr)
+            print(f"  sub_team: {args.sub_team or 'MCO'}", file=sys.stderr)
+            print(f"  products: {args.products or 'OCP'}", file=sys.stderr)
+            print(f"  test_type: {args.test_type or 'Functional'}", file=sys.stderr)
+            print(f"  version: {args.version or 'NOT SET'}", file=sys.stderr)
+            print(f"  trello_jira: {args.trello_jira or 'NOT SET'}", file=sys.stderr)
+        else:
+            result = fix_metadata_fields(
+                client, tc_id, project,
+                component=args.component,
+                sub_team=args.sub_team,
+                products=args.products,
+                test_type=args.test_type,
+                version=args.version,
+                trello_jira=args.trello_jira
+            )
+
+            if result['status'] == 'success':
+                print(f"✓ {result['message']}", file=sys.stderr)
+                print(f"  Updated: {', '.join(result['updated_fields'])}", file=sys.stderr)
+                updates_made = True
+            else:
+                print(f"❌ Error: {result['error']}", file=sys.stderr)
+                sys.exit(1)
+
+        print()
+
+    # Update individual fields
+    field_updates = {}
+    if args.title:
+        field_updates['title'] = args.title
+    if args.description:
+        field_updates['description'] = args.description
+    if args.status:
+        field_updates['status'] = args.status
+    if args.severity:
+        field_updates['severity'] = args.severity
+    if args.component and not args.fix_metadata:
+        field_updates['component'] = args.component
+    if args.sub_team and not args.fix_metadata:
+        field_updates['sub_team'] = args.sub_team
+    if args.products and not args.fix_metadata:
+        field_updates['products'] = args.products
+    if args.test_type and not args.fix_metadata:
+        field_updates['test_type'] = args.test_type
+    if args.version and not args.fix_metadata:
+        field_updates['version'] = args.version
+    if args.trello_jira and not args.fix_metadata:
+        field_updates['trello_jira'] = args.trello_jira
+
+    if field_updates:
+        print("Updating fields...", file=sys.stderr)
+
+        if args.dry_run:
+            print("DRY RUN: Would update:", file=sys.stderr)
+            for key, value in field_updates.items():
+                print(f"  {key}: {value}", file=sys.stderr)
+        else:
+            result = update_test_case_fields(client, tc_id, project, **field_updates)
+
+            if result['status'] == 'success':
+                print(f"✓ {result['message']}", file=sys.stderr)
+                print(f"  Updated: {', '.join(result['updated_fields'])}", file=sys.stderr)
+                updates_made = True
+            else:
+                print(f"❌ Error: {result['error']}", file=sys.stderr)
+                sys.exit(1)
+
+        print()
+
+    # Update test steps
+    if args.steps_file:
+        print("Updating test steps...", file=sys.stderr)
+
+        if args.dry_run:
+            print(f"DRY RUN: Would update test steps from: {args.steps_file}", file=sys.stderr)
+            print("Note: Requires SOAP API for existing TCs", file=sys.stderr)
+        else:
+            # Check for SOAP credentials if force_soap or likely needed
+            if not polarion_username or not polarion_password:
+                print("⚠️  Warning: POLARION_USERNAME/PASSWORD not set", file=sys.stderr)
+                print("   Test step updates on existing TCs require SOAP API", file=sys.stderr)
+                print("   Set credentials in .env to enable test step updates", file=sys.stderr)
+                print()
+
+            result = update_test_steps(
+                client, tc_id, project,
+                args.steps_file,
+                force_soap=args.force_soap
+            )
+
+            if result['status'] == 'success':
+                print(f"✓ {result['message']}", file=sys.stderr)
+                if result.get('method'):
+                    print(f"  Method: {result['method']}", file=sys.stderr)
+                updates_made = True
+            else:
+                print(f"❌ Error: {result['error']}", file=sys.stderr)
+                if 'soap_error' in result:
+                    print(f"   SOAP Error: {result['soap_error']}", file=sys.stderr)
+                sys.exit(1)
+
+        print()
+
+    # Summary
+    if args.dry_run:
+        print("✓ DRY RUN COMPLETE - No changes made", file=sys.stderr)
+    elif updates_made:
+        print("=" * 80, file=sys.stderr)
+        print("✓ UPDATE COMPLETE", file=sys.stderr)
+        print("=" * 80, file=sys.stderr)
+        print(f"Test Case: {tc_id}", file=sys.stderr)
+        print(f"URL: {polarion_url}/polarion/#/project/{project}/workitem?id={tc_id}", file=sys.stderr)
+        print("=" * 80, file=sys.stderr)
+    else:
+        print("No updates specified. Use --help for usage.", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/scripts/validate_tc.py b/.claude/scripts/validate_tc.py
new file mode 100755
index 0000000000..4d9c1ea80e
--- /dev/null
+++ b/.claude/scripts/validate_tc.py
@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""
+Validate Polarion test case draft JSON before creation.
+
+Usage:
+    python3 validate_tc.py <draft.json>
+    python3 validate_tc.py <draft.json> --strict
+
+Validates:
+- Title format: ^[MCO][.+] .+
+- Required fields: component, sub_team, products, test_type, version, trello_jira
+- Test steps have real commands in expected_result (not narrative-only)
+"""
+
+import json
+import re
+import sys
+from typing import Dict, List, Any, Tuple
+
+
+class TCValidator:
+    """Polarion test case validator"""
+
+    # Required fields that must not be empty
+    REQUIRED_FIELDS = [
+        'component',
+        'sub_team',
+        'products',
+        'test_type',
+        'version',
+        'trello_jira'
+    ]
+
+    # Title pattern: [MCO][TICKET-ID] Description
+    TITLE_PATTERN = r'^\[MCO\]\[.+\] .+'
+
+    # Patterns that indicate real commands (not just narrative)
+    COMMAND_PATTERNS = [
+        r'\$ ',                    # Shell prompt
+        r'oc (get|create|apply|patch|delete|logs|debug|label|describe)',
+        r'kubectl ',
+        r'curl ',
+        r'ssh ',
+        r'cat <<EOF',
+        r'apiVersion:',            # YAML content
+        r'kind:',
+        r'metadata:',
+        r'Starting pod/',          # oc debug output
+        r'State: idle',            # rpm-ostree status
+        r'Deployments:',
+        r'Version: \d+\.',         # Version output
+        r'HTTP/\d',                # HTTP response
+        r'machineconfigpool\.',    # Resource creation output
+    ]
+
+    def __init__(self, strict: bool = False):
+        self.strict = strict
+        self.errors = []
+        self.warnings = []
+
+    def validate_file(self, filepath: str) -> bool:
+        """Validate TC from JSON file"""
+        try:
+            with open(filepath, 'r') as f:
+                data = json.load(f)
+        except FileNotFoundError:
+            self.errors.append(f"File not found: {filepath}")
+            return False
+        except json.JSONDecodeError as e:
+            self.errors.append(f"Invalid JSON: {e}")
+            return False
+
+        return self.validate(data)
+
+    def validate(self, data: Dict[str, Any]) -> bool:
+        """Validate TC data"""
+        self.errors = []
+        self.warnings = []
+
+        # Validate title
+        self._validate_title(data.get('title', ''))
+
+        # Validate required fields
+        self._validate_required_fields(data)
+
+        # Validate test steps
+        steps = data.get('test_steps', [])
+        if steps:
+            self._validate_test_steps(steps)
+        else:
+            self.warnings.append("No test steps defined")
+
+        return len(self.errors) == 0
+
+    def _validate_title(self, title: str):
+        """Validate title format"""
+        if not title:
+            self.errors.append("Title is empty")
+            return
+
+        if not re.match(self.TITLE_PATTERN, title):
+            self.errors.append(
+                f"Title does not match pattern: {self.TITLE_PATTERN}\n"
+                f"  Got: {title}\n"
+                f"  Expected: [MCO][TICKET-ID] Description\n"
+                f"  Example: [MCO][MCO-2136] Validate osImageStream inheritance"
+            )
+
+    def _validate_required_fields(self, data: Dict[str, Any]):
+        """Validate required fields are present and non-empty"""
+        for field in self.REQUIRED_FIELDS:
+            value = data.get(field, '')
+
+            if not value or (isinstance(value, str) and value.strip() == ''):
+                self.errors.append(f"Required field '{field}' is empty")
+            elif isinstance(value, str):
+                # Check for placeholder values
+                if value.lower() in ['todo', 'tbd', 'fixme', 'xxx']:
+                    self.errors.append(
+                        f"Required field '{field}' has placeholder value: {value}"
+                    )
+
+    def _validate_test_steps(self, steps: List[Dict[str, str]]):
+        """Validate test steps have real commands, not just narrative"""
+        for i, step in enumerate(steps, 1):
+            step_text = step.get('step', '')
+            expected = step.get('expected_result', '')
+
+            if not step_text:
+                self.warnings.append(f"Step {i}: 'step' field is empty")
+
+            if not expected:
+                self.errors.append(f"Step {i}: 'expected_result' field is empty")
+                continue
+
+            # Check if expected result has actual commands
+            has_command = any(
+                re.search(pattern, expected, re.IGNORECASE)
+                for pattern in self.COMMAND_PATTERNS
+            )
+
+            if not has_command:
+                # Check if it's purely narrative (long sentences, no technical content)
+                is_narrative = self._is_narrative_only(expected)
+
+                if is_narrative:
+                    msg = (
+                        f"Step {i}: Expected result appears to be narrative-only.\n"
+                        f"  Include actual commands and expected output.\n"
+                        f"  Got: {expected[:100]}..."
+                    )
+                    if self.strict:
+                        self.errors.append(msg)
+                    else:
+                        self.warnings.append(msg)
+
+    def _is_narrative_only(self, text: str) -> bool:
+        """Check if text is narrative-only (no commands or technical output)"""
+        # Narrative indicators
+        narrative_words = [
+            'should', 'will', 'must', 'verify', 'ensure', 'check',
+            'confirms', 'validates', 'processes', 'triggers', 'detects'
+        ]
+
+        # Count narrative words
+        narrative_count = sum(
+            1 for word in narrative_words
+            if word in text.lower()
+        )
+
+        # If mostly narrative and no technical patterns, it's narrative-only
+        if narrative_count >= 2:
+            has_technical = any(
+                pattern in text
+                for pattern in ['$', 'oc ', 'kubectl', 'apiVersion', ':', '{', '}']
+            )
+            return not has_technical
+
+        return False
+
+    def print_report(self):
+        """Print validation report"""
+        if self.errors:
+            print("❌ VALIDATION FAILED\n")
+            print("Errors:")
+            for i, err in enumerate(self.errors, 1):
+                print(f"  {i}. {err}")
+            print()
+
+        if self.warnings:
+            print("⚠️  Warnings:")
+            for i, warn in enumerate(self.warnings, 1):
+                print(f"  {i}. {warn}")
+            print()
+
+        if not self.errors and not self.warnings:
+            print("✓ VALIDATION PASSED")
+            print("  All checks passed. TC is ready for creation.")
+        elif not self.errors:
+            print("✓ VALIDATION PASSED (with warnings)")
+            print("  TC meets minimum requirements but has warnings.")
+
+    def get_exit_code(self) -> int:
+        """Get exit code based on validation result"""
+        return 1 if self.errors else 0
+
+
+def create_sample_draft() -> str:
+    """Create a sample draft for testing"""
+    sample = {
+        "title": "[MCO][MCO-2136] Validate osImageStream inheritance for custom MachineConfigPools",
+        "description": "Verify that custom MCPs inherit osImageStream from worker pool when not explicitly set",
+        "component": "Machine Config Operator",
+        "sub_team": "MCO",
+        "products": "OCP",
+        "test_type": "Functional",
+        "version": "4.22",
+        "trello_jira": "MCO-2136",
+        "test_steps": [
+            {
+                "step": "Create custom MCP without osImageStream field",
+                "expected_result": (
+                    "$ oc create -f - << EOF\n"
+                    "apiVersion: machineconfiguration.openshift.io/v1\n"
+                    "kind: MachineConfigPool\n"
+                    "metadata:\n"
+                    "  name: rhel9\n"
+                    "EOF\n"
+                    "machineconfigpool.machineconfiguration.openshift.io/rhel9 created"
+                )
+            },
+            {
+                "step": "Check osImageStream is inherited",
+                "expected_result": (
+                    "$ oc get mcp rhel9 -ojsonpath='{.status.osImageStream.name}'\n"
+                    "rhel9"
+                )
+            }
+        ]
+    }
+
+    filepath = '/tmp/test-specs/sample_draft.json'
+    with open(filepath, 'w') as f:
+        json.dump(sample, f, indent=2)
+
+    return filepath
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 validate_tc.py <draft.json> [--strict]")
+        print()
+        print("Options:")
+        print("  --strict    Treat warnings as errors")
+        print()
+        print("To create a sample draft:")
+        print("  python3 validate_tc.py --sample")
+        sys.exit(1)
+
+    # Handle --sample flag
+    if sys.argv[1] == '--sample':
+        filepath = create_sample_draft()
+        print(f"✓ Sample draft created at: {filepath}")
+        print()
+        print("Validating sample...")
+        print()
+        validator = TCValidator(strict=False)
+        validator.validate_file(filepath)
+        validator.print_report()
+        sys.exit(0)
+
+    filepath = sys.argv[1]
+    strict = '--strict' in sys.argv
+
+    print(f"Validating: {filepath}")
+    if strict:
+        print("Mode: STRICT (warnings treated as errors)")
+    print()
+
+    validator = TCValidator(strict=strict)
+    validator.validate_file(filepath)
+    validator.print_report()
+
+    sys.exit(validator.get_exit_code())
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.claude/skills/mco-automate-test-workflow.md b/.claude/skills/mco-automate-test-workflow.md
index 6163b497ea..e75d5ed87c 100644
--- a/.claude/skills/mco-automate-test-workflow.md
+++ b/.claude/skills/mco-automate-test-workflow.md
@@ -9,11 +9,32 @@ Generate new e2e test code in `test/extended-priv/` from test specifications.
 
 ## Input Detection
 
-- **Text file**: path exists on disk -> read and parse it for test case ID, title, preconditions, steps, expected results, tags
-- **Polarion ID**: matches `OCP-\d+` or purely numeric -> future (MCO-2220)
-- **Jira ID**: matches `MCO-\d+` -> future (MCO-2221)
+- **Text file**: path exists on disk → read and parse it for test case ID, title, preconditions, steps, expected results, tags
+- **Polarion ID**: matches `OCP-\d+` or `OSE-\d+` → fetch via `fetch_polarion.py`, use `/tmp/test-specs/<id>.txt`
+- **Jira ID**: matches `MCO-\d+` → future (MCO-2221)
 
-Only text file input is supported now.
+### Polarion ID Workflow
+
+When `<spec-source>` is a Polarion ID (e.g., `OCP-88122`):
+
+1. **Fetch test case**:
+   ```bash
+   python3 .claude/scripts/fetch_polarion.py <id>
+   ```
+   - Outputs JSON to stdout
+   - Saves `/tmp/test-specs/<id>.txt` (formatted spec)
+
+2. **Parse fetched spec**:
+   - Read `/tmp/test-specs/<id>.txt`
+   - Extract test steps from "Test Steps:" section
+   - Extract metadata from "Metadata:" section
+   - Use title from "Title:" line
+
+3. **Validate**:
+   - Ensure test steps have commands (not just narrative)
+   - Verify required fields present (Component, Sub Team, Version)
+
+4. **Generate test code** following the same conventions as text file input
 
 ## Target File Resolution
 
diff --git a/.claude/skills/mco-create-tc-workflow.md b/.claude/skills/mco-create-tc-workflow.md
new file mode 100644
index 0000000000..69e9bca1bb
--- /dev/null
+++ b/.claude/skills/mco-create-tc-workflow.md
@@ -0,0 +1,236 @@
+---
+name: mco-create-tc-workflow
+description: Create Polarion test case with validation and confirmation
+---
+
+# MCO Create TC Workflow
+
+**CRITICAL RULE**: Always validate → show summary → wait for confirmation before creating.
+
+Never create malformed test cases like `wrong.pdf` (OCP-88941).
+
+## Instructions
+
+When invoked via `/mco-create-tc-from-pr` or `/mco-create-tc-from-jira`:
+
+### Step 1: Parse Source
+
+**From GitHub PR comment** (`#issuecomment-<id>`):
+```bash
+python3 .claude/scripts/fetch_github_pr.py --repo openshift/machine-config-operator --pr <number> --comment <comment-id>
+```
+Saves to `/tmp/test-specs/drafts/pr-<number>.json`
+
+**From GitHub PR review** (`#pullrequestreview-<id>`):
+
+The fetch script does NOT cover PR reviews. Fetch directly via GitHub API:
+```python
+import urllib.request, json
+
+def fetch(url):
+    req = urllib.request.Request(url, headers={
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "mco-tc-script"
+    })
+    return json.loads(urllib.request.urlopen(req).read())
+
+pr = fetch("https://api.github.com/repos/openshift/machine-config-operator/pulls/<NUMBER>")
+reviews = fetch("https://api.github.com/repos/openshift/machine-config-operator/pulls/<NUMBER>/reviews")
+review = next(r for r in reviews if r['id'] == <REVIEW_ID>)
+```
+Then build the draft manually from `pr['title']` and `review['body']`.
+
+**From PR URL only** (no anchor):
+Fetch both issue comments and PR reviews, scan for QE verification content.
+
+**From Draft File**:
+Load existing JSON file directly.
+
+### Step 2: Extract Test Steps — STRICT RULES
+
+**Rule 1 — Verbatim code blocks**:
+Copy every code block from the PR comment EXACTLY as written. Never:
+- Abbreviate log lines with `...`
+- Summarize or paraphrase output
+- Add comments or explanations inside expected results
+- Shorten long lines (e.g. MCD log lines like `I0603 05:28:15.146853    2588 update.go:2970] "Starting update from ..."`)
+
+**Rule 2 — No heredoc syntax**:
+If original uses `cat <<EOF | oc apply -f -`, convert to file-based pattern:
+```
+# filename.yaml
+<yaml content verbatim>
+
+oc apply -f filename.yaml
+<output line>
+```
+Reason: Polarion splits heredoc content out of the expected result cell and renders it above the table.
+
+**Rule 3 — Step vs Expected Result**:
+- **step**: plain-text description of the action
+- **expected_result**: verbatim code block content from the comment
+
+### Step 3: Validate Draft
+
+```bash
+python3 .claude/scripts/validate_tc.py /tmp/test-specs/drafts/pr-<number>.json
+```
+
+**Must pass validation**:
+- Title: `^\[MCO\]\[.+\] .+`
+- Required fields: component, sub_team, products, test_type, version, trello_jira
+- Test steps: expected_result has commands (not narrative-only)
+
+If validation fails:
+1. Show errors
+2. Offer to fix common issues (missing fields, title format)
+3. Re-validate
+4. Do NOT proceed to creation until valid
+
+### Step 4: Show Summary
+
+Display:
+```
+================================================================================
+TEST CASE SUMMARY
+================================================================================
+Title: [MCO][OCPBUGS-86650] Verify password is applied only when hash changes
+Component: Machine Config Operator
+Sub Team: MCO
+Products: OCP
+Test Type: Functional
+Version: 4.19
+Jira: OCPBUGS-86650
+Test Steps: 5
+================================================================================
+
+Step 1: Apply a MachineConfig with a password hash for the core user
+Expected: # 99-worker-core-password-test.yaml
+          apiVersion: machineconfiguration.openshift.io/v1
+          ...
+
+Step 2: Wait for MCP rollout and verify MCD logs show password configured
+Expected: oc get mcp
+          ...
+          oc logs ... | grep -i pass
+          I0603 05:28:15.567308    2588 update.go:2546] Password has been configured
+...
+================================================================================
+```
+
+### Step 5: Request Confirmation
+
+**BLOCKING REQUIREMENT**: Wait for user confirmation before creating.
+
+Ask:
+```
+Create this test case in Polarion? (yes/no)
+```
+
+**Do NOT create** if user says no, asks to modify, or is silent.
+
+### Step 6: Create (Only After Confirmation)
+
+```bash
+python3 .claude/scripts/create_polarion_tc.py /tmp/test-specs/drafts/pr-<number>.json
+```
+
+Note the TC ID. The initial creation's PATCH for custom fields often fails silently — always proceed to Step 7 regardless.
+
+### Step 7: Always Patch Fields + Steps Separately
+
+> **Known issue**: The creation PATCH for custom fields (Component, Sub Team, Products, Test Type, Version, Trello/Jira) often fails silently. Always run this step regardless of whether creation reported success. Verify each field in the Polarion UI after patching — if any field is still empty, set it manually in Polarion.
+
+Even if creation reports success, always run:
+```bash
+python3 .claude/scripts/update_polarion_tc.py OCP-XXXXX \
+  --component "Machine Config Operator" \
+  --sub-team "MCO" \
+  --products "OCP" \
+  --test-type "Functional" \
+  --version "<VERSION>" \
+  --trello-jira "<JIRA>" \
+  --steps-file /tmp/test-specs/drafts/pr-<number>.json
+```
+
+Verify output shows:
+- `✓ Updated 6 field(s)` — casecomponent, subteam2, mcoproducts, casetesttype, plannedin, linkedworkitems
+- `✓ Added N test steps via REST API`
+
+### Step 8: Show Result
+
+```
+================================================================================
+✓ TEST CASE CREATED SUCCESSFULLY
+================================================================================
+ID: OCP-89248
+URL: https://polarion.engineering.redhat.com/polarion/#/project/OSE/workitem?id=OCP-89248
+================================================================================
+```
+
+## Re-uploading Steps (If Steps Already Exist)
+
+When re-uploading steps to an existing TC, the client detects existing steps and falls back to SOAP, which fails with "Not authorized." Fix: delete all steps via REST first.
+
+```python
+import sys, time
+sys.path.insert(0, '.claude/scripts')
+
+def load_env():
+    import os
+    env_vars = {}
+    if os.path.exists('.env'):
+        with open('.env') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    k, v = line.split('=', 1)
+                    env_vars[k] = v
+    return env_vars
+
+env = load_env()
+from polarion_client import PolarionClient
+
+client = PolarionClient(
+    url=env.get('POLARION_URL', 'https://polarion.engineering.redhat.com'),
+    token=env.get('POLARION_TOKEN', ''),
+    verify_ssl=False,
+    username=env.get('POLARION_USERNAME', ''),
+    password=env.get('POLARION_PASSWORD', '')
+)
+
+TC_ID = "OCP-XXXXX"
+
+# Loop-delete: Polarion re-indexes IDs after each delete, so fetch fresh each round
+for attempt in range(10):
+    result = client._make_request("GET", f"projects/OSE/workitems/{TC_ID}/teststeps")
+    remaining = result.get("data", [])
+    if not remaining:
+        break
+    for s in remaining:
+        sid = s.get('id', '').split('/')[-1]
+        client._make_request("DELETE", f"projects/OSE/workitems/{TC_ID}/teststeps/{sid}")
+    time.sleep(0.5)
+```
+
+Then re-run Step 7 to POST fresh steps via REST.
+
+## Memory Enforcement
+
+Load memory before creating:
+- `feedback_polarion_tc.md` — "Always show summary and confirm before creating"
+- `feedback_polarion_fields.md` — "Never leave Component/Test Type/Sub Team/Products/Version/Jira empty"
+
+## Error Handling
+
+**PR review URL (`#pullrequestreview-`)**: fetch script will report "Comment not found". Switch to GitHub reviews API manually.
+
+**Heredoc in original comment**: convert to `cat filename.yaml` + `oc apply -f` pattern before writing to draft.
+
+**SOAP fallback fails ("Not authorized")**: existing steps are blocking REST. Run the delete loop, then re-POST.
+
+**Custom fields empty after creation**: run `update_polarion_tc.py` — the initial PATCH silently failed.
+
+**POLARION_TOKEN not configured**: point to setup instructions. Do NOT proceed.
+
+**Partial success** (TC created but steps failed): report TC ID and URL. Note steps need re-upload via delete loop + REST POST.
diff --git a/.claude/skills/mco-fetch-workflow.md b/.claude/skills/mco-fetch-workflow.md
new file mode 100644
index 0000000000..441f52b75c
--- /dev/null
+++ b/.claude/skills/mco-fetch-workflow.md
@@ -0,0 +1,77 @@
+---
+name: mco-fetch-workflow
+description: Fetch test artifacts from Polarion, GitHub PR, or Jira
+---
+
+# MCO Fetch Workflow
+
+Thin wrapper around fetch scripts. Delegates to Python scripts in `.claude/scripts/`.
+
+## Instructions
+
+When invoked with `/mco-fetch <type> <id>`:
+
+1. **Parse arguments**:
+   - `tc <id>` → Polarion test case
+   - `pr <number> [comment-id]` → GitHub PR comment
+   - `jira <key>` → Jira issue
+
+2. **Fetch Polarion test case**:
+   ```bash
+   python3 .claude/scripts/fetch_polarion.py <id>
+   ```
+   - Outputs JSON to stdout
+   - Saves `/tmp/test-specs/<id>.txt` for /automate-test
+
+3. **Fetch GitHub PR**:
+   ```bash
+   python3 .claude/scripts/fetch_github_pr.py --repo openshift/machine-config-operator --pr <number> [--comment <id>]
+   ```
+   - Parses QE pre-merge testing comment
+   - Saves `/tmp/test-specs/drafts/pr-<number>.json`
+
+4. **Fetch Jira issue**:
+   ```bash
+   python3 .claude/scripts/fetch_jira.py <issue-key>
+   ```
+   - Fetches metadata and acceptance criteria
+   - Saves `/tmp/test-specs/jira/<issue-key>.json`
+
+5. **Show summary**:
+   - Display title, status
+   - Show output file location
+   - List test steps count (if TC)
+
+## Example
+
+```
+/mco-fetch tc OCP-88122
+```
+
+**Expected output**:
+```
+Fetching OCP-88122 from Polarion...
+
+✓ Test Case: OCP-88122
+  Title: [MCO][MCO-2136] Validate osImageStream inheritance for custom MachineConfigPools
+  Status: draft
+  Component: Machine Config Operator
+  Version: 4.22
+  Test Steps: 6
+
+Output saved:
+- /tmp/test-specs/OCP-88122.txt (for /automate-test)
+- JSON output in conversation
+```
+
+## Error Handling
+
+- Check POLARION_TOKEN is configured
+- If auth fails → point to setup instructions
+- If TC not found → verify ID format
+
+## Implementation
+
+See `.claude/README.md` section "Workflows" for full documentation.
+
+Script source of truth: `.claude/scripts/fetch_polarion.py`, `fetch_github_pr.py`, `fetch_jira.py`
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000000..23a1f52fa3
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,36 @@
+# Polarion Configuration
+POLARION_URL=https://polarion.engineering.redhat.com
+POLARION_PROJECT=OSE
+
+# Polarion REST API Authentication (required)
+# Generate token at: https://polarion.engineering.redhat.com/polarion/#/user/me
+POLARION_TOKEN=your_personal_access_token_here
+
+# Polarion SOAP API Authentication (optional - only for updating test steps on existing TCs)
+# Required if you need to update test steps on existing test cases
+# New test cases can add steps during creation without these
+POLARION_USERNAME=your_username
+POLARION_PASSWORD=your_password
+
+# GitHub Configuration (optional)
+GITHUB_TOKEN=your_github_token_here
+GITHUB_ORG=openshift
+GITHUB_REPO=machine-config-operator
+
+# Jira Configuration (for fetch_jira.py)
+JIRA_URL=https://redhat.atlassian.net
+JIRA_EMAIL=you@redhat.com
+JIRA_TOKEN=your_jira_api_token_here
+# Generate token at: https://id.atlassian.com/manage-profile/security/api-tokens
+# For Basic Auth: base64(email:token) - script handles this automatically
+# For Bearer: just use token - script tries Bearer first, falls back to Basic
+
+# MCO Test Defaults
+MCO_COMPONENT=Machine Config Operator
+MCO_SUB_TEAM=MCO
+MCO_TEST_TYPE=Functional
+MCO_PRODUCTS=OCP
+MCO_DEFAULT_VERSION=4.22
+
+# SSL Verification (for development/testing)
+VERIFY_SSL=true
diff --git a/.gitignore b/.gitignore
index 351476ed04..2b1657e8fc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,12 @@ junit*.xml
 checkstyle*.xml
 mco-unit-test-coverage.out
 mco-unit-test-coverage.html
+
+# MCO QE Tooling
+.env
+.claude/.env
+.claude/settings.local.json
+
+# MCO QE Tooling outputs
+/test-specs/
+.claude/__pycache__/