@oddessentials/agent-guild 0.30.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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "0.30.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/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';
@@ -46,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
@@ -98,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();
@@ -124,6 +127,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   api = createManagerServer({
     manager,
     registry,
+    environment,
     usage,
     history,
     modelStats,

package/src/manager/server.mjs

@@ -104,6 +104,7 @@ export function createManagerServer({
   modelStats,
   news = null,
   changelog = null,
+  environment = null,
   github = null,
   token,
   host = '127.0.0.1',
@@ -307,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() });
@@ -544,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' }));
@@ -650,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';
@@ -1392,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);
@@ -5379,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();
@@ -5391,6 +5394,8 @@ function connectEvents() {
       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') {
@@ -5421,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();
@@ -5469,6 +5475,7 @@ let statsInterval;
 let newsTimer;
 
 function showAuth(message = '') {
+  state.environmentUI?.close();
   state.remoteAccessUI?.setAvailable(null);
   managerLoss.cancel();
   closePanel();
@@ -5924,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

@@ -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; }