@pixelbyte-software/pixcode 1.48.6 → 1.49.0

package/scripts/hermes/configure-pixcode-mcp.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const hermesHome = process.env.HERMES_HOME || path.join(os.homedir(), '.hermes');
+const configPath = path.join(hermesHome, 'config.yaml');
+const appRoot = process.env.PIXCODE_APP_ROOT || process.cwd();
+const baseUrl = process.env.PIXCODE_BASE_URL;
+const apiKey = process.env.PIXCODE_API_KEY;
+
+if (!baseUrl || !apiKey) {
+  process.stderr.write('PIXCODE_BASE_URL and PIXCODE_API_KEY are required for Pixcode MCP setup.\n');
+  process.exit(1);
+}
+
+const mcpServerPath = path.join(appRoot, 'scripts', 'hermes', 'pixcode-mcp-server.mjs');
+const block = [
+  '  pixcode:',
+  '    command: "node"',
+  '    args:',
+  `      - "${mcpServerPath.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
+  '    env:',
+  `      PIXCODE_BASE_URL: "${baseUrl.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
+  `      PIXCODE_API_KEY: "${apiKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
+  '    enabled: true',
+  '    tools:',
+  '      include:',
+  '        - pixcode_list_projects',
+  '        - pixcode_get_provider_status',
+  '        - pixcode_open_cli_terminal',
+  '      resources: false',
+  '      prompts: false',
+].join('\n');
+
+function findRootKeyEnd(lines, startIndex) {
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (/^\S[^:]*:\s*(?:#.*)?$/.test(lines[index])) {
+      return index;
+    }
+  }
+  return lines.length;
+}
+
+function findNestedKeyEnd(lines, startIndex, parentEnd) {
+  for (let index = startIndex + 1; index < parentEnd; index += 1) {
+    if (/^  \S[^:]*:\s*(?:#.*)?$/.test(lines[index])) {
+      return index;
+    }
+  }
+  return parentEnd;
+}
+
+function upsertPixcodeMcpConfig(rawConfig) {
+  const lines = rawConfig.split(/\r?\n/);
+  const mcpIndex = lines.findIndex((line) => /^mcp_servers:\s*(?:#.*)?$/.test(line));
+
+  if (mcpIndex === -1) {
+    const prefix = rawConfig.trim() ? `${rawConfig.replace(/\s*$/, '')}\n\n` : '';
+    return `${prefix}mcp_servers:\n${block}\n`;
+  }
+
+  const mcpEnd = findRootKeyEnd(lines, mcpIndex);
+  const pixcodeIndex = lines.findIndex((line, index) => (
+    index > mcpIndex && index < mcpEnd && /^  pixcode:\s*(?:#.*)?$/.test(line)
+  ));
+
+  if (pixcodeIndex === -1) {
+    lines.splice(mcpIndex + 1, 0, block);
+    return `${lines.join('\n').replace(/\s*$/, '')}\n`;
+  }
+
+  const pixcodeEnd = findNestedKeyEnd(lines, pixcodeIndex, mcpEnd);
+  lines.splice(pixcodeIndex, pixcodeEnd - pixcodeIndex, block);
+  return `${lines.join('\n').replace(/\s*$/, '')}\n`;
+}
+
+fs.mkdirSync(hermesHome, { recursive: true });
+const previous = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+const next = upsertPixcodeMcpConfig(previous);
+
+if (previous !== next) {
+  fs.writeFileSync(configPath, next);
+  process.stdout.write(`Pixcode MCP configured in ${configPath}\n`);
+} else {
+  process.stdout.write(`Pixcode MCP already configured in ${configPath}\n`);
+}

package/scripts/hermes/pixcode-mcp-server.mjs

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import readline from 'node:readline';
+
+const baseUrl = (process.env.PIXCODE_BASE_URL || '').replace(/\/$/, '');
+const apiKey = process.env.PIXCODE_API_KEY || '';
+
+const tools = [
+  {
+    name: 'pixcode_list_projects',
+    description: 'List Pixcode workspaces/projects visible to this user, including display name, path, and file count when available.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'pixcode_get_provider_status',
+    description: 'Get install/auth/version status for one Pixcode CLI provider.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        provider: {
+          type: 'string',
+          enum: ['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode'],
+        },
+      },
+      required: ['provider'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'pixcode_open_cli_terminal',
+    description: 'Ask the open Pixcode workbench to open a visible CLI terminal for a provider in a project.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        provider: {
+          type: 'string',
+          enum: ['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode'],
+        },
+        projectPath: {
+          type: 'string',
+          description: 'Absolute project path. Omit to use the currently selected Pixcode project.',
+        },
+        prompt: {
+          type: 'string',
+          description: 'Optional short reason shown to Pixcode for audit/display.',
+        },
+      },
+      required: ['provider'],
+      additionalProperties: false,
+    },
+  },
+];
+
+function send(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+
+function textResult(text) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text,
+      },
+    ],
+  };
+}
+
+async function pixcodeFetch(endpoint, options = {}) {
+  if (!baseUrl || !apiKey) {
+    throw new Error('Pixcode MCP is missing PIXCODE_BASE_URL or PIXCODE_API_KEY.');
+  }
+
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    body = text;
+  }
+
+  if (!response.ok) {
+    throw new Error(`Pixcode API ${endpoint} failed with HTTP ${response.status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`);
+  }
+
+  return body;
+}
+
+async function callTool(name, args = {}) {
+  if (name === 'pixcode_list_projects') {
+    const projects = await pixcodeFetch('/api/projects');
+    const normalized = (Array.isArray(projects) ? projects : []).map((project) => ({
+      name: project.name,
+      displayName: project.displayName,
+      path: project.fullPath || project.path,
+      fileCount: project.fileCount ?? null,
+    }));
+    return textResult(JSON.stringify(normalized, null, 2));
+  }
+
+  if (name === 'pixcode_get_provider_status') {
+    const provider = String(args.provider || '');
+    const body = await pixcodeFetch(`/api/providers/${encodeURIComponent(provider)}/auth/status?refresh=1`);
+    return textResult(JSON.stringify(body?.data ?? body, null, 2));
+  }
+
+  if (name === 'pixcode_open_cli_terminal') {
+    const body = await pixcodeFetch('/api/orchestration/hermes/terminal-launches', {
+      method: 'POST',
+      body: JSON.stringify({
+        provider: args.provider,
+        projectPath: args.projectPath || null,
+        prompt: args.prompt || null,
+      }),
+    });
+    return textResult(JSON.stringify(body?.event ?? body, null, 2));
+  }
+
+  throw new Error(`Unknown Pixcode MCP tool: ${name}`);
+}
+
+async function handleMessage(message) {
+  if (message.method === 'initialize') {
+    send({
+      jsonrpc: '2.0',
+      id: message.id,
+      result: {
+        protocolVersion: message.params?.protocolVersion || '2024-11-05',
+        capabilities: {
+          tools: {},
+        },
+        serverInfo: {
+          name: 'pixcode-mcp',
+          version: '1.0.0',
+        },
+      },
+    });
+    return;
+  }
+
+  if (message.method === 'tools/list') {
+    send({
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { tools },
+    });
+    return;
+  }
+
+  if (message.method === 'tools/call') {
+    try {
+      const result = await callTool(message.params?.name, message.params?.arguments || {});
+      send({
+        jsonrpc: '2.0',
+        id: message.id,
+        result,
+      });
+    } catch (error) {
+      send({
+        jsonrpc: '2.0',
+        id: message.id,
+        error: {
+          code: -32000,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+    return;
+  }
+
+  if (typeof message.id !== 'undefined') {
+    send({
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32601,
+        message: `Method not found: ${message.method}`,
+      },
+    });
+  }
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Number.POSITIVE_INFINITY,
+});
+
+rl.on('line', (line) => {
+  if (!line.trim()) return;
+
+  void (async () => {
+    try {
+      await handleMessage(JSON.parse(line));
+    } catch (error) {
+      send({
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32700,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  })();
+});

package/scripts/smoke/git-install-update.mjs

@@ -65,20 +65,51 @@ assert.match(
 
 assert.match(
   updater,
-  /npm[\s\S]*install[\s\S]*--no-audit[\s\S]*--no-fund/,
-  'Safe updater should reinstall dependencies after updating source files.',
+  /shouldRunNpmInstall/,
+  'Safe updater should decide whether dependency reconciliation is needed from changed files.',
 );
 
 assert.match(
   updater,
-  /npm[\s\S]*run[\s\S]*build/,
-  'Safe updater should rebuild source installs after updating source files.',
+  /Dependencies unchanged; skipping npm install\./,
+  'Safe updater should skip npm install when package manifests did not change.',
 );
 
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pixcode-git-update-'));
-const origin = path.join(tempRoot, 'origin.git');
-const source = path.join(tempRoot, 'source');
-const install = path.join(tempRoot, 'install');
+assert.match(
+  updater,
+  /shouldRunBuild/,
+  'Safe updater should decide whether source rebuild is needed from changed files.',
+);
+
+assert.match(
+  updater,
+  /Build inputs unchanged; skipping build\./,
+  'Safe updater should skip build when only non-runtime files changed.',
+);
+
+function makeTempRepo(name) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), `pixcode-git-update-${name}-`));
+  const origin = path.join(tempRoot, 'origin.git');
+  const source = path.join(tempRoot, 'source');
+  const install = path.join(tempRoot, 'install');
+
+  fs.mkdirSync(source, { recursive: true });
+  run('git', ['init', '--bare', origin], tempRoot);
+  run('git', ['init', '-b', 'main'], source);
+  writePackage(source, '1.0.0');
+  fs.mkdirSync(path.join(source, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(source, 'src', 'app.js'), 'old\n');
+  fs.writeFileSync(path.join(source, 'README.md'), 'old docs\n');
+  fs.writeFileSync(path.join(source, 'tracked.txt'), 'old\n');
+  run('git', ['add', '.'], source);
+  run('git', ['commit', '-m', 'initial'], source);
+  run('git', ['remote', 'add', 'origin', origin], source);
+  run('git', ['push', '-u', 'origin', 'main'], source);
+  run('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], origin);
+  run('git', ['clone', origin, install], tempRoot);
+
+  return { origin, source, install };
+}
 
 function run(command, args, cwd) {
   const result = spawnSync(command, args, {
@@ -99,22 +130,24 @@ function run(command, args, cwd) {
     `${command} ${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
   );
 
-  return result.stdout.trim();
+  return `${result.stdout}${result.stderr}`.trim();
 }
 
-function writePackage(version) {
+function writePackage(root, version, dependencies = {}) {
   fs.writeFileSync(
-    path.join(source, 'package.json'),
+    path.join(root, 'package.json'),
     JSON.stringify({
       name: 'pixcode-update-smoke',
       version,
       scripts: {
+        preinstall: 'node -e "require(\\"node:fs\\").writeFileSync(\\"install-ran.txt\\", \\"install\\")"',
         build: 'node -e "require(\\"node:fs\\").writeFileSync(\\"built.txt\\", \\"built\\")"',
       },
+      dependencies,
     }, null, 2),
   );
   fs.writeFileSync(
-    path.join(source, 'package-lock.json'),
+    path.join(root, 'package-lock.json'),
     JSON.stringify({
       name: 'pixcode-update-smoke',
       version,
@@ -130,47 +163,93 @@ function writePackage(version) {
   );
 }
 
-fs.mkdirSync(source, { recursive: true });
-run('git', ['init', '--bare', origin], tempRoot);
-run('git', ['init', '-b', 'main'], source);
-writePackage('1.0.0');
-fs.writeFileSync(path.join(source, 'tracked.txt'), 'old\n');
-run('git', ['add', '.'], source);
-run('git', ['commit', '-m', 'initial'], source);
-run('git', ['remote', 'add', 'origin', origin], source);
-run('git', ['push', '-u', 'origin', 'main'], source);
-run('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], origin);
-run('git', ['clone', origin, install], tempRoot);
-
-writePackage('1.0.1');
-fs.writeFileSync(path.join(source, 'tracked.txt'), 'new\n');
-run('git', ['add', '.'], source);
-run('git', ['commit', '-m', 'update'], source);
-run('git', ['push', 'origin', 'main'], source);
-
-fs.writeFileSync(path.join(install, 'tracked.txt'), 'local dirty change\n');
-fs.writeFileSync(path.join(install, 'untracked.txt'), 'local untracked change\n');
-run(process.execPath, [updaterPath], install);
-
-assert.equal(
-  JSON.parse(fs.readFileSync(path.join(install, 'package.json'), 'utf8')).version,
-  '1.0.1',
-  'Safe updater should fast-forward the install checkout.',
-);
-assert.equal(
-  fs.readFileSync(path.join(install, 'tracked.txt'), 'utf8'),
-  'new\n',
-  'Safe updater should apply the remote tracked file after stashing local edits.',
-);
-assert.match(
-  run('git', ['stash', 'list'], install),
-  /pixcode-auto-update-/,
-  'Safe updater should leave local dirty files recoverable in git stash.',
-);
-assert.equal(
-  fs.readFileSync(path.join(install, 'built.txt'), 'utf8'),
-  'built',
-  'Safe updater should run the repository build after installing dependencies.',
-);
+{
+  const { source, install } = makeTempRepo('deps');
+
+  fs.mkdirSync(path.join(source, 'local-dep'), { recursive: true });
+  fs.writeFileSync(
+    path.join(source, 'local-dep', 'package.json'),
+    JSON.stringify({ name: 'pixcode-smoke-local-dep', version: '1.0.0' }, null, 2),
+  );
+  writePackage(source, '1.0.1', { 'pixcode-smoke-local-dep': 'file:./local-dep' });
+  fs.writeFileSync(path.join(source, 'tracked.txt'), 'new\n');
+  run('git', ['add', '.'], source);
+  run('git', ['commit', '-m', 'dependency update'], source);
+  run('git', ['push', 'origin', 'main'], source);
+
+  fs.writeFileSync(path.join(install, 'tracked.txt'), 'local dirty change\n');
+  fs.writeFileSync(path.join(install, 'untracked.txt'), 'local untracked change\n');
+  run(process.execPath, [updaterPath], install);
+
+  assert.equal(
+    JSON.parse(fs.readFileSync(path.join(install, 'package.json'), 'utf8')).version,
+    '1.0.1',
+    'Safe updater should fast-forward the install checkout.',
+  );
+  assert.equal(
+    fs.readFileSync(path.join(install, 'tracked.txt'), 'utf8'),
+    'new\n',
+    'Safe updater should apply the remote tracked file after stashing local edits.',
+  );
+  assert.match(
+    run('git', ['stash', 'list'], install),
+    /pixcode-auto-update-/,
+    'Safe updater should leave local dirty files recoverable in git stash.',
+  );
+  assert.equal(
+    fs.readFileSync(path.join(install, 'install-ran.txt'), 'utf8'),
+    'install',
+    'Dependency updates should run npm install.',
+  );
+  assert.equal(
+    fs.readFileSync(path.join(install, 'built.txt'), 'utf8'),
+    'built',
+    'Safe updater should run the repository build after dependency updates.',
+  );
+}
+
+{
+  const { source, install } = makeTempRepo('source');
+
+  fs.writeFileSync(path.join(source, 'src', 'app.js'), 'new source\n');
+  run('git', ['add', '.'], source);
+  run('git', ['commit', '-m', 'source update'], source);
+  run('git', ['push', 'origin', 'main'], source);
+
+  run(process.execPath, [updaterPath], install);
+
+  assert.equal(
+    fs.existsSync(path.join(install, 'install-ran.txt')),
+    false,
+    'Source-only updates should skip npm install.',
+  );
+  assert.equal(
+    fs.readFileSync(path.join(install, 'built.txt'), 'utf8'),
+    'built',
+    'Source-only updates should produce a fresh build output.',
+  );
+}
+
+{
+  const { source, install } = makeTempRepo('docs');
+
+  fs.writeFileSync(path.join(source, 'README.md'), 'new docs\n');
+  run('git', ['add', '.'], source);
+  run('git', ['commit', '-m', 'docs update'], source);
+  run('git', ['push', 'origin', 'main'], source);
+
+  run(process.execPath, [updaterPath], install);
+
+  assert.equal(
+    fs.existsSync(path.join(install, 'install-ran.txt')),
+    false,
+    'Docs-only updates should skip npm install.',
+  );
+  assert.equal(
+    fs.existsSync(path.join(install, 'built.txt')),
+    false,
+    'Docs-only updates should not create build output.',
+  );
+}
 
 console.log('git install update smoke passed');

package/scripts/smoke/pixcode-workbench-1-48.mjs

@@ -18,6 +18,7 @@ const serverIndex = read('server/index.js');
 const hermesRoutes = read('server/modules/orchestration/hermes/hermes.routes.ts');
 const shellTerminal = read('src/components/shell/hooks/useShellTerminal.ts');
 const gitPanelHeader = read('src/components/git-panel/view/GitPanelHeader.tsx');
+const themeContext = read('src/contexts/ThemeContext.jsx');
 
 assert.match(
   preferenceHook,
@@ -52,13 +53,25 @@ assert.match(workbench, /onClose=\{closeTerminal\}/, 'Closing the workbench term
 assert.match(workbench, /WorkbenchCliPanelToolbar/, 'CLI terminal should keep history and new-session actions visible.');
 assert.match(workbench, /WORKBENCH_CLI_STATE_STORAGE_KEY/, 'CLI terminal should remember per-project open state across workspace switches.');
 assert.match(workbench, /function WorkbenchBottomTerminal/, 'Terminal activity should render as a bottom plain-shell panel.');
+assert.match(workbench, /BOTTOM_TERMINAL_MIN_HEIGHT/, 'Bottom terminal should support height resizing.');
+assert.match(workbench, /isBottomTerminalMinimized/, 'Bottom terminal should support minimizing without closing.');
 assert.match(workbench, /isPlainShell/, 'Bottom terminal should open the selected project folder without starting the selected AI CLI.');
-assert.match(workbench, /startHermesAgent/, 'Right CLI panel should launch Hermes Agent in the active project.');
+assert.match(workbench, /HERMES_AGENT_START_COMMAND/, 'Hermes Agent should launch from the bottom terminal through a server-side sentinel.');
+assert.doesNotMatch(workbench, /Project-scoped agent terminal\. Installs Hermes when missing/, 'Right CLI panel should not show the old Hermes card.');
+assert.match(workbench, /shrinkCliPanel/, 'Right CLI panel should expose a shrink action.');
+assert.match(workbench, /expandCliPanel/, 'Right CLI panel should expose an expand action.');
+assert.match(workbench, /vscodeWorkbench\.welcome\.openProject/, 'Workbench welcome should expose a simple Open Project action.');
+assert.match(workbench, /vscodeWorkbench\.welcome\.cloneProject/, 'Workbench welcome should expose a simple Clone action.');
+assert.match(workbench, /vscodeWorkbench\.welcome\.startHermes/, 'Workbench welcome should expose a Hermes start action.');
+assert.match(workbench, /DarkModeToggle/, 'Workbench welcome should expose a dark-mode toggle.');
+assert.match(themeContext, /return true;/, 'Pixcode should default new installs to dark mode.');
 assert.match(workbench, /openNewCliSessionPicker/, 'CLI terminal plus should return to provider selection before starting a fresh session.');
 assert.match(workbench, /terminateCurrentCliSession\(selectedProvider\)/, 'CLI terminal plus should terminate the existing provider PTY before showing selection.');
 assert.match(workbench, /forceNewSession=\{terminalLaunch\.forceNewSession\}/, 'Fresh CLI sessions should bypass the cached default PTY.');
 assert.match(serverIndex, /\/api\/shell\/sessions\/terminate/, 'Backend should expose an authenticated endpoint to terminate cached provider PTYs immediately.');
 assert.match(serverIndex, /isPlainShell && !initialCommand/, 'Backend should spawn an interactive plain shell when no terminal command is provided.');
+assert.match(serverIndex, /pixcode:hermes:start/, 'Backend should expand Hermes terminal sentinels on the server host.');
+assert.doesNotMatch(serverIndex, /iex \(irm https:\/\/raw\.githubusercontent\.com\/NousResearch\/hermes-agent\/main\/scripts\/install\.ps1\)/, 'Windows Hermes install should avoid the old inline iex pattern.');
 assert.doesNotMatch(shellTerminal, /new WebglAddon\(\)/, 'Workbench terminal should use the stable xterm renderer.');
 assert.match(workbench, /setActivityPanel\('explorer'\)/, 'Selecting a project should return the side panel to Explorer.');
 assert.match(gitPanelHeader, /compact/, 'Workbench Source Control should have compact icon-only controls.');
@@ -80,6 +93,7 @@ assert.doesNotMatch(workbench, /tabs\.orchestration/, 'Workbench menus should no
 assert.match(serverIndex, /app\.use\('\/hermes', createHermesTaskRouter\(\)\)/, 'Internal task router should be mounted behind Hermes.');
 assert.doesNotMatch(serverIndex, /app\.use\('\/a2a'/, 'Server should not expose the old A2A route.');
 assert.match(hermesRoutes, /createHermesRouter/, 'Hermes should have a dedicated orchestration API router.');
+assert.match(hermesRoutes, /terminal-launches/, 'Hermes MCP should be able to request visible Pixcode CLI terminal launches.');
 assert.match(serverIndex, /forceNewSession/, 'Shell backend should support explicit fresh-session launches from the workbench.');
 assert.match(serverIndex, /killProviderPtySessions/, 'Shell backend should terminate old provider PTYs when a fresh CLI session is requested.');
 

package/scripts/smoke/vscode-workbench-polish.mjs

@@ -51,6 +51,15 @@ assert.match(
   'Workbench center should show a project landing page instead of a blank editor when no project is selected.',
 );
 
+for (const token of [
+  'vscodeWorkbench.welcome.openProject',
+  'vscodeWorkbench.welcome.cloneProject',
+  'vscodeWorkbench.welcome.startHermes',
+  'DarkModeToggle',
+]) {
+  assert.match(workbench, new RegExp(token.replaceAll('.', '\\.')), `Workbench welcome should include ${token}.`);
+}
+
 assert.match(
   workbench,
   /function WorkbenchCliPanel/,
@@ -244,6 +253,10 @@ assert.match(
   'Terminal activity should open a VS Code-style bottom terminal instead of the provider CLI picker.',
 );
 
+for (const token of ['BOTTOM_TERMINAL_MIN_HEIGHT', 'isBottomTerminalMinimized', 'shrinkCliPanel', 'expandCliPanel']) {
+  assert.match(workbench, new RegExp(token), `Workbench should include ${token}.`);
+}
+
 assert.match(
   workbench,
   /isPlainShell/,
@@ -252,8 +265,14 @@ assert.match(
 
 assert.match(
   workbench,
-  /startHermesAgent/,
-  'Right CLI panel should offer Hermes Agent as a project-scoped control agent.',
+  /HERMES_AGENT_START_COMMAND/,
+  'Hermes Agent should launch through the bottom terminal with a server-side command sentinel.',
+);
+
+assert.doesNotMatch(
+  workbench,
+  /Project-scoped agent terminal\. Installs Hermes when missing/,
+  'Right CLI picker should not show the old Hermes install card.',
 );
 
 assert.match(