Make interactive mode a real session with a visible work trail

User-reported: sending a task felt like it fell out of the CLI rather
than being part of one experience — the prompt took over the screen,
the run ended, and the program exited after a single task.

- The prompt no longer switches to the terminal's alternate screen or
  clears the display. It draws inline and redraws only its own rows
  (wrapping accounted for), so everything above it stays on screen and
  in scrollback.
- Running `yolocoder` with no task now stays in a session: prompt,
  work, result, prompt again. `/exit`, `/quit`, or Ctrl+C leaves.
  Passing a task as an argument still runs once and exits.
- Progress is now a permanent trail instead of one self-overwriting
  line: the files read, searches run, plan, patch, apply, and test
  result each print and stay. ui.Session animates the current activity
  while Log writes lines above it; agent reports through a Progress
  interface.
- A self-update now says it happened before relaunching, so the
  version change isn't silent.

Verified through a pty: multi-turn session, conversational reply,
coding task trail, Shift+Enter multiline, /exit, Ctrl+C, and one-shot
mode.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: torrmal

README.md

@@ -11,12 +11,20 @@ repository is required: YoloCoder maps and patches the folder directly. If
 the folder already has its own `.git` (not an ancestor directory's), it's
 used opportunistically for a `.gitignore`-aware map and faster patch checks.
 
-Running `yolocoder` without a task opens a multiline terminal editor showing
-the current folder. Paste multiline instructions normally, use arrow keys to
-reposition the cursor, press Enter to submit, and press Shift+Enter for a new
+Passing a task runs it once and exits. Running `yolocoder` with no task starts
+an interactive session instead: it prompts, works, reports what it did, then
+prompts again, all in one continuous transcript. Leave with `/exit` or Ctrl+C.
+
+At the prompt, paste multiline instructions normally, use arrow keys to
+reposition the cursor, press Enter to send, and press Shift+Enter for a new
 line (falls back to Enter-only in terminals that don't report Shift+Enter
 separately).
 
+While it works, YoloCoder prints what it is actually doing — the files it
+reads, the searches it runs, the plan, the patch, and the test result — so
+the finished session leaves a readable trail rather than a single status
+line that overwrites itself.
+
 ## Install
 
 macOS and Linux:

cmd/yolocoder/main.go

@@ -2,11 +2,14 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
 
 	"github.com/mindsdb/yolocoder/internal/app"
+	"github.com/mindsdb/yolocoder/internal/config"
+	"github.com/mindsdb/yolocoder/internal/terminal"
 	"github.com/mindsdb/yolocoder/internal/ui"
 	"github.com/mindsdb/yolocoder/internal/update"
 	"github.com/mindsdb/yolocoder/internal/version"
@@ -43,6 +46,7 @@ func main() {
 		// loaded until the next separate invocation. If it can't even
 		// start the new binary, fall through and keep running on the
 		// old one rather than aborting.
+		fmt.Println("[^_^] Updated to a new build, restarting...")
 		if err := update.Relaunch(); err != nil {
 			fmt.Fprintln(os.Stderr, "restart after update:", err)
 		}
@@ -67,36 +71,69 @@ func main() {
 		os.Exit(app.RunModel(args[1:]))
 	}
 
-	fmt.Printf("YoloCoder %s\n", version.Display())
-	workingDirectory, err := os.Getwd()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "find current folder: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Printf("Folder: %s\n", workingDirectory)
 	fromEnvironment := false
 	if len(args) > 0 && args[0] == "--llm-from-env-vars" {
 		fromEnvironment = true
 		args = args[1:]
 	}
-	task := strings.TrimSpace(strings.Join(args, " "))
-	task, provider, err := app.PrepareTask(task, fromEnvironment)
+
+	fmt.Printf("\x1b[36m[^_^] YoloCoder %s\x1b[0m  \x1b[2m%s\x1b[0m\n", version.Display(), app.Folder())
+
+	provider, err := app.Provider(fromEnvironment)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
-	var reply string
-	var runErr error
-	ui.WithRobot(os.Stdout, "Thinking...", func(status ui.RobotStatus) {
-		reply, runErr = app.RunTask(context.Background(), task, provider, status)
-	})
-	if runErr != nil {
-		fmt.Fprintln(os.Stderr, runErr)
-		os.Exit(1)
+
+	// A task on the command line is a one-shot run; without one, stay in
+	// an interactive session so follow-up tasks keep the same context on
+	// screen instead of ending after a single change.
+	if task := strings.TrimSpace(strings.Join(args, " ")); task != "" {
+		if err := runTask(task, provider); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		return
+	}
+
+	fmt.Printf("\x1b[2mEnter: send  •  Shift+Enter: new line  •  Ctrl+C or /exit: quit\x1b[0m\n\n")
+	for {
+		task, err := app.PromptTask()
+		if err != nil {
+			if errors.Is(err, terminal.ErrEditorCancelled) {
+				fmt.Println("[^_^] Bye.")
+				return
+			}
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		switch task {
+		case "":
+			continue
+		case "/exit", "/quit":
+			fmt.Println("[^_^] Bye.")
+			return
+		}
+		if err := runTask(task, provider); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+		fmt.Println()
+	}
+}
+
+// runTask runs one task, reporting progress as it goes and printing the
+// model's reply at the end.
+func runTask(task string, provider config.LLM) error {
+	session := ui.NewSession(os.Stdout)
+	session.Start("Thinking...")
+	reply, err := app.RunTask(context.Background(), task, provider, session)
+	session.Stop()
+	if err != nil {
+		return err
 	}
-	if reply != "" {
-		fmt.Printf("[*_*] %s\n", reply)
-	} else {
-		fmt.Println("[*_*] Done.")
+	if reply == "" {
+		reply = "Done."
 	}
+	fmt.Printf("[*_*] %s\n", reply)
+	return nil
 }

internal/agent/agent.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strconv"
 	"strings"
 	"time"
 
@@ -66,6 +67,14 @@ func jsonSpan(text string) string {
 	return ""
 }
 
+// Progress reports what the agent is doing. Status replaces a transient
+// activity line; Log writes a permanent line, leaving the user a readable
+// trail of the work rather than a single message that overwrites itself.
+type Progress interface {
+	Status(string)
+	Log(string)
+}
+
 type Runner struct {
 	client     *Client
 	repository *repo.Repository
@@ -78,8 +87,8 @@ func NewRunner(client *Client, repository *repo.Repository) *Runner {
 // Run routes the message first: a plain conversational message gets the
 // model's direct reply with the repository never touched, and only an
 // actual coding task goes through the map/plan/patch/test loop.
-func (runner *Runner) Run(ctx context.Context, task string, progress func(string)) (string, error) {
-	progress("Reading your message...")
+func (runner *Runner) Run(ctx context.Context, task string, progress Progress) (string, error) {
+	progress.Status("Reading your message...")
 	decision, err := runner.route(ctx, task)
 	if err != nil {
 		return "", err
@@ -88,50 +97,65 @@ func (runner *Runner) Run(ctx context.Context, task string, progress func(string
 		return decision.Reply, nil
 	}
 
+	progress.Status("Mapping the folder...")
 	repoMap, err := runner.repository.Map()
 	if err != nil {
 		return "", err
 	}
-	progress("Finding the right code...")
-	plan, contextText, err := runner.plan(ctx, task, repoMap)
+	progress.Log(fmt.Sprintf("  mapped %d files", countMapped(repoMap)))
+
+	progress.Status("Finding the right code...")
+	plan, contextText, err := runner.plan(ctx, task, repoMap, progress)
 	if err != nil {
 		return "", err
 	}
+	progress.Log("  plan: " + plan.Summary)
+	for _, path := range plan.FilesToModify {
+		progress.Log("  will edit " + path)
+	}
 	plannedContext, err := runner.readPlanFiles(plan)
 	if err != nil {
 		return "", err
 	}
 	contextText += "\nPLANNED FILES:\n" + plannedContext
-	progress("Making the change...")
-	patch, err := runner.patch(ctx, task, repoMap, plan, contextText, "")
-	if err != nil {
-		return "", err
-	}
 
 	var evidence string
+	var patch Patch
 	for attempt := 0; attempt < 3; attempt++ {
 		if attempt > 0 {
-			progress("Repairing from new evidence...")
+			progress.Status("Repairing from new evidence...")
 			contextText, err = runner.readPlanFiles(plan)
 			if err != nil {
 				return "", err
 			}
-			patch, err = runner.patch(ctx, task, repoMap, plan, contextText, evidence)
-			if err != nil {
-				return "", err
-			}
+		} else {
+			progress.Status("Writing the change...")
 		}
-		progress("Applying the patch...")
+		patch, err = runner.patch(ctx, task, repoMap, plan, contextText, evidence)
+		if err != nil {
+			return "", err
+		}
+		progress.Log("  patch: " + patch.Summary)
+
+		progress.Status("Applying the patch...")
 		if err := runner.repository.Apply(patch.Diff); err != nil {
+			progress.Log("  patch did not apply, retrying")
 			evidence = "The patch did not apply:\n" + err.Error()
 			continue
 		}
-		progress("Testing the change...")
+		progress.Log("  applied the patch")
+
+		progress.Status("Testing the change...")
 		testResult := RunTests(ctx, runner.repository.Root)
 		if testResult.Passed {
-			progress("Done.")
+			if testResult.Skipped {
+				progress.Log("  no test command detected")
+			} else {
+				progress.Log("  tests passed")
+			}
 			return patch.Summary, nil
 		}
+		progress.Log("  tests failed, retrying")
 		evidence = "The patch applied, but tests failed. Produce an incremental diff against the current repository.\n" + testResult.Output
 	}
 	return "", fmt.Errorf("could not complete the task after repair attempts:\n%s", evidence)
@@ -165,7 +189,7 @@ func (runner *Runner) route(ctx context.Context, task string) (routeDecision, er
 // response state, and one that doesn't will reject a function_call_output
 // referencing a call_id it never stored, so the transcript is tracked here
 // instead.
-func (runner *Runner) plan(ctx context.Context, task, repoMap string) (Plan, string, error) {
+func (runner *Runner) plan(ctx context.Context, task, repoMap string, progress Progress) (Plan, string, error) {
 	taskText := fmt.Sprintf("TASK:\n%s\n\nREPOSITORY MAP:\n%s", task, repoMap)
 	var transcript []any
 	var collected strings.Builder
@@ -203,6 +227,7 @@ func (runner *Runner) plan(ctx context.Context, task, repoMap string) (Plan, str
 			transcript = []any{inputMessage{Role: "user", Content: taskText}}
 		}
 		for _, call := range calls {
+			progress.Log("  " + describeCall(call))
 			output := runner.runTool(ctx, call)
 			fmt.Fprintf(&collected, "\nTOOL %s:\n%s\n", call.Name, output)
 			transcript = append(transcript, call)
@@ -242,6 +267,34 @@ func (runner *Runner) patch(ctx context.Context, task, repoMap string, plan Plan
 	return patch, nil
 }
 
+// describeCall renders a tool call as a short line for the progress log,
+// so the user can see which files the model is actually looking at.
+func describeCall(call responseItem) string {
+	var arguments toolArguments
+	if err := json.Unmarshal([]byte(call.Arguments), &arguments); err != nil {
+		return call.Name
+	}
+	switch call.Name {
+	case "read_files":
+		return "read " + strings.Join(arguments.Paths, ", ")
+	case "search":
+		return "search " + strconv.Quote(arguments.Query)
+	default:
+		return call.Name
+	}
+}
+
+// countMapped counts the files listed in a repository map.
+func countMapped(repoMap string) int {
+	count := 0
+	for _, line := range strings.Split(repoMap, "\n") {
+		if strings.TrimSpace(line) != "" {
+			count++
+		}
+	}
+	return count
+}
+
 func (runner *Runner) runTool(ctx context.Context, call responseItem) string {
 	var arguments toolArguments
 	if err := json.Unmarshal([]byte(call.Arguments), &arguments); err != nil {

internal/agent/agent_test.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/mindsdb/yolocoder/internal/repo"
@@ -103,13 +104,21 @@ func TestRunnerToolPlanPatchApply(t *testing.T) {
 
 	client := &Client{endpoint: server.URL, apiKey: "test", model: "test", http: server.Client()}
 	runner := NewRunner(client, repository)
-	reply, err := runner.Run(context.Background(), "Change old to new", func(string) {})
+	progress := &recordingProgress{}
+	reply, err := runner.Run(context.Background(), "Change old to new", progress)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if reply != "Update greeting" {
 		t.Fatalf("reply = %q", reply)
 	}
+	// The permanent log is what tells the user what actually happened.
+	trail := strings.Join(progress.logs, "\n")
+	for _, want := range []string{"read hello.txt", "plan: Update greeting", "will edit hello.txt", "applied the patch"} {
+		if !strings.Contains(trail, want) {
+			t.Fatalf("progress log missing %q:\n%s", want, trail)
+		}
+	}
 	content, err := os.ReadFile(filepath.Join(repository.Root, "hello.txt"))
 	if err != nil {
 		t.Fatal(err)
@@ -134,7 +143,7 @@ func TestRunnerRoutesNonCodingMessageWithoutTouchingRepository(t *testing.T) {
 	client := &Client{endpoint: server.URL, apiKey: "test", model: "test", http: server.Client()}
 	repository := &repo.Repository{Root: filepath.Join(t.TempDir(), "does-not-exist")}
 	runner := NewRunner(client, repository)
-	reply, err := runner.Run(context.Background(), "hi", func(string) {})
+	reply, err := runner.Run(context.Background(), "hi", &recordingProgress{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -164,3 +173,18 @@ func integrationRepository(t *testing.T) *repo.Repository {
 	}
 	return &repo.Repository{Root: root}
 }
+
+// recordingProgress captures progress output so tests can assert on the
+// trail the user would see.
+type recordingProgress struct {
+	statuses []string
+	logs     []string
+}
+
+func (progress *recordingProgress) Status(message string) {
+	progress.statuses = append(progress.statuses, message)
+}
+
+func (progress *recordingProgress) Log(message string) {
+	progress.logs = append(progress.logs, message)
+}

internal/agent/tester.go

@@ -14,13 +14,16 @@ const maxTestOutput = 128 << 10
 
 type TestResult struct {
 	Passed bool
-	Output string
+	// Skipped reports that no test command was detected, so Passed is
+	// true only because there was nothing to run.
+	Skipped bool
+	Output  string
 }
 
 func RunTests(ctx context.Context, root string) TestResult {
 	name, args := detectTestCommand(root)
 	if name == "" {
-		return TestResult{Passed: true, Output: "No supported test command detected."}
+		return TestResult{Passed: true, Skipped: true, Output: "No supported test command detected."}
 	}
 	testCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
 	defer cancel()

internal/app/app.go

@@ -16,8 +16,8 @@ import (
 const Help = `YoloCoder
 
 Usage:
-  yolocoder <task>                make and test a coding change
-  yolocoder                       prompt for a task
+  yolocoder <task>                make and test a coding change, then exit
+  yolocoder                       start an interactive session
   yolocoder --llm-from-env-vars <task>
                                   use OPENAI_* environment variables
   yolocoder config show           show the saved provider