diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bcdaa6..d222d73 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Diff view: `.md` lines render as styled markdown (headings/bold/italic/code/lists/blockquotes/HRs) instead of raw source. A pre-rendering pass scans each `.md` file’s pre/post images so per-line styling has full block context (e.g. lines inside fenced code render verbatim)
 - 8 markdown themes (`bright`, `forest`, `sunset`, `ocean`, `neon`, `autumn`, `candy`, `mono`) with distinct colour palettes; press `[t]` to cycle
 - Kanban board uses the full terminal width: columns abut directly (no per-column margin, no inter-group separator, no internal padding) and the column floor drops to 12 cols so narrow terminals stop overflowing. Card secondary-row gutter tightens from 4 to 2 cols so descriptions have more room
+- Kanban footer no longer wraps mid-word at narrow widths. Hints are packed as atomic chunks separated by `  ·  `, and footer width is now independent of cursor position — so moving between items with/without a worktree no longer shifts the board up/down (the “flicker”)
 - Add changes here. The first bullet under each release is used as the short “what’s new” message in the app’s update notice.
 
 ## 1.1.2 - 2026-04-19
diff --git a/src/screens/TrackerBoardScreen.tsx b/src/screens/TrackerBoardScreen.tsx
index 90f88fb..c2c6b5b 100644
--- a/src/screens/TrackerBoardScreen.tsx
+++ b/src/screens/TrackerBoardScreen.tsx
@@ -694,11 +694,14 @@ export default function TrackerBoardScreen({
   }
 
   // Column height = termRows minus all vertical chrome:
-  //   1 title row + 1 footer row + footerStatusRow (optional)
+  //   1 title row + footerRows + footerStatusRow (optional)
   //   + 1 reserved by FullScreen (prevents terminal scroll)
   //   + 1 margin (keeps content from touching the edge)
+  // footerRows is computed from the deterministic packing below so wrapped
+  // footers don't push the board off the bottom of the terminal.
   const footerStatusRow = proposalStatus ? 1 : 0;
-  const colHeight = Math.max(5, termRows - (4 + footerStatusRow));
+  const footerRows = packFooterChunks(buildFooterChunks(), Math.max(20, termCols - 2)).length;
+  const colHeight = Math.max(5, termRows - (3 + footerStatusRow + footerRows));
 
   // Group columns
   const planColIndices: number[] = [];
@@ -948,6 +951,7 @@ export default function TrackerBoardScreen({
         )}
         {!inputActive && (
           <Footer
+            termCols={termCols}
             hasSession={!!currentItemSession}
             hasWorktree={hasWorktree}
             hasItem={!!currentItem}
@@ -959,74 +963,135 @@ export default function TrackerBoardScreen({
   );
 }
 
-const Footer = React.memo(function Footer({hasSession, hasWorktree, hasItem, inactive}: {hasSession: boolean; hasWorktree: boolean; hasItem: boolean; inactive: boolean}) {
-  const sep = <Text dimColor>  ·  </Text>;
+// One footer hint, e.g. "↵ open" or "a attach". `plain` is the visible width
+// used for packing decisions; `render` returns the styled node. Chunks are
+// atomic — packing never breaks one across rows, so narrow terminals get a
+// clean multi-row footer instead of mid-word wrapping.
+type FooterChunk = {key: string; plain: string; render: (ctx: FooterState) => React.ReactNode};
+type FooterState = {hasSession: boolean; hasWorktree: boolean; hasItem: boolean; inactive: boolean};
+
+const CHUNK_SEP = '  ·  ';
+
+// Chunks are listed in display order. The list is structurally constant —
+// hint visibility (hasItem / hasWorktree / hasSession) only changes a chunk's
+// colour/dim treatment, never its `plain` width. That keeps the packed row
+// count stable across cursor moves and removes the up/down board flicker.
+function buildFooterChunks(): FooterChunk[] {
+  const dim = (s: string) => <Text dimColor>{s}</Text>;
+  const k = (label: string, color: string | undefined = 'magenta', bold = false) => (
+    <Text color={color} bold={bold}>{label}</Text>
+  );
+  return [
+    {
+      key: 'nav',
+      plain: 'nav ←/→ cols ↑/↓ items',
+      render: () => (<>{dim('nav ')}{k('←/→')}{dim(' cols ')}{k('↑/↓')}{dim(' items')}</>),
+    },
+    {
+      key: 'open',
+      plain: '↵ open',
+      render: () => (<>{k('↵')}{dim(' open')}</>),
+    },
+    {
+      key: 'attach',
+      plain: 'a attach',
+      render: ({hasItem, hasSession}) => hasItem
+        ? <>{k('a', hasSession ? 'yellow' : 'magenta', hasSession)}<Text color={hasSession ? 'yellow' : undefined} bold={hasSession} dimColor={!hasSession}> attach</Text></>
+        : <Text dimColor>a attach</Text>,
+    },
+    {
+      key: 'shell',
+      plain: 's shell',
+      render: ({hasWorktree}) => hasWorktree
+        ? <>{k('s')}{dim(' shell')}</>
+        : <Text dimColor>s shell</Text>,
+    },
+    {
+      key: 'run',
+      plain: 'x run',
+      render: ({hasWorktree}) => hasWorktree
+        ? <>{k('x')}{dim(' run')}</>
+        : <Text dimColor>x run</Text>,
+    },
+    {
+      key: 'diff',
+      plain: 'd diff',
+      render: ({hasWorktree}) => hasWorktree
+        ? <>{k('d')}{dim(' diff')}</>
+        : <Text dimColor>d diff</Text>,
+    },
+    {
+      key: 'archive',
+      plain: 'archive',
+      render: ({hasItem}) => hasItem
+        ? <>{dim('archi')}{k('v')}{dim('e')}</>
+        : <Text dimColor>archive</Text>,
+    },
+    {
+      key: 'new',
+      plain: 'n new',
+      render: () => <>{k('n')}{dim(' new')}</>,
+    },
+    {
+      key: 'inactive',
+      // Same width for both labels (inactive=8, activate=8) so row count
+      // doesn't flip when the user toggles inactive on the selected item.
+      plain: 'i inactive',
+      render: ({hasItem, inactive}) => hasItem
+        ? <>{k('i')}{dim(inactive ? ' activate' : ' inactive')}</>
+        : <Text dimColor>i inactive</Text>,
+    },
+    {key: 'proposals', plain: 'p proposals', render: () => <>{k('p')}{dim(' proposals')}</>},
+    {key: 'stages', plain: 'e stages', render: () => <>{k('e')}{dim(' stages')}</>},
+    {key: 'config', plain: 'c config', render: () => <>{k('c')}{dim(' config')}</>},
+    {key: 'project', plain: 'P switch project', render: () => <>{k('P')}{dim(' switch project')}</>},
+    {key: 'worktrees', plain: 't worktrees', render: () => <>{k('t')}{dim(' worktrees')}</>},
+    {key: 'back', plain: 'q back', render: () => <>{k('q')}{dim(' back')}</>},
+  ];
+}
+
+// Greedy packing: fill each row up to `maxWidth`, separated by CHUNK_SEP.
+// Chunks are atomic — never split mid-label. Exported for the colHeight
+// calc (so the board reserves the right number of rows) and for the
+// Footer's own render pass.
+export function packFooterChunks(chunks: FooterChunk[], maxWidth: number): FooterChunk[][] {
+  const rows: FooterChunk[][] = [];
+  let cur: FooterChunk[] = [];
+  let curWidth = 0;
+  for (const ch of chunks) {
+    const sep = cur.length > 0 ? CHUNK_SEP.length : 0;
+    const next = curWidth + sep + ch.plain.length;
+    if (next > maxWidth && cur.length > 0) {
+      rows.push(cur);
+      cur = [ch];
+      curWidth = ch.plain.length;
+    } else {
+      cur.push(ch);
+      curWidth = next;
+    }
+  }
+  if (cur.length > 0) rows.push(cur);
+  return rows;
+}
+
+const Footer = React.memo(function Footer({termCols, hasSession, hasWorktree, hasItem, inactive}: {termCols: number; hasSession: boolean; hasWorktree: boolean; hasItem: boolean; inactive: boolean}) {
+  const chunks = buildFooterChunks();
+  const state: FooterState = {hasSession, hasWorktree, hasItem, inactive};
+  // -2 for the wrapping Box's paddingX={1}; floor at 20 so degenerate widths
+  // still pack one-chunk-per-row instead of dividing by zero.
+  const rows = packFooterChunks(chunks, Math.max(20, termCols - 2));
   return (
-    <Box>
-      <Text dimColor>nav </Text>
-      <Text color="magenta">←/→</Text>
-      <Text dimColor> cols </Text>
-      <Text color="magenta">↑/↓</Text>
-      <Text dimColor> items</Text>
-      {sep}
-      <Text color="magenta">↵</Text>
-      <Text dimColor> open</Text>
-      {hasItem && (
-        <>
-          <Text>  </Text>
-          <Text color={hasSession ? 'yellow' : 'magenta'} bold={hasSession}>a</Text>
-          <Text color={hasSession ? 'yellow' : undefined} dimColor={!hasSession}> attach</Text>
-        </>
-      )}
-      {hasWorktree && (
-        <>
-          {sep}
-          <Text color="magenta">s</Text>
-          <Text dimColor> shell</Text>
-          <Text>  </Text>
-          <Text color="magenta">x</Text>
-          <Text dimColor> run</Text>
-          <Text>  </Text>
-          <Text color="magenta">d</Text>
-          <Text dimColor> diff</Text>
-        </>
-      )}
-      {hasItem && (
-        <>
-          <Text>  </Text>
-          <Text dimColor>archi</Text>
-          <Text color="magenta">v</Text>
-          <Text dimColor>e</Text>
-        </>
-      )}
-      {sep}
-      <Text color="magenta">n</Text>
-      <Text dimColor> new</Text>
-      {hasItem && (
-        <>
-          <Text>  </Text>
-          <Text color="magenta">i</Text>
-          <Text dimColor>{inactive ? ' activate' : ' inactive'}</Text>
-        </>
-      )}
-      {sep}
-      <Text color="magenta">p</Text>
-      <Text dimColor> proposals</Text>
-      <Text>  </Text>
-      <Text color="magenta">e</Text>
-      <Text dimColor> stages</Text>
-      <Text>  </Text>
-      <Text color="magenta">c</Text>
-      <Text dimColor> config</Text>
-      <Text>  </Text>
-      <Text color="magenta">P</Text>
-      <Text dimColor> switch project</Text>
-      <Text>  </Text>
-      <Text color="magenta">t</Text>
-      <Text dimColor> worktrees</Text>
-      <Text>  </Text>
-      <Text color="magenta">q</Text>
-      <Text dimColor> back</Text>
+    <Box flexDirection="column">
+      {rows.map((row, ri) => (
+        <Box key={ri}>
+          {row.map((ch, ci) => (
+            <React.Fragment key={ch.key}>
+              {ci > 0 && <Text dimColor>{CHUNK_SEP}</Text>}
+              {ch.render(state)}
+            </React.Fragment>
+          ))}
+        </Box>
+      ))}
     </Box>
   );
 });
diff --git a/tests/e2e/terminal/tracker-board-size.test.mjs b/tests/e2e/terminal/tracker-board-size.test.mjs
index fc80446..5f9f197 100644
--- a/tests/e2e/terminal/tracker-board-size.test.mjs
+++ b/tests/e2e/terminal/tracker-board-size.test.mjs
@@ -38,7 +38,7 @@ function makeTmpProject(slugs) {
   return tmpDir;
 }
 
-async function renderBoard({width, height, slugs = {discovery: ['alpha'], requirements: [], implement: [], cleanup: []}}) {
+async function renderBoard({width, height, slugs = {discovery: ['alpha'], requirements: [], implement: [], cleanup: []}, cursorMoves = 0}) {
   process.env.E2E_TTY_ROWS = String(height);
   process.env.E2E_TTY_COLS = String(width);
 
@@ -78,6 +78,14 @@ async function renderBoard({width, height, slugs = {discovery: ['alpha'], requir
     {timeout: 3000, interval: 30, message: `kanban board visible at ${height}x${width}`}
   );
 
+  // Move the cursor right N times so callers can test how layout responds to
+  // selection. `[C` is the CSI sequence for arrow-right that Ink's input
+  // pipeline reads from stdin.
+  for (let i = 0; i < cursorMoves; i++) {
+    stdin.write('');
+    await new Promise(r => setTimeout(r, 50));
+  }
+
   return {
     frame: () => stripAnsi(stdout.lastFrame() || ''),
     rawFrame: () => stdout.lastFrame() || '',
@@ -124,7 +132,8 @@ for (const [height, width] of SIZE_COMBOS) {
       const lines = text.split('\n');
       // Column borders use ╭ / ╰. The first ╭ marks the top of the column boxes;
       // the last ╰ marks the bottom. Their span is the visible board height.
-      // colHeight = max(5, termRows - 4): 1 title + 1 footer + 1 FullScreen-reserved + 1 margin.
+      // colHeight = max(5, termRows - (3 + footerRows)). At narrow widths the
+      // footer packs to up to 3 rows, so chrome maxes out at 6 rows total.
       const top = lines.findIndex(l => l.includes('╭'));
       let bottom = -1;
       for (let i = lines.length - 1; i >= 0; i--) {
@@ -132,7 +141,7 @@ for (const [height, width] of SIZE_COMBOS) {
       }
       assert.ok(top !== -1 && bottom > top, `Column boxes not found at ${height}x${width}`);
       const boardSpan = bottom - top + 1;
-      const minSpan = Math.max(5, height - 4);
+      const minSpan = Math.max(5, height - 6);
       assert.ok(
         boardSpan >= minSpan,
         `Board only ${boardSpan} of ${height} rows at ${height}x${width} ` +
@@ -196,6 +205,128 @@ for (const [height, width] of SIZE_COMBOS) {
   });
 }
 
+// Footer hint chunks — the canonical list of atomic chunks the footer renders.
+// If a rendered footer row contains text outside this set (after stripping
+// separators), packing has split a chunk mid-word, which is the bug we're
+// guarding against.
+const FOOTER_CHUNKS = [
+  'nav ←/→ cols ↑/↓ items',
+  '↵ open',
+  'a attach',
+  's shell',
+  'x run',
+  'd diff',
+  'archive',
+  'n new',
+  'i inactive',
+  'i activate',
+  'p proposals',
+  'e stages',
+  'c config',
+  'P switch project',
+  't worktrees',
+  'q back',
+];
+
+function extractFooterRows(text) {
+  // The footer lives at the bottom of the frame. Identify rows that look like
+  // hint rows: contain at least one known chunk and don't include box-drawing
+  // chars from the column borders.
+  const lines = text.split('\n');
+  const out = [];
+  for (const raw of lines) {
+    const trimmed = raw.replace(/^\s+|\s+$/g, '');
+    if (!trimmed) continue;
+    if (raw.includes('╭') || raw.includes('╰') || raw.includes('│')) continue;
+    if (raw.includes('tracker') && raw.includes('demo')) continue; // title bar
+    if (FOOTER_CHUNKS.some(c => trimmed.includes(c))) out.push(trimmed);
+  }
+  return out;
+}
+
+const FOOTER_TEST_WIDTHS = [80, 96, 100, 120];
+for (const width of FOOTER_TEST_WIDTHS) {
+  test(`tracker board footer @ ${width}: chunks pack atomically — no mid-word wrap`, async () => {
+    const {frame, cleanup} = await renderBoard({width, height: 22});
+    try {
+      const text = frame();
+      const rows = extractFooterRows(text);
+      assert.ok(rows.length > 0, `No footer rows found at width ${width}. Frame:\n${text}`);
+      for (const row of rows) {
+        // Each row should split cleanly into known chunks on the `  ·  ` separator.
+        const parts = row.split('  ·  ').map(s => s.trim()).filter(Boolean);
+        for (const part of parts) {
+          assert.ok(
+            FOOTER_CHUNKS.includes(part),
+            `Footer row at width ${width} contains unknown chunk "${part}" — likely a mid-word wrap. ` +
+            `Row: ${JSON.stringify(row)}. Known chunks: ${FOOTER_CHUNKS.join(', ')}`
+          );
+        }
+      }
+    } finally { cleanup(); }
+  });
+}
+
+test('tracker board footer: 80x20 frame matches saved fixture', async () => {
+  // Golden frame captured at 80x20 — the canonical narrow-terminal layout.
+  // Regenerate by running the same renderBoard at 80x20 and writing the
+  // populated portion of the frame to the fixture file.
+  const {frame, cleanup} = await renderBoard({width: 80, height: 20});
+  try {
+    const text = frame();
+    const lines = text.split('\n');
+    // Trim trailing blanks so trailing-newline differences don't cause noise.
+    let last = lines.length;
+    while (last > 0 && lines[last - 1].trim() === '') last--;
+    const captured = lines.slice(0, last).join('\n') + '\n';
+
+    const fixturePath = path.join(
+      path.dirname(new URL(import.meta.url).pathname),
+      '../../fixtures/kanban-narrow-footer.txt'
+    );
+    const golden = fs.readFileSync(fixturePath, 'utf8');
+    assert.strictEqual(
+      captured, golden,
+      `Narrow-footer fixture drifted. To update:\n` +
+      `  node -e "process.env.E2E_TTY_COLS=80; process.env.E2E_TTY_ROWS=20; …"\n` +
+      `Captured:\n${captured}\nExpected:\n${golden}`
+    );
+  } finally { cleanup(); }
+});
+
+test('tracker board footer: row count stable when cursor moves between columns', async () => {
+  const width = 100;
+  const height = 22;
+
+  // Render twice, once with the cursor parked on the first (planning) column
+  // and once with it on the implementation column. The footer chunk widths
+  // are fixed regardless of session/worktree state, so the row count must
+  // match — that's what kills the up/down board flicker.
+  const a = await renderBoard({
+    width,
+    height,
+    slugs: {discovery: ['alpha'], requirements: [], implement: ['gamma'], cleanup: []},
+  });
+  let rowsA;
+  try { rowsA = extractFooterRows(a.frame()); } finally { a.cleanup(); }
+
+  const b = await renderBoard({
+    width,
+    height,
+    slugs: {discovery: ['alpha'], requirements: [], implement: ['gamma'], cleanup: []},
+    cursorMoves: 2, // move right twice to land on the Implement column
+  });
+  let rowsB;
+  try { rowsB = extractFooterRows(b.frame()); } finally { b.cleanup(); }
+
+  assert.strictEqual(
+    rowsA.length, rowsB.length,
+    `Footer row count changed when cursor moved (${rowsA.length} -> ${rowsB.length}). ` +
+    `That would shift the board vertically and produce the flicker. ` +
+    `Rows A: ${JSON.stringify(rowsA)}. Rows B: ${JSON.stringify(rowsB)}`
+  );
+});
+
 // Scrolling / overflow — make sure many items in a column fit within its box
 // (bounded by the terminal height) and surface an indicator for off-screen items.
 test('tracker board with many items: column clips and shows scroll indicator', async () => {
diff --git a/tests/fixtures/kanban-narrow-footer.txt b/tests/fixtures/kanban-narrow-footer.txt
new file mode 100644
index 0000000..564a6fa
--- /dev/null
+++ b/tests/fixtures/kanban-narrow-footer.txt
@@ -0,0 +1,18 @@
+ demo  ·  tracker
+╭──────────────────╮╭──────────────────╮╭──────────────────╮╭──────────────────╮
+│Discovery        1││Requirements     0││Implement        0││Cleanup and subm 0│
+│▸   alpha         ││  (empty)         ││  (empty)         ││  (empty)         │
+│  needs           ││                  ││                  ││                  │
+│  requirements…   ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+│                  ││                  ││                  ││                  │
+╰──────────────────╯╰──────────────────╯╰──────────────────╯╰──────────────────╯
+ nav ←/→ cols ↑/↓ items  ·  ↵ open  ·  a attach  ·  s shell  ·  x run
+ d diff  ·  archive  ·  n new  ·  i inactive  ·  p proposals  ·  e stages
+ c config  ·  P switch project  ·  t worktrees  ·  q back
diff --git a/tracker/items/kanban-narrow-bottom-bar/implementation.md b/tracker/items/kanban-narrow-bottom-bar/implementation.md
new file mode 100644
index 0000000..4639be3
--- /dev/null
+++ b/tracker/items/kanban-narrow-bottom-bar/implementation.md
@@ -0,0 +1,68 @@
+# Implementation — kanban-narrow-bottom-bar
+
+## What was built
+Refactored the kanban-board footer in `src/screens/TrackerBoardScreen.tsx`
+to render every key-hint as an atomic chunk, pack them deterministically into
+rows by `termCols`, and reserve the resulting row count in the board's column
+height budget.
+
+## Key changes
+
+### `src/screens/TrackerBoardScreen.tsx`
+- Added `FooterChunk` / `FooterState` types and `buildFooterChunks()` — every
+  hint is a single styled `<Text>` element with a `plain` width used for
+  packing decisions. The chunk list is structurally constant; only colour /
+  dim treatment changes with selection state, so packed row count is
+  selection-independent (kills the up/down flicker).
+- Added `packFooterChunks(chunks, maxWidth)` — greedy packer that fills rows
+  separated by `  ·  ` (two-space-bullet-two-space) without splitting any
+  chunk mid-label. Exported so the colHeight calc can call it.
+- Rebuilt `<Footer>` to take `termCols`, build the chunks, pack them, and
+  render each row as a sibling `<Box>` inside a `flexDirection="column"`.
+  When unavailable (no item/worktree/session), chunks render dimmed instead
+  of disappearing — keeps width stable.
+- Updated `colHeight` calc: instead of subtracting a hard-coded `1` footer
+  row, it now calls `packFooterChunks` and subtracts the actual row count.
+  Total chrome maxes out at 6 rows (1 title + 3 footer + 1 FullScreen + 1
+  margin).
+
+### `tests/e2e/terminal/tracker-board-size.test.mjs`
+- Added `extractFooterRows()` + a `FOOTER_CHUNKS` allow-list. New per-width
+  tests (80, 96, 100, 120) assert every rendered footer row splits cleanly
+  on `  ·  ` into known chunks — catches any future mid-word wrap.
+- Added a flicker-stability test: render the same width twice, once with
+  cursor in the planning column and once moved over to the implement
+  column; assert footer row count matches.
+- Added a fixture-equality test against
+  `tests/fixtures/kanban-narrow-footer.txt`, the canonical 80×20 frame.
+- Relaxed `column boxes occupy most of the terminal height` minSpan from
+  `height - 4` to `height - 6` to account for footers up to 3 rows.
+- Threaded an optional `cursorMoves` arg through `renderBoard()` so tests
+  can drive selection via right-arrow keystrokes.
+
+### `tests/fixtures/kanban-narrow-footer.txt`
+New golden ASCII frame captured at 80×20 — what reviewers visually compare
+when this layout changes.
+
+## Decisions / trade-offs
+- **Consistent `  ·  ` separator everywhere.** The old footer mixed
+  `<Text>  </Text>` (2 spaces) between some hint groups and `  ·  `
+  between others. The packing logic is much simpler with one separator, and
+  the visual rhythm is cleaner. Cost: at very wide terminals (≥160 cols),
+  the footer now wraps to 2 rows where the old version sometimes fit on 1.
+  Acceptable — narrow-terminal correctness wins.
+- **Always render every chunk (dimmed when unavailable).** Variant — hide
+  chunks when N/A — would have kept the footer shorter at wide terminals
+  but reintroduced the flicker. Confirmed with user before implementing.
+- **Inactive label kept at fixed width.** Both `i inactive` and
+  `i activate` are 10 chars, so toggling `i` doesn't shift packing. Good
+  luck.
+
+## Notes for cleanup
+- Verified all 79 kanban-board-size tests pass; full jest suite (815 tests)
+  passes. 10 pre-existing failures in `mainview-row-visibility.test.mjs`
+  exist on the branch base too — unrelated to this work.
+- The `_render-board.mjs` helper I used during discovery has been deleted;
+  the proper assertions now live in `tracker-board-size.test.mjs`.
+- Branch: `kanban-narrow-bottom-bar` (worktree at
+  `/home/mserv/projects/devteam-branches/kanban-narrow-bottom-bar/`).
diff --git a/tracker/items/kanban-narrow-bottom-bar/notes.md b/tracker/items/kanban-narrow-bottom-bar/notes.md
new file mode 100644
index 0000000..6af690a
--- /dev/null
+++ b/tracker/items/kanban-narrow-bottom-bar/notes.md
@@ -0,0 +1,62 @@
+# Discovery — kanban-narrow-bottom-bar
+
+## Problem
+At narrow terminal widths (~80–120 cols) the kanban view's bottom-bar key-hints
+overflow and Ink wraps the row by character: hints like `nav`, `←/→`, `cols`
+end up split across two rows as `na`, `←/→`, `col` etc., producing a ragged,
+unreadable footer. The page also "flickers" up/down as the user moves the
+cursor between items.
+
+## Findings
+
+### Where the footer lives
+`src/screens/TrackerBoardScreen.tsx`, `Footer` component (lines 962–1032).
+It renders as a single flex-row `<Box>` containing ~30 small `<Text>` children.
+
+### Why it wraps so ugly
+Ink/Yoga lays the row out as a normal row of inline elements. When the row
+exceeds `termCols`, each child `<Text>` wraps independently. Because the
+hints are split across many tiny `<Text>`s (so we can colour the key letter
+separately from its label), the wrap happens *between* and even *within*
+the small `<Text>` elements — letters split mid-word, separators end up on
+the wrong line.
+
+### Why it flickers
+`Footer` re-renders conditionally based on the *selected* item:
+
+- `hasItem`     adds the `a attach`, archive, and `i inactive/activate` chunks.
+- `hasSession`  changes the colour and bolding of `a`.
+- `hasWorktree` adds the `s shell · x run · d diff` chunk.
+
+As the user moves selection between items with/without a worktree or session,
+the footer's total width changes by ~25 cols. That pushes its wrap from
+1 row to 2 (or 2 to 3), the board's `colHeight` budget doesn't account for
+the wrapped row, and the whole frame shifts up/down — visible as a flicker.
+
+### Vertical budget today (`TrackerBoardScreen.tsx:701`)
+`colHeight = max(5, termRows - (4 + footerStatusRow))`. The `4` reserves
+exactly one row for the footer. There's no notion of "the footer might wrap"
+in this calc.
+
+### Existing terminal test
+`tests/e2e/terminal/tracker-board-size.test.mjs` already iterates a matrix
+of `[height × width]` combos and asserts column-title alignment, max width,
+and max height. It does **not** assert footer behaviour. Reused as the
+home for new assertions.
+
+## Recommendation
+Two-part fix in `TrackerBoardScreen.tsx`:
+
+1. **Deterministic footer packing.** Rebuild `Footer` so each logical hint
+   ("nav / cols", "↵ open", "a attach", "s shell · x run · d diff", …) is
+   a single atomic `<Text>` element. Pack them into rows by measuring their
+   plain-text widths against `termCols`. Always render every hint (greyed
+   out when unavailable) so footer width is **independent of selection** —
+   removes the flicker.
+
+2. **Reserve the wrapped footer's vertical budget.** Compute `footerRows`
+   from the same packing pass and subtract it from `colHeight`. Then the
+   board never overshoots the terminal.
+
+Add terminal-test assertions for footer-row count + ASCII screenshot
+fixture for visual review.
diff --git a/tracker/items/kanban-narrow-bottom-bar/requirements.md b/tracker/items/kanban-narrow-bottom-bar/requirements.md
new file mode 100644
index 0000000..14df611
--- /dev/null
+++ b/tracker/items/kanban-narrow-bottom-bar/requirements.md
@@ -0,0 +1,64 @@
+# Requirements — kanban-narrow-bottom-bar
+
+## Problem
+At narrow terminal widths (~80–120 cols) the kanban view's bottom-bar key-hints
+overflow and Ink wraps the row by character: hints like `nav`, `←/→`, `cols`
+end up split across two rows as `na`, `←/→`, `col` etc., producing a ragged,
+unreadable footer. The page also "flickers" up/down as the user moves the
+cursor between items.
+
+## Why
+Two coupled issues, both in `src/screens/TrackerBoardScreen.tsx`:
+
+1. **In-word wrap.** The `Footer` renders as ~30 individual `<Text>` children
+   in a single flex row. When the row exceeds `termCols`, Ink/Yoga wraps each
+   `<Text>` independently — splitting hint labels mid-character.
+2. **Footer width depends on selection.** `hasItem`, `hasSession`, and
+   `hasWorktree` toggle whole hint chunks on/off as the cursor moves, so the
+   footer's total width — and therefore the wrap-induced row count — changes
+   per item. The board's `colHeight` budget (`termRows - 4`) reserves exactly
+   one row for the footer, so any extra row pushes the rendered frame off the
+   bottom of the terminal, causing the visible up/down flicker.
+
+## Summary
+Rebuild the kanban footer to render every key-hint chunk unconditionally
+(greyed when unavailable so footer width is independent of selection), then
+deterministically pack the chunks into rows that fit `termCols`. Subtract
+the resulting `footerRows` from the column-height budget so the wrapped
+footer never overflows the terminal. Cover the fix with a terminal
+rendering test plus a saved ASCII fixture for human review.
+
+## Acceptance criteria
+
+### Footer rendering
+1. The footer renders every key-hint chunk on every frame, regardless of
+   whether the currently-selected item has a session, worktree, or even
+   exists. Chunks for currently-unavailable actions render in a dim/gray
+   style; chunks for the active "attach" state still highlight in yellow
+   when a session is running.
+2. Hint chunks (e.g. `nav ←/→ cols ↑/↓ items`, `↵ open`, `a attach`,
+   `s shell · x run · d diff`, `v archive`, `n new`, `i inactive`,
+   `p proposals`, `e stages`, `c config`, `P switch project`,
+   `t worktrees`, `q back`) are atomic — no chunk is ever split across
+   two rows.
+3. Chunks pack greedily into rows of width ≤ `termCols`, separated by
+   `  ·  ` (two-space-bullet-two-space) within a row.
+
+### Layout stability
+4. Footer row count depends only on `termCols`, not on the currently-
+   selected item. Moving the cursor between an item with a worktree and
+   one without (or between any two items) does not change the rendered
+   row count or shift the board vertically.
+5. The board's column-height calculation subtracts the dynamic
+   `footerRows` (in addition to the existing chrome rows). Total rendered
+   output fits within `termRows` for every size in the existing
+   `SIZE_COMBOS` matrix in `tests/e2e/terminal/tracker-board-size.test.mjs`.
+
+### Tests + fixture
+6. A new terminal test in `tracker-board-size.test.mjs` (or a sibling file)
+   asserts: (a) the footer never wraps mid-chunk at width 80, 96, 100, 120;
+   (b) the footer's row count is stable across cursor moves; (c) the full
+   rendered frame fits within `termRows` at width 80 × height 18.
+7. A golden ASCII fixture under `tests/fixtures/kanban-narrow-footer.txt`
+   captures the rendered frame at one narrow size (e.g. 80 × 20) for
+   visual review and regression catching.