@ersbeth/codelife 0.0.0-stage → 0.11.1

package/scripts/work/branch.mjs

@@ -0,0 +1,81 @@
+// The branch a piece of work belongs on, derived once (R-192): `lot <n>` is lot #n's,
+// an existing `lot/<n>-*` or one derived from the umbrella's sentence; `issue <n>` is that issue's,
+// its lot's when its title names one, else its own existing one, else by where you stand. Reads only
+// — nothing is created or switched. A summary of `- branch:`, `- from:` for an existing branch — the
+// base, a resume's too — or a branch to cut, and `- develop:` for a cut from it; a branch that cannot be named, or a `develop`
+// its origin does not hold whole, prints `- stop:` and exits 1. `node <this directory>/branch.mjs
+// lot|issue <n>`, from the repository's root.
+import { prep, said } from '../prepare-lib.mjs';
+
+const [mode, n] = process.argv.slice(2);
+if (!['lot', 'issue'].includes(mode) || !/^\d+$/.test(n || '')) {
+  console.error('usage: node branch.mjs lot|issue <number>');
+  process.exit(2);
+}
+const { say, stop, done, op, must, title, slug, kind } = prep('branch');
+const tree = JSON.parse(must('git', 'status'));
+const view = (k) => JSON.parse(must('tracker', 'view', [k]));
+
+// A branch cut from `develop` is cut from what `origin/develop` holds whole, a forge being there to
+// carry the difference into a merge request.
+const held = () => {
+  if (kind() === 'none') return;
+  const r = op('git', 'is_ancestor', ['develop', 'origin/develop']);
+  const it = r.stdout.trim();
+  if (it === 'no origin') say('develop: no origin, nothing compared');
+  else if (r.status !== 0 || it !== 'contained') stop(`develop is not held whole by origin/develop (${it || said(r)}): \`git log origin/develop..develop\` to read what it holds that origin lacks, then \`git push -u origin develop\` after a pull when the two diverged`);
+  else say('develop: contained in origin/develop');
+};
+
+// The work branch already named for it, local or origin's, whatever its title became since; two is a stop.
+const work = /^(feature|fix|hotfix|lot)\//;
+const existing = (glob, what) => {
+  const names = [...new Set(must('git', 'branches', [glob]).split('\n').filter(Boolean).map((b) => b.replace(/^origin\//, '')))].filter((b) => work.test(b));
+  if (names.length > 1) stop(`two branches for ${what}: ${names.join(', ')} — which one is right is yours to say`);
+  return names[0];
+};
+
+// The lot's: an existing branch, or one cut from develop, its base either way; you stand on no other lot's.
+const lot = (k) => {
+  const found = existing(`lot/${k}-*`, `lot #${k}`);
+  const branch = found ?? `lot/${k}-${slug(view(k).title)}`;
+  say(`branch: ${branch} — ${found ? 'exists' : 'does not exist'}`);
+  say('from: develop');
+  if (!found) held();
+  if (/^lot\//.test(tree.branch) && tree.branch !== branch) stop(`you stand on ${tree.branch}, another lot's branch: two lots on one branch is two merge requests that cannot be separated`);
+  done();
+};
+
+if (mode === 'lot') lot(n);
+const issue = view(n);
+const named = title('title.lot_of.mjs', issue.title);
+if (named) lot(named);
+
+// No lot: a branch whose work is merged — its merge request, or its commits in a line — is no branch to work on — derive as if standing on develop.
+const parent = op('git', 'parent');
+let finished = parent.status === 0 && parent.stdout.startsWith('finished');
+let why = parent.stdout.trim();
+// A squash leaves no commit of its own in a line, which git.parent cannot see: the forge says it, where there is one.
+if (!finished && kind() !== 'none' && work.test(tree.branch)) {
+  const merged = must('tracker', 'mr.find_for_branch', [tree.branch]).split('\n').find((l) => l.endsWith(' merged'));
+  if (merged) [finished, why] = [true, `merge request ${merged.split(' ')[0]} merged`];
+}
+const here = finished ? 'develop' : tree.branch;
+if (finished) say(`${tree.branch} is finished (${why}): derived as if standing on develop`);
+// Its own branch, where a resume or a delegated run's return goes, wherever you stand.
+const own = existing(`*/${n}-*`, `#${n}`);
+if (own) {
+  say(`branch: ${own} — exists`);
+  say(`from: ${own.startsWith('hotfix/') ? 'main' : 'develop'}`);
+  done();
+}
+const cut = (kind, from) => {
+  say(`branch: ${kind}/${n}-${slug(issue.title)} — does not exist`);
+  say(`from: ${from}`);
+  if (from === 'develop') held();
+};
+if (here === 'develop') cut(issue.labels.includes('bug') ? 'fix' : 'feature', 'develop');
+else if (here === 'main' || here.startsWith('support/')) cut('hotfix', here);
+else if (work.test(here)) say(`branch: ${here} — in place`);
+else stop(`you stand on ${here}, neither a line nor a work branch: say where this work belongs`);
+done();

package/scripts/work/close.mjs

@@ -0,0 +1,74 @@
+// /work's close, one command (R-193): nothing reaches the forge unless every commit the closing
+// comment cites is one HEAD contains and the commit step made for this issue — its `Closes:` footer
+// names it, or, for `Already fixed in <hash> (#<earlier>)` — the hash with backticks on both sides or
+// none — its `Closes:` or `Refs:` footer names that earlier issue, of any lot, and the tracker reads it
+// closed; or, with `--wontfix`, it adds to docs/spec/ the refusal line the comment quotes. Then the comment and the close through scripts/tracker/close.mjs, and the line of the issue in its
+// umbrella's task list ticked, with any row whose issue is already closed; the umbrella closed when
+// the issue has its row and no member is open. A refusal prints `- stop:` and exits 1, nothing posted.
+// `codelife issue close <issue> <comment file> <hash>… [--wontfix]`, from the repository's root.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeLot, currentBranch, prep, said, tasks } from '../prepare-lib.mjs';
+
+const [n, file, ...rest] = process.argv.slice(2);
+const wontfix = rest.includes('--wontfix'), hashes = rest.filter((a) => a !== '--wontfix');
+if (!/^\d+$/.test(n || '') || !file || !hashes.length || !hashes.every((h) => /^[0-9a-f]{7,40}$/.test(h))) {
+  console.error('usage: codelife issue close <issue> <comment file> <hash>… [--wontfix]');
+  process.exit(2);
+}
+const { say, stop, done, op, must, title } = prep('close');
+
+let comment;
+try { comment = readFileSync(file, 'utf8'); } catch (e) { stop(`the comment cannot be read — ${e.message}`); }
+for (const h of hashes) {
+  if (!comment.includes(h)) stop(`the comment does not cite ${h}; nothing posted`);
+  // The commits from its parent to HEAD hold it only when HEAD contains it.
+  const r = op('git', 'log_since', [`${h}~1`]);
+  const c = r.status === 0 && JSON.parse(r.stdout).find((x) => x.sha.startsWith(h));
+  if (!c) stop(`${h} is not a commit HEAD contains${r.status ? ` — ${said(r)}` : ''}; nothing posted`);
+  const owner = comment.match(new RegExp(`Already fixed in (\`?)${h}[0-9a-f]*\\1 \\(#(\\d+)\\)`))?.[2] ?? n;
+  // Another issue's commit, of this lot or an earlier one, may cite it in `Refs:` alone (R-85); the issue's own must close it.
+  // A refusal another run already wrote (K-8's R-185): the commit adding to docs/spec/ the line the comment quotes.
+  const wrote = () => wontfix && owner === n && spawnSync('git', ['show', '--format=', '--unified=0', h, '--', 'docs/spec'], { encoding: 'utf8' }).stdout
+    .split('\n').some((l) => /^\+- \S/.test(l) && comment.includes(l.slice(1)));
+  const cites = c.closes.includes(`#${owner}`) ? 'closes' : owner !== n && c.refs.includes(`#${owner}`) ? 'cites' : wrote() ? 'wrote the refusal line quoted for' : '';
+  if (!cites) {
+    stop(`${h} (${c.subject}) closes ${c.closes.join(' ') || 'no issue'}${owner === n ? '' : ` and cites ${c.refs.join(' ') || 'no issue'}`}, not #${owner}: it is not the commit the commit step made; nothing posted`);
+  }
+  // `Refs:` is the footer of an issue that stays open (R-85), and a `Closes:` commit may be an abandoned one: an earlier issue must be closed.
+  if (owner !== n && !/^closed$/i.test(JSON.parse(must('tracker', 'view', [owner])).state)) {
+    stop(`${h} names #${owner}, which is not closed: the commit is not yet the fix; nothing posted`);
+  }
+  say(`commit: ${h} — ${c.subject} — ${cites} #${owner}, in HEAD`);
+}
+
+// Everything the close needs is read before anything is written: a view that fails stops the run
+// with nothing posted, never with the issue closed and its umbrella left behind.
+const issue = JSON.parse(must('tracker', 'view', [n]));
+const lot = title('title.lot_of.mjs', issue.title);
+const { body = '', state: lotState = '' } = lot ? JSON.parse(must('tracker', 'view', [lot])) : {};
+const row = (m, box) => new RegExp(`^- \\[${box}\\] #${m}\\b`, 'm');
+const ticked = row(n, '[xX]').test(body), unticked = row(n, ' ').test(body);
+// Every other row's state read from its issue, never from its tick (R-193): a closed member whose
+// line is unticked is ticked with this one — the reconciliation — and none still open closes the
+// umbrella on its `lot-closing` comment, unless this issue has no row there to close it with.
+const others = tasks(body).filter((t) => t.n !== n).map((t) => ({ ...t, closed: /^closed$/i.test(JSON.parse(must('tracker', 'view', [t.n])).state) }));
+const tick = [...(unticked ? [n] : []), ...others.filter((t) => t.closed && row(t.n, ' ').test(body)).map((t) => t.n)];
+const dir = mkdtempSync(join(tmpdir(), 'close-'));
+let after = body;
+for (const m of tick) {
+  after = title('lot.row.mjs', after, 'tick', m);
+  if (!after) stop(`#${lot}'s task list cannot be ticked — scripts/tracker/lot.row.mjs failed; nothing written`);
+}
+say(must('tracker', 'close', [n, file, ...(wontfix ? ['wontfix'] : [])]).trim());
+if (!lot) {
+  say('umbrella: none');
+  done();
+}
+if (tick.length) { writeFileSync(join(dir, 'body.md'), after); must('tracker', 'issue.update', [lot, join(dir, 'body.md')]); }
+const left = others.filter((t) => !t.closed).map((t) => `#${t.n}`);
+say(`umbrella: #${lot} — #${n}'s line ${unticked ? 'ticked' : ticked ? 'already ticked' : 'not in its task list'}; still open: ${left.join(', ') || 'none'}${ticked || unticked ? '' : ', so the umbrella stays open'}`);
+if (!left.length && (ticked || unticked)) say(`umbrella: ${closeLot(must, lot, lotState, tasks(body).map((t) => t.n), '/work', currentBranch())}, with its last member`);
+done();

package/scripts/work/member.mjs

@@ -0,0 +1,73 @@
+// `codelife lot join <umbrella> <n>[:S|M|L]…` and `codelife lot leave <umbrella> <n> <reason file>`
+// (R-251, R-202): a member's lot written in the two places it lives, as one operation — its
+// title's lot half, through scripts/tracker/title.*.mjs, and its row of the umbrella's `## The order`, through `lot.row.mjs`; a leave also opens the member's body on `Left lot #<umbrella> on <date>:
+// <reason>`, and closes the umbrella when no row is left open. A join refuses a member of another
+// lot, whose title would name two; its members' rows are appended in the order given, the umbrella
+// read once and written once (#1136). Every issue is viewed bare, its comments unread. Every new text
+// is computed before the first write, and none is written when one fails.
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeLot, prep, tasks } from '../prepare-lib.mjs';
+
+const [mode, u, ...rest] = process.argv.slice(2);
+const usage = () => {
+  console.error('usage: codelife lot join <umbrella> <n>[:S|M|L]... | codelife lot leave <umbrella> <n> <reason file>');
+  process.exit(2);
+};
+// A join's members in order, each `<n>[:S|M|L]` — or `<n> S|M|L`, the one-member form's effort.
+const members = [];
+for (const a of mode === 'join' ? rest : []) {
+  const m = a.match(/^(\d+)(?::([SML]))?$/);
+  if (m) members.push({ n: m[1], effort: m[2] });
+  else if (/^[SML]$/.test(a) && members.length && !members.at(-1).effort) members.at(-1).effort = a;
+  else usage();
+}
+const [n, reasonFile] = mode === 'leave' ? rest : [];
+if (!/^\d+$/.test(u || '') || (mode === 'join' ? !members.length : mode !== 'leave' || !/^\d+$/.test(n || '') || !reasonFile)) usage();
+const { say, stop, done, op, must, title } = prep(`lot ${mode}`);
+const view = (k) => JSON.parse(must('tracker', 'view', [k, '--bare'])), umbrella = view(u);
+const dir = mkdtempSync(join(tmpdir(), 'member-')), file = (name, text) => { writeFileSync(join(dir, name), text); return join(dir, name); };
+const date = new Date().toISOString().slice(0, 10);
+const cannot = (k) => stop(`#${u}'s task list or #${k}'s title cannot be written — scripts/tracker/title.*.mjs failed; nothing written`);
+
+let body = umbrella.body;
+const issues = [];   // { n, from, named, memberBody } — each member's write, in order
+if (mode === 'join') {
+  for (const { n, effort } of members) {
+    const member = view(n), lot = title('title.lot_of.mjs', member.title);
+    if (lot && lot !== u) stop(`#${n} is a member of lot #${lot} — \`codelife lot leave ${lot} ${n}\` first; nothing written`);
+    const named = lot ? member.title : title('title.join.mjs', member.title, u);
+    body = body && title('lot.row.mjs', body, 'add', n, file(`sentence-${n}`, title('title.sentence_of.mjs', member.title)), ...(effort ? [effort] : []));
+    if (!named || !body) cannot(n);
+    issues.push({ n, from: member.title, named, memberBody: '-' });
+  }
+} else {
+  let reason;   // one line, wherever it is written
+  try { reason = readFileSync(reasonFile, 'utf8').trim().replace(/\s+/g, ' '); } catch (e) { stop(`the reason cannot be read — ${e.message}`); }
+  const member = view(n), inLot = title('title.lot_of.mjs', member.title) === u;
+  const named = inLot ? title('title.leave.mjs', member.title, u) : member.title;
+  body = title('lot.row.mjs', umbrella.body, 'leave', n, date, file('reason', reason));
+  if (!named || !body) cannot(n);
+  issues.push({ n, from: member.title, named, memberBody: inLot ? file('member.md', `Left lot #${u} on ${date}: ${reason}\n\n${member.body}`) : '-' });
+}
+// A leave that leaves no row open closes the open umbrella (R-70): otherwise a lot with nothing to work.
+// A row whose issue cannot be viewed is not known closed, so it keeps the umbrella open and stops nothing.
+const changed = body !== umbrella.body.trim(), rows = tasks(body).map((t) => t.n), closed = (s) => /^closed$/i.test(s);
+const rowClosed = (m) => { const r = op('tracker', 'view', [m, '--bare']); return r.status === 0 && closed(JSON.parse(r.stdout).state); };
+const emptied = mode === 'leave' && rows.every(rowClosed);
+if (emptied) {   // every remaining row is closed: ticked in the same body update, as `issue close` does (R-193)
+  for (const m of rows.filter((m) => new RegExp(`^- \\[ \\] #${m}\\b`, 'm').test(body))) {
+    body = title('lot.row.mjs', body, 'tick', m);
+    if (!body) stop(`#${u}'s task list cannot be ticked — scripts/tracker/lot.row.mjs failed; nothing written`);
+  }
+}
+
+for (const i of issues) {
+  if (i.named !== i.from || i.memberBody !== '-') must('tracker', 'issue.update', [i.n, i.memberBody, file(`title-${i.n}`, i.named)]);
+  say(`member: #${i.n} — ${i.named}`);
+}
+if (body !== umbrella.body.trim()) must('tracker', 'issue.update', [u, file('body.md', body)]);
+say(`umbrella: #${u} — ${issues.map((i) => `#${i.n}`).join(', ')}'s row${issues.length > 1 ? 's' : ''} ${mode === 'join' ? 'appended' : 'removed'}${changed ? '' : ', already so'}`);
+if (emptied) say(`umbrella: ${closeLot(must, u, umbrella.state, rows, 'codelife lot leave', null)}, no member left open`);
+done();

package/scripts/work/prepare.mjs

@@ -0,0 +1,116 @@
+// /work's preparation, one command (R-288): the forge's authentication, then the number read as an
+// umbrella — an issue labelled `lot` — or a lone issue. An umbrella's task list, each member's state
+// and `plan` comment, the orphans its `debt-link` comments point at; a lone issue's evidence and its
+// last plan or refusal; a lot's member typed alone stops, naming its umbrella (C-892); a closed one
+// whose branch exists has only its merge request left (R-295). Then the
+// moved-rule check, the tree and the branch — every forge and git read through the scripts of
+// `scripts/tracker/`, `scripts/git/` and `scripts/read-roadmap/` — and a summary printed, which the brief and the table are made
+// from. A precondition or a read that fails prints `- stop:` and exits 1, before any table; nothing
+// reads stdin. `node <this directory>/prepare.mjs <umbrella-or-issue>`, from the repository's root.
+import { readFileSync } from 'node:fs';
+import { prep, said, first, gist, tasks as tasksOf } from '../prepare-lib.mjs';
+
+const n = process.argv[2];
+if (!/^\d+$/.test(n || '')) {
+  console.error('usage: node prepare.mjs <umbrella-or-issue-number>');
+  process.exit(2);
+}
+const { summary, say, stop, done, include, op, must, title, kind } = prep('prepare');
+
+// The contract and the forge: a forge that does not answer is an issue that cannot be read. Under
+// `none` the issues are files and there is no one to authenticate with.
+const forge = kind();
+if (forge === 'none') say('forge: none — the issues folder, no authentication');
+else {
+  const auth = op('tracker', 'auth');
+  if (auth.status !== 0) stop(`the forge's authentication — ${said(auth)}`);
+  say(`forge: ${forge} — ${auth.stdout.trim()}`);
+}
+
+// A repository that cannot run one test is not ported (R-190): no fix without its regression test.
+let pkg = {};
+try { pkg = JSON.parse(readFileSync('package.json', 'utf8')); } catch {}
+if (!pkg.scripts?.['test:one']) stop('no `test:one` script: this repository cannot run one test — `/setup`, then `/port-toolchain`');
+
+// The tree, the branch you stand on, and the one the work belongs on, by the branch script.
+const branch = (mode) => {
+  const tree = JSON.parse(must('git', 'status'));
+  const dirty = [...tree.staged, ...tree.modified, ...tree.untracked];
+  if (dirty.length) stop(`the tree is not clean: ${[...new Set(dirty)].join(', ')}`);
+  include(op('work', 'branch', [mode, n]));
+  say(`standing on: ${tree.branch}, the tree clean`);
+  done();
+};
+// A closed issue or umbrella has nothing left to work, but its branch may still hold a merge request
+// to open: a delegated run's return, its held choices put to you there (R-295). No branch, a stop.
+const finished = (mode) => {
+  if (!/^- branch: .* — exists$/m.test(op('work', 'branch', [mode, n]).stdout)) stop(`#${n} is closed — nothing to work`);
+  say(`closed: #${n} — nothing left to work but the merge request`);
+  branch(mode);
+};
+
+const issue = JSON.parse(must('tracker', 'view', [n]));
+// What an issue's comments say of its plan: the last plan, refusal or closing — the one reader both
+// paths call, so a refused member is named as a refused lone issue is. On an issue still open, a last
+// closing is a delegated run's STATUS: its stop said, after the plan or refusal it stopped in.
+const planOf = (comments) => {
+  const marks = comments.filter((c) => /^codelife: (plan|refused|closing) — /.test(first(c.body)))
+    .map((c) => { const [kind, , date = 'an undated run'] = first(c.body).slice(10).split(' — '); return { kind, date, body: c.body }; });
+  const state = (m) => m && { plan: `plan of ${m.date}`, refused: `refused on ${m.date}, after any plan` }[m.kind];
+  const last = marks.at(-1);
+  return last?.kind !== 'closing' ? state(last) ?? 'no plan'
+    : [state(marks.findLast((m) => m.kind !== 'closing')), `stopped — ${gist(last.body) ?? 'no reason given'}`].filter(Boolean).join(', ');
+};
+if (!issue.labels.includes('lot')) {
+  // A lone issue, a lot of one (R-199): no order, no line to tick, its branch derived (R-192).
+  const lot = title('title.lot_of.mjs', issue.title);
+  if (lot) stop(`#${n} is a member of lot #${lot}, whose order is the umbrella's — \`/work ${lot}\``);
+  if (tasksOf(issue.body).length) stop(`#${n} carries a task list but no \`lot\` label — label it, then \`/work ${n}\``);
+  if (/^closed$/i.test(issue.state)) finished('issue');
+  say(`issue: #${n}, lone — ${issue.title} — ${issue.labels.join(', ') || 'no label'} — ${issue.milestone || 'no milestone'}`);
+  // What the issue already carries: a campaign's finding, and the last of its plan, refusal or closing.
+  const finding = issue.comments.map((c) => first(c.body)).find((l) => /^codelife: finding — /.test(l));
+  say(finding ? `evidence: the finding comment (${finding.split(' — ').at(2) ?? 'undated'})` : 'evidence: the issue\'s "Where it comes from"');
+  say(`plan: ${planOf(issue.comments)}`);
+  const moved = op('read-roadmap', 'moved', [n]);
+  for (const l of moved.stdout.split('\n').filter((l) => /^- (roadmap|mark|moved #\d+): /.test(l))) summary.push(l);
+  if (moved.status !== 0) stop(/^- moved #/m.test(moved.stdout) ? 'a rule the issue cites moved, or could not be checked — `/roadmap` first' : `scripts/read-roadmap/moved.mjs failed — ${said(moved)}`);
+  branch('issue');
+}
+
+// The umbrella, its task list in order, and each member's state and plan.
+const umbrella = issue;
+if (/^closed$/i.test(umbrella.state)) finished('lot');
+const tasks = tasksOf(umbrella.body);
+if (!tasks.length) stop(`#${n} carries no task list: a lot whose order was never decided`);
+const members = tasks.map((t) => ({ ...t, ...JSON.parse(must('tracker', 'view', [t.n])) }));
+const closed = members.filter((m) => /^closed$/i.test(m.state));
+say(`umbrella: #${n} — ${umbrella.title} — ${closed.length} of ${members.length} members closed`);
+
+// The orphans a `debt-link` on the umbrella points at: open, titled as the link says, naming no lot.
+const joins = [];
+for (const c of umbrella.comments.filter((c) => first(c.body).startsWith('codelife: debt-link — '))) {
+  const [, k, named] = c.body.match(/^Filed as [^#\s]*#(\d+) — (.+?)\.?$/m) ?? [];
+  if (!k || members.some((m) => m.n === k)) continue;
+  const o = JSON.parse(must('tracker', 'view', [k]));
+  if (!/^closed$/i.test(o.state) && o.title === named && !title('title.lot_of.mjs', o.title)) joins.push({ n: k, title: o.title });
+}
+
+// Each open member's moved-rule check, in one call: a rule moved stops the run before its table.
+const open = members.filter((m) => !closed.includes(m));
+const moved = open.length ? op('read-roadmap', 'moved', open.map((m) => m.n)) : { status: 0, stdout: '' };
+const verdict = Object.fromEntries([...moved.stdout.matchAll(/^- moved #(\d+): (.*)$/gm)].map((m) => [m[1], m[2]]));
+for (const l of moved.stdout.split('\n').filter((l) => /^- (roadmap|mark): /.test(l))) summary.push(l);
+for (const m of members) {
+  say(closed.includes(m) ? `member: #${m.n} (${m.effort || 'no effort'}) — closed, skipped — ${m.title}`
+    : `member: #${m.n} (${m.effort || 'no effort'}) — open — ${planOf(m.comments)} — moved: ${verdict[m.n] ?? 'not read'} — ${m.title}`);
+}
+for (const j of joins) say(`join: #${j.n}, last — ${j.title}`);
+if (moved.status !== 0) {
+  const stopped = open.filter((m) => !verdict[m.n] || verdict[m.n].startsWith('stops'));
+  stop(stopped.length && Object.keys(verdict).length ? `a rule moved, or could not be checked, for ${stopped.map((m) => `#${m.n}`).join(', ')} — \`/roadmap\` first`
+    : `read-roadmap's moved failed — ${said(moved)}`);
+}
+
+// The lot's branch: an existing `lot/<n>-*`, or one derived from the umbrella's sentence.
+branch('lot');

package/scripts/work/reopen.mjs

@@ -0,0 +1,40 @@
+// /work's reopen, one command — the inverse of `issue close`: a held choice the user refused at /work
+// (R-295). The comment first, so a reopen cut midway leaves the reason and never a silently reopened
+// issue; then the issue reopened, its line unticked in its umbrella, and the umbrella reopened when
+// its last close closed it. Everything is read before anything is written. A refusal prints `- stop:`
+// and exits 1, nothing posted. `codelife issue reopen <issue> <comment file>`, from the repository's root.
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { prep } from '../prepare-lib.mjs';
+
+const [n, file, ...rest] = process.argv.slice(2);
+if (!/^\d+$/.test(n || '') || !file || rest.length) {
+  console.error('usage: codelife issue reopen <issue> <comment file>');
+  process.exit(2);
+}
+const { say, stop, done, must, title, kind } = prep('reopen');
+if (kind() === 'none') stop('tracker.kind: none — a held choice is validated by its push, and there is no merge request to push it with; nothing posted');
+try { readFileSync(file, 'utf8'); } catch (e) { stop(`the comment cannot be read — ${e.message}`); }
+
+const closed = (s) => /^closed$/i.test(s);
+const issue = JSON.parse(must('tracker', 'view', [n]));
+const lot = title('title.lot_of.mjs', issue.title);
+const umbrella = lot ? JSON.parse(must('tracker', 'view', [lot])) : null;
+const body = umbrella ? title('lot.row.mjs', umbrella.body, 'untick', n) : '';
+if (umbrella && !body) stop(`#${lot}'s task list cannot be unticked — scripts/tracker/lot.row.mjs failed; nothing posted`);
+
+say(must('tracker', 'note', [n, file]).trim());
+say(closed(issue.state) ? must('tracker', 'reopen', [n]).trim() : `#${n} already open`);
+if (!umbrella) {
+  say('umbrella: none');
+  done();
+}
+if (body !== umbrella.body.trim()) {
+  const f = join(mkdtempSync(join(tmpdir(), 'reopen-')), 'body.md');
+  writeFileSync(f, body);
+  must('tracker', 'issue.update', [lot, f]);
+  say(`umbrella: #${lot} — #${n}'s line unticked`);
+} else say(`umbrella: #${lot} — #${n}'s line already unticked, or not in its task list`);
+if (closed(umbrella.state)) say(`umbrella: ${must('tracker', 'reopen', [lot]).trim()}`);
+done();

package/scripts/work-feedback/prepare.mjs

@@ -0,0 +1,96 @@
+// /work-feedback's preparation, `codelife feedback prep [<n>]` (K-13): the merge request — the
+// argument, or the one open for the current branch —, the account its author, HEAD on its branch at
+// its head or ahead of it, the tree clean; then the rows left to answer — the latest pass's numbers
+// still open, the comments people wrote after it and the threads they opened —, less those an answer
+// already carries, each one a commit's `Answers:` trailer names marked with that commit. A
+// precondition that fails prints `- stop:` and exits 1. From the repository's root.
+//
+// The run folder, outside the tree: rows.md, one `### <number or link>` section per row, whole.
+import '../node-floor.mjs';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pkg = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+let n = process.argv[2];
+if (n !== undefined && !/^\d+$/.test(n)) {
+  console.error('usage: codelife feedback prep [<mr-number>]');
+  process.exit(2);
+}
+const summary = ['### prepare'];
+const say = (line) => summary.push(`- ${line}`);
+const stop = (why) => {
+  say(`stop: ${why}`);
+  console.log(summary.join('\n'));
+  process.exit(1);
+};
+// must <domain> <operation> <args> — that script's stdout, or the stop naming it and its error.
+const must = (domain, operation, args = []) => {
+  const r = spawnSync(process.execPath, [join(pkg, 'scripts', domain, `${operation}.mjs`), ...args], { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  if (r.status !== 0) stop(`${domain} ${operation} failed — ${(r.stderr || r.stdout).trim()}`);
+  return r.stdout;
+};
+const lines = (text) => text.split('\n').filter(Boolean);
+
+// Where you are: the account, the merge request, the branch, the head and the tree.
+const account = must('tracker', 'account').trim();
+if (n === undefined) {
+  const branch = spawnSync('git', ['branch', '--show-current'], { encoding: 'utf8' }).stdout.trim();
+  const open = branch ? lines(must('tracker', 'mr.find_for_branch', [branch])).filter((l) => l.endsWith(' open')) : [];
+  if (open.length !== 1) stop(`no number given, and ${branch ? `${branch} has ${open.length} open merge requests` : 'HEAD is on no branch'} — \`/work-feedback <n>\``);
+  n = open[0].split(' ')[0];
+  say(`number: !${n}, the open merge request of ${branch}`);
+}
+const mr = JSON.parse(must('tracker', 'mr.view', [n]));
+say(`merge request: !${n} — ${mr.source} into ${mr.target}, head ${mr.sha}, merge base ${mr.base}, author ${mr.author}, state ${mr.state}`);
+if (!/^open/i.test(mr.state)) stop(`!${n} is ${mr.state}: there is nothing left to answer on it`);
+if (mr.author !== account) stop(`!${n} is ${mr.author}'s, not ${account}'s — its author answers its review; /review-mr reviews another person's`);
+const checkout = () => must('tracker', 'mr.checkout_command', [n]).trim();
+const tree = JSON.parse(must('git', 'status'));
+if (tree.branch !== mr.source) stop(`HEAD is on ${tree.branch}, not ${mr.source} — \`${checkout()}\` reaches it`);
+if (spawnSync('git', ['merge-base', '--is-ancestor', mr.sha, 'HEAD']).status !== 0) stop(`HEAD ${tree.oid} does not contain the head ${mr.sha} — \`${checkout()}\` reaches it`);
+const dirty = [...tree.staged, ...tree.modified, ...tree.untracked];
+if (dirty.length) stop(`the tree is not clean: ${dirty.join(', ')}`);
+const ahead = +spawnSync('git', ['rev-list', '--count', `${mr.sha}..HEAD`], { encoding: 'utf8' }).stdout.trim();
+say(`branch: ${mr.source}, clean, ${ahead ? `${ahead} commits ahead of the head, waiting to be pushed` : 'at the head'}`);
+
+// What was said: the latest pass, the answers to it, the comments and the open threads after it.
+const said = must('tracker', 'mr.comments', [n]);
+const [, k, read] = said.match(/^- latest pass: (\d+) — (\S+) — /m) || [];
+const sections = said.split(/^#### /m).slice(1).map((s) => {
+  const [head, ...body] = s.split('\n');
+  return { head, url: head.split(' — ').at(-1), body: body.join('\n').trim() };
+});
+// The rows an answer already carries: the first cell of each line of its table.
+const answered = new Set(sections.filter((s) => s.head.startsWith('answer to ')).flatMap((s) =>
+  lines(s.body).filter((l) => l.startsWith('| ')).map((l) => l.split('|')[1].trim()).flatMap((c) => c.split(/,\s*/))));
+// The rows a commit since the merge base answers: `pass <k> <n>`, or a comment's link.
+const trailers = new Map();
+for (const c of JSON.parse(must('git', 'log_since', [mr.base]))) for (const a of c.answers) trailers.set(a, c.sha.slice(0, 8));
+
+const rows = [];
+const add = (id, key, text) => {
+  if (answered.has(id)) return;
+  rows.push({ id, text, commit: trailers.get(key) });
+};
+const pass = sections.find((s) => s.head.startsWith('pass '));
+if (pass) {
+  const findings = pass.body.split(/^### /m).find((s) => s.startsWith('Findings')) ?? '';
+  for (const item of findings.split(/^(?=\d+\. )/m).filter((s) => /^\d+\. /.test(s))) {
+    const state = item.replace(/\s*\n\s*/g, ' ').match(/\*([^*]+)\*\s*$/)?.[1].trim() ?? '';
+    if (/^(new|open)\b/.test(state) || /^refused\b.*\bkept$/.test(state)) add(item.match(/^\d+/)[0], `pass ${k} ${item.match(/^\d+/)[0]}`, item.trim());
+  }
+}
+for (const s of sections.filter((s) => /^(comment|open thread) by /.test(s.head))) add(s.url, s.url, `${s.head}\n\n${s.body}`);
+
+say(k ? `pass: ${k}, at ${read}` : 'pass: none — the comments people wrote are the rows');
+const committed = rows.filter((r) => r.commit);
+const numbers = rows.filter((r) => /^\d+$/.test(r.id)).map((r) => r.id), people = rows.length - numbers.length;
+say(`rows: ${rows.length} — ${[numbers.length && `pass ${k}'s ${numbers.join(', ')}`, people && `${people} written by people`].filter(Boolean).join(', ') || 'none'}${committed.length ? `; already committed, to answer: ${committed.map((r) => `${r.id} in ${r.commit}`).join(', ')}` : ''}`);
+if (!rows.length) stop(`nothing left to answer on !${n}${ahead ? `, yet ${ahead} commits wait to be pushed — \`/mr\` pushes them` : ''}`);
+const run = mkdtempSync(join(tmpdir(), 'codelife-feedback-'));
+writeFileSync(join(run, 'rows.md'), rows.map((r) => `### ${r.id}${r.commit ? ` — committed in ${r.commit}` : ''}\n\n${r.text}\n`).join('\n'));
+say(`run: ${run} — rows.md holds each row whole`);
+console.log(summary.join('\n'));

package/skills/audit/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: audit
+description: Evaluate the whole tree at HEAD through the lenses, file every finding, and fold the campaign's report into the audit table at its commit.
+argument-hint: "[full | targeted <lenses>]"
+---
+
+# /audit
+
+Evaluates the **whole tree at `HEAD`** through the lenses and turns what it finds into **one issue
+per finding**, one issue per root cause or contested decision, and **one umbrella per lot**. Five
+verbs do the mechanics; one `codelife:judge` agent per part dispatches that part's lenses and writes
+its findings; this brief asks what is yours to decide — each table, the lots — and fixes nothing. A
+campaign runs in place, and its folder lives in the tree only until its close.
+
+## Preconditions
+
+None to check here: `codelife audit prep` checks the tree, the campaign under way, the lenses and
+the push tier, and prints a `- stop:` line for each that fails. A stop ends the run — say it in your
+reply with what to do, and run nothing else.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+`codelife audit prep` writes the campaign folder, so a run you did not type stops before it. Then
+`codelife audit prep <parameters>`, its block written **in your reply**, in the user's language —
+a tool's output is not one —, every line kept as printed. Then the questions, together, each with
+its recommendation:
+
+- `stop: the push tier is red` — fix it first, recommended, or audit the failure: the same command
+  with `--red`.
+- `stop: <ID> has no reference` — a new domain lens: write `docs/audit/lenses/<ID>.md` with the user
+  from `templates/lens.md` — its id, objective, questions and probes asked —, then prep again.
+- `campaign: … resumed` — resume, recommended, or abandon: on your word delete that folder, then
+  prep again.
+- `tracker: not connected` — nothing can be filed: stop, recommended, and connect first.
+
+State that findings **will** be filed, one table at a time, each confirmed by you first.
+
+## Parameters
+
+`full` — every lens the contract's `kind` makes applicable and every domain lens under
+`docs/audit/lenses/` — or `targeted <LENS>…`, a domain lens like any other. Default `full`. A
+resumed campaign keeps its own.
+
+## Steps
+
+1. **Judges** — in the index prep wrote from `templates/index.md`, write your model into the
+   *Environment* row. Say `cap:`'s line, then dispatch one agent per row of `judges.tsv`: the Agent
+   tool, `subagent_type: codelife:judge`, the prompt the row's folder and nothing else — as many at
+   once as `cap:` says, another as each returns. A block's `Withheld:` reproductions are shown **in your reply** and written nowhere. A
+   judge that fails, or returns no `### judge result`, stops the campaign before any table: Next is
+   `/audit`, which dispatches that part alone.
+2. **Tables**, in the order the index lists the lenses — the hygiene lenses together, every other
+   one alone. `codelife audit table <LENS>[,<LENS>…]`; a `- stop:` line is said and followed. Write
+   the table **in your reply** with, per row, your proposed disposition — nature and severity for a
+   new one, `known`, `false`, `refused`, `merged <id>` —, the rows you doubt flagged, and the lines
+   below it. One answer per table; nothing is filed before it. A row dropped is **false** — the lens
+   was wrong — or **refused** — true and not to be fixed: write its line of `## Rejected` in the
+   capability it concerns (`codelife help method refusal`), and its address goes in the row. Then
+   the rows to a file, one per line as `codelife help audit file` reads them, and
+   `codelife audit file <file>`, its block in your reply. A point below the rows you want filed goes
+   to `/new-issue` later.
+3. **Questions** — what sits behind several findings is a root cause, and each *Contested* line a
+   decision whose reason a fact contests: **nothing about either is decided here**. Propose them **in
+   your reply**, one issue each, written as
+   `codelife help template feature` prints one — the findings or the
+   decision's sentence and the fact as its *Context*, the question asked — and filed on your yes by
+   `codelife issue create --once feature - audit:A<n>-question-<k> <file>`. Each goes in the index's
+   *main problems* with its number.
+4. **Plan** — lots, ordered so that what catches a regression lands first; one lot is one merge
+   request. Each answers a cause — the false claim deleted rather than guarded, one primitive its
+   sites call rather than an assertion at each —, names its dependencies, its *done when* and its
+   expected net line count. Proposed **in your reply** with your reasoning; you change the grouping,
+   the order or the sizing. Confirmed, each umbrella is written as
+   `codelife help template lot` prints one, *The order* empty, filed by
+   `codelife issue create --once lot - audit:A<n>-lot-<X> <file>`, then
+   `codelife lot join <umbrella> <n>:<effort>…`. The plan goes in the index.
+5. **Close** — write the index's lead, then `codelife audit close`, its block in your reply. A file
+   it names as differing from the open is restored only on your word, and named in *Left open*
+   otherwise. Then `codelife commit` with `docs(audits): close campaign A<n>` on the paths it prints,
+   `codelife audit fold`, and `codelife commit` with `docs(audits): fold campaign A<n>` on its paths.
+
+## Never
+
+- Measure anything but `HEAD`, or check out, stash or switch.
+- File a row, a question or a lot without your answer, or decide a root cause, a contested decision
+  or the lots yourself.
+- Write anything outside `docs/audit/` but a `## Rejected` line you confirmed, or restore a file
+  without your word.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading, its fields in the user's language:
+
+```markdown
+### audit result
+- Produced: the issues by lens, the questions, the lot umbrellas, the two commits — the close,
+  whose sha the campaign row links, and the fold.
+- Decided: the lenses, each table's corrections, the lots and their order, a red baseline audited.
+- Left open: the questions, none decided; the points below the rows you kept for `/new-issue`; the
+  files the fingerprint found changed.
+- Next: `/brainstorm #<n>` on a question; `/work <umbrella>` on the first lot.
+```

package/skills/audit/templates/index.md

@@ -0,0 +1,36 @@
+<!-- generated by codelife — /audit -->
+# Campaign {{id}} — {{type}}, {{date}}
+
+> **⚠ IN PROGRESS.** This campaign is not closed: its findings are not all filed. Do not cite it.
+> `/audit` resumes it; a part whose folder holds no `part.md` is not judged yet.
+
+{{lead: one or two sentences on the state of the repository at this commit, for a developer who knows the language and the forge but not this repository}}
+
+## The main problems
+
+{{each root cause and each decision contested, under a ### heading in plain words: what goes wrong and why it recurs, with the findings that are its instances — or the decision's sentence and the fact against it — then its issue #n; or "None."}}
+
+## The plan
+
+{{each lot in order: its umbrella #n and name, its dependencies, its done when, its members}}
+
+## What this campaign could not measure
+
+{{measure}}. Each part's `part.md` holds every lens's *Method* and *Limits*.
+
+## The campaign
+
+| | |
+|---|---|
+| **Commit** | `{{commit}}` on `{{branch}}` |
+| **Type** | {{type}} |
+| **Lenses run** | {{lenses}} |
+| **Baseline** | {{baseline}} |
+| **Environment** | {{model: the model this campaign ran on}} |
+| **Instrument** | {{instrument}} |
+| **Previous campaign** | {{previous}} |
+| **Swept** | {{open}} open issues and {{decisions}} decisions, passed to every lens as known |
+
+## Findings by lens
+
+{{findings}}