Generics question

A few days ago I posted a question about implementing
an immutable object in my design (the final answer
being to do it just like Bloch says to do it in
Effective Java).

I'm stuck again with an aspect of this design, this
time involving generics.

To summarize (sorry, this is going to be long winded):
For an application involving university curriculum data,
I have a base class History:

public class History {
  . . .
}

which is a base class for course properties:

public class NameHistory extends History {
  . . .
}

public class UnitsHistory extends History {
  . . .
}

etc. To enforce business rules relating to history
(history must cover the entire timespan in which the
course is active, with no gaps or overlaps, etc.), I
have a "manager" class:

public class ContinuousHistory<T extends History> {
  . . .
}

The Course class uses ContinuousHistory as its api to
the history data:

public class Course {
  private ContinuousHistory<NameHistory> nameHistory;
  private ContinuousHistory<UnitsHistory> unitsHistory;
  . . .
}

All well and good so far. This implementation works
great, and there's no way to mess with the History data
without going through the ContinuousHistory manager,
just as I intended.

The user will edit this history data using a JTable,
and I'm writing a JPanel to hold the JTable, which I
can drop into a window to provide editing functionality.

The only difference between the JTable editor for units
vs. the one for course names, vs. the one for titles,
etc., is in the TableModel. I'm trying to define an
abstract HistoryTableModel (which extends
AbstractTableModel). I then extend HistoryTableModel
to define NameTableModel, UnitsTableModel,
TitleTableModel, etc.

Okay that's the background (thanks for reading this far).
Now for the problem.

My HistoryTableModel starts off like this:

public abstract class HistoryTableModel
   extends AbstractTableModel {

  // I've tried various things here, this is just
  // the latest.
  protected ContinuousHistory<? extends History> history;

  public abstract Object getValueAt(int row, int col);

  // This is just an example method.
  public final int getRowCount() {
    return history.getHistoryData().size();
  }

  . . .
}

Now here's one of the concrete subclasses:

public class TitleTableModel extends HistoryTableModel {
  public TitleTableModel(
    ContinuousHistory<? extends History> history)
  {
    this.history = (ContinuousHistory<TermTypeHistory>)
                    history;
  }

  public Object getValueAt(int row, int col) {
    TitleHistory th = history.get(row); // COMPILE ERROR

    // etc.
  }

  . . .
}

This implementation won't compile, saying:
  Type mismatch: cannot convert from capture-of ? extends
  History to TitleHistory
at the spot I indicated above.

What's the right way to declare "history" in class
HistoryTableModel so that it will be a
ContinuousHistory<some class which extends History>,
and the right way to declare the subclass to use it as
a ContinuousHistory<TermTypeHistory> (or whatever other
concrete class)? I've tried a dozen or so different ways,
and I can't find one that works.

Thanks.