start-command 0.25.2 → 0.25.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # start-command
 
+## 0.25.3
+
+### Patch Changes
+
+- 873781e: Record detached isolation output in the tracked log path in real time.
+
 ## 0.25.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/bin/cli.js

@@ -2,7 +2,6 @@
 
 const process = require('process');
 const os = require('os');
-const fs = require('fs');
 const path = require('path');
 
 // Import modules
@@ -20,6 +19,7 @@ const {
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   createLogPath,
   getDefaultDockerImage,
 } = require('../lib/isolation');
@@ -405,7 +405,7 @@ async function runWithIsolation(
   }
 
   // Create log file path
-  const logFilePath = createLogPath(environment || 'direct');
+  const logFilePath = createLogPath(environment || 'direct', sessionId);
 
   // Get session name (will be generated by runIsolated if not provided)
   const sessionName =
@@ -559,6 +559,8 @@ async function runWithIsolation(
     );
   }
 
+  writeLogFile(logFilePath, logContent);
+
   let result;
 
   if (environment) {
@@ -566,7 +568,7 @@ async function runWithIsolation(
     // Note: Isolation environments currently use native spawn/execSync
     // Future: Add command-stream support with raw() function for multiplexers
     result = await runIsolated(environment, cmd, {
-      session: options.session,
+      session: sessionName,
       image: effectiveImage,
       endpoint: options.endpoint,
       detached: mode === 'detached',
@@ -574,6 +576,7 @@ async function runWithIsolation(
       keepAlive: options.keepAlive,
       autoRemoveDockerContainer: options.autoRemoveDockerContainer,
       shell: options.shell,
+      logPath: logFilePath,
     });
   } else if (createdUser) {
     // Run directly as the created user (no isolation environment)
@@ -592,12 +595,13 @@ async function runWithIsolation(
   if (!result.success && result.message) {
     console.error(`Error: ${result.message}`);
   }
-  // Add result to log content
-  logContent += `${result.message}\n`;
-  logContent += createLogFooter(endTime, exitCode);
-
-  // Write log file
-  writeLogFile(logFilePath, logContent);
+  if (mode === 'detached' && result.success) {
+    appendLogFile(logFilePath, `${result.message}\n`);
+  } else {
+    // Add result to log content
+    appendLogFile(logFilePath, `${result.message}\n`);
+    appendLogFile(logFilePath, createLogFooter(endTime, exitCode));
+  }
 
   // Update execution record: detached keeps "executing" (resolved at query time)
   if (executionRecord && store) {
@@ -674,9 +678,7 @@ async function runDirect(cmd, sessionId) {
   const shellArgs = isWindows ? ['-Command', cmd] : ['-c', cmd];
 
   // Setup logging
-  const logDir = config.logDir || os.tmpdir();
-  const logFilename = generateLogFilename();
-  const logFilePath = path.join(logDir, logFilename);
+  const logFilePath = createLogPath('direct', sessionId);
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -825,9 +827,7 @@ async function runDirectWithCommandStream(
   const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
 
   // Setup logging
-  const logDir = config.logDir || os.tmpdir();
-  const logFilename = generateLogFilename();
-  const logFilePath = path.join(logDir, logFilename);
+  const logFilePath = createLogPath('direct', sessionId);
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -911,6 +911,7 @@ async function runDirectWithCommandStream(
 
   let exitCode = 0;
   try {
+    writeLogFile(logFilePath, logContent);
     // Use raw() to pass the command without auto-escaping
     // This is important for complex commands with pipes, redirects, etc.
     const result = await $cmd`${raw(cmd)}`;
@@ -924,14 +925,17 @@ async function runDirectWithCommandStream(
     // Collect output for log
     if (result.stdout) {
       logContent += result.stdout;
+      appendLogFile(logFilePath, result.stdout);
     }
     if (result.stderr) {
       logContent += result.stderr;
+      appendLogFile(logFilePath, result.stderr);
     }
   } catch (err) {
     exitCode = err.code || 1;
     const errorMessage = `Error executing command: ${err.message}`;
     logContent += `\n${errorMessage}\n`;
+    appendLogFile(logFilePath, `\n${errorMessage}\n`);
     console.error(`\n${errorMessage}`);
   }
 
@@ -944,7 +948,10 @@ async function runDirectWithCommandStream(
 
   // Write log file
   try {
-    fs.writeFileSync(logFilePath, logContent, 'utf8');
+    appendLogFile(
+      logFilePath,
+      `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`
+    );
   } catch (err) {
     console.error(`\nWarning: Could not save log file: ${err.message}`);
   }
@@ -985,13 +992,3 @@ async function runDirectWithCommandStream(
 
   process.exit(exitCode);
 }
-
-/**
- * Generate unique log filename for direct execution
- * @returns {string} Log filename
- */
-function generateLogFilename() {
-  const timestamp = Date.now();
-  const random = Math.random().toString(36).substring(2, 8);
-  return `start-command-${timestamp}-${random}.log`;
-}

package/src/lib/isolation-log-utils.js

@@ -5,6 +5,18 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+function getTempRoot() {
+  return process.env.START_TEMP_ROOT || path.join(os.tmpdir(), 'start-command');
+}
+
+function ensureDirectory(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function ensureParentDirectory(filePath) {
+  ensureDirectory(path.dirname(filePath));
+}
+
 /**
  * Generate timestamp for logging
  * @returns {string} ISO timestamp without 'T' and 'Z'
@@ -77,6 +89,7 @@ function createLogFooter(endTime, exitCode) {
  */
 function writeLogFile(logPath, content) {
   try {
+    ensureParentDirectory(logPath);
     fs.writeFileSync(logPath, content, 'utf8');
     return true;
   } catch (err) {
@@ -85,23 +98,79 @@ function writeLogFile(logPath, content) {
   }
 }
 
+/**
+ * Append to a log file, creating its parent directory when needed.
+ * @param {string} logPath - Path to log file
+ * @param {string} content - Log content to append
+ * @returns {boolean} Success status
+ */
+function appendLogFile(logPath, content) {
+  try {
+    ensureParentDirectory(logPath);
+    fs.appendFileSync(logPath, content, 'utf8');
+    return true;
+  } catch (err) {
+    console.error(`\nWarning: Could not append log file: ${err.message}`);
+    return false;
+  }
+}
+
 /**
  * Get log directory from environment or use system temp
  * @returns {string} Log directory path
  */
 function getLogDir() {
-  return process.env.START_LOG_DIR || os.tmpdir();
+  return process.env.START_LOG_DIR || path.join(getTempRoot(), 'logs');
+}
+
+/**
+ * Get a start-command temporary directory for sidecar files.
+ * @param {...string} segments - Optional path segments below the temp directory
+ * @returns {string} Directory path
+ */
+function getTempDir(...segments) {
+  const dir = path.join(getTempRoot(), 'tmp', ...segments);
+  ensureDirectory(dir);
+  return dir;
 }
 
 /**
  * Create log file path
  * @param {string} environment - The isolation environment
+ * @param {string|null} executionId - Optional execution UUID/session ID
  * @returns {string} Full path to log file
  */
-function createLogPath(environment) {
+function createLogPath(environment, executionId = null) {
   const logDir = getLogDir();
+  if (executionId) {
+    return environment === 'direct'
+      ? path.join(logDir, 'direct', `${executionId}.log`)
+      : path.join(logDir, 'isolation', environment, `${executionId}.log`);
+  }
   const logFilename = generateLogFilename(environment);
-  return path.join(logDir, logFilename);
+  return environment === 'direct'
+    ? path.join(logDir, 'direct', logFilename)
+    : path.join(logDir, 'isolation', environment, logFilename);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function createShellLogFooterSnippet() {
+  const dateCommand =
+    "date '+%Y-%m-%d %H:%M:%S.%3N' 2>/dev/null || date '+%Y-%m-%d %H:%M:%S'";
+  return `printf '\\n==================================================\\nFinished: %s\\nExit Code: %s\\n' "$(${dateCommand})" "$__start_command_exit"`;
+}
+
+function wrapCommandWithLogFooter(command, options = {}) {
+  const shell = options.shell || 'sh';
+  const keepAlive = Boolean(options.keepAlive);
+  const footer = createShellLogFooterSnippet();
+  const afterFooter = keepAlive
+    ? `exec ${shellQuote(shell)}`
+    : 'exit "$__start_command_exit"';
+  return `(${command}); __start_command_exit=$?; ${footer}; ${afterFooter}`;
 }
 
 /**
@@ -136,12 +205,20 @@ function runAsIsolatedUser(cmd, username) {
 }
 
 module.exports = {
+  getTempRoot,
+  ensureDirectory,
+  ensureParentDirectory,
   getTimestamp,
   generateLogFilename,
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   getLogDir,
+  getTempDir,
   createLogPath,
+  shellQuote,
+  createShellLogFooterSnippet,
+  wrapCommandWithLogFooter,
   runAsIsolatedUser,
 };

package/src/lib/isolation.js

@@ -13,8 +13,15 @@ const {
   getScreenVersion,
   supportsLogfileOption,
   runScreenWithLogCapture: _runScreenWithLogCapture,
+  startDetachedScreenWithLogCapture,
   resetScreenVersionCache,
 } = require('./screen-isolation');
+const {
+  appendLogFile,
+  createShellLogFooterSnippet,
+  shellQuote,
+  wrapCommandWithLogFooter,
+} = require('./isolation-log-utils');
 
 /**
  * Check if a command is available on the system
@@ -170,14 +177,21 @@ function wrapCommandWithUser(command, user) {
  * @param {string|null} user - Username to run command as (optional)
  * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string}>}
  */
-function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
+function runScreenWithLogCapture(
+  command,
+  sessionName,
+  shellInfo,
+  user = null,
+  logPath = null
+) {
   return _runScreenWithLogCapture(
     command,
     sessionName,
     shellInfo,
     user,
     wrapCommandWithUser,
-    isInteractiveShellCommand
+    isInteractiveShellCommand,
+    logPath
   );
 }
 
@@ -199,54 +213,24 @@ function runInScreen(command, options = {}) {
 
   const sessionName = options.session || generateSessionName('screen');
   const shellInfo = getShell();
-  const { shell, shellArg } = shellInfo;
 
   try {
-    // Wrap command with user switch if specified
-    let effectiveCommand = wrapCommandWithUser(command, options.user);
-
     if (options.detached) {
-      if (options.keepAlive) {
-        effectiveCommand = `${effectiveCommand}; exec ${shell}`;
-      }
-
-      const screenArgs = isInteractiveShellCommand(command)
-        ? ['-dmS', sessionName, ...command.trim().split(/\s+/)]
-        : ['-dmS', sessionName, shell, shellArg, effectiveCommand];
-
-      if (DEBUG) {
-        console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
-        console.log(`[DEBUG] keepAlive: ${options.keepAlive || false}`);
-      }
-
-      // Use spawnSync with array args (not execSync string) to avoid quoting issues (issue #25)
-      const result = spawnSync('screen', screenArgs, {
-        stdio: 'inherit',
-      });
-
-      if (result.error) {
-        throw result.error;
-      }
-
-      let message = `Command started in detached screen session: ${sessionName}`;
-      if (options.keepAlive) {
-        message += `\nSession will stay alive after command completes.`;
-      } else {
-        message += `\nSession will exit automatically after command completes.`;
-      }
-      message += `\nReattach with: screen -r ${sessionName}`;
-
-      return Promise.resolve({
-        success: true,
-        sessionName,
-        message,
-      });
+      return Promise.resolve(
+        startDetachedScreenWithLogCapture(command, sessionName, shellInfo, {
+          user: options.user,
+          keepAlive: options.keepAlive,
+          logPath: options.logPath,
+          wrapCommandWithUser,
+        })
+      );
     } else {
       return runScreenWithLogCapture(
         command,
         sessionName,
         shellInfo,
-        options.user
+        options.user,
+        options.logPath
       );
     }
   } catch (err) {
@@ -294,12 +278,40 @@ function runInTmux(command, options = {}) {
         console.log(`[DEBUG] keepAlive: ${options.keepAlive || false}`);
       }
 
-      execSync(
-        `tmux new-session -d -s "${sessionName}" "${effectiveCommand}"`,
-        {
+      if (options.logPath) {
+        const loggedCommand = wrapCommandWithLogFooter(effectiveCommand, {
+          shell,
+          keepAlive: options.keepAlive,
+        });
+        spawnSync('tmux', ['new-session', '-d', '-s', sessionName, shell], {
           stdio: 'inherit',
-        }
-      );
+        });
+        spawnSync(
+          'tmux',
+          [
+            'pipe-pane',
+            '-t',
+            sessionName,
+            '-o',
+            `cat >> ${shellQuote(options.logPath)}`,
+          ],
+          { stdio: 'inherit' }
+        );
+        spawnSync(
+          'tmux',
+          ['send-keys', '-t', sessionName, loggedCommand, 'C-m'],
+          {
+            stdio: 'inherit',
+          }
+        );
+      } else {
+        execSync(
+          `tmux new-session -d -s "${sessionName}" "${effectiveCommand}"`,
+          {
+            stdio: 'inherit',
+          }
+        );
+      }
 
       let message = `Command started in detached tmux session: ${sessionName}`;
       if (options.keepAlive) {
@@ -401,8 +413,8 @@ function runInSsh(command, options = {}) {
         ? `${remoteShell} ${shellInteractiveFlag}`
         : remoteShell;
       const remoteCommand = isInteractiveShellCommand(command)
-        ? `nohup ${command} > /tmp/${sessionName}.log 2>&1 &`
-        : `nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/${sessionName}.log 2>&1 &`;
+        ? `mkdir -p /tmp/start-command/logs/isolation/ssh && nohup ${command} > /tmp/start-command/logs/isolation/ssh/${sessionName}.log 2>&1 &`
+        : `mkdir -p /tmp/start-command/logs/isolation/ssh && nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/start-command/logs/isolation/ssh/${sessionName}.log 2>&1 &`;
       const sshArgs = [sshTarget, remoteCommand];
 
       if (DEBUG) {
@@ -419,7 +431,7 @@ function runInSsh(command, options = {}) {
       return Promise.resolve({
         success: true,
         sessionName,
-        message: `Command started in detached SSH session on ${sshTarget}\nSession: ${sessionName}\nView logs: ssh ${sshTarget} "tail -f /tmp/${sessionName}.log"`,
+        message: `Command started in detached SSH session on ${sshTarget}\nSession: ${sessionName}\nView logs: ssh ${sshTarget} "tail -f /tmp/start-command/logs/isolation/ssh/${sessionName}.log"`,
       });
     } else {
       const extraFlags = shellInteractiveFlag ? [shellInteractiveFlag] : [];
@@ -568,6 +580,19 @@ function runInDocker(command, options = {}) {
         encoding: 'utf8',
       }).trim();
 
+      if (options.logPath) {
+        const loggerScript = [
+          `docker logs -f ${shellQuote(containerName)} >> ${shellQuote(options.logPath)} 2>&1`,
+          `__start_command_exit=$(docker inspect -f '{{.State.ExitCode}}' ${shellQuote(containerName)} 2>/dev/null || printf '%s' '-1')`,
+          `${createShellLogFooterSnippet()} >> ${shellQuote(options.logPath)}`,
+        ].join('; ');
+        const logger = spawn('sh', ['-c', loggerScript], {
+          detached: true,
+          stdio: 'ignore',
+        });
+        logger.unref();
+      }
+
       let message = `Command started in detached docker container: ${containerName}`;
       message += `\nContainer ID: ${containerId.substring(0, 12)}`;
       if (options.keepAlive) {
@@ -582,6 +607,9 @@ function runInDocker(command, options = {}) {
       }
       message += `\nAttach with: docker attach ${containerName}`;
       message += `\nView logs: docker logs ${containerName}`;
+      if (options.logPath) {
+        message += `\nLive log: ${options.logPath}`;
+      }
 
       return Promise.resolve({
         success: true,
@@ -696,6 +724,7 @@ function runIsolated(backend, command, options = {}) {
       ? options.endpointStack[0]
       : options.endpoint,
     session: options.sessionStack ? options.sessionStack[0] : options.session,
+    logPath: options.logPath,
   };
 
   switch (backend) {
@@ -746,6 +775,7 @@ module.exports = {
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   getLogDir,
   createLogPath,
   getScreenVersion,

package/src/lib/screen-isolation.js

@@ -2,8 +2,12 @@
 
 const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const {
+  ensureParentDirectory,
+  getTempDir,
+  wrapCommandWithLogFooter,
+} = require('./isolation-log-utils');
 
 const setTimeout = globalThis.setTimeout;
 
@@ -131,14 +135,21 @@ function runScreenWithLogCapture(
   shellInfo,
   user = null,
   wrapCommandWithUser,
-  isInteractiveShellCommand
+  isInteractiveShellCommand,
+  logPath = null
 ) {
   const { shell, shellArg } = shellInfo;
-  const logFile = path.join(os.tmpdir(), `screen-output-${sessionName}.log`);
+  const screenTempDir = getTempDir('isolation', 'screen');
+  const logFile =
+    logPath || path.join(screenTempDir, `screen-output-${sessionName}.log`);
+  const shouldCleanupLogFile = !logPath;
   const exitCodeFile = path.join(
-    os.tmpdir(),
+    screenTempDir,
     `screen-exit-${sessionName}.code`
   );
+  ensureParentDirectory(logFile);
+  const logStartOffset =
+    logPath && fs.existsSync(logFile) ? fs.statSync(logFile).size : 0;
 
   return new Promise((resolve) => {
     try {
@@ -159,7 +170,7 @@ function runScreenWithLogCapture(
       // - `logfile <path>` sets the output log path (replaces -Logfile CLI option)
       // - `logfile flush 0` forces immediate buffer flush (prevents output loss)
       // - `deflog on` enables logging for any subsequently created windows
-      const screenrcFile = path.join(os.tmpdir(), `screenrc-${sessionName}`);
+      const screenrcFile = path.join(screenTempDir, `screenrc-${sessionName}`);
       const screenrcContent = [
         `logfile ${logFile}`,
         'logfile flush 0',
@@ -243,7 +254,7 @@ function runScreenWithLogCapture(
 
         let output = '';
         try {
-          output = fs.readFileSync(logFile, 'utf8');
+          output = fs.readFileSync(logFile, 'utf8').slice(logStartOffset);
         } catch {
           // Log file might not exist if command produced no output
         }
@@ -313,7 +324,10 @@ function runScreenWithLogCapture(
 
       // Clean up temp files
       const cleanupTempFiles = () => {
-        for (const f of [logFile, screenrcFile, exitCodeFile]) {
+        const filesToRemove = shouldCleanupLogFile
+          ? [logFile, screenrcFile, exitCodeFile]
+          : [screenrcFile, exitCodeFile];
+        for (const f of filesToRemove) {
           try {
             fs.unlinkSync(f);
           } catch {
@@ -392,6 +406,105 @@ function runScreenWithLogCapture(
   });
 }
 
+/**
+ * Start a detached GNU Screen session with live command output appended to logPath.
+ * The command itself prints the final footer through the terminal so screen writes it
+ * after the command output in the same log stream.
+ */
+function startDetachedScreenWithLogCapture(
+  command,
+  sessionName,
+  shellInfo,
+  options = {}
+) {
+  const { shell, shellArg } = shellInfo;
+  const {
+    user = null,
+    keepAlive = false,
+    logPath = null,
+    wrapCommandWithUser,
+  } = options;
+
+  const screenTempDir = getTempDir('isolation', 'screen');
+  const logFile =
+    logPath || path.join(screenTempDir, `screen-output-${sessionName}.log`);
+  ensureParentDirectory(logFile);
+
+  const screenrcFile = path.join(screenTempDir, `screenrc-${sessionName}`);
+  const screenrcContent = [
+    `logfile ${logFile}`,
+    'logfile flush 0',
+    'deflog on',
+    '',
+  ].join('\n');
+
+  try {
+    fs.writeFileSync(screenrcFile, screenrcContent);
+  } catch (err) {
+    return {
+      success: false,
+      sessionName,
+      message: `Failed to create screenrc for logging: ${err.message}`,
+    };
+  }
+
+  const effectiveCommand = wrapCommandWithLogFooter(
+    wrapCommandWithUser ? wrapCommandWithUser(command, user) : command,
+    { shell, keepAlive }
+  );
+  const screenArgs = [
+    '-dmS',
+    sessionName,
+    '-L',
+    '-c',
+    screenrcFile,
+    shell,
+    shellArg,
+    effectiveCommand,
+  ];
+
+  if (isDebug()) {
+    console.error(`[screen-isolation] Running: screen ${screenArgs.join(' ')}`);
+    console.error(`[screen-isolation] screenrc: ${screenrcContent.trim()}`);
+    console.error(`[screen-isolation] Log file: ${logFile}`);
+  }
+
+  try {
+    const result = spawnSync('screen', screenArgs, { stdio: 'inherit' });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      return {
+        success: false,
+        sessionName,
+        message: `Failed to start screen session (exit code ${result.status})`,
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      sessionName,
+      message: `Failed to run in screen: ${err.message}`,
+    };
+  }
+
+  let message = `Command started in detached screen session: ${sessionName}`;
+  if (keepAlive) {
+    message += `\nSession will stay alive after command completes.`;
+  } else {
+    message += `\nSession will exit automatically after command completes.`;
+  }
+  message += `\nReattach with: screen -r ${sessionName}`;
+  message += `\nLive log: ${logFile}`;
+
+  return {
+    success: true,
+    sessionName,
+    message,
+  };
+}
+
 /** Reset screen version cache (useful for testing) */
 function resetScreenVersionCache() {
   cachedScreenVersion = null;
@@ -402,5 +515,6 @@ module.exports = {
   getScreenVersion,
   supportsLogfileOption,
   runScreenWithLogCapture,
+  startDetachedScreenWithLogCapture,
   resetScreenVersionCache,
 };

package/src/lib/spawn-helpers.js

@@ -11,6 +11,20 @@
 
 const { spawn } = require('child_process');
 const fs = require('fs');
+const path = require('path');
+
+function ensureParentDirectory(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function writeInitialLog(logFilePath, logContent) {
+  ensureParentDirectory(logFilePath);
+  fs.writeFileSync(logFilePath, logContent || '', 'utf8');
+}
+
+function appendLog(logFilePath, content) {
+  fs.appendFileSync(logFilePath, content, 'utf8');
+}
 
 /**
  * Run command using Bun.spawn (for Bun runtime)
@@ -44,6 +58,8 @@ async function runWithBunSpawn(options) {
   let logContent = options.logContent || '';
 
   try {
+    writeInitialLog(logFilePath, logContent);
+
     // Spawn the process using Bun's native API
     const proc = Bun.spawn([shell, ...shellArgs], {
       stdout: 'pipe',
@@ -87,6 +103,7 @@ async function runWithBunSpawn(options) {
           }
           const text = decoder.decode(value);
           process.stdout.write(text);
+          appendLog(logFilePath, text);
           output += text;
         }
       } catch (err) {
@@ -109,6 +126,7 @@ async function runWithBunSpawn(options) {
           }
           const text = decoder.decode(value);
           process.stderr.write(text);
+          appendLog(logFilePath, text);
           output += text;
         }
       } catch (err) {
@@ -133,12 +151,11 @@ async function runWithBunSpawn(options) {
     const durationMs = Date.now() - startTimeMs;
     const endTime = new Date().toISOString().replace('T', ' ').substring(0, 23);
 
-    // Write log file
+    // Write log footer
     try {
-      logContent += `\n${'='.repeat(50)}\n`;
-      logContent += `Finished: ${endTime}\n`;
-      logContent += `Exit Code: ${exitCode}\n`;
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      const footer = `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`;
+      logContent += footer;
+      appendLog(logFilePath, footer);
     } catch (err) {
       console.error(`\nWarning: Could not save log file: ${err.message}`);
     }
@@ -175,7 +192,7 @@ async function runWithBunSpawn(options) {
 
     // Write log file
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      writeInitialLog(logFilePath, logContent);
     } catch (writeErr) {
       console.error(`\nWarning: Could not save log file: ${writeErr.message}`);
     }
@@ -223,6 +240,7 @@ function runWithNodeSpawn(options) {
   } = options;
 
   let logContent = options.logContent || '';
+  writeInitialLog(logFilePath, logContent);
 
   // Execute the command with captured output
   const child = spawn(shell, shellArgs, {
@@ -248,6 +266,7 @@ function runWithNodeSpawn(options) {
   child.stdout.on('data', (data) => {
     const text = data.toString();
     process.stdout.write(text);
+    appendLog(logFilePath, text);
     logContent += text;
   });
 
@@ -255,6 +274,7 @@ function runWithNodeSpawn(options) {
   child.stderr.on('data', (data) => {
     const text = data.toString();
     process.stderr.write(text);
+    appendLog(logFilePath, text);
     logContent += text;
   });
 
@@ -272,9 +292,12 @@ function runWithNodeSpawn(options) {
     logContent += `Finished: ${endTime}\n`;
     logContent += `Exit Code: ${exitCode}\n`;
 
-    // Write log file
+    // Write log footer
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      appendLog(
+        logFilePath,
+        `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`
+      );
     } catch (err) {
       console.error(`\nWarning: Could not save log file: ${err.message}`);
     }
@@ -312,7 +335,7 @@ function runWithNodeSpawn(options) {
 
     // Write log file
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      writeInitialLog(logFilePath, logContent);
     } catch (writeErr) {
       console.error(`\nWarning: Could not save log file: ${writeErr.message}`);
     }

package/src/lib/status-formatter.js

@@ -8,6 +8,7 @@
  */
 
 const { execSync } = require('child_process');
+const fs = require('fs');
 const {
   escapeForLinksNotation,
   formatAsNestedLinksNotation,
@@ -72,6 +73,22 @@ function isDetachedSessionAlive(record) {
   }
 }
 
+function readExitCodeFromLog(logPath) {
+  if (!logPath) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(logPath, 'utf8');
+    const matches = [...content.matchAll(/Exit Code:\s*(-?\d+)/g)];
+    if (matches.length === 0) {
+      return null;
+    }
+    return parseInt(matches[matches.length - 1][1], 10);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Enrich execution record with live session status for detached executions.
  * If a record shows "executing" but the detached session has actually ended,
@@ -99,7 +116,7 @@ function enrichDetachedStatus(record) {
     // Session ended but record says executing - correct it
     enriched.status = 'executed';
     if (enriched.exitCode === null || enriched.exitCode === undefined) {
-      enriched.exitCode = -1; // Unknown exit code
+      enriched.exitCode = readExitCodeFromLog(enriched.logPath) ?? -1;
     }
     if (!enriched.endTime) {
       enriched.endTime = new Date().toISOString();

package/test/isolation-log-utils.test.js

@@ -14,6 +14,7 @@ const {
   createLogFooter,
   getLogDir,
   createLogPath,
+  getTempRoot,
 } = require('../src/lib/isolation-log-utils');
 
 describe('isolation-log-utils', () => {
@@ -194,13 +195,12 @@ describe('isolation-log-utils', () => {
       }
     });
 
-    it('should fall back to os.tmpdir() when START_LOG_DIR is not set', () => {
-      const os = require('os');
+    it('should fall back to /tmp/start-command/logs when START_LOG_DIR is not set', () => {
       const original = process.env.START_LOG_DIR;
       delete process.env.START_LOG_DIR;
       try {
         const dir = getLogDir();
-        assert.strictEqual(dir, os.tmpdir());
+        assert.strictEqual(dir, path.join(getTempRoot(), 'logs'));
       } finally {
         if (original !== undefined) {
           process.env.START_LOG_DIR = original;
@@ -230,5 +230,19 @@ describe('isolation-log-utils', () => {
       const logPath = createLogPath('screen');
       assert.ok(logPath.startsWith(logDir));
     });
+
+    it('should create stable isolation log path when execution id is provided', () => {
+      const logPath = createLogPath('screen', 'uuid-123');
+      assert.ok(
+        logPath.endsWith(
+          path.join('logs', 'isolation', 'screen', 'uuid-123.log')
+        )
+      );
+    });
+
+    it('should create stable direct log path without duplicated environment segment', () => {
+      const logPath = createLogPath('direct', 'uuid-123');
+      assert.ok(logPath.endsWith(path.join('logs', 'direct', 'uuid-123.log')));
+    });
   });
 });

package/test/screen-integration.test.js

@@ -7,9 +7,27 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
-const { execSync } = require('child_process');
+const { execSync, spawnSync } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const { isCommandAvailable, runInScreen } = require('../src/lib/isolation');
 
+function waitForFileContent(filePath, predicate, timeoutMs = 5000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      if (predicate(content)) {
+        return content;
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+}
+
 describe('Screen Integration Tests', () => {
   describe('runInScreen (if available)', () => {
     it('should run command in detached screen session', async () => {
@@ -38,6 +56,85 @@ describe('Screen Integration Tests', () => {
       }
     });
 
+    it('should stream detached screen output to the tracked CLI log path', () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const executionId = crypto.randomUUID();
+      const sessionName = `test-screen-log-${Date.now()}`;
+      const appFolder = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'start-command-test-store-')
+      );
+      const cliPath = path.join(__dirname, '..', 'src', 'bin', 'cli.js');
+      const command =
+        'printf "detached-log-test-1\\n"; sleep 0.2; printf "detached-log-test-2\\n"';
+
+      const result = spawnSync(
+        process.execPath,
+        [
+          cliPath,
+          '--session-id',
+          executionId,
+          '-i',
+          'screen',
+          '-d',
+          '--session',
+          sessionName,
+          '--',
+          command,
+        ],
+        {
+          encoding: 'utf8',
+          env: {
+            ...process.env,
+            START_APP_FOLDER: appFolder,
+            START_DISABLE_AUTO_ISSUE: '1',
+          },
+        }
+      );
+
+      assert.strictEqual(
+        result.status,
+        0,
+        `CLI failed:\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`
+      );
+
+      const logPathMatch = result.stdout.match(/│ log\s+(.+)/);
+      assert.ok(result.stdout.includes(`│ screen    ${sessionName}`));
+      assert.ok(logPathMatch, `Expected log path in output:\n${result.stdout}`);
+
+      const logPath = logPathMatch[1].trim();
+      assert.ok(
+        logPath.endsWith(
+          path.join('logs', 'isolation', 'screen', `${executionId}.log`)
+        ),
+        `Unexpected log path: ${logPath}`
+      );
+
+      const logContent = waitForFileContent(
+        logPath,
+        (content) =>
+          content.includes('detached-log-test-1') &&
+          content.includes('detached-log-test-2') &&
+          content.includes('Exit Code: 0')
+      );
+
+      assert.ok(
+        logContent.includes('detached-log-test-1'),
+        `Missing first output line in log:\n${logContent}`
+      );
+      assert.ok(
+        logContent.includes('detached-log-test-2'),
+        `Missing second output line in log:\n${logContent}`
+      );
+      assert.ok(
+        logContent.includes('Command started in detached screen session'),
+        `Missing detached start message in log:\n${logContent}`
+      );
+    });
+
     it('should run command in attached mode and capture output (issue #15)', async () => {
       if (!isCommandAvailable('screen')) {
         console.log('  Skipping: screen not installed');