geneseed 3.1.0 → 3.1.2

package/js/lib/text.mjs

@@ -0,0 +1,181 @@
+/**
+ * String primitives — measuring, padding, stripping, decoding and reading an integer.
+ *
+ * These are definitions, not an adaptation of somebody else's; see `fs.mjs` for why the
+ * measurements against CPython are recorded per function, and why NONE of these is the Node
+ * default — the warning the retired `py` prefix used to carry now lives in each docblock.
+ * Every function here is a place the Node default DIVERGES from the answer this tool needs:
+ * `codePointLength` counts code points where `.length` counts units, `WHITESPACE` is a wider
+ * set than `String.trim`'s, `parseIntStrict` accepts what `Number()` does not and rejects what
+ * it does, and `percentDecode` leaves a bad escape alone where `decodeURIComponent` throws.
+ */
+/**
+ * `len(s)` — CODE POINTS, where `String.length` counts UTF-16 units.
+ *
+ * They differ on every astral character: `len("𝔊")` is 1 and `"𝔊".length` is 2. Only
+ * matters where a length becomes layout, which is exactly what the status panel does with
+ * it — a theme name or a memory path outside the BMP would shear the frame by one column
+ * per character under `.length`.
+ */
+export const codePointLength = (s) => [...s].length;
+
+/**
+ * `str.ljust(width)` — pad with spaces to `width` CODE POINTS, never truncate.
+ *
+ * `String.padEnd` counts UTF-16 units, so it is `codePointLength`'s difference again, one call later.
+ */
+export const padEndToWidth = (s, width) => s + ' '.repeat(Math.max(0, width - codePointLength(s)));
+
+/**
+ * `int(s)` for a base-10 string — the VALUE, or null where Python raises `ValueError`.
+ *
+ * Null rather than a throw because EVERY call site branches on the failure rather than
+ * propagating it: `askChoice` falls through to matching the answer against the option KEYS,
+ * `javaMajorOk` treats an unparseable major as "not new enough", and the terminal-width,
+ * port and timeout readers each fall back to a default. Python spells that `except ValueError`.
+ *
+ * Three things separate this from `Number(s)` and each one changes an answer:
+ *
+ *   * `Number('')` is 0 and `int('')` raises. So is `Number(' ')`, and `Number('0x10')` is
+ *     16 where `int('0x10')` raises — a wizard answer of `0x2` must fall through to the key
+ *     match, not select option 16.
+ *   * PEP 515 underscores: `int('1_0')` is 10, `Number('1_0')` is NaN. Leading, trailing and
+ *     doubled ones still raise, so the rule is "between digits" and not "strip them".
+ *   * `int()` accepts any Unicode decimal digit — `int('٣')` is 3 — and `Number('٣')` is NaN.
+ *     Every `Nd` block is exactly ten contiguous code points, so a digit's value is its
+ *     offset from the first `Nd` code point at or below it, which is what the walk finds.
+ *
+ * Surrounding whitespace is Python's to strip and this does NOT strip it: `int(' 1')` is 1
+ * where this answers null. STRIPPING IS THE CALLER'S JOB, and the callers that are handed a
+ * raw environment value do it — `js/ui/cli.mjs`'s `helpWidth` and `js/web/activity.mjs` wrap
+ * the argument in `stripWhitespace` first.
+ *
+ * Gated by a corpus in `tests/test_pure_function_parity.py` — a primitive reproduction gets
+ * one owner and a corpus, never a cell (P5c).
+ */
+export function parseIntStrict(s) {
+  if (typeof s !== 'string' || s === '') return null;
+  let body = s;
+  let sign = 1;
+  if (body[0] === '+' || body[0] === '-') {
+    if (body[0] === '-') sign = -1;
+    body = body.slice(1);
+  }
+  const chars = [...body];
+  if (chars.length === 0) return null;
+  let value = 0n;
+  let prevWasDigit = false;
+  for (const ch of chars) {
+    if (ch === '_') {
+      // Only BETWEEN digits: a leading, trailing or doubled underscore is a ValueError.
+      if (!prevWasDigit) return null;
+      prevWasDigit = false;
+      continue;
+    }
+    if (!/^\p{Nd}$/u.test(ch)) return null;
+    const cp = ch.codePointAt(0);
+    let zero = cp;
+    while (zero > 0 && /^\p{Nd}$/u.test(String.fromCodePoint(zero - 1))) zero -= 1;
+    value = value * 10n + BigInt(cp - zero);
+    prevWasDigit = true;
+  }
+  if (!prevWasDigit) return null;   // a trailing underscore
+  return Number(sign === -1 ? -value : value);
+}
+
+/**
+ * Python's `\s` for a `str` pattern, as a character-class BODY — measured, not recalled.
+ *
+ * The two languages' whitespace classes are nearly the same and the difference had been
+ * carried as a standing item reading "differing from JS `\s` only at U+FEFF". That was
+ * incomplete in both directions, and a corpus over `slugifyHeading` is what found it:
+ *
+ *     python \s = js \s  -  U+FEFF  +  U+001C..U+001F  +  U+0085
+ *
+ * JavaScript counts the byte-order mark as whitespace and Python does not; Python counts
+ * the four C0 information separators and the NEL, and JavaScript does not. Neither shows
+ * up in a docs heading anyone has written — which is exactly why it took a corpus rather
+ * than a cell, and why it is spelled out here rather than approximated with `\s`.
+ */
+export const WHITESPACE = '\t\n\v\f\r \u001c-\u001f\u0085\u00a0\u1680'
+  + '\u2000-\u200a\u2028\u2029\u202f\u205f\u3000';
+
+const STRIP_RE = new RegExp(`^[${WHITESPACE}]+|[${WHITESPACE}]+$`, 'g');
+const STRIP_START_RE = new RegExp(`^[${WHITESPACE}]+`);
+const STRIP_END_RE = new RegExp(`[${WHITESPACE}]+$`);
+
+/** `str.strip()` — Python's whitespace set, which `String.trim()`'s is not. */
+export function stripWhitespace(s) {
+  return s.replace(STRIP_RE, '');
+}
+
+/**
+ * `str.lstrip()` / `str.rstrip()` — the ONE-SIDED halves, over the same `WHITESPACE`.
+ *
+ * P2 added them for `_build_render._insert_theme_keys`, which uses all three spellings within
+ * four lines (`lines[0].strip()`, `ln.lstrip().startswith('"')`,
+ * `lines[pred].rstrip().endswith(",")`). They are here rather than in `js/build/themes.mjs` for the
+ * reason this file exists at all: `js/hosts/settings.mjs` already carries a private second copy of
+ * the character class, and a THIRD one — in the module that decides where a comma goes in a
+ * committed theme file — is how the three drift apart. One owner of the set, three views of it.
+ */
+export function stripWhitespaceStart(s) {
+  return s.replace(STRIP_START_RE, '');
+}
+
+export function stripWhitespaceEnd(s) {
+  return s.replace(STRIP_END_RE, '');
+}
+/**
+ * `urllib.parse.unquote(s)` — percent-decoding as Python does it, which is NOT
+ * `decodeURIComponent`.
+ *
+ * The whole difference is what happens to a sequence that is not an escape.
+ * `decodeURIComponent('a%ZZ')` throws a `URIError`, and so does a trailing bare `%`; the
+ * web shell would answer both as a 500 where the reference answers a 404 naming the
+ * literal text. `unquote` leaves them alone: CPython builds a table of every two-hex-digit
+ * pair in both cases and treats a `KeyError` as "this was not an escape", emitting `%` and
+ * the rest of the fragment verbatim.
+ *
+ * The outer split on `([\x00-\x7f]+)` is Python's too, and it is not decoration: only the
+ * ASCII runs are candidates for decoding, so a literal non-ASCII character already in the
+ * path is passed through rather than mixed into the byte buffer. Consecutive escapes ARE
+ * accumulated before decoding, which is what makes `%C3%A9` one `é` and not two
+ * replacement characters.
+ *
+ * `Buffer.toString('utf-8')` substitutes U+FFFD for an undecodable sequence, which is
+ * `errors='replace'`. The two decoders can disagree on HOW MANY replacement characters a
+ * truncated multi-byte sequence yields — Python's maximal-subpart rule against WHATWG's —
+ * and the corpus in `tests/test_pure_function_parity.py` is where that is measured rather
+ * than assumed.
+ */
+const HEX_PAIR = /^[0-9A-Fa-f]{2}$/;
+
+function unquoteToBytes(run) {
+  const bits = run.split('%');
+  if (bits.length === 1) return Buffer.from(run, 'latin1');
+  const out = [Buffer.from(bits[0], 'latin1')];
+  for (const item of bits.slice(1)) {
+    const pair = item.slice(0, 2);
+    if (HEX_PAIR.test(pair)) {
+      out.push(Buffer.from([parseInt(pair, 16)]), Buffer.from(item.slice(2), 'latin1'));
+    } else {
+      out.push(Buffer.from(`%${item}`, 'latin1'));
+    }
+  }
+  return Buffer.concat(out);
+}
+
+export function percentDecode(s) {
+  if (!s.includes('%')) return s;
+  // `re.split` with ONE capture group alternates [gap, group, gap, group, …], so the ASCII
+  // runs are the odd indices on both sides.
+  const bits = s.split(/([\x00-\x7f]+)/);
+  let res = bits[0];
+  for (let i = 1; i < bits.length; i += 2) {
+    res += unquoteToBytes(bits[i]).toString('utf-8');
+    res += bits[i + 1] ?? '';
+  }
+  return res;
+}
+

package/js/lib/udiff.mjs

@@ -260,7 +260,7 @@ export function unifiedDiff(a, b, {
  */
 const LINE_BOUNDARY = /\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/g;
 
-export function pySplitLines(text) {
+export function splitLines(text) {
   const out = [];
   let last = 0;
   LINE_BOUNDARY.lastIndex = 0;

package/js/{memory.mjs → maintain/memory.mjs}

@@ -30,9 +30,9 @@
 import { readdirSync, statSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
 
-import { memoryDropIndex } from './hooks.mjs';
-import { resolveMemoryDir } from './hosts.mjs';
-import { pyPrint, pyPrintErr } from './lib/fs.mjs';
+import { memoryDropIndex } from '../hosts/hooks.mjs';
+import { resolveMemoryDir } from '../hosts/hosts.mjs';
+import { printOut, printErr } from '../lib/fs.mjs';
 
 const isFile = (p) => { try { return statSync(p).isFile(); } catch { return false; } };
 
@@ -77,22 +77,22 @@ export function cmdMemory(args) {
   if (dir === null) {
     // The resolver answers null for "no store anywhere on the chain", which is also what an
     // explicit `--memory` that is not a directory gives — so the message names both.
-    pyPrintErr('[memory] no memory store found. Pass --memory <dir>, set $GENESEED_MEMORY, '
+    printErr('[memory] no memory store found. Pass --memory <dir>, set $GENESEED_MEMORY, '
       + 'or run this from a directory with a memory/ store.\n');
     return 1;
   }
   if (args.action === 'list') {
     const facts = memoryFacts(dir);
     if (!facts.length) {
-      pyPrint(`[memory] ${dir}: no facts.\n`);
+      printOut(`[memory] ${dir}: no facts.\n`);
       return 0;
     }
-    pyPrint(`[memory] ${dir}\n`);
-    for (const name of facts) pyPrint(`  ${name}\n`);
+    printOut(`[memory] ${dir}\n`);
+    for (const name of facts) printOut(`  ${name}\n`);
     return 0;
   }
   if (!args.name) {
-    pyPrintErr('[memory] rm needs the name of a fact.\n');
+    printErr('[memory] rm needs the name of a fact.\n');
     return 2;
   }
   if (!memoryDelete(dir, args.name)) {
@@ -100,9 +100,9 @@ export function cmdMemory(args) {
     // `NotFound(name)` for a reserved name, a name with a separator and a fact that is not
     // there. Telling a caller that `MEMORY` exists but is protected is a distinction this
     // verb has no reason to draw.
-    pyPrintErr(`[memory] no such fact '${args.name}' in ${dir}.\n`);
+    printErr(`[memory] no such fact '${args.name}' in ${dir}.\n`);
     return 1;
   }
-  pyPrint(`[memory] deleted ${args.name}.\n`);
+  printOut(`[memory] deleted ${args.name}.\n`);
   return 0;
 }

package/js/{migrate.mjs → maintain/migrate.mjs}

@@ -24,25 +24,27 @@
  * THE TWO TRIGGERS, AND WHY IT TAKES BOTH. Work is needed when the machine's wiring is
  * `legacy` (see `migrateShape` — and note that shapes 2 and 3 differ only inside the shim
  * body, never in the settings file) OR when the stamp does not name this ROOT. Neither alone
- * is enough: an OpenCode-only machine wires no hooks at all, so its shape is permanently
- * `none` and a shape-only trigger would re-emit it on every run forever; and a user who
- * reinstalls the old Python build flips the shape back to `legacy` while the stamp still
- * matches, which must migrate again. Both inputs, and the stamp is written only on success.
+ * was enough: an OpenCode-only machine wires no hooks at all, so its shape is permanently
+ * `none` and a shape-only trigger would re-emit it on every run forever; and reinstalling the
+ * old build flipped the shape back to `legacy` while the stamp still matched, which had to
+ * migrate again. With the old build gone the second case can no longer arise, but the shape
+ * read stays: it is what makes the verb idempotent rather than stamp-dependent. The stamp is
+ * written only on success.
  */
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import path from 'node:path';
 
-import { main as driverMain } from '../bin/geneseed.mjs';
-import { ROOT } from './checkout.mjs';
+import { main as driverMain } from '../../bin/build-driver.mjs';
+import { ROOT } from '../build/source.mjs';
 import {
   EMIT_HOST_SCOPE, defaultMode, defaultPosture, defaultTheme, doctrinesForBuild,
   footprintOfDir, installState, installTargets, modeOfDir, postureOfDir, readMaybe, themeOfDir,
-} from './installs.mjs';
-import { DEFAULT_EMIT, setupBuildArgs } from './generate.mjs';
+} from '../hosts/installs.mjs';
+import { DEFAULT_EMIT, setupBuildArgs } from '../build/generate.mjs';
 import {
   autostartPaths, autostartStale, hookShimPath, migrateShape, readJsonc, shimHome,
-} from './settings.mjs';
-import { writeText, pyPrint, pyPrintErr } from './lib/fs.mjs';
+} from '../hosts/settings.mjs';
+import { writeText, printOut, printErr } from '../lib/fs.mjs';
 
 /** Every emit name the generator answers to — the set an unrecognised marker is NOT in. */
 const KNOWN_EMITS = new Set(EMIT_HOST_SCOPE.keys());
@@ -50,7 +52,7 @@ const KNOWN_EMITS = new Set(EMIT_HOST_SCOPE.keys());
 /**
  * The settings file a host wires hooks into, or null for a host that has none.
  *
- * Only Claude and Bob carry hook commands. OpenCode's hooks are a PLUGIN (`js/opencode.mjs`
+ * Only Claude and Bob carry hook commands. OpenCode's hooks are a PLUGIN (`js/hosts/opencode.mjs`
  * emits JS that runs in the host's own process and names neither the shim nor `harness.py`),
  * and Copilot has no hook mechanism at all. So those two classify as `none` and their whole
  * migration is the re-emit — which is the same re-emit, in the same change, on all three
@@ -150,34 +152,34 @@ export function cmdMigrate(args = {}) {
   if (unrecognised.length) {
     // Refuse the WHOLE run. A migration that skipped the row it did not understand and
     // migrated the rest is the half-migrated machine this verb exists to prevent.
-    pyPrintErr('[migrate] REFUSED — unrecognised install marker(s):\n');
+    printErr('[migrate] REFUSED — unrecognised install marker(s):\n');
     for (const u of unrecognised) {
-      pyPrintErr(`[migrate]   ${u.host}:${u.scope} (${u.root}) has .geneseed-emit `
+      printErr(`[migrate]   ${u.host}:${u.scope} (${u.root}) has .geneseed-emit `
         + `'${u.marker}', which is not an emit this generator answers to.\n`);
     }
-    pyPrintErr('[migrate] Nothing was changed. Fix or delete the marker, then re-run.\n');
+    printErr('[migrate] Nothing was changed. Fix or delete the marker, then re-run.\n');
     return 3;
   }
 
   if (!rows.length) {
-    pyPrint('[migrate] no active installs detected.\n');
+    printOut('[migrate] no active installs detected.\n');
     return 0;
   }
 
   if (!needed) {
-    pyPrint(`[migrate] already on the npm shape (${rows.length} install(s)); nothing to do.\n`);
+    printOut(`[migrate] already on the npm shape (${rows.length} install(s)); nothing to do.\n`);
     return 0;
   }
 
-  pyPrint(`[migrate] ${rows.length} install(s), wiring shape: ${shape}\n`);
+  printOut(`[migrate] ${rows.length} install(s), wiring shape: ${shape}\n`);
   if (dryRun) {
     for (const r of rows) {
-      pyPrint(`[migrate] would re-emit ${r.host}:${r.scope} (${r.root})\n`);
+      printOut(`[migrate] would re-emit ${r.host}:${r.scope} (${r.root})\n`);
     }
     for (const p of autostartFindings()) {
-      pyPrint(`[migrate] would report the autostart entry at ${p}\n`);
+      printOut(`[migrate] would report the autostart entry at ${p}\n`);
     }
-    pyPrint('[migrate] --dry-run: nothing was written.\n');
+    printOut('[migrate] --dry-run: nothing was written.\n');
     return 0;
   }
 
@@ -195,7 +197,7 @@ export function cmdMigrate(args = {}) {
       saved.push([p, dest]);
     }
   } catch (e) {
-    pyPrintErr(`[migrate] could not stage a backup (${e.message}); nothing was changed.\n`);
+    printErr(`[migrate] could not stage a backup (${e.message}); nothing was changed.\n`);
     return 1;
   }
 
@@ -222,15 +224,15 @@ export function cmdMigrate(args = {}) {
       postureOfDir(r.root) || defaultPosture(), modeOfDir(r.root) || defaultMode(),
       doctrinesForBuild(r.root));
     const label = `${r.host}:${r.scope} (${r.root})`;
-    pyPrint(`[migrate] re-emitting ${label}: theme=${theme} emit=${emit}\n`);
+    printOut(`[migrate] re-emitting ${label}: theme=${theme} emit=${emit}\n`);
     let rc = 1;
     try { rc = driverMain(argv); } catch { rc = 1; }
     if (rc !== 0) {
       // Step 4 — ALL OR NOTHING. `rebuild-all` continues here on purpose; a migration
       // must not, or the machine is left half on each shape.
-      pyPrintErr(`[migrate] FAILED ${label} (exit ${rc}) — rolling back.\n`);
+      printErr(`[migrate] FAILED ${label} (exit ${rc}) — rolling back.\n`);
       restore();
-      pyPrintErr(`[migrate] rolled back ${saved.length} file(s); the install is unchanged.\n`);
+      printErr(`[migrate] rolled back ${saved.length} file(s); the install is unchanged.\n`);
       return 1;
     }
   }
@@ -241,7 +243,7 @@ export function cmdMigrate(args = {}) {
     writeText(stampPath(), `${ROOT}\n`);
   } catch { /* an unwritable stamp costs a redundant re-emit next run, never correctness */ }
 
-  pyPrint(`[migrate] migrated ${rows.length} install(s).\n`);
+  printOut(`[migrate] migrated ${rows.length} install(s).\n`);
 
   // Step 5 — what could NOT be fixed automatically. Reported, never rewritten: nothing in
   // this repository has ever written an autostart entry, so migrate does not own the file.
@@ -250,7 +252,7 @@ export function cmdMigrate(args = {}) {
   // `web restart` and `web status` stay blind to the server this note just told someone to
   // launch at every login. Derived, not trusted: `TheMigrateNoteAdvisesARealWebAction`.
   for (const p of autostartFindings()) {
-    pyPrint(`[migrate] NOTE: the autostart entry at ${p} still names another checkout — `
+    printOut(`[migrate] NOTE: the autostart entry at ${p} still names another checkout — `
       + 'update it by hand to run: geneseed web start --no-browser\n');
   }
   return 0;

package/js/{setup.mjs → maintain/setup.mjs}

@@ -1,5 +1,5 @@
 /**
- * `rituals/_harness_setup.py`'s wizard — the LINE-MODE install flow, and the first verb in
+ * The install wizard — the LINE-MODE flow, and the first verb in
  * this port that reads stdin.
  *
  * WHAT `setup` ACTUALLY IS, measured rather than taken from the brief. `cmd_setup` is 21
@@ -44,18 +44,20 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readSync } from 'node:fs';
 import path from 'node:path';
 
-import { main as driverMain, resolveOut } from '../bin/geneseed.mjs';
-import { playLine } from './anim.mjs';
-import { discoverNames, PACK_ORDER } from './checkout.mjs';
-import { exportImprovements } from './diff.mjs';
-import { cmdDoctor } from './doctor.mjs';
-import { setupBuildArgs } from './generate.mjs';
-import { GLOBAL_MANIFEST, opencodeConfigDir } from './hosts.mjs';
+import { main as driverMain, resolveOut } from '../../bin/build-driver.mjs';
+import { playLine } from '../ui/anim.mjs';
+import { discoverNames, PACK_ORDER } from '../build/source.mjs';
+import { exportImprovements } from '../inspect/diff.mjs';
+import { cmdDoctor } from '../inspect/doctor.mjs';
+import { setupBuildArgs } from '../build/generate.mjs';
+import { GLOBAL_MANIFEST, opencodeConfigDir } from '../hosts/hosts.mjs';
 import {
   defaultMode, defaultPosture, defaultTheme, installedDefaults, themeFiles,
-} from './installs.mjs';
-import { pyInt, pyPrint, pyPrintErr, pyWhich } from './lib/fs.mjs';
-import { NO_WINDOW } from './lib/proc.mjs';
+} from '../hosts/installs.mjs';
+import { printOut, printErr } from '../lib/fs.mjs';
+import { which } from '../lib/paths.mjs';
+import { parseIntStrict } from '../lib/text.mjs';
+import { NO_WINDOW } from '../lib/proc.mjs';
 
 // --------------------------------------------------------------------------------------
 // the three readers
@@ -68,7 +70,7 @@ import { NO_WINDOW } from './lib/proc.mjs';
  * until EOF rather than until Enter, so a wizard built on it would hang on a real terminal
  * until the user pressed Ctrl-D. Reading fd 0 one byte at a time to the first `\n` is what
  * `input()` does, and it is the only synchronous shape that stops where Enter stops. The
- * body arrived in P5h inside `js/uninstall.mjs`'s `confirm`; `setup` is the second caller,
+ * body arrived in P5h inside `js/maintain/uninstall.mjs`'s `confirm`; `setup` is the second caller,
  * so it moved to where the Python's own owner is — `_harness_setup` — and `confirm` is built
  * on it here exactly as `_confirm` is built on `_ask` there.
  *
@@ -83,7 +85,7 @@ import { NO_WINDOW } from './lib/proc.mjs';
  */
 export function ask(prompt, dflt = '') {
   const suffix = dflt ? ` [${dflt}]` : '';
-  // `input()` writes its prompt to stdout with no newline — nothing for `pyPrint` to
+  // `input()` writes its prompt to stdout with no newline — nothing for `printOut` to
   // translate, and it must NOT gain one.
   process.stdout.write(`${prompt}${suffix}: `);
   // `?? ''` because `readLine` reports EOF-with-nothing-read as null since P6h; `_ask`
@@ -154,7 +156,7 @@ export function confirm(prompt, dflt = true) {
  *     integer never reaches it. `99` against a five-option menu returns the default; it does
  *     not go looking for an option literally named `99`.
  *   * An in-range index wins, a parsed out-of-range index falls to the default, and only an
- *     UNPARSEABLE answer is matched against the keys. `pyInt` is what separates the second
+ *     UNPARSEABLE answer is matched against the keys. `parseIntStrict` is what separates the second
  *     case from the third, and it is not `Number()` — see its own docblock.
  *   * The default's index is computed with `next(...)` and no fallback, so a default that is
  *     not in `options` raises `StopIteration` on the reference. That is reachable (a
@@ -163,15 +165,15 @@ export function confirm(prompt, dflt = true) {
  *     place, and a silent `-1` here would be a divergence dressed as robustness.
  */
 export function askChoice(prompt, options, dflt) {
-  pyPrint(`\n${prompt}:\n`);
+  printOut(`\n${prompt}:\n`);
   options.forEach(([key, desc], i) => {
     const label = desc ? `${key} — ${desc}` : key;
-    pyPrint(`  ${i + 1}) ${label}${key === dflt ? '   (default)' : ''}\n`);
+    printOut(`  ${i + 1}) ${label}${key === dflt ? '   (default)' : ''}\n`);
   });
   const defaultIdx = options.findIndex(([k]) => k === dflt);
   if (defaultIdx < 0) throw new Error(`StopIteration: no option named ${dflt}`);
   const raw = ask('Choose', String(defaultIdx + 1));
-  const idx = pyInt(raw);
+  const idx = parseIntStrict(raw);
   if (idx !== null) {
     if (idx >= 1 && idx <= options.length) return options[idx - 1][0];
   } else {
@@ -359,7 +361,7 @@ function askDoctrines(deployed = null) {
  * carrier said none" and the two open the question differently.
  */
 export function collectSetupLines() {
-  pyPrint('Geneseed setup — answer a few questions; nothing is written until you confirm.\n');
+  printOut('Geneseed setup — answer a few questions; nothing is written until you confirm.\n');
   const inst = installedDefaults();
   const theme = askChoice('Theme', themeOptions(), inst.theme || defaultTheme());
   const posture = askChoice('Posture', postureOptions(), inst.posture || defaultPosture());
@@ -383,11 +385,21 @@ export function collectSetupLines() {
   // own: the menu the user just answered was built from `doctrineOptions()`, so "they picked
   // everything" must be judged against that same list, not against a second one.
   const allPacks = doctrineOptions().map(([n]) => n);
-  pyPrint(`\nAbout to run:  geneseed build ${
-    setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines, allPacks)
-      .join(' ')}\n`);
+  // ⚠ PRESERVED, NOT ASKED. The wizard has no per-rule question — five registers is already
+  // the ceiling for a prompt sequence somebody answers by holding Enter, and a rule list is a
+  // console control, not a terminal one. But it must not be DROPPED either: re-running the
+  // wizard on an install that excluded `process 5` would otherwise hand the consent gate back
+  // without a word, which is the same silent widening the pack question was fixed for.
+  //
+  // `null` when there is nothing to preserve rather than `[]`: an empty list makes
+  // `setupBuildArgs` spell `--exclude-rules none`, and that string would land in the
+  // "About to run:" line every recorded wizard probe compares byte for byte.
+  const excludeRules = inst.excludeRules?.length ? inst.excludeRules : null;
+  printOut(`\nAbout to run:  geneseed build ${
+    setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines, allPacks,
+      excludeRules).join(' ')}\n`);
   if (!confirm('Proceed?', true)) return null;
-  return { theme, posture, mode, doctrines, emit, out, root, footprint };
+  return { theme, posture, mode, doctrines, excludeRules, emit, out, root, footprint };
 }
 
 // --------------------------------------------------------------------------------------
@@ -399,14 +411,14 @@ export function collectSetupLines() {
  *
  * `21.0.2` gives 21 and the legacy `1.8.0` gives 1, which is never >= 21 — that asymmetry is
  * the whole function. `\p{Nd}` rather than `[0-9]` because Python's `\d` matches any Unicode
- * decimal and JS's does not without the flag, and `pyInt` reads the group for the same
+ * decimal and JS's does not without the flag, and `parseIntStrict` reads the group for the same
  * reason. No `java` prints such a banner; matching Python where it is free is cheaper than a
  * comment explaining where it does not.
  */
 export function javaMajorOk(versionOutput, minimum = 21) {
   const m = /version "(\p{Nd}+)/u.exec(versionOutput);
   if (!m) return false;
-  const n = pyInt(m[1]);
+  const n = parseIntStrict(m[1]);
   return n !== null && n >= minimum;
 }
 
@@ -415,14 +427,14 @@ export function javaMajorOk(versionOutput, minimum = 21) {
  * for itself. Today that is a JDK 21+ for `jdtls`; the JS-runtime servers self-download.
  *
  * THE SECOND SPAWN ON THIS ENTRY POINT, and the reason `test_the_cli_reaches_child_process_\
- * only_where_it_is_declared` became a TABLE. `js/doctor.mjs` was the sole allowed importer
+ * only_where_it_is_declared` became a TABLE. `js/inspect/doctor.mjs` was the sole allowed importer
  * for one binding and one argv; this is the second, and the port's rule is that the second
  * instance of anything turns a special case into a table cross-checked against the source.
  * The argv is asserted literally there, so an allow-list entry cannot be reused to start an
  * interpreter.
  */
 export function lspPrereqs() {
-  const java = pyWhich('java');
+  const java = which('java');
   let ok = false;
   if (java) {
     try {
@@ -512,7 +524,7 @@ export function setupSummaryLines(theme, emit, out, root, ok) {
  * sides (`_harness_build.cmd_build`, and `driverMain` here), so the line still names a
  * command the reader can type, and names one that survives the deletion.
  *
- * `theme_anim.play_line` USED TO BE THE SECOND, and P7c crossed it — `js/anim.mjs`, gated by
+ * `theme_anim.play_line` USED TO BE THE SECOND, and P7c crossed it — `js/ui/anim.mjs`, gated by
  * `_theme_anim_cases()` in `tests/test_pure_function_parity.py`. The bare `catch` around it
  * is the reference's own, labelled there "cosmetic only — never block a successful install",
  * and it is kept for the same reason: the animation runs AFTER the build has already
@@ -521,12 +533,12 @@ export function setupSummaryLines(theme, emit, out, root, ok) {
 export function setupLines() {
   const sel = collectSetupLines();
   if (!sel) {
-    pyPrint('[setup] cancelled — nothing written.\n');
+    printOut('[setup] cancelled — nothing written.\n');
     return 0;
   }
   const {
     theme, emit, out, root, footprint = 'lean', posture = 'peer', mode = 'direct',
-    doctrines = null,
+    doctrines = null, excludeRules = null,
   } = sel;
   if (emit === 'opencode-global') {
     // The build below overwrites the deployed global harness, and the self-improvement loops
@@ -534,29 +546,29 @@ export function setupLines() {
     try {
       const [ipath] = exportImprovements();
       if (ipath) {
-        pyPrint(`- local edits found in the deployed harness — saved to ${ipath}\n`);
-        pyPrint('  (hand that file to your agent to back-port them into src/)\n');
+        printOut(`- local edits found in the deployed harness — saved to ${ipath}\n`);
+        printOut('  (hand that file to your agent to back-port them into src/)\n');
       }
     } catch (e) {
-      pyPrint(`! could not export local edits (${e && e.message}) — continuing.\n`);
+      printOut(`! could not export local edits (${e && e.message}) — continuing.\n`);
     }
   }
   // Same list the question was built from — see `collectSetupLines`. The build that actually
   // runs must carry the pack selection the plan line just previewed, or the wizard would print
   // one command and run another.
   const argv = setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines,
-    doctrineOptions().map(([n]) => n));
-  pyPrint(`Running:  geneseed build ${argv.join(' ')}\n`);
+    doctrineOptions().map(([n]) => n), excludeRules);
+  printOut(`Running:  geneseed build ${argv.join(' ')}\n`);
   const rc = driverMain(argv);
   if (rc !== 0) {
-    pyPrintErr('[setup] build failed — no harness written (see the output above).\n');
+    printErr('[setup] build failed — no harness written (see the output above).\n');
     return rc;
   }
   try {
     playLine(theme, true);        // themed install animation (motion → reveal card)
   } catch { /* cosmetic only — never block a successful install */ }
   for (const [kind, text] of setupSummaryLines(theme, emit, out, root, true)) {
-    pyPrint(`${{ ok: '✓', warn: '!', info: '-' }[kind] ?? '-'} ${text}\n`);
+    printOut(`${{ ok: '✓', warn: '!', info: '-' }[kind] ?? '-'} ${text}\n`);
   }
   if (confirm('\nRun a health check (doctor) now?', true)) {
     // Scoped to the theme just installed — no full-sweep noise post-install.
@@ -574,7 +586,7 @@ export function setupLines() {
  */
 export function cmdSetup() {
   if (!process.stdin.isTTY) {
-    pyPrintErr('[setup] needs an interactive terminal. Non-interactive? e.g.:\n'
+    printErr('[setup] needs an interactive terminal. Non-interactive? e.g.:\n'
       + '  geneseed build --emit opencode-global --theme neutral\n');
     return 1;
   }