geneseed 3.1.1 → 3.1.2

package/js/build/emit-common.mjs

@@ -0,0 +1,255 @@
+/**
+ * What every emit shares — the constants that name what this tool owns, the small readers it
+ * walks a tree with, and the three writers both GLOBAL emits call.
+ *
+ * Split out of `emit.mjs` because each of `globalMemory`, `globalNotebook`, `shipLeanLaws`
+ * and `stripCapabilityLinks` has two callers in two different host emits. A helper with two
+ * hosts belongs to neither, and putting it in one of them is how a file grows to 1400 lines.
+ *
+ * Nothing here decides WHICH host is being emitted. `emit-opencode.mjs` and
+ * `emit-claude.mjs` do that; `emit.mjs` renders the bundle they read from.
+ */
+import path from 'node:path';
+import { copyFile, writeText } from '../lib/fs.mjs';
+import { SRC_DIR_TOKENS, destRel } from './render.mjs';
+import { mkdirSync, readdirSync, statSync } from 'node:fs';
+
+/** `_build_render.SRC_DIRS_MARKER`. */
+export const SRC_DIRS_MARKER = '.geneseed-srcdirs.json';
+/**
+ * `_build_render.OWNED_SRC_DIRS` — wiped and regenerated each run.
+ *
+ * `ontology` and `doctrines` are appended, not inserted: this array's iteration order is the
+ * key order of the `.geneseed-srcdirs.json` marker it fills, and appending keeps the three
+ * original keys where an existing install's marker already has them.
+ *
+ * They belong here for the same reason `laws` does — they are GENERATED, so an install must
+ * not keep a copy the source no longer produces. Without them a build writes the dirs on
+ * every run and never wipes them, which turns the doctrines toggle into a one-way switch:
+ * disable a pack, rebuild, and its rendered file sits in the install forever, contradicting
+ * the `Active packs:` line in the AGENT.md right beside it.
+ */
+export const OWNED_SRC_DIRS = ['laws', 'agents', 'skills', 'ontology', 'doctrines'];
+
+/**
+ * The constitution dirs a LEAN emit re-ships in full text — see `shipLeanLaws`.
+ *
+ * Not all of `OWNED_SRC_DIRS`: `agents` and `skills` are already written as whole files by
+ * the native layer, and only the three constitution dirs are inlined into AGENT.md in a
+ * form (terse, or pack-filtered) that loses text the reader may still need.
+ */
+const LEAN_FULL_TEXT_DIRS = ['laws', 'ontology', 'doctrines'];
+
+/**
+ * `_build_core.CAPABILITY_LINK_RE` — the DEFAULT only.
+ *
+ * `cfg.capabilityLinkRe` overrides it and the driver always supplies one, for the same
+ * reason `cfg.structure` exists: the constant is in `_OWNED` because a doctor test
+ * redirects it to the pre-fix form and asserts the emit then renders dead links, and a
+ * redirect that stops at the process boundary half-works silently. The literal stays as
+ * the fallback for the parity harnesses, which drive this module in-process.
+ */
+const CAPABILITY_LINK_RE =
+  /\[([^\]]+)\]\((?:(?!https?:\/\/|\/)[A-Za-z0-9_.-]+\/)*(?:agents|skills)\/[A-Za-z0-9_-]+\.md\)/g;
+
+/** `_build_render._TMPL_SPEC_RE`. */
+export const TMPL_SPEC_RE = /\{\{DIR_(AGENTS|SKILLS)\}\}\/([A-Za-z0-9_-]+)\.md/g;
+
+// ---------------------------------------------------------------------------
+// Small filesystem predicates. Python spells these `Path.is_file()` / `is_dir()`, both
+// of which answer False for a missing path rather than raising; `statSync` throws.
+// ---------------------------------------------------------------------------
+
+export function isFile(p) {
+  try { return statSync(p).isFile(); } catch { return false; }
+}
+
+export function isDir(p) {
+  try { return statSync(p).isDirectory(); } catch { return false; }
+}
+
+/** `dict.get(key)` with Python's semantics — OWN properties only.
+ *
+ * The same hazard `js/hosts/settings.mjs` and `js/hosts/native.mjs` both spell out: the keys here come
+ * out of a manifest the user can edit, and `old['constructor']` hands back
+ * `Object.prototype`'s member where Python's `.get` returns None. */
+export function get(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
+}
+
+export function isDict(v) {
+  return Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+}
+
+/** `Path.rglob("*")` restricted to files, skipping `__pycache__` as Python's callers do. */
+export function rglobFiles(root, out = []) {
+  for (const name of readdirSync(root)) {
+    if (name === '__pycache__') continue;
+    const full = path.join(root, name);
+    if (isDir(full)) rglobFiles(full, out);
+    else out.push(full);
+  }
+  return out;
+}
+
+/**
+ * `Path.rglob("*")` restricted to files, keeping EVERYTHING — including `__pycache__`.
+ *
+ * Not a duplicate of `rglobFiles` by accident: `source_fingerprint`'s Python filters
+ * `__pycache__` and the legacy-store migration in `_global_memory` does not, so a single
+ * walk would be wrong for one caller either way. A user's legacy bundle really can carry
+ * one (the harness ships `.py` skill scripts), and copying it or not is a byte difference
+ * the two runtimes would disagree on silently.
+ */
+function rglobAllFiles(root, out = []) {
+  for (const name of readdirSync(root)) {
+    const full = path.join(root, name);
+    if (isDir(full)) rglobAllFiles(full, out);
+    else out.push(full);
+  }
+  return out;
+}
+
+/** `p.relative_to(base).as_posix()`. */
+export function relPosix(base, p) {
+  return path.relative(base, p).split(path.sep).join('/');
+}
+
+/**
+ * `_build_emit._strip_capability_links` — `re.sub(r"\1")`, so the pattern needs `g`.
+ *
+ * Exported for `js/inspect/checks-build.mjs`: `_rendered_problems` applies the same de-linking before
+ * comparing an OpenCode bundle's AGENT.md against a fresh render, because the emit puts
+ * that difference back by design and a check that did not would report the file stale on
+ * every run forever.
+ */
+export function stripCapabilityLinks(cfg, text) {
+  const re = cfg.capabilityLinkRe
+    ? new RegExp(cfg.capabilityLinkRe, 'g')
+    : CAPABILITY_LINK_RE;
+  return text.replace(re, '$1');
+}
+
+// ---------------------------------------------------------------------------
+// The global-store helpers, shared by the `opencode-global` and `claude` jobs
+// ---------------------------------------------------------------------------
+
+/**
+ * `_build_global._global_memory` — ensure `<cfg>/memory` exists, without ever touching a
+ * store that already holds something.
+ *
+ * The three outcomes are the returned status string, which the emit prints, so they are
+ * compared through stdout as well as through the tree. Python's `theme` parameter is
+ * dropped: the store dir is ALWAYS the classic English `memory/`, never themed (the
+ * OpenCode config dir uses fixed names), so the argument was never read.
+ *
+ * The migration branch copies arbitrary USER files out of a legacy bundle, which is the
+ * reason this is not a plain translation: everything it touches is the user's, and the
+ * only thing keeping it safe is that it runs at all only when the destination is empty.
+ */
+export function globalMemory(cfgDir, items, legacy, srcRoot) {
+  const memName = 'memory';
+  const memDir = path.join(cfgDir, memName);
+  if (isDir(memDir) && readdirSync(memDir).length) return `kept ${memName}/`;
+  mkdirSync(memDir, { recursive: true });
+  if (legacy) {
+    // `dict.fromkeys([mem_name, "memory", "anamnesis"])` — de-duplicated, order kept.
+    // `mem_name` is the literal 'memory' and the Python docstring beside it says the
+    // store name is NEVER themed, so the first two entries always collapse and
+    // `anamnesis` — an older themed install's name — is the only live alias. The dedupe
+    // is what keeps the duplicate harmless rather than copying the same dir twice.
+    for (const nm of [...new Set([memName, 'memory', 'anamnesis'])]) {
+      const src = path.join(legacy, nm);
+      if (isDir(src) && readdirSync(src).length) {
+        for (const f of rglobAllFiles(src)) {
+          const dest = path.join(memDir, path.relative(src, f));
+          mkdirSync(path.dirname(dest), { recursive: true });
+          copyFile(f, dest);
+        }
+        return `migrated ${nm}/ -> ${memName}/`;
+      }
+    }
+  }
+  for (const { text, src } of items) {
+    const sp = relPosix(srcRoot, src).split('/');
+    if (sp[0] === 'memory' && sp.length > 1) {
+      // `destRel`, because this seeds from the SOURCE path and not from the item's `rel`
+      // (which is themed, and `memory/` never is). Without it the store would be seeded
+      // with the on-disk name `gitignore` — see `js/build/render.mjs`'s `destRel`.
+      const dest = path.join(memDir, destRel(path.join(...sp.slice(1))));
+      mkdirSync(path.dirname(dest), { recursive: true });
+      if (text !== null) writeText(dest, text);
+      else copyFile(src, dest);
+    }
+  }
+  return `seeded ${memName}/`;
+}
+
+/** `_build_global._global_notebook` — the same shape, with no `anamnesis` alias. */
+export function globalNotebook(cfgDir, items, legacy, srcRoot) {
+  const nbName = 'notebook';
+  const nbDir = path.join(cfgDir, nbName);
+  if (isDir(nbDir) && readdirSync(nbDir).length) return `kept ${nbName}/`;
+  mkdirSync(nbDir, { recursive: true });
+  if (legacy) {
+    const src = path.join(legacy, nbName);
+    if (isDir(src) && readdirSync(src).length) {
+      for (const f of rglobAllFiles(src)) {
+        const dest = path.join(nbDir, path.relative(src, f));
+        mkdirSync(path.dirname(dest), { recursive: true });
+        copyFile(f, dest);
+      }
+      return `migrated ${nbName}/`;
+    }
+  }
+  for (const { text, src } of items) {
+    const sp = relPosix(srcRoot, src).split('/');
+    if (sp[0] === nbName && sp.length > 1) {
+      // `destRel` — same reason as `globalMemory` above.
+      const dest = path.join(nbDir, destRel(path.join(...sp.slice(1))));
+      mkdirSync(path.dirname(dest), { recursive: true });
+      if (text !== null) writeText(dest, text);
+      else copyFile(src, dest);
+    }
+  }
+  return `seeded ${nbName}/`;
+}
+
+/**
+ * `_build_global._ship_lean_laws`.
+ *
+ * Historically the one RENDER that ran AFTER a WIRE, which is why the phase-order
+ * normalisation had to move it before the seam could be cut. Re-derived rather than
+ * trusted: its inputs are `items` and `theme` (both from `render_all`) and its only
+ * output besides the files is what it APPENDS to `owned` — which travels back in the
+ * payload for the manifest and the prune. It reads nothing any wiring stage writes, so
+ * its new position is not merely legal, it has no dependency on the old one.
+ *
+ * NO LONGER LEAN-ONLY, and the name is kept because the lean case is still the whole reason
+ * it exists. `doctrines` ships at BOTH footprints, because the two footprints lose different
+ * things: lean loses text (every rule is truncated to its first sentence, so the full text has
+ * to be on disk), while FULL loses whole packs (only the active ones are inlined, so the
+ * inactive ones have to be on disk). AGENT.md tells the agent it may read a rule in a pack
+ * that is not active, and `src/doctrines/README.md` rests cross-pack citations on exactly
+ * that — a claim the emit has to make true, not merely the `files` bundle.
+ */
+export function shipLeanLaws(items, theme, cfgDir, owned, footprint) {
+  // Themed names, resolved through the same token table `build`'s wipe resolves, so the dir
+  // a lean emit re-ships and the dir it prunes can never be two different spellings.
+  const wanted = footprint === 'lean' ? LEAN_FULL_TEXT_DIRS : ['doctrines'];
+  const dirs = new Set(wanted.map((d) => theme[SRC_DIR_TOKENS[d]] ?? d));
+  for (const { rel, text } of items) {
+    const parts = rel.split('/');
+    // `parts.length` mirrors Python's `parts and parts[0]`, where `Path("").parts` really
+    // is empty. `String.split` never returns an empty array, so this half can never be
+    // false here — kept for the mirror, and its mutation stays green because there is
+    // nothing to detect, not because the gate cannot see it.
+    if (text !== null && parts.length && dirs.has(parts[0])) {
+      const dest = path.join(cfgDir, ...parts);
+      mkdirSync(path.dirname(dest), { recursive: true });
+      writeText(dest, text);
+      owned.push(rel);
+    }
+  }
+}
+

package/js/build/emit-opencode.mjs

@@ -0,0 +1,214 @@
+/**
+ * The OpenCode emits — a project's `.opencode/` and the global config directory.
+ *
+ * Split out of `emit.mjs` beside `emit-claude.mjs`, over the shared writers in
+ * `emit-common.mjs`. The two are siblings on purpose: an emit that is right for one host and
+ * wrong for the other is the defect these have historically carried, and it reads far more
+ * plainly as two files with the same shape than as two sections of one.
+ */
+import path from 'node:path';
+import { VERSION_MARKER } from '../hosts/hosts.mjs';
+import { loadAgentOverrides, writeNativeLayer } from '../hosts/native.mjs';
+import {
+  copyPlugins, copyWorkflows, ensureAgentOverridesStub, writeColorThemes, writeCommandLayer,
+  writePonytailCommand, writePrimaryAgent, writeTheme,
+} from '../hosts/opencode.mjs';
+import { mergeOpencodeJson } from '../hosts/settings.mjs';
+import { readText, writeText } from '../lib/fs.mjs';
+import { assertSourceComplete, build, phaseLog } from './bundle.mjs';
+import {
+  globalMemory, globalNotebook, isFile, relPosix, shipLeanLaws, stripCapabilityLinks,
+} from './emit-common.mjs';
+import { renderAll } from './render.mjs';
+import {
+  ensureExcludesStub, ensureMemoryIndex, ensureNotebookIndex, ensureProfileStub, ensureRulesStub,
+  ensureWikiStub,
+} from './stubs.mjs';
+import { writeVersion } from './version.mjs';
+import { mkdirSync } from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// emit_opencode — the RENDER stage only
+// ---------------------------------------------------------------------------
+
+/**
+ * RENDER and WIRE for `_build_emit.emit_opencode` — everything through the
+ * `mergeOpencodeJson` call at the bottom. PRUNE and MANIFEST are the driver's, in
+ * `bin/build-driver.mjs`.
+ *
+ * `oldOwned` and `manifestExisted` arrive in the job rather than being read here. The
+ * manifest is the DRIVER's stage: it reads the file, hands the prior claim in, and prunes
+ * and rewrites it after this returns. One owner of the file, and this function is not it.
+ *
+ * `nativeCatalog` likewise arrives decided. It is `HOSTS['opencode']['native_catalog']` from
+ * `js/hosts/hosts.mjs`, resolved by the driver before the call; passing the decision rather
+ * than re-reading the registry keeps one owner of it.
+ */
+export function emitOpencodeRender(cfg, job) {
+  phaseLog('RENDER');
+  const {
+    theme: _theme, out, root, footprint, nativeCatalog, oldOwned, manifestExisted, agentPath,
+  } = job;
+  const oc = path.join(root, '.opencode');
+
+  build(cfg, _theme, out, { footprint, nativeCatalog });
+
+  // OpenCode loads agents/skills natively, so strip AGENT.md's per-row spec links to
+  // plain names (the portable build keeps them). A deliberate de-link, not a fix.
+  const agentMd = path.join(out, 'AGENT.md');
+  if (isFile(agentMd)) writeText(agentMd, stripCapabilityLinks(cfg, readText(agentMd)));
+
+  const owned = [];
+  const { theme, items } = renderAll(cfg, _theme);
+
+  ensureAgentOverridesStub(cfg, out);
+  const overrides = loadAgentOverrides(out);
+
+  const { nAgents, nSkills, written } = writeNativeLayer(
+    items, path.join(oc, 'agents'), path.join(oc, 'skills'), overrides,
+    { host: 'opencode', oldOwned, cfg: oc, manifestExisted, theme, src: cfg.src });
+  for (const p of written) owned.push(relPosix(oc, p));
+
+  const primary = writePrimaryAgent(cfg, path.join(oc, 'agents'), overrides);
+  if (primary) owned.push(relPosix(oc, primary));
+
+  const commands = writeCommandLayer(cfg, items, path.join(oc, 'command'));
+  commands.push(writePonytailCommand(path.join(oc, 'command')));   // always-on /ponytail
+  for (const p of commands) owned.push(relPosix(oc, p));
+
+  owned.push(relPosix(oc, writeTheme(path.join(oc, 'themes'), _theme, theme)));
+  for (const p of writeColorThemes(cfg, path.join(oc, 'themes'))) owned.push(relPosix(oc, p));
+
+  const nPlugins = copyPlugins(cfg, path.join(oc, 'plugins'), owned);
+  const nWorkflows = copyWorkflows(cfg, path.join(oc, 'workflows'), owned);
+
+  // WIRE — the one file of this emit the user co-owns. `agentPath` arrives decided
+  // (`_rel_under` is the Python side by design), and only the BASENAME is consumed
+  // downstream: `opencode.json`, or the `.jsonc` sibling when that is what is on disk.
+  phaseLog('WIRE');
+  const cfgName = path.basename(mergeOpencodeJson(path.join(root, 'opencode.json'), agentPath,
+    cfg.doctrines, cfg.excludeRules));
+
+  return {
+    owned,
+    stats: {
+      nAgents, nSkills, nPlugins, nWorkflows, nCommands: commands.length, primary: !!primary,
+    },
+    cfgName,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// emit_opencode_global — the ninth, and the last emit to cross
+// ---------------------------------------------------------------------------
+
+/**
+ * BOTH halves of `_build_global.emit_opencode_global`, the "everything global, zero
+ * per-repo" OpenCode deployment. PRUNE and MANIFEST are the driver's; there is no VERIFY,
+ * because this emit writes no settings file.
+ *
+ * ASSEMBLY, NOT TRANSLATION. Every unit it needs was already here — 58 of the 65 functions
+ * in its Python closure, counted with `ast` rather than by name-mapping, which is how the
+ * scout that produced this list first reported `_posture_body` and `_mode_body` as missing
+ * when both are `registerBody` in `js/build/render.mjs`. What is new is the assembly and the
+ * three values that had to be decided on the Python side.
+ *
+ * `cfgDir` IS THE FIRST OF THEM AND THE REASON THE OTHERS WERE ASKED ABOUT.
+ * `_build_core._opencode_config_dir` is an `_OWNED` name — the suite and `harness diff`
+ * both redirect it at a sandbox — so resolving it here would render 135 files into the
+ * developer's real `~/.config/opencode`. Python's entry point resolves it once, before
+ * anything else, and sends the answer. Fourth phase running (`STRUCTURE` at P2d,
+ * `capabilityLinkRe` at P2e, `_PREAMBLE_CONFIG_DIR` at P3b): send the decision, never the
+ * resolver.
+ *
+ * `out` IS NOT THE TARGET, and with the default nobody can tell. `emit_opencode_global`
+ * writes into `<cfg>` and takes `out` ONLY as the legacy bundle to migrate a memory or
+ * notebook store from; the CLI's `--out` defaults to a directory this emit never writes a
+ * byte into. A port that derived the legacy source from `<cfg>` would pass every cell that
+ * leaves them coincident — the `claude/bundle-in-subfolder` finding at a third call site.
+ *
+ * `agentPath` travels for the same reason `emitOpencodeRender`'s does: it is WIRE's one
+ * input, and `Path.as_posix()` is the Python side's spelling of it.
+ */
+export function emitOpencodeGlobalRender(cfg, job) {
+  phaseLog('RENDER');
+  const {
+    theme: themeName, cfgDir, out, footprint, nativeCatalog, oldOwned, agentPath,
+  } = job;
+
+  // No `lawsPrefix`: the standalone laws dir sits beside AGENT.md in <cfg>, so the lean
+  // pointer's relative `laws/universal.md` resolves with no prefix.
+  const { theme, items } = renderAll(cfg, themeName, { footprint, nativeCatalog });
+  assertSourceComplete(cfg, 'opencode-global');
+  mkdirSync(cfgDir, { recursive: true });
+
+  const owned = [];
+  const agentText = items.find((i) => i.rel === 'AGENT.md' && i.text !== null)?.text ?? null;
+  if (agentText !== null) {
+    // OpenCode loads agents/skills natively, so drop AGENT.md's per-row spec links to
+    // plain names. Memory links stay RELATIVE: in the global layout AGENT.md and the
+    // store are siblings, so `memory/` resolves from AGENT.md's own location and stays
+    // hermetic — no absolute path a doctor check would flag as an escape.
+    writeText(path.join(cfgDir, 'AGENT.md'), stripCapabilityLinks(cfg, agentText));
+    owned.push('AGENT.md');
+  }
+
+  ensureAgentOverridesStub(cfg, cfgDir);
+  const overrides = loadAgentOverrides(cfgDir);
+
+  // `manifestExisted` is deliberately not passed — the Python does not pass it either, so
+  // the pre-manifest header line is unreachable from this emit on both sides.
+  const { nAgents, nSkills, written } = writeNativeLayer(
+    items, path.join(cfgDir, 'agents'), path.join(cfgDir, 'skills'), overrides,
+    { host: 'opencode', oldOwned, cfg: cfgDir, theme, src: cfg.src });
+  for (const p of written) owned.push(relPosix(cfgDir, p));
+
+  const primary = writePrimaryAgent(cfg, path.join(cfgDir, 'agents'), overrides);
+  if (primary) owned.push(relPosix(cfgDir, primary));
+
+  const commands = writeCommandLayer(cfg, items, path.join(cfgDir, 'command'));
+  commands.push(writePonytailCommand(path.join(cfgDir, 'command')));   // always-on /ponytail
+  for (const p of commands) owned.push(relPosix(cfgDir, p));
+
+  owned.push(relPosix(cfgDir, writeTheme(path.join(cfgDir, 'themes'), themeName, theme)));
+  for (const p of writeColorThemes(cfg, path.join(cfgDir, 'themes'))) {
+    owned.push(relPosix(cfgDir, p));
+  }
+
+  const nPlugins = copyPlugins(cfg, path.join(cfgDir, 'plugins'), owned);
+  const nWorkflows = copyWorkflows(cfg, path.join(cfgDir, 'workflows'), owned);
+
+  const memStatus = globalMemory(cfgDir, items, out, cfg.src);
+  ensureMemoryIndex(path.join(cfgDir, 'memory'));
+  const nbStatus = globalNotebook(cfgDir, items, out, cfg.src);
+  ensureNotebookIndex(path.join(cfgDir, 'notebook'));
+  ensureWikiStub(cfgDir);
+  ensureRulesStub(cfgDir);
+  ensureProfileStub(cfgDir);
+  ensureExcludesStub(cfgDir);
+
+  writeVersion(cfg, cfgDir);
+  owned.push(VERSION_MARKER);
+
+  shipLeanLaws(items, theme, cfgDir, owned, footprint);
+
+  // WIRE — the one file of this emit the user co-owns, and the last render is now behind
+  // us. Inlined the way `emitOpencodeRender`'s is (one call, the same merge, the same file
+  // name). Nothing walks the SOURCE for that split now: `tests/unit/emit_phase_order.test.mjs`
+  // reads the runtime `GENESEED_PHASE_LOG` trace instead, so the `phaseLog('WIRE')` below is
+  // what the gate sees — and deleting it is mutation M30.
+  phaseLog('WIRE');
+  const cfgName = path.basename(mergeOpencodeJson(path.join(cfgDir, 'opencode.json'),
+    agentPath, cfg.doctrines, cfg.excludeRules));
+
+  return {
+    owned,
+    stats: {
+      nAgents, nSkills, nPlugins, nWorkflows, nCommands: commands.length, primary: !!primary,
+    },
+    memStatus,
+    nbStatus,
+    cfgName,
+  };
+}
+

package/js/{generate.mjs → build/generate.mjs}

@@ -1,19 +1,19 @@
 /**
- * `rituals/_harness_build.py`'s three cheap verbs — `build`, `prompt` and `theme`.
+ * The three cheap generator verbs — `build`, `prompt` and `theme`.
  *
  * These are the harness's GENERATOR FACE: the subcommands whose whole job is to drive the
- * thing `bin/geneseed.mjs` already is. That is why they are the cheapest slice left and why
+ * thing `bin/build-driver.mjs` already is. That is why they are the cheapest slice left and why
  * they are the last one that can be measured by a closure walk alone — `cmd_build`'s body is
  * three lines because the work is a `subprocess`, and a name walk cannot see through one.
  *
  * WHY `build` IMPORTS THE DRIVER RATHER THAN SPAWNING IT. The Python is
  * `run([sys.executable, BUILD, *extra]).returncode` — a passthrough to a second process.
- * Reproducing that shape here would mean spawning `node bin/geneseed.mjs`, and
+ * Reproducing that shape here would mean spawning `node bin/build-driver.mjs`, and
  * `test_the_cli_reaches_no_child_process_module` forbids it: the ban is transitive over this
  * entry's imports, and P5c's argument for keeping it is that `web`, `upgrade` and `setup`
  * will genuinely need to spawn, so the ban should outlive them rather than be dismantled by
  * a verb that does not. It is also the wrong shape on its own terms. Python needs a second
- * process because `build.py` is a different PROGRAM; `bin/geneseed.mjs` is a module in this
+ * process because `build.py` is a different PROGRAM; `bin/build-driver.mjs` is a module in this
  * one, and a Node CLI spawning a Node driver to do work it could do in-process is exactly
  * the passthrough the whole port has been removing. So the driver's `main` is exported and
  * called directly, and the observable contract — the tree, the streams, the exit code — is
@@ -32,19 +32,18 @@
 import { existsSync, mkdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 
-import { main as driverMain } from '../bin/geneseed.mjs';
-import { makeCfg, PACK_ORDER } from './checkout.mjs';
-import { opencodeConfigDir, pyResolve } from './hosts.mjs';
+import { main as driverMain } from '../../bin/build-driver.mjs';
+import { makeCfg, PACK_ORDER } from './source.mjs';
+import { opencodeConfigDir, resolvePath } from '../hosts/hosts.mjs';
 import {
   EMIT_HOST_SCOPE, defaultMode, defaultPosture, defaultTheme, doctrinesForBuild,
   excludedRulesOfDir, footprintOfDir, installState, installTargets, modeOfDir, postureOfDir,
   readMaybe, themeOfDir,
-} from './installs.mjs';
-import { colorThemeFiles, colorThemeJson, PALETTE_ROLES } from './opencode.mjs';
+} from '../hosts/installs.mjs';
+import { colorThemeFiles, colorThemeJson, PALETTE_ROLES } from '../hosts/opencode.mjs';
 import { renderAll } from './render.mjs';
-import {
-  jsonDumpsIndent, parseJson, pyPrint, pyPrintErr, pyRepr, readText, writeText,
-} from './lib/fs.mjs';
+import { printOut, printErr, readText, writeText } from '../lib/fs.mjs';
+import { jsonDumpsIndent, parseJson, formatRepr } from '../lib/json.mjs';
 
 /** `_harness_build._HEX_RE`. Anchored at BOTH ends — `#123` and `#1122334` both fail. */
 const HEX_RE = /^#[0-9a-fA-F]{6}$/;
@@ -52,18 +51,18 @@ const HEX_RE = /^#[0-9a-fA-F]{6}$/;
 /**
  * `raise SystemExit(msg)` — the message on stderr, exit 1.
  *
- * The convention `js/emit.mjs`'s `assertSourceComplete` set and `bin/geneseed-cli.mjs`
+ * The convention `js/build/bundle.mjs`'s `assertSourceComplete` set and `bin/geneseed-cli.mjs`
  * honours: write at the raise site, mark the throw as a DELIBERATE refusal with `exitCode`,
  * and let anything unmarked keep its stack. Python prints a traceback for an unhandled
  * exception, so dressing a crash as a one-liner would hide a bug.
  */
 function sysExit(msg) {
-  // `pyPrintErr`, NOT a local newline translation. The first draft inlined the `\n` ->
+  // `printErr`, NOT a local newline translation. The first draft inlined the `\n` ->
   // `\r\n` rule here and every cell passed, because `harness_golden` reads stderr through
   // `subprocess`'s universal-newline decode and cannot see the difference — the same
   // transport hole P5b measured. A second copy of a translation is exactly what P5d's
-  // `pyStrPath`/`pyPathStr` split was, and it is ungated in precisely the same way.
-  pyPrintErr(`${msg}\n`);
+  // `pyStrPath`/`toPlatformPath` split was, and it is ungated in precisely the same way.
+  printErr(`${msg}\n`);
   const e = new Error(msg);
   e.exitCode = 1;
   throw e;
@@ -188,7 +187,7 @@ export const DEFAULT_EMIT = new Map([
 export function cmdRebuildAll() {
   const targets = installTargets().filter(([h, s, r]) => installState(r, h, s) === 'active');
   if (!targets.length) {
-    pyPrint('[rebuild-all] no active installs detected.\n');
+    printOut('[rebuild-all] no active installs detected.\n');
     return 0;
   }
   const failures = [];
@@ -218,20 +217,20 @@ export function cmdRebuildAll() {
     const argv = setupBuildArgs(theme, emit, out, out, footprint, posture, mode, doctrines,
       PACK_ORDER, excludeRules);
     const label = `${host}:${scope} (${root})`;
-    pyPrint(`[rebuild-all] ${label}: theme=${theme} emit=${emit} footprint=${footprint} `
+    printOut(`[rebuild-all] ${label}: theme=${theme} emit=${emit} footprint=${footprint} `
       + `posture=${posture} mode=${mode}\n`);
     const rc = driverMain(argv);
     if (rc !== 0) {
       failures.push(label);
-      pyPrintErr(`[rebuild-all] FAILED ${label} (exit ${rc})\n`);
+      printErr(`[rebuild-all] FAILED ${label} (exit ${rc})\n`);
     }
   }
   if (failures.length) {
-    pyPrintErr(`[rebuild-all] ${failures.length}/${targets.length} install(s) failed: `
+    printErr(`[rebuild-all] ${failures.length}/${targets.length} install(s) failed: `
       + `${failures.join(', ')}\n`);
     return 1;
   }
-  pyPrint(`[rebuild-all] rebuilt ${targets.length} install(s).\n`);
+  printOut(`[rebuild-all] rebuilt ${targets.length} install(s).\n`);
   return 0;
 }
 
@@ -311,9 +310,9 @@ export function cmdPrompt(args) {
     if (dest) mkdirSync(dest, { recursive: true });
     writeText(args.out, text);
     // The RAW argument, not the resolved path — `f"[prompt] wrote {args.out}"`.
-    pyPrint(`[prompt] wrote ${args.out} (${themeName})\n`);
+    printOut(`[prompt] wrote ${args.out} (${themeName})\n`);
   } else {
-    pyPrint(text);
+    printOut(text);
   }
   return 0;
 }
@@ -324,8 +323,8 @@ export function cmdPrompt(args) {
 
 /** `_harness_build._resolve_themes_dir` — explicit `--dir`, else a repo `.opencode/`, else global. */
 export function resolveThemesDir(args) {
-  // `Path(args.dir).expanduser().resolve()` — `pyResolve` already expands a leading `~`.
-  if (args.dir) return pyResolve(args.dir);
+  // `Path(args.dir).expanduser().resolve()` — `resolvePath` already expands a leading `~`.
+  if (args.dir) return resolvePath(args.dir);
   const repo = path.join(process.cwd(), '.opencode');
   if (!args.globalDir && isDir(repo)) return path.join(repo, 'themes');
   return path.join(opencodeConfigDir(), 'themes');
@@ -383,7 +382,7 @@ export function loadUserPalette(args, cfg) {
   }
   // `f"{r}={pal[r]!r}"` — Python's repr, so a string is single-quoted and an int is bare.
   const bad = [...pal].filter(([, v]) => !(typeof v === 'string' && HEX_RE.test(v)))
-    .map(([r, v]) => `${r}=${pyRepr(v)}`);
+    .map(([r, v]) => `${r}=${formatRepr(v)}`);
   if (bad.length) sysExit(`[theme] non-#rrggbb value(s): ${bad.join(', ')}`);
   return pal;
 }
@@ -421,8 +420,8 @@ export function cmdTheme(args) {
     writeText(dest, `${jsonDumpsIndent(colorThemeJson(Object.fromEntries(pal), transparent))}\n`);
     written.push(dest);
   }
-  pyPrint(`[theme] wrote ${written.map((p) => path.basename(p)).join(', ')} to ${destDir}\n`);
-  pyPrint(`[theme] select in OpenCode with: /theme ${full}`
+  printOut(`[theme] wrote ${written.map((p) => path.basename(p)).join(', ')} to ${destDir}\n`);
+  printOut(`[theme] select in OpenCode with: /theme ${full}`
     + (args.solidOnly ? '' : `  (or /theme ${full}-transparent)`) + '\n');
   return 0;
 }