feat: Sync JS implementation with Rust for timeline naming and virtual commands

JavaScript implementation updates:
- Renamed "spine" terminology to "timeline" throughout output-blocks.js
  - SPINE constant → TIMELINE_MARKER (old name deprecated)
  - createSpineLine() → createTimelineLine() (old name deprecated)
  - createEmptySpineLine() → createEmptyTimelineLine() (old name deprecated)
- Added virtual command visualization for Docker image pulls
  - When Docker isolation requires pulling an image, it's shown as `$ docker pull <image>`
  - Pull output is streamed in real-time with result markers (✓/✗)
  - Only displayed when image actually needs to be pulled (conditional display)
- New API additions:
  - createVirtualCommandBlock() - for formatting virtual commands
  - createVirtualCommandResult() - for result markers
  - createTimelineSeparator() - for separator between virtual and user commands
  - dockerImageExists() - check if image is available locally
  - dockerPullImage() - pull with streaming output
  - createStartBlock({ deferCommand }) - defer command display for multi-step execution
- Renamed "isolation backend" to "isolation environment" in docs and error messages
- All deprecated items have backward-compatible aliases for smooth migration

Fixes #70

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: konard

README.md

@@ -96,7 +96,7 @@ Variables like `$packageName`, `$version`, `$repository` are captured and used i
 
 ### Automatic Logging
 
-All command output is automatically saved to your system's temporary directory. Output uses a "status spine" format with clear visual distinction:
+All command output is automatically saved to your system's temporary directory. Output uses a "timeline" format with clear visual distinction:
 
 ```
 │ session   abc-123-def-456-ghi
@@ -205,28 +205,28 @@ The `--isolated-user` option:
 - Runs the command as that user
 - Automatically deletes the user after the command completes (unless `--keep-user` is specified)
 - Requires sudo access without password (NOPASSWD configuration)
-- Works with screen and tmux isolation backends (not docker)
+- Works with screen and tmux isolation environments (not docker)
 
 This is useful for:
 
 - Running untrusted code in isolation
 - Testing with a clean user environment
 - Ensuring commands don't affect your user's files
 
-#### Supported Backends
+#### Supported Isolation Environments
 
-| Backend  | Description                                    | Installation                                               |
-| -------- | ---------------------------------------------- | ---------------------------------------------------------- |
-| `screen` | GNU Screen terminal multiplexer                | `apt install screen` / `brew install screen`               |
-| `tmux`   | Modern terminal multiplexer                    | `apt install tmux` / `brew install tmux`                   |
-| `docker` | Container isolation (requires --image)         | [Docker Installation](https://docs.docker.com/get-docker/) |
-| `ssh`    | Remote execution via SSH (requires --endpoint) | `apt install openssh-client` / `brew install openssh`      |
+| Environment | Description                                    | Installation                                               |
+| ----------- | ---------------------------------------------- | ---------------------------------------------------------- |
+| `screen`    | GNU Screen terminal multiplexer                | `apt install screen` / `brew install screen`               |
+| `tmux`      | Modern terminal multiplexer                    | `apt install tmux` / `brew install tmux`                   |
+| `docker`    | Container isolation (requires --image)         | [Docker Installation](https://docs.docker.com/get-docker/) |
+| `ssh`       | Remote execution via SSH (requires --endpoint) | `apt install openssh-client` / `brew install openssh`      |
 
 #### Isolation Options
 
 | Option                           | Description                                               |
 | -------------------------------- | --------------------------------------------------------- |
-| `--isolated, -i`                 | Isolation backend (screen, tmux, docker, ssh)             |
+| `--isolated, -i`                 | Isolation environment (screen, tmux, docker, ssh)         |
 | `--attached, -a`                 | Run in attached/foreground mode (default)                 |
 | `--detached, -d`                 | Run in detached/background mode                           |
 | `--session, -s`                  | Custom session/container name                             |
@@ -266,7 +266,7 @@ The tool works in any environment:
 - **No `gh-upload-log`?** - Issue can still be created with local log reference
 - **Repository not detected?** - Command runs normally with logging
 - **No permission to create issue?** - Skipped with a clear message
-- **Isolation backend not installed?** - Clear error message with installation instructions
+- **Isolation environment not installed?** - Clear error message with installation instructions
 
 ## Requirements
 
@@ -335,7 +335,7 @@ You can create your own substitution patterns by placing a `substitutions.lino`
 
 ## Log File Format
 
-Log files are saved as `start-command-{timestamp}-{random}.log` and contain the command output along with metadata. The console output uses a "status spine" format:
+Log files are saved as `start-command-{timestamp}-{random}.log` and contain the command output along with metadata. The console output uses a "timeline" format:
 
 ```
 │ session   abc-123-def-456-ghi

js/src/bin/cli.js

@@ -512,12 +512,15 @@ async function runWithIsolation(
   }
 
   // Print start block with session ID and isolation info
+  // For docker isolation, defer command printing to allow virtual commands (like docker pull) to be shown first
+  const deferCommand = environment === 'docker';
   console.log(
     createStartBlock({
       sessionId,
       timestamp: startTime,
       command: cmd,
       extraLines,
+      deferCommand,
     })
   );
   console.log('');
@@ -558,8 +561,8 @@ async function runWithIsolation(
   let result;
 
   if (environment) {
-    // Run in isolation backend (screen, tmux, docker, ssh)
-    // Note: Isolation backends currently use native spawn/execSync
+    // Run in isolation environment (screen, tmux, docker, ssh)
+    // Note: Isolation environments currently use native spawn/execSync
     // Future: Add command-stream support with raw() function for multiplexers
     result = await runIsolated(environment, cmd, {
       session: options.session,
@@ -571,7 +574,7 @@ async function runWithIsolation(
       autoRemoveDockerContainer: options.autoRemoveDockerContainer,
     });
   } else if (createdUser) {
-    // Run directly as the created user (no isolation backend)
+    // Run directly as the created user (no isolation environment)
     result = await runAsIsolatedUser(cmd, createdUser);
   } else {
     // This shouldn't happen in isolation mode, but handle gracefully

js/src/lib/args-parser.js

@@ -30,7 +30,7 @@ const DEBUG =
   process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
 
 /**
- * Valid isolation backends
+ * Valid isolation environments
  */
 const VALID_BACKENDS = ['screen', 'tmux', 'docker', 'ssh'];
 
@@ -80,7 +80,7 @@ function generateUUID() {
  */
 function parseArgs(args) {
   const wrapperOptions = {
-    isolated: null, // Isolation backend: screen, tmux, docker, ssh
+    isolated: null, // Isolation environment: screen, tmux, docker, ssh
     attached: false, // Run in attached mode
     detached: false, // Run in detached mode
     session: null, // Session name
@@ -375,11 +375,11 @@ function validateOptions(options) {
     );
   }
 
-  // Validate isolation backend
+  // Validate isolation environment
   if (options.isolated !== null) {
     if (!VALID_BACKENDS.includes(options.isolated)) {
       throw new Error(
-        `Invalid isolation backend: "${options.isolated}". Valid options are: ${VALID_BACKENDS.join(', ')}`
+        `Invalid isolation environment: "${options.isolated}". Valid options are: ${VALID_BACKENDS.join(', ')}`
       );
     }
 

js/src/lib/isolation.js

@@ -618,6 +618,70 @@ function runInSsh(command, options = {}) {
   }
 }
 
+/**
+ * Check if a Docker image exists locally
+ * @param {string} image - Docker image name
+ * @returns {boolean} True if image exists locally
+ */
+function dockerImageExists(image) {
+  try {
+    execSync(`docker image inspect ${image}`, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pull a Docker image with output streaming
+ * Displays the pull operation as a virtual command in the timeline
+ * @param {string} image - Docker image to pull
+ * @returns {{success: boolean, output: string}} Pull result
+ */
+function dockerPullImage(image) {
+  const {
+    createVirtualCommandBlock,
+    createVirtualCommandResult,
+    createTimelineSeparator,
+  } = require('./output-blocks');
+
+  // Print the virtual command line
+  console.log(createVirtualCommandBlock(`docker pull ${image}`));
+  console.log();
+
+  let output = '';
+  let success = false;
+
+  try {
+    // Run docker pull with inherited stdio for real-time output
+    const result = spawnSync('docker', ['pull', image], {
+      stdio: ['pipe', 'inherit', 'inherit'],
+    });
+
+    success = result.status === 0;
+
+    if (result.stdout) {
+      output = result.stdout.toString();
+    }
+    if (result.stderr) {
+      output += result.stderr.toString();
+    }
+  } catch (err) {
+    console.error(`Failed to run docker pull: ${err.message}`);
+    output = err.message;
+    success = false;
+  }
+
+  // Print result marker and separator
+  console.log();
+  console.log(createVirtualCommandResult(success));
+  console.log(createTimelineSeparator());
+
+  return { success, output };
+}
+
 /**
  * Run command in Docker container
  * @param {string} command - Command to execute
@@ -644,6 +708,24 @@ function runInDocker(command, options = {}) {
 
   const containerName = options.session || generateSessionName('docker');
 
+  // Check if image exists locally; if not, pull it as a virtual command
+  if (!dockerImageExists(options.image)) {
+    const pullResult = dockerPullImage(options.image);
+    if (!pullResult.success) {
+      return Promise.resolve({
+        success: false,
+        containerName: null,
+        message: `Failed to pull Docker image: ${options.image}`,
+        exitCode: 1,
+      });
+    }
+  }
+
+  // Print the user command (this appears after any virtual commands like docker pull)
+  const { createCommandLine } = require('./output-blocks');
+  console.log(createCommandLine(command));
+  console.log();
+
   try {
     if (options.detached) {
       // Detached mode: docker run -d --name <name> [--user <user>] <image> <shell> -c '<command>'
@@ -753,8 +835,8 @@ function runInDocker(command, options = {}) {
 }
 
 /**
- * Run command in the specified isolation backend
- * @param {string} backend - Isolation backend (screen, tmux, docker, ssh)
+ * Run command in the specified isolation environment
+ * @param {string} backend - Isolation environment (screen, tmux, docker, ssh)
  * @param {string} command - Command to execute
  * @param {object} options - Options
  * @returns {Promise<{success: boolean, message: string}>}
@@ -772,7 +854,7 @@ function runIsolated(backend, command, options = {}) {
     default:
       return Promise.resolve({
         success: false,
-        message: `Unknown isolation backend: ${backend}`,
+        message: `Unknown isolation environment: ${backend}`,
       });
   }
 }
@@ -885,7 +967,7 @@ function resetScreenVersionCache() {
 }
 
 /**
- * Run command as an isolated user (without isolation backend)
+ * Run command as an isolated user (without isolation environment)
  * Uses sudo -u to switch users
  * @param {string} cmd - Command to execute
  * @param {string} username - User to run as
@@ -990,4 +1072,7 @@ module.exports = {
   resetScreenVersionCache,
   canRunLinuxDockerImages,
   getDefaultDockerImage,
+  // Docker image utilities for virtual command visualization
+  dockerImageExists,
+  dockerPullImage,
 };