geneseed 3.14.0 → 3.16.0

package/js/build/generate.mjs

@@ -9,25 +9,27 @@
  * WHY `build` IMPORTS THE DRIVER RATHER THAN SPAWNING IT. The Python is
  * `run([sys.executable, BUILD, *extra]).returncode` — a passthrough to a second process.
  * Reproducing that shape here would mean spawning `node bin/build-driver.mjs`, and
- * `test_the_cli_reaches_no_child_process_module` forbids it: the ban is transitive over this
- * entry's imports, and P5c's argument for keeping it is that `web`, `upgrade` and `setup`
- * will genuinely need to spawn, so the ban should outlive them rather than be dismantled by
- * a verb that does not. It is also the wrong shape on its own terms. Python needs a second
+ * `tests/unit/hook_cli.test.mjs`'s 'the CLI entry reaches child_process only where it is
+ * declared' forbids it: the check is transitive over this entry's imports and allow-lists only
+ * the modules that genuinely start processes — `web`, `upgrade`, `setup` — and P5c's argument
+ * for it is that the ban should outlive them rather than be dismantled by a verb that does not.
+ * It is also the wrong shape on its own terms. Python needs a second
  * process because `build.py` is a different PROGRAM; `bin/build-driver.mjs` is a module in this
  * one, and a Node CLI spawning a Node driver to do work it could do in-process is exactly
  * the passthrough the whole port has been removing. So the driver's `main` is exported and
  * called directly, and the observable contract — the tree, the streams, the exit code — is
- * what `build/*` in `tests/harness_golden.py` compares.
+ * what the `build/*` cells of `tests/golden.mjs --cli` assert.
  *
  * WHAT NO CELL CAN REACH HERE, stated rather than left implicit. `fenceFor`'s real arm is
  * unreachable from the matrix: measured over the whole rendered tree, the longest backtick
  * run in any source text is 3, so `max(4, longest + 1)` picks 4 for all 96 files, and a port
  * that hardcoded four backticks is byte-identical in every prompt cell. Reaching the other
  * arm needs a file in `src/`, and `src/` is the tree no fixture can redirect (P5d). It is
- * therefore gated as a pure function over a corpus in `tests/snapshot/pure_snapshot.test.mjs`, with the
- * unreachability measured in BOTH directions rather than asserted: one test proves the corpus
- * leaves the floor, and one re-renders every theme × posture × mode of the live tree and proves
- * `src/` still does not. The 96 above is one render — the sweep is 13 440 files.
+ * the former Python suite gated it as a pure function over a corpus, with the unreachability
+ * measured in BOTH directions rather than asserted: one test proved the corpus left the floor,
+ * and one re-rendered every theme × posture × mode of the live tree and proved `src/` still did
+ * not. The 96 above is one render — the sweep was 13 440 files. That suite is gone and no Node
+ * test calls `fenceFor`, so the real arm is pinned by nothing today.
  */
 import { existsSync, mkdirSync, statSync } from 'node:fs';
 import path from 'node:path';
@@ -38,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';
@@ -95,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'],
 ];
 
@@ -138,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);
@@ -162,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;
 }
 
@@ -202,7 +208,7 @@ export function installProfile(host, scope, root) {
   const posture = postureOfDir(root) || defaultPosture();
   const mode = modeOfDir(root) || defaultMode();
   // Read off the deployed loop skill; no config fallback — `DEFAULT_PRESET` is the engine's.
-  const trust = trustOfDir(root) || DEFAULT_PRESET;
+  const trust = trustOfDir(root, host) || DEFAULT_PRESET;
   // A rebuild that defaulted the pack selection would re-emit an install into a constitution
   // its owner did not choose — and in one direction that is not merely surprising: dropping
   // the process pack takes the commit/push consent RULES out of AGENT.md while
@@ -215,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
@@ -225,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,
   };
 }
 
@@ -360,7 +368,9 @@ export function buildPrompt(cfg, themeName) {
  * Windows. At ~10,000 newlines in a 400 KB document that is the largest byte difference this
  * port could ship, and `harness_golden` can only see half of it — the FILE half is compared
  * directly, the stdout half is folded by `subprocess`'s universal-newline decode, which is
- * why `test_the_two_entry_points_agree_on_stdout_BYTES` grew a `prompt` row.
+ * why the former Python suite's stdout-bytes comparison grew a `prompt` row — kept today as
+ * a row of `tests/unit/hook_cli.test.mjs`'s 'every newline the entry points write is the
+ * platform's'.
  */
 export function cmdPrompt(args) {
   // `args.theme or "neutral"` — a literal in the Python, NOT the config's theme, so this

package/js/build/render.mjs

@@ -8,7 +8,7 @@
  *
  * WHY THIS HALF AND NOT MORE. The emits split into five stages —
  * RENDER* -> WIRE* -> PRUNE -> MANIFEST -> VERIFY (see `_build_global._emit_claude_core`
- * and tests/test_emit_phase_order.py). RENDER produces files Geneseed owns wholesale;
+ * and tests/unit/emit_phase_order.test.mjs). RENDER produces files Geneseed owns wholesale;
  * WIRE reconciles files the user co-owns (settings.json, opencode.json, the CLAUDE.md
  * managed block) and lives in `js/hosts/settings.mjs`, driven from the two emit modules.
  * THIS module is only RENDER
@@ -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

@@ -20,9 +20,9 @@
  * `capabilityLinkRe`'s equivalent override in `stripCapabilityLinks` had no producer either
  * and was deleted outright in the over-engineering cleanup, `cfg` param and all.
  *
- * The move is safe for the reason P5c's was: `tests/golden.py` drives `bin/build-driver.mjs`
- * over 259 cells and compares the tree byte-for-byte, and every one of them builds a cfg
- * from these paths. A depth error or a renamed key fails 259 cells, not zero.
+ * The move is safe for the reason P5c's was: `tests/golden.mjs` drives `bin/build-driver.mjs`
+ * over every emit configuration and requires each to render, and every one of them builds a
+ * cfg from these paths. A depth error or a renamed key fails every cell, not zero.
  */
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
@@ -38,7 +38,7 @@ import { DEFAULT_PRESET } from '../loop/score.mjs';
  * on raw or folded text, so one behaviour serves both.
  */
 const _packTexts = new Map();
-export function readRawText(file) {
+function readRawText(file) {
   const key = path.resolve(file);
   const mtime = statSync(file).mtimeMs;
   const hit = _packTexts.get(key);
@@ -160,8 +160,8 @@ export function resolveRuleIds(text, src = SRC) {
  * `_OWNED` redirect the suite uses is an in-process write, and no env var moves it
  * (`$GENESEED_ROOT` is `harness context`'s doc-discovery root — a different name for a
  * different job). Both implementations therefore answer from their own file's location,
- * which is what makes them comparable and what makes them unfenceable. See the
- * status/version section of `tests/harness_golden.py`.
+ * which is what made them comparable and what makes them unfenceable. See
+ * `js/inspect/status.mjs`'s header for what that leaves unreachable from any cell.
  */
 export const ROOT = path.resolve(import.meta.dirname, '../..');
 export const SRC = path.join(ROOT, 'src');
@@ -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/build/stubs.mjs

@@ -9,8 +9,9 @@
  */
 import path from 'node:path';
 import { writeText } from '../lib/fs.mjs';
+import { isDir } from '../lib/fs.mjs';
 import { jsonDumpsIndent } from '../lib/json.mjs';
-import { isDir } from './emit-common.mjs';
+import { EXCLUDES_FILE } from '../hosts/hosts.mjs';
 import { existsSync } from 'node:fs';
 
 // ---------------------------------------------------------------------------
@@ -102,8 +103,8 @@ usually one promoted from a recurring memory. Review it by that date, then
 graduate it (remove the marker) or demote it back to memory.
 `;
 
-/** `_build_render.EXCLUDES_FILE`. */
-export const EXCLUDES_FILE = 'excludes.json';
+// Owned by `js/hosts/hosts.mjs` (the hook reads it there); re-exported for `js/inspect/excludes.mjs`.
+export { EXCLUDES_FILE };
 
 /**
  * `_build_render.EXCLUDES_STUB` — one long line, exactly as Python spells it.
@@ -232,8 +233,8 @@ export const ensureProfileStub = stubWriter(PROFILE_FILE, PROFILE_STUB);
 
 /**
  * `_build_render.ensure_excludes_stub` — the sovereign-repo list, seeded once and NEVER
- * overwritten. Reachable only from the Claude-shaped emits, which is why it arrived with
- * `emitClaudeRender` rather than with the bundle stubs beside it.
+ * overwritten. Called by every GLOBAL emit — the Claude-shaped ones and opencode-global —
+ * since that is where the hook looks for it.
  */
 export const ensureExcludesStub = stubWriter(EXCLUDES_FILE, EXCLUDES_STUB);
 

package/js/build/version.mjs

@@ -8,9 +8,11 @@
  */
 import path from 'node:path';
 import { VERSION_MARKER } from '../hosts/hosts.mjs';
-import { sourceReleaseVersion } from '../hosts/opencode.mjs';
 import { readText, writeText } from '../lib/fs.mjs';
-import { isDir, relPosix, rglobFiles } from './emit-common.mjs';
+import { parseJson } from '../lib/json.mjs';
+import { isDir } from '../lib/fs.mjs';
+import { relPosix } from '../lib/text.mjs';
+import { rglobFiles } from './emit-common.mjs';
 import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 
@@ -132,6 +134,23 @@ export function versionIsNewer(a, b) {
   return false;
 }
 
+/**
+ * `_build_core.source_release_version` — the release this checkout would install. It reads
+ * `cfg.config`, so it takes `cfg`. It lived in `js/hosts/opencode.mjs` for no better reason
+ * than that the first caller was there; every reader since asks a version question, so it
+ * lives with them. `js/hosts/opencode.mjs` re-exports it for its older importers.
+ */
+export function sourceReleaseVersion(cfg) {
+  try {
+    const data = parseJson(readText(cfg.config));
+    const v = data && typeof data === 'object' && !Array.isArray(data) ? data.version : null;
+    if (typeof v === 'string' && v) return v;
+  } catch {
+    // OSError / JSONDecodeError — degrade to "not newer" rather than raising.
+  }
+  return '0.0.0';
+}
+
 /** `_build_render._warn_if_downgrade` — STDOUT, matching the Python. */
 function warnIfDowngrade(cfg, out) {
   const deployed = readReleaseVersion(out);

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

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { readText, printOut as out, printErr as err, withDiscardableStderr } from '../lib/fs.mjs';
 import { normcase, toPlatformPath } from '../lib/paths.mjs';
+import { relPosix } from '../lib/text.mjs';
 import { resolvePath, sovereignBypass } from './hosts.mjs';
 import { isFile, isDir, selfAndParents, sortPaths, listDir } from './hooks-prims.mjs';
 
@@ -95,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,
@@ -177,7 +189,7 @@ function disp(pathStr, root) {
       !== path.parse(path.resolve(root)).root.toLowerCase()) {
     return pathStr;
   }
-  return path.relative(root, pathStr).split(path.sep).join('/');
+  return relPosix(root, pathStr);
 }
 
 
@@ -330,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) {
@@ -378,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/hooks-prims.mjs

@@ -23,8 +23,8 @@ import { comparePaths } from '../lib/paths.mjs';
 // none of that reached the hook, because a corpus finds what it is pointed at and nothing
 // named `pyStrPath` was. The consequence was live: `sovereignBypass` compares an
 // `excludes.json` entry against cwd, so a hand-edited `..` entry made the NODE hook stand
-// down for a repo Python still gates. `context/bypass-does-not-match-a-dotdot-entry` is
-// the cell.
+// down for a repo Python still gates. (Since the Python is gone, exclude entries resolve `..`
+// and symlinks on every host — `context/sovereign-bypass-matches-a-dotdot-entry` is the cell.)
 //
 // So the line is not "duplicate rather than couple" — it is "one owner for anything that
 // reproduces a language primitive, wherever it is used". `fs.mjs` carries no