@pennyfarthing/core 7.4.0 → 7.4.1

package/pennyfarthing-dist/scripts/hooks/post-merge.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+# post-merge.sh - Git hook for automatic sprint YAML updates after PR merge
+# Story 8-1: Git Hook for PR Merge Detection
+#
+# This hook runs after git pull or git merge operations, detecting when a
+# story branch is merged and automatically updating the sprint YAML status.
+#
+# Installation:
+#   Installed to .git/hooks/post-merge by pennyfarthing init or doctor --fix
+#
+# Dependencies:
+#   - yq (for YAML manipulation)
+#   - sprint-common.sh (for shared sprint functions)
+
+set -uo pipefail
+
+# Find project root by looking for .claude/ marker
+find_project_root() {
+    local dir="$PWD"
+    while [[ ! -d "$dir/.claude" ]] && [[ "$dir" != "/" ]]; do
+        dir="$(dirname "$dir")"
+    done
+    if [[ -d "$dir/.claude" ]]; then
+        echo "$dir"
+    else
+        return 1
+    fi
+}
+
+# Initialize paths
+PROJECT_ROOT="$(find_project_root 2>/dev/null || echo "")"
+if [[ -z "$PROJECT_ROOT" ]]; then
+    # Not in a pennyfarthing project, silently exit
+    exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+SESSION_DIR="$PROJECT_ROOT/.session"
+SPRINT_FILE="$PROJECT_ROOT/sprint/current-sprint.yaml"
+
+# Source sprint-common.sh for shared functions
+SPRINT_COMMON="$PROJECT_ROOT/.pennyfarthing/scripts/sprint/sprint-common.sh"
+if [[ -f "$SPRINT_COMMON" ]]; then
+    # shellcheck source=/dev/null
+    source "$SPRINT_COMMON"
+fi
+
+# extract_story_id BRANCH_NAME
+# Extract story ID from branch name pattern feat/X-Y-*
+# Returns: X-Y (e.g., "8-1" from "feat/8-1-merge-detection")
+# Returns empty for non-matching branches
+extract_story_id() {
+    local branch="$1"
+
+    # Match pattern: feat/EPIC-STORY-description or feat/EPIC-STORY
+    if [[ "$branch" =~ ^feat/([0-9]+-[0-9]+) ]]; then
+        echo "${BASH_REMATCH[1]}"
+    fi
+    # Returns empty string for non-matching patterns
+}
+
+# update_story_status STORY_ID NEW_STATUS
+# Update story status in sprint YAML and add completed date
+# Uses yq for YAML manipulation
+update_story_status() {
+    local story_id="$1"
+    local new_status="${2:-done}"
+    local completed_date
+    completed_date=$(date +%Y-%m-%d)
+
+    if [[ ! -f "$SPRINT_FILE" ]]; then
+        return 1
+    fi
+
+    # Check if yq is available
+    if ! command -v yq &>/dev/null; then
+        echo "Warning: yq not found, cannot update sprint YAML" >&2
+        return 1
+    fi
+
+    # Extract epic and story numbers
+    local epic_num="${story_id%%-*}"
+    local story_num="${story_id#*-}"
+
+    # Update status and add completed date using yq
+    yq eval -i "
+        (.epics[] | select(.id == \"$epic_num\") | .stories[] | select(.id == \"$story_num\")).status = \"$new_status\" |
+        (.epics[] | select(.id == \"$epic_num\") | .stories[] | select(.id == \"$story_num\")).completed = \"$completed_date\"
+    " "$SPRINT_FILE"
+
+    return $?
+}
+
+# log_reconciliation STORY_ID MESSAGE
+# Log reconciliation event to .session/ directory
+log_reconciliation() {
+    local story_id="$1"
+    local message="${2:-Merge detected}"
+    local timestamp
+    timestamp=$(date +"%Y-%m-%d %H:%M:%S")
+
+    # Ensure session directory exists
+    mkdir -p "$SESSION_DIR"
+
+    local log_file="$SESSION_DIR/reconciliation.log"
+
+    echo "[$timestamp] Story $story_id: $message" >> "$log_file"
+}
+
+# Main hook logic
+main() {
+    # Get the current branch after merge
+    local current_branch
+    current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+
+    # Only process if we're on develop or main (after a PR merge)
+    if [[ "$current_branch" != "develop" && "$current_branch" != "main" ]]; then
+        exit 0
+    fi
+
+    # Get the branches that were just merged
+    # The reflog shows what was merged: the previous HEAD and the merged commit
+    local merged_refs
+    merged_refs=$(git reflog -1 --format='%gs' 2>/dev/null)
+
+    # Check if this was a merge operation
+    if [[ ! "$merged_refs" =~ merge ]]; then
+        # Could be a pull with fast-forward - check for merged branches
+        # Look at recently merged branches by checking merge commits
+        :
+    fi
+
+    # Find recently merged feature branches by examining merge commits
+    local merge_commits
+    merge_commits=$(git log --merges --oneline -10 --since="5 minutes ago" 2>/dev/null)
+
+    # Extract branch names from merge commits
+    while IFS= read -r commit_line; do
+        # Parse "Merge pull request #X from user/feat/X-Y-description"
+        # or "Merge branch 'feat/X-Y-description'"
+        local branch_name=""
+
+        if [[ "$commit_line" =~ feat/([0-9]+-[0-9]+[a-zA-Z0-9-]*) ]]; then
+            branch_name="feat/${BASH_REMATCH[1]}"
+        fi
+
+        if [[ -n "$branch_name" ]]; then
+            local story_id
+            story_id=$(extract_story_id "$branch_name")
+
+            if [[ -n "$story_id" ]]; then
+                # Update sprint YAML
+                if update_story_status "$story_id" "done"; then
+                    log_reconciliation "$story_id" "Status updated to 'done' after merge (branch: $branch_name)"
+                else
+                    log_reconciliation "$story_id" "Failed to update status (branch: $branch_name)"
+                fi
+            fi
+        fi
+    done <<< "$merge_commits"
+}
+
+# Only run main when executed directly (not when sourced for testing)
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

package/pennyfarthing-dist/scripts/hooks/pre-commit.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# pre-commit.sh - Git hook to enforce branch protection
+#
+# Prevents direct commits to protected branches (main, develop).
+# Exception: sprint/ folder commits allowed on develop for administrative tracking.
+#
+# Installation:
+#   Installed to .git/hooks/pre-commit by pennyfarthing init or doctor --fix
+#   Or symlink: ln -sf ../../pennyfarthing-dist/scripts/hooks/pre-commit.sh .git/hooks/pre-commit
+
+set -uo pipefail
+
+BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+PROTECTED_BRANCHES="^(main|develop)$"
+
+if [[ $BRANCH =~ $PROTECTED_BRANCHES ]]; then
+    # Special case: Allow sprint/ folder commits on develop branch
+    if [[ $BRANCH == "develop" ]]; then
+        STAGED_FILES=$(git diff --cached --name-only)
+        NON_SPRINT_FILES=$(echo "$STAGED_FILES" | grep -v "^sprint/")
+
+        # If all staged files are in sprint/, allow the commit
+        if [ -z "$NON_SPRINT_FILES" ] && [ -n "$STAGED_FILES" ]; then
+            exit 0
+        fi
+    fi
+
+    echo ""
+    echo "COMMIT BLOCKED"
+    echo ""
+    echo "You are trying to commit directly to: $BRANCH"
+    echo "This violates the git workflow rules."
+    echo ""
+    echo "Protected branches: main, develop"
+    echo ""
+    echo "What to do:"
+    echo "1. Create a feature branch:"
+    echo "   git checkout -b <type>/<epic-story>-<description>"
+    echo ""
+    echo "2. Example:"
+    echo "   git checkout -b feat/8-2-add-authentication"
+    echo ""
+    echo "3. Then commit your changes on the feature branch"
+    echo ""
+    echo "Exception: Sprint tracking files (sprint/*) can be committed to develop"
+    echo ""
+    exit 1
+fi
+
+exit 0

package/pennyfarthing-dist/scripts/hooks/pre-edit-check.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env zsh
+# Pre-edit hook: Verify edits don't touch protected files
+# Called by Claude Code before Edit/Write tool calls
+#
+# Input: JSON via stdin with tool_name, tool_input
+# Output: Exit 0 to allow, Exit 2 to block (stderr shown to Claude)
+
+set -euo pipefail
+
+# Read input from stdin
+input=$(cat)
+
+# Extract file path from tool input
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // .tool_input.path // ""')
+
+# Protected patterns (files that should never be edited automatically)
+protected_patterns=(
+    "*.env"
+    "*.pem"
+    "*.key"
+    "*credentials*"
+    "*secrets*"
+    ".git/*"
+    "node_modules/*"
+    "vendor/*"
+)
+
+# Pennyfarthing managed files protection
+# These are managed by `pennyfarthing update`, don't edit directly
+# EXCEPTION: If we ARE in the pennyfarthing library itself, allow edits
+is_pennyfarthing_lib=false
+if [[ -d "${CLAUDE_PROJECT_DIR:-$PWD}/pennyfarthing-dist" ]]; then
+    is_pennyfarthing_lib=true
+fi
+
+if [[ "$file_path" == *".claude/pennyfarthing/"* ]] && [[ "$is_pennyfarthing_lib" == "false" ]]; then
+    echo "BLOCKED: Cannot edit managed pennyfarthing files." >&2
+    echo "File: $file_path" >&2
+    echo "" >&2
+    echo "These files are managed by pennyfarthing and will be overwritten on update." >&2
+    echo "Instead:" >&2
+    echo "  - Put project-specific customizations in .claude/project/" >&2
+    echo "  - For framework changes, edit the pennyfarthing repo and run 'pennyfarthing update'" >&2
+    exit 2
+fi
+
+# Check if file matches any protected pattern
+for pattern in "${protected_patterns[@]}"; do
+    if [[ "$file_path" == $pattern ]]; then
+        echo "BLOCKED: Cannot edit protected file matching pattern: $pattern" >&2
+        echo "File: $file_path" >&2
+        exit 2
+    fi
+done
+
+# Additional check: warn on certain file types but allow
+warn_patterns=(
+    "*.md"
+    "*.json"
+)
+
+# For warnings, just log to stderr but allow (exit 0)
+for pattern in "${warn_patterns[@]}"; do
+    if [[ "$file_path" == $pattern ]]; then
+        # Could log warnings here if needed
+        :
+    fi
+done
+
+# Allow the edit
+exit 0

package/pennyfarthing-dist/scripts/hooks/pre-push.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# pre-push.sh - Git hook to remind about Jira sync before push
+#
+# Checks if sprint files were modified and reminds to sync to Jira.
+#
+# Installation:
+#   Installed to .git/hooks/pre-push by pennyfarthing init or doctor --fix
+#   Or symlink: ln -sf ../../pennyfarthing-dist/scripts/hooks/pre-push.sh .git/hooks/pre-push
+
+set -uo pipefail
+
+# Find project root
+find_project_root() {
+    local dir="$PWD"
+    while [[ ! -d "$dir/.claude" ]] && [[ "$dir" != "/" ]]; do
+        dir="$(dirname "$dir")"
+    done
+    if [[ -d "$dir/.claude" ]]; then
+        echo "$dir"
+    else
+        return 1
+    fi
+}
+
+PROJECT_ROOT="$(find_project_root 2>/dev/null || echo "")"
+if [[ -z "$PROJECT_ROOT" ]]; then
+    exit 0
+fi
+
+SPRINT_FILE="$PROJECT_ROOT/sprint/current-sprint.yaml"
+
+# Check if there are uncommitted changes to sprint file
+if git diff --name-only | grep -q "sprint/current-sprint.yaml"; then
+    echo "Warning: current-sprint.yaml has uncommitted changes"
+    echo "   Consider committing before pushing"
+    echo ""
+fi
+
+# Get the range of commits being pushed
+REMOTE="$1"
+URL="$2"
+
+while read local_ref local_sha remote_ref remote_sha; do
+    if [ "$local_sha" != "0000000000000000000000000000000000000000" ]; then
+        # Check if sprint file changed in this push
+        if git diff --name-only "$remote_sha..$local_sha" 2>/dev/null | grep -q "sprint/current-sprint.yaml"; then
+            echo "Sprint changes detected in push"
+            echo "   Reminder: Sync to Jira if story statuses changed"
+            echo ""
+        fi
+    fi
+done
+
+exit 0

package/pennyfarthing-dist/scripts/hooks/session-start.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env zsh
+# Session start hook: Initialize environment for Claude Code session
+# Called by Claude Code when a new session starts
+#
+# Uses CLAUDE_ENV_FILE to persist environment variables for the session.
+# Projects using pennyfarthing can add their own hooks for project-specific vars.
+#
+# Also validates previous session checkpoint to detect cross-session state changes.
+
+set -euo pipefail
+
+# Load shared functions
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/../lib/checkpoint.sh"
+
+# Read input from stdin (contains session_id, source, cwd, etc.)
+input=$(cat)
+session_id=$(echo "$input" | jq -r '.session_id // "unknown"')
+source_type=$(echo "$input" | jq -r '.source // "unknown"')
+
+# Ensure .session directory exists
+mkdir -p "$CLAUDE_PROJECT_DIR/.session"
+mkdir -p "$CLAUDE_PROJECT_DIR/.session/agents"
+
+# Note: Agent cleanup is handled by agent-session.sh (7-day TTL) to preserve multi-session state
+# DO NOT clear .session/agents/* here - it breaks parallel sessions
+
+# Create session log entry
+echo "$(date -Iseconds) | Session $source_type: $session_id" >> "$CLAUDE_PROJECT_DIR/.session/session-log.txt"
+
+# Validate previous session checkpoint (cross-session continuity)
+validate_checkpoint() {
+    local prev_state
+    prev_state=$(checkpoint_restore "session_state")
+
+    if [[ -z "$prev_state" ]]; then
+        # No previous checkpoint - fresh start
+        return 0
+    fi
+
+    # Parse checkpoint data (format: key=value;key=value;...)
+    local prev_sha prev_agent prev_story prev_phase prev_session
+    prev_sha=$(echo "$prev_state" | tr ';' '\n' | grep '^sha=' | cut -d= -f2)
+    prev_agent=$(echo "$prev_state" | tr ';' '\n' | grep '^agent=' | cut -d= -f2)
+    prev_story=$(echo "$prev_state" | tr ';' '\n' | grep '^story=' | cut -d= -f2)
+    prev_phase=$(echo "$prev_state" | tr ';' '\n' | grep '^phase=' | cut -d= -f2)
+    prev_session=$(echo "$prev_state" | tr ';' '\n' | grep '^session=' | cut -d= -f2)
+
+    # Get current git SHA
+    local current_sha=""
+    if command -v git &>/dev/null && git rev-parse --git-dir &>/dev/null; then
+        current_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "")
+    fi
+
+    # Compare git state
+    if [[ -n "$prev_sha" && -n "$current_sha" && "$prev_sha" != "$current_sha" ]]; then
+        # Git state changed between sessions - write warning to session log
+        local warning="CROSS_SESSION_DRIFT: Git changed since last session (was: $prev_sha, now: $current_sha)"
+        if [[ -n "$prev_story" ]]; then
+            warning="$warning | Story: $prev_story"
+        fi
+        if [[ -n "$prev_agent" ]]; then
+            warning="$warning | Agent: $prev_agent"
+        fi
+        echo "$(date -Iseconds) | $warning" >> "$CLAUDE_PROJECT_DIR/.session/session-log.txt"
+
+        # Also write to a dedicated drift log for easy scanning
+        echo "$(date -Iseconds) | prev_sha=$prev_sha | current_sha=$current_sha | story=$prev_story | agent=$prev_agent | phase=$prev_phase" >> "$CLAUDE_PROJECT_DIR/.session/drift-log.txt"
+    fi
+}
+
+# Run checkpoint validation (don't fail if it errors)
+validate_checkpoint 2>/dev/null || true
+
+# Write environment variables to CLAUDE_ENV_FILE (persists for session)
+if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
+    cat >> "$CLAUDE_ENV_FILE" << EOF
+# Pennyfarthing core environment
+export PROJECT_ROOT="$CLAUDE_PROJECT_DIR"
+export SESSION_ID="$session_id"
+EOF
+
+    # Auto-configure OTEL if Cyclist is running (Story 20-1)
+    PORT_FILE="$CLAUDE_PROJECT_DIR/.cyclist-port"
+    if [[ -f "$PORT_FILE" ]]; then
+        CYCLIST_PORT=$(cat "$PORT_FILE" 2>/dev/null)
+        if [[ "$CYCLIST_PORT" =~ ^[0-9]+$ ]]; then
+            cat >> "$CLAUDE_ENV_FILE" << EOF
+# OTEL auto-configuration for Cyclist (Story 20-1)
+export OTEL_EXPORTER_OTLP_PROTOCOL="http/json"
+export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:$CYCLIST_PORT"
+EOF
+        fi
+    fi
+fi
+
+exit 0

package/pennyfarthing-dist/scripts/hooks/session-stop.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env zsh
+# Session stop hook: Save checkpoint for cross-session continuity
+# Called by Claude Code when a session ends
+#
+# Writes session state to checkpoint:
+#   - Active agent (from .session/agents/)
+#   - Current story (from .session/*-session.md)
+#   - Workflow phase (from session file)
+#   - Git SHA (current HEAD)
+#   - Session ID
+#
+# Next session can validate this against current git state.
+
+set -euo pipefail
+
+# Load shared functions
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/../lib/checkpoint.sh"
+
+# Read input from stdin (contains session_id, source, etc.)
+input=$(cat)
+session_id=$(echo "$input" | jq -r '.session_id // "unknown"')
+
+# Get current agent for this session
+agent=""
+agent_file="$PROJECT_ROOT/.session/agents/$session_id"
+if [[ -f "$agent_file" ]]; then
+    agent=$(cat "$agent_file")
+fi
+
+# Find active story from session files
+story=""
+phase=""
+session_file=$(find "$PROJECT_ROOT/.session" -maxdepth 1 -name "*-session.md" -type f 2>/dev/null | head -1)
+if [[ -n "$session_file" && -f "$session_file" ]]; then
+    # Extract story ID from filename (e.g., 8-3-session.md -> 8-3)
+    story=$(basename "$session_file" | sed 's/-session\.md$//')
+
+    # Extract phase from session file (look for "Phase:" line)
+    phase=$(grep -i "^- Phase:" "$session_file" 2>/dev/null | head -1 | sed 's/.*Phase:[[:space:]]*//' | cut -d' ' -f1 || echo "")
+fi
+
+# Get current git SHA
+git_sha=""
+if command -v git &>/dev/null && git rev-parse --git-dir &>/dev/null; then
+    git_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "")
+fi
+
+# Build checkpoint data (semicolon-separated key=value pairs)
+checkpoint_data="agent=${agent};story=${story};phase=${phase};sha=${git_sha};session=${session_id}"
+
+# Save checkpoint
+checkpoint_save "session_state" "$checkpoint_data"
+
+# Log session end
+echo "$(date -Iseconds) | Session end: $session_id (agent=$agent, story=$story)" >> "$PROJECT_ROOT/.session/session-log.txt"
+
+exit 0

package/pennyfarthing-dist/scripts/jira/README.md

@@ -0,0 +1,33 @@
+# Jira Scripts
+
+Scripts for Jira integration, synchronization, and story management.
+
+## Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `jira-lib.sh` | Shared Jira bash utilities (library) |
+| `jira-lib.mjs` | Shared Jira JavaScript utilities (library) |
+| `jira-claim-story.sh` | Claim a story (assign and move to In Progress) |
+| `jira-reconcile.sh` | Reconcile Jira with sprint YAML |
+| `jira-sync.sh` | Sync story to Jira |
+| `jira-sync.mjs` | Sync story to Jira (JavaScript) |
+| `jira-sync-story.sh` | Sync individual story |
+| `jira-sync-story.mjs` | Sync individual story (JavaScript) |
+| `create-jira-epic.sh` | Create Jira epic with stories |
+| `create-jira-story.sh` | Create individual Jira story |
+| `sync-epic-jira.sh` | Sync epic to Jira |
+| `sync-epic-to-jira.sh` | Sync epic to Jira (alternate) |
+| `jira-bidirectional-sync.mjs` | Bidirectional sync between YAML and Jira |
+
+## Usage
+
+```bash
+.pennyfarthing/scripts/core/run.sh jira/jira-claim-story.sh MSSCI-12345
+.pennyfarthing/scripts/core/run.sh jira/jira-reconcile.sh
+```
+
+## Ownership
+
+- **Primary users:** SM agent, `/jira` skill
+- **Maintained by:** Core Pennyfarthing team

package/pennyfarthing-dist/scripts/jira/create-jira-epic.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+# Create a Jira epic and its child stories from sprint YAML
+# Usage: .pennyfarthing/scripts/core/run.sh create-jira-epic.sh <epic-id> [--dry-run]
+
+set -euo pipefail
+
+EPIC_ID="${1:-}"
+DRY_RUN=false
+
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=true ;;
+  esac
+done
+
+if [[ -z "$EPIC_ID" ]]; then
+  echo "Usage: create-jira-epic.sh <epic-id> [--dry-run]"
+  exit 1
+fi
+
+# Find project root
+if [[ -z "${PROJECT_ROOT:-}" ]]; then
+  d="$PWD"
+  while [[ ! -d "$d/.claude" ]] && [[ "$d" != "/" ]]; do
+    d="$(dirname "$d")"
+  done
+  PROJECT_ROOT="$d"
+fi
+
+SPRINT_FILE="$PROJECT_ROOT/sprint/current-sprint.yaml"
+SCRIPTS_DIR="$PROJECT_ROOT/.pennyfarthing/scripts"
+JIRA_PROJECT="${JIRA_PROJECT_KEY:-MSSCI}"
+PROJECT_LABEL="${PROJECT_LABEL:-${PROJECT_NAME:-pennyfarthing}}"
+
+# Find epic (by id or jira key)
+EPIC_DATA=$(yq -o json ".epics[] | select(.id == \"$EPIC_ID\" or .jira == \"$EPIC_ID\")" "$SPRINT_FILE" 2>/dev/null || echo "")
+
+if [[ -z "$EPIC_DATA" || "$EPIC_DATA" == "null" ]]; then
+  echo "Error: Epic $EPIC_ID not found"
+  yq '.epics[].id' "$SPRINT_FILE" 2>/dev/null
+  exit 1
+fi
+
+EPIC_TITLE=$(echo "$EPIC_DATA" | yq -r '.title // "Unknown"' | sed 's/^Epic: //')
+EPIC_JIRA=$(echo "$EPIC_DATA" | yq -r '.jira // ""')
+
+echo ""
+echo "Epic: $EPIC_TITLE"
+echo "Dry run: $DRY_RUN"
+echo ""
+
+# Create epic if needed
+if [[ -n "$EPIC_JIRA" && "$EPIC_JIRA" != "null" ]]; then
+  echo "Epic already exists: $EPIC_JIRA"
+  JIRA_EPIC_KEY="$EPIC_JIRA"
+else
+  if [[ "$DRY_RUN" == "true" ]]; then
+    echo "[DRY RUN] Would create epic: $EPIC_TITLE"
+    JIRA_EPIC_KEY="MSSCI-XXXXX"
+  else
+    EPIC_DESCRIPTION=$(echo "$EPIC_DATA" | yq -r '.description // ""')
+    EPIC_OUTPUT=$(echo "" | jira issue create \
+      --project "$JIRA_PROJECT" \
+      --type Epic \
+      --summary "$EPIC_TITLE" \
+      --body "$EPIC_DESCRIPTION" \
+      --label "$PROJECT_LABEL" \
+      --no-input 2>&1) || {
+        echo "Error: $EPIC_OUTPUT"
+        exit 1
+      }
+
+    JIRA_EPIC_KEY=$(echo "$EPIC_OUTPUT" | grep -oE 'MSSCI-[0-9]+' | head -1)
+    echo "Created epic: $JIRA_EPIC_KEY"
+
+    yq eval -i "(.epics[] | select(.id == \"$EPIC_ID\")).jira = \"$JIRA_EPIC_KEY\"" "$SPRINT_FILE"
+  fi
+fi
+
+echo ""
+echo "Creating stories..."
+echo ""
+
+# Get story IDs that need Jira keys
+STORY_IDS=$(yq -r "(.epics[] | select(.jira == \"$JIRA_EPIC_KEY\" or .id == \"$EPIC_ID\")).stories[] | select(.jira == null or .jira == \"\") | .id" "$SPRINT_FILE" 2>/dev/null || echo "")
+
+if [[ -z "$STORY_IDS" ]]; then
+  echo "All stories already have Jira keys"
+else
+  for STORY_ID in $STORY_IDS; do
+    if [[ "$DRY_RUN" == "true" ]]; then
+      TITLE=$(yq -r "(.epics[] | select(.jira == \"$JIRA_EPIC_KEY\" or .id == \"$EPIC_ID\")).stories[] | select(.id == \"$STORY_ID\") | .title" "$SPRINT_FILE")
+      echo "[DRY RUN] Would create: $STORY_ID - $TITLE"
+    else
+      "$SCRIPTS_DIR/create-jira-story.sh" "$JIRA_EPIC_KEY" "$STORY_ID"
+    fi
+  done
+fi
+
+echo ""
+echo "Done. View epic: jira issue view $JIRA_EPIC_KEY"