Suppress gob run output on success, dump on failure

gob run now waits silently instead of streaming output. On success,
it shows a summary with helper commands to inspect output. On failure
(including signal kills), it dumps full stdout/stderr then the summary.
This reduces noise for AI agents that only need output when diagnosing
failures.

Author: juanibiapina

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- `gob run` now suppresses command output on success; on failure, full output is dumped after completion
+
 ### Removed
 
 - `await-any` command

README.md

@@ -179,9 +179,9 @@ Do NOT use `gob` for:
 
 - `gob add <cmd>` - Start command in background, returns job ID
 - `gob add --description "context" <cmd>` - Start with description for context
-- `gob run <cmd>` - Run and wait for completion (equivalent to `gob add` + `gob await`)
+- `gob run <cmd>` - Run and wait for completion (output on failure only)
 - `gob run --description "context" <cmd>` - Run with description for context
-- `gob await <job_id>` - Wait for job to finish, stream output
+- `gob await <job_id>` - Wait for job to finish, stream output in real-time
 - `gob list` - List jobs with IDs, status, and descriptions
 - `gob logs <job_id>` - View stdout and stderr (stdout→stdout, stderr→stderr)
 - `gob stdout <job_id>` - View current stdout (useful if job may be stuck)

cmd/follow.go

@@ -126,6 +126,90 @@ func followJob(jobID string, pid int, stdoutPath string, avgDurationMs int64) (F
 	return result, nil
 }
 
+// waitForJob waits for a job to complete without streaming output.
+// It monitors for completion, stuck condition, or interruption using file mod times
+// for stuck detection instead of a Follower.
+func waitForJob(pid int, stdoutPath string, avgDurationMs int64) (FollowResult, error) {
+	// Derive stderr path from stdout path
+	stderrPath := strings.Replace(stdoutPath, ".stdout.log", ".stderr.log", 1)
+
+	// Wait for log files to exist
+	for i := 0; i < 50; i++ {
+		_, errStdout := os.Stat(stdoutPath)
+		_, errStderr := os.Stat(stderrPath)
+		if errStdout == nil && errStderr == nil {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	// Check if log files exist
+	if _, err := os.Stat(stdoutPath); os.IsNotExist(err) {
+		return FollowResult{}, fmt.Errorf("stdout log file not found: %s", stdoutPath)
+	}
+	if _, err := os.Stat(stderrPath); os.IsNotExist(err) {
+		return FollowResult{}, fmt.Errorf("stderr log file not found: %s", stderrPath)
+	}
+
+	// Calculate stuck detection threshold
+	var stuckTimeoutMs int64
+	if avgDurationMs == 0 {
+		stuckTimeoutMs = DefaultStuckTimeoutMs
+	} else {
+		stuckTimeoutMs = avgDurationMs + NoOutputWindowMs
+	}
+
+	stuckTimeout := time.Duration(stuckTimeoutMs) * time.Millisecond
+	noOutputWindow := time.Duration(NoOutputWindowMs) * time.Millisecond
+
+	// Set up signal handling - on Ctrl+C, just exit (job continues in background)
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	defer signal.Stop(sigCh)
+
+	result := FollowResult{}
+	startTime := time.Now()
+
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-sigCh:
+			// Interrupted — job continues in background
+			return result, nil
+		case <-ticker.C:
+			// Check if process completed
+			if !process.IsProcessRunning(pid) {
+				result.Completed = true
+				return result, nil
+			}
+
+			// Check for stuck condition using file mod times
+			elapsed := time.Since(startTime)
+			if elapsed > stuckTimeout {
+				lastOutput := lastFileModTime(stdoutPath, stderrPath)
+				if time.Since(lastOutput) > noOutputWindow {
+					result.PossiblyStuck = true
+					return result, nil
+				}
+			}
+		}
+	}
+}
+
+// lastFileModTime returns the most recent modification time of the given files.
+func lastFileModTime(paths ...string) time.Time {
+	var latest time.Time
+	for _, p := range paths {
+		info, err := os.Stat(p)
+		if err == nil && info.ModTime().After(latest) {
+			latest = info.ModTime()
+		}
+	}
+	return latest
+}
+
 // CalculateStuckTimeout returns the stuck detection timeout based on average duration
 // No data: 5 minutes
 // Has data: avg + 1 minute

cmd/run.go

@@ -15,12 +15,13 @@ var runCmd = &cobra.Command{
 	Use:                "run [--description <desc>] [--] <command> [args...]",
 	Short:              "Add a job and wait for it to complete",
 	DisableFlagParsing: true,
-	Long: `Add a new background job and immediately wait for it to complete.
+	Long: `Add a new background job and wait for it to complete.
 
-This is equivalent to running 'gob add' followed by 'gob await'.
+The job is started as a detached process. Output is suppressed on success
+and dumped on failure. Use 'gob add' + 'gob await' for real-time streaming.
 
-The job is started as a detached process and its output is streamed in real-time.
-The command exits with the job's exit code when it completes.
+On success: prints a summary with helper commands to inspect output.
+On failure: prints the full stdout and stderr, then a summary.
 
 Examples:
   # Run a build and wait for it
@@ -40,7 +41,9 @@ Examples:
   gob run -d "Run tests" -- npm test
 
 Output:
-  Shows job statistics (if available), then streams the job's output.
+  Shows job statistics (if available), then waits silently.
+  On success: summary with commands to view output.
+  On failure: full stdout/stderr followed by summary.
 
 Exit codes:
   Exits with the job's exit code (0 if successful, non-zero otherwise).
@@ -165,21 +168,21 @@ Exit codes:
 			fmt.Printf("  Stuck detection: timeout after %s\n", formatDuration(stuckTimeout))
 		}
 
-		// Follow the output until completion
-		followResult, err := followJob(result.Job.ID, result.Job.PID, result.Job.StdoutPath, avgDurationMs)
+		// Wait for job to complete (without streaming output)
+		waitResult, err := waitForJob(result.Job.PID, result.Job.StdoutPath, avgDurationMs)
 		if err != nil {
 			return err
 		}
 
-		if followResult.PossiblyStuck {
+		if waitResult.PossiblyStuck {
 			fmt.Printf("\nJob %s possibly stuck (no output for 1m)\n", result.Job.ID)
 			fmt.Printf("  gob stdout %s   # check current output\n", result.Job.ID)
 			fmt.Printf("  gob await %s    # continue waiting with output\n", result.Job.ID)
 			fmt.Printf("  gob stop %s     # stop the job\n", result.Job.ID)
 			return nil
 		}
 
-		if !followResult.Completed {
+		if !waitResult.Completed {
 			fmt.Printf("\nJob %s continues running in background\n", result.Job.ID)
 			fmt.Printf("  gob await %s   # wait for completion with live output\n", result.Job.ID)
 			fmt.Printf("  gob stop %s    # stop the job\n", result.Job.ID)
@@ -192,9 +195,23 @@ Exit codes:
 			return err
 		}
 
+		// On failure (non-zero or killed by signal), dump stdout/stderr
+		if job.ExitCode == nil || *job.ExitCode != 0 {
+			if err := printJobOutput(job); err != nil {
+				return err
+			}
+		}
+
 		// Show summary
 		printJobSummary(job)
 
+		// On success, show helper commands for inspecting output
+		if job.ExitCode != nil && *job.ExitCode == 0 {
+			fmt.Printf("  gob stdout %s   # view stdout\n", result.Job.ID)
+			fmt.Printf("  gob stderr %s   # view stderr\n", result.Job.ID)
+			fmt.Printf("  gob logs %s     # view both\n", result.Job.ID)
+		}
+
 		// Exit with job's exit code
 		if job.ExitCode != nil && *job.ExitCode != 0 {
 			os.Exit(*job.ExitCode)

test/run.bats

@@ -18,15 +18,18 @@ load 'test_helper'
   run "$JOB_CLI" run echo "hello world"
   assert_success
   assert_output --partial "Running job"
-  assert_output --partial "hello world"
   assert_output --partial "completed"
+  assert_output --partial "Exit code: 0"
 }
 
-@test "run command shows job output" {
-  run "$JOB_CLI" run -- sh -c "echo 'test output'; echo 'more output'"
+@test "run command suppresses output on success" {
+  # Use arithmetic so the output ("val_23", "val_34") differs from the command text
+  run "$JOB_CLI" run -- sh -c 'echo val_$((20+3)); echo val_$((30+4))'
   assert_success
-  assert_output --partial "test output"
-  assert_output --partial "more output"
+  refute_output --partial "val_23"
+  refute_output --partial "val_34"
+  assert_output --partial "gob stdout"
+  assert_output --partial "gob logs"
 }
 
 @test "run command shows summary with command" {
@@ -87,13 +90,13 @@ load 'test_helper'
   run "$JOB_CLI" run "echo hello world"
   assert_success
   assert_output --partial "Running job"
-  assert_output --partial "hello world"
 }
 
-@test "run command shows stderr output" {
-  run "$JOB_CLI" run -- sh -c "echo 'stderr message' >&2"
+@test "run command suppresses stderr on success" {
+  # Use arithmetic so the output ("err_45") differs from the command text
+  run "$JOB_CLI" run -- sh -c 'echo err_$((40+5)) >&2'
   assert_success
-  assert_output --partial "stderr message"
+  refute_output --partial "err_45"
 }
 
 @test "run command attaches to already running job" {
@@ -161,15 +164,38 @@ load 'test_helper'
   assert_output --partial "Expected duration if failure:"
 }
 
-@test "run command streams output in real-time" {
-  # Start a job that outputs something and completes
-  run "$JOB_CLI" run -- sh -c "echo 'first'; sleep 0.2; echo 'second'"
+@test "run command does not show output on success" {
+  # Use arithmetic so the output ("out_56", "out_67") differs from the command text
+  run "$JOB_CLI" run -- sh -c 'echo out_$((50+6)); sleep 0.2; echo out_$((60+7))'
   assert_success
-  assert_output --partial "first"
-  assert_output --partial "second"
+  refute_output --partial "out_56"
+  refute_output --partial "out_67"
   assert_output --partial "completed"
 }
 
+@test "run command shows output on failure" {
+  run "$JOB_CLI" run -- sh -c "echo 'failure stdout'; echo 'failure stderr' >&2; exit 1"
+  assert_failure 1
+  assert_output --partial "failure stdout"
+  assert_output --partial "failure stderr"
+  assert_output --partial "Exit code: 1"
+}
+
+@test "run command shows helper commands on success" {
+  run "$JOB_CLI" run true
+  assert_success
+  assert_output --partial "gob stdout"
+  assert_output --partial "gob stderr"
+  assert_output --partial "gob logs"
+}
+
+@test "run command does not show helper commands on failure" {
+  run "$JOB_CLI" run false
+  assert_failure
+  refute_output --partial "gob stdout"
+  refute_output --partial "gob logs"
+}
+
 @test "run command with --description stores description" {
   run "$JOB_CLI" run --description "Run test description" true
   assert_success