geneseed 3.17.0 → 3.18.0

package/js/hosts/installs.mjs

@@ -35,7 +35,7 @@
 import { existsSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 
-import { CONFIG, PACK_ORDER, THEMES, discoverNames, knownSkillIds } from '../build/source.mjs';
+import { CONFIG, PACK_ORDER, THEMES, discoverNames, resolveSkillNames } from '../build/source.mjs';
 import { CLAUDE_STYLE, GLOBAL_MANIFEST, HOSTS, resolvePath } from './hosts.mjs';
 import { registryRoots } from '../inspect/registry.mjs';
 import { printErr, readText, isFile, isDir } from '../lib/fs.mjs';
@@ -408,7 +408,7 @@ export function excludedRulesOfDir(d) {
   }, []);
 }
 
-/** `Excluded skills: bruno-test-writer, daydream` — written only when something is excluded. */
+/** `Excluded skills: bruno, daydream` — written only when something is excluded. */
 const EXCLUDED_SKILLS_RE = /^Excluded skills:[ \t]*(.+?)[ \t]*$/m;
 
 /**
@@ -416,17 +416,23 @@ const EXCLUDED_SKILLS_RE = /^Excluded skills:[ \t]*(.+?)[ \t]*$/m;
  * re-render the same set. Same semantics as `excludedRulesOfDir`: a missing line is `[]`
  * (nothing excluded), and a name this checkout does not ship condemns the whole line to `[]`
  * — re-admitting a skill is the safe direction, and the flag would refuse the name anyway.
+ *
+ * A name that only got OLDER is not unknown: an alias reads back as its target and a retired
+ * name drops out (`resolveSkillNames`), so a skill merge does not quietly re-admit everything
+ * else the install left out. Silent unless the caller passes `notify` — status, diff and the
+ * console call this on every read; the replays that rebuild an install (`rebuild-all`,
+ * `upgrade`, `migrate`) pass it.
  */
-export function excludedSkillsOfDir(d) {
+export function excludedSkillsOfDir(d, notify = null) {
   return firstCarrier(d, (carrierPath) => {
     const text = readMaybe(carrierPath);
     if (text === null) return undefined;
     const m = EXCLUDED_SKILLS_RE.exec(text);
     if (!m) return undefined;
-    const names = m[1].split(',').map((s) => s.trim()).filter(Boolean);
-    const known = knownSkillIds();
-    if (!names.every((n) => known.includes(n))) return [];
-    return [...new Set(names)].sort();
+    const { ids, notices, unknown } = resolveSkillNames(m[1].split(',').map((s) => s.trim()).filter(Boolean));
+    if (unknown.length) return [];
+    if (notify) for (const n of notices) notify(n);
+    return ids;
   }, []);
 }
 

package/js/hosts/mcp.mjs

@@ -5,7 +5,7 @@
  * at "~90 new, already in js/: `_mcp_load`/`readJsonc` (P6c), `settings.mjs`'s atomic write".
  * Measured against `js/`: `readJsonc` had crossed and NOTHING ELSE HAD. `js/web/api.mjs`
  * carries a five-line `mcpLoad` that is the no-host, comment-tolerant reader P6c needed for
- * `wiki.jsonc`, which is one arm of one of these thirteen functions. `_MCP_PRESETS`,
+ * `geneseed-wiki.jsonc`, which is one arm of one of these thirteen functions. `_MCP_PRESETS`,
  * `_mcp_servers_key`, `_mcp_preset_block`, `_mcp_apply`, `_mcp_state`, `_mcp_set_enabled`,
  * `_mcp_load`'s host fork, `_mcp_commented`, `_mcp_save`, `_mcp_config_for`,
  * `_mcp_install_targets`, `_mcp_known_names` and `_mcp_meta` are 168 lines of Python, all

package/js/hosts/native.mjs

@@ -32,6 +32,7 @@ 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';
+import { aliasesOf } from '../build/source.mjs';
 
 /** What a folder skill writes where it needs its own directory — see `writeNativeLayer`. */
 const SKILL_DIR_PLACEHOLDER = '<this-skill-directory>';
@@ -253,6 +254,25 @@ export function stripSkillBodyLinks(body) {
   return body.replace(SKILL_BODY_LINK_RE, '$1');
 }
 
+/**
+ * A first-party skill's SIDE FILES (`src/skills/<stem>/<file>`, beside the flat spec) are
+ * linked from the spec as `[…](<stem>/<file>)` — the path that resolves in `src/` and in the
+ * flat bundle, where doctor's dead-link scan proves it. A native skill sits one level deeper
+ * (`skills/<stem>/SKILL.md`), and an alias or a command copies the body somewhere else again,
+ * so there the link becomes a code-span path under `dir`: the placeholder a host that
+ * announces the skill's base directory resolves, or the answer for one that does not.
+ *
+ * A link with an `#anchor` (which `sideFileProblems` accepts) gets the same pointer with the
+ * anchor DROPPED: the pointer is a path the agent hands to a file-read tool, and
+ * `deep.md#two` names no file. Left unmatched, `stripSkillBodyLinks` would reduce the link to
+ * its label and the agent would never learn where the file is.
+ */
+export function pointSideFiles(body, stem, dir) {
+  // A function, not a `$1` string: `dir` is a real path and may itself hold a `$`.
+  return body.replace(new RegExp(`\\[[^\\]]+\\]\\(${stem}/([^)\\s#]+)(?:#[^)\\s]*)?\\)`, 'g'),
+    (_m, f) => `\`${dir}/${f}\``);
+}
+
 /** `_build_emit._agent_color_map` — validated, always a valid OpenCode slot. */
 function agentColorMap(theme) {
   let raw = null;
@@ -479,8 +499,8 @@ export function claimer(oldOwned, cfg, manifestExisted = true) {
  * `<this-skill-directory>/…`; Claude Code resolves that because it announces each skill's
  * base directory on load, while on Bob the model got the text with a hole in it and went
  * hunting through the filesystem. With the option, every rendered `.md` of a vendored folder
- * has the placeholder replaced by the answer. Only vendored folders carry the placeholder — a
- * flat skill has no siblings to point at.
+ * has the placeholder replaced by the answer. A flat skill with side files points at them
+ * through the same option (`pointSideFiles`), placeholder when it is absent.
  *
  * `opts.claim` — a `claimer` closure the caller shares with its other writers; built from
  * `oldOwned`/`cfg`/`manifestExisted` when absent.
@@ -498,13 +518,15 @@ export function claimer(oldOwned, cfg, manifestExisted = true) {
  */
 export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null, {
   host = 'opencode', oldOwned = null, cfg = null, manifestExisted = true,
-  theme = null, src, skillDirOf = null, claim = claimer(oldOwned, cfg, manifestExisted),
+  theme = null, src = undefined, skillDirOf = null, claim = claimer(oldOwned, cfg, manifestExisted),
 } = {}) {
   const ov = overrides || {};
   if (host === 'claude') warnClaudeIgnored(ov);
   let nAgents = 0;
   let nSkills = 0;
   const written = [];
+  const sideFiles = [];            // [stem, dest, text], written after the loop
+  const claimedSkills = new Set(); // stems whose own SKILL.md claim held
 
   const write = (dest, text) => {
     mkdirSync(path.dirname(dest), { recursive: true });
@@ -534,6 +556,15 @@ export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null,
       continue;
     }
     if (text === null) continue;
+    // A first-party side file rides next to its skill's SKILL.md, read only when the body
+    // points the agent at it; not a skill, so not counted. `sideFileProblems` holds the
+    // layout (a flat spec beside it, one level, `.md`, linked from the body). Held until the
+    // loop ends: written only once its skill's own SKILL.md claim held (the alias rule), so a
+    // user's file at the target never gets a geneseed side file dropped beside it.
+    if (sparts.length === 3 && sparts[0] === 'skills') {
+      sideFiles.push([sparts[1], path.join(skillsDir, sparts[1], sparts[2]), text]);
+      continue;
+    }
     if (sparts.length !== 2 || !sparts[1].endsWith('.md')) continue;
     const [folder, fname] = sparts;
     const targetDir = { agents: agentsDir, skills: skillsDir }[folder];
@@ -567,18 +598,42 @@ export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null,
     } else {
       // Skills are BYTE-IDENTICAL across hosts: name + description, body link-stripped.
       // The user-only key is emitted for every host too — Claude Code and Bob honour it,
-      // OpenCode ignores an unknown key — so the identity holds.
+      // OpenCode ignores an unknown key — so the identity holds. ALIASES are the one
+      // exception: OpenCode has no user-only skill, so an alias skill there would land in the
+      // model's catalogue as a duplicate; it gets a command instead (`writeAliasCommands`).
       fm = [`name: ${stem}`, `description: ${jsonDumps(skillDescription(text))}`];
       if (isUserInvokedOnly(text)) fm.push('disable-model-invocation: true');
-      body = stripSkillBodyLinks(body);
+      body = stripSkillBodyLinks(pointSideFiles(body, stem, skillDirOf ? skillDirOf(stem)
+        : SKILL_DIR_PLACEHOLDER));
       dest = path.join(skillsDir, stem, 'SKILL.md');
       kind = 'skill';
     }
     if (!claim(dest)) continue;
     write(dest, `---\n${fm.join('\n')}\n---\n\n${body}`);
+    if (kind === 'skill') claimedSkills.add(stem);
+    // An old name keeps answering `/name`: user-only, so the model's catalogue lists the
+    // skill once. Read off the already-filtered items, so excluding the target drops its
+    // aliases; through `claim`, so manifest, prune and uninstall own them; not counted.
+    // Only once the target's own claim held: a user's file at the target gets no alias
+    // pointing at a skill this install never wrote.
+    if (kind === 'skill' && host === 'claude') {
+      // The host announces the ALIAS's folder as the base directory, so a side-file pointer
+      // climbs back to the target's.
+      const aliasBody = skillDirOf ? body : stripSkillBodyLinks(
+        pointSideFiles(lstripNewlines(text), stem, `${SKILL_DIR_PLACEHOLDER}/../${stem}`));
+      for (const alias of aliasesOf(text)) {
+        const aliasDest = path.join(skillsDir, alias, 'SKILL.md');
+        if (!claim(aliasDest)) continue;
+        write(aliasDest, `---\nname: ${alias}\ndescription: ${jsonDumps(`Alias of ${stem}.`)}\n`
+          + `disable-model-invocation: true\n---\n\n${aliasBody}`);
+      }
+    }
     if (kind === 'agent') nAgents += 1;
     else nSkills += 1;
   }
+  for (const [stem, dest, text] of sideFiles) {
+    if (claimedSkills.has(stem) && claim(dest)) write(dest, stripSkillBodyLinks(text));
+  }
   return { nAgents, nSkills, written };
 }
 

package/js/hosts/opencode.mjs

@@ -27,7 +27,8 @@ import { writeText, readText, copyFile } from '../lib/fs.mjs';
 import { jsonDumps, jsonDumpsIndent, parseJson } from '../lib/json.mjs';
 import { comparePaths } from '../lib/paths.mjs';
 import { sourceReleaseVersion } from '../build/version.mjs';
-import { firstBlockquote, stripSkillBodyLinks, pushOverrideLines } from './native.mjs';
+import { aliasesOf } from '../build/source.mjs';
+import { firstBlockquote, stripSkillBodyLinks, pointSideFiles, pushOverrideLines } from './native.mjs';
 
 // Re-exported for `js/web/api.mjs` and the tests, which import it from here.
 export { sourceReleaseVersion };
@@ -104,7 +105,7 @@ const AGENT_OVERRIDES_STUB = {
  * `/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 = {
+export const COMMAND_SET = {
   commit: 'commit', plan: 'plan', 'code-review': 'geneseed-code-review',
   'review-response': 'review-response', ship: 'ship', debug: 'debug', research: 'research',
 };
@@ -276,7 +277,7 @@ export function ensureAgentOverridesStub(cfg, base) {
  * `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) {
+export function writePrimaryAgent(cfg, agentsDir, overrides, claim = (_dest) => true) {
   if (!truthyEnv('GENESEED_PRIMARY') || !existsSync(cfg.primaryAgentSrc)
       || !statSync(cfg.primaryAgentSrc).isFile()) {
     return null;
@@ -296,7 +297,8 @@ export function writePrimaryAgent(cfg, agentsDir, overrides, claim = () => true)
 }
 
 /** `_build_emit._write_command_layer` — the opt-in /slash commands. */
-export function writeCommandLayer(cfg, items, commandDir, claim = () => true) {
+export function writeCommandLayer(cfg, items, commandDir, claim = (_dest) => true,
+  skillDirOf = (n) => path.join(path.dirname(commandDir), 'skills', n).split(path.sep).join('/')) {
   if (!truthyEnv('GENESEED_COMMANDS')) return [];
   const byName = new Map();
   for (const { text, src } of items) {
@@ -318,7 +320,8 @@ export function writeCommandLayer(cfg, items, commandDir, claim = () => true) {
     const dest = path.join(commandDir, `${name}.md`);
     if (!claim(dest)) continue;
     const desc = firstBlockquote(text);
-    const body = stripSkillBodyLinks(text.replace(/^\n+/, ''));
+    // A command has no base directory, so a side-file pointer names the skill's own.
+    const body = stripSkillBodyLinks(pointSideFiles(text.replace(/^\n+/, ''), skill, skillDirOf(skill)));
     mkdirSync(path.dirname(dest), { recursive: true });
     writeText(dest, `---\ndescription: ${jsonDumps(desc)}\n---\n\n${body}`);
     written.push(dest);
@@ -326,8 +329,36 @@ export function writeCommandLayer(cfg, items, commandDir, claim = () => true) {
   return written;
 }
 
+/**
+ * A merged skill's OLD names as `/alias` commands — OpenCode's form of the user-only alias
+ * skill `writeNativeLayer` writes for the Claude dialect. A command, not a skill, because
+ * OpenCode has no user-only skill: an alias skill would sit in the model's catalogue as a
+ * second copy of its target. UNCONDITIONAL, unlike the `GENESEED_COMMANDS` set — an old name
+ * that only works behind an opt-in is a name that broke. Read off the already-filtered
+ * `items`, so excluding the target drops its aliases.
+ */
+export function writeAliasCommands(cfg, items, commandDir, claim = (_dest) => true,
+  skillDirOf = (n) => path.join(path.dirname(commandDir), 'skills', n).split(path.sep).join('/')) {
+  const written = [];
+  for (const { text, src } of items) {
+    if (text === null) continue;
+    const sp = path.relative(cfg.src, src).split(path.sep);
+    if (sp.length !== 2 || sp[0] !== 'skills' || !sp[1].endsWith('.md') || sp[1].startsWith('_')) continue;
+    const stem = sp[1].slice(0, -3);
+    const body = stripSkillBodyLinks(pointSideFiles(text.replace(/^\n+/, ''), stem, skillDirOf(stem)));
+    for (const alias of aliasesOf(text)) {
+      const dest = path.join(commandDir, `${alias}.md`);
+      if (!claim(dest)) continue;
+      mkdirSync(path.dirname(dest), { recursive: true });
+      writeText(dest, `---\ndescription: ${jsonDumps(`Alias of ${sp[1].slice(0, -3)}.`)}\n---\n\n${body}`);
+      written.push(dest);
+    }
+  }
+  return written;
+}
+
 /** `_build_emit._write_ponytail_command` — registered UNCONDITIONALLY; null when the user's. */
-export function writePonytailCommand(commandDir, claim = () => true) {
+export function writePonytailCommand(commandDir, claim = (_dest) => true) {
   const dest = path.join(commandDir, 'ponytail.md');
   if (!claim(dest)) return null;
   mkdirSync(path.dirname(dest), { recursive: true });

package/js/hosts/settings.mjs

@@ -165,6 +165,7 @@ const OWNED_BASH = ['rm -rf *', 'git commit*', 'git push*', ...LAW_IV_BASH];
  * caller warns on it. This is the one branch where the boundary can end up with NO Geneseed
  * gate at all while the constitution states the rule — the unsafe direction — so it must not
  * also be the silent one.
+ * @returns {[boolean, string[], string | null]}
  */
 function reconcileOpencodePermission(perm, want) {
   // A `permission` that is not an object, or whose `bash` is not one — OpenCode also accepts a

package/js/hosts/shim.mjs

@@ -215,6 +215,7 @@ function shimIsLive(p) {
  * The fallback is strictly no worse than the old behaviour and far better than emitting
  * commands naming a shim that does not exist — those fail on every hook (9009 under
  * cmd.exe, 127 under sh) and take both gates down with them.
+ * @param {{ runner?: string, entry?: string, platform?: NodeJS.Platform }} [opts]
  */
 export function hookPrefix({ runner, entry, platform = process.platform } = {}) {
   // NOT a default. `runner`/`entry` have no computable fallback on this side — this process's

package/js/inspect/checks-authoring.mjs

@@ -19,7 +19,8 @@ import { readText } from '../lib/fs.mjs';
 import { which } from '../lib/paths.mjs';
 import { NO_WINDOW } from '../lib/proc.mjs';
 import {
-  folderSkillProblems, registryProblems, secretProblems, vendorPinProblems,
+  aliasProblems, folderSkillProblems, registryProblems, secretProblems, sideFileProblems,
+  vendorPinProblems,
 } from './checks-repo.mjs';
 import { constitutionProblems, leanBlockProblems } from './checks-constitution.mjs';
 import { countTableProblems } from './checks-counts.mjs';
@@ -109,6 +110,8 @@ export function authoringProblems() {
   problems.push(...secretProblems());
   problems.push(...vendorPinProblems());
   problems.push(...folderSkillProblems());
+  problems.push(...aliasProblems());
+  problems.push(...sideFileProblems());
   problems.push(...constitutionProblems());
   problems.push(...leanBlockProblems());
   problems.push(...countTableProblems());

package/js/inspect/checks-repo.mjs

@@ -7,15 +7,20 @@
  * itself and compares it against what is on disk.
  */
 import path from 'node:path';
-import { PLUGIN_SRC, ROOT, SRC, THEMES, WORKFLOW_SRC } from '../build/source.mjs';
+import {
+  ALIASES_RE, PLUGIN_SRC, RETIRED_SKILL_IDS, ROOT, SRC, THEMES, WORKFLOW_SRC, aliasesOf, knownSkillIds,
+} from '../build/source.mjs';
 import { VENDORED_SKILL_DIRS } from '../hosts/native.mjs';
+import { COMMAND_SET } from '../hosts/opencode.mjs';
 import { hookShimPath, shimDeadPaths } from '../hosts/shim.mjs';
 import { readText } from '../lib/fs.mjs';
 import { formatRepr, formatValue } from '../lib/json.mjs';
 import { splitLines } from '../lib/udiff.mjs';
 import { ENTITY_STATUSES } from './inventory.mjs';
+import { assessRepo } from './scorecard.mjs';
+import { badgeUrl, renderSvg } from './scorecard-svg.mjs';
 import { isDir, isFile, rglob, srcStems } from './scan.mjs';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 
 /**
  * `_harness_build._registry_keys` — every entity the registry must describe.
@@ -106,6 +111,7 @@ export function registryProblems() {
  *
  * `(?i)` becomes the `i` flag on the last one only, which is where the Python puts it.
  */
+/** @type {Array<[string, RegExp]>} */
 const SECRET_PATTERNS = [
   ['Anthropic API key', /sk-ant-[A-Za-z0-9_-]{20,}/],
   ['OpenAI-style API key', /\bsk-[A-Za-z0-9]{32,}/],
@@ -240,6 +246,83 @@ export function vendorPinProblems() {
   return problems;
 }
 
+/**
+ * Every `<!-- aliases: … -->` name is a clean, unclaimed, single-owner path segment.
+ *
+ * An alias becomes a folder (`skills/<alias>/`) and a command file (`command/<alias>.md`) on
+ * every install, so a name that collides overwrites something: another skill, another
+ * skill's alias, or an OpenCode command (`COMMAND_SET`, `/ponytail`). A retired skill id is
+ * refused as an alias AND as a live skill — `RETIRED_SKILL_IDS` is the list of names that
+ * already meant something on someone's machine. The emit trusts all of this; this is where
+ * it is checked.
+ */
+export function aliasProblems(src = SRC) {
+  const problems = [];
+  const known = knownSkillIds(src);
+  const reserved = new Set([...Object.keys(COMMAND_SET), 'ponytail']);
+  for (const id of known) {
+    if (Object.hasOwn(RETIRED_SKILL_IDS, id)) {
+      problems.push(`[authoring] skill '${id}' reuses a retired skill id (RETIRED_SKILL_IDS)`);
+    }
+  }
+  const owner = new Map();
+  for (const id of known) {
+    let text;
+    try { text = readText(path.join(src, 'skills', `${id}.md`)); } catch { continue; }  // a folder skill
+    // `aliasesOf` reads the FIRST marker line only, so a second one would be dropped in silence.
+    if ((text.match(new RegExp(ALIASES_RE.source, 'gm')) || []).length > 1) {
+      problems.push(`[authoring] skills/${id}.md declares aliases on more than one line — merge them`);
+    }
+    for (const alias of aliasesOf(text)) {
+      const where = `skills/${id}.md alias '${alias}'`;
+      if (!/^[a-z0-9-]+$/.test(alias)) problems.push(`[authoring] ${where} is not [a-z0-9-]+`);
+      else if (known.includes(alias)) problems.push(`[authoring] ${where} is already a skill`);
+      else if (Object.hasOwn(RETIRED_SKILL_IDS, alias)) {
+        problems.push(`[authoring] ${where} is a retired skill id (RETIRED_SKILL_IDS)`);
+      } else if (reserved.has(alias)) problems.push(`[authoring] ${where} is an OpenCode command name`);
+      else if (owner.has(alias)) {
+        problems.push(`[authoring] ${where} is already declared by skills/${owner.get(alias)}.md`);
+      } else owner.set(alias, id);
+    }
+  }
+  return problems;
+}
+
+/**
+ * A first-party skill's side files (`src/skills/<name>/<file>.md`, emitted beside its SKILL.md
+ * and read only when the body points at them) keep the one layout every writer assumes: a flat
+ * `<name>.md` owns the folder, files sit one level down, each is `.md` (rendered and themed),
+ * none is `SKILL.md` (the emit writes that one), and the spec links every one as
+ * `[…](<name>/<file>)` — an unlinked side file ships to every install and is never read.
+ * Vendored folders are exempt: they carry their own SKILL.md and their own layout.
+ */
+export function sideFileProblems(src = SRC) {
+  const problems = [];
+  const dir = path.join(src, 'skills');
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (!e.isDirectory() || e.name.startsWith('_') || VENDORED_SKILL_DIRS.has(e.name)) continue;
+    const name = e.name;
+    let spec;
+    try { spec = readText(path.join(dir, `${name}.md`)); } catch {
+      problems.push(`[authoring] skills/${name}/ has no skills/${name}.md — a side-file folder `
+        + 'belongs to a flat spec (or list a folder skill in VENDORED_SKILL_DIRS)');
+      continue;
+    }
+    for (const f of readdirSync(path.join(dir, name), { withFileTypes: true })) {
+      const where = `skills/${name}/${f.name}`;
+      if (!f.isFile() || !f.name.endsWith('.md')) {
+        problems.push(`[authoring] ${where} — a side file is a .md one level down`);
+      } else if (f.name === 'SKILL.md') {
+        problems.push(`[authoring] ${where} collides with the SKILL.md the emit writes`);
+      } else if (!spec.includes(`](${name}/${f.name})`) && !spec.includes(`](${name}/${f.name}#`)) {
+        problems.push(`[authoring] ${where} is not linked from skills/${name}.md — `
+          + `link it as [${name}/${f.name}](${name}/${f.name}) or delete it`);
+      }
+    }
+  }
+  return problems.sort();
+}
+
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 
 /**
@@ -359,3 +442,82 @@ export function moduleMapProblems() {
   }
   return problems;
 }
+
+/**
+ * The AI Harness Scorecard checks this repo passes, written out — the ratchet's floor.
+ *
+ * Taken from `geneseed scorecard` on main after #209-#213 (security policy, PR template, ARCHITECTURE
+ * and ADRs, the audit and commitlint jobs, Dependabot, coverage, property tests, fuzzing): 26 of 31,
+ * 81.2/100, matching upstream's Python tool check for check. Then the weekly Stryker run and the
+ * offline link check added mutation_testing and stale_doc_detection: 28 of 31, 88.7 (A); the checkJs
+ * pass added type_safety (partial: `strict` is off): 29 of 31, 90.4. Grouped by pillar, in upstream
+ * order.
+ * The ratchet is on `passed`, which upstream sets for any score above zero: `test_suite_exists`
+ * and `error_handling_policy` pass at 1.5 of 3, and a full check sliding to a partial one is
+ * invisible here. A check this repo starts to pass is added by hand; one it stops passing is a
+ * doctor problem until fixed or deliberately removed from this list, in the same commit.
+ */
+export const SCORECARD_FLOOR = [
+  'architecture_doc',
+  'agent_instructions',
+  'adr_presence',
+  'module_boundary_docs',
+  'ci_pipeline_exists',
+  'linter_enforcement',
+  'type_safety',
+  'dependency_auditing',
+  'conventional_commits',
+  'unsafe_code_policy',
+  'test_suite_exists',
+  'feature_matrix_testing',
+  'coverage_measurement',
+  'mutation_testing',
+  'property_based_testing',
+  'fuzz_testing',
+  'contract_tests',
+  'tests_blocking_ci',
+  'code_review_required',
+  'scheduled_ci',
+  'stale_doc_detection',
+  'mr_template',
+  'automated_review',
+  'doc_sync_check',
+  'ai_usage_norms',
+  'small_batch_enforcement',
+  'multiple_approach_culture',
+  'error_handling_policy',
+  'security_critical_marking',
+];
+
+/**
+ * The scorecard ratchet — one problem per `SCORECARD_FLOOR` check that no longer passes.
+ *
+ * DEVELOPMENT CHECKOUT ONLY: it scores `.github/` (CI, CODEOWNERS, the PR template), and
+ * `.github/` is WITHHELD from the npm package (`tests/unit/package_manifest.test.mjs`), so an npm
+ * install would fail half the floor for files it was never meant to carry. A `.git` entry (a
+ * directory in a clone, a FILE in a worktree — hence `existsSync`, not `isDir`) plus
+ * `.github/workflows` is what only a checkout of this repository has. Anything else skips: [].
+ */
+export function scorecardProblems(root = ROOT) {
+  if (!existsSync(path.join(root, '.git')) || !isDir(path.join(root, '.github', 'workflows'))) return [];
+  const a = assessRepo(root);
+  const checks = new Map(a.categories.flatMap((c) => c.checks).map((k) => [k.id, k]));
+  // THE README CARD IS A RENDER OF THIS SAME ASSESSMENT, compared byte for byte: a card that no
+  // longer matches the score is the stale-number problem the badges have, caught the same way.
+  const card = path.join(root, ...SCORECARD_CARD.split('/'));
+  const stale = isFile(card) && readText(card) === renderSvg(a) ? [] : [
+    `[scorecard] ${SCORECARD_CARD} does not match the current score — run: geneseed scorecard --svg ${SCORECARD_CARD}`,
+  ];
+  const readme = path.join(root, 'README.md');
+  if (isFile(readme) && !readText(readme).includes(`(${badgeUrl(a)})`)) {
+    stale.push(`[scorecard] README.md's scorecard badge does not show the current score — set it to ${badgeUrl(a)}`);
+  }
+  return stale.concat(SCORECARD_FLOOR.filter((id) => !checks.get(id)?.passed).map((id) => {
+    const k = checks.get(id);
+    return `[scorecard] ${id} no longer passes — it is in SCORECARD_FLOOR (js/inspect/checks-repo.mjs)`
+      + (k ? `: ${k.evidence}. Fix: ${k.remediation}` : ', and the scorecard has no such check');
+  }));
+}
+
+/** Where the README's scorecard card lives, and what doctor compares against a fresh render. */
+export const SCORECARD_CARD = 'docs/assets/scorecard.svg';

package/js/inspect/diff.mjs

@@ -189,7 +189,10 @@ export function diffCollect({ target = null, theme = null, emit = null, footprin
     // reference render names the temp tree. Mapped back to the deployed dir before comparing,
     // or every such skill reads as edited. A deployment that has since MOVED still differs,
     // and that is real drift — its skills point at a directory that is no longer theirs.
+    // A side-file pointer (and a global OpenCode command's) spells the same directory
+    // `/`-separated, so that spelling is mapped too.
     const deployedDir = resolvePath(dir);
+    const posix = (p) => p.split(path.sep).join('/');
     const rels = [...new Set([...ownedSet(dir), ...ownedSet(expected)])].sort();
     for (const rel of rels) {
       const a = path.join(dir, rel);
@@ -198,7 +201,8 @@ export function diffCollect({ target = null, theme = null, emit = null, footprin
         // `read_text(errors="replace")` — Node's utf8 decoder substitutes U+FFFD for the
         // same bytes, and `readText` folds the line endings the way `Path.read_text` does.
         const ta = readText(a);
-        const tb = readText(b).split(expected).join(deployedDir);
+        const tb = readText(b).split(expected).join(deployedDir)
+          .split(posix(expected)).join(posix(deployedDir));
         if (cmpKey(rel, ta) !== cmpKey(rel, tb)) {
           const diff = unifiedDiff(splitLines(tb), splitLines(ta), {
             fromfile: `source/${rel}`, tofile: `deployed/${rel}`, lineterm: '',

package/js/inspect/doctor.mjs

@@ -40,7 +40,7 @@ import { authoringProblems, loopProblems } from './checks-authoring.mjs';
 import {
   checkBuild, colorThemeProblems, renderedProblems, themeParityProblems,
 } from './checks-build.mjs';
-import { moduleMapProblems, shimProblems } from './checks-repo.mjs';
+import { moduleMapProblems, scorecardProblems, shimProblems } from './checks-repo.mjs';
 import { isDoctorNote, sortedProblems, sortedUnique, stemOf, withTempDir } from './scan.mjs';
 
 /**
@@ -220,6 +220,7 @@ export function doctorCollect({
   problems = problems.concat(ran('loops', 'Loop catalogue', loopProblems()));
   problems = problems.concat(ran('shim', 'Hook shim', shimProbs));
   problems = problems.concat(ran('map', 'Module map', moduleMapProblems()));
+  problems = problems.concat(ran('scorecard', 'Scorecard floor', scorecardProblems()));
   // P10c's `cli` check is GONE, and the reason is not that it stopped mattering. It hashed
   // `rituals/harness.py` and compared that against a digest baked into `cli.json`, to catch a
   // parser edited without regenerating the table. P2 made the table the OWNED document

package/js/inspect/inventory.mjs

@@ -92,23 +92,21 @@ export const SKILL_CLASS = {
   brainstorm: 'design', plan: 'design', council: 'design',
   workflow: 'design', 'parallel-agents': 'design', pipeline: 'design',
   loop: 'design', 'brick-forge': 'design',
-  'codebase-design': 'design', 'domain-modeling': 'design', wayfinder: 'design',
-  tickets: 'design',
-  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',
-  worktree: 'build', 'ci-fix': 'build', 'deps-audit': 'build',
+  'codebase-design': 'design', wayfinder: 'design',
+  develop: 'build', refactor: 'build', debug: 'build', dependencies: 'build',
+  'frontend-design': 'build', prototype: 'build',
+  'forge-mcp': 'build', bruno: 'build', worktree: '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',
+  commit: 'ship', ship: 'ship', release: 'ship', handoff: 'ship',
+  'git-history': 'understand',
   research: 'understand', ingest: 'understand', 'document-project': 'understand',
   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',
+  herdr: 'harness', 'skill-forge': 'harness',
   teach: 'learn', quiz: 'learn', 'learn-mode': 'learn',
 };