@pixelbyte-software/pixcode 1.50.2 → 1.50.4

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

@@ -35,7 +35,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 can type startup input into that terminal. 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.',
+    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.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -66,7 +66,15 @@ const tools = [
         },
         waitForOutputMs: {
           type: 'number',
-          description: 'Optional milliseconds to wait and then read recent terminal output. Useful when the user asks you to report the provider output.',
+          description: 'Optional milliseconds to wait for recent terminal output. Pixcode keeps polling while terminalState is busy, so use a large value when the user asks for the final provider answer.',
+        },
+        waitForCompletionMs: {
+          type: 'number',
+          description: 'Optional explicit milliseconds to wait for the visible provider CLI to return to an idle prompt before reporting output. Overrides waitForOutputMs.',
+        },
+        launchId: {
+          type: 'number',
+          description: 'Optional Pixcode terminal launch id. Use the id returned by pixcode_open_cli_terminal when reading one specific visible terminal.',
         },
       },
       required: ['provider'],
@@ -186,15 +194,87 @@ async function readProviderStatus(provider) {
   return body?.data ?? body;
 }
 
-async function readProviderTerminalOutput(provider, projectPath, maxChars) {
+async function readProviderTerminalOutput(provider, projectPath, maxChars, launchId = null) {
   const params = new URLSearchParams({
     provider,
     maxChars: String(maxChars || 12000),
   });
   if (projectPath) params.set('projectPath', projectPath);
+  if (launchId) params.set('launchId', String(launchId));
   return pixcodeFetch(`/api/shell/sessions/provider-output?${params.toString()}`);
 }
 
+function getLastMatchIndex(text, pattern) {
+  let lastIndex = -1;
+  for (const match of text.matchAll(pattern)) {
+    lastIndex = match.index ?? lastIndex;
+  }
+  return lastIndex;
+}
+
+function inferTerminalState(provider, terminalOutput) {
+  if (!terminalOutput) return 'unknown';
+  if (typeof terminalOutput.terminalState === 'string') return terminalOutput.terminalState;
+  if (typeof terminalOutput.isBusy === 'boolean') return terminalOutput.isBusy ? 'busy' : 'idle';
+  if (terminalOutput.active === false) return terminalOutput.output ? 'idle' : 'unknown';
+
+  const output = String(terminalOutput.output || '');
+  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),
+    getLastMatchIndex(output, /\bWorking\s*\([^)]*esc to interrupt[^)]*\)/giu),
+    getLastMatchIndex(output, /\bmsg=interrupt\b/giu),
+  );
+
+  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 (lastBusy >= 0) return 'busy';
+  return 'unknown';
+}
+
+function isTerminalReadbackFinal(provider, terminalOutput) {
+  const terminalState = inferTerminalState(provider, terminalOutput);
+  return terminalState === 'idle' || terminalState === 'completed' || terminalState === 'exited';
+}
+
+async function waitForProviderTerminalOutput(provider, projectPath, waitMs, launchId = null) {
+  const startedAt = Date.now();
+  let latestOutput = null;
+  do {
+    const elapsed = Date.now() - startedAt;
+    const remaining = Math.max(0, waitMs - elapsed);
+    await sleep(Math.min(1000, Math.max(250, remaining)));
+    latestOutput = await readProviderTerminalOutput(provider, projectPath, 12000, launchId).catch((error) => ({
+      active: false,
+      terminalState: 'unknown',
+      error: error instanceof Error ? error.message : String(error),
+    }));
+
+    if (latestOutput?.output && isTerminalReadbackFinal(provider, latestOutput)) {
+      break;
+    }
+  } while (Date.now() - startedAt < waitMs);
+
+  if (latestOutput && !latestOutput.terminalState) {
+    latestOutput.terminalState = inferTerminalState(provider, latestOutput);
+  }
+  if (latestOutput && typeof latestOutput.isBusy !== 'boolean') {
+    latestOutput.isBusy = latestOutput.terminalState === 'busy';
+  }
+  return latestOutput;
+}
+
 function isLegacyPromptLikelyStartupInput(prompt) {
   if (!prompt || prompt.length > 160 || prompt.includes('\n')) return false;
   if (/^[/:!@]/u.test(prompt)) return true;
@@ -287,26 +367,27 @@ async function callTool(name, args = {}) {
         permissionMode,
       }),
     });
+    const launchId = Number(body?.event?.id || body?.id || 0) || null;
     let terminalOutput = null;
-    const waitForOutputMs = Math.min(15000, Math.max(0, Number(args.waitForOutputMs || 0)));
+    const defaultWaitMs = startupInput ? 180000 : 0;
+    const requestedWaitMs = Number(args.waitForCompletionMs ?? args.waitForOutputMs ?? defaultWaitMs);
+    const waitForOutputMs = Math.min(600000, Math.max(0, requestedWaitMs));
     if (waitForOutputMs > 0) {
-      const startedAt = Date.now();
-      do {
-        await sleep(Math.min(1000, Math.max(250, waitForOutputMs)));
-        terminalOutput = await readProviderTerminalOutput(provider, projectPath, 12000).catch((error) => ({
-          active: false,
-          error: error instanceof Error ? error.message : String(error),
-        }));
-        if (terminalOutput?.active && terminalOutput?.output) break;
-      } while (Date.now() - startedAt < waitForOutputMs);
+      terminalOutput = await waitForProviderTerminalOutput(provider, projectPath, waitForOutputMs, launchId);
     }
+    const terminalOutputFinal = terminalOutput ? isTerminalReadbackFinal(provider, terminalOutput) : false;
     return textResult(JSON.stringify({
       launched: true,
+      launchId,
       pixcodeMcpConfigured: mcpConfigured,
       pixcodeMcpError: mcpError,
       event: body?.event ?? body,
       permissionBypass: bypassPermissions,
       status,
+      terminalOutputFinal,
+      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.'
+        : undefined,
       terminalOutput,
     }, null, 2));
   }
@@ -317,7 +398,15 @@ async function callTool(name, args = {}) {
       ? args.projectPath.trim()
       : null;
     const maxChars = Math.min(20000, Math.max(1000, Number(args.maxChars || 12000)));
-    const body = await readProviderTerminalOutput(provider, projectPath, maxChars);
+    const launchId = Number(args.launchId || 0) || null;
+    const body = await readProviderTerminalOutput(provider, projectPath, maxChars, launchId);
+    if (body && !body.terminalState) {
+      body.terminalState = inferTerminalState(provider, body);
+    }
+    if (body && typeof body.isBusy !== 'boolean') {
+      body.isBusy = body.terminalState === 'busy';
+    }
+    body.terminalOutputFinal = isTerminalReadbackFinal(provider, body);
     return textResult(JSON.stringify(body, null, 2));
   }
 

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

@@ -9,6 +9,7 @@ const apiKey = 'px_smoke_key';
 const seen = [];
 const providerMcpUpserts = [];
 const terminalLaunches = [];
+const providerOutputReads = [];
 
 function readJson(req) {
   return new Promise((resolve, reject) => {
@@ -90,7 +91,7 @@ const server = createServer(async (req, res) => {
     res.statusCode = 201;
     res.end(JSON.stringify({
       event: {
-        id: 1,
+        id: terminalLaunches.length,
         provider: body.provider,
         projectPath: body.projectPath,
         prompt: body.prompt,
@@ -100,6 +101,39 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/api/shell/sessions/provider-output') {
+    providerOutputReads.push({
+      provider: url.searchParams.get('provider'),
+      projectPath: url.searchParams.get('projectPath'),
+      launchId: url.searchParams.get('launchId'),
+    });
+    const outputs = [
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        terminalState: 'busy',
+        output: 'OpenAI Codex\n› /init\n\n• Working (10s • esc to interrupt)\n',
+      },
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        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: 'Baseline check passed: npm test reports 195 passing, 0 failing.\n\n› Use /skills to list available skills\n',
+      },
+    ];
+    res.end(JSON.stringify(outputs[Math.min(providerOutputReads.length - 1, outputs.length - 1)]));
+    return;
+  }
+
   res.statusCode = 404;
   res.end(JSON.stringify({ error: url.pathname }));
 });
@@ -190,13 +224,38 @@ try {
   assert.equal(providerMcpUpserts.length, 1, 'Codex launch should upsert a project-scoped Pixcode MCP server');
   assert.equal(providerMcpUpserts[0].name, 'pixcode', 'Provider MCP server should be named pixcode');
 
+  providerOutputReads.length = 0;
+  const launchWithReadback = await callMcp(child, 'tools/call', {
+    name: 'pixcode_open_cli_terminal',
+    arguments: {
+      provider: 'codex',
+      projectPath: '/root/pixcode',
+      prompt: 'read final output',
+      startupInput: '/init',
+      waitForOutputMs: 3000,
+    },
+  });
+  assert(
+    providerOutputReads.length >= 3,
+    `readback should keep polling until the provider terminal is idle, reads=${providerOutputReads.length}`,
+  );
+  assert.match(
+    launchWithReadback.content[0].text,
+    /195 passing, 0 failing/,
+    'readback should return the final Codex output instead of the first working frame',
+  );
+  assert(
+    providerOutputReads.every((read) => read.launchId === '2'),
+    `readback should be tied to the Hermes terminal launch id, reads=${JSON.stringify(providerOutputReads)}`,
+  );
+
   const blockedLaunch = await callMcp(child, 'tools/call', {
     name: 'pixcode_open_cli_terminal',
     arguments: { provider: 'qwen', projectPath: '/root/pixcode', prompt: 'smoke' },
   });
   assert.match(blockedLaunch.content[0].text, /"launched": false/, 'uninstalled providers should not create terminal launches');
   assert.match(blockedLaunch.content[0].text, /"reason": "not_installed"/, 'uninstalled provider response should explain the block');
-  assert.equal(terminalLaunches.length, 1, 'Only the installed Codex provider should be launched');
+  assert.equal(terminalLaunches.length, 2, 'Only installed Codex provider launches should be created');
 
   assert(seen.every((entry) => entry.auth === `Bearer ${apiKey}`), 'all MCP calls should use the Pixcode bearer key');
   console.log('hermes MCP Pixcode roundtrip smoke passed');

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

@@ -84,6 +84,20 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/api/shell/sessions/provider-output') {
+    const launchId = Number(url.searchParams.get('launchId') || 0) || null;
+    res.end(JSON.stringify({
+      active: true,
+      provider: url.searchParams.get('provider') || 'codex',
+      projectPath,
+      launchId,
+      terminalState: 'idle',
+      isBusy: false,
+      output: 'Hermes launched Codex through Pixcode MCP\n\n› ',
+    }));
+    return;
+  }
+
   res.statusCode = 404;
   res.end(JSON.stringify({ error: url.pathname }));
 });

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

@@ -27,6 +27,7 @@ assert.match(settingsTab, /command:\s*'hermes model'/, 'Hermes settings should e
 assert.match(settingsTab, /command:\s*'hermes auth'/, 'Hermes settings should expose the credential manager.');
 assert.match(settingsTab, /command:\s*'hermes setup tools'/, 'Hermes settings should expose tool setup.');
 assert.match(settingsTab, /command:\s*'hermes doctor'/, 'Hermes settings should expose diagnostics.');
+assert.match(settingsTab, /command:\s*'hermes sessions browse'/, 'Hermes settings should open the interactive sessions browser, not the sessions usage screen.');
 assert.match(
   settingsTab,
   /pixcode:hermes-terminal[\s\S]+command[\s\S]+title/,
@@ -82,6 +83,36 @@ assert.match(
   /multi-step|piece-by-piece|long-running/i,
   'Pixcode MCP should tell Hermes to send arbitrary multi-step work as visible provider terminal input.',
 );
+assert.match(
+  pixcodeMcpServer,
+  /defaultWaitMs\s*=\s*startupInput \? 180000 : 0/,
+  'Pixcode MCP should wait for visible provider completion by default when startupInput is present.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /launchId/,
+  'Pixcode MCP should tie provider output readback to the terminal launch id.',
+);
+assert.match(
+  serverIndex,
+  /requestedLaunchId[\s\S]+session\.hermesLaunchId === requestedLaunchId/,
+  'Provider output API should filter by Hermes terminal launch id when supplied.',
+);
+assert.match(
+  serverIndex,
+  /const hermesLaunchId = Number\.isFinite\(Number\(data\.hermesLaunchId\)\)/,
+  'Shell backend should persist Hermes terminal launch ids on PTY sessions.',
+);
+assert.match(
+  workbench,
+  /terminalHermesLaunchId/,
+  'Workbench CLI panel should pass Hermes launch ids into provider shells.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /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,
   /startup input typed into the provider CLI/,
@@ -139,14 +170,34 @@ assert.match(
 );
 assert.match(
   shellConnection,
-  /provider === 'codex' \? '\\n' : '\\r'/,
-  'Codex startup input should submit with LF because CR can leave /init typed but unsubmitted in Codex TUI.',
+  /provider === 'codex'[\s\S]+startupInputRef\.current/,
+  'Codex startup input should be handled at process launch instead of typed into an already-open TUI.',
+);
+assert.match(
+  shellConnection,
+  /startupInput:\s*handlesStartupInputInCommand \? startupInputForCommand : null/,
+  'Shell websocket init should send Codex startup input to the backend command builder.',
 );
 assert.doesNotMatch(
   workbench,
   /hermesCliLaunch\.startupInput \? `\$\{hermesCliLaunch\.startupInput\}\\r` : null/,
   'Workbench should not pre-append CR before provider-aware startup input normalization.',
 );
+assert.match(
+  shellTypes,
+  /startupInput\?: string \| null/,
+  'Shell init messages should carry launch-time startup input for providers that accept an initial prompt.',
+);
+assert.match(
+  serverIndex,
+  /const startupInput = typeof data\.startupInput === 'string'/,
+  'Shell backend should read launch-time startup input from the websocket init payload.',
+);
+assert.match(
+  serverIndex,
+  /provider === 'codex'[\s\S]+startupInput[\s\S]+quoteShellArgForPlatform\(startupInput\)/,
+  'Codex provider terminals should start with the requested prompt as a CLI argument so banners/update notices cannot swallow Enter.',
+);
 assert.match(
   shellView,
   /permissionOverride/,

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

@@ -66,12 +66,15 @@ assert.match(workbench, /isBottomTerminalMinimized/, 'Bottom terminal should sup
 assert.match(workbench, /bottomTerminalProject/, 'Bottom terminal should stay bound to the project it was opened for.');
 assert.match(workbench, /setBottomTerminalProject/, 'Opening a bottom terminal should capture its project instead of following workspace selection changes.');
 assert.match(workbench, /terminalProject = bottomTerminalProject \?\? selectedProject/, 'Workbench should render bottom terminals against their captured project binding.');
+assert.match(workbench, /WORKBENCH_HERMES_STATE_STORAGE_KEY/, 'Hermes bottom terminal open state should be stored per workspace.');
+assert.match(workbench, /readWorkbenchHermesState/, 'Workspace switches should restore the Hermes terminal state for that project.');
+assert.match(workbench, /writeWorkbenchHermesState/, 'Opening, minimizing, and closing Hermes should persist per-project state.');
 assert.match(workbench, /isPlainShell/, 'Bottom terminal should open the selected project folder without starting the selected AI CLI.');
 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_HISTORY_COMMAND = 'hermes sessions'/, 'Hermes terminal should expose the native Hermes sessions/history command.');
+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.');
@@ -137,6 +140,7 @@ assert.match(shellTerminal, /handleTerminalPaste/, 'Terminal should support brow
 assert.match(shellTerminal, /handleCopyPasteShortcut/, 'Terminal should normalize Ctrl/Cmd copy and paste shortcuts.');
 assert.match(shellTerminal, /event\.shiftKey/, 'Terminal should support Ctrl+Shift+C/V style shortcuts.');
 assert.match(shellTerminal, /copyTerminalSelection/, 'Terminal should copy selected terminal text through shortcuts.');
+assert.match(read('src/components/shell/view/Shell.tsx'), /sendInput\(`\$\{opt\.number\}\\r`\)/, 'CLI prompt option buttons should submit the selected option with Enter, not leave the choice typed.');
 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

@@ -314,8 +314,8 @@ assert.match(
 
 assert.match(
   workbench,
-  /HERMES_HISTORY_COMMAND = 'hermes sessions'/,
-  'Hermes Agent should expose native Hermes session history from the bottom terminal.',
+  /HERMES_HISTORY_COMMAND = 'hermes sessions browse'/,
+  'Hermes Agent should expose the native interactive Hermes session browser from the bottom terminal.',
 );
 
 assert.doesNotMatch(

package/server/index.js

@@ -324,6 +324,77 @@ function killProviderPtySessions(projectPath, provider) {
     return killed;
 }
 
+function getLastRegexMatchIndex(text, pattern) {
+    let lastIndex = -1;
+    for (const match of text.matchAll(pattern)) {
+        lastIndex = match.index ?? lastIndex;
+    }
+    return lastIndex;
+}
+
+function detectProviderTerminalState(provider, output) {
+    const cleanOutput = String(output || '');
+    if (!cleanOutput.trim()) {
+        return {
+            terminalState: 'unknown',
+            isBusy: false,
+            terminalStateReason: 'empty_output',
+        };
+    }
+
+    if (/Process exited with code/iu.test(cleanOutput)) {
+        return {
+            terminalState: 'exited',
+            isBusy: false,
+            terminalStateReason: 'process_exit',
+        };
+    }
+
+    const lastBusy = Math.max(
+        getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*[•*]\s*(?:Working|Running|Thinking)\b/giu),
+        getLastRegexMatchIndex(cleanOutput, /\bWorking\s*\([^)]*esc to interrupt[^)]*\)/giu),
+        getLastRegexMatchIndex(cleanOutput, /\bmsg=interrupt\b/giu),
+    );
+
+    if (provider === 'codex') {
+        const lastPrompt = Math.max(
+            getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*›(?:\s|$)/gu),
+            getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*❯(?:\s|$)/gu),
+        );
+
+        if (lastBusy >= 0) {
+            const isBusy = lastPrompt <= lastBusy;
+            return {
+                terminalState: isBusy ? 'busy' : 'idle',
+                isBusy,
+                terminalStateReason: isBusy ? 'codex_busy_marker_after_prompt' : 'codex_prompt_after_busy_marker',
+            };
+        }
+
+        if (lastPrompt >= 0 && /(?:Initialized|Baseline check passed|I did not modify files|Use \/skills)/iu.test(cleanOutput)) {
+            return {
+                terminalState: 'idle',
+                isBusy: false,
+                terminalStateReason: 'codex_idle_prompt',
+            };
+        }
+    }
+
+    if (lastBusy >= 0) {
+        return {
+            terminalState: 'busy',
+            isBusy: true,
+            terminalStateReason: 'generic_busy_marker',
+        };
+    }
+
+    return {
+        terminalState: 'unknown',
+        isBusy: false,
+        terminalStateReason: 'no_known_marker',
+    };
+}
+
 function normalizeShellPermissionMode(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -405,6 +476,10 @@ function quotePowerShellArg(value) {
     return `"${String(value).replace(/`/g, '``').replace(/\$/g, '`$').replace(/"/g, '`"')}"`;
 }
 
+function quoteShellArgForPlatform(value) {
+    return os.platform() === 'win32' ? quotePowerShellArg(value) : quoteBashArg(value);
+}
+
 const HERMES_CLI_COMMAND_PATTERN = /^hermes(?:\s+[A-Za-z0-9._:/=@+-]+)*\s*$/;
 
 function isHermesCliCommand(command) {
@@ -528,6 +603,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
     const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.trim()
         ? req.query.projectPath.trim()
         : null;
+    const launchId = Number.parseInt(String(req.query.launchId || ''), 10);
+    const requestedLaunchId = Number.isFinite(launchId) && launchId > 0 ? launchId : null;
     const maxChars = Math.min(
         20000,
         Math.max(1000, Number.parseInt(String(req.query.maxChars || '12000'), 10) || 12000)
@@ -543,7 +620,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
         if (
             session?.provider === provider &&
             !session?.isPlainShell &&
-            (!requestedProjectPath || path.resolve(session.projectPath || os.homedir()) === requestedProjectPath)
+            (!requestedProjectPath || path.resolve(session.projectPath || os.homedir()) === requestedProjectPath) &&
+            (!requestedLaunchId || session.hermesLaunchId === requestedLaunchId)
         ) {
             if (!matchedSession || (session.updatedAt || 0) > (matchedSession.updatedAt || 0)) {
                 matchedSession = session;
@@ -556,19 +634,24 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
             active: false,
             provider,
             projectPath: requestedProjectPath,
+            launchId: requestedLaunchId,
             output: '',
             message: 'No active provider terminal session found for this project.',
         });
     }
 
     const rawOutput = matchedSession.buffer.join('').slice(-maxChars);
+    const output = stripAnsiSequences(rawOutput);
+    const terminalState = detectProviderTerminalState(provider, output);
     res.json({
         active: true,
         provider,
         projectPath: path.resolve(matchedSession.projectPath || os.homedir()),
         sessionId: matchedSession.sessionId || null,
+        launchId: matchedSession.hermesLaunchId || null,
         updatedAt: matchedSession.updatedAt || null,
-        output: stripAnsiSequences(rawOutput),
+        ...terminalState,
+        output,
     });
 });
 
@@ -2261,6 +2344,12 @@ function handleShellConnection(ws, request) {
                 const hasSession = data.hasSession;
                 const provider = data.provider || 'claude';
                 const initialCommand = data.initialCommand;
+                const startupInput = typeof data.startupInput === 'string' && data.startupInput.trim()
+                    ? data.startupInput.trim()
+                    : null;
+                const hermesLaunchId = Number.isFinite(Number(data.hermesLaunchId)) && Number(data.hermesLaunchId) > 0
+                    ? Number(data.hermesLaunchId)
+                    : null;
                 const isPlainShell = data.isPlainShell || (!!initialCommand && !hasSession) || provider === 'plain-shell';
                 const isHermesCliLaunch = isPlainShell && isHermesCliCommand(initialCommand);
                 const forceNewSession = Boolean(data.forceNewSession);
@@ -2418,6 +2507,8 @@ function handleShellConnection(ws, request) {
                             } else {
                                 shellCommand = `${command} resume "${sessionId}" || ${command}`;
                             }
+                        } else if (startupInput) {
+                            shellCommand = `${command} ${quoteShellArgForPlatform(startupInput)}`;
                         } else {
                             shellCommand = command;
                         }
@@ -2539,6 +2630,7 @@ function handleShellConnection(ws, request) {
                         timeoutId: null,
                         projectPath,
                         sessionId,
+                        hermesLaunchId,
                         provider,
                         isPlainShell,
                         keepAliveUntilExit: false,