geneseed 3.9.0 → 3.11.0

package/js/web/actions.mjs

@@ -41,7 +41,7 @@ import { excludeAdd, excludeRemove } from '../inspect/excludes.mjs';
 import { setupBuildArgs } from '../build/generate.mjs';
 import { frontmatter, memoryDropIndex } from '../hosts/hooks.mjs';
 import {
-  HOSTS, bobConfigDir, claudeConfigDir, copilotConfigDir, expanduser, openclaudeConfigDir,
+  HOSTS, bobConfigDir, claudeConfigDir, expanduser, openclaudeConfigDir,
   opencodeConfigDir, resolvePath,
 } from '../hosts/hosts.mjs';
 import {
@@ -644,7 +644,7 @@ export function apiMcpToggle(state, body) {
     return { ok: false, error: 'config holds comments — edit it by hand to keep them' };
   }
   let cfg;
-  if (['claude', 'bob', 'copilot', 'openclaude'].includes(host)) {
+  if (['claude', 'bob', 'openclaude'].includes(host)) {
     if (isFile(p)) {
       let parsed;
       try {
@@ -816,7 +816,6 @@ const EMIT_FOR = new Map([
   ['opencode global', 'opencode-global'], ['opencode project', 'opencode'],
   ['claude global', 'claude-global'], ['claude project', 'claude'],
   ['bob global', 'bob-global'], ['bob project', 'bob'],
-  ['copilot global', 'copilot-global'], ['copilot project', 'copilot'],
   ['openclaude global', 'openclaude-global'], ['openclaude project', 'openclaude'],
 ]);
 
@@ -952,7 +951,7 @@ export function apiDeployCmd(state, body) {
     return { error: `folder not writable: ${root}` };
   }
   const cfgdirs = new Set();
-  for (const fn of [opencodeConfigDir, claudeConfigDir, bobConfigDir, copilotConfigDir,
+  for (const fn of [opencodeConfigDir, claudeConfigDir, bobConfigDir,
     openclaudeConfigDir]) {
     try {
       cfgdirs.add(resolvePath(fn()));
@@ -978,7 +977,7 @@ export function apiDeployCmd(state, body) {
   // and `PreToolUse::Bash` went with them. `doctrinesForBuild` resolves unknown to ALL packs.
   const doctrines = bodyDoctrines(body) ?? doctrinesForBuild(root);
   const excludeRules = bodyExcludeRules(body) ?? excludedRulesOfDir(root);
-  // project-scope emit name == host name (opencode / claude / bob / copilot / openclaude)
+  // 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);
   return { cmd: [process.execPath, path.join(ROOT, 'bin', 'build-driver.mjs'), ...argv] };

package/js/web/api.mjs

@@ -141,8 +141,8 @@ export function webState(theme = null, target = null) {
    * Re-point the console at another detected install's data dir.
    *
    * `root` is the install ROOT the markers and sigils live at. It defaults to `target` and
-   * differs only for claude/bob/copilot PROJECT installs, where the data sits under
-   * `<repo>/.claude|.bob|.github` while `.geneseed-emit`/`-theme`/`-footprint` land at
+   * differs only for claude/bob/openclaude PROJECT installs, where the data sits under
+   * `<repo>/.claude|.bob|.openclaude` while `.geneseed-emit`/`-theme`/`-footprint` land at
    * `<repo>/` — reading them from the data dir mis-detects the install as opencode/neutral,
    * and a Diff or a Restore would then overwrite it in the wrong dialect.
    */
@@ -725,7 +725,7 @@ export const apiExcludes = () => excludesSnapshot();
  * nested-marker host cannot silently read the bare root.
  */
 export function viewCfg(host, scope, root) {
-  if (scope === 'project' && ['claude', 'bob', 'copilot', 'openclaude'].includes(host)) {
+  if (scope === 'project' && ['claude', 'bob', 'openclaude'].includes(host)) {
     return path.join(root, HOSTS.find((h) => h.host === host).projectMarker);
   }
   return root;
@@ -795,7 +795,7 @@ export function apiOverview(state) {
   // can re-emit exactly it. Mirrors `viewCfg`'s rule, spelled out separately here.
   let install = null;
   for (const [host, scope, root] of installTargets()) {
-    const data = (scope === 'project' && ['claude', 'bob', 'copilot', 'openclaude'].includes(host))
+    const data = (scope === 'project' && ['claude', 'bob', 'openclaude'].includes(host))
       ? path.join(root, HOSTS.find((h) => h.host === host).projectMarker) : root;
     try {
       if (samePath(data, state.target)) {
@@ -819,6 +819,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,

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) {
@@ -268,6 +292,7 @@ export async function statusDaemon(theme = null) {
   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,6 +301,33 @@ export async function statusDaemon(theme = null) {
   return 1;
 }
 
+/**
+ * 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, 4747, 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.`);
+  }
+}
+
 export async function restartDaemon(theme = null, port = 4747, openBrowser = true,
   onlyIfRunning = false) {
   const { target } = webState(theme);

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/server.mjs

@@ -28,7 +28,7 @@ import { which } from '../lib/paths.mjs';
 import { parseIntStrict } from '../lib/text.mjs';
 import { promptLine } from '../maintain/setup.mjs';
 import { webState } from './api.mjs';
-import { clearDaemon, openUrl, readDaemon, restartDaemon, startDaemon, statusDaemon, stopDaemon, writeDaemon } from './daemon.mjs';
+import { clearDaemon, codeStamp, openUrl, readDaemon, restartDaemon, startDaemon, statusDaemon, stopDaemon, writeDaemon } from './daemon.mjs';
 import { isFile, makeHandler } from './handler.mjs';
 import { JobManager } from './jobs.mjs';
 import { spawnSync } from 'node:child_process';
@@ -137,6 +137,9 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
     printOut('      Run `geneseed setup` first — serving anyway (read-only UI).\n');
   }
   const token = randomBytes(24).toString('base64url');
+  // The code this server loaded, compared on every overview against the files on disk now.
+  const startCode = codeStamp();
+  state.daemonStale = () => startCode !== codeStamp();
   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.
@@ -156,7 +159,7 @@ export async function serve({ theme = null, port = 4747, openBrowser = true,
       if (daemon) {
         writeDaemon(state.target, {
           pid: process.pid, port: hostPort, url,
-          token, theme: state.theme, started: Math.floor(Date.now() / 1000),
+          token, theme: state.theme, started: Math.floor(Date.now() / 1000), code: startCode,
         });
       }
       printOut(`[web] Geneseed UI on ${url}  (theme: ${state.theme})\n`);

package/package.json

@@ -1,14 +1,13 @@
 {
   "//": "Every field here is argued and gated in tests/unit/package_manifest.test.mjs. `files`, `bin` and `engines` each have a test that fails when reality drifts from this file; `version` mirrors harness.config.json and is gated too. Read that docblock before editing this one.",
   "name": "geneseed",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "A portable, theme-able harness you implant once and use everywhere to grow a disciplined AI coding agent.",
   "keywords": [
     "ai",
     "agent",
     "claude-code",
     "opencode",
-    "copilot",
     "openclaude",
     "agents-md",
     "skills",
@@ -39,7 +38,11 @@
     "themes/",
     "adapters/",
     "docs/*.md",
-    "docs/web/",
+    "docs/_groups.json",
+    "docs/understand/",
+    "docs/guides/",
+    "docs/concepts/",
+    "docs/reference/",
     "web/dist/",
     "web/src/pages/Laws.jsx",
     "harness.config.json",
@@ -48,8 +51,6 @@
     "geneseed.cmd",
     "CHANGELOG.md",
     "DESIGN.md",
-    "QUICKSTART.md",
-    "SETUP.md",
     "SHIPPED.md"
   ],
   "devDependencies": {

package/registry.json

@@ -295,6 +295,13 @@
       "added": "2026-06-07",
       "last_verified": "2026-09-06"
     },
+    "skills/learn-mode": {
+      "status": "experimental",
+      "version": "1.0.0",
+      "owner": "Guillaume Lemer",
+      "added": "2026-10-02",
+      "last_verified": ""
+    },
     "skills/migrate": {
       "status": "approved",
       "version": "1.0.0",