From 28a7e9a8aaddb4d1fdbec56fec66374ce26bd0d2 Mon Sep 17 00:00:00 2001
From: Michael Gilardi <11632652+mgilardi@users.noreply.github.com>
Date: Mon, 9 Nov 2026 17:41:33 -0700
Subject: [PATCH] Add an Impact view next to List and Markdown

The owner asked for project buckets ordered by impact and effort, top
five each, without losing the current view. One bucket per category;
effort comes from the size estimates and impact is a plain field on the
item's line (impact:high, or impact:high* when the user set it). A Focus
column holds each category's top item. Finishing an item leaves it in
place and the next joins only when asked. Dragging reorders the view
only, or moves an item to another category. The phone note hides the
new field. Decisions are in docs/DECISIONS.md.

Tested: 37 unit tests, 134 engine tests, ci-checks.sh and the e2e run
(81 checks, 21 of them for this view) pass locally. Not built: Claude
rating unrated items during /morning and /weekly, which needs the
owner's yes for the RULES.md change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CwdHcRvts6qgU3EZBfNtvY
---
 CHANGELOG.md                   |   4 +
 apps/desktop/e2e/ui.mjs        |  46 +++++++
 apps/desktop/src/App.tsx       |  26 ++--
 apps/desktop/src/ImpactUI.tsx  | 219 +++++++++++++++++++++++++++++++++
 apps/desktop/src/ListUI.tsx    |   4 +
 apps/desktop/src/app.css       |  18 +++
 apps/desktop/src/focus.test.ts | 119 ++++++++++++++++++
 apps/desktop/src/focus.ts      | 131 ++++++++++++++++++++
 apps/desktop/src/master.ts     |  33 ++++-
 apps/desktop/tsconfig.json     |   1 +
 docs/DECISIONS.md              |   1 +
 docs/test-audit.md             |  15 +++
 engine/tools/notes.py          |   2 +-
 tests/test_engine.py           |   4 +-
 14 files changed, 611 insertions(+), 12 deletions(-)
 create mode 100644 apps/desktop/src/ImpactUI.tsx
 create mode 100644 apps/desktop/src/focus.test.ts
 create mode 100644 apps/desktop/src/focus.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 92556bf..9571092 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## Unreleased
+- **An Impact view in the app, next to List and Markdown.** One bucket per category, each showing its best five: low effort and high impact first, then high/high, low/low and high effort with low impact. Effort comes from the size estimate, and you rate impact with one click. A Focus column holds the top item from each category, most imperative first. Something you finish there stays in place, marked completed, and the next one joins only when you ask. Drag to reorder a bucket, or drag (or use Move…) to put an item in another category. The List view hasn't changed.
+- **Other tools can hand Theseus items for your yes.** `engine/tools/intake.py` reads what they leave in `data/intake/`; nothing joins your list until you accept it.
+
 ## 0.6.1
 - **Fewer calls to connected services.** ClickUp's connector allows 100 calls a day, and syncing every 15 minutes used most of them. Connected services are now read at set times (`reread_times`), plus the morning and nightly runs, and a ClickUp read takes two calls.
 - **A first wall display.** `theseus wall setup <host>` puts your list on a TV or monitor from a Raspberry Pi, grouped by category, with no Claude. Your Mac sends only what the screen's views use, and never messages, email or your Today note. Task titles stay off until you choose, and `theseus wall hours 6am 12am` sets when the screen is on. It hasn't run on a real Pi yet.
diff --git a/apps/desktop/e2e/ui.mjs b/apps/desktop/e2e/ui.mjs
index ffdd538..af04f4b 100644
--- a/apps/desktop/e2e/ui.mjs
+++ b/apps/desktop/e2e/ui.mjs
@@ -115,5 +115,51 @@ st.engine_version='0.4.0';await sleep(3300);ok('warns when the engine is out of
 await p.click('nav button:has-text("Activity")');await p.waitForSelector('text=Sam Rivera');ok('Activity lists thread notes with both marks',await p.isVisible('text=checked 2026-11-05 10:00:00'));await p.click('button:has-text("Sam Rivera")');await p.waitForSelector('text=Short replies.');ok('a thread note opens',await p.isVisible('text=Short replies.'));
 await p.click('nav button:has-text("Setup")');await p.click('button:has-text("Commands")');await p.waitForSelector('text=THESEUS COMMANDS');ok('Setup shows the command list',await p.isVisible('text=THESEUS COMMANDS'));
 await sleep(100);ok('still no page errors',errs.length===0);if(errs.length)console.log(errs.slice(0,3));
+// the impact view ------------------------------------------------------------
+{const IMPACT=`# ★ Master List
+
+## 🔥 NOW
+- [ ] Big important · #Biz · ~3h · impact:high · id:t1
+- [ ] Quick important · #Biz · ~15m · impact:high · id:t2
+- [ ] Quick minor · #Biz · ~10m · impact:low · id:t3
+- [ ] Unrated · #Biz · id:t4
+- [ ] Home thing · #Home · due 11/4 · ~20m · impact:low · id:t5
+
+## ⏭ NEXT
+- [ ] Big minor · #Biz · ~2h · impact:low · id:t7
+- [ ] Biz six · #Biz · ~15m · id:t8
+- [ ] Biz seven · #Biz · ~15m · id:t9
+- [ ] Biz eight · #Biz · ~15m · id:t13
+- [ ] Biz nine · #Biz · ~15m · id:t14
+- [ ] Home two · #Home · ~1h · id:t10
+
+## ⏳ WAITING ON
+- [ ] Waiting thing · #Biz · impact:high · id:t12
+
+## ✅ DONE
+`;
+ await p.evaluate(()=>localStorage.clear());file=IMPACT;await sleep(3400);
+ await p.click('nav >> text=List');await p.click('.segmented >> text=Impact');await p.waitForSelector('.impact-board');
+ const bucket=(c)=>p.locator('[data-drop-group="impact:'+c+'"]');const titles=async(c)=>(await bucket(c).locator('.task-title').allInnerTexts());
+ ok('impact: a bucket per category, five at most, easiest wins first',JSON.stringify(await titles('Biz'))===JSON.stringify(['Quick important','Big important','Quick minor','Big minor','Biz six']));
+ ok('impact: waiting items are left out',!(await p.locator('.impact-board').innerText()).includes('Waiting thing'));
+ ok('impact: focus holds each bucket\'s top item',JSON.stringify(await p.locator('.impact-focus .task-title').allInnerTexts())===JSON.stringify(['Quick important','Home thing']));
+ ok('impact: opening the view changes nothing',file===IMPACT);
+ await p.screenshot({path:OUT+'/impact.png'});
+ await bucket('Biz').locator('[data-drag-id="t8"] .impact button:has-text("High")').click();await sleep(700);ok('impact: one click rates it and marks it yours',file.includes('- [ ] Biz six · #Biz · ~15m · impact:high* · id:t8'));
+ await bucket('Biz').locator('[data-drag-id="t8"] .impact button:has-text("High")').click();await sleep(700);ok('impact: clicking your rating again takes it off',file.includes('- [ ] Biz six · #Biz · ~15m · id:t8'));
+ {const before=file;await bucket('Biz').locator('[data-drag-id="t1"] select.move-to').selectOption('up');await sleep(500);ok('impact: Move up reorders the bucket',(await titles('Biz'))[0]==='Big important');ok('impact: and leaves the list file alone',file===before);
+  await bucket('Biz').locator('button:has-text("Reset order")').click();await sleep(300);ok('impact: reset goes back to impact order',(await titles('Biz'))[0]==='Quick important');}
+ {const before=file;await drag('Biz six',bucket('Biz').locator('[data-drag-id="t2"]'));await sleep(500);ok('impact: drag within a bucket reorders the view only',(await titles('Biz'))[0]==='Biz six'&&file===before);await bucket('Biz').locator('button:has-text("Reset order")').click();await sleep(300);}
+ await bucket('Biz').locator('[data-drag-id="t3"] select.move-to').selectOption('Home');await sleep(700);ok('impact: Move to project changes the category',file.includes('- [ ] Quick minor · #Home · ~10m · impact:low · id:t3'));ok('impact: and it shows in that bucket',(await titles('Home')).includes('Quick minor'));
+ await drag('Big minor',bucket('Home').locator('[data-drag-id="t5"]'));await sleep(700);ok('impact: dragging to another bucket changes the category',file.includes('- [ ] Big minor · #Home · ~2h · impact:low · id:t7'));
+ await bucket('Biz').locator('[data-drag-id="t1"] .check').click();await sleep(3900);ok('impact: checked off goes to Done in the file',/- \[x\] Big important · #Biz[^\n]*done \d+\/\d+/.test(file));
+ ok('impact: it stays in its place, marked completed',(await titles('Biz'))[1]==='Big important'&&await bucket('Biz').locator('text=Completed').isVisible());
+ ok('impact: the next one waits to be asked for',(await titles('Biz')).length===5&&await bucket('Biz').locator('text=Add the next one?').isVisible());
+ await p.screenshot({path:OUT+'/impact-completed.png'});
+ await bucket('Biz').locator('.impact-next button:has-text("Add")').click();await sleep(300);ok('impact: Add puts it at the bottom',(await titles('Biz')).length===6&&!(await bucket('Biz').locator('text=Add the next one?').isVisible()));
+ await bucket('Biz').locator('.is-done .check').click();await sleep(700);ok('impact: unchecking reopens it',/- \[ \] Big important · #Biz/.test(file));
+ await p.click('.segmented >> text=List');await p.waitForSelector('[data-drag-id="t2"]');ok('impact: the List view is still there',await p.isVisible('[data-drag-id="t2"]'));ok('impact: ratings show as a chip there',await p.locator('[data-drag-id="t2"] .chip-impact').isVisible());
+ await sleep(100);ok('impact: no page errors',errs.length===0);if(errs.length)console.log(errs.slice(0,3));}
 await b.close();srv.close();
 
diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index fefa964..8c310fd 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -1,6 +1,7 @@
 import { invoke } from '@tauri-apps/api/core'
 import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
+import { ImpactView } from './ImpactUI'
 import { inlineParts } from './inline'
 import { Block, ListTools, useListActions, type ListActions } from './ListUI'
 import { commsSection, dropEmoji, nowSection } from './master'
@@ -139,13 +140,16 @@ export default function App() {
   )
 }
 
+type ListView = 'list' | 'impact' | 'markdown'
+
 function ListPage({ m, a }: { m: Master; a: ListActions }) {
-  const [raw, setRaw] = useState(() => {
-    try { return localStorage.getItem('theseus.listView') === 'markdown' } catch { return false }
+  const [view, setView] = useState<ListView>(() => {
+    try { const v = localStorage.getItem('theseus.listView'); return v === 'markdown' || v === 'impact' ? v : 'list' } catch { return 'list' }
   })
-  const choose = (v: boolean) => {
-    setRaw(v)
-    try { localStorage.setItem('theseus.listView', v ? 'markdown' : 'list') } catch { /* it's only a convenience */ }
+  const raw = view === 'markdown'
+  const choose = (v: ListView) => {
+    setView(v)
+    try { localStorage.setItem('theseus.listView', v) } catch { /* it's only a convenience */ }
   }
   const closedAtFirst = new Set(['eventually', 'done', 'projects', 'figure out'])
   return (
@@ -153,12 +157,15 @@ function ListPage({ m, a }: { m: Master; a: ListActions }) {
       <div className="head">
         <div className="grow">
           <h1>List</h1>
-          <div className="sub">Drag to reorder. Double-click to rename. Everything saves as you go.</div>
+          <div className="sub">{view === 'impact'
+            ? 'Each project’s top five, easiest wins first. Rate impact with one click; effort comes from the size estimate.'
+            : 'Drag to reorder. Double-click to rename. Everything saves as you go.'}</div>
         </div>
         <ListTools m={m} />
         <div className="segmented" role="group" aria-label="View">
-          <button aria-pressed={!raw} onClick={() => choose(false)}><Icon name="list" />List</button>
-          <button aria-pressed={raw} onClick={() => choose(true)}><Icon name="code" />Markdown</button>
+          <button aria-pressed={view === 'list'} onClick={() => choose('list')}><Icon name="list" />List</button>
+          <button aria-pressed={view === 'impact'} onClick={() => choose('impact')}><Icon name="sparkle" />Impact</button>
+          <button aria-pressed={raw} onClick={() => choose('markdown')}><Icon name="code" />Markdown</button>
         </div>
       </div>
       {m.notice && <div className="notice"><Icon name="info" /><div className="grow">{m.notice}</div><button className="btn quiet icon" style={{ height: 22, width: 22 }} aria-label="Dismiss" onClick={m.clearNotice}><Icon name="close" size={14} /></button></div>}
@@ -166,7 +173,8 @@ function ListPage({ m, a }: { m: Master; a: ListActions }) {
       {raw && m.text !== null && (
         <textarea className="md-editor" spellCheck={false} aria-label="Master list as Markdown" value={m.text} onChange={(e) => m.type(e.target.value)} />
       )}
-      {!raw && m.doc?.sections.map((s) => <Block key={s.key} section={s} m={m} a={a} collapsible defaultOpen={!closedAtFirst.has(s.key)} />)}
+      {view === 'impact' && m.text && <ImpactView m={m} a={a} />}
+      {view === 'list' && m.doc?.sections.map((s) => <Block key={s.key} section={s} m={m} a={a} collapsible defaultOpen={!closedAtFirst.has(s.key)} />)}
     </div>
   )
 }
diff --git a/apps/desktop/src/ImpactUI.tsx b/apps/desktop/src/ImpactUI.tsx
new file mode 100644
index 0000000..4bde413
--- /dev/null
+++ b/apps/desktop/src/ImpactUI.tsx
@@ -0,0 +1,219 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+import { buckets, type Candidate, dayKey, type DayState, focus, freshDay, NO_CATEGORY, slots, type Level } from './focus'
+import type { ListActions } from './ListUI'
+import { dropEmoji, findItem, type Item, setCategory, setImpact } from './master'
+import { Icon } from './ui/Icon'
+import { startRowDrag } from './ui/useDrag'
+import type { Master } from './useMaster'
+
+/** Small view settings that only this window needs. Nothing here is the list itself, which stays in data/master.md. */
+function useStored<T>(key: string, initial: T) {
+  const [v, setV] = useState<T>(() => {
+    try { const s = localStorage.getItem(key); return s ? (JSON.parse(s) as T) : initial } catch { return initial }
+  })
+  const set = useCallback((next: T | ((old: T) => T)) => {
+    setV((old) => {
+      const value = typeof next === 'function' ? (next as (o: T) => T)(old) : next
+      try { localStorage.setItem(key, JSON.stringify(value)) } catch { /* it's only a convenience */ }
+      return value
+    })
+  }, [key])
+  return [v, set] as const
+}
+
+const GROUP = 'impact:'
+const label = (cat: string) => (cat === NO_CATEGORY ? 'No category' : cat)
+
+function ImpactPicker({ c, m }: { c: Candidate; m: Master }) {
+  const pick = (level: Level) => {
+    // Clicking your own choice again takes it off, so Claude can suggest one again.
+    const next = c.mine && c.impact === level ? null : level
+    m.apply((md) => setImpact(md, c.item.key, next))
+  }
+  const suggested = c.impact !== null && !c.mine
+  return (
+    <span className={`impact ${suggested ? 'suggested' : ''}`} role="group" aria-label={`Impact of ${c.item.title}${suggested ? ', suggested by Claude' : ''}`} data-no-drag>
+      {(['high', 'low'] as const).map((l) => (
+        <button key={l} aria-pressed={c.impact === l} title={suggested && c.impact === l ? 'Suggested by Claude. Click to make it yours.' : c.mine && c.impact === l ? 'Your rating. Click again to take it off.' : `Rate ${l} impact`} onClick={() => pick(l)}>
+          {l === 'high' ? 'High' : 'Low'}
+        </button>
+      ))}
+    </span>
+  )
+}
+
+function Meta({ c }: { c: Candidate }) {
+  const due = c.item.chips.find((x) => x.kind === 'due')
+  const size = c.item.chips.find((x) => x.kind === 'size')
+  return (
+    <span className="impact-meta muted small">
+      {size ? <span title="Effort, from the size estimate">{size.text}{c.effort ? ` · ${c.effort} effort` : ''}</span> : <span title="No size estimate yet, so effort is unknown">effort ?</span>}
+      {due && <span><Icon name="clock" size={11} /> {dropEmoji(due.text)}</span>}
+    </span>
+  )
+}
+
+function OpenRow({ c, at, cat, cats, m, a, onCheck, onMove, inFocus }: {
+  c: Candidate; at: number; cat: string; cats: string[]; m: Master; a: ListActions
+  onCheck: (c: Candidate, at: number) => void; onMove: (c: Candidate, to: string) => void; inFocus?: boolean
+}) {
+  const inGrace = a.waiting.has(c.item.key)
+  return (
+    <div
+      className={`task impact-row ${inGrace ? 'grace' : ''}`}
+      data-drag-id={inFocus ? undefined : c.item.key}
+      onPointerDown={inFocus ? undefined : (e) => startRowDrag(e, c.item.key, dropEmoji(c.item.title), (t) => onMove(c, t.group === `${GROUP}${cat}` ? `before:${t.before ?? ''}` : t.group.slice(GROUP.length)))}
+    >
+      {!inFocus && <span className="grip" aria-hidden="true"><Icon name="grip" size={14} /></span>}
+      <button className={`check ${inGrace ? 'on' : ''}`} role="checkbox" aria-checked={inGrace} aria-label={`${inGrace ? 'Uncheck' : 'Check off'} ${c.item.title}`} onClick={() => onCheck(c, at)}>
+        {inGrace && <Icon name="check" size={12} strokeWidth={2.5} />}
+      </button>
+      <div className="task-body">
+        <div className="task-line">
+          <span className="task-title">{dropEmoji(c.item.title)}</span>
+          {inFocus && <span className="chip chip-category">{label(cat)}</span>}
+        </div>
+        <div className="impact-line">
+          <ImpactPicker c={c} m={m} />
+          <Meta c={c} />
+        </div>
+      </div>
+      {!inFocus && !inGrace && (
+        <select className="move-to" aria-label={`Move ${c.item.title}`} value="" data-no-drag onChange={(e) => { if (e.target.value) onMove(c, e.target.value) }}>
+          <option value="">Move…</option>
+          <option value="up">Up</option>
+          <option value="down">Down</option>
+          <optgroup label="To project">
+            {cats.filter((x) => x !== cat && x !== NO_CATEGORY).map((x) => <option key={x} value={x}>{x}</option>)}
+          </optgroup>
+        </select>
+      )}
+      {inGrace && <button className="btn quiet undo-now" onClick={() => onCheck(c, at)}>Undo</button>}
+    </div>
+  )
+}
+
+function DoneRow({ item, a, onReopen }: { item: Item | null; a: ListActions; onReopen: () => void }) {
+  if (!item) return null
+  return (
+    <div className="task impact-row is-done">
+      <button className="check on" role="checkbox" aria-checked aria-label={`Uncheck ${item.title}`} onClick={() => { onReopen(); a.toggle(item) }}>
+        <Icon name="check" size={12} strokeWidth={2.5} />
+      </button>
+      <div className="task-body">
+        <div className="task-line"><span className="task-title">{dropEmoji(item.title)}</span><span className="chip chip-done"><Icon name="check" size={12} />Completed</span></div>
+      </div>
+    </div>
+  )
+}
+
+/**
+ * Another way to see the same list: one bucket per category, its best five first by impact and effort, and Focus in front with the top
+ * item of every bucket. Checking off, rating impact and moving to another category change data/master.md like everything else in the app.
+ * The order you drag here is this view's own, and doesn't change the List view.
+ */
+export function ImpactView({ m, a }: { m: Master; a: ListActions }) {
+  const [order, setOrder] = useStored<Record<string, string[]>>('theseus.impact.order', {})
+  const [hidden, setHidden] = useStored<string[]>('theseus.impact.hidden', [])
+  const [pinned, setPinned] = useStored<string[]>('theseus.impact.pinned', [])
+  const [day, setDay] = useStored<DayState>('theseus.impact.day', freshDay(new Date()))
+  const [now, setNow] = useState(() => new Date())
+  useEffect(() => { const t = window.setInterval(() => setNow(new Date()), 60_000); return () => window.clearInterval(t) }, [])
+  const today = day.day === dayKey(now) ? day : freshDay(now)
+
+  const all = useMemo(() => (m.doc ? buckets(m.doc, order) : new Map<string, Candidate[]>()), [m.doc, order])
+  const cats = useMemo(() => {
+    const list = [...all.keys()]
+    return [...list.filter((c) => pinned.includes(c)).sort((x, y) => pinned.indexOf(x) - pinned.indexOf(y)), ...list.filter((c) => !pinned.includes(c))]
+  }, [all, pinned])
+  const shown = cats.filter((c) => !hidden.includes(c))
+  const top = useMemo(() => focus(new Map(shown.map((c) => [c, all.get(c)!])), now), [all, shown, now])
+  const find = useCallback((key: string) => (m.doc ? findItem(m.doc, key)?.item ?? null : null), [m.doc])
+
+  const update = (fn: (d: DayState) => DayState) => setDay(() => fn(day.day === dayKey(now) ? day : freshDay(now)))
+  const onCheck = (cat: string) => (c: Candidate, at: number) => {
+    const key = c.item.key
+    if (a.waiting.has(key)) update((d) => ({ ...d, done: { ...d.done, [cat]: (d.done[cat] ?? []).filter((f) => f.key !== key) } }))
+    else update((d) => ({ ...d, done: { ...d.done, [cat]: [...(d.done[cat] ?? []).filter((f) => f.key !== key), { key, at }] } }))
+    a.toggle(c.item)
+  }
+  const onReopen = (cat: string, key: string) => update((d) => ({ ...d, done: { ...d.done, [cat]: (d.done[cat] ?? []).filter((f) => f.key !== key) } }))
+  const addNext = (cat: string) => update((d) => ({ ...d, added: { ...d.added, [cat]: (d.added[cat] ?? 0) + 1 } }))
+
+  const onMove = (cat: string, visible: string[]) => (c: Candidate, to: string) => {
+    const key = c.item.key
+    let next: string[] | null = null
+    const rest = visible.filter((k) => k !== key)
+    if (to === 'up' || to === 'down') {
+      const i = visible.indexOf(key)
+      const j = to === 'up' ? i - 1 : i + 1
+      if (i < 0 || j < 0 || j >= visible.length) return
+      next = [...visible]
+      ;[next[i], next[j]] = [next[j], next[i]]
+    } else if (to.startsWith('before:')) {
+      const before = to.slice(7)
+      const at = before ? rest.indexOf(before) : rest.length
+      next = [...rest.slice(0, at < 0 ? rest.length : at), key, ...rest.slice(at < 0 ? rest.length : at)]
+    } else {
+      // Another bucket: the item's category changes, everywhere.
+      m.apply((md) => setCategory(md, key, to))
+      setOrder((o) => ({ ...o, [cat]: (o[cat] ?? []).filter((k) => k !== key) }))
+      return
+    }
+    setOrder((o) => ({ ...o, [cat]: next! }))
+  }
+
+  if (!m.doc) return null
+  return (
+    <div className="impact-board">
+      <div className="card block impact-focus">
+        <div className="block-head"><Icon name="flame" className="block-icon" /><span className="block-name">Focus</span><span className="muted num small">{top.length}</span></div>
+        <div className="impact-hint muted small">The top item from each project, most imperative first.</div>
+        {top.map((c) => <OpenRow key={c.item.key} c={c} at={0} cat={c.category} cats={cats} m={m} a={a} onCheck={onCheck(c.category)} onMove={() => {}} inFocus />)}
+        {top.length === 0 && <div className="block-empty muted small">Nothing open.</div>}
+      </div>
+      {shown.map((cat) => {
+        const list = all.get(cat)!
+        const openKeys = new Set(list.map((c) => c.item.key))
+        const finished = (today.done[cat] ?? []).filter((f) => !openKeys.has(f.key) && find(f.key)?.done)
+        const { rows, next } = slots(list, finished, Math.min(today.added[cat] ?? 0, finished.length), find)
+        const visible = rows.flatMap((r) => (r.kind === 'open' ? [r.c.item.key] : []))
+        const move = onMove(cat, visible)
+        let at = -1
+        return (
+          <div key={cat} className="card block" data-drop-group={`${GROUP}${cat}`}>
+            <div className="block-head">
+              <Icon name="tag" className="block-icon" />
+              <span className="block-name">{label(cat)}</span>
+              <span className="muted num small">{list.length}</span>
+              <span className="grow" />
+              {order[cat]?.length ? <button className="btn quiet tiny" onClick={() => setOrder((o) => { const n = { ...o }; delete n[cat]; return n })} title="Go back to the impact and effort order">Reset order</button> : null}
+              <button className="btn quiet tiny" aria-pressed={pinned.includes(cat)} onClick={() => setPinned((p) => (p.includes(cat) ? p.filter((x) => x !== cat) : [...p, cat]))}>{pinned.includes(cat) ? 'Unpin' : 'Pin'}</button>
+              <button className="btn quiet tiny" onClick={() => setHidden((h) => [...h, cat])}>Hide</button>
+            </div>
+            {rows.map((r) => {
+              at++
+              return r.kind === 'open'
+                ? <OpenRow key={r.c.item.key} c={r.c} at={at} cat={cat} cats={cats} m={m} a={a} onCheck={onCheck(cat)} onMove={move} />
+                : <DoneRow key={`done:${r.key}`} item={r.item} a={a} onReopen={() => onReopen(cat, r.key)} />
+            })}
+            {next && (
+              <div className="impact-next">
+                <span className="muted small">Add the next one?</span>
+                <span className="grow">{dropEmoji(next.item.title)}</span>
+                <button className="btn tiny" onClick={() => addNext(cat)}>Add</button>
+              </div>
+            )}
+            {list.length > visible.length && <div className="impact-more muted small">{list.length - visible.length} more in {label(cat)}</div>}
+          </div>
+        )
+      })}
+      {hidden.length > 0 && (
+        <div className="impact-hidden muted small">
+          Hidden: {hidden.map((h) => <button key={h} className="btn quiet tiny" onClick={() => setHidden((x) => x.filter((y) => y !== h))}>Show {label(h)}</button>)}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/ListUI.tsx b/apps/desktop/src/ListUI.tsx
index 068dcba..9257df6 100644
--- a/apps/desktop/src/ListUI.tsx
+++ b/apps/desktop/src/ListUI.tsx
@@ -78,6 +78,10 @@ export type ListActions = ReturnType<typeof useListActions>
 function ChipView({ c }: { c: Chip }) {
   const icon: Partial<Record<Chip['kind'], IconName>> = { due: 'clock', reminder: 'bell', repeat: 'repeat', skylight: 'house', link: 'link', done: 'check' }
   const label: Partial<Record<Chip['kind'], string>> = { reminder: 'Has a reminder', skylight: 'On Skylight' }
+  if (c.kind === 'impact') {
+    const mine = c.text.endsWith('*')
+    return <span className="chip chip-impact" title={mine ? 'Your impact rating' : 'Impact suggested by Claude'}>{c.text.replace('*', '')} impact</span>
+  }
   const name = icon[c.kind]
   return (
     <span className={`chip chip-${c.kind}`} title={label[c.kind]}>
diff --git a/apps/desktop/src/app.css b/apps/desktop/src/app.css
index 8aeccea..85c25de 100644
--- a/apps/desktop/src/app.css
+++ b/apps/desktop/src/app.css
@@ -59,3 +59,21 @@
 .segmented button[aria-pressed='true'] { background: var(--accent-soft); color: var(--accent); font-weight: 500; }
 .md-editor { width: 100%; height: calc(100vh - 130px); padding: 14px 16px; border: 1px solid var(--border); border-radius: 10px; background: var(--panel); color: inherit; font: 12.5px/1.6 ui-monospace, Menlo, monospace; resize: none; box-shadow: var(--shadow); user-select: text; -webkit-user-select: text; }
 .column .block-head { padding-bottom: 6px; }
+
+/* The impact view */
+.impact-board { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 14px; align-items: start; }
+.impact-focus { grid-column: 1 / -1; border-color: color-mix(in srgb, var(--accent) 35%, var(--border)); }
+.impact-hint { padding: 0 14px 8px 38px; }
+.impact-line { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 10px; margin-top: 3px; }
+.impact { display: inline-flex; border: 1px solid var(--border); border-radius: 6px; overflow: hidden; }
+.impact button { height: 20px; padding: 0 7px; border: 0; background: none; color: var(--muted); font: inherit; font-size: 11px; cursor: pointer; }
+.impact button[aria-pressed='true'] { background: var(--accent-soft); color: var(--accent); font-weight: 600; }
+.impact.suggested button[aria-pressed='true'] { font-weight: 400; font-style: italic; }
+.impact-meta { display: inline-flex; gap: 8px; align-items: center; }
+.chip-impact { padding: 0 6px; border-radius: 9px; border: 1px dashed var(--border); line-height: 15px; }
+.move-to { flex: none; height: 22px; max-width: 86px; font: inherit; font-size: 11px; color: var(--muted); background: var(--field); border: 1px solid var(--border); border-radius: 6px; }
+.impact-next { display: flex; align-items: center; gap: 8px; padding: 7px 10px 8px 32px; border-top: 1px dashed var(--border); background: var(--accent-soft); }
+.impact-more { padding: 6px 14px 8px 32px; border-top: 1px solid var(--border); }
+.impact-hidden { grid-column: 1 / -1; display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }
+.btn.tiny { height: 22px; padding: 0 8px; font-size: 11px; }
+.impact-row .task-title { user-select: none; -webkit-user-select: none; cursor: inherit; }
diff --git a/apps/desktop/src/focus.test.ts b/apps/desktop/src/focus.test.ts
new file mode 100644
index 0000000..de204c1
--- /dev/null
+++ b/apps/desktop/src/focus.test.ts
@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { buckets, candidates, daysUntil, effortOf, focus, NO_CATEGORY, sizeMinutes, slots, tierOf, TOP } from './focus.ts'
+import { findItem, items, parse, findSection, setCategory, setImpact } from './master.ts'
+
+const MD = `# ★ Master List
+
+## 🔥 NOW
+- [ ] Big important · #Biz · ~3h · impact:high · id:t1
+- [ ] Quick important · #Biz · ~15m · impact:high* · id:t2
+- [ ] Quick minor · #Biz · ~10m · impact:low · id:t3
+- [ ] Unrated · #Biz · id:t4
+- [ ] Home thing · #Home · due 11/4 · ~20m · impact:low · id:t5
+
+## 💬 COMMUNICATIONS
+- [ ] Reply to a friend · #Friends · impact:high · id:t6
+
+## ⏭ NEXT
+- [ ] Big minor · #Biz · ~2h · impact:low · id:t7
+- [ ] Biz six · #Biz · ~15m · id:t8
+- [ ] Biz seven · #Biz · ~15m · id:t9
+- [ ] No category at all · id:t10
+- [ ] Repeating · #Home · ↻ every Monday · done for now 11/2 · id:t11
+
+## ⏳ WAITING ON
+- [ ] Waiting thing · #Biz · impact:high · id:t12
+
+## ✅ DONE
+- [x] Old · #Biz · done 11/1 · id:t13
+`
+const today = new Date(2026, 10, 3)
+const keys = (list: { item: { key: string } }[]) => list.map((c) => c.item.key)
+
+test('sizes become minutes, and half an hour is the line between low and high effort', () => {
+  assert.equal(sizeMinutes('15m'), 15)
+  assert.equal(sizeMinutes('~2h?'), 120)
+  assert.equal(sizeMinutes('1.5h'), 90)
+  assert.equal(sizeMinutes('1d'), 480)
+  assert.equal(sizeMinutes('soon'), null)
+  assert.equal(effortOf(30), 'low')
+  assert.equal(effortOf(45), 'high')
+  assert.equal(effortOf(null), null)
+})
+
+test('the order is low effort/high impact, high/high, low/low, high/low, and unrated last', () => {
+  const order = [tierOf('high', 'low'), tierOf('high', 'high'), tierOf('low', 'low'), tierOf('low', 'high'), tierOf(null, 'low')]
+  assert.deepEqual([...order].sort((a, b) => a - b), order)
+  assert.ok(tierOf('high', null) < tierOf('high', 'high'))
+})
+
+test('waiting, done and done-for-now items are not candidates', () => {
+  const ks = keys(candidates(parse(MD)))
+  for (const k of ['t11', 't12', 't13']) assert.ok(!ks.includes(k), k)
+})
+
+test('a bucket is a category, sorted by impact and effort, then list order', () => {
+  const b = buckets(parse(MD))
+  assert.deepEqual(keys(b.get('Biz')!), ['t2', 't1', 't3', 't7', 't8', 't9', 't4'])
+  assert.deepEqual(keys(b.get(NO_CATEGORY)!), ['t10'])
+  assert.equal([...b.keys()].at(-1), NO_CATEGORY)
+})
+
+test('what the user arranged by dragging comes first, in that order', () => {
+  const b = buckets(parse(MD), { Biz: ['t4', 't3'] })
+  assert.deepEqual(keys(b.get('Biz')!).slice(0, 3), ['t4', 't3', 't2'])
+})
+
+test('the user’s own rating is marked as theirs', () => {
+  const c = candidates(parse(MD))
+  assert.equal(c.find((x) => x.item.key === 't2')!.mine, true)
+  assert.equal(c.find((x) => x.item.key === 't1')!.mine, false)
+})
+
+test('focus takes each bucket’s top item and ranks them: impact, then urgency, then section', () => {
+  const f = focus(buckets(parse(MD)), today)
+  assert.deepEqual(keys(f), ['t2', 't6', 't5', 't10'])
+})
+
+test('due dates count from today, across a new year too', () => {
+  assert.equal(daysUntil('Fri 11/7', today), 4)
+  assert.equal(daysUntil('11/1', today), -2)
+  assert.equal(daysUntil('1/2', new Date(2026, 11, 30)), 3)
+  assert.equal(daysUntil('someday', today), null)
+})
+
+test('a bucket shows five; one finished here stays in place and the next waits to be asked for', () => {
+  const list = buckets(parse(MD)).get('Biz')!
+  const find = () => null
+  let s = slots(list, [], 0, find)
+  assert.equal(s.rows.length, TOP)
+  assert.equal(s.next, null)
+  const rest = list.filter((c) => c.item.key !== 't1')
+  s = slots(rest, [{ key: 't1', at: 1 }], 0, find)
+  assert.deepEqual(s.rows.map((r) => (r.kind === 'done' ? `done:${r.key}` : r.c.item.key)), ['t2', 'done:t1', 't3', 't7', 't8'])
+  assert.equal(s.next?.item.key, 't9')
+  s = slots(rest, [{ key: 't1', at: 1 }], 1, find)
+  assert.deepEqual(s.rows.map((r) => (r.kind === 'done' ? `done:${r.key}` : r.c.item.key)), ['t2', 'done:t1', 't3', 't7', 't8', 't9'])
+  assert.equal(s.next, null)
+})
+
+test('setting impact marks it as the user’s, replaces any old rating, and can be taken off', () => {
+  let md = setImpact(MD, 't1', 'low')
+  const line = findItem(parse(md), 't1')!.item.line
+  assert.match(line, /impact:low\* · id:t1$/)
+  assert.doesNotMatch(line, /impact:high/)
+  md = setImpact(md, 't1', null)
+  assert.doesNotMatch(findItem(parse(md), 't1')!.item.line, /impact:/)
+  assert.equal(setImpact(MD, 'nope', 'high'), MD)
+})
+
+test('moving to another category changes only the category, and adds one if there was none', () => {
+  let md = setCategory(MD, 't3', 'Home')
+  assert.equal(findItem(parse(md), 't3')!.item.line, '- [ ] Quick minor · #Home · ~10m · impact:low · id:t3')
+  assert.deepEqual(items(findSection(parse(md), 'now')).map((i) => i.key), ['t1', 't2', 't3', 't4', 't5'])
+  md = setCategory(md, 't10', '#Biz')
+  assert.equal(findItem(parse(md), 't10')!.item.line, '- [ ] No category at all · #Biz · id:t10')
+  assert.equal(setCategory(MD, 't3', '  '), MD)
+})
diff --git a/apps/desktop/src/focus.ts b/apps/desktop/src/focus.ts
new file mode 100644
index 0000000..755a4b3
--- /dev/null
+++ b/apps/desktop/src/focus.ts
@@ -0,0 +1,131 @@
+/**
+ * The impact view: one bucket per category, best first by impact and effort, and a Focus column with each bucket's top item.
+ * Impact is the item's own `impact:` field. Effort comes from its size estimate (`~15m`), so there's nothing extra to keep up.
+ * Pure functions over the parsed list, so the screen and the tests see the same order.
+ */
+import { type Doc, type Item, isDoneKey, items } from './master.ts'
+
+export type Level = 'high' | 'low' | null
+export type Candidate = { item: Item; section: string; sectionIndex: number; index: number; category: string; impact: Level; mine: boolean; effort: Level; minutes: number | null; tier: number }
+
+export const TOP = 5
+export const NO_CATEGORY = 'Uncategorized'
+const LEFT_OUT = /^(waiting|projects?\b)/
+
+/** Minutes from a size estimate like "15m", "1h", "~2h?", "1.5h" or "1d". null when there's none or it can't be read. */
+export function sizeMinutes(text: string): number | null {
+  const m = text.replace(/^~/, '').match(/^(\d+(?:\.\d+)?)\s*(m|min|mins|h|hr|hrs|d|day|days)\b/i)
+  if (!m) return null
+  const n = Number(m[1])
+  const unit = m[2].toLowerCase()
+  return unit.startsWith('d') ? n * 8 * 60 : unit.startsWith('h') ? n * 60 : n
+}
+
+/** Half an hour or less is low effort. Anything bigger is high. */
+export const effortOf = (minutes: number | null): Level => (minutes === null ? null : minutes <= 30 ? 'low' : 'high')
+
+export function impactOf(it: Item): { impact: Level; mine: boolean } {
+  const chip = it.chips.find((c) => c.kind === 'impact')
+  if (!chip) return { impact: null, mine: false }
+  return { impact: chip.text.startsWith('high') ? 'high' : 'low', mine: chip.text.endsWith('*') }
+}
+
+/**
+ * Low effort and high impact first, then high/high, low/low and high effort/low impact. Rated items come before unrated ones, and an
+ * item missing only its size sits between the two effort levels of its impact.
+ */
+export function tierOf(impact: Level, effort: Level) {
+  const i = impact === 'high' ? 0 : impact === 'low' ? 1 : 2
+  const e = effort === 'low' ? 0 : effort === null ? 1 : 2
+  return i * 3 + e
+}
+
+export const categoryOf = (it: Item) => it.chips.find((c) => c.kind === 'category')?.text ?? NO_CATEGORY
+
+/** Every open item that could be worked on, with what the view needs to rank it. Waiting On, Projects and Done are left out. */
+export function candidates(doc: Doc): Candidate[] {
+  const out: Candidate[] = []
+  let index = 0
+  doc.sections.forEach((s, sectionIndex) => {
+    if (isDoneKey(s.key) || LEFT_OUT.test(s.key)) return
+    for (const item of items(s)) {
+      if (item.done || item.doneForNow) continue
+      const { impact, mine } = impactOf(item)
+      const size = item.chips.find((c) => c.kind === 'size')
+      const minutes = size ? sizeMinutes(size.text) : null
+      const effort = effortOf(minutes)
+      out.push({ item, section: s.key, sectionIndex, index: index++, category: categoryOf(item), impact, mine, effort, minutes, tier: tierOf(impact, effort) })
+    }
+  })
+  return out
+}
+
+/**
+ * Each category's candidates, best first. `order` is what the user arranged by dragging in this view: those keys come first, in that order,
+ * and everything else follows by tier and then by its place in the list.
+ */
+export function buckets(doc: Doc, order: Record<string, string[]> = {}): Map<string, Candidate[]> {
+  const by = new Map<string, Candidate[]>()
+  for (const c of candidates(doc)) {
+    const list = by.get(c.category) ?? []
+    list.push(c)
+    by.set(c.category, list)
+  }
+  for (const [cat, list] of by) {
+    const placed = order[cat] ?? []
+    const at = (c: Candidate) => { const i = placed.indexOf(c.item.key); return i < 0 ? Infinity : i }
+    list.sort((a, b) => at(a) - at(b) || a.tier - b.tier || a.index - b.index)
+  }
+  return new Map([...by].sort(([a, x], [b, y]) => (a === NO_CATEGORY ? 1 : b === NO_CATEGORY ? -1 : x[0].index - y[0].index || a.localeCompare(b))))
+}
+
+/** Days from `today` to a due chip like "Fri 11/7" or "11/14". Past dates are negative. The year is whichever puts it nearest today. */
+export function daysUntil(due: string, today: Date): number | null {
+  const m = due.match(/(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?/)
+  if (!m) return null
+  const start = new Date(today.getFullYear(), today.getMonth(), today.getDate())
+  const day = (y: number) => Math.round((new Date(y, Number(m[1]) - 1, Number(m[2])).getTime() - start.getTime()) / 86_400_000)
+  if (m[3]) return day(m[3].length === 2 ? 2000 + Number(m[3]) : Number(m[3]))
+  const y = today.getFullYear()
+  return [day(y - 1), day(y), day(y + 1)].reduce((a, b) => (Math.abs(b) < Math.abs(a) ? b : a))
+}
+
+/** Overdue or due within 2 days, then within a week, then anything later or undated. */
+export function urgencyOf(c: Candidate, today: Date) {
+  const due = c.item.chips.find((x) => x.kind === 'due')
+  const d = due ? daysUntil(due.text, today) : null
+  return d === null ? 2 : d <= 2 ? 0 : d <= 7 ? 1 : 2
+}
+
+/**
+ * Focus: the top item of every bucket, ranked against each other. High impact comes first, then what can't wait (urgency), then where
+ * the list already puts it (Now before Next), then the smaller job, then list order. Low and unrated impact count the same here, so an
+ * unrated item never jumps ahead of something known and due tomorrow.
+ */
+export function focus(all: Map<string, Candidate[]>, today: Date): Candidate[] {
+  const imp = (c: Candidate) => (c.impact === 'high' ? 0 : 1)
+  const eff = (c: Candidate) => (c.effort === 'low' ? 0 : c.effort === null ? 1 : 2)
+  return [...all.values()].map((list) => list[0]).filter(Boolean)
+    .sort((a, b) => imp(a) - imp(b) || urgencyOf(a, today) - urgencyOf(b, today) || a.sectionIndex - b.sectionIndex || eff(a) - eff(b) || a.index - b.index)
+}
+
+/** What the view remembers for one day: items finished here, and where they were, and how many replacements were asked for. */
+export type DayState = { day: string; done: Record<string, { key: string; at: number }[]>; added: Record<string, number> }
+export const dayKey = (d: Date) => `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`
+export const freshDay = (d: Date): DayState => ({ day: dayKey(d), done: {}, added: {} })
+
+export type Slot = { kind: 'open'; c: Candidate } | { kind: 'done'; key: string; item: Item | null }
+
+/**
+ * The rows a bucket shows today. Finishing an item here leaves it in its place, marked done, and doesn't pull the next one up by itself.
+ * The user asks for a replacement ("Add the next one?"), and it joins at the bottom. Items finished elsewhere just drop out and
+ * the next one moves up, because nothing here was promised about them.
+ */
+export function slots(list: Candidate[], finished: { key: string; at: number }[], added: number, find: (key: string) => Item | null) {
+  const room = Math.max(0, TOP - finished.length + added)
+  const open = list.slice(0, room)
+  const rows: Slot[] = open.map((c) => ({ kind: 'open', c }))
+  for (const f of [...finished].sort((a, b) => a.at - b.at)) rows.splice(Math.min(f.at, rows.length), 0, { kind: 'done', key: f.key, item: find(f.key) })
+  const next = finished.length > added ? list[room] ?? null : null
+  return { rows, next }
+}
diff --git a/apps/desktop/src/master.ts b/apps/desktop/src/master.ts
index 9fa20c4..1855ef8 100644
--- a/apps/desktop/src/master.ts
+++ b/apps/desktop/src/master.ts
@@ -2,7 +2,7 @@
  * The master list, data/master.md, as data. Every change in the app is a pure function from text to text, so the list view, the
  * Markdown view and undo all work on the same thing, and lines the app doesn't understand stay exactly as they were.
  */
-export type Chip = { kind: 'category' | 'due' | 'size' | 'reminder' | 'repeat' | 'skylight' | 'link' | 'done' | 'note'; text: string }
+export type Chip = { kind: 'category' | 'due' | 'size' | 'impact' | 'reminder' | 'repeat' | 'skylight' | 'link' | 'done' | 'note'; text: string }
 export type Item = { kind: 'item'; key: string; done: boolean; title: string; id: string | null; chips: Chip[]; repeating: boolean; doneForNow: boolean; line: string; children: string[] }
 export type TextBlock = { kind: 'text'; line: string }
 export type Section = { key: string; heading: string; title: string; blocks: (Item | TextBlock)[] }
@@ -10,6 +10,7 @@ export type Doc = { head: string[]; sections: Section[] }
 
 const ITEM = /^- \[( |x|X)\] (.*)$/
 const SEP = ' · '
+const IMPACT = /^impact:(high|low)\*?$/
 
 /** Section title without its leading emoji or its ": explanation". */
 export function sectionTitle(heading: string) {
@@ -29,6 +30,7 @@ function chipsOf(parts: string[]): { chips: Chip[]; id: string | null; doneForNo
     else if (seg.startsWith('#')) chips.push({ kind: 'category', text: seg.slice(1) })
     else if (/^due\b/.test(seg)) chips.push({ kind: 'due', text: seg.slice(3).trim() })
     else if (/^~\d/.test(seg)) chips.push({ kind: 'size', text: seg.slice(1) })
+    else if (IMPACT.test(seg)) chips.push({ kind: 'impact', text: seg.slice(7) }) // "high", or "high*" when the user set it
     else if (/^done for now\b/.test(seg)) doneForNow = true
     else if (/^done\b/.test(seg)) chips.push({ kind: 'done', text: seg.slice(4).trim() })
     else if (seg.startsWith('↻')) { repeating = true; chips.push({ kind: 'repeat', text: seg.slice(1).trim() }) }
@@ -203,6 +205,35 @@ export function editTitle(md: string, key: string, title: string) {
   return serialize(doc)
 }
 
+/**
+ * The user's own impact rating, written `impact:high*`: the star means the user chose it, so Claude never changes it.
+ * null takes the rating off, and then Claude may suggest one again.
+ */
+export function setImpact(md: string, key: string, level: 'high' | 'low' | null) {
+  const doc = parse(md)
+  const hit = findItem(doc, key)
+  if (!hit) return md
+  setLine(hit.item, (mark, parts) => {
+    const rest = parts.filter((p, i) => i === 0 || !IMPACT.test(p.trim()))
+    return [mark, level ? withSegment(rest, `impact:${level}*`) : rest]
+  })
+  return serialize(doc)
+}
+
+/** Moves an item to another category. Its place in the list stays the same. */
+export function setCategory(md: string, key: string, category: string) {
+  const clean = category.replace(/^#/, '').replace(/[^\p{L}\p{N}_-]/gu, '')
+  const doc = parse(md)
+  const hit = findItem(doc, key)
+  if (!clean || !hit) return md
+  setLine(hit.item, (mark, parts) => {
+    const at = parts.findIndex((p, i) => i > 0 && p.trim().startsWith('#'))
+    if (at < 0) return [mark, [parts[0], `#${clean}`, ...parts.slice(1)]]
+    return [mark, parts.map((p, i) => (i === at ? `#${clean}` : p))]
+  })
+  return serialize(doc)
+}
+
 /** A new item has no id or a real category yet; the next sync gives it both. */
 export function addItem(md: string, sectionK: string, title: string) {
   const clean = title.replace(/\s*·\s*/g, ' - ').replace(/\n/g, ' ').trim()
diff --git a/apps/desktop/tsconfig.json b/apps/desktop/tsconfig.json
index b120f13..a0ccd1c 100644
--- a/apps/desktop/tsconfig.json
+++ b/apps/desktop/tsconfig.json
@@ -12,6 +12,7 @@
       "DOM.Iterable"
     ],
     "noEmit": true,
+    "allowImportingTsExtensions": true,
     "types": [
       "vite/client"
     ]
diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md
index a7a1c05..5f101ac 100644
--- a/docs/DECISIONS.md
+++ b/docs/DECISIONS.md
@@ -2,6 +2,7 @@
 
 Choices the owner has made, newest first, with the date each was made. Later work follows them without asking again. Bigger design choices have their own notes in `docs/adr`, and plans live in `docs/ROADMAP.md`.
 
+- **2026-11-09 · An impact view, alongside the list.** The owner asked for project buckets with drag and drop, ordered by impact and effort, top five each, and "don't get rid of our existing view". His choices: buckets are categories; effort comes from the size estimates (`~15m`), so he rates impact only, and Claude fills in only missing sizes; a Focus column holds the top item from each category, ranked against each other ("so I can either work project specific or just imperative specific"). Impact is a plain field on the item's line, `impact:high` (Claude's suggestion) or `impact:high*` (his, which Claude never changes). Finishing an item there leaves it in place marked completed, and the next one joins only when he asks. Order dragged in the view is the view's own; dragging to another bucket changes the category. He also allowed Claude to rate unrated items and fill missing sizes during /morning and /weekly; that RULES.md change waits for his yes in a session.
 - **2026-11-08 · Intake from other tools needs the user's yes.** The owner's words: "Build it; yes before joining". Another tool (first, a console app with action items from meeting notes) appends JSON Lines to `data/intake/<tool>.jsonl` and never edits the list or the Notes. `engine/tools/intake.py` reads it; new items are offered to the user and only accepted ones join the master list. Not the Notes inbox, because that is the user's own words. Wiring it into the workflows (RULES.md) waits for the owner's yes in a session.
 - **2026-11-07 · Copyright.** `LICENSE` reads "Copyright (c) 2026 EXTANT APE". In prose the org is written EXTANT APE; GitHub URLs keep `ExtantApe`. The leak check allows that exact line through `scripts/leak-allow.txt`.
 - **2026-11-07 · Name every way data leaves the Mac.** The manifesto lists each one: Claude Code, connectors you turn on, Apple's own sync, and a wall display if you connect one. Anything new that sends data off the Mac is named there first.
diff --git a/docs/test-audit.md b/docs/test-audit.md
index a13bc70..01ff317 100644
--- a/docs/test-audit.md
+++ b/docs/test-audit.md
@@ -2,6 +2,21 @@
 
 How the tests line up with what Theseus promises. Redo it after every feature or fix, and at least every 14 days while the repo has commits.
 
+## 2026-11-09 · the Impact view
+
+| Promise | Proved by |
+| --- | --- |
+| The order is low effort/high impact, high/high, low/low, high/low, unrated last; effort comes from the size estimate | `focus.test.ts`: sizes become minutes, tier order, bucket order |
+| Focus holds each category's top item, high impact first, then urgency, then section | `focus.test.ts`: focus ranking, due dates across a new year |
+| Five per bucket; a finished item stays in place and the next joins only when asked | `focus.test.ts` slots; e2e "stays in its place", "waits to be asked for", "Add puts it at the bottom" |
+| The user's rating is marked as theirs and replaces Claude's; clicking again takes it off | `focus.test.ts` setImpact; e2e rating checks |
+| Dragging or Move up/down changes only the view; another bucket changes only the category | e2e "reorders the view only", "leaves the list file alone"; `focus.test.ts` setCategory keeps the item's place |
+| Opening the view changes nothing, and the List view is unchanged | e2e "opening the view changes nothing", "the List view is still there"; the earlier e2e checks still pass |
+| Waiting On, Projects and Done never appear | `focus.test.ts` candidates; e2e "waiting items are left out" |
+| The phone note doesn't show `impact:` fields | `test_list_counts_are_recounted_and_ids_hidden` |
+
+Skipped: keyboard-only drag replacement is the native `<select>` ("Move…"), so its screen-reader behavior is the browser's; the e2e test drives it by value. Claude's rating during /morning and /weekly isn't built yet (waits for the owner's yes), so it has no tests.
+
 ## 2026-11-09 · first audit
 
 What exists: `tests/test_engine.py` (134 tests, stdlib, run by `scripts/ci-checks.sh`), `apps/desktop/src/*.test.ts` (22, `node --test`), 2 Rust tests in the desktop app, the desktop and wall end-to-end runs in CI (`apps/desktop/e2e/ui.mjs`, `apps/wall/e2e.mjs`), and `apps/wall/sim/test_connection.py`. CI also runs the leak check, syntax checks for every script and tool, `swiftc -typecheck` on `ek.swift`, and the shared-file check.
diff --git a/engine/tools/notes.py b/engine/tools/notes.py
index b5989b4..9ef6bef 100755
--- a/engine/tools/notes.py
+++ b/engine/tools/notes.py
@@ -183,7 +183,7 @@ def h(t: str) -> str:
 
 # -------------------------------------------------------- markdown → Notes HTML
 
-ID_TOKEN = re.compile(r"\s*·?\s*\b(?:id|was):[\w-]+")
+ID_TOKEN = re.compile(r"\s*·?\s*\b(?:id|was|impact):[\w-]+\*?")
 COMMENT = re.compile(r"<!--.*?-->", re.S)
 
 
diff --git a/tests/test_engine.py b/tests/test_engine.py
index be7c3ce..4a44a32 100644
--- a/tests/test_engine.py
+++ b/tests/test_engine.py
@@ -290,11 +290,13 @@ def test_notes_only_counts_a_real_not_found_as_missing(self):
     def test_list_counts_are_recounted_and_ids_hidden(self):
         code = ("import sys; sys.path.insert(0, %r); import notes\n"
                 "md = '# List\\n_Updated Mon 1/1 6:00am · 9 NOW_\\n\\n## 🔥 NOW\\n- [ ] a · id:t1\\n- [x] b\\n## ⏭ NEXT\\n- [ ] c\\n- [ ] d\\n'\n"
-                "out = notes.fresh_counts(md); print(out.splitlines()[1]); print(notes.md_to_html('- [x] a · was:figure-out · id:t1'))" % str(TOOLS))
+                "out = notes.fresh_counts(md); print(out.splitlines()[1]); print(notes.md_to_html('- [x] a · was:figure-out · impact:high* · ~15m · id:t1'))" % str(TOOLS))
         p = subprocess.run(["/usr/bin/python3", "-c", code], capture_output=True, text=True, env=self.env, cwd=self.ws)
         self.assertIn("· 1 NOW · 2 NEXT_", p.stdout, p.stderr)
         self.assertNotIn("was:", p.stdout)
         self.assertNotIn("id:", p.stdout)
+        self.assertNotIn("impact", p.stdout)
+        self.assertIn("~15m", p.stdout)
 
     def test_search_marks_every_hit_and_separates_only_apart_windows(self):
         code = """import sys, types, argparse, datetime as dt