geneseed 3.1.0 → 3.1.2

package/js/{diff.mjs → inspect/diff.mjs}

@@ -14,7 +14,7 @@
  * THE SECOND thing the walk shows only as one name: `_diff_collect` runs a whole GLOBAL EMIT
  * into a temp dir. `build.HOSTS[host]["emit_global"]` is a `build.*` reference like any other
  * in the table, and behind it is the generator. That call is why this file imports
- * `bin/geneseed.mjs` — the same in-process route `js/generate.mjs` established for `build`,
+ * `bin/build-driver.mjs` — the same in-process route `js/build/generate.mjs` established for `build`,
  * under the same transitive `child_process` ban.
  *
  * WHAT NO CELL CAN VARY, stated rather than left implicit:
@@ -22,30 +22,33 @@
  *   * **The diff algorithm.** A cell can produce ONE edited file and see one hunk. It cannot
  *     produce the shapes where `difflib`'s choices differ from any other diff's — ties, the
  *     recursion's alignment, and above all `autojunk`, which only engages at 200 lines and
- *     changes the hunks on every real harness file. Gated as a corpus in
- *     `tests/test_pure_function_parity.py`, measured in both directions (28 of the 176 cases
- *     there disagree when `autojunk` is switched off, so the corpus is not describing a
- *     constant).
+ *     changes the hunks on every real harness file. Gated as a corpus —
+ *     `tests/fixtures/pure_probe.mjs`'s `unified_diff` entry, replayed by
+ *     `tests/snapshot/pure_snapshot.test.mjs` against `tests/__snapshots__/primitives/` —
+ *     measured in both directions (28 of the 176 cases there disagree when `autojunk` is
+ *     switched off, so the corpus is not describing a constant).
  *   * **The timestamp.** `_write_improvements` names the file `improvements-%Y%m%d-%H%M%S.md`
  *     and stamps the report with `datetime.now()`, so the two implementations cannot write the
  *     same bytes across a second boundary — and a cell runs them in sequence, so the boundary
- *     is a coin flip. `harness_golden._STAMPS` normalises both spellings out of the snapshot,
- *     which costs the FORMAT assertion and pays it back in
- *     `test_the_improvements_filename_is_stamped_the_same_way_by_both` — absolute, per
- *     implementation, because a comparison made tolerant of a value owes one somewhere else.
+ *     is a coin flip. The cell harness normalises both spellings out of the snapshot, which
+ *     costs the FORMAT assertion and pays it back in `tests/unit/hook_cli.test.mjs`'s
+ *     `the improvements filename is stamped the declared way` — absolute, and asserted
+ *     directly rather than by comparison, because a check made tolerant of a value owes one
+ *     somewhere else.
  */
 import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { emitGlobalInto } from '../bin/geneseed.mjs';
-import { GLOBAL_MANIFEST, VERSION_MARKER, expanduser, opencodeConfigDir } from './hosts.mjs';
+import { emitGlobalInto } from '../../bin/build-driver.mjs';
+import { GLOBAL_MANIFEST, VERSION_MARKER, expanduser, opencodeConfigDir } from '../hosts/hosts.mjs';
 import {
   EMIT_HOST_SCOPE, defaultTheme, doctrinesForBuild, footprintOfDir, modeOfDir, postureOfDir,
   readJsonMaybe, readMaybe, themeOfDir,
-} from './installs.mjs';
-import { unifiedDiff, pySplitLines } from './lib/udiff.mjs';
-import { pyPathStr, pyPrint, pyPrintErr, readText, writeText } from './lib/fs.mjs';
+} from '../hosts/installs.mjs';
+import { unifiedDiff, splitLines } from '../lib/udiff.mjs';
+import { printOut, printErr, readText, writeText } from '../lib/fs.mjs';
+import { toPlatformPath } from '../lib/paths.mjs';
 
 const isFile = (p) => { try { return statSync(p).isFile(); } catch { return false; } };
 
@@ -100,7 +103,7 @@ export function manifestScope(d) {
  *
  * The emit prints its own summary line, which is not part of `diff`'s output; the Python
  * swallows it and lets stderr through, so a WARN from the emit still reaches the user. Both
- * halves matter and only the first needs code here — `pyPrint` and every driver funnel go
+ * halves matter and only the first needs code here — `printOut` and every driver funnel go
  * through `process.stdout.write`, so replacing that one method is the whole redirect.
  *
  * `finally`, because the emit can throw: a swallow that leaked would silence every later line
@@ -183,13 +186,13 @@ export function diffCollect({ target = null, theme = null, emit = null, footprin
         const ta = readText(a);
         const tb = readText(b);
         if (cmpKey(rel, ta) !== cmpKey(rel, tb)) {
-          const diff = unifiedDiff(pySplitLines(tb), pySplitLines(ta), {
+          const diff = unifiedDiff(splitLines(tb), splitLines(ta), {
             fromfile: `source/${rel}`, tofile: `deployed/${rel}`, lineterm: '',
           });
           files.push({ rel, status: 'edited', diff });
         }
       } else if (isFile(a)) {
-        const body = pySplitLines(readText(a));
+        const body = splitLines(readText(a));
         files.push({
           rel,
           status: 'added',
@@ -334,8 +337,8 @@ export function flushExportNotes() {
       .sort();
   } catch { return; }
   if (fresh.length === 0) return;
-  for (const p of fresh) pyPrint(`[geneseed] improvements file saved: ${pyPathStr(p)}\n`);
-  pyPrint('[geneseed] the deployed harness carried local edits — hand the file to '
+  for (const p of fresh) printOut(`[geneseed] improvements file saved: ${toPlatformPath(p)}\n`);
+  printOut('[geneseed] the deployed harness carried local edits — hand the file to '
     + 'your agent to back-port them into src/.\n');
 }
 
@@ -344,14 +347,14 @@ export function cmdDiff(args) {
   const { target, theme, files } = diffCollect({ target: args.target, theme: args.theme });
   if (files === null) {
     if (existsSync(path.join(target, GLOBAL_MANIFEST)) && manifestScope(target) === 'project') {
-      pyPrintErr(`[diff] ${target} is a PROJECT install — diff only compares GLOBAL `
+      printErr(`[diff] ${target} is a PROJECT install — diff only compares GLOBAL `
         + 'installs against a fresh render (a project layer is diffed against '
         + 'its own repo, which this command does not do). Pass --target at a '
         + 'global config dir (opencode-global/claude-global/bob-global/'
         + 'copilot-global), or omit '
         + '--target to use the default.\n');
     } else {
-      pyPrintErr(`[diff] no global Geneseed install at ${target} (no ${GLOBAL_MANIFEST}). `
+      printErr(`[diff] no global Geneseed install at ${target} (no ${GLOBAL_MANIFEST}). `
         + 'Pass --target, or run `--emit opencode-global` first.\n');
     }
     return 1;
@@ -359,31 +362,31 @@ export function cmdDiff(args) {
   const edited = files.filter((f) => f.status === 'edited');
   const added = files.filter((f) => f.status === 'added');
   const missing = files.filter((f) => f.status === 'missing');
-  pyPrint(`[diff] deployed ${target}  vs  source (theme: ${theme})\n`);
-  pyPrint(`[diff] ${edited.length} edited, ${added.length} added-in-deployed, `
+  printOut(`[diff] deployed ${target}  vs  source (theme: ${theme})\n`);
+  printOut(`[diff] ${edited.length} edited, ${added.length} added-in-deployed, `
     + `${missing.length} missing-from-deployed\n`);
-  for (const f of edited) pyPrint(`  ~ ${f.rel}   (edited in deployed — review to back-port)\n`);
-  for (const f of added) pyPrint(`  + ${f.rel}   (only in deployed — your addition)\n`);
-  for (const f of missing) pyPrint(`  - ${f.rel}   (in source, not deployed — re-emit to add)\n`);
+  for (const f of edited) printOut(`  ~ ${f.rel}   (edited in deployed — review to back-port)\n`);
+  for (const f of added) printOut(`  + ${f.rel}   (only in deployed — your addition)\n`);
+  for (const f of missing) printOut(`  - ${f.rel}   (in source, not deployed — re-emit to add)\n`);
   if (args.out) {
     if (files.length) {
       // Bare `--out` is argparse's `nargs="?"` const: True, meaning "the default timestamped
       // path". `parse()` gives a flag `true` and an option a string, so the two arrive
       // distinguishable here without a third kind of entry in the VERBS table.
       const outPath = args.out === true ? null : args.out;
-      pyPrint(`[diff] improvements file written: ${
+      printOut(`[diff] improvements file written: ${
         writeImprovements(target, theme, files, outPath)}\n`);
     } else {
-      pyPrint('[diff] no differences — nothing written.\n');
+      printOut('[diff] no differences — nothing written.\n');
     }
   }
   if (args.full) {
     for (const f of edited) {
-      pyPrint(`\n--- ${f.rel} (source -> deployed) ---\n`);
-      pyPrint(`${f.diff.join('\n')}\n`);
+      printOut(`\n--- ${f.rel} (source -> deployed) ---\n`);
+      printOut(`${f.diff.join('\n')}\n`);
     }
   } else if (edited.length && !args.out) {
-    pyPrint('\nRun with --full to see the line-level diffs, or --out FILE to export them.\n');
+    printOut('\nRun with --full to see the line-level diffs, or --out FILE to export them.\n');
   }
   return 0;
 }

package/js/inspect/doctor.mjs

@@ -0,0 +1,286 @@
+/**
+ * `geneseed doctor` — validate the build.
+ *
+ * Sixteen `*Problems` checks over one theme (or every theme) — and `[doctor] ok — …` when all
+ * sixteen find nothing. The checks themselves live beside this file, in `checks-build.mjs`,
+ * `checks-repo.mjs` and `checks-authoring.mjs`, over the primitives in `scan.mjs`; what is left
+ * here is the driver that chooses the themes, runs the checks and prints the verdict.
+ *
+ * WHY THE GATE LOOKS THE WAY IT DOES, and it is worth stating here rather than only in the
+ * spec: **delete any single check and a clean run is byte-identical**, so a comparison of two
+ * runs cannot tell a full doctor from a stub that prints the OK line.
+ * `tests/unit/harness.test.mjs` and `tests/unit/authoring_gates.test.mjs` therefore plant ONE
+ * FAULT PER CHECK, in a private copy of the checkout — see `copyCheckout` in
+ * `tests/helpers/cli_golden.mjs` for why a verb that reads `ROOT` needed a fixture kind that
+ * did not exist until the port.
+ *
+ * WHY THIS IS THE VERB THAT SPAWNS. `bin/geneseed-cli.mjs` is under a blanket transitive
+ * `child_process` ban, and its own docblock predicted the day a verb that genuinely spawns
+ * would land: this is it. `authoringProblems` runs `node --check` over the OpenCode plugins,
+ * and there is no in-process equivalent — `vm.Script` compiles as a SCRIPT and every plugin is
+ * ESM (`import { promises as fs } from "node:fs"`), which `node --check` accepts through
+ * module-syntax detection and `vm.Script` rejects with a SyntaxError of its own. So the ban is
+ * an ALLOW-LIST of exactly the shape the hook entry already carries for `$GENESEED_LLM`: one
+ * binding, one call site, and a test that names the argv. What the ban actually protects —
+ * that this tool never shells back to the generator — is asserted directly instead.
+ *
+ * WHAT `doctorCollect` DOES NOT REACH, MEASURED RATHER THAN ASSUMED. It takes `groups` and
+ * `cmdDoctor` does not pass it: that parameter is the WEB's, and `apiDoctor` in
+ * `js/web/api.mjs` is its only caller. `ran` exists for it — four lines of accumulator that
+ * keep the Doctor page's per-check cards a parameter rather than a rewrite.
+ */
+import path from 'node:path';
+import { emitGlobalInto, emitProjectInto, main as driverMain } from '../../bin/build-driver.mjs';
+import { ROOT } from '../build/source.mjs';
+import { resolvePath } from '../hosts/hosts.mjs';
+import { installedDefaults, themeFiles } from '../hosts/installs.mjs';
+import { validateIsVendored } from '../hosts/native.mjs';
+import { printOut } from '../lib/fs.mjs';
+import { authoringProblems } from './checks-authoring.mjs';
+import {
+  checkBuild, colorThemeProblems, renderedProblems, themeParityProblems,
+} from './checks-build.mjs';
+import { moduleMapProblems, shimProblems } from './checks-repo.mjs';
+import { isDoctorNote, sortedProblems, sortedUnique, stemOf, withTempDir } from './scan.mjs';
+
+/**
+ * `_harness_build._themes_to_check` — which themes doctor validates.
+ *
+ * An explicit `--theme` wins. Otherwise, unless `--all` forces the maintainer sweep, scope to
+ * the theme THIS host installed so a one-theme user is not buried under the same problem
+ * echoed across all fourteen. Falls back to the full sweep when nothing is installed (a fresh
+ * clone) or the detected theme is unknown, so a maintainer in a clean checkout still gets
+ * full coverage. Pure, and gated as such: `--all` is a 14-theme sweep no cell can afford.
+ */
+export function themesToCheck(theme, allThemes, detected, available) {
+  if (theme) return [theme];
+  if (!allThemes && detected && available.includes(detected)) return [detected];
+  return [...available].sort();
+}
+
+/**
+ * `contextlib.redirect_stdout(io.StringIO())` — swallow an emit's log, and ONLY stdout.
+ *
+ * The Python redirects stdout and leaves stderr alone, so a WARN from the emit still reaches
+ * the user. Reproducing that exactly is the point: swallowing both would hide
+ * `warnBobGlobalOverProject` and swallowing neither would put ~200 lines of emit summary into
+ * doctor's output. `withPlatformNewlines` inside `emitGlobalInto` wraps whatever `write` is
+ * installed at call time, so it translates into this buffer and the bytes never leave.
+ */
+function swallowStdout(fn) {
+  const real = process.stdout.write.bind(process.stdout);
+  process.stdout.write = () => true;
+  try { return fn(); } finally { process.stdout.write = real; }
+}
+
+/**
+ * `_harness_build._global_emit_problems` — validate the opencode-global emit, in BOTH
+ * footprints.
+ *
+ * The RECOMMENDED install, and otherwise a doctor blind spot: the files build and ./Harness
+ * were checked and the global layout never was. The two footprints produce genuinely
+ * different AGENT.md bodies — lean swaps the inlined laws for a digest plus a pointer and
+ * ships a standalone laws file the full emit does not write — so checking one leaves the
+ * other's links and tokens unvalidated, and lean being the default made that the shape most
+ * installs actually run.
+ */
+export function globalEmitProblems(themeName) {
+  const problems = [];
+  for (const footprint of ['lean', 'full']) {
+    withTempDir((tmp) => {
+      const cfgDir = path.join(tmp, 'cfg');
+      try {
+        swallowStdout(() => emitGlobalInto('opencode', {
+          theme: themeName, out: path.join(tmp, 'bundle'), cfgDir, footprint,
+        }));
+      } catch (e) {
+        if (e && e.exitCode !== undefined) {
+          problems.push(`[${themeName} global/${footprint}] build failed`);
+          return;
+        }
+        throw e;
+      }
+      problems.push(...checkBuild(`${themeName} global/${footprint}`, cfgDir));
+    });
+  }
+  return problems;
+}
+
+/**
+ * `_harness_build._claude_bob_emit_problems` — validate the claude/bob/copilot PER-REPO
+ * emits, which were never checked before.
+ *
+ * That is exactly why the CLAUDE.md/AGENTS.md skill-table dead links shipped unnoticed: the
+ * emits that render straight into a repo were outside doctor's sweep. Scanned with
+ * `validateIsVendored` rather than `isVendoredPath`, because the native per-repo layer nests
+ * skills one level deeper than a bundle does.
+ */
+export function claudeBobEmitProblems(themeName) {
+  const problems = [];
+  for (const label of ['claude', 'bob', 'copilot']) {
+    withTempDir((tmp) => {
+      const root = path.join(tmp, 'root');
+      try {
+        swallowStdout(() => emitProjectInto(label, {
+          theme: themeName, out: path.join(root, 'bundle'), root,
+        }));
+      } catch (e) {
+        if (e && e.exitCode !== undefined) {
+          problems.push(`[${themeName} ${label}] build failed`);
+          return;
+        }
+        throw e;
+      }
+      problems.push(...checkBuild(`${themeName} ${label}`, root, validateIsVendored));
+    });
+  }
+  return problems;
+}
+
+/**
+ * `_harness_build._doctor_collect` — run every check; return `[themes, problems]`.
+ *
+ * ONE PARAMETER OF THE PYTHON IS NOT HERE, and the absence is on purpose. `on_progress` is
+ * the TUI's — it drags ~140 lines of curses drawing behind it and nothing in this tree can
+ * supply one. `groups` DID land, with the caller that needed it: it is the structured
+ * `{check, label, problems}` view the Doctor page renders, and `js/web/api.mjs`'s `apiDoctor`
+ * passes an array. `cmdDoctor` passes nothing and gets the flat list, so the return contract
+ * is the same either way.
+ *
+ * THE PER-THEME BUILD IS THE DRIVER, IN-PROCESS. The Python shells to `build.py` and reads a
+ * return code; here that is `driverMain`, the route P5e established and the only one the
+ * `child_process` allow-list leaves. `cwd=ROOT` does not travel in-process and does not have
+ * to: `--out` is an absolute path, which is the one input `resolveOut` would have read the
+ * working directory for.
+ */
+export function doctorCollect({
+  theme = null, allThemes = false, bundle = null, noBundle = false, groups = null,
+} = {}) {
+  const available = themeFiles().map(stemOf);
+  if (!available.length) return [[], ['[doctor] no themes found']];
+
+  // `_ran` — the label is the one place each check is NAMED, and since P6b a caller can
+  // pass an array to collect them. `/api/doctor` renders one card per entry, which is the
+  // only reason the structured view exists; `cmd_doctor` passes nothing and gets the flat
+  // list, so the return contract is unchanged either way. `on_progress` is still P7's.
+  const ran = (check, label, probs) => {
+    if (groups !== null) groups.push({ check, label, problems: sortedProblems(probs) });
+    return probs;
+  };
+
+  // Only probe the deployed install when we actually need it (no theme / not --all).
+  const detected = (theme || allThemes) ? null : (installedDefaults().theme ?? null);
+  const themes = themesToCheck(theme, allThemes, detected, available);
+  // Sampled HERE, before the emit loop below — every emit rewrites the hook shim, so a check
+  // placed after them could only ever observe the freshly repaired file and would be dead
+  // code that always reports clean. Reported in its usual slot further down.
+  const shimProbs = shimProblems();
+  let problems = [];
+  withTempDir((tmp) => {
+    for (const themeName of themes) {
+      const out = path.join(tmp, themeName);
+      // capture_output=True: BOTH streams, unlike the emits below, which redirect stdout
+      // only. A failing build's stderr is not doctor's output either — the return code is.
+      const rc = captureBoth(() => driverMain(['--theme', themeName, '--out', out]));
+      if (rc !== 0) {
+        problems = problems.concat(ran('build', `Build scan (${themeName})`,
+          [`[${themeName}] build failed`]));
+        continue;
+      }
+      problems = problems.concat(ran('build', `Build scan (${themeName})`,
+        checkBuild(themeName, out)));
+      problems = problems.concat(ran('global', `Global install (${themeName})`,
+        globalEmitProblems(themeName)));
+      problems = problems.concat(ran('claude_bob',
+        `Claude/Bob/Copilot per-repo emit (${themeName})`, claudeBobEmitProblems(themeName)));
+    }
+  });
+  problems = problems.concat(ran('parity', 'Theme parity', themeParityProblems()));
+  problems = problems.concat(ran('colors', 'Colour themes', colorThemeProblems()));
+  problems = problems.concat(ran('authoring', 'Authoring gates', authoringProblems()));
+  problems = problems.concat(ran('shim', 'Hook shim', shimProbs));
+  problems = problems.concat(ran('map', 'Module map', moduleMapProblems()));
+  // P10c's `cli` check is GONE, and the reason is not that it stopped mattering. It hashed
+  // `rituals/harness.py` and compared that against a digest baked into `cli.json`, to catch a
+  // parser edited without regenerating the table. P2 made the table the OWNED document
+  // (`js/cli-table.json`), so there is no generator to fall behind and no second file to hash
+  // — the digest was a claim about a file this migration deletes. What replaces it is
+  // `tests/unit/cli_table.test.mjs`, which holds the owned table against the two entry points
+  // that dispatch from it: no second file to hash, and no generator that can fall behind.
+  if (!noBundle) {
+    // `Path(bundle).expanduser().resolve()`, which `resolvePath` already IS — the default is
+    // deliberately NOT resolved, because the Python's `ROOT / "Harness"` is not either and
+    // the resolved spelling is what the messages print.
+    const b = bundle ? resolvePath(bundle) : path.join(ROOT, 'Harness');
+    problems = problems.concat(ran('bundle', 'Committed bundle drift', renderedProblems(b)));
+  }
+  return [themes, sortedUnique(problems)];
+}
+
+/** `run(..., capture_output=True)` — both streams into the void, the return code out. */
+function captureBoth(fn) {
+  const out = process.stdout.write.bind(process.stdout);
+  const err = process.stderr.write.bind(process.stderr);
+  process.stdout.write = () => true;
+  process.stderr.write = () => true;
+  try { return fn(); } finally { process.stdout.write = out; process.stderr.write = err; }
+}
+
+/**
+ * `_harness_build.cmd_doctor` — the CLI face.
+ *
+ * With `--theme`, one theme. With none it scopes to the INSTALLED theme, so a one-theme
+ * install is not buried under the same issue repeated across every theme; `--all` is the full
+ * maintainer sweep. The cross-theme parity check runs in every mode.
+ */
+export function cmdDoctor(args) {
+  const [themes, collected] = doctorCollect({
+    theme: args.theme, allThemes: Boolean(args.all), bundle: args.bundle,
+    noBundle: Boolean(args.noBundle),
+  });
+  if (!themes.length) {
+    printOut(`${collected.length ? collected[0] : '[doctor] no themes found'}\n`);
+    return 1;
+  }
+  // ⚠ NOTES ARE PRINTED AND NOT COUNTED. The only producer is the pack-off citation report in
+  // `constitutionProblems`, and the state it describes is one the install's owner chose: a
+  // build that leaves body prose citing a pack it did not render. Silence there is how prose
+  // and boundary drift apart, and a non-zero exit there is doctor failing a legal
+  // configuration. Nothing in the recorded CLI corpus produces one — the checkout's own
+  // `harness.config.json` names no packs — so the byte-compared output is unmoved.
+  const notes = collected.filter(isDoctorNote);
+  const problems = collected.filter((p) => !isDoctorNote(p));
+  const scoped = !args.theme && !args.all && themes.length === 1;
+  const note = scoped
+    ? `  (scoped to installed theme '${themes[0]}'; run with --all to sweep every theme)` : '';
+  for (const n of notes) printOut(`${n}\n`);
+  if (problems.length) {
+    printOut(`[doctor] ${problems.length} problem(s) across ${themes.length} theme(s):\n`);
+    for (const p of problems) printOut(`  - ${p}\n`);
+    if (problems.some((p) => p.includes('dead link'))) {
+      printOut('  tip: dead links to skills mean your source is incomplete — run '
+        + '`./geneseed update` (or re-sync src/), then re-check.\n');
+    }
+    if (problems.some((p) => p.startsWith('[themes]') && p.includes('missing key'))) {
+      // ⚠ THE TIP USED TO NAME `./geneseed build --sync-themes`, AND THAT COMMAND ERRORS.
+      // It was argued here on the premise that "`build` forwards its extra arguments to the
+      // generator" — which was true of the reference and is not true of `cmdBuild`
+      // (`js/build/generate.mjs`), which forwards `--theme` and nothing else. So the front door
+      // answered `unrecognized arguments: --sync-themes` to anyone who followed doctor's own
+      // advice, for as long as the premise went unchecked. The flag belongs to the GENERATOR,
+      // whose binary is `geneseed-build` — which is what `README.md` and `SETUP.md` have said
+      // all along. A hint is a command; if it is not runnable it is decoration.
+      printOut('  tip: a theme is missing a key another theme defines — run '
+        + '`geneseed-build --sync-themes` to fill it from _TEMPLATE.json, '
+        + 'then restyle the added key(s) and re-check.\n');
+    }
+    if (note) printOut(`${note}\n`);
+    return 1;
+  }
+  printOut('[doctor] ok — ' + `${themes.length} theme(s) clean: no unresolved tokens, no dead `
+    + 'links, nothing escapes the bundle; themes in parity; specs carry purpose '
+    + 'lines; rendered bundle in sync\n');
+  if (note) printOut(`${note}\n`);
+  return 0;
+}
+

package/js/{excludes.mjs → inspect/excludes.mjs}

@@ -1,35 +1,32 @@
 /**
- * `rituals/_harness_exclude.py` — the sovereign-repo exclusion WRITER.
+ * The sovereign-repo exclusion WRITER.
  *
- * THE READER WAS ALREADY HERE. `js/hooks.mjs` has carried `sovereignBypass`, `EXCLUDES_FILE`
+ * THE READER WAS ALREADY HERE. `js/hosts/hooks.mjs` has carried `sovereignBypass`, `EXCLUDES_FILE`
  * and `EXCLUDE_DIRS` since P5a: every hook call reads `excludes.json` and stands down when
  * cwd is under an excluded folder. This module is the other half — `harness exclude
  * add|remove|list`, which maintains that file across every global install and wires the
  * host-native per-repo suppression into the excluded repo.
  *
- * THE PYTHON WRITER STAYS, AND THAT IS A DECISION RATHER THAN AN OMISSION.
- * `rituals/_web_actions.py:371-390` calls `excludes_snapshot()`, `exclude_add` and
- * `exclude_remove` "verbatim: this endpoint owns no exclusion logic of its own", and the web
- * server is P6. So until that phase there are two writers for one user-owned file. What
- * makes that survivable is what makes it survivable for the machine-wide hook shim: the two
- * implementations are held byte-equal by `tests/harness_golden.py`, which runs every cell
- * against both and compares stdout, stderr, the exit code and every file left behind. What
- * it does NOT cover is two processes writing at the same instant — `_write_excludes` is
- * temp-plus-rename on both sides, so a concurrent pair loses one edit rather than tearing
- * the file, which is the same guarantee the single-writer version had against itself.
+ * THE WEB ENDPOINT IS THIS MODULE — there is exactly ONE writer. `js/web/actions.mjs`
+ * dispatches straight to `excludeAdd`/`excludeRemove` here, and `apiExcludes` in
+ * `js/web/api.mjs` is `excludesSnapshot()` unmodified, so the CLI and the console are one
+ * writer over one user-owned file. It used to be two, with a Python endpoint calling the
+ * same three names, and the surviving hazard is the one that outlived the split: two
+ * PROCESSES writing at the same instant. `writeExcludes` is temp-plus-rename, so a
+ * concurrent pair loses one edit rather than tearing the file.
  *
  * Every path a hook takes on this file is READ-only, so nothing here is on the PreToolUse
- * latency budget — which is why it lives beside the CLI and not in `js/hooks.mjs`.
+ * latency budget — which is why it lives beside the CLI and not in `js/hosts/hooks.mjs`.
  */
 import { existsSync, mkdirSync, readdirSync, renameSync, rmdirSync, statSync, unlinkSync }
   from 'node:fs';
 import path from 'node:path';
-import { EXCLUDES_FILE, EXCLUDES_STUB, BOB_RULES_STUB } from './emit.mjs';
-import { wireClaudeExcludes, unwireClaudeExcludes } from './settings.mjs';
-import { GLOBAL_MANIFEST, HOSTS, pyResolve } from './hosts.mjs';
-import {
-  readText, writeText, parseJson, jsonDumpsIndent, normcase, pyPathStr, pyPrint, pyPrintErr,
-} from './lib/fs.mjs';
+import { EXCLUDES_FILE, EXCLUDES_STUB, BOB_RULES_STUB } from '../build/stubs.mjs';
+import { wireClaudeExcludes, unwireClaudeExcludes } from '../hosts/settings.mjs';
+import { GLOBAL_MANIFEST, HOSTS, resolvePath } from '../hosts/hosts.mjs';
+import { readText, writeText, printOut, printErr } from '../lib/fs.mjs';
+import { parseJson, jsonDumpsIndent } from '../lib/json.mjs';
+import { normcase, toPlatformPath } from '../lib/paths.mjs';
 
 const get = (o, k) => (o && Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
 const isDict = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
@@ -78,19 +75,19 @@ function writeExcludes(cfg, data) {
 }
 
 /** `_canon` — `Path(p).expanduser().resolve()`. */
-const canon = (p) => pyResolve(p);
+const canon = (p) => resolvePath(p);
 
 /**
  * `_same` — is this stored entry the same folder as `repo`?
  *
- * `pyPathStr` and not `path.normalize`: the latter collapses `a/../b` to `b`, and Python's
+ * `toPlatformPath` and not `path.normalize`: the latter collapses `a/../b` to `b`, and Python's
  * `Path()` does not, so a hand-edited entry carrying `..` matches here and would not match
  * there. Getting that backwards makes `exclude remove` unwire a repo the reference left
  * alone.
  */
 function same(stored, repo) {
   if (typeof stored !== 'string' || !stored) return false;
-  return normcase(pyPathStr(stored)) === normcase(repo);
+  return normcase(toPlatformPath(stored)) === normcase(repo);
 }
 
 /**
@@ -112,7 +109,7 @@ export function excludeAdd(target) {
     const priorWired = (isDict(prior) ? get(prior, 'wired') : null) || {};
     const wired = {};
     if (host === 'claude' && isDir(repo)) {
-      const entry = pyResolve(path.join(cfg, 'CLAUDE.md')).split(path.sep).join('/');
+      const entry = resolvePath(path.join(cfg, 'CLAUDE.md')).split(path.sep).join('/');
       const added = wireClaudeExcludes(
         path.join(repo, '.claude', 'settings.local.json'), [entry]);
       if (added.length) {
@@ -200,7 +197,7 @@ export function excludeRemove(target) {
         // Node's own wording. No cell can reach this branch (`unlink` on a file that
         // `isFile` just confirmed, `rmdir` on a directory just measured empty), so a
         // translation table here would be an unobservable guess. Same class as P5b's
-        // untested `die()` newline; `js/settings.mjs`'s `pyOsError` is the same stub for
+        // untested `die()` newline; `js/hosts/settings.mjs`'s `asOsError` is the same stub for
         // the same reason.
         messages.push(`${host}: could not remove ${stub} (${e.message})`);
       }
@@ -213,8 +210,8 @@ export function excludeRemove(target) {
 }
 
 /**
- * `excludes_snapshot` — the union view across installs, shared by the CLI `list` and (on the
- * Python side) the web endpoint. Also flags installs whose lists diverge: a global emit made
+ * `excludes_snapshot` — the union view across installs, shared by the CLI `list` and by the
+ * web endpoint (`apiExcludes` in `js/web/api.mjs` is this function, unmodified). Also flags installs whose lists diverge: a global emit made
  * after the exclusions were added starts with an empty stub.
  */
 export function excludesSnapshot() {
@@ -224,7 +221,7 @@ export function excludesSnapshot() {
     for (const e of readExcludes(cfg).excludes) {
       const p = isDict(e) ? get(e, 'path') : e;
       if (typeof p !== 'string' || !p) continue;
-      const key = normcase(pyPathStr(p));
+      const key = normcase(toPlatformPath(p));
       if (!byPath.has(key)) {
         byPath.set(key, { path: p, hosts: [],
           wired: (isDict(e) ? get(e, 'wired') : null) || {} });
@@ -242,11 +239,11 @@ export function cmdExclude(args) {
   if (args.action === 'list') {
     const snap = excludesSnapshot();
     if (!snap.installs.length) {
-      pyPrint('[geneseed] no global install found.\n');
+      printOut('[geneseed] no global install found.\n');
       return 1;
     }
     if (!snap.excludes.length) {
-      pyPrint('[geneseed] no folders excluded.\n');
+      printOut('[geneseed] no folders excluded.\n');
       return 0;
     }
     const allHosts = new Set(snap.installs.map((i) => i.host));
@@ -254,18 +251,18 @@ export function cmdExclude(args) {
       const missing = [...allHosts].filter((h) => !rec.hosts.includes(h)).sort();
       const flag = missing.length
         ? `  (MISSING from: ${missing.join(', ')} — re-run \`harness exclude add\`)` : '';
-      pyPrint(`  ${rec.path}  [${rec.hosts.slice().sort().join(', ')}]${flag}\n`);
+      printOut(`  ${rec.path}  [${rec.hosts.slice().sort().join(', ')}]${flag}\n`);
     }
     return 0;
   }
   if (!args.path) {
-    pyPrintErr('[geneseed] exclude add/remove needs a folder path.\n');
+    printErr('[geneseed] exclude add/remove needs a folder path.\n');
     return 2;
   }
   const res = args.action === 'add' ? excludeAdd(args.path) : excludeRemove(args.path);
-  for (const m of res.messages) pyPrintErr(`[geneseed] ${m}\n`);
+  for (const m of res.messages) printErr(`[geneseed] ${m}\n`);
   const verb = args.action === 'add' ? 'excluded' : 're-included';
-  pyPrint(res.ok ? `[geneseed] ${res.path} ${verb}.\n`
+  printOut(res.ok ? `[geneseed] ${res.path} ${verb}.\n`
     : `[geneseed] nothing done for ${res.path}.\n`);
   return res.ok ? 0 : 1;
 }