@oddessentials/agent-guild 0.30.0 → 0.32.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
@@ -171,8 +195,11 @@ of them from the box at its top; it starts on the repository the focused
 terminal's folder is a clone of. **Issues** lists, opens, edits and closes
 issues. **Actions** shows the latest workflow runs and whether one is still
 going, refreshing while it is on screen. **Pull requests** lists the open
-ones. **Repositories** lists and creates repositories and clones them over SSH
-with a key Agent Guild keeps for each account. On a wide window the side panel
+ones. **Branches** lists every remote branch of the selected repository, with
+its default and protected branches marked. Filter by name, copy a branch name,
+or open it on GitHub. Larger lists load progressively; **Refresh** checks for
+changes while keeping your place in the list. **Repositories** lists and creates
+repositories and clones them over SSH with a key Agent Guild keeps for each account. On a wide window the side panel
 makes room for itself; on a smaller one it lies over the cards, and over the
 terminals when they would get too narrow. Drag its edge to resize it. Escape
 or **Close** puts it away.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "0.30.0",
+  "version": "0.32.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/github-views.mjs

@@ -1,4 +1,4 @@
-// Issues, Actions runs and open pull requests of one repository, read with a
+// Branches, Issues, Actions runs and open pull requests of one repository, read with a
 // signed-in account. Reading and editing stay shallow: GitHub's page is the full view.
 
 import { nextLink, parseRepo } from './github.mjs';
@@ -114,6 +114,42 @@ export function createViews(github) {
   }
 
   return {
+    async branches(accountId, owner, name, { page = '1' } = {}) {
+      if (!/^[1-9]\d*$/.test(String(page)) || !Number.isSafeInteger(Number(page))) {
+        throw refusal(400, 'bad_page', 'page must be a positive integer');
+      }
+      page = Number(page);
+      // One metadata read per listing, never a protection request per branch.
+      const [listing, metadata] = await Promise.all([
+        call(accountId, owner, name, `/branches?per_page=100&page=${page}`),
+        page === 1 ? call(accountId, owner, name, '').then(({ body }) => ({ body }), (error) => ({ error: error.message })) : null,
+      ]);
+      const { body, res, repo } = listing;
+      if (!Array.isArray(body)) throw refusal(502, 'github_error', 'GitHub did not return a branch list');
+      let nextPage = null;
+      const next = nextLink(res.headers.get('link'));
+      if (next) {
+        // Reconstruct our own route; never send credentials to a supplied Link URL.
+        try { nextPage = Number(new URL(next).searchParams.get('page')); } catch { /* rejected below */ }
+        if (!Number.isSafeInteger(nextPage) || nextPage <= page) {
+          throw refusal(502, 'github_error', 'GitHub returned an invalid next page for branches');
+        }
+      }
+      const branches = body.filter((item) => typeof item?.name === 'string' && item.name.length > 0).map((item) => ({
+        name: item.name,
+        sha: typeof item.commit?.sha === 'string' && /^[a-f0-9]{40,64}$/i.test(item.commit.sha) ? item.commit.sha : null,
+        protected: item.protected === true,
+        url: `${WEB}/${repo.fullName}/tree/${encodeURIComponent(item.name)}`,
+      }));
+      return {
+        branches, nextPage,
+        defaultBranch: typeof metadata?.body?.default_branch === 'string' ? metadata.body.default_branch : null,
+        metadataError: metadata?.error ?? null,
+        fetchedAt: new Date().toISOString(),
+        url: `${WEB}/${repo.fullName}/branches`,
+      };
+    },
+
     async issues(accountId, owner, name, { state = 'open' } = {}) {
       if (state !== 'open' && state !== 'closed' && state !== 'all') throw refusal(400, 'bad_state', 'state must be open, closed or all');
       const { body, res, repo } = await call(accountId, owner, name, `/issues?state=${state}&per_page=${PAGE}&sort=updated&direction=desc`);

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() });
@@ -449,7 +458,7 @@ export function createManagerServer({
       const folder = manager.resolveCwd(url.searchParams.get('cwd'));
       return sendJson(res, 200, { folder, repo: folderOrigin(folder) });
     }
-    const view = route.match(/^\/github\/accounts\/([^/]+)\/repos\/([^/]+)\/([^/]+)\/(issues|actions|pulls)(?:\/([^/]+))?$/);
+    const view = route.match(/^\/github\/accounts\/([^/]+)\/repos\/([^/]+)\/([^/]+)\/(issues|actions|pulls|branches)(?:\/([^/]+))?$/);
     if (view) {
       let parts;
       try { parts = view.map((part) => (part === undefined ? part : decodeURIComponent(part))); } catch { throw new HttpError(400, 'repo must be a GitHub repository written as owner/name', 'bad_repo'); }
@@ -463,6 +472,7 @@ export function createManagerServer({
       if (kind === 'issues' && number !== undefined && method === 'PATCH') {
         return sendJson(res, 200, { issue: await views.updateIssue(id, owner, name, number, await readJsonBody(req)) });
       }
+      if (kind === 'branches' && number === undefined && method === 'GET') return sendJson(res, 200, await views.branches(id, owner, name, { page: url.searchParams.get('page') ?? '1' }));
       if (kind === 'actions' && number === undefined && method === 'GET') return sendJson(res, 200, await views.actions(id, owner, name));
       if (kind === 'pulls' && number === undefined && method === 'GET') return sendJson(res, 200, await views.pulls(id, owner, name));
     }
@@ -544,6 +554,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 +662,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);
@@ -2965,6 +2967,13 @@ function loadGitHub() {
 function setGitHub(github) {
   const before = state.github?.signIn;
   state.github = github;
+  const branches = githubPick.data.branches;
+  if (branches && !github.accounts.some((a) => a.id === branches.repo.accountId && !a.needsSignIn)) {
+    // Replace the generation even while the dock is closed; signing in again must
+    // never make an earlier account's pending answer current.
+    githubPick.data.branches = { ...branches, value: null, loading: false, nextPage: null,
+      error: `Sign in as @${branches.repo.login} in Repositories to see its branches.` };
+  }
   const done = github.signIn?.status === 'done' && before?.status === 'pending' ? github.signIn : null;
   if (done) {
     selectGitHubAccount(done.accountId);
@@ -3084,7 +3093,7 @@ function openGitHub({ focus = true } = {}) {
   loadGitHub();
   if (githubPick.repo) {
     loadView('actions');
-    if (githubShownView() === 'issues' || githubShownView() === 'pulls') loadView(githubShownView());
+    if (['issues', 'pulls', 'branches'].includes(githubShownView())) loadView(githubShownView());
   }
   followTerminal();
   if (focus) ($('github-card').querySelector('.btn.primary') ?? $('dock-close')).focus();
@@ -3495,7 +3504,7 @@ function useFolder(dir) {
 
 // ---- GitHub repository views ------------------------------------------------
 
-const GITHUB_VIEWS = ['repos', 'issues', 'actions', 'pulls'];
+const GITHUB_VIEWS = ['repos', 'issues', 'actions', 'pulls', 'branches'];
 const RUNS_POLL_MS = 6000;
 const RUNS_IDLE_POLL_MS = 30000;
 const BODY_LIMIT = 48000;
@@ -3590,7 +3599,11 @@ function pickRepo(repo, { chosen = false } = {}) {
     githubPick.recent = remember(githubPick.recent, repo);
     save(GITHUB_RECENT_KEY, JSON.stringify(githubPick.recent));
   }
-  if (!same) Object.assign(githubPick, { data: {}, editing: null });
+  if (!same) {
+    Object.assign(githubPick, { data: {}, editing: null });
+    $('github-branches-filter').value = '';
+    $('github-branches').scrollTop = 0;
+  }
   if ((!same || chosen) && githubView.accountId !== repo.accountId && state.github?.accounts.some((a) => a.id === repo.accountId)) {
     selectGitHubAccount(repo.accountId);
     githubView.card = null;
@@ -3603,7 +3616,7 @@ function pickRepo(repo, { chosen = false } = {}) {
   renderGitHubViews();
   if (!dockShows('github')) return;
   loadView('actions');
-  if (githubShownView() === 'issues' || githubShownView() === 'pulls') loadView(githubShownView());
+  if (['issues', 'pulls', 'branches'].includes(githubShownView())) loadView(githubShownView());
 }
 
 /** Picks the repository whose clone holds the focused terminal's folder, once for each terminal focused. */
@@ -3626,6 +3639,7 @@ async function followTerminal() {
 }
 
 async function loadView(view) {
+  if (view === 'branches') return loadBranches();
   const repo = githubPick.repo;
   if (!repo || view === 'repos') return;
   const query = view === 'issues' ? `?state=${githubPick.issueState}` : '';
@@ -3650,6 +3664,170 @@ async function loadView(view) {
   if (view === 'actions') scheduleRuns();
 }
 
+// Each object is a listing generation, scoped to the selected account/repository.
+// A retry continues that generation; Refresh replaces it and starts at page one.
+function branchesCurrent(request) {
+  return githubPick.data.branches === request && githubPick.repo && repoKey(githubPick.repo) === request.key
+    && state.github?.accounts.some((a) => a.id === request.repo.accountId && !a.needsSignIn);
+}
+
+function branchesVisible() {
+  return dockShows('github') && githubShownView() === 'branches' && document.visibilityState === 'visible';
+}
+
+async function loadBranches({ resume = false } = {}) {
+  const repo = githubPick.repo;
+  if (!repo || !state.github?.accounts.some((a) => a.id === repo.accountId && !a.needsSignIn)) return;
+  const before = viewData('branches');
+  if (resume && (!before || before.loading || before.nextPage === null)) return;
+  const request = resume ? before : {
+    key: repoKey(repo), repo, value: before?.value ?? null, loading: false, error: null,
+    nextPage: 1, received: false, rows: new Map(), defaultBranch: null, metadataError: null,
+  };
+  githubPick.data.branches = request;
+  request.loading = true;
+  request.error = null;
+  renderGitHubViews();
+  try {
+    while (request.nextPage !== null && branchesVisible() && branchesCurrent(request)) {
+      const page = request.nextPage;
+      const result = await api('GET', `${repoPath(repo)}/branches?page=${page}`);
+      if (!branchesCurrent(request)) return;
+      // A malformed response must not masquerade as a complete, empty list.
+      if (!Array.isArray(result.branches) || (result.nextPage !== null
+        && (!Number.isSafeInteger(result.nextPage) || result.nextPage <= page))) {
+        throw new Error('Could not read the next page of branches. Try again.');
+      }
+      if (page === 1) {
+        request.defaultBranch = result.defaultBranch;
+        request.metadataError = result.metadataError;
+      }
+      for (const branch of result.branches) request.rows.set(branch.name, branch);
+      request.nextPage = result.nextPage;
+      request.received = true;
+      request.value = { ...result, branches: [...request.rows.values()],
+        defaultBranch: request.defaultBranch, metadataError: request.metadataError };
+      renderGitHubViews();
+    }
+  } catch (err) {
+    if (!branchesCurrent(request)) return;
+    if (err instanceof AuthError) { showAuth(err.message); return; }
+    request.error = err.message;
+  } finally {
+    if (branchesCurrent(request)) {
+      request.loading = false;
+      renderGitHubViews();
+    }
+  }
+}
+
+/** Keep the first visible branch at the same pixel offset when earlier rows arrive. */
+function branchAnchor(panel, list) {
+  const { top, bottom } = panel.getBoundingClientRect();
+  const row = [...list.children].find((node) => {
+    const rect = node.getBoundingClientRect();
+    return rect.bottom > top && rect.top < bottom;
+  });
+  return row ? { name: row.dataset.branch, offset: row.getBoundingClientRect().top - top } : null;
+}
+
+async function copyBranch(name, control) {
+  const request = viewData('branches');
+  control.disabled = true;
+  let message;
+  try {
+    if (!navigator.clipboard?.writeText) throw new Error('Clipboard unavailable');
+    await navigator.clipboard.writeText(name);
+    message = `Copied branch name: ${name}`;
+  } catch {
+    message = 'Could not copy. Select the branch name and copy it using your browser.';
+  } finally {
+    control.disabled = false;
+  }
+  if (request === viewData('branches') && branchesVisible() && control.isConnected) toast(message);
+}
+
+function renderBranches({ preserveAnchor = true } = {}) {
+  const panel = $('github-branches');
+  const list = $('github-branches-list');
+  const repo = githubPick.repo;
+  const key = repo ? repoKey(repo) : '';
+  const same = panel.dataset.repo === key;
+  const anchor = same && preserveAnchor ? branchAnchor(panel, list) : null;
+  const focused = list.contains(document.activeElement) ? document.activeElement : null;
+  const oldScroll = same ? panel.scrollTop : 0;
+  if (!same) { list.replaceChildren(); panel.dataset.repo = key; }
+  $('github-branches-pick').hidden = Boolean(repo);
+  $('github-branches-content').hidden = !repo;
+  if (!repo) return;
+  const slot = viewData('branches');
+  const value = slot?.value;
+  const query = $('github-branches-filter').value.trim().toLocaleLowerCase();
+  $('github-branches-clear').disabled = !$('github-branches-filter').value;
+  const refresh = $('github-branches-refresh');
+  const usable = state.github?.accounts.some((a) => a.id === repo.accountId && !a.needsSignIn);
+  refresh.disabled = Boolean(slot?.loading) || !usable;
+  refresh.textContent = slot?.loading ? (value ? 'Refreshing…' : 'Loading…') : 'Refresh';
+  const out = $('github-branches-out');
+  out.href = value?.url ?? `https://github.com/${repo.fullName}/branches`;
+  out.title = `Open ${repo.fullName} branches on GitHub`;
+  const branches = (value?.branches ?? []).filter((b) => b.name.toLocaleLowerCase().includes(query)).sort((a, b) =>
+    Number(b.name === value.defaultBranch) - Number(a.name === value.defaultBranch)
+      || a.name.localeCompare(b.name) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  const complete = Boolean(value && value.nextPage === null && (!slot.error || slot.received));
+  const count = value?.branches.length ?? 0;
+  let status = !value ? (slot?.error ? 'Branches could not be loaded.' : 'Loading branches…')
+    : query ? `${branches.length} of ${count} loaded branches match.`
+      : `${count} ${count === 1 ? 'branch' : 'branches'}${complete ? '' : ' loaded'}.`;
+  if (value && !slot.received) status += slot.loading ? ' Refreshing…' : ' Showing previous results.';
+  else if (!complete && value) status += slot.loading ? ' Loading more…' : ' Listing incomplete.';
+  if (complete && !branches.length) status = query ? `No branches match “${$('github-branches-filter').value.trim()}”.` : 'No remote branches yet.';
+  const statusNode = $('github-branches-status');
+  if (statusNode.textContent !== status) statusNode.textContent = status;
+  const failure = $('github-branches-error');
+  failure.hidden = !slot?.error;
+  failure.querySelector('span').textContent = slot?.error ?? '';
+  $('github-branches-retry').disabled = Boolean(slot?.loading) || slot?.nextPage === null || !usable;
+  const metadata = $('github-branches-metadata');
+  metadata.hidden = !value?.metadataError;
+  metadata.textContent = value?.metadataError ? 'Branches loaded, but the default branch could not be identified. Refresh to try again.' : '';
+  const existing = new Map([...list.children].map((row) => [row.dataset.branch, row]));
+  const wanted = new Set(branches.map((branch) => branch.name));
+  let cursor = list.firstElementChild;
+  for (const branch of branches) {
+    let row = existing.get(branch.name);
+    if (!row) {
+      const copy = button('Copy name', () => copyBranch(branch.name, copy));
+      copy.setAttribute('aria-label', `Copy branch name ${branch.name}`);
+      row = recordRow(`branch:${branch.name}`, branch.name, '', copy, branch.url);
+      row.classList.add('github-branch');
+      row.dataset.branch = branch.name;
+      row.setAttribute('role', 'listitem');
+      row.querySelector('.history-title').append(el('span', 'github-branch-badges'));
+    }
+    const badges = row.querySelector('.github-branch-badges');
+    const badgeState = `${branch.name === value.defaultBranch}:${branch.protected}`;
+    if (badges.dataset.state !== badgeState) {
+      badges.dataset.state = badgeState;
+      badges.replaceChildren(...[
+        branch.name === value.defaultBranch ? badge('', 'Default', 'Default branch') : null,
+        branch.protected ? badge('', 'Protected', 'Protected by branch protection or rulesets') : null,
+      ].filter(Boolean));
+    }
+    row.querySelector('.history-meta').textContent = branch.sha ? branch.sha.slice(0, 7) : '';
+    row.querySelector('.history-meta').title = branch.sha ?? '';
+    if (row === cursor) cursor = cursor.nextElementSibling;
+    else list.insertBefore(row, cursor);
+  }
+  for (const row of [...list.children]) if (!wanted.has(row.dataset.branch)) row.remove();
+  if (focused?.isConnected && document.activeElement !== focused) focused.focus({ preventScroll: true });
+  panel.scrollTop = oldScroll;
+  if (anchor) {
+    const row = [...list.children].find((node) => node.dataset.branch === anchor.name);
+    if (row) panel.scrollTop += row.getBoundingClientRect().top - panel.getBoundingClientRect().top - anchor.offset;
+  }
+}
+
 function viewData(view) {
   const slot = githubPick.data[view];
   const repo = githubPick.repo;
@@ -3822,6 +4000,7 @@ function renderGitHubViews() {
   $('github-issues').hidden = shown !== 'issues';
   $('github-runs').hidden = shown !== 'actions';
   $('github-pulls').hidden = shown !== 'pulls';
+  $('github-branches').hidden = shown !== 'branches';
   const ready = Boolean(state.github && githubAccount() && !githubAccount().needsSignIn);
   $('github-clone-into').hidden = !ready || shown !== 'repos';
   const running = Boolean(viewData('actions')?.value?.running);
@@ -3831,6 +4010,7 @@ function renderGitHubViews() {
   if (shown === 'issues') renderIssues();
   else if (shown === 'actions') renderRuns();
   else if (shown === 'pulls') renderPulls();
+  else if (shown === 'branches') renderBranches();
 }
 
 /** Rebuilds a panel and puts the focus back on the control with the same `data-key`. */
@@ -5379,6 +5559,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 +5572,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 +5604,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 +5653,7 @@ let statsInterval;
 let newsTimer;
 
 function showAuth(message = '') {
+  state.environmentUI?.close();
   state.remoteAccessUI?.setAvailable(null);
   managerLoss.cancel();
   closePanel();
@@ -5643,6 +5828,18 @@ $('github-views').addEventListener('click', (e) => {
   if (view) switchGitHubView(view);
 });
 $('github-views').addEventListener('keydown', moveGitHubView);
+$('github-branches-refresh').addEventListener('click', () => loadView('branches'));
+$('github-branches-retry').addEventListener('click', () => loadBranches({ resume: true }));
+$('github-branches-filter').addEventListener('input', () => {
+  $('github-branches').scrollTop = 0;
+  renderBranches({ preserveAnchor: false });
+});
+$('github-branches-clear').addEventListener('click', () => {
+  $('github-branches-filter').value = '';
+  $('github-branches').scrollTop = 0;
+  renderBranches({ preserveAnchor: false });
+  $('github-branches-filter').focus();
+});
 $('github-parent').addEventListener('change', () => setCloneParent(cloneParent()));
 $('github-parent-pick').addEventListener('click', firstClick(() => chooseFolder('clone')));
 $('history-here').addEventListener('change', renderHistory);
@@ -5703,6 +5900,7 @@ document.addEventListener('visibilitychange', () => {
   if (document.visibilityState === 'visible' && state.connected && Date.now() - newsLoadedAt > 60000) loadNews();
   if (document.visibilityState === 'visible' && dockShows('github') && githubShownView() === 'actions') loadView('actions');
   else scheduleRuns();
+  if (branchesVisible() && !viewData('branches')?.error) loadBranches({ resume: true });
 });
 addEventListener('pagehide', () => {
   flushNotes();
@@ -5924,5 +6122,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,127 @@
+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', () => {
+    // A queued close from an earlier opening must not clear the current opener.
+    if (dialog.open) return;
+    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

@@ -208,6 +208,7 @@
         <button id="github-view-issues" class="github-view" type="button" role="tab" aria-controls="github-issues" aria-selected="false" data-view="issues" tabindex="-1">Issues</button>
         <button id="github-view-actions" class="github-view" type="button" role="tab" aria-controls="github-runs" aria-selected="false" data-view="actions" tabindex="-1" aria-label="Actions">Actions<span id="github-running" class="github-running" hidden></span></button>
         <button id="github-view-pulls" class="github-view" type="button" role="tab" aria-controls="github-pulls" aria-selected="false" data-view="pulls" tabindex="-1" aria-label="Pull requests"><span class="long">Pull requests</span><span class="short" aria-hidden="true">PRs</span></button>
+        <button id="github-view-branches" class="github-view" type="button" role="tab" aria-controls="github-branches" aria-selected="false" data-view="branches" tabindex="-1">Branches</button>
       </div>
       <div id="github-repos" class="models-body github-body" role="tabpanel" aria-labelledby="github-view-repos">
         <section id="github-card" class="github-card" aria-live="polite" hidden></section>
@@ -241,6 +242,27 @@
       <div id="github-issues" class="models-body github-body" role="tabpanel" aria-labelledby="github-view-issues" hidden></div>
       <div id="github-runs" class="models-body github-body" role="tabpanel" aria-labelledby="github-view-actions" hidden></div>
       <div id="github-pulls" class="models-body github-body" role="tabpanel" aria-labelledby="github-view-pulls" hidden></div>
+      <div id="github-branches" class="models-body github-body" role="tabpanel" aria-labelledby="github-view-branches" hidden>
+        <p id="github-branches-pick" class="github-view-note">Pick a repository above to see its branches.</p>
+        <div id="github-branches-content" hidden>
+          <div class="github-view-tools">
+            <button id="github-branches-refresh" class="btn" type="button">Refresh</button>
+            <span class="github-spacer"></span>
+            <a id="github-branches-out" class="btn github-out" target="_blank" rel="noopener noreferrer" aria-description="Opens in a new tab">GitHub</a>
+          </div>
+          <div class="github-branch-filter">
+            <input id="github-branches-filter" type="search" placeholder="Filter branches" aria-label="Filter branches" spellcheck="false" autocomplete="off">
+            <button id="github-branches-clear" class="btn" type="button" disabled>Clear</button>
+          </div>
+          <p id="github-branches-status" class="github-view-note" role="status" aria-live="polite" aria-atomic="true"></p>
+          <div id="github-branches-error" class="github-error" hidden>
+            <span role="alert"></span>
+            <button id="github-branches-retry" class="btn" type="button">Retry</button>
+          </div>
+          <p id="github-branches-metadata" class="github-view-note" hidden></p>
+          <div id="github-branches-list" class="history-list" role="list" aria-label="Remote branches"></div>
+        </div>
+      </div>
       <div id="github-clone-into" class="history-form github-form">
         <label for="github-parent">Clone into</label>
         <div class="cwd-field single">
@@ -344,6 +366,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 +519,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; }
@@ -884,10 +898,27 @@ a.news-link:visited { color: var(--muted); }
 .github-view[aria-selected="true"] { color: var(--heading); background: var(--surface-2); border-color: var(--border); border-bottom-color: var(--surface-2); }
 .github-view:focus-visible { outline: 2px solid var(--focus); outline-offset: -2px; }
 .github-view .short { display: none; }
-@container (max-width: 340px) {
+@container (max-width: 440px) {
   .github-view .long { display: none; }
   .github-view .short { display: inline; }
 }
+#github-branches { overflow-anchor: none; }
+.github-branch-filter { display: flex; align-items: center; gap: 6px; }
+.github-branch-filter input {
+  flex: 1; min-width: 0; padding: 7px 10px; border: 1px solid var(--border); border-radius: var(--radius);
+  background: var(--surface); color: var(--text); font: inherit; font-size: 0.85rem;
+}
+.github-branch-filter input:focus-visible { outline: 2px solid var(--focus); outline-offset: 1px; }
+.github-branch .history-title { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: baseline; }
+.github-branch .github-record-title { min-width: 0; overflow-wrap: anywhere; }
+.github-branch-badges { display: inline-flex; flex-wrap: wrap; gap: 4px; }
+.github-branch .history-meta { font-family: var(--font-mono, monospace); }
+.github-branch > .btn { align-self: start; }
+#github-branches-error .btn { margin-left: 6px; }
+@media (pointer: coarse) {
+  .github-branch-filter input { font-size: 16px; }
+  .github-branch > .btn, #github-branches .github-view-tools .btn, .github-branch-filter .btn { min-height: 36px; }
+}
 .github-running { width: 8px; height: 8px; border-radius: 50%; background: var(--warn); box-shadow: 0 0 0 3px color-mix(in srgb, var(--warn) 25%, transparent); animation: pulse 1.4s ease-in-out infinite; }
 .github-body[hidden] { display: none; }
 .github-view-tools { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; padding-bottom: 6px; }