start-command 0.17.0 → 0.17.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # start-command
 
+## 0.17.2
+
+### Patch Changes
+
+- d38a67f: fix: Use 'close' event instead of 'exit' for reliable stdout capture on macOS
+
+  The 'exit' event fires when the process terminates, but stdio streams may still have buffered data. On macOS, fast-executing commands like 'echo hi' could exit before stdout data events fired, causing no output to be displayed and no finish block shown.
+  - Changed from 'exit' to 'close' event in JavaScript for reliable output capture
+  - Updated Rust to use piped stdout/stderr with threads for real-time display and capture
+  - Added case study documentation for Issue #57 root cause analysis
+
+## 0.17.1
+
+### Patch Changes
+
+- 82a5297: fix: Improve output uniformity and ensure echo hi works in all modes
+  - Fixed truncation of log paths, session IDs, and result messages in output blocks
+  - Added consistent empty line formatting before/after command output
+  - Ensured proper output display in screen isolation mode
+  - Added integration tests for echo command across all isolation modes
+
 ## 0.17.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "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

@@ -511,6 +511,8 @@ async function runWithIsolation(
   }
 
   // Print finish block with result message inside
+  // Add empty line before finish block for visual separation
+  console.log('');
   const durationMs = Date.now() - startTimeMs;
   console.log(
     createFinishBlock({
@@ -638,8 +640,11 @@ function runDirect(cmd, sessionId) {
     logContent += text;
   });
 
-  // Handle process exit
-  child.on('exit', (code) => {
+  // Handle process close (not 'exit' - we need to wait for all stdio to be closed)
+  // The 'close' event fires after all stdio streams have been closed, ensuring
+  // all stdout/stderr data has been received. The 'exit' event can fire before
+  // buffered data is received, causing output loss on macOS (Issue #57).
+  child.on('close', (code) => {
     const exitCode = code || 0;
     const endTime = getTimestamp();
 

package/src/lib/isolation.js

@@ -1,11 +1,4 @@
-/**
- * Isolation Runners for start-command
- *
- * Provides execution of commands in various isolated environments:
- * - screen: GNU Screen terminal multiplexer
- * - tmux: tmux terminal multiplexer
- * - docker: Docker containers
- */
+/** Isolation Runners for start-command (screen, tmux, docker, ssh) */
 
 const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
@@ -237,9 +230,13 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
             let output = '';
             try {
               output = fs.readFileSync(logFile, 'utf8');
-              // Display the output
+              // 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
@@ -281,6 +278,10 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
             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

package/src/lib/output-blocks.js

@@ -85,10 +85,15 @@ function createHorizontalLine(width, style) {
  * Pad or truncate text to fit a specific width
  * @param {string} text - Text to pad
  * @param {number} width - Target width
+ * @param {boolean} [allowOverflow=false] - If true, don't truncate long text
  * @returns {string} Padded text
  */
-function padText(text, width) {
+function padText(text, width, allowOverflow = false) {
   if (text.length >= width) {
+    // If overflow is allowed, return text as-is (for copyable content like paths)
+    if (allowOverflow) {
+      return text;
+    }
     return text.substring(0, width);
   }
   return text + ' '.repeat(width - text.length);
@@ -99,12 +104,17 @@ function padText(text, width) {
  * @param {string} text - Text content
  * @param {number} width - Total width (including borders)
  * @param {object} style - Box style
+ * @param {boolean} [allowOverflow=false] - If true, allow text to overflow (for copyable content)
  * @returns {string} Bordered line
  */
-function createBorderedLine(text, width, style) {
+function createBorderedLine(text, width, style, allowOverflow = false) {
   if (style.vertical) {
     const innerWidth = width - 4; // 2 for borders, 2 for padding
-    const paddedText = padText(text, innerWidth);
+    const paddedText = padText(text, innerWidth, allowOverflow);
+    // If text overflows, extend the right border position
+    if (allowOverflow && text.length > innerWidth) {
+      return `${style.vertical} ${paddedText} ${style.vertical}`;
+    }
     return `${style.vertical} ${paddedText} ${style.vertical}`;
   }
   return text;
@@ -234,14 +244,18 @@ function createFinishBlock(options) {
   lines.push(createTopBorder(width, style));
 
   // Add result message first if provided (e.g., "Docker container exited...")
+  // Allow overflow so the full message is visible and copyable
   if (resultMessage) {
-    lines.push(createBorderedLine(resultMessage, width, style));
+    lines.push(createBorderedLine(resultMessage, width, style, true));
   }
 
   lines.push(createBorderedLine(finishedMsg, width, style));
   lines.push(createBorderedLine(`Exit code: ${exitCode}`, width, style));
-  lines.push(createBorderedLine(`Log: ${logPath}`, width, style));
-  lines.push(createBorderedLine(`Session ID: ${sessionId}`, width, style));
+  // Allow overflow for log path and session ID so they can be copied completely
+  lines.push(createBorderedLine(`Log: ${logPath}`, width, style, true));
+  lines.push(
+    createBorderedLine(`Session ID: ${sessionId}`, width, style, true)
+  );
   lines.push(createBottomBorder(width, style));
 
   return lines.join('\n');

package/test/echo-integration.test.js

@@ -0,0 +1,767 @@
+#!/usr/bin/env bun
+/**
+ * Integration tests for echo command across all isolation modes
+ *
+ * Issue #55: Ensure `echo "hi"` works reliably in all modes with proper output
+ *
+ * These tests verify for ALL isolation modes (attached + detached):
+ * 1. Command output is captured and displayed
+ * 2. Start and finish blocks are properly formatted
+ * 3. Empty lines exist before and after command output
+ * 4. Log paths and session IDs are not truncated (fully copyable)
+ *
+ * Test coverage:
+ * - No isolation mode (direct execution)
+ * - Screen isolation: attached + detached
+ * - Tmux isolation: attached + detached
+ * - Docker isolation: attached + detached
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { execSync } = require('child_process');
+const path = require('path');
+const {
+  isCommandAvailable,
+  canRunLinuxDockerImages,
+} = require('../src/lib/isolation');
+
+// Path to the CLI
+const CLI_PATH = path.join(__dirname, '..', 'src', 'bin', 'cli.js');
+
+// Helper function to run the CLI and capture output
+function runCli(args, options = {}) {
+  const timeout = options.timeout || 30000;
+  try {
+    const result = execSync(`bun run ${CLI_PATH} ${args}`, {
+      encoding: 'utf8',
+      timeout,
+      env: {
+        ...process.env,
+        START_DISABLE_AUTO_ISSUE: '1',
+        START_DISABLE_TRACKING: '1',
+      },
+      maxBuffer: 1024 * 1024, // 1MB
+    });
+    return { success: true, output: result };
+  } catch (err) {
+    return {
+      success: false,
+      output: err.stdout || '',
+      stderr: err.stderr || '',
+      exitCode: err.status,
+    };
+  }
+}
+
+// Verify output contains expected structure for attached modes (shows finish block)
+function verifyAttachedModeOutput(output, expectedOutputText = 'hi') {
+  // Should contain start block
+  assert.ok(
+    output.includes('╭'),
+    'Output should contain start block top border'
+  );
+  assert.ok(output.includes('╰'), 'Output should contain block bottom border');
+  assert.ok(output.includes('Session ID:'), 'Output should contain Session ID');
+  assert.ok(
+    output.includes('Starting at'),
+    'Output should contain Starting at timestamp'
+  );
+
+  // Should contain command output
+  assert.ok(
+    output.includes(expectedOutputText),
+    `Output should contain the "${expectedOutputText}" command output`
+  );
+
+  // Should contain finish block (for attached modes)
+  assert.ok(
+    output.includes('Finished at'),
+    'Output should contain Finished at timestamp'
+  );
+  assert.ok(output.includes('Exit code:'), 'Output should contain Exit code');
+  assert.ok(output.includes('Log:'), 'Output should contain Log path');
+
+  // Verify there are empty lines around output (structure check)
+  const lines = output.split('\n');
+  const outputIndex = lines.findIndex((l) => l.trim() === expectedOutputText);
+
+  if (outputIndex > 0) {
+    // Check for empty line before output
+    const lineBefore = lines[outputIndex - 1];
+    // Line before should be empty or end of start block
+    assert.ok(
+      lineBefore.trim() === '' || lineBefore.includes('╰'),
+      `Expected empty line or block end before output, got: "${lineBefore}"`
+    );
+  }
+
+  if (outputIndex >= 0 && outputIndex < lines.length - 1) {
+    // Check for empty line after output
+    const lineAfter = lines[outputIndex + 1];
+    // Line after should be empty or start of finish block
+    assert.ok(
+      lineAfter.trim() === '' || lineAfter.includes('╭'),
+      `Expected empty line or block start after output, got: "${lineAfter}"`
+    );
+  }
+}
+
+// Verify output for detached modes (only start block, no finish block)
+function verifyDetachedModeOutput(output) {
+  // Should contain start block
+  assert.ok(
+    output.includes('╭'),
+    'Output should contain start block top border'
+  );
+  assert.ok(output.includes('╰'), 'Output should contain block bottom border');
+  assert.ok(output.includes('Session ID:'), 'Output should contain Session ID');
+  assert.ok(
+    output.includes('Starting at'),
+    'Output should contain Starting at timestamp'
+  );
+
+  // Should show detached mode info
+  assert.ok(
+    output.includes('Mode: detached') || output.includes('Reattach with'),
+    'Output should indicate detached mode or show reattach instructions'
+  );
+}
+
+// Verify log path is not truncated
+function verifyLogPathNotTruncated(output) {
+  const logMatch = output.match(/Log: (.+)/);
+  assert.ok(logMatch, 'Should have Log line');
+  const logPath = logMatch[1].trim();
+  // Remove trailing box border character if present
+  const cleanPath = logPath.replace(/\s*│\s*$/, '').trim();
+
+  // Log path should end with .log extension
+  assert.ok(
+    cleanPath.endsWith('.log'),
+    `Log path should end with .log extension, got: "${cleanPath}"`
+  );
+}
+
+// Verify session ID is a valid UUID
+function verifySessionId(output) {
+  const sessionMatches = output.match(/Session ID: ([a-f0-9-]+)/g);
+  assert.ok(
+    sessionMatches && sessionMatches.length >= 1,
+    'Should have Session ID'
+  );
+
+  // Extract UUID from first match
+  const uuidMatch = sessionMatches[0].match(
+    /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/
+  );
+  assert.ok(uuidMatch, 'Session ID should be a valid UUID format');
+}
+
+describe('Echo Integration Tests - Issue #55', () => {
+  // ============================================
+  // NO ISOLATION MODE (Direct Execution)
+  // ============================================
+  describe('No Isolation Mode (Direct Execution)', () => {
+    it('should execute echo hi and show output with proper formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      verifyAttachedModeOutput(result.output);
+      verifyLogPathNotTruncated(result.output);
+      verifySessionId(result.output);
+
+      console.log('  ✓ No isolation mode: echo hi works correctly');
+    });
+
+    it('should execute echo with single quotes', () => {
+      const result = runCli("'echo hi'");
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+
+      console.log('  ✓ No isolation mode: echo with single quotes works');
+    });
+
+    it('should execute echo with double quotes', () => {
+      const result = runCli('\'echo "hi"\'');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+
+      console.log('  ✓ No isolation mode: echo with double quotes works');
+    });
+
+    it('should have consistent empty line formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // The pattern should be:
+      // [start block]
+      // [empty line]
+      // hi
+      // [empty line]
+      // [finish block]
+
+      const lines = result.output.split('\n');
+      let foundHi = false;
+      let hiIndex = -1;
+
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === 'hi') {
+          foundHi = true;
+          hiIndex = i;
+          break;
+        }
+      }
+
+      assert.ok(foundHi, 'Should find "hi" output on its own line');
+
+      // Check line before hi
+      if (hiIndex > 0) {
+        const prevLine = lines[hiIndex - 1].trim();
+        assert.ok(
+          prevLine === '' || prevLine.startsWith('╰'),
+          `Line before "hi" should be empty or end of start block`
+        );
+      }
+
+      // Check line after hi
+      if (hiIndex < lines.length - 1) {
+        const nextLine = lines[hiIndex + 1].trim();
+        assert.ok(
+          nextLine === '' || nextLine.startsWith('╭'),
+          `Line after "hi" should be empty or start of finish block`
+        );
+      }
+
+      console.log('  ✓ Empty line formatting is consistent');
+    });
+  });
+
+  // ============================================
+  // SCREEN ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Screen Isolation Mode', () => {
+    const screenAvailable = isCommandAvailable('screen');
+
+    if (!screenAvailable) {
+      it('should skip screen tests when screen is not installed', () => {
+        console.log('  ⚠ screen not installed, skipping screen tests');
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      it('should execute echo hi in attached screen mode with proper formatting', () => {
+        const result = runCli('--isolated screen -- echo hi', {
+          timeout: 30000,
+        });
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyAttachedModeOutput(result.output);
+        verifyLogPathNotTruncated(result.output);
+        verifySessionId(result.output);
+
+        // Should show isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: screen'),
+          'Should show screen isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: attached'),
+          'Should show attached mode'
+        );
+
+        console.log('  ✓ Screen isolation (attached): echo hi works correctly');
+      });
+
+      it('should execute echo with quotes in attached screen mode', () => {
+        const result = runCli('--isolated screen -- echo "hello world"', {
+          timeout: 30000,
+        });
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        assert.ok(
+          result.output.includes('hello world'),
+          'Output should contain "hello world"'
+        );
+
+        console.log('  ✓ Screen isolation (attached): echo with quotes works');
+      });
+
+      it('should show exit code and finish block in attached screen mode', () => {
+        const result = runCli('--isolated screen -- echo hi', {
+          timeout: 30000,
+        });
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Exit code: 0'),
+          'Should show exit code 0'
+        );
+        assert.ok(
+          result.output.includes('exited with code 0') ||
+            result.output.includes('Finished at'),
+          'Should show completion info'
+        );
+
+        console.log(
+          '  ✓ Screen isolation (attached): finish block displays correctly'
+        );
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached screen mode', () => {
+        const sessionName = `test-screen-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated screen -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        // Detached mode should succeed (command starts in background)
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show screen isolation info with detached mode
+        assert.ok(
+          result.output.includes('[Isolation] Environment: screen'),
+          'Should show screen isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: kill the screen session
+        try {
+          execSync(`screen -S ${sessionName} -X quit`, { stdio: 'ignore' });
+        } catch {
+          // Session may have already exited
+        }
+
+        console.log(
+          '  ✓ Screen isolation (detached): echo hi starts correctly'
+        );
+      });
+
+      it('should provide reattach instructions in detached screen mode', () => {
+        const sessionName = `test-screen-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated screen -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('screen -r'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`screen -S ${sessionName} -X quit`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Screen isolation (detached): reattach instructions displayed'
+        );
+      });
+    });
+  });
+
+  // ============================================
+  // TMUX ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Tmux Isolation Mode', () => {
+    const tmuxAvailable = isCommandAvailable('tmux');
+
+    if (!tmuxAvailable) {
+      it('should skip tmux tests when tmux is not installed', () => {
+        console.log('  ⚠ tmux not installed, skipping tmux tests');
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      // Note: Attached tmux mode requires a TTY, which is not available in CI
+      // We test that it properly handles no-TTY scenario
+      it('should handle attached tmux mode (may require TTY)', () => {
+        const result = runCli('--isolated tmux -- echo hi', { timeout: 30000 });
+
+        // Either succeeds or fails due to no TTY - both are valid
+        if (result.success) {
+          assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+          assert.ok(
+            result.output.includes('[Isolation] Environment: tmux'),
+            'Should show tmux isolation info'
+          );
+          console.log('  ✓ Tmux isolation (attached): echo hi works correctly');
+        } else {
+          // May fail due to no TTY in CI
+          console.log(
+            '  ⚠ Tmux isolation (attached): skipped (no TTY available)'
+          );
+          assert.ok(true);
+        }
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached tmux mode', () => {
+        const sessionName = `test-tmux-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        // Detached mode should succeed
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show tmux isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: tmux'),
+          'Should show tmux isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: kill the tmux session
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Session may have already exited
+        }
+
+        console.log('  ✓ Tmux isolation (detached): echo hi starts correctly');
+      });
+
+      it('should provide reattach instructions in detached tmux mode', () => {
+        const sessionName = `test-tmux-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('tmux attach'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Tmux isolation (detached): reattach instructions displayed'
+        );
+      });
+
+      it('should execute echo with quotes in detached tmux mode', () => {
+        const sessionName = `test-tmux-quotes-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo "hello world"`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+
+        // Cleanup
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log('  ✓ Tmux isolation (detached): echo with quotes works');
+      });
+    });
+  });
+
+  // ============================================
+  // DOCKER ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Docker Isolation Mode', () => {
+    const dockerAvailable = canRunLinuxDockerImages();
+
+    if (!dockerAvailable) {
+      it('should skip docker tests when docker is not available or cannot run Linux containers', () => {
+        console.log(
+          '  ⚠ docker not available or cannot run Linux containers, skipping docker tests'
+        );
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      it('should execute echo hi in attached docker mode with proper formatting', () => {
+        const containerName = `test-docker-attached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyAttachedModeOutput(result.output);
+        verifyLogPathNotTruncated(result.output);
+        verifySessionId(result.output);
+
+        // Should show docker isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: docker'),
+          'Should show docker isolation info'
+        );
+        assert.ok(
+          result.output.includes('[Isolation] Image: alpine:latest'),
+          'Should show docker image info'
+        );
+
+        console.log('  ✓ Docker isolation (attached): echo hi works correctly');
+      });
+
+      it('should execute echo with quotes in attached docker mode', () => {
+        const containerName = `test-docker-quotes-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo "hello world"`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        assert.ok(
+          result.output.includes('hello world'),
+          'Output should contain "hello world"'
+        );
+
+        console.log('  ✓ Docker isolation (attached): echo with quotes works');
+      });
+
+      it('should show exit code and finish block in attached docker mode', () => {
+        const containerName = `test-docker-finish-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Exit code: 0'),
+          'Should show exit code 0'
+        );
+        assert.ok(
+          result.output.includes('exited with code 0') ||
+            result.output.includes('Finished at'),
+          'Should show completion info'
+        );
+
+        console.log(
+          '  ✓ Docker isolation (attached): finish block displays correctly'
+        );
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached docker mode', () => {
+        const containerName = `test-docker-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        // Detached mode should succeed
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show docker isolation info with detached mode
+        assert.ok(
+          result.output.includes('[Isolation] Environment: docker'),
+          'Should show docker isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: remove the docker container
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Container may have already exited
+        }
+
+        console.log(
+          '  ✓ Docker isolation (detached): echo hi starts correctly'
+        );
+      });
+
+      it('should provide reattach instructions in detached docker mode', () => {
+        const containerName = `test-docker-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('docker attach') ||
+            result.output.includes('docker logs'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Docker isolation (detached): reattach instructions displayed'
+        );
+      });
+
+      it('should execute echo with quotes in detached docker mode', () => {
+        const containerName = `test-docker-quotes-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo "hello world"`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+
+        // Cleanup
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log('  ✓ Docker isolation (detached): echo with quotes works');
+      });
+    });
+  });
+
+  // ============================================
+  // OUTPUT BLOCK FORMATTING (Cross-mode tests)
+  // ============================================
+  describe('Output Block Formatting', () => {
+    it('should not truncate long log paths', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // Get the log path line
+      const logMatch = result.output.match(/Log: (.+)/);
+      assert.ok(logMatch, 'Should have Log line');
+
+      const logLine = logMatch[0];
+      // Log line should contain full path ending in .log
+      assert.ok(
+        logLine.includes('.log'),
+        'Log path should be complete and not truncated'
+      );
+
+      console.log('  ✓ Log paths are not truncated');
+    });
+
+    it('should show full session ID in both start and finish blocks', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // Get session IDs from output (should appear twice: start and finish block)
+      const sessionMatches = result.output.match(/Session ID: ([a-f0-9-]+)/g);
+      assert.ok(
+        sessionMatches && sessionMatches.length >= 2,
+        'Should have Session ID in both blocks'
+      );
+
+      // Extract UUID from first match
+      const uuidMatch = sessionMatches[0].match(
+        /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/
+      );
+      assert.ok(uuidMatch, 'Session ID should be a valid UUID format');
+
+      console.log('  ✓ Session IDs are complete UUIDs in both blocks');
+    });
+
+    it('should have consistent exit code formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(
+        result.output.includes('Exit code: 0'),
+        'Should show "Exit code: 0" for successful command'
+      );
+
+      console.log('  ✓ Exit code formatting is consistent');
+    });
+
+    it('should include timing information in finish block', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(
+        result.output.includes('seconds') || result.output.includes('in 0.'),
+        'Should include timing information'
+      );
+
+      console.log('  ✓ Timing information is present in finish block');
+    });
+  });
+});
+
+console.log('=== Echo Integration Tests - Issue #55 ===');
+console.log(
+  'Testing that "echo hi" works correctly across all isolation modes'
+);
+console.log(
+  'Coverage: No isolation, Screen (attached/detached), Tmux (attached/detached), Docker (attached/detached)'
+);
+console.log('');