bdtui 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-06-21
+
+### Added
+
+- `Shift+r`: reset all narrowing filters (title search, epic scope, type) and reload fresh.
+- The status bar now summarizes every active narrowing filter together — e.g. `"login"  ·  epic: bd-12  ·  type: task — 3 results | Shift+r to reset` — instead of only the most recent one. The epic filter now shows the same result-count/reset hint that title search did.
+- The tab bar gains a persistent `search:` indicator for the active title filter, alongside the existing `type:` and `epic:` indicators.
+
+### Changed
+
+- `r` (reload) now **keeps** active filters instead of clearing the epic filter; use `Shift+r` to clear filters. This reverses the `0.5.0` behavior where `r` cleared the epic filter.
+- The `/` title filter is now persistent state: it survives a reload (`r`) and composes with the epic and type filters. The prompt pre-fills with the current search, and submitting an empty value clears just the title filter.
+
+### Fixed
+
+- `Shift+c` (claim) and `Shift+g` (jump to bottom) now actually fire. They were registered as bare uppercase `C`/`G`, but blessed reports a shifted letter as `S-<lower>`, so the handlers were dead — claim did nothing and `Shift+g` only reached the last *loaded* page instead of revealing all rows and jumping to the true bottom.
+- Reloading or filtering while scoped to an epic on the **All**/**Closed** tabs no longer caps the fetch at bd's default 50 rows, which could drop an epic's children from the scoped view.
+- The title search is now tag-escaped before it reaches the status bar, so a query containing `{`/`}` no longer corrupts the status line.
+- Reparenting with `h` no longer throws `Unexpected token '✓' … is not valid JSON`. `bd dep add`/`bd dep remove` print a human-readable line rather than JSON, so their output is no longer parsed as JSON.
+- `h` (change parent) now **detaches every existing parent first, then attaches** the chosen one — previously it added the new parent before removing the old, so the JSON error above left the bead with two parents. It also clears *all* existing parent-child links (not just the first), repairing beads that already ended up with multiple parents.
+
+## [0.6.0] - 2026-06-14
+
+### Fixed
+
+- The **Closed** and **All** tabs now render the epic→children tree like the other tabs; previously they showed a flat, ungrouped list with every bead at the top level. Closed children nest under their epic (parent epics that aren't themselves closed are pulled in as the grouping anchor).
+
+### Changed
+
+- Tree views now build from the `parent` field that `bd` embeds in each `bd list`/`bd ready` row instead of fetching one `bd dep list` per bead. The Closed/All tabs gain the tree at no extra per-bead subprocess cost (lazy "load more" pagination is unchanged), and the Ready/Blocked/In-progress tabs load with fewer `bd` calls. The Blocked tab keeps a per-row `bd dep list` fallback for the derived-blocked rows `bd blocked` returns without a `parent` field.
+
 ## [0.5.1] - 2026-06-14
 
 ### Fixed

package/README.md

@@ -66,18 +66,21 @@ be-12  P2 ready   T  └ Another child
 |-----|--------|
 | `j` / `↓` | Move down |
 | `k` / `↑` | Move up |
-| `g` / `G` | Jump to top / bottom |
+| `g` / `Shift+g` | Jump to top / bottom |
 | `Enter` / `l` | Focus detail pane |
-| `h` / `Esc` | Back to list |
-| `f` | Cycle filter: ready → open → in_progress → all |
-| `r` | Reload current filter |
-| `/` | In-memory title filter |
+| `h` / `Esc` | Back to list (from detail) |
+| `Tab` / `Shift+Tab` | Next / previous status filter (blocked/ready/in_progress/closed/all) |
+| `t` | Cycle type filter (all/epic/task/chore/bug) |
+| `e` | Filter by epic (modal picker; `x` clears) |
+| `/` | In-memory title filter (empty submit clears it) |
+| `r` | Reload (keeps active filters) |
+| `Shift+r` | Reset all filters (title / epic / type) and reload |
 | `s` | Change status |
 | `c` | Close with reason |
-| `C` | Claim (in_progress + assign self) |
+| `Shift+c` | Claim (in_progress + assign self) |
 | `o` | Reopen |
 | `p` | Change priority |
-| `D` | Dependency menu (add / remove) |
+| `h` | Change parent (epic / standalone) |
 | `y` | Yank bead ID to clipboard |
 | `w` | Pick a workflow skill (`/executor-task`, `/executor-task-worktree`, `/executor-epic-task`, `/executor-epic-task-worktree`) and copy it with the selected task's ID. Disabled for epics. See [workflow-template](https://github.com/jsiovn/workflow-template). |
 | `?` | Help overlay |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bdtui",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Terminal UI for the bd beads issue tracker",
   "type": "module",
   "bin": {

package/src/app.js

@@ -1,6 +1,6 @@
 import blessed from 'blessed';
 import { execFile } from 'child_process';
-import { state, loadList, loadDetail, applyMutation, applyTypeFilter, isPaged, ensureSelectedVisible } from './state.js';
+import { state, loadList, loadDetail, applyMutation, applyFilters, isPaged, ensureSelectedVisible } from './state.js';
 import { createList, renderList } from './views/list.js';
 import { createDetail, renderDetail } from './views/detail.js';
 import { statusPicker, priorityPicker, textPrompt, parentPicker, skillPicker, epicPicker } from './views/modals.js';
@@ -10,6 +10,11 @@ import { bdUpdate, bdClose, bdClaim, bdReopen, bdDepAdd, bdDepRemove, bdDepListD
 const FILTERS = ['blocked', 'ready', 'in_progress', 'closed', 'all'];
 const TYPE_FILTERS = ['all', 'epic', 'task', 'chore', 'bug'];
 
+// Neutralize blessed tag markup in free text before it lands in a tags:true
+// box (mirrors esc() in views/detail.js). The title search is user-typed, so a
+// query like "{bold}" would otherwise corrupt the status line.
+const escTags = (s) => String(s ?? '').replace(/\{/g, '{open}').replace(/\}/g, '{close}');
+
 export async function run(cwd) {
   state.cwd = cwd;
 
@@ -38,8 +43,19 @@ export async function run(cwd) {
   let debounceTimer = null;
 
   let statusTimer = null;
+  // Describe every active narrowing filter (title search, epic scope, type) in
+  // one line with the result count and reset hint. Returns null when none are
+  // active so the caller can fall back to a plain "Ready".
+  function filterSummary() {
+    const parts = [];
+    if (state.textFilter) parts.push(`"${escTags(state.textFilter)}"`);
+    if (state.epicFilter) parts.push(`epic: ${state.epicFilter}`);
+    if (state.typeFilter !== 'all') parts.push(`type: ${state.typeFilter}`);
+    if (parts.length === 0) return null;
+    return `${parts.join('  ·  ')} — ${state.listOrder.length} results | Shift+r to reset`;
+  }
   function defaultStatus() {
-    return state.filter ? `Filter: ${state.filter}` : 'Ready';
+    return filterSummary() || 'Ready';
   }
   function setStatus(msg, isError = false, transient = false) {
     if (statusTimer) { clearTimeout(statusTimer); statusTimer = null; }
@@ -67,8 +83,11 @@ export async function run(cwd) {
     const epicInfo = state.epicFilter
       ? `  {gray-fg}│{/}  {magenta-fg}epic:{/} ${state.epicFilter}`
       : '';
+    const textInfo = state.textFilter
+      ? `  {gray-fg}│{/}  {green-fg}search:{/} "${escTags(state.textFilter)}"`
+      : '';
     const info  = count > 0 ? `{gray-fg}  │  ${count} beads{/}` : '';
-    tabBar.setContent(tabs.join('{gray-fg}│{/}') + typeInfo + epicInfo + info);
+    tabBar.setContent(tabs.join('{gray-fg}│{/}') + typeInfo + epicInfo + textInfo + info);
   }
 
   function setFocusBorder(focused) {
@@ -142,7 +161,7 @@ export async function run(cwd) {
       ensureSelectedVisible();
       if (state.selectedId) await loadDetail(state.selectedId);
       render();
-      setStatus('Ready');
+      setStatus(defaultStatus());
     } catch (err) {
       setStatus(err.message, true, true);
     }
@@ -158,7 +177,7 @@ export async function run(cwd) {
       state.selectedId = state.listOrder[0] || null;
       if (state.selectedId) await loadDetail(state.selectedId);
       render();
-      setStatus(`Filter: ${state.filter}`);
+      setStatus(defaultStatus());
     } catch (err) {
       setStatus(err.message, true, true);
     }
@@ -167,7 +186,7 @@ export async function run(cwd) {
   async function cycleTypeFilter() {
     const idx = TYPE_FILTERS.indexOf(state.typeFilter);
     state.typeFilter = TYPE_FILTERS[(idx + 1) % TYPE_FILTERS.length];
-    applyTypeFilter();
+    applyFilters();
     if (state.selectedId && !state.listOrder.includes(state.selectedId)) {
       state.selectedId = state.listOrder[0] || null;
     } else if (!state.selectedId) {
@@ -185,7 +204,7 @@ export async function run(cwd) {
         return;
       }
     }
-    setStatus(`Type: ${state.typeFilter}`, false, true);
+    setStatus(defaultStatus());
   }
 
   // ── Global keys ────────────────────────────────────────────────────────────
@@ -201,11 +220,20 @@ export async function run(cwd) {
 
   key(['q', 'C-c'], () => { screen.destroy(); process.exit(0); });
 
+  // r reloads data while preserving every active filter; Shift+r clears all
+  // narrowing filters (title search, epic scope, type) and reloads fresh.
+  // blessed reports a shifted letter as `S-<lower>` (never bare uppercase), so
+  // the binding must be 'S-r' — 'R' would be dead. Same for S-c / S-g below.
   key(['r'], async () => {
-    const wasEpic = !!state.epicFilter;
+    await refresh();
+  });
+  key(['S-r'], async () => {
+    const had = !!(state.textFilter || state.epicFilter || state.typeFilter !== 'all');
+    state.textFilter = null;
     state.epicFilter = null;
+    state.typeFilter = 'all';
     await refresh();
-    if (wasEpic) setStatus('Epic filter cleared', false, true);
+    if (had) setStatus('Filters reset', false, true);
   });
   key(['tab'], () => cycleFilter(1));
   key(['S-tab'], () => cycleFilter(-1));
@@ -241,7 +269,7 @@ export async function run(cwd) {
         return;
       }
     } else {
-      applyTypeFilter();
+      applyFilters();
     }
     state.selectedId = state.listOrder[0] || null;
     if (state.selectedId) {
@@ -251,7 +279,7 @@ export async function run(cwd) {
       }
     }
     render();
-    setStatus(picked ? `Epic: ${picked}` : 'Epic filter cleared', false, true);
+    setStatus(defaultStatus());
   });
 
   key(['?'], () => {
@@ -289,10 +317,15 @@ export async function run(cwd) {
       setStatus(err.message, true, true);
       return;
     }
-    const currentParentId = downDeps.find((d) => d.dependency_type === 'parent-child')?.id ?? null;
+    // A bead should have at most one parent, but a prior bug could leave it with
+    // several parent-child deps — collect them all so we can clear every one.
+    const currentParentIds = downDeps
+      .filter((d) => d.dependency_type === 'parent-child')
+      .map((d) => d.id)
+      .filter(Boolean);
     let newParent;
     try {
-      newParent = await parentPicker(screen, epics, { selfId: id, currentParentId });
+      newParent = await parentPicker(screen, epics, { selfId: id, currentParentIds });
     } catch (err) {
       list.focus();
       if (err.message !== 'cancelled') setStatus(err.message, true, true);
@@ -302,13 +335,13 @@ export async function run(cwd) {
     setStatus(`Reparenting ${id}…`);
     try {
       await applyMutation(id, async () => {
-        if (newParent) {
+        // Detach every existing parent first so the bead is never left with two
+        // parents, then attach the chosen one (skip if it's already a parent).
+        for (const pid of currentParentIds) {
+          if (pid !== newParent) await bdDepRemove(id, pid, state.cwd);
+        }
+        if (newParent && !currentParentIds.includes(newParent)) {
           await bdDepAdd(id, newParent, 'parent-child', state.cwd);
-          if (currentParentId && currentParentId !== newParent) {
-            await bdDepRemove(id, currentParentId, state.cwd);
-          }
-        } else if (currentParentId) {
-          await bdDepRemove(id, currentParentId, state.cwd);
         }
       });
       await loadList();
@@ -331,7 +364,7 @@ export async function run(cwd) {
     screen.render();
   });
 
-  key(['G'], () => {
+  key(['S-g'], () => {
     if (screen.focused !== list) return;
     // Jump to the true bottom — in paged mode reveal every remaining batch first.
     if (isPaged() && state.visibleCount < state.listOrder.length) {
@@ -346,22 +379,20 @@ export async function run(cwd) {
   key(['/'], async () => {
     if (screen.focused !== list) return;
     try {
-      const query = await textPrompt(screen, 'Filter by title');
+      // Pre-fill with the active search so it can be edited; an empty submit
+      // clears the title filter (other filters stay put).
+      const query = await textPrompt(screen, 'Filter by title', state.textFilter || '');
       list.focus();
-      if (!query) { render(); return; }
-      const q = query.toLowerCase();
-      state.listOrder = state.listOrder.filter((id) => {
-        const b = state.beadsById.get(id);
-        return b?.title?.toLowerCase().includes(q);
-      });
-      state.visibleCount = isPaged()
-        ? Math.min(state.pageSize, state.listOrder.length)
-        : state.listOrder.length;
-      state.selectedId = state.listOrder[0] || null;
+      state.textFilter = query || null;
+      applyFilters();
+      if (!state.selectedId || !state.listOrder.includes(state.selectedId)) {
+        state.selectedId = state.listOrder[0] || null;
+      }
+      ensureSelectedVisible();
       renderList(list);
       renderDetail(detail);
       screen.render();
-      setStatus(`"${query}" — ${state.listOrder.length} results | r to reset`);
+      setStatus(defaultStatus());
     } catch {
       list.focus();
     }
@@ -409,7 +440,7 @@ export async function run(cwd) {
     }
   });
 
-  key(['C'], async () => {
+  key(['S-c'], async () => {
     if (screen.focused !== list || !state.selectedId) return;
     const id = state.selectedId;
     setStatus(`Claiming ${id}…`);

package/src/bd.js

@@ -16,6 +16,18 @@ async function runBd(args, cwd) {
   }
 }
 
+// Run a bd command whose stdout we don't consume (e.g. `dep add`/`dep remove`,
+// which print a human-readable "✓ Added dependency…" line, not JSON). We can't
+// JSON.parse that — doing so was the source of the "Unexpected token '✓'" error.
+// Failures still surface: a non-zero exit rejects execFile and we throw stderr.
+async function runBdVoid(args, cwd) {
+  try {
+    await execFileP('bd', args, { cwd, maxBuffer: MAX_BUFFER });
+  } catch (err) {
+    throw new Error(err.stderr?.trim() || err.message);
+  }
+}
+
 // `bd blocked` only returns *derived*-blocked beads (open beads whose blockers
 // aren't all closed); it omits beads whose status was explicitly set to
 // "blocked". The Blocked tab should show both, so merge the two sources, deduped.
@@ -83,11 +95,11 @@ export const bdReopen = (id, cwd) => runBd(['reopen', id, '--json'], cwd);
 export const bdDepAdd = (child, parent, type, cwd) => {
   const args = ['dep', 'add', child, parent];
   if (type && type !== 'blocks') args.push('--type', type);
-  return runBd(args, cwd);
+  return runBdVoid(args, cwd);
 };
 
 export const bdDepRemove = (child, parent, cwd) =>
-  runBd(['dep', 'remove', child, parent], cwd);
+  runBdVoid(['dep', 'remove', child, parent], cwd);
 
 // Returns all children of an epic (all statuses — bd children includes closed by default)
 export const bdChildren = (id, cwd) => runBd(['children', id, '--json'], cwd);

package/src/keys.js

@@ -7,7 +7,7 @@ export const HELP_TEXT = [
   '  j / ↓       Move down in list',
   '  k / ↑       Move up in list',
   '  g           Jump to top',
-  '  G           Jump to bottom',
+  '  Shift+g     Jump to bottom',
   '  Enter / l   Focus detail pane',
   '  h / Esc     Back to list (from detail)',
   '',
@@ -17,15 +17,16 @@ export const HELP_TEXT = [
   '  Shift+Tab   Previous status filter',
   '  t           Cycle type filter (all/epic/task/chore/bug)',
   '  e           Filter by epic (modal picker; x clears; switches status to all)',
-  '  r           Reload (also clears epic filter)',
-  '  /           In-memory title filter',
+  '  /           In-memory title filter (empty submit clears it)',
+  '  r           Reload (keeps active filters)',
+  '  Shift+r     Reset all filters (title / epic / type) and reload',
   '  (all & closed tabs load more rows as you scroll to the bottom)',
   '',
   '  Mutations',
   '  ──────────────────────────────────────',
   '  s           Change status',
   '  c           Close with reason',
-  '  C           Claim bead (in_progress + assign self)',
+  '  Shift+c     Claim bead (in_progress + assign self)',
   '  o           Reopen',
   '  p           Change priority',
   '  h           Change parent (epic / standalone)',

package/src/state.js

@@ -15,6 +15,7 @@ export const state = {
   filter: 'ready',
   typeFilter: 'all',   // 'all' | 'epic' | 'task'
   epicFilter: null,    // null or epic bead id — when set, list is scoped to that epic + its children
+  textFilter: null,    // null or lowercase-matched title substring (in-memory)
   blockedIds: new Set(), // ids that appear in `bd blocked` — derived state, not raw status
   pageSize: 100,        // lazy "load more" batch size for the flat all view
   visibleCount: 0,     // how many of listOrder are currently rendered (paged mode)
@@ -22,8 +23,8 @@ export const state = {
 };
 
 // The "all" and "closed" tabs (no epic filter) can hold huge numbers of beads,
-// so they use a flat, lazily-revealed list; every other view loads fully and
-// renders the epic→children tree.
+// so they reveal rows lazily in pageSize batches; every other view renders its
+// rows all at once. All tabs build the same epic→children tree (see loadList).
 export function isPaged() {
   return (state.filter === 'all' || state.filter === 'closed') && !state.epicFilter;
 }
@@ -60,7 +61,11 @@ function scopeToEpic(items, epicId) {
   return out;
 }
 
-export function applyTypeFilter() {
+// Apply every active narrowing filter (epic → type → text) to fullTreeItems and
+// rebuild listOrder/treeMeta. Kept in one place so a reload (`r`) can replay the
+// same filters and the status bar can describe them. Filters compose: an epic
+// scope, a type filter, and a title search can all be active at once.
+export function applyFilters() {
   let items = state.fullTreeItems;
   if (state.epicFilter) {
     items = scopeToEpic(items, state.epicFilter);
@@ -71,6 +76,15 @@ export function applyTypeFilter() {
       .sort((x, y) => byUpdatedDesc(state.beadsById.get(x.id), state.beadsById.get(y.id)))
       .map((t) => ({ id: t.id, depth: 0, isLast: false }));
   }
+  if (state.textFilter) {
+    const q = state.textFilter.toLowerCase();
+    // A title-search result set is no longer a tree, so flatten every surviving
+    // row to depth 0 — otherwise a matched child whose parent was filtered out
+    // renders as an orphan indented under a branch glyph.
+    items = items
+      .filter((t) => state.beadsById.get(t.id)?.title?.toLowerCase().includes(q))
+      .map((t) => ({ id: t.id, depth: 0, isLast: false }));
+  }
   state.listOrder = items.map((t) => t.id);
   state.treeMeta = new Map(items.map((t) => [t.id, { depth: t.depth, isLast: t.isLast }]));
   state.visibleCount = isPaged()
@@ -80,22 +94,33 @@ export function applyTypeFilter() {
 
 function buildTreeOrder(beads, parentOf) {
   const byId = new Map(beads.map((b) => [b.id, b]));
-  const childrenOf = new Map();
+  // A bead is a root when it has no parent present in this bead set (epics and
+  // standalone beads). The tree is intentionally two levels deep — epics on top,
+  // their direct children indented under them.
+  const isRoot = (id) => {
+    const pid = parentOf.get(id);
+    return !pid || !byId.has(pid);
+  };
 
+  const childrenOf = new Map();
+  const roots = [];
   for (const b of beads) {
     const pid = parentOf.get(b.id);
-    if (pid && byId.has(pid)) {
+    // Nest a bead only when its parent is itself a root. Anything else — no
+    // parent, a parent filtered out of this view, or a parent that is itself
+    // nested (deeper than two levels) — renders at the top level so no bead is
+    // ever silently dropped from the list.
+    if (pid && byId.has(pid) && isRoot(pid)) {
       if (!childrenOf.has(pid)) childrenOf.set(pid, []);
       childrenOf.get(pid).push(b);
+    } else {
+      roots.push(b);
     }
   }
 
   for (const children of childrenOf.values()) {
     children.sort(byUpdatedDesc);
   }
-
-  const childIds = new Set([...childrenOf.values()].flat().map((b) => b.id));
-  const roots = beads.filter((b) => !childIds.has(b.id));
   roots.sort(byUpdatedDesc);
 
   const ordered = [];
@@ -110,50 +135,51 @@ function buildTreeOrder(beads, parentOf) {
   return ordered;
 }
 
-// Flat load for the paged tabs ("all" / "closed"). Skips the per-bead
-// parent-child dep fetch (which spawns one bd subprocess per bead) and the tree
-// build, so even very large repos load in a single bd call; the UI reveals rows
-// in pageSize batches.
-async function loadListFlat() {
-  const [beads, blocked] = await Promise.all([
-    bdList(state.filter, state.cwd, { unlimited: true }),
-    bdList('blocked', state.cwd).catch(() => []),
-  ]);
-  state.blockedIds = new Set((blocked || []).map((b) => b.id));
-  for (const b of beads) {
-    state.beadsById.set(b.id, { ...state.beadsById.get(b.id), ...b });
-  }
-  beads.sort(byUpdatedDesc);
-  state.fullTreeItems = beads.map((b) => ({ id: b.id, depth: 0, isLast: false }));
-  applyTypeFilter();
-  return beads;
-}
-
 export async function loadList() {
-  if (isPaged()) return loadListFlat();
+  // The all/closed tabs lift bd's 50-row cap so the full tree is available; the
+  // renderer still reveals rows in pageSize batches (see isPaged). This is keyed
+  // off the tab itself, NOT isPaged(): an epic filter makes isPaged() false but
+  // we still need every bead fetched so scopeToEpic can find the epic's children
+  // (otherwise reloading while epic-scoped would silently drop children past
+  // row 50).
+  const unlimited = state.filter === 'all' || state.filter === 'closed';
   const [beads, blocked] = await Promise.all([
-    bdList(state.filter, state.cwd),
+    bdList(state.filter, state.cwd, { unlimited }),
     bdList('blocked', state.cwd).catch(() => []),
   ]);
   state.blockedIds = new Set((blocked || []).map((b) => b.id));
   const byId = new Map(beads.map((b) => [b.id, b]));
 
-  // Build parent-child map from real bd deps (dependency_type === 'parent-child').
-  // Fetch only for non-epic beads — epics don't have epic parents in this model.
-  const candidates = beads.filter((b) => b.issue_type !== 'epic');
-  const depLists = await Promise.all(
-    candidates.map((b) => bdDepListDown(b.id, state.cwd))
-  );
-
+  // Parent-child relationships come straight from the `parent` field bd embeds in
+  // every list row (the target of the bead's parent-child dependency). This is
+  // the same data `bd dep list` returns, so the tree builds from the single
+  // `bd list` call above — no per-bead subprocess fan-out, even on huge repos.
   const parentOf = new Map();
-  candidates.forEach((b, i) => {
-    const pc = depLists[i].find((d) => d.dependency_type === 'parent-child');
-    if (pc?.id) parentOf.set(b.id, pc.id);
-  });
+  for (const b of beads) {
+    if (b.parent && b.parent !== b.id) parentOf.set(b.id, b.parent);
+  }
+
+  // The Blocked tab merges in `bd blocked` (derived-blocked) rows, and that
+  // command — unlike `bd list` — omits the `parent` field entirely. Recover the
+  // parent for those rows with a dep-list lookup. Scoped to the blocked filter
+  // (the only parent-less source) and to non-epic rows without an embedded
+  // parent, so it stays a handful of calls on an already-small view.
+  if (state.filter === 'blocked') {
+    const needsLookup = beads.filter((b) => !('parent' in b) && b.issue_type !== 'epic');
+    const depLists = await Promise.all(
+      needsLookup.map((b) => bdDepListDown(b.id, state.cwd))
+    );
+    needsLookup.forEach((b, i) => {
+      const pc = depLists[i].find((d) => d.dependency_type === 'parent-child');
+      if (pc?.id && pc.id !== b.id) parentOf.set(b.id, pc.id);
+    });
+  }
 
   // Bring in parent epics that aren't already in the filtered list so the tree
   // can root under them. Only add the epic itself, NOT its other children —
-  // that's what caused closed beads to leak into ready/open filters.
+  // that's what caused closed beads to leak into ready/open filters. Skipped for
+  // "all", which already contains every bead. The fetch is bounded by the number
+  // of distinct missing parents (≈ epic count), not the bead count.
   if (state.filter !== 'all') {
     const missingParents = [...new Set(parentOf.values())].filter((id) => !byId.has(id));
     const fetched = await Promise.all(
@@ -172,7 +198,7 @@ export async function loadList() {
   }
 
   state.fullTreeItems = buildTreeOrder(beads, parentOf);
-  applyTypeFilter();
+  applyFilters();
   return beads;
 }
 

package/src/views/modals.js

@@ -186,10 +186,11 @@ export function skillPicker(screen, beadId) {
   return listPicker(screen, 'Copy workflow command', items, 'magenta', 56, 1);
 }
 
-export function parentPicker(screen, epics, { selfId, currentParentId } = {}) {
+export function parentPicker(screen, epics, { selfId, currentParentIds = [] } = {}) {
   return new Promise((resolve, reject) => {
+    const exclude = new Set([selfId, ...currentParentIds]);
     const sorted = [...epics]
-      .filter((e) => e.id !== selfId && e.id !== currentParentId)
+      .filter((e) => !exclude.has(e.id))
       .sort((a, b) => {
         const ta = a.updated_at || '', tb = b.updated_at || '';
         if (ta !== tb) return tb.localeCompare(ta);