geneseed 3.14.0 → 3.16.0

package/js/hosts/native.mjs

@@ -3,7 +3,7 @@
  *
  * A faithful translation of `_build_emit._write_native_layer` and the frontmatter
  * builders it dispatches to. Capability specs become host-native subagents and skills:
- * one dialect per host (OpenCode / Claude Code), vendored skill folders copied
+ * one agent dialect per host family (OpenCode / Claude Code), vendored skill folders copied
  * through verbatim, authoring templates shipped flat.
  *
  * WHY THIS IS THE HARD HALF. `js/build/render.mjs` is a pure function of `src/` and `themes/`;
@@ -15,8 +15,7 @@
  *   2. Claim-on-create decides which files get written AT ALL: a target that already
  *      exists and was not in the previous manifest belongs to the user, and is skipped
  *      with a warning. So the output is a function of what is already on disk.
- *   3. Three host dialects diverge inside one loop — including a FILENAME change
- *      (`<name>.agent.md`) that drags a link rewrite along with it.
+ *   3. Two agent dialects diverge inside one loop, on the same filenames.
  *
  * None of the three is reachable from the golden harness's happy path: golden emits into
  * a fresh tree with an empty overrides stub. `tests/unit/user_files.test.mjs` drives
@@ -32,9 +31,10 @@ import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { writeText, copyFile, readText } from '../lib/fs.mjs';
 import { jsonDumps, parseJson, formatValue, formatRepr, isTruthy, isDict } from '../lib/json.mjs';
+import { relPosix } from '../lib/text.mjs';
 
 /** What a folder skill writes where it needs its own directory — see `writeNativeLayer`. */
-export const SKILL_DIR_PLACEHOLDER = '<this-skill-directory>';
+const SKILL_DIR_PLACEHOLDER = '<this-skill-directory>';
 
 /** Mirrors `_build_core.VENDORED_SKILL_DIRS`. */
 export const VENDORED_SKILL_DIRS = new Set(['react-view-transitions', 'daydream', 'token-report', 'explain-changes']);
@@ -108,11 +108,6 @@ export function firstBlockquote(text) {
   return '';
 }
 
-/** `_build_emit.desc_of`. */
-export function descOf(text) {
-  return firstBlockquote(text);
-}
-
 /**
  * The `**Trigger:**` paragraph of a skill, flattened to one line — markdown links reduced
  * to their text, HTML comments dropped, whitespace collapsed. '' when the skill has none.
@@ -155,7 +150,7 @@ function triggerOf(text) {
  */
 const DESCRIPTION_CAP = 320;
 function skillDescription(text) {
-  return withWhen(descOf(text), triggerOf(text));
+  return withWhen(firstBlockquote(text), triggerOf(text));
 }
 
 /**
@@ -188,7 +183,7 @@ function dispatchOf(text) {
 
 /** The emitted `description:` of an agent — purpose + its first dispatch condition. */
 export function agentDescription(text) {
-  return withWhen(descOf(text), dispatchOf(text));
+  return withWhen(firstBlockquote(text), dispatchOf(text));
 }
 
 /** Purpose + ` Use when: ` + the first sentence of `trig`, capped — see `skillDescription`. */
@@ -299,11 +294,9 @@ function given(v) {
  * `Object.prototype` for an agent named `constructor`, `toString` or `valueOf`, and would
  * hand back a function where Python hands back `None`.
  *
- * Known divergence, recorded rather than papered over: where the value is present but is
- * NOT an object (a user writing `"reviewer": "haiku"` instead of
- * `"reviewer": {"model": "haiku"}`), Python raises AttributeError and aborts the emit
- * while this returns undefined for every key and emits no override lines. Not a byte
- * difference on any path the gate covers — a difference in which malformed input crashes.
+ * A value that is present but NOT an object (`"reviewer": "haiku"` instead of
+ * `"reviewer": {"model": "haiku"}`) never reaches here from a file: `loadAgentOverrides`
+ * warns and drops it. A caller handing one in directly gets no override lines.
  */
 function agentOverride(overrides, stem) {
   return (Object.hasOwn(overrides, stem) && overrides[stem]) || {};
@@ -366,13 +359,36 @@ function opencodeAgentFrontmatter(stem, text, overrides, theme = null) {
   return fm;
 }
 
-/** `_build_emit._load_agent_overrides`. */
+/** The keys the OpenCode dialect renders. Claude's honours `model` alone — see `writeNativeLayer`. */
+const OVERRIDE_KEYS = ['model', 'temperature', 'variant', 'steps'];
+
+/**
+ * '' when `v` may be written into a frontmatter line, else why not.
+ *
+ * Each value lands VERBATIM after `key: `, so a string carrying a line break writes frontmatter
+ * keys of its own (`"haiku\npermission: allow"`), and anything `formatValue` cannot render — a
+ * boolean, a list, an object — threw a bare TypeError that aborted the emit with a stack trace
+ * naming nothing the user wrote.
+ */
+function overrideProblem(v) {
+  if (typeof v === 'string') return /[\r\n\u2028\u2029]/.test(v) ? 'contains a line break' : '';
+  // `parseJson` yields exactly one object `isDict` refuses: its number wrapper.
+  const isNumber = typeof v === 'object' && v !== null && !Array.isArray(v) && !isDict(v);
+  if (isNumber && Number.isFinite(+v)) return '';
+  return 'is not a string or a finite number';
+}
+
+/**
+ * `_build_emit._load_agent_overrides`, with every value that would break the frontmatter
+ * dropped and named on stderr — the user's file, so a bad entry is a warning, never an abort.
+ */
 export function loadAgentOverrides(base) {
+  const file = path.join(base, 'agent-overrides.json');
   let data;
   try {
     // parseJson, not JSON.parse: the override values are rendered with `formatValue`, which
     // needs the int/float distinction the raw literal carries and `JSON.parse` discards.
-    data = parseJson(readText(path.join(base, 'agent-overrides.json')));
+    data = parseJson(readText(file));
   } catch {
     // Missing or malformed => no overrides, so agents inherit the host model.
     // Wider than Python's `except (OSError, json.JSONDecodeError)` by one case: a file
@@ -382,12 +398,72 @@ export function loadAgentOverrides(base) {
     return {};
   }
   const agents = isDict(data) ? data.agents : null;
-  return isDict(agents) ? agents : {};
+  if (!isDict(agents)) return {};
+  // In place: `data` is a fresh parse, and deleting keeps a `__proto__`-named entry an own
+  // property, where copying into a new object would assign a prototype instead.
+  for (const [stem, entry] of Object.entries(agents)) {
+    if (entry === null) continue;
+    if (!isDict(entry)) {
+      warn(`[geneseed] WARN: ${file}: agents.${stem} is not an object — skipped`);
+      delete agents[stem];
+      continue;
+    }
+    for (const key of OVERRIDE_KEYS) {
+      if (!given(entry[key])) continue;
+      const why = overrideProblem(entry[key]);
+      if (!why) continue;
+      warn(`[geneseed] WARN: ${file}: agents.${stem}.${key} ${why} — skipped`);
+      delete entry[key];
+    }
+  }
+  return agents;
 }
 
-/** `Path.relative_to(base).as_posix()`. */
-function relPosix(base, target) {
-  return path.relative(base, target).split(path.sep).join('/');
+/**
+ * Warn once per override key the Claude dialect drops. The seeded `agent-overrides.json`
+ * advertises all four keys on every host, and Claude Code's agent frontmatter takes `model`
+ * only — so a `temperature` set there was silently a no-op.
+ */
+function warnClaudeIgnored(overrides) {
+  const ignored = new Set();
+  for (const entry of Object.values(overrides)) {
+    if (!isDict(entry)) continue;
+    for (const key of OVERRIDE_KEYS.slice(1)) if (given(entry[key])) ignored.add(key);
+  }
+  for (const key of ignored) {
+    warn(`[geneseed] WARN: agent-overrides.json sets '${key}', which Claude-family hosts do `
+      + "not support — only 'model' is applied");
+  }
+}
+
+/**
+ * Claim-on-create, as a closure over one emit's prior manifest: `claim(dest)` is true when
+ * `dest` may be (over)written, false for a pre-existing file no previous emit owned — the
+ * user's, left alone, named on stderr, and kept out of the manifest by the caller.
+ *
+ * Its own function because every writer whose path lands in `owned` needs it, and uninstall
+ * deletes what `owned` names: the OpenCode command and primary-agent writers pushed their
+ * paths without it, so uninstall removed a user's own `command/commit.md`. ONE closure per
+ * emit, shared by all of them, so the pre-manifest header still prints once.
+ *
+ * `oldOwned === null` (or no `cfg`) is a caller doing no ownership at all: claim everything.
+ */
+export function claimer(oldOwned, cfg, manifestExisted = true) {
+  const oldSet = oldOwned !== null && oldOwned !== undefined ? new Set(oldOwned) : null;
+  let headerPrinted = false;
+  return (dest) => {
+    if (oldSet === null || cfg === null || !existsSync(dest)) return true;
+    const rel = relPosix(cfg, dest);
+    if (oldSet.has(rel)) return true;
+    if (!manifestExisted && !headerPrinted) {
+      warn('[geneseed] first emit over a pre-manifest install — existing files '
+        + 'are treated as yours');
+      headerPrinted = true;
+    }
+    warn(`[geneseed] kept your existing ${rel} — skipped Geneseed's copy to avoid `
+      + 'clobbering it');
+    return false;
+  };
 }
 
 /**
@@ -406,6 +482,9 @@ function relPosix(base, target) {
  * has the placeholder replaced by the answer. Only vendored folders carry the placeholder — a
  * flat skill has no siblings to point at.
  *
+ * `opts.claim` — a `claimer` closure the caller shares with its other writers; built from
+ * `oldOwned`/`cfg`/`manifestExisted` when absent.
+ *
  * Returns `{ nAgents, nSkills, written }` — Python's 3-tuple, with `written` as absolute
  * paths in write order.
  *
@@ -419,30 +498,13 @@ function relPosix(base, target) {
  */
 export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null, {
   host = 'opencode', oldOwned = null, cfg = null, manifestExisted = true,
-  theme = null, src, skillDirOf = null,
+  theme = null, src, skillDirOf = null, claim = claimer(oldOwned, cfg, manifestExisted),
 } = {}) {
   const ov = overrides || {};
-  const oldSet = oldOwned !== null && oldOwned !== undefined ? new Set(oldOwned) : null;
+  if (host === 'claude') warnClaudeIgnored(ov);
   let nAgents = 0;
   let nSkills = 0;
   const written = [];
-  let headerPrinted = false;
-
-  // True -> ok to (over)write; false -> a pre-existing file we never owned, so it is the
-  // user's: leave it, warn, and keep it out of the manifest.
-  const claim = (dest) => {
-    if (oldSet === null || cfg === null || !existsSync(dest)) return true;
-    const rel = relPosix(cfg, dest);
-    if (oldSet.has(rel)) return true;
-    if (!manifestExisted && !headerPrinted) {
-      warn('[geneseed] first emit over a pre-manifest install — existing files '
-        + 'are treated as yours');
-      headerPrinted = true;
-    }
-    warn(`[geneseed] kept your existing ${rel} — skipped Geneseed's copy to avoid `
-      + 'clobbering it');
-    return false;
-  };
 
   const write = (dest, text) => {
     mkdirSync(path.dirname(dest), { recursive: true });
@@ -498,13 +560,9 @@ export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null,
     let dest;
     let kind;
     if (folder === 'agents') {
-      if (host === 'claude') {
-        fm = claudeAgentFrontmatter(stem, text, ov);
-        dest = path.join(agentsDir, `${stem}.md`);
-      } else {
-        fm = opencodeAgentFrontmatter(stem, text, ov, theme);
-        dest = path.join(agentsDir, `${stem}.md`);
-      }
+      fm = host === 'claude' ? claudeAgentFrontmatter(stem, text, ov)
+        : opencodeAgentFrontmatter(stem, text, ov, theme);
+      dest = path.join(agentsDir, `${stem}.md`);
       kind = 'agent';
     } else {
       // Skills are BYTE-IDENTICAL across hosts: name + description, body link-stripped.

package/js/hosts/opencode.mjs

@@ -16,18 +16,21 @@
  *
  * TWO STREAMS, AND THE SPLIT IS NOT TIDY. `_warn_if_overrides_stale` prints to STDOUT
  * while every warning in `js/hosts/native.mjs` goes to stderr. That is the Python's own
- * inconsistency and it is reproduced, not corrected: the parity gate compares both
- * specification, and `tests/unit/agent_overrides.test.mjs` pins the stale notice to stdout.
- * It is safe because this is the
- * generator's CLI, which prints progress to stdout by design — unlike a hook path, where
- * a stray stdout byte silently disarms a blocking gate.
+ * inconsistency and it is reproduced, not corrected: `tests/unit/agent_overrides.test.mjs`
+ * pins the stale notice to stdout. It is safe because this is the generator's CLI, which
+ * prints progress to stdout by design — unlike a hook path, where a stray stdout byte
+ * silently disarms a blocking gate.
  */
 import { existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { writeText, readText, copyFile } from '../lib/fs.mjs';
 import { jsonDumps, jsonDumpsIndent, parseJson } from '../lib/json.mjs';
 import { comparePaths } from '../lib/paths.mjs';
-import { descOf, stripSkillBodyLinks, pushOverrideLines } from './native.mjs';
+import { sourceReleaseVersion } from '../build/version.mjs';
+import { firstBlockquote, stripSkillBodyLinks, pushOverrideLines } from './native.mjs';
+
+// Re-exported for `js/web/api.mjs` and the tests, which import it from here.
+export { sourceReleaseVersion };
 
 /** ANSI colour-name -> integer (0-7). Mirrors `_build_emit._ANSI`. */
 const ANSI = {
@@ -94,9 +97,17 @@ const AGENT_OVERRIDES_STUB = {
   },
 };
 
-/** Mirrors `_build_emit.COMMAND_SET` — the hot skills worth a one-keystroke trigger. */
-const COMMAND_SET = ['commit', 'plan', 'code-review', 'review-response',
-  'ship', 'debug', 'research'];
+/**
+ * `_build_emit.COMMAND_SET` — the hot skills worth a one-keystroke trigger, as command name ->
+ * skill name. A map, not a list, because the two can differ: `code-review` became
+ * `geneseed-code-review` (so it no longer shadows a host built-in) while the command stays
+ * `/code-review`. As a list the renamed entry missed its skill and was dropped in silence, so a
+ * missing skill is now a thrown error in `writeCommandLayer`.
+ */
+const COMMAND_SET = {
+  commit: 'commit', plan: 'plan', 'code-review': 'geneseed-code-review',
+  'review-response': 'review-response', ship: 'ship', debug: 'debug', research: 'research',
+};
 
 /** Mirrors `_build_emit.PONYTAIL_COMMAND_BODY`. */
 const PONYTAIL_COMMAND_BODY =
@@ -113,22 +124,6 @@ function truthyEnv(name) {
   return ['1', 'on', 'true', 'yes'].includes((process.env[name] || '').toLowerCase());
 }
 
-/**
- * `_build_core.source_release_version`. It reads `cfg.config`, so it takes `cfg` rather than
- * importing core — and it stayed HERE when core landed as `js/build/source.mjs`, which is why
- * `js/build/version.mjs` reaches back into the OpenCode module for it.
- */
-export function sourceReleaseVersion(cfg) {
-  try {
-    const data = parseJson(readText(cfg.config));
-    const v = data && typeof data === 'object' && !Array.isArray(data) ? data.version : null;
-    if (typeof v === 'string' && v) return v;
-  } catch {
-    // OSError / JSONDecodeError — degrade to "not newer" rather than raising.
-  }
-  return '0.0.0';
-}
-
 const GRAY = 8;
 const GREEN = 2;
 const RED = 1;
@@ -181,7 +176,6 @@ export function writeTheme(themesDir, themeName, theme) {
   return dest;
 }
 
-/** `_build_emit._color_theme_json`. */
 /**
  * `_build_emit._PALETTE_ROLES` — every role some slot reads, as a set.
  *
@@ -192,6 +186,7 @@ export function writeTheme(themesDir, themeName, theme) {
  */
 export const PALETTE_ROLES = new Set(Object.values(SLOT_ROLE));
 
+/** `_build_emit._color_theme_json`. */
 export function colorThemeJson(palette, transparent) {
   const t = {};
   for (const [slot, role] of Object.entries(SLOT_ROLE)) {
@@ -272,8 +267,16 @@ export function ensureAgentOverridesStub(cfg, base) {
   writeText(dest, `${jsonDumpsIndent(stub, { ensureAscii: false })}\n`);
 }
 
-/** `_build_emit._write_primary_agent` — the opt-in `mode: primary` orchestrator. */
-export function writePrimaryAgent(cfg, agentsDir, overrides) {
+/**
+ * `_build_emit._write_primary_agent` — the opt-in `mode: primary` orchestrator.
+ *
+ * `claim` is `claimer`'s closure from `js/hosts/native.mjs`, and this and the two command
+ * writers below take it for the reason `writeNativeLayer` does: their paths are pushed into
+ * `owned`, and uninstall deletes what `owned` names — so writing over a user's own
+ * `command/commit.md` without the check made uninstall delete it. Default: claim everything,
+ * for a caller with no manifest to consult.
+ */
+export function writePrimaryAgent(cfg, agentsDir, overrides, claim = () => true) {
   if (!truthyEnv('GENESEED_PRIMARY') || !existsSync(cfg.primaryAgentSrc)
       || !statSync(cfg.primaryAgentSrc).isFile()) {
     return null;
@@ -286,13 +289,14 @@ export function writePrimaryAgent(cfg, agentsDir, overrides) {
     && overrides.orchestrator) || {};
   pushOverrideLines(fm, ov);
   const dest = path.join(agentsDir, 'orchestrator.md');
+  if (!claim(dest)) return null;
   mkdirSync(path.dirname(dest), { recursive: true });
   writeText(dest, `---\n${fm.join('\n')}\n---\n\n${body}`);
   return dest;
 }
 
 /** `_build_emit._write_command_layer` — the opt-in /slash commands. */
-export function writeCommandLayer(cfg, items, commandDir) {
+export function writeCommandLayer(cfg, items, commandDir, claim = () => true) {
   if (!truthyEnv('GENESEED_COMMANDS')) return [];
   const byName = new Map();
   for (const { text, src } of items) {
@@ -304,12 +308,17 @@ export function writeCommandLayer(cfg, items, commandDir) {
     }
   }
   const written = [];
-  for (const name of COMMAND_SET) {
-    const text = byName.get(name);
-    if (text === undefined) continue;
-    const desc = descOf(text);
-    const body = stripSkillBodyLinks(text.replace(/^\n+/, ''));
+  for (const [name, skill] of Object.entries(COMMAND_SET)) {
+    // A command runs a skill; `--exclude-skills` took that skill out, so the command goes too.
+    if ((cfg.excludeSkills ?? []).includes(skill)) continue;
+    const text = byName.get(skill);
+    if (text === undefined) {
+      throw new Error(`COMMAND_SET: /${name} runs skill '${skill}', which src/skills/ does not have`);
+    }
     const dest = path.join(commandDir, `${name}.md`);
+    if (!claim(dest)) continue;
+    const desc = firstBlockquote(text);
+    const body = stripSkillBodyLinks(text.replace(/^\n+/, ''));
     mkdirSync(path.dirname(dest), { recursive: true });
     writeText(dest, `---\ndescription: ${jsonDumps(desc)}\n---\n\n${body}`);
     written.push(dest);
@@ -317,9 +326,10 @@ export function writeCommandLayer(cfg, items, commandDir) {
   return written;
 }
 
-/** `_build_emit._write_ponytail_command` — registered UNCONDITIONALLY. */
-export function writePonytailCommand(commandDir) {
+/** `_build_emit._write_ponytail_command` — registered UNCONDITIONALLY; null when the user's. */
+export function writePonytailCommand(commandDir, claim = () => true) {
   const dest = path.join(commandDir, 'ponytail.md');
+  if (!claim(dest)) return null;
   mkdirSync(path.dirname(dest), { recursive: true });
   const desc = 'Set the ponytail minimal-code level for the session: lite | full | ultra | off';
   writeText(dest, `---\ndescription: ${jsonDumps(desc)}\n---\n\n${PONYTAIL_COMMAND_BODY}`);

package/js/hosts/shim.mjs

@@ -273,7 +273,8 @@ export function hookPrefix({ runner, entry, platform = process.platform } = {})
  * interpreter silently disables every hook in the install. Both halves are gone. `runner` is
  * `process.execPath` — the node already running this file, which by construction exists —
  * so there is nothing left to discover and no way for discovery to fail. P4e kept the
- * unreachable exit-3 branch because `test_the_node_driver_classifies_every_emit` asserts a
+ * unreachable exit-3 branch because 'the driver classifies every emit'
+ * (`tests/unit/node_driver.test.mjs`) asserts a
  * partition it belongs to; nothing asserts a partition over this one, so keeping it would
  * be keeping code no test can reach for no stated reason.
  *
@@ -287,7 +288,8 @@ export function hookPrefix({ runner, entry, platform = process.platform } = {})
  *
  * That is correct exactly while the two entry points answer the same verbs the same way, so
  * the gate that used to be a formality is now load-bearing:
- * `test_the_entry_carries_exactly_the_verbs_the_emitter_wires` reads the emitter's wiring
+ * 'the hook entry carries exactly the verbs the emitter wires' (`tests/unit/hook_cli.test.mjs`)
+ * reads the emitter's wiring
  * and `bin/geneseed-hook.mjs`'s VERBS table and requires them EQUAL — a wired verb the entry
  * lacks is a dead hook on every install on the machine, not just this one. The alternative
  * considered and rejected was a per-driver shim path: the path is baked into every already

package/js/inspect/diff.mjs

@@ -22,11 +22,10 @@
  *   * **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 —
- *     `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).
+ *     changes the hunks on every real harness file. The former Python suite gated it as a
+ *     corpus, measured in both directions (28 of its 176 cases disagreed when `autojunk` was
+ *     switched off). That corpus is gone and no Node test drives `unifiedDiff` directly, so
+ *     beyond the one hunk the `diff/--full-…` cell sees, nothing pins these shapes today.
  *   * **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
@@ -45,7 +44,8 @@ import {
   GLOBAL_MANIFEST, VERSION_MARKER, expanduser, opencodeConfigDir, resolvePath,
 } from '../hosts/hosts.mjs';
 import {
-  EMIT_HOST_SCOPE, defaultTheme, doctrinesForBuild, excludedRulesOfDir, footprintOfDir, modeOfDir, postureOfDir,
+  EMIT_HOST_SCOPE, defaultTheme, doctrinesForBuild, excludedRulesOfDir, excludedSkillsOfDir,
+  footprintOfDir, modeOfDir, postureOfDir,
   trustOfDir,
   readJsonMaybe, readMaybe, themeOfDir,
 } from '../hosts/installs.mjs';
@@ -177,10 +177,12 @@ export function diffCollect({ target = null, theme = null, emit = null, footprin
       // makes explicit rather than leaving to `makeCfg`'s parameter default two layers down.
       posture: postureOfDir(dir), mode: modeOfDir(dir), doctrines: doctrinesForBuild(dir),
       // The loop skill's preset, or its `Default trust preset:` line reads as edited.
-      trust: trustOfDir(dir),
+      trust: trustOfDir(dir, host),
       // The excluded rules, or an install built `--exclude-rules "process 5"` reads its
       // carrier as drift: `expected` would re-state the rule the deployment took away.
       excludeRules: excludedRulesOfDir(dir),
+      // The excluded skills, or every skill the install left out reads as deleted.
+      excludeSkills: excludedSkillsOfDir(dir),
     }));
     // The one place a render depends on WHERE it is installed: a global Bob emit writes each
     // folder skill's absolute directory into its SKILL.md (see `writeNativeLayer`), so the

package/js/inspect/excludes.mjs

@@ -78,14 +78,19 @@ const canon = (p) => resolvePath(p);
 /**
  * `_same` — is this stored entry the same folder as `repo`?
  *
- * `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.
+ * Resolved like `repo` itself (`canon`: `..` collapsed, symlinks followed), the one rule the
+ * hook's `sovereignBypass` and the OpenCode plugins apply too — so an entry that EXCLUDES a
+ * folder is exactly the entry `exclude remove` can take back. It used to compare lexically,
+ * mirroring the former Python `Path()`, which made a hand-edited `<repo>/../repo` an entry the
+ * plugins honoured, the hook ignored, and `remove` could not find.
  */
 function same(stored, repo) {
   if (typeof stored !== 'string' || !stored) return false;
-  return normcase(toPlatformPath(stored)) === normcase(repo);
+  try {
+    return normcase(canon(stored)) === normcase(repo);
+  } catch {
+    return false;  // a `~user` form `expanduser` refuses names no folder
+  }
 }
 
 /**

package/js/inspect/status.mjs

@@ -34,25 +34,26 @@
  * became the second and third. Nothing about them changed in the move — the 166-cell
  * acceptance matrix is what licensed attempting it, `status`'s own eleven cells among them.
  *
- * WHAT NO CELL CAN REACH, and where it is gated instead. `tests/harness_golden.py`'s
- * status/version section carries the long form; the short form is that ROOT is not
+ * WHAT NO CELL CAN REACH, and where it is gated instead. The former Python matrix's
+ * status/version section carried the long form; the short form is that ROOT is not
  * redirectable across a process boundary, so three things here are unreachable from any
  * cell: `versionVerdict`'s "up to date" (needs a marker holding a fingerprint no cell can
  * know), `accentFor`'s cyan fallback (an unknown theme is refused upstream by
  * `effectiveTheme`), and the whole ANSI half of `statusLines` (`_color_enabled` is
  * `sys.stdout.isatty()`, and every harness captures stdout through a pipe). All three are
- * PURE FUNCTIONS of their arguments, so all three are gated as a corpus instead:
- * `tests/fixtures/pure_probe.mjs` calls them and `tests/snapshot/pure_snapshot.test.mjs`
- * replays that against `tests/__snapshots__/primitives/`. That was a third answer to the
- * colour question, which had been posed as a choice between shipping it ungated and not
- * shipping it.
+ * PURE FUNCTIONS of their arguments, so the former Python suite gated all three as a corpus
+ * instead — a third answer to the colour question, which had been posed as a choice between
+ * shipping it ungated and not shipping it. That corpus is gone: `tests/unit/lifecycle.test.mjs`
+ * now calls `versionVerdict` and both halves of `statusLines` directly, and nothing pins
+ * `accentFor`'s fallback.
  *
  * `manifestIsClaude` was a FOURTH until wave 2 of the P0/P1 review: it is only reached for
  * a candidate with no known host, and `ROOT/"Harness"` was ordered ahead of the sandbox's
  * own. Both ROOT-relative bundle candidates are gone from this walk and from
  * `installedDefaults`, so the only no-known-host candidate left is `cwd/"Harness"`, which
  * is inside the sandbox. It is reachable now; no cell seeds a manifest without an emit
- * marker, so it is still gated only by the corpus, and that is a gap rather than a wall.
+ * marker, so it is gated only by the direct calls in `tests/unit/claude.test.mjs`, and that is
+ * a gap rather than a wall.
  */
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -66,19 +67,15 @@ import {
 } 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
-// three verbs now read them. `defaultTheme`, `manifestIsClaude` and `installedDefaults` are
-// re-exported below because `tests/fixtures/pure_probe.mjs` names this module for two of them
-// and a corpus that followed the code to its new file would stop testing the caller's view.
+// three verbs now read them.
 import {
-  defaultTheme, installedDefaults, installTargets, manifestIsClaude, readJsonMaybe, readMaybe,
+  defaultTheme, installedDefaults, installTargets, readJsonMaybe, readMaybe,
 } from '../hosts/installs.mjs';
 import { installProfile, rebuildCommand } from '../build/generate.mjs';
 import { shimDead } from '../hosts/shim.mjs';
 import { printOut } from '../lib/fs.mjs';
 import { codePointLength, padEndToWidth } from '../lib/text.mjs';
 
-export { defaultTheme, manifestIsClaude };
-
 // ---- version ---------------------------------------------------------------------------
 
 /** `_harness_status._version_verdict`. */
@@ -331,13 +328,13 @@ export function statusLines(d, color = false) {
       + `(${d.facts} fact${d.facts === 1 ? '' : 's'})`],
     ['version', `${d.installed_fp || '(none)'}  ${DOT}  source ${d.source_fp}`],
   ];
-  // ⚠ A ROW, NOT A WIDER `components` LINE, AND THE REASON IS THAT THE CORPUS CANNOT BE
-  // RE-BLESSED. `statusLines` has 30 recorded cases per platform in
-  // `tests/__snapshots__/primitives/`, every one of them holding the box's exact bytes —
-  // including `17 agents · 47 skills · 37 laws` — and the recorder was Python and is gone.
-  // Touching `components` moves all 30; adding a row would too, since the box width is
-  // measured over `rows`. So the row is CONDITIONAL on a key the recorded arguments do not
-  // carry, exactly as `agent_md` below already is, and the recording renders unchanged.
+  // ⚠ A ROW, NOT A WIDER `components` LINE. When this landed, `statusLines` had 30 recorded
+  // cases per platform in the former Python suite's corpus, every one holding the box's exact
+  // bytes — including `17 agents · 47 skills · 37 laws` — and no recorder left to re-bless them.
+  // Touching `components` would have moved all 30; adding a row would too, since the box width
+  // is measured over `rows`. So the row is CONDITIONAL on a key those arguments did not carry,
+  // exactly as `agent_md` below already is. The corpus is gone; a caller without the key still
+  // gets the box it got before.
   //
   // It carries the two tiers `components` cannot: `components` counts the invariants as
   // `laws`, which is still true, and says nothing about the ontology or the packs.
@@ -373,7 +370,8 @@ export function statusLines(d, color = false) {
     const packs = p.doctrines.length ? p.doctrines.join(',') : 'no packs';
     const excl = p.excludeRules?.length ? `excluding ${p.excludeRules.join(',')}` : 'no rules excluded';
     rows.push([`${p.host}:${p.scope}`, [p.state, p.theme, p.footprint, `${p.posture}/${p.mode}/${p.trust}`,
-      packs, excl].join(` ${DOT} `) + where]);
+      packs, excl, ...(p.excludeSkills?.length ? [`skills off: ${p.excludeSkills.join(',')}`] : [])]
+      .join(` ${DOT} `) + where]);
   }
 
   const labelW = Math.max(...rows.map(([k]) => codePointLength(k)));

package/js/inspect/validate.mjs

@@ -32,7 +32,8 @@ import { isDir, isFile, rglob, withTempDir, within } from './scan.mjs';
 export const VALIDATE_USAGE = [
   'usage: geneseed validate [-h] [--theme THEME] [--emit EMIT] [--out OUT] [--root ROOT]',
   '                         [--footprint {lean,full}] [--posture POSTURE] [--mode MODE]',
-  '                         [--trust TRUST] [--doctrines DOCTRINES] [--exclude-rules RULES] [-v]',
+  '                         [--trust TRUST] [--doctrines DOCTRINES] [--exclude-rules RULES]',
+  '                         [--exclude-skills SKILLS] [-v]',
   '',
   "Render and emit into a throwaway sandbox, run the doctor's checks, and write nothing real.",
   "Takes the generator's render flags (see geneseed-build --help) except --sync-themes and",
@@ -127,6 +128,7 @@ export function cmdValidate(args) {
     const opts = {
       theme: args.theme, footprint: args.footprint, posture: args.posture, mode: args.mode,
       trust: args.trust, doctrines: args.doctrines, excludeRules: args.excludeRules,
+      excludeSkills: args.excludeSkills,
     };
     let scanDirs;
     try {
@@ -149,8 +151,8 @@ export function cmdValidate(args) {
       // which ends `raise SystemExit(res.get("exit", 1))` — an INTEGER — so every refusal
       // that crosses the seam arrives here as `SystemExit(1)` and `str(e)` is `'1'`, not the
       // sentence `load_theme` wrote on stderr on the way out. A port that printed `e.message`
-      // says `unknown theme 'x'` where the reference says `1`. The corpus in
-      // `tests/test_maintainer_tools_parity.py` is what found it; nothing else could.
+      // says `unknown theme 'x'` where the reference says `1`. The former Python
+      // cross-implementation corpus is what found it; nothing else could.
       if (e && e.exitCode !== undefined) {
         printOut(`[validate-only] render/emit FAILED for theme '${args.theme}' `
           + `emit '${emit}': ${e.exitCode}\n`);