@oddessentials/agent-guild 0.29.0 → 0.31.0

package/README.md

@@ -86,6 +86,30 @@ Prompt are also offered when found. On macOS and Linux it follows your login
 shell. Pick the default chip to clear a saved choice and follow the default
 again. The choice applies to new sessions.
 
+**See the manager environment.** The Shell card summarizes detected Node.js,
+Python, Go, .NET SDK, R and Rust versions. **Environment details** shows the
+resolved paths, detection results, .NET runtimes and detected nvm/NVM for
+Windows, vfox, uv and pnpm launchers. Tools are listed by presence; their
+activation is not inferred. This describes the computer running Agent Guild
+and its manager environment, including when viewed remotely. Selected shells,
+projects and existing sessions may use different versions.
+
+Python always uses `python` when it is found on the manager's PATH; otherwise
+it uses `python3`. A broken `python` remains the primary result, with a
+different `python3` shown separately. **Not found** means no command was
+resolved, **Runtime unavailable** means a launcher was found but no runtime
+could safely be reported, and **Probe failed** means inspection or the version
+check failed. Missing optional runtimes never prevent starting a shell.
+
+Discovery runs on first viewing and again on **Refresh**, in an isolated
+helper with a neutral temporary working directory. It does not load shell
+profiles, activate tools, download runtimes or modify installations. Unknown
+script/shim launchers and Windows execution aliases are left unverified.
+Refresh checks the manager's current environment; it does not reload its
+PATH from a shell. Existing results remain visible during refresh. Go reports
+the local bundled toolchain with automatic switching disabled, and the Node
+version running Agent Guild is also shown in details.
+
 **Work inside tmux or herdr.** When installed, the Shell card also offers
 tmux (3.2 or later, on macOS and Linux) and herdr. A tmux card runs a tmux
 session of its own, with your own configuration, and tools in it report to
@@ -160,8 +184,10 @@ vX.Y.Z** switches over when you are ready. The version badge opens
 
 **Keep notes at hand.** **Notes** in the top bar opens a notepad for prompts,
 commands and to-dos in the side panel, next to your terminals. It saves up to
-100,000 characters as you type and keeps them in this browser, never on the
-manager; every tab of the page shows the same notes.
+100,000 characters as you type. The same notes follow every browser signed in
+to this manager, including one opened through remote access. This browser
+keeps a copy too: if the manager is unreachable, the line under the title
+says the notes are saved in this browser only, and they sync when it is back.
 
 **GitHub beside your work.** **GitHub** in the top bar opens the side panel.
 Sign in to one or more GitHub accounts, then search the repositories of all

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Launch and watch AI coding-assistant terminal sessions from one local web page. A bundled session manager owns the terminals so the page can close and reconnect.",
   "license": "MIT",
   "repository": {

package/src/manager/config.mjs

@@ -45,6 +45,8 @@ export const paths = {
   get accounts() { return path.join(dataDir(), 'accounts'); },
   get github() { return path.join(dataDir(), 'github'); },
   get remoteAccess() { return path.join(dataDir(), 'remote-access.json'); },
+  /** The shared notepad. A missing file means it was never stored. */
+  get notes() { return path.join(dataDir(), 'notes.json'); },
   get log() { return path.join(dataDir(), 'manager.log'); },
   /** Launchers for agent-guild-report, put first on every session's PATH. */
   get shims() { return path.join(dataDir(), 'bin'); },

package/src/manager/environment-probe.mjs

@@ -0,0 +1,189 @@
+// Passive discovery only. This module is also the isolated helper entry point.
+// Never source profiles, invoke package managers, or use a project directory.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { resolveCommand, killWindowsTree } from './command-resolver.mjs';
+
+export const RUNTIMES = [
+  { id: 'node', label: 'Node.js', command: 'node', args: ['--version'], pattern: /^v(\d+\.\d+\.\d+(?:-[\w.-]+)?)\s*$/m },
+  { id: 'python', label: 'Python', command: 'python', args: ['--version'], pattern: /^Python (\d+\.\d+\.\d+(?:[\w.+-]*)?)/m },
+  { id: 'go', label: 'Go', command: 'go', args: ['version'], pattern: /^go version go(\d+\.\d+(?:\.\d+)?(?:[\w.-]*)?)(?:\s|$)/m },
+  { id: 'dotnet', label: '.NET SDK', command: 'dotnet', args: ['--version'], pattern: /^(\d+\.\d+\.\d+(?:-[\w.-]+)?)\s*$/m },
+  { id: 'r', label: 'R', command: 'R', args: ['--version'], pattern: /^R version (\d+\.\d+\.\d+(?:[\w.-]*)?)/m },
+  { id: 'rust', label: 'Rust', command: 'rustc', args: ['--version'], pattern: /^rustc (\d+\.\d+\.\d+(?:-[\w.-]+)?)(?:\s|$)/m },
+];
+const LIMIT = 32 * 1024;
+const TIMEOUT_MS = 1800;
+
+function readHead(file) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const bytes = Buffer.alloc(LIMIT);
+    return bytes.subarray(0, fs.readSync(fd, bytes, 0, bytes.length, 0));
+  } finally { fs.closeSync(fd); }
+}
+
+function value(env, name) {
+  return env[Object.keys(env).find((key) => key.toUpperCase() === name.toUpperCase())];
+}
+
+export function probeEnv(env) {
+  const out = { ...env };
+  // Overrides apply only to the helper's probes, never the manager or sessions.
+  const overrides = {
+    NODE_OPTIONS: '', GOTOOLCHAIN: 'local', GOENV: 'off', GOWORK: 'off',
+    RUSTUP_AUTO_INSTALL: '0', PYTHON_MANAGER_AUTOMATIC_INSTALL: 'false',
+    DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_SKIP_FIRST_TIME_EXPERIENCE: '1',
+    DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: 'true', DOTNET_NOLOGO: '1',
+    COREPACK_ENABLE_NETWORK: '0', UV_OFFLINE: '1', UV_PYTHON_DOWNLOADS: 'never',
+  };
+  for (const key of Object.keys(out)) if (Object.hasOwn(overrides, key.toUpperCase())) delete out[key];
+  return { ...out, ...overrides };
+}
+
+// Do not execute unknown script shims. Most version managers link to native
+// runtimes; following the link makes their normal installations work directly.
+// R's Unix launcher is itself an official shell script and exits on --version.
+export function passiveExecutable(file, id, { platform = process.platform, env = process.env, realpath = fs.realpathSync, read = readHead } = {}) {
+  const real = realpath(file);
+  const normalized = real.replaceAll('\\', '/').toLowerCase();
+  if (/\/(?:shims|\.nodejs)\//.test(normalized) || /\/(?:mise|asdf|volta)(?:\.exe)?$/.test(normalized)) {
+    return { error: 'A version-manager shim was found. Its runtime cannot be checked without activating the manager.' };
+  }
+  if (platform === 'win32' && /\/windowsapps\//.test(normalized)) {
+    return { error: 'A Windows execution alias was found. A runtime behind this alias has not been verified.' };
+  }
+  const head = read(real);
+  const binary = head[0] === 0x4d && head[1] === 0x5a // PE
+    || head[0] === 0x7f && head.subarray(1, 4).toString() === 'ELF'
+    || ['feedface', 'feedfacf', 'cefaedfe', 'cffaedfe', 'cafebabe', 'bebafeca', 'cafebabf', 'bfbafeca'].includes(head.subarray(0, 4).toString('hex'));
+  if (binary) {
+    // rustup dispatches using argv[0]; preserve its rustc proxy's name.
+    return { file: id === 'rust' && /\/rustup(?:\.exe)?$/.test(normalized) ? file : real };
+  }
+  const text = head.toString('utf8');
+  if (id === 'r' && platform !== 'win32' && text.startsWith('#!') && /R_HOME_DIR=/.test(text) && /--version/.test(text)) return { file: real };
+  return { error: 'A script launcher was found. Passive detection does not execute unrecognized wrappers.' };
+}
+
+// The helper has a second, independent overall deadline in Environment. A
+// timeout here resolves immediately, even if a descendant retains stdout.
+export function runProbe(file, args, { env, cwd, timeoutMs = TIMEOUT_MS, spawnProcess = spawn } = {}) {
+  return new Promise((resolve) => {
+    let child, timer, size = 0, output = '', settled = false;
+    const stop = () => {
+      if (!child?.pid) return;
+      if (process.platform === 'win32') killWindowsTree(child.pid);
+      else { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
+      child.stdout?.destroy(); child.stderr?.destroy(); child.unref();
+    };
+    const finish = (result, kill = false) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (kill) stop();
+      resolve({ output, ...result });
+    };
+    try {
+      child = spawnProcess(file, args, { env, cwd, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+      timer = setTimeout(() => finish({ error: 'Version check timed out.' }, true), timeoutMs);
+      for (const stream of [child.stdout, child.stderr]) stream.on('data', (chunk) => {
+        size += chunk.length;
+        if (size > LIMIT) return finish({ error: 'Version check produced too much output.' }, true);
+        output += chunk.toString();
+      });
+      child.on('error', () => finish({ error: 'Could not run the resolved executable.' }, true));
+      child.on('close', (code) => finish({ code }));
+    } catch { finish({ error: 'Could not run the resolved executable.' }, true); }
+  });
+}
+
+const unavailable = {
+  node: /no (?:default |installed )?(?:node|version)|version .*not installed/i,
+  python: /no (?:suitable |installed )?(?:python|runtime)|python was not found|no runtimes? (?:are )?installed/i,
+  go: /cannot find GOROOT|toolchain .*not available/i,
+  dotnet: /no .NET SDKs were found|compatible .NET SDK was not found|SDK .*not found/i,
+  rust: /no default is configured|toolchain .*not installed|could not choose a version|toolchain .*is not installable/i,
+};
+
+export async function scanRuntime(definition, { env, cwd, platform = process.platform, resolve = resolveCommand, inspect = passiveExecutable, run = runProbe } = {}) {
+  const { id, label, command, args, pattern } = definition;
+  const base = { id, label, status: 'not_found', version: null, path: null, command, detail: null };
+  const one = async (name) => {
+    const file = resolve(name, env, platform);
+    if (!file) return { ...base, command: name };
+    const row = { ...base, command: name, path: file };
+    try {
+      const executable = inspect(file, id, { platform, env });
+      if (executable.error) return { ...row, status: 'unavailable', detail: executable.error };
+      const result = await run(executable.file, args, { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd, DOTNET_GENERATE_ASPNET_CERTIFICATE: 'false' }, cwd });
+      if (result.error) return { ...row, status: 'failed', detail: result.error };
+      const version = result.code === 0 ? pattern.exec(result.output)?.[1] : null;
+      if (version) return { ...row, status: 'ok', version };
+      const missing = unavailable[id]?.test(result.output);
+      return { ...row, status: missing ? 'unavailable' : 'failed', detail: missing
+        ? 'The launcher was found, but it could not provide a local runtime.'
+        : result.code === 0 ? 'The version response was not recognized.' : 'The version command did not complete successfully.' };
+    } catch { return { ...row, status: 'failed', detail: 'Could not inspect the resolved executable.' }; }
+  };
+  // Fixed on every OS: python wins if it resolves, even when its probe fails.
+  let row = await one(command);
+  if (id === 'python') {
+    const other = await one('python3');
+    if (!row.path) row = other;
+    else if (other.path && other.path !== row.path) row.alternatives = [other];
+  }
+  if (id === 'dotnet' && row.path && row.status !== 'failed') {
+    try {
+      const executable = inspect(row.path, id, { platform, env });
+      if (!executable.error) {
+        const result = await run(executable.file, ['--list-runtimes'], { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd }, cwd });
+        if (result.code === 0) row.runtimes = result.output.split(/\r?\n/).map((line) => line.match(/^(Microsoft\.[\w.]+) (\d+\.\d+\.\d+(?:-[\w.-]+)?) \[/))
+          .filter(Boolean).map((match) => ({ name: match[1], version: match[2] }));
+      }
+    } catch { /* SDK result remains usable */ }
+  }
+  return row;
+}
+
+export function detectTools({ env, platform = process.platform, resolve = resolveCommand, exists = fs.existsSync } = {}) {
+  const tools = [];
+  const add = (id, label, file) => { if (file) tools.push({ id, label, path: file, status: 'detected' }); };
+  if (platform === 'win32') add('nvm-windows', 'NVM for Windows', resolve('nvm', env, platform));
+  else {
+    const home = value(env, 'HOME') || os.homedir();
+    const dir = value(env, 'NVM_DIR') || path.posix.join(home, '.nvm');
+    const file = path.posix.join(dir, 'nvm.sh');
+    if (path.posix.isAbsolute(file) && exists(file)) add('nvm', 'nvm', file);
+  }
+  for (const name of ['vfox', 'uv', 'pnpm']) add(name, name, resolve(name, env, platform));
+  return tools;
+}
+
+if (process.argv[2] === '--scan-environment' && process.send) {
+  // A fresh temporary directory contains no project files. Manager env is
+  // retained; no selected shell, project or session is inspected or changed.
+  let cwd;
+  try {
+    cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-guild-environment-'));
+    process.chdir(cwd);
+    const env = { ...process.env };
+    process.send({ tools: detectTools({ env }) });
+    // Two batches bound concurrency while giving each runtime its own result.
+    for (let i = 0; i < RUNTIMES.length; i += 3) {
+      await Promise.all(RUNTIMES.slice(i, i + 3).map(async (definition) => {
+        const runtime = await scanRuntime(definition, { env, cwd });
+        process.send({ runtime });
+      }));
+    }
+  } finally {
+    // Windows cannot remove a process's current working directory.
+    process.chdir(os.tmpdir());
+    if (cwd && path.dirname(cwd) === path.resolve(os.tmpdir()) && path.basename(cwd).startsWith('agent-guild-environment-')) {
+      fs.rmSync(cwd, { recursive: true, force: true });
+    }
+  }
+  process.send({ done: true });
+}

package/src/manager/environment.mjs

@@ -0,0 +1,86 @@
+// Read-only snapshot of the manager environment. Discovery runs outside the
+// manager: even a blocked filesystem lookup cannot hold up terminals or HTTP.
+import { EventEmitter } from 'node:events';
+import { fork } from 'node:child_process';
+import { killWindowsTree } from './command-resolver.mjs';
+import { RUNTIMES } from './environment-probe.mjs';
+
+export const ENVIRONMENT_TIMEOUT_MS = 10000;
+
+export class Environment extends EventEmitter {
+  constructor({ env, forkWorker = fork, timeoutMs = ENVIRONMENT_TIMEOUT_MS } = {}) {
+    super();
+    this.env = env ?? process.env;
+    this.forkWorker = forkWorker;
+    this.timeoutMs = timeoutMs;
+    this.closed = false;
+    this.run = null;
+    this.value = {
+      scope: 'manager', platform: process.platform, revision: 0, refreshing: false, checkedAt: null, error: null,
+      managerNode: { version: process.versions.node, path: process.execPath },
+      runtimes: RUNTIMES.map(({ id, label }) => ({ id, label, status: 'pending', version: null, path: null })),
+      tools: [],
+    };
+  }
+
+  snapshot() { return this.value; }
+
+  // Never awaits discovery. A refresh reads the manager's current environment;
+  // it does not reload shell profiles, the registry, or a client's working folder.
+  refresh() {
+    if (this.closed || this.run) return this.snapshot();
+    const run = { child: null, timer: null, rows: new Map(), tools: [] };
+    this.run = run;
+    this.value = { ...this.value, revision: this.value.revision + 1, refreshing: true, error: null };
+    const finish = (error = null) => {
+      if (this.run !== run) return;
+      this.run = null;
+      clearTimeout(run.timer);
+      this.stopWorker(run.child);
+      this.value = {
+        ...this.value, revision: this.value.revision + 1, refreshing: false, checkedAt: new Date().toISOString(), error,
+        runtimes: RUNTIMES.map(({ id, label }) => run.rows.get(id) ?? {
+          id, label, status: 'failed', version: null, path: null, detail: error || 'The environment check did not finish.',
+        }),
+        tools: run.tools,
+      };
+      if (!this.closed) this.emit('updated');
+    };
+    try {
+      // A preload in NODE_OPTIONS must not execute inside a passive scan.
+      const env = { ...this.env };
+      for (const key of Object.keys(env)) if (key.toUpperCase() === 'NODE_OPTIONS') delete env[key];
+      run.child = this.forkWorker(new URL('./environment-probe.mjs', import.meta.url), ['--scan-environment'], {
+        env, execArgv: [], stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+        windowsHide: true, detached: process.platform !== 'win32',
+      });
+      run.child.on('message', (message) => {
+        if (this.run !== run) return;
+        if (message?.runtime && RUNTIMES.some((r) => r.id === message.runtime.id)) run.rows.set(message.runtime.id, message.runtime);
+        if (Array.isArray(message?.tools)) run.tools = message.tools;
+        if (message?.done) finish();
+      });
+      run.child.once('error', () => finish('Could not start the environment check.'));
+      run.child.once('exit', () => finish('The environment check stopped before finishing.'));
+      run.timer = setTimeout(() => finish('The environment check timed out.'), this.timeoutMs);
+      run.timer.unref();
+    } catch { finish('Could not start the environment check.'); }
+    this.emit('updated');
+    return this.snapshot();
+  }
+
+  stopWorker(child) {
+    if (!child?.pid) return;
+    if (process.platform === 'win32') killWindowsTree(child.pid);
+    else { try { process.kill(-child.pid, 'SIGKILL'); } catch { /* already exited */ } }
+  }
+
+  close() {
+    this.closed = true;
+    if (this.run) {
+      clearTimeout(this.run.timer);
+      this.stopWorker(this.run.child);
+      this.run = null;
+    }
+  }
+}

package/src/manager/main.mjs

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ProviderRegistry } from './providers.mjs';
+import { Environment } from './environment.mjs';
 import { SessionManager } from './session-manager.mjs';
 import { UsageMonitor } from './usage.mjs';
 import { SessionHistory } from './session-history.mjs';
@@ -13,6 +14,7 @@ import { NewsFeed } from './news.mjs';
 import { Changelog } from './changelog.mjs';
 import { GitHub } from './github.mjs';
 import { createManagerServer } from './server.mjs';
+import { createNotesStore } from './notes.mjs';
 import { RemoteAccess, loadRemoteAccess } from './remote-access.mjs';
 import { SelfUpdate } from './self-update.mjs';
 import { resolveBaseEnv, pathReader } from './shell-env.mjs';
@@ -45,6 +47,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   ensureDataDir();
   const token = loadOrCreateToken();
   const baseEnv = resolveBaseEnv();
+  const environment = new Environment({ env: baseEnv });
   const remoteAccess = new RemoteAccess({ file: paths.remoteAccess, env: baseEnv, loaded: remoteSettings, ...remoteOptions });
   const webDir = path.join(rootDir, 'web');
   // The hooks in examples/ call `agent-guild-report` by name; these shims
@@ -97,6 +100,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     if (closing) return closing;
     console.log(`[manager] ${restart ? 'restarting' : 'stopping'} (${reason}); ending ${manager.sessions.size} session(s)`);
     clearInterval(versionTimer);
+    environment.close();
     remoteAccess.close();
     github.close();
     removeRuntimeFile();
@@ -123,6 +127,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   api = createManagerServer({
     manager,
     registry,
+    environment,
     usage,
     history,
     modelStats,
@@ -138,6 +143,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     extraHosts: remoteSettings.config.access.hosts,
     extraOrigins: remoteSettings.config.access.origins,
     remoteAccess,
+    notes: createNotesStore(paths.notes),
     launcher: launcherPath(),
     onShutdownRequest: ({ restart = false } = {}) => shutdown('requested via API', { restart }).then(() => process.exit(0)),
   });

package/src/manager/notes.mjs

@@ -0,0 +1,120 @@
+// One notepad for every browser signed in to this manager.
+// A missing file means notes were never stored. An empty string is a notepad
+// the user cleared; those two must stay distinct so an old browser cannot
+// put cleared notes back.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const NOTES_LIMIT = 100000;
+/** Larger than the API's usual 64 KiB body, and enough for a full notepad after JSON escaping. */
+export const NOTES_BODY_LIMIT = 1024 * 1024;
+const NOTES_FILE_LIMIT = 2 * 1024 * 1024;
+
+function notesError(code, message, status, notes) {
+  // The store reports an unreadable file once, so the server does not log every request that hits it.
+  const error = Object.assign(new Error(message), { code, status, logged: code === 'notes_unreadable' });
+  if (notes) error.notes = notes;
+  return error;
+}
+
+/** @returns {{ revision: string, text: string } | null} null when the file is not there yet */
+function readNotes(file) {
+  let stat;
+  try { stat = fs.statSync(file); } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw notesError('notes_unreadable', 'Notes could not be read.', 500);
+  }
+  if (!stat.isFile() || stat.size > NOTES_FILE_LIMIT) throw notesError('notes_unreadable', 'Notes could not be read.', 500);
+  let value;
+  try { value = JSON.parse(fs.readFileSync(file, 'utf8')); } catch {
+    throw notesError('notes_unreadable', 'Notes could not be read.', 500);
+  }
+  if (!value || value.version !== 1 || typeof value.revision !== 'string' || !value.revision || value.revision.length > 100
+    || typeof value.text !== 'string' || value.text.length > NOTES_LIMIT) {
+    throw notesError('notes_unreadable', 'Notes could not be read.', 500);
+  }
+  return { revision: value.revision, text: value.text };
+}
+
+function writeNotes(file, notes) {
+  const contents = `${JSON.stringify({ version: 1, revision: notes.revision, text: notes.text }, null, 2)}\n`;
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const next = `${file}.${randomUUID()}.tmp`;
+  let descriptor;
+  try {
+    descriptor = fs.openSync(next, 'wx', 0o600);
+    fs.writeFileSync(descriptor, contents);
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = undefined;
+    fs.renameSync(next, file);
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+    try { fs.unlinkSync(next); } catch { /* renamed, or never created */ }
+  }
+  try { fs.chmodSync(file, 0o600); } catch { /* not supported on Windows */ }
+}
+
+/**
+ * @param {string} [file] omit for an in-memory store (tests). The real manager passes its notes file.
+ * @param {{ warn?: (message: string) => void }} [options] where the one line about an unreadable file goes
+ */
+export function createNotesStore(file, { warn = (message) => console.warn(message) } = {}) {
+  let current = { revision: null, text: '' };
+  let loaded = !file;
+  let warned = false;
+
+  /** An unreadable file is read again next time, so fixing or removing it needs no restart. */
+  function ensure() {
+    if (loaded) return;
+    let read;
+    try { read = readNotes(file); } catch (error) {
+      if (!warned) warn(`[notes] ${file} cannot be read, so notes are not shared until it is fixed or removed.`);
+      warned = true;
+      throw error;
+    }
+    warned = false;
+    current = read ?? { revision: null, text: '' };
+    loaded = true;
+  }
+
+  function snapshot() {
+    ensure();
+    return { revision: current.revision, text: current.text };
+  }
+
+  function save(body) {
+    ensure();
+    if (!body || typeof body.text !== 'string') throw notesError('bad_notes', 'Notes must be text.', 400);
+    if (body.text.length > NOTES_LIMIT) {
+      throw notesError('notes_too_long', `Notes hold up to ${NOTES_LIMIT.toLocaleString('en-US')} characters.`, 400);
+    }
+    const revision = body.revision ?? null;
+    if (revision !== null && (typeof revision !== 'string' || !revision || revision.length > 100)) {
+      throw notesError('bad_notes', 'Notes must be text.', 400);
+    }
+    if (revision !== current.revision) {
+      throw notesError('stale_notes', 'Notes changed in another browser.', 409, { revision: current.revision, text: current.text });
+    }
+    const next = { revision: randomUUID(), text: body.text };
+    if (file) writeNotes(file, next);
+    current = next;
+    loaded = true;
+    return { revision: next.revision, text: next.text };
+  }
+
+  return {
+    snapshot,
+    save,
+    /** `{ known: false }` when the file cannot be read, so a client does not treat that as an empty notepad. */
+    helloRevision() {
+      try {
+        return { known: true, revision: snapshot().revision };
+      } catch {
+        return { known: false };
+      }
+    },
+  };
+}

package/src/manager/server.mjs

@@ -12,6 +12,7 @@ import { createViews } from './github-views.mjs';
 import { createFolderOpener } from './folder-opener.mjs';
 import { createFolderBrowser } from './folder-browser.mjs';
 import { normalizeAccess } from './access-policy.mjs';
+import { NOTES_BODY_LIMIT, createNotesStore } from './notes.mjs';
 
 const require = createRequire(import.meta.url);
 const API = '/api/v1';
@@ -63,7 +64,7 @@ class HttpError extends Error {
   }
 }
 
-function readJsonBody(req) {
+function readJsonBody(req, max = MAX_BODY) {
   return new Promise((resolve, reject) => {
     let size = 0;
     const chunks = [];
@@ -71,7 +72,7 @@ function readJsonBody(req) {
     req.on('data', (chunk) => {
       if (tooLarge) return; // drain the rest so the 413 response can be read
       size += chunk.length;
-      if (size > MAX_BODY) {
+      if (size > max) {
         tooLarge = true;
         chunks.length = 0;
         reject(new HttpError(413, 'request body too large', 'too_large'));
@@ -103,6 +104,7 @@ export function createManagerServer({
   modelStats,
   news = null,
   changelog = null,
+  environment = null,
   github = null,
   token,
   host = '127.0.0.1',
@@ -113,6 +115,8 @@ export function createManagerServer({
   extraHosts = [],
   extraOrigins = [],
   remoteAccess = null,
+  /** In-memory when omitted, so a test server never reads the user's notes file. */
+  notes = createNotesStore(),
   folderOpener = createFolderOpener({ resolveCwd: (cwd) => manager.resolveCwd(cwd) }),
   folderBrowser = createFolderBrowser(),
   /** The double-click launcher file for this platform, or null when the package carries none. */
@@ -252,6 +256,15 @@ export function createManagerServer({
 
     requireAuth(req, url);
 
+    if (route === '/notes' && method === 'GET') {
+      return sendJson(res, 200, { notes: notes.snapshot() });
+    }
+    if (route === '/notes' && method === 'PUT') {
+      const saved = notes.save(await readJsonBody(req, NOTES_BODY_LIMIT));
+      broadcast({ type: 'notes.updated', notes: saved });
+      return sendJson(res, 200, { notes: saved });
+    }
+
     if (remoteAccess && route === '/remote-access' && method === 'GET') {
       return sendJson(res, 200, { remoteAccess: remoteAccess.snapshot() });
     }
@@ -295,6 +308,14 @@ export function createManagerServer({
       const session = await manager.upgrade();
       return sendJson(res, 201, { session: session.toJSON() });
     }
+    if (route === '/environment' && method === 'GET' && environment) {
+      if (!environment.snapshot().checkedAt) environment.refresh();
+      return sendJson(res, 200, environment.snapshot());
+    }
+    if (route === '/environment/refresh' && method === 'POST' && environment) {
+      await readJsonBody(req);
+      return sendJson(res, 202, environment.refresh());
+    }
     if (route === '/providers' && method === 'GET') {
       registry.refreshVersions().catch(() => {});
       return sendJson(res, 200, { providers: registry.list() });
@@ -486,12 +507,13 @@ export function createManagerServer({
       else serveStatic(req, res, url.pathname);
     } catch (err) {
       const status = err.status || 500;
-      if (status >= 500) console.error('[server]', err);
+      if (status >= 500 && !err.logged) console.error('[server]', err);
       if (!res.headersSent) {
         const error = { code: err.code || 'error', message: err.message };
         if (err.running !== undefined) error.running = err.running;
         if (err.pending !== undefined) error.pending = err.pending;
         if (err.target !== undefined) error.target = err.target;
+        if (err.notes !== undefined) error.notes = err.notes;
         sendJson(res, status, { error });
       }
     }
@@ -531,6 +553,8 @@ export function createManagerServer({
   }
   manager.on('event', broadcast);
   registry.on('updated', () => broadcast({ type: 'providers.updated', providers: registry.list() }));
+  const environmentUpdated = () => broadcast({ type: 'environment.updated', environment: environment.snapshot() });
+  environment?.on('updated', environmentUpdated);
   selfUpdate?.on('updated', () => broadcast({ type: 'manager.upgrade', upgrade: upgradeInfo() }));
   news?.on('updated', () => broadcast({ type: 'news.updated' }));
   changelog?.on('updated', () => broadcast({ type: 'changelog.updated' }));
@@ -539,7 +563,11 @@ export function createManagerServer({
 
   function handleEvents(ws, req) {
     eventClients.add(ws);
-    safeSend(ws, { type: 'hello', version, pid: process.pid, platform: process.platform, startedAt, launcher, folderOpener: folderOpenerFor(req), remoteAccess: remoteAccess ? { available: true } : null, upgrade: upgradeInfo(), sessions: manager.list() });
+    const hello = { type: 'hello', version, pid: process.pid, platform: process.platform, startedAt, launcher, folderOpener: folderOpenerFor(req), remoteAccess: remoteAccess ? { available: true } : null, upgrade: upgradeInfo(), sessions: manager.list() };
+    const notesHello = notes.helloRevision();
+    if (notesHello.known) hello.notesRevision = notesHello.revision;
+    else hello.notesUnreadable = true;
+    safeSend(ws, hello);
     ws.on('close', () => eventClients.delete(ws));
     ws.on('message', () => { /* events socket is server -> client only */ });
   }
@@ -633,6 +661,7 @@ export function createManagerServer({
     },
     /** @param {{ notice?: object }} [opts] a final event for the events clients */
     async close({ notice } = {}) {
+      environment?.off('updated', environmentUpdated);
       if (notice) await farewell(notice);
       clearInterval(heartbeat);
       for (const ws of wss.clients) ws.terminate();

package/web/app.js

@@ -8,6 +8,7 @@ import { topbarInline, dockMode, clampDockWidth, stageBesideDock, splitMode, cla
 import { highlightParts, rankRepos, recentFirst, remember, repoForOrigin, repoKey } from './repo-search.js';
 import { createActivityFavicon, isSessionWorking } from './activity-favicon.js';
 import { createRemoteAccessUI } from './remote-access.js';
+import { createEnvironmentUI } from './environment.js';
 import { matchFolders, readRecentFolders, rememberFolder } from './folders.js';
 
 const TOKEN_KEY = 'agentGuild.token';
@@ -31,6 +32,7 @@ const SESSION_ORDER_KEY = 'agentGuild.sessionOrder';
 const SOUND_KEY = 'agentGuild.sound';
 const VOICE_KEY = 'agentGuild.voice';
 const NOTES_KEY = 'agentGuild.notes';
+const NOTES_REV_KEY = 'agentGuild.notesRevision';
 const DOCK_KEY = 'agentGuild.dock';
 const DOCK_WIDTH_KEY = 'agentGuild.dockWidth';
 const PANES_KEY = 'agentGuild.panes';
@@ -366,35 +368,63 @@ function moveInMenu(e) {
 /** Notes share the page's storage with every other setting, so they stay far below the browser's limit for it. */
 const NOTES_LIMIT = 100000;
 const NOTES_STATUS = {
-  saved: 'Saved in this browser as you type',
+  saved: 'Saved and synced across your browsers',
+  local: 'Saved in this browser only. Syncs when the manager is back.',
+  damaged: 'Not syncing: the manager’s notes file is damaged. Saved in this browser only.',
   long: `Not saved: notes hold up to ${NOTES_LIMIT.toLocaleString('en-US')} characters. Shorten them to save.`,
   refused: 'Not saved: the browser’s storage for this page is full or turned off. Copy what you need before you close the page.',
 };
+/** How long a burst of typing waits before one save to the manager. */
+const NOTES_PUSH_MS = 400;
+/** Browsers drop a keepalive request larger than 64 KiB, so a bigger notepad waits for the next open. */
+const NOTES_KEEPALIVE_BYTES = 60 * 1024;
 /**
  * `saved`: the notes as this page last read or wrote them in storage. `status`: whether the text in the
- * panel is saved, too `long` or `refused`; `shown`: the status the line under the title shows.
+ * panel is saved, too `long` or `refused`; `sync`: whether the manager has it (`ok`), could not be reached
+ * (`local`) or cannot read its notes file (`damaged`); `shown`: the status the line under the title shows.
+ * `base`: the manager revision this page last saved from. `acked`: the text of that revision.
+ * `flight`: the save to the manager under way. Text typed meanwhile is sent when it finishes.
  */
-const notesView = { saved: '', status: 'saved', shown: 'saved' };
+const notesView = { saved: '', status: 'saved', sync: 'ok', shown: 'saved', base: null, acked: null, timer: 0, flight: null };
 
 /** Shows notes another tab saved since this page last read or wrote them. Saved notes win over text this page could not save. */
 function refreshNotes() {
   let text;
   // Unlike load(), a read that fails is not taken for empty notes.
   try { text = localStorage.getItem(NOTES_KEY) ?? ''; } catch { return; }
-  if (text === notesView.saved) return;
-  notesView.saved = text;
-  notesView.status = 'saved';
-  $('notes-text').value = text;
+  const revision = load(NOTES_REV_KEY);
+  if (text === notesView.saved && revision === notesView.base) return;
+  if (text !== notesView.saved) {
+    notesView.saved = text;
+    notesView.status = 'saved';
+    $('notes-text').value = text;
+  }
+  // The revision is kept only while the stored text is the one it names, so that text is on the manager.
+  if (revision) notesView.acked = text;
+  if (revision !== notesView.base) notesView.base = revision;
   renderNotesStatus();
   guardLeaving();
 }
 
-/** Saves the notes on every change; emptying them removes the saved copy. */
+/** Saves the notes on every change; emptying them removes the saved copy. This stays in the browser. */
 function saveNotes() {
   const text = $('notes-text').value;
-  if (text.length > NOTES_LIMIT) notesView.status = 'long';
-  else if (!save(NOTES_KEY, text || null)) notesView.status = 'refused';
-  else {
+  if (text.length > NOTES_LIMIT) {
+    notesView.status = 'long';
+    renderNotesStatus();
+    guardLeaving();
+    return;
+  }
+  // A reload can tell these keystrokes have not reached the manager: the stored revision goes first, so
+  // stored text never sits beside a revision it does not match. The revision in memory stays, for the save.
+  // An empty panel is probed with the same text, and that must not look like a new edit.
+  const revision = text !== notesView.saved ? load(NOTES_REV_KEY) : null;
+  if (revision) save(NOTES_REV_KEY, null);
+  if (!save(NOTES_KEY, text || null)) {
+    // The stored text did not change, so it still matches its revision.
+    if (revision) save(NOTES_REV_KEY, revision);
+    notesView.status = 'refused';
+  } else {
     notesView.status = 'saved';
     notesView.saved = text;
   }
@@ -404,16 +434,30 @@ function saveNotes() {
 
 /** The line under the title is a live region, so it is rewritten only when the status changes. */
 function renderNotesStatus() {
-  if (notesView.shown === notesView.status) return;
-  notesView.shown = notesView.status;
+  // A problem saving in this browser outranks one reaching the manager.
+  const shown = notesView.status === 'saved' && notesView.sync !== 'ok' ? notesView.sync : notesView.status;
+  if (notesView.shown === shown) return;
+  notesView.shown = shown;
   const sub = $('notes-sub');
-  sub.textContent = NOTES_STATUS[notesView.status];
-  sub.classList.toggle('warn', notesView.status !== 'saved');
+  sub.textContent = NOTES_STATUS[shown];
+  sub.classList.toggle('warn', shown !== 'saved');
+}
+
+/** Whether the manager has the notes. Typing never changes this, so the line does not flicker. */
+function setNotesSync(sync) {
+  if (notesView.sync === sync) return;
+  notesView.sync = sync;
+  renderNotesStatus();
+}
+
+/** A save or read that failed. A file the manager cannot read is reported as such; anything else is unreachable. */
+function notesFailed(error) {
+  setNotesSync(error?.code === 'notes_unreadable' ? 'damaged' : 'local');
 }
 
 /** Another tab saved the notes, or cleared this page's storage. */
 function notesStored(e) {
-  if (e.key === NOTES_KEY || e.key === null) refreshNotes();
+  if (e.key === NOTES_KEY || e.key === NOTES_REV_KEY || e.key === null) refreshNotes();
 }
 
 function openNotes({ focus = true } = {}) {
@@ -430,6 +474,181 @@ function toggleNotes() {
   else openNotes();
 }
 
+function sharedPrefix(left, right) {
+  const end = Math.min(left.length, right.length);
+  let i = 0;
+  while (i < end && left.charCodeAt(i) === right.charCodeAt(i)) i += 1;
+  return i;
+}
+
+/** Takes the manager's notes. A selection that still sits in the unchanged prefix stays put. */
+function adoptNotes(notes) {
+  const area = $('notes-text');
+  const next = notes.text;
+  if (typeof next !== 'string') return;
+  if (next !== area.value) {
+    const start = area.selectionStart;
+    const end = area.selectionEnd;
+    const previous = area.value;
+    const focused = document.activeElement === area;
+    area.value = next;
+    if (focused) {
+      const keep = sharedPrefix(previous, next);
+      if (start <= keep && end <= keep) area.setSelectionRange(start, end);
+    }
+  }
+  notesView.saved = next;
+  notesView.acked = next;
+  notesView.base = notes.revision ?? null;
+  notesView.status = 'saved';
+  notesView.sync = 'ok';
+  // Revision last, and only over text that was stored: a stored revision always names the stored text.
+  save(NOTES_REV_KEY, null);
+  if (save(NOTES_KEY, next || null)) save(NOTES_REV_KEY, notes.revision || null);
+  renderNotesStatus();
+  guardLeaving();
+}
+
+function notesPushable() {
+  const text = $('notes-text').value;
+  if (notesView.status !== 'saved' || text.length > NOTES_LIMIT) return false;
+  if (text === notesView.acked) return false;
+  if (notesView.base == null && text === '') return false;
+  return true;
+}
+
+function scheduleNotesPush(delay = NOTES_PUSH_MS) {
+  clearTimeout(notesView.timer);
+  notesView.timer = 0;
+  if (!notesPushable()) return Promise.resolve();
+  if (delay === 0) return pushNotes();
+  notesView.timer = setTimeout(() => { notesView.timer = 0; void pushNotes(); }, delay);
+  return Promise.resolve();
+}
+
+/** The page is being hidden or closed: send what the debounce still holds. */
+function flushNotes() {
+  void scheduleNotesPush(0);
+}
+
+/**
+ * One save to the manager at a time, so two of this page's own saves can never race each other. Text typed
+ * while a save is under way follows it. A conflict sends this page's text once more at the manager's revision:
+ * the latest typing wins, and the text on screen is never replaced by an older copy.
+ */
+function pushNotes() {
+  // The save under way checks for newer text when it finishes.
+  if (notesView.flight) return notesView.flight;
+  const run = (async () => {
+    let resent = false;
+    for (;;) {
+      if (!notesPushable()) return;
+      const outcome = await sendNotes($('notes-text').value);
+      if (outcome === 'stale' && !resent) resent = true;
+      else if (outcome !== 'ok') return;
+    }
+  })();
+  notesView.flight = run;
+  return run.finally(() => { notesView.flight = null; });
+}
+
+/** @returns {Promise<'ok'|'stale'|'failed'>} `stale`: the manager moved on, and `base` now names its revision. */
+async function sendNotes(text) {
+  const body = { revision: notesView.base, text };
+  // A hidden page may be closing: keepalive lets the save outlive it, for bodies the browser allows.
+  const keepalive = document.visibilityState === 'hidden'
+    && new TextEncoder().encode(JSON.stringify(body)).length <= NOTES_KEEPALIVE_BYTES;
+  let payload;
+  try {
+    payload = (await api('PUT', '/notes', body, { keepalive })).notes;
+  } catch (error) {
+    if (error instanceof AuthError) {
+      showAuth(error.message);
+      return 'failed';
+    }
+    if (error.code !== 'stale_notes' || !error.notes || typeof error.notes.text !== 'string') {
+      notesFailed(error);
+      return 'failed';
+    }
+    // The manager already holds exactly this text, saved by another tab or an earlier request.
+    if (error.notes.text === $('notes-text').value) {
+      adoptNotes(error.notes);
+      return 'ok';
+    }
+    notesView.base = error.notes.revision ?? null;
+    return 'stale';
+  }
+  if (!payload || typeof payload.text !== 'string') {
+    notesFailed();
+    return 'failed';
+  }
+  if ($('notes-text').value === text) adoptNotes(payload);
+  else {
+    // Typing went on during the save: the newer text follows from this revision.
+    notesView.base = payload.revision ?? notesView.base;
+    setNotesSync('ok');
+  }
+  return 'ok';
+}
+
+/** Another browser's save. Our own echo matches the text already on screen and only adopts the revision. */
+function applyServerNotes(notes) {
+  if (!notes || typeof notes.text !== 'string') return;
+  const area = $('notes-text');
+  if (notes.text === area.value) {
+    adoptNotes(notes);
+    return;
+  }
+  if (notesView.acked !== null && area.value !== notesView.acked) {
+    notesView.base = notes.revision ?? notesView.base;
+    return;
+  }
+  adoptNotes(notes);
+}
+
+/** The notes part of hello. A missing revision means this manager cannot share notes. */
+async function catchUpNotes(revision, unreadable) {
+  if (unreadable) {
+    setNotesSync('damaged');
+    return;
+  }
+  if (revision === undefined) return;
+  // Hello can arrive before the first read. Load this browser's copy before deciding, unless typing has started.
+  if (notesView.saved === '' && $('notes-text').value === '' && notesView.acked === null) refreshNotes();
+  const local = $('notes-text').value;
+  // No file yet, or it was removed. Text this browser has is the first copy. An empty panel writes nothing.
+  if (revision === null) notesView.acked = local ? null : '';
+  if (revision === null || revision === notesView.base) {
+    if (notesPushable()) await scheduleNotesPush(0);
+    else setNotesSync('ok');
+    return;
+  }
+  await pullNotes();
+}
+
+/** The manager moved on while this page was away. Its copy wins unless this browser has edits it never sent. */
+async function pullNotes() {
+  let notes;
+  try {
+    notes = (await api('GET', '/notes')).notes;
+  } catch (error) {
+    if (error instanceof AuthError) showAuth(error.message);
+    else notesFailed(error);
+    return;
+  }
+  if (!notes || typeof notes.text !== 'string') return;
+  const local = $('notes-text').value;
+  // `acked` is unknown only when this browser holds text no revision names: an edit that never reached the manager.
+  const unsent = local !== notes.text && (notesView.acked === null ? local !== '' : local !== notesView.acked);
+  if (!unsent) {
+    adoptNotes(notes);
+    return;
+  }
+  notesView.base = notes.revision ?? null;
+  setNotesSync('ok');
+  await scheduleNotesPush(0);
+}
+
 // ---- dock -----------------------------------------------------------------
 
 const DOCK_PANELS = ['github', 'notes'];
@@ -717,9 +936,10 @@ function renderAgents(container, agents, shells = []) {
 
 class AuthError extends Error {}
 
-async function api(method, path, body) {
+async function api(method, path, body, options = {}) {
   const res = await fetch(`/api/v1${path}`, {
     method,
+    keepalive: options.keepalive === true,
     headers: {
       Authorization: `Bearer ${state.token}`,
       ...(body ? { 'Content-Type': 'application/json' } : {}),
@@ -1173,6 +1393,7 @@ function renderProviders() {
     renderVendorLinks(node, provider);
     renderAccounts(node, provider);
     renderShells(node, provider);
+    state.environmentUI?.renderCard(node, provider);
     renderMultiplexers(node, provider);
     renderUsage(node, provider);
     renderReportingSetup(node, provider);
@@ -5160,6 +5381,7 @@ function connectEvents() {
       state.sessions = new Map(msg.sessions.map((s) => [s.id, s]));
       for (const id of [...state.views.keys()]) if (!state.sessions.has(id)) dropSession(id);
       managerConnected(msg);
+      state.environmentUI?.connected(msg.pid);
       renderSessions();
       if (!sessionsShown && load(DOCK_KEY) === 'github' && !dockView.panel) openGitHub({ focus: false });
       restorePanes();
@@ -5169,6 +5391,11 @@ function connectEvents() {
       // A changelog.updated sent while the socket was down is lost; catch up the open panel.
       if ($('changelog').open) loadChangelog();
       if (dockShows('github')) loadGitHub();
+      catchUpNotes(msg.notesRevision, msg.notesUnreadable === true);
+    } else if (msg.type === 'notes.updated') {
+      applyServerNotes(msg.notes);
+    } else if (msg.type === 'environment.updated') {
+      state.environmentUI?.updated(msg.environment);
     } else if (msg.type === 'remote-access.updated') {
       state.remoteAccessUI?.updated();
     } else if (msg.type === 'news.updated') {
@@ -5199,6 +5426,7 @@ function connectEvents() {
   };
   ws.onclose = (event) => {
     if (state.pageAway || state.eventsSocket !== ws) return;
+    state.environmentUI?.disconnected();
     if (event?.code === 4403) {
       state.remoteRevoked = true;
       managerLoss.cancel();
@@ -5247,6 +5475,7 @@ let statsInterval;
 let newsTimer;
 
 function showAuth(message = '') {
+  state.environmentUI?.close();
   state.remoteAccessUI?.setAvailable(null);
   managerLoss.cancel();
   closePanel();
@@ -5457,7 +5686,7 @@ document.addEventListener('keydown', (e) => {
 addEventListener('scroll', () => { if (tipFor) hideTip(); }, true);
 addEventListener('resize', () => { if (tipFor) hideTip(); });
 $('notes-open').addEventListener('click', firstClick(toggleNotes));
-$('notes-text').addEventListener('input', saveNotes);
+$('notes-text').addEventListener('input', () => { saveNotes(); void scheduleNotesPush(); });
 addEventListener('storage', notesStored);
 // On load, and again for a page back from the back/forward cache, which may have missed another tab's notes.
 addEventListener('pageshow', refreshNotes);
@@ -5474,12 +5703,16 @@ $('news').addEventListener('close', () => {
   newsView.opener = null;
 });
 document.addEventListener('visibilitychange', () => {
-  if (document.visibilityState !== 'visible') stopDictation();
+  if (document.visibilityState !== 'visible') {
+    stopDictation();
+    flushNotes();
+  }
   if (document.visibilityState === 'visible' && state.connected && Date.now() - newsLoadedAt > 60000) loadNews();
   if (document.visibilityState === 'visible' && dockShows('github') && githubShownView() === 'actions') loadView('actions');
   else scheduleRuns();
 });
 addEventListener('pagehide', () => {
+  flushNotes();
   state.pageAway = true;
   activityFavicon.setPaused(true);
   terminalCopy.close();
@@ -5698,5 +5931,6 @@ publishTopbarHeight();
 applyDockLayout();
 
 state.remoteAccessUI = createRemoteAccessUI({ api, getToken: () => state.token, isConnected: () => state.connected, onAuthError: showAuth });
+state.environmentUI = createEnvironmentUI({ api, onAuthError: showAuth, isAuthError: (err) => err instanceof AuthError });
 state.token = readTokenFromHash() || load(TOKEN_KEY);
 boot();

package/web/environment.js

@@ -0,0 +1,125 @@
+const STATES = { pending: 'Not checked', not_found: 'Not found', unavailable: 'Runtime unavailable', failed: 'Probe failed' };
+
+export function runtimeValue(row) { return row.status === 'ok' ? row.version : STATES[row.status] || 'Probe failed'; }
+
+export function createEnvironmentUI({ api, onAuthError, isAuthError = () => false, document = globalThis.document }) {
+  const $ = (id) => document.getElementById(id);
+  const dialog = $('environment');
+  let data = null, request = 0, pending = false, online = false, managerPid = null, error = '', openerId = null;
+  const element = (tag, text, className) => {
+    const node = document.createElement(tag);
+    if (text !== undefined) node.textContent = text;
+    if (className) node.className = className;
+    return node;
+  };
+
+  function renderSummary(host) {
+    const values = host.querySelector('.environment-values');
+    const found = (data?.runtimes || []).filter((row) => row.status === 'ok');
+    values.replaceChildren(...found.flatMap((row) => [element('dt', row.label), element('dd', row.version)]));
+    const note = host.querySelector('.environment-note');
+    note.textContent = error ? 'Environment check unavailable'
+      : data?.refreshing ? data.checkedAt ? 'Refreshing · showing previous check' : 'Checking environment…'
+        : data?.error ? 'Some checks could not finish'
+          : !data ? 'Not checked' : !found.length ? 'No runtime versions verified' : 'Manager environment';
+  }
+
+  function rowElement(row) {
+    const node = element('section', undefined, 'environment-row');
+    const head = element('div', undefined, 'environment-row-head');
+    head.append(element('strong', row.label), element('span', runtimeValue(row)));
+    node.append(head);
+    if (row.command) node.append(element('p', `Command: ${row.command}`, 'environment-detail'));
+    if (row.path) node.append(element('code', row.path, 'environment-path'));
+    const detail = row.detail || (row.status === 'not_found' ? 'No executable was found on the manager’s PATH.' : '');
+    if (detail) node.append(element('p', detail, 'environment-detail'));
+    for (const alternate of row.alternatives || []) {
+      node.append(element('p', `Also found: ${alternate.command} · ${runtimeValue(alternate)}`, 'environment-detail'));
+      node.append(element('code', alternate.path, 'environment-path'));
+      if (alternate.detail) node.append(element('p', alternate.detail, 'environment-detail'));
+    }
+    for (const runtime of row.runtimes || []) node.append(element('p', `${runtime.name} ${runtime.version}`, 'environment-detail'));
+    return node;
+  }
+
+  function render() {
+    for (const host of document.querySelectorAll('.environment-summary:not([hidden])')) renderSummary(host);
+    $('environment-refresh').disabled = !online || pending || Boolean(data?.refreshing);
+    $('environment-refresh').textContent = pending || data?.refreshing ? 'Checking…' : 'Refresh';
+    $('environment-status').textContent = error || (data?.refreshing
+      ? data.checkedAt ? 'Refreshing. Previous results remain visible.' : 'Checking the manager environment…'
+      : data?.error || (data?.checkedAt ? `Last checked ${new Date(data.checkedAt).toLocaleString()}` : 'Not checked yet.'));
+    $('environment-runtimes').replaceChildren(...(data?.runtimes || []).map(rowElement));
+    const tools = data?.tools || [];
+    $('environment-tools').replaceChildren(...tools.map((tool) => {
+      const node = element('section', undefined, 'environment-row');
+      node.append(element('strong', `${tool.label} · Detected`), element('code', tool.path, 'environment-path'));
+      return node;
+    }));
+    $('environment-tools-empty').hidden = Boolean(tools.length);
+    $('environment-tools-empty').textContent = data?.refreshing ? 'Checking…' : data?.error ? 'Tool discovery did not finish.' : 'No supported tools detected.';
+    $('environment-manager-node').textContent = data?.managerNode
+      ? `Agent Guild is running on Node.js ${data.managerNode.version} (${data.managerNode.path}).` : '';
+  }
+
+  function updated(snapshot) {
+    if (!online || !snapshot || snapshot.scope !== 'manager') return;
+    if (data && snapshot.revision < data.revision) return;
+    data = snapshot;
+    error = '';
+    render();
+  }
+
+  async function load(refresh = false) {
+    if (!online || pending) return;
+    const current = ++request;
+    pending = true;
+    error = '';
+    render();
+    try {
+      const snapshot = await api(refresh ? 'POST' : 'GET', refresh ? '/environment/refresh' : '/environment', refresh ? {} : undefined);
+      if (current === request) updated(snapshot);
+    } catch (err) {
+      if (current !== request) return;
+      if (isAuthError(err)) onAuthError?.(err.message);
+      else error = 'Could not read the manager environment. Try Refresh.';
+    } finally {
+      if (current === request) { pending = false; render(); }
+    }
+  }
+
+  $('environment-close').addEventListener('click', () => dialog.close());
+  $('environment-refresh').addEventListener('click', () => load(true));
+  dialog.addEventListener('click', (event) => { if (event.target === dialog) dialog.close(); });
+  dialog.addEventListener('close', () => {
+    if (openerId) document.querySelector(`.provider[data-id="${openerId}"] .environment-open`)?.focus();
+    openerId = null;
+  });
+  return {
+    updated,
+    connected(pid) {
+      if (pid !== managerPid) { data = null; managerPid = pid; }
+      request++; pending = false; online = true;
+      load();
+    },
+    disconnected() {
+      request++; pending = false; online = false;
+      error = 'Disconnected. Results are from the last check.';
+      render();
+    },
+    close() { openerId = null; dialog.close(); this.disconnected(); },
+    renderCard(card, provider) {
+      const host = card.querySelector('.environment-summary');
+      host.hidden = !Array.isArray(provider.shells);
+      if (host.hidden) return;
+      const button = host.querySelector('.environment-open');
+      button.dataset.muxFocus = `${provider.id}:environment`;
+      button.addEventListener('click', () => {
+        openerId = provider.id;
+        render();
+        if (!dialog.open) dialog.showModal();
+      });
+      renderSummary(host);
+    },
+  };
+}

package/web/index.html

@@ -258,7 +258,7 @@
       </div>
     </section>
     <section id="notes" class="dock-panel notes-panel" role="tabpanel" aria-labelledby="notes-title" hidden>
-      <p id="notes-sub" class="dock-sub sub" aria-live="polite">Saved in this browser as you type</p>
+      <p id="notes-sub" class="dock-sub sub" aria-live="polite">Saved and synced across your browsers</p>
       <div class="dock-body">
         <textarea id="notes-text" class="notes-text" aria-labelledby="notes-title" aria-describedby="notes-sub" autocomplete="off" placeholder="Prompts, commands, to-dos: anything you want to keep at hand"></textarea>
       </div>
@@ -344,6 +344,28 @@
     </div>
   </dialog>
 
+  <dialog id="environment" class="models environment-dialog" aria-labelledby="environment-title">
+    <div class="models-bar">
+      <div class="models-heading">
+        <h2 id="environment-title">Manager environment</h2>
+        <p class="sub">On the computer running Agent Guild</p>
+      </div>
+      <button id="environment-close" class="btn" type="button">Close</button>
+    </div>
+    <div class="models-body">
+      <p class="environment-detail">Versions available to the manager. Shell profiles, projects and existing sessions can use different versions.</p>
+      <p class="environment-detail">Python uses <code>python</code> when found, otherwise <code>python3</code>. A failed <code>python</code> check stays primary.</p>
+      <p id="environment-status" class="environment-detail" role="status"></p>
+      <button id="environment-refresh" class="btn" type="button">Refresh</button>
+      <div id="environment-runtimes"></div>
+      <h3>Detected tools</h3>
+      <p class="environment-detail">Presence only. Activation and the runtimes these tools manage are not checked.</p>
+      <div id="environment-tools"></div>
+      <p id="environment-tools-empty" class="environment-detail"></p>
+      <p id="environment-manager-node" class="environment-detail"></p>
+    </div>
+  </dialog>
+
   <dialog id="models" class="models" aria-labelledby="models-title">
     <div class="models-bar">
       <span id="models-icon" class="provider-icon small"></span>
@@ -475,6 +497,11 @@
       </div>
       <div class="accounts" role="tablist" aria-label="Accounts" hidden></div>
       <div class="shells" role="tablist" aria-label="Shells" hidden></div>
+      <div class="environment-summary" hidden>
+        <button class="environment-open" type="button" aria-haspopup="dialog">Environment details</button>
+        <dl class="environment-values"></dl>
+        <p class="environment-note"></p>
+      </div>
       <div class="usage"></div>
       <div class="model-stats"></div>
       <div class="reporting-row" hidden>

package/web/styles.css

@@ -152,6 +152,20 @@ main { max-width: calc(1200px + var(--dock-space, 0px)); margin: 0 auto; padding
 .account-chip.unsigned { border-style: dashed; }
 .provider .usage { display: grid; gap: 4px; }
 .provider .usage:empty { display: none; }
+.environment-summary { min-width: 0; font-size: .78rem; }
+.environment-open { padding: 0; border: 0; background: none; color: var(--accent); font: inherit; cursor: pointer; text-align: left; }
+.environment-open:hover { text-decoration: underline; }
+.environment-open:focus-visible { outline: 2px solid var(--focus); outline-offset: 3px; border-radius: 2px; }
+.environment-values { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: 3px 10px; margin: 6px 0; }
+.environment-values:empty { display: none; }
+.environment-values dt { color: var(--muted); }
+.environment-values dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
+.environment-note { margin: 4px 0 0; color: var(--muted); font-size: .72rem; }
+.environment-detail { font-size: .85rem; line-height: 1.5; color: var(--muted); overflow-wrap: anywhere; }
+.environment-row { padding: 12px 0; border-bottom: 1px solid var(--border); }
+.environment-row-head { display: flex; flex-wrap: wrap; justify-content: space-between; gap: 6px 14px; font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
+.environment-row p { margin: 5px 0; }
+.environment-path { display: block; margin-top: 5px; font-size: .8rem; overflow-wrap: anywhere; }
 .meter { display: grid; grid-template-columns: 5.5em 1fr auto; align-items: center; gap: 8px; font-size: 0.75rem; color: var(--muted); }
 .meter-label { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .meter-bar { height: 6px; border-radius: 3px; background: var(--surface-2); overflow: hidden; }
@@ -743,6 +757,8 @@ a.news-link:visited { color: var(--muted); }
 }
 .notes-text:focus-visible { outline: 2px solid var(--focus); outline-offset: 1px; }
 .notes-panel .sub.warn { color: var(--warn); }
+/* Room below the status line for the field's focus ring, and for a warning that wraps to two lines. */
+.notes-panel .dock-sub { flex-shrink: 0; padding-bottom: 8px; line-height: 1.4; }
 @media (pointer: coarse) {
   /* iOS zooms in on a field with smaller text when it takes focus. */
   .notes-text { font-size: 16px; }