geneseed 3.3.0 → 3.5.0

package/js/hosts/settings.mjs

@@ -90,18 +90,22 @@ const consentRuleOn = (d, excluded = []) =>
  * doctrine section — and a boundary that keeps asking for a rule the install did not adopt is
  * the one disagreement the tiering is not allowed to produce. (It does NOT follow that the
  * string is gone from the bundle; see `claudeHookGroups` for what D5 ships anyway and why.)
- * `rm -rf *`, `git push --force*` and `git push -f*` stay in EVERY build: they are
- * Law IV's territory — an always-on invariant — not the process pack's, and the guard
- * plugin's own force-push arm is unconditional for the same reason.
+ * `rm -rf *`, the force pushes and the history-discarding git verbs (`reset --hard`,
+ * `clean -f`, `branch -D`, `checkout --`) stay in EVERY build: they are Law IV's territory —
+ * an always-on invariant — not the process pack's. They mirror `DESTRUCTIVE_GIT_RE` in
+ * js/hosts/hooks.mjs, so Claude's git-gate and OpenCode's permission ask about the same acts;
+ * before, OpenCode only logged the last four.
  */
+const LAW_IV_BASH = ['git push --force*', 'git push -f*', 'git reset --hard*', 'git clean -f*',
+  'git branch -D*', 'git checkout -- *'];
+
 function defaultPermission(doctrines = null, excluded = []) {
   const bash = { 'rm -rf *': 'ask' };
   if (consentRuleOn(doctrines, excluded)) {
     bash['git commit*'] = 'ask';
     bash['git push*'] = 'ask';
   }
-  bash['git push --force*'] = 'ask';
-  bash['git push -f*'] = 'ask';
+  for (const k of LAW_IV_BASH) bash[k] = 'ask';
   return { bash };
 }
 
@@ -112,7 +116,7 @@ function defaultPermission(doctrines = null, excluded = []) {
  * has to be able to recognise a key that is Geneseed's business at all — to add it back when
  * the pack returns, and to name it when this build no longer wants it but will not remove it.
  */
-const OWNED_BASH = ['rm -rf *', 'git commit*', 'git push*', 'git push --force*', 'git push -f*'];
+const OWNED_BASH = ['rm -rf *', 'git commit*', 'git push*', ...LAW_IV_BASH];
 
 /**
  * Bring an ALREADY-WRITTEN `permission` block back into line with the pack selection, and
@@ -639,15 +643,16 @@ export function hookPrefix({ runner, entry, platform = process.platform } = {})
 /**
  * `_build_settings._claude_hook_groups` — Geneseed's Claude hooks, keyed by event.
  *
- * ⚠ `doctrines` IS WHERE PROMPT AND BOUNDARY ARE KEPT IN AGREEMENT. The `git-gate` group is
- * the tool-boundary half of doctrine process 5. With the process pack off, that rule is no
- * longer BINDING — `src/doctrines/process.md` is not rendered into the carrier's doctrine
- * section and nothing in the constitution obliges the agent to it — so a gate that stopped
- * every Bash call to ask for consent to a rule the install did not adopt is the disagreement
- * the three-tier split forbids. Omitting the group here is also what UNWIRES it from an
- * install that had it: `mergeClaudeSettings` prunes every previously-managed group that is not
- * in this return value, so flipping the pack off and rebuilding takes the hook out of
- * settings.json rather than leaving it orphaned.
+ * ⚠ `doctrines` IS WHERE PROMPT AND BOUNDARY ARE KEPT IN AGREEMENT. The `git-gate` group
+ * carries TWO rules: Law IV (destructive git — universal, every build) and doctrine process 5
+ * (consent before commit/push). With the process pack off, or process 5 excluded, that second
+ * rule is no longer BINDING — so a gate that stopped every commit to ask for consent to a rule
+ * the install did not adopt is the disagreement the three-tier split forbids. The group stays
+ * and gains `--no-consent`, which skips only the process-5 branch. It once DROPPED the whole
+ * group instead, and Law IV went with it — on Claude only, since Bob and Copilot carry it
+ * through `tool-gate`. The command changing is also what re-wires an existing install:
+ * `mergeClaudeSettings` prunes every previously-managed group that is not in this return
+ * value.
  *
  * ⚠ WHAT THIS DOES **NOT** CLAIM, because it was written here once and it was false: that the
  * string `process 5` is absent from a pack-off bundle. It is not — 18 emitted files still cite
@@ -695,14 +700,29 @@ export function claudeHookGroups(cfg, hookOpts, doctrines = null, excluded = [],
       Stop: [{ hooks: [{ type: 'command', command: `${run} learn ${mem} || exit 0` }] }],
     };
   }
+  if (host === 'copilot') {
+    // COPILOT'S OWN SCHEMA (docs.github.com/en/copilot/reference/hooks-configuration): camelCase
+    // events, each an ARRAY of `{type: "command", command}` entries — no matcher groups, so the
+    // array elements ARE the groups this merge appends and prunes. `preToolUse` answers with
+    // a top-level `permissionDecision` (`--host copilot`), and `agentStop`/`preCompact` carry
+    // `transcriptPath`, so `learn` runs here as on Claude. No matcher, so `tool-gate` reads
+    // the payload's shape. Unverified live: no Copilot CLI on the authoring machine.
+    const c = ' --host copilot';
+    const entry = (command) => [{ type: 'command', command }];
+    return {
+      sessionStart: entry(`${run} context --root "${cfg}"${c} || exit 0`),
+      preToolUse: entry(`${run} tool-gate --root "${cfg}"${c}`),
+      agentStop: entry(`${run} learn ${mem} || exit 0`),
+      preCompact: entry(`${run} learn ${mem} || exit 0`),
+    };
+  }
   const context = `${run} context --root "${cfg}" || exit 0`;
-  const gate = `${run} git-gate --root "${cfg}"`;
+  const gate = `${run} git-gate --root "${cfg}"${consentRuleOn(doctrines, excluded) ? '' : ' --no-consent'}`;
   const ruleGate = `${run} rule-gate --root "${cfg}"`;
   const learn = `${run} learn ${mem} || exit 0`;
   return {
     PreToolUse: [
-      ...(consentRuleOn(doctrines, excluded)
-        ? [{ matcher: 'Bash', hooks: [{ type: 'command', command: gate }] }] : []),
+      { matcher: 'Bash', hooks: [{ type: 'command', command: gate }] },
       {
         matcher: 'Write|Edit|MultiEdit|NotebookEdit',
         hooks: [{ type: 'command', command: ruleGate }],
@@ -731,90 +751,11 @@ export function claudeHookGroups(cfg, hookOpts, doctrines = null, excluded = [],
 }
 
 /**
- * Geneseed's Copilot hooks, keyed by Copilot's event names.
- *
- * COPILOT'S SETTINGS ARE NOT CLAUDE'S. `~/.copilot/settings.json` carries `hooks` as a map of
- * event → ONE `{command, shell?, timeout?}` object, not event → list of matcher groups, so
- * nothing in `claudeHookGroups`/`mergeClaudeSettings` can be reused for it: there is no
- * array to append to, and a second Geneseed group per event is not expressible. Two hooks:
- *
- *   * `sessionStart` → `context --host copilot`: the same project-context injection Claude
- *     gets, in Copilot's `{"additionalContext"}` envelope.
- *   * `toolCall` → `tool-gate --host copilot`: both gates behind the one command the event
- *     allows, block-only for Laws I/IV, warn for the rest (js/hosts/hooks.mjs's header).
- *
- * No `sessionEnd`/`agentStop` → `learn`: Copilot's payloads for those carry no
- * `transcript_path`, so `learn` would have nothing to distil. The memory write-back stays on
- * the preamble for this host, as before.
- *
- * `|| exit 0` on the non-gate, as in `claudeHookGroups` and for the same reason.
- */
-export function copilotHooks(cfg, hookOpts) {
-  const run = hookPrefix(hookOpts);
-  return {
-    sessionStart: { command: `${run} context --root "${cfg}" --host copilot || exit 0` },
-    toolCall: { command: `${run} tool-gate --root "${cfg}" --host copilot` },
-  };
-}
-
-/**
- * Wire Copilot's hooks into `p` — returns the complete current claim set, `[{event, hook}]`.
- *
- * ONE SLOT PER EVENT MEANS A FOREIGN HOOK CANNOT BE JOINED, ONLY DISPLACED — and displacing
- * a hook the user wrote is not Geneseed's to do. A slot is taken when it holds a hook that
- * is neither canonical nor a claim recorded by a previous emit; that event is skipped with a
- * warning and never claimed. A recorded stale claim (a moved shim) is replaced, as the Claude
- * merge prunes stale groups. Comments in the file mean it is not rewritten, as everywhere.
+ * LEGACY: the single-slot Copilot shape (`hooks.<event>` = ONE object, events `sessionStart` /
+ * `toolCall`) an emit wrote before Copilot's hooks became event → array. Copilot has no
+ * `toolCall` event any more, so those gates never ran. Nothing writes this shape now; these
+ * two only take an older install's recorded `copilot_hooks` claims back out.
  */
-export function mergeCopilotSettings(p, priorHooks = null, hookOpts = {}) {
-  const prior = (priorHooks || []).filter(isDict);
-  let config = {};
-  let hadComments = false;
-  if (existsSync(p)) {
-    try {
-      const [loaded, hc] = readJsonc(readText(p));
-      hadComments = hc;
-      if (isDict(loaded)) config = loaded;
-    } catch (e) {
-      if (!isOsError(e)) throw e;
-    }
-  }
-  let hooks = get(config, 'hooks');
-  if (!isDict(hooks)) hooks = {};
-  const canonical = copilotHooks(path.dirname(p), hookOpts);
-  const claims = [];
-  let changed = false;
-  for (const [event, hook] of Object.entries(canonical)) {
-    const cur = get(hooks, event);
-    const recorded = prior.find((r) => get(r, 'event') === event);
-    if (isDict(cur) && deepEquals(cur, hook)) { claims.push({ event, hook }); continue; }
-    if (isDict(cur) && !(recorded && deepEquals(recorded.hook, cur))) {
-      process.stderr.write(`[geneseed] ${path.basename(p)}: hooks.${event} is already set and `
-        + 'is not Geneseed\'s — left alone, so this event is not wired.\n');
-      continue;
-    }
-    hooks[event] = hook;
-    claims.push({ event, hook });
-    changed = true;
-  }
-  // A recorded claim whose event is no longer canonical: unwire it, or it fires forever.
-  for (const rec of prior) {
-    const event = get(rec, 'event');
-    if (event in canonical) continue;
-    if (deepEquals(get(hooks, event), get(rec, 'hook'))) { delete hooks[event]; changed = true; }
-  }
-  if (!changed) return [p, claims];
-  if (hadComments) {
-    process.stderr.write(`[geneseed] ${path.basename(p)} has comments — not rewriting it `
-      + "(your edits are kept). Add Geneseed's hooks by hand from adapters/copilot/README.md.\n");
-    return [p, prior];
-  }
-  if (Object.keys(hooks).length) config.hooks = hooks;
-  else delete config.hooks;
-  atomicWriteJson(p, config);
-  return [p, claims];
-}
-
 /** Remove exactly the recorded Copilot hooks from `p`. True when the file was rewritten. */
 export function unwireCopilotSettings(p, recorded) {
   if (!existsSync(p) || !recorded || !recorded.length) return false;
@@ -876,9 +817,15 @@ export function copilotIntegrityCheck(p, recorded, expect = 'present') {
  * `managed` is the complete current claim set, so unwire removes exactly those.
  *
  * `scope` is accepted and unused, exactly as in the Python.
+ *
+ * `cfgDir` is the install's own dir — what the hooks carry as `--root` and under which
+ * `memory/` lives. It is NOT always `dirname(p)`: Bob's global settings file is nested
+ * (`~/.bob/settings/settings.json`), and deriving the root from it pointed every global Bob
+ * hook at `~/.bob/settings` — memory learned where nothing reads it, excludes missed, and a
+ * global that never stood down for a project install.
  */
 export function mergeClaudeSettings(p, _scope = 'global', priorHooks = null, hookOpts = {},
-  doctrines = null, excluded = [], host = 'claude') {
+  doctrines = null, excluded = [], host = 'claude', cfgDir = path.dirname(p)) {
   const prior = (priorHooks || []).filter(isDict);
   let config = {};
   let hadComments = false;
@@ -898,7 +845,7 @@ export function mergeClaudeSettings(p, _scope = 'global', priorHooks = null, hoo
   }
   let hooks = get(config, 'hooks');
   if (!isDict(hooks)) hooks = {};
-  const canonical = claudeHookGroups(path.dirname(p), hookOpts, doctrines, excluded, host);
+  const canonical = claudeHookGroups(cfgDir, hookOpts, doctrines, excluded, host);
   const canonFlat = [];
   for (const [event, groups] of Object.entries(canonical)) {
     for (const g of groups) canonFlat.push({ event, group: g });
@@ -1231,7 +1178,8 @@ export function settingsIntegrityCheck(p, managed, expect = 'present') {
   for (const [event, group] of presentGroups) {
     const key = `${formatRepr(event)}\u0000${jsonDumpsCompact(group, { sortKeys: true })}`;
     if (recordedSet.has(key)) continue;
-    const cmds = (get(group, 'hooks') || []).filter(isDict)
+    // A Claude group nests its commands under `hooks`; a Copilot entry IS the command.
+    const cmds = [...(get(group, 'hooks') || []).filter(isDict), group]
       .map((h) => (has(h, 'command') ? h.command : ''));
     if (cmds.some((c) => typeof c === 'string'
       && GENESEED_HOOK_SNIFF.some((mk) => c.includes(mk)))) {

package/js/inspect/checks-authoring.mjs

@@ -279,6 +279,91 @@ const DOCTRINE_CITE_RE = /\{\{DOCTRINE\}\}\s+([a-z]+)\s+(\d+)/g;
 const DOCTRINE_TOKEN_RE = /\{\{DOCTRINE\}\}/;
 const DOC_TOKEN_RE = /\{\{(DOC_[A-Z0-9_]+)\}\}/g;
 
+/**
+ * The LEAN block grammar, and the heading split, both duplicated from `js/build/render.mjs`.
+ *
+ * Deliberately duplicated, the way `DOCTRINE_HEADING_RE` above is: both are module-private
+ * there, and exporting them so one gate could borrow them would widen the renderer's surface
+ * for a reader that only needs to know the shape. Two literals, one paragraph apart from the
+ * rule they encode, is cheaper than a seam.
+ */
+const LEAN_BLOCK_RE =
+  /[ \t]*<!-- LEAN:begin -->\n([\s\S]*?)[ \t]*<!-- LEAN:else -->\n([\s\S]*?)[ \t]*<!-- LEAN:end -->\n/g;
+
+/** `### ` at line start — the same cut `splitAtLawHeadings` makes, and for the same addresses. */
+function leanRuleBlocks(text) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if ((i === 0 || text[i - 1] === '\n') && text.startsWith('### ', i)) {
+      out.push(text.slice(start, i));
+      start = i;
+    }
+  }
+  out.push(text.slice(start));
+  return out.slice(1);                        // drop the lead chunk: the file's preamble
+}
+
+/**
+ * Every authored rule carries exactly one LEAN block, and both halves say something.
+ *
+ * ⚠ `resolveLean` IS A REPLACE OVER A MARKER PAIR, WHICH MAKES IT A NO-OP ON MARKERLESS TEXT.
+ * A rule whose block was never written, or lost to an edit, therefore ships its FULL body at
+ * the default footprint — silently, in every install, with every other gate in the tree green.
+ * That is the failure this arm exists for, and before it there was no LEAN gate anywhere in
+ * `js/inspect/`: not for the doctrine packs, and not for the invariants either.
+ *
+ * The other two shapes are cheaper to state than to debug. An empty lean half renders a
+ * heading over nothing at the footprint most installs use. Two blocks in one rule are
+ * ambiguous by construction — `LEAN_BLOCK_RE` is global, so both would resolve, and which
+ * text the reader gets would be a fact about the order they were written in.
+ *
+ * The ontology is exempt on purpose: it carries ONE file-wide block whose halves each repeat
+ * the four `####` section headings, which is a different shape with its own gate in
+ * `tests/unit/emit_smoke.test.mjs` (four distinct names, eight occurrences).
+ */
+export function leanBlockProblems() {
+  const problems = [];
+  const files = [['laws', path.join(SRC, 'laws', 'universal.md')]];
+  for (const pack of PACK_ORDER) files.push(['doctrines', path.join(SRC, 'doctrines', `${pack}.md`)]);
+
+  for (const [dir, file] of files) {
+    const rel = `${dir}/${path.basename(file)}`;
+    let text;
+    try { text = readText(file); } catch (e) {
+      problems.push(`[authoring] ${rel} unreadable: ${e.message} — every rule in it would ship `
+        + 'its full body at the lean footprint, unannounced');
+      continue;
+    }
+    for (const block of leanRuleBlocks(text)) {
+      // The address as the SOURCE spells it — `{{LAW}} II`, `{{DOCTRINE}} craft 1` — because
+      // that is the string an author greps for, and the rendered spelling is fourteen strings.
+      const heading = block.slice(0, block.indexOf('\n') === -1 ? undefined : block.indexOf('\n'));
+      const addr = heading.replace(/^###\s+/, '').split(/\s+[—-]\s+/)[0].trim();
+      const found = [...block.matchAll(LEAN_BLOCK_RE)];
+      if (found.length === 0) {
+        problems.push(`[authoring] ${rel}: ${addr} has no LEAN block — resolveLean is a no-op on `
+          + 'markerless text, so the rule would inline its FULL body at the default footprint');
+        continue;
+      }
+      if (found.length > 1) {
+        problems.push(`[authoring] ${rel}: ${addr} has ${found.length} LEAN blocks — both resolve, `
+          + 'so which text a reader is handed is a fact about the order they were written in');
+      }
+      const [, full, lean] = found[0];
+      if (!full.trim()) {
+        problems.push(`[authoring] ${rel}: ${addr} has an empty full half — the rule would vanish `
+          + 'from a full build and from its own on-disk file');
+      }
+      if (!lean.trim()) {
+        problems.push(`[authoring] ${rel}: ${addr} has an empty lean half — the rule would render `
+          + 'as a heading over nothing at the footprint most installs use');
+      }
+    }
+  }
+  return problems;
+}
+
 /**
  * The three-tier constitution's own authoring gates — the doctrine twin of the `LAW_CLASS` /
  * `LAW_META` family, plus the two purity rules the tiering rests on.
@@ -292,7 +377,7 @@ const DOC_TOKEN_RE = /\{\{(DOC_[A-Z0-9_]+)\}\}/g;
  * ⚠ THE VOCABULARY GATES ARE HERE BECAUSE `themeParityProblems` CANNOT SEE THEM. That check is
  * presence-only and SYMMETRIC over the union of every theme's keys: a key missing from all
  * fourteen is in parity, and a key whose VALUE breaks a parser is not its business at all. So
- * `DOC_*` coverage, the `LEX_I..LEX_IX` equality and the single-word tier noun each need a gate
+ * `DOC_*` coverage, the `LEX_I..LEX_XI` equality and the single-word tier noun each need a gate
  * that reads the SOURCE and asks what the source requires.
  */
 export function constitutionProblems() {
@@ -378,6 +463,18 @@ export function constitutionProblems() {
   // The whole tree, not the template: a skill footer citing `process 9` is as broken as a
   // template one, and it is the shape 339 rewired citations could have left behind.
   const cited = new Map();                                    // 'process.5' -> [rel, …]
+  // ⚠ A RETIRED LAW KEEPS ITS NUMBER, SO A CITATION OF IT STILL RESOLVES — to "Retired". Laws
+  // are appended, never renumbered, which is what keeps ~150 cross-references stable; the price
+  // is that nothing else notices `{{LAW}} IX` in a skill that means "ask first" (it is rigor 5
+  // now) or `{{LAW}} XI` that means "verify" (folded into III). Read off the canon itself, so a
+  // law retired tomorrow is covered the same day.
+  const retired = new Set();
+  try {
+    for (const [, num] of readText(path.join(SRC, 'laws', 'universal.md'))
+      .matchAll(/^### \{\{LAW\}\} ([IVXLCDM]+) —[^\n]*\n<!-- LEAN:begin -->\nRetired\b/gm)) {
+      retired.add(num);
+    }
+  } catch { /* an unreadable canon is reported elsewhere */ }
   for (const p of rglob(SRC)) {
     if (!isFile(p) || !(p.endsWith('.md') || p.endsWith('.tmpl'))) continue;
     let text;
@@ -392,6 +489,14 @@ export function constitutionProblems() {
         + 'reference a toggleable one, or a pack-off build ships a rule pointing at text '
         + 'that is not there. State the point directly instead');
     }
+    if (rel !== 'laws/universal.md') {
+      for (const [, num] of text.matchAll(/\{\{LAW\}\}\s+([IVXLCDM]+)\b/g)) {
+        if (retired.has(num)) {
+          problems.push(`[authoring] ${rel} cites {{LAW}} ${num}, which is retired — cite the `
+            + 'law or rule its text now lives in');
+        }
+      }
+    }
     for (const [, pack, n] of text.matchAll(DOCTRINE_CITE_RE)) {
       const key = `${pack}.${Number(n)}`;
       if (!cited.has(key)) cited.set(key, []);
@@ -583,9 +688,17 @@ export function countTableProblems() {
   }
   problems.push(...lawMetaProblems(lawNums, LAW_CLASS, LAW_CLASSES));
 
+  // WHAT SHIPS, NOT WHAT IS FLAT. A folder skill (`src/skills/<name>/SKILL.md`, vendored with
+  // its scripts or references) ships exactly like a flat one, so the badge, the README list and
+  // the SHIPPED.md triple count it. It is added HERE rather than in `srcStems`, whose other
+  // readers above — the AGENT.md table links and SKILL_CLASS — are about flat specs only.
+  const skillsDir = path.join(SRC, 'skills');
+  const shippedSkills = new Set([...skillFiles, ...(isDir(skillsDir) ? readdirSync(skillsDir) : [])
+    .filter((d) => !d.startsWith('_') && isFile(path.join(skillsDir, d, 'SKILL.md')))]);
+
   const counts = {
     agents: srcStems('agents').size,
-    skills: srcStems('skills').size,
+    skills: shippedSkills.size,
     laws: lawNums.length,
     themes: themeFiles().length,
     // Last on purpose: the badge loop below walks this object in insertion order and the
@@ -656,7 +769,7 @@ export function countTableProblems() {
     problems.push('[authoring] SHIPPED.md carries no \'N laws, N agents, N skills\' line — '
       + 'deleting it is how that gate goes green while the count drifts');
   }
-  problems.push(...proseMirrorProblems(readme, web, counts, skillFiles, shipped));
+  problems.push(...proseMirrorProblems(readme, web, counts, shippedSkills, shipped));
   return problems;
 }
 
@@ -756,6 +869,7 @@ export function authoringProblems() {
   problems.push(...secretProblems());
   problems.push(...vendorPinProblems());
   problems.push(...constitutionProblems());
+  problems.push(...leanBlockProblems());
   problems.push(...countTableProblems());
   return problems;
 }

package/js/inspect/diff.mjs

@@ -40,7 +40,7 @@ import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } fro
 import os from 'node:os';
 import path from 'node:path';
 
-import { emitGlobalInto } from '../../bin/build-driver.mjs';
+import { emitGlobalInto } from '../build/driver.mjs';
 import { GLOBAL_MANIFEST, VERSION_MARKER, expanduser, opencodeConfigDir } from '../hosts/hosts.mjs';
 import {
   EMIT_HOST_SCOPE, defaultTheme, doctrinesForBuild, footprintOfDir, modeOfDir, postureOfDir,

package/js/inspect/doctor.mjs

@@ -30,7 +30,7 @@
  * 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 { emitGlobalInto, emitProjectInto, main as driverMain } from '../build/driver.mjs';
 import { ROOT } from '../build/source.mjs';
 import { resolvePath } from '../hosts/hosts.mjs';
 import { installedDefaults, themeFiles } from '../hosts/installs.mjs';

package/js/inspect/excludes.mjs

@@ -244,7 +244,7 @@ export function cmdExclude(args) {
     for (const rec of snap.excludes) {
       const missing = [...allHosts].filter((h) => !rec.hosts.includes(h)).sort();
       const flag = missing.length
-        ? `  (MISSING from: ${missing.join(', ')} — re-run \`harness exclude add\`)` : '';
+        ? `  (MISSING from: ${missing.join(', ')} — re-run \`geneseed exclude add\`)` : '';
       printOut(`  ${rec.path}  [${rec.hosts.slice().sort().join(', ')}]${flag}\n`);
     }
     return 0;

package/js/inspect/inventory.mjs

@@ -90,21 +90,26 @@ export const LAW_CLASSES = ['security', 'process', 'verify', 'craft', 'context',
 
 /** `_harness_tui.SKILL_CLASS` — each skill's category, keyed by file stem. */
 export const SKILL_CLASS = {
-  brainstorm: 'design', clarify: 'design', plan: 'design', council: 'design',
+  brainstorm: 'design', plan: 'design', council: 'design',
   workflow: 'design', 'parallel-agents': 'design', pipeline: 'design',
   'codebase-design': 'design', 'domain-modeling': 'design', wayfinder: 'design',
   tickets: 'design',
-  tdd: 'build', develop: 'build', refactor: 'build', debug: 'build', migrate: 'build',
+  develop: 'build', refactor: 'build', debug: 'build', migrate: 'build',
   'frontend-design': 'build', 'opencode-theme': 'build', prototype: 'build',
   'forge-mcp': 'build', 'bruno-collection-generator': 'build', 'bruno-test-writer': 'build',
-  'geneseed-code-review': 'review', 'fresh-eyes': 'review', 'gap-detector': 'review',
+  worktree: 'build', 'ci-fix': 'build', 'deps-audit': 'build',
+  'geneseed-code-review': 'review', 'fresh-eyes': 'review', 'security-audit': 'review',
   'roast-me': 'review', 'review-response': 'review', ponytail: 'review',
   commit: 'ship', ship: 'ship', release: 'ship', handoff: 'ship', 'git-rescue': 'ship',
-  'repo-map': 'understand', 'git-archaeology': 'understand', decode: 'understand',
+  'repo-map': 'understand', 'git-archaeology': 'understand',
   research: 'understand', ingest: 'understand', 'document-project': 'understand',
-  wiki: 'understand', prose: 'understand', geneseed: 'understand', rule: 'understand',
-  profile: 'understand', herdr: 'understand',
-  'crash-course': 'learn', drill: 'learn', feynman: 'learn', 'learning-path': 'learn',
+  prose: 'understand',
+  // `harness` — skills about the agent's own apparatus (its harness, memory, rules,
+  // knowledge base, terminal) rather than about the user's code. They sat under
+  // `understand` before, which made that class a grab-bag.
+  wiki: 'harness', geneseed: 'harness', rule: 'harness', profile: 'harness',
+  herdr: 'harness', 'skill-forge': 'harness', 'consolidate-memory': 'harness',
+  teach: 'learn', quiz: 'learn',
 };
 
 /** `k in dict` — own keys only, where `k in obj` also finds `Object.prototype` members. */

package/js/inspect/scan.mjs

@@ -11,7 +11,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { SRC } from '../build/source.mjs';
-import { comparePaths, normcase } from '../lib/paths.mjs';
+import { comparePaths, within } from '../lib/paths.mjs';
 import { isDir, isFile } from '../lib/fs.mjs';
 import { has } from '../lib/json.mjs';
 import { mkdtempSync, readdirSync, rmSync } from 'node:fs';
@@ -41,19 +41,8 @@ export function stripCode(text) {
   return text.replace(FENCE_RE, '').replace(COMMENT_RE, '').replace(INLINE_CODE_RE, '');
 }
 
-/**
- * `_harness_core._within` — `child.relative_to(parent)` without the exception.
- *
- * Segment-wise and through `normcase`, because that is what `PurePath` comparison does: a
- * bundle at `C:\Temp\X` contains `c:\temp\x\a.md` on Windows and does not on Linux. A
- * `startsWith` on the raw strings would additionally call `/tmp/bundle2` a child of
- * `/tmp/bundle`, which is the classic version of this bug.
- */
-export function within(child, parent) {
-  const c = normcase(child).split(/[\\/]/);
-  const p = normcase(parent).split(/[\\/]/);
-  return p.length <= c.length && p.every((seg, i) => c[i] === seg);
-}
+// `within` — owned by js/lib/paths.mjs; re-exported for this module's importers.
+export { within };
 
 /** `sorted(d.glob(pat))`, or `[]` for a directory that is not there. */
 export function globSorted(dir, filter) {

package/js/inspect/status.mjs

@@ -62,7 +62,7 @@ import { tuiInventory } from './inventory.mjs';
 import { readVersion, sourceFingerprint } from '../build/version.mjs';
 import {
   claudeConfigDir, bobConfigDir, copilotConfigDir, opencodeConfigDir, resolvePath,
-  resolveMemoryDir, sovereignBypass,
+  resolveMemoryDir, sovereignBypass, GATE_LEDGER,
 } from '../hosts/hosts.mjs';
 // P5f moved the install DETECTORS out of this file — `diff` renders its expected copy in the
 // deployed theme and footprint, and `rebuild-all` re-emits in the deployed everything, so
@@ -194,7 +194,7 @@ export function gateSummary(cfgDirs) {
     if (sovereignBypass(cfg)) standingDown.push(String(cfg));
     let raw;
     try {
-      raw = readFileSync(path.join(cfg, 'notebook', 'gates.jsonl'), 'utf8');
+      raw = readFileSync(path.join(cfg, GATE_LEDGER), 'utf8');
     } catch {
       continue;
     }

package/js/inspect/validate.mjs

@@ -7,7 +7,7 @@
  * reached — see its row in `tests/ported.json`.
  */
 import path from 'node:path';
-import { buildInto, emitGlobalInto, emitProjectInto } from '../../bin/build-driver.mjs';
+import { buildInto, emitGlobalInto, emitProjectInto } from '../build/driver.mjs';
 import { resolvePath } from '../hosts/hosts.mjs';
 import { validateIsVendored } from '../hosts/native.mjs';
 import { printOut, printErr, readText } from '../lib/fs.mjs';

package/js/lib/fs.mjs

@@ -202,19 +202,34 @@ export function withPlatformNewlines(fn) {
  * it for its own existing callers rather than owning a copy itself. `js/hosts/hooks.mjs` is
  * the deliberate exception — the hot path keeps its own inline copy rather than pay an import.
  *
- * `statSync`'s Node default THROWS for a missing path; `throwIfNoEntry: false` (Node >= 15.3)
- * is the one option that turns ONLY that case into `undefined`, and still throws for anything
- * else — a permission failure, a path with a non-directory ancestor (`ENOTDIR`). Every copy
- * this replaces used a bare `try/catch` instead, which swallowed ALL of those alike into the
- * same `false`. That is a real, deliberate narrowing: a permission failure silently read as
- * "not there" was the wrong answer to preserve, not a byte worth keeping.
+ * WHICH ERRORS MEAN "NO", matching `pathlib`'s `_ignore_error`: `ENOENT` (nothing there),
+ * `ENOTDIR` (a path THROUGH a file — `skills/brainstorm.md/SKILL.md`), `ELOOP`, `EBADF`. Each is a
+ * definite answer that nothing of that kind is at the path. Anything else — a permission
+ * failure above all — still throws: read as "not there" it would be the wrong answer, silently.
+ * Every copy this replaced used a bare `try/catch` that swallowed everything alike.
+ *
+ * ⚠ `ENOTDIR` WAS ONCE LEFT TO THROW here, on the reading that it resembled an access error.
+ * It is not one, and Windows reports the same probe as `ENOENT` — so the difference only shows
+ * on macOS/Linux: the folder-skill count asked `isFile(<skills>/<flat>.md/SKILL.md)` and the
+ * web console's overview died with `ENOTDIR` there while every Windows run stayed green.
  */
+const NOT_THERE = new Set(['ENOENT', 'ENOTDIR', 'ELOOP', 'EBADF']);
+
+function statOrNull(p) {
+  try {
+    return statSync(p);
+  } catch (e) {
+    if (e && NOT_THERE.has(e.code)) return null;
+    throw e;
+  }
+}
+
 export function isFile(p) {
-  return statSync(p, { throwIfNoEntry: false })?.isFile() ?? false;
+  return statOrNull(p)?.isFile() ?? false;
 }
 
 export function isDir(p) {
-  return statSync(p, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  return statOrNull(p)?.isDirectory() ?? false;
 }
 
 /**

package/js/lib/json.mjs

@@ -248,8 +248,14 @@ export function has(obj, key) {
   return Object.hasOwn(obj, key);
 }
 
+/**
+ * `isinstance(x, dict)` for a value that came out of `parseJson`. Numbers come back WRAPPED
+ * (`JsonNumber`), so `typeof v === 'object'` alone says yes to every number — and a settings
+ * file with `"permission": 5` then read as a dict the merge could write into, silently
+ * skipping the git gate. The one exclusion is the wrapper; everything else is unchanged.
+ */
 export function isDict(v) {
-  return Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+  return Boolean(v) && typeof v === 'object' && !Array.isArray(v) && !(v instanceof JsonNumber);
 }
 
 /**

package/js/lib/proc.mjs

@@ -20,9 +20,11 @@
  * CAPTURING SPAWNS ONLY, and the asymmetry is deliberate. The rule was measured on Windows:
  * a process that sets `STARTF_USESTDHANDLES` only when a stream is redirected gives an
  * INHERITING child spawned with `CREATE_NO_WINDOW` a fresh hidden console and discards
- * everything it prints — `geneseed build > log.txt` wrote an empty file. libuv always passes
- * the handles explicitly, so the flag on an inheriting spawn would be harmless here; it stays
- * off anyway, because an inheriting child of a console-owning parent shows no window in the
- * first place, so it would buy nothing and re-open a failure mode already paid for once.
+ * everything it prints — `geneseed build > log.txt` wrote an empty file. That was Python's
+ * `CREATE_NO_WINDOW` creation flag. Node's `windowsHide` is a different mechanism, and libuv
+ * always passes the handles explicitly, so on an INHERITING spawn it is harmless: the child
+ * writes to the parent's handles. A few inheriting sites set it (`js/hosts/link.mjs`,
+ * `js/maintain/update.mjs`) and are correct — `tests/unit/spawn_hygiene.test.mjs` explains why
+ * it asserts no inverse rule.
  */
 export const NO_WINDOW = { windowsHide: process.platform === 'win32' };

package/js/maintain/migrate.mjs

@@ -34,7 +34,7 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import path from 'node:path';
 
-import { main as driverMain } from '../../bin/build-driver.mjs';
+import { main as driverMain } from '../build/driver.mjs';
 import { ROOT } from '../build/source.mjs';
 import {
   EMIT_HOST_SCOPE, defaultMode, defaultPosture, defaultTheme, doctrinesForBuild,

package/js/maintain/setup.mjs

@@ -44,7 +44,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readSync } from 'node:fs';
 import path from 'node:path';
 
-import { main as driverMain, resolveOut } from '../../bin/build-driver.mjs';
+import { main as driverMain, resolveOut } from '../build/driver.mjs';
 import { playLine } from '../ui/anim.mjs';
 import { discoverNames, PACK_ORDER } from '../build/source.mjs';
 import { exportImprovements } from '../inspect/diff.mjs';