@pixelbyte-software/pixcode 1.50.4 → 1.50.6

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

@@ -7,6 +7,8 @@ const baseUrl = (process.env.PIXCODE_BASE_URL || '').replace(/\/$/, '');
 const apiKey = process.env.PIXCODE_API_KEY || '';
 const appRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const mcpServerPath = path.join(appRoot, 'scripts', 'hermes', 'pixcode-mcp-server.mjs');
+const READBACK_IDLE_STABLE_MS = 2500;
+const DEFAULT_STARTUP_WAIT_MS = 100000;
 
 const tools = [
   {
@@ -35,7 +37,7 @@ const tools = [
   },
   {
     name: 'pixcode_open_cli_terminal',
-    description: 'Use this instead of Hermes shell/proc/skill execution whenever the user asks to open Codex, Claude, Cursor, Gemini, Qwen, or OpenCode inside Pixcode. It asks the open Pixcode workbench to open a visible provider CLI terminal in the project and submit startup input there. Do not run a parallel Hermes codex/claude/proc command for the same request. For multi-step, piece-by-piece, or long-running work, put the full user instruction in startupInput so the provider CLI does the work visibly inside Pixcode. When startupInput is present, Pixcode waits for the terminal to become idle before returning readback by default; never treat the first working frame as final output.',
+    description: 'Use this instead of Hermes shell/proc/skill execution whenever the user asks to open Codex, Claude, Cursor, Gemini, Qwen, or OpenCode inside Pixcode. It asks the open Pixcode workbench to continue the existing visible provider terminal in the project and submit startup input there. Do not run a parallel Hermes codex/claude/proc command for the same request. Do not request a fresh session unless the user explicitly asks for a new session. For multi-step, piece-by-piece, or long-running work, put the full user instruction in startupInput so the provider CLI does the work visibly inside Pixcode. When startupInput is present, Pixcode waits for the terminal to become idle before returning readback by default; never treat the first working frame as final output.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -55,6 +57,10 @@ const tools = [
           type: 'string',
           description: 'Exact startup input typed into the provider CLI after the TUI is ready. Use this for commands like /init, hello prompts, or full multi-step task instructions the user asked to run visibly.',
         },
+        forceNewSession: {
+          type: 'boolean',
+          description: 'Start a fresh visible provider CLI session only when the user explicitly asks for a new session. Omit or false to continue the existing visible provider terminal.',
+        },
         bypassPermissions: {
           type: 'boolean',
           description: 'When true, Pixcode starts the provider CLI with its strongest no-approval/bypass flags where supported. Defaults to true for Hermes-launched visible task work.',
@@ -222,21 +228,21 @@ function inferTerminalState(provider, terminalOutput) {
   if (!output.trim()) return 'unknown';
   if (/Process exited with code/iu.test(output)) return 'idle';
 
-  const lastBusy = Math.max(
-    getLastMatchIndex(output, /(?:^|\n)\s*[•*]\s*(?:Working|Running|Thinking)\b/giu),
+  const lastWeakBusy = getLastMatchIndex(output, /(?:^|\n)\s*[•*]\s*(?:Working|Running|Thinking)\b/giu);
+  const lastStrongBusy = Math.max(
     getLastMatchIndex(output, /\bWorking\s*\([^)]*esc to interrupt[^)]*\)/giu),
     getLastMatchIndex(output, /\bmsg=interrupt\b/giu),
   );
+  const lastBusy = Math.max(lastWeakBusy, lastStrongBusy);
 
   if (provider === 'codex') {
     const lastPrompt = Math.max(
       getLastMatchIndex(output, /(?:^|\n)\s*›(?:\s|$)/gu),
       getLastMatchIndex(output, /(?:^|\n)\s*❯(?:\s|$)/gu),
     );
-    if (lastBusy >= 0) return lastPrompt > lastBusy ? 'idle' : 'busy';
-    return lastPrompt >= 0 && /(?:Initialized|Baseline check passed|I did not modify files|Use \/skills)/iu.test(output)
-      ? 'idle'
-      : 'unknown';
+    if (lastPrompt >= 0) return lastStrongBusy > lastPrompt ? 'busy' : 'idle';
+    if (lastBusy >= 0) return 'busy';
+    return 'unknown';
   }
 
   if (lastBusy >= 0) return 'busy';
@@ -245,12 +251,30 @@ function inferTerminalState(provider, terminalOutput) {
 
 function isTerminalReadbackFinal(provider, terminalOutput) {
   const terminalState = inferTerminalState(provider, terminalOutput);
-  return terminalState === 'idle' || terminalState === 'completed' || terminalState === 'exited';
+  return terminalState === 'idle' || terminalState === 'completed' || terminalState === 'exited' || terminalState === 'failed';
+}
+
+function isTerminalReadbackHardFinal(provider, terminalOutput) {
+  const terminalState = inferTerminalState(provider, terminalOutput);
+  return terminalState === 'completed' || terminalState === 'exited' || terminalState === 'failed' || Boolean(terminalOutput?.terminalFailed);
+}
+
+function getReadbackFingerprint(terminalOutput) {
+  return [
+    terminalOutput?.terminalState || '',
+    terminalOutput?.lifecycleState || '',
+    terminalOutput?.exitCode ?? '',
+    terminalOutput?.exitSignal || '',
+    String(terminalOutput?.output || '').slice(-12000),
+  ].join('\n---pixcode-readback---\n');
 }
 
 async function waitForProviderTerminalOutput(provider, projectPath, waitMs, launchId = null) {
   const startedAt = Date.now();
   let latestOutput = null;
+  let stableFingerprint = null;
+  let stableSince = 0;
+  let stableFinal = false;
   do {
     const elapsed = Date.now() - startedAt;
     const remaining = Math.max(0, waitMs - elapsed);
@@ -262,7 +286,23 @@ async function waitForProviderTerminalOutput(provider, projectPath, waitMs, laun
     }));
 
     if (latestOutput?.output && isTerminalReadbackFinal(provider, latestOutput)) {
-      break;
+      if (isTerminalReadbackHardFinal(provider, latestOutput)) {
+        stableFinal = true;
+        break;
+      }
+
+      const fingerprint = getReadbackFingerprint(latestOutput);
+      if (fingerprint !== stableFingerprint) {
+        stableFingerprint = fingerprint;
+        stableSince = Date.now();
+      }
+      if (Date.now() - stableSince >= READBACK_IDLE_STABLE_MS) {
+        stableFinal = true;
+        break;
+      }
+    } else {
+      stableFingerprint = null;
+      stableSince = 0;
     }
   } while (Date.now() - startedAt < waitMs);
 
@@ -272,6 +312,10 @@ async function waitForProviderTerminalOutput(provider, projectPath, waitMs, laun
   if (latestOutput && typeof latestOutput.isBusy !== 'boolean') {
     latestOutput.isBusy = latestOutput.terminalState === 'busy';
   }
+  if (latestOutput) {
+    latestOutput.readbackStable = stableFinal;
+    latestOutput.terminalOutputFinal = stableFinal;
+  }
   return latestOutput;
 }
 
@@ -285,13 +329,13 @@ function isLegacyPromptLikelyStartupInput(prompt) {
   return prompt.length <= 80;
 }
 
-async function ensureProviderPixcodeMcp(provider, projectPath) {
+async function upsertProviderPixcodeMcp(provider, projectPath, scope) {
   const body = await pixcodeFetch(`/api/providers/${encodeURIComponent(provider)}/mcp/servers`, {
     method: 'POST',
     body: JSON.stringify({
       name: 'pixcode',
       transport: 'stdio',
-      scope: 'project',
+      scope,
       workspacePath: projectPath || process.cwd(),
       command: process.execPath,
       args: [mcpServerPath],
@@ -304,6 +348,22 @@ async function ensureProviderPixcodeMcp(provider, projectPath) {
   return body?.data?.server ?? body?.server ?? body;
 }
 
+async function ensureProviderPixcodeMcp(provider, projectPath) {
+  try {
+    const server = await upsertProviderPixcodeMcp(provider, projectPath, 'project');
+    return { scope: 'project', server, projectScopeError: null };
+  } catch (error) {
+    const projectScopeError = error instanceof Error ? error.message : String(error);
+    try {
+      const server = await upsertProviderPixcodeMcp(provider, projectPath, 'user');
+      return { scope: 'user', server, projectScopeError };
+    } catch (fallbackError) {
+      const userScopeError = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+      throw new Error(`Pixcode MCP auto-config failed for project scope (${projectScopeError}) and user scope (${userScopeError})`);
+    }
+  }
+}
+
 async function callTool(name, args = {}) {
   if (name === 'pixcode_list_projects') {
     const projects = await pixcodeFetch('/api/projects');
@@ -339,9 +399,10 @@ async function callTool(name, args = {}) {
     }
 
     let mcpConfigured = false;
+    let mcpConfig = null;
     let mcpError = null;
     try {
-      await ensureProviderPixcodeMcp(provider, projectPath);
+      mcpConfig = await ensureProviderPixcodeMcp(provider, projectPath);
       mcpConfigured = true;
     } catch (error) {
       mcpError = error instanceof Error ? error.message : String(error);
@@ -351,6 +412,7 @@ async function callTool(name, args = {}) {
       ? args.startupInput
       : (isLegacyPromptLikelyStartupInput(args.prompt) ? args.prompt.trim() : null);
     const bypassPermissions = args.bypassPermissions === false ? false : true;
+    const forceNewSession = args.forceNewSession === true || args.newSession === true || args.freshSession === true;
     const permissionMode = typeof args.permissionMode === 'string' && args.permissionMode.trim()
       ? args.permissionMode.trim()
       : (bypassPermissions ? 'bypassPermissions' : null);
@@ -362,6 +424,7 @@ async function callTool(name, args = {}) {
         projectPath,
         prompt: args.prompt || null,
         startupInput,
+        forceNewSession,
         bypassPermissions,
         skipPermissions: bypassPermissions,
         permissionMode,
@@ -369,24 +432,31 @@ async function callTool(name, args = {}) {
     });
     const launchId = Number(body?.event?.id || body?.id || 0) || null;
     let terminalOutput = null;
-    const defaultWaitMs = startupInput ? 180000 : 0;
+    const defaultWaitMs = startupInput ? DEFAULT_STARTUP_WAIT_MS : 0;
     const requestedWaitMs = Number(args.waitForCompletionMs ?? args.waitForOutputMs ?? defaultWaitMs);
     const waitForOutputMs = Math.min(600000, Math.max(0, requestedWaitMs));
     if (waitForOutputMs > 0) {
       terminalOutput = await waitForProviderTerminalOutput(provider, projectPath, waitForOutputMs, launchId);
     }
-    const terminalOutputFinal = terminalOutput ? isTerminalReadbackFinal(provider, terminalOutput) : false;
+    const terminalOutputFinal = terminalOutput
+      ? Boolean(terminalOutput.terminalOutputFinal ?? isTerminalReadbackFinal(provider, terminalOutput))
+      : false;
     return textResult(JSON.stringify({
       launched: true,
       launchId,
       pixcodeMcpConfigured: mcpConfigured,
+      pixcodeMcpScope: mcpConfig?.scope ?? null,
+      pixcodeMcpProjectScopeError: mcpConfig?.projectScopeError ?? null,
       pixcodeMcpError: mcpError,
       event: body?.event ?? body,
       permissionBypass: bypassPermissions,
       status,
       terminalOutputFinal,
+      terminalFailed: Boolean(terminalOutput?.terminalFailed),
       message: terminalOutput && !terminalOutputFinal
         ? 'Provider terminal is still running or not at an idle prompt yet. Do not summarize this as final output; call pixcode_read_cli_terminal with launchId later.'
+        : terminalOutput?.terminalFailed
+          ? 'Provider terminal exited with a failure. Do not report this as successful; tell the user the visible CLI failed and include the exit code/output.'
         : undefined,
       terminalOutput,
     }, null, 2));
@@ -407,6 +477,7 @@ async function callTool(name, args = {}) {
       body.isBusy = body.terminalState === 'busy';
     }
     body.terminalOutputFinal = isTerminalReadbackFinal(provider, body);
+    body.terminalFailed = Boolean(body.terminalFailed);
     return textResult(JSON.stringify(body, null, 2));
   }
 

package/scripts/smoke/hermes-api-install.mjs

@@ -37,6 +37,7 @@ assert.match(hermesInstallJobs, /windowsCmdFallbackCommand/, 'Hermes install sho
 assert.match(hermesInstallJobs, /retrying through cmd\.exe without elevation/, 'Hermes install logs should explain the no-admin Windows EPERM fallback.');
 assert.match(read('scripts/hermes/configure-pixcode-mcp.mjs'), /platform_toolsets/, 'Pixcode MCP config should enable the Pixcode toolset for Hermes API server runs.');
 assert.match(read('scripts/hermes/configure-pixcode-mcp.mjs'), /api_server:[\s\S]+pixcode/, 'Hermes API server should see Pixcode MCP tools during /v1/runs.');
+assert.match(read('scripts/hermes/configure-pixcode-mcp.mjs'), /const cliToolsets = \['mcp-pixcode'\]/, 'Hermes CLI profile should use Pixcode MCP-only tools by default so provider CLIs stay visible.');
 assert.match(serverIndex, /buildHermesPathEnv\(process\.env/, 'Shell PTYs should inherit Hermes bin directories so typing hermes in Pixcode terminal works on Windows.');
 assert.match(serverIndex, /env: shellEnv/, 'Shell PTYs should use the augmented shell environment instead of raw process.env.');
 assert.doesNotMatch(serverIndex, /pixcode:hermes:start/, 'Hermes H button should not depend on a shell sentinel.');
@@ -46,7 +47,7 @@ assert.match(workbench, /HermesActivityButton/, 'Workbench activity rail should
 assert.match(workbench, /command=\{hermesCommand\}/, 'Opening the Hermes H button should show the real Hermes terminal/TUI.');
 assert.match(workbench, /bottomTerminalCommand/, 'Hermes settings should be able to launch Hermes subcommands in the bottom terminal.');
 assert.match(workbench, /openBottomTerminal\('hermes'\)/, 'Opening Hermes should restore the Hermes terminal.');
-assert.match(workbench, /openBottomTerminal\('hermes', \{ command: 'hermes', forceNewSession: true \}\)/, 'The Hermes new-session action should reset the Hermes terminal session.');
+assert.match(workbench, /openBottomTerminal\('hermes', \{[\s\S]*command: HERMES_DEFAULT_COMMAND,[\s\S]*forceNewSession: true,[\s\S]*\}\)/, 'The Hermes new-session action should reset the Hermes terminal session with the guarded default command.');
 assert.match(workbench, /installLogRef/, 'Hermes install log panel should keep a scroll ref.');
 assert.match(workbench, /scrollTop = installLogRef\.current\.scrollHeight/, 'Hermes install logs should auto-scroll to the latest line.');
 assert.doesNotMatch(workbench, /suspendAutoConnect/, 'Right CLI launches should not be blocked by an open Hermes bottom terminal.');

package/scripts/smoke/hermes-mcp-pixcode-roundtrip.mjs

@@ -122,6 +122,13 @@ const server = createServer(async (req, res) => {
         terminalState: 'busy',
         output: 'OpenAI Codex\n› /init\n\n• Ran npm test\n• Working (30s • esc to interrupt)\n',
       },
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        terminalState: 'idle',
+        output: 'OpenAI Codex\n› /init\n\n• Ran npm test\n\n› Implement {feature}\n',
+      },
       {
         active: true,
         provider: 'codex',
@@ -155,7 +162,7 @@ function callMcp(child, method, params = undefined) {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
       reject(new Error(`MCP call timed out: ${method}`));
-    }, 5000);
+    }, 10000);
     const onLine = (line) => {
       if (!line.trim()) return;
       const message = JSON.parse(line);
@@ -232,11 +239,11 @@ try {
       projectPath: '/root/pixcode',
       prompt: 'read final output',
       startupInput: '/init',
-      waitForOutputMs: 3000,
+      waitForOutputMs: 7000,
     },
   });
   assert(
-    providerOutputReads.length >= 3,
+    providerOutputReads.length >= 5,
     `readback should keep polling until the provider terminal is idle, reads=${providerOutputReads.length}`,
   );
   assert.match(

package/scripts/smoke/hermes-rest-codex-launch.mjs

@@ -72,6 +72,7 @@ const server = createServer(async (req, res) => {
       projectPath: body.projectPath,
       prompt: body.prompt,
       startupInput: body.startupInput,
+      forceNewSession: Boolean(body.forceNewSession),
       permissionMode: body.permissionMode,
       skipPermissions: Boolean(body.skipPermissions),
       bypassPermissions: Boolean(body.bypassPermissions),
@@ -175,10 +176,10 @@ try {
       instructions: [
         'You are testing Pixcode integration.',
         'Use the MCP tool named mcp_pixcode_pixcode_open_cli_terminal exactly once.',
-        'Call it with provider="codex", the supplied projectPath, startupInput equal to the supplied task, prompt="Pixcode Hermes REST smoke visible Codex task", and bypassPermissions=true.',
+        'Call it with provider="codex", the supplied projectPath, startupInput equal to the supplied task, prompt="Pixcode Hermes REST smoke visible Codex task", forceNewSession=false, and bypassPermissions=true.',
         'After the tool call, answer with "codex launch requested".',
       ].join(' '),
-      input: `Call mcp_pixcode_pixcode_open_cli_terminal with provider codex, projectPath ${JSON.stringify(projectPath)}, startupInput ${JSON.stringify(codexTask)}, prompt "Pixcode Hermes REST smoke visible Codex task", and bypassPermissions true.`,
+      input: `Call mcp_pixcode_pixcode_open_cli_terminal with provider codex, projectPath ${JSON.stringify(projectPath)}, startupInput ${JSON.stringify(codexTask)}, prompt "Pixcode Hermes REST smoke visible Codex task", forceNewSession false, and bypassPermissions true.`,
     }),
   });
   if (!response.ok || !body?.run_id) {
@@ -195,6 +196,7 @@ try {
   assert.equal(launch.bypassPermissions, true, 'Hermes Codex launch should request provider permission bypass.');
   assert.equal(launch.skipPermissions, true, 'Hermes Codex launch should carry skipPermissions for providers that use skip flags.');
   assert.equal(launch.permissionMode, 'bypassPermissions', 'Hermes Codex launch should use bypassPermissions mode.');
+  assert.equal(launch.forceNewSession, false, 'Hermes Codex launch should continue the visible provider terminal unless a fresh session is explicit.');
   console.log(JSON.stringify({
     ok: true,
     runId: body.run_id,

package/scripts/smoke/hermes-settings-commands.mjs

@@ -55,8 +55,8 @@ assert.match(
 );
 assert.match(
   workbench,
-  /HERMES_DEFAULT_COMMAND\s*=\s*'hermes --yolo'/,
-  'Hermes terminal should default to --yolo so Hermes approval prompts do not stop visible work.',
+  /HERMES_DEFAULT_COMMAND\s*=\s*'hermes --yolo --toolsets mcp-pixcode'/,
+  'Hermes terminal should default to Pixcode MCP-only toolsets so provider CLIs stay visible inside Pixcode.',
 );
 assert.match(
   serverIndex,
@@ -85,8 +85,18 @@ assert.match(
 );
 assert.match(
   pixcodeMcpServer,
-  /defaultWaitMs\s*=\s*startupInput \? 180000 : 0/,
-  'Pixcode MCP should wait for visible provider completion by default when startupInput is present.',
+  /DEFAULT_STARTUP_WAIT_MS\s*=\s*100000/,
+  'Pixcode MCP default completion wait should stay under the Hermes MCP tool timeout.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /lastStrongBusy[\s\S]+lastPrompt[\s\S]+\?\s*'busy'\s*:\s*'idle'/,
+  'Codex readback should ignore weak spinner remnants once the prompt has returned.',
+);
+assert.match(
+  serverIndex,
+  /lastStrongBusy[\s\S]+lastPrompt[\s\S]+\?\s*'busy'\s*:\s*'idle'/,
+  'Backend provider-output should ignore weak Codex spinner remnants once the prompt has returned.',
 );
 assert.match(
   pixcodeMcpServer,
@@ -98,6 +108,31 @@ assert.match(
   /requestedLaunchId[\s\S]+session\.hermesLaunchId === requestedLaunchId/,
   'Provider output API should filter by Hermes terminal launch id when supplied.',
 );
+assert.match(
+  serverIndex,
+  /lifecycleState/,
+  'Provider output API should expose provider-agnostic PTY lifecycle state instead of relying only on terminal text regex.',
+);
+assert.match(
+  serverIndex,
+  /terminalFailed/,
+  'Provider output API should expose non-zero visible terminal exits as failures for Hermes readback.',
+);
+assert.match(
+  serverIndex,
+  /existingSession[\s\S]+existingSession\.pty/,
+  'Completed visible terminal records should not be reattached as live PTYs.',
+);
+assert.match(
+  serverIndex,
+  /session\.pty\s*!==\s*shellProcess/,
+  'Stale PTY exit handlers should not mark a replacement provider session as completed or failed.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /terminalFailed/,
+  'Pixcode MCP should tell Hermes when the visible provider terminal failed.',
+);
 assert.match(
   serverIndex,
   /const hermesLaunchId = Number\.isFinite\(Number\(data\.hermesLaunchId\)\)/,
@@ -113,6 +148,21 @@ assert.match(
   /terminalState is busy|terminalState.+busy|terminal to become idle/i,
   'Pixcode MCP should not summarize the first busy terminal frame as final output.',
 );
+assert.match(
+  pixcodeMcpServer,
+  /READBACK_IDLE_STABLE_MS/,
+  'Pixcode MCP should require a stable idle readback before reporting provider output as final.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /readbackStable/,
+  'Pixcode MCP should mark whether a visible provider readback was stable before Hermes summarizes it.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /scope:\s*'user'/,
+  'Pixcode MCP provider auto-config should fall back to user scope when project scope cannot be written.',
+);
 assert.match(
   pixcodeMcpServer,
   /startup input typed into the provider CLI/,
@@ -170,14 +220,29 @@ assert.match(
 );
 assert.match(
   shellConnection,
-  /provider === 'codex'[\s\S]+startupInputRef\.current/,
-  'Codex startup input should be handled at process launch instead of typed into an already-open TUI.',
+  /provider === 'codex'[\s\S]+forceNewSessionRef\.current[\s\S]+startupInputForCommand/,
+  'Codex startup input should be passed as a process argument only for explicit fresh sessions.',
 );
 assert.match(
   shellConnection,
   /startupInput:\s*handlesStartupInputInCommand \? startupInputForCommand : null/,
   'Shell websocket init should send Codex startup input to the backend command builder.',
 );
+assert.match(
+  workbench,
+  /forceNewSession:\s*hermesCliLaunch\.forceNewSession === true/,
+  'Hermes-launched provider work should continue the current visible terminal unless forceNewSession is explicit.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /forceNewSession/,
+  'Pixcode MCP should let Hermes request a fresh visible provider session only when the user asks for one.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /continue the existing visible provider terminal/i,
+  'Pixcode MCP tool instructions should tell Hermes to continue existing visible provider terminals by default.',
+);
 assert.doesNotMatch(
   workbench,
   /hermesCliLaunch\.startupInput \? `\$\{hermesCliLaunch\.startupInput\}\\r` : null/,

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

@@ -73,13 +73,14 @@ assert.match(workbench, /isPlainShell/, 'Bottom terminal should open the selecte
 assert.doesNotMatch(workbench, /HERMES_AGENT_START_COMMAND/, 'Hermes Agent should not launch from the bottom terminal through a server-side sentinel.');
 assert.doesNotMatch(workbench, /HermesApiChatPanel|HermesTerminalTranscript/, 'Hermes Agent should use the real PTY terminal UI, not a custom REST chat transcript.');
 assert.doesNotMatch(workbench, /REST POST \/|transport=|response=|gateway=http/, 'Hermes terminal UI must not expose REST debug internals to the user.');
-assert.match(workbench, /HERMES_DEFAULT_COMMAND = 'hermes --yolo'/, 'Hermes Agent bottom panel should launch the actual `hermes` CLI in a bypass-enabled PTY.');
+assert.match(workbench, /HERMES_DEFAULT_COMMAND = 'hermes --yolo --toolsets mcp-pixcode'/, 'Hermes Agent bottom panel should launch the actual `hermes` CLI with Pixcode MCP-only tools.');
 assert.match(workbench, /HERMES_HISTORY_COMMAND = 'hermes sessions browse'/, 'Hermes terminal history should open the native interactive session picker.');
 assert.match(workbench, /onOpenHistory=\{openHermesHistory\}/, 'Hermes terminal header should wire its history button to the native Hermes sessions command.');
 assert.match(workbench, /Pixcode MCP Live/, 'Hermes terminal should show a user-facing Pixcode MCP live badge.');
 assert.doesNotMatch(workbench, /ml-auto border-blue-500\/40 bg-blue-500\/10/, 'Hermes REST panel must not use right-aligned chat bubbles.');
 assert.match(workbench, /terminal-launches\/stream/, 'Hermes CLI launch requests should arrive through an EventSource stream.');
 assert.doesNotMatch(workbench, /HERMES_TERMINAL_LAUNCH_POLL_MS|setInterval\([\s\S]*terminal-launches/, 'Hermes CLI launch requests should not be polled every few seconds.');
+assert.match(workbench, /forceNewSession:\s*hermesCliLaunch\.forceNewSession === true/, 'Hermes MCP provider launches should continue the current visible CLI session by default.');
 assert.doesNotMatch(workbench, /Project-scoped agent terminal\. Installs Hermes when missing/, 'Right CLI panel should not show the old Hermes card.');
 assert.doesNotMatch(workbench, /vscodeWorkbench\.hermes\.docsShort|HERMES_AGENT_DOCS_URL/, 'Hermes terminal header should not include a docs shortcut.');
 assert.match(workbench, /shrinkCliPanel/, 'Right CLI panel should expose a shrink action.');
@@ -135,6 +136,7 @@ assert.match(read('scripts/smoke/hermes-api-install.mjs'), /hermes API install s
 assert.match(workbench, /terminalStartupInput/, 'Hermes terminal launch prompts should be passed into the selected CLI.');
 assert.match(read('src/components/shell/hooks/useShellConnection.ts'), /startupInputRef/, 'Shell connections should support one-shot startup input for Hermes-triggered CLI work.');
 assert.match(read('src/components/shell/hooks/useShellConnection.ts'), /isCliReadyForStartupInput/, 'Hermes-triggered CLI input should wait until the provider TUI is ready.');
+assert.match(read('src/components/shell/hooks/useShellConnection.ts'), /forceNewSessionRef\.current[\s\S]+startupInputForCommand/, 'Codex startup input should only be sent as a CLI argument for explicit fresh sessions.');
 assert.doesNotMatch(read('src/components/shell/hooks/useShellConnection.ts'), /TERMINAL_INIT_DELAY_MS \* 3/, 'Hermes-triggered CLI input should not be sent on a blind fixed delay.');
 assert.match(shellTerminal, /handleTerminalPaste/, 'Terminal should support browser paste events.');
 assert.match(shellTerminal, /handleCopyPasteShortcut/, 'Terminal should normalize Ctrl/Cmd copy and paste shortcuts.');

package/scripts/smoke/tunnel-persistence.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const externalAccess = readFileSync('server/services/external-access.js', 'utf8');
+const networkRoutes = readFileSync('server/routes/network.js', 'utf8');
+const serverIndex = readFileSync('server/index.js', 'utf8');
+
+assert.match(
+  externalAccess,
+  /TUNNEL_PERSISTENCE_PATH/,
+  'Tunnel service should persist the user-requested tunnel state outside process memory.',
+);
+assert.match(
+  externalAccess,
+  /persistTunnelPreference/,
+  'Tunnel service should write tunnel start/stop intent to disk.',
+);
+assert.match(
+  externalAccess,
+  /desired:\s*true/,
+  'Starting a tunnel should mark tunnel intent as desired until the user stops it.',
+);
+assert.match(
+  externalAccess,
+  /desired:\s*false/,
+  'Stopping a tunnel should clear persisted tunnel intent.',
+);
+assert.match(
+  externalAccess,
+  /restoreRequestedTunnel/,
+  'Tunnel service should expose a startup restore hook.',
+);
+assert.match(
+  externalAccess,
+  /restoring/,
+  'Tunnel restore should distinguish automatic restart attempts from direct user starts.',
+);
+assert.match(
+  networkRoutes,
+  /persistPreference:\s*true/,
+  'Manual tunnel starts should persist the user preference through the network route.',
+);
+assert.match(
+  serverIndex,
+  /restoreRequestedTunnel/,
+  'Server startup should restore a requested tunnel after updates/restarts.',
+);
+assert.match(
+  serverIndex,
+  /restoreRequestedTunnel\(\{ port: Number\(SERVER_PORT\) \}\)/,
+  'Server startup should restore the tunnel against the current backend port.',
+);
+
+console.log('tunnel persistence smoke passed');

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

@@ -266,6 +266,12 @@ assert.match(
   'Right CLI panel should mark explicitly started new sessions so the backend does not reconnect the old PTY.',
 );
 
+assert.match(
+  workbench,
+  /forceNewSession:\s*hermesCliLaunch\.forceNewSession === true/,
+  'Hermes-triggered provider work should reuse the current visible CLI session unless a fresh session is explicitly requested.',
+);
+
 assert.match(
   workbench,
   /function WorkbenchCliPanelToolbar/,
@@ -308,8 +314,8 @@ assert.doesNotMatch(
 
 assert.match(
   workbench,
-  /HERMES_DEFAULT_COMMAND = 'hermes --yolo'/,
-  'Hermes Agent should launch the Hermes CLI directly in bypass mode.',
+  /HERMES_DEFAULT_COMMAND = 'hermes --yolo --toolsets mcp-pixcode'/,
+  'Hermes Agent should launch the Hermes CLI directly in bypass mode with only the Pixcode MCP toolset.',
 );
 
 assert.match(