geneseed 3.13.0 → 3.15.0

package/js/hosts/memory-files.mjs

@@ -0,0 +1,190 @@
+/**
+ * The memory store's file format — fact files with frontmatter, the `MEMORY.md` index, the
+ * per-agent lesson files — read and written without spawning anything.
+ *
+ * SPLIT FROM `learn` FOR THE CLI's SAKE. `learn` spawns the model CLI, and the web console
+ * (`js/web/api.mjs`, `js/web/actions.mjs`), `geneseed memory` (`js/maintain/memory.mjs`) and the
+ * loop catalogue (`js/loop/catalog.mjs`) imported the hook module only for `frontmatter` and
+ * `memoryDropIndex` — which dragged `node:child_process` into `bin/geneseed-cli.mjs`'s closure
+ * and made the hook module a row in `tests/unit/hook_cli.test.mjs`'s spawn allow-list for a
+ * spawn the CLI never makes. Everything here is fs-only; `hooks-learn.mjs` is the one spawner.
+ */
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { readText, writeText } from '../lib/fs.mjs';
+import { normcase } from '../lib/paths.mjs';
+import { isFile, listDir, sortPaths, splitLines, splitWords } from './hooks-prims.mjs';
+
+const FRONTMATTER_RE = /^\s*---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+const FILE_SEP_RE = /^---FILE---[^\S\n]*$/m;
+// A memory `name:` becomes a FILENAME and the model writes it, so it is a plain slug or
+// nothing — no separator, no `..`, no drive. Looser than `hooks-learn.mjs`'s AGENT_NAME_RE on
+// purpose: a memory slug is a phrase (case and length vary), and a refused one is a fact
+// silently lost.
+const MEMORY_SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+const MAX_AGENT_BULLETS = 100;
+
+/** `append_agent_lesson` — one dated bullet, capped at the newest MAX_AGENT_BULLETS. */
+export function appendAgentLesson(memDir, agent, lesson) {
+  const d = path.join(memDir, 'agents');
+  mkdirSync(d, { recursive: true });
+  const f = path.join(d, `${agent}.md`);
+  let bullets = [];
+  if (existsSync(f)) bullets = splitLines(readText(f)).filter((l) => l.startsWith('- '));
+  const now = new Date();
+  const day = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-`
+    + `${String(now.getDate()).padStart(2, '0')}`;
+  bullets.push(`- ${day}: ${splitWords(lesson).join(' ')}`);
+  bullets = bullets.slice(-MAX_AGENT_BULLETS);
+  writeText(f, `# ${agent} \u2014 lessons\n${bullets.join('\n')}\n`);
+  return f;
+}
+
+/**
+ * `_frontmatter` — leading YAML-ish frontmatter as a flat map, plus the body.
+ *
+ * Exported since P6b, whose `memoryItems` reads `name` and `description` off a fact file
+ * exactly as `_web_catalog._memory_items` does. That makes the web its SECOND owner, which
+ * this port treats as a coverage event rather than a tidiness one — the fields it produces
+ * are unreachable from a P6b cell (only the COUNT is consumed) and P6c's catalog cells are
+ * what gate them.
+ */
+export function frontmatter(md) {
+  const m = FRONTMATTER_RE.exec(md);
+  if (!m) return [new Map(), md];
+  const fm = new Map();
+  for (const line of splitLines(m[1])) {
+    const at = line.indexOf(':');
+    if (at >= 0) {
+      // `str.strip('"')` strips the character from BOTH ends, however many there are.
+      fm.set(line.slice(0, at).trim(), line.slice(at + 1).trim().replace(/^"+|"+$/g, ''));
+    }
+  }
+  return [fm, m[2]];
+}
+
+const fmGet = (fm, key) => (fm.has(key) ? fm.get(key) : '');
+
+/** `Path.stem` for a filename. */
+const stem = (name) => path.basename(name, path.extname(name));
+
+/** `mem_dir.glob("*.md")` — case-INSENSITIVE on Windows, as pathlib's glob is. */
+function globMd(dir) {
+  return listDir(dir).filter((n) => normcase(n).endsWith('.md')
+    && 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) {
+  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)) {
+    chunk = chunk.trim();
+    if (!chunk || chunk.toUpperCase() === 'NOTHING') continue;
+    const [fm] = frontmatter(chunk);
+    const name = fmGet(fm, 'name').trim();
+    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}` : ''}`);
+  }
+  if (indexLines.length) {
+    const index = path.join(memDir, 'MEMORY.md');
+    const current = existsSync(index) ? `${readText(index).replace(/\n+$/, '')}\n`
+      : '# Memory Index\n';
+    writeText(index, `${current}${indexLines.join('\n')}\n`);
+  }
+  return written;
+}
+
+/**
+ * `_harness_tui_views._memory_drop_index` — remove the index line(s) naming `<name>.md`.
+ *
+ * ITS PYTHON HOME IS THE TUI, and it is here because this is where its SIBLINGS' twins are:
+ * `appendAgentLesson` writes the index lines this deletes and `consolidateMemory` rebuilds
+ * them, so the three rules about MEMORY.md's format live together rather than one of them
+ * living beside a web endpoint. P7 ports the TUI's memory view onto this same function.
+ *
+ * The P6f plan asked whether P5's `learn` had already brought it across. It had not —
+ * nothing in `js/` referenced it — which is the third time a plan's "already ported" column
+ * was answered by reading rather than by trusting.
+ *
+ * SUBSTRING, NOT PARSE, exactly as the reference is: any line containing `(<name>.md)` goes,
+ * so a hand-written index in a different shape still loses its entry. And the file is only
+ * REWRITTEN when something actually changed, which keeps a delete of an unindexed fact from
+ * touching the user's mtime.
+ */
+export function memoryDropIndex(memDir, name) {
+  const idx = path.join(memDir, 'MEMORY.md');
+  let lines;
+  try {
+    lines = splitLines(readText(idx));
+  } catch {
+    return;                       // the reference's `except OSError: return`
+  }
+  const keep = lines.filter((ln) => !ln.includes(`(${name}.md)`));
+  if (keep.length === lines.length) return;
+  try {
+    writeText(idx, `${keep.join('\n')}\n`);
+  } catch { /* the reference swallows OSError here too */ }
+}
+
+/**
+ * `consolidate_memory` — rebuild MEMORY.md from the fact files actually on disk: index
+ * orphans, prune dead lines, report duplicate descriptions (never auto-merge — nuance is
+ * the user's to keep).
+ */
+export function consolidateMemory(memDir) {
+  const skip = RESERVED_STEMS;
+  const facts = new Map();
+  for (const name of sortPaths(globMd(memDir))) {
+    const s = stem(name);
+    if (skip.has(s.toLowerCase())) continue;
+    try {
+      facts.set(s, fmGet(frontmatter(readText(path.join(memDir, name)))[0], 'description').trim());
+    } catch { continue; }
+  }
+  const index = path.join(memDir, 'MEMORY.md');
+  const oldSlugs = new Set();
+  if (existsSync(index)) {
+    for (const line of splitLines(readText(index))) {
+      const m = /^- \[[^\]]*\]\(([^)]+)\.md\)/.exec(line.trim());
+      if (m) oldSlugs.add(m[1]);
+    }
+  }
+  const lines = ['# Memory Index', ''];
+  for (const [slug, desc] of facts) {
+    lines.push(`- [${slug}](${slug}.md)${desc ? ` \u2014 ${desc}` : ''}`);
+  }
+  writeText(index, `${lines.join('\n')}\n`);
+  const seen = new Map();
+  const dups = [];
+  for (const [slug, desc] of facts) {
+    if (desc && seen.has(desc)) dups.push([seen.get(desc), slug]);
+    if (!seen.has(desc)) seen.set(desc, slug);
+  }
+  const added = [...facts.keys()].filter((s) => !oldSlugs.has(s)).sort();
+  const pruned = [...oldSlugs].filter((s) => !facts.has(s)).sort();
+  return { added, pruned, duplicates: dups };
+}

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,15 @@ 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)) {
+    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 +324,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}`);