geneseed 3.10.0 → 3.12.0

package/js/web/api.mjs

@@ -21,10 +21,12 @@ import { excludesSnapshot } from '../inspect/excludes.mjs';
 import { GLOBAL_MANIFEST, HOSTS, opencodeConfigDir, resolvePath } from '../hosts/hosts.mjs';
 import {
   doctrinesForBuild, excludedRulesOfDir, footprintOfDir, installState, installTargets,
-  installedDefaults, modeOfDir,
+  installedDefaults, modeOfDir, trustOfDir,
   postureOfDir, readJsonMaybe, readMaybe, themeOfDir,
 } from '../hosts/installs.mjs';
 import { frontmatter } from '../hosts/hooks.mjs';
+import { DEFAULT_PRESET, PRESETS } from '../loop/score.mjs';
+import { loadCatalog, catalogProblems } from '../loop/catalog.mjs';
 import {
   SKILL_CLASS, entityStatus, loadRegistry, tuiInventory,
 } from '../inspect/inventory.mjs';
@@ -87,6 +89,7 @@ export function webState(theme = null, target = null) {
     footprint: null,
     posture: null,
     mode: null,
+    trust: null,
     _inv: null,
     _doctor: null,
   };
@@ -98,6 +101,7 @@ export function webState(theme = null, target = null) {
   st.footprint = footprintOfDir(st.target);      // 'full' when no marker
   st.posture = postureOfDir(st.target) || 'peer';
   st.mode = modeOfDir(st.target) || 'direct';
+  st.trust = trustOfDir(st.target) || DEFAULT_PRESET;
 
   Object.defineProperty(st, 'inventory', {
     get() {
@@ -154,6 +158,7 @@ export function webState(theme = null, target = null) {
     st.footprint = footprintOfDir(st.root);
     st.posture = postureOfDir(st.root) || 'peer';
     st.mode = modeOfDir(st.root) || 'direct';
+    st.trust = trustOfDir(st.root) || DEFAULT_PRESET;
     st._inv = null;
     st._doctor = null;
   };
@@ -165,6 +170,7 @@ export function webState(theme = null, target = null) {
     st.footprint = footprintOfDir(st.root);
     st.posture = postureOfDir(st.root) || 'peer';
     st.mode = modeOfDir(st.root) || 'direct';
+    st.trust = trustOfDir(st.root) || DEFAULT_PRESET;
   };
   return st;
 }
@@ -741,11 +747,12 @@ export function apiInstalls(state) {
       footprint: footprintOfDir(root),
       posture: postureOfDir(root),
       mode: modeOfDir(root),
+      trust: trustOfDir(root),
       selected: samePath(viewCfg(host, scope, root), state.target),
     });
   }
   return { installs: out, postures: discoverNames('postures', 'peer'),
-    modes: discoverNames('modes', 'direct') };
+    modes: discoverNames('modes', 'direct'), trusts: Object.keys(PRESETS) };
 }
 
 /** Beside the deployed AGENT.md. */
@@ -819,6 +826,9 @@ export function apiOverview(state) {
     install,
     target: state.target,
     deployed: deployed(state),
+    // True when the files on disk changed under this server since it started (an upgrade).
+    // `serve` installs the comparison; a state built without a server has none and is false.
+    daemon_stale: Boolean(state.daemonStale?.()),
     counts: {
       agents: inv.agents.length,
       skills: inv.skills.length,
@@ -845,6 +855,9 @@ export function apiOverview(state) {
       notebook: notebookItems(state).length,
       wiki: wikiItems(state).length,
       config: configItems(state).length,
+      // The rail's Loops badge: templates only, from the same catalogue `/api/loops` reads —
+      // a brick is a part, the template is what a person runs.
+      loops: loadCatalog({ projectRoot: state.root }).templates.size,
     },
     doctor: state.doctor,
     diff,
@@ -930,6 +943,31 @@ export function apiRecent(state) {
   return { items: items.slice(0, RECENT_LIMIT), skipped, limit: RECENT_LIMIT };
 }
 
+/**
+ * The Loops page: the brick and template catalogue the `geneseed loop` CLI reads, resolved from
+ * the install ROOT — for a project install that is the repo, where `<repo>/.geneseed/` lives; for
+ * a global one it is the config dir, which has no `.geneseed/` and so adds nothing. Read-only:
+ * the page draws templates and lists bricks, it never writes one.
+ *
+ * A template's graph is passed whole (`graph`) rather than flattened, because the page's ring
+ * layout needs `nodes`, `edges` and `loops` exactly as the engine reads them.
+ */
+export function apiLoops(state) {
+  const { bricks, templates, overridden } = loadCatalog({ projectRoot: state.root });
+  const byName = ([a], [b]) => (a < b ? -1 : 1);
+  return {
+    templates: [...templates].sort(byName).map(([name, { origin, ...graph }]) => ({
+      name, description: graph.description || '', origin, graph,
+    })),
+    bricks: [...bricks].sort(byName).map(([, b]) => ({ reason: null, ...b })),
+    overridden,
+    // A brick or template the catalogue skipped (bad frontmatter, not JSON, misnamed), and a
+    // template that fails the graph rules: the page says so — the same list `loop check`
+    // prints — or a team's broken override would just silently not be there.
+    problems: catalogProblems({ projectRoot: state.root }),
+  };
+}
+
 /** The source's release label, or null when it cannot be read. */
 function releaseLabel() {
   const v = sourceReleaseVersion({ config: CONFIG });
@@ -979,4 +1017,5 @@ export const STATE_ROUTES = {
   // answers — a daemon whose POST worked and whose GET 501'd would have no way to obtain one.
   '/api/rules': apiRules,
   '/api/mcp': apiMcp,
+  '/api/loops': apiLoops,
 };

package/js/web/daemon.mjs

@@ -13,6 +13,7 @@ import { printOut, writeText } from '../lib/fs.mjs';
 import { isTruthy, jsonDumpsCompact } from '../lib/json.mjs';
 import { webState } from './api.mjs';
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { chmodSync, mkdirSync, openSync, readFileSync, unlinkSync } from 'node:fs';
 import { join, resolve as pathResolve } from 'node:path';
 
@@ -20,6 +21,29 @@ const ROOT = pathResolve(import.meta.dirname, '..', '..');
 
 // ---- the daemon record -----------------------------------------------------
 
+/**
+ * Which code a console serves: the package version and a hash of the `web/dist/index.html` it
+ * would load. A daemon writes the stamp it started with into its record; an npm upgrade or a
+ * `git pull` that replaces `web/dist/` changes the stamp on disk, and the daemon — still
+ * serving the old `index.html`, whose chunk hashes may no longer exist — is then STALE.
+ * Read fresh on every call: the comparison is against the files as they are NOW.
+ */
+export function codeStamp(root = ROOT) {
+  const read = (rel) => { try { return readFileSync(join(root, rel)); } catch { return ''; } };
+  let version = 'unknown';
+  try { version = JSON.parse(read('package.json')).version ?? version; } catch { /* unknown */ }
+  const html = createHash('sha256').update(read(join('web', 'dist', 'index.html'))).digest('hex');
+  return `${version}:${html.slice(0, 12)}`;
+}
+
+/** A record written by an older daemon carries no `code` — and is stale by definition. */
+export function daemonStale(record, root = ROOT) {
+  return record?.code !== codeStamp(root);
+}
+
+export const STALE_LINE = '[web] running OLD code (started before the last upgrade) — '
+  + 'geneseed web restart';
+
 const statePath = (target) => join(target, '.geneseed-web.json');
 
 export function readDaemon(target) {
@@ -243,9 +267,42 @@ export async function startDaemon(theme, port, openBrowser = true) {
   return 1;
 }
 
-export async function stopDaemon(theme = null) {
+/**
+ * `--port` NAMES WHICH DAEMON, and the record holds only one. With no `--port` (`port` null)
+ * the verbs act on whatever the record names, as they always have. With one, they act only if
+ * the record is on that port: `stop --port 4791` once POSTed shutdown to the recorded url and
+ * stopped the console on 4747. So a record on another port is refused — no request sent, record
+ * left in place — and a server answering on the named port that is NOT the record is explained,
+ * because its token is not on record and there is nothing to guess it from.
+ *
+ * Null when the verb may go ahead; otherwise the exit code, already explained on stdout.
+ */
+async function portRefusal(st, port, verb) {
+  if (port === null || port === undefined) return null;
+  const recorded = isTruthy(st) && isTruthy(st.url) ? Number(st.port) : null;
+  if (recorded === port) return null;
+  if (recorded !== null) {
+    if (verb === 'status') {
+      printOut(`[web] not running on port ${port} (the recorded daemon is on port ${recorded}).\n`);
+    } else {
+      printOut(`[web] the recorded daemon is on port ${recorded}, not ${port} — not touching it.\n`);
+      printOut(`      \`geneseed web ${verb} --port ${recorded}\` (or no --port) ${verb}s that one.\n`);
+    }
+  }
+  if (await probe(`http://127.0.0.1:${port}`)) {
+    printOut(`[web] a server answers on port ${port} but is not the recorded daemon, so its `
+      + 'token is unknown — stop it from its own page (Stop) or end its process.\n');
+    return 1;
+  }
+  // Nothing recorded and nothing on the named port: the verb's own no-daemon arm says so.
+  return recorded === null ? null : 1;
+}
+
+export async function stopDaemon(theme = null, port = null) {
   const { target } = webState(theme);
   const st = readDaemon(target);
+  const refused = await portRefusal(st, port, 'stop');
+  if (refused !== null) return refused;
   if (!isTruthy(st) || !isTruthy(st.url)) {
     // NO `clearDaemon` HERE — deliberately asymmetric with `liveDaemon`/`statusDaemon`,
     // which DO delete a record naming no url. Unifying the two would delete a file this
@@ -263,11 +320,14 @@ export async function stopDaemon(theme = null) {
   return 0;
 }
 
-export async function statusDaemon(theme = null) {
+export async function statusDaemon(theme = null, port = null) {
   const { target } = webState(theme);
+  const refused = await portRefusal(readDaemon(target), port, 'status');
+  if (refused !== null) return refused;
   const st = await liveDaemon(target);
   if (st) {
     printOut(`[web] running on ${st.url}  (theme: ${none(st.theme)}, pid ${none(st.pid)})\n`);
+    if (daemonStale(st)) printOut(`${STALE_LINE}\n`);
     return 0;
   }
   // EXIT 1, which is the verb's whole contract for a script. The snapshot's `<exit>`
@@ -276,13 +336,43 @@ export async function statusDaemon(theme = null) {
   return 1;
 }
 
-export async function restartDaemon(theme = null, port = 4747, openBrowser = true,
+/**
+ * Bounce a running console so it serves the code now on disk — `upgrade` after it rebuilt,
+ * `rebuild-all` when the running one is stale. EXCEPT inside a web job (`GENESEED_WEB_JOB`,
+ * set by `js/web/jobs.mjs`): restarting here would kill the process tracking that very job,
+ * leaving the console stuck on 'running'; the server restarts itself after an update job, and
+ * shows its stale banner otherwise. `onlyIfStale` is `rebuild-all`'s: after an `upgrade`
+ * (which bounces, then runs `rebuild-all`) the console is current, and bouncing it again
+ * would drop the open tab for nothing. Never throws — no rebuild fails over a console.
+ */
+export async function bounceDaemonIfRunning(theme, log, { onlyIfStale = false } = {}) {
+  if (onlyIfStale) {
+    const st = readDaemon(webState(theme).target);
+    if (!st || !daemonStale(st)) return;
+  }
+  if (process.env.GENESEED_WEB_JOB) {
+    log(onlyIfStale
+      ? '[geneseed] the web console is running old code — use its Restart banner.'
+      : '[geneseed] web daemon will restart itself after this job to load the new code.');
+    return;
+  }
+  try {
+    await restartDaemon(theme, null, false, true);
+  } catch (e) {
+    log(`[geneseed] ⚠️  could not refresh the web daemon (${e && e.message ? e.message : e}) — \`geneseed web restart\` manually if it was running.`);
+  }
+}
+
+/** `port` null keeps the recorded daemon's port (4747 if none); see `portRefusal`. */
+export async function restartDaemon(theme = null, port = null, openBrowser = true,
   onlyIfRunning = false) {
   const { target } = webState(theme);
   const st = readDaemon(target);
+  const refused = await portRefusal(st, port, 'restart');
+  if (refused !== null) return refused;
   const live = (await liveDaemon(target)) !== null;
   if (onlyIfRunning && !live) return 0;
-  const usePort = (st && isTruthy(st.port) ? st.port : null) || port;
+  const usePort = port ?? ((st && isTruthy(st.port) ? st.port : null) || 4747);
   let open = openBrowser;
   if (live) {
     // A live daemon means a tab is already open on this (preserved) port and will

package/js/web/docs.mjs

@@ -1,5 +1,5 @@
 /**
- * The web console's Docs pages, and the registry built from `docs/web/`.
+ * The web console's Docs pages, and the registry built from `docs/<folder>/` (DOC_FOLDERS).
  *
  * `cli` docs render via `cliReference()` in `js/ui/cli.mjs`, which reads
  * `js/cli-table.json` — the CLI's own metadata, since `harness.build_argparser()`'s parser
@@ -7,9 +7,9 @@
  * the same file, so there is exactly one description of the CLI surface, not a second
  * transcription of it.
  *
- * `tests/unit/web_server.test.mjs` holds `KINDS` against a written-out list of the five
+ * `tests/unit/web_server.test.mjs` holds `KINDS` against a written-out list of the six
  * kinds this daemon dispatches on — same declaration-vs-dispatch shape as the route table,
- * which is why it is a table here too and not five `if`s.
+ * which is why it is a table here too and not six `if`s.
  *
  * THE `?harness=` QUERY PARAM IS the Docs selector, and it is the ONLY input to these
  * endpoints that is not the checkout itself — the one thing a test can vary. Every
@@ -18,7 +18,7 @@
 import { readdirSync } from 'node:fs';
 import path from 'node:path';
 
-import { ROOT, THEMES } from '../build/source.mjs';
+import { DOCS, DOC_FOLDERS, ROOT, THEMES } from '../build/source.mjs';
 import { cliReference } from '../ui/cli.mjs';
 import { readJsonMaybe, readMaybe } from '../hosts/installs.mjs';
 import { resolvePath } from '../hosts/hosts.mjs';
@@ -30,8 +30,6 @@ import { statusData } from '../inspect/status.mjs';
 import { originDisplay } from '../maintain/update.mjs';
 import { NotFound, deployed, resolveLinks } from './api.mjs';
 
-const DOC_DIR = path.join(ROOT, 'docs', 'web');
-
 /**
  * A docs page split into its frontmatter map and its body.
  *
@@ -61,24 +59,45 @@ function docFrontmatter(text) {
 }
 
 /**
- * The Docs registry, built from `docs/web/`.
+ * Every docs page source as `{ id, rel }`, `rel` relative to ROOT with forward slashes.
+ *
+ * The id is the basename because it is the router's address (`#/docs/<id>`); the folder is
+ * GitHub's business, not the console's. Two pages with one basename would leave one of them
+ * unreachable, so a duplicate throws instead of shadowing.
+ */
+export function docSources(docRoot = DOCS) {
+  const out = [];
+  const seen = new Set();
+  for (const folder of DOC_FOLDERS) {
+    let names;
+    try { names = readdirSync(path.join(docRoot, folder)); } catch { continue; }
+    for (const name of names.filter((n) => normcase(n).endsWith('.md')).sort()) {
+      const id = name.slice(0, -3);
+      if (seen.has(id)) throw new Error(`duplicate docs page id: ${id}`);
+      seen.add(id);
+      out.push({ id, rel: `docs/${folder}/${name}` });
+    }
+  }
+  return out;
+}
+
+/**
+ * The Docs registry, built from `docSources()` and `docs/_groups.json`.
  *
  * A page whose file is missing or malformed is skipped rather than crashing the server; an
  * unreadable registry yields an empty Docs section, which the UI renders as "no pages".
  *
- * NOT cached at module load. The difference is invisible to a request — `docs/web/` cannot
+ * NOT cached at module load. The difference is invisible to a request — the docs tree cannot
  * change under a running daemon any more than `dist/` can — and a module-level constant
  * would freeze whatever `ROOT` was when this file was first imported.
  */
 export function docGroups() {
-  const groups = readJsonMaybe(path.join(DOC_DIR, '_groups.json'));
+  const groups = readJsonMaybe(path.join(DOCS, '_groups.json'));
   if (!Array.isArray(groups)) return [];
   const byId = new Map();
   for (const g of groups) byId.set(g.id, { ...g, pages: [] });
-  let names;
-  try { names = readdirSync(DOC_DIR); } catch { return []; }
-  for (const name of names.filter((n) => normcase(n).endsWith('.md')).sort()) {
-    const text = readMaybe(path.join(DOC_DIR, name));
+  for (const { id, rel } of docSources()) {
+    const text = readMaybe(path.join(ROOT, rel));
     if (text === null) continue;
     const [meta, body] = docFrontmatter(text);
     const group = byId.get(meta.group);
@@ -86,7 +105,7 @@ export function docGroups() {
     if (group === undefined) continue;
     const order = Object.hasOwn(meta, 'order') ? meta.order : 0;
     delete meta.order;
-    const page = { id: name.slice(0, -3), ...meta };
+    const page = { id, rel, ...meta };
     if (body.trim()) page.body = body.replace(/\n+$/, '');
     group.pages.push([order, page]);
   }
@@ -103,50 +122,96 @@ export function docGroups() {
   return out;
 }
 
+// ---- markdown tables as data ------------------------------------------------------------
+
+/** One table row's cells; a `\|` inside a cell is kept as a literal bar. */
+function tableCells(line) {
+  return line.trim().replace(/^\|/, '').replace(/\|$/, '').split(/(?<!\\)\|/)
+    .map((c) => c.trim().replace(/\\\|/g, '|'));
+}
+
 /**
- * The neutral term, the theme key whose value renames it, and the one-line description. A
- * key of `null` marks a term no theme renames.
+ * The body rows of the first table whose header, lower-cased, is exactly `head` — or `null`.
+ *
+ * A TABLE IS THE DATA so a page reads the same on GitHub as in the console: the map on
+ * understand page 2 and the glossary are both tables a person can read, and the console builds
+ * its richer view from the same rows rather than from a second copy that could drift. A row
+ * with the wrong number of cells is a malformed table, so the whole answer is `null`.
  */
-const GLOSSARY_KEYS = [
-  // The three tiers, in constitutional order and before the entities — a reader who does not
-  // know what an Ethos is here cannot read the rest of the glossary's first rows.
-  //
-  // `Ethos (Ontology)` for the same reason as `Rule (Law)` below: the neutral theme renamed
-  // what a reader SEES, while the address the reader will meet in `src/ontology/`, in the
-  // `ONTOLOGY` theme key and in every identifier did not move. The parenthesis is the bridge
-  // between the two, and the glossary is the one page that owes a reader that bridge.
-  ['Ethos (Ontology)', 'ONTOLOGY', 'the always-on worldview under the rules — telos, evidence, '
-    + 'decisions, conduct; it holds the Pact'],
-  ['Rule (Law)', 'LAW', 'one of the nine always-on invariants: what is never done'],
-  ['Rules (Laws)', 'LAWS', 'the body of always-on invariants'],
-  ['Doctrine', 'DOCTRINE', 'one practice rule, cited `<pack> <n>` — how work is done here'],
-  ['Doctrines', 'DOCTRINES', 'the practice packs, chosen at build time; inactive packs still '
-    + 'ship in the bundle'],
-  ['Agent', 'AGENT', 'a capability specialist'],
-  ['Agents', 'AGENTS', 'the roster of specialists'],
-  ['Skill', 'SKILL', 'a repeatable workflow'],
-  ['Skills', 'SKILLS', 'the catalogue of workflows'],
-  ['Memory', 'MEMORY', 'durable, one-fact-per-file knowledge'],
-  ['Notebook', 'NOTEBOOK', "the agent's sovereign space"],
-  ['Wiki', 'WIKI', 'the machine-wide knowledge base'],
-  // Still a token, still themed, but it names a CONCEPT INSIDE the ontology's Telos now
-  // rather than a peer of the Rules — `src/postures/peer.md` cites it and the section that
-  // used to carry it is the Ethos.
-  ['Pact', 'PACT', 'the two-way collaboration contract, stated in Telos, the first Ethos '
-    + 'section'],
-  ['Posture', null, 'the relationship register the agent works in '
-    + '(peer, mentor, expert, assistant, artisan)'],
-  ['Mode', null, 'how work gets executed — direct (the agent works every '
-    + 'task itself) or foreman (substantial tasks spawn an isolated pipeline)'],
-  ['Footprint', null, 'how much of the Rules loads inline each turn '
-    + '(full vs lean)'],
-  ['Profile', null, 'who you are — seeded once, colours but never binds'],
-  ['Memory force', null, "a memory's binding strength (constraint, "
-    + 'choice, conviction, tempered)'],
-  ['Tagline', 'TAGLINE', 'the one-line essence of the theme'],
-  ['Loaded sigil', 'LOADED_SIGIL', 'what the agent emits when ready'],
-  ['Benediction', 'BENEDICTION', 'the closing line of an install'],
-];
+export function tableRows(body, head) {
+  const lines = body.split('\n');
+  for (let i = 0; i + 1 < lines.length; i += 1) {
+    if (!lines[i].trim().startsWith('|')) continue;
+    const h = tableCells(lines[i]).map((c) => c.toLowerCase());
+    if (h.length !== head.length || h.some((c, j) => c !== head[j])) continue;
+    const rows = [];
+    for (let j = i + 2; j < lines.length && lines[j].trim().startsWith('|'); j += 1) {
+      const row = tableCells(lines[j]);
+      if (row.length !== head.length) return null;
+      rows.push(row);
+    }
+    return rows;
+  }
+  return null;
+}
+
+const MAP_HEAD = ['piece', 'what it does for you', 'kind', 'cost', 'turn it off'];
+export const MAP_KINDS = ['enforced', 'automatic', 'asked', 'on demand'];
+
+/** The "what lands on your machine" table as rows, or `null` when absent or malformed. */
+export function parseMapTable(body) {
+  const rows = tableRows(body, MAP_HEAD);
+  if (!rows || !rows.length) return null;
+  const out = rows.map(([piece, does, kind, cost, off]) => (
+    { piece, does, kind: kind.toLowerCase(), cost, off }));
+  return out.every((r) => MAP_KINDS.includes(r.kind)) ? out : null;
+}
+
+const GLOSSARY_HEAD = ['term', 'theme key', 'meaning', 'in dev terms'];
+
+/**
+ * The glossary table: term, the theme key whose value renames it (`—` when no theme does),
+ * the meaning, and the developer analogy (`—` when there is none).
+ */
+export function parseGlossaryTable(body) {
+  const rows = tableRows(body, GLOSSARY_HEAD);
+  if (!rows) return [];
+  const dash = (s) => (s === '—' || s === '-' || s === '' ? null : s);
+  return rows.map(([label, key, desc, analogy]) => (
+    { label, key: dash(key), desc, analogy: dash(analogy) }));
+}
+
+// ---- links between pages ----------------------------------------------------------------
+
+const MD_LINK_RE = /\]\((?!https?:|#|mailto:)([^)\s]+?\.md)(#[^)\s]*)?\)/g;
+// ponytail: the canonical repo, not the install's origin; a fork's console links upstream.
+const GITHUB_BLOB = 'https://github.com/Arylmera/Geneseed/blob/main/';
+
+/**
+ * Relative `.md` links, which is how the pages link on GitHub, rewritten for the console.
+ *
+ * A target that is a docs page becomes `#/docs/<id>` (its `#anchor` dropped — the console
+ * addresses pages, not headings); any other repo file — a maintainer doc, a README under
+ * `src/` — opens on GitHub, since the console does not serve it. Absolute URLs, in-page
+ * anchors and fenced examples are left alone.
+ */
+export function rewriteDocLinks(body, fromRel, idByRel) {
+  if (!body.includes('.md')) return body;
+  let inFence = false;
+  return body.split('\n').map((line) => {
+    if (line.startsWith('```')) { inFence = !inFence; return line; }
+    if (inFence) return line;
+    return line.replace(MD_LINK_RE, (m, target, anchor) => {
+      const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(fromRel), target));
+      const id = idByRel.get(resolved);
+      return id ? `](#/docs/${id})` : `](${GITHUB_BLOB}${resolved}${anchor ?? ''})`;
+    });
+  }).join('\n');
+}
+
+function idsByRel() {
+  return new Map(docSources().map((s) => [s.rel, s.id]));
+}
 
 // ---- counts substituted into concept bodies -------------------------------------------
 
@@ -239,6 +304,13 @@ export function harnessBlocksBalanced(lines) {
   return !open;
 }
 
+/**
+ * The visible `*(OpenCode only)*` line a block opens with. It exists for GitHub, which hides
+ * the marker; the console has already filtered the block to the reader's host, so there the
+ * label only repeats what the host selector says, and it goes with the marker.
+ */
+const HOST_LABEL_RE = /^\s*\*\((OpenCode|Claude Code) only\)\*\s*$/;
+
 export function stripHarnessBlocks(body, harnessName) {
   if (!HARNESS_HINT_RE.test(body)) return body;
   const lines = splitLines(body);
@@ -246,7 +318,10 @@ export function stripHarnessBlocks(body, harnessName) {
   const out = [];
   let keep = true;
   let inFence = false;
+  let afterOpen = false;
   for (const line of lines) {
+    const labelSlot = afterOpen;
+    afterOpen = false;
     if (line.startsWith('```')) {
       inFence = !inFence;
       if (keep) out.push(line);
@@ -254,8 +329,9 @@ export function stripHarnessBlocks(body, harnessName) {
     }
     if (!inFence) {
       const m = HARNESS_OPEN_RE.exec(line);
-      if (m) { keep = m[1] === harnessName; continue; }
+      if (m) { keep = m[1] === harnessName; afterOpen = true; continue; }
       if (HARNESS_CLOSE_RE.test(line)) { keep = true; continue; }
+      if (labelSlot && HOST_LABEL_RE.test(line)) continue;
     }
     if (keep) out.push(line);
   }
@@ -363,8 +439,8 @@ function readDocSource(rel) {
   return readMaybe(target) ?? '';
 }
 
-/** The deployed theme's words beside the neutral ones. */
-function glossary(state) {
+/** The deployed theme's words beside the neutral ones, from `docs/reference/glossary.md`. */
+function glossary(state, page) {
   const load = (theme) => {
     const doc = readJsonMaybe(path.join(THEMES, `${theme}.json`));
     return doc && typeof doc === 'object' && !Array.isArray(doc) ? doc : {};
@@ -372,10 +448,10 @@ function glossary(state) {
   const neutral = load('neutral');
   const themed = state.theme !== 'neutral' ? load(state.theme) : neutral;
   const rows = [];
-  for (const [label, key, desc] of GLOSSARY_KEYS) {
+  for (const { label, key, desc, analogy } of parseGlossaryTable(page.body ?? '')) {
     if (key === null) {
       const term = label.toLowerCase();
-      rows.push({ label, neutral: term, themed: term, desc });
+      rows.push({ label, neutral: term, themed: term, desc, analogy });
       continue;
     }
     rows.push({
@@ -383,6 +459,7 @@ function glossary(state) {
       neutral: String(Object.hasOwn(neutral, key) ? neutral[key] : '').trim(),
       themed: String(Object.hasOwn(themed, key) ? themed[key] : '').trim(),
       desc,
+      analogy,
     });
   }
   return { theme: state.theme, rows };
@@ -452,7 +529,7 @@ export function apiDocsPage(state, pageId, harnessName = null) {
 }
 
 /**
- * The five kinds, as a TABLE and not five `if`s.
+ * The six kinds, as a TABLE and not six `if`s.
  *
  * `tests/unit/web_server.test.mjs` holds `Object.keys(KIND_ROUTES)` against a written-out
  * list of the kinds `apiDocsPage` must dispatch on — this table is what the dispatcher
@@ -470,17 +547,24 @@ const KIND_ROUTES = {
       body = sliced;
       if (ok) anchor = null;
     }
-    body = stripHarnessBlocks(body, hn);
+    body = rewriteDocLinks(stripHarnessBlocks(body, hn), page.source, idsByRel());
     return { id: pageId, title: page.title, kind: 'markdown', body,
       source: page.source, anchor, links: resolveLinks(state, body) };
   },
   concept: (state, pageId, page, hn) => {
-    const body = subCounts(state, stripHarnessBlocks(page.body ?? '', hn));
+    const body = rewriteDocLinks(subCounts(state, stripHarnessBlocks(page.body ?? '', hn)),
+      page.rel, idsByRel());
     return { id: pageId, title: page.title, kind: 'concept', body,
       link: page.link ?? null, links: resolveLinks(state, body) };
   },
+  // A concept page plus the rows of its own map table, for the console's map view.
+  map: (state, pageId, page, hn) => {
+    const body = rewriteDocLinks(stripHarnessBlocks(page.body ?? '', hn), page.rel, idsByRel());
+    return { id: pageId, title: page.title, kind: 'map', body, rows: parseMapTable(body),
+      links: resolveLinks(state, body) };
+  },
   glossary: (state, pageId, page) => ({
-    id: pageId, title: page.title, kind: 'glossary', ...glossary(state),
+    id: pageId, title: page.title, kind: 'glossary', ...glossary(state, page),
   }),
   about: (state, pageId, page) => ({
     id: pageId, title: page.title, kind: 'about', ...about(state),

package/js/web/handler.mjs

@@ -295,6 +295,7 @@ export function makeHandler(state, jm, token, dist, holder = null) {
     // packs — never to `harness.config.json`, which would drop the consent gate.
     const cmds = actionCommands(action, {
       theme, emit, footprint: state.footprint, posture: state.posture, mode: state.mode,
+      trust: state.trust,
       doctrines: doctrinesForBuild(state.target),
     });
     if (!isTruthy(cmds)) {

package/js/web/jobs.mjs

@@ -88,6 +88,7 @@ import path from 'node:path';
 
 import { ROOT, PACK_ORDER } from '../build/source.mjs';
 import { setupBuildArgs } from '../build/generate.mjs';
+import { DEFAULT_PRESET } from '../loop/score.mjs';
 import { isDict } from '../hosts/mcp.mjs';
 import { readText, writeText, isFile } from '../lib/fs.mjs';
 import { jsonDumpsCompact, parseJson, isTruthy } from '../lib/json.mjs';
@@ -402,9 +403,10 @@ export const INLINE_ACTIONS = ['restore', 'install', 'deploy'];
 function actionTable({
   theme = 'neutral', emit = 'opencode-global', footprint = 'full',
   posture = 'peer', mode = 'direct', doctrines = [...PACK_ORDER], excludeRules = [],
+  trust = DEFAULT_PRESET,
 } = {}) {
   const buildArgv = setupBuildArgs(theme, emit, null, null, footprint, posture, mode,
-    doctrines, PACK_ORDER, excludeRules);
+    doctrines, PACK_ORDER, excludeRules, trust);
   return {
     doctor: [[NODE(), CLI(), 'doctor']],
     build: [[NODE(), GEN(), ...buildArgv]],