local-kanban 2.0.0-beta.6 → 2.0.0-beta.7

package/CHANGELOG.md

@@ -8,6 +8,20 @@ version it goes out as and opens an empty one again. Released sections are histo
 
 ## [Unreleased]
 
+## [2.0.0-beta.7]
+
+### Added
+
+- Health has a second section, Stands: the git worktrees left behind by tasks, with each one's project, task, size and date, and whether it can go (nothing uncommitted, every commit already in main), still holds work not in main (its commits and the changes, on request) or is busy (a Claude session, a running process, its task in work). «Remove the ticked» opens one task per repository with the stands that can go and starts it like «Fix»; its Claude checks each stand again right before removing it, never with `--force`, and asks you about the rest. The board itself removes nothing.
+
+### Changed
+
+- Health: after «Fix», the row of the project names the task of the fix and shows Claude's state on it — starting, working, waiting for you, not running, or waiting for your review.
+
+### Fixed
+
+- A board no longer takes in or closes a terminal another board started on the same tmux socket: a terminal counts as its own only with the board's own port in its environment.
+
 ## [2.0.0-beta.6]
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-kanban",
-  "version": "2.0.0-beta.6",
+  "version": "2.0.0-beta.7",
   "license": "MIT",
   "author": "Dannylamao",
   "repository": {

package/public/js/board.js

@@ -793,7 +793,7 @@ const LIVE_BADGE = {
   brokeRetrying: ['busy', 'connection lost · going on', "The connection to the API broke off in the middle of Claude's answer — the board tells it to go on by itself"],
   brokeStuck: ['wait', 'answer broke off', "The connection to the API broke off in the middle of Claude's answer, and it did not go on — open the card"],
 };
-function liveBadge(t) {
+export function liveBadge(t) {
   if (hasAsk(t.id)) return `<span class="card-live live-wait live-ask" title="${esc(tr('Claude is waiting for your answer — open the card'))}"><span class="live-dot"></span>${tr('needs your answer')}</span>`;
   const l = state.live[t.id];
   const b = l && (WORKING.has(t.status) || t.status === 'ready') && LIVE_BADGE[l.claude === 'gone' && l.interrupted ? 'interrupted'

package/public/js/core.js

@@ -1487,6 +1487,47 @@ const I18N_RU = {
   'tmux was updated under the running terminals of the board': 'tmux обновили под работающими терминалами доски',
   'the project has no CLAUDE.md of its own any more': 'у проекта больше нет своего CLAUDE.md',
   'Fix': 'Починить',
+  'Open the task of the fix': 'Открыть задачу починки',
+  'Claude is not running': 'Claude не запущен',
+  'waits for your review': 'ждёт твоей проверки',
+  'Instructions': 'Инструкции',
+  'How large the CLAUDE.md of each project is': 'Насколько велик CLAUDE.md каждого проекта',
+  'Stands': 'Стенды',
+  'The git worktrees left behind by tasks, and their branches': 'Рабочие копии git, оставшиеся после задач, и их ветки',
+  'GB': 'ГБ',
+  'a Claude session is open in the folder': 'в папке открыта сессия Claude',
+  'a process runs in the folder': 'в папке запущен процесс',
+  'its task is in work': 'задача в работе',
+  'the worktree is locked': 'рабочая копия заперта',
+  'could not tell what is in it': 'не удалось понять, что в ней',
+  'not committed': 'не закоммичено',
+  'not in main': 'нет в main',
+  'detached HEAD with commits of its own': 'без ветки, со своими коммитами',
+  'in main as the same change': 'в main той же правкой',
+  'in main by its title': 'в main по заголовку',
+  'in main by its issue number': 'в main по номеру issue',
+  'Remove': 'Убрать',
+  'Show what is not in main': 'Показать, чего нет в main',
+  'free on the disk': 'свободно на диске',
+  'measured against': 'сверено с',
+  'no main branch to measure against': 'нет ветки main для сверки',
+  'Looking at the stands…': 'Смотрю стенды…',
+  'Looked at': 'Проверено в',
+  'can go': 'можно убрать',
+  'No stands: the projects of the board have no git worktrees besides the main one.': 'Стендов нет: у проектов доски нет рабочих копий git, кроме основной.',
+  'A stand is a git worktree of a task (.claude/worktrees/<KEY>) and its branch. «Can go» — nothing uncommitted and every commit is in main; the task you open checks each one again right before removing it, and never removes one with work not in main.': 'Стенд — рабочая копия git задачи (.claude/worktrees/<КЛЮЧ>) и её ветка. «Можно убрать» — нет незакоммиченного, и каждый коммит есть в main; задача, которую ты заведёшь, сверит каждый ещё раз прямо перед удалением и не тронет тот, где есть работа не из main.',
+  'Untick all': 'Снять все',
+  'Tick all that can go': 'Отметить все, что можно убрать',
+  'Remove the ticked': 'Убрать отмеченные',
+  'Can go': 'Можно убрать',
+  'Work not in main': 'Есть несданное',
+  'Not removed by the task: it asks you what to do with each.': 'Задача их не удаляет: про каждый она спросит тебя.',
+  'Busy': 'Заняты',
+  'Being looked at': 'Проверяются',
+  'Nothing differs from main.': 'Ничем не отличается от main.',
+  'Could not show the changes': 'Не удалось показать изменения',
+  'A cleanup of these stands is already open': 'Уборка этих стендов уже заведена',
+  'Could not look at the stands': 'Не удалось посмотреть стенды',
   'Open the task «Shrink CLAUDE.md» and start Claude on it — only while nobody works in the folder of the project': 'Завести задачу «Ужать CLAUDE.md» и сразу запустить на ней Claude — только пока в папке проекта никто не работает',
   'Claude works in the folder of this project — fix its CLAUDE.md once that work is over.': 'В папке этого проекта сейчас работает Claude — почини его CLAUDE.md, когда эта работа закончится.',
   'Tasks in work': 'Задачи в работе',

package/public/js/health-rules.js

@@ -9,6 +9,15 @@ export function fileState(f, norms) {
 
 export const fixable = (main, norms) => ['heavy', 'long'].includes(fileState(main, norms));
 
+const FIX_WORK = new Set(['prep', 'doing', 'ready', 'deploy']);
+export function fixStage(fix) {
+  if (!fix) return 'none';
+  if (FIX_WORK.has(fix.status)) return 'work';
+  if (fix.status === 'review') return 'review';
+  if (fix.status === 'backlog' || fix.status === 'todo') return 'todo';
+  return 'none';
+}
+
 const RANK = { heavy: 0, long: 1, ok: 2 };
 
 /** The projects split for the section: with their own CLAUDE.md (worst first, then the most loaded at the start), without
@@ -43,3 +52,23 @@ export function healthCounts(own, norms) {
   }
   return n;
 }
+
+const BY_SIZE = (a, b) => (b.size || 0) - (a.size || 0) || String(a.path).localeCompare(String(b.path));
+/** The stands split for the section — what can go first, the biggest first: {free, unsent, busy, reading}. */
+export function standGroups(stands) {
+  const out = { free: [], unsent: [], busy: [], reading: [] };
+  for (const s of stands || []) (out[s.state] || out.reading).push(s);
+  for (const k of Object.keys(out)) out[k].sort(BY_SIZE);
+  return out;
+}
+/** How many stands and how much room: {n, size, freeN, freeSize}. */
+export function standTotals(stands) {
+  let size = 0; let freeN = 0; let freeSize = 0;
+  for (const s of stands || []) {
+    size += s.size || 0;
+    if (s.state === 'free') { freeN += 1; freeSize += s.size || 0; }
+  }
+  return { n: (stands || []).length, size, freeN, freeSize };
+}
+/** The chosen folders that can still go: a stand chosen earlier that is no longer free drops out of the choice. */
+export const chosenFree = (chosen, stands) => (stands || []).filter((s) => s.state === 'free' && chosen.has(s.path)).map((s) => s.path);

package/public/js/health-stands.js

@@ -0,0 +1,201 @@
+import { $, HEALTH, api, esc, fmtNum, ic, state, tr } from './core.js';
+import { keepFocus } from './now.js';
+import { plural } from './settings.js';
+import { styledAlert, styledConfirm } from './sidebar.js';
+import { refusalLine } from './unsaved.js';
+import { openDrawer } from './drawer.js';
+import { SHORT_MONTHS, STATUS_LABELS, launchInClaude, taskPromptText } from './sse.js';
+import { chosenFree, standGroups, standTotals } from './health-rules.js';
+
+const POLL_MS = 2000; // while the walk runs
+let last = null;
+let drawnSig = '';
+let poll = null;
+const chosen = new Set(); // folders ticked by the person — kept through repaints
+const opened = new Set(); // stands unfolded
+const diffs = new Map(); // folder → the diff text, once asked for
+let starting = false;
+
+function gb(n) {
+  if (!n) return '—';
+  if (n >= 1024 ** 3) return `${fmtNum(n / 1024 ** 3, 1)} ${tr('GB')}`;
+  return `${fmtNum(Math.max(1, Math.round(n / 1024 ** 2)), 0)} ${tr('MB')}`; // a stand of a few files is no «0.0 GB»
+}
+const statusWord = (st) => STATUS_LABELS[st] || st;
+function day(ms) {
+  if (!ms) return '';
+  const d = new Date(ms);
+  return `${d.getDate()} ${SHORT_MONTHS[d.getMonth()]}${d.getFullYear() !== new Date().getFullYear() ? ` ${d.getFullYear()}` : ''}`;
+}
+const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+
+/** Why a stand is not free, in words. */
+function whyWords(s) {
+  const n = () => (s.commits || []).filter((c) => !c.found).length;
+  return s.why.map((w) => ({
+    session: tr('a Claude session is open in the folder'),
+    process: tr('a process runs in the folder'),
+    task: `${tr('its task is in work')}${s.task ? ` (${statusWord(s.task.status)})` : ''}`,
+    locked: tr('the worktree is locked'),
+    unknown: tr('could not tell what is in it'),
+    dirty: `${tr('not committed')}: ${s.changes?.files ?? '?'} ${plural(s.changes?.files ?? 0, 'file', 'files')}`,
+    commits: `${tr('not in main')}: ${n()} ${plural(n(), 'commit', 'commits')}`,
+    detached: tr('detached HEAD with commits of its own'),
+  }[w] || w)).join(' · ');
+}
+const FOUND = {
+  patch: 'in main as the same change',
+  title: 'in main by its title',
+  issue: 'in main by its issue number',
+};
+
+function rowHTML(s) {
+  const name = s.path.split('/').pop();
+  const box = s.state === 'free'
+    ? `<input type="checkbox" class="st-pick" data-path="${esc(s.path)}"${chosen.has(s.path) ? ' checked' : ''} aria-label="${esc(`${tr('Remove')} ${name}`)}">`
+    : '<span class="st-pick-gap"></span>';
+  const key = s.key ? `<a class="hl-fix-key" href="#" data-key="${esc(s.key)}">${esc(s.key)}</a>${s.task ? ` <span class="muted">${esc(statusWord(s.task.status))}</span>` : ''}` : '';
+  const head = `<span class="hl-main"><span class="hl-name" title="${esc(s.path)}">${esc(name)}</span>`
+    + `<span class="hl-what"><span>${esc(s.project.name)}</span>${key ? `<span>${key}</span>` : ''}${s.branch && s.branch !== name ? `<span class="st-branch">${esc(s.branch)}</span>` : ''}`
+    + `${s.state !== 'free' && s.state !== 'reading' ? `<span class="st-why">${esc(whyWords(s))}</span>` : ''}</span></span>`
+    + `<span class="hl-start st-size">${esc(gb(s.size))}${s.changed_at ? ` · ${esc(day(s.changed_at))}` : ''}</span>`;
+  const commits = s.commits || [];
+  if (!commits.length && !(s.state === 'unsent' && s.dirty)) return `<div class="hl-row st-row">${box}<span class="st-chev-gap"></span>${head}</div>`;
+  const list = commits.map((c) => `<div class="hl-file"><span class="hl-file-path">${esc(c.sha.slice(0, 9))} ${esc(c.title)}</span>`
+    + `<span class="hl-file-kind${c.found ? '' : ' hl-heavy'}">${esc(c.found ? tr(FOUND[c.found]) : tr('not in main'))}</span></div>`).join('');
+  const diff = s.state === 'unsent'
+    ? (diffs.has(s.path) ? `<pre class="st-diff">${esc(diffs.get(s.path))}</pre>` : `<button type="button" class="btn-ghost st-diff-btn" data-path="${esc(s.path)}">${esc(tr('Show what is not in main'))}</button>`)
+    : '';
+  return `<details class="hl-proj st-proj" data-path="${esc(s.path)}"${opened.has(s.path) ? ' open' : ''}><summary class="hl-row st-row">${box}${ic('chevron', 13)}${head}</summary>`
+    + `<div class="hl-files">${list}${diff}</div></details>`;
+}
+
+function groupHTML(head, list, hint = '') {
+  if (!list.length) return '';
+  return `<div class="hl-sec-h">${esc(tr(head))} <span class="hl-sec-n">${list.length}</span></div>${hint ? `<div class="muted hl-hint st-hint">${esc(tr(hint))}</div>` : ''}`
+    + `<div class="panel hl-list">${list.map(rowHTML).join('')}</div>`;
+}
+
+function paint(d, tabs) {
+  const g = standGroups(d.stands);
+  const t = standTotals(d.stands);
+  const picked = chosenFree(chosen, d.stands);
+  const repos = d.repos.map((r) => `<div class="st-repo"><span class="hl-file-path">${esc(r.top)}</span><span class="muted">${r.free ? `${tr('free on the disk')}: ${esc(gb(r.free))}` : ''}${r.main ? ` · ${tr('measured against')} ${esc(r.main)}` : ` · ${tr('no main branch to measure against')}`}</span></div>`).join('');
+  const walk = d.running
+    ? `${tr('Looking at the stands…')} ${d.done} / ${d.total}`
+    : `${tr('Looked at')} ${hhmm(d.at)}`;
+  const sum = t.n
+    ? `${t.n} ${plural(t.n, 'stand', 'stands')} · ${gb(t.size)} · ${tr('can go')}: ${t.freeN} (${gb(t.freeSize)})`
+    : (d.running ? '' : tr('No stands: the projects of the board have no git worktrees besides the main one.'));
+  const head = '<div class="panel hl-norms">'
+    + `<div class="hl-h">${tr('Stands')}<button type="button" class="btn-ghost st-again"${d.running ? ' disabled' : ''}>${tr('Check again')}</button></div>`
+    + `<div class="muted hl-hint">${esc(tr('A stand is a git worktree of a task (.claude/worktrees/<KEY>) and its branch. «Can go» — nothing uncommitted and every commit is in main; the task you open checks each one again right before removing it, and never removes one with work not in main.'))}</div>`
+    + `${repos}<div class="hl-sum muted">${esc(walk)}</div></div>`;
+  const bar = g.free.length
+    ? `<div class="st-bar"><button type="button" class="btn-ghost st-all">${esc(picked.length === g.free.length ? tr('Untick all') : `${tr('Tick all that can go')} (${g.free.length})`)}</button>`
+      + `<button type="button" class="btn-primary st-go"${picked.length && !starting ? '' : ' disabled'}>${esc(`${tr('Remove the ticked')} (${picked.length})`)}</button></div>`
+    : '';
+  const box = $('health');
+  keepFocus(box, () => {
+    box.innerHTML = `<div class="now-wrap hl-wrap">${tabs}${head}${sum ? `<div class="hl-sum muted">${esc(sum)}</div>` : ''}${bar}`
+      + groupHTML('Can go', g.free)
+      + groupHTML('Work not in main', g.unsent, 'Not removed by the task: it asks you what to do with each.')
+      + groupHTML('Busy', g.busy)
+      + groupHTML('Being looked at', g.reading) + '</div>';
+  });
+  box.querySelectorAll('details.st-proj').forEach((el) => {
+    el.ontoggle = () => { if (el.open) opened.add(el.dataset.path); else opened.delete(el.dataset.path); };
+  });
+  box.querySelectorAll('.st-pick').forEach((c) => {
+    c.onclick = (e) => e.stopPropagation(); // a tick in <summary> does not fold it
+    c.onchange = () => { if (c.checked) chosen.add(c.dataset.path); else chosen.delete(c.dataset.path); repaint(); };
+  });
+  box.querySelectorAll('a.hl-fix-key').forEach((a) => {
+    a.onclick = (e) => { e.preventDefault(); e.stopPropagation(); openDrawer(a.dataset.key); };
+  });
+  box.querySelectorAll('.st-diff-btn').forEach((b) => { b.onclick = () => showDiff(b.dataset.path, b); });
+  const again = box.querySelector('.st-again');
+  if (again) again.onclick = () => { again.disabled = true; renderStands(tabs, { force: true }); };
+  const all = box.querySelector('.st-all');
+  if (all) {
+    all.onclick = () => {
+      if (picked.length === g.free.length) chosen.clear(); else g.free.forEach((s) => chosen.add(s.path));
+      repaint();
+    };
+  }
+  const go = box.querySelector('.st-go');
+  if (go) go.onclick = () => removeChosen(go, tabs);
+}
+let lastTabs = '';
+const sigOf = (d) => JSON.stringify([d, [...chosen], [...diffs.keys()], starting]);
+function repaint() {
+  if (!last || state.slug !== HEALTH) return;
+  drawnSig = sigOf(last);
+  paint(last, lastTabs);
+}
+
+async function showDiff(path, btn) {
+  btn.disabled = true;
+  try {
+    const r = await api('GET', `/api/health/stands/diff?path=${encodeURIComponent(path)}`, undefined, { quiet: true });
+    diffs.set(path, r.text || tr('Nothing differs from main.'));
+    opened.add(path);
+    repaint();
+  } catch (e) {
+    btn.disabled = false;
+    styledAlert(refusalLine('Could not show the changes', e, tr));
+  }
+}
+
+async function removeChosen(btn, tabs) {
+  const paths = chosenFree(chosen, last?.stands);
+  if (!paths.length || starting) return;
+  starting = true;
+  btn.disabled = true;
+  try {
+    let r;
+    try { r = await api('POST', '/api/health/stands/task', { paths }, { quiet: true }); } catch (e) {
+      const b = e.body || {};
+      if (b.reason === 'cleanup-open' && b.key) {
+        styledConfirm(`${tr('A cleanup of these stands is already open')}: ${b.key}.`, { okLabel: `${tr('Open')} ${b.key}` }).then((ok) => { if (ok) openDrawer(b.key); });
+      } else styledAlert(refusalLine('Could not open the task', e, tr));
+      return;
+    }
+    chosen.clear();
+    for (const t of r.tasks || []) await launchInClaude({ text: taskPromptText(t.key), project: t.project, keys: [t.key], btn });
+  } finally {
+    starting = false;
+    renderStands(tabs).catch(() => {});
+  }
+}
+
+let seq = 0;
+let askedAt = 0;
+const REASK_MS = 30000; // a finished picture changes only with a walk: the events of the board do not ask for it again
+/** Draw the stands; `tabs` — the switch of the sections, drawn on top. Asks again every POLL_MS while the walk runs. */
+export async function renderStands(tabs, { force = false } = {}) {
+  lastTabs = tabs;
+  if (!force && last && !last.running && Date.now() - askedAt < REASK_MS) {
+    if (!$('health').querySelector('.st-again')) { drawnSig = ''; repaint(); }
+    return;
+  }
+  clearTimeout(poll);
+  const my = ++seq;
+  askedAt = Date.now();
+  if (!last) $('health').innerHTML = `<div class="now-wrap hl-wrap">${tabs}<div class="muted">${tr('Looking at the stands…')}</div></div>`;
+  let d;
+  try { d = await api('GET', `/api/health/stands${force ? '?refresh=1' : ''}`, undefined, { quiet: true }); } catch (e) {
+    if (my !== seq || state.slug !== HEALTH) return;
+    if (!last) $('health').innerHTML = `<div class="now-wrap hl-wrap">${tabs}<div class="muted">${esc(refusalLine('Could not look at the stands', e, tr))}</div></div>`;
+    else { askedAt = 0; const b = $('health').querySelector('.st-again'); if (b) b.disabled = false; } // a failed «Check again» can be pressed again
+    return;
+  }
+  if (my !== seq || state.slug !== HEALTH) return;
+  if (last && last.at !== d.at) diffs.clear(); // a new walk: what was not in main may have landed since
+  last = d;
+  const sig = sigOf(d);
+  if (sig !== drawnSig || !$('health').querySelector('.st-bar, .st-again')) { drawnSig = sig; paint(d, tabs); }
+  if (d.running) poll = setTimeout(() => { if (state.slug === HEALTH && $('health').querySelector('.st-again')) renderStands(tabs).catch(() => {}); }, POLL_MS);
+}
+/** The section was left: no more asking. */
+export function stopStands() { clearTimeout(poll); seq += 1; }

package/public/js/health.js

@@ -1,16 +1,45 @@
 
 import { $, HEALTH, LANG, api, esc, ic, state, tr } from './core.js';
+import { liveBadge } from './board.js';
 import { keepFocus } from './now.js';
 import { plural } from './settings.js';
 import { selectProject, styledAlert, styledConfirm } from './sidebar.js';
 import { refusalLine } from './unsaved.js';
 import { openDrawer } from './drawer.js';
-import { launchInClaude, taskPromptText } from './sse.js';
-import { fileState, fixable, healthCounts, healthGroups, startTotal } from './health-rules.js';
+import { STATUS_LABELS, launchInClaude, taskPromptText } from './sse.js';
+import { fileState, fixStage, fixable, healthCounts, healthGroups, startTotal } from './health-rules.js';
+import { renderStands, stopStands } from './health-stands.js';
+import { localStore } from './store.js';
+
+const TAB_KEY = 'kb.ui.healthTab';
+const TABS = ['files', 'stands'];
+let tab = 'files';
+try { const v = localStore.getItem(TAB_KEY); if (TABS.includes(v)) tab = v; } catch { /* private mode: the first one */ }
+function tabsHTML() {
+  const b = (v, label, title) => `<button type="button" class="dr-btn${tab === v ? ' active' : ''}" data-hl-tab="${v}" role="tab" aria-selected="${tab === v}" title="${esc(tr(title))}">${esc(tr(label))}</button>`;
+  return `<div class="now-bar hl-tabs"><div class="dash-range" role="tablist">${b('files', 'Instructions', 'How large the CLAUDE.md of each project is')}`
+    + `${b('stands', 'Stands', 'The git worktrees left behind by tasks, and their branches')}</div></div>`;
+}
+// one listener on the section for the switch: both sections draw it anew on every paint
+let tabsWired = false;
+function wireTabs() {
+  if (tabsWired) return;
+  tabsWired = true;
+  $('health').addEventListener('click', (e) => {
+    const b = e.target.closest?.('[data-hl-tab]');
+    if (!b || b.dataset.hlTab === tab) return;
+    tab = b.dataset.hlTab;
+    try { localStore.setItem(TAB_KEY, tab); } catch { /* the choice lives until reload */ }
+    drawnSig = '';
+    if (tab !== 'stands') stopStands();
+    renderHealth().catch(() => {});
+  });
+}
 
 const FRESH_MS = 30000;
 const DOCS_URL = 'https://code.claude.com/docs/en/memory';
 let last = null; // { at, d }
+let fixes = {};
 let drawnSig = '';
 const opened = new Set(); // the projects whose files are unfolded — kept through repaints
 
@@ -51,9 +80,8 @@ function projectHTML(p, d) {
     : `<span class="hl-size muted">${esc(tr('no CLAUDE.md of its own'))}</span>`;
   const start = `<span class="hl-start${total.over ? ' hl-heavy' : ''}" title="${esc(tr('Everything a session reads when it starts in this folder, with your own files'))}">`
     + `${esc(tr('at the start'))}: ${esc(num(total.chars))} ${esc(plural(total.chars, 'character', 'characters'))}</span>`;
-  const fix = p.main && fixable(p.main, norms)
-    ? `<button type="button" class="btn-ghost hl-fix" data-slug="${esc(p.slug)}" title="${esc(tr('Open the task «Shrink CLAUDE.md» and start Claude on it — only while nobody works in the folder of the project'))}">${esc(tr('Fix'))}</button>`
-    : '';
+  const button = `<button type="button" class="btn-ghost hl-fix" data-slug="${esc(p.slug)}" title="${esc(tr('Open the task «Shrink CLAUDE.md» and start Claude on it — only while nobody works in the folder of the project'))}">${esc(tr('Fix'))}</button>`;
+  const fix = fixHTML(fixes[p.slug], p.main && fixable(p.main, norms) ? button : '');
   const files = [...p.files, ...p.nested];
   const body = files.length
     ? files.map((f) => fileHTML(f, norms)).join('')
@@ -64,6 +92,18 @@ function projectHTML(p, d) {
     + `<div class="hl-files">${body}</div></details>`;
 }
 
+const statusWord = (st) => STATUS_LABELS[st] || st;
+function fixHTML(fx, button) {
+  const stage = fixStage(fx);
+  if (stage === 'none') return button;
+  const key = `<a class="hl-fix-key" href="#" data-key="${esc(fx.key)}" title="${esc(tr('Open the task of the fix'))}">${esc(fx.key)}</a>`;
+  let what;
+  if (stage === 'work') what = liveBadge({ id: fx.id, status: fx.status }) || `<span class="muted">${esc(statusWord(fx.status))} · ${esc(tr('Claude is not running'))}</span>`;
+  else if (stage === 'review') what = `<span class="muted">${esc(tr('waits for your review'))}</span>`;
+  else what = `<span class="muted">${esc(statusWord(fx.status))}</span>`;
+  return `<span class="hl-fixing">${key}${what}${stage === 'todo' ? button : ''}</span>`;
+}
+
 function normsHTML(d) {
   const n = d.norms;
   const row = (lead, why) => `<div class="hl-norm"><span class="hl-norm-n">${lead}</span><span class="muted">${why}</span></div>`;
@@ -100,7 +140,7 @@ function paint(d) {
     : '';
   const box = $('health');
   keepFocus(box, () => {
-    box.innerHTML = `<div class="now-wrap hl-wrap">${normsHTML(d)}<div class="hl-sum muted">${esc(sum)}</div>${mine}`
+    box.innerHTML = `<div class="now-wrap hl-wrap">${tabsHTML()}${normsHTML(d)}<div class="hl-sum muted">${esc(sum)}</div>${mine}`
       + groupHTML(tr('With a CLAUDE.md of its own'), own, d)
       + groupHTML(tr('Without one'), bare, d, { fold: true })
       + groupHTML(tr('No folder on this computer'), away, d, { fold: true }) + '</div>';
@@ -115,6 +155,9 @@ function paint(d) {
     a.onclick = (e) => { e.preventDefault(); e.stopPropagation(); selectProject(a.dataset.slug); };
   });
   box.querySelector('.hl-again').onclick = (e) => { e.currentTarget.disabled = true; renderHealth({ force: true }); };
+  box.querySelectorAll('a.hl-fix-key').forEach((a) => {
+    a.onclick = (e) => { e.preventDefault(); e.stopPropagation(); openDrawer(a.dataset.key); };
+  });
   box.querySelectorAll('.hl-fix').forEach((b) => {
     b.onclick = (e) => { e.preventDefault(); e.stopPropagation(); fixProject(b.dataset.slug, b); }; // a click in <summary> folds it
   });
@@ -148,30 +191,46 @@ async function fixProject(slug, btn) {
     fixing.delete(slug);
     btn.disabled = false;
   }
+  renderHealth().catch(() => {});
 }
 
 let seq = 0;
 /** Draw the section; the folders are walked again only when the last answer is older than FRESH_MS, or on `force`. */
+export function repaintHealth() {
+  if (state.slug !== HEALTH || tab !== 'files' || !last || !$('health').firstChild) return;
+  const sig = sigOf(last.d);
+  if (sig !== drawnSig) { drawnSig = sig; paint(last.d); }
+}
+// the badge itself, not only state.live: a question of its Claude (hasAsk) outranks the state of the session
+const sigOf = (d) => JSON.stringify([d, fixes, Object.values(fixes).map((f) => liveBadge({ id: f.id, status: f.status }))]);
+async function loadFixes() {
+  try { fixes = (await api('GET', '/api/health/fixes', undefined, { quiet: true })).fixes || {}; } catch { /* the last ones stay */ }
+}
 export async function renderHealth({ force = false } = {}) {
+  wireTabs();
+  if (tab === 'stands') return renderStands(tabsHTML());
   if (last && !force && Date.now() - last.at < FRESH_MS) {
+    await loadFixes();
+    if (state.slug !== HEALTH || tab !== 'files') return;
     if (!$('health').firstChild) { drawnSig = ''; }
-    const sig = JSON.stringify(last.d);
+    const sig = sigOf(last.d);
     if (sig !== drawnSig) { drawnSig = sig; paint(last.d); }
     return;
   }
   const my = ++seq;
-  if (!last) $('health').innerHTML = `<div class="now-wrap"><div class="muted">${tr('Measuring the instructions of the projects…')}</div></div>`;
+  if (!last || !$('health').querySelector('.hl-again')) $('health').innerHTML = `<div class="now-wrap hl-wrap">${tabsHTML()}<div class="muted">${tr('Measuring the instructions of the projects…')}</div></div>`;
   let d;
-  try { d = await api('GET', '/api/health', undefined, { quiet: true }); }
+  try { [d] = await Promise.all([api('GET', '/api/health', undefined, { quiet: true }), loadFixes()]); }
   catch {
     if (my !== seq || state.slug !== HEALTH) return;
-    if (!last) $('health').innerHTML = `<div class="now-wrap"><div class="muted">${tr('Could not measure the instructions of the projects.')}</div></div>`;
+    if (tab !== 'files') return;
+    if (!last) $('health').innerHTML = `<div class="now-wrap hl-wrap">${tabsHTML()}<div class="muted">${tr('Could not measure the instructions of the projects.')}</div></div>`;
     else { const b = $('health').querySelector('.hl-again'); if (b) b.disabled = false; }
     return; // a failed reload keeps the last picture
   }
   if (my !== seq) return;
   last = { at: Date.now(), d };
-  if (state.slug !== HEALTH) return; // the person moved on; the answer waits for the next opening
-  drawnSig = JSON.stringify(d);
+  if (state.slug !== HEALTH || tab !== 'files') return; // the person moved on; the answer waits for the next opening
+  drawnSig = sigOf(d);
   paint(d);
 }

package/public/js/settings.js

@@ -1318,6 +1318,7 @@ const PLURAL_RU = {
   question: ['вопрос', 'вопроса', 'вопросов'],
   tool: ['инструмент', 'инструмента', 'инструментов'],
   'background task': ['фоновую работу', 'фоновые работы', 'фоновых работ'],
+  stand: ['стенд', 'стенда', 'стендов'],
 };
 export function plural(n, one, many) {
   const forms = LANG === 'ru' && PLURAL_RU[one];

package/public/js/sse.js

@@ -1,4 +1,5 @@
 
+import { repaintHealth } from './health.js';
 import { applyLive, patchCard, renderBoard } from './board.js';
 import { $, ALL, ALL_STATUSES, AUTO, HEALTH, CALENDAR, CHAOS, DASH, DONE, HORIZON, LANG, NOW, REVIEW, SETTINGS, api, esc, fmtNum, ic, readyInUse, retryUnsaved, seg, setGhSyncOn, state, tr } from './core.js';
 import { applyChecklist, closeDrawer, commentArrived, openDrawer, openTerminalOf, peekTerminal, refreshWork, renderComments, renderIssueRow, syncOpenDrawerStatus } from './drawer.js';
@@ -70,7 +71,7 @@ async function loadLive() {
     const fresh = applyTerminalQuestions(live.questions);
     if (liveLoaded) maybeQuestionAlert(fresh, maybeWaitingAlert(changes));
     liveLoaded = true;
-    markNowEntry(); repaintReview();
+    markNowEntry(); repaintReview(); repaintHealth();
   } catch {  }
 }
 
@@ -347,12 +348,12 @@ function streamMessage(data) {
   if (ev.type === 'sync.status') { refreshSync(); return; }
   if (ev.type === 'session.chat') { chatEvent(ev.data?.session); return; }
   if (ev.type === 'task.work') { const open = state.drawerKey && (ev.data?.keys || []).includes(state.drawerKey); if (open) refreshUsage(state.drawerKey); if (open) refreshWork(state.drawerKey); return; }
-  if (ev.type === 'task.live') { liveEvents++; state.liveProjects = ev.data?.projects || []; maybeQuestionAlert(applyTerminalQuestions(ev.data?.questions), maybeWaitingAlert(applyLive(ev.data?.tasks))); markNowEntry(); peekTerminal(); if (state.slug === DASH || state.slug === NOW || state.slug === REVIEW) loadTasks().catch(() => {}); return; }
+  if (ev.type === 'task.live') { liveEvents++; state.liveProjects = ev.data?.projects || []; maybeQuestionAlert(applyTerminalQuestions(ev.data?.questions), maybeWaitingAlert(applyLive(ev.data?.tasks))); markNowEntry(); peekTerminal(); if (state.slug === DASH || state.slug === NOW || state.slug === REVIEW) loadTasks().catch(() => {}); repaintHealth(); return; }
   if (ev.type === 'task.checklist') { applyChecklist(ev.data?.key, ev.data?.checklist); if (state.slug === NOW && !ev.data?.text_only) loadTasks().catch(() => {}); return; }
   if (ev.type === 'limits.updated') { applyLimits(ev.data); return; }
   if (ev.type === 'share.updated') { applyShare(ev.data); return; }
   if (ev.type === 'automation.updated') { applyAutomations(ev.data); return; }
-  if (ev.type === 'ask.created' || ev.type === 'ask.removed') { applyAskEvent(ev); return; }
+  if (ev.type === 'ask.created' || ev.type === 'ask.removed') { applyAskEvent(ev); repaintHealth(); return; }
   if (ev.type === 'task.comment') commentArrived(ev.data.key, ev.data.comment, ev.data.comments_n);
   maybeReviewSound(ev);
   maybeReviewNotify(ev);

package/public/style.css

@@ -2783,6 +2783,22 @@ a.hl-name:hover { color: var(--accent); }
 .hl-start { flex: none; font-size: 12px; color: var(--muted); font-variant-numeric: tabular-nums; white-space: nowrap; }
 .hl-start.hl-heavy { color: var(--accent); }
 .hl-fix { flex: none; font-size: 12px; padding: 3px 10px; }
+.hl-fixing { flex: none; display: inline-flex; align-items: center; gap: 8px; font-size: 12px; white-space: nowrap; }
+.hl-fix-key { color: var(--text); font-variant-numeric: tabular-nums; }
+.hl-fixing .card-live { font-size: 12px; }
+.hl-tabs { margin-bottom: 2px; }
+.st-row { align-items: center; }
+.st-pick { flex: none; width: 15px; height: 15px; margin: 0; accent-color: var(--accent); cursor: pointer; }
+.st-pick-gap { flex: none; width: 15px; }
+.st-chev-gap { flex: none; width: 13px; }
+.st-branch { font-family: ui-monospace, monospace; font-size: 11.5px; overflow-wrap: anywhere; }
+.st-why { color: var(--text); }
+.st-bar { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+.st-bar .btn-ghost, .st-bar .btn-primary { font-size: 12.5px; }
+.st-repo { display: flex; flex-wrap: wrap; gap: 2px 10px; font-size: 12px; }
+.st-hint { padding: 0 2px; }
+.st-diff-btn { align-self: flex-start; font-size: 12px; padding: 3px 10px; }
+.st-diff { margin: 0; max-height: 360px; overflow: auto; font: 11.5px/1.45 ui-monospace, monospace; background: var(--input-bg); border: 1px solid var(--border-soft); border-radius: 6px; padding: 8px 10px; white-space: pre; }
 .hl-files { display: flex; flex-direction: column; gap: 6px; padding: 0 0 12px 23px; }
 .hl-file { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 1px 12px; font-size: 12px; line-height: 1.4; }
 .hl-file-path { font-family: ui-monospace, monospace; font-size: 11.5px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
@@ -2794,7 +2810,9 @@ a.hl-name:hover { color: var(--accent); }
   .hl-norm { grid-template-columns: 1fr; }
   .hl-row { align-items: flex-start; }
   .hl-start { display: none; }
+  .hl-start.st-size { display: inline; align-self: flex-start; }
   .hl-state { white-space: normal; }
+  .hl-fixing { flex: 0 1 auto; flex-wrap: wrap; justify-content: flex-end; row-gap: 4px; max-width: 50%; white-space: normal; text-align: right; }
   .hl-file { grid-template-columns: 1fr; }
   .hl-file-size { grid-column: 1; grid-row: auto; white-space: normal; }
 }

package/src/auto-health.js

@@ -68,6 +68,15 @@ export async function fixHolds(project, registry = readRegistry) {
   return { sessions: claudesAt(folder, entries), keys };
 }
 
+/** The open task «Shrink CLAUDE.md» of each project, the newest: {slug: {id, key, status}}. Read on every look — no walk. */
+export function openFixes() {
+  const rows = db.prepare(`SELECT p.slug, t.id, p.prefix || '-' || t.task_no AS key, t.status FROM tasks t JOIN projects p ON p.id = t.project_id
+    WHERE p.archived = 0 AND t.title IN (?, ?) AND t.status NOT IN ('done', 'cancelled') ORDER BY t.id`).all(TITLES.ru, TITLES.en);
+  const out = {};
+  for (const r of rows) out[r.slug] = { id: r.id, key: r.key, status: r.status }; // the newest wins
+  return out;
+}
+
 const fixing = new Map(); // slug → the press in flight
 /** The task of «Fix» for a project: one still open of the same title (backlog → To do), else a new one in To do.
     {key, created} or {code, error, reason, …} of a refusal. */

package/src/phantom.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { claudeCli, claudeRunnable, EFFORT_VAR, effortProblem, keysProblem, onPath } from './launch.js';
 import { SESSION_ID_RE } from './claude-sessions.js';
 import { db, logError } from './db.js';
-import { claudeConfigFile, DATA_DIR, tmuxSocket } from './config.js';
+import { claudeConfigFile, DATA_DIR, PORT, tmuxSocket } from './config.js';
 import { readRegistry, stateOf, screenState } from './claude-live.js';
 import { waitsOwnWork } from './own-wait.js';
 import { clearKeys, inField, promptBox, tallBox, undim } from './prompt-box.js';
@@ -511,6 +511,36 @@ async function captureScreens(sids) {
   return new Map(sids.map((sid, i) => [sid, parts[i]]).filter(([, screen]) => screen !== undefined));
 }
 
+const portOfEnv = (env) => {
+  const m = /^KB_URL=(.*)$/m.exec(env || '');
+  if (!m) return null;
+  try { const u = new URL(m[1].trim()); return Number(u.port || (u.protocol === 'https:' ? 443 : 80)); } catch { return null; }
+};
+/** The port of the board that started each session (KB_URL in the session's environment): Map sid → port, or null with
+    no KB_URL; a session tmux did not answer about (closed in between) is missing. One call to tmux, as captureScreens. */
+export async function boardPorts(sids) {
+  const out = new Map();
+  if (!sids.length || !tmuxBin()) return out;
+  const cut = `kb-cut-${randomUUID()}`;
+  const r = await tmux(...sids.flatMap((sid) => [['display-message', '-p', cut], ['show-environment', '-t', `=${sessionName(sid)}`]]));
+  if (!r.err) {
+    const parts = r.out.split(`${cut}\n`).slice(1);
+    sids.forEach((sid, i) => { if (parts[i] !== undefined) out.set(sid, portOfEnv(parts[i])); });
+    return out;
+  }
+  // a session that closed in between fails the whole chain: the rest are asked one by one
+  for (const sid of sids) {
+    const one = await tmux(['show-environment', '-t', `=${sessionName(sid)}`]);
+    if (!one.err) out.set(sid, portOfEnv(one.out));
+  }
+  return out;
+}
+/** The sessions of `sids` this very board started (its port in their KB_URL). */
+export async function startedHere(sids) {
+  const ports = await boardPorts(sids);
+  return sids.filter((sid) => ports.get(sid) === PORT);
+}
+
 let sweeping = Promise.resolve();
 /** Close the board's terminals none of whose tasks is in play anymore. Returns the ids of the sessions closed. */
 export function closeFinishedTerminals() {
@@ -534,7 +564,10 @@ async function sweepOnce() {
     }
     return seen.get(sid);
   };
-  const panes = (await socketPanes()).filter((p) => ours.has(p.sid) && !tasksOf(p.sid).work);
+  const candidates = (await socketPanes()).filter((p) => ours.has(p.sid) && !tasksOf(p.sid).work);
+  if (!candidates.length) return [];
+  const here = new Set(await startedHere(candidates.map((p) => p.sid)));
+  const panes = candidates.filter((p) => here.has(p.sid));
   if (!panes.length) return [];
   const claudes = await registryByPid();
   const finished = [];
@@ -668,15 +701,12 @@ export async function boardLook() {
 /** The board's own live terminals with a question open on their screen: [sid]. */
 export async function boardQuestions() { return (await boardLook()).questions; }
 
-/** Sessions this board started before it kept board_sessions: one on its socket that is tied to its tasks
-    is its own. Only at the start of the board itself, never on a request — a test's database must never
-    claim a session of the live socket. */
 export async function adoptBoardTerminals() {
   if (!tmuxBin()) return 0;
   const tied = db.prepare('SELECT 1 FROM task_sessions WHERE session_id = ? LIMIT 1');
   const add = db.prepare('INSERT OR IGNORE INTO board_sessions (session_id) VALUES (?)');
   let n = 0;
-  for (const p of await socketPanes()) if (tied.get(p.sid)) n += add.run(p.sid).changes;
+  for (const sid of await startedHere((await socketPanes()).map((p) => p.sid).filter((sid) => tied.get(sid)))) n += add.run(sid).changes;
   return n;
 }
 

package/src/routes/health.js

@@ -1,6 +1,9 @@
-import { db } from '../db.js';
+import { db, uiLang } from '../db.js';
+import { PORT } from '../config.js';
+import { scalarQuery } from '../query-params.js';
+import { cleanupTasks, knownStand, standDiff, standsView } from '../stands.js';
 import { healthView } from '../health.js';
-import { healthFixTask } from '../auto-health.js';
+import { healthFixTask, openFixes } from '../auto-health.js';
 
 let flight = null; // a second request while the folders are walked waits for the same walk
 export default async function healthRoutes(app) {
@@ -11,6 +14,27 @@ export default async function healthRoutes(app) {
     }
     return flight;
   });
+  app.get('/api/health/stands', (req, reply) => {
+    const q = scalarQuery(req.query, ['refresh']);
+    if (q.error) return reply.code(400).send({ error: q.error });
+    return standsView({ force: q.values.refresh === '1' });
+  });
+  // what of a stand is not in main — only a folder of the last walk, never a path the request makes up
+  app.get('/api/health/stands/diff', async (req, reply) => {
+    const q = scalarQuery(req.query, ['path']);
+    if (q.error) return reply.code(400).send({ error: q.error });
+    if (!q.values.path || !knownStand(q.values.path)) return reply.code(404).send({ error: 'no such stand in the last look', field: 'path' });
+    return standDiff(q.values.path);
+  });
+  // the task of the cleanup — one per repository; the page then starts each as «Fix» does
+  app.post('/api/health/stands/task', async (req, reply) => {
+    const paths = req.body?.paths;
+    if (!Array.isArray(paths) || !paths.length || paths.some((p) => typeof p !== 'string')) return reply.code(400).send({ error: 'paths: a list of folders', field: 'paths' });
+    const r = await cleanupTasks(app, paths, uiLang() === 'en' ? 'en' : 'ru', { host: `127.0.0.1:${PORT}` });
+    if (r.code) { const { code, ...body } = r; return reply.code(code).send(body); }
+    return r;
+  });
+  app.get('/api/health/fixes', () => ({ fixes: openFixes() }));
   app.post('/api/health/fix', async (req, reply) => {
     const slug = req.body?.project;
     if (typeof slug !== 'string' || !slug) return reply.code(400).send({ error: 'project: a slug', field: 'project' });

package/src/routes/system.js

@@ -13,7 +13,7 @@ import { listBackups, backupNow, backupPath, backupState, ATTACH_MIRROR } from '
 import { inspectBackup, startPreview, stopPreview, currentPreview, UPLOAD_PREFIX } from '../restore.js';
 import { langOverride, ghOwnerEnv, ghRepoEnv, launchDryRun, PORT } from '../config.js';
 import { claudeWord, launchOptions, launchProblem, launchSpec, runLaunch } from '../launch.js';
-import { TMUX_COMMAND_MAX, boardProblem, claudeAtPrompt, folderTrusted, lookedLately, markTaskless, phantomAvailable, phantomPane, phantomSpec, phantomStop, runPhantom, taskTerminal, tmuxBin, tmuxCommandBytes, tmuxRefusal } from '../phantom.js';
+import { TMUX_COMMAND_MAX, boardProblem, claudeAtPrompt, folderTrusted, lookedLately, markTaskless, phantomAvailable, phantomPane, phantomSpec, phantomStop, runPhantom, startedHere, taskTerminal, tmuxBin, tmuxCommandBytes, tmuxRefusal } from '../phantom.js';
 import { ADOPT_TOKEN, freshTerminalSessions, isBoardSession, markBoardSession, markResumed, prepHolder, tieLaunched } from '../claude-sessions.js';
 import { CHECK_LABEL, OPEN_CHECK, doneRules, isCheck, leadCheck } from '../review-check.js';
 import { liveTick, readRegistry } from '../claude-live.js';
@@ -601,7 +601,7 @@ export default async function systemRoutes(app) {
         let term = await taskTerminal(t.id);
         // returned the task, the last round) makes room, or the fix waited for its terminal for up to six hours. Only the fix of
         // an automation asks for it (`adopt` would not do: a resume sends that too), and never over a terminal being looked at
-        for (let i = 0; i < ROOM_TRIES && b.makeRoom === ADOPT_TOKEN && term?.session && !term.unknown && !term.dead && await restsAtPrompt(term.session); i += 1) {
+        for (let i = 0; i < ROOM_TRIES && b.makeRoom === ADOPT_TOKEN && term?.session && !term.unknown && !term.dead && (await startedHere([term.session])).length && await restsAtPrompt(term.session); i += 1) {
           await phantomStop(term.session);
           term = await taskTerminal(t.id);
         }

package/src/share.js

@@ -46,7 +46,7 @@ function knownHosts(port) {
    GitHub mirror, the door itself. Reading them is fine; changing — 403 to a guest. Backups are not read either
    (`OWNER_READ`): one is the whole database, `share.key` included, and the key is the door's secret. The board itself
    (tasks, the chat and terminals of Claude, answers to its questions) is shared, as the owner asked. */
-const OWNER_READ = [/^\/api\/backups(\/|$)/];
+const OWNER_READ = [/^\/api\/backups(\/|$)/, /^\/api\/health\/stands(\/|$)/];
 const OWNER_ONLY = [/^\/api\/claude\/hooks/, /^\/api\/update/, /^\/api\/fs\/pick/, /^\/api\/skills/,
   /^\/api\/projects\/(clone|server-git|ssh-check)/, /^\/api\/projects\/[^/]+\/docs/, /^\/api\/sync\/config/, /^\/api\/share/, /^\/api\/flow/,
   /^\/api\/tasks\/[^/]+\/chat\/run/]; // the chat's command opens a Terminal window on the owner's screen

package/src/stands.js

@@ -0,0 +1,388 @@
+
+import { execFile } from 'node:child_process';
+import { realpath, stat, statfs } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, sep } from 'node:path';
+import { existsSync } from 'node:fs';
+import { db } from './db.js';
+import { readRegistry, stateOf } from './claude-live.js';
+import { bin } from './bin-path.js';
+
+const GIT_MS = 20_000;
+const DU_MS = 120_000;
+const AT_ONCE = 4; // folders walked side by side
+export const STANDS_FRESH_MS = 10 * 60_000; // an older picture is walked again on the next look
+export const FORCE_EVERY_MS = 15_000; // «Check again» — not more often
+const WORK = new Set(['prep', 'doing', 'ready', 'deploy']);
+const DIFF_MAX = 200_000;
+
+const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' };
+function run(cmd, args, { cwd, timeout = GIT_MS, max = 32 * 1024 * 1024 } = {}) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { cwd, timeout, maxBuffer: max, env }, (err, out) => resolve(err ? { err, out: String(out || '') } : { out: String(out) }));
+  });
+}
+const git = (dir, args, opts) => run(bin('git'), ['-C', dir, ...args], opts);
+const real = async (p) => { try { return await realpath(p); } catch { return p; } };
+export const within = (folder, path) => {
+  const rel = relative(folder, path);
+  return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+};
+
+/** `git worktree list --porcelain` read: [{path, head, branch, detached, locked, prunable, bare}] — the first is the main
+    checkout. Pure. */
+export function parseWorktrees(text) {
+  const out = [];
+  for (const block of String(text).split(/\n\s*\n/)) {
+    const w = {};
+    for (const line of block.split('\n')) {
+      const [k, ...rest] = line.split(' ');
+      const v = rest.join(' ');
+      if (k === 'worktree') w.path = v;
+      else if (k === 'HEAD') w.head = v;
+      else if (k === 'branch') w.branch = v.replace(/^refs\/heads\//, '');
+      else if (k === 'detached') w.detached = true;
+      else if (k === 'locked') w.locked = v || true;
+      else if (k === 'prunable') w.prunable = v || true;
+      else if (k === 'bare') w.bare = true;
+    }
+    if (w.path) out.push(w);
+  }
+  return out;
+}
+
+/** The key of a task in the name of a folder or a branch («ck-559-kanban-task-0e9ea3», «claude/IB-830») — upper case —
+    whose prefix is one of `prefixes`; null. A hash tail («pdf-ee85f1») is no key. Pure. */
+export function keyIn(names, prefixes) {
+  for (const name of names) {
+    for (const m of String(name || '').matchAll(/(?:^|[^a-z0-9])([a-z][a-z0-9]{0,9})-(\d{1,6})(?=$|[^a-z0-9])/gi)) {
+      const prefix = m[1].toUpperCase();
+      if (prefixes.has(prefix)) return `${prefix}-${Number(m[2])}`;
+    }
+  }
+  return null;
+}
+
+/* The issues a message names: «(lamaohub/server-comp#6144)», «#6144». A bare number of a few digits is no proof of the same
+   work — only `owner/repo#N` counts, the form the board's commits carry. */
+const ISSUE = /\b[\w.-]+\/[\w.-]+#(\d+)\b/g;
+export const issuesIn = (msg) => [...String(msg || '').matchAll(ISSUE)].map((m) => m[1]);
+
+/** A title that names its work: three words and fifteen characters at least — the board's commits are sentences; «WIP»,
+    «Fix tests», «Update README» stand in any long log for other work. */
+export const telling = (title) => String(title || '').trim().length >= 15 && String(title).trim().split(/\s+/).length >= 3;
+/** How the commits of a branch stand against main: each commit {sha, title, found: 'patch'|'title'|'issue'|null}.
+    `cherry` — the lines of `git cherry <main> <head>` («+ sha» not in main as a patch, «- sha» is); `main` — {titles: Set,
+    issues: Set} of the log of main; `messages` — sha → {title, body}. Pure. */
+export function matchCommits(cherry, messages, main) {
+  const out = [];
+  for (const line of String(cherry).split('\n')) {
+    const m = /^([+-]) ([0-9a-f]{7,64})/.exec(line.trim());
+    if (!m) continue;
+    const msg = messages.get(m[2]) || { title: '', body: '' };
+    let found = null;
+    if (m[1] === '-') found = 'patch';
+    else if (telling(msg.title) && main.titles.has(msg.title)) found = 'title';
+    else {
+      const issues = issuesIn(`${msg.title}\n${msg.body}`);
+      if (issues.length && issues.every((n) => main.issues.has(n))) found = 'issue';
+    }
+    out.push({ sha: m[2], title: msg.title, found });
+  }
+  return out;
+}
+
+/** The state of a stand from what was read of it. Pure: {state: 'reading'|'busy'|'unsent'|'free', why: [words…]}. */
+export function standState(s) {
+  if (s.read === false) return { state: 'reading', why: [] }; // the walk has not come to it yet
+  const why = [];
+  if (s.sessions) why.push('session');
+  if (s.processes) why.push('process');
+  if (s.task && WORK.has(s.task.status)) why.push('task');
+  if (why.length) return { state: 'busy', why };
+  if (s.locked) why.push('locked');
+  if (s.dirty === null || s.commits === null || s.processes === null) why.push('unknown'); // git or lsof did not answer, or no main to measure by
+  if (s.dirty) why.push('dirty');
+  if (s.commits?.some((c) => !c.found)) why.push('commits');
+  if (s.detached && s.commits?.length) why.push('detached');
+  if (why.length) return { state: 'unsent', why };
+  return { state: 'free', why: [] };
+}
+
+/** The main branch of the origin to measure against: origin/main, origin/master, else the local main/master; null. */
+async function mainRef(top) {
+  for (const ref of ['refs/remotes/origin/main', 'refs/remotes/origin/master', 'refs/heads/main', 'refs/heads/master']) {
+    const r = await git(top, ['rev-parse', '--verify', '--quiet', ref]);
+    if (!r.err && r.out.trim()) return ref.replace(/^refs\/(remotes|heads)\//, '');
+  }
+  return null;
+}
+
+/** The titles and issue numbers in the log of main (the newest 50 000 commits). */
+async function mainLog(top, ref) {
+  const r = await git(top, ['log', '--max-count=50000', '--format=%s%x1f%b%x1e', ref], { max: 256 * 1024 * 1024, timeout: 60_000 });
+  const titles = new Set();
+  const issues = new Set();
+  if (r.err) return { titles, issues, failed: true };
+  for (const rec of r.out.split('\x1e')) {
+    const [title, body = ''] = rec.split('\x1f');
+    const t = title.trim();
+    if (t) titles.add(t);
+    for (const n of issuesIn(`${t}\n${body}`)) issues.add(n);
+  }
+  return { titles, issues };
+}
+
+/** The folders where some process stands (its cwd) — one call to lsof; null when lsof did not answer. */
+async function processFolders() {
+  const r = await run(bin('lsof'), ['-n', '-P', '-a', '-d', 'cwd', '-Fn'], { timeout: 30_000, max: 64 * 1024 * 1024 });
+  // lsof exits 1 when some processes could not be read — the rest is still there; killed by the timeout, the list is partial
+  if (r.err && (!r.out || r.err.killed || r.err.signal)) return null;
+  const out = [];
+  for (const line of r.out.split('\n')) if (line.startsWith('n/')) out.push(line.slice(1));
+  return out;
+}
+
+let picture = null; // the last walk: {at, done, total, repos, stands, running}
+let flight = null;
+let forcedAt = 0;
+
+/** What is known of the stands now; a walk starts when none is known, the picture is older than STANDS_FRESH_MS, or on
+    `force` (not more often than FORCE_EVERY_MS). */
+// the folders of the board's projects: a project added, moved or archived since the walk makes the picture old at once
+const foldersNow = () => JSON.stringify(db.prepare("SELECT path FROM projects WHERE archived = 0 AND path IS NOT NULL AND path != '' ORDER BY id").all().map((r) => r.path));
+export function standsView({ force = false } = {}) {
+  const old = !picture || Date.now() - picture.at > STANDS_FRESH_MS || picture.folders !== foldersNow();
+  if (!flight && (old || (force && Date.now() - forcedAt > FORCE_EVERY_MS))) {
+    if (force) forcedAt = Date.now();
+    if (picture) picture.running = true; // the page asks again until the new walk has its picture
+    flight = walk().catch((e) => { picture = { ...(picture || emptyPicture()), running: false, error: e.message }; }).finally(() => { flight = null; });
+  }
+  return shown(picture || { ...emptyPicture(), running: true });
+}
+const emptyPicture = () => ({ at: Date.now(), done: 0, total: 0, repos: [], stands: [], running: true, folders: foldersNow() });
+const shown = (p) => ({ at: p.at, running: Boolean(p.running), done: p.done, total: p.total, error: p.error || null,
+  repos: p.repos.map(({ log, ...r }) => r), stands: p.stands.map(({ messages, ...s }) => ({ ...s, ...standState(s) })) });
+/** For a test: wait for the walk in flight. */
+export const standsSettled = () => flight || Promise.resolve();
+/** For a test: forget the last picture. */
+export function forgetStands() { picture = null; forcedAt = 0; }
+
+/** The repositories of the board's projects: [{top, common, projects: [{id, slug, name, prefix, path}]}]. */
+async function boardRepos() {
+  const projects = db.prepare('SELECT id, slug, name, prefix, path FROM projects WHERE archived = 0 AND path IS NOT NULL AND path != \'\' ORDER BY position, name COLLATE NOCASE').all();
+  const byCommon = new Map();
+  for (const p of projects) {
+    if (!existsSync(p.path)) continue;
+    const r = await git(p.path, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    if (r.err) continue;
+    const common = await real(r.out.trim());
+    if (!byCommon.has(common)) byCommon.set(common, { common, projects: [] });
+    byCommon.get(common).projects.push(p);
+  }
+  return [...byCommon.values()];
+}
+
+async function walk() {
+  const prefixes = new Map(db.prepare('SELECT prefix, id FROM projects').all().map((r) => [String(r.prefix).toUpperCase(), r.id]));
+  const taskOf = db.prepare(`SELECT t.id, t.status, t.title, p.slug, p.name AS project_name FROM tasks t JOIN projects p ON p.id = t.project_id
+    WHERE p.prefix = ? COLLATE NOCASE AND t.task_no = ?`);
+  const next = { at: Date.now(), done: 0, total: 0, repos: [], stands: [], running: true, folders: foldersNow() };
+  for (const repo of await boardRepos()) {
+    const list = await git(repo.projects[0].path, ['worktree', 'list', '--porcelain']);
+    if (list.err) continue;
+    const all = parseWorktrees(list.out);
+    const top = all[0]?.path;
+    if (!top) continue;
+    const ref = await mainRef(top);
+    let free = null;
+    try { const f = await statfs(top); free = Number(f.bavail) * Number(f.bsize); } catch { /* not known */ }
+    const r = { top, main: ref, free, projects: repo.projects.map(({ slug, name }) => ({ slug, name })), log: null };
+    next.repos.push(r);
+    for (const w of all.slice(1)) {
+      if (w.bare) continue;
+      const key = keyIn([basename(w.path), w.branch], new Set(prefixes.keys()));
+      const t = key ? taskOf.get(key.split('-')[0], Number(key.split('-')[1])) : null;
+      // the project of the stand: its key's, else the project of the repository whose folder is its top, else the first
+      const own = (t && repo.projects.find((p) => p.slug === t.slug)) || repo.projects.find((p) => p.path === top) || repo.projects[0];
+      next.stands.push({
+        path: w.path, top, branch: w.branch || null, head: w.head || null, detached: Boolean(w.detached),
+        locked: w.locked ? (w.locked === true ? '' : w.locked) : null, prunable: Boolean(w.prunable),
+        project: { slug: own.slug, name: own.name }, key,
+        task: t ? { id: t.id, status: t.status, title: t.title } : null,
+        read: false, dirty: null, changes: null, commits: null, sessions: 0, processes: 0, size: null, changed_at: null, missing: false,
+      });
+    }
+  }
+  next.total = next.stands.length;
+  // the sizes of the last walk stay on until measured anew: a stand does not jump to «—» on «Check again»
+  const before = new Map((picture?.stands || []).map((s) => [s.path, s]));
+  for (const s of next.stands) { const b = before.get(s.path); if (b) { s.size = b.size; s.changed_at = b.changed_at; } }
+  picture = next;
+
+  const registry = [...(await readRegistry()).values()].filter((e) => e.cwd && stateOf(e) !== 'gone');
+  const sessionDirs = await Promise.all(registry.map((e) => real(e.cwd)));
+  const procDirs = await processFolders();
+  const logs = new Map();
+  const logOf = (top, ref) => {
+    if (!logs.has(top)) logs.set(top, ref ? mainLog(top, ref) : Promise.resolve({ titles: new Set(), issues: new Set(), failed: true }));
+    return logs.get(top);
+  };
+  const reposByTop = new Map(next.repos.map((r) => [r.top, r]));
+
+  const one = async (s) => {
+    const dir = await real(s.path);
+    s.sessions = sessionDirs.filter((d) => within(dir, d)).length;
+    s.processes = procDirs ? procDirs.filter((d) => within(dir, d)).length : null; // null — not known: no stand is free by it
+    // no folder (deleted by hand, `prunable`): nothing in it to lose, but its branch is still compared with main below
+    if (!existsSync(s.path)) { s.missing = true; s.dirty = 0; s.changes = { files: 0 }; }
+    const st = s.missing ? null : await git(s.path, ['status', '--porcelain', '--untracked-files=normal']);
+    if (!st) { /* the folder is gone */ } else if (st.err) { s.dirty = null; } else {
+      const lines = st.out.split('\n').filter(Boolean);
+      s.dirty = lines.length;
+      s.changes = { files: lines.length, untracked: lines.filter((l) => l.startsWith('??')).length };
+    }
+    const ref = reposByTop.get(s.top)?.main;
+    if (!ref || !s.head) { s.commits = null; return; }
+    const ch = await git(s.top, ['cherry', ref, s.head]);
+    if (ch.err) { s.commits = null; return; }
+    const shas = ch.out.split('\n').map((l) => l.trim().slice(2)).filter(Boolean);
+    const messages = new Map();
+    if (shas.length) {
+      const lg = await git(s.top, ['log', '--no-walk=unsorted', '--format=%H%x1f%s%x1f%b%x1e', ...shas.slice(0, 500)]);
+      for (const rec of (lg.out || '').split('\x1e')) {
+        const [sha, title = '', body = ''] = rec.replace(/^\n/, '').split('\x1f');
+        if (sha) messages.set(sha.trim(), { title: title.trim(), body });
+      }
+    }
+    const main = await logOf(s.top, ref);
+    s.commits = matchCommits(ch.out, messages, main).map((c) => ({ ...c, sha: c.sha.slice(0, 12) }));
+    if (s.missing) return;
+    const lc = await git(s.path, ['log', '-1', '--format=%ct', 'HEAD']);
+    s.changed_at = Number(lc.out?.trim()) * 1000 || null;
+    try { // the index moves with every add, commit and checkout in the folder
+      const gd = await git(s.path, ['rev-parse', '--path-format=absolute', '--git-dir']);
+      const idx = await stat(join(gd.out.trim(), 'index'));
+      s.changed_at = Math.max(s.changed_at || 0, idx.mtimeMs);
+    } catch { /* the date of the commit stays */ }
+  };
+  await pool(next.stands, one, (s) => { s.read = true; next.done += 1; });
+  // sizes last: the states are what the page needs first
+  await pool(next.stands.filter((s) => !s.missing), async (s) => {
+    const du = await run(bin('du'), ['-sk', s.path], { timeout: DU_MS });
+    const kb = Number((du.out || '').split(/\s/)[0]);
+    if (Number.isFinite(kb) && kb > 0) s.size = kb * 1024;
+  });
+  next.running = false;
+  next.at = Date.now();
+}
+
+async function pool(items, fn, after = () => {}) {
+  let i = 0;
+  const worker = async () => {
+    while (i < items.length) {
+      const item = items[i++];
+      try { await fn(item); } catch { /* one stand that could not be read stays unread */ }
+      after(item);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(AT_ONCE, items.length) }, worker));
+}
+
+/** A stand of the last picture by its folder — the only folders the routes below may name. */
+export const knownStand = (path) => picture?.stands.find((s) => s.path === path) || null;
+
+/** What of a stand is not in main, for the eyes of the owner: the patches of its commits found nowhere in main, then the
+    changes not committed — capped at DIFF_MAX characters. */
+export async function standDiff(path) {
+  const s = knownStand(path);
+  if (!s) return null;
+  const parts = [];
+  const lost = (s.commits || []).filter((c) => !c.found).map((c) => c.sha);
+  if (lost.length) {
+    const r = await git(s.top, ['show', '--stat', '--patch', '--format=commit %H%n%s%n', ...lost.slice(0, 50)], { max: 64 * 1024 * 1024 });
+    parts.push(r.out);
+  }
+  if (s.dirty && existsSync(s.path)) {
+    const r = await git(s.path, ['diff', 'HEAD', '--stat', '--patch'], { max: 64 * 1024 * 1024 });
+    const u = await git(s.path, ['ls-files', '--others', '--exclude-standard']);
+    parts.push(`# not committed\n${r.out}${u.out.trim() ? `\n# untracked\n${u.out}` : ''}`);
+  }
+  const text = parts.join('\n');
+  return { text: text.length > DIFF_MAX ? `${text.slice(0, DIFF_MAX)}\n… (cut at ${DIFF_MAX} characters)` : text, cut: text.length > DIFF_MAX };
+}
+
+/* The task of the cleanup: one per repository, in the project of most of its chosen stands. Its Claude checks each stand
+   again right before removing it — the picture may be minutes old, and a session may have opened in a folder since. */
+const TITLES = { ru: 'Убрать старые стенды', en: 'Remove old stands' };
+export const STAND_TITLES = TITLES;
+const gb = (n) => (n ? `${(n / 1024 ** 3).toFixed(1)} GB` : '?');
+export function cleanupWords(lang, repo, chosen, unsent) {
+  const list = chosen.map((s) => `- ${s.path} — ${s.branch ? `branch ${s.branch}` : 'detached HEAD'}${s.head ? ` @ ${s.head.slice(0, 12)}` : ''}${s.size ? ` · ${gb(s.size)}` : ''}${s.missing ? ' · no folder: `git worktree prune`' : ''}`).join('\n');
+  const asks = unsent.map((s) => `- ${s.path}${s.branch ? ` (${s.branch})` : ''}: ${standState(s).why.join(', ')}`).join('\n');
+  if (lang === 'en') {
+    return `Remove the old stands (git worktrees) of ${repo.top}, chosen in Health → Stands: ${chosen.length}.\n\n${list}\n\n`
+      + 'For EACH stand, right before removing it, check all three again — skip it and say why if any fails:\n'
+      + '1. nothing uncommitted or untracked: `git -C <folder> status --porcelain` is empty;\n'
+      + `2. every commit of the branch is in ${repo.main || 'origin/main'}: \`git fetch origin\`, then \`git cherry ${repo.main || 'origin/main'} <branch>\`; a «+» commit counts only if the same title or the same issue number is in \`git log ${repo.main || 'origin/main'}\` — otherwise it is work not handed in;\n`
+      + '3. not busy: no Claude session and no process in the folder (`lsof +D <folder>`), the task of its key is not in prep/doing/ready/deploy.\n\n'
+      + 'Then `git worktree remove <folder>` (never --force) and `git branch -d <branch>` (never -D; refused — leave the branch and say so). '
+      + 'Do not touch the main checkout, the branch main, other projects or the stash.\n\n'
+      + 'In the report: per stand — removed or kept and why, and the last commit of each removed branch (`<sha> <branch>`): it lives on in the reflog and can be brought back with `git branch <branch> <sha>`.'
+      + (asks ? `\n\nNot in this task — work not in main, ask the owner what to do with each:\n${asks}` : '')
+      + '\n\nThe board opened this task: Health → Stands.';
+  }
+  return `Убрать старые стенды (рабочие копии git) в ${repo.top}, выбранные в «Здоровье → Стенды»: ${chosen.length}.\n\n${list}\n\n`
+    + 'По КАЖДОМУ стенду прямо перед удалением ещё раз проверить все три условия — не прошло хоть одно, стенд не трогать и сказать почему:\n'
+    + '1. нет незакоммиченного и неотслеживаемого: `git -C <папка> status --porcelain` пуст;\n'
+    + `2. каждый коммит ветки есть в ${repo.main || 'origin/main'}: \`git fetch origin\`, затем \`git cherry ${repo.main || 'origin/main'} <ветка>\`; коммит с «+» считается, только если тот же заголовок или тот же номер issue есть в \`git log ${repo.main || 'origin/main'}\` — иначе это несданная работа;\n`
+    + '3. не занят: в папке нет сессии Claude и процесса (`lsof +D <папка>`), задача ключа не в prep/doing/ready/deploy.\n\n'
+    + 'Затем `git worktree remove <папка>` (без --force) и `git branch -d <ветка>` (не -D; отказал — ветку оставить и сказать). '
+    + 'Основной чекаут, ветку main, чужие проекты и stash не трогать.\n\n'
+    + 'В отчёте: по каждому стенду — удалён или оставлен и почему, и последний коммит каждой удалённой ветки (`<sha> <ветка>`): она ещё живёт в reflog, вернуть — `git branch <ветка> <sha>`.'
+    + (asks ? `\n\nНе в этой задаче — работа, которой нет в main, спросить владельца, что делать с каждым:\n${asks}` : '')
+    + '\n\nЗадачу завела доска: «Здоровье → Стенды».';
+}
+
+/** The tasks of a cleanup of `paths` (folders of the last picture): only stands `free` by it; one task per repository —
+    the open one of the same title in that project (Backlog/To do: its description is written anew), else a new one in To
+    do. [{key, project, n}] or {code, error, reason}. */
+export async function cleanupTasks(app, paths, lang, headers) {
+  if (!picture) return { code: 409, reason: 'not-walked', error: 'the stands have not been looked at yet' };
+  const want = new Set(Array.isArray(paths) ? paths.filter((p) => typeof p === 'string') : []);
+  const shownNow = shown(picture).stands;
+  const chosen = shownNow.filter((s) => want.has(s.path) && s.state === 'free');
+  if (!chosen.length) return { code: 409, reason: 'nothing-free', error: 'none of the chosen stands can be removed' };
+  const byTop = new Map();
+  for (const s of chosen) { if (!byTop.has(s.top)) byTop.set(s.top, []); byTop.get(s.top).push(s); }
+  // one cleanup a repository, whichever of its projects holds it: two Claudes removing worktrees of one repository at once
+  // would race. All are looked at before any task is written — a refusal for the second must not lose the first one's task
+  const openOf = db.prepare(`SELECT p.slug, p.prefix || '-' || t.task_no AS key, t.status FROM tasks t JOIN projects p ON p.id = t.project_id
+    WHERE p.slug IN (SELECT value FROM json_each(?)) AND t.title IN (?, ?) AND t.status NOT IN ('done', 'cancelled') ORDER BY t.id DESC LIMIT 1`);
+  const plan = [];
+  for (const [top, list] of byTop) {
+    const repo = picture.repos.find((r) => r.top === top);
+    const open = openOf.get(JSON.stringify(repo.projects.map((p) => p.slug)), TITLES.ru, TITLES.en);
+    if (open && !['backlog', 'todo'].includes(open.status)) {
+      return { code: 409, reason: 'cleanup-open', key: open.key, error: `a cleanup of these stands is already ${open.status === 'review' ? 'waiting for your review' : 'in work'}: ${open.key}` };
+    }
+    const count = new Map();
+    for (const s of list) count.set(s.project.slug, (count.get(s.project.slug) || 0) + 1);
+    plan.push({ repo, list, open, slug: open?.slug || [...count].sort((a, b) => b[1] - a[1])[0][0] });
+  }
+  const out = [];
+  for (const { repo, list, open, slug } of plan) {
+    const description = cleanupWords(lang, repo, list, shownNow.filter((s) => s.top === repo.top && s.state === 'unsent'));
+    let key;
+    if (open) {
+      const res = await app.inject({ method: 'PATCH', url: `/api/tasks/${encodeURIComponent(open.key)}`, headers, payload: { description, status: 'todo' } });
+      if (res.statusCode >= 300) return { code: res.statusCode, error: res.json?.().error || 'could not update the task' };
+      key = open.key;
+    } else {
+      const res = await app.inject({ method: 'POST', url: '/api/tasks', headers, payload: { project: slug, title: TITLES[lang === 'en' ? 'en' : 'ru'], description, status: 'todo' } });
+      if (res.statusCode >= 300) return { code: res.statusCode, error: res.json().error || 'could not open the task' };
+      key = res.json().key;
+    }
+    out.push({ key, project: slug, n: list.length });
+  }
+  return { tasks: out };
+}