geneseed 3.14.0 → 3.15.0

package/js/hosts/installs.mjs

@@ -107,8 +107,8 @@ export const defaultMode = () => configuredDefault('mode', 'direct');
  * `_build_render.theme_files` — shipped themes, `_`-prefixed scaffolds excluded.
  *
  * `dir` defaults to the checkout's own `themes/`, which is every caller but one: P2's
- * `syncThemes` is driven over a FIXTURE directory by the cross-implementation corpus in
- * `tests/test_maintainer_tools_parity.py`, because the tool it belongs to rewrites committed
+ * `syncThemes` is driven over a FIXTURE directory by the corpus in
+ * `tests/unit/maintainer_tools.test.mjs`, because the tool it belongs to rewrites committed
  * files and cannot be gated against the real ones. A parameter, not a second enumeration —
  * a scaffold mistaken for a theme is exactly what this function exists to prevent, once.
  *
@@ -162,12 +162,26 @@ function firstCarrier(d, probe, fallback = null) {
   return fallback;
 }
 
-/** `_harness_setup._theme_of_dir` — the marker, else the sigil in one of five carriers. */
+/**
+ * A marker value that can only name a file directly in the themes dir: no separator, no `..`,
+ * and not a `_`-prefixed scaffold.
+ */
+const THEME_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+
+/**
+ * `_harness_setup._theme_of_dir` — the marker, else the sigil in one of five carriers.
+ *
+ * The marker's value becomes `<themes>/<name>.json` in `loadTheme`, so a path in it
+ * (`../harness.config`) loaded any `.json` as a theme. A value that is not a plain name falls
+ * through to the sigil scan, as a missing marker does. A plain name that is not shipped is
+ * still RETURNED: `loadTheme` then refuses it loudly, which `status`/`rebuild-all`/`migrate`
+ * cells pin ("unknown theme 'nosuchtheme'"), rather than a typo going unnoticed.
+ */
 export function themeOfDir(d) {
   const marker = path.join(d, '.geneseed-theme');
   if (isFile(marker)) {
     const name = (readMaybe(marker) ?? '').trim();
-    if (name) return name;
+    if (THEME_NAME_RE.test(name)) return name;
   }
   return firstCarrier(d, (carrierPath) => themeFromAgent(carrierPath) || undefined);
 }
@@ -210,7 +224,7 @@ export function footprintOfDir(d) {
  * the string, so a posture file named `Foreman` renders `**Foreman**` and one named `FOREMAN`
  * would be scanned for as `**Foreman**` by both implementations only if this reproduces the
  * lowercasing. Every shipped name is already lowercase, which is exactly why the difference
- * would go unnoticed — the corpus in `tests/test_pure_function_parity.py` is what covers it.
+ * would go unnoticed — the former Python corpus covered it, and no test drives it now.
  */
 export function capitalize(s) {
   return s.length ? s[0].toUpperCase() + s.slice(1).toLowerCase() : s;
@@ -239,10 +253,15 @@ export const modeOfDir = (d) => leadOfDir(d, discoverNames('modes', 'direct'));
  * `Default trust preset: **<Label>**` line, and this scans the places an emit lands it: the
  * native layer (`skills/loop/SKILL.md`, in the root itself for a global install and under the
  * host's `projectMarker` for a project one) and the plain bundle (`skills/loop.md`).
+ *
+ * `host` narrows the project dirs to that host's own: in a repo carrying `.opencode/` AND
+ * `.claude/`, the Claude row otherwise read OpenCode's preset, since OpenCode comes first in
+ * `HOSTS`. Without it every host's dir is tried, in `HOSTS` order — the caller that has no host.
  */
 const TRUST_RE = /^Default trust preset: \*\*(Prudent|Balanced|Aggressive)\*\*/m;
-export function trustOfDir(d) {
-  for (const base of ['', ...HOSTS.map((h) => h.projectMarker)]) {
+export function trustOfDir(d, host = null) {
+  const rows = host === null ? HOSTS : HOSTS.filter((h) => h.host === host);
+  for (const base of ['', ...rows.map((h) => h.projectMarker)]) {
     for (const rel of [['skills', 'loop', 'SKILL.md'], ['skills', 'loop.md']]) {
       const m = TRUST_RE.exec(readMaybe(path.join(d, base, ...rel)) ?? '');
       if (m) return m[1].toLowerCase();
@@ -406,13 +425,13 @@ export function manifestIsClaude(cfgDir) {
   return isDict(claudeReadManifest(cfgDir).managed);
 }
 
-/** `_harness_mcp._EMIT_HOST_SCOPE` — a marker's emit name fixes (host, scope). */
-export const EMIT_HOST_SCOPE = new Map([
-  ['opencode', ['opencode', 'project']], ['opencode-global', ['opencode', 'global']],
-  ['claude', ['claude', 'project']], ['claude-global', ['claude', 'global']],
-  ['bob', ['bob', 'project']], ['bob-global', ['bob', 'global']],
-  ['openclaude', ['openclaude', 'project']], ['openclaude-global', ['openclaude', 'global']],
-]);
+/**
+ * `_harness_mcp._EMIT_HOST_SCOPE` — a marker's emit name fixes (host, scope). Derived from
+ * `HOSTS`, whose emit names are `<host>` and `<host>-global`, so a new host is one row there.
+ */
+export const EMIT_HOST_SCOPE = new Map(HOSTS.flatMap(({ host }) => [
+  [host, [host, 'project']], [`${host}-global`, [host, 'global']],
+]));
 
 /** `_harness_mcp._emit_host_scope_of` — `root`'s own marker, resolved, or null. */
 export function emitHostScopeOf(root) {

package/js/hosts/link.mjs

@@ -57,8 +57,8 @@
  * never needs to:
  *
  *   * `winUserPathScript` is PURE — the escaping, the split and the idempotence live there
- *     and `tests/test_win_user_path.py` runs it over a corpus (apostrophes, trailing
- *     separators, UNC roots) against the Python twin, byte for byte.
+ *     and `tests/unit/win_user_path.test.mjs` runs it over a corpus of hazards (apostrophes,
+ *     typographic quotes, trailing separators, UNC roots) and asserts each property absolutely.
  *   * `cmdLink` SHORT-CIRCUITS when the bin dir is already on `PATH`, so a cell that seeds
  *     `PATH` with its own sandboxed bin dir exercises the whole verb and never spawns.
  *   * `cmdUnlink` has no such short-circuit, so its cells seed a `PATH` with no `powershell`
@@ -81,9 +81,11 @@ import os from 'node:os';
 import { ROOT } from '../build/source.mjs';
 import { readMaybe } from './installs.mjs';
 import { printOut, printErr, writeText } from '../lib/fs.mjs';
-import { toPlatformPath } from '../lib/paths.mjs';
+import { toPlatformPath, which } from '../lib/paths.mjs';
 
 const IS_WIN = process.platform === 'win32';
+/** What `cmdUnlink` recognises a written Unix launcher by — see `isOurLauncher`. */
+const SHIM_MARKER = 'GENESEED_LINK_SHIM';
 
 /** `_harness_lifecycle._win_bin_dir`. */
 function winBinDir() {
@@ -97,12 +99,18 @@ function winBinDir() {
  * `_harness_lifecycle._win_user_path_script` — the PowerShell one-liner, built but not run.
  *
  * Every quoting hazard in this verb is in this string, which is why it is a separate
- * function on both sides: `''` is PowerShell's single-quote escape, the `;` split drops
+ * function: `''` is PowerShell's single-quote escape, the `;` split drops
  * empty segments so a trailing separator cannot append an empty entry, and `-notcontains`
  * is what makes `link` idempotent.
+ *
+ * THE ESCAPE COVERS FIVE CHARACTERS, NOT ONE. PowerShell also reads the typographic quotes
+ * U+2018–U+201B as single quotes, so one of them left bare in a directory name closes the
+ * string exactly as `'` does and turns the rest of the path into code. Each is doubled with
+ * ITSELF — `‘‘` is the escape for `‘` — which is what PowerShell's own `CodeGeneration.
+ * EscapeSingleQuotedStringContent` does.
  */
 export function winUserPathScript(action, directory) {
-  const d = directory.replaceAll("'", "''");   // PS single-quote escape (O'Brien)
+  const d = directory.replace(/['‘-‛]/g, '$&$&');   // PS single-quote escape (O'Brien)
   if (action === 'add') {
     return `$d='${d}';`
       + "$p=[Environment]::GetEnvironmentVariable('Path','User');"
@@ -134,13 +142,56 @@ export function winUserPathScript(action, directory) {
  * false rather than crashing the verb.
  */
 function winUserPath(action, directory) {
-  const r = spawnSync('powershell',
+  // `which`, never a bare name: Windows resolves a bare name against the cwd first, and
+  // `which` never searches the cwd implicitly (see its docblock).
+  const ps = which('powershell');
+  if (!ps) return false;
+  const r = spawnSync(ps,
     ['-NoProfile', '-Command', winUserPathScript(action, directory)],
     { stdio: 'inherit', windowsHide: true });
   if (r.error) return false;
   return r.status === 0;
 }
 
+/**
+ * Is `dir` one of the ENTRIES of a Windows PATH string?
+ *
+ * Entry-wise, not a substring test: `…\Geneseed\bin` is a substring of `…\Geneseed\bin2` and of
+ * `…\Geneseed\bin\old`, and a substring hit skipped the registry write while the shim's own dir
+ * stayed off PATH. Trailing separators and case are both noise on Windows.
+ */
+export function winPathHas(pathEnv, dir) {
+  const norm = (s) => s.replace(/[\\/]+$/, '').toLowerCase();
+  const want = norm(dir);
+  return pathEnv.split(';').some((e) => e && norm(e) === want);
+}
+
+/**
+ * The Unix launcher's text. Single-quoted, never double: inside `"…"` the shell still expands
+ * `$`, backticks and `\`, so an install path holding any of them ran as code each time
+ * `geneseed` started. `'\''` is the one escape single quotes need.
+ */
+export function unixShimText(exe, entry) {
+  const q = (s) => `'${s.replaceAll("'", "'\\''")}'`;
+  return `#!/bin/sh\n# ${SHIM_MARKER}\nexec ${q(exe)} ${q(entry)} "$@"\n`;
+}
+
+/**
+ * Is the file at `f` a launcher `geneseed link` made? Two shapes exist on disk. (a) A symlink,
+ * judged by `os.readlink(f)` raw, then `.name` — NOT a resolved path: the question is whether
+ * the link's own target BASENAME is `geneseed`, so a symlink pointing at some other program
+ * that happens to sit in a `geneseed` directory is left alone. That is every install made
+ * before the shim. (b) A regular file carrying the marker — never "any regular file called
+ * geneseed", which would be npm's own bin link or a stranger's program.
+ *
+ * ONE OWNER FOR BOTH VERBS. `unlink` always refused what is not ours; `link` used to delete
+ * whatever sat at its destination before writing, so the two disagreed about the same file.
+ */
+function isOurLauncher(f) {
+  if (isSymlink(f)) return path.basename(readlinkSync(f)) === 'geneseed';
+  return existsSync(f) && (readMaybe(f) ?? '').includes(SHIM_MARKER);
+}
+
 /** `_harness_lifecycle.cmd_link` — put `geneseed` on PATH so it runs from any directory. */
 export function cmdLink(args) {
   const here = ROOT;
@@ -159,8 +210,7 @@ export function cmdLink(args) {
       return 1;
     }
     printOut(`geneseed: wrote shim ${shim}\n`);
-    const on_path = (process.env.PATH || '').toLowerCase().includes(bindir.toLowerCase());
-    if (on_path || winUserPath('add', bindir)) {
+    if (winPathHas(process.env.PATH || '', bindir) || winUserPath('add', bindir)) {
       printOut(`geneseed: '${bindir}' is on your user PATH — open a NEW terminal, then run \`geneseed\`.\n`);
     } else {
       printOut(`geneseed: add '${bindir}' to your PATH manually, then run \`geneseed\` from anywhere.\n`);
@@ -174,8 +224,8 @@ export function cmdLink(args) {
   // PATH=` line) as well as comparing it against `PATH.split(os.pathsep)`, so an argument
   // that is not already normalised diverges in three places at once. A trailing slash is the
   // cheapest one: `str(Path('/x/bin/'))` is `/x/bin` and the raw string is not.
-  // `harness_golden`'s `link/an-explicit-dir-argument-is-used-instead-of-the-default` passes
-  // one, and it is the cell that found this.
+  // The retired cell `link/an-explicit-dir-argument-is-used-instead-of-the-default` passed
+  // one, and it is what found this.
   let targetDir = args.dir ? toPlatformPath(args.dir) : null;
   if (targetDir === null) {
     const local = path.join(os.homedir(), '.local', 'bin');
@@ -191,16 +241,23 @@ export function cmdLink(args) {
   try {
     mkdirSync(targetDir, { recursive: true });
     // `dest.is_symlink() or dest.exists()` — the first half is what catches a BROKEN
-    // symlink, which `existsSync` follows and reports absent.
-    if (isSymlink(dest) || existsSync(dest)) rmSync(dest, { force: true });
+    // symlink, which `existsSync` follows and reports absent. Only OUR launcher is replaced:
+    // anything else there — npm's own bin link, a stranger's program — is refused, the same
+    // judgement `cmdUnlink` makes about the same file.
+    if (isSymlink(dest) || existsSync(dest)) {
+      if (!isOurLauncher(dest)) {
+        printErr(`geneseed: ${dest} exists and is not a launcher geneseed wrote — leaving it `
+          + 'alone. Remove it yourself, or pick another dir: geneseed link <dir>\n');
+        return 1;
+      }
+      rmSync(dest, { force: true });
+    }
     // A WRITTEN SHIM, not a symlink to `ROOT/geneseed`. The bash launcher execs a Python
     // interpreter, so symlinking it puts Python on PATH from the Node verb. The Windows
-    // arm above has always written a shim; this is the same shape. `GENESEED_LINK_SHIM`
-    // is the marker `cmdUnlink` recognises — without it, unlink cannot tell our file from
+    // arm above has always written a shim; this is the same shape. `SHIM_MARKER`
+    // is what `cmdUnlink` recognises — without it, unlink cannot tell our file from
     // a stranger's and would have to refuse every regular file, which is a no-op.
-    writeText(dest, '#!/bin/sh\n'
-      + '# GENESEED_LINK_SHIM\n'
-      + `exec "${process.execPath}" "${entry}" "$@"\n`);
+    writeText(dest, unixShimText(process.execPath, entry));
     chmodSync(dest, 0o755);
   } catch (e) {
     printErr(`geneseed: could not write ${dest} (${asOsError(e)}) — pick a writable dir: `
@@ -246,15 +303,7 @@ export function cmdUnlink() {
     if (seen.has(d)) continue;
     seen.add(d);
     const f = path.join(d, 'geneseed');
-    // TWO shapes, because two shapes exist on disk. (a) `os.readlink(f)` raw, then `.name`
-    // — NOT a resolved path: the reference asks whether the link's own target BASENAME is
-    // `geneseed`, so a symlink pointing at some other program that happens to sit in a
-    // `geneseed` directory is left alone. That is every install made before the shim.
-    // (b) a regular file we wrote, identified by its marker — never "any regular file
-    // called geneseed", which would delete a stranger's program.
-    const ours = (isSymlink(f) && path.basename(readlinkSync(f)) === 'geneseed')
-      || (!isSymlink(f) && existsSync(f) && (readMaybe(f) ?? '').includes('GENESEED_LINK_SHIM'));
-    if (ours) {
+    if (isOurLauncher(f)) {
       try {
         rmSync(f);
         printOut(`geneseed: removed ${f}\n`);

package/js/hosts/memory-files.mjs

@@ -74,18 +74,25 @@ function globMd(dir) {
     && isFile(path.join(dir, n)));
 }
 
+/** Stems that name the store's own files, never a fact — `MEMORY` is the index itself. */
+const RESERVED_STEMS = new Set(['memory', 'readme']);
+
 /** `_existing_slugs` — slugs already stored, so learn never re-emits a known fact. */
 export function existingSlugs(memDir) {
-  const skip = new Set(['memory', 'readme']);
-  return new Set(globMd(memDir).map(stem).filter((s) => !skip.has(s.toLowerCase())));
+  return new Set(globMd(memDir).map(stem).filter((s) => !RESERVED_STEMS.has(s.toLowerCase())));
 }
 
 /**
  * `_write_memories` — split the model output into files, write each NEW one, and append a
  * pointer line to MEMORY.md. `existing` is MUTATED, so a reply carrying the same slug
  * twice writes it once.
+ *
+ * A reserved stem is refused (`name: MEMORY` would overwrite the index), and names compare
+ * LOWERCASE: on Windows and macOS `User-Prefs.md` and `user-prefs.md` are one file, so a
+ * case variant of a stored slug would overwrite it.
  */
 export function writeMemories(modelOutput, memDir, existing) {
+  const taken = new Set([...existing].map((s) => s.toLowerCase()));
   const written = [];
   const indexLines = [];
   for (let chunk of modelOutput.split(FILE_SEP_RE)) {
@@ -93,9 +100,11 @@ export function writeMemories(modelOutput, memDir, existing) {
     if (!chunk || chunk.toUpperCase() === 'NOTHING') continue;
     const [fm] = frontmatter(chunk);
     const name = fmGet(fm, 'name').trim();
-    if (!MEMORY_SLUG_RE.test(name) || existing.has(name)) continue;
+    const key = name.toLowerCase();
+    if (!MEMORY_SLUG_RE.test(name) || RESERVED_STEMS.has(key) || taken.has(key)) continue;
     writeText(path.join(memDir, `${name}.md`), `${chunk.replace(/\n+$/, '')}\n`);
     existing.add(name);
+    taken.add(key);
     written.push(name);
     const desc = fmGet(fm, 'description').trim();
     indexLines.push(`- [${name}](${name}.md)${desc ? ` \u2014 ${desc}` : ''}`);
@@ -147,7 +156,7 @@ export function memoryDropIndex(memDir, name) {
  * the user's to keep).
  */
 export function consolidateMemory(memDir) {
-  const skip = new Set(['memory', 'readme']);
+  const skip = RESERVED_STEMS;
   const facts = new Map();
   for (const name of sortPaths(globMd(memDir))) {
     const s = stem(name);

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.