great-cto 3.16.0 → 3.18.0

package/board/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "great_cto",
   "id": "great_cto",
   "description": "Engineering process for solo founders and teams up to 50 engineers. Agents do architecture, code review, QA, and security. You make two decisions per feature.",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "author": {
     "name": "Great CTO",
     "url": "https://github.com/avelikiy/great_cto"

package/board/packages/board/fixtures/fake-bd-fail.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Test fixture: a `bd` stand-in that always exits non-zero, for testing the
+# failure path of warmTasksAsync (packages/board/beads-warm-async.test.mjs).
+if [ "$1" = "--version" ]; then
+  echo "bd-fake 0.0.0"
+  exit 0
+fi
+echo "dolt: database is locked" >&2
+exit 1

package/board/packages/board/fixtures/fake-bd-slow.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# Test fixture: a `bd` stand-in that sleeps before answering, so the
+# boot-responsiveness tests can prove the board stays answerable DURING a
+# slow `bd list` — not just that the code calls the right function. Loaded
+# only via GREAT_CTO_BD_BIN in packages/board/*.test.mjs; never used outside
+# tests.
+if [ "$1" = "--version" ]; then
+  echo "bd-fake 0.0.0"
+  exit 0
+fi
+sleep "${FAKE_BD_DELAY_SECS:-3}"
+echo "[]"

package/board/packages/board/lib/alert-recurrence.mjs

@@ -0,0 +1,73 @@
+/**
+ * Has this alert fired here before?
+ *
+ * `alerts-fired.json` has recorded every alert this machine sent, keyed
+ * `<event>:<project>:<id>` with the time it fired. It was read only as a dedupe
+ * set — "have I already sent THIS instance" — so a gate going stale for the
+ * first time in a project and the ninth in a month produced the same sentence,
+ * and the operator had no way to tell a one-off from a pattern.
+ *
+ * A threshold cannot make that distinction; only history can, and the history
+ * was already on disk.
+ *
+ * Three states, because the file is lossy and its absence means something:
+ *
+ *   unknown    — no history to read. NOT "first": a count nobody took is not a
+ *                count of zero, and this is the substitution the project exists
+ *                to refuse.
+ *   first      — history exists and holds nothing for this rule in this project.
+ *   recurring  — it holds N earlier fires inside the window.
+ *
+ * `atLeast` marks a count taken from a FULL history: the writer keeps only the
+ * last 500 keys, so anything older is gone and the number is a floor.
+ */
+
+/** The writer's cap — see writeAlertsFired in alerts.mjs. */
+const HISTORY_CAP = 500;
+const DEFAULT_WINDOW_DAYS = 30;
+
+/**
+ * @param {Record<string,string>|null} fired  parsed alerts-fired.json, or null
+ *   when there is no such file
+ * @param {{event: string, project: string, now?: number, windowDays?: number}} q
+ * @returns {{state:'unknown'|'first'|'recurring', count:number|null,
+ *            windowDays:number, atLeast:boolean, sentence:string}}
+ */
+export function recurrence(fired, { event, project, now = Date.now(), windowDays = DEFAULT_WINDOW_DAYS }) {
+  if (!fired || typeof fired !== 'object') {
+    return {
+      state: 'unknown', count: null, windowDays, atLeast: false,
+      sentence: 'No alert history on this machine, so whether this has happened before is unknown.',
+    };
+  }
+
+  // Anchored on the full `event:project:` prefix. A bare startsWith(event) would
+  // count `gate.stalest` as `gate.stale`, and a project slug may itself contain
+  // a colon — so both parts are matched as one literal prefix.
+  const prefix = `${event}:${project}:`;
+  const cutoff = now - windowDays * 86_400_000;
+  const keys = Object.keys(fired);
+
+  let count = 0;
+  for (const k of keys) {
+    if (!k.startsWith(prefix)) continue;
+    const at = Date.parse(fired[k]);
+    // An unreadable timestamp is not evidence of a recent fire. Skipped, not
+    // counted as now — which is what a NaN comparison would have done silently.
+    if (!Number.isFinite(at) || at < cutoff) continue;
+    count++;
+  }
+
+  const atLeast = keys.length >= HISTORY_CAP;
+  if (count === 0) {
+    return {
+      state: 'first', count: 0, windowDays, atLeast,
+      sentence: `First time this has fired for this project in ${windowDays} days.`,
+    };
+  }
+  return {
+    state: 'recurring', count, windowDays, atLeast,
+    sentence: `${atLeast ? 'At least ' : ''}${count} other time${count === 1 ? '' : 's'} `
+      + `in the last ${windowDays} days for this project — a pattern, not a one-off.`,
+  };
+}

package/board/packages/board/lib/alerts.mjs

@@ -8,18 +8,25 @@ import {
 } from '../push-adapter.mjs';
 import { GREAT_CTO_DIR, PUSH_SUBS_FILE, VAPID_KEYS_FILE, VAPID_SUBJECT, BUILD_VERSION } from './config.mjs';
 import { _reportRepublishDedupeSet } from './state.mjs';
+import { recurrence } from './alert-recurrence.mjs';
 import { listProjects, readProjectMd } from './projects.mjs';
 import { addNotification } from './notifications.mjs';
 import { getMetrics } from './metrics.mjs';
 import { getCostHistory, getInbox } from './data-readers.mjs';
-// Every sweep below runs over EVERY registered project, and `bd list` is
-// spawnSync — the event loop is held for the whole of it. At 16 projects and
-// 2-6 s each that is ~60 s per sweep, and three of these fire every five
-// minutes. Sweeps therefore read at sweep freshness, not interactive freshness:
-// see SWEEP_MAX_AGE_MS in beads.mjs for the arithmetic that made the board
-// unanswerable while reporting "live · synced just now".
+// Every sweep below runs over EVERY registered project. `sweep: true` opts a
+// COLD project (never read this process) into bdList()'s non-blocking fill
+// path instead of its synchronous one — the same escape hatch a WARM-but-
+// stale entry already gets. Without it: a real board's first cron tick
+// (t=+5:10, no request in flight) lagged the event loop 9.8s reading a
+// single project synchronously; at 16 projects and 2-6s each that is ~60s
+// per sweep, three of which fire every five minutes, indefinitely. Sweeps
+// read at sweep freshness, not interactive freshness — see SWEEP_MAX_AGE_MS
+// in beads.mjs for the arithmetic that made the board unanswerable while
+// reporting "live · synced just now". `sweep: true` must NEVER be added to
+// an interactive read's opts: an ordinary request is someone waiting on
+// THIS project's answer, and the fill path answers `[]` instead.
 import { getTasks, SWEEP_MAX_AGE_MS } from './beads.mjs';
-const SWEEP = { maxAgeMs: SWEEP_MAX_AGE_MS };
+const SWEEP = { maxAgeMs: SWEEP_MAX_AGE_MS, sweep: true };
 import { readVerdicts } from './verdicts.mjs';
 import { isFailure } from './fleet.mjs';
 import { getShareState, toggleShare } from './share.mjs';
@@ -37,6 +44,22 @@ function readAlertsFired() {
   try { return JSON.parse(fs.readFileSync(ALERTS_FIRED_PATH, 'utf8')); } catch { return {}; }
 }
 
+/**
+ * The same file, read as HISTORY rather than as a dedupe set.
+ *
+ * readAlertsFired answers "have I already sent this instance", and `{}` on
+ * failure is right for that: not knowing must never block a send. Read as
+ * history, that same `{}` says "this has never happened here" — a claim nobody
+ * checked. `null` keeps the two apart.
+ */
+function readAlertsHistory() {
+  try {
+    if (!fs.existsSync(ALERTS_FIRED_PATH)) return null;
+    const parsed = JSON.parse(fs.readFileSync(ALERTS_FIRED_PATH, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch { return null; }
+}
+
 function writeAlertsFired(map) {
   try {
     if (!fs.existsSync(GREAT_CTO_DIR)) fs.mkdirSync(GREAT_CTO_DIR, { recursive: true });
@@ -234,14 +257,24 @@ function startAlertCron() {
           const ageHr = (Date.now() - created) / 3600_000;
           if (ageHr < 2 || ageHr > 24 * 7) continue;
           const dedupeKey = `gate.stale:${proj.slug}:${g.id}`;
+          // How often this has happened here. A threshold says the gate is old;
+          // only the history says whether old gates are this project's normal
+          // state. Both readings come from the same file — one as a dedupe set,
+          // this one as history.
+          const seen = recurrence(readAlertsHistory(), { event: 'gate.stale', project: proj.slug });
           const stalePayload = {
             title: `${proj.slug} — ${g.title.slice(0, 60)} pending ${ageHr.toFixed(1)}h`,
-            body: `A gate has been waiting for your approval for ${ageHr.toFixed(1)} hours.\n\nGate: ${g.id}\nProject: ${proj.slug}`,
+            body: `A gate has been waiting for your approval for ${ageHr.toFixed(1)} hours.\n\n${seen.sentence}\n\nGate: ${g.id}\nProject: ${proj.slug}`,
             level: 'warning',
             project: proj.slug,
             link: `http://localhost:3141/?project=${encodeURIComponent(proj.slug)}&task=${encodeURIComponent(g.id)}#inbox`,
             action: 'Approve in board',
-            kv: { gate: g.id, agent: g.agent || 'unknown', age: `${ageHr.toFixed(1)}h` },
+            kv: {
+              gate: g.id, agent: g.agent || 'unknown', age: `${ageHr.toFixed(1)}h`,
+              // `unknown` is carried through rather than rendered as 0 — a count
+              // nobody took is not a count of none.
+              seen_before: seen.count === null ? 'unknown' : `${seen.atLeast ? '\u2265' : ''}${seen.count}`,
+            },
           };
           fireEmailAlert('gate.stale', dedupeKey, stalePayload);
           addNotification('gate.stale', stalePayload, dedupeKey);

package/board/packages/board/lib/beads.mjs

@@ -38,6 +38,15 @@ import { log } from './log.mjs';
 // because each request arrived just after the entry expired.
 const BD_CACHE_TTL_MS = Number(process.env.GREAT_CTO_BD_CACHE_TTL_MS || 300000);
 
+/**
+ * When a cwd was last told "your cache entry is wrong" — by an invalidate or
+ * a stale-mark, whichever most recently ran. A background fetch that STARTED
+ * before this timestamp answers a question nobody is asking anymore: see
+ * `bdRefreshAsync`, which compares its own start time against this map before
+ * committing its result, so a slow fetch racing a write always loses to it.
+ */
+const lastInvalidatedAt = new Map();
+
 /**
  * Drop a directory's entry so the next read is guaranteed fresh.
  *
@@ -47,6 +56,7 @@ const BD_CACHE_TTL_MS = Number(process.env.GREAT_CTO_BD_CACHE_TTL_MS || 300000);
  */
 function bdCacheInvalidate(cwd) {
   clearSelfTouch(cwd);
+  lastInvalidatedAt.set(cwd, Date.now());
   bdCache.delete(cwd);
 }
 
@@ -63,6 +73,7 @@ function bdCacheInvalidate(cwd) {
  */
 function bdCacheStale(cwd) {
   clearSelfTouch(cwd);
+  lastInvalidatedAt.set(cwd, Date.now());
   const cached = bdCache.get(cwd);
   if (cached) bdCache.set(cwd, { ...cached, ts: 0 });
 }
@@ -290,13 +301,16 @@ const refreshing = new Set();
  * measured at 1-10 s because it was queued behind a task read. Warming at boot
  * moved the first stall out of sight; this removes the rest.
  *
- * Nothing awaits it. It exists to make the NEXT read fast, and a caller that
- * needed the new data would have had to block for it anyway.
+ * `onDone`, if given, fires exactly once at every exit point (success,
+ * failure, or "already refreshing"). Every existing caller omits it and stays
+ * fire-and-forget — the ONE caller that wants to know when the fill finished
+ * is the boot warm-up (see `warmTasksAsync`), which logs how long it took.
  */
-function bdRefreshAsync(cwd) {
-  if (refreshing.has(cwd)) return;
+function bdRefreshAsync(cwd, onDone = () => {}) {
+  if (refreshing.has(cwd)) { onDone({ ok: false, skipped: true }); return; }
   refreshing.add(cwd);
-  lastBdRunAt.set(cwd, Date.now());
+  const startedAt = Date.now();
+  lastBdRunAt.set(cwd, startedAt);
   let out = '';
   try {
     const child = spawn(BD_BIN, ['list', '--json', '--all', '--include-gates'], { cwd, env: bdEnv() });
@@ -304,31 +318,87 @@ function bdRefreshAsync(cwd) {
     child.on('error', (e) => {
       refreshing.delete(cwd);
       bdFailures.set(cwd, `bd could not be run: ${e?.message || e}`.slice(0, 300));
+      onDone({ ok: false });
     });
     child.on('close', (code) => {
       refreshing.delete(cwd);
       lastBdRunAt.set(cwd, Date.now());
-      if (code !== 0) { bdFailures.set(cwd, `bd exited ${code}`); return; }
+      if (code !== 0) { bdFailures.set(cwd, `bd exited ${code}`); onDone({ ok: false }); return; }
       try {
         const parsed = JSON.parse(out || '[]');
         // Same guard as the sync path: bd 0.6x can answer 0 with a JSON object,
         // and a non-array rendered as no tasks is the silent zero again.
         if (!Array.isArray(parsed)) {
           bdFailures.set(cwd, String(parsed?.error || 'bd returned something that is not a task list').slice(0, 300));
+          onDone({ ok: false });
+          return;
+        }
+        // This fetch answers "what was true at `startedAt`?" — if anyone has
+        // since told the cache it's wrong (a write's invalidate/stale-mark)
+        // or already written something newer (a synchronous cold read that
+        // raced us and won), our answer is superseded. Committing it now
+        // would silently resurrect data from before a change a caller is
+        // already waiting to see reflected — exactly what made
+        // `tests/pipeline-e2e.test.mjs`'s gate-approval assertions flake once
+        // this function started running from a COLD cache (the boot warm-up)
+        // instead of only ever refreshing an already-populated one.
+        const supersededByInvalidation = (lastInvalidatedAt.get(cwd) || 0) >= startedAt;
+        const supersededByFresherEntry = (bdCache.get(cwd)?.ts || 0) >= startedAt;
+        if (supersededByInvalidation || supersededByFresherEntry) {
+          onDone({ ok: true, count: parsed.length, discarded: true });
           return;
         }
         bdFailures.delete(cwd);
         bdCache.set(cwd, { ts: Date.now(), data: parsed });
+        onDone({ ok: true, count: parsed.length });
       } catch (e) {
         bdFailures.set(cwd, `bd output could not be parsed: ${e?.message || e}`.slice(0, 300));
+        onDone({ ok: false });
       }
     });
   } catch (e) {
     refreshing.delete(cwd);
     bdFailures.set(cwd, `bd could not be spawned: ${e?.message || e}`.slice(0, 300));
+    onDone({ ok: false });
   }
 }
 
+/**
+ * Warm a directory's task cache at boot, WITHOUT blocking the event loop.
+ *
+ * The boot warm-up used to call `getTasks(cwd)` directly — `bdList()`'s
+ * COLD-cache path, which is `bd()`'s synchronous `spawnSync`, because a cold
+ * cache has nothing to serve while a background refresh runs, so it has
+ * always been the one path in this file that blocks. That's the right call
+ * for a REQUEST (something is waiting and there's no stale data to fall back
+ * on); it was the wrong call at boot, because a boot warm-up has nobody
+ * waiting on it — its only job is to be ready before someone asks.
+ *
+ * Measured with an artificially slow `bd` (GREAT_CTO_BD_BIN pointed at a
+ * fixture that sleeps N seconds before answering): the board bound its port,
+ * then answered `000` on EVERY endpoint — including /api/version, a plain
+ * readdirSync with nothing to do with bd — for the fixture's entire delay.
+ * The port being open did not matter; the single process serving it was
+ * blocked inside `spawnSync` the whole time. `bd()`'s own 8s spawnSync
+ * timeout capped that run at ~8s; a real cold Dolt store or lock contention
+ * has no such cap, which is consistent with the up-to-2-minute stalls
+ * reported in production.
+ *
+ * This calls `bdRefreshAsync` — the SAME `spawn`-based, non-blocking path
+ * already used for warm-cache "stale-while-revalidate" reads — for the cold
+ * boot case too. The returned Promise exists only so the boot log can report
+ * how long the fill took; nothing waits on it, and the server is accepting
+ * and answering connections for the entire duration either way.
+ *
+ * @returns {Promise<{ok: boolean, count?: number, skipped?: boolean, ms: number}>}
+ */
+function warmTasksAsync(cwd) {
+  const t0 = Date.now();
+  return new Promise((resolve) => {
+    bdRefreshAsync(cwd, (result) => resolve({ ...result, ms: Date.now() - t0 }));
+  });
+}
+
 function bdList(cwd = process.cwd(), runner = bd, opts = {}) {
   const maxAge = Number.isFinite(opts.maxAgeMs) ? opts.maxAgeMs : BD_CACHE_TTL_MS;
   const cached = bdCache.get(cwd);
@@ -338,14 +408,7 @@ function bdList(cwd = process.cwd(), runner = bd, opts = {}) {
   if (cached && Date.now() - cached.ts < ttl) return cached.data;
 
   // Stale-while-revalidate. An entry that exists is served immediately, however
-  // old, and refreshed off the event loop. Only a directory with NO entry at all
-  // blocks — which after the boot warm-up means a project nobody has opened yet,
-  // once.
-  //
-  // The alternative was making this async and every caller with it: getTasks,
-  // getInbox, getPipeline, the metrics readers, the SSE broadcast, the alert
-  // sweeps. That refactor is the correct end state and is not what a board
-  // hanging today needs.
+  // old, and refreshed off the event loop.
   //
   // The injected `runner` is how the tests drive this. When one is supplied the
   // sync path is kept, so a test that stubs `bd` still observes the call it
@@ -354,6 +417,32 @@ function bdList(cwd = process.cwd(), runner = bd, opts = {}) {
     bdRefreshAsync(cwd);
     return cached.data;
   }
+
+  // A directory with NO entry at all — genuinely never read. Left
+  // synchronous for an ordinary caller: a request FOR this project is
+  // waiting on the answer, and returning `[]` while a background fill
+  // catches up would be wrong data handed to a caller who cannot tell it
+  // apart from "no tasks" — confirmed the hard way. This branch originally
+  // covered every caller, and tests/board-gate.test.mjs,
+  // tests/pipeline-e2e.test.mjs and tests/resume-e2e.test.mjs all went red:
+  // a gate approved seconds after project creation read back as "no gates",
+  // because the read that should have shown it took the async path and
+  // answered empty instead.
+  //
+  // `opts.sweep` is the one caller allowed to skip the wait: the alert cron,
+  // which already has its own looser freshness contract (SWEEP_MAX_AGE_MS)
+  // and iterates EVERY registered project on a timer nobody is blocking on.
+  // Measured live, unprompted: a real board's first cron tick (t=+5:10, no
+  // request in flight) lagged the event loop 9.8s doing exactly this
+  // synchronous cold read, once per registered project, every five minutes,
+  // indefinitely. For that caller specifically, the same non-blocking fill
+  // stale-while-revalidate already uses for a WARM entry is safe on a COLD
+  // one too — the cron does not need this tick's answer to be correct, only
+  // bounded in staleness, which the background fill still gives it.
+  if (!cached && runner === bd && opts.sweep) {
+    bdRefreshAsync(cwd);
+    return [];
+  }
   try {
     lastBdRunAt.set(cwd, Date.now());
     const result = runner(['list', '--json', '--all', '--include-gates'], { cwd });
@@ -593,7 +682,22 @@ function getReadDegradation(cwd = process.cwd()) {
   // tasks.md first: if that file exists and is broken, that is the specific
   // problem. Otherwise report bd's failure, which until now was swallowed — the
   // board answered "no tasks" for a project whose database bd refused to open.
-  return readDegradation.get(cwd) || bdFailureFor(cwd) || null;
+  const fromTasksMd = readDegradation.get(cwd);
+  if (fromTasksMd) return fromTasksMd;
+
+  // A project that never ran `bd init` has no beads store to fail. bd still
+  // reports its absence as an error, and reporting THAT as a degradation put a
+  // permanent "counts are incomplete" banner over complete counts on every
+  // project that tracks tasks in tasks.md — a supported source, not a fallback
+  // of last resort. Absent and broken are different states; this file already
+  // draws that line for tasks.md ("Missing is a normal state") and now draws it
+  // for beads too.
+  //
+  // Deliberately narrow: an existing .beads/ that bd cannot open is still a
+  // defect and is still reported. Only absence is forgiven.
+  if (checkBeadsAvailable(cwd)) return null;
+
+  return bdFailureFor(cwd) || null;
 }
 
 function parseTasksMd(cwd) {
@@ -743,6 +847,7 @@ export {
   checkBeadsAvailable,
   bdWriteSerialised,
   bdList,
+  warmTasksAsync,
   bdFailureFor,
   parseTasksMd,
   getReadDegradation,

package/board/packages/board/lib/data-readers.mjs

@@ -27,6 +27,14 @@ function getMemory(cwd = process.cwd()) {
   ];
   const result = layers.map(l => ({
     ...l,
+    // `path` opens the file; `displayPath` is what a person — or a README
+    // screenshot — sees. An absolute path here names the operator's home
+    // directory and username: fine in a local tool, wrong the moment the screen
+    // is photographed. The layer already knows its scope, so the display form is
+    // derived rather than guessed.
+    displayPath: l.scope === 'global'
+      ? path.join('~', path.relative(home, l.path)).split(path.sep).join('/')
+      : path.relative(cwd, l.path).split(path.sep).join('/'),
     content: readFileSafe(l.path),
     exists: fs.existsSync(l.path),
     size: fs.existsSync(l.path) ? fs.statSync(l.path).size : 0,

package/board/packages/board/lib/docs.mjs

@@ -14,6 +14,7 @@
 
 import fs from 'node:fs';
 import { judgeFreshness } from '../../../scripts/lib/freshness.mjs';
+import { linkGraph } from '../../../scripts/lib/doc-links.mjs';
 import path from 'node:path';
 
 /**
@@ -148,6 +149,10 @@ export function titleFromText(text) {
   return m ? m[1].replace(/\.md$/i, '').trim() : null;
 }
 
+/** Generated summaries and translated copies — see listDocs. */
+const IS_COPY = /\.summary\.md$/i;
+const IS_TRANSLATED = /^docs[/\\][a-z]{2}(-[A-Z]{2})?[/\\]/;
+
 function walk(dir, root, out, depth = 0) {
   if (depth > 3 || out.length >= MAX_DOCS) return;
   let entries;
@@ -158,6 +163,10 @@ function walk(dir, root, out, depth = 0) {
     const abs = path.join(dir, e.name);
     if (e.isDirectory()) { walk(abs, root, out, depth + 1); continue; }
     if (!e.name.toLowerCase().endsWith('.md')) continue;
+    // A generated summary and a translation are copies of a document, not more
+    // documents. Counting them made this screen report 188 where there are 156,
+    // and stood a machine-written summary in the index beside its own source.
+    if (IS_COPY.test(e.name) || IS_TRANSLATED.test(path.relative(root, abs))) continue;
     let st;
     try { st = fs.statSync(abs); } catch { continue; }
     out.push({ abs, rel: path.relative(root, abs), size: st.size, modified: st.mtime.toISOString() });
@@ -336,6 +345,17 @@ export function listDocs(root, { max = MAX_DOCS } = {}) {
     }
   }
 
+  // How many documents cite this one. Measured over docs/ only, which is where
+  // the link graph is defined; anything outside it gets `null` — "not measured"
+  // and "measured, and the answer is none" are different facts, and rendering
+  // the first as the second is the substitution this whole board refuses.
+  let inboundBy = null;
+  try {
+    const g = linkGraph(path.join(root, 'docs'));
+    inboundBy = new Map();
+    for (const [k, v] of g.inbound) inboundBy.set(path.relative(root, k), v.length);
+  } catch { inboundBy = null; }
+
   const seen = new Set();
   const docs = [];
   for (const d of found) {
@@ -353,6 +373,7 @@ export function listDocs(root, { max = MAX_DOCS } = {}) {
       title: (text !== null && titleFromText(text)) || path.basename(d.rel, '.md'),
       group: groupFor(d.rel, { text: text ?? '' }),
       size: d.size,
+      inbound: inboundBy ? (inboundBy.has(d.rel) ? inboundBy.get(d.rel) : null) : null,
       modified: d.modified,
       // A modification time answers "when was this file last touched", which is
       // a different question from "is this still true". A typo fix rejuvenates a