Commit a4b1953a9b46

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# Jira search helper with common query patterns
+
+set -euo pipefail
+
+usage() {
+    cat <<EOF
+Usage: jira-search <pattern> [options]
+
+Common search patterns:
+  my-open          My open issues
+  my-progress      My in-progress issues
+  my-week          My issues updated this week
+  my-blocked       My blocked issues
+  team-bugs        Unassigned team bugs
+  team-blocked     All blocked team issues
+  stale            Stale issues (>30 days no update)
+  high-priority    High priority open issues
+  needs-review     Issues in code/QE review
+
+Options:
+  --project PROJECT   Filter by project (default: SRVKP)
+  --plain             Plain text output
+  --paginate N        Limit results (default: 20)
+
+Examples:
+  jira-search my-open
+  jira-search team-bugs --project SRVCOM
+  jira-search stale --plain
+EOF
+    exit 1
+}
+
+# Default options
+PROJECT="SRVKP"
+PLAIN=""
+PAGINATE=20
+
+# Parse pattern
+PATTERN="${1:-}"
+shift || true
+
+# Parse options
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --project)
+            PROJECT="$2"
+            shift 2
+            ;;
+        --plain)
+            PLAIN="--plain"
+            shift
+            ;;
+        --paginate)
+            PAGINATE="$2"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            ;;
+        *)
+            echo "Unknown option: $1"
+            usage
+            ;;
+    esac
+done
+
+# Build JQL based on pattern
+ORDER_BY=""
+REVERSE=""
+
+case "$PATTERN" in
+    my-open)
+        JQL="assignee = currentUser() AND status NOT IN (Done, Closed)"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    my-progress)
+        JQL="assignee = currentUser() AND status IN ('In Progress', 'Code Review', 'QE Review')"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    my-week)
+        JQL="assignee = currentUser() AND updated >= startOfWeek()"
+        ORDER_BY="--order-by updated"
+        REVERSE="--reverse"
+        ;;
+    my-blocked)
+        JQL="assignee = currentUser() AND status = Blocked"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    team-bugs)
+        JQL="project = $PROJECT AND type = Bug AND assignee is EMPTY"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    team-blocked)
+        JQL="project = $PROJECT AND status = Blocked"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    stale)
+        JQL="project = $PROJECT AND status NOT IN (Done, Closed) AND updated <= -30d"
+        ORDER_BY="--order-by updated"
+        ;;
+    high-priority)
+        JQL="project = $PROJECT AND priority IN (Critical, Blocker, High) AND status NOT IN (Done, Closed)"
+        ORDER_BY="--order-by priority"
+        REVERSE="--reverse"
+        ;;
+    needs-review)
+        JQL="project = $PROJECT AND status IN ('Code Review', 'QE Review')"
+        ORDER_BY="--order-by created"
+        ;;
+    "")
+        echo "Error: Pattern required"
+        usage
+        ;;
+    *)
+        echo "Error: Unknown pattern: $PATTERN"
+        usage
+        ;;
+esac
+
+# Execute search
+# shellcheck disable=SC2086
+exec jira issue list --jql "$JQL" $PLAIN --paginate "$PAGINATE" $ORDER_BY $REVERSE

@@ -0,0 +1,308 @@
+#!/usr/bin/env bash
+# Generate sprint summary for standup, planning, or retrospective
+
+set -euo pipefail
+
+usage() {
+    cat <<EOF
+Usage: jira-sprint-summary [options]
+
+Generate sprint summaries and reports.
+
+Options:
+  --current          Current sprint summary (default)
+  --prev             Previous sprint summary
+  --next             Next sprint summary
+  --standup          Daily standup format
+  --retro            Retrospective format
+  --planning         Planning format
+  --format FORMAT    Output format: text, org, md (default: text)
+  --output FILE      Output to file (default: stdout)
+  -h, --help         Show this help
+
+Examples:
+  # Current sprint summary
+  jira-sprint-summary --current
+
+  # Daily standup notes
+  jira-sprint-summary --standup
+
+  # Retrospective data
+  jira-sprint-summary --prev --retro --format org
+EOF
+    exit 1
+}
+
+# Default options
+SPRINT_TYPE="current"
+REPORT_TYPE="summary"
+FORMAT="text"
+OUTPUT=""
+
+# Parse options
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --current) SPRINT_TYPE="current"; shift ;;
+        --prev) SPRINT_TYPE="prev"; shift ;;
+        --next) SPRINT_TYPE="next"; shift ;;
+        --standup) REPORT_TYPE="standup"; shift ;;
+        --retro) REPORT_TYPE="retro"; shift ;;
+        --planning) REPORT_TYPE="planning"; shift ;;
+        --format) FORMAT="$2"; shift 2 ;;
+        --output) OUTPUT="$2"; shift 2 ;;
+        -h|--help) usage ;;
+        *) echo "Unknown option: $1"; usage ;;
+    esac
+done
+
+# Get sprint list based on type
+case "$SPRINT_TYPE" in
+    current) SPRINT_FLAG="--current" ;;
+    prev) SPRINT_FLAG="--prev" ;;
+    next) SPRINT_FLAG="--next" ;;
+esac
+
+# Get sprint info
+SPRINT_INFO=$(jira sprint list "$SPRINT_FLAG" 2>/dev/null) || {
+    echo "Error: Could not fetch sprint"
+    exit 1
+}
+
+SPRINT_NAME=$(echo "$SPRINT_INFO" | head -1)
+
+# Get sprint ID for queries (try to extract from first field)
+SPRINT_ID=$(jira sprint list "$SPRINT_FLAG" --plain 2>/dev/null | head -1 | awk '{print $1}' || echo "")
+
+# Generate JQL for sprint
+if [[ "$SPRINT_TYPE" == "current" ]]; then
+    SPRINT_JQL="sprint in openSprints()"
+elif [[ -n "$SPRINT_ID" ]]; then
+    SPRINT_JQL="sprint = $SPRINT_ID"
+else
+    echo "Warning: Could not determine sprint ID, using openSprints()" >&2
+    SPRINT_JQL="sprint in openSprints()"
+fi
+
+# Fetch sprint issues
+ISSUES=$(jira issue list --jql "$SPRINT_JQL" --plain 2>/dev/null || echo "")
+TOTAL_COUNT=$(echo "$ISSUES" | grep -c "^" || echo "0")
+
+# Count by status
+DONE_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = Done" --plain 2>/dev/null | grep -c "^" || echo "0")
+IN_PROGRESS_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = 'In Progress'" --plain 2>/dev/null | grep -c "^" || echo "0")
+CODE_REVIEW_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = 'Code Review'" --plain 2>/dev/null | grep -c "^" || echo "0")
+QE_REVIEW_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = 'QE Review'" --plain 2>/dev/null | grep -c "^" || echo "0")
+TODO_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = 'To Do'" --plain 2>/dev/null | grep -c "^" || echo "0")
+BLOCKED_COUNT=$(jira issue list --jql "$SPRINT_JQL AND status = Blocked" --plain 2>/dev/null | grep -c "^" || echo "0")
+
+# Calculate completion rate
+if [[ $TOTAL_COUNT -gt 0 ]]; then
+    COMPLETION_RATE=$((DONE_COUNT * 100 / TOTAL_COUNT))
+else
+    COMPLETION_RATE=0
+fi
+
+# Count by type
+BUG_COUNT=$(jira issue list --jql "$SPRINT_JQL AND type = Bug" --plain 2>/dev/null | grep -c "^" || echo "0")
+TASK_COUNT=$(jira issue list --jql "$SPRINT_JQL AND type = Task" --plain 2>/dev/null | grep -c "^" || echo "0")
+STORY_COUNT=$(jira issue list --jql "$SPRINT_JQL AND type = Story" --plain 2>/dev/null | grep -c "^" || echo "0")
+
+# Generate output based on report type and format
+generate_output() {
+    case "$REPORT_TYPE" in
+        standup)
+            case "$FORMAT" in
+                org)
+                    cat <<EOF
+* Daily Standup - $(date +'%Y-%m-%d')
+** Sprint: $SPRINT_NAME
+
+** Yesterday
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND updated >= -1d" --plain 2>/dev/null | head -5 | sed 's/^/- /')
+
+** Today
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status IN ('In Progress', 'Code Review')" --plain 2>/dev/null | sed 's/^/- /')
+
+** Blockers
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status = Blocked" --plain 2>/dev/null | sed 's/^/- /' || echo "- None")
+
+** Sprint Progress
+- Total: $TOTAL_COUNT issues
+- Done: $DONE_COUNT ($COMPLETION_RATE%)
+- In Progress: $IN_PROGRESS_COUNT
+- To Do: $TODO_COUNT
+- Blocked: $BLOCKED_COUNT
+EOF
+                    ;;
+                md)
+                    cat <<EOF
+# Daily Standup - $(date +'%Y-%m-%d')
+
+## Sprint: $SPRINT_NAME
+
+### Yesterday
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND updated >= -1d" --plain 2>/dev/null | head -5 | sed 's/^/- /')
+
+### Today
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status IN ('In Progress', 'Code Review')" --plain 2>/dev/null | sed 's/^/- /')
+
+### Blockers
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status = Blocked" --plain 2>/dev/null | sed 's/^/- /' || echo "- None")
+
+### Sprint Progress
+- Total: $TOTAL_COUNT issues
+- Done: $DONE_COUNT ($COMPLETION_RATE%)
+- In Progress: $IN_PROGRESS_COUNT
+- To Do: $TODO_COUNT
+- Blocked: $BLOCKED_COUNT
+EOF
+                    ;;
+                *)
+                    cat <<EOF
+=== Daily Standup - $(date +'%Y-%m-%d') ===
+Sprint: $SPRINT_NAME
+
+Yesterday:
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND updated >= -1d" --plain 2>/dev/null | head -5)
+
+Today:
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status IN ('In Progress', 'Code Review')" --plain 2>/dev/null)
+
+Blockers:
+$(jira issue list --jql "$SPRINT_JQL AND assignee = currentUser() AND status = Blocked" --plain 2>/dev/null || echo "None")
+
+Sprint Progress:
+  Total: $TOTAL_COUNT issues
+  Done: $DONE_COUNT ($COMPLETION_RATE%)
+  In Progress: $IN_PROGRESS_COUNT
+  To Do: $TODO_COUNT
+  Blocked: $BLOCKED_COUNT
+EOF
+                    ;;
+            esac
+            ;;
+
+        retro)
+            case "$FORMAT" in
+                org)
+                    cat <<EOF
+* Sprint Retrospective - $SPRINT_NAME
+
+** Metrics
+- Total Issues: $TOTAL_COUNT
+- Completed: $DONE_COUNT
+- Incomplete: $((TOTAL_COUNT - DONE_COUNT))
+- Completion Rate: $COMPLETION_RATE%
+
+** Issue Breakdown
+- Bugs: $BUG_COUNT
+- Tasks: $TASK_COUNT
+- Stories: $STORY_COUNT
+
+** Status Distribution
+- Done: $DONE_COUNT
+- In Progress: $IN_PROGRESS_COUNT
+- Code Review: $CODE_REVIEW_COUNT
+- QE Review: $QE_REVIEW_COUNT
+- To Do: $TODO_COUNT
+- Blocked: $BLOCKED_COUNT
+
+** Completed Issues
+$(jira issue list --jql "$SPRINT_JQL AND status = Done" --columns KEY,SUMMARY --plain 2>/dev/null | sed 's/^/- /')
+
+** Incomplete Issues
+$(jira issue list --jql "$SPRINT_JQL AND status != Done" --columns KEY,SUMMARY --plain 2>/dev/null | sed 's/^/- /')
+
+** What Went Well
+
+
+** What Could Be Improved
+
+
+** Action Items
+- [ ]
+
+EOF
+                    ;;
+                *)
+                    cat <<EOF
+=== Sprint Retrospective - $SPRINT_NAME ===
+
+Metrics:
+  Total Issues: $TOTAL_COUNT
+  Completed: $DONE_COUNT
+  Incomplete: $((TOTAL_COUNT - DONE_COUNT))
+  Completion Rate: $COMPLETION_RATE%
+
+Issue Breakdown:
+  Bugs: $BUG_COUNT
+  Tasks: $TASK_COUNT
+  Stories: $STORY_COUNT
+
+Status Distribution:
+  Done: $DONE_COUNT
+  In Progress: $IN_PROGRESS_COUNT
+  Code Review: $CODE_REVIEW_COUNT
+  QE Review: $QE_REVIEW_COUNT
+  To Do: $TODO_COUNT
+  Blocked: $BLOCKED_COUNT
+
+Completed Issues:
+$(jira issue list --jql "$SPRINT_JQL AND status = Done" --columns KEY,SUMMARY --plain 2>/dev/null)
+
+Incomplete Issues:
+$(jira issue list --jql "$SPRINT_JQL AND status != Done" --columns KEY,SUMMARY --plain 2>/dev/null)
+EOF
+                    ;;
+            esac
+            ;;
+
+        planning)
+            cat <<EOF
+=== Sprint Planning - $SPRINT_NAME ===
+
+Current Sprint Summary:
+  Total: $TOTAL_COUNT issues
+  Done: $DONE_COUNT
+  Remaining: $((TOTAL_COUNT - DONE_COUNT))
+
+High Priority Backlog Items:
+$(jira issue list --jql "priority IN (Critical, High) AND status = 'To Do' AND sprint is EMPTY ORDER BY priority DESC" --limit 10 --plain 2>/dev/null)
+
+Unassigned Bugs:
+$(jira issue list --jql "type = Bug AND assignee is EMPTY AND status = 'To Do' ORDER BY priority DESC" --limit 5 --plain 2>/dev/null)
+EOF
+            ;;
+
+        *)
+            # Default summary
+            cat <<EOF
+=== Sprint Summary - $SPRINT_NAME ===
+
+Total Issues: $TOTAL_COUNT
+Completion: $DONE_COUNT/$TOTAL_COUNT ($COMPLETION_RATE%)
+
+Status Breakdown:
+  Done:        $DONE_COUNT
+  In Progress: $IN_PROGRESS_COUNT
+  Code Review: $CODE_REVIEW_COUNT
+  QE Review:   $QE_REVIEW_COUNT
+  To Do:       $TODO_COUNT
+  Blocked:     $BLOCKED_COUNT
+
+Type Breakdown:
+  Bugs:    $BUG_COUNT
+  Tasks:   $TASK_COUNT
+  Stories: $STORY_COUNT
+EOF
+            ;;
+    esac
+}
+
+# Output to file or stdout
+if [[ -n "$OUTPUT" ]]; then
+    generate_output > "$OUTPUT"
+    echo "Summary written to: $OUTPUT"
+else
+    generate_output
+fi

@@ -0,0 +1,201 @@
+#!/usr/bin/env bash
+# Convert Jira issue to org-mode format
+
+set -euo pipefail
+
+usage() {
+    cat <<EOF
+Usage: jira-to-org ISSUE-KEY [options]
+
+Convert Jira issue to org-mode format for denote notes.
+
+Options:
+  --template TYPE    Template type: investigation, planning, discussion
+  --output FILE      Output file (default: stdout)
+  -h, --help         Show this help
+
+Examples:
+  jira-to-org SRVKP-1234
+  jira-to-org SRVKP-1234 --template investigation
+  jira-to-org SRVKP-1234 --output ~/notes/issue.org
+EOF
+    exit 1
+}
+
+ISSUE_KEY="${1:-}"
+TEMPLATE="basic"
+OUTPUT=""
+
+shift || true
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --template)
+            TEMPLATE="$2"
+            shift 2
+            ;;
+        --output)
+            OUTPUT="$2"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            ;;
+        *)
+            echo "Unknown option: $1"
+            usage
+            ;;
+    esac
+done
+
+if [[ -z "$ISSUE_KEY" ]]; then
+    echo "Error: ISSUE-KEY required"
+    usage
+fi
+
+# Fetch issue details
+ISSUE_DATA=$(jira issue view "$ISSUE_KEY" --plain 2>/dev/null || {
+    echo "Error: Failed to fetch issue $ISSUE_KEY"
+    exit 1
+})
+
+# Extract fields (basic parsing - adjust based on actual output format)
+SUMMARY=$(echo "$ISSUE_DATA" | grep -A1 "^Summary:" | tail -1 | sed 's/^[[:space:]]*//')
+STATUS=$(echo "$ISSUE_DATA" | grep "Status:" | sed 's/.*Status:[[:space:]]*//' | awk '{print $1}')
+PRIORITY=$(echo "$ISSUE_DATA" | grep "Priority:" | sed 's/.*Priority:[[:space:]]*//' | awk '{print $1}')
+ASSIGNEE=$(echo "$ISSUE_DATA" | grep "Assignee:" | sed 's/.*Assignee:[[:space:]]*//')
+TYPE=$(echo "$ISSUE_DATA" | grep "Type:" | sed 's/.*Type:[[:space:]]*//' | awk '{print $1}')
+
+# Generate org-mode content based on template
+generate_org() {
+    cat <<EOF
+* $ISSUE_KEY: $SUMMARY
+
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/$ISSUE_KEY
+:JIRA_KEY: $ISSUE_KEY
+:JIRA_STATUS: $STATUS
+:JIRA_PRIORITY: $PRIORITY
+:JIRA_TYPE: $TYPE
+:CREATED: $(date '+[%Y-%m-%d %a %H:%M]')
+:END:
+
+[[https://issues.redhat.com/browse/$ISSUE_KEY][View in Jira]]
+
+** Issue Details
+- Status: $STATUS
+- Priority: $PRIORITY
+- Assignee: $ASSIGNEE
+- Type: $TYPE
+
+** Description
+EOF
+
+    # Add template-specific sections
+    case "$TEMPLATE" in
+        investigation)
+            cat <<'EOF'
+
+** Investigation
+*** Hypothesis
+
+
+*** Findings
+
+
+*** Root Cause
+
+
+** Solution
+*** Proposed Fix
+
+
+*** Testing Plan
+- [ ] Test case 1
+- [ ] Test case 2
+
+*** Implementation Notes
+
+
+** Related
+- Related issues:
+- PRs:
+- Documentation:
+EOF
+            ;;
+        planning)
+            cat <<'EOF'
+
+** Goals
+
+
+** Requirements
+*** Functional Requirements
+
+
+*** Non-Functional Requirements
+
+
+** Design
+*** Architecture
+
+
+*** Components
+
+
+** Implementation Plan
+*** Phase 1
+- [ ] Task 1
+- [ ] Task 2
+
+** Testing Strategy
+
+
+** Timeline
+| Phase | Start | End | Status |
+|-------+-------+-----+--------|
+|       |       |     |        |
+EOF
+            ;;
+        discussion)
+            cat <<'EOF'
+
+** Context
+
+
+** Discussion Points
+
+
+** Decisions
+
+
+** Action Items
+- [ ] Action 1
+- [ ] Action 2
+
+** Next Steps
+
+EOF
+            ;;
+        basic)
+            cat <<'EOF'
+
+** Notes
+
+
+** Tasks
+- [ ] Task 1
+
+** Related
+EOF
+            ;;
+    esac
+}
+
+# Output to file or stdout
+if [[ -n "$OUTPUT" ]]; then
+    generate_org > "$OUTPUT"
+    echo "Created org-mode note: $OUTPUT"
+else
+    generate_org
+fi

@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+# Convert Jira issues to org-mode TODOs
+
+set -euo pipefail
+
+usage() {
+    cat <<EOF
+Usage: jira-to-todo [options] [ISSUE-KEY...]
+
+Convert Jira issues to org-mode TODO format and optionally add to todos.org.
+
+Options:
+  --jql QUERY        Use JQL query to find issues
+  --output FILE      Output file (default: stdout)
+  --section SECTION  Section in todos.org (Work, Projects, Systems, Personal)
+  --add              Add to ~/desktop/org/todos.org
+  --state STATE      TODO state (TODO, NEXT, STRT) (default: TODO)
+  --priority N       Org priority [#1] through [#5]
+  -h, --help         Show this help
+
+Examples:
+  # Convert single issue
+  jira-to-todo SRVKP-1234
+
+  # Convert my sprint issues and add to Work section
+  jira-to-todo --jql "sprint in openSprints() AND assignee = currentUser()" --add --section Work
+
+  # Convert and save to file
+  jira-to-todo SRVKP-1234 SRVKP-5678 --output /tmp/todos.org
+EOF
+    exit 1
+}
+
+# Default options
+JQL=""
+OUTPUT=""
+SECTION=""
+ADD_TO_FILE=false
+STATE="TODO"
+PRIORITY=""
+ISSUES=()
+
+# Parse options
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --jql)
+            JQL="$2"
+            shift 2
+            ;;
+        --output)
+            OUTPUT="$2"
+            shift 2
+            ;;
+        --section)
+            SECTION="$2"
+            shift 2
+            ;;
+        --add)
+            ADD_TO_FILE=true
+            shift
+            ;;
+        --state)
+            STATE="$2"
+            shift 2
+            ;;
+        --priority)
+            PRIORITY="[#$2]"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            ;;
+        -*)
+            echo "Unknown option: $1"
+            usage
+            ;;
+        *)
+            ISSUES+=("$1")
+            shift
+            ;;
+    esac
+done
+
+# Get issues from JQL or arguments
+if [[ -n "$JQL" ]]; then
+    mapfile -t ISSUE_KEYS < <(jira issue list --jql "$JQL" --plain 2>/dev/null | awk '{print $1}')
+elif [[ ${#ISSUES[@]} -gt 0 ]]; then
+    ISSUE_KEYS=("${ISSUES[@]}")
+else
+    echo "Error: Provide ISSUE-KEY or --jql QUERY"
+    usage
+fi
+
+if [[ ${#ISSUE_KEYS[@]} -eq 0 ]]; then
+    echo "No issues found"
+    exit 1
+fi
+
+# Convert priority from Jira to org (if not specified)
+jira_to_org_priority() {
+    local jira_priority="$1"
+    case "$jira_priority" in
+        Blocker|Critical) echo "[#1]" ;;
+        Major|High) echo "[#2]" ;;
+        Medium) echo "[#3]" ;;
+        Minor) echo "[#4]" ;;
+        Trivial) echo "[#5]" ;;
+        *) echo "[#3]" ;;  # Default to medium
+    esac
+}
+
+# Generate TODO entry for an issue
+generate_todo() {
+    local issue_key="$1"
+
+    # Fetch issue details
+    local issue_data
+    issue_data=$(jira issue view "$issue_key" --plain 2>/dev/null) || {
+        echo "Warning: Could not fetch $issue_key" >&2
+        return 1
+    }
+
+    # Parse fields (basic extraction - adjust based on actual format)
+    local summary status jira_priority type
+    summary=$(echo "$issue_data" | grep -i "summary" | head -1 | sed 's/.*:[[:space:]]*//' || echo "Unknown")
+    status=$(echo "$issue_data" | grep -i "status" | head -1 | sed 's/.*:[[:space:]]*//' | awk '{print $1}' || echo "Unknown")
+    jira_priority=$(echo "$issue_data" | grep -i "priority" | head -1 | sed 's/.*:[[:space:]]*//' | awk '{print $1}' || echo "Medium")
+    type=$(echo "$issue_data" | grep -i "type" | head -1 | sed 's/.*:[[:space:]]*//' | awk '{print $1}' || echo "Task")
+
+    # Determine org priority
+    local org_priority
+    if [[ -n "$PRIORITY" ]]; then
+        org_priority="$PRIORITY"
+    else
+        org_priority=$(jira_to_org_priority "$jira_priority")
+    fi
+
+    # Determine TODO state based on Jira status
+    local todo_state="$STATE"
+    if [[ "$STATE" == "TODO" ]]; then
+        case "$status" in
+            "In Progress"|"Code Review"|"QE Review") todo_state="STRT" ;;
+            "To Do") todo_state="TODO" ;;
+            "Done") todo_state="DONE" ;;
+            *) todo_state="TODO" ;;
+        esac
+    fi
+
+    # Generate TODO entry
+    cat <<EOF
+** $todo_state $org_priority $issue_key: $summary
+:PROPERTIES:
+:CREATED:       [$(date +'%Y-%m-%d %a %H:%M')]
+:JIRA:          https://issues.redhat.com/browse/$issue_key
+:JIRA_KEY:      $issue_key
+:JIRA_STATUS:   $status
+:JIRA_PRIORITY: $jira_priority
+:JIRA_TYPE:     $type
+:CATEGORY:      work
+:END:
+
+Jira: [[https://issues.redhat.com/browse/$issue_key][$issue_key]]
+Type: $type | Status: $status | Priority: $jira_priority
+
+EOF
+}
+
+# Generate all TODOs
+generate_all() {
+    for issue_key in "${ISSUE_KEYS[@]}"; do
+        generate_todo "$issue_key"
+    done
+}
+
+# Output to file or stdout
+if [[ "$ADD_TO_FILE" == true ]]; then
+    TODOS_FILE="$HOME/desktop/org/todos.org"
+
+    if [[ ! -f "$TODOS_FILE" ]]; then
+        echo "Error: $TODOS_FILE not found"
+        exit 1
+    fi
+
+    if [[ -z "$SECTION" ]]; then
+        echo "Error: --section required when using --add"
+        exit 1
+    fi
+
+    # Create temporary file with new TODOs
+    TMPFILE=$(mktemp)
+    generate_all > "$TMPFILE"
+
+    # Use org-manager to add to section (if available)
+    if command -v ~/.config/claude/skills/Org/tools/org-manager &>/dev/null; then
+        # TODO: Implement adding to specific section
+        # For now, just append to file and let user refile
+        echo "Adding ${#ISSUE_KEYS[@]} TODOs to inbox..."
+        cat "$TMPFILE" >> "$HOME/desktop/org/inbox.org"
+        echo "TODOs added to inbox.org. Please refile to appropriate sections."
+    else
+        # Fallback: just show the TODOs
+        echo "Generated TODOs (add manually to $SECTION section):"
+        cat "$TMPFILE"
+    fi
+
+    rm "$TMPFILE"
+
+elif [[ -n "$OUTPUT" ]]; then
+    generate_all > "$OUTPUT"
+    echo "TODOs written to: $OUTPUT"
+else
+    generate_all
+fi

@@ -0,0 +1,320 @@
+# Add Comment to Jira Issue
+
+Add comments, updates, or discussion to Jira issues.
+
+## When to Use
+
+- User wants to add a comment to an issue
+- Need to provide update or status
+- Responding to question in issue
+- Documenting progress or findings
+- Communicating with team on issue
+
+## Steps
+
+1. **Identify the issue** to comment on
+2. **Prepare the comment** text
+3. **Add the comment** using jira command
+4. **Confirm addition**
+5. **Offer to view** the updated issue
+
+## Commands
+
+### Interactive Comment
+```bash
+jira issue comment add ISSUE-KEY
+```
+Opens editor for multi-line comment
+
+### Inline Comment
+```bash
+jira issue comment add ISSUE-KEY "Comment text here"
+```
+
+### Comment from File
+```bash
+jira issue comment add ISSUE-KEY --from-file comment.txt
+```
+
+### View Comments
+```bash
+jira issue view ISSUE-KEY --comments 10
+```
+
+### Comment with Mention
+```bash
+jira issue comment add ISSUE-KEY "[~vdemeester] Can you take a look at this?"
+```
+
+## Comment Formatting
+
+### Mention User
+```
+[~username] or [@username]
+```
+
+### Link to Issue
+```
+SRVKP-1234 (auto-linked)
+```
+
+### Code Block
+```
+{code:bash}
+kubectl get pods
+{code}
+```
+
+### Quote
+```
+{quote}
+Original text here
+{quote}
+```
+
+### Bold/Italic
+```
+*bold text*
+_italic text_
+```
+
+### Lists
+```
+* Item 1
+* Item 2
+** Sub-item 2a
+```
+
+### Links
+```
+[Link text|https://example.com]
+```
+
+## Examples
+
+### Example 1: Quick Update
+**User**: "Comment on SRVKP-7327 that I'm investigating this"
+
+**Action**:
+```bash
+jira issue comment add SRVKP-7327 "Investigating this issue. Will provide update by EOD."
+```
+
+**Response**: "Added comment. Would you like to change the status to In Progress?"
+
+### Example 2: Provide Solution
+**User**: "Add comment with the workaround for SRVKP-1234"
+
+**Action**:
+```bash
+jira issue comment add SRVKP-1234 "$(cat <<'EOF'
+*Workaround Found*
+
+Set the following SCC to the default service account:
+
+{code:bash}
+oc adm policy add-scc-to-user anyuid system:serviceaccount:default:default
+{code}
+
+This allows the affinity assistant pod to be created successfully.
+EOF
+)"
+```
+
+### Example 3: Tag Team Member
+**User**: "Ask Vincent to review SRVKP-5678"
+
+**Action**:
+```bash
+jira issue comment add SRVKP-5678 "[~vdemeester] Could you review this when you have time? Thanks!"
+```
+
+### Example 4: Progress Update
+**User**: "Comment that I've finished the implementation"
+
+**Action**:
+```bash
+jira issue comment add ISSUE-KEY "Implementation completed. Ready for code review.
+
+Changes:
+* Added feature X
+* Updated tests
+* Updated documentation
+
+PR: https://github.com/org/repo/pull/123"
+```
+
+## Common Comment Patterns
+
+### Status Update
+```bash
+jira issue comment add ISSUE-KEY "Working on this. Currently investigating the root cause."
+```
+
+### Blocker Notification
+```bash
+jira issue comment add ISSUE-KEY "Blocked by SRVKP-9999. Cannot proceed until that's resolved."
+```
+
+### Request for Information
+```bash
+jira issue comment add ISSUE-KEY "[~reporter] Can you provide more details about how to reproduce this?"
+```
+
+### Resolution Summary
+```bash
+jira issue comment add ISSUE-KEY "Fixed in PR #123. The issue was caused by X. Solution implemented: Y."
+```
+
+### Testing Results
+```bash
+jira issue comment add ISSUE-KEY "Tested on environment X. All scenarios passed. Ready for QE review."
+```
+
+## Multi-line Comments
+
+For longer comments, use heredoc:
+
+```bash
+jira issue comment add ISSUE-KEY "$(cat <<'EOF'
+# Investigation Summary
+
+## Root Cause
+The issue occurs because...
+
+## Proposed Fix
+We should...
+
+## Testing Plan
+1. Test scenario A
+2. Test scenario B
+3. Verify no regression
+
+## Timeline
+- Implementation: 2 days
+- Testing: 1 day
+- Review: 1 day
+EOF
+)"
+```
+
+## Comment Best Practices
+
+### 1. Be Clear and Concise
+- State the purpose upfront
+- Use formatting for readability
+- Break up long text into sections
+
+### 2. Provide Context
+- Reference related issues
+- Link to PRs, commits, docs
+- Include relevant code snippets
+
+### 3. Tag Appropriately
+- Mention users who need to see it
+- Use @username or [~username]
+- Don't over-notify
+
+### 4. Use Formatting
+- Code blocks for code
+- Lists for steps or items
+- Bold for important points
+- Links for references
+
+### 5. Keep Professional
+- Focus on facts and solutions
+- Be constructive in feedback
+- Use neutral tone
+
+## Viewing Comments
+
+### View All Comments
+```bash
+jira issue view ISSUE-KEY --comments 100
+```
+
+### View Recent Comments
+```bash
+jira issue view ISSUE-KEY --comments 5
+```
+
+### Plain Text Comments
+```bash
+jira issue view ISSUE-KEY --comments 10 --plain
+```
+
+## Comment Templates
+
+### Investigation Update
+```
+*Investigation Update*
+
+Status: In Progress
+Findings:
+* Finding 1
+* Finding 2
+
+Next Steps:
+* Step 1
+* Step 2
+
+ETA: [date]
+```
+
+### Fix Applied
+```
+*Fix Applied*
+
+Changes: [PR link or commit]
+Testing: Passed local tests
+Deployment: Ready for QE
+
+Resolves: [describe how it fixes the issue]
+```
+
+### Needs Information
+```
+*Additional Information Needed*
+
+To proceed, we need:
+1. [Item 1]
+2. [Item 2]
+
+[~reporter] Could you provide these details?
+```
+
+### Blocked
+```
+*Issue Blocked*
+
+Blocked by: SRVKP-XXXX
+Reason: [explain dependency]
+Workaround: [if available]
+
+Can we prioritize the blocker?
+```
+
+## Follow-up Actions
+
+After commenting:
+- **Change status**: If comment indicates progress
+- **Update labels**: Add relevant tags
+- **Notify team**: Send email if urgent
+- **Link issues**: Connect related work
+- **Log work**: Track time spent
+
+## Tips
+
+- **Use templates**: Save common comment patterns
+- **Format code**: Always use code blocks
+- **Link everything**: PRs, commits, docs
+- **Be timely**: Comment when you make progress
+- **Document decisions**: Explain why, not just what
+- **Use mentions sparingly**: Notify only relevant people
+- **Edit if needed**: Fix mistakes or add clarification
+
+## Integration
+
+- **Notes Skill**: Copy comment content to notes
+- **Email Skill**: Send comment summary to stakeholders
+- **Git**: Reference issue in commits with similar message

@@ -0,0 +1,332 @@
+# Create Jira Issue
+
+Create new Jira issues (bugs, tasks, stories, epics).
+
+## When to Use
+
+- User wants to create a new ticket
+- User says "file a bug", "create task", "new issue"
+- Need to track work or report a problem
+- Converting discussion or notes into actionable items
+
+## Steps
+
+1. **Determine issue type** (Bug, Task, Story, Epic)
+2. **Gather required information**:
+   - Summary (title)
+   - Description
+   - Project key (default: SRVKP)
+   - Priority (optional)
+   - Labels (optional)
+   - Assignee (optional)
+3. **Create issue** using interactive or non-interactive mode
+4. **Confirm creation** and provide issue key
+5. **Offer follow-up actions** (assign, link to note, add to sprint)
+
+## Commands
+
+### Interactive Create
+```bash
+jira issue create
+```
+Prompts for all fields interactively
+
+### Create with Template
+```bash
+jira issue create -t
+```
+Uses project template
+
+### Create Bug
+```bash
+jira issue create \
+  --type Bug \
+  --summary "Affinity assistant pod not created" \
+  --priority Major \
+  --label bug,scc
+```
+
+### Create Task
+```bash
+jira issue create \
+  --type Task \
+  --summary "Update documentation for feature X" \
+  --assignee $(jira me)
+```
+
+### Create from File
+```bash
+jira issue create --template issue-template.json
+```
+
+## Required Fields
+
+### All Issues
+- **Project**: Usually SRVKP (can be set as default)
+- **Issue Type**: Bug, Task, Story, Epic, Spike, Sub-task
+- **Summary**: Brief title (should be descriptive)
+
+### Bugs
+- **Description**: Steps to reproduce, actual/expected behavior
+- **Priority**: Severity of the issue
+- **Affects Version**: Which version has the bug
+- **Environment**: OS, platform, configuration
+
+### Stories/Tasks
+- **Description**: What needs to be done and why
+- **Acceptance Criteria**: Definition of done
+
+### Epics
+- **Epic Name**: Short name for the epic
+- **Description**: High-level goal
+
+## Issue Types
+
+### Bug
+Software defects that need fixing
+```bash
+jira issue create \
+  --type Bug \
+  --summary "Title" \
+  --priority Major \
+  --description "$(cat <<'EOF'
+Description of problem:
+Steps to reproduce:
+1.
+2.
+3.
+
+Actual results:
+
+
+Expected results:
+
+
+Reproducibility: Always/Intermittent/Only Once
+EOF
+)"
+```
+
+### Task
+General work items
+```bash
+jira issue create \
+  --type Task \
+  --summary "Implement feature X" \
+  --description "Technical details..."
+```
+
+### Story
+User-focused features
+```bash
+jira issue create \
+  --type Story \
+  --summary "As a user, I want to..." \
+  --description "User story and acceptance criteria"
+```
+
+### Epic
+Large initiatives
+```bash
+jira issue create \
+  --type Epic \
+  --summary "Epic: Major feature set" \
+  --description "High-level goals and sub-initiatives"
+```
+
+## Priority Levels
+
+- **Blocker**: Blocks development/testing, needs immediate attention
+- **Critical**: System crashes, data loss, no workaround
+- **Major**: Major functionality broken, workaround exists
+- **Minor**: Minor functionality issue
+- **Trivial**: Cosmetic issues, nice-to-have
+
+## Common Labels
+
+Red Hat Jira common labels:
+- `bug` - Bug fix
+- `feature` - New feature
+- `documentation` - Docs work
+- `test` - Testing work
+- `release-notes-pending` - Needs release notes
+- `docs-pending` - Needs documentation
+- `customer-reported` - From customer
+- `security` - Security issue
+
+## Examples
+
+### Example 1: Quick Bug Report
+**User**: "File a bug that the affinity assistant pod isn't being created"
+
+**Action**:
+```bash
+jira issue create \
+  --type Bug \
+  --summary "Affinity assistant pod not created" \
+  --priority Major \
+  --label bug,docs-pending \
+  --description "Description of the issue..."
+```
+
+**Response**: "Created SRVKP-7327. Would you like me to assign it to you or add it to the current sprint?"
+
+### Example 2: Task from Discussion
+**User**: "Create a task to update the beets configuration documentation"
+
+**Action**:
+```bash
+jira issue create \
+  --type Task \
+  --summary "Update beets configuration documentation" \
+  --assignee $(jira me) \
+  --label documentation
+```
+
+### Example 3: Interactive Creation
+**User**: "Create a new issue"
+
+**Action**: Run `jira issue create` and guide user through prompts:
+1. Project: SRVKP (or ask)
+2. Issue Type: (ask user)
+3. Summary: (ask user)
+4. Description: (ask user to provide details)
+5. Additional fields as needed
+
+## Best Practices
+
+### 1. Clear Summaries
+- Be specific and descriptive
+- Include key information in title
+- Avoid vague titles like "Fix bug" or "Update code"
+
+**Good**: "Affinity assistant pod fails to create with default serviceAccount"
+**Bad**: "Pod issue"
+
+### 2. Detailed Descriptions
+For bugs:
+- Steps to reproduce
+- Actual vs expected behavior
+- Environment details
+- Reproducibility
+
+For tasks/stories:
+- Context and motivation
+- Acceptance criteria
+- Technical notes if relevant
+
+### 3. Appropriate Priority
+- Don't over-prioritize everything as Critical
+- Consider actual impact on users/system
+- Align with team conventions
+
+### 4. Useful Labels
+- Add relevant labels for filtering
+- Include `release-notes-pending` if user-facing
+- Add `docs-pending` if docs needed
+- Tag with component or area
+
+### 5. Link Related Issues
+- Reference related issues in description
+- Use "relates to", "blocks", "is blocked by"
+- Link to epics or parent issues
+
+## Description Templates
+
+### Bug Template
+```markdown
+### Description of problem:
+[What's wrong]
+
+### Prerequisites:
+[Setup, operators/versions]
+
+### Steps to Reproduce:
+1. [First step]
+2. [Second step]
+3. [Third step]
+
+### Actual results:
+[What happens]
+
+### Expected results:
+[What should happen]
+
+### Reproducibility:
+Always / Intermittent / Only Once
+
+### Additional info:
+[Logs, screenshots, etc]
+```
+
+### Task Template
+```markdown
+### Objective:
+[What needs to be done]
+
+### Context:
+[Why this is needed]
+
+### Acceptance Criteria:
+- [ ] [Criterion 1]
+- [ ] [Criterion 2]
+- [ ] [Criterion 3]
+
+### Technical Notes:
+[Implementation details]
+```
+
+## Follow-up Actions
+
+After creating an issue:
+- **Assign it**: To yourself or team member
+- **Add to sprint**: Include in current sprint
+- **Link to epic**: Associate with larger initiative
+- **Create note**: Document in org-mode
+- **Add TODO**: Track in personal task list
+- **Share**: Send link to team
+
+## Non-Interactive Examples
+
+### Create and Assign
+```bash
+jira issue create \
+  --type Task \
+  --summary "Title" \
+  --assignee $(jira me) \
+  --no-input
+```
+
+### Create with Labels
+```bash
+jira issue create \
+  --type Bug \
+  --summary "Title" \
+  --label bug,critical,customer-reported \
+  --priority Critical
+```
+
+### Create Sub-task
+```bash
+jira issue create \
+  --type Sub-task \
+  --summary "Subtask title" \
+  --parent SRVKP-1234
+```
+
+## Tips
+
+- **Use templates**: Save common issue patterns
+- **Set defaults**: Configure default project/type in config
+- **Copy from similar**: Base on previous issues
+- **Include context**: Link to docs, PRs, commits
+- **Tag appropriately**: Make issues discoverable
+- **Assign on creation**: If you know the owner
+- **Link immediately**: Connect to epics/sprints early
+
+## Integration
+
+- **Notes Skill**: Reference issue in denote notes
+- **TODOs Skill**: Create corresponding TODO
+- **Git**: Reference issue key in commits
+- **Email**: Notify team about new issue

@@ -0,0 +1,356 @@
+# Link Jira Issue to Org-Mode Note
+
+Create or link Jira issues with org-mode denote notes for documentation and context.
+
+## When to Use
+
+- User wants to document a Jira issue in detail
+- Need to track investigation or research
+- Creating comprehensive issue analysis
+- Linking work context with issues
+- Project planning with Jira integration
+
+## Steps
+
+1. **Identify the Jira issue** to document
+2. **Fetch issue details** for context
+3. **Create denote note** with appropriate tags
+4. **Add Jira issue link** to note
+5. **Optionally add note link** to Jira comment
+6. **Confirm creation** and offer next actions
+
+## Integration Pattern
+
+### 1. Fetch Issue Information
+```bash
+jira issue view ISSUE-KEY --plain
+```
+
+### 2. Create Denote Note
+Use Notes skill to create note with:
+- **Title**: "ISSUE-KEY: Issue Summary"
+- **Tags**: `jira`, project tag (e.g., `tekton`), issue type (e.g., `bug`)
+- **Keywords**: Relevant keywords from issue
+
+### 3. Add Jira Link to Note
+```org
+* ISSUE-KEY: Issue Summary
+
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/ISSUE-KEY
+:CREATED: [timestamp]
+:END:
+
+[[https://issues.redhat.com/browse/ISSUE-KEY][View in Jira]]
+
+** Issue Details
+- Status: [status]
+- Priority: [priority]
+- Assignee: [assignee]
+- Type: [type]
+
+** Description
+[Issue description]
+
+** Investigation Notes
+[Your notes here]
+
+** Related Work
+- Link to related notes
+- Link to code changes
+- Link to documentation
+```
+
+### 4. Link Note to Jira (Optional)
+```bash
+jira issue comment add ISSUE-KEY "Documentation: file://path/to/note.org"
+```
+
+## Examples
+
+### Example 1: Document Bug Investigation
+**User**: "Create a note for investigating SRVKP-7327"
+
+**Actions**:
+1. Fetch issue:
+```bash
+jira issue view SRVKP-7327 --plain
+```
+
+2. Create note with Notes skill:
+- Title: "SRVKP-7327: Affinity assistant pod not created"
+- Tags: `jira`, `tekton`, `bug`, `affinity-assistant`
+
+3. Populate note with issue details and add sections for:
+- Root cause analysis
+- Investigation steps
+- Testing notes
+- Solution approach
+
+4. Add comment to Jira:
+```bash
+jira issue comment add SRVKP-7327 "Investigation notes: [link to note]"
+```
+
+### Example 2: Feature Planning
+**User**: "Create a planning note for the new epic SRVKP-8000"
+
+**Actions**:
+1. Fetch epic details
+2. Create note with:
+   - Epic summary
+   - Goals and requirements
+   - Sub-tasks breakdown
+   - Technical approach
+3. Link sub-tasks as they're created
+
+### Example 3: Link Existing Note
+**User**: "Link my note about affinity assistants to SRVKP-7327"
+
+**Actions**:
+1. Find the note using Notes skill
+2. Add Jira property to note:
+```org
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/SRVKP-7327
+:END:
+```
+3. Add comment to Jira with note reference
+
+## Note Templates
+
+### Bug Investigation Note
+```org
+* SRVKP-XXXX: Bug Summary
+
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/SRVKP-XXXX
+:CREATED: [timestamp]
+:END:
+
+[[https://issues.redhat.com/browse/SRVKP-XXXX][View in Jira]]
+
+** Issue Details
+- Status: To Do
+- Priority: Major
+- Assignee: username
+- Reporter: reporter-name
+- Type: Bug
+
+** Description
+[Issue description from Jira]
+
+** Reproduction Steps
+1. Step 1
+2. Step 2
+3. Step 3
+
+** Investigation
+*** Hypothesis
+[Initial thoughts on root cause]
+
+*** Findings
+- Finding 1
+- Finding 2
+
+*** Root Cause
+[Identified root cause]
+
+** Solution
+*** Proposed Fix
+[Description of fix]
+
+*** Testing Plan
+- [ ] Test case 1
+- [ ] Test case 2
+- [ ] Regression testing
+
+*** Implementation Notes
+[Technical details]
+
+** Related
+- Related issues: [[SRVKP-YYYY]]
+- PRs: [[link]]
+- Documentation: [[link]]
+```
+
+### Feature Planning Note
+```org
+* SRVKP-XXXX: Feature Name
+
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/SRVKP-XXXX
+:TYPE: Epic
+:CREATED: [timestamp]
+:END:
+
+** Overview
+[Feature description]
+
+** Goals
+- Goal 1
+- Goal 2
+- Goal 3
+
+** Requirements
+*** Functional Requirements
+- Requirement 1
+- Requirement 2
+
+*** Non-Functional Requirements
+- Performance
+- Security
+- Scalability
+
+** Design
+*** Architecture
+[Architecture overview]
+
+*** Components
+- Component 1: [description]
+- Component 2: [description]
+
+*** Data Model
+[Data structures]
+
+** Implementation Plan
+*** Phase 1: [Name]
+- [ ] Task 1 - SRVKP-XXX1
+- [ ] Task 2 - SRVKP-XXX2
+
+*** Phase 2: [Name]
+- [ ] Task 3 - SRVKP-XXX3
+- [ ] Task 4 - SRVKP-XXX4
+
+** Testing Strategy
+- Unit tests
+- Integration tests
+- E2E tests
+
+** Documentation
+- User documentation
+- API documentation
+- Migration guide
+
+** Timeline
+| Phase | Start | End | Status |
+|-------+-------+-----+--------|
+| Phase 1 | [date] | [date] | In Progress |
+| Phase 2 | [date] | [date] | Planned |
+
+** Related Issues
+- SRVKP-XXX1: [[link]]
+- SRVKP-XXX2: [[link]]
+```
+
+### Meeting/Discussion Note
+```org
+* SRVKP-XXXX Discussion Notes
+
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/SRVKP-XXXX
+:MEETING_DATE: [date]
+:ATTENDEES: person1, person2, person3
+:END:
+
+** Context
+[Issue being discussed]
+
+** Discussion Points
+*** Point 1
+[Discussion and decisions]
+
+*** Point 2
+[Discussion and decisions]
+
+** Decisions
+- Decision 1
+- Decision 2
+
+** Action Items
+- [ ] Action 1 - @person1
+- [ ] Action 2 - @person2
+
+** Next Steps
+[What happens next]
+```
+
+## Workflow Integration
+
+### From Jira to Note
+1. User mentions Jira issue
+2. Fetch issue details
+3. Create denote note with structure
+4. Populate with issue information
+5. Add sections for work tracking
+
+### From Note to Jira
+1. User creates note about topic
+2. Realize it needs Jira tracking
+3. Create Jira issue with Notes skill context
+4. Link note to newly created issue
+5. Add Jira property to note
+
+### Bi-directional Linking
+1. Issue has note reference in comment
+2. Note has Jira property
+3. Easy navigation between both
+4. Synchronized updates
+
+## Org-Mode Properties for Jira
+
+```org
+:PROPERTIES:
+:JIRA: https://issues.redhat.com/browse/ISSUE-KEY
+:JIRA_KEY: SRVKP-1234
+:JIRA_STATUS: In Progress
+:JIRA_PRIORITY: Major
+:JIRA_ASSIGNEE: username
+:LAST_SYNCED: [timestamp]
+:END:
+```
+
+## Benefits
+
+1. **Rich Documentation**: More detailed than Jira allows
+2. **Local Search**: Find issues via denote search
+3. **Context Preservation**: Keep investigation notes
+4. **Linking**: Connect issues with code, docs, other notes
+5. **Version Control**: Track note changes over time
+6. **Offline Access**: Work without internet
+7. **Integration**: Part of your note-taking workflow
+
+## Best Practices
+
+1. **Create early**: Start note when beginning work
+2. **Update regularly**: Keep notes current
+3. **Link liberally**: Connect to related notes
+4. **Use org features**: Tags, TODOs, timestamps
+5. **Sync key info**: Update Jira with major findings
+6. **Preserve context**: Don't delete investigation paths
+7. **Structure consistently**: Use templates
+
+## Follow-up Actions
+
+After linking:
+- **Add TODO**: If action needed
+- **Update Jira**: Comment with note link
+- **Tag appropriately**: For denote searching
+- **Link related notes**: Cross-reference
+- **Schedule review**: Revisit for updates
+
+## Tips
+
+- **Use denote backlinks**: Find all issues-related notes
+- **Tag by project**: `tekton`, `pipelines`, etc.
+- **Tag by type**: `bug`, `feature`, `investigation`
+- **Include timestamps**: Track when work done
+- **Export to Jira**: Copy sections to Jira when done
+- **Archive when done**: Don't delete, archive
+
+## Integration with Other Skills
+
+- **Notes Skill**: Create and manage denote notes
+- **TODOs Skill**: Create action items from issues
+- **Git Skill**: Link commits to issues and notes
+- **Org Skill**: Manage org-mode structure

@@ -0,0 +1,235 @@
+# List Jira Issues
+
+List and filter Jira issues based on various criteria.
+
+## When to Use
+
+- User asks to see their issues/tickets
+- User wants to filter issues by status, priority, assignee, etc.
+- Need to get an overview of work items
+- Preparing for standup or sprint planning
+- Finding issues to work on
+
+## Steps
+
+1. **Determine filter criteria** from user request
+2. **Construct appropriate jira command** with filters
+3. **Execute and present results** in a clear format
+4. **Offer refinement or actions** on the listed issues
+
+## Common Commands
+
+### My Open Issues
+```bash
+jira issue list -a $(jira me) -s ~Done
+```
+
+### My Current Work
+```bash
+jira issue list -a $(jira me) -s "In Progress"
+```
+
+### High Priority Issues
+```bash
+jira issue list -p Critical,Blocker,High -s ~Done
+```
+
+### Recent Bugs
+```bash
+jira issue list -t Bug --created-after -7d
+```
+
+### Unassigned Issues in Project
+```bash
+jira issue list -a x@
+```
+
+### Issues Updated Recently
+```bash
+jira issue list --updated-after -3d
+```
+
+### Plain Text List (for processing)
+```bash
+jira issue list --plain -a $(jira me)
+```
+
+## Filter Options
+
+### By Assignee
+- `-a USERNAME` or `-a $(jira me)` for yourself
+- `-a x@` for unassigned issues
+
+### By Status
+- `-s "To Do"` - Specific status
+- `-s "To Do","In Progress"` - Multiple statuses
+- `-s ~Done` - NOT Done (all open)
+
+### By Type
+- `-t Bug` - Bugs only
+- `-t Task,Story` - Multiple types
+- `-t Epic` - Epics only
+
+### By Priority
+- `-p Critical,Blocker` - High priority
+- `-p Minor,Trivial` - Low priority
+
+### By Time
+- `--created-after -7d` - Created in last 7 days
+- `--updated-after -1w` - Updated in last week
+- `--created-before 2025-01-01` - Before specific date
+
+### By Labels
+- `-l documentation,bug` - Has specific labels
+- `-l release-notes-pending` - Needs release notes
+
+### Custom Columns
+```bash
+jira issue list --columns TYPE,KEY,SUMMARY,STATUS,ASSIGNEE
+```
+
+### Limit Results
+```bash
+jira issue list -a $(jira me) --limit 20
+```
+
+## Output Formatting
+
+### Default View
+Shows table with key, summary, status, assignee
+
+### Plain Text (--plain)
+Best for scripting and AI processing:
+```bash
+jira issue list --plain -a $(jira me) -s "In Progress"
+```
+
+### No Truncation (--no-truncate)
+Shows full field values:
+```bash
+jira issue list --no-truncate
+```
+
+### Reverse Order (--reverse)
+Reverse the sort order:
+```bash
+jira issue list --reverse
+```
+
+## Examples
+
+### Example 1: Daily Standup Prep
+**User**: "What am I working on?"
+
+**Action**:
+```bash
+jira issue list -a $(jira me) -s "In Progress","Code Review"
+```
+
+**Presentation**: List issues with status, highlighting blockers
+
+### Example 2: Find Something to Work On
+**User**: "Show me unassigned tasks in SRVKP"
+
+**Action**:
+```bash
+jira issue list -a x@ -t Task -s "To Do" --limit 10
+```
+
+**Follow-up**: "Would you like me to assign any of these to you?"
+
+### Example 3: Check Team Progress
+**User**: "What bugs are still open?"
+
+**Action**:
+```bash
+jira issue list -t Bug -s ~Done --order-by priority
+```
+
+**Presentation**: Group by priority, show counts
+
+### Example 4: Sprint Planning
+**User**: "Show high priority items not in a sprint"
+
+**Action**:
+```bash
+jira issue list -p High,Critical --jql "sprint is EMPTY"
+```
+
+## Advanced JQL Queries
+
+For complex queries, use `--jql`:
+
+### Issues I Reported
+```bash
+jira issue list --jql "reporter = currentUser()"
+```
+
+### Stale Issues
+```bash
+jira issue list --jql "status != Done AND updated <= -30d"
+```
+
+### Issues Needing Review
+```bash
+jira issue list --jql "status = 'Code Review' AND assignee = currentUser()"
+```
+
+### Blocked Issues
+```bash
+jira issue list --jql "status = Blocked ORDER BY priority DESC"
+```
+
+## Common Patterns
+
+### 1. Daily Standup
+```bash
+# What I did yesterday
+jira issue list -a $(jira me) --updated-after -1d --plain
+
+# What I'm doing today
+jira issue list -a $(jira me) -s "In Progress" --plain
+```
+
+### 2. Sprint Overview
+```bash
+# All sprint issues by status
+jira issue list --jql "sprint in openSprints() GROUP BY status"
+```
+
+### 3. Bug Triage
+```bash
+# Unassigned bugs by priority
+jira issue list -t Bug -a x@ --order-by priority --reverse
+```
+
+### 4. Release Planning
+```bash
+# Issues with release label
+jira issue list -l release-2.0 -s ~Done
+```
+
+## Follow-up Actions
+
+After listing issues, offer to:
+- **View specific issue**: Get details on interesting item
+- **Update filters**: Refine the search
+- **Assign issues**: Take ownership
+- **Create TODO**: Add to personal task list
+- **Export list**: Save to file or share
+
+## Tips
+
+- **Use --plain for scripting**: Easier to parse
+- **Combine filters**: Narrow down results effectively
+- **Save common queries**: Document frequent JQL patterns
+- **Use $(jira me)**: Always works regardless of username
+- **Check counts first**: Use `--limit` for large result sets
+- **Group by fields**: Use JQL GROUP BY for summaries
+- **Order by priority**: Show most important first
+
+## Integration
+
+- **TODOs Skill**: Convert list to org-mode TODOs
+- **Notes Skill**: Document planning in notes
+- **Email Skill**: Send list summaries to team