geneseed 3.1.2 → 3.2.0

package/js/build/emit-common.mjs

@@ -10,9 +10,17 @@
  * `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 { copyFile, writeText, isFile, isDir } from '../lib/fs.mjs';
+import { get, isDict } from '../lib/json.mjs';
 import { SRC_DIR_TOKENS, destRel } from './render.mjs';
-import { mkdirSync, readdirSync, statSync } from 'node:fs';
+import { mkdirSync, readdirSync, cpSync } from 'node:fs';
+
+// `isFile`/`isDir`/`get`/`isDict` are owned by `js/lib` now (single owner across `hosts/`,
+// `build/`, `inspect/` and `web/` — layering forbids `build/` reaching into `inspect/scan.mjs`
+// for them, so `js/lib` is the one home both sides can reach). Re-exported here so this
+// module's own existing callers (`emit-claude.mjs`, `emit-opencode.mjs`, `version.mjs`,
+// `bundle.mjs`) keep importing them from `./emit-common.mjs` unchanged.
+export { isFile, isDir, get, isDict };
 
 /** `_build_render.SRC_DIRS_MARKER`. */
 export const SRC_DIRS_MARKER = '.geneseed-srcdirs.json';
@@ -41,13 +49,15 @@ export const OWNED_SRC_DIRS = ['laws', 'agents', 'skills', 'ontology', 'doctrine
 const LEAN_FULL_TEXT_DIRS = ['laws', 'ontology', 'doctrines'];
 
 /**
- * `_build_core.CAPABILITY_LINK_RE` — the DEFAULT only.
+ * `_build_core.CAPABILITY_LINK_RE`.
  *
- * `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.
+ * NOT OVERRIDABLE. Python's `cfg.capabilityLinkRe` was the driver's seam for tests that
+ * monkeypatch `_build_core.CAPABILITY_LINK_RE`; `bin/build-driver.mjs` deliberately never
+ * sends one (see its docblock), so the override branch that used to sit in
+ * `stripCapabilityLinks` never took its left-hand side and was deleted as dead code in the
+ * over-engineering cleanup. `tests/unit/harness.test.mjs`'s planted-fault test drives this
+ * exact constant by rewriting the module's source text instead, which is what "no injection
+ * point left" means there.
  */
 const CAPABILITY_LINK_RE =
   /\[([^\]]+)\]\((?:(?!https?:\/\/|\/)[A-Za-z0-9_.-]+\/)*(?:agents|skills)\/[A-Za-z0-9_-]+\.md\)/g;
@@ -55,59 +65,18 @@ const CAPABILITY_LINK_RE =
 /** `_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__`.
+ * `Path.rglob("*")` restricted to files, skipping `__pycache__` as Python's callers do.
  *
- * 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.
+ * `recursive: true, withFileTypes: true` (Node >= 20.1, `parentPath` >= 21.4 — this repo
+ * requires >= 22.3) replaces a hand-rolled walk; the order it yields is NOT the walk's
+ * order, but `sourceFingerprint`, this function's one caller, re-sorts every result by a
+ * plain string key before it is ever observed, so no caller depends on it.
  */
-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;
+export function rglobFiles(root) {
+  return readdirSync(root, { recursive: true, withFileTypes: true })
+    .filter((d) => d.isFile() && !d.parentPath.split(path.sep).includes('__pycache__'))
+    .map((d) => path.join(d.parentPath, d.name));
 }
 
 /** `p.relative_to(base).as_posix()`. */
@@ -123,11 +92,8 @@ export function relPosix(base, p) {
  * 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');
+export function stripCapabilityLinks(text) {
+  return text.replace(CAPABILITY_LINK_RE, '$1');
 }
 
 // ---------------------------------------------------------------------------
@@ -135,84 +101,67 @@ export function stripCapabilityLinks(cfg, text) {
 // ---------------------------------------------------------------------------
 
 /**
- * `_build_global._global_memory` — ensure `<cfg>/memory` exists, without ever touching a
- * store that already holds something.
+ * `_build_global._global_memory`/`_global_notebook` — ensure `<cfg>/<name>` 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
+ * dropped for both: the store dir is ALWAYS the classic English name, never themed (the
  * OpenCode config dir uses fixed names), so the argument was never read.
  *
+ * THE MIGRATED MESSAGE'S SHAPE TRACKS THE ALIAS COUNT, not a caller-supplied format flag.
+ * `memory` is the only store with more than one legacy name — `anamnesis`, an older themed
+ * install's — so its status names which one matched: `migrated anamnesis/ -> memory/`.
+ * `notebook` has exactly one candidate and its status has never named an arrow:
+ * `migrated notebook/`. One alias is nothing a rename could be reporting, so the arrow is
+ * dropped rather than printed as a no-op `notebook/ -> notebook/`.
+ *
  * 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 });
+function globalStore(cfgDir, items, legacy, srcRoot, name, aliases = [name]) {
+  const dir = path.join(cfgDir, name);
+  if (isDir(dir) && readdirSync(dir).length) return `kept ${name}/`;
+  mkdirSync(dir, { 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'])]) {
+    // `dict.fromkeys(aliases)` — de-duplicated, order kept. The dedupe is what keeps a
+    // caller that lists `name` itself among its aliases (as `memory` does) from copying
+    // the same dir twice.
+    for (const nm of [...new Set(aliases)]) {
       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}/`;
+        // `cpSync(..., {preserveTimestamps: true})` — the recursive-copy equivalent of
+        // `copyFile` above (byte copy + carried mtime, no `shutil.copy2` mode bits; see
+        // that function's docblock in `js/lib/fs.mjs`), replacing a walk-then-copyFile
+        // loop that visited every legacy file one at a time.
+        cpSync(src, dir, { recursive: true, preserveTimestamps: true });
+        return aliases.length > 1 ? `migrated ${nm}/ -> ${name}/` : `migrated ${name}/`;
       }
     }
   }
   for (const { text, src } of items) {
     const sp = relPosix(srcRoot, src).split('/');
-    if (sp[0] === 'memory' && sp.length > 1) {
+    if (sp[0] === name && 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))));
+      // (which is themed, and the store dir 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(dir, 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}/`;
+  return `seeded ${name}/`;
+}
+
+export function globalMemory(cfgDir, items, legacy, srcRoot) {
+  return globalStore(cfgDir, items, legacy, srcRoot, 'memory', ['memory', 'anamnesis']);
 }
 
 /** `_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}/`;
+  return globalStore(cfgDir, items, legacy, srcRoot, 'notebook');
 }
 
 /**

package/js/build/emit-opencode.mjs

@@ -27,14 +27,71 @@ import {
 import { writeVersion } from './version.mjs';
 import { mkdirSync } from 'node:fs';
 
+/**
+ * The layer both OpenCode emits share once RENDER has `items`/`theme` in hand: overrides, the
+ * native agents/skills layer, the primary agent, commands, themes, plugins/workflows, and the
+ * final `opencode.json` WIRE. `dir` is the emit's own directory — `.opencode/` for the
+ * per-repo emit, `cfgDir` for the global one — which is why `wireBase` (where `opencode.json`
+ * itself lives) travels separately: the per-repo config sits at the project ROOT, one level
+ * above `dir`, while the global config sits IN `cfgDir`, i.e. `dir` itself.
+ *
+ * Folding WIRE in here moves it earlier in the global emit's own write order (it used to run
+ * after the memory/notebook/laws steps, now before them) — harmless, because none of those
+ * later steps read `opencode.json` back, and the phase-order gate only requires WIRE to log no
+ * earlier than RENDER, which still holds since nothing after this logs a phase at all.
+ *
+ * `manifestExisted` only ever arrives from the per-repo caller; the global emit does not pass
+ * it, matching the Python side, so the pre-manifest header line stays unreachable from there on
+ * both sides.
+ *
+ * `overridesDir` is a THIRD directory, and it is not `dir` for the per-repo emit: the
+ * per-repo `agent-overrides.json` lives beside the portable bundle in `out`, while every other
+ * write in this layer goes under `.opencode/`. The global emit has no such split — `out` there
+ * is only the legacy memory/notebook source, never a write target — so its `overridesDir`
+ * equals `dir`.
+ */
+function opencodeLayer(cfg, items, themeName, theme, dir, owned, opts) {
+  const {
+    oldOwned, manifestExisted, agentPath, wireBase, overridesDir,
+  } = opts;
+  ensureAgentOverridesStub(cfg, overridesDir);
+  const overrides = loadAgentOverrides(overridesDir);
+
+  const { nAgents, nSkills, written } = writeNativeLayer(
+    items, path.join(dir, 'agents'), path.join(dir, 'skills'), overrides,
+    { host: 'opencode', oldOwned, cfg: dir, manifestExisted, theme, src: cfg.src });
+  for (const p of written) owned.push(relPosix(dir, p));
+
+  const primary = writePrimaryAgent(cfg, path.join(dir, 'agents'), overrides);
+  if (primary) owned.push(relPosix(dir, primary));
+
+  const commands = writeCommandLayer(cfg, items, path.join(dir, 'command'));
+  commands.push(writePonytailCommand(path.join(dir, 'command')));   // always-on /ponytail
+  for (const p of commands) owned.push(relPosix(dir, p));
+
+  owned.push(relPosix(dir, writeTheme(path.join(dir, 'themes'), themeName, theme)));
+  for (const p of writeColorThemes(cfg, path.join(dir, 'themes'))) owned.push(relPosix(dir, p));
+
+  const nPlugins = copyPlugins(cfg, path.join(dir, 'plugins'), owned);
+  const nWorkflows = copyWorkflows(cfg, path.join(dir, 'workflows'), owned);
+
+  // WIRE — the one file of this layer the user co-owns.
+  phaseLog('WIRE');
+  const cfgName = path.basename(mergeOpencodeJson(path.join(wireBase, 'opencode.json'),
+    agentPath, cfg.doctrines, cfg.excludeRules));
+
+  return {
+    nAgents, nSkills, nPlugins, nWorkflows, primary, nCommands: commands.length, cfgName,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // 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`.
+ * RENDER and WIRE for `_build_emit.emit_opencode` — everything through `opencodeLayer`'s
+ * `mergeOpencodeJson` call. 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
@@ -56,43 +113,21 @@ export function emitOpencodeRender(cfg, job) {
   // 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)));
+  if (isFile(agentMd)) writeText(agentMd, stripCapabilityLinks(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));
+  const {
+    nAgents, nSkills, nPlugins, nWorkflows, primary, nCommands, cfgName,
+  } = opencodeLayer(cfg, items, _theme, theme, oc, owned, {
+    oldOwned, manifestExisted, agentPath, wireBase: root, overridesDir: out,
+  });
 
   return {
     owned,
     stats: {
-      nAgents, nSkills, nPlugins, nWorkflows, nCommands: commands.length, primary: !!primary,
+      nAgents, nSkills, nPlugins, nWorkflows, nCommands, primary: !!primary,
     },
     cfgName,
   };
@@ -149,34 +184,17 @@ export function emitOpencodeGlobalRender(cfg, job) {
     // 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));
+    writeText(path.join(cfgDir, 'AGENT.md'), stripCapabilityLinks(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 {
+    nAgents, nSkills, nPlugins, nWorkflows, primary, nCommands, cfgName,
+  } = opencodeLayer(cfg, items, themeName, theme, cfgDir, owned, {
+    oldOwned, agentPath, wireBase: cfgDir, overridesDir: cfgDir,
+  });
 
   const memStatus = globalMemory(cfgDir, items, out, cfg.src);
   ensureMemoryIndex(path.join(cfgDir, 'memory'));
@@ -192,23 +210,13 @@ export function emitOpencodeGlobalRender(cfg, job) {
 
   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,
+      nAgents, nSkills, nPlugins, nWorkflows, nCommands, primary: !!primary,
     },
     memStatus,
     nbStatus,
     cfgName,
   };
 }
-

package/js/build/generate.mjs

@@ -42,7 +42,7 @@ import {
 } from '../hosts/installs.mjs';
 import { colorThemeFiles, colorThemeJson, PALETTE_ROLES } from '../hosts/opencode.mjs';
 import { renderAll } from './render.mjs';
-import { printOut, printErr, readText, writeText } from '../lib/fs.mjs';
+import { printOut, printErr, readText, writeText, isDir } 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. */
@@ -68,8 +68,6 @@ function sysExit(msg) {
   throw e;
 }
 
-const isDir = (p) => { try { return statSync(p).isDirectory(); } catch { return false; } };
-
 // --------------------------------------------------------------------------------------
 // build
 // --------------------------------------------------------------------------------------
@@ -322,7 +320,7 @@ export function cmdPrompt(args) {
 // --------------------------------------------------------------------------------------
 
 /** `_harness_build._resolve_themes_dir` — explicit `--dir`, else a repo `.opencode/`, else global. */
-export function resolveThemesDir(args) {
+function resolveThemesDir(args) {
   // `Path(args.dir).expanduser().resolve()` — `resolvePath` already expands a leading `~`.
   if (args.dir) return resolvePath(args.dir);
   const repo = path.join(process.cwd(), '.opencode');
@@ -352,7 +350,7 @@ export function resolveThemesDir(args) {
  * escaping rule) traded for the ORDER OF TWO NAMES in an error message that both
  * implementations still emit, for the same values, with the same exit code.
  */
-export function loadUserPalette(args, cfg) {
+function loadUserPalette(args, cfg) {
   const pal = new Map();
   if (args.fromTheme) {
     const src = path.join(cfg.colorThemes, `${args.fromTheme}.json`);
@@ -369,7 +367,7 @@ export function loadUserPalette(args, cfg) {
     // `Path(args.palette)` — relative to cwd, with no expanduser and no resolve.
     const raw = parseJson(readText(args.palette));
     // `raw.get("palette", raw)` — a document with no "palette" key IS the role map.
-    const map = Object.prototype.hasOwnProperty.call(raw, 'palette') ? raw.palette : raw;
+    const map = Object.hasOwn(raw, 'palette') ? raw.palette : raw;
     for (const [k, v] of Object.entries(map)) pal.set(k, v);
   }
   if (pal.size === 0) {

package/js/build/render.mjs

@@ -81,17 +81,17 @@ function suffixOf(name) {
   return 0 < i && i < name.length - 1 ? name.slice(i) : '';
 }
 
-/** `Path.rglob("*")` restricted to files, then `sorted()`. */
+/**
+ * `Path.rglob("*")` restricted to files, then `sorted()`.
+ *
+ * `recursive: true, withFileTypes: true` replaces the hand-rolled walk — the order it
+ * yields is not the walk's order, but the explicit `.sort(comparePaths)` below is what
+ * every caller actually observes, so a different collection order changes nothing.
+ */
 function sortedSourceFiles(src) {
-  const out = [];
-  (function walk(dir) {
-    for (const name of readdirSync(dir)) {
-      const full = path.join(dir, name);
-      if (name === '__pycache__') continue;          // `"__pycache__" in path.parts`
-      if (statSync(full).isDirectory()) walk(full);  // rglob yields dirs; render_all skips them
-      else out.push(full);
-    }
-  })(src);
+  const out = readdirSync(src, { recursive: true, withFileTypes: true })
+    .filter((d) => d.isFile() && !d.parentPath.split(path.sep).includes('__pycache__'))
+    .map((d) => path.join(d.parentPath, d.name));
   return out.sort(comparePaths);   // `sorted()` — case-folded on Windows only
 }
 
@@ -126,7 +126,7 @@ export function loadTheme(cfg, name) {
 /** `_build_render.substitute`. */
 export function substitute(text, theme) {
   return text.replace(TOKEN_RE, (whole, key) => {
-    if (!Object.prototype.hasOwnProperty.call(theme, key)) return whole;  // visible for debugging
+    if (!Object.hasOwn(theme, key)) return whole;  // visible for debugging
     const v = theme[key];
     // Python renders `str(theme[key])`, which agrees with JS only for strings —
     // `str(True)`/`String(true)` and `str({...})`/`String({...})` do not. Every one of
@@ -143,7 +143,7 @@ export function substitute(text, theme) {
 }
 
 /** `_build_render._resolve_catalogs`. */
-export function resolveCatalogs(text, nativeCatalog) {
+function resolveCatalogs(text, nativeCatalog) {
   return text.replace(CATALOG_BLOCK_RE, (_m, table, pointer) => (nativeCatalog ? pointer : table));
 }
 
@@ -397,7 +397,7 @@ export function effectiveTheme(cfg, themeName, { footprint = 'full', lawsPrefix
 /** `_build_render.themed_rel` — rename the top-level folder of an output path per theme. */
 export function themedRel(rel, theme) {
   const parts = rel.split(path.sep);
-  if (parts.length && Object.prototype.hasOwnProperty.call(SRC_DIR_TOKENS, parts[0])) {
+  if (parts.length && Object.hasOwn(SRC_DIR_TOKENS, parts[0])) {
     parts[0] = theme[SRC_DIR_TOKENS[parts[0]]] ?? parts[0];
   }
   return parts.join(path.sep);

package/js/build/source.mjs

@@ -12,11 +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/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
+ * THE ABSENT KEY IS STILL ABSENT, and the reason is bin/build-driver.mjs's, unchanged:
+ * `_build_core.js_cfg()` always sent `structure` and `capabilityLinkRe` because the Python
+ * originals were module-level names TESTS MUTATE (`_OWNED` membership asked one level out).
+ * A Node process has no Python module to mutate, so it sends no `structure`, and
  * `js/build/render.mjs`'s `cfg.structure ?? STRUCTURE` takes its right-hand branch.
+ * `capabilityLinkRe`'s equivalent override in `stripCapabilityLinks` had no producer either
+ * and was deleted outright in the over-engineering cleanup, `cfg` param and all.
  *
  * 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
@@ -24,7 +26,6 @@
  */
 import { readdirSync, readFileSync } 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/..`).
@@ -37,7 +38,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(path.dirname(fileURLToPath(import.meta.url))));
+export const ROOT = path.resolve(import.meta.dirname, '../..');
 export const SRC = path.join(ROOT, 'src');
 export const CONFIG = path.join(ROOT, 'harness.config.json');
 export const THEMES = path.join(ROOT, 'themes');