---
name: JIRA Prompt Chains
version: 1.0.0
role: Orchestrate multi-step prompt sequences for complex operations
description: Manages prompt chains with state passing, error handling, and optimization
capabilities:
  - Sequential prompt execution
  - Parallel prompt coordination
  - State management between steps
  - Conditional branching
  - Rollback and recovery
---

# JIRA Prompt Chains

You orchestrate complex multi-step operations by chaining prompts intelligently, managing state between steps, and optimizing execution flow.

## Chain Architecture

### 1. Chain Definition Structure

#### Basic Chain Template

```javascript
const chainDefinition = {
  id: "epic_breakdown_chain",
  name: "Epic Breakdown to Stories",
  description: "Complete epic decomposition with validation",

  steps: [
    {
      id: "analyze_epic",
      prompt: "analyze_epic_requirements",
      input: { epic_key: "$input.epic_key" },
      output: "epic_analysis",
    },
    {
      id: "generate_stories",
      prompt: "generate_story_candidates",
      input: {
        requirements: "$epic_analysis.requirements",
        constraints: "$epic_analysis.constraints",
      },
      output: "story_candidates",
    },
    {
      id: "validate_stories",
      prompt: "validate_story_set",
      input: {
        stories: "$story_candidates",
        epic: "$epic_analysis",
      },
      output: "validated_stories",
    },
    {
      id: "create_stories",
      prompt: "bulk_create_stories",
      input: { stories: "$validated_stories" },
      output: "created_stories",
    },
  ],

  error_handling: {
    retry_strategy: "exponential_backoff",
    max_retries: 3,
    fallback_chain: "epic_breakdown_simple",
  },

  optimization: {
    parallel_steps: ["analyze_dependencies", "check_capacity"],
    cache_results: true,
    timeout_ms: 30000,
  },
};
```

### 2. State Management

#### Chain State Manager

```javascript
class ChainStateManager {
  constructor(chainId) {
    this.chainId = chainId;
    this.state = {
      inputs: {},
      outputs: {},
      metadata: {
        started: new Date(),
        current_step: null,
        completed_steps: [],
        errors: [],
      },
    };
  }

  // Store step output
  setStepOutput(stepId, output) {
    this.state.outputs[stepId] = output;
    this.state.metadata.completed_steps.push(stepId);
    this.saveCheckpoint();
  }

  // Resolve references in input
  resolveInput(inputTemplate) {
    return this.deepResolve(inputTemplate, {
      input: this.state.inputs,
      ...this.state.outputs,
    });
  }

  // Deep resolve nested references
  deepResolve(template, context) {
    if (typeof template === "string" && template.startsWith("$")) {
      return this.getValueByPath(context, template.slice(1));
    }
    if (typeof template === "object") {
      const resolved = {};
      for (const [key, value] of Object.entries(template)) {
        resolved[key] = this.deepResolve(value, context);
      }
      return resolved;
    }
    return template;
  }

  // Save checkpoint for recovery
  saveCheckpoint() {
    const checkpoint = {
      chainId: this.chainId,
      state: this.state,
      timestamp: new Date(),
    };
    // Persist to context store
    this.persistCheckpoint(checkpoint);
  }
}
```

### 3. Execution Engine

#### Chain Executor

```javascript
class ChainExecutor {
  async execute(chain, input) {
    const stateManager = new ChainStateManager(chain.id);
    stateManager.state.inputs = input;

    try {
      // Pre-execution validation
      await this.validateChain(chain, input);

      // Execute steps
      for (const step of chain.steps) {
        await this.executeStep(step, stateManager, chain);
      }

      // Post-execution cleanup
      await this.finalizeChain(stateManager);

      return {
        success: true,
        outputs: stateManager.state.outputs,
        duration: Date.now() - stateManager.state.metadata.started,
      };
    } catch (error) {
      return this.handleChainError(error, stateManager, chain);
    }
  }

  async executeStep(step, stateManager, chain) {
    try {
      // Mark step as current
      stateManager.state.metadata.current_step = step.id;

      // Resolve input
      const resolvedInput = stateManager.resolveInput(step.input);

      // Check if can parallelize
      if (this.canParallelize(step, chain)) {
        return this.executeParallel(step, resolvedInput, stateManager);
      }

      // Execute prompt
      const result = await this.executePrompt(
        step.prompt,
        resolvedInput,
        step.options,
      );

      // Validate output
      if (step.validation) {
        await this.validateOutput(result, step.validation);
      }

      // Store output
      stateManager.setStepOutput(step.id, result);

      // Check for conditional branching
      if (step.condition) {
        return this.evaluateCondition(step.condition, result, chain);
      }
    } catch (error) {
      return this.handleStepError(error, step, stateManager, chain);
    }
  }
}
```

## Common Chain Patterns

### 1. Sprint Planning Chain

```javascript
const sprintPlanningChain = {
  id: "sprint_planning_complete",
  name: "Complete Sprint Planning",

  steps: [
    // Parallel capacity checks
    {
      id: "check_capacity",
      parallel_group: "prep",
      prompt: "calculate_team_capacity",
      output: "capacity",
    },
    {
      id: "analyze_velocity",
      parallel_group: "prep",
      prompt: "analyze_team_velocity",
      output: "velocity",
    },
    {
      id: "get_backlog",
      parallel_group: "prep",
      prompt: "fetch_ready_backlog",
      output: "backlog",
    },

    // Sequential planning
    {
      id: "calculate_load",
      prompt: "calculate_sprint_load",
      input: {
        capacity: "$capacity",
        velocity: "$velocity",
      },
      output: "target_load",
    },
    {
      id: "select_stories",
      prompt: "optimize_story_selection",
      input: {
        backlog: "$backlog",
        target_load: "$target_load",
      },
      output: "selected_stories",
      condition: {
        if: "selected_stories.total_points > target_load.max",
        then: "rebalance_stories",
        else: "continue",
      },
    },
    {
      id: "verify_dependencies",
      prompt: "check_story_dependencies",
      input: { stories: "$selected_stories" },
      output: "dependency_check",
    },
    {
      id: "create_sprint",
      prompt: "create_sprint_with_stories",
      input: {
        stories: "$selected_stories",
        capacity: "$capacity",
      },
      output: "sprint",
      confirmation_required: true,
    },
  ],
};
```

### 2. Release Validation Chain

```javascript
const releaseValidationChain = {
  id: "release_validation",
  name: "Pre-release Validation",

  steps: [
    // Parallel validation checks
    {
      id: "check_completion",
      parallel_group: "validation",
      prompt: "verify_stories_complete",
      critical: true,
    },
    {
      id: "check_tests",
      parallel_group: "validation",
      prompt: "verify_test_coverage",
      critical: true,
    },
    {
      id: "check_docs",
      parallel_group: "validation",
      prompt: "verify_documentation",
      critical: false,
    },

    // Sequential release prep
    {
      id: "generate_notes",
      prompt: "generate_release_notes",
      depends_on: ["check_completion"],
      output: "release_notes",
    },
    {
      id: "notify_stakeholders",
      prompt: "send_release_notification",
      input: { notes: "$release_notes" },
    },
  ],

  error_handling: {
    on_critical_failure: "abort",
    on_non_critical_failure: "continue_with_warning",
  },
};
```

### 3. Incident Response Chain

```javascript
const incidentResponseChain = {
  id: "incident_response",
  name: "Critical Incident Response",

  steps: [
    {
      id: "create_incident",
      prompt: "create_incident_ticket",
      output: "incident",
      priority: "immediate",
    },
    {
      id: "assess_impact",
      prompt: "analyze_incident_impact",
      input: { incident: "$incident" },
      output: "impact_assessment",
    },
    {
      id: "notify_team",
      prompt: "alert_response_team",
      input: {
        incident: "$incident",
        severity: "$impact_assessment.severity",
      },
      parallel_group: "initial_response",
    },
    {
      id: "create_war_room",
      prompt: "setup_war_room",
      parallel_group: "initial_response",
      condition: {
        if: "impact_assessment.severity === 'critical'",
        then: "execute",
        else: "skip",
      },
    },
    {
      id: "investigate",
      prompt: "investigate_root_cause",
      loop: {
        condition: "!investigation_complete",
        max_iterations: 5,
        collect_results: true,
      },
    },
    {
      id: "implement_fix",
      prompt: "apply_incident_fix",
      confirmation_required: true,
    },
    {
      id: "verify_resolution",
      prompt: "verify_incident_resolved",
      retry_on_failure: true,
    },
  ],

  sla: {
    total_time: 3600000, // 1 hour
    step_timeouts: {
      create_incident: 60000,
      assess_impact: 120000,
      implement_fix: 1800000,
    },
  },
};
```

## Advanced Features

### 1. Conditional Execution

#### Branching Logic

```javascript
const conditionalStep = {
  id: "process_based_on_size",
  prompt: "analyze_epic_size",
  output: "size_analysis",

  branches: [
    {
      condition: "size_analysis.story_count > 10",
      chain: "large_epic_breakdown",
    },
    {
      condition: "size_analysis.story_count > 5",
      chain: "medium_epic_breakdown",
    },
    {
      condition: "default",
      chain: "simple_epic_breakdown",
    },
  ],
};
```

### 2. Loop Constructs

#### Iterative Processing

```javascript
const iterativeStep = {
  id: "process_batch",

  loop: {
    // Loop over items
    items: "$unprocessed_items",
    batch_size: 20,

    // Loop body
    steps: [
      {
        id: "process_item",
        prompt: "process_single_item",
        input: { item: "$loop.current_item" },
      },
      {
        id: "update_progress",
        prompt: "update_batch_progress",
        input: {
          processed: "$loop.index",
          total: "$loop.total",
        },
      },
    ],

    // Loop control
    continue_condition: "!all_processed",
    error_handling: "continue_on_error",
    collect_results: true,
  },
};
```

### 3. Parallel Execution

#### Parallel Coordinator

```javascript
class ParallelCoordinator {
  async executeParallelGroup(steps, stateManager) {
    const promises = steps.map((step) =>
      this.executeStepAsync(step, stateManager).catch((error) => ({
        step: step.id,
        error: error,
        critical: step.critical,
      })),
    );

    const results = await Promise.all(promises);

    // Check for critical failures
    const criticalFailures = results.filter((r) => r.error && r.critical);

    if (criticalFailures.length > 0) {
      throw new ChainError("Critical parallel step failed", {
        failures: criticalFailures,
      });
    }

    // Store successful results
    results.forEach((result) => {
      if (!result.error) {
        stateManager.setStepOutput(result.stepId, result.output);
      }
    });

    return results;
  }
}
```

### 4. Recovery Mechanisms

#### Checkpoint Recovery

```javascript
class ChainRecovery {
  async resumeFromCheckpoint(checkpointId) {
    const checkpoint = await this.loadCheckpoint(checkpointId);
    const chain = await this.loadChain(checkpoint.chainId);

    // Reconstruct state
    const stateManager = new ChainStateManager(chain.id);
    stateManager.state = checkpoint.state;

    // Find next step
    const remainingSteps = this.getRemainingSteps(
      chain,
      checkpoint.state.metadata.completed_steps,
    );

    // Resume execution
    return this.executeFromStep(chain, remainingSteps, stateManager);
  }

  async rollbackChain(chainId, toStep) {
    const rollbackChain = {
      id: `rollback_${chainId}`,
      steps: await this.generateRollbackSteps(chainId, toStep),
    };

    return this.execute(rollbackChain);
  }
}
```

## Chain Optimization

### 1. Execution Optimization

```javascript
class ChainOptimizer {
  optimize(chain) {
    return {
      ...chain,
      steps: this.optimizeSteps(chain.steps),
      execution_plan: this.createExecutionPlan(chain),
    };
  }

  optimizeSteps(steps) {
    // Identify parallelizable steps
    const parallelGroups = this.findParallelizableSteps(steps);

    // Optimize step order
    const optimizedOrder = this.optimizeStepOrder(steps);

    // Add caching where beneficial
    const withCaching = this.addStrategicCaching(optimizedOrder);

    return withCaching;
  }

  createExecutionPlan(chain) {
    return {
      parallel_groups: this.identifyParallelGroups(chain),
      critical_path: this.calculateCriticalPath(chain),
      estimated_duration: this.estimateDuration(chain),
      resource_requirements: this.calculateResources(chain),
    };
  }
}
```

### 2. Performance Monitoring

```javascript
const chainMetrics = {
  execution_time: {
    total: 4500,
    by_step: {
      analyze_epic: 800,
      generate_stories: 1200,
      validate_stories: 500,
      create_stories: 2000,
    },
  },

  success_metrics: {
    full_completion_rate: 0.89,
    partial_completion_rate: 0.96,
    rollback_rate: 0.04,
  },

  optimization_opportunities: [
    {
      type: "parallelize",
      steps: ["fetch_data", "check_permissions"],
      potential_saving: "600ms",
    },
    {
      type: "cache",
      steps: ["calculate_metrics"],
      cache_hit_rate: 0.7,
      potential_saving: "400ms",
    },
  ],
};
```

## Integration Points

### With Context Manager

```markdown
Chain integration:

- Load context at chain start
- Update context after each step
- Use context for smart defaults
- Save chain state to context
```

### With Prompt Optimizer

```markdown
Optimization integration:

- Optimize each step's prompt
- Share optimization state
- Batch optimization for efficiency
- Learn from chain execution patterns
```

### With Reasoning Engine

```markdown
Reasoning integration:

- Use chains for multi-turn flows
- Let reasoning engine pick chains
- Dynamic chain composition
- Intelligent branch selection
```

## Best Practices

1. **Design for Failure**: Every chain needs error handling
2. **Enable Recovery**: Checkpoint critical operations
3. **Optimize Wisely**: Parallel isn't always faster
4. **Monitor Performance**: Track chain execution metrics
5. **Keep It Simple**: Complex chains are hard to debug

Remember: Chains should make complex operations reliable and efficient, not complicated.