geneseed 3.1.3 → 3.3.0

package/js/build/emit-claude.mjs

@@ -10,8 +10,8 @@ import { VERSION_MARKER } from '../hosts/hosts.mjs';
 import { loadAgentOverrides, writeNativeLayer } from '../hosts/native.mjs';
 import { ensureAgentOverridesStub } from '../hosts/opencode.mjs';
 import {
-  managedBlockRemove, managedBlockWrite, mergeClaudeSettings, unwireClaudeExcludes,
-  unwireClaudeSettings, wireClaudeExcludes,
+  managedBlockRemove, managedBlockWrite, mergeClaudeSettings, mergeCopilotSettings,
+  unwireClaudeExcludes, unwireClaudeSettings, wireClaudeExcludes,
 } from '../hosts/settings.mjs';
 import { writeText } from '../lib/fs.mjs';
 import { isTruthy } from '../lib/json.mjs';
@@ -54,8 +54,7 @@ export function emitClaudeRender(cfg, job) {
 
   // `os.path.relpath(cfg, claude_md.parent)` — note the reversed argument order, and
   // that Python answers '.' for an identical pair where `path.relative` answers ''.
-  const relCfg = path.relative(path.dirname(claudeMd), cfgDir).split(path.sep).join('/')
-    || '.';
+  const relCfg = relPosix(path.dirname(claudeMd), cfgDir) || '.';
   const lawsPrefix = relCfg === '.' ? '' : `${relCfg}/`;
   const { theme, items } = renderAll(cfg, themeName, { footprint, lawsPrefix, nativeCatalog });
   assertSourceComplete(cfg, `claude-${scope}`);
@@ -98,7 +97,7 @@ export function emitClaudeRender(cfg, job) {
     const rulesMd = path.join(cfgDir, 'rules', 'geneseed.md');
     mkdirSync(path.dirname(rulesMd), { recursive: true });
     writeText(rulesMd, scope === 'project' ? BOB_RULES_STUB
-      : stripCapabilityLinks(cfg, prefixedAgentText('../') || agentText));
+      : stripCapabilityLinks(prefixedAgentText('../') || agentText));
     owned.push('rules/geneseed.md');
   }
 
@@ -146,7 +145,7 @@ export function emitClaudeRender(cfg, job) {
   // consumes and no more.
   let claudeMdText = null;
   if (agentText !== null && !(isBob && scope === 'global')) {
-    claudeMdText = stripCapabilityLinks(cfg, prefixedAgentText(lawsPrefix) || agentText);
+    claudeMdText = stripCapabilityLinks(prefixedAgentText(lawsPrefix) || agentText);
   }
 
   // WIRE — see `claudeWire` below. One child per emit, so the two halves are two
@@ -212,7 +211,7 @@ function claudeWire(job, claudeMdText, hasAgentText, doctrines = null, excludeRu
     // above — unreachable here (CLAUDE.md is a file, cfgDir a directory, so the pair is
     // never identical) and spelled anyway, because the two call sites are 400 lines apart
     // and only one of them is obviously safe.
-    const rel = path.relative(cfgDir, claudeMd).split(path.sep).join('/') || '.';
+    const rel = relPosix(cfgDir, claudeMd) || '.';
     managed.claude_md = { rel };
   } else if (isBob && scope === 'global' && isTruthy(get(old, 'claude_md'))) {
     const oldCm = isDict(get(old, 'claude_md')) ? get(old, 'claude_md') : {};
@@ -226,12 +225,19 @@ function claudeWire(job, claudeMdText, hasAgentText, doctrines = null, excludeRu
   // settings.local.json — the personal, untracked file — never the team-shared
   // settings.json, which would hand every teammate failing hooks pointing at this machine's
   // node and this machine's checkout. (Bob documents no local variant, so it keeps
-  // settings.json.) Copilot has NO
-  // settings.json and no hook mechanism at all, so the whole stage is skipped: nothing
-  // written, no settings_* keys recorded for the lifecycle to unwire.
+  // settings.json.) Copilot's settings are a different shape entirely (one command per
+  // event, no matcher groups) and take the `else` branch below; its PROJECT scope wires
+  // nothing, because the CLI documents hooks in `~/.copilot/settings.json` only and a
+  // machine-absolute hook committed into `.github/` would fail on every teammate's machine.
   if (!isCopilot) {
-    const settingsName = scope === 'project' && !isBob ? 'settings.local.json' : 'settings.json';
+    // Bob GLOBAL: its hooks doc puts the global file at `~/.bob/settings/settings.json`
+    // (nested), where an older emit wrote `~/.bob/settings.json`; the `oldSf !==
+    // settingsName` branch below unwires the old file, so a re-emit migrates. Bob's project
+    // file stays `.bob/settings.json`.
+    const settingsName = scope === 'project' && !isBob ? 'settings.local.json'
+      : isBob && scope === 'global' ? path.join('settings', 'settings.json') : 'settings.json';
     const settingsPath = path.join(cfgDir, settingsName);
+    mkdirSync(path.dirname(settingsPath), { recursive: true });
     managed.settings_file = settingsName;
     // Migration: an older install wired hooks/excludes into a different file — unwire the
     // recorded claims there, or they linger (and run) forever.
@@ -248,7 +254,7 @@ function claudeWire(job, claudeMdText, hasAgentText, doctrines = null, excludeRu
     // DECIDES the install's packs, so the marker on disk is still the previous build's.
     const [, managedHooks] = mergeClaudeSettings(
       settingsPath, scope, oldSf === settingsName ? get(old, 'settings_hooks') : null, hookOpts,
-      doctrines, excludeRules,
+      doctrines, excludeRules, host,
     );
     managed.settings_hooks = managedHooks;
 
@@ -281,6 +287,14 @@ function claudeWire(job, claudeMdText, hasAgentText, doctrines = null, excludeRu
     } else if (priorExcl.length) {
       managed.settings_excludes = priorExcl;
     }
+  } else if (scope === 'global') {
+    // `copilot_hooks`, not `settings_hooks`: a distinct key so the Claude-shaped unwire and
+    // integrity code, which walks `settings_hooks` as event→group arrays, never sees a
+    // Copilot record it would misread.
+    const settingsPath = path.join(cfgDir, 'settings.json');
+    managed.settings_file = 'settings.json';
+    const [, claims] = mergeCopilotSettings(settingsPath, get(old, 'copilot_hooks'), hookOpts);
+    managed.copilot_hooks = claims;
   }
   return managed;
 }

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) {