feat: add ability to delete individual runs

Add CLI command 'gob runs delete <run_id>' and TUI keybinding 'd' in
the Runs panel to delete stopped runs and their log files. Job
statistics (run count, success rate, durations) are recalculated
after deletion.

Author: juanibiapina

CHANGELOG.md

@@ -9,6 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Delete individual runs**: Remove stopped runs and their log files without deleting the entire job
+  - CLI: `gob runs delete <run_id>` - delete a specific run by ID
+  - TUI: Press `d` in the Runs panel to delete the selected run
+  - Only stopped runs can be deleted; running runs must be stopped first
+  - Deletes associated stdout/stderr log files from disk
+  - Job statistics (run count, success rate, durations) are recalculated after deletion
+
 - **TUI stderr panel expansion**: The stderr panel now expands to 80% of the right side when focused, making it easier to read error output
 
 - **TUI progress bar**: Shows a progress bar in the Runs panel when a job is running

README.md

@@ -261,7 +261,7 @@ The TUI has an info bar and five panels:
 | `w` | Toggle line wrap |
 | `s/S` | Stop / kill job |
 | `r` | Restart job |
-| `d` | Delete stopped job |
+| `d` | Delete stopped job/run |
 | `n` | New job |
 | `1/2/3/4/5` | Switch to panel |
 | `?` | Show all shortcuts |
@@ -313,6 +313,7 @@ Run `gob <command> --help` for detailed usage, examples, and flags.
 | `await-all` | Wait for all jobs to complete (`--timeout`) |
 | `list` | List jobs (`--all` for all directories) |
 | `runs <id>` | Show run history for a job |
+| `runs delete <run_id>` | Delete a stopped run and its logs |
 | `stats <id>` | Show statistics for a job |
 | `stdout <id>` | View stdout (`--follow` for real-time) |
 | `stderr <id>` | View stderr (`--follow` for real-time) |

cmd/runs.go

@@ -34,6 +34,9 @@ Example output:
   abc-4  1 hour ago  2m15s     ✓ (0)
   abc-3  2 hours ago 2m45s     ✗ (1)
 
+Subcommands:
+  runs delete <run_id>  Delete a stopped run and its log files
+
 Exit codes:
   0: Success
   1: Error (job not found)`,
@@ -106,6 +109,46 @@ Exit codes:
 	},
 }
 
+var runsDeleteCmd = &cobra.Command{
+	Use:   "delete <run_id>",
+	Short: "Delete a stopped run and its log files",
+	Long: `Delete a stopped run and its associated log files.
+
+The run must be stopped (not currently running). To delete a running run,
+first stop the job with 'gob stop <job_id>'.
+
+Examples:
+  gob runs delete abc-1
+  gob runs delete myserver-5
+
+Exit codes:
+  0: Success
+  1: Error (run not found, run still running)`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		runID := args[0]
+
+		// Connect to daemon
+		client, err := daemon.NewClient()
+		if err != nil {
+			return fmt.Errorf("failed to create client: %w", err)
+		}
+		defer client.Close()
+
+		if err := client.Connect(); err != nil {
+			return fmt.Errorf("failed to connect to daemon: %w", err)
+		}
+
+		// Delete the run
+		if err := client.RemoveRun(runID); err != nil {
+			return err
+		}
+
+		fmt.Printf("Deleted run %s\n", runID)
+		return nil
+	},
+}
+
 // formatRelativeTime formats a time as a human-readable relative string
 func formatRelativeTime(t time.Time) string {
 	d := time.Since(t)
@@ -136,4 +179,5 @@ func formatRelativeTime(t time.Time) string {
 func init() {
 	RootCmd.AddCommand(runsCmd)
 	runsCmd.Flags().BoolVar(&runsJSON, "json", false, "Output in JSON format")
+	runsCmd.AddCommand(runsDeleteCmd)
 }

internal/daemon/client.go

@@ -385,6 +385,23 @@ func (c *Client) Remove(jobID string) (int, error) {
 	return int(pid), nil
 }
 
+// RemoveRun removes a stopped run and its log files
+func (c *Client) RemoveRun(runID string) error {
+	req := NewRequest(RequestTypeRemoveRun)
+	req.Payload["run_id"] = runID
+
+	resp, err := c.SendRequest(req)
+	if err != nil {
+		return err
+	}
+
+	if !resp.Success {
+		return fmt.Errorf("%s", resp.Error)
+	}
+
+	return nil
+}
+
 // StopAll stops all running jobs
 func (c *Client) StopAll() (stopped int, err error) {
 	req := NewRequest(RequestTypeStopAll)

internal/daemon/daemon.go

@@ -356,6 +356,8 @@ func (d *Daemon) handleRequest(req *Request) *Response {
 		return d.handleStats(req)
 	case RequestTypePorts:
 		return d.handlePorts(req)
+	case RequestTypeRemoveRun:
+		return d.handleRemoveRun(req)
 	default:
 		return NewErrorResponse(fmt.Errorf("unknown request type: %s", req.Type))
 	}
@@ -619,6 +621,22 @@ func (d *Daemon) handleRemove(req *Request) *Response {
 	return resp
 }
 
+// handleRemoveRun handles a remove_run request
+func (d *Daemon) handleRemoveRun(req *Request) *Response {
+	runID, ok := req.Payload["run_id"].(string)
+	if !ok {
+		return NewErrorResponse(fmt.Errorf("missing run_id"))
+	}
+
+	if err := d.jobManager.RemoveRun(runID); err != nil {
+		return NewErrorResponse(err)
+	}
+
+	resp := NewSuccessResponse()
+	resp.Data["run_id"] = runID
+	return resp
+}
+
 // handleStopAll handles a stop_all request
 func (d *Daemon) handleStopAll(req *Request) *Response {
 	stopped := d.jobManager.StopAll()

internal/daemon/daemon_test.go

@@ -464,3 +464,109 @@ func TestDaemon_handlePorts_AllJobs(t *testing.T) {
 		t.Error("expected ports in response")
 	}
 }
+
+func TestDaemon_handleRemoveRun(t *testing.T) {
+	tmpDir := t.TempDir()
+	executor := NewFakeProcessExecutor()
+	jm := NewJobManagerWithExecutor(tmpDir, nil, executor, nil)
+
+	// Add a job (which creates a run)
+	job, _, _ := jm.AddJob([]string{"echo"}, "/workdir", "", nil)
+
+	// Get the run ID
+	runs, _ := jm.ListRunsForJob(job.ID)
+	runID := runs[0].ID
+
+	// Stop the process first
+	executor.LastHandle().Stop()
+	time.Sleep(10 * time.Millisecond)
+
+	d := &Daemon{jobManager: jm}
+	req := &Request{
+		Type: RequestTypeRemoveRun,
+		Payload: map[string]interface{}{
+			"run_id": runID,
+		},
+	}
+
+	resp := d.handleRequest(req)
+
+	if !resp.Success {
+		t.Errorf("expected success, got error: %s", resp.Error)
+	}
+
+	if resp.Data["run_id"] != runID {
+		t.Errorf("expected run_id %s in response, got %v", runID, resp.Data["run_id"])
+	}
+
+	// Verify run is actually removed
+	runs, _ = jm.ListRunsForJob(job.ID)
+	if len(runs) != 0 {
+		t.Errorf("expected 0 runs after removal, got %d", len(runs))
+	}
+}
+
+func TestDaemon_handleRemoveRun_MissingRunID(t *testing.T) {
+	tmpDir := t.TempDir()
+	executor := NewFakeProcessExecutor()
+	jm := NewJobManagerWithExecutor(tmpDir, nil, executor, nil)
+
+	d := &Daemon{jobManager: jm}
+	req := &Request{
+		Type:    RequestTypeRemoveRun,
+		Payload: map[string]interface{}{},
+	}
+
+	resp := d.handleRequest(req)
+
+	if resp.Success {
+		t.Error("expected error for missing run_id")
+	}
+}
+
+func TestDaemon_handleRemoveRun_NotFound(t *testing.T) {
+	tmpDir := t.TempDir()
+	executor := NewFakeProcessExecutor()
+	jm := NewJobManagerWithExecutor(tmpDir, nil, executor, nil)
+
+	d := &Daemon{jobManager: jm}
+	req := &Request{
+		Type: RequestTypeRemoveRun,
+		Payload: map[string]interface{}{
+			"run_id": "nonexistent-1",
+		},
+	}
+
+	resp := d.handleRequest(req)
+
+	if resp.Success {
+		t.Error("expected error for nonexistent run")
+	}
+}
+
+func TestDaemon_handleRemoveRun_Running(t *testing.T) {
+	tmpDir := t.TempDir()
+	executor := NewFakeProcessExecutor()
+	jm := NewJobManagerWithExecutor(tmpDir, nil, executor, nil)
+
+	// Add a job (which creates a running run)
+	job, _, _ := jm.AddJob([]string{"echo"}, "/workdir", "", nil)
+
+	// Get the run ID while it's still running
+	runs, _ := jm.ListRunsForJob(job.ID)
+	runID := runs[0].ID
+
+	d := &Daemon{jobManager: jm}
+	req := &Request{
+		Type: RequestTypeRemoveRun,
+		Payload: map[string]interface{}{
+			"run_id": runID,
+		},
+	}
+
+	resp := d.handleRequest(req)
+
+	if resp.Success {
+		t.Error("expected error for running run")
+	}
+}

internal/daemon/db.go

@@ -177,6 +177,12 @@ func (s *Store) UpdateRun(run *Run) error {
 	return err
 }
 
+// DeleteRun removes a run from the database
+func (s *Store) DeleteRun(runID string) error {
+	_, err := s.db.Exec("DELETE FROM runs WHERE id = ?", runID)
+	return err
+}
+
 // LoadJobs loads all jobs from the database
 func (s *Store) LoadJobs() ([]*Job, error) {
 	rows, err := s.db.Query(`

internal/daemon/job.go

@@ -1004,6 +1004,112 @@ func (jm *JobManager) RemoveJob(jobID string) error {
 	return nil
 }
 
+// RemoveRun removes a stopped run and its log files
+func (jm *JobManager) RemoveRun(runID string) error {
+	jm.mu.Lock()
+	defer jm.mu.Unlock()
+
+	run, ok := jm.runs[runID]
+	if !ok {
+		return fmt.Errorf("run not found: %s", runID)
+	}
+
+	// Check if run is currently running
+	if run.Status == "running" {
+		return fmt.Errorf("cannot remove running run: %s (stop the job first)", runID)
+	}
+
+	// Get the job for stats update
+	job, jobExists := jm.jobs[run.JobID]
+
+	// Capture run info for event before deletion
+	runResp := runToResponse(run)
+
+	// Update job statistics if job exists
+	if jobExists && run.StoppedAt != nil {
+		durationMs := run.StoppedAt.Sub(run.StartedAt).Milliseconds()
+
+		// Decrement counts
+		job.RunCount--
+		if run.ExitCode != nil && *run.ExitCode == 0 {
+			job.SuccessCount--
+			job.SuccessTotalDurationMs -= durationMs
+		} else if run.ExitCode != nil {
+			job.FailureCount--
+			job.FailureTotalDurationMs -= durationMs
+		}
+		// Killed processes (ExitCode == nil) only affect RunCount
+
+		// Recalculate min/max duration from remaining runs
+		jm.recalculateMinMaxDuration(job)
+	}
+
+	// Delete log files
+	os.Remove(run.StdoutPath)
+	os.Remove(run.StderrPath)
+
+	// Remove from in-memory map
+	delete(jm.runs, runID)
+
+	// Delete from database and update job stats
+	if jm.store != nil {
+		if err := jm.store.DeleteRun(runID); err != nil {
+			Logger.Warn("failed to delete run from database", "id", runID, "error", err)
+		}
+		if jobExists {
+			if err := jm.store.UpdateJob(job); err != nil {
+				Logger.Warn("failed to update job stats", "id", job.ID, "error", err)
+			}
+		}
+	}
+
+	// Emit removed event with updated stats
+	var jobResp JobResponse
+	var stats *StatsResponse
+	if jobExists {
+		jobResp = jm.jobToResponse(job)
+		s := jobToStats(job)
+		stats = &s
+	}
+	jm.emitEvent(Event{
+		Type:            EventTypeRunRemoved,
+		JobID:           run.JobID,
+		Job:             jobResp,
+		Run:             &runResp,
+		Stats:           stats,
+		JobCount:        len(jm.jobs),
+		RunningJobCount: jm.countRunningJobsLocked(),
+	})
+
+	return nil
+}
+
+// recalculateMinMaxDuration recalculates min/max duration from all stopped runs for a job
+func (jm *JobManager) recalculateMinMaxDuration(job *Job) {
+	job.MinDurationMs = 0
+	job.MaxDurationMs = 0
+
+	first := true
+	for _, run := range jm.runs {
+		if run.JobID != job.ID || run.StoppedAt == nil {
+			continue
+		}
+		durationMs := run.StoppedAt.Sub(run.StartedAt).Milliseconds()
+		if first {
+			job.MinDurationMs = durationMs
+			job.MaxDurationMs = durationMs
+			first = false
+		} else {
+			if durationMs < job.MinDurationMs {
+				job.MinDurationMs = durationMs
+			}
+			if durationMs > job.MaxDurationMs {
+				job.MaxDurationMs = durationMs
+			}
+		}
+	}
+}
+
 // StopAll stops all running jobs and their process trees
 func (jm *JobManager) StopAll() (stopped int) {
 	jm.mu.Lock()