diff --git a/CHANGELOG.md b/CHANGELOG.md
index e9c51031..c7eb2d0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -310,6 +310,13 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Under the hood (tidying)
 
+- **Lists inside lists, the server's half (7a5a1).** A list can now say how it is picked: on its own
+  (as every list was), only through the features that open it (a SOLDIER's SPECIALTY at level 3), or
+  both (FEATS: one at creation, more from features). A feature opening a list says how many picks it
+  gives. A pick made under a feature counts while that feature is unlocked; lower the level or take
+  the class away and it is kept, waiting, its bonuses and levels gone until the feature unlocks
+  again. Lists can nest as deep as they go, and the builder names any that open each other in a loop.
+  The settings on the CHOICES page and the picks under features on the sheet come next.
 - **Every health model, proven in a browser.** The second gap in e2e/COVERAGE.md is closed: a new
   browser test plays each of the seven health models a system can choose, one at a time. A player
   with a token hurts and heals it from HIT_POINTS (a pool under its own name, two tracks where
diff --git a/README.md b/README.md
index 61529d03..916b13c5 100644
--- a/README.md
+++ b/README.md
@@ -611,6 +611,7 @@ CITY_NET/
 │       ├── system_builder_choices.test.js # A system's choices: a class list with levels and multiclassing, a nested list and an any-number list check clean; every part of a list, an option and a feature refused where it is wrong (picks, levels only in a levelled list, modifier targets and amounts, uses and their rest, rolls and a roll's changes, another list and never itself), ids shared across options and features, an option's @<option>_level free, the limits; carried beside the system in a .citysys and checked when installed; a change said in PUBLISH's preview
 │       ├── system_builder_choices_import.test.js # The choices import's reader: adding and updating by name, ids from names, a new class's level readable in the same file, empty cells and `-`, uses and refills, same-named features by level, every skipped line and why, the list's limits, quotes, semicolons and tabs, nothing changed in what it was given; the PREVIEW route, main admin only
 │       ├── system_builder_choices_numbers.test.js # What picks do to a character's numbers: picks read from the sheet keeping only what holds (a known option, once, within what the list allows, MORE THAN ONCE for multiclassing, levels from 1 to the highest); each option's level, a list's sum and @level, a system's own level left alone; features unlocked by level; on a save, a stat's modifier reaching the formulas reading it while the stat stays as typed, a formula's added before what reads it, amounts from levels, a pick taken away taking its effects; an amount reading a formula refused, a list's sum name kept free; rolls reading the same numbers; PUBLISH's preview showing a feature changed; the picks never a player's to write
+│       ├── system_builder_nested_choices.test.js # Lists inside lists (7a5a1): PICKED and HOW MANY checked, loops through other lists named; a pick under a feature counting while it is unlocked and has room, kept waiting when it locks, deeper lists in any order, a list picked both ways counting its own apart, picks a list's way no longer counts kept; only what counts reaching the numbers; what the sheet is told; picking under a feature and every refusal
 │       ├── system_builder_picking.test.js # Picking: a player's pick (room, not twice, a requirement in words), never a drop, their own levels and spent uses within bounds; the GM past a requirement but not past room, and taking a pick away; every save writing the picks, levels, where each change comes from, uses and what isn't met (none for a system without choices); the lists as the sheet draws them, never a formula; a rest refilling the uses it or what it counts as refills; no _ name a player's to write; through the socket as a player (their own only, told why not, nothing written) and as the GM (on the player named)
 │       ├── system_builder_citysys_zip.test.js # Sharing with pictures: the uploads a system names and where a symbol shows, left out cleanly (a mark for a bare symbol), a zip made and read back, a picture missing from disk left out, one shared picture; a zip someone sent refused when broken, empty, too large or holding two systems, nothing unpacked outside its places, past an upload's size or past the count (a broken entry proves it), and only named pictures stored; through the routes: the count listed, ?images=1 a zip, otherwise the .citysys without, a zip installed on a server without its pictures, nothing stored when refused, GM only
 │       ├── system_builder_words.test.js # Every term in every form resolved for the builder; only the terms a system renamed sent with its sheet; the server's own text, the starter sheet and a one-pool HEALTH folder using a system's word only where it chose one
diff --git a/backend/__tests__/system_builder_nested_choices.test.js b/backend/__tests__/system_builder_nested_choices.test.js
new file mode 100644
index 00000000..239658cd
--- /dev/null
+++ b/backend/__tests__/system_builder_nested_choices.test.js
@@ -0,0 +1,191 @@
+/**
+ * Lists inside lists (7a5a1). Approved mockup nested-choices (2026-10-28): a list picked THROUGH
+ * FEATURES gets a pick under each unlocked feature that opens it (as many as the feature says, stored
+ * with `from`), BOTH adds its own picks too; a pick whose feature locks again is kept, not counted, and
+ * counts again once it unlocks; nesting goes as deep as the lists do, never round in a loop.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createRequire } from 'module';
+
+const require_ = createRequire(import.meta.url);
+const { PICKS_KEY, heldOf, picksOf, workedOf, overlayOf, choicesShown, loopsOf } = require_('../systemBuilder/choices');
+const { pickAction } = require_('../systemBuilder/picking');
+const { checkDefinition } = require_('../systemBuilder/definition');
+
+const HEARTH = {
+  format: 1, name: 'Hearth',
+  stats: [{ id: 'abilities', label: 'ABILITIES', stats: [{ id: 'int', label: 'Intellect' }] }],
+  derived: [{ id: 'defense', label: 'Defense', formula: '10' }],
+  choices: [
+    { id: 'classes', one: 'Class', many: 'Classes', levelled: true, again: true, options: [
+      { id: 'soldier', label: 'Soldier', features: [
+        { id: 'specialty', label: 'Specialty', at: 3, choice: 'specialties' },
+        { id: 'feat_6', label: 'Feat', at: 6, choice: 'feats', choice_count: 2 },
+      ] },
+      { id: 'mage', label: 'Mage', features: [{ id: 'cantrip', label: 'Cantrip', choice: 'feats' }] },
+    ] },
+    { id: 'specialties', one: 'Specialty', many: 'Specialties', picked: 'features', options: [
+      { id: 'duelist', label: 'Duelist', features: [
+        { id: 'riposte', label: 'Riposte', modifiers: [{ target: 'defense', amount: '1' }] },
+        { id: 'school', label: 'School', choice: 'schools' },
+      ] },
+      { id: 'vanguard', label: 'Vanguard', requires: '@int >= 13' },
+    ] },
+    { id: 'schools', one: 'School', many: 'Schools', picked: 'features', levelled: true, options: [{ id: 'iron', label: 'Iron' }] },
+    { id: 'feats', one: 'Feat', many: 'Feats', picked: 'both', options: [
+      { id: 'tough', label: 'Tough' }, { id: 'quick', label: 'Quick' }, { id: 'keen', label: 'Keen' }, { id: 'lucky', label: 'Lucky' },
+    ] },
+    { id: 'origins', one: 'Origin', many: 'Origins', options: [{ id: 'port', label: 'Port' }] },
+  ],
+};
+const sheet = (stored, extra = {}) => ({ int: 10, ...extra, [PICKS_KEY]: stored });
+const soldierAt = (level) => ({ classes: [{ option: 'soldier', level }] });
+const ids = (picks) => picks.map((p) => `${p.list.id}:${p.option.id}${p.from ? `<${p.from}` : ''}${p.active === false ? ' (waiting)' : ''}`);
+const problems = (def) => checkDefinition(def).problems.map((p) => `${p.where}: ${p.message}`);
+const withList = (id, patch) => ({ ...HEARTH, choices: HEARTH.choices.map((c) => (c.id === id ? { ...c, ...patch } : c)) });
+
+describe('the checks', () => {
+  it('takes the system as it is', () => {
+    expect(problems(HEARTH)).toEqual([]);
+  });
+
+  it('a list is picked on its own, through features or both; a feature opening a list says how many, 1 to 10', () => {
+    expect(problems(withList('origins', { picked: 'sometimes' }))).toEqual(['list origins, picked: own (on its own), features (through the features that open it) or both']);
+    const count = (f) => ({ ...HEARTH, choices: HEARTH.choices.map((c) => (c.id === 'origins' ? { ...c, options: [{ id: 'port', label: 'Port', features: [f] }] } : c)) });
+    expect(problems(count({ id: 'dock', label: 'Dock', choice_count: 2 }))).toEqual(['list origins, option port, feature dock, choice_count: Only a feature that opens a list says how many']);
+    expect(problems(count({ id: 'dock', label: 'Dock', choice: 'feats', choice_count: 11 }))).toEqual(['list origins, option port, feature dock, choice_count: A number from 1 to 10']);
+    expect(problems(count({ id: 'dock', label: 'Dock', choice: 'feats', choice_count: 1.5 }))).toEqual(['list origins, option port, feature dock, choice_count: A number from 1 to 10']);
+  });
+
+  it('lists never open each other in a loop, the way round named for each list on it', () => {
+    const loop = withList('schools', { options: [{ id: 'iron', label: 'Iron', features: [{ id: 'back', label: 'Back', choice: 'classes' }] }] });
+    expect(problems(loop)).toEqual([
+      'list classes: Its features open lists that lead back to it: CLASSES → SPECIALTIES → SCHOOLS → CLASSES',
+      'list specialties: Its features open lists that lead back to it: SPECIALTIES → SCHOOLS → CLASSES → SPECIALTIES',
+      'list schools: Its features open lists that lead back to it: SCHOOLS → CLASSES → SPECIALTIES → SCHOOLS',
+    ]);
+    expect(loopsOf(HEARTH)).toEqual([]);
+  });
+});
+
+describe('reading the picks', () => {
+  it('counts a pick under a feature while that feature is unlocked, and keeps it waiting when it locks', () => {
+    const stored = { ...soldierAt(3), specialties: [{ option: 'duelist', from: 'specialty' }] };
+    expect(ids(heldOf(HEARTH, sheet(stored)))).toEqual(['classes:soldier', 'specialties:duelist<specialty']);
+    const lowered = { ...stored, ...soldierAt(2) };
+    expect(ids(heldOf(HEARTH, sheet(lowered)))).toEqual(['classes:soldier', 'specialties:duelist<specialty (waiting)']);
+    expect(ids(picksOf(HEARTH, sheet(lowered)))).toEqual(['classes:soldier']);
+    // The class taken away: kept the same way, in case it comes back.
+    expect(ids(heldOf(HEARTH, sheet({ specialties: stored.specialties })))).toEqual(['specialties:duelist<specialty (waiting)']);
+  });
+
+  it('gives as many picks under a feature as it says, the rest waiting', () => {
+    const stored = { ...soldierAt(6), feats: [{ option: 'tough', from: 'feat_6' }, { option: 'quick', from: 'feat_6' }, { option: 'keen', from: 'feat_6' }] };
+    expect(ids(heldOf(HEARTH, sheet(stored)))).toEqual(['classes:soldier', 'feats:tough<feat_6', 'feats:quick<feat_6', 'feats:keen<feat_6 (waiting)']);
+  });
+
+  it('counts a pick only under a feature opening its own list, whatever a sheet says', () => {
+    const stored = { ...soldierAt(3), feats: [{ option: 'tough', from: 'specialty' }] };
+    expect(ids(heldOf(HEARTH, sheet(stored)))).toEqual(['classes:soldier', 'feats:tough<specialty (waiting)']);
+  });
+
+  it('a list picked both ways counts its own picks and those under features apart', () => {
+    const stored = { ...soldierAt(6), feats: [{ option: 'lucky' }, { option: 'keen' }, { option: 'tough', from: 'feat_6' }] };
+    // Its own: one (A CHARACTER PICKS); the second own pick past that was never kept.
+    expect(ids(heldOf(HEARTH, sheet(stored)))).toEqual(['classes:soldier', 'feats:lucky', 'feats:tough<feat_6']);
+  });
+
+  it('keeps picks a list\'s way of picking no longer counts, for if it changes back', () => {
+    const own = withList('specialties', { picked: 'own' });
+    expect(ids(heldOf(own, sheet({ ...soldierAt(3), specialties: [{ option: 'duelist', from: 'specialty' }] })))).toEqual(['classes:soldier', 'specialties:duelist<specialty (waiting)']);
+    expect(ids(heldOf(HEARTH, sheet({ specialties: [{ option: 'duelist' }] })))).toEqual(['specialties:duelist (waiting)']);
+    // A feature opening a list picked on its own gives nothing to pick under it.
+    expect(workedOf(own, sheet(soldierAt(3))).opens).toEqual([]);
+  });
+
+  it('goes as deep as the lists go, each level waiting on the one above', () => {
+    const stored = { ...soldierAt(3), specialties: [{ option: 'duelist', from: 'specialty' }], schools: [{ option: 'iron', level: 2, from: 'school' }] };
+    expect(ids(heldOf(HEARTH, sheet(stored)))).toEqual(['classes:soldier', 'specialties:duelist<specialty', 'schools:iron<school']);
+    expect(ids(heldOf(HEARTH, sheet({ ...stored, ...soldierAt(1) })))).toEqual(['classes:soldier', 'specialties:duelist<specialty (waiting)', 'schools:iron<school (waiting)']);
+    // Order on the sheet doesn't matter: a deeper pick stored first still counts.
+    const reversed = { schools: stored.schools, specialties: stored.specialties, ...soldierAt(3) };
+    expect(ids(picksOf(HEARTH, sheet(reversed)))).toEqual(['classes:soldier', 'specialties:duelist<specialty', 'schools:iron<school']);
+  });
+
+  it('only what counts reaches the numbers: a waiting pick\'s bonus and level are gone', () => {
+    const stored = { ...soldierAt(3), specialties: [{ option: 'duelist', from: 'specialty' }], schools: [{ option: 'iron', level: 2, from: 'school' }] };
+    expect(overlayOf(HEARTH, sheet(stored))).toMatchObject({ add: { defense: 1 }, levels: { iron_level: 2, schools_level: 2 } });
+    expect(overlayOf(HEARTH, sheet({ ...stored, ...soldierAt(2) }))).toMatchObject({ add: {}, levels: { iron_level: 0, schools_level: 0 } });
+  });
+});
+
+describe('what the sheet is told', () => {
+  it('every pick kept, those waiting marked, and each feature\'s picks open', () => {
+    const stored = { ...soldierAt(6), specialties: [{ option: 'duelist', from: 'specialty' }], feats: [{ option: 'tough', from: 'feat_6' }], schools: [{ option: 'iron', from: 'school', level: 1 }] };
+    const worked = workedOf(HEARTH, sheet({ ...stored, ...soldierAt(6) }));
+    expect(worked.picks).toEqual([
+      { list: 'classes', option: 'soldier', level: 6 },
+      { list: 'specialties', option: 'duelist', from: 'specialty' },
+      { list: 'schools', option: 'iron', level: 1, from: 'school' },
+      { list: 'feats', option: 'tough', from: 'feat_6' },
+    ]);
+    expect(worked.opens).toEqual([
+      { feature: 'specialty', list: 'specialties', count: 1, used: 1 },
+      { feature: 'feat_6', list: 'feats', count: 2, used: 1 },
+      { feature: 'school', list: 'schools', count: 1, used: 1 },
+    ]);
+    const lowered = workedOf(HEARTH, sheet({ ...stored, ...soldierAt(2) }));
+    expect(lowered.picks.filter((p) => p.waiting).map((p) => p.option)).toEqual(['duelist', 'iron', 'tough']);
+    expect(lowered.opens).toEqual([]);
+  });
+
+  it('each list\'s way of picking, and how many a feature opens', () => {
+    const shown = choicesShown(HEARTH);
+    expect(shown.map((c) => c.picked)).toEqual(['own', 'features', 'features', 'both', 'own']);
+    expect(shown[0].options[0].features.map((f) => [f.opens, f.opensCount])).toEqual([['specialties', 1], ['feats', 2]]);
+  });
+});
+
+describe('picking under a feature', () => {
+  const at = (level, more = {}) => sheet({ ...soldierAt(level), ...more });
+
+  it('picks under a feature that is unlocked and has room, storing which', () => {
+    const r = pickAction(HEARTH, at(3), { kind: 'pick', list: 'specialties', option: 'duelist', from: 'specialty' });
+    expect(r.ok).toBe(true);
+    expect(r.data[PICKS_KEY].specialties).toEqual([{ option: 'duelist', from: 'specialty' }]);
+    expect(pickAction(HEARTH, r.data, { kind: 'pick', list: 'specialties', option: 'vanguard', from: 'specialty', gm: true }, { gm: true }))
+      .toEqual({ ok: false, error: 'No more Specialties can be picked there' });
+  });
+
+  it('refuses a feature not yet unlocked, one opening another list, and a list picked through features without one', () => {
+    expect(pickAction(HEARTH, at(2), { kind: 'pick', list: 'specialties', option: 'duelist', from: 'specialty' })).toEqual({ ok: false, error: 'Nothing unlocked there opens the Specialties' });
+    expect(pickAction(HEARTH, at(6), { kind: 'pick', list: 'specialties', option: 'duelist', from: 'feat_6' })).toEqual({ ok: false, error: 'Nothing unlocked there opens the Specialties' });
+    expect(pickAction(HEARTH, at(3), { kind: 'pick', list: 'specialties', option: 'duelist' })).toEqual({ ok: false, error: 'The Specialties are picked under the features that open them' });
+    expect(pickAction(HEARTH, at(3), { kind: 'pick', list: 'origins', option: 'port', from: 'specialty' })).toEqual({ ok: false, error: 'The Origins aren\'t picked under features' });
+  });
+
+  it('a list picked both ways: its own picks up to what it allows, and under features apart', () => {
+    const own = pickAction(HEARTH, at(6), { kind: 'pick', list: 'feats', option: 'lucky' });
+    expect(own.ok).toBe(true);
+    expect(pickAction(HEARTH, own.data, { kind: 'pick', list: 'feats', option: 'keen' })).toEqual({ ok: false, error: 'No more Feats can be picked' });
+    const under = pickAction(HEARTH, own.data, { kind: 'pick', list: 'feats', option: 'keen', from: 'feat_6' });
+    expect(under.data[PICKS_KEY].feats).toEqual([{ option: 'lucky' }, { option: 'keen', from: 'feat_6' }]);
+  });
+
+  it('keeps a waiting pick when another is stored, and won\'t pick it twice', () => {
+    const waiting = at(2, { specialties: [{ option: 'duelist', from: 'specialty' }], feats: [{ option: 'tough', from: 'cantrip' }] });
+    expect(pickAction(HEARTH, waiting, { kind: 'pick', list: 'specialties', option: 'duelist', from: 'specialty' })).toEqual({ ok: false, error: 'Duelist is already picked' });
+    const levelled = pickAction(HEARTH, waiting, { kind: 'level', list: 'classes', option: 'soldier', level: 1 });
+    expect(levelled.data[PICKS_KEY].specialties).toEqual([{ option: 'duelist', from: 'specialty' }]);
+    const mage = pickAction(HEARTH, waiting, { kind: 'pick', list: 'feats', option: 'quick' });
+    expect(mage.data[PICKS_KEY].feats).toEqual([{ option: 'tough', from: 'cantrip' }, { option: 'quick' }]);
+  });
+
+  it('the GM takes a waiting pick away; a requirement still holds under a feature', () => {
+    const waiting = at(2, { specialties: [{ option: 'duelist', from: 'specialty' }] });
+    expect(pickAction(HEARTH, waiting, { kind: 'drop', list: 'specialties', option: 'duelist' }, { gm: true }).data[PICKS_KEY].specialties).toEqual([]);
+    expect(pickAction(HEARTH, at(3), { kind: 'pick', list: 'specialties', option: 'vanguard', from: 'specialty' })).toEqual({ ok: false, error: 'Vanguard needs INTELLECT >= 13' });
+    expect(pickAction(HEARTH, at(3), { kind: 'pick', list: 'specialties', option: 'vanguard', from: 'specialty' }, { gm: true }).ok).toBe(true);
+  });
+});
diff --git a/backend/__tests__/system_builder_picking.test.js b/backend/__tests__/system_builder_picking.test.js
index eee5fc89..753d811a 100644
--- a/backend/__tests__/system_builder_picking.test.js
+++ b/backend/__tests__/system_builder_picking.test.js
@@ -118,6 +118,7 @@ describe('what the sheet shows', () => {
     runtime.metaOf(HEARTH).recompute(data);
     expect(data[WORKED_KEY]).toEqual({
       picks: [{ list: 'classes', option: 'soldier', level: 3 }],
+      opens: [],
       levels: { soldier_level: 3, mage_level: 0, classes_level: 3, level: 3 },
       from: { defense: [{ feature: 'Guard Stance', amount: 1 }] },
       uses: { rally: { max: 4, spent: 1 } },
@@ -150,7 +151,7 @@ describe('what the sheet shows', () => {
   it('the lists as the sheet draws them: words, never a formula', () => {
     const shown = choicesShown(HEARTH);
     expect(shown[0]).toEqual({
-      id: 'classes', one: 'Class', many: 'Classes', picks: 1, again: true, levelled: true,
+      id: 'classes', one: 'Class', many: 'Classes', picks: 1, again: true, levelled: true, picked: 'own',
       options: [
         { id: 'soldier', label: 'Soldier', features: [
           { id: 'guard', label: 'Guard Stance', at: 1, modifies: ['Defense'] },
diff --git a/backend/systemBuilder/choices.js b/backend/systemBuilder/choices.js
index c090158e..f52ac43b 100644
--- a/backend/systemBuilder/choices.js
+++ b/backend/systemBuilder/choices.js
@@ -7,6 +7,8 @@
 //       picks: 1,            // how many a character picks: a whole number, or 'any'; 1 when absent
 //       levelled: true,      // each pick has a level, and its features unlock by it
 //       again: true,         // MORE THAN ONCE: more can be added after those (multiclassing)
+//       picked: 'features',  // 7a5a: own (on its own, as when absent), features (only under the
+//                            // features that open it) or both (its own picks, and those)
 //       options: [
 //         { id: 'soldier', label: 'Soldier', description: '...',
 //           requires: '@str >= 13',          // optional: a formula, met when it isn't 0
@@ -17,7 +19,7 @@
 //               uses: { count: '1', refill: 'short_rest' },     // ticked off on the sheet, refilled by a rest
 //               rolls: ['rally'],                               // rolls of the system it gives
 //               changes: [{ roll: 'mind_save', change: 'advantage' }], // a change it lets one roll take
-//               choice: 'specialties' },                        // a list picked from when it unlocks
+//               choice: 'specialties', choice_count: 2 },       // a list picked from when it unlocks, and how many (1)
 //           ] },
 //       ] },
 //   ]
@@ -33,6 +35,12 @@
 // comes with the sheet (7a3). Read here, only what holds is kept: an option of that list, once, no
 // more than the list allows, a level from 1 up in a levelled list (1 when it has none).
 //
+// Lists inside lists (7a5a; approved mockup docs/mockups/nested-choices.html, 2026-10-28): a list
+// picked THROUGH FEATURES (or BOTH) gets a pick under each unlocked feature that opens it, as many as
+// the feature says, stored with `from` naming that feature. A pick whose feature locks again (a level
+// lowered, the pick above it dropped) is kept but not counted, and counts again once it unlocks:
+// heldOf reads every pick kept, picksOf only those that count. Lists never open each other in a loop.
+//
 // Levels are read in formulas, rolls and modifier amounts: @<option>_level (0 when not taken),
 // @<list>_level, a levelled list's sum, and @level, every levelled list's sum, unless the system
 // has a stat or formula called level of its own, which keeps meaning what it always did (the user,
@@ -76,10 +84,14 @@ const LIMITS = {
   picks: 100,
   label: 40,
   description: 1000,
+  /** How many picks one feature opening a list gives (7a5a). */
+  opens: 10,
 };
-const LIST_KEYS = new Set(['id', 'one', 'many', 'picks', 'levelled', 'again', 'options']);
+/** How a list is picked (7a5a): on its own, only under the features that open it, or both. */
+const PICKED = ['own', 'features', 'both'];
+const LIST_KEYS = new Set(['id', 'one', 'many', 'picks', 'levelled', 'again', 'picked', 'options']);
 const OPTION_KEYS = new Set(['id', 'label', 'description', 'requires', 'features']);
-const FEATURE_KEYS = new Set(['id', 'label', 'text', 'at', 'modifiers', 'uses', 'rolls', 'changes', 'choice']);
+const FEATURE_KEYS = new Set(['id', 'label', 'text', 'at', 'modifiers', 'uses', 'rolls', 'changes', 'choice', 'choice_count']);
 
 const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const list = (v) => (Array.isArray(v) ? v : []);
@@ -214,8 +226,17 @@ const checkChoices = (definition, problems) => {
       if (typeof f.choice !== 'string' || !listIds.has(f.choice)) problems.push({ where: `${where}, choice`, message: 'Not one of this system\'s lists' });
       else if (f.choice === ownList) problems.push({ where: `${where}, choice`, message: 'A list can\'t be picked from inside itself' });
     }
+    if (f.choice_count !== undefined) {
+      if (f.choice === undefined) problems.push({ where: `${where}, choice_count`, message: 'Only a feature that opens a list says how many' });
+      else if (!Number.isInteger(f.choice_count) || f.choice_count < 1 || f.choice_count > LIMITS.opens) problems.push({ where: `${where}, choice_count`, message: `A number from 1 to ${LIMITS.opens}` });
+    }
   };
 
+  const names = new Map(choicesOf(definition).map((c) => [c.id, String(c.many || c.id).toUpperCase()]));
+  for (const { list: id, path } of loopsOf(definition)) {
+    problems.push({ where: `list ${id}`, message: `Its features open lists that lead back to it: ${path.map((p) => names.get(p)).join(' → ')}` });
+  }
+
   lists.slice(0, LIMITS.lists).forEach((c, i) => {
     const where = isPlainObject(c) && typeof c.id === 'string' && NAME.test(c.id) ? `list ${c.id}` : `list ${i + 1}`;
     if (!isPlainObject(c)) { problems.push({ where, message: 'Must be a list to pick from' }); return; }
@@ -229,6 +250,7 @@ const checkChoices = (definition, problems) => {
     for (const key of ['levelled', 'again']) {
       if (c[key] !== undefined && typeof c[key] !== 'boolean') problems.push({ where: `${where}, ${key}`, message: `Must say ${key}: true or ${key}: false` });
     }
+    if (c.picked !== undefined && !PICKED.includes(c.picked)) problems.push({ where: `${where}, picked`, message: 'own (on its own), features (through the features that open it) or both' });
     if (c.levelled === true && typeof c.id === 'string' && (targets.has(`${c.id}_level`) || optionLevels.has(`${c.id}_level`))) {
       problems.push({ where, message: `Its levels add up as @${c.id}_level, which a stat, formula or option already has` });
     }
@@ -256,33 +278,110 @@ const checkChoices = (definition, problems) => {
   });
 };
 
+/** The lists each list's features open, other than itself (that is refused on its own). */
+const opensOf = (definition) => {
+  const lists = choicesOf(definition);
+  const ids = new Set(lists.map((c) => c.id));
+  return new Map(lists.map((c) => [c.id, [...new Set(optionsOf(c).flatMap((o) => list(o.features)).filter(isPlainObject)
+    .map((f) => f.choice).filter((id) => typeof id === 'string' && id !== c.id && ids.has(id)))]]));
+};
+
+/** Each list that leads back to itself through others, with the way round: [{ list, path }]. */
+const loopsOf = (definition) => {
+  const opens = opensOf(definition);
+  const out = [];
+  for (const start of opens.keys()) {
+    // Breadth first, so the way round named is the shortest.
+    const came = new Map([[start, null]]);
+    const queue = [start];
+    let found = null;
+    while (queue.length && !found) {
+      const at = queue.shift();
+      for (const next of opens.get(at) || []) {
+        if (next === start) { found = at; break; }
+        if (!came.has(next)) { came.set(next, at); queue.push(next); }
+      }
+    }
+    if (!found) continue;
+    const path = [start];
+    for (let at = found; at !== start; at = came.get(at)) path.splice(1, 0, at);
+    out.push({ list: start, path: [...path, start] });
+  }
+  return out;
+};
+
 /** How many of a list a character may have: as many as it picks, or no end when more can follow (again) or any. */
 const capOf = (c) => (c.again === true || c.picks === 'any' ? Infinity : Number.isInteger(c.picks) ? c.picks : 1);
 
+/** How a list is picked: on its own when it says nothing. */
+const pickedOf = (c) => (PICKED.includes(c.picked) ? c.picked : 'own');
+/** How many picks a feature opening a list gives: 1 when it says nothing. */
+const openCountOf = (f) => (Number.isInteger(f.choice_count) && f.choice_count >= 1 ? Math.min(f.choice_count, LIMITS.opens) : 1);
+
 /**
- * A character's picks, as stored on their sheet, kept only where they hold: [{ list, option, level }],
- * the list and option as the definition has them, level null in a list that isn't levelled.
+ * The features among `picks` that open a list picked through features (or both), each with how
+ * many picks it gives and how many of them are taken: [{ feature, list, count, used }].
  */
-const picksOf = (definition, data) => {
+const openingsOf = (definition, picks) => {
+  const lists = new Map(choicesOf(definition).map((c) => [c.id, c]));
+  return unlockedOf(picks)
+    .filter(({ feature }) => typeof feature.choice === 'string' && lists.has(feature.choice) && pickedOf(lists.get(feature.choice)) !== 'own')
+    .map(({ feature }) => ({ feature, list: lists.get(feature.choice), count: openCountOf(feature), used: picks.filter((p) => p.from === feature.id).length }));
+};
+
+/**
+ * Every pick a character's sheet keeps: [{ list, option, level, from, active }], the list and option
+ * as the definition has them, level null in a list that isn't levelled, `from` the feature it was
+ * picked under (null for a list's own), `active` whether it counts. A list's own picks count up to
+ * what it allows (those past it aren't kept); one picked under a feature counts while that feature is
+ * unlocked by a pick that counts, and has room, worked out down the lists until nothing more
+ * changes. Picks that don't count are kept for when they do: a list switched to THROUGH FEATURES
+ * keeps its own, a list switched back keeps those picked under features.
+ */
+const heldOf = (definition, data) => {
   const stored = isPlainObject(data) && isPlainObject(data[PICKS_KEY]) ? data[PICKS_KEY] : {};
-  const out = [];
+  const held = [];
   for (const c of choicesOf(definition)) {
+    const mode = pickedOf(c);
     const mine = Object.prototype.hasOwnProperty.call(stored, c.id) && Array.isArray(stored[c.id]) ? stored[c.id] : [];
     const options = new Map(optionsOf(c).map((o) => [o.id, o]));
     const taken = new Set();
+    let own = 0;
     for (const p of mine.slice(0, LIMITS.options)) {
-      if (taken.size >= capOf(c)) break;
       const id = isPlainObject(p) ? p.option : p;
       if (typeof id !== 'string' || !options.has(id) || taken.has(id)) continue;
+      const from = isPlainObject(p) && typeof p.from === 'string' ? p.from : null;
+      // A list's own picks past what it allows were never kept.
+      if (!from && mode !== 'features' && own >= capOf(c)) continue;
       taken.add(id);
       const level = c.levelled !== true ? null
         : isPlainObject(p) && Number.isInteger(p.level) && p.level >= 1 ? Math.min(p.level, LIMITS.level) : 1;
-      out.push({ list: c, option: options.get(id), level });
+      const counts = from ? (mode === 'own' ? false : null) : mode !== 'features';
+      if (counts) own += 1;
+      held.push({ list: c, option: options.get(id), level, from, active: counts });
     }
   }
-  return out;
+  // Picks under features, settled from the top down: each pass may unlock features for the next.
+  for (let changed = true; changed;) {
+    changed = false;
+    const room = new Map(openingsOf(definition, held.filter((p) => p.active === true))
+      .map((o) => [o.feature.id, { list: o.list, left: o.count - o.used }]));
+    for (const p of held.filter((x) => x.active === null)) {
+      const r = room.get(p.from);
+      if (r && r.list === p.list && r.left > 0) { p.active = true; r.left -= 1; changed = true; }
+    }
+  }
+  for (const p of held) if (p.active === null) p.active = false;
+  return held;
 };
 
+/**
+ * A character's picks that count: [{ list, option, level, from }], as heldOf reads them. What the
+ * numbers, uses, rests and rolls read.
+ */
+const picksOf = (definition, data) => heldOf(definition, data).filter((p) => p.active)
+  .map(({ list: c, option, level, from }) => ({ list: c, option, level, from }));
+
 /** The levels `picks` give, by the names formulas read them (levelNamesOf): untaken options read 0. */
 const levelsOf = (definition, picks) => {
   const levels = {};
@@ -408,15 +507,20 @@ const usesOf = (definition, data) => {
 };
 
 /**
- * What the sheet shows of a character's picks, worked out on every save: the picks with their levels,
- * the levels formulas read, what each changed value's modifiers come from, each feature's uses
+ * What the sheet shows of a character's picks, worked out on every save: every pick kept with its
+ * level, the feature it was picked under and whether it waits (7a5a), each feature's picks open, the
+ * levels formulas read, what each changed value's modifiers come from, each feature's uses
  * ({ max, spent }), and the options not taken whose requirement isn't met.
  */
 const workedOf = (definition, data) => {
-  const picks = picksOf(definition, data);
-  const taken = new Set(picks.map((p) => p.option.id));
+  const held = heldOf(definition, data);
+  const picks = held.filter((p) => p.active);
+  const taken = new Set(held.map((p) => p.option.id));
   return {
-    picks: picks.map((p) => ({ list: p.list.id, option: p.option.id, ...(p.level === null ? {} : { level: p.level }) })),
+    picks: held.map((p) => ({ list: p.list.id, option: p.option.id, ...(p.level === null ? {} : { level: p.level }),
+      ...(p.from ? { from: p.from } : {}), ...(p.active ? {} : { waiting: true }) })),
+    // 7a5a: each unlocked feature opening a list picked through features, and how many it gives and has.
+    opens: openingsOf(definition, picks).map((o) => ({ feature: o.feature.id, list: o.list.id, count: o.count, used: o.used })),
     levels: levelsOf(definition, picks),
     from: overlayOf(definition, data).from,
     uses: Object.fromEntries(usesOf(definition, data).map((u) => [u.feature.id, { max: u.max, spent: u.spent }])),
@@ -437,7 +541,7 @@ const choicesShown = (definition) => {
   return lists.map((c) => ({
     id: c.id, one: c.one, many: c.many,
     picks: c.picks === 'any' ? 'any' : Number.isInteger(c.picks) ? c.picks : 1,
-    again: c.again === true, levelled: c.levelled === true,
+    again: c.again === true, levelled: c.levelled === true, picked: pickedOf(c),
     options: optionsOf(c).map((o) => ({
       id: o.id, label: o.label || o.id,
       ...(typeof o.description === 'string' && o.description.trim() ? { description: o.description } : {}),
@@ -454,13 +558,13 @@ const choicesShown = (definition) => {
           const change = roll ? list(roll.changes).find((x) => x.id === ch.change) : null;
           return `${(change && change.label) || ch.change} on ${(roll && roll.label) || ch.roll}`;
         }) } : {}),
-        ...(typeof f.choice === 'string' && lists.some((l) => l.id === f.choice) ? { opens: f.choice } : {}),
+        ...(typeof f.choice === 'string' && lists.some((l) => l.id === f.choice) ? { opens: f.choice, opensCount: openCountOf(f) } : {}),
       })),
     })),
   }));
 };
 
 module.exports = {
-  LIMITS, PICKS_KEY, USES_KEY, WORKED_KEY, checkChoices, choicesOf, picksOf, levelsOf, levelNamesOf, unlockedOf, overlayOf, effectiveData,
+  LIMITS, PICKED, PICKS_KEY, USES_KEY, WORKED_KEY, checkChoices, choicesOf, heldOf, picksOf, pickedOf, openingsOf, loopsOf, levelsOf, levelNamesOf, unlockedOf, overlayOf, effectiveData,
   capOf, valueOn, meets, namesOf, needsText, usesOf, workedOf, choicesShown,
 };
diff --git a/backend/systemBuilder/picking.js b/backend/systemBuilder/picking.js
index dbbe35d4..ed5e93d9 100644
--- a/backend/systemBuilder/picking.js
+++ b/backend/systemBuilder/picking.js
@@ -3,7 +3,9 @@
 // the server, the sheet as stored the only thing trusted.
 //
 //   pick   a player picks for their own character while the list has room and the option's
-//          requirement is met; the GM may pick past a requirement, never past the list's room
+//          requirement is met; the GM may pick past a requirement, never past the list's room.
+//          A list picked through features (7a5a) is picked under one that opens it (`from`), while
+//          that feature is unlocked and has room; a list picked both ways takes either
 //   drop   only the GM takes a pick away
 //   level  a pick's level in a levelled list, from 1 to the highest: the player or the GM
 //   use    how many of a feature's uses are spent, from none to all of them: the player or the GM
@@ -12,18 +14,19 @@
 // not. The socket (sockets/choices.js) stores it through the sheet queue and works the numbers out
 // again. Picks and spent uses are kept where choices.js says (PICKS_KEY, USES_KEY).
 
-const { choicesOf, picksOf, capOf, meets, needsText, usesOf, PICKS_KEY, USES_KEY, LIMITS } = require('./choices');
+const { choicesOf, heldOf, pickedOf, openingsOf, capOf, meets, needsText, usesOf, PICKS_KEY, USES_KEY, LIMITS } = require('./choices');
 
 const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const fail = (error) => ({ ok: false, error });
 
-/** The list's picks, stored back as they are read: only what holds, in order. */
-const storedPicks = (picks, c) => picks.filter((p) => p.list === c).map((p) => (p.level === null ? { option: p.option.id } : { option: p.option.id, level: p.level }));
+/** The list's picks, stored back as they are read: every one kept (those waiting too), in order. */
+const storedPicks = (held, c) => held.filter((p) => p.list === c)
+  .map((p) => ({ option: p.option.id, ...(p.level === null ? {} : { level: p.level }), ...(p.from ? { from: p.from } : {}) }));
 
 const withPicks = (data, listId, stored) => ({ ...data, [PICKS_KEY]: { ...(isPlainObject(data[PICKS_KEY]) ? data[PICKS_KEY] : {}), [listId]: stored } });
 
 /**
- * One action on a sheet's picks. `action` is { kind: 'pick' | 'drop' | 'level', list, option, level }
+ * One action on a sheet's picks. `action` is { kind: 'pick' | 'drop' | 'level', list, option, level, from }
  * or { kind: 'use', feature, spent }; `gm` says whether the GM asks. Returns { ok: true, data } or
  * { ok: false, error } in words for the person who asked.
  */
@@ -44,22 +47,33 @@ const pickAction = (definition, data, action, { gm = false } = {}) => {
   const option = (Array.isArray(c.options) ? c.options : []).find((o) => isPlainObject(o) && o.id === action.option);
   if (!option) return fail(`Not one of the ${c.many || c.id}`);
   const name = option.label || option.id;
-  const picks = picksOf(definition, sheet);
-  const mine = picks.filter((p) => p.list === c);
+  const many = c.many || c.id;
+  const held = heldOf(definition, sheet);
+  const mine = held.filter((p) => p.list === c);
   const taken = mine.find((p) => p.option === option);
 
   if (action.kind === 'pick') {
     if (taken) return fail(`${name} is already picked`);
-    if (mine.length >= capOf(c)) return fail(`No more ${c.many || c.id} can be picked`);
+    const from = typeof action.from === 'string' ? action.from : null;
+    const mode = pickedOf(c);
+    if (from) {
+      if (mode === 'own') return fail(`The ${many} aren't picked under features`);
+      const opening = openingsOf(definition, held.filter((p) => p.active)).find((o) => o.feature.id === from);
+      if (!opening || opening.list !== c) return fail(`Nothing unlocked there opens the ${many}`);
+      if (opening.used >= opening.count) return fail(`No more ${many} can be picked there`);
+    } else {
+      if (mode === 'features') return fail(`The ${many} are picked under the features that open them`);
+      if (mine.filter((p) => !p.from && p.active).length >= capOf(c)) return fail(`No more ${many} can be picked`);
+    }
     if (!gm && !meets(definition, sheet, option)) return fail(`${name} needs ${needsText(definition, option.requires)}`);
-    const added = c.levelled === true ? { option: option.id, level: 1 } : { option: option.id };
-    return { ok: true, data: withPicks(sheet, c.id, [...storedPicks(picks, c), added]) };
+    const added = { option: option.id, ...(c.levelled === true ? { level: 1 } : {}), ...(from ? { from } : {}) };
+    return { ok: true, data: withPicks(sheet, c.id, [...storedPicks(held, c), added]) };
   }
 
   if (action.kind === 'drop') {
     if (!gm) return fail('Only the GM takes a pick away');
     if (!taken) return fail(`${name} isn't picked`);
-    return { ok: true, data: withPicks(sheet, c.id, storedPicks(picks, c).filter((p) => p.option !== option.id)) };
+    return { ok: true, data: withPicks(sheet, c.id, storedPicks(held, c).filter((p) => p.option !== option.id)) };
   }
 
   if (action.kind === 'level') {
@@ -67,7 +81,7 @@ const pickAction = (definition, data, action, { gm = false } = {}) => {
     if (!taken) return fail(`${name} isn't picked`);
     const level = Number(action.level);
     if (!Number.isInteger(level) || level < 1 || level > LIMITS.level) return fail(`A level from 1 to ${LIMITS.level}`);
-    return { ok: true, data: withPicks(sheet, c.id, storedPicks(picks, c).map((p) => (p.option === option.id ? { ...p, level } : p))) };
+    return { ok: true, data: withPicks(sheet, c.id, storedPicks(held, c).map((p) => (p.option === option.id ? { ...p, level } : p))) };
   }
 
   return fail('Nothing to do');
diff --git a/e2e/COVERAGE.md b/e2e/COVERAGE.md
index 5f87279a..5523c667 100644
--- a/e2e/COVERAGE.md
+++ b/e2e/COVERAGE.md
@@ -75,6 +75,7 @@ panel), so a control that looks fine but does nothing is caught for all of them.
 | Option | Variants | Server tests | Browser test | Status |
 |---|---|---|---|---|
 | Lists and options | one / several / any, MORE THAN ONCE, LEVELLED, a requirement | `choices` | `builder-choices`, `sheet-choices` | **AT THE TABLE** |
+| Lists inside lists | a list picked ON ITS OWN, THROUGH FEATURES or BOTH; a feature's HOW MANY; a pick waiting when its feature locks; nested deeper | `nested_choices`, `picking` | | **GAP** until 7a5a2, which brings the builder's settings, the sheet and their journey |
 | Features | at a level; modifiers, uses and their rest, rolls, roll changes, a list opened | `choices`, `choices_numbers` | `builder-choices` | **BUILDER ONLY**, at the table in 7a3 |
 | What picks do to the numbers | a modifier reaching a formula, levels unlocking features | `choices_numbers` | `sheet-choices` (Defense +1 from Guard Stance; Veteran at level 2) | **AT THE TABLE** |
 | Picking at the table | a player picks, one not met off with what it needs; sets a level; ticks a use | `picking` | `sheet-choices` | **AT THE TABLE** |
diff --git a/frontend/src/sheets/choices.ts b/frontend/src/sheets/choices.ts
index f9f40396..dbe0b721 100644
--- a/frontend/src/sheets/choices.ts
+++ b/frontend/src/sheets/choices.ts
@@ -15,7 +15,7 @@ import { restList } from './rests';
 import { rollList } from './rolls';
 
 /** backend choices.js LIMITS, held equal by a test. */
-export const LIMITS = { lists: 20, options: 100, features: 40, modifiers: 10, rolls: 10, level: 30, picks: 100, label: 40, description: 1000 } as const;
+export const LIMITS = { lists: 20, options: 100, features: 40, modifiers: 10, rolls: 10, level: 30, picks: 100, label: 40, description: 1000, opens: 10 } as const;
 
 type Obj = Record<string, unknown>;
 const isObject = (v: unknown): v is Obj => !!v && typeof v === 'object' && !Array.isArray(v);