geneseed 3.1.3 → 3.3.0

package/adapters/opencode/README.md

@@ -383,7 +383,11 @@ behaviour** — nothing changes the machine's current agent/model unless you opt
   files (Law I), catastrophic shell like `rm -rf /` (Law IV), and any mutation under
   a declared wiki's `protected` folders (AGENT.md §8, from `wiki.jsonc`); **warns** on
   `.env` writes and force-push. `GENESEED_GUARD=off` disables it, `=warn` downgrades
-  blocks to warnings.
+  blocks to warnings. Every **block** appends one line to the install's
+  `notebook/gates.jsonl` (rule `law-1` / `law-4` / `process-1` / `wiki`, a timestamp,
+  never the path or command) — the same ledger the Claude-family hooks write, so
+  `geneseed status` counts what the boundary caught on every host. Warnings are not
+  recorded.
 - **Invisible context injection** (the default). The context plugin delivers via
   `experimental.chat.messages.transform`, so the PROJECT CONTEXT block never appears in
   the conversation and survives compaction inherently; on a build without the hook it

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

@@ -60,6 +60,36 @@ const WARN_ONLY = MODE === "warn"
 
 function log(msg) { console.error(`[geneseed-guard] ${msg}`) }
 
+// ---- the gate ledger ------------------------------------------------------------
+// The twin of `ledger()` in js/hosts/hooks.mjs: one JSON line per BLOCK into
+// `<cfg>/notebook/gates.jsonl`, the rule and never the content, so `geneseed status` can
+// count what the boundary actually caught on an OpenCode install too. Until this the
+// recommended install was the one with no gate evidence at all. A warning is not recorded
+// (nothing was refused) and neither is `GENESEED_GUARD=warn`. `notebook/` is never created
+// here — an install without one (or a test importing this file) records nothing. Capped
+// at the newest MAX_LEDGER_LINES like the hook's; never throws, never decides.
+const MAX_LEDGER_LINES = 1000
+async function ledger(rule) {
+  try {
+    const bases = []
+    if (process.env.GENESEED_HARNESS) bases.push(process.env.GENESEED_HARNESS)
+    bases.push(path.dirname(PLUGIN_DIR))
+    for (const base of bases) {
+      const dir = path.join(base, "notebook")
+      if (!(await isDir(dir))) continue
+      const file = path.join(dir, "gates.jsonl")
+      await fs.appendFile(file, `${JSON.stringify({
+        ts: new Date().toISOString(), verb: "guard", rule, cwd: process.cwd(),
+      })}\n`)
+      const lines = (await fs.readFile(file, "utf8")).split("\n").filter(Boolean)
+      if (lines.length > MAX_LEDGER_LINES) {
+        await fs.writeFile(file, `${lines.slice(-MAX_LEDGER_LINES).join("\n")}\n`)
+      }
+      return
+    }
+  } catch { /* the ledger never decides */ }
+}
+
 // Files the agent must not write (secrets / private keys) → BLOCK.
 const SECRET_RE = [
   /(^|\/)id_(rsa|ed25519|ecdsa|dsa)(\.pub)?$/i,
@@ -119,6 +149,7 @@ const hasAny = (name, parts) => parts.some((s) => name.includes(s))
 // per wiki. Mutating anything under one is denied. Same resolution chain as the
 // context plugin: $GENESEED_WIKI -> $GENESEED_HARNESS/wiki.jsonc -> beside the install.
 async function isFile(p) { try { return (await fs.stat(p)).isFile() } catch { return false } }
+async function isDir(p) { try { return (await fs.stat(p)).isDirectory() } catch { return false } }
 
 // wiki.jsonc is JSONC (the seeded stub carries a commented example): strip // and
 // /* */ comments plus trailing commas before parsing — string-aware, so quoted
@@ -243,22 +274,25 @@ export const GeneseedGuard = async () => {
       if (await sovereignBypass(process.cwd())) return
       const tool = (input?.tool || input?.name || "").toLowerCase()
       const args = output?.args || input?.args || {}
-      const deny = (why) => {
+      // `rule` is the ledger key, spelled as js/hosts/hooks.mjs spells it (`law-1`,
+      // `law-4`, `process-1`) plus `wiki`, so status counts one vocabulary across hosts.
+      const deny = async (why, rule) => {
         if (WARN_ONLY) { log(`WARN (would block): ${why}`); return false }
         log(`BLOCKED: ${why}`)
+        await ledger(rule)
         throw new Error(`[geneseed-guard] blocked: ${why} — set GENESEED_GUARD=off to allow`)
       }
       try {
         if (hasAny(tool, WRITE_TOOLS)) {
           const p = pickPath(args)
-          if (p && SECRET_RE.some((re) => re.test(p))) { deny(`write to secret/key file ${p} (Law I)`); return }
+          if (p && SECRET_RE.some((re) => re.test(p))) { await deny(`write to secret/key file ${p} (Law I)`, "law-1"); return }
           if (p && SECRET_WARN_RE.some((re) => re.test(p))) log(`WARN: writing ${p} — keep secrets out of tracked files (Law I)`)
           const store = p && ruleStoreTarget(p)
           if (store && !RULE_STORE_BUMPED.has(p)) {
             RULE_STORE_BUMPED.add(p)
-            deny(`writing to ${store} — a standing rule, or a fact to remember? That ` +
+            await deny(`writing to ${store} — a standing rule, or a fact to remember? That ` +
                  `choice is the user's (Doctrine process 1). Settle it through the rule skill, ` +
-                 `then re-issue this write`)
+                 `then re-issue this write`, "process-1")
             return
           }
         }
@@ -268,14 +302,14 @@ export const GeneseedGuard = async () => {
             const abs = (path.isAbsolute(p) ? p : path.resolve(p)).replace(/\\/g, "/").toLowerCase()
             const hit = (await protectedPrefixes()).find(
               (x) => abs.startsWith(x.prefix) || abs === x.prefix.slice(0, -1))
-            if (hit) { deny(`mutation in protected wiki folder — ${hit.label} (AGENT.md §8)`); return }
+            if (hit) { await deny(`mutation in protected wiki folder — ${hit.label} (AGENT.md §8)`, "wiki"); return }
           }
         }
         // NOT else-if: a compound tool name (e.g. exec_and_save) can match both
         // classes, and the shell check must still run after the write check.
         if (hasAny(tool, SHELL_TOOLS)) {
           const c = pickCommand(args)
-          if (c && SHELL_BLOCK_RE.some((re) => re.test(c))) { deny(`catastrophic command (Law IV): ${c.slice(0, 80)}`); return }
+          if (c && SHELL_BLOCK_RE.some((re) => re.test(c))) { await deny(`catastrophic command (Law IV): ${c.slice(0, 80)}`, "law-4"); return }
           if (c && SHELL_WARN_RE.some((re) => re.test(c))) log(`WARN: irreversible op — confirm intent (Law IV): ${c.slice(0, 80)}`)
         }
       } catch (err) {

package/bin/build-driver.mjs

@@ -16,14 +16,16 @@
  * values this file must originate. `ROOT` and the seven paths under it come from this
  * script's own location, not from an inherited `cfg`.
  *
- * TWO KEYS ARE DELIBERATELY ABSENT FROM `cfg`, and their absence is load-bearing.
- * `js_cfg()` (_build_core.py:199) always sends `structure` and `capabilityLinkRe`, because
- * the Python originals are module-level names that TESTS MUTATE — `_OWNED` membership
- * asked one level out. This driver has no Python module to mutate, so it sends neither and
- * `js/build/render.mjs:215`'s `cfg.structure ?? STRUCTURE` and `js/build/bundle.mjs`'s
- * `cfg.capabilityLinkRe ? ... : <default>` take their right-hand branches for the first
- * time. Those two fallbacks have been dead code since they were written — always
- * overridden by the driver that always supplies them. P4 is what makes them live.
+ * A KEY IS DELIBERATELY ABSENT FROM `cfg`, and its absence is load-bearing.
+ * `js_cfg()` (_build_core.py:199) always sent `structure` and `capabilityLinkRe`, because
+ * the Python originals were module-level names that TESTS MUTATE — `_OWNED` membership
+ * asked one level out. This driver has no Python module to mutate, so it sends neither;
+ * `js/build/render.mjs:215`'s `cfg.structure ?? STRUCTURE` takes its right-hand branch for
+ * that reason — a fallback that was dead code until P4, always overridden by the driver
+ * that always supplies it. `capabilityLinkRe`'s equivalent fallback in
+ * `js/build/emit-common.mjs`'s `stripCapabilityLinks` was P4's other one made live, and the
+ * over-engineering cleanup then deleted the override branch outright: nothing had ever
+ * supplied one, so there was no longer a `cfg` left to be absent from.
  *
  * THE FOOTPRINT DEFAULT IS THE FLAG'S, NOT THE FUNCTION'S. `--footprint` defaults to
  * `lean` (build.py:354); every `emit_*`/`build` SIGNATURE defaults to `full`. A driver
@@ -32,15 +34,16 @@
  */
 import {
   existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmdirSync,
-  statSync, unlinkSync,
+  unlinkSync,
 } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { parseArgs as nodeParseArgs } from 'node:util';
 import { build, phaseLog } from '../js/build/bundle.mjs';
 import { emitClaudeRender } from '../js/build/emit-claude.mjs';
 import { emitOpencodeRender, emitOpencodeGlobalRender } from '../js/build/emit-opencode.mjs';
-import { settingsIntegrityCheck } from '../js/hosts/settings.mjs';
-import { writeText, withPlatformNewlines } from '../js/lib/fs.mjs';
+import { copilotIntegrityCheck, settingsIntegrityCheck } from '../js/hosts/settings.mjs';
+import { writeText, withPlatformNewlines, isFile } from '../js/lib/fs.mjs';
 import { parseJson, jsonDumpsIndent } from '../js/lib/json.mjs';
 // P5c moved these out of this file: `bin/geneseed-cli.mjs` needs the same four resolvers to
 // find a global install, and a resolver that decides WHERE a driver writes is the last thing
@@ -188,6 +191,26 @@ const FLAGS = {
   '-v': 'verbose', '--verbose': 'verbose',
 };
 
+/**
+ * `util.parseArgs`'s own option table, DERIVED from `VALUED`/`FLAGS` rather than typed out a
+ * second time — a hand-written twin is exactly the anti-drift failure this module's docblock
+ * already names for `usage()`. Every `VALUED` entry is `type: 'string'` (so a bare `--flag
+ * value` form is captured as one token instead of leaking `value` as an orphan positional);
+ * every long `FLAGS` entry is `type: 'boolean'`. `-v` gets `short: 'v'` for the same reason
+ * `-h` deliberately does NOT get one below `PARSE_OPTIONS` — see `parseArgs`'s docblock.
+ */
+const PARSE_OPTIONS = Object.fromEntries([
+  ...Object.keys(VALUED).map((f) => [f.slice(2), { type: 'string' }]),
+  ...Object.keys(FLAGS).filter((f) => f.startsWith('--')).map((f) => [f.slice(2), { type: 'boolean' }]),
+]);
+PARSE_OPTIONS.verbose = { type: 'boolean', short: 'v' };
+
+/** `token.name` (dashes stripped, short aliases folded in) -> this file's `args` key. */
+const VALUED_BY_NAME = Object.fromEntries(Object.keys(VALUED).map((f) => [f.slice(2), VALUED[f]]));
+const FLAG_BY_NAME = Object.fromEntries(
+  Object.keys(FLAGS).filter((f) => f.startsWith('--')).map((f) => [f.slice(2), FLAGS[f]]),
+);
+
 /**
  * The four flags `choice` validates, as ONE table for the same anti-drift reason.
  *
@@ -307,7 +330,31 @@ function usage() {
   ].join('\n');
 }
 
-/** argparse's `--flag value` and `--flag=value`, plus the `--target` alias for `--out`. */
+/**
+ * argparse's `--flag value` and `--flag=value`, plus the `--target` alias for `--out` — the
+ * SPLITTING now done by `util.parseArgs({tokens: true})`, with every choice/mutex/wording
+ * decision this function made before P6 (Task 4) still made HERE, unmoved.
+ *
+ * `strict: false` is load-bearing twice: it lets an unrecognized flag surface as a token this
+ * walk can refuse in its OWN words rather than node's, and it is what makes a value-taking
+ * flag (`type: 'string'` in `PARSE_OPTIONS`) swallow the very next raw argument even when that
+ * argument itself looks like a flag — `--theme --posture peer` sets `theme` to the literal
+ * string `"--posture"` and leaves `peer` a stray token, exactly as the hand-rolled version
+ * being replaced did with its own `argv[i += 1]`. That is not a bug this port inherited by
+ * accident: it is the one shape `parseArgs`'s tokenizer reproduces for free, and reproducing
+ * anything smarter (a lookahead that refuses to swallow a flag-shaped value) would be new
+ * behaviour, not a preserved one.
+ *
+ * `-h` DELIBERATELY IS NOT `PARSE_OPTIONS.help`'s short alias. Declaring one would make
+ * `parseArgs` fold a bundled `-vh` into two tokens — `verbose` then `help` — and print the
+ * help text for a cluster the original parser refused outright as one unrecognized argument.
+ * Detecting help by re-reading `argv[tok.index]` for the literal text `-h`/`--help` keeps the
+ * ORIGINAL equality check (`tok === '-h' || tok === '--help'`) intact no matter how `parseArgs`
+ * privately tokenizes the cluster, and `argv[tok.index]` is what recovers that literal text
+ * for every refusal below — `tok.name`/`tok.rawName` are `parseArgs`'s own canonicalisation and
+ * would print `-b`/`-o`/`-g`/`-u`/`-s` for a bundle like `-bogus` where the original parser (and
+ * this one) refuses the whole typed token, `-bogus`, once.
+ */
 function parseArgs(argv, defaults) {
   const args = {
     theme: defaults.theme, posture: defaults.posture, mode: defaults.mode,
@@ -316,11 +363,12 @@ function parseArgs(argv, defaults) {
     out: 'Harness', emit: 'files', footprint: 'lean', root: null,
     syncThemes: false, validateOnly: false, verbose: false,
   };
-  for (let i = 0; i < argv.length; i += 1) {
-    const tok = argv[i];
-    const eq = tok.indexOf('=');
-    const name = eq > 0 ? tok.slice(0, eq) : tok;
-    if (tok === '-h' || tok === '--help') {
+  const { tokens } = nodeParseArgs({
+    args: argv, options: PARSE_OPTIONS, allowPositionals: true, strict: false, tokens: true,
+  });
+  for (const tok of tokens) {
+    if (tok.kind === 'option' && tok.value === undefined
+      && (argv[tok.index] === '-h' || argv[tok.index] === '--help')) {
       process.stdout.write(usage());
       // The same marker `die` throws, with a SUCCESS code: help is not a refusal, and
       // `main`'s catch is what turns either into this process's exit status. A bare
@@ -330,15 +378,24 @@ function parseArgs(argv, defaults) {
       e.exitCode = 0;
       throw e;
     }
-    if (VALUED[name]) {
-      const val = eq > 0 ? tok.slice(eq + 1) : argv[i += 1];
-      if (val === undefined) die(2, `argument ${name}: expected one argument`);
-      args[VALUED[name]] = val;
-    } else if (FLAGS[tok]) {
-      args[FLAGS[tok]] = true;
-    } else {
-      die(2, `unrecognized arguments: ${tok}`);
+    if (tok.kind === 'option' && VALUED_BY_NAME[tok.name] !== undefined) {
+      if (tok.value === undefined) die(2, `argument ${tok.rawName}: expected one argument`);
+      args[VALUED_BY_NAME[tok.name]] = tok.value;
+      continue;
+    }
+    // `tok.value === undefined` excludes `--sync-themes=x` from matching here — a store_true
+    // flag never took `=` in the hand-rolled version either, because its `FLAGS[tok]` lookup
+    // keyed on the WHOLE typed token (equals sign and all), never on the split-off flag name.
+    // `parseArgs` always sets a `value` KEY on every option token (`undefined` when none was
+    // given), so this must compare the VALUE, not `'value' in tok` — the key is always there.
+    if (tok.kind === 'option' && tok.value === undefined && FLAG_BY_NAME[tok.name] !== undefined) {
+      args[FLAG_BY_NAME[tok.name]] = true;
+      continue;
     }
+    // Every other shape — an unrecognized option, a bare positional, or `--` (which `parseArgs`
+    // always treats as a terminator but this parser never did) — refuses with the literal text
+    // typed at that argv position, matching the original's `unrecognized arguments: ${tok}`.
+    die(2, `unrecognized arguments: ${argv[tok.index]}`);
   }
   const choices = choicesFor();
   for (const flag of Object.keys(choices)) choice(flag, args[VALUED[flag]], choices[flag]);
@@ -532,10 +589,6 @@ function writeManifestAtomic(file, data) {
   renameSync(tmp, file);
 }
 
-function isFile(p) {
-  try { return statSync(p).isFile(); } catch { return false; }
-}
-
 /**
  * Write-before-delete: remove only what this layer owned before and no longer produces.
  *
@@ -567,6 +620,30 @@ function pruneOwned(oc, oldOwned, owned) {
   }
 }
 
+/**
+ * The manifest PRE-read all three emit bodies performed inline: does a manifest already
+ * exist at `manifestPath`, and if so, what does it parse to. `existed` is what
+ * `emitOpencode` alone needs (as `manifestExisted`, threaded into the render job); every
+ * caller reads `doc.owned`, and `emitClaudeCore` also reads `doc.managed` — `doc` is `null`
+ * on a missing OR a corrupt manifest, so `(doc && doc.owned) || []` covers both the same way
+ * the three inline try/catches did.
+ */
+function readManifest(manifestPath) {
+  const existed = existsSync(manifestPath);
+  let doc = null;
+  if (existed) {
+    try { doc = parseJson(readFileSync(manifestPath, 'utf8')); } catch { doc = null; }
+  }
+  return { existed, doc };
+}
+
+/** The "+ primary agent, N command(s)" tail both OpenCode summary lines share. */
+function extrasTail(stats) {
+  const extras = [...(stats.primary ? ['primary agent'] : []),
+    ...(stats.nCommands ? [`${stats.nCommands} command(s)`] : [])];
+  return extras.length ? ` + ${extras.join(', ')}` : '';
+}
+
 /**
  * `_build_global._project_survivors` — registered per-repo PROJECT installs of `emitName`.
  *
@@ -624,14 +701,8 @@ function emitOpencode(cfg, args, out) {
   // PRE. A missing manifest reads as "owned nothing before", which is what makes the first
   // re-emit after an upgrade treat already-existing files as the user's (claim-on-create)
   // rather than deleting them. The prune set is then empty by construction.
-  const manifestExisted = existsSync(manifestPath);
-  let oldOwned = [];
-  if (manifestExisted) {
-    try {
-      const m = parseJson(readFileSync(manifestPath, 'utf8'));
-      oldOwned = (m && m.owned) || [];
-    } catch { oldOwned = []; }
-  }
+  const { existed: manifestExisted, doc } = readManifest(manifestPath);
+  const oldOwned = (doc && doc.owned) || [];
 
   const agentPathRel = relUnder(out, root);
   const agentPath = agentPathRel ? `${agentPathRel}/AGENT.md` : 'AGENT.md';
@@ -658,9 +729,7 @@ function emitOpencode(cfg, args, out) {
     scope: 'project',
   });
 
-  const extras = [...(stats.primary ? ['primary agent'] : []),
-    ...(stats.nCommands ? [`${stats.nCommands} command(s)`] : [])];
-  const extra = extras.length ? ` + ${extras.join(', ')}` : '';
+  const extra = extrasTail(stats);
   process.stdout.write(`[geneseed] opencode layer: ${stats.nAgents} subagents, `
     + `${stats.nSkills} skills, ${stats.nPlugins} plugin(s), `
     + `${stats.nWorkflows} workflow file(s), ${cfgName} (instructions: ${agentPath})`
@@ -687,13 +756,8 @@ function emitOpencodeGlobal(cfg, args, out) {
   const cfgDir = args.cfgDir ?? opencodeConfigDir();
   const manifestPath = path.join(cfgDir, GLOBAL_MANIFEST);
 
-  let oldOwned = [];
-  if (existsSync(manifestPath)) {
-    try {
-      const m = parseJson(readFileSync(manifestPath, 'utf8'));
-      oldOwned = (m && m.owned) || [];
-    } catch { oldOwned = []; }
-  }
+  const { doc } = readManifest(manifestPath);
+  const oldOwned = (doc && doc.owned) || [];
 
   const agentPath = path.join(cfgDir, 'AGENT.md').split(path.sep).join('/');
 
@@ -717,9 +781,7 @@ function emitOpencodeGlobal(cfg, args, out) {
     owned: [...owned].sort(),
   });
 
-  const extras = [...(stats.primary ? ['primary agent'] : []),
-    ...(stats.nCommands ? [`${stats.nCommands} command(s)`] : [])];
-  const extra = extras.length ? ` + ${extras.join(', ')}` : '';
+  const extra = extrasTail(stats);
   process.stdout.write(`[geneseed] opencode-global -> ${cfgDir}: ${stats.nAgents} subagents, `
     + `${stats.nSkills} skills, ${stats.nPlugins} plugin(s), `
     + `${stats.nWorkflows} workflow file(s), AGENT.md, ${memStatus}, ${nbStatus}, `
@@ -749,16 +811,10 @@ function emitOpencodeGlobal(cfg, args, out) {
  */
 function emitClaudeCore(cfg, args, { cfgDir, claudeMd, scope, host, out, hookOpts }) {
   const manifestPath = path.join(cfgDir, GLOBAL_MANIFEST);
-  let oldOwned = [];
-  let oldManaged = {};
-  if (existsSync(manifestPath)) {
-    try {
-      const data = parseJson(readFileSync(manifestPath, 'utf8'));
-      oldOwned = data.owned || [];
-      oldManaged = (data.managed && typeof data.managed === 'object'
-        && !Array.isArray(data.managed)) ? data.managed : {};
-    } catch { oldOwned = []; oldManaged = {}; }
-  }
+  const { doc } = readManifest(manifestPath);
+  const oldOwned = (doc && doc.owned) || [];
+  const oldManaged = (doc && doc.managed && typeof doc.managed === 'object'
+    && !Array.isArray(doc.managed)) ? doc.managed : {};
   const isCopilot = host === 'copilot';
 
   // RENDER + WIRE in one child's worth of work. `preambleExclude` is null for every host
@@ -792,8 +848,8 @@ function emitClaudeCore(cfg, args, { cfgDir, claudeMd, scope, host, out, hookOpt
   // VERIFY — re-read the settings file just written and match it against the claims just
   // recorded, so a merge that silently did not stick (a commented file, a mid-flight
   // external edit, a bug in the merge) is loud now instead of surfacing as hooks that
-  // quietly never fire. Skipped for Copilot, which writes no settings file at all
-  // (`_emit_claude_core:827`) — the other half of why Copilot could cross first.
+  // quietly never fire. Copilot's settings have their own shape and their own check; a
+  // Copilot PROJECT emit records no hooks and so checks nothing.
   //
   // On the Python driver this stage runs in Python AFTER a Node child did the wiring, which
   // makes it a live cross-implementation check on every build. Here both halves are Node, so
@@ -804,15 +860,17 @@ function emitClaudeCore(cfg, args, { cfgDir, claudeMd, scope, host, out, hookOpt
   // SILENT ON SUCCESS, which is its own coverage hazard: a clean emit prints nothing, so
   // deleting this call is byte-identical in all 259 cells. `test_verify_reports_an_orphaned
   // _geneseed_hook` plants the fault that makes it speak.
+  phaseLog('VERIFY');
   if (!isCopilot) {
-    phaseLog('VERIFY');
     settingsIntegrityCheck(
       path.join(cfgDir, managed.settings_file || 'settings.json'), managed, 'present');
+  } else if (managed.copilot_hooks) {
+    copilotIntegrityCheck(path.join(cfgDir, 'settings.json'), managed.copilot_hooks, 'present');
   }
   return {
     nAgents: stats.nAgents,
     nSkills: stats.nSkills,
-    nHooks: (managed.settings_hooks || []).length,
+    nHooks: (managed.settings_hooks || managed.copilot_hooks || []).length,
     memStatus,
     nbStatus,
   };
@@ -827,7 +885,8 @@ function emitCopilot(cfg, args, out) {
   });
   process.stdout.write(`[geneseed] copilot (folder) -> ${root}: AGENTS.md + .github/ `
     + `(${r.nAgents} agents (.agent.md), ${r.nSkills} skills), ${r.memStatus}, `
-    + `${r.nbStatus}. No settings.json/hooks (Copilot has none).\n`);
+    + `${r.nbStatus}. No hooks at project scope (Copilot reads hooks from `
+    + '~/.copilot/settings.json only — the global emit wires them).\n');
   return cfgDir;
 }
 
@@ -835,14 +894,17 @@ function emitCopilot(cfg, args, out) {
 function emitCopilotGlobal(cfg, args, out) {
   const cfgDir = args.cfgDir ?? copilotConfigDir();
   warnCopilotGlobalOverProject();
+  // The hook runner pair, as for Claude and Bob: the global emit is the one Copilot scope
+  // that wires hooks (`~/.copilot/settings.json`), and the shim it bakes is machine-wide.
+  const hookOpts = hookRunnerEntry();
   const r = emitClaudeCore(cfg, args, {
     cfgDir, claudeMd: path.join(cfgDir, 'copilot-instructions.md'),
-    scope: 'global', host: 'copilot', out,
+    scope: 'global', host: 'copilot', out, hookOpts,
   });
   process.stdout.write(`[geneseed] copilot-global -> ${cfgDir}: ${r.nAgents} agents (.agent.md), `
-    + `${r.nSkills} skills, copilot-instructions.md, ${r.memStatus}, ${r.nbStatus}. `
-    + 'No settings.json/hooks (Copilot has no hook mechanism — memory rides the '
-    + "preamble's instructions); MCP servers go in mcp-config.json.\n");
+    + `${r.nSkills} skills, copilot-instructions.md, ${r.memStatus}, ${r.nbStatus}, `
+    + `${r.nHooks} hooks (settings.json: sessionStart context, toolCall gate). Memory `
+    + "write-back rides the preamble's instructions; MCP servers go in mcp-config.json.\n");
   return cfgDir;
 }
 
@@ -1123,30 +1185,22 @@ function run(argv) {
   // The marker directory is the emit's TARGET, which for a global emit is the config dir it
   // just rendered into and not `--out` at all — so the emit returns it rather than the
   // caller guessing (build.py:427-436 re-resolves; returning it keeps one resolution).
+  //
+  // NINE ARMS, TWO TABLES ALREADY ON FILE: `GLOBAL_EMITS` and `PROJECT_EMITS` above are
+  // exactly this dispatch's `-global` and per-repo halves, keyed by host rather than by
+  // `--emit` name, so splitting the suffix reaches both without a third map.
   let markerDir = out;
-  if (args.emit === 'opencode') {
-    emitOpencode(cfg, args, out);
-  } else if (args.emit === 'opencode-global') {
-    markerDir = emitOpencodeGlobal(cfg, args, out);
-  } else if (args.emit === 'copilot') {
+  if (args.emit.endsWith('-global')) {
+    markerDir = GLOBAL_EMITS[args.emit.slice(0, -'-global'.length)](cfg, args, out);
+  } else if (args.emit !== 'files') {
     // The PROJECT emits keep their markers in `out`, not in the host config dir the emit
     // wrote to (build.py:435-436) — `.github/` is the layer, `out` is the install.
-    emitCopilot(cfg, args, out);
-  } else if (args.emit === 'copilot-global') {
-    markerDir = emitCopilotGlobal(cfg, args, out);
-  } else if (args.emit === 'claude') {
-    emitClaude(cfg, args, out);
-  } else if (args.emit === 'claude-global') {
-    markerDir = emitClaudeGlobal(cfg, args, out);
-  } else if (args.emit === 'bob') {
-    emitBob(cfg, args, out);
-  } else if (args.emit === 'bob-global') {
-    markerDir = emitBobGlobal(cfg, args, out);
+    PROJECT_EMITS[args.emit](cfg, args, out);
   } else {
-    // `nativeCatalog: false` is build.py:421's three-positional-argument call reproduced:
-    // `build(args.theme, out, args.footprint)` leaves `native_catalog` at its signature
-    // default. It is the one signature default this driver DOES inherit, and it is
-    // inherited because the Python CLI inherits it too.
+    // The ninth choice, a plain bundle: `nativeCatalog: false` is build.py:421's
+    // three-positional-argument call reproduced — `build(args.theme, out, args.footprint)`
+    // leaves `native_catalog` at its signature default. It is the one signature default
+    // this driver DOES inherit, and it is inherited because the Python CLI inherits it too.
     build(cfg, args.theme, out, { footprint: args.footprint, nativeCatalog: false });
   }