geneseed 3.15.0 → 3.16.0

package/CHANGELOG.md

@@ -8,6 +8,18 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
 
 ## [Unreleased]
 
+## [3.16.0] — 2026-10-05
+
+**Upgrading:** re-emit (`geneseed rebuild-all`) so the context hook stays under Claude Code's output cap. To drop skills you never use, rebuild an install with `--exclude-skills <name,…>` (see [Exclusions](docs/concepts/exclusions.md)).
+
+### Added
+
+- `--exclude-skills <name,…>` leaves skills you never use out of an install, on every host: their files, their catalogue rows and any OpenCode command that runs them. The install records the list on an `Excluded skills:` line, and `upgrade`, `rebuild-all`, `diff`, `setup` and the web console keep it. Unknown skills are refused, and so are the ten the harness links to by path. `status` shows `skills off: …`.
+
+### Fixed
+
+- The context hook (Claude Code, Bob, OpenClaude) now keeps its whole output under 9,000 characters. Claude Code shows the model only a preview of a hook output past ~10k, so a doc-heavy repo lost its context silently — this repo's was 25.6 KB, now 2.5 KB. Eager docs that do not fit are listed lazy with the reason; the lazy listing folds three or more docs in one folder into `dir/ — N docs` and ends in a count if it is still too long. The OpenCode plugin folds its project listing the same way.
+
 ## [3.15.0] — 2026-10-05
 
 **Upgrading:** re-emit (`geneseed rebuild-all`) so OpenCode installs get the hardened plugins and

package/SHIPPED.md

@@ -20,7 +20,7 @@ historical references, not files distributed with the repo.
 > **On version numbers.** [`harness.config.json`](harness.config.json)'s `version` is a
 > human-readable label only. The canonical identity of an installed harness is the
 > **source fingerprint** stamped in `.geneseed-version` (see `geneseed version`), not the
-> string. Current label: **3.15.0**.
+> string. Current label: **3.16.0**.
 
 ## Capabilities
 

package/adapters/opencode/plugins/geneseed-context.js

@@ -117,6 +117,8 @@ const MAX_DEPTH = 6
 // the head of each file (enough for an H1) rather than the whole thing — a large
 // docs/ tree must not cost one full-file read per entry on every session start.
 const LAZY_HEADING_LIMIT = envNum("GENESEED_LAZY_HEADINGS", 64)
+// Same threshold as the Claude hook's LAZY_FOLD_AT.
+const LAZY_FOLD_AT = 3
 const HEADING_SLICE_BYTES = 4096
 
 // Quiet by default — OpenCode surfaces a plugin's stderr in the UI (red text). Set
@@ -664,7 +666,7 @@ async function wikiSets() {
 // Render one eager+lazy set into `out`. The budget state (eager bytes, heading
 // reads) is SHARED across segments — project context and every wiki draw from the
 // same caps, so the whole block stays bounded no matter how many wikis are declared.
-async function renderSet(out, { eager, lazy }, state) {
+async function renderSet(out, { eager, lazy }, state, { fold = false } = {}) {
   const perFile = EAGER_FILE_KB * 1024
   const total = EAGER_TOTAL_KB * 1024
   const demoted = []
@@ -692,8 +694,26 @@ async function renderSet(out, { eager, lazy }, state) {
     state.injected++
   }
 
+  // The project listing folds like the Claude hook's (js/hosts/hooks-context.mjs): three or more
+  // undescribed docs sharing a parent directory become one `dir/ — N docs` line — a docs/ tree
+  // of 186 files was 186 lines on every session. Root files never fold. A wiki listing keeps its
+  // per-note headings: a vault is navigated by them, and it carries its own cap.
+  const byDir = new Map()
+  if (fold) {
+    for (const l of lazy) {
+      const dir = path.posix.dirname(l.rel.replace(/\\/g, "/"))
+      if (!l.desc && dir !== ".") byDir.set(dir, (byDir.get(dir) || 0) + 1)
+    }
+  }
+  const folded = new Set()
   const lazyLines = []
   for (const l of lazy) {
+    const dir = path.posix.dirname(l.rel.replace(/\\/g, "/"))
+    if (!l.desc && byDir.get(dir) >= LAZY_FOLD_AT) {
+      if (!folded.has(dir)) lazyLines.push(`  - ${dir}/ — ${byDir.get(dir)} docs`)
+      folded.add(dir)
+      continue
+    }
     let head = l.desc
     // Only crack open files we have no description for, and cap how many — bounded by
     // a head-slice read so a big docs/ tree stays cheap on every session start.
@@ -734,7 +754,7 @@ async function buildBlock(sets, wikis = [], commands = [], session = []) {
   }
 
   const proj = []
-  await renderSet(proj, sets, state)
+  await renderSet(proj, sets, state, { fold: true })
 
   if (commands.length) {
     proj.push("--- Project commands (runnable targets discovered in the repo root) ---")

package/docs/concepts/exclusions.md

@@ -4,18 +4,18 @@ order: 12
 title: "Exclusions"
 kind: "concept"
 section: "Configuration"
-description: "Two ways to switch things off: one rule, or every hook in a folder."
+description: "Three ways to switch things off: one rule, one skill, or every hook in a folder."
 link: {"hash": "#/harness", "label": "Manage in Harness →"}
 ---
-Geneseed has two different ways to switch something off, and they work at different scales:
+Geneseed has three ways to switch something off, and they work at different scales:
 
-| | Sovereign repo | Per-rule exclusion |
-| --- | --- | --- |
-| **Switches off** | the whole global install, inside one folder | one doctrine rule, everywhere the install applies |
-| **Scope** | a folder and everything under it | the install |
-| **Applies to** | **global** installs only | any install |
-| **Set with** | `geneseed exclude add <path>` | `--exclude-rules` at build time |
-| **Takes effect** | on the next tool call, no rebuild | on rebuild |
+| | Sovereign repo | Per-rule exclusion | Per-skill exclusion |
+| --- | --- | --- | --- |
+| **Switches off** | the whole global install, inside one folder | one doctrine rule, everywhere the install applies | one skill, everywhere the install applies |
+| **Scope** | a folder and everything under it | the install | the install |
+| **Applies to** | **global** installs only | any install | any install |
+| **Set with** | `geneseed exclude add <path>` | `--exclude-rules` at build time | `--exclude-skills` at build time |
+| **Takes effect** | on the next tool call, no rebuild | on rebuild | on rebuild |
 
 > **You already know this:** `.gitignore` versus disabling one lint rule. One makes a tool ignore a whole folder; the other keeps the tool running everywhere with one check turned off.
 
@@ -55,3 +55,15 @@ geneseed build --emit claude-global --exclude-rules "process 7"
 ```
 
 The install records it (`Excluded rules: process 7` beside its pack list) and every rebuild and upgrade keeps it. The always-on Rules and the Ethos cannot be excluded. Picking packs and rules is covered in [Doctrine packs and single rules](../guides/setup-doctrines.md); what the layers are is in [Rules](rules.md).
+
+### Per-skill exclusion — skills you never use
+
+Every installed skill costs a line in the host's skill listing, every session. Skills you never use can be left out of an install:
+
+```bash
+geneseed build --emit claude-global --exclude-skills "bruno-test-writer,bruno-collection-generator,react-view-transitions"
+```
+
+The skill's files are not written, its catalogue row goes, and an OpenCode `/command` that runs it goes too. The install records the list (`Excluded skills: …` under its skill section), and every rebuild and upgrade keeps it. `--exclude-skills none` puts them all back.
+
+A few skills cannot be excluded, because the harness itself links to them by path — `council`, `rule`, `skill-forge`, `workflow` and a handful more. The flag names them when it refuses one. Skills you installed yourself are not Geneseed's to exclude: remove those from the host's skills folder directly.

package/docs/guides/install-scripted.md

@@ -12,7 +12,7 @@ description: "The build command to run in a script, a CI job, or a shell with no
 geneseed build --emit opencode-global --theme neutral
 ```
 
-`geneseed build` takes the same flags as the generator `geneseed-build`. `--emit` picks the host and its scope: `files`, `opencode`, `opencode-global`, `claude`, `claude-global`, `bob`, `bob-global`, `openclaude` or `openclaude-global`. A `-global` emit writes into the tool's own config directory. A project emit writes into the repo you name with `--out <repo> --root <repo>`. All the other flags (`--theme`, `--footprint`, `--posture`, `--mode`, `--trust`, `--doctrines`, `--exclude-rules`) are covered in [Choose your setup](choose-your-setup.md) and the two pages after it.
+`geneseed build` takes the same flags as the generator `geneseed-build`. `--emit` picks the host and its scope: `files`, `opencode`, `opencode-global`, `claude`, `claude-global`, `bob`, `bob-global`, `openclaude` or `openclaude-global`. A `-global` emit writes into the tool's own config directory. A project emit writes into the repo you name with `--out <repo> --root <repo>`. All the other flags (`--theme`, `--footprint`, `--posture`, `--mode`, `--trust`, `--doctrines`, `--exclude-rules`) are covered in [Choose your setup](choose-your-setup.md) and the two pages after it. `--exclude-skills` leaves skills you never use out of the install; see [Exclusions](../concepts/exclusions.md).
 
 To test a build before writing anything, use `geneseed validate` with the same flags. See [Verify](verify.md).
 

package/docs/guides/project-context.md

@@ -25,7 +25,7 @@ With no configuration, the context step finds these files:
 - **Lazy:** `docs/`, `doc/`, `documentation/`, `architecture/`, `adr/` and `ADR/`, monorepo `packages/*/README.md` and `apps/*/README.md`, and any other root `*.md`.
 - **Never scanned:** `node_modules`, `.git`, `dist`, `build`, `vendor`, `.next`, `target`, `.venv`, `__pycache__`, `.opencode` and `.harness`.
 
-Eager files share a 48 KB budget per session. An eager file that would go over the budget is listed instead, to be read on demand.
+On Claude Code, Bob and OpenClaude the whole injection stays under 9,000 characters, because Claude Code hands the model only a short preview of a hook output past about 10,000 and keeps the rest in a file. Your session files come first, then eager files whole; an eager file that does not fit is listed instead, to be read on demand. On OpenCode eager files share a 48 KB budget. On every host, three or more docs in one folder are listed as that folder with a count (`docs/guides/ — 30 docs`), not file by file.
 
 On OpenCode the context plugin does this work. On Claude Code, Bob and OpenClaude, the session-start hook does it (`geneseed-hook context`). Both read the same override file, described next.
 

package/docs/token-footprint.md

@@ -35,11 +35,13 @@ pointer to the host's own inventory instead, ~1.9k tokens lighter. A session fil
 byte-identical to its seed is skipped — it says nothing — so a fresh install injects none
 of them; until 2026-10 the hook read them from the repo root, where a Claude-shaped install
 never puts them, and none reached the session at all. The
-eager-injection path is budget-capped identically everywhere — 16 KB per file
-(cut at a line break, with a marker saying so) and 48 KB per session (files past
-the budget are listed lazy with the reason) — so a 40k-character README no
-longer leaves whole every session, and growing Memory degrades every host the
-same way instead of one silently falling behind. The hook also **never injects
+eager-injection path is budget-capped on every host. The SessionStart hook (Claude Code,
+Bob, OpenClaude) keeps its whole payload under 9,000 characters: Claude Code persists a
+hook output past ~10k to a file and shows the model a 2 KB preview, so until 2026-10 a
+doc-heavy repo's context was cut off unannounced. Session files come first, eager docs
+are injected whole or listed lazy with the reason. The OpenCode plugin has no such cap
+and keeps 16 KB per file / 48 KB per session. Both fold a lazy listing: three or more
+docs in one folder become one `dir/ — N docs` line. The hook also **never injects
 the root file the host loads by itself** (`CLAUDE.md` on Claude Code,
 `AGENTS.md` on Bob, `AGENT.md`/`AGENTS.md`/`CLAUDE.md` on OpenCode):
 until 2026-09 it did, and the whole harness was paid twice per session.
@@ -106,11 +108,12 @@ token counter also includes, none of which Geneseed controls:
 2. **Your repo's docs, injected eagerly** — the context delivery
    (plugin on OpenCode, SessionStart hook on Claude Code / Bob / OpenClaude) discovers and
    injects `README.md`, `CONTRIBUTING.md`, and files under `docs/`, up to the
-   48 KB budget (≈12k tokens). A doc-heavy repo fills it.
+   budget: 9,000 characters for the whole hook payload (≈2.3k tokens), 48 KB on
+   OpenCode (≈12k tokens).
 3. **Wiki eager entries** plus the lazy listing of the rest, if a wiki is
    configured.
 4. **Grown Memory/Notebook** — the emitted starter set is ~1.2k, but both
-   accumulate with use (same 48 KB shared budget).
+   accumulate with use (same shared budget).
 5. **Other instruction files the host also loads** — a global install plus a
    per-repo install, a personal `~/.claude/CLAUDE.md`, or MCP servers each add
    their own share.

package/harness.config.json

@@ -2,5 +2,5 @@
   "_comment": "version is a human-readable release label only; the canonical identity of an installed harness is the source fingerprint stamped in .geneseed-version (see `harness version`), not this string.",
   "theme": "neutral",
   "product": "Geneseed",
-  "version": "3.15.0"
+  "version": "3.16.0"
 }

package/js/build/args.mjs

@@ -10,7 +10,9 @@ import { existsSync, readFileSync } from 'node:fs';
 import { parseArgs as nodeParseArgs } from 'node:util';
 import { withPlatformNewlines } from '../lib/fs.mjs';
 import path from 'node:path';
-import { CONFIG, discoverNames, PACK_ORDER, knownRuleIds } from './source.mjs';
+import {
+  CONFIG, discoverNames, PACK_ORDER, knownRuleIds, knownSkillIds, linkedSkillIds,
+} from './source.mjs';
 // The loop engine's trust presets — the `--trust` choices. `score.mjs` imports nothing, which is
 // what lets it sit inside this module's `child_process` ban.
 import { DEFAULT_PRESET, PRESETS } from '../loop/score.mjs';
@@ -30,7 +32,7 @@ const EMITS = ['files', 'opencode', 'opencode-global', 'claude', 'claude-global'
 export function configDefaults() {
   const d = {
     theme: 'neutral', posture: 'peer', mode: 'direct', trust: DEFAULT_PRESET,
-    doctrines: [...PACK_ORDER], excludeRules: [],
+    doctrines: [...PACK_ORDER], excludeRules: [], excludeSkills: [],
   };
   if (!existsSync(CONFIG)) return d;
   try {
@@ -93,7 +95,7 @@ export function configDefaults() {
  */
 const VALUED = {
   '--theme': 'theme', '--posture': 'posture', '--mode': 'mode', '--trust': 'trust',
-  '--doctrines': 'doctrines', '--exclude-rules': 'excludeRules',
+  '--doctrines': 'doctrines', '--exclude-rules': 'excludeRules', '--exclude-skills': 'excludeSkills',
   '--out': 'out', '--target': 'out', '--emit': 'emit',
   '--footprint': 'footprint', '--root': 'root', '--config-dir': 'cfgDir',
 };
@@ -177,6 +179,33 @@ function parseExcludeRules(value) {
   return [...new Set(out)].sort();
 }
 
+/**
+ * `--exclude-skills "bruno-test-writer,openscad"` -> the cfg's skill exclusion array.
+ *
+ * Refused, by name: a skill this checkout does not ship (a typo would exclude nothing in
+ * silence), and a skill the constitution or another skill links to by path — excluding it
+ * would ship that link dead (`linkedSkillIds`). Sorted and deduped for marker stability.
+ */
+function parseExcludeSkills(value) {
+  const s = value.trim();
+  if (s === 'none' || s === '') return [];
+  const known = knownSkillIds();
+  const linked = linkedSkillIds();
+  const out = [];
+  for (const name of s.split(',').map((x) => x.trim()).filter(Boolean)) {
+    if (!known.includes(name)) {
+      die(2, `argument --exclude-skills: unknown skill '${name}' (choose from `
+        + `${known.filter((k) => !linked.includes(k)).join(', ')}, or 'none')`);
+    }
+    if (linked.includes(name)) {
+      die(2, `argument --exclude-skills: '${name}' cannot be excluded — the harness links to it `
+        + `by path (protected: ${linked.join(', ')})`);
+    }
+    out.push(name);
+  }
+  return [...new Set(out)].sort();
+}
+
 /**
  * `--doctrines craft,rigor` / `--doctrines none` -> the cfg's pack array.
  *
@@ -271,6 +300,7 @@ export function parseArgs(argv, defaults) {
     trust: defaults.trust,
     doctrines: defaults.doctrines,
     excludeRules: defaults.excludeRules,
+    excludeSkills: defaults.excludeSkills ?? [],
     out: 'Harness', emit: 'files', footprint: 'lean', root: null,
     syncThemes: false, validateOnly: false, verbose: false,
   };
@@ -314,6 +344,7 @@ export function parseArgs(argv, defaults) {
   // already the array `configDefaults` built, and re-parsing an array would stringify it.
   if (typeof args.doctrines === 'string') args.doctrines = parseDoctrines(args.doctrines);
   if (typeof args.excludeRules === 'string') args.excludeRules = parseExcludeRules(args.excludeRules);
+  if (typeof args.excludeSkills === 'string') args.excludeSkills = parseExcludeSkills(args.excludeSkills);
   return args;
 }
 

package/js/build/driver.mjs

@@ -596,16 +596,17 @@ const PROJECT_EMITS = {
  * mode readers return `null` for "undetectable" too, which an explicit `posture: null` would
  * carry straight past the parameter default.
  */
-function axesCfg({ posture, mode, trust, doctrines, excludeRules }) {
+function axesCfg({ posture, mode, trust, doctrines, excludeRules, excludeSkills }) {
   return makeCfg({
     ...(posture ? { posture } : {}), ...(mode ? { mode } : {}), ...(trust ? { trust } : {}),
     ...(doctrines ? { doctrines } : {}), ...(excludeRules ? { excludeRules } : {}),
+    ...(excludeSkills ? { excludeSkills } : {}),
   });
 }
 
 export function emitProjectInto(host, {
   theme, out, root, footprint = 'full', posture = null, mode = null, trust = null,
-  doctrines = null, excludeRules = null,
+  doctrines = null, excludeRules = null, excludeSkills = null,
 }) {
   const emit = PROJECT_EMITS[host];
   // The axes ride the same rail into every `*Into`, and for the same reason: a drift reader
@@ -613,7 +614,7 @@ export function emitProjectInto(host, {
   // edited on every narrowed install, and `validate --doctrines craft` that ignored its flag
   // checked an all-packs render nobody asked for.
   return withPlatformNewlines(() => emit(
-    axesCfg({ posture, mode, trust, doctrines, excludeRules }), { theme, footprint, root }, out,
+    axesCfg({ posture, mode, trust, doctrines, excludeRules, excludeSkills }), { theme, footprint, root }, out,
   ));
 }
 
@@ -627,15 +628,15 @@ export function emitProjectInto(host, {
  */
 export function buildInto({
   theme, out, footprint = 'lean', posture = null, mode = null, trust = null, doctrines = null,
-  excludeRules = null,
+  excludeRules = null, excludeSkills = null,
 }) {
-  return withPlatformNewlines(() => build(axesCfg({ posture, mode, trust, doctrines, excludeRules }),
+  return withPlatformNewlines(() => build(axesCfg({ posture, mode, trust, doctrines, excludeRules, excludeSkills }),
     theme, out, { footprint, nativeCatalog: false }));
 }
 
 export function emitGlobalInto(host, {
   theme, out, cfgDir, footprint, posture = null, mode = null, doctrines = null, trust = null,
-  excludeRules = null,
+  excludeRules = null, excludeSkills = null,
 }) {
   // `build.HOSTS.get(host, build.HOSTS["opencode"])` — an unknown host falls back rather than
   // raising, because the host comes from a marker file a user can edit.
@@ -651,7 +652,7 @@ export function emitGlobalInto(host, {
   // edited on every install that chose a register, narrowed its packs or excluded a rule —
   // the same scar the footprint left in `diffCollect`, one axis over each time.
   return withPlatformNewlines(() => emit(
-    axesCfg({ posture, mode, trust, doctrines, excludeRules }),
+    axesCfg({ posture, mode, trust, doctrines, excludeRules, excludeSkills }),
     { theme, footprint, root: null, cfgDir }, out,
   ));
 }

package/js/build/generate.mjs

@@ -40,7 +40,7 @@ import { DEFAULT_PRESET } from '../loop/score.mjs';
 import { opencodeConfigDir, resolvePath } from '../hosts/hosts.mjs';
 import {
   EMIT_HOST_SCOPE, defaultMode, defaultPosture, defaultTheme, doctrinesForBuild,
-  excludedRulesOfDir, footprintOfDir, installState, installTargets, modeOfDir, postureOfDir,
+  excludedRulesOfDir, excludedSkillsOfDir, footprintOfDir, installState, installTargets, modeOfDir, postureOfDir,
   readMaybe, themeOfDir, trustOfDir,
 } from '../hosts/installs.mjs';
 import { colorThemeFiles, colorThemeJson, PALETTE_ROLES } from '../hosts/opencode.mjs';
@@ -97,7 +97,7 @@ function sysExit(msg) {
 const BUILD_FORWARD = [
   ['theme', '--theme'], ['emit', '--emit'], ['footprint', '--footprint'],
   ['posture', '--posture'], ['mode', '--mode'], ['trust', '--trust'], ['doctrines', '--doctrines'],
-  ['excludeRules', '--exclude-rules'], ['out', '--out'], ['root', '--root'],
+  ['excludeRules', '--exclude-rules'], ['excludeSkills', '--exclude-skills'], ['out', '--out'], ['root', '--root'],
   ['configDir', '--config-dir'],
 ];
 
@@ -140,7 +140,7 @@ export function cmdBuild(args) {
  */
 export function setupBuildArgs(theme, emit, out = null, root = null, footprint = 'lean',
   posture = 'peer', mode = 'direct', doctrines = null, allPacks = PACK_ORDER,
-  excludeRules = null, trust = DEFAULT_PRESET) {
+  excludeRules = null, trust = DEFAULT_PRESET, excludeSkills = null) {
   const argv = ['--theme', theme, '--emit', emit];
   if (!emit.endsWith('-global')) {
     if (out) argv.push('--out', out);
@@ -164,6 +164,10 @@ export function setupBuildArgs(theme, emit, out = null, root = null, footprint =
   if (Array.isArray(excludeRules)) {
     argv.push('--exclude-rules', excludeRules.length ? excludeRules.join(',') : 'none');
   }
+  // Skills elide when nothing is excluded: the driver's default IS nothing (no config key
+  // feeds it), so the flag's absence and `none` are the same answer, and every argv that
+  // excludes nothing stays the bytes it was before the flag existed.
+  if (excludeSkills?.length) argv.push('--exclude-skills', excludeSkills.join(','));
   return argv;
 }
 
@@ -217,9 +221,11 @@ export function installProfile(host, scope, root) {
   // dropped it would quietly hand back every rule its owner switched off, and `process 5` is
   // one of them. `null` (no marker) stays `null` so the argv omits the flag, as it always did.
   const excludeRules = excludedRulesOfDir(root);
+  // Skills left out stay left out: an upgrade that forgot them would put them all back.
+  const excludeSkills = excludedSkillsOfDir(root);
   const out = scope === 'global' ? null : root;
   const argv = setupBuildArgs(theme, emit, out, out, footprint, posture, mode, doctrines,
-    PACK_ORDER, excludeRules, trust);
+    PACK_ORDER, excludeRules, trust, excludeSkills);
   // A GLOBAL ROW NAMES ITS OWN DIR. `root` came from the host's config-dir resolver, which
   // honours env overrides (`OPENCODE_CONFIG_DIR`, `CLAUDE_CONFIG_DIR`…); without the flag the
   // same argv run from a shell lacking that variable re-emits into the DEFAULT dir — a second
@@ -227,7 +233,7 @@ export function installProfile(host, scope, root) {
   if (scope === 'global') argv.push('--config-dir', root);
   return {
     host, scope, root, state: installState(root, host, scope),
-    emit, theme, footprint, posture, mode, trust, doctrines, excludeRules, argv,
+    emit, theme, footprint, posture, mode, trust, doctrines, excludeRules, excludeSkills, argv,
   };
 }
 

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

@@ -96,11 +96,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,
@@ -331,14 +342,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 +434,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/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/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 {

package/js/maintain/setup.mjs

@@ -277,11 +277,18 @@ export function collectSetupLines() {
   // `setupBuildArgs` spell `--exclude-rules none`, and that string would land in the
   // "About to run:" line every recorded wizard probe compares byte for byte.
   const excludeRules = inst.excludeRules?.length ? inst.excludeRules : null;
+  // Skills left out are preserved the same way, and elide when there are none.
+  const excludeSkills = inst.excludeSkills?.length ? inst.excludeSkills : null;
   printOut(`\nAbout to run:  geneseed build ${
     setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines, allPacks,
-      excludeRules).join(' ')}\n`);
+      excludeRules, undefined, excludeSkills).join(' ')}\n`);
   if (!confirm('Proceed?', true)) return null;
-  return { theme, posture, mode, doctrines, excludeRules, emit, out, root, footprint };
+  // The key only when there is something to carry, so a selection that excludes no skill is
+  // the same object it was before the flag existed.
+  return {
+    theme, posture, mode, doctrines, excludeRules, ...(excludeSkills ? { excludeSkills } : {}),
+    emit, out, root, footprint,
+  };
 }
 
 // --------------------------------------------------------------------------------------
@@ -463,7 +470,7 @@ export function setupLines() {
   }
   const {
     theme, emit, out, root, footprint = 'lean', posture = 'peer', mode = 'direct',
-    doctrines = null, excludeRules = null,
+    doctrines = null, excludeRules = null, excludeSkills = null,
   } = sel;
   if (emit === 'opencode-global') {
     // The build below overwrites the deployed global harness, and the self-improvement loops
@@ -482,7 +489,7 @@ export function setupLines() {
   // runs must carry the pack selection the plan line just previewed, or the wizard would print
   // one command and run another.
   const argv = setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines,
-    doctrineOptions().map(([n]) => n), excludeRules);
+    doctrineOptions().map(([n]) => n), excludeRules, undefined, excludeSkills);
   printOut(`Running:  geneseed build ${argv.join(' ')}\n`);
   const rc = driverMain(argv);
   if (rc !== 0) {

package/js/maintain/update.mjs

@@ -617,7 +617,7 @@ export async function installAxes(dir, { installProfile, setupBuildArgs }) {
   if (!existsSync(path.join(String(dir), '.geneseed-emit'))) return [];
   const p = installProfile('opencode', 'global', String(dir));
   return setupBuildArgs('', 'files', null, null, p.footprint, p.posture, p.mode, p.doctrines,
-    undefined, p.excludeRules, p.trust).slice(4);
+    undefined, p.excludeRules, p.trust, p.excludeSkills).slice(4);
 }
 
 /**

package/js/web/actions.mjs

@@ -46,7 +46,8 @@ import {
   opencodeConfigDir, resolvePath,
 } from '../hosts/hosts.mjs';
 import {
-  EMIT_HOST_SCOPE, doctrinesForBuild, excludedRulesOfDir, footprintOfDir, installState,
+  EMIT_HOST_SCOPE, doctrinesForBuild, excludedRulesOfDir, excludedSkillsOfDir, footprintOfDir,
+  installState,
   installTargets, modeOfDir, postureOfDir, trustOfDir,
 } from '../hosts/installs.mjs';
 import {
@@ -550,6 +551,7 @@ export function apiRestore(state, files) {
       // The excluded rules for the same boundary reason: without them a restored AGENT.md
       // re-states a rule whose hook gate the install deliberately left unwired.
       excludeRules: excludedRulesOfDir(target),
+      excludeSkills: excludedSkillsOfDir(target),
     }));
     for (const raw of (isTruthy(files) ? files : [])) {
       const rel = stripWhitespace(formatValue(raw).replace(/\\/g, '/')).replace(/^\/+/, '');
@@ -622,7 +624,7 @@ export function apiInstallCmd(state, body) {
   const excludeRules = bodyExcludeRules(body) ?? excludedRulesOfDir(root);
   const out = scope === 'global' ? null : String(root);
   const argv = setupBuildArgs(theme || 'neutral', emit, out, out, fp, pos, mode, doctrines,
-    PACK_ORDER, excludeRules, trust);
+    PACK_ORDER, excludeRules, trust, excludedSkillsOfDir(root));
   return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }
 
@@ -716,6 +718,6 @@ export function apiDeployCmd(state, body) {
   const excludeRules = bodyExcludeRules(body) ?? excludedRulesOfDir(root);
   // project-scope emit name == host name (opencode / claude / bob / openclaude)
   const argv = setupBuildArgs(theme || 'neutral', host, root, root, fp, pos, mode, doctrines,
-    PACK_ORDER, excludeRules, trust);
+    PACK_ORDER, excludeRules, trust, excludedSkillsOfDir(root));
   return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "Every field here is argued and gated in tests/unit/package_manifest.test.mjs. `files`, `bin` and `engines` each have a test that fails when reality drifts from this file; `version` mirrors harness.config.json and is gated too. Read that docblock before editing this one.",
   "name": "geneseed",
-  "version": "3.15.0",
+  "version": "3.16.0",
   "description": "A portable, theme-able harness you implant once and use everywhere to grow a disciplined AI coding agent.",
   "keywords": [
     "ai",

package/src/AGENT.md.tmpl

@@ -295,7 +295,7 @@ inventory — that list is the catalogue and it is authoritative. Each written
 procedure is in [`{{DIR_SKILLS}}/`]({{DIR_SKILLS}}/) and the host loads it on
 demand.
 <!-- CATALOG:end -->
-
+{{EXCLUDED_SKILLS_LINE}}
 When a task repeats and no {{SKILL}} covers it, forge one through the
 [skill-forge]({{DIR_SKILLS}}/skill-forge.md) {{SKILL}}: copy
 [`{{DIR_SKILLS}}/_template.md`]({{DIR_SKILLS}}/_template.md), keep it to one coherent