start-command 0.24.7 → 0.24.9

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # start-command
 
+## 0.24.9
+
+### Patch Changes
+
+- 48515a1: fix: capture output from quick-completing commands in screen isolation (issue #96)
+
+  When running a short-lived command like `agent --version` through screen isolation:
+
+  ```
+  $ --isolated screen -- agent --version
+  ```
+
+  the version output was silently lost — the command exited cleanly (exit code 0)
+  but no output was displayed.
+
+  **Root cause:** GNU Screen's internal log buffer flushes every 10 seconds by default
+  (`log_flush = 10`). For commands that complete faster than this, the buffer may not
+  be flushed to the log file before the screen session terminates.
+
+  **Fix:** A temporary screenrc file with `logfile flush 0` is passed to screen via
+  the `-c` option. This forces screen to flush the log buffer after every write,
+  eliminating the 10-second flush delay for quick-completing commands.
+
+  A retry mechanism is also added for the tee fallback path (older screen < 4.5.1)
+  to handle the TOCTOU race where the log file appears empty when first read
+  immediately after session completion.
+
+  Both JavaScript (`isolation.js`) and Rust (`isolation.rs`) implementations are fixed
+  with equivalent test coverage added.
+
+## 0.24.8
+
+### Patch Changes
+
+- 1195fc1: Add CI/CD coverage enforcement and Rust/JS test parity checks (issue #93)
+  - Add `scripts/check-test-parity.mjs` script to enforce Rust/JS test count within 10%
+  - Add coverage job to JavaScript CI/CD workflow (80% minimum threshold)
+  - Update `ARCHITECTURE.md` to document dual-language sync requirements
+  - Update `REQUIREMENTS.md` to document test coverage requirements and parity rules
+
 ## 0.24.7
 
 ### Patch Changes

package/package.json

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

package/src/lib/isolation.js

@@ -1,94 +1,20 @@
 /** Isolation Runners for start-command (screen, tmux, docker, ssh) */
 
 const { execSync, spawn, spawnSync } = require('child_process');
-const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { generateSessionName } = require('./args-parser');
 const outputBlocks = require('./output-blocks');
 
-const setTimeout = globalThis.setTimeout;
-
 // Debug mode from environment
 const DEBUG =
   process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
 
-// Cache for screen version detection
-let cachedScreenVersion = null;
-let screenVersionChecked = false;
-
-/**
- * Get the installed screen version
- * @returns {{major: number, minor: number, patch: number}|null} Version object or null if detection fails
- */
-function getScreenVersion() {
-  if (screenVersionChecked) {
-    return cachedScreenVersion;
-  }
-
-  screenVersionChecked = true;
-
-  try {
-    const output = execSync('screen --version', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    // Match patterns like "4.09.01", "4.00.03", "4.5.1"
-    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
-    if (match) {
-      cachedScreenVersion = {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10),
-      };
-
-      if (DEBUG) {
-        console.log(
-          `[DEBUG] Detected screen version: ${cachedScreenVersion.major}.${cachedScreenVersion.minor}.${cachedScreenVersion.patch}`
-        );
-      }
-
-      return cachedScreenVersion;
-    }
-  } catch {
-    if (DEBUG) {
-      console.log('[DEBUG] Could not detect screen version');
-    }
-  }
-
-  return null;
-}
-
-/**
- * Check if screen supports the -Logfile option
- * The -Logfile option was introduced in GNU Screen 4.5.1
- * @returns {boolean} True if -Logfile is supported
- */
-function supportsLogfileOption() {
-  const version = getScreenVersion();
-  if (!version) {
-    // If we can't detect version, assume older version and use fallback
-    return false;
-  }
-
-  // -Logfile was added in 4.5.1
-  // Compare: version >= 4.5.1
-  if (version.major > 4) {
-    return true;
-  }
-  if (version.major < 4) {
-    return false;
-  }
-  // major === 4
-  if (version.minor > 5) {
-    return true;
-  }
-  if (version.minor < 5) {
-    return false;
-  }
-  // minor === 5
-  return version.patch >= 1;
-}
+const {
+  getScreenVersion,
+  supportsLogfileOption,
+  runScreenWithLogCapture: _runScreenWithLogCapture,
+  resetScreenVersionCache,
+} = require('./screen-isolation');
 
 /**
  * Check if a command is available on the system
@@ -245,159 +171,14 @@ function wrapCommandWithUser(command, user) {
  * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string}>}
  */
 function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
-  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();
-
-  return new Promise((resolve) => {
-    try {
-      let screenArgs;
-      // Wrap command with user switch if specified
-      let effectiveCommand = wrapCommandWithUser(command, user);
-
-      if (useNativeLogging) {
-        // Modern screen (>= 4.5.1): Use -L -Logfile option for native log capture
-        // screen -dmS <session> -L -Logfile <logfile> <shell> -c '<command>'
-        const logArgs = ['-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(' ')}`
-          );
-        }
-      } 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];
-
-        if (DEBUG) {
-          console.log(
-            `[DEBUG] Running screen with tee fallback (older screen version): screen ${screenArgs.join(' ')}`
-          );
-        }
-      }
-
-      // 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;
-      }
-
-      // Poll for session completion
-      const checkInterval = 100; // ms
-      const maxWait = 300000; // 5 minutes max
-      let waited = 0;
-
-      const checkCompletion = () => {
-        try {
-          // Check if session still exists
-          const sessions = execSync('screen -ls', {
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-          });
-
-          if (!sessions.includes(sessionName)) {
-            // Session ended, read output
-            let output = '';
-            try {
-              output = fs.readFileSync(logFile, 'utf8');
-              // Display the output with surrounding empty lines for consistency
-              if (output.trim()) {
-                process.stdout.write(output);
-                // Add trailing newline if output doesn't end with one
-                if (!output.endsWith('\n')) {
-                  process.stdout.write('\n');
-                }
-              }
-            } catch {
-              // Log file might not exist if command was very quick
-            }
-
-            // Clean up log file
-            try {
-              fs.unlinkSync(logFile);
-            } catch {
-              // Ignore cleanup errors
-            }
-
-            resolve({
-              success: true,
-              sessionName,
-              message: `Screen session "${sessionName}" exited with code 0`,
-              exitCode: 0,
-              output,
-            });
-            return;
-          }
-
-          waited += checkInterval;
-          if (waited >= maxWait) {
-            resolve({
-              success: false,
-              sessionName,
-              message: `Screen session "${sessionName}" timed out after ${maxWait / 1000} seconds`,
-              exitCode: 1,
-            });
-            return;
-          }
-
-          setTimeout(checkCompletion, checkInterval);
-        } catch {
-          // screen -ls failed, session probably ended
-          let output = '';
-          try {
-            output = fs.readFileSync(logFile, 'utf8');
-            if (output.trim()) {
-              process.stdout.write(output);
-              // Add trailing newline if output doesn't end with one
-              if (!output.endsWith('\n')) {
-                process.stdout.write('\n');
-              }
-            }
-          } catch {
-            // Ignore
-          }
-
-          try {
-            fs.unlinkSync(logFile);
-          } catch {
-            // Ignore
-          }
-
-          resolve({
-            success: true,
-            sessionName,
-            message: `Screen session "${sessionName}" exited with code 0`,
-            exitCode: 0,
-            output,
-          });
-        }
-      };
-
-      // Start checking after a brief delay
-      setTimeout(checkCompletion, checkInterval);
-    } catch (err) {
-      resolve({
-        success: false,
-        sessionName,
-        message: `Failed to run in screen: ${err.message}`,
-      });
-    }
-  });
+  return _runScreenWithLogCapture(
+    command,
+    sessionName,
+    shellInfo,
+    user,
+    wrapCommandWithUser,
+    isInteractiveShellCommand
+  );
 }
 
 /**
@@ -934,12 +715,6 @@ function runIsolated(backend, command, options = {}) {
   }
 }
 
-/** Reset screen version cache (useful for testing) */
-function resetScreenVersionCache() {
-  cachedScreenVersion = null;
-  screenVersionChecked = false;
-}
-
 const {
   getTimestamp,
   generateLogFilename,

package/src/lib/screen-isolation.js

@@ -0,0 +1,309 @@
+/** Screen-specific isolation helpers extracted from isolation.js */
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const setTimeout = globalThis.setTimeout;
+
+// Debug mode from environment
+const DEBUG =
+  process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
+
+// Cache for screen version detection
+let cachedScreenVersion = null;
+let screenVersionChecked = false;
+
+/**
+ * Get the installed screen version
+ * @returns {{major: number, minor: number, patch: number}|null} Version object or null if detection fails
+ */
+function getScreenVersion() {
+  if (screenVersionChecked) {
+    return cachedScreenVersion;
+  }
+
+  screenVersionChecked = true;
+
+  try {
+    const output = execSync('screen --version', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    // Match patterns like "4.09.01", "4.00.03", "4.5.1"
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (match) {
+      cachedScreenVersion = {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+      };
+
+      if (DEBUG) {
+        console.log(
+          `[DEBUG] Detected screen version: ${cachedScreenVersion.major}.${cachedScreenVersion.minor}.${cachedScreenVersion.patch}`
+        );
+      }
+
+      return cachedScreenVersion;
+    }
+  } catch {
+    if (DEBUG) {
+      console.log('[DEBUG] Could not detect screen version');
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if screen supports the -Logfile option
+ * The -Logfile option was introduced in GNU Screen 4.5.1
+ * @returns {boolean} True if -Logfile is supported
+ */
+function supportsLogfileOption() {
+  const version = getScreenVersion();
+  if (!version) {
+    // If we can't detect version, assume older version and use fallback
+    return false;
+  }
+
+  // -Logfile was added in 4.5.1
+  // Compare: version >= 4.5.1
+  if (version.major > 4) {
+    return true;
+  }
+  if (version.major < 4) {
+    return false;
+  }
+  // major === 4
+  if (version.minor > 5) {
+    return true;
+  }
+  if (version.minor < 5) {
+    return false;
+  }
+  // minor === 5
+  return version.patch >= 1;
+}
+
+/**
+ * Run command in GNU Screen using detached mode with log capture.
+ * Supports screen >= 4.5.1 (native -Logfile) and older versions (tee fallback).
+ * @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}>}
+ */
+function runScreenWithLogCapture(
+  command,
+  sessionName,
+  shellInfo,
+  user = null,
+  wrapCommandWithUser,
+  isInteractiveShellCommand
+) {
+  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();
+
+  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;
+        }
+
+        // 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(' ')}`
+          );
+        }
+      } 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];
+
+        if (DEBUG) {
+          console.log(
+            `[DEBUG] Running screen with tee fallback (older screen version): screen ${screenArgs.join(' ')}`
+          );
+        }
+      }
+
+      // 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;
+      }
+
+      // 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)
+      const readAndDisplayOutput = (retryCount = 0) => {
+        let output = '';
+        try {
+          output = fs.readFileSync(logFile, 'utf8');
+        } catch {
+          // 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) {
+          return new Promise((resolveRetry) => {
+            setTimeout(() => {
+              resolveRetry(readAndDisplayOutput(1));
+            }, 50);
+          });
+        }
+
+        // Display the output
+        if (output.trim()) {
+          process.stdout.write(output);
+          // Add trailing newline if output doesn't end with one
+          if (!output.endsWith('\n')) {
+            process.stdout.write('\n');
+          }
+        }
+        return Promise.resolve(output);
+      };
+
+      // Clean up temp files
+      const cleanupTempFiles = () => {
+        try {
+          fs.unlinkSync(logFile);
+        } catch {
+          // Ignore cleanup errors
+        }
+        if (screenrcFile) {
+          try {
+            fs.unlinkSync(screenrcFile);
+          } catch {
+            // Ignore cleanup errors
+          }
+        }
+      };
+
+      // Poll for session completion
+      const checkInterval = 100; // ms
+      const maxWait = 300000; // 5 minutes max
+      let waited = 0;
+
+      const checkCompletion = () => {
+        try {
+          // Check if session still exists
+          const sessions = execSync('screen -ls', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          if (!sessions.includes(sessionName)) {
+            // Session ended, read output (with retry for tee path race condition)
+            readAndDisplayOutput().then((output) => {
+              cleanupTempFiles();
+              resolve({
+                success: true,
+                sessionName,
+                message: `Screen session "${sessionName}" exited with code 0`,
+                exitCode: 0,
+                output,
+              });
+            });
+            return;
+          }
+
+          waited += checkInterval;
+          if (waited >= maxWait) {
+            cleanupTempFiles();
+            resolve({
+              success: false,
+              sessionName,
+              message: `Screen session "${sessionName}" timed out after ${maxWait / 1000} seconds`,
+              exitCode: 1,
+            });
+            return;
+          }
+
+          setTimeout(checkCompletion, checkInterval);
+        } catch {
+          // screen -ls failed, session probably ended
+          readAndDisplayOutput().then((output) => {
+            cleanupTempFiles();
+            resolve({
+              success: true,
+              sessionName,
+              message: `Screen session "${sessionName}" exited with code 0`,
+              exitCode: 0,
+              output,
+            });
+          });
+        }
+      };
+
+      // Start checking after a brief delay
+      setTimeout(checkCompletion, checkInterval);
+    } catch (err) {
+      resolve({
+        success: false,
+        sessionName,
+        message: `Failed to run in screen: ${err.message}`,
+      });
+    }
+  });
+}
+
+/** Reset screen version cache (useful for testing) */
+function resetScreenVersionCache() {
+  cachedScreenVersion = null;
+  screenVersionChecked = false;
+}
+
+module.exports = {
+  getScreenVersion,
+  supportsLogfileOption,
+  runScreenWithLogCapture,
+  resetScreenVersionCache,
+};

package/test/echo-integration.test.js

@@ -24,6 +24,7 @@ const path = require('path');
 const {
   isCommandAvailable,
   canRunLinuxDockerImages,
+  hasTTY,
 } = require('../src/lib/isolation');
 
 // Path to the CLI
@@ -537,6 +538,14 @@ describe('Echo Integration Tests - Issue #55', () => {
     }
 
     describe('Attached Mode', () => {
+      if (!hasTTY()) {
+        it('should skip attached docker tests when no TTY is available', () => {
+          console.log('  ⚠ no TTY available, skipping attached docker tests');
+          assert.ok(true);
+        });
+        return;
+      }
+
       it('should execute echo hi in attached docker mode with proper formatting', () => {
         const containerName = `test-docker-attached-${Date.now()}`;
         const result = runCli(

package/test/failure-handler.test.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for failure-handler module
+ * Tests pure functions: parseGitUrl and handleFailure early-exit behavior
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { parseGitUrl, handleFailure } = require('../src/lib/failure-handler');
+
+describe('failure-handler', () => {
+  describe('parseGitUrl', () => {
+    it('should parse HTTPS GitHub URL', () => {
+      const result = parseGitUrl('https://github.com/owner/my-repo');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+      assert.strictEqual(result.url, 'https://github.com/owner/my-repo');
+    });
+
+    it('should parse HTTPS URL with .git suffix', () => {
+      const result = parseGitUrl('https://github.com/owner/my-repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+      assert.strictEqual(result.url, 'https://github.com/owner/my-repo');
+    });
+
+    it('should parse SSH git@ URL', () => {
+      const result = parseGitUrl('git@github.com:owner/my-repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'my-repo');
+    });
+
+    it('should parse git+https URL format', () => {
+      const result = parseGitUrl('git+https://github.com/owner/repo.git');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'owner');
+      assert.strictEqual(result.repo, 'repo');
+    });
+
+    it('should return null for empty string', () => {
+      const result = parseGitUrl('');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for null/undefined input', () => {
+      assert.strictEqual(parseGitUrl(null), null);
+      assert.strictEqual(parseGitUrl(undefined), null);
+    });
+
+    it('should return null for non-github URL', () => {
+      const result = parseGitUrl('https://gitlab.com/owner/repo');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for invalid/random string', () => {
+      const result = parseGitUrl('not-a-url-at-all');
+      assert.strictEqual(result, null);
+    });
+
+    it('should normalize URL to https://github.com format', () => {
+      const result = parseGitUrl('git@github.com:myorg/myrepo');
+      assert.ok(result !== null);
+      assert.ok(result.url.startsWith('https://github.com/'));
+    });
+
+    it('should handle URL with subdirectory (only owner/repo captured)', () => {
+      const result = parseGitUrl('https://github.com/myorg/myrepo/issues');
+      assert.ok(result !== null);
+      assert.strictEqual(result.owner, 'myorg');
+      assert.strictEqual(result.repo, 'myrepo');
+    });
+
+    it('should return object with owner, repo, url keys', () => {
+      const result = parseGitUrl('https://github.com/test/project');
+      assert.ok(result !== null);
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'owner'));
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'repo'));
+      assert.ok(Object.prototype.hasOwnProperty.call(result, 'url'));
+    });
+  });
+
+  describe('handleFailure', () => {
+    it('should return early when disableAutoIssue is true', () => {
+      // This should not throw and should return without calling external processes
+      const config = { disableAutoIssue: true };
+      // If it tries to call external tools, it would either throw or hang;
+      // returning cleanly means the early-exit path was taken.
+      assert.doesNotThrow(() => {
+        handleFailure(config, 'someCmd', 'someCmd --flag', 1, '/tmp/fake.log');
+      });
+    });
+
+    it('should return early when disableAutoIssue is true (verbose mode)', () => {
+      const config = { disableAutoIssue: true, verbose: true };
+      assert.doesNotThrow(() => {
+        handleFailure(config, 'cmd', 'cmd arg', 2, '/tmp/fake.log');
+      });
+    });
+  });
+});

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

@@ -0,0 +1,234 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for isolation-log-utils module
+ * Tests pure utility functions for log file management
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const path = require('path');
+const {
+  getTimestamp,
+  generateLogFilename,
+  createLogHeader,
+  createLogFooter,
+  getLogDir,
+  createLogPath,
+} = require('../src/lib/isolation-log-utils');
+
+describe('isolation-log-utils', () => {
+  describe('getTimestamp', () => {
+    it('should return a non-empty string', () => {
+      const ts = getTimestamp();
+      assert.strictEqual(typeof ts, 'string');
+      assert.ok(ts.length > 0);
+    });
+
+    it('should return a timestamp without T or Z (ISO-like but space-separated)', () => {
+      const ts = getTimestamp();
+      assert.ok(!ts.includes('T'), 'Should not contain ISO T separator');
+      assert.ok(!ts.endsWith('Z'), 'Should not end with Z');
+    });
+
+    it('should contain date-like content (numbers and dashes)', () => {
+      const ts = getTimestamp();
+      // Expect format like "2024-01-15 10:30:45.123"
+      assert.match(ts, /\d{4}-\d{2}-\d{2}/);
+    });
+
+    it('should return different values on successive calls (or same within same ms)', () => {
+      const ts1 = getTimestamp();
+      assert.strictEqual(typeof ts1, 'string');
+      // Just verify it's callable multiple times without error
+      const ts2 = getTimestamp();
+      assert.strictEqual(typeof ts2, 'string');
+    });
+  });
+
+  describe('generateLogFilename', () => {
+    it('should return a string ending with .log', () => {
+      const filename = generateLogFilename('screen');
+      assert.ok(filename.endsWith('.log'));
+    });
+
+    it('should include the environment name in the filename', () => {
+      const filename = generateLogFilename('docker');
+      assert.ok(filename.includes('docker'));
+    });
+
+    it('should start with "start-command-"', () => {
+      const filename = generateLogFilename('tmux');
+      assert.ok(filename.startsWith('start-command-'));
+    });
+
+    it('should generate unique filenames on successive calls', () => {
+      const f1 = generateLogFilename('screen');
+      const f2 = generateLogFilename('screen');
+      // Due to random component, should be different
+      assert.notStrictEqual(f1, f2);
+    });
+
+    it('should handle different environment names', () => {
+      const environments = ['screen', 'tmux', 'docker', 'user', 'none'];
+      for (const env of environments) {
+        const filename = generateLogFilename(env);
+        assert.ok(
+          filename.includes(env),
+          `Filename should include environment "${env}"`
+        );
+        assert.ok(filename.endsWith('.log'));
+      }
+    });
+  });
+
+  describe('createLogHeader', () => {
+    const baseParams = {
+      command: 'npm test',
+      environment: 'screen',
+      mode: 'attached',
+      sessionName: 'test-session-123',
+      startTime: '2024-01-15 10:30:00.000',
+    };
+
+    it('should return a non-empty string', () => {
+      const header = createLogHeader(baseParams);
+      assert.strictEqual(typeof header, 'string');
+      assert.ok(header.length > 0);
+    });
+
+    it('should include the command in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('npm test'));
+    });
+
+    it('should include the environment in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('screen'));
+    });
+
+    it('should include the session name in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('test-session-123'));
+    });
+
+    it('should include the mode in the header', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('attached'));
+    });
+
+    it('should include image field when provided', () => {
+      const params = { ...baseParams, image: 'node:20-alpine' };
+      const header = createLogHeader(params);
+      assert.ok(header.includes('node:20-alpine'));
+    });
+
+    it('should include user field when provided', () => {
+      const params = { ...baseParams, user: 'isolateduser' };
+      const header = createLogHeader(params);
+      assert.ok(header.includes('isolateduser'));
+    });
+
+    it('should NOT include Image line when image is not provided', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(!header.includes('Image:'));
+    });
+
+    it('should contain separator line', () => {
+      const header = createLogHeader(baseParams);
+      assert.ok(header.includes('==='));
+    });
+  });
+
+  describe('createLogFooter', () => {
+    it('should return a non-empty string', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.strictEqual(typeof footer, 'string');
+      assert.ok(footer.length > 0);
+    });
+
+    it('should include the exit code', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 42);
+      assert.ok(footer.includes('42'));
+    });
+
+    it('should include exit code 0', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.ok(footer.includes('0'));
+    });
+
+    it('should include the end time', () => {
+      const endTime = '2024-01-15 10:35:00.000';
+      const footer = createLogFooter(endTime, 1);
+      assert.ok(footer.includes(endTime));
+    });
+
+    it('should contain separator line', () => {
+      const footer = createLogFooter('2024-01-15 10:35:00.000', 0);
+      assert.ok(footer.includes('='));
+    });
+  });
+
+  describe('getLogDir', () => {
+    it('should return a string', () => {
+      const dir = getLogDir();
+      assert.strictEqual(typeof dir, 'string');
+    });
+
+    it('should return a non-empty path', () => {
+      const dir = getLogDir();
+      assert.ok(dir.length > 0);
+    });
+
+    it('should use START_LOG_DIR env var when set', () => {
+      const original = process.env.START_LOG_DIR;
+      process.env.START_LOG_DIR = '/tmp/custom-log-dir';
+      try {
+        const dir = getLogDir();
+        assert.strictEqual(dir, '/tmp/custom-log-dir');
+      } finally {
+        if (original === undefined) {
+          delete process.env.START_LOG_DIR;
+        } else {
+          process.env.START_LOG_DIR = original;
+        }
+      }
+    });
+
+    it('should fall back to os.tmpdir() when START_LOG_DIR is not set', () => {
+      const os = require('os');
+      const original = process.env.START_LOG_DIR;
+      delete process.env.START_LOG_DIR;
+      try {
+        const dir = getLogDir();
+        assert.strictEqual(dir, os.tmpdir());
+      } finally {
+        if (original !== undefined) {
+          process.env.START_LOG_DIR = original;
+        }
+      }
+    });
+  });
+
+  describe('createLogPath', () => {
+    it('should return a string ending with .log', () => {
+      const logPath = createLogPath('screen');
+      assert.ok(logPath.endsWith('.log'));
+    });
+
+    it('should return an absolute path', () => {
+      const logPath = createLogPath('tmux');
+      assert.ok(path.isAbsolute(logPath));
+    });
+
+    it('should include the environment name', () => {
+      const logPath = createLogPath('docker');
+      assert.ok(logPath.includes('docker'));
+    });
+
+    it('should be under the log directory', () => {
+      const logDir = getLogDir();
+      const logPath = createLogPath('screen');
+      assert.ok(logPath.startsWith(logDir));
+    });
+  });
+});

package/test/isolation.test.js

@@ -678,6 +678,39 @@ describe('Isolation Runner with Available Backends', () => {
       );
       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()}"`);
+    });
   });
 
   describe('runInTmux (if available)', () => {