geneseed 4.9.4 → 4.14.0

package/js/maintain/setup.mjs

@@ -41,12 +41,13 @@
  * a cell could not have varied the answers at all.
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 import { main as driverMain, resolveOut } from '../build/driver.mjs';
 import { playLine } from '../ui/anim.mjs';
-import { discoverNames, GATE_SWITCHES, PACK_ORDER } from '../build/source.mjs';
+import { discoverNames, GATE_SWITCHES, PACK_ORDER, loadKits } from '../build/source.mjs';
 import { exportImprovements } from '../inspect/diff.mjs';
 import { cmdDoctor } from '../inspect/doctor.mjs';
 import { setupBuildArgs } from '../build/generate.mjs';
@@ -227,6 +228,25 @@ function askDoctrines(deployed = null) {
     known === null || known.includes(name) ? 'yes' : 'no') === 'yes');
 }
 
+/**
+ * The Kits questions (spec A5): one yes/no per shipped kit, each defaulting to whether the install
+ * has it on (`deployed`, its `Active kits:` marker), so holding Enter keeps the installed set. A
+ * single pick could not hold two kits at once, which is why the menu became per kit when the second
+ * kit shipped. Asked ONLY when this checkout ships a kit, so a kit-less wizard reads exactly the
+ * stdin it always did (and has no kit to carry: `kitsOfDir` drops an unshipped one).
+ * Returns the kit list, or null for none (`setupBuildArgs` omits `--kits`).
+ */
+export function askKits(deployed = null, kits = null) {
+  try { kits ??= loadKits(); } catch (e) {
+    process.stderr.write(`warning: kit question skipped — ${e.message}\n`);
+    return null;
+  }
+  const on = (deployed ?? []).filter((k) => kits.has(k));
+  const picked = [...kits].filter(([k, m]) => askChoice(`Kit ${k} — ${m.description ?? k}`,
+    [['yes', `install the ${k} kit`], ['no', `leave ${k} out`]], on.includes(k) ? 'yes' : 'no') === 'yes');
+  return picked.length ? picked.map(([k]) => k) : null;
+}
+
 /**
  * `_harness_setup._collect_setup_lines` — the six questions, the plan, the confirm.
  *
@@ -260,13 +280,15 @@ function targetGates(emit, out) {
   }
 }
 
-export function collectSetupLines() {
+export function collectSetupLines(kitMap = null) {
   printOut('Geneseed setup — answer a few questions; nothing is written until you confirm.\n');
   const inst = installedDefaults();
   const theme = askChoice('Theme', themeOptions(), inst.theme || defaultTheme());
   const posture = askChoice('Posture', postureOptions(), inst.posture || defaultPosture());
   const mode = askChoice('Mode', modeOptions(), inst.mode || defaultMode());
   const doctrines = askDoctrines(inst.doctrines);
+  // Kits on stay on (spec A3); `kitsOfDir` already dropped a retired one.
+  const kits = askKits(inst.kits, kitMap);
   const emit = askChoice('Install mode', EMIT_OPTIONS, inst.emit || 'opencode-global');
   const footprint = askChoice('Footprint', FOOTPRINT_OPTIONS,
     inst.footprint || 'lean');
@@ -304,13 +326,13 @@ export function collectSetupLines() {
   const gated = Object.values(gates).some((on) => on === false);
   printOut(`\nAbout to run:  geneseed build ${
     setupBuildArgs(theme, emit, out, root, footprint, posture, mode, doctrines, allPacks,
-      excludeRules, undefined, excludeSkills, gates).join(' ')}\n`);
+      excludeRules, undefined, excludeSkills, gates, kits).join(' ')}\n`);
   if (!confirm('Proceed?', true)) return null;
   // The key only when there is something to carry, so a selection that excludes no skill and
   // switches off no gate is the same object it was before either existed.
   return {
     theme, posture, mode, doctrines, excludeRules, ...(excludeSkills ? { excludeSkills } : {}),
-    ...(gated ? { gates } : {}),
+    ...(gated ? { gates } : {}), ...(kits ? { kits } : {}),
     emit, out, root, footprint,
   };
 }
@@ -494,11 +516,11 @@ export function setupLines() {
   }
   const {
     theme, emit, out, root, footprint = 'lean', posture = 'peer', mode = 'direct',
-    doctrines = null, excludeRules = null, excludeSkills = null, gates = {},
+    doctrines = null, excludeRules = null, excludeSkills = null, gates = {}, kits = null,
   } = sel;
   if (emit === 'opencode-global') {
-    // The build below overwrites the deployed global harness, and the self-improvement loops
-    // may have edited it in place. Preserve that drift first.
+    // The build below overwrites the deployed global harness, which may carry hand edits (or
+    // in-place edits from a harness older than the notebook notes). Preserve that drift first.
     try {
       const [ipath] = exportImprovements();
       if (ipath) {
@@ -513,7 +535,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, undefined, excludeSkills, gates);
+    doctrineOptions().map(([n]) => n), excludeRules, undefined, excludeSkills, gates, kits);
   printOut(`Running:  geneseed build ${argv.join(' ')}\n`);
   const rc = driverMain(argv);
   if (rc !== 0) {
@@ -551,26 +573,83 @@ export function cmdSetup() {
 }
 
 /**
- * The AI coding tools Geneseed installs into, as `[label, present, url]` rows in HOSTS order.
+ * The AI coding tools Geneseed installs into, as `[label, present, url, where]` rows in HOSTS
+ * order. `where` is the path found OFF the PATH (see `userInstall`), else null.
  *
- * PRESENT MEANS THE COMMAND IS ON PATH, and nothing else. The config dir looked like a second
- * signal — a desktop-only install has one and no command — but GENESEED ITSELF CREATES IT: a
- * `bob-global` emit writes `~/.bob` on a machine that never had Bob, and the first run of this
- * check reported Bob present on exactly such a machine. A wrong "ok" sends the user to an
- * install mode for a tool they cannot open; a wrong "not found" costs one line they can ignore.
+ * PRESENT MEANS THE TOOL ITSELF WAS FOUND — its command on PATH, or its program in a per-user
+ * install location — and never its config dir. That dir looked like a signal — a desktop-only
+ * install has one and no command — but GENESEED ITSELF CREATES IT: a `bob-global` emit writes
+ * `~/.bob` on a machine that never had Bob, and the first run of this check reported Bob present
+ * on exactly such a machine. A wrong "ok" sends the user to an install mode for a tool they
+ * cannot open; a wrong "not found" costs a line, and `toolsReport` lets them name the path.
  *
  * NO SPAWN, deliberately. `which` walks PATH by hand, so asking costs nothing on the CLI's
  * child_process allow-list — a `claude --version` probe would have been a third entry there to
- * learn nothing `which` does not already say. `lookup` is the seam for the test, which cannot
- * rely on what this machine happens to have installed.
+ * learn nothing `which` does not already say. `lookup` and `userLookup` are the seams for the
+ * test, which cannot rely on what this machine happens to have installed.
  */
-export function hostTools({ lookup = which } = {}) {
+export function hostTools({ lookup = which, userLookup = userInstall } = {}) {
   return [
     ['OpenCode', 'opencode', 'https://opencode.ai/docs/'],
     ['Claude Code', 'claude', 'https://code.claude.com/docs/en/setup'],
     ['IBM Bob', 'bob', 'https://bob.ibm.com/'],
     ['OpenClaude', 'openclaude', 'https://openclaude.gitlawb.com/'],
-  ].map(([label, cmd, url]) => [label, Boolean(lookup(cmd)), url]);
+  ].map(([label, cmd, url]) => {
+    if (lookup(cmd)) return [label, true, url, null];
+    const where = userLookup(cmd);
+    return [label, Boolean(where), url, where || null];
+  });
+}
+
+/**
+ * Per-host off-PATH places: a bin dir a tool's own installer uses, and a name pattern for the
+ * desktop app folder. Only Bob ships as a desktop IDE; matching `claude` against app folders
+ * would find the Claude desktop chat app, which is not Claude Code.
+ */
+const USER_BIN_DIRS = {
+  opencode: ['.opencode/bin'],
+  claude: ['.claude/local'],
+  bob: [],
+  openclaude: [],
+};
+const APP_PATTERN = { bob: /\bbob\b/i };
+
+/**
+ * Where a tool installed FOR ONE USER lives when its installer did not put it on PATH — the
+ * report of 2026-10 was IBM Bob installed under the user's own profile, which `which` never sees.
+ *
+ * Three kinds of place, each one the tool's own program, never its config dir:
+ *   * a per-user bin dir: `~/.local/bin` and `~/bin` for every tool, plus the dir its own
+ *     installer uses (`USER_BIN_DIRS`) — an executable file, through `which` and its PATHEXT;
+ *   * on Windows, `%APPDATA%\npm` (a per-user `npm i -g`) and a desktop app folder under
+ *     `%LOCALAPPDATA%\Programs` whose name matches `APP_PATTERN`;
+ *   * on macOS, a matching `.app` in `/Applications` or `~/Applications`.
+ * The first hit wins. Everything a machine could differ on is a parameter, for the test.
+ */
+export function userInstall(cmd, {
+  home = os.homedir(), env = process.env, platform = process.platform,
+  find = which, list = listDir,
+} = {}) {
+  const bins = ['.local/bin', 'bin', ...(USER_BIN_DIRS[cmd] ?? [])].map((d) => path.join(home, d));
+  if (platform === 'win32' && env.APPDATA) bins.push(path.join(env.APPDATA, 'npm'));
+  const hit = find(cmd, bins.join(path.delimiter));
+  if (hit) return hit;
+  const pattern = APP_PATTERN[cmd];
+  if (!pattern) return null;
+  const appDirs = platform === 'win32'
+    ? (env.LOCALAPPDATA ? [path.join(env.LOCALAPPDATA, 'Programs')] : [])
+    : platform === 'darwin' ? ['/Applications', path.join(home, 'Applications')] : [];
+  for (const dir of appDirs) {
+    const name = list(dir).find((n) => pattern.test(n)
+      && (platform !== 'darwin' || n.endsWith('.app')));
+    if (name) return path.join(dir, name);
+  }
+  return null;
+}
+
+/** `readdirSync`, with a missing or unreadable dir as no entries. */
+function listDir(dir) {
+  try { return readdirSync(dir); } catch { return []; }
 }
 
 /**
@@ -578,16 +657,25 @@ export function hostTools({ lookup = which } = {}) {
  * answer knowing it — and when NONE is, ask whether to stop and install one first. It never
  * installs one: on a managed machine that is IT's call, and each tool has its own installer.
  * A missing tool among several present is a line, not a question; nobody needs all four.
+ * When none is found, the user can name where theirs is before being asked to stop — the
+ * search covers PATH and the usual per-user places, not every folder an installer may pick.
  * `false` is the user choosing to stop.
  */
 export function toolsReport(tools = hostTools()) {
   printOut('AI coding tools on this machine:\n');
-  for (const [label, present, url] of tools) {
-    printOut(present ? `  ok  ${label}\n` : `  --  ${label} not on PATH — install: ${url}\n`);
+  for (const [label, present, url, where] of tools) {
+    if (!present) printOut(`  --  ${label} not found — install: ${url}\n`);
+    else printOut(where ? `  ok  ${label} (${where}, not on PATH)\n` : `  ok  ${label}\n`);
   }
   if (tools.some(([, present]) => present)) { printOut('\n'); return true; }
-  printOut('\nNone of them is installed. Install the one you use (links above), then run setup '
-    + 'again — or go on and pick the plain bundle, which any AGENT.md tool can read.\n');
+  printOut('\nNone of them was found on PATH or in the usual per-user folders.\n');
+  // Quotes stripped: a path dragged into a Windows console arrives wrapped in them.
+  const given = ask('Installed somewhere else? Path to the tool (Enter to skip)')
+    .replace(/^"(.*)"$/, '$1');
+  if (given && existsSync(given)) { printOut(`  ok  ${given}\n\n`); return true; }
+  if (given) printOut(`  --  nothing at ${given}\n`);
+  printOut('Install the one you use (links above), then run setup again — or go on and pick the '
+    + 'plain bundle, which any AGENT.md tool can read.\n');
   if (confirm('Continue without one?', false)) { printOut('\n'); return true; }
   printOut('Stopped. Run setup again once a tool is installed.\n');
   return false;

package/js/maintain/update.mjs

@@ -632,7 +632,7 @@ export async function installAxes(dir, { installProfile, setupBuildArgs }, notif
   if (legacyProcessCarrierOfDir(String(dir), 'opencode')) return null;
   const p = installProfile('opencode', 'global', String(dir), notify);
   return setupBuildArgs('', 'files', null, null, p.footprint, p.posture, p.mode, p.doctrines,
-    undefined, p.excludeRules, p.trust, p.excludeSkills, p).slice(4);
+    undefined, p.excludeRules, p.trust, p.excludeSkills, p, p.kits).slice(4);
 }
 
 /**
@@ -796,8 +796,8 @@ export async function upgrade(ref = null, themeArg = null) {
  * `_harness_lifecycle.cmd_upgrade` — the harness verb, which is `export_improvements()` and
  * then `upgrade()`.
  *
- * THE EXPORT RUNS FIRST AND MUST NEVER BLOCK. The self-improvement loops edit the deployed
- * harness in place and the rebuild is about to overwrite those edits, so the drift has to be
+ * THE EXPORT RUNS FIRST AND MUST NEVER BLOCK. A deployed harness can carry in-place edits (by
+ * hand, or by a harness older than the notebook notes) and the rebuild is about to overwrite them, so the drift has to be
  * captured against the PRE-refresh source. Anything it throws is a warning on stderr and the
  * upgrade continues — a failed export is a lost note, a blocked upgrade is a broken install.
  */

package/js/web/actions.mjs

@@ -34,7 +34,7 @@ import path from 'node:path';
 
 import { emitGlobalInto } from '../build/driver.mjs';
 import {
-  ROOT, discoverNames, knownRuleIds, PACK_ORDER,
+  ROOT, discoverNames, knownRuleIds, loadKits, PACK_ORDER,
 } from '../build/source.mjs';
 import { withStdoutSwallowed } from '../inspect/diff.mjs';
 import { excludeAdd, excludeRemove } from '../inspect/excludes.mjs';
@@ -46,9 +46,10 @@ import {
   opencodeConfigDir, resolvePath,
 } from '../hosts/hosts.mjs';
 import {
-  EMIT_HOST_SCOPE, doctrinesForBuild, excludedRulesOfDir, excludedSkillsOfDir,
+  EMIT_HOST_SCOPE, doctrinesForBuild, excludedRulesOfDir, excludedSkillsOfDir, kitsOfDir,
   footprintOfDir, gatesOfDir,
-  installState, installTargets, legacyProcessCarrierOfDir, modeOfDir, postureOfDir, trustOfDir,
+  installState, installTargets, legacyProcessCarrierOfDir, modeOfDir, postureOfDir, themeOfDir,
+  trustOfDir,
 } from '../hosts/installs.mjs';
 import {
   isDict, mcpCommented, mcpInstallTargets, mcpLoad, mcpServerNames, mcpState,
@@ -131,6 +132,15 @@ function bodyExcludeRules(body) {
     (n) => n.trim().replace(/[ \t]+/, '.'));
 }
 
+/**
+ * A request body's `kits` — REPLACES the install's kits (the Kits tab sends the whole set it
+ * wants): `[]`/`'none'` give `[]`, an omitted key gives `null` (keep the install's own), and an
+ * unknown name gives `null` too, which `apiInstallCmd` refuses for a body that HAS the key.
+ */
+function bodyKits(body) {
+  return bodyList(body, 'kits', () => [...loadKits().keys()]);
+}
+
 /**
  * The gate switches across the trust boundary (`deletionGate`, `secretsGate`, `doneGate`), each
  * on its own: only a real JSON boolean counts. Anything else — a string `"false"`, a number,
@@ -465,6 +475,14 @@ export function buildActionCmds(state, body) {
     const [, , ...rest] = installProfile(host, scope, state.root).argv;
     return actionCommands('build', { buildArgv: ['--theme', theme, ...rest] });
   }
+  // Only a GLOBAL emit has a home of its own. Any other carries no folder on this route, so the
+  // generator fell back to its default `./Harness` — and jobs run with the Geneseed checkout as
+  // cwd, so a Bob "project" install landed inside the clone (reported 2026-10), where the doctor's
+  // bundle check then read it as 178 missing files. The `deploy` action takes a chosen folder.
+  if (!emit.endsWith('-global')) {
+    return { error: `${emit} installs into a folder you choose — use Deploy with a folder, `
+      + 'not Build' };
+  }
   return actionCommands('build', {
     theme, emit, footprint: state.footprint, posture: state.posture, mode: state.mode,
     trust: state.trust,
@@ -539,6 +557,8 @@ export function apiRestore(state, files) {
       // re-states a rule whose hook gate the install deliberately left unwired.
       excludeRules: excludedRulesOfDir(target),
       excludeSkills: excludedSkillsOfDir(target),
+      // The kits: a restored AGENT.md keeps its Kits block and `Active kits:` line.
+      kits: kitsOfDir(target),
       // The gate switches: a restored AGENT.md must keep the install's `<gate>: off` lines.
       ...gatesOfDir(target),
     }));
@@ -607,8 +627,9 @@ export function apiInstallCmd(state, body) {
   if (emit === undefined) return { error: `no install mode for ${host}:${scope}` };
   // Every read-back below is narrowed to `host`'s OWN carrier (host-compat B1) — see the
   // comment at `installProfile` in `js/build/generate.mjs`.
+  // The theme default is THIS install's own, not the viewed one's: the Kits tab acts on any row.
   const { theme, footprint: fp, posture: pos, mode, trust } = bodyAxes(body, {
-    theme: state.theme, footprint: footprintOfDir(root),
+    theme: themeOfDir(root, host) || state.theme, footprint: footprintOfDir(root),
     posture: postureOfDir(root, host) || 'peer',
     mode: modeOfDir(root, host) || 'direct', trust: trustOfDir(root, host) || DEFAULT_PRESET });
   // Unspecified means "keep what this install already has", exactly as theme, footprint,
@@ -626,9 +647,20 @@ export function apiInstallCmd(state, body) {
   // The gate switches (the Constitution page's toggles): a strict boolean per gate in the body,
   // else the install's own answer — so a pack Apply keeps every switch as it is.
   const gates = bodyGates(body, root, host);
+  // The page sends `kits` deliberately, so an unknown name is refused: ignoring it would run a
+  // no-op rebuild and report success. An omitted key keeps the install's own kits.
+  let kits = null;
+  try {
+    kits = bodyKits(body);
+    if (kits === null && bget(body, 'kits') !== null) {
+      return { error: `unknown kit in ${formatRepr(bget(body, 'kits'))} — this Geneseed ships: `
+        + [...loadKits().keys()].join(', ') };
+    }
+  } catch (e) { return { error: String(e?.message ?? e) }; }
   const out = scope === 'global' ? null : String(root);
   const argv = setupBuildArgs(theme || 'neutral', emit, out, out, fp, pos, mode, doctrines,
-    PACK_ORDER, excludeRules, trust, excludedSkillsOfDir(root, host), gates);
+    PACK_ORDER, excludeRules, trust, excludedSkillsOfDir(root, host), gates,
+    kits ?? kitsOfDir(root, host));
   return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }
 
@@ -730,6 +762,6 @@ export function apiDeployCmd(state, body) {
   const gates = bodyGates(body, root, host);
   // 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, excludedSkillsOfDir(root, host), gates);
+    PACK_ORDER, excludeRules, trust, excludedSkillsOfDir(root, host), gates, kitsOfDir(root, host));
   return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };
 }

package/js/web/api.mjs

@@ -8,31 +8,33 @@
  * bind paths to these functions are `routes.mjs`. This file imports none of its route siblings,
  * which is what keeps the old `api ↔ actions` and `api ↔ activity` cycles from coming back.
  */
-import { statSync } from 'node:fs';
+import { readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 
-import { CONFIG, ROOT, THEMES, discoverNames, makeCfg } from '../build/source.mjs';
+import { CONFIG, CREDIT_RE, ROOT, SRC, THEMES, discoverNames, loadKits, makeCfg, upstreamOf } from '../build/source.mjs';
 import { readVersion, sourceFingerprint } from '../build/version.mjs';
 import { sourceReleaseVersion } from '../hosts/opencode.mjs';
 import { alwaysOnCost } from '../inspect/cost.mjs';
+import { installProfile } from '../build/generate.mjs';
 import { diffCollect, renderMemo } from '../inspect/diff.mjs';
 import { excludesSnapshot } from '../inspect/excludes.mjs';
-import { CLAUDE_STYLE, HOSTS, VERSION_MARKER, resolvePath } from '../hosts/hosts.mjs';
+import { VERSION_MARKER, resolvePath } from '../hosts/hosts.mjs';
 import {
-  footprintOfDir, gatesOfDir, installState, installTargets, modeOfDir, trustOfDir,
-  postureOfDir, readJsonMaybe, themeOfDir,
+  footprintOfDir, gatesOfDir, installState, installTargets, legacyProcessCarrierOfDir, modeOfDir,
+  trustOfDir,
+  postureOfDir, readJsonMaybe, readMaybe, themeOfDir,
 } from '../hosts/installs.mjs';
 import { PRESETS } from '../loop/score.mjs';
 import { loadCatalog, catalogProblems } from '../loop/catalog.mjs';
 import { activeLoops } from '../loop/registry.mjs';
 import { EMIT_OPTIONS, themeOptions } from '../maintain/setup.mjs';
-import { accentFor, statusData } from '../inspect/status.mjs';
+import { accentFor, keptKitFiles, statusData } from '../inspect/status.mjs';
 import { isFile } from '../lib/fs.mjs';
 import { comparePaths, normcase } from '../lib/paths.mjs';
 import {
   configItems, deployed, dget, memoryItems, notebookItems, wikiItems,
 } from './catalog.mjs';
-import { stampMinute } from './state.mjs';
+import { stampMinute, viewCfg } from './state.mjs';
 import { updateStatus } from './update-check.mjs';
 
 /**
@@ -106,16 +108,9 @@ export function apiDiff(state) {
 /** The union across every global install, verbatim. */
 export const apiExcludes = () => excludesSnapshot();
 
-/**
- * The data dir an install's inventory/memory/diff is read from. Host-driven, so a new
- * nested-marker host cannot silently read the bare root.
- */
-export function viewCfg(host, scope, root) {
-  if (scope === 'project' && CLAUDE_STYLE.includes(host)) {
-    return path.join(root, HOSTS.find((h) => h.host === host).projectMarker);
-  }
-  return root;
-}
+// `viewCfg` moved to `state.mjs`, which needs it to pick a default view and cannot import
+// this module back (this one imports `stampMinute` from it).
+export { viewCfg } from './state.mjs';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 
@@ -231,6 +226,70 @@ export function apiFleet(state) {
   return { installs, source_fp: sourceFp, doctor: state.doctor };
 }
 
+/** Source files of a kit member: `<dir>/<name>.md`, or every `.md` in a `<dir>/<name>/` folder. */
+function memberTexts(dir, name) {
+  const one = readMaybe(path.join(SRC, dir, `${name}.md`));
+  if (one !== null && one !== undefined) return [one];
+  const d = path.join(SRC, dir, name);
+  try { return readdirSync(d).filter((f) => f.endsWith('.md')).map((f) => readMaybe(path.join(d, f)) ?? ''); } catch { return []; }
+}
+
+/** Upstream credits cited by a kit's rules and member sources; an unknown key is skipped, never a 500. */
+function kitCredits(m, rules) {
+  const texts = [rules, ...(m.skills ?? []).flatMap((n) => memberTexts('skills', n)),
+    ...(m.agents ?? []).flatMap((n) => memberTexts('agents', n))];
+  const keys = new Set();
+  for (const t of texts) for (const x of t.matchAll(CREDIT_RE)) keys.add(x[1]);
+  const out = [];
+  for (const key of [...keys].sort()) {
+    let u;
+    try { u = upstreamOf(key); } catch { u = null; }
+    if (!u) continue;
+    out.push({ key, repo: u.repo, author: u.author, license: u.license, commit: u.commit,
+      compareUrl: `https://github.com/${u.repo}/compare/${u.commit}...HEAD` });
+  }
+  return out;
+}
+
+/**
+ * EVERY INSTALL'S KITS — the Kits tab. Its own route, like `apiFleet`: it re-reads each carrier
+ * and the kit manifests, which the sidebar's `/api/installs` refetch must not pay for.
+ *
+ * `kits` per row is `installProfile(...).kits`, the reader `rebuild-all` uses, so the tab shows
+ * what a rebuild would keep. A malformed manifest answers 200 with `error` and EMPTY lists, never
+ * rows without kits (which would read as "no kit on") and never a 500. `editable:false` carries
+ * the two refusals `apiInstallCmd` makes, so the page can say why before the click.
+ */
+export function apiKits() {
+  let known;
+  try { known = loadKits(); } catch (e) {
+    return { kits: [], installs: [], error: String(e?.message ?? e) };
+  }
+  const kits = [...known].map(([name, m]) => {
+    const rules = readMaybe(path.join(SRC, 'kits', name, 'rules.md')) ?? '';
+    return { name, description: m.description ?? '', skills: m.skills ?? [], agents: m.agents ?? [],
+      rules, rulesWordBudget: m.rulesWordBudget ?? null, banned: m.banned ?? [],
+      credits: kitCredits(m, rules) };
+  });
+  const installs = [];
+  for (const [host, scope, root] of installTargets()) {
+    const st = installState(root, host, scope);
+    if (st === 'absent') continue;
+    try {
+      const p = installProfile(host, scope, root);
+      const reason = st === 'disabled' ? 'install is disabled — reactivate it first'
+        : legacyProcessCarrierOfDir(root, host) ? 'predates the comms pack — run geneseed setup for it first'
+          : null;
+      installs.push({ ...installRowBase(host, scope, root, st), kits: p.kits,
+        keptKitFiles: keptKitFiles(host, scope, root, p.kits), editable: reason === null, reason });
+    } catch (e) {
+      installs.push({ ...installRowBase(host, scope, root, 'unreadable'),
+        error: String(e?.message ?? e) });
+    }
+  }
+  return { kits, installs };
+}
+
 /** The dashboard aggregate. */
 export function apiOverview(state) {
   const inv = state.inventory;

package/js/web/catalog.mjs

@@ -24,6 +24,7 @@ import { readText, withDiscardableStderr, isDir, isFile } from '../lib/fs.mjs';
 import { comparePaths, normcase, within } from '../lib/paths.mjs';
 import { stripWhitespace } from '../lib/text.mjs';
 import { readJsonc } from '../hosts/settings.mjs';
+import { loadKits } from '../build/source.mjs';
 
 /** A requested catalog section or item that does not exist. */
 export class NotFound extends Error {}
@@ -466,16 +467,29 @@ function constitutionItems(inv) {
   ];
 }
 
+/** `Map<'skills/x' | 'agents/y', kit>` from the shipped manifests; a broken manifest means no badges, not a 500. */
+function kitOwners() {
+  const owner = new Map();
+  try {
+    for (const [kit, m] of loadKits()) {
+      for (const n of m.skills ?? []) owner.set(`skill:${n}`, kit);
+      for (const n of m.agents ?? []) owner.set(`agent:${n}`, kit);
+    }
+  } catch { /* shortcut: unreadable manifests hide the badge; apiKits reports the error */ }
+  return owner;
+}
+
 export function apiCatalog(state, section) {
   if (!SECTIONS.includes(section)) throw new NotFound(section);
   const inv = state.inventory;
   let items;
+  const owner = kitOwners();
   if (section === 'agents') {
     items = inv.agents.map((e) => ({ name: e.name, title: e.name, desc: e.desc,
-      source: e.source ?? null, status: e.status ?? 'unknown' }));
+      source: e.source ?? null, status: e.status ?? 'unknown', kit: owner.get(`agent:${e.name}`) ?? null }));
   } else if (section === 'skills') {
     items = inv.skills.map((e) => ({ name: e.name, title: e.name, desc: e.desc,
-      source: e.source ?? null, klass: e.klass ?? 'build', status: e.status ?? 'unknown' }));
+      source: e.source ?? null, klass: e.klass ?? 'build', status: e.status ?? 'unknown', kit: owner.get(`skill:${e.name}`) ?? null }));
   } else if (section === 'laws') {
     items = constitutionItems(inv);
   } else if (section === 'memory') {
@@ -499,6 +513,7 @@ export function apiItem(state, type, name) {
       links: resolveLinks(state, e.body), source: e.source ?? null };
     if (type === 'skill') out.klass = e.klass ?? 'build';
     out.status = e.status ?? 'unknown';
+    out.kit = kitOwners().get(`${type}:${name}`) ?? null;
     return out;
   }
   if (type === 'law') {

package/js/web/handler.mjs

@@ -303,6 +303,7 @@ export function makeHandler(state, jm, token, dist, holder = null) {
     // Build resolves its argv off the install (`buildActionCmds`); the other actions take no
     // axes and self-resolve the deployed theme downstream.
     const cmds = action === 'build' ? buildActionCmds(state, body) : actionCommands(action);
+    if (cmds && Object.hasOwn(cmds, 'error')) return sendJson(res, cmds, 400, ae);
     if (!isTruthy(cmds)) {
       return sendJson(res, { error: `unknown action ${action}` }, 404, ae);
     }

package/js/web/routes.mjs

@@ -21,7 +21,7 @@ import { percentDecode } from '../lib/text.mjs';
 import { apiExcludesMutate, apiInstallToggle, apiLoopsPresetMutate, apiMcp, apiMemoryDelete, apiSelectView } from './actions.mjs';
 import { apiActivity, apiActivityDetail, apiActivityToggle } from './activity.mjs';
 import {
-  apiDiff, apiDoctor, apiExcludes, apiFleet, apiInstalls, apiLoops, apiLoopsActive, apiOverview,
+  apiDiff, apiDoctor, apiExcludes, apiFleet, apiInstalls, apiKits, apiLoops, apiLoopsActive, apiOverview,
   apiRecent, apiSetup, apiThemes, apiUpdate,
 } from './api.mjs';
 import { NotFound, apiCatalog, apiItem } from './catalog.mjs';
@@ -151,6 +151,7 @@ export const STATE_ROUTES = {
     new URL(url || '', 'http://x').searchParams.has('fresh')),
   '/api/installs': apiInstalls,
   '/api/fleet': apiFleet,
+  '/api/kits': apiKits,
   '/api/update': apiUpdate,
   '/api/usage': apiUsage,
   '/api/gates': apiGates,

package/js/web/server.mjs

@@ -27,7 +27,7 @@ import { isFile, printOut } from '../lib/fs.mjs';
 import { which } from '../lib/paths.mjs';
 import { parseIntStrict } from '../lib/text.mjs';
 import { promptLine } from '../lib/prompt.mjs';
-import { warmDoctor, webState } from './state.mjs';
+import { fallbackView, warmDoctor, webState } from './state.mjs';
 import { clearDaemon, codeStamp, openUrl, readDaemon, restartDaemon, startDaemon, statusDaemon, stopDaemon, writeDaemon } from './daemon.mjs';
 import { makeHandler } from './handler.mjs';
 import { JobManager } from './jobs.mjs';
@@ -132,6 +132,12 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
     }
   }
   const state = webState(theme);
+  // The daemon record and the job file stay at the DEFAULT target, captured before the view
+  // moves: `geneseed web stop`/`status` find them through `webState(theme).target`, which never
+  // moves, and a view that followed a Bob-only install into ~/.bob would hide the record.
+  const home = state.target;
+  const fallback = fallbackView(home);
+  if (fallback) state.selectView(...fallback);
   if (!existsSync(join(state.target, GLOBAL_MANIFEST))) {
     printOut(`[web] no deployed harness at ${state.target}.\n`);
     printOut('      Run `geneseed setup` first — serving anyway (read-only UI).\n');
@@ -143,7 +149,7 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
   const holder = {};
   // The console's job list survives a reload and a restart because it is a FILE on disk,
   // not held in process memory.
-  const jm = new JobManager(join(state.target, '.geneseed-web-runs.json'));
+  const jm = new JobManager(join(home, '.geneseed-web-runs.json'));
   const srv = createServer(makeHandler(state, jm, token, dist, holder));
   holder.srv = srv;
   return new Promise((done) => {
@@ -157,7 +163,7 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
       const hostPort = /** @type {import('node:net').AddressInfo} */ (srv.address()).port;
       const url = `http://127.0.0.1:${hostPort}`;
       if (daemon) {
-        writeDaemon(state.target, {
+        writeDaemon(home, {
           pid: process.pid, port: hostPort, url,
           token, theme: state.theme, started: Math.floor(Date.now() / 1000), code: startCode,
         });
@@ -177,8 +183,8 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
       });
       srv.on('close', () => {
         if (daemon) {
-          const st = readDaemon(state.target);
-          if (!st || st.pid === process.pid) clearDaemon(state.target);
+          const st = readDaemon(home);
+          if (!st || st.pid === process.pid) clearDaemon(home);
         }
         done(0);
       });