geneseed 3.15.0 → 3.17.0

package/js/build/render.mjs

@@ -162,10 +162,31 @@ export function substitute(text, theme) {
 }
 
 /** `_build_render._resolve_catalogs`. */
-function resolveCatalogs(text, nativeCatalog) {
+function resolveCatalogs(text, nativeCatalog, excludeSkills = []) {
   // `true`/`false` still mean "both kinds", for the plain-bundle callers that pass a boolean.
   const nat = nativeCatalog === true ? { skills: true, agents: true } : (nativeCatalog || {});
-  return text.replace(CATALOG_BLOCK_RE, (_m, kind, table, pointer) => (nat[kind] ? pointer : table));
+  return text.replace(CATALOG_BLOCK_RE, (_m, kind, table, pointer) => (nat[kind] ? pointer
+    : kind === 'skills' ? dropExcludedSkillRows(table, excludeSkills) : table));
+}
+
+/**
+ * The skills catalogue table, minus the rows of `--exclude-skills` — a row naming a skill the
+ * install never wrote is a dead link. A folder skill's bullet runs onto indented continuation
+ * lines, which go with it. Only the plain bundle reaches this: every host emit replaces the
+ * table with the pointer to its own inventory.
+ */
+function dropExcludedSkillRows(table, excludeSkills) {
+  if (!excludeSkills.length) return table;
+  const names = excludeSkills.join('|');
+  const gone = new RegExp(`\\{\\{DIR_SKILLS\\}\\}/(?:${names})(?:\\.md|/SKILL\\.md)\\)`);
+  const out = [];
+  let dropping = false;
+  for (const line of table.split('\n')) {
+    if (dropping && /^[ \t]+\S/.test(line)) continue;
+    dropping = /^(?:\||- )/.test(line) && gone.test(line);
+    if (!dropping) out.push(line);
+  }
+  return out.join('\n');
 }
 
 /**
@@ -247,7 +268,7 @@ export function renderFile(cfg, filePath, theme, footprint = 'full', lawsPrefix
     return inner;
   });
 
-  text = resolveCatalogs(text, nativeCatalog);
+  text = resolveCatalogs(text, nativeCatalog, cfg.excludeSkills ?? []);
   text = resolveLean(text, footprint);
   return substitute(text, theme);
 }
@@ -414,6 +435,11 @@ export function effectiveTheme(cfg, themeName, { footprint = 'full', lawsPrefix
   theme.EXCLUDED_RULES_LINE = dropped.length
     ? `\nExcluded rules: ${dropped.map((id) => id.replace('.', ' ')).join(', ')}`
     : '';
+  // The skills twin, under the same contract: written only when something is excluded, so a
+  // default build stays byte-identical, and read back by `excludedSkillsOfDir`.
+  const skipped = [...(cfg.excludeSkills ?? [])].sort();
+  // It fills a template line of its own, so its value carries the blank line around it.
+  theme.EXCLUDED_SKILLS_LINE = skipped.length ? `\nExcluded skills: ${skipped.join(', ')}\n` : '';
   return theme;
 }
 
@@ -460,8 +486,12 @@ export function renderAll(cfg, themeName, {
 } = {}) {
   const theme = effectiveTheme(cfg, themeName, { footprint, lawsPrefix });
   const items = [];
+  const skipped = new Set(cfg.excludeSkills ?? []);
   for (const file of sortedSourceFiles(cfg.src)) {
     const rel = path.relative(cfg.src, file);
+    // `--exclude-skills`: the one filter every host's emit and the plain bundle read through.
+    const sp = rel.split(path.sep);
+    if (sp[0] === 'skills' && sp.length >= 2 && skipped.has(sp[1].replace(/\.md$/, ''))) continue;
     const outRel = destRel(themedRel(rel, theme)).split(path.sep).join('/');  // as_posix()
     // The on-disk `laws/`, `ontology/` and `doctrines/` are the "complete text" the two lean
     // pointers promise — §1's and the Doctrines section's. They render at full whatever the

package/js/build/source.mjs

@@ -236,6 +236,40 @@ export function knownRuleIds() {
   return ruleCanon(SRC).rules.filter((r) => r.kind === 'DOCTRINE').map((r) => `${r.pack}.${r.n}`);
 }
 
+/**
+ * Every skill this checkout ships: a flat `skills/<name>.md` (authoring `_` files are not
+ * skills) or a vendored `skills/<name>/` folder. The one enumerator `--exclude-skills` closes
+ * against, for the reason `knownRuleIds` is one.
+ */
+export function knownSkillIds() {
+  const dir = path.join(SRC, 'skills');
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((e) => !e.name.startsWith('_') && (e.isDirectory() || e.name.endsWith('.md')))
+    .map((e) => e.name.replace(/\.md$/, '')).sort();
+}
+
+/**
+ * The skills the constitution or another skill LINKS to by path (`{{DIR_SKILLS}}/<name>`),
+ * outside the §4 catalogue table. They cannot be excluded: the link would ship dead. Scanned,
+ * not listed, so a new link protects its target the day it is written.
+ */
+export function linkedSkillIds() {
+  const linked = new Set();
+  const walk = (d) => {
+    for (const e of readdirSync(d, { withFileTypes: true })) {
+      const f = path.join(d, e.name);
+      if (e.isDirectory()) walk(f);
+      else if (/\.(md|tmpl)$/.test(e.name)) {
+        const text = readFileSync(f, 'utf8')
+          .replace(/<!-- CATALOG:begin skills -->[\s\S]*?<!-- CATALOG:end -->/, '');
+        for (const m of text.matchAll(/\{\{DIR_SKILLS\}\}\/([a-z0-9-]+)/g)) linked.add(m[1]);
+      }
+    }
+  };
+  walk(SRC);
+  return [...linked].sort();
+}
+
 /**
  * `_build_core.js_cfg()`, originated rather than received.
  *
@@ -250,7 +284,7 @@ export function knownRuleIds() {
  */
 export function makeCfg({
   posture = 'peer', mode = 'direct', trust = DEFAULT_PRESET, doctrines = PACK_ORDER,
-  excludeRules = [],
+  excludeRules = [], excludeSkills = [],
 } = {}) {
   return {
     root: ROOT,
@@ -276,5 +310,7 @@ export function makeCfg({
     // is already absent, and dropping the exclusion would silently re-admit the rule the day
     // the pack came back.
     excludeRules: Array.isArray(excludeRules) ? [...excludeRules] : [],
+    // Skill names left out of this install — same "unspecified takes nothing away" default.
+    excludeSkills: Array.isArray(excludeSkills) ? [...excludeSkills] : [],
   };
 }

package/js/cli-table.json

@@ -178,6 +178,21 @@
           "type": null,
           "hidden": false
         },
+        {
+          "names": [
+            "--exclude-skills"
+          ],
+          "dest": "exclude_skills",
+          "metavar": null,
+          "help": "",
+          "choices": null,
+          "default": null,
+          "required": false,
+          "nargs": null,
+          "is_flag": false,
+          "type": null,
+          "hidden": false
+        },
         {
           "names": [
             "--out"

package/js/hosts/hooks-context.mjs

@@ -32,7 +32,8 @@ const _ERRNO = {
 function asOsError(e, filename) {
   const hit = _ERRNO[e && e.code];
   if (!hit) return String((e && e.message) || e);
-  // Python reprs the filename, so a Windows path comes out with its backslashes doubled.
+  // The `[Errno N] text: 'file'` shape this hook has always printed: the filename is quoted,
+  // so a Windows path comes out with its backslashes doubled.
   return `[Errno ${hit[0]}] ${hit[1]}: ${JSON.stringify(filename).replace(/^"|"$/g, "'")
     .replace(/\\"/g, '"')}`;
 }
@@ -57,7 +58,7 @@ function fnTranslate(pat) {
       if (pat[j] === '!') j += 1;
       if (pat[j] === ']') j += 1;
       while (j < pat.length && pat[j] !== ']') j += 1;
-      // An unterminated `[` is a LITERAL bracket in Python's translate, not an error.
+      // An unterminated `[` is a LITERAL bracket (fnmatch semantics), not an error.
       if (j >= pat.length) { out += '\\['; continue; }
       let body = pat.slice(i + 1, j).replaceAll('\\', '\\\\');
       if (body.startsWith('!')) body = `^${body.slice(1)}`;
@@ -77,9 +78,14 @@ function fnTranslate(pat) {
  */
 let HOST = 'claude';
 
-// Kept in step with adapters/opencode/plugins/geneseed-context.js, same as the Python.
+// Kept in step with adapters/opencode/plugins/geneseed-context.js.
 const EAGER_ROOT = ['AGENTS.md', 'AGENT.md', 'CLAUDE.md', '.cursorrules',
-  'README.md', 'CONTRIBUTING.md', 'user-rules.md', 'PROFILE.md'];
+  'README.md', 'README.adoc', 'CONTRIBUTING.md', 'CONTRIBUTING.adoc', 'user-rules.md', 'PROFILE.md'];
+// Project docs are Markdown or AsciiDoc: the document-project skill writes AsciiDoc by default
+// when a project has no docs yet, so a loader blind to `.adoc` would hide every doc it wrote.
+// Agent-runtime files (AGENTS.md, CLAUDE.md, specs) stay Markdown whatever the project uses.
+const DOC_EXT = new Set(['.md', '.adoc']);
+const isDoc = (name) => DOC_EXT.has(path.extname(name).toLowerCase());
 const LAZY_DIRS = ['docs', 'doc', 'documentation', 'architecture', 'adr', 'ADR'];
 const EXCLUDE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'vendor', '.next',
   'target', '.venv', '__pycache__', '.opencode', '.harness']);
@@ -96,11 +102,22 @@ const NATIVE_ROOT = {
   openclaude: ['AGENTS.md', 'CLAUDE.md'],
 };
 
-// Eager injection budget: a root README of 40k chars was going out whole, every session and
-// every compaction, and cost more than the harness itself. Per-file cut at the last line
-// break under the cap; files that would push the total over the budget are listed lazy.
-const EAGER_FILE_BYTES = 16 * 1024;
-const EAGER_TOTAL_BYTES = 48 * 1024;
+// The whole payload's budget, in characters. Claude Code does not hand a hook's stdout to the
+// model past roughly 10k characters: it saves the output to a file and the model sees a 2 KB
+// preview, so everything after the cut is lost without a word. Observed 2026-10 (a 25.6 KB and
+// a 16.5 KB SessionStart output, both persisted); the exact threshold is not documented, hence
+// the margin. The old 48 KB eager budget never bound — the host's cap always cut first.
+// Priority inside the budget: session files (the user's own), then eager docs (whole, or
+// listed lazy), then the lazy listing, folded per directory and cut with a count.
+const OUTPUT_BUDGET = 9000;
+// Kept back from the eager docs so the lazy listing always has room to say what exists.
+const LAZY_RESERVE = 1500;
+// A directory with this many undescribed lazy files is listed once, with its count.
+const LAZY_FOLD_AT = 3;
+// What a line costs against the budget: its characters plus a terminator counted as two,
+// because stdout goes out as \r\n on Windows — a 144-line listing overran by 137 before this.
+// Multi-line text pays one more per inner line break, for the same reason.
+const cost = (s) => s.length + (s.match(/\n/g) || []).length + 2;
 
 // The files the root instruction file names for session start, relative to the HARNESS dir
 // (`--root`: `.claude/`, `.bob/`, a global config dir) — not to the repo root discovery walks,
@@ -171,9 +188,8 @@ export function globalHookStandingDown(hookRoot, cwd) {
 
 /** `_disp` — relative to the repo root when it sits under it, else verbatim. */
 function disp(pathStr, root) {
-  // `os.path.relpath` raises ValueError across drives and the Python falls back to the
-  // path as given; `path.relative` silently returns an absolute path instead, which would
-  // print a DIFFERENT string rather than the same one.
+  // A path on another drive has no relative form, so it is printed as given. `path.relative`
+  // would silently return an absolute path instead — a different string, not the same one.
   if (path.parse(path.resolve(pathStr)).root.toLowerCase()
       !== path.parse(path.resolve(root)).root.toLowerCase()) {
     return pathStr;
@@ -182,18 +198,18 @@ function disp(pathStr, root) {
 }
 
 
-function rglobMd(dir, acc = []) {
+function rglobDocs(dir, acc = []) {
   for (const name of listDir(dir)) {
     const full = path.join(dir, name);
-    if (isDir(full)) rglobMd(full, acc);
-    else if (isFile(full) && path.extname(name).toLowerCase() === '.md') acc.push(full);
+    if (isDir(full)) rglobDocs(full, acc);
+    else if (isFile(full) && isDoc(name)) acc.push(full);
   }
   return acc;
 }
 
 /**
  * `_discover_context` — the no-manifest path, mirroring the OpenCode context plugin.
- * Root entry docs are eager; other root markdown, the doc trees and monorepo package
+ * Root entry docs are eager; other root docs (.md or .adoc), the doc trees and monorepo package
  * READMEs are lazy.
  */
 export function discoverContext(root, host = HOST) {
@@ -206,12 +222,12 @@ export function discoverContext(root, host = HOST) {
     const name = path.basename(full);
     if (native.includes(name)) continue;
     if (EAGER_ROOT.includes(name)) eager.set(full, null);
-    else if (path.extname(name).toLowerCase() === '.md') lazy.set(full, null);
+    else if (isDoc(name)) lazy.set(full, null);
   }
   for (const d of LAZY_DIRS) {
     const sub = path.join(root, d);
     if (!isDir(sub)) continue;
-    for (const md of sortPaths(rglobMd(sub))) {
+    for (const md of sortPaths(rglobDocs(sub))) {
       const parts = path.relative(root, md).split(/[\\/]/);
       if (parts.some((part) => EXCLUDE_DIRS.has(part))) continue;
       if (!eager.has(md) && !lazy.has(md)) lazy.set(md, null);
@@ -222,8 +238,10 @@ export function discoverContext(root, host = HOST) {
     if (!isDir(base)) continue;
     for (const pkg of sortPaths(listDir(base).map((n) => path.join(base, n)))) {
       if (!isDir(pkg) || EXCLUDE_DIRS.has(path.basename(pkg))) continue;
-      const readme = path.join(pkg, 'README.md');
-      if (isFile(readme) && !eager.has(readme) && !lazy.has(readme)) lazy.set(readme, null);
+      for (const name of ['README.md', 'README.adoc']) {
+        const readme = path.join(pkg, name);
+        if (isFile(readme) && !eager.has(readme) && !lazy.has(readme)) lazy.set(readme, null);
+      }
     }
   }
   return [
@@ -270,19 +288,18 @@ export function resolveContextSets(root, hookRoot = null) {
   let extend;
   try {
     let data = JSON.parse(raw);
-    // Valid JSON of the wrong SHAPE, guarded on both sides — see the Python original. JS
-    // would not have thrown here (`[].context` is merely undefined), which is exactly why
-    // the guard is written out rather than left to fall out of the language: without it,
-    // the two CLIs disagree about a file a user really does hand-edit.
+    // Valid JSON of the wrong SHAPE (null, a number, an array) is an empty manifest, not a
+    // syntax error. The guard is written out rather than left to fall out of the language:
+    // without it, `null.context` throws into the catch below and a file a user really does
+    // hand-edit is reported as invalid JSON when it is not.
     data = data && typeof data === 'object' && !Array.isArray(data) ? data : {};
     entries = data.context || [];
     if (!Array.isArray(entries)) entries = [];
     extend = Boolean(data.extend);
   } catch {
-    // See the Python original for why the decoder's own message is not quoted: the two
-    // engines disagree on the wording and on the offset, and V8 supplies no offset at all
-    // for the commonest shapes. Reporting the file is what the user needs; reporting
-    // WHICH decoder found it is what makes two implementations impossible.
+    // The decoder's own message is not quoted: its wording and offset are engine details,
+    // and V8 supplies no offset at all for the commonest shapes. Reporting the file is what
+    // the user needs.
     err(`[context] ${manifest} is not valid JSON — no context was loaded `
       + '(fix the syntax, then re-run).\n');
     return [[], [], String(manifest)];
@@ -331,14 +348,58 @@ export function resolveContextSets(root, hookRoot = null) {
 }
 
 /**
- * Cut `text` at the last line break under EAGER_FILE_BYTES and say where the rest is — one rule
- * for a session file and an eager doc alike. `where` finishes the sentence.
+ * Cut a session file at the last line break that fits `room` and say where the rest is. Only
+ * session files are cut: they are the user's own rules, and half of them beats none. An eager
+ * doc that does not fit is listed lazy instead — a README cut mid-section misleads.
  */
-function capEager(text, where) {
-  if (text.length <= EAGER_FILE_BYTES) return text;
-  const nl = text.lastIndexOf('\n', EAGER_FILE_BYTES);
-  return `${text.slice(0, nl > 0 ? nl : EAGER_FILE_BYTES)}\n`
-    + `[context] truncated at ${EAGER_FILE_BYTES / 1024} KB — read ${where}`;
+function capToRoom(text, room, where) {
+  if (cost(text) <= room) return text;
+  const marker = `\n[context] truncated (session budget) — read ${where}`;
+  let cut = text.length;
+  do cut = text.lastIndexOf('\n', cut - 1);
+  while (cut > 0 && cost(text.slice(0, cut) + marker) > room);
+  return `${cut > 0 ? text.slice(0, cut) : ''}${marker}`;
+}
+
+/**
+ * The lazy listing: a described entry gets its own line; undescribed entries sharing a parent
+ * directory are folded into one `dir/ — N docs` line once there are LAZY_FOLD_AT of them (a
+ * `docs/` tree of 186 files was 186 lines). Lines past `room` become one count line.
+ */
+function lazyLines(entries, root, room) {
+  const byDir = new Map();
+  for (const e of entries) {
+    const dir = path.dirname(disp(e.path, root));
+    // Root files stay listed one by one: there are few, and each name says what it is.
+    if (e.description || e.over || dir === '.') continue;
+    byDir.set(dir, (byDir.get(dir) || 0) + 1);
+  }
+  const lines = [];
+  const folded = new Set();
+  for (const e of entries) {
+    const shown = disp(e.path, root);
+    const dir = path.dirname(shown);
+    if (!e.description && !e.over && byDir.get(dir) >= LAZY_FOLD_AT) {
+      if (folded.has(dir)) continue;
+      folded.add(dir);
+      lines.push(`  - ${dir.replace(/\\/g, '/')}/ — ${byDir.get(dir)} docs`);
+      continue;
+    }
+    const why = e.over ? ' (eager, but over the session budget — read on demand)' : '';
+    lines.push(`  - ${shown}${e.description ? ` — ${e.description}` : ''}${why}`);
+  }
+  const kept = [];
+  let used = 0;
+  for (const [i, l] of lines.entries()) {
+    const tail = `  - … ${lines.length - i} more not listed (session budget)`;
+    if (used + cost(l) + (i < lines.length - 1 ? cost(tail) : 0) > room) {
+      kept.push(tail);
+      break;
+    }
+    kept.push(l);
+    used += cost(l);
+  }
+  return kept;
 }
 
 export function cmdContext(args) {
@@ -379,51 +440,46 @@ export function cmdContext(args) {
   }
 
   const lines = [];
+  // `spent` counts every character pushed, headers included: the budget is the host's cap on
+  // the whole payload, not on the file bodies alone.
   let spent = 0;
+  const push = (...ls) => { for (const l of ls) { lines.push(l); spent += cost(l); } };
   if (session.length) {
-    lines.push('=== SESSION FILES \u2014 your harness files, injected at session start '
+    push('=== SESSION FILES \u2014 your harness files, injected at session start '
       + '(untouched seeds skipped) ===', '');
     for (const s of session) {
-      const text = capEager(s.text, `${s.abs} on demand`);
-      spent += text.length;
-      lines.push(`----- ${s.rel} -----`, text, '');
+      const head = `----- ${s.rel} -----`;
+      push(head, capToRoom(s.text, OUTPUT_BUDGET - LAZY_RESERVE - spent - cost(head) - cost(''),
+        `${s.abs} on demand`), '');
     }
   }
   if (eager.length || lazy.length) {
-    lines.push(`=== PROJECT CONTEXT \u2014 binding for this repo (via ${source}) ===`, '');
+    push(`=== PROJECT CONTEXT \u2014 binding for this repo (via ${source}) ===`, '');
   }
   const demoted = [];
   for (const entry of eager) {
     const p = entry.path === undefined ? '' : entry.path;
     const desc = entry.description === undefined ? '' : entry.description;
     const target = path.isAbsolute(p) ? p : path.join(root, p);
+    const head = `----- ${disp(p, root)}${desc ? ` \u2014 ${desc}` : ''} -----`;
     let text;
     try {
       text = readText(target).replace(/\n+$/, '');
     } catch (e) {
-      lines.push(`----- ${disp(p, root)}${desc ? ` \u2014 ${desc}` : ''} -----`,
-        `[context] MISSING eager file: ${asOsError(e, target)}`, '');
+      push(head, `[context] MISSING eager file: ${asOsError(e, target)}`, '');
       continue;
     }
-    text = capEager(text, `${disp(p, root)} on demand for the rest`);
-    if (spent + text.length > EAGER_TOTAL_BYTES) {
-      demoted.push(entry);
+    if (spent + cost(head) + cost(text) + cost('') > OUTPUT_BUDGET - LAZY_RESERVE) {
+      demoted.push({ ...entry, over: true });
       continue;
     }
-    spent += text.length;
-    lines.push(`----- ${disp(p, root)}${desc ? ` \u2014 ${desc}` : ''} -----`, text, '');
+    push(head, text, '');
   }
 
   if (lazy.length || demoted.length) {
-    lines.push('--- Lazy entries (load only when the task needs them) ---');
-    for (const entry of [...lazy, ...demoted]) {
-      const p = entry.path === undefined ? '' : entry.path;
-      const desc = entry.description === undefined ? '' : entry.description;
-      const over = demoted.includes(entry)
-        ? ` (eager, but over the ${EAGER_TOTAL_BYTES / 1024} KB session budget \u2014 read on demand)` : '';
-      lines.push(`  - ${disp(p, root)}${desc ? ` \u2014 ${desc}` : ''}${over}`);
-    }
-    lines.push('');
+    const title = '--- Lazy entries (load only when the task needs them) ---';
+    push(title);
+    push(...lazyLines([...lazy, ...demoted], root, OUTPUT_BUDGET - spent - cost('')), '');
   }
 
   // Claude Code takes a SessionStart hook's plain stdout as context; Bob reads it the same way.

package/js/hosts/hooks.mjs

@@ -201,7 +201,7 @@ const BOB_DENY_EXIT = 2;
  * logs. `gate-error` is a warning too: a crashed gate that blocked every tool call would be
  * a lockout, not a safeguard, and there is no prompt through which the user could clear it.
  */
-const BLOCK_RULES = new Set(['law-1', 'law-4']);
+const BLOCK_RULES = new Set(['law-1', 'law-4', 'rigor-5']);
 
 /**
  * THE GATE LEDGER — one JSON line per ask, nothing per defer.
@@ -358,6 +358,33 @@ const SECRET_RE =
   /\b(?:AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,}|sk-ant-[A-Za-z0-9_-]{20,}|xox[abprs]-[0-9A-Za-z-]{10,})\b|-----BEGIN [A-Z ]*PRIVATE KEY-----/;
 const DOTENV_RE = /(^|[\\/])\.env(\.[^\\/]*)?$/;
 
+/**
+ * External Gate's boundary half: the checks an agent is judged by must sit outside what it can
+ * edit, or a failing check is one edit away from a passing one. A project opts in by listing
+ * them, one repo-relative path per line (`#` comments), in `.geneseed/protected-checks.txt` at
+ * its git root — found by walking up from the WRITE TARGET, not the cwd, so a session in one repo
+ * writing into another reads that other repo's list. The list protects itself. Returns the entry
+ * the path falls under, or null. ponytail: a write tool only — a shell `sed -i` or redirect is
+ * not seen here; CI running the checks is the boundary that holds against that.
+ */
+export const SENSOR_LIST = '.geneseed/protected-checks.txt';
+function protectedCheck(p) {
+  try {
+    const target = resolvePath(p);
+    const root = gitRootOf(path.dirname(target));
+    if (!root) return null;
+    const text = readFileSync(path.join(root, SENSOR_LIST), 'utf8');
+    // `normcase` folds case AND slashes on Windows, so both sides go through it, the trailing
+    // separator of the prefix included.
+    const rel = normcase(path.relative(root, target));
+    const entries = [SENSOR_LIST, ...text.split(/\r?\n/).map((l) => l.trim().replace(/[\\/]+$/, ''))
+      .filter((l) => l && !l.startsWith('#'))];
+    return entries.find((e) => rel === normcase(e) || rel.startsWith(normcase(`${e}/`))) ?? null;
+  } catch {
+    return null;   // no list (the common case) or an unreadable one: nothing is protected
+  }
+}
+
 function ruleGate(args) {
   if (sovereignBypass(args.root)) return 0;
   return ruleDecide(args, readPayload());
@@ -378,6 +405,12 @@ function ruleDecide(args, payload) {
       + 'credential-shaped string. Secrets live in .env or a secret manager, never in a '
       + 'tracked file.');
   }
+  const sensor = protectedCheck(p);
+  if (sensor) {
+    return ask(args, 'rule-gate', 'rigor-5', `Geneseed (External Gate) — ${p} is a protected `
+      + `check (${sensor}, listed in ${SENSOR_LIST}). A check the agent can edit is not a `
+      + 'check: fix the code, not the check, unless the user asks for this edit.');
+  }
   const target = ruleGateTarget(p, args.root);
   if (!target) return 0;
   return ask(args, 'rule-gate', 'process-1', `Geneseed (Persist Insight) \u2014 writing to `

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 } from '../build/source.mjs';
+import { CONFIG, PACK_ORDER, THEMES, discoverNames, knownSkillIds } 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,6 +408,28 @@ export function excludedRulesOfDir(d) {
   }, []);
 }
 
+/** `Excluded skills: bruno-test-writer, daydream` — written only when something is excluded. */
+const EXCLUDED_SKILLS_RE = /^Excluded skills:[ \t]*(.+?)[ \t]*$/m;
+
+/**
+ * The skills a DEPLOYED install left out, read back so `upgrade`, `rebuild-all` and `diff`
+ * 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.
+ */
+export function excludedSkillsOfDir(d) {
+  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();
+  }, []);
+}
+
 // ---- what host a deployed dir belongs to (`_harness_mcp`) ---------------------------------
 
 /** `_harness_mcp._claude_read_manifest`. */
@@ -554,7 +576,7 @@ export function installTargets() {
 export function installedDefaults() {
   const found = {
     theme: null, posture: null, mode: null, emit: null, footprint: null, doctrines: null,
-    excludeRules: null,
+    excludeRules: null, excludeSkills: null,
   };
   const candidates = [];
   for (const { host, configDir } of HOSTS) {
@@ -596,6 +618,7 @@ export function installedDefaults() {
     // pre-selects. The cost of that choice is that "excludes nothing" and "no carrier" are
     // indistinguishable here, which is exactly what the marker itself already says.
     if (!found.excludeRules?.length) found.excludeRules = excludedRulesOfDir(base);
+    if (!found.excludeSkills?.length) found.excludeSkills = excludedSkillsOfDir(base);
   }
   return found;
 }

package/js/hosts/opencode.mjs

@@ -309,6 +309,8 @@ export function writeCommandLayer(cfg, items, commandDir, claim = () => true) {
   }
   const written = [];
   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`);

package/js/hosts/settings.mjs

@@ -513,7 +513,8 @@ export function claudeHookGroups(cfg, hookOpts, doctrines = null, excluded = [],
       SessionStart: [{ hooks: [{ type: 'command', command: `${run} context --root "${cfg}"${b} || exit 0` }] }],
       // One group, both gates: process 5's consent is a stderr line here (Bob has no ask
       // tier), so the pack toggle that drops Claude's git-gate group has nothing to drop —
-      // `tool-gate` only ever EXITS 2 for Laws I and IV, which every build carries.
+      // `tool-gate` only ever EXITS 2 for Laws I and IV, which every build carries, and for a
+      // write under a project's own `.geneseed/protected-checks.txt` — the project opted in.
       PreToolUse: [{ hooks: [{ type: 'command', command: `${run} tool-gate --root "${cfg}"${b}` }] }],
       Stop: [{ hooks: [{ type: 'command', command: `${run} learn ${mem} || exit 0` }] }],
     };

package/js/inspect/checks-constitution.mjs

@@ -169,14 +169,14 @@ const DOCTRINE_TOKEN_RE = /\{\{DOCTRINE(?:\}\}|:)/;
 /**
  * The rules the hooks enforce at the tool boundary, and the address each is bound to there. The
  * hook path cannot afford to read the canon on every tool call, so its gate-ledger keys
- * (`law-1`, `law-4`, `process-1`, `process-5` in `js/hosts/hooks.mjs` and the OpenCode guard
+ * (`law-1`, `law-4`, `process-1`, `process-5`, `rigor-5` in `js/hosts/hooks.mjs` and the OpenCode guard
  * plugin), `CONSENT_RULE` in `js/hosts/settings.mjs` and the console's `HOOK_GATED` stay
  * number-keyed — and this pin is what turns a renumber that moves one of these rules into a
  * doctor failure instead of a gate silently guarding its neighbour.
  */
 export const HOOK_PINNED = {
   'sealed-secrets': 'I', 'deletion-is-deliberate': 'IV',
-  'persist-insight': 'process 1', 'consent-before-push': 'process 5',
+  'persist-insight': 'process 1', 'consent-before-push': 'process 5', 'external-gate': 'rigor 5',
 };
 
 /**

package/js/inspect/diff.mjs

@@ -44,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';
@@ -180,6 +181,8 @@ export function diffCollect({ target = null, theme = null, emit = null, footprin
       // 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/status.mjs

@@ -370,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 {