start-command 0.24.9 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # start-command
 
+## 0.25.0
+
+### Minor Changes
+
+- c0b3a03: fix: use screenrc-based logging for all screen versions (issue #96)
+
+  The previous fix (v0.24.9) used `-L -Logfile` for screen >= 4.5.1 and tee fallback
+  for older versions. The tee fallback failed on macOS with screen 4.00.03 because
+  tee's write buffers weren't flushed before the session ended.
+
+  The new approach uses screenrc directives (`logfile`, `logfile flush 0`, `deflog on`)
+  that work on ALL screen versions, eliminating both the version-dependent branching
+  and the unreliable tee fallback entirely.
+
+  Additional improvements:
+  - **Exit code capture**: Commands now report their actual exit code via a sidecar
+    file, instead of always reporting 0.
+  - **Enhanced retry logic**: 3 retries with increasing delays (50/100/200ms) instead
+    of a single 50ms retry.
+  - **Better debug output**: Screen isolation debug messages respond to both
+    `START_DEBUG` and `START_VERBOSE` environment variables.
+  - **New tests**: Exit code capture, stderr capture, and multi-line output verification
+    in both JavaScript and Rust.
+
+  Fixes #96
+
 ## 0.24.9
 
 ### Patch Changes

package/package.json

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

package/src/lib/args-parser.js

@@ -18,6 +18,7 @@
  * --auto-remove-docker-container   Automatically remove docker container after exit (disabled by default)
  * --shell <shell>                  Shell to use in isolation environments: auto, bash, zsh, sh (default: auto)
  * --use-command-stream             Use command-stream library for command execution (experimental)
+ * --verbose                        Enable verbose/debug output (sets START_VERBOSE=1)
  * --status <uuid>                  Show status of a previous command execution by UUID
  * --output-format <format>         Output format for status (links-notation, json, text)
  * --cleanup                        Clean up stale "executing" records (processes that crashed or were killed)
@@ -395,6 +396,12 @@ function parseOption(args, index, options) {
     return 1;
   }
 
+  // --verbose (enable verbose/debug output, sets START_VERBOSE env var)
+  if (arg === '--verbose') {
+    process.env.START_VERBOSE = '1';
+    return 1;
+  }
+
   // --session-id or --session-name (alias) <uuid>
   if (arg === '--session-id' || arg === '--session-name') {
     if (index + 1 < args.length && !args[index + 1].startsWith('-')) {

package/src/lib/screen-isolation.js

@@ -7,9 +7,16 @@ const path = require('path');
 
 const setTimeout = globalThis.setTimeout;
 
-// Debug mode from environment
-const DEBUG =
-  process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
+// Debug mode from environment (START_DEBUG or START_VERBOSE).
+// Evaluated as a function so that env vars set after module load (e.g., by --verbose flag) are respected.
+function isDebug() {
+  return (
+    process.env.START_DEBUG === '1' ||
+    process.env.START_DEBUG === 'true' ||
+    process.env.START_VERBOSE === '1' ||
+    process.env.START_VERBOSE === 'true'
+  );
+}
 
 // Cache for screen version detection
 let cachedScreenVersion = null;
@@ -40,17 +47,17 @@ function getScreenVersion() {
         patch: parseInt(match[3], 10),
       };
 
-      if (DEBUG) {
-        console.log(
-          `[DEBUG] Detected screen version: ${cachedScreenVersion.major}.${cachedScreenVersion.minor}.${cachedScreenVersion.patch}`
+      if (isDebug()) {
+        console.error(
+          `[screen-isolation] Detected screen version: ${cachedScreenVersion.major}.${cachedScreenVersion.minor}.${cachedScreenVersion.patch}`
         );
       }
 
       return cachedScreenVersion;
     }
   } catch {
-    if (DEBUG) {
-      console.log('[DEBUG] Could not detect screen version');
+    if (isDebug()) {
+      console.error('[screen-isolation] Could not detect screen version');
     }
   }
 
@@ -90,14 +97,33 @@ function supportsLogfileOption() {
 
 /**
  * Run command in GNU Screen using detached mode with log capture.
- * Supports screen >= 4.5.1 (native -Logfile) and older versions (tee fallback).
+ *
+ * Uses a unified approach combining the `-L` flag with screenrc directives:
+ * - `-L` flag enables logging for the initial window (available on ALL screen versions)
+ * - `logfile <path>` in screenrc sets the log file path (replaces `-Logfile` CLI option)
+ * - `logfile flush 0` forces immediate flushing (no 10-second delay)
+ * - `deflog on` enables logging for any additional windows
+ *
+ * Key insight: `deflog on` only applies to windows created AFTER screenrc processing,
+ * but the default window is created BEFORE screenrc is processed. The `-L` flag is
+ * needed to enable logging for that initial window. Without it, output is silently
+ * lost on macOS screen 4.00.03 (issue #96).
+ *
+ * This replaces the previous version-dependent approach that used:
+ * - `-L -Logfile` for screen >= 4.5.1 (native logging)
+ * - `tee` fallback for screen < 4.5.1 (e.g., macOS bundled 4.0.3)
+ *
+ * The tee fallback had reliability issues on macOS because:
+ * - tee's write buffers may not be flushed before the session ends
+ * - The TOCTOU race between session detection and file read was hard to mitigate
+ *
  * @param {string} command - Command to execute
  * @param {string} sessionName - Session name
  * @param {object} shellInfo - Shell info from getShell()
  * @param {string|null} user - Username to run command as (optional)
  * @param {Function} wrapCommandWithUser - Function to wrap command with user
  * @param {Function} isInteractiveShellCommand - Function to check if command is interactive shell
- * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string}>}
+ * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string, exitCode: number}>}
  */
 function runScreenWithLogCapture(
   command,
@@ -109,63 +135,93 @@ function runScreenWithLogCapture(
 ) {
   const { shell, shellArg } = shellInfo;
   const logFile = path.join(os.tmpdir(), `screen-output-${sessionName}.log`);
-
-  // Check if screen supports -Logfile option (added in 4.5.1)
-  const useNativeLogging = supportsLogfileOption();
+  const exitCodeFile = path.join(
+    os.tmpdir(),
+    `screen-exit-${sessionName}.code`
+  );
 
   return new Promise((resolve) => {
     try {
-      let screenArgs;
       // Wrap command with user switch if specified
       let effectiveCommand = wrapCommandWithUser(command, user);
 
-      // Temporary screenrc file for native logging path (issue #96)
-      // Setting logfile flush 0 forces screen to flush its log buffer after every write,
-      // preventing output loss for quick-completing commands like `agent --version`.
-      // Without this, screen buffers log writes and flushes every 10 seconds by default.
-      let screenrcFile = null;
-
-      if (useNativeLogging) {
-        // Modern screen (>= 4.5.1): Use -L -Logfile option for native log capture
-        // Use a temporary screenrc with `logfile flush 0` to force immediate log flushing
-        // (issue #96: quick commands like `agent --version` lose output without this)
-        screenrcFile = path.join(os.tmpdir(), `screenrc-${sessionName}`);
-        try {
-          fs.writeFileSync(screenrcFile, 'logfile flush 0\n');
-        } catch {
-          // If we can't create the screenrc, proceed without it (best effort)
-          screenrcFile = null;
-        }
+      // Wrap command to capture exit code in a sidecar file.
+      // We save $? after the command completes so we can report the real exit code
+      // instead of always assuming 0 (previous behavior).
+      const isBareShell = isInteractiveShellCommand(command);
+      if (!isBareShell) {
+        effectiveCommand = `${effectiveCommand}; echo $? > "${exitCodeFile}"`;
+      }
 
-        // screen -dmS <session> -c <screenrc> -L -Logfile <logfile> <shell> -c '<command>'
-        const logArgs = screenrcFile
-          ? ['-dmS', sessionName, '-c', screenrcFile, '-L', '-Logfile', logFile]
-          : ['-dmS', sessionName, '-L', '-Logfile', logFile];
-        screenArgs = isInteractiveShellCommand(command)
-          ? [...logArgs, ...command.trim().split(/\s+/)]
-          : [...logArgs, shell, shellArg, effectiveCommand];
-
-        if (DEBUG) {
-          console.log(
-            `[DEBUG] Running screen with native log capture (-Logfile): screen ${screenArgs.join(' ')}`
+      // Create temporary screenrc with logging configuration.
+      // Combined with the -L flag (which enables logging for the initial window),
+      // these directives work on ALL screen versions (including macOS 4.00.03):
+      // - `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 screenrcContent = [
+        `logfile ${logFile}`,
+        'logfile flush 0',
+        'deflog on',
+        '',
+      ].join('\n');
+
+      try {
+        fs.writeFileSync(screenrcFile, screenrcContent);
+      } catch (err) {
+        if (isDebug()) {
+          console.error(
+            `[screen-isolation] Failed to create screenrc: ${err.message}`
           );
         }
-      } else {
-        // Older screen (< 4.5.1, e.g., macOS bundled 4.0.3): Use tee fallback
-        // The parentheses ensure proper grouping of the command and its stderr
-        const isBareShell = isInteractiveShellCommand(command);
-        if (!isBareShell) {
-          effectiveCommand = `(${effectiveCommand}) 2>&1 | tee "${logFile}"`;
-        }
-        screenArgs = isBareShell
-          ? ['-dmS', sessionName, ...command.trim().split(/\s+/)]
-          : ['-dmS', sessionName, shell, shellArg, effectiveCommand];
+        resolve({
+          success: false,
+          sessionName,
+          message: `Failed to create screenrc for logging: ${err.message}`,
+        });
+        return;
+      }
 
-        if (DEBUG) {
-          console.log(
-            `[DEBUG] Running screen with tee fallback (older screen version): screen ${screenArgs.join(' ')}`
-          );
-        }
+      // Build screen arguments:
+      //   screen -dmS <session> -L -c <screenrc> <shell> -c '<command>'
+      //
+      // The -L flag explicitly enables logging for the initial window.
+      // Without -L, `deflog on` in screenrc only applies to windows created
+      // AFTER the screenrc is processed — but the default window is created
+      // BEFORE screenrc processing. This caused output to be silently lost
+      // on macOS screen 4.00.03 (issue #96).
+      //
+      // The -L flag is available on ALL screen versions (including 4.00.03).
+      // Combined with `logfile <path>` in screenrc, -L logs to our custom path
+      // instead of the default `screenlog.0`.
+      const screenArgs = isBareShell
+        ? [
+            '-dmS',
+            sessionName,
+            '-L',
+            '-c',
+            screenrcFile,
+            ...command.trim().split(/\s+/),
+          ]
+        : [
+            '-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}`);
+        console.error(`[screen-isolation] Exit code file: ${exitCodeFile}`);
       }
 
       // Use spawnSync with array args (not execSync string) to avoid quoting issues (issue #25)
@@ -177,11 +233,14 @@ function runScreenWithLogCapture(
         throw result.error;
       }
 
-      // Helper to read log file output and write to stdout
-      // Includes a short retry for the tee fallback path to handle the TOCTOU race
-      // condition where the session appears gone but the log file isn't fully written yet
-      // (issue #96)
+      // Helper to read log file output and write to stdout.
+      // Uses multiple retries with increasing delays to handle the race condition
+      // where the screen session disappears from `screen -ls` but the log file
+      // hasn't been fully flushed yet (issue #96).
       const readAndDisplayOutput = (retryCount = 0) => {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAYS = [50, 100, 200]; // ms
+
         let output = '';
         try {
           output = fs.readFileSync(logFile, 'utf8');
@@ -189,17 +248,36 @@ function runScreenWithLogCapture(
           // Log file might not exist if command produced no output
         }
 
-        // If output is empty and we haven't retried yet, wait briefly and retry once.
-        // This handles the race where tee's write hasn't been flushed to disk yet
-        // when the screen session appears done in `screen -ls` (issue #96).
-        if (!output.trim() && retryCount === 0) {
+        // If output is empty and we haven't exhausted retries, wait and retry.
+        if (!output.trim() && retryCount < MAX_RETRIES) {
+          const delay = RETRY_DELAYS[retryCount] || 200;
+          if (isDebug()) {
+            console.error(
+              `[screen-isolation] Log file empty, retry ${retryCount + 1}/${MAX_RETRIES} after ${delay}ms`
+            );
+          }
           return new Promise((resolveRetry) => {
             setTimeout(() => {
-              resolveRetry(readAndDisplayOutput(1));
-            }, 50);
+              resolveRetry(readAndDisplayOutput(retryCount + 1));
+            }, delay);
           });
         }
 
+        if (isDebug() && !output.trim()) {
+          console.error(
+            `[screen-isolation] Log file still empty after ${MAX_RETRIES} retries`
+          );
+          // Check if log file exists at all
+          try {
+            const stats = fs.statSync(logFile);
+            console.error(
+              `[screen-isolation] Log file exists, size: ${stats.size} bytes`
+            );
+          } catch {
+            console.error(`[screen-isolation] Log file does not exist`);
+          }
+        }
+
         // Display the output
         if (output.trim()) {
           process.stdout.write(output);
@@ -211,16 +289,33 @@ function runScreenWithLogCapture(
         return Promise.resolve(output);
       };
 
-      // Clean up temp files
-      const cleanupTempFiles = () => {
+      // Read exit code from sidecar file
+      const readExitCode = () => {
+        if (isBareShell) {
+          return 0; // Can't capture exit code for interactive shells
+        }
         try {
-          fs.unlinkSync(logFile);
+          const content = fs.readFileSync(exitCodeFile, 'utf8').trim();
+          const code = parseInt(content, 10);
+          if (isDebug()) {
+            console.error(`[screen-isolation] Captured exit code: ${code}`);
+          }
+          return isNaN(code) ? 0 : code;
         } catch {
-          // Ignore cleanup errors
+          if (isDebug()) {
+            console.error(
+              `[screen-isolation] Could not read exit code file, defaulting to 0`
+            );
+          }
+          return 0;
         }
-        if (screenrcFile) {
+      };
+
+      // Clean up temp files
+      const cleanupTempFiles = () => {
+        for (const f of [logFile, screenrcFile, exitCodeFile]) {
           try {
-            fs.unlinkSync(screenrcFile);
+            fs.unlinkSync(f);
           } catch {
             // Ignore cleanup errors
           }
@@ -241,14 +336,15 @@ function runScreenWithLogCapture(
           });
 
           if (!sessions.includes(sessionName)) {
-            // Session ended, read output (with retry for tee path race condition)
+            // Session ended, read output and exit code
             readAndDisplayOutput().then((output) => {
+              const exitCode = readExitCode();
               cleanupTempFiles();
               resolve({
-                success: true,
+                success: exitCode === 0,
                 sessionName,
-                message: `Screen session "${sessionName}" exited with code 0`,
-                exitCode: 0,
+                message: `Screen session "${sessionName}" exited with code ${exitCode}`,
+                exitCode,
                 output,
               });
             });
@@ -271,12 +367,13 @@ function runScreenWithLogCapture(
         } catch {
           // screen -ls failed, session probably ended
           readAndDisplayOutput().then((output) => {
+            const exitCode = readExitCode();
             cleanupTempFiles();
             resolve({
-              success: true,
+              success: exitCode === 0,
               sessionName,
-              message: `Screen session "${sessionName}" exited with code 0`,
-              exitCode: 0,
+              message: `Screen session "${sessionName}" exited with code ${exitCode}`,
+              exitCode,
               output,
             });
           });

package/test/isolation.test.js

@@ -525,193 +525,8 @@ describe('Isolation Runner with Available Backends', () => {
   } = require('../src/lib/isolation');
   const { execSync } = require('child_process');
 
-  describe('runInScreen (if available)', () => {
-    it('should run command in detached screen session', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      const result = await runInScreen('echo "test from screen"', {
-        session: `test-session-${Date.now()}`,
-        detached: true,
-      });
-
-      assert.strictEqual(result.success, true);
-      assert.ok(result.sessionName);
-      assert.ok(result.message.includes('screen'));
-      assert.ok(result.message.includes('Reattach with'));
-
-      // Clean up the session
-      try {
-        execSync(`screen -S ${result.sessionName} -X quit`, {
-          stdio: 'ignore',
-        });
-      } catch {
-        // Session may have already exited
-      }
-    });
-
-    it('should run command in attached mode and capture output (issue #15)', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      // Test attached mode - this should work without TTY using log capture fallback
-      const result = await runInScreen('echo hello', {
-        session: `test-attached-${Date.now()}`,
-        detached: false,
-      });
-
-      assert.strictEqual(result.success, true);
-      assert.ok(result.sessionName);
-      assert.ok(result.message.includes('exited with code 0'));
-      // The output property should exist when using log capture
-      if (result.output !== undefined) {
-        console.log(`  Captured output: "${result.output.trim()}"`);
-        assert.ok(
-          result.output.includes('hello'),
-          'Output should contain the expected message'
-        );
-      }
-    });
-
-    it('should handle multi-line output in attached mode', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      const result = await runInScreen(
-        "echo 'line1'; echo 'line2'; echo 'line3'",
-        {
-          session: `test-multiline-${Date.now()}`,
-          detached: false,
-        }
-      );
-
-      assert.strictEqual(result.success, true);
-      if (result.output !== undefined) {
-        console.log(
-          `  Captured multi-line output: "${result.output.trim().replace(/\n/g, '\\n')}"`
-        );
-        assert.ok(result.output.includes('line1'));
-        assert.ok(result.output.includes('line2'));
-        assert.ok(result.output.includes('line3'));
-      }
-    });
-
-    it('should capture output from commands with quoted strings (issue #25)', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      // This is the exact scenario from issue #25:
-      // $ --isolated screen --verbose -- echo "hello"
-      // Previously failed because of shell quoting issues with execSync
-      const result = await runInScreen('echo "hello"', {
-        session: `test-quoted-${Date.now()}`,
-        detached: false,
-      });
-
-      assert.strictEqual(result.success, true);
-      assert.ok(result.sessionName);
-      assert.ok(result.message.includes('exited with code 0'));
-      if (result.output !== undefined) {
-        console.log(`  Captured quoted output: "${result.output.trim()}"`);
-        assert.ok(
-          result.output.includes('hello'),
-          'Output should contain "hello" (issue #25 regression test)'
-        );
-      }
-    });
-
-    it('should capture output from commands with complex quoted strings', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      // Test more complex quoting scenarios
-      const result = await runInScreen('echo "hello from attached mode"', {
-        session: `test-complex-quote-${Date.now()}`,
-        detached: false,
-      });
-
-      assert.strictEqual(result.success, true);
-      if (result.output !== undefined) {
-        console.log(
-          `  Captured complex quote output: "${result.output.trim()}"`
-        );
-        assert.ok(
-          result.output.includes('hello from attached mode'),
-          'Output should contain the full message with spaces'
-        );
-      }
-    });
-
-    it('should always return output property in attached mode (issue #25 fix verification)', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      // This test verifies that attached mode always uses log capture,
-      // ensuring output is never lost even for quick commands.
-      // This is the core fix for issue #25 where output was lost on macOS
-      // because screen's virtual terminal was destroyed before output could be seen.
-      const result = await runInScreen('echo "quick command output"', {
-        session: `test-output-guaranteed-${Date.now()}`,
-        detached: false,
-      });
-
-      assert.strictEqual(result.success, true);
-      assert.ok(
-        result.output !== undefined,
-        'Attached mode should always return output property'
-      );
-      assert.ok(
-        result.output.includes('quick command output'),
-        'Output should be captured (issue #25 fix verification)'
-      );
-      console.log(`  Verified output capture: "${result.output.trim()}"`);
-    });
-
-    it('should capture output from version-flag commands (issue #96)', async () => {
-      if (!isCommandAvailable('screen')) {
-        console.log('  Skipping: screen not installed');
-        return;
-      }
-
-      // This test verifies that screen isolation captures output from quick-completing
-      // commands like `agent --version` or `node --version`.
-      // Issue #96: output was silently lost because screen's internal log buffer was
-      // not flushed before the session terminated (default 10s flush interval).
-      // Fix: use a temporary screenrc with `logfile flush 0` to force immediate flushing.
-      const result = await runInScreen('node --version', {
-        session: `test-version-flag-${Date.now()}`,
-        detached: false,
-      });
-
-      assert.strictEqual(result.success, true, 'Command should succeed');
-      assert.ok(
-        result.output !== undefined,
-        'Attached mode should always return output property'
-      );
-      assert.ok(
-        result.output.trim().length > 0,
-        'Output should not be empty (issue #96: version output was silently lost)'
-      );
-      // node --version outputs something like "v20.0.0"
-      assert.ok(
-        result.output.includes('v') || /\d+\.\d+/.test(result.output),
-        'Output should contain version string'
-      );
-      console.log(`  Captured version output: "${result.output.trim()}"`);
-    });
-  });
+  // Screen integration tests moved to screen-integration.test.js
+  // to keep file under the 1000-line limit.
 
   describe('runInTmux (if available)', () => {
     it('should run command in detached tmux session', async () => {

package/test/screen-integration.test.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env bun
+/**
+ * Integration tests for screen isolation
+ * Tests actual screen session behavior including output capture, exit codes, and edge cases.
+ * Extracted from isolation.test.js to keep file sizes under the 1000-line limit.
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { execSync } = require('child_process');
+const { isCommandAvailable, runInScreen } = require('../src/lib/isolation');
+
+describe('Screen Integration Tests', () => {
+  describe('runInScreen (if available)', () => {
+    it('should run command in detached screen session', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "test from screen"', {
+        session: `test-session-${Date.now()}`,
+        detached: true,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('screen'));
+      assert.ok(result.message.includes('Reattach with'));
+
+      // Clean up the session
+      try {
+        execSync(`screen -S ${result.sessionName} -X quit`, {
+          stdio: 'ignore',
+        });
+      } catch {
+        // Session may have already exited
+      }
+    });
+
+    it('should run command in attached mode and capture output (issue #15)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      // Test attached mode - this should work without TTY using log capture fallback
+      const result = await runInScreen('echo hello', {
+        session: `test-attached-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('exited with code 0'));
+      // The output property should exist when using log capture
+      if (result.output !== undefined) {
+        console.log(`  Captured output: "${result.output.trim()}"`);
+        assert.ok(
+          result.output.includes('hello'),
+          'Output should contain the expected message'
+        );
+      }
+    });
+
+    it('should handle multi-line output in attached mode', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen(
+        "echo 'line1'; echo 'line2'; echo 'line3'",
+        {
+          session: `test-multiline-${Date.now()}`,
+          detached: false,
+        }
+      );
+
+      assert.strictEqual(result.success, true);
+      if (result.output !== undefined) {
+        console.log(
+          `  Captured multi-line output: "${result.output.trim().replace(/\n/g, '\\n')}"`
+        );
+        assert.ok(result.output.includes('line1'));
+        assert.ok(result.output.includes('line2'));
+        assert.ok(result.output.includes('line3'));
+      }
+    });
+
+    it('should capture output from commands with quoted strings (issue #25)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "hello"', {
+        session: `test-quoted-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('exited with code 0'));
+      if (result.output !== undefined) {
+        console.log(`  Captured quoted output: "${result.output.trim()}"`);
+        assert.ok(
+          result.output.includes('hello'),
+          'Output should contain "hello" (issue #25 regression test)'
+        );
+      }
+    });
+
+    it('should capture output from commands with complex quoted strings', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "hello from attached mode"', {
+        session: `test-complex-quote-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      if (result.output !== undefined) {
+        console.log(
+          `  Captured complex quote output: "${result.output.trim()}"`
+        );
+        assert.ok(
+          result.output.includes('hello from attached mode'),
+          'Output should contain the full message with spaces'
+        );
+      }
+    });
+
+    it('should always return output property in attached mode (issue #25 fix verification)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "quick command output"', {
+        session: `test-output-guaranteed-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(
+        result.output !== undefined,
+        'Attached mode should always return output property'
+      );
+      assert.ok(
+        result.output.includes('quick command output'),
+        'Output should be captured (issue #25 fix verification)'
+      );
+      console.log(`  Verified output capture: "${result.output.trim()}"`);
+    });
+
+    it('should capture output from version-flag commands (issue #96)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('node --version', {
+        session: `test-version-flag-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true, 'Command should succeed');
+      assert.ok(
+        result.output !== undefined,
+        'Attached mode should always return output property'
+      );
+      assert.ok(
+        result.output.trim().length > 0,
+        'Output should not be empty (issue #96: version output was silently lost)'
+      );
+      assert.ok(
+        result.output.includes('v') || /\d+\.\d+/.test(result.output),
+        'Output should contain version string'
+      );
+      console.log(`  Captured version output: "${result.output.trim()}"`);
+    });
+
+    it('should capture exit code from failed commands (issue #96)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('nonexistent_command_12345', {
+        session: `test-exit-code-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(
+        result.success,
+        false,
+        'Command should fail (command not found)'
+      );
+      assert.ok(result.exitCode !== undefined, 'Exit code should be captured');
+      assert.ok(
+        result.exitCode !== 0,
+        `Exit code should be non-zero for failed command, got: ${result.exitCode}`
+      );
+      console.log(`  Captured exit code: ${result.exitCode}`);
+    });
+
+    it('should capture stderr output in screen isolation (issue #96)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen('echo "stderr-test" >&2', {
+        session: `test-stderr-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true, 'Command should succeed');
+      assert.ok(result.output !== undefined, 'Output should be captured');
+      assert.ok(
+        result.output.includes('stderr-test'),
+        'stderr output should be captured via screen logging'
+      );
+      console.log(`  Captured stderr output: "${result.output.trim()}"`);
+    });
+
+    it('should capture multi-line output with correct exit code (issue #96)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen(
+        'echo "line1" && echo "line2" && echo "line3"',
+        {
+          session: `test-multiline-exit-${Date.now()}`,
+          detached: false,
+        }
+      );
+
+      assert.strictEqual(result.success, true, 'Command should succeed');
+      assert.strictEqual(
+        result.exitCode,
+        0,
+        'Exit code should be 0 for successful command'
+      );
+      assert.ok(result.output.includes('line1'), 'Should contain line1');
+      assert.ok(result.output.includes('line2'), 'Should contain line2');
+      assert.ok(result.output.includes('line3'), 'Should contain line3');
+      console.log(`  Multi-line output with exit code 0: verified`);
+    });
+  });
+});