@lovek4d/kickflip 0.3.1 → 0.5.0

package/board/public/app-cards.js

@@ -3,7 +3,7 @@
 // app-core.js and app-threads.js.
 BoardView.part((B) => {
   const { $, store, state, markSeen, seen, toast, links } = B;
-  const { esc, ago, REVIEW, reviewAge, unreadCount, workLines, heldUntilWords, holdPicker, linkText, mergeButton, buildButton, installButton, tryButton, tryWords, BUTTON, LINK_ARROW } = BoardUI;
+  const { esc, ago, REVIEW, reviewAge, unreadCount, workLines, BUILD_PHASES, phaseStrip, phaseMotion, heldUntilWords, holdPicker, linkText, mergeButton, buildButton, installButton, tryButton, tryWords, waitOn, prName, BUTTON, LINK_ARROW } = BoardUI;
 
   const mainSheet = $('#mainLogSheet');
   const mainRetry = $('#mainLogRetry');
@@ -57,11 +57,10 @@ BoardView.part((B) => {
       }
       mainState = main.state;
     }
+    // Retry waits (ui.js BUSY's look) from the tap until main is up again or its build fails.
     const busy = postingMain || followMainAfter !== null || main.state === 'running';
     mainRetry.disabled = busy;
-    mainRetry.setAttribute('aria-disabled', String(busy));
-    mainRetry.classList.toggle('main-log-going', busy);
-    mainRetry.innerHTML = busy ? `<span class="try-spin" aria-hidden="true"></span>${esc(words.going)}` : 'Retry';
+    if (busy) mainRetry.setAttribute('aria-busy', 'true'); else mainRetry.removeAttribute('aria-busy');
   }
   B.renderMainLog = renderMainLog;
   B.on(B.root, 'click', (ev) => {
@@ -99,8 +98,43 @@ BoardView.part((B) => {
     }
   });
 
+  // Main's refresh icon pulls now, spinning until the server answers. After a failed pull, a hover pointer's click
+  // pulls again while its reason shows on hover; a touch tap opens the reason instead, and a tap anywhere closes it.
+  // An open reason shifts left as far as it would run past the screen's right edge, less the 16px gutter.
+  function paintMain() {
+    BoardUI.setHTML($('#tryMain'), BoardUI.mainBar(state.board?.main, state.mainPull));
+    const why = $('#tryMain .main-pull-why.open');
+    if (!why) return;
+    const over = why.getBoundingClientRect().right - (innerWidth - 16);
+    if (over > 0) why.style.left = `${-over}px`;
+  }
+  B.on(B.root, 'click', async (ev) => {
+    const button = ev.target.closest('button[data-main-pull]');
+    if (!button) {
+      if (state.mainPull.open) { state.mainPull.open = false; paintMain(); }
+      return;
+    }
+    ev.preventDefault();
+    const pull = state.board?.main?.pull;
+    if (!pull || pull.running || state.mainPull.sending) return;
+    if (pull.error && !matchMedia('(hover: hover)').matches) {
+      state.mainPull.open = !state.mainPull.open;
+      paintMain();
+      return;
+    }
+    state.mainPull = { sending: true, open: false };
+    paintMain();
+    try {
+      const response = await fetch(B.site.url('api/try/main/pull'), { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+      const out = await response.json();
+      if (!response.ok) throw new Error(out.error || 'The hub refused the pull.');
+    } catch (error) { if (B.alive()) toast(error.message || 'Could not pull. Is the host awake?'); }
+    state.mainPull.sending = false;
+    if (B.alive()) { paintMain(); B.reload(); }
+  });
+
   // Hold's sheet: the shared duration picker in place of a confirm, since a chip is already a deliberate tap
-  // (docs/adr/0118-a-card-can-be-held-until-a-time.md). A chip or Custom sends card-hold {key, hold: true, for}.
+  // (docs/adr/2026-11-02-1727-a-card-can-be-held-until-a-time.md). A chip or Custom sends card-hold {key, hold: true, for}.
   const holdSheet = $('#holdSheet');
   let holdPicking = null;
   const localInput = (d) => {
@@ -117,9 +151,9 @@ BoardView.part((B) => {
   function openHold(it) {
     $('#holdTitle').textContent = `Hold ${it.ref}`;
     $('#holdLede').textContent = `${it.lane === 'todo' ? 'It won’t start' : 'Claude stops work on it'} until then. Forever holds it until you unhold it.`;
-    $('#holdPicker').innerHTML = holdPicker(it.key, state.board.holdChoices || []);
-    const input = $('#holdPicker [data-hold-at]');
     const now = Date.now();
+    $('#holdPicker').innerHTML = holdPicker(it.key, state.board.holdChoices, new Date(now));
+    const input = $('#holdPicker [data-hold-at]');
     input.min = localInput(new Date(now + 60_000));
     input.max = localInput(new Date(now + 30 * 86_400_000));
     input.value = input.defaultValue = localInput(new Date(now + 3_600_000));
@@ -127,10 +161,12 @@ BoardView.part((B) => {
     holdSheet.showModal();
     $('#holdTitle').focus({ preventScroll: true });
   }
+  // The card's Hold waits while the server records the hold (docs/adr/2026-11-03-1850-a-tap-waits-for-the-server-to-record-it.md).
   async function hold(key, choice) {
     closeHold();
-    try { await B.sentHere(key, () => B.send('card-hold', { key, hold: true, for: choice })); }
-    catch { toast('Could not hold. Is the host awake?'); }
+    const button = $(`button[data-confirm="hold"][data-key="${CSS.escape(key)}"]`);
+    try { await waitOn(button, B.sentHere(key, () => B.send('card-hold', { key, hold: true, for: choice }))); }
+    catch (e) { B.failed(e); }
   }
   B.on($('#holdClose'), 'click', closeHold);
   B.on(holdSheet, 'click', (ev) => {
@@ -180,15 +216,15 @@ BoardView.part((B) => {
       }
     }
     if (it.branch) rows.push(['Branch', `<code>${esc(it.branch)}</code>`]);
-    // building is an implementer at work, since Build means the package (docs/adr/0166-a-todo-cards-button-reads-implement.md).
+    // building is an implementer at work, since Build means the package (docs/adr/2026-11-03-1549-a-todo-cards-button-reads-implement.md).
     if (it.status) rows.push(['Status', esc(it.status === 'building' ? 'implementing' : it.status)]);
-    // docs/adr/0156-a-follow-up-is-a-work-card-with-a-parent.md: each link row is a row of labels that open their cards.
+    // docs/adr/2026-11-03-0526-a-follow-up-is-a-work-card-with-a-parent.md: each link row is a row of labels that open their cards.
     for (const [label, list] of [['Parent', it.parent ? [it.parent] : []], ['Children', it.children], ['Related to', it.related], ['Blocked by', it.blockedBy], ['Waits on it', it.waitsOnIt]]) {
       if (list?.length) rows.push([label, list.map(cardLink).join(' ')]);
     }
     if (it.manualSteps.length) rows.push(['Manual steps', linkText(it.manualSteps.join('; '), ctx)]);
     if (it.next) rows.push(['Next', linkText(it.next, ctx)]);
-    // docs/adr/0062-notes-is-a-link-in-the-details-list.md
+    // docs/adr/2026-10-30-1626-notes-is-a-link-in-the-details-list.md
     const external = [
       it.hasNotes ? `<a href="notes.html?item=${encodeURIComponent(it.key)}">Notes ${LINK_ARROW}</a>` : '',
       // A vscode: link opens a folder on the machine whose browser follows it, so only the host's browser gets one.
@@ -208,7 +244,7 @@ BoardView.part((B) => {
 
   const cardLink = (l) => `<a class="card-link" href="#item=${encodeURIComponent(l.key)}">${esc(l.ref)}</a>`;
   // A card whose branch is pushed to a plain git remote has no PR to link, so its line copies the branch name
-  // (docs/adr/0127-a-board-can-work-on-any-git-remote.md).
+  // (docs/adr/2026-11-02-1850-a-board-can-work-on-any-git-remote.md).
   const pushedLink = (it) => `<a href="#" data-copy-branch="${esc(it.pushed.branch)}" title="Copy the branch name">${esc(pushedWords(it))}</a>`;
   const pushedWords = (it) => [`Pushed ${it.ref}${it.pushed.host ? ` to ${it.pushed.host}` : ''}`, it.pushed.at && ago(it.pushed.at)].filter(Boolean).join(' · ');
   B.on(B.root, 'click', (ev) => {
@@ -223,18 +259,21 @@ BoardView.part((B) => {
     });
   });
 
-  const sendingMerge = new Set();
-  const sendingBuild = new Set();
+  const openPRs = (it) => (it.prs || []).filter((p) => p.state === 'OPEN');
   const CONFIRM = {
     resume: (it, ref) => `Unhold ${ref}?${it.heldUntil ? ` It's held until ${heldUntilWords(it.heldUntil)}.` : ''} It can start again once nothing blocks it.`,
     nudge: () => 'Nudge Claude to check this implementer?',
-    grill: (it, ref) => `Ask Claude for questions about ${ref}?`,
-    merge: (it, ref) => `Merge ${ref}? Claude squash-merges #${it.pr?.number} if it is still approved, green and clean.`,
+    // docs/adr/2026-11-04-2100-a-land-waits-for-your-merge.md
+    merge: (it, ref) => (it.mergeReady ? `Merge ${ref}? The board rebases ${it.mergeReady.branch} onto ${it.mergeReady.base} as it is now, reruns the tests if  moved, and lands it.`
+      : openPRs(it).length > 1
+      ? `Merge ${ref}? Claude squash-merges ${openPRs(it).map(prName).join(', ')} in turn if they are still approved, green and clean.`
+      : `Merge ${ref}? Claude squash-merges ${openPRs(it).map(prName).join('')} if it is still approved, green and clean.`),
     'card-build': (it, ref) => (it.blockedBy?.length
       ? `${it.held ? 'Unhold and implement' : 'Implement'} ${ref} once ${it.blockedBy.map((d) => d.ref).join(', ')} ${it.blockedBy.length === 1 ? 'is' : 'are'} done? It waits in In Progress until then.`
       : `${it.held ? `Unhold and implement ${ref}?` : `Implement ${ref}?`} Claude starts its implementer now with the notes as they stand.`),
     finish: (it, ref) => (it.kind === 'ask' ? `Mark this task done? "${it.title}" moves to Done.`
-      : `Close ${ref}? It moves to Done and Claude stops work on it.${it.pr?.state === 'OPEN' ? ' Its PR stays open on GitHub.' : it.pushed ? ` Its branch stays on ${it.pushed.host || 'the remote'}.` : ''}`),
+      : it.ownerStep ? `Done with "${it.ownerStep}"? ${ref} moves to Done and its ticket closes.`
+      : `Close ${ref}? It moves to Done and Claude stops work on it.${openPRs(it).length ? ` Its PR${openPRs(it).length > 1 ? 's stay' : ' stays'} open on GitHub.` : it.pushed ? ` Its branch stays on ${it.pushed.host || 'the remote'}.` : ''}`),
   };
 
   const classes = (it, button, base = '') => {
@@ -248,36 +287,101 @@ BoardView.part((B) => {
     const ask = (act, label, cls = '') => `<button${cls ? ` class="${cls}"` : ''} data-confirm="${act}" data-key="${key}">${label}</button>`;
     const hold = it.kind !== 'work' || !it.holdable ? ''
       : it.held ? (it.buildable ? '' : ask('resume', 'Unhold', 'unhold')) : ask('hold', 'Hold');
-    return `<div class="actions" data-actions="${key}">${actionRow('workflow', `${mergeButton(it, sendingMerge.has(it.key))}${hold}${actionButton(it)}${tryButton(it)}${buildButton(it, sendingBuild.has(it.key))}`)}</div>`;
+    return `<div class="actions" data-actions="${key}">${actionRow('workflow', `${mergeButton(it)}${hold}${actionButton(it)}${tryButton(it)}${buildButton(it)}`)}</div>`;
   }
 
-  // board/domain.mjs actionButtonOf picks the button and resolvedBy its colour (docs/adr/0059-an-unstarted-card-waits-on-its-questions-in-todo.md).
+  // board/domain.mjs actionButtonOf picks the button and resolvedBy its colour (docs/adr/2026-10-30-1309-an-unstarted-card-waits-on-its-questions-in-todo.md).
   const ACTION_BUTTONS = {
     [BUTTON.openQuestions]: (it) => `<a${classes(it, BUTTON.openQuestions, 'button')} href="questions.html#${esc(it.questions.first)}">Open questions</a>`,
     [BUTTON.markDone]: (it) => `<button${classes(it, BUTTON.markDone)} data-confirm="finish" data-key="${esc(it.key)}">Mark as done</button>`,
-    [BUTTON.grill]: (it) => (it.grilling ? '<button disabled>Writing questions…</button>' : `<button data-confirm="grill" data-key="${esc(it.key)}">Grill</button>`),
   };
   const actionButton = (it) => ACTION_BUTTONS[it.actionButton]?.(it) || '';
 
-  // The latest bump among New cards takes no second bump (docs/adr/0014-a-pending-ask-can-be-deleted-or-bumped.md).
+  // The latest bump among New cards takes no second bump (docs/adr/2026-10-29-1639-a-pending-ask-can-be-deleted-or-bumped.md).
   const latestBump = (it) => Boolean(it.isNew && it.bumpedAt) && !state.board.items.some((i) => i.isNew && (i.bumpedAt || '') > it.bumpedAt);
-  function card(it) {
+  // band {step, actions} draws the card in a wave band (app-lanes.js).
+  // Its open questions asked since this browser last opened it are one more unread message: the thread's "N new
+  // questions" line (app-threads.js; docs/adr/2026-11-04-2130-a-button-tap-is-a-status-line-or-a-message-footer.md).
+  function card(it, band = {}) {
+    const unseen = (times) => (state.openItems.has(it.key) ? 0 : unreadCount(times, seen[it.key]));
+    const unread = unseen(it.othersAt) + Math.min(1, unseen(it.questions?.askedAt));
     return `<details class="item" data-key="${esc(it.key)}" ${state.openItems.has(it.key) ? 'open' : ''}>
           <summary class="work">
             <span class="status ${it.lane}"></span>
-            <div class="title-wrap">${workLines(it, { unread: state.openItems.has(it.key) ? 0 : unreadCount(it.othersAt, seen[it.key]), top: latestBump(it) })}</div>
+            <div class="title-wrap">${workLines(it, { unread, top: latestBump(it), ...band })}</div>
           </summary>
           ${state.openItems.has(it.key) ? detail(it) : ''}
         </details>`;
   }
 
+  // The phase bars move as a card's reached count changes across redraws
+  // (docs/adr/2026-11-03-1850-the-phase-bars-animate-as-a-build-starts-advances-and-ends.md,
+  // docs/adr/2026-11-03-2024-every-in-progress-card-shows-its-phase-bars.md). phases is each card's last drawn count by
+  // key, null for no strip; the first draw only records it, so a loaded board stays still.
+  const phases = new Map();
+  let drawn = false;
+  const PHASE_STEP = 40;
+  const play = (el, frames, opts, hold = 'backwards') => el.animate(frames, { fill: hold, easing: 'ease-out', ...opts });
+  const GROW = [{ opacity: 0, transform: 'scaleX(0)', transformOrigin: 'left' }, { opacity: 1, transform: 'none', transformOrigin: 'left' }];
+  const PHASE_SWEEP = 120;
+  // --bar-fill is the strip's fill, the muted one on a dimmed strip (style.css).
+  const SWEEP = 'linear-gradient(var(--bar-fill), var(--bar-fill))';
+  const sweepFrame = (size) => ({ backgroundColor: 'var(--line)', backgroundImage: SWEEP, backgroundRepeat: 'no-repeat', backgroundPosition: 'left', backgroundSize: size });
+  const stripOf = (card) => {
+    const bars = card?.querySelector('.card-time .phase-bars');
+    return bars && { sep: bars.previousElementSibling?.matches('.sep') ? bars.previousElementSibling : null, bars };
+  };
+  const cardEl = (key) => $(`details.item[data-key="${CSS.escape(key)}"]`);
+  // Before lanes redraw: each drawn strip, kept so a build that ends can still leave.
+  function captureStrips() {
+    const strips = new Map();
+    for (const [key, reached] of phases) {
+      const strip = typeof reached === 'number' && stripOf(cardEl(key));
+      if (strip) strips.set(key, { sep: strip.sep?.cloneNode(true), bars: strip.bars.cloneNode(true) });
+    }
+    return strips;
+  }
+  // Sweeps bars from to before to full, one after another, starting after delay.
+  const sweep = (bars, from, to, delay) => [...bars.querySelectorAll('i')].slice(from, to)
+    .forEach((bar, k) => play(bar, [sweepFrame('0% 100%'), sweepFrame('100% 100%')], { duration: 220, delay: delay + k * PHASE_SWEEP, easing: 'ease-in-out' }));
+  // After lanes redraw: compares each card's reached count to its last, then enters, fills or leaves its strip. An
+  // entering strip grows in one bar at a time, then sweeps each reached bar.
+  function moveStrips(items, before) {
+    const next = new Map(items.map((it) => [it.key, phaseStrip(it)?.reached ?? null]));
+    const still = reduceMotion.matches || !drawn;
+    for (const [key, reached] of next) {
+      const kind = still ? null : phaseMotion(phases.get(key), reached);
+      if (!kind) continue;
+      const strip = stripOf(cardEl(key));
+      if (kind === 'leave') {
+        const gone = before.get(key);
+        const row = cardEl(key)?.querySelector('.card-time');
+        if (!gone || !row) continue;
+        const bars = [...gone.bars.querySelectorAll('i')].reverse();
+        row.append(...[gone.sep, gone.bars].filter(Boolean));
+        Promise.all(bars.map((bar, k) => play(bar, [...GROW].reverse(), { duration: 120, delay: k * PHASE_STEP, easing: 'ease-in' }, 'forwards').finished))
+          .then(() => play(gone.sep ?? gone.bars, [{ opacity: 1 }, { opacity: 0 }], { duration: 100 }, 'forwards').finished)
+          .finally(() => { gone.sep?.remove(); gone.bars.remove(); });
+      } else if (strip && kind === 'enter') {
+        if (strip.sep) play(strip.sep, [{ opacity: 0 }, { opacity: 1 }], { duration: 120 });
+        [...strip.bars.querySelectorAll('i')].forEach((bar, k) => play(bar, GROW, { duration: 140, delay: 60 + k * PHASE_STEP }));
+        sweep(strip.bars, 0, reached, 60 + BUILD_PHASES.length * PHASE_STEP + 140);
+      } else if (strip && kind === 'fill') {
+        sweep(strip.bars, phases.get(key), reached, 0);
+      }
+    }
+    phases.clear();
+    for (const [key, reached] of next) phases.set(key, reached);
+    drawn = true;
+  }
+
   B.on(B.root, 'toggle', (ev) => {
     const el = ev.target;
     if (!el.matches?.('details.item')) return;
     const key = el.dataset.key;
     if (el.open) {
       state.openItems.add(key);
-      const it = state.board.items.find((i) => i.key === key);
+      const it = state.board.items.find((i) => i.key === key) || state.archived.cards.find((i) => i.key === key);
       markSeen(it);
       const unread = el.querySelector('summary .card-unread');
       const line = unread?.parentNode;
@@ -313,29 +417,27 @@ BoardView.part((B) => {
     const key = button.dataset.try;
     const it = state.board.items.find((i) => i.key === key);
     if (!it || !(await B.confirm(`${tryWords(it.try?.kind).go} ${it.ref}? The hub runs its build script.`)) || !B.alive()) return;
-    button.disabled = true;
-    try {
+    // Serve / Build waits until the hub has started the build; the card's chip then says it runs.
+    const post = (async () => {
       const r = await fetch(B.site.url('api/try'), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ key }) });
       const out = await r.json();
       if (!r.ok) throw new Error(out.error || 'The hub refused the build.');
-    } catch (error) { toast(error.message || 'Could not start. Is the host awake?'); }
+    })();
+    try { await waitOn(button, post); } catch (error) { toast(error.message || 'Could not start. Is the host awake?'); }
     B.reload();
   });
 
   // A work card's bump icon bumps it, or unbumps a bumped one, with no confirm
-  // (docs/adr/0145-build-on-a-blocked-card-queues-it.md), and the card moves at once
-  // (docs/adr/0151-every-owner-tap-the-server-can-apply-draws-at-once.md).
+  // (docs/adr/2026-11-03-0301-build-on-a-blocked-card-queues-it.md). The icon pulses until the server has recorded it, and the card
+  // moves as its answer lands (docs/adr/2026-11-03-1850-a-tap-waits-for-the-server-to-record-it.md).
   B.on(B.root, 'click', async (ev) => {
     const b = ev.target.closest('button[data-card-bump]');
     if (!b) return;
     ev.preventDefault();
     const key = b.dataset.cardBump;
     const unbump = b.hasAttribute('data-bumped');
-    const icon = `button[data-card-bump="${CSS.escape(key)}"]`;
-    const sending = B.sentHere(key, () => B.send(unbump ? 'card-unbump' : 'card-bump', { key }, B.drawItem(key, (it) => ({ ...it, bumpedAt: unbump ? null : new Date().toISOString() }))));
-    B.fadeBump(icon, !unbump);
-    try { await sending; toast(unbump ? 'Unbumped' : 'Moved to the top'); }
-    catch { B.fadeBump(icon, unbump); toast(B.FAILED); }
+    try { await waitOn(b, B.sentHere(key, () => B.send(unbump ? 'card-unbump' : 'card-bump', { key }))); toast(unbump ? 'Unbumped' : 'Moved to the top'); }
+    catch (e) { B.failed(e); }
   });
 
   B.on(B.root, 'click', async (ev) => {
@@ -346,48 +448,39 @@ BoardView.part((B) => {
     const it = state.board.items.find((i) => i.key === key);
     if (it && act === 'hold') { openHold(it); return; }
     if (!it || !(await B.confirm(CONFIRM[act](it, it.ref)))) return;
-    if (act === 'resume') {
-      try { await B.sentHere(key, () => B.send('card-hold', { key, hold: false })); }
-      catch { toast('Could not resume. Is the host awake?'); }
-      return;
-    }
-    // docs/adr/0052-auto-merge-is-a-board-setting-off-by-default.md
-    if (act === 'merge') {
-      sendingMerge.add(key);
-      redrawActions(key);
-      try { await B.sentHere(key, () => B.send('card-merge', { key })); }
-      catch { toast('Could not send. Is the host awake?'); }
-      sendingMerge.delete(key);
-      redrawActions(key);
-      return;
-    }
-    if (act === 'card-build') {
-      sendingBuild.add(key);
-      redrawActions(key);
-      try { await B.sentHere(key, () => B.send('card-build', { key })); }
-      catch { toast('Could not send. Is the host awake?'); }
-      sendingBuild.delete(key);
-      redrawActions(key);
-      return;
-    }
-    // docs/adr/0106-the-board-applies-the-owners-hold-resume-and-done-at-once.md
-    // The card closes first, or app-core.js steady would anchor it and scroll the page after it into Done.
-    if (act === 'finish') {
-      const card = $(`details.item[data-key="${CSS.escape(key)}"]`);
-      if (card) card.open = false;
-      try { await B.sentHere(key, () => (it.kind === 'ask' ? B.send('ask-done', { id: it.id }) : B.send('card-done', { key }))); }
-      catch { toast('Could not close. Is the host awake?'); }
-      B.syncDone(key);
+    // Unhold, Merge (docs/adr/2026-10-29-1752-auto-merge-is-a-board-setting-off-by-default.md), Implement and Done wait while the
+    // server records them (docs/adr/2026-11-03-1850-a-tap-waits-for-the-server-to-record-it.md).
+    const sent = { resume: ['card-hold', { key, hold: false }], merge: ['card-merge', { key }], 'card-build': ['card-build', { key }],
+      finish: it.kind === 'ask' ? ['ask-done', { id: it.id }] : ['card-done', { key }] }[act];
+    if (sent) {
+      // Done closes its card once the server answers, before the answer's board lands, or app-core.js steady would
+      // anchor it and scroll the page after it into Done (docs/adr/2026-11-02-0009-the-board-applies-the-owners-hold-resume-and-done-at-once.md).
+      const close = act === 'finish' ? () => {
+        const card = $(`details.item[data-key="${CSS.escape(key)}"]`);
+        if (card) BoardUI.closeDetails(card);
+        state.openItems.delete(key);
+        store.set('openItems', [...state.openItems]);
+      } : null;
+      // docs/adr/2026-11-04-2320-a-merge-tap-waits-its-turn-to-land.md: Merge spins until a board shows the card left
+      // In Review, or no longer merging there, which is its refusal.
+      const pend = act === 'merge' ? `${key}:merge` : null;
+      if (pend) BoardUI.pending.start(pend, (board) => { const c = board.items.find((i) => i.key === key); return !c || c.lane !== 'review' || !c.merging; });
+      try {
+        const out = await waitOn(b, B.sentHere(key, () => B.send(...sent, close)));
+        if (pend) { BoardUI.pending.answered(pend, out.board.generatedAt); B.render(); }
+      } catch (e) {
+        if (pend) { BoardUI.pending.drop(pend); B.render(); }
+        B.failed(e);
+      }
+      if (act === 'finish') B.syncDone(key);
       return;
     }
-    const row = $(`.actions[data-actions="${CSS.escape(key)}"]`);
-    row?.querySelectorAll('button').forEach((x) => { x.disabled = true; });
-    b.disabled = true;
+    // The tapped button waits and the rest of its action row is disabled until the server answers.
+    const group = { group: $(`.actions[data-actions="${CSS.escape(key)}"]`)?.querySelectorAll('button') ?? [] };
     try {
-      if (act === 'nudge') { await B.sentHere(key, () => B.send('builder-nudge', { key })); b.textContent = 'Sent'; toast('Nudge sent'); }
-      else { await B.sentHere(key, () => B.send('grill-more', { key })); B.loadThread(key, { force: true }); }
+      await waitOn(b, B.sentHere(key, () => B.send('builder-nudge', { key })), group); b.disabled = true; toast('Nudge sent');
     } catch { redrawActions(key); toast('Could not send. Is the host awake?'); }
   });
 
-  Object.assign(B, { detail, card });
+  Object.assign(B, { captureStrips, moveStrips, detail, card });
 });

package/board/public/app-core.js

@@ -36,7 +36,7 @@ BoardView.part((B) => {
   }
 
   // Runs paint through keepFocus and keeps the anchor where it was on screen, scrolling the page by however far it
-  // moved, in the same task so nothing visibly jumps (docs/adr/0063-an-open-card-moves-at-once-and-the-page-follows-it.md).
+  // moved, in the same task so nothing visibly jumps (docs/adr/2026-10-30-1637-an-open-card-moves-at-once-and-the-page-follows-it.md).
   // The anchor is the field being typed in, else the title row of the open card on screen, else there is none. A field
   // in a dialog doesn't move with the page, so the card anchors then.
   function anchorOf() {
@@ -95,27 +95,6 @@ BoardView.part((B) => {
     store.set('seenThreads', seen);
   }
 
-  // iOS commits a pending predictive-text word after Send clears the box, which would refill it and resave the draft.
-  // So Send blurs first, and input is dropped while the send runs and for a moment after it succeeds.
-  const quiet = new Map();
-  function quieted(draftKey, ta) {
-    const until = quiet.get(draftKey) || 0;
-    if (until <= Date.now()) return false;
-    if (until !== Infinity) ta.value = '';
-    return true;
-  }
-  async function sendDraft(draftKey, ta, current, send) {
-    ta.blur();
-    quiet.set(draftKey, Infinity);
-    try { await send(); } catch (e) { quiet.delete(draftKey); store.set(draftKey, (current() || ta).value); throw e; }
-    store.set(draftKey, '');
-    const now = current();
-    if (now) now.value = '';
-    quiet.set(draftKey, Date.now() + 1000);
-  }
-
-  // A deleted ask is hidden on the server, so it leaves every device (docs/adr/0008-dismissals-hide-on-the-server.md).
-  const hide = (id, hidden) => fetch(B.site.url('api/hide'), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id, hidden }) });
   // The ui-links.js linkContext for text shown on item `key`'s card or thread.
   const links = (key) => BoardUI.linkContext(state.board?.items || [], key);
   const svg = (body, size = 20) => `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${body}</svg>`;
@@ -126,5 +105,5 @@ BoardView.part((B) => {
   const confirm = (message, labels) => dialogs.confirm(message, { ...labels, signal: controller.signal });
   const notice = dialogs.notice;
 
-  Object.assign(B, { steady, restorePlace, plural, seen, markSeen, quieted, sendDraft, hide, links, svg, confirm, notice });
+  Object.assign(B, { steady, restorePlace, plural, seen, markSeen, links, svg, confirm, notice });
 });

package/board/public/app-header.js

@@ -1,8 +1,8 @@
 // The board view's header and GitHub status: the time since the last change signal or refresh, refresh, the In Review
-// header's GitHub line (docs/adr/0021-the-board-shows-github-checks-and-watcher-health.md);
-// the GitHub mark's Hub links sheet and a new board's setup checklist (docs/adr/0040-one-board-registry-for-every-hub-feature.md);
+// header's GitHub line (docs/adr/2026-10-29-1639-the-board-shows-github-checks-and-watcher-health.md);
+// the GitHub mark's Hub links sheet and a new board's setup checklist (docs/adr/2026-10-29-1639-one-board-registry-for-every-hub-feature.md);
 // and the wake: any tap on an asleep board's page, refresh included, asks the hub to resume its session
-// (docs/adr/0147-boards-run-in-the-background-and-the-hub-board-in-tmux.md). Needs app-core.js.
+// (docs/adr/2026-11-03-0313-boards-run-in-the-background-and-the-hub-board-in-tmux.md). Needs app-core.js.
 BoardView.part((B) => {
   const { $, state, toast } = B;
   const { statusLine, freshSig, nextFresh, githubLine, remoteLine, linksList, setupCard, checkLanded, githubRefresh, headerControls } = BoardUI;
@@ -16,7 +16,14 @@ BoardView.part((B) => {
     $('#setup').innerHTML = setupCard(d.setup);
     if ($('#linksSheet').open) $('#linksList').innerHTML = linksList(d.links);
   }
-  const renderStatus = () => { $('#status').innerHTML = statusLine(state.fresh?.at, { link: state.link, watcher: state.board?.checks?.watcher, pause: B.pause?.(), waking: state.waking }); };
+  // The status line, and the moon right of the title while the owner reads away (hub/presence.mjs ownerTracker).
+  const renderStatus = () => {
+    $('#status').innerHTML = statusLine(state.fresh?.at, { link: state.link, watcher: state.board?.checks?.watcher, pause: B.pause?.(), waking: state.waking });
+    const moon = $('.away-moon');
+    const away = Boolean(B.away?.());
+    moon.classList.toggle('on', away);
+    moon.setAttribute('aria-hidden', String(!away));
+  };
   // A board load and its open threads landed; via is ui-header.js nextFresh's.
   function landed(via) {
     state.fresh = nextFresh(state.fresh, { via, at: new Date().toISOString(), sig: freshSig(state.board, state.threadCache, state.openItems) });
@@ -100,7 +107,7 @@ BoardView.part((B) => {
   B.on($('.nav'), 'click', (ev) => {
     if (ev.target.closest('a[aria-disabled="true"]')) { ev.preventDefault(); ev.stopImmediatePropagation(); }
   }, true);
-  // A load can return in milliseconds, so the spin and "Reconnecting…" hold long enough to read.
+  // A load can return in milliseconds, so the spin and "reconnecting…" hold long enough to read.
   const RELOAD_MIN = 700;
   async function reloading(load) {
     controls.reloading = true;