geneseed 3.1.1 → 3.1.3

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;
 }

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

@@ -10,11 +10,13 @@
  * RENDER* -> WIRE* -> PRUNE -> MANIFEST -> VERIFY (see `_build_global._emit_claude_core`
  * and tests/test_emit_phase_order.py). RENDER produces files Geneseed owns wholesale;
  * WIRE reconciles files the user co-owns (settings.json, opencode.json, the CLAUDE.md
- * managed block) and stays in Python for now, in `_build_settings.py`. Node takes RENDER
+ * managed block) and lives in `js/hosts/settings.mjs`, driven from the two emit modules.
+ * THIS module is only RENDER
  * because it is the only stage whose output is a pure function of the source tree.
  *
  * PARITY IS THE CONTRACT, NOT THE INTENT. Every function here has a named Python
- * counterpart and must produce byte-identical output for it; tests/test_render_parity.py
+ * counterpart and had to produce byte-identical output for it. The reference is gone, so
+ * what holds the line is `tests/golden.mjs --against`, replaying recorded emit cells;
  * drives both over every theme x footprint x posture x mode and byte-compares the
  * written trees. Where Python and JS semantics differ silently — path sort order,
  * `.suffix`, `splitlines`, universal newlines — the difference is spelled out at the
@@ -28,9 +30,11 @@
  */
 import { readdirSync, statSync, existsSync } from 'node:fs';
 import path from 'node:path';
-import { readText, parseJson, normcase, comparePaths } from './lib/fs.mjs';
-// `js/checkout.mjs` imports nothing but node builtins, so this direction cannot cycle.
-import { PACK_ORDER } from './checkout.mjs';
+import { readText } from '../lib/fs.mjs';
+import { parseJson } from '../lib/json.mjs';
+import { normcase, comparePaths } from '../lib/paths.mjs';
+// `js/build/source.mjs` imports nothing but node builtins, so this direction cannot cycle.
+import { PACK_ORDER } from './source.mjs';
 
 /** Document STRUCTURE is theme-INDEPENDENT — mirrors `_build_render.STRUCTURE`. */
 export const STRUCTURE = {
@@ -47,7 +51,7 @@ export const STRUCTURE = {
 
 /**
  * Source top-level dirs whose OUTPUT name is themed. Mirrors `SRC_DIR_TOKENS`.
- * Exported because `js/emit.mjs`'s `build` resolves the same tokens to decide which
+ * Exported because `js/build/bundle.mjs`'s `build` resolves the same tokens to decide which
  * dirs it owns and wipes — one owner, so the two cannot disagree about a folder name.
  */
 export const SRC_DIR_TOKENS = {
@@ -101,7 +105,7 @@ export function loadTheme(cfg, name) {
     // `sys.exit(<str>)` — the message on stderr, exit 1 — spelled the way
     // `assertSourceComplete` spells it: written at the raise site, and the throw carries
     // only the marker. ⚠ It was once described as an unreachable nicety under
-    // `bin/geneseed.mjs`, on the grounds that `--theme` is validated against `choices` before
+    // `bin/build-driver.mjs`, on the grounds that `--theme` is validated against `choices` before
     // anything renders — it is not: `--theme` takes a value and has no `choices` entry, so THIS
     // is the refusal, on every path. It is also reachable from `geneseed status`, which takes
     // its theme from a `.geneseed-theme`
@@ -253,7 +257,7 @@ function registerBody(cfg, theme, dir, selected, fallback) {
  * entry point and an emit that quietly dropped a pack the user asked for is exactly the
  * failure the `Active packs:` marker would then attest to.
  *
- * Both throw with `exitCode`, the marker `bin/geneseed.mjs`'s `main` turns into a status.
+ * Both throw with `exitCode`, the marker `bin/build-driver.mjs`'s `main` turns into a status.
  */
 function activeDoctrines(cfg) {
   const dir = path.join(cfg.src, 'doctrines');
@@ -265,7 +269,7 @@ function activeDoctrines(cfg) {
   const stray = onDisk.filter((n) => !PACK_ORDER.includes(n));
   if (stray.length) {
     const e = new Error(`doctrine pack file(s) ${stray.join(', ')} exist under src/doctrines/ `
-      + 'but are missing from PACK_ORDER (js/checkout.mjs) — add them there, or they render '
+      + 'but are missing from PACK_ORDER (js/build/source.mjs) — add them there, or they render '
       + 'into no install at all');
     e.exitCode = 1;
     throw e;

package/js/{checkout.mjs → build/source.mjs}

@@ -2,8 +2,8 @@
  * 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
+ * The inverse of `js/hosts/hosts.mjs`. That module answers "where does the output go"; this one
+ * answers "where is the source". Both were `bin/build-driver.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.
  *
@@ -12,13 +12,13 @@
  * `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:
+ * THE TWO ABSENT KEYS ARE STILL ABSENT, and the reason is bin/build-driver.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.
+ * `js/build/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`
+ * The move is safe for the reason P5c's was: `tests/golden.py` drives `bin/build-driver.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.
  */
@@ -37,7 +37,7 @@ import { fileURLToPath } from 'node:url';
  * 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 ROOT = path.dirname(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');
@@ -48,8 +48,8 @@ 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
+ * P5f moved this here from `bin/build-driver.mjs`, which had the only caller until
+ * `js/hosts/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.
@@ -72,7 +72,7 @@ export function discoverNames(dir, first) {
  * DELIBERATELY NOT `discoverNames('doctrines', 'craft')`. That helper `.sort()`s, so it
  * answers `craft, ops, process, rigor`; the constitution's order is a reading order —
  * write it (craft), prove it (rigor), run it (ops), ship it (process) — and no sort
- * produces it. Discovery still runs, but as a GATE rather than as the order: `js/render.mjs`
+ * produces it. Discovery still runs, but as a GATE rather than as the order: `js/build/render.mjs`
  * refuses to build when a pack file exists under `src/doctrines/` that is missing from this
  * array, so a fifth pack cannot be silently dropped from every install.
  *