geneseed 2.0.0

package/geneseed

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+#
+# Geneseed — front door. A thin shim: it finds the checkout and hands every argument
+# to the Node CLI, which owns the verbs, the parsing and the refusals.
+#
+#     ./geneseed                    open the web console, else the TUI menu (`home`)
+#     ./geneseed <command> [args]   anything bin/geneseed-cli.mjs carries
+#     ./geneseed --help             the verb list, printed by the CLI itself
+#
+# NO VERB TABLE HERE, deliberately. This launcher used to enumerate the commands it
+# would forward, and that list had gone stale: `migrate`, `exclude` and `rule-gate`
+# all existed, all fell to its `*)` arm and all exited 2 — while `geneseed.cmd`
+# passed everything through, so the two front doors disagreed about what the harness
+# could do. One CLI, one verb table, one refusal. `./geneseed` in a checkout now
+# behaves exactly like the `geneseed` an `npm i -g` puts on PATH, because that is
+# this same entry point (package.json `bin`). The four HOOK verbs (`context`,
+# `learn`, `git-gate`, `rule-gate`) live on `bin/geneseed-hook.mjs` and are reached
+# by hooks with a baked absolute path; the CLI's refusal names that file.
+#
+# $GENESEED_NODE overrides the interpreter — the analogue of the $PYTHON knob this
+# file carried while the harness was Python. Unset, a bare `node` is used.
+set -eo pipefail
+# Resolve through symlinks so HERE is the real repo dir. `geneseed link` writes a
+# shim naming its entry by absolute path rather than a symlink, but an install made
+# before it did left ~/.local/bin/geneseed pointing at THIS file, and this loop is
+# the only reason those still work.
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+  dir="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  case "$SOURCE" in /*) ;; *) SOURCE="$dir/$SOURCE" ;; esac
+done
+HERE="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+
+# Bare `./geneseed` is the `home` verb — the web console when the environment can
+# show it (interactive + GUI browser), else the interactive TUI menu; GENESEED_NO_WEB=1
+# disables the web-first default. The CLI entry requires a verb, so the default is here.
+if [ "$#" -eq 0 ]; then set -- home; fi
+exec "${GENESEED_NODE:-node}" "$HERE/bin/geneseed-cli.mjs" "$@"

package/geneseed.cmd

@@ -0,0 +1,34 @@
+@echo off
+rem Geneseed — native Windows front door (cmd.exe). A thin shim: it hands every
+rem argument to the Node CLI, which owns the verbs, the parsing and the refusals.
+rem
+rem   geneseed                    open the web console, else the TUI menu (`home`)
+rem   geneseed <command> [args]   anything bin\geneseed-cli.mjs carries
+rem   geneseed --help             the verb list, printed by the CLI itself
+rem
+rem There is no verb table here — see the bash `geneseed` for why the old one was a
+rem liability. There is no PowerShell twin either: pwsh and Windows PowerShell both
+rem run a .cmd directly, so `.\geneseed.cmd setup` is the PowerShell spelling too.
+rem
+rem %GENESEED_NODE% overrides the interpreter — the analogue of the %PYTHON% knob
+rem this file carried while the harness was Python. Unset, a bare `node` is used.
+rem
+rem TWO MECHANICS, both measured rather than assumed:
+rem   * `exit /b %ERRORLEVEL%`, not a bare `exit /b`. A bare one propagates a child's
+rem     exit code fine, but returns 0 when the command could not be LAUNCHED at all —
+rem     which is exactly the %GENESEED_NODE%-is-wrong case, and "the front door
+rem     reported success having run nothing" is the worst answer available.
+rem   * a `goto`, not a parenthesized `if` block, so each `exit /b` sits on its own
+rem     top-level line. %ERRORLEVEL% inside a block expands at parse time and would
+rem     return a stale code — which is what forced the bare form in the first place.
+setlocal
+set "HERE=%~dp0"
+set "NODE=node"
+if defined GENESEED_NODE set "NODE=%GENESEED_NODE%"
+if "%~1"=="" goto :home
+"%NODE%" "%HERE%bin\geneseed-cli.mjs" %*
+exit /b %ERRORLEVEL%
+
+:home
+"%NODE%" "%HERE%bin\geneseed-cli.mjs" home
+exit /b %ERRORLEVEL%

package/harness.config.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "version is a human-readable release label only; the canonical identity of an installed harness is the source fingerprint stamped in .geneseed-version (see `harness version`), not this string.",
+  "theme": "neutral",
+  "product": "Geneseed",
+  "version": "2.0.0"
+}

package/js/anim.mjs

@@ -0,0 +1,326 @@
+/**
+ * `rituals/theme_anim.py` — the per-theme install animation the LINE wizard plays.
+ *
+ * P7c, and the one leftover of that phase that is NOT the declared curses panel. P5i ported
+ * `_setup_lines` and left this out with a note — "belongs to P7 with the rest of the terminal
+ * layer" — and the rest of the terminal layer turned out to be the panel, which stays
+ * declared (`tests/test_tui_boundary.py` says why, and asserts it). This module is the part
+ * that has nothing to do with curses: it draws on the ORDINARY terminal, with cursor-up
+ * escapes and a sleep, and its only caller is a function that already crossed.
+ *
+ * SO IT IS NOT IN `js/tui.mjs`, DELIBERATELY. That module carries a structural assertion that
+ * it contains no escape sequence at all — the thing that makes "the panel is declared" a
+ * measurement instead of a promise. This file necessarily contains `\x1b[{n}A`, so putting it
+ * there would have turned that assertion red and invited someone to weaken it. A line-mode
+ * animation and a full-screen panel are different subsystems in the reference too: they live
+ * in different files there and they do here.
+ *
+ * WHAT THE PYTHON DOES THAT THIS DOES NOT, and it is one line. `_anim_ok` calls
+ * `os.system("")` on Windows, whose only purpose is the side effect of making the console
+ * enable VT/ANSI processing; it is not a probe and its return value is discarded. Node's
+ * console writer already enables virtual-terminal processing on Windows when stdout is a TTY
+ * (libuv does it when the stream is opened), so the effect is present and the call is not
+ * needed — which is fortunate, because it is a `child_process` spawn and this port is barred
+ * from those. The consequence is that the reference's `except Exception: return False` arm
+ * around it has no counterpart here. That arm needs `cmd.exe` to be unlaunchable on a machine
+ * that has already reached an interactive wizard, and `anim_ok` is compared over ten
+ * environments in `tests/test_pure_function_parity.py` — none of which can produce it on
+ * either side.
+ *
+ * WHAT GATES IT. `tests/test_pure_function_parity.py`'s `_theme_anim_cases()`: `art_for` over
+ * every key plus the prototype-chain names, `_place`/`_tile`/`_height` over their arithmetic,
+ * `_anim_ok` over its whole decision table, and `play_line` itself over 24 environments —
+ * captured on the reference side through a real `TextIOWrapper`, so the CRLF translation is
+ * inside the comparison rather than outside it.
+ */
+import { pyInt, pyLen, pyLjust, pyPrint } from './lib/fs.mjs';
+
+export const ART = {
+  imperial: {
+    title: '+ ADEPTUS ASTARTES +',
+    sprite: [
+      ['   .---.   ', '  |[o o]|  ', '<#|=====|#====-', '  | ### |  ', '  /     \\  '],
+      ['   .---.   ', '  |[o o]|  ', '<#|=====|#====-', '  | ### |  ', '  \\     /  '],
+    ],
+    ground: '_',
+    card: [
+      '        |>>|        ',
+      "     .--'=='--.     ",
+      '    |[ O    O ]|    ',
+      '  <#|==========|#===---',
+      '    |  ::##::  |    ',
+      '    /          \\    ',
+      '   THE EMPEROR PROTECTS',
+    ],
+  },
+  pirate: {
+    title: '~ HOIST THE COLOURS ~',
+    sprite: [
+      ['    |    ', '   /|\\   ', '  /_|_\\  ', ' \\=====/ '],
+      ['    |    ', '   /|\\   ', '  /_|_\\  ', ' \\=====/ '],
+    ],
+    ground: '~^~ ',
+    card: [
+      '         |    |         ',
+      '        /|\\  /|         ',
+      '       /_|_\\/_|         ',
+      '   __|~~~~~~~~~~|__      ',
+      '   \\===== JOLLY ====/    ',
+      ' ~^~~^~~^~~^~~^~~^~~^~~  ',
+      '      DEAD MEN TELL NO TALES',
+    ],
+  },
+  cyberpunk: {
+    title: '>_ JACK IN',
+    sprite: [
+      ['1 0  01  1 0', ' 0 11 0  1 0', '0  1  10 0 1', ' 11 0  1  10'],
+      ['0 1  10  0 1', ' 1 00 1  0 1', '1  0  01 1 0', ' 00 1  0  01'],
+    ],
+    ground: '=-',
+    card: [
+      ' 010  1  0 11  0 1  010 ',
+      '1  01 0 11  0  1 00  1 0',
+      ' 11  0  WAKE UP  1  0 1 ',
+      '0  1 01  0 11  0 1  00 1',
+      ' 1 0  THE NET IS YOURS 0',
+      '=-=-=-=-=-=-=-=-=-=-=-=-',
+    ],
+  },
+  gamer: {
+    title: '* PRESS START *',
+    sprite: [
+      ['  ___        ', ' /C  o  o  o ', ' \\___        '],
+      ['  ___        ', ' (c   o  o  o', ' \\___        '],
+    ],
+    ground: '.',
+    card: [
+      '   ___                  .oOo.   ',
+      '  /C   o  o  o  o  o    | x x |  ',
+      '  \\___                 |__o__|  ',
+      '  HI-SCORE  999999    1UP  x3   ',
+      '  >>> LEVEL CLEARED <<<         ',
+    ],
+  },
+  military: {
+    title: '[ ADVANCE - MOVE OUT ]',
+    sprite: [
+      ['    ____      ', ' __/    \\__==-', '|  o  o  o |  ', "'-O-O-O-O-'  "],
+      ['    ____      ', ' __/    \\__==-', '|  o  o  o |  ', "'O-O-O-O-O'  "],
+    ],
+    ground: '^',
+    card: [
+      '        ____            ',
+      '     __/    \\_____===-   ',
+      '    | o   o   o   |      ',
+      "    '-O-O-O-O-O-O-'      ",
+      '  ^^^^^^^^^^^^^^^^^^^^   ',
+      '    MISSION  GO  GO  GO  ',
+    ],
+  },
+  sports: {
+    title: '<< GAME ON >>',
+    sprite: [
+      ['   (o)      |‾|', '           | |', '  _________|_|'],
+      ['      (o)   |‾|', '           | |', '  _________|_|'],
+    ],
+    ground: '_',
+    card: [
+      '                    .---.   ',
+      '      (o)           |   |   ',
+      '     /              | G |   ',
+      '  ________________  |_O_|   ',
+      '   >>>  GOOOAAL !!!  <<<    ',
+    ],
+  },
+  wizard: {
+    title: '~* CAST THE RITE *~',
+    sprite: [
+      ['    ,*  .   ', '   /|   *   ', '  (o o)  .  ', '  /|*|\\ *   ', '   | |     '],
+      ['    .  *,   ', '   /|  .    ', '  (o o) *   ', '  /|*|\\  .  ', '   | |     '],
+    ],
+    ground: '.',
+    card: [
+      '         ,*.    *  .        ',
+      '        /|   *   .   *      ',
+      '       (o  o)  .  *   .     ',
+      '       /|**|\\   *    *      ',
+      '        |  |   .  THE       ',
+      '      ARCANE IS BOUND       ',
+    ],
+  },
+  neutral: {
+    title: 'Geneseed',
+    sprite: [
+      ['>>>        '],
+      ['   >>>     '],
+      ['      >>>  '],
+    ],
+    ground: '',
+    card: [
+      '  [############------]  ',
+      '  harness ready.        ',
+    ],
+  },
+};
+
+export const DEFAULT = 'neutral';
+
+/**
+ * `theme_anim.art_for` — `ART.get(theme, ART[DEFAULT])`.
+ *
+ * `Object.hasOwn`, not `ART[theme] ?? ART[DEFAULT]`. `ART['constructor']` is a function on
+ * the prototype chain and therefore not nullish, so the `??` spelling would hand a Function
+ * back to `play_line` where the reference hands back the neutral theme. The third table in
+ * this port to carry the trap — `_icon` and `_mark` were the first two — and the corpus
+ * names all four inherited keys.
+ */
+export function artFor(theme) {
+  return Object.hasOwn(ART, theme) ? ART[theme] : ART[DEFAULT];
+}
+
+/** A code-point slice — Python's `s[a:b]`, which does not count UTF-16 units. */
+const cut = (s, a, b) => Array.from(s).slice(a, b).join('');
+
+/**
+ * `shutil.get_terminal_size((80, 24)).columns`.
+ *
+ * `pyInt` and not `parseInt`, and the corpus has a case for exactly that: Python's `int()`
+ * refuses `'80x'` outright and `get_terminal_size` swallows the ValueError into the fallback,
+ * where `parseInt('80x')` is a cheerful 80. A width one column off is invisible in a terminal
+ * and loud in a byte comparison. `<= 0` is the reference's own guard, which is why `'0'` and
+ * `'-5'` fall through to the fallback rather than producing a zero-width canvas.
+ */
+function terminalColumns() {
+  const env = pyInt(process.env.COLUMNS);
+  if (env !== null && env > 0) return env;
+  // `sys.__stdout__` over there, `process.stdout` here. Both are undefined-ish off a
+  // terminal, and both then take the (80, 24) fallback.
+  const real = process.stdout.columns;
+  return typeof real === 'number' && real > 0 ? real : 80;
+}
+
+/**
+ * `theme_anim._anim_ok` — whether an in-place ANSI animation is safe here.
+ *
+ * ⚠ TERM=dumb AND TERM UNSET ARE NOT REFUSALS ON WINDOWS. The reference guards that branch
+ * with `if os.name != "nt"`, so on Windows a dumb TERM still animates — which is right,
+ * because TERM is not what a Windows console is configured by. Reading the branch as an
+ * unconditional refusal would disable the animation on the only platform whose users get the
+ * line wizard by default.
+ */
+export function animOk() {
+  if (process.env.GENESEED_NO_ANIM || process.env.GENESEED_TUI_PLAIN) return false;
+  if (!process.stdout.isTTY) return false;
+  const term = (process.env.TERM || '').toLowerCase();
+  if (term === 'dumb' || term === '') {
+    if (process.platform !== 'win32') return false;
+  }
+  // The reference's `os.system("")` goes here; see the module header for why it does not.
+  return true;
+}
+
+/** `theme_anim._place` — a sprite row drawn at column `x`, clipped to `width`. */
+export function place(row, x, width) {
+  const s = x >= 0 ? ' '.repeat(x) + row : cut(row, -x);
+  return cut(s, 0, width);
+}
+
+/**
+ * `theme_anim._tile` — the ground line, scrolled by `phase`.
+ *
+ * Two Python arithmetic rules, both of which JavaScript spells differently. `width //
+ * len(tile)` is FLOOR division, so a negative width gives a negative repeat count — which
+ * Python turns into an empty string and `String.repeat` turns into a RangeError, hence the
+ * clamp. And `phase % len(tile)` is non-negative in Python for a positive divisor while
+ * JavaScript keeps the sign of the dividend, so a negative phase indexes off the front of the
+ * string instead of wrapping to the end. `_spin` had the same trap in P7b.
+ */
+export function tile(tileStr, width, phase = 0) {
+  if (!tileStr) return '';
+  const n = pyLen(tileStr);
+  const base = tileStr.repeat(Math.max(0, Math.floor(width / n) + 2));
+  const off = ((phase % n) + n) % n;
+  return cut(base, off, off + width);
+}
+
+/** `theme_anim._height` — `max((len(p) for p in poses), default=0)`. */
+export function height(poses) {
+  return Math.max(0, ...poses.map((p) => p.length));
+}
+
+/**
+ * `str.center(width)`, which is not `padStart`+`padEnd` and not symmetric.
+ *
+ * CPython's `stringlib` computes `left = marg // 2 + (marg & width & 1)`, and that last term
+ * is a genuine oddity rather than a rounding convention: when the margin AND the width are
+ * both odd the extra column goes on the LEFT, and otherwise on the right. Nothing about
+ * "centre this" implies it. The title line of every animation is the only caller.
+ */
+function pyCenter(s, width) {
+  const marg = width - pyLen(s);
+  if (marg <= 0) return s;
+  /* eslint-disable-next-line no-bitwise */
+  const left = Math.floor(marg / 2) + (marg & width & 1);
+  return ' '.repeat(left) + s + ' '.repeat(marg - left);
+}
+
+/** `time.sleep(seconds)`, synchronously. `Atomics.wait` is the stdlib's only sync sleep. */
+const sleep = (ms) => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+
+/**
+ * `theme_anim.play_line` — scroll the themed sprite, then settle on the static card.
+ *
+ * Never raises: the reference wraps the animation in `except Exception` and degrades to the
+ * static card, and `_setup_lines` wraps the whole call again in a bare `except: pass` marked
+ * "cosmetic only — never block a successful install". Both layers are kept. A failed
+ * animation must not be able to fail an install that already succeeded.
+ */
+export function playLine(theme, ok = true) {
+  const art = artFor(theme);
+  const width = Math.min(terminalColumns() - 1, 56);
+  pyPrint('\n');
+  pyPrint(`${pyCenter(art.title, width)}\n`);
+  if (!ok) return;
+  if (!animOk()) {
+    for (const r of art.card) pyPrint(`${cut(r, 0, width)}\n`);
+    pyPrint('\n');
+    return;
+  }
+  const poses = art.sprite;
+  const ground = art.ground || '';
+  const h = height(poses);
+  const canvasH = h + (ground ? 1 : 0);
+  const spriteW = Math.max(0, ...poses.flatMap((p) => p.map((r) => pyLen(r))));
+  try {
+    pyPrint('\n'.repeat(canvasH));
+    const steps = Math.min(width + spriteW, 64);      // cap to ~1.6s of motion
+    for (let i = 0; i <= steps; i += 1) {
+      const pose = poses[Math.floor(i / 3) % poses.length];
+      const x = width - i;                            // enter from the right, travel left
+      const lines = [];
+      for (let r = 0; r < h; r += 1) lines.push(place(r < pose.length ? pose[r] : '', x, width));
+      if (ground) lines.push(tile(ground, width, i));
+      pyPrint(`\x1b[${canvasH}A`);
+      for (const ln of lines) pyPrint(`\r${cut(pyLjust(ln, width), 0, width)}\n`);
+      sleep(25);
+    }
+    // settle on the card
+    pyPrint(`\x1b[${canvasH}A`);
+    const card = art.card;
+    for (let r = 0; r < canvasH; r += 1) {
+      const row = r < card.length ? cut(card[r], 0, width) : '';
+      pyPrint(`\r${cut(pyLjust(row, width), 0, width)}\n`);
+    }
+    // any extra card rows beyond the canvas
+    for (let r = canvasH; r < card.length; r += 1) pyPrint(`${cut(card[r], 0, width)}\n`);
+    pyPrint('\n');
+  } catch {
+    // Terminal didn't cooperate — leave a clean static card.
+    try {
+      for (const r of art.card) pyPrint(`${cut(r, 0, width)}\n`);
+      pyPrint('\n');
+    } catch { /* nothing left to try */ }
+  }
+}

package/js/catalog.mjs

@@ -0,0 +1,112 @@
+/**
+ * `geneseed catalog` — the shipped roster, in a terminal.
+ *
+ * WHY THIS VERB IS NEW RATHER THAN PORTED. The reference had no `catalog` subcommand: the
+ * same information existed only behind the web console's catalog endpoint and behind the
+ * full-screen browse panel, so the one way to ask "what does this harness actually ship"
+ * from a shell was to start a server. The endpoint's answer is the source of the fields
+ * rendered here — name, one-line purpose, source file, lifecycle status, and a skill's
+ * category — so this is a second FACE on one walk and not a second walk.
+ *
+ * THAT WALK IS `tuiInventory`, WHICH ALREADY HAD FOUR CALLERS and now has five. Nothing
+ * about the classification lives here; a listing that re-derived "which files are agents"
+ * would be the second classifier the inventory module's header exists to forbid.
+ *
+ * IT RETIRES THREE HELPERS THAT HAD NO PRODUCT CALLER. `tuiEntries`, `icon`/`fit`/`truncd`
+ * and the display-width table under them were ported for a panel that was then dropped, and
+ * were reachable only from their own gates. They are the right tools for this rendering
+ * — `dwidth` is what keeps an emoji-bearing purpose line from breaking the column — so the
+ * roster is built out of them rather than beside them. `detailLines` is NOT used and stays
+ * uncalled: it renders a selected entry's whole body into a detail pane, which a listing
+ * has no place for.
+ *
+ * NOTHING HERE PAINTS. No cursor moves, no clears, no alternate screen: this writes lines
+ * and stops, exactly as `status` does. That is what keeps the dropped panel dropped.
+ */
+import { helpWidth } from './cli.mjs';
+import { tuiInventory } from './inventory.mjs';
+import { defaultTheme, installedDefaults } from './installs.mjs';
+import { pyPrint } from './lib/fs.mjs';
+import { dwidth, fit, icon, truncd, tuiEntries } from './tui.mjs';
+
+/** The listing's section names, and the row kind each one selects. */
+export const CATALOG_KINDS = { agents: 'agent', skills: 'skill', laws: 'law' };
+
+/**
+ * The badge column: what the catalog endpoint carries beside the name that is not the
+ * purpose. An agent has a lifecycle status, a skill has that and a category, a law has a
+ * governance class and no status at all — which is the endpoint's shape, not a shortcut.
+ */
+function badgeFor(kind, data) {
+  if (kind === 'law') return data.klass ?? 'craft';
+  if (kind === 'skill') return `${data.klass ?? 'build'}/${data.status ?? 'unknown'}`;
+  return data.status ?? 'unknown';
+}
+
+/**
+ * The rendered roster as lines, with no trailing newline on any of them.
+ *
+ * A SECTION WITH NO ROWS PRINTS NO HEADING. The heading is emitted lazily, when the first
+ * row that survives the filter arrives — so `catalog laws` on an install whose render
+ * produced no laws is EMPTY rather than a heading over nothing, and the caller can tell the
+ * two apart and say so.
+ *
+ * The name column is measured over the rows actually being printed, not over the whole
+ * inventory: filtering to `agents` must not leave a gutter the width of the longest law
+ * title. `dwidth` rather than `String.length`, because a purpose line can carry an emoji
+ * and a status glyph is two columns wide in every tier but ASCII.
+ */
+export function catalogLines(inv, section, width, showSource = false) {
+  const kinds = section ? [CATALOG_KINDS[section]] : Object.values(CATALOG_KINDS);
+  const rows = tuiEntries(inv);
+  const shown = rows.filter(([kind]) => kinds.includes(kind));
+  if (!shown.length) return [];
+  const cap = Math.max(12, Math.floor(width / 2));
+  const nameW = Math.min(cap, Math.max(...shown.map(([, label]) => dwidth(label))));
+  const badgeW = Math.max(...shown.map(([kind, , data]) => dwidth(badgeFor(kind, data))));
+
+  const out = [];
+  let pending = null;
+  for (const [kind, label, data] of rows) {
+    if (kind === 'head') { pending = label; continue; }
+    if (!kinds.includes(kind)) continue;
+    if (pending !== null) {
+      if (out.length) out.push('');
+      out.push(pending);
+      pending = null;
+    }
+    // `source` is the endpoint's field and is an absolute path, so it replaces the purpose
+    // column rather than joining it — two long strings on one line is a column layout that
+    // is a wrapped mess on every terminal narrower than the sum of them.
+    //
+    // AND IT IS THE ONE COLUMN THAT IS NEVER TRUNCATED. A purpose line cut at the terminal
+    // edge still reads; half a path is not a path, and the reason to ask for one is to hand
+    // it to something else.
+    const tail = showSource ? (data.source ?? '') : (data.desc ?? '');
+    const row = `  ${icon(kind)} ${fit(label, nameW)}  ${fit(badgeFor(kind, data), badgeW)}  ${tail}`
+      .replace(/\s+$/, '');
+    out.push(showSource ? row : truncd(row, width));
+  }
+  return out;
+}
+
+/**
+ * The verb.
+ *
+ * An unknown `--theme` is refused by `effectiveTheme` on the way through the render, with
+ * the wording every other theme-taking verb already prints — so there is no second theme
+ * validator here, and the entry point's `exitCode` arm carries the refusal out.
+ */
+export function cmdCatalog(args) {
+  const theme = args.theme || installedDefaults().theme || defaultTheme();
+  // `helpWidth()` is `COLUMNS`, else the terminal, else 80 — minus the two columns argparse
+  // subtracts for its own layout. This listing wants the whole terminal, so it adds them
+  // back rather than owning a second copy of that precedence chain.
+  const lines = catalogLines(tuiInventory(theme), args.section, helpWidth() + 2, args.source);
+  if (!lines.length) {
+    pyPrint(`[catalog] nothing to list${args.section ? ` under ${args.section}` : ''}.\n`);
+    return 1;
+  }
+  for (const line of lines) pyPrint(`${line}\n`);
+  return 0;
+}

package/js/checkout.mjs

@@ -0,0 +1,88 @@
+/**
+ * The checkout this code is running FROM — `_build_core`'s ROOT and the paths under it,
+ * plus the `cfg` every render needs.
+ *
+ * The inverse of `js/hosts.mjs`. That module answers "where does the output go"; this one
+ * answers "where is the source". Both were `bin/geneseed.mjs`'s, and both leave it for the
+ * same arithmetic reason: `bin/geneseed-cli.mjs` needs them too, and the value that decides
+ * which tree gets rendered is the last thing that should exist twice.
+ *
+ * WHY A NON-EMITTING VERB NEEDS A cfg AT ALL. `harness status` counts agents, skills and
+ * laws, and it counts them by RENDERING — `_status_data` -> `_tui_inventory(theme)` ->
+ * `build.render_all(theme)`. So the CLI has to build the same `cfg` the driver builds, and
+ * until this move only the driver could.
+ *
+ * THE TWO ABSENT KEYS ARE STILL ABSENT, and the reason is bin/geneseed.mjs's, unchanged:
+ * `_build_core.js_cfg()` always sends `structure` and `capabilityLinkRe` because the Python
+ * originals are module-level names TESTS MUTATE (`_OWNED` membership asked one level out).
+ * A Node process has no Python module to mutate, so it sends neither and
+ * `js/render.mjs`'s `cfg.structure ?? STRUCTURE` takes its right-hand branch.
+ *
+ * The move is safe for the reason P5c's was: `tests/golden.py` drives `bin/geneseed.mjs`
+ * over 259 cells and compares the tree byte-for-byte, and every one of them builds a cfg
+ * from these paths. A depth error or a renamed key fails 259 cells, not zero.
+ */
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * `_build_core.ROOT` — the checkout, from this file's own location (`js/..`).
+ *
+ * NOT redirectable, and that is a property rather than a gap. The Python side is
+ * `Path(__file__).resolve().parent` with every path under it derived at import; the
+ * `_OWNED` redirect the suite uses is an in-process write, and no env var moves it
+ * (`$GENESEED_ROOT` is `harness context`'s doc-discovery root — a different name for a
+ * different job). Both implementations therefore answer from their own file's location,
+ * which is what makes them comparable and what makes them unfenceable. See the
+ * status/version section of `tests/harness_golden.py`.
+ */
+export const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+export const SRC = path.join(ROOT, 'src');
+export const CONFIG = path.join(ROOT, 'harness.config.json');
+export const THEMES = path.join(ROOT, 'themes');
+export const PLUGIN_SRC = path.join(ROOT, 'adapters', 'opencode', 'plugins');
+export const WORKFLOW_SRC = path.join(ROOT, 'adapters', 'opencode', 'workflows');
+
+/**
+ * `_build_render.posture_names()` / `mode_names()` — discovered, never hardcoded, so a new
+ * posture file appears in both CLIs' choices with no code change.
+ *
+ * P5f moved this here from `bin/geneseed.mjs`, which had the only caller until
+ * `js/installs.mjs` needed the same two lists: `_posture_of_dir` scans a deployed carrier for
+ * `**<Name>**` and has to be scanning for the SAME names the driver's `--posture` accepts.
+ * Two discoveries of one directory is precisely the shape that lets a new posture file be
+ * buildable and undetectable.
+ */
+export function discoverNames(dir, first) {
+  let names = [];
+  try {
+    names = readdirSync(path.join(SRC, dir))
+      .filter((f) => f.endsWith('.md') && path.basename(f, '.md').toLowerCase() !== 'readme')
+      .map((f) => path.basename(f, '.md'))
+      .sort();
+  } catch { /* missing dir — fall through to the single default below */ }
+  names.sort((a, b) => (a !== first) - (b !== first) || (a < b ? -1 : a > b ? 1 : 0));
+  return names.length ? names : [first];
+}
+
+/**
+ * `_build_core.js_cfg()`, originated rather than received.
+ *
+ * `posture` and `mode` are `_build_core`'s module defaults (`peer` / `direct`) unless a
+ * caller overrides them. `build.py`'s `main()` sets them from its flags; `rituals/harness.py`
+ * never touches them, so every harness verb that renders renders at the defaults.
+ */
+export function makeCfg({ posture = 'peer', mode = 'direct' } = {}) {
+  return {
+    root: ROOT,
+    src: SRC,
+    themes: THEMES,
+    config: CONFIG,
+    colorThemes: path.join(THEMES, 'opencode'),
+    pluginSrc: PLUGIN_SRC,
+    workflowSrc: WORKFLOW_SRC,
+    posture,
+    mode,
+  };
+}