geneseed 3.1.0 → 3.1.2

package/js/web/actions.mjs

@@ -7,15 +7,15 @@
  * of magnitude:
  *
  *   * `_memory_drop_index` — "check whether P5's `learn` ported it". It did not; nothing in
- *     `js/` referenced it. It lands in `js/hooks.mjs`, beside the other memory-store
+ *     `js/` referenced it. It lands in `js/hosts/hooks.mjs`, beside the other memory-store
  *     primitives, because that is where its Python siblings' twins already live.
  *   * `_mcp_load` — "already in js/ (P6c)". What crossed in P6c is `readJsonc` and a
  *     five-line no-host reader inside `js/web/api.mjs` for `wiki.jsonc`. The host fork and
- *     the other twelve MCP functions are 168 lines of new `js/mcp.mjs`.
+ *     the other twelve MCP functions are 168 lines of new `js/hosts/mcp.mjs`.
  *   * `settings.mjs`'s atomic write — a DIFFERENT Python function from `_mcp_save`, with a
- *     different temp suffix and no parent-directory creation. See `js/mcp.mjs`.
+ *     different temp suffix and no parent-directory creation. See `js/hosts/mcp.mjs`.
  *   * `api_install_toggle` — "~25 new; `_move_tree`, `_prune_empty_ancestors` and the stash
- *     ARE in `js/uninstall.mjs` (P5h)". `DISABLED_STASH`, `installKind` and `installState`
+ *     ARE in `js/maintain/uninstall.mjs` (P5h)". `DISABLED_STASH`, `installKind` and `installState`
  *     are. `_move_tree`, `_prune_empty_ancestors`, `_install_move_list`, `_install_relive`,
  *     `_install_readd_entry`, `_install_deactivate`, `_install_reactivate`,
  *     `_claude_deactivate` and `_claude_reactivate` are not — 293 lines of unported
@@ -57,15 +57,13 @@
  *
  * `web/dist` therefore does NOT need rebuilding, and it was not rebuilt.
  *
- * WHAT GATES IT, since no cell can. The value never reaches a response, so
- * `tests/web_golden.py` is structurally blind to it — which is exactly the shape a corpus
- * answers and a cell cannot (the phase rule: a cell runs the PROGRAM, a corpus runs the
- * FUNCTION). The gate is a unit test that calls BOTH implementations and asserts three
- * things: the reference's argv head is its own interpreter and `build.py`, absolutely; the
- * twin's head is `process.execPath` and `bin/geneseed-cli.mjs`, absolutely; and the TAIL —
- * every argument after the head, which is where a real port bug would live — is identical.
- * That is the absolute-assertion-per-side discipline a tolerant comparison owes, applied to
- * a value the byte gate cannot reach.
+ * WHAT GATES IT, since no cell can. The value never reaches a response, so a request-level
+ * corpus is structurally blind to it — exactly the shape a function-level gate answers and a
+ * cell cannot. That gate is `tests/unit/web_jobs.test.mjs`: it asserts the argv HEAD
+ * absolutely — `process.execPath` plus `bin/build-driver.mjs`, and no interpreter name
+ * anywhere in it — and pins the TAIL, every argument after the head, against a frozen
+ * literal. The tail is where a real bug would live, and asserting it absolutely rather than
+ * by comparison is what let it outlive the implementation it was once compared against.
  *
  * THE CODE IS P6g's, THE DECISION IS THIS PHASE's. `api_install_cmd`, `api_deploy_cmd` and
  * `api_restore` all sit behind `/api/actions/<x>`, which needs the `JobManager` to route at
@@ -86,16 +84,17 @@
  * behaviour a 501 produces.
  *
  * ---------------------------------------------------------------------------------------
- * `api_install_toggle` IS DEFERRED, with its measurement.
- *
- * The endpoint is 27 lines over three engine calls. One of the three (`_install_uninstall`)
- * crossed in P5h. The other two pull in 293 lines of all-or-nothing tree moves with
- * rollback, a stash layout, an `instructions`-entry unmerge, a re-emit-while-disabled guard
- * and a host fork into `_claude_deactivate`/`_claude_reactivate`. None of it is web code and
- * none of it has a `harness` VERB — which is why P5 never reached it — and its gate is a
- * file-move fixture of the kind `harness_golden` is built for, not a request script. Porting
- * it inside a web phase would put the largest unported engine block behind the weakest
- * available gate. `/api/install` stays in `NOT_PORTED_POST`.
+ * `api_install_toggle` CROSSED IN P6i, AND THE ENGINE CAME WITH IT.
+ *
+ * The endpoint is 27 lines over three engine calls, and the reason it waited is worth
+ * keeping: two of the three pull in 293 lines of all-or-nothing tree moves with rollback, a
+ * stash layout, an `instructions`-entry unmerge, a re-emit-while-disabled guard and a host
+ * fork. None of that is web code, and porting it inside a web phase would have put the
+ * largest engine block behind the weakest available gate — a request script rather than a
+ * file-move fixture. So it landed where it belongs: `installDeactivate` and
+ * `installReactivate` live in `js/maintain/uninstall.mjs` beside `installUninstall`, the
+ * reversible siblings of the same owned-file walk, and `apiInstallToggle` below is the thin
+ * endpoint over them.
  */
 import {
   accessSync, constants, copyFileSync, mkdirSync, mkdtempSync, rmSync, statSync, unlinkSync,
@@ -103,29 +102,31 @@ import {
 import os from 'node:os';
 import path from 'node:path';
 
-import { emitGlobalInto } from '../../bin/geneseed.mjs';
-import { ROOT, discoverNames, PACK_ORDER } from '../checkout.mjs';
-import { withStdoutSwallowed } from '../diff.mjs';
-import { excludeAdd, excludeRemove } from '../excludes.mjs';
-import { setupBuildArgs } from '../generate.mjs';
-import { frontmatter, memoryDropIndex } from '../hooks.mjs';
+import { emitGlobalInto } from '../../bin/build-driver.mjs';
+import {
+  ROOT, discoverNames, knownRuleIds, PACK_ORDER,
+} from '../build/source.mjs';
+import { withStdoutSwallowed } from '../inspect/diff.mjs';
+import { excludeAdd, excludeRemove } from '../inspect/excludes.mjs';
+import { setupBuildArgs } from '../build/generate.mjs';
+import { frontmatter, memoryDropIndex } from '../hosts/hooks.mjs';
 import {
   HOSTS, bobConfigDir, claudeConfigDir, copilotConfigDir, expanduser, opencodeConfigDir,
-  pyResolve,
-} from '../hosts.mjs';
+  resolvePath,
+} from '../hosts/hosts.mjs';
 import {
-  EMIT_HOST_SCOPE, doctrinesForBuild, footprintOfDir, installState, installTargets, modeOfDir,
-  postureOfDir, readMaybe,
-} from '../installs.mjs';
+  EMIT_HOST_SCOPE, doctrinesForBuild, excludedRulesOfDir, footprintOfDir, installState,
+  installTargets, modeOfDir, postureOfDir, readMaybe,
+} from '../hosts/installs.mjs';
 import {
   MCP_PRESETS, isDict, mcpApply, mcpCommented, mcpInstallTargets, mcpKnownNames, mcpLoad,
   mcpMeta, mcpPresetBlock, mcpSave, mcpSetEnabled, mcpState,
-} from '../mcp.mjs';
-import {
-  PY_SPACE, parseJson, pyLen, pyRepr, pyStr, pyStripSpace, pyTruthy, readText, writeText,
-} from '../lib/fs.mjs';
-import { installDeactivate, installReactivate, installUninstall } from '../uninstall.mjs';
-import { pySplitLines } from '../lib/udiff.mjs';
+} from '../hosts/mcp.mjs';
+import { readText, writeText } from '../lib/fs.mjs';
+import { parseJson, formatRepr, formatValue, isTruthy } from '../lib/json.mjs';
+import { WHITESPACE, codePointLength, stripWhitespace } from '../lib/text.mjs';
+import { installDeactivate, installReactivate, installUninstall } from '../maintain/uninstall.mjs';
+import { splitLines } from '../lib/udiff.mjs';
 import {
   NotFound, deployed, emitChoices, fingerprint, themeChoices, viewCfg, within,
 } from './api.mjs';
@@ -138,7 +139,7 @@ const bget = (body, key, dflt = null) => (isDict(body) && Object.hasOwn(body, ke
   ? body[key] : dflt);
 
 /** `str(x or "")` — Python's truthiness, then Python's `str`. */
-const strOr = (v) => (pyTruthy(v) ? pyStr(v) : '');
+const strOr = (v) => (isTruthy(v) ? formatValue(v) : '');
 
 /**
  * A request body's `doctrines` -> a normalised pack list, or `null` for "said nothing usable".
@@ -170,8 +171,34 @@ function bodyDoctrines(body) {
   return PACK_ORDER.filter((p) => names.includes(p));
 }
 
+/**
+ * The SECOND doctrine axis across the same trust boundary — which individual rules to drop.
+ *
+ * Same shape and same reasons as `bodyDoctrines` above: a list closed member by member
+ * against what this checkout actually ships (`knownRuleIds`, the one enumerator the CLI flag
+ * uses too), re-ordered canonically because the `Excluded rules:` line it produces is a
+ * marker a later reader parses back out, and `null` on any rejection so the caller decides
+ * what "unspecified" means.
+ *
+ * Accepts `process 7` or `process.7` — the console sends the dotted address, and a curl by
+ * hand naturally writes the spelling the marker shows. `none`/`[]` is the deliberate empty
+ * selection: "exclude nothing", which is a real answer and NOT the same as not saying.
+ */
+function bodyExcludeRules(body) {
+  const raw = bget(body, 'excludeRules');
+  if (Array.isArray(raw) && !raw.length) return [];
+  const names = Array.isArray(raw) ? raw
+    : (typeof raw === 'string' ? raw.split(',').map((s) => s.trim()).filter(Boolean) : null);
+  if (names === null || !names.length) return null;
+  if (names.length === 1 && names[0] === 'none') return [];
+  const known = knownRuleIds();
+  const ids = names.map((n) => (typeof n === 'string' ? n.trim().replace(/[ \t]+/, '.') : n));
+  if (!ids.every((n) => typeof n === 'string' && known.includes(n))) return null;
+  return known.filter((id) => ids.includes(id));
+}
+
 /** `str.split()` with no argument — runs of PYTHON whitespace, no empties. */
-const pyWords = (s) => s.split(new RegExp(`[${PY_SPACE}]+`)).filter(Boolean);
+const splitWords = (s) => s.split(new RegExp(`[${WHITESPACE}]+`)).filter(Boolean);
 
 /** `datetime.date.today().isoformat()` — LOCAL, as the reference's naive `date.today()` is. */
 export function todayIso(d = new Date()) {
@@ -213,7 +240,7 @@ const rulesPath = (state) => path.join(state.target, RULES_FILE);
  * `_web_catalog.RULE_HEAD_RE` — `## R<n> — Title`, anchored at column 0 so a rule body's
  * fenced code and the stub's indented format example never parse as rules.
  *
- * The whitespace classes are `PY_SPACE`, not `\s`: P6d measured the two apart and this
+ * The whitespace classes are `WHITESPACE`, not `\s`: P6d measured the two apart and this
  * pattern runs over a HAND-EDITED file, which is where a non-breaking space actually turns
  * up. `\S` is its complement for the same reason.
  *
@@ -225,26 +252,26 @@ const rulesPath = (state) => path.join(state.target, RULES_FILE);
  * and the web editor cannot produce (it writes `R<n>` itself from `max(ids) + 1`).
  */
 export const RULE_HEAD_RE = new RegExp(
-  `^##[${PY_SPACE}]+R(\\d+)[${PY_SPACE}]*[—–-]+[${PY_SPACE}]*`
-  + `([^${PY_SPACE}].*?)[${PY_SPACE}]*$`,
+  `^##[${WHITESPACE}]+R(\\d+)[${WHITESPACE}]*[—–-]+[${WHITESPACE}]*`
+  + `([^${WHITESPACE}].*?)[${WHITESPACE}]*$`,
 );
 
 /** `_web_catalog.RULES_BUDGET` — advisory; nothing blocks past it. */
 export const RULES_BUDGET = { max_rules: 15, max_tokens: 1500 };
 
-const META_RE = new RegExp(`^\\((.+)\\)[${PY_SPACE}]*$`);
+const META_RE = new RegExp(`^\\((.+)\\)[${WHITESPACE}]*$`);
 
 /** `_web_catalog._parse_rule_meta` — `{}` when the line is body rather than metadata. */
 function parseRuleMeta(line) {
-  const m = META_RE.exec(pyStripSpace(line));
+  const m = META_RE.exec(stripWhitespace(line));
   if (!m) return {};
   const meta = {};
   for (const part of m[1].split('|')) {
     const at = part.indexOf(':');
     if (at < 0) continue;               // `partition` with no separator — not a pair
-    const key = pyStripSpace(part.slice(0, at)).toLowerCase().replaceAll(' ', '_');
+    const key = stripWhitespace(part.slice(0, at)).toLowerCase().replaceAll(' ', '_');
     if (['scope', 'source', 'trial_until'].includes(key)) {
-      meta[key] = pyStripSpace(part.slice(at + 1));
+      meta[key] = stripWhitespace(part.slice(at + 1));
     }
   }
   return meta;
@@ -258,7 +285,7 @@ function parseRuleMeta(line) {
  * formatting, hand-written sections — untouched.
  */
 export function parseRules(text) {
-  const lines = pySplitLines(text);
+  const lines = splitLines(text);
   const rules = [];
   const warnings = [];
   const seen = new Set();
@@ -273,7 +300,7 @@ export function parseRules(text) {
     if (seen.has(rid)) warnings.push(`duplicate rule id R${rid}`);
     seen.add(rid);
     let k = idx + 1;
-    while (k < end && !pyStripSpace(lines[k])) k += 1;
+    while (k < end && !stripWhitespace(lines[k])) k += 1;
     const meta = k < end ? parseRuleMeta(lines[k]) : {};
     if (Object.keys(meta).length) k += 1;
     rules.push({
@@ -282,7 +309,7 @@ export function parseRules(text) {
       scope: Object.hasOwn(meta, 'scope') ? meta.scope : 'project',
       source: Object.hasOwn(meta, 'source') ? meta.source : '',
       trial_until: Object.hasOwn(meta, 'trial_until') ? meta.trial_until : '',
-      body: pyStripSpace(lines.slice(k, end).join('\n')),
+      body: stripWhitespace(lines.slice(k, end).join('\n')),
       start: idx,
       end,
     });
@@ -310,8 +337,8 @@ export function apiRules(state) {
   return { exists: true, path: p, rules: out, warnings, fingerprint: fingerprint(text),
     // `len(text) // 4` — CODE POINTS. `String.length` counts UTF-16 units, so an emoji in a
     // rule body would put the two token estimates two apart.
-    stats: { rules: rules.length, lines: pySplitLines(text).length,
-      tokens: Math.floor(pyLen(text) / 4), ...RULES_BUDGET } };
+    stats: { rules: rules.length, lines: splitLines(text).length,
+      tokens: Math.floor(codePointLength(text) / 4), ...RULES_BUDGET } };
 }
 
 /** `_web_actions._rules_read`. */
@@ -325,7 +352,7 @@ function ruleBlock(rid, title, scope, source, trialUntil, body) {
   const meta = [`scope: ${scope}`];
   if (source) meta.push(`source: ${source}`);
   if (trialUntil) meta.push(`trial until: ${trialUntil}`);
-  return `## R${rid} — ${title}\n(${meta.join(' | ')})\n${pyStripSpace(body)}\n`;
+  return `## R${rid} — ${title}\n(${meta.join(' | ')})\n${stripWhitespace(body)}\n`;
 }
 
 /**
@@ -337,14 +364,14 @@ function ruleBlock(rid, title, scope, source, trialUntil, body) {
  * `int()`.
  */
 function ruleFields(body) {
-  const title = pyWords(strOr(bget(body, 'title'))).join(' ');
-  const text = pyStripSpace(strOr(bget(body, 'body')));
+  const title = splitWords(strOr(bget(body, 'title'))).join(' ');
+  const text = stripWhitespace(strOr(bget(body, 'body')));
   if (!title) throw new Error('a rule needs a title');
   if (!text) throw new Error('a rule needs body text');
   let scope = bget(body, 'scope');
   if (scope !== 'user' && scope !== 'project') scope = 'project';
-  const source = pyWords(strOr(bget(body, 'source'))).join(' ');
-  const trial = pyStripSpace(strOr(bget(body, 'trial_until')));
+  const source = splitWords(strOr(bget(body, 'source'))).join(' ');
+  const trial = stripWhitespace(strOr(bget(body, 'trial_until')));
   if (trial && !/^\p{Nd}{4}-\p{Nd}{2}-\p{Nd}{2}$/u.test(trial)) {
     throw new Error('trial until must be YYYY-MM-DD');
   }
@@ -360,7 +387,7 @@ function ruleFields(body) {
  */
 function ruleId(v) {
   if (typeof v === 'string') {
-    const s = pyStripSpace(v);
+    const s = stripWhitespace(v);
     if (!/^[+-]?\d+$/.test(s)) throw new NotFound('rule id');
     return Number(s);
   }
@@ -384,7 +411,7 @@ function ruleId(v) {
 export function apiRulesMutate(state, body) {
   const op = bget(body, 'op');
   if (op !== 'add' && op !== 'update' && op !== 'delete') {
-    throw new NotFound(`rules op ${pyRepr(op)}`);
+    throw new NotFound(`rules op ${formatRepr(op)}`);
   }
   const [p, original] = rulesRead(state);
   let text = original;
@@ -404,17 +431,17 @@ export function apiRulesMutate(state, body) {
     rid = ruleId(bget(body, 'id'));
     const target = rules.find((r) => r.id === rid);
     if (target === undefined) throw new NotFound(`rule R${rid}`);
-    const lines = pySplitLines(text);
+    const lines = splitLines(text);
     if (op === 'update') {
       const [title, rtext, scope, source, trial] = ruleFields(body);
       const block = ruleBlock(rid, title, scope, source, trial, rtext);
       lines.splice(target.start, target.end - target.start,
-        ...pySplitLines(block.replace(/\n+$/, '')));
+        ...splitLines(block.replace(/\n+$/, '')));
     } else {
       // delete — also swallow ONE preceding blank separator line, or repeated deletes leave
       // a growing run of blank lines in the user's file.
       let start = target.start;
-      if (start > 0 && !pyStripSpace(lines[start - 1])) start -= 1;
+      if (start > 0 && !stripWhitespace(lines[start - 1])) start -= 1;
       lines.splice(start, target.end - start);
     }
     next = `${lines.join('\n').replace(/\n+$/, '')}\n`;
@@ -447,14 +474,14 @@ export function apiRulesPromote(state, body) {
   const res = apiRulesMutate(state, {
     op: 'add',
     fingerprint: bget(body, 'fingerprint', ''),
-    title: pyTruthy(bget(body, 'title')) ? bget(body, 'title') : fmName,
-    body: pyTruthy(bget(body, 'body')) ? bget(body, 'body')
-      : (pyStripSpace(memBody) || fmDesc),
+    title: isTruthy(bget(body, 'title')) ? bget(body, 'title') : fmName,
+    body: isTruthy(bget(body, 'body')) ? bget(body, 'body')
+      : (stripWhitespace(memBody) || fmDesc),
     scope: bget(body, 'scope'),
     source: `memory ${name}, promoted ${today}`,
     trial_until: trial,
   });
-  if (pyTruthy(res.ok) && pyTruthy(bget(body, 'delete_memory'))) {
+  if (isTruthy(res.ok) && isTruthy(bget(body, 'delete_memory'))) {
     apiMemoryDelete(state, name);
     res.deleted_memory = name;
   }
@@ -520,7 +547,7 @@ export function apiMemoryDelete(state, name) {
  */
 export function apiExcludesMutate(state, body) {
   const action = bget(body, 'action');
-  const p = pyStripSpace(strOr(bget(body, 'path')));
+  const p = stripWhitespace(strOr(bget(body, 'path')));
   if ((action !== 'add' && action !== 'remove') || !p) {
     return { ok: false, path: p,
       messages: ['body must be {action: add|remove, path: <folder>}'] };
@@ -585,7 +612,7 @@ export function mcpTargetPaths() {
 
 export function apiMcpToggle(state, body) {
   const name = strOr(bget(body, 'name'));
-  const want = pyTruthy(bget(body, 'enabled'));
+  const want = isTruthy(bget(body, 'enabled'));
   const pathArg = strOr(bget(body, 'path'));
   const known = mcpTargetPaths();
   const hit = known.get(pathArg);
@@ -680,7 +707,7 @@ export function buildOverride(state, body) {
  * `.geneseed-emit`, so the EXPECTED render uses the install's own host dialect.
  *
  * Returns the HOST rather than a function, because `emitGlobalInto(host, …)` is how the twin
- * of `build.HOSTS[host]["emit_global"]` is already spelt (`js/diff.mjs` calls it that way).
+ * of `build.HOSTS[host]["emit_global"]` is already spelt (`js/inspect/diff.mjs` calls it that way).
  * An unknown or missing marker falls back to OpenCode, exactly as the reference's two
  * `.get(..., default)` calls do.
  */
@@ -721,10 +748,10 @@ export function apiRestore(state, files) {
   const restored = [];
   const deleted = [];
   const errors = [];
-  const target = pyResolve(state.target);
+  const target = resolvePath(state.target);
   const tmp = mkdtempSync(path.join(os.tmpdir(), 'geneseed-restore-'));
   try {
-    const expected = pyResolve(path.join(tmp, 'expected'));
+    const expected = resolvePath(path.join(tmp, 'expected'));
     withStdoutSwallowed(() => emitGlobalInto(globalEmitHostFor(state.emit), {
       theme: state.theme,
       out: path.join(tmp, 'bundle'),
@@ -740,10 +767,10 @@ export function apiRestore(state, files) {
       // read-side hole `diffCollect` had (and the reason the panel offered the file at all).
       doctrines: doctrinesForBuild(target),
     }));
-    for (const raw of (pyTruthy(files) ? files : [])) {
-      const rel = pyStripSpace(pyStr(raw).replace(/\\/g, '/')).replace(/^\/+/, '');
-      const dst = pyResolve(path.join(target, rel));
-      const src = pyResolve(path.join(expected, rel));
+    for (const raw of (isTruthy(files) ? files : [])) {
+      const rel = stripWhitespace(formatValue(raw).replace(/\\/g, '/')).replace(/^\/+/, '');
+      const dst = resolvePath(path.join(target, rel));
+      const src = resolvePath(path.join(expected, rel));
       if (!rel || !within(dst, target) || !within(src, expected)) {
         errors.push(`${rel}: outside the deployed tree`);
       } else if (isFile(src)) {
@@ -789,7 +816,7 @@ const EMIT_FOR = new Map([
  * `{cmd: [...]}` IS A RETURN TYPE, NOT A RESPONSE. `_post_routes` hands it straight to the job
  * runner in the same process; it never reaches the wire. That is what collapsed P6f's
  * "argv-in-a-response-body" question — see this file's header — and why the twin's head is
- * `process.execPath` + `bin/geneseed.mjs` rather than a Python argv it would then have to
+ * `process.execPath` + `bin/build-driver.mjs` rather than a Python argv it would then have to
  * pretend to run.
  */
 export function apiInstallCmd(state, body) {
@@ -825,9 +852,15 @@ export function apiInstallCmd(state, body) {
   // `null` elided the flag, and the generator's config fallback then narrowed the install and
   // took its consent gate with it. `doctrinesForBuild` resolves unknown to ALL packs.
   const doctrines = bodyDoctrines(body) ?? doctrinesForBuild(root);
+  // The per-rule axis needs NO `doctrinesForBuild`-style rescue: the marker it reads is only
+  // written when something is excluded, so its absence is a statement ("nothing") rather than
+  // the silence a pre-2.3 carrier gives on packs. Unspecified therefore keeps the install's
+  // own answer, and a pre-marker install answers the empty list — which is what it has.
+  const excludeRules = bodyExcludeRules(body) ?? excludedRulesOfDir(root);
   const out = scope === 'global' ? null : String(root);
-  const argv = setupBuildArgs(theme || 'neutral', emit, out, out, fp, pos, mode, doctrines);
-  return { cmd: [process.execPath, path.join(ROOT, 'bin', 'geneseed.mjs'), ...argv] };
+  const argv = setupBuildArgs(theme || 'neutral', emit, out, out, fp, pos, mode, doctrines,
+    PACK_ORDER, excludeRules);
+  return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }
 
 /**
@@ -848,7 +881,7 @@ export function apiInstallCmd(state, body) {
  * and this endpoint moves and deletes whole trees, so the root is never built from raw body
  * input. An unknown pair is a `NotFound`, which the shell answers 404.
  *
- * THE ENGINE IS `js/uninstall.mjs`'s, and P6i is what brought it. `installDeactivate` /
+ * THE ENGINE IS `js/maintain/uninstall.mjs`'s, and P6i is what brought it. `installDeactivate` /
  * `installReactivate` are the reversible siblings of `installUninstall` — the same owned-file
  * walk and ancestor prune with `move` where the reversal has `unlink` — which is why they live
  * beside it rather than in the web tree. `remove` is `installUninstall`, which crossed in P5h
@@ -875,26 +908,26 @@ export function apiInstallToggle(state, body) {
     // is validated IN THE ENGINE — an unknown value falls back to `keep`, never a surprise
     // delete, which is why a bogus body value is passed through rather than rejected here.
     const mem = bget(body, 'memory');
-    res = installUninstall(root, host, scope, pyTruthy(mem) ? mem : 'keep');
+    res = installUninstall(root, host, scope, isTruthy(mem) ? mem : 'keep');
   } else {
     // `{action!r}` — Python's repr, SINGLE-quoted. `JSON.stringify` would double-quote it
     // inside a JSON string body and the two sides would differ on every typo.
-    res = { ok: false, error: `unknown action ${pyRepr(action)}` };
+    res = { ok: false, error: `unknown action ${formatRepr(action)}` };
   }
   state.refresh();
   return res;
 }
 
 export function apiDeployCmd(state, body) {
-  const host = pyStripSpace(strOr(bget(body, 'host')));
+  const host = stripWhitespace(strOr(bget(body, 'host')));
   if (!HOSTS.some((h) => h.host === host)) {
     return { error: `unknown host: ${host || '(none)'}` };
   }
-  const raw = pyStripSpace(strOr(bget(body, 'path')));
+  const raw = stripWhitespace(strOr(bget(body, 'path')));
   if (!raw) return { error: 'no folder given' };
   let root;
   try {
-    root = pyResolve(expanduser(raw));
+    root = resolvePath(expanduser(raw));
   } catch {
     return { error: `bad path: ${raw}` };
   }
@@ -907,7 +940,7 @@ export function apiDeployCmd(state, body) {
   const cfgdirs = new Set();
   for (const fn of [opencodeConfigDir, claudeConfigDir, bobConfigDir, copilotConfigDir]) {
     try {
-      cfgdirs.add(pyResolve(fn()));
+      cfgdirs.add(resolvePath(fn()));
     } catch { /* the reference's bare `except: pass` */ }
   }
   if (cfgdirs.has(root)) {
@@ -929,7 +962,9 @@ export function apiDeployCmd(state, body) {
   // existing all-four Claude install dropped it to one pack — measured: 6 hook groups became 5
   // and `PreToolUse::Bash` went with them. `doctrinesForBuild` resolves unknown to ALL packs.
   const doctrines = bodyDoctrines(body) ?? doctrinesForBuild(root);
+  const excludeRules = bodyExcludeRules(body) ?? excludedRulesOfDir(root);
   // project-scope emit name == host name (opencode / claude / bob / copilot)
-  const argv = setupBuildArgs(theme || 'neutral', host, root, root, fp, pos, mode, doctrines);
-  return { cmd: [process.execPath, path.join(ROOT, 'bin', 'geneseed.mjs'), ...argv] };
+  const argv = setupBuildArgs(theme || 'neutral', host, root, root, fp, pos, mode, doctrines,
+    PACK_ORDER, excludeRules);
+  return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }

package/js/web/activity.mjs

@@ -1,5 +1,5 @@
 /**
- * `rituals/_web_activity.py` — the live-activity surface, and the first web endpoint that
+ * The live-activity surface — the one web endpoint that
  * DELETES.
  *
  * It reads the per-session JSON files the `geneseed-activity` OpenCode plugin writes into
@@ -7,11 +7,11 @@
  * directory self-cleans), and returns what is left. Writer and reader share only that
  * directory: no RPC, crash-isolated, and cross-tool by construction.
  *
- * ONLY THE GET HALF CROSSES IN P6e. `/api/activity` answers both verbs and
- * `api_activity_toggle` is a WRITE, so the path stays in `NOT_PORTED_POST` and the
- * partition test in `tests/test_web_server.py` keeps that honest. The consequence for the
- * gate is that the on/off flag can be READ but never flipped, which is why its two arms are
- * two cells rather than two requests in one.
+ * BOTH VERBS CROSS. `/api/activity` answers a GET through `apiActivity` and a POST through
+ * `apiActivityToggle` at the bottom of this file; `NOT_PORTED_POST` is empty and still
+ * declared. It is also the one POST route whose result is sent at 200 whatever `ok` says,
+ * which is why `POST_ROUTES` in `js/web/routes.mjs` carries a 409 COLUMN rather than a rule —
+ * and giving this row the 409 treatment is mutation M22.
  *
  * THE PLAN GUESSED `tasklist` AND THE SOURCE SAYS OTHERWISE. `_win_pid_alive` shells
  * nothing: it goes through `ctypes` to `OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION)` and
@@ -33,16 +33,17 @@
  * a third party and carry `cost` — a float. Python's `json.loads` types `1.0` a float and
  * `json.dumps` writes it back `1.0`; `JSON.parse` gives a bare `1` that `bareInts` then
  * renders `1`. `parseJson`'s wrapper is the only thing that survives the round trip, and
- * `s-live`'s `"cost": 1.0` is the cell that says so. Its companion is `pyTruthy`: an
+ * `s-live`'s `"cost": 1.0` is the cell that says so. Its companion is `isTruthy`: an
  * `entry.get("cost") or 0` over a wrapper object is TRUE for a wrapped zero, where Python's
  * `0.0 or 0` is the int `0` — so `s-older`'s `"cost": 0.0` must come back `0` and not `0.0`.
  */
 import { mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
 
-import {
-  normcase, parseJson, pyInt, pyStripSpace, pyTruthy, readText, writeText,
-} from '../lib/fs.mjs';
+import { readText, writeText } from '../lib/fs.mjs';
+import { parseJson, isTruthy } from '../lib/json.mjs';
+import { normcase } from '../lib/paths.mjs';
+import { parseIntStrict, stripWhitespace } from '../lib/text.mjs';
 import { NotFound } from './api.mjs';
 
 /**
@@ -86,7 +87,7 @@ export function activityEnabled(state) {
   } catch {
     return true;
   }
-  return !['off', '0', 'false', 'no'].includes(pyStripSpace(raw).toLowerCase());
+  return !['off', '0', 'false', 'no'].includes(stripWhitespace(raw).toLowerCase());
 }
 
 /**
@@ -99,10 +100,10 @@ export function activityEnabled(state) {
  * what `int({})` and `int([])` raising looks like from here. `int(1.9)` truncates and
  * `int(True)` is 1, both of which a hand-edited snapshot can produce.
  */
-function pyIntOf(raw) {
+function toIntOr(raw) {
   if (raw === true) return 1;
   if (raw === false) return 0;
-  if (typeof raw === 'string') return pyInt(pyStripSpace(raw));
+  if (typeof raw === 'string') return parseIntStrict(stripWhitespace(raw));
   const n = (raw !== null && typeof raw === 'object' && !Array.isArray(raw))
     ? raw.valueOf() : raw;
   if (typeof n !== 'number' || !Number.isFinite(n)) return null;
@@ -111,7 +112,7 @@ function pyIntOf(raw) {
 
 /** `_pid_alive` — best-effort liveness for the writer process. See this file's header. */
 export function pidAlive(raw) {
-  const pid = pyIntOf(raw);
+  const pid = toIntOr(raw);
   if (pid === null || pid <= 0) return false;
   try {
     process.kill(pid, 0);
@@ -131,7 +132,7 @@ export function pidAlive(raw) {
  */
 function normalizeEntry(entry, stem) {
   const g = (k) => (Object.hasOwn(entry, k) ? entry[k] : null);
-  const or = (k, dflt) => (pyTruthy(g(k)) ? g(k) : dflt);
+  const or = (k, dflt) => (isTruthy(g(k)) ? g(k) : dflt);
   return {
     session_id: or('session_id', stem),
     agent: g('agent'),
@@ -164,7 +165,7 @@ function readEntry(p) {
 
 /** `_is_live` — the writer's pid is alive AND the snapshot is not stale. */
 function isLive(entry, now) {
-  const updated = pyTruthy(Object.hasOwn(entry, 'updated_at') ? entry.updated_at : null)
+  const updated = isTruthy(Object.hasOwn(entry, 'updated_at') ? entry.updated_at : null)
     ? entry.updated_at : 0;
   return (now - Number(updated)) <= ACTIVITY_STALE_SECONDS && pidAlive(
     Object.hasOwn(entry, 'pid') ? entry.pid : null);
@@ -236,7 +237,7 @@ export function apiActivityDetail(state, sid) {
   let timeline = [];
   let full = {};
   const det = readEntry(path.join(d, `${stem}.detail.json`));
-  if (pyTruthy(det)) {
+  if (isTruthy(det)) {
     const tl = Object.hasOwn(det, 'timeline') ? det.timeline : null;
     timeline = Array.isArray(tl) ? tl : [];
     full = det;
@@ -245,14 +246,14 @@ export function apiActivityDetail(state, sid) {
   // The detail file carries the uncapped lists; fall back to the snapshot's capped ones.
   // Assigning over an existing key keeps its POSITION in both languages, which is what lets
   // the response stay byte-comparable.
-  session.files = pyTruthy(fg('files')) ? fg('files') : session.files;
-  session.todos = pyTruthy(fg('todos')) ? fg('todos') : session.todos;
+  session.files = isTruthy(fg('files')) ? fg('files') : session.files;
+  session.todos = isTruthy(fg('todos')) ? fg('todos') : session.todos;
   // The compact transcript: an ordered list of {role, text, t} turns. Empty falls back to
   // the title as the opening user turn, because OpenCode derives the title from the first
   // prompt.
   const conv = fg('conversation');
   let conversation = Array.isArray(conv) ? conv : [];
-  if (conversation.length === 0 && pyTruthy(session.title)) {
+  if (conversation.length === 0 && isTruthy(session.title)) {
     conversation = [{ role: 'user', text: session.title }];
   }
   return { session, timeline, conversation };
@@ -272,7 +273,7 @@ export function apiActivityDetail(state, sid) {
  */
 export function apiActivityToggle(state, body) {
   const raw = (body && Object.hasOwn(body, 'enabled')) ? body.enabled : true;
-  const enabled = pyTruthy(raw);
+  const enabled = isTruthy(raw);
   const p = activityFlag(state);
   try {
     mkdirSync(path.dirname(p), { recursive: true });