docs: move tmux documentation to its own file

39 files changed, 1427 insertions, 1262 deletions

diff --git a/internal/appconfig/config.go b/internal/appconfig/config.go
index 87b5a29..2c4cee3 100644
--- a/internal/appconfig/config.go
+++ b/internal/appconfig/config.go
@@ -74,14 +74,14 @@ type App struct {
 	// Code actions
 	PromptCodeActionRewriteSystem     string `json:"-" toml:"-"`
 	PromptCodeActionDiagnosticsSystem string `json:"-" toml:"-"`
-    PromptCodeActionDocumentSystem    string `json:"-" toml:"-"`
-    PromptCodeActionRewriteUser       string `json:"-" toml:"-"`
-    PromptCodeActionDiagnosticsUser   string `json:"-" toml:"-"`
-    PromptCodeActionDocumentUser      string `json:"-" toml:"-"`
-    PromptCodeActionGoTestSystem      string `json:"-" toml:"-"`
-    PromptCodeActionGoTestUser        string `json:"-" toml:"-"`
-    PromptCodeActionSimplifySystem    string `json:"-" toml:"-"`
-    PromptCodeActionSimplifyUser      string `json:"-" toml:"-"`
+	PromptCodeActionDocumentSystem    string `json:"-" toml:"-"`
+	PromptCodeActionRewriteUser       string `json:"-" toml:"-"`
+	PromptCodeActionDiagnosticsUser   string `json:"-" toml:"-"`
+	PromptCodeActionDocumentUser      string `json:"-" toml:"-"`
+	PromptCodeActionGoTestSystem      string `json:"-" toml:"-"`
+	PromptCodeActionGoTestUser        string `json:"-" toml:"-"`
+	PromptCodeActionSimplifySystem    string `json:"-" toml:"-"`
+	PromptCodeActionSimplifyUser      string `json:"-" toml:"-"`
 	// CLI
 	PromptCLIDefaultSystem string `json:"-" toml:"-"`
 	PromptCLIExplainSystem string `json:"-" toml:"-"`
@@ -129,10 +129,10 @@ func newDefaultConfig() App {
 		PromptCodeActionRewriteUser:       "Instruction: {{instruction}}\n\nSelected code to transform:\n{{selection}}",
 		PromptCodeActionDiagnosticsUser:   "Diagnostics to resolve (selection only):\n{{diagnostics}}\n\nSelected code:\n{{selection}}",
 		PromptCodeActionDocumentUser:      "Add documentation comments to this code:\n{{selection}}",
-        PromptCodeActionGoTestSystem:      "You are a precise Go unit test generator. Given a Go function, write one or more Test* functions using the testing package. Do NOT include package or imports, only the test function(s). Prefer table-driven tests. Keep it minimal and idiomatic.",
-        PromptCodeActionGoTestUser:        "Function under test:\n{{function}}",
-        PromptCodeActionSimplifySystem:    "You are a precise code improvement engine. Simplify and improve the given code while preserving behavior. Return only the improved code with no prose or backticks.",
-        PromptCodeActionSimplifyUser:      "Improve this code:\n{{selection}}",
+		PromptCodeActionGoTestSystem:      "You are a precise Go unit test generator. Given a Go function, write one or more Test* functions using the testing package. Do NOT include package or imports, only the test function(s). Prefer table-driven tests. Keep it minimal and idiomatic.",
+		PromptCodeActionGoTestUser:        "Function under test:\n{{function}}",
+		PromptCodeActionSimplifySystem:    "You are a precise code improvement engine. Simplify and improve the given code while preserving behavior. Return only the improved code with no prose or backticks.",
+		PromptCodeActionSimplifyUser:      "Improve this code:\n{{selection}}",
 
 		PromptCLIDefaultSystem: "You are Hexai CLI. Default to very short, concise answers. If the user asks for commands, output only the commands (one per line) with no commentary or explanation. Only when the word 'explain' appears in the prompt, produce a verbose explanation.",
 		PromptCLIExplainSystem: "You are Hexai CLI. The user requested an explanation. Provide a clear, verbose explanation with reasoning and details. If commands are needed, include them with brief context.",
@@ -260,16 +260,16 @@ type sectionPromptsChat struct {
 }
 
 type sectionPromptsCodeAction struct {
-    RewriteSystem     string `toml:"rewrite_system"`
-    DiagnosticsSystem string `toml:"diagnostics_system"`
-    DocumentSystem    string `toml:"document_system"`
-    RewriteUser       string `toml:"rewrite_user"`
-    DiagnosticsUser   string `toml:"diagnostics_user"`
-    DocumentUser      string `toml:"document_user"`
-    GoTestSystem      string `toml:"go_test_system"`
-    GoTestUser        string `toml:"go_test_user"`
-    SimplifySystem    string `toml:"simplify_system"`
-    SimplifyUser      string `toml:"simplify_user"`
+	RewriteSystem     string `toml:"rewrite_system"`
+	DiagnosticsSystem string `toml:"diagnostics_system"`
+	DocumentSystem    string `toml:"document_system"`
+	RewriteUser       string `toml:"rewrite_user"`
+	DiagnosticsUser   string `toml:"diagnostics_user"`
+	DocumentUser      string `toml:"document_user"`
+	GoTestSystem      string `toml:"go_test_system"`
+	GoTestUser        string `toml:"go_test_user"`
+	SimplifySystem    string `toml:"simplify_system"`
+	SimplifyUser      string `toml:"simplify_user"`
 }
 
 type sectionPromptsCLI struct {
@@ -393,7 +393,7 @@ func (fc *fileConfig) toApp() App {
 		out.PromptChatSystem = fc.Prompts.Chat.System
 	}
 	// code action
-    if (fc.Prompts.CodeAction != sectionPromptsCodeAction{}) {
+	if (fc.Prompts.CodeAction != sectionPromptsCodeAction{}) {
 		if strings.TrimSpace(fc.Prompts.CodeAction.RewriteSystem) != "" {
 			out.PromptCodeActionRewriteSystem = fc.Prompts.CodeAction.RewriteSystem
 		}
@@ -415,16 +415,16 @@ func (fc *fileConfig) toApp() App {
 		if strings.TrimSpace(fc.Prompts.CodeAction.GoTestSystem) != "" {
 			out.PromptCodeActionGoTestSystem = fc.Prompts.CodeAction.GoTestSystem
 		}
-        if strings.TrimSpace(fc.Prompts.CodeAction.GoTestUser) != "" {
-            out.PromptCodeActionGoTestUser = fc.Prompts.CodeAction.GoTestUser
-        }
-        if strings.TrimSpace(fc.Prompts.CodeAction.SimplifySystem) != "" {
-            out.PromptCodeActionSimplifySystem = fc.Prompts.CodeAction.SimplifySystem
-        }
-        if strings.TrimSpace(fc.Prompts.CodeAction.SimplifyUser) != "" {
-            out.PromptCodeActionSimplifyUser = fc.Prompts.CodeAction.SimplifyUser
-        }
-    }
+		if strings.TrimSpace(fc.Prompts.CodeAction.GoTestUser) != "" {
+			out.PromptCodeActionGoTestUser = fc.Prompts.CodeAction.GoTestUser
+		}
+		if strings.TrimSpace(fc.Prompts.CodeAction.SimplifySystem) != "" {
+			out.PromptCodeActionSimplifySystem = fc.Prompts.CodeAction.SimplifySystem
+		}
+		if strings.TrimSpace(fc.Prompts.CodeAction.SimplifyUser) != "" {
+			out.PromptCodeActionSimplifyUser = fc.Prompts.CodeAction.SimplifyUser
+		}
+	}
 	// cli
 	if (fc.Prompts.CLI != sectionPromptsCLI{}) {
 		if strings.TrimSpace(fc.Prompts.CLI.DefaultSystem) != "" {
@@ -623,15 +623,15 @@ func (a *App) mergePrompts(other *App) {
 	if strings.TrimSpace(other.PromptCodeActionGoTestSystem) != "" {
 		a.PromptCodeActionGoTestSystem = other.PromptCodeActionGoTestSystem
 	}
-    if strings.TrimSpace(other.PromptCodeActionGoTestUser) != "" {
-        a.PromptCodeActionGoTestUser = other.PromptCodeActionGoTestUser
-    }
-    if strings.TrimSpace(other.PromptCodeActionSimplifySystem) != "" {
-        a.PromptCodeActionSimplifySystem = other.PromptCodeActionSimplifySystem
-    }
-    if strings.TrimSpace(other.PromptCodeActionSimplifyUser) != "" {
-        a.PromptCodeActionSimplifyUser = other.PromptCodeActionSimplifyUser
-    }
+	if strings.TrimSpace(other.PromptCodeActionGoTestUser) != "" {
+		a.PromptCodeActionGoTestUser = other.PromptCodeActionGoTestUser
+	}
+	if strings.TrimSpace(other.PromptCodeActionSimplifySystem) != "" {
+		a.PromptCodeActionSimplifySystem = other.PromptCodeActionSimplifySystem
+	}
+	if strings.TrimSpace(other.PromptCodeActionSimplifyUser) != "" {
+		a.PromptCodeActionSimplifyUser = other.PromptCodeActionSimplifyUser
+	}
 	// CLI
 	if strings.TrimSpace(other.PromptCLIDefaultSystem) != "" {
 		a.PromptCLIDefaultSystem = other.PromptCLIDefaultSystem
diff --git a/internal/appconfig/config_test.go b/internal/appconfig/config_test.go
index 5cb79a0..dc8c39c 100644
--- a/internal/appconfig/config_test.go
+++ b/internal/appconfig/config_test.go
@@ -25,15 +25,15 @@ func writeFile(t *testing.T, path, content string) {
 // clearHexaiEnv removes any HEXAI_* variables to prevent environment leakage
 // into tests that expect file-only configuration.
 func clearHexaiEnv(t *testing.T) {
-    t.Helper()
-    for _, e := range os.Environ() {
-        if strings.HasPrefix(e, "HEXAI_") {
-            kv := strings.SplitN(e, "=", 2)
-            if len(kv) > 0 {
-                t.Setenv(kv[0], "")
-            }
-        }
-    }
+	t.Helper()
+	for _, e := range os.Environ() {
+		if strings.HasPrefix(e, "HEXAI_") {
+			kv := strings.SplitN(e, "=", 2)
+			if len(kv) > 0 {
+				t.Setenv(kv[0], "")
+			}
+		}
+	}
 }
 
 func withEnv(t *testing.T, k, v string) {
@@ -54,10 +54,10 @@ func TestLoad_Defaults_NoLogger(t *testing.T) {
 }
 
 func TestLoad_Defaults_WithLogger_NoFile_NoEnv(t *testing.T) {
-    clearHexaiEnv(t)
-    t.Setenv("XDG_CONFIG_HOME", t.TempDir())
-    logger := newLogger()
-    cfg := Load(logger)
+	clearHexaiEnv(t)
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	logger := newLogger()
+	cfg := Load(logger)
 	def := newDefaultConfig()
 	if cfg.MaxTokens != def.MaxTokens || cfg.ContextMode != def.ContextMode || cfg.ContextWindowLines != def.ContextWindowLines {
 		t.Fatalf("expected defaults; got %+v want %+v", cfg, def)
@@ -207,9 +207,9 @@ func TestLoadFromFile_InvalidTOML(t *testing.T) {
 }
 
 func TestLoad_FileTables_Sectioned(t *testing.T) {
-    clearHexaiEnv(t)
-    dir := t.TempDir()
-    t.Setenv("XDG_CONFIG_HOME", dir)
+	clearHexaiEnv(t)
+	dir := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", dir)
 	cfgPath := filepath.Join(dir, "hexai", "config.toml")
 	content := `
 [general]
@@ -290,9 +290,9 @@ temperature = 0.0
 }
 
 func TestLoad_FileTables_Prompts_AllSections(t *testing.T) {
-    clearHexaiEnv(t)
-    dir := t.TempDir()
-    t.Setenv("XDG_CONFIG_HOME", dir)
+	clearHexaiEnv(t)
+	dir := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", dir)
 	cfgPath := filepath.Join(dir, "hexai", "config.toml")
 	content := `
 [prompts.completion]
diff --git a/internal/editor/editor.go b/internal/editor/editor.go
index 44aa1d4..a1af1be 100644
--- a/internal/editor/editor.go
+++ b/internal/editor/editor.go
@@ -1,70 +1,70 @@
 package editor
 
 import (
-    "errors"
-    "os"
-    "os/exec"
-    "path/filepath"
-    "strings"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
 )
 
 // Resolve returns the editor command from HEXAI_EDITOR or EDITOR.
 func Resolve() (string, error) {
-    ed := strings.TrimSpace(os.Getenv("HEXAI_EDITOR"))
-    if ed == "" {
-        ed = strings.TrimSpace(os.Getenv("EDITOR"))
-    }
-    if ed == "" {
-        return "", errors.New("no editor configured (set HEXAI_EDITOR or EDITOR)")
-    }
-    return ed, nil
+	ed := strings.TrimSpace(os.Getenv("HEXAI_EDITOR"))
+	if ed == "" {
+		ed = strings.TrimSpace(os.Getenv("EDITOR"))
+	}
+	if ed == "" {
+		return "", errors.New("no editor configured (set HEXAI_EDITOR or EDITOR)")
+	}
+	return ed, nil
 }
 
 // RunEditor is the seam that invokes the editor on the given file path.
 // Override in tests to avoid launching a real editor.
 var RunEditor = func(editor, path string) error {
-    cmd := exec.Command(editor, path)
-    cmd.Stdin = os.Stdin
-    cmd.Stdout = os.Stdout
-    cmd.Stderr = os.Stderr
-    return cmd.Run()
+	cmd := exec.Command(editor, path)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
 }
 
 // OpenTempAndEdit creates a temporary .md file, writes initial content if provided,
 // opens it in the resolved editor, then reads the final content and removes the file.
 // Returns the trimmed content.
 func OpenTempAndEdit(initial []byte) (string, error) {
-    ed, err := Resolve()
-    if err != nil {
-        return "", err
-    }
-    // Create temp file under system temp dir; ensure .md suffix
-    dir := os.TempDir()
-    f, err := os.CreateTemp(dir, "hexai-*.md")
-    if err != nil {
-        return "", err
-    }
-    path := f.Name()
-    defer func() { _ = os.Remove(path) }()
-    if len(initial) > 0 {
-        if _, err := f.Write(initial); err != nil {
-            _ = f.Close()
-            return "", err
-        }
-    }
-    if err := f.Sync(); err != nil {
-        _ = f.Close()
-        return "", err
-    }
-    if err := f.Close(); err != nil {
-        return "", err
-    }
-    if err := RunEditor(ed, path); err != nil {
-        return "", err
-    }
-    b, err := os.ReadFile(filepath.Clean(path))
-    if err != nil {
-        return "", err
-    }
-    return strings.TrimSpace(string(b)), nil
+	ed, err := Resolve()
+	if err != nil {
+		return "", err
+	}
+	// Create temp file under system temp dir; ensure .md suffix
+	dir := os.TempDir()
+	f, err := os.CreateTemp(dir, "hexai-*.md")
+	if err != nil {
+		return "", err
+	}
+	path := f.Name()
+	defer func() { _ = os.Remove(path) }()
+	if len(initial) > 0 {
+		if _, err := f.Write(initial); err != nil {
+			_ = f.Close()
+			return "", err
+		}
+	}
+	if err := f.Sync(); err != nil {
+		_ = f.Close()
+		return "", err
+	}
+	if err := f.Close(); err != nil {
+		return "", err
+	}
+	if err := RunEditor(ed, path); err != nil {
+		return "", err
+	}
+	b, err := os.ReadFile(filepath.Clean(path))
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(b)), nil
 }
diff --git a/internal/editor/editor_test.go b/internal/editor/editor_test.go
index df6dec7..06cc165 100644
--- a/internal/editor/editor_test.go
+++ b/internal/editor/editor_test.go
@@ -1,39 +1,44 @@
 package editor
 
 import (
-    "os"
-    "path/filepath"
-    "testing"
+	"os"
+	"path/filepath"
+	"testing"
 )
 
 func TestResolve_EnvPriority(t *testing.T) {
-    t.Setenv("HEXAI_EDITOR", "ed1")
-    t.Setenv("EDITOR", "ed2")
-    ed, err := Resolve()
-    if err != nil || ed != "ed1" {
-        t.Fatalf("Resolve failed: %v %q", err, ed)
-    }
-    t.Setenv("HEXAI_EDITOR", "")
-    ed, err = Resolve()
-    if err != nil || ed != "ed2" {
-        t.Fatalf("Resolve fallback failed: %v %q", err, ed)
-    }
+	t.Setenv("HEXAI_EDITOR", "ed1")
+	t.Setenv("EDITOR", "ed2")
+	ed, err := Resolve()
+	if err != nil || ed != "ed1" {
+		t.Fatalf("Resolve failed: %v %q", err, ed)
+	}
+	t.Setenv("HEXAI_EDITOR", "")
+	ed, err = Resolve()
+	if err != nil || ed != "ed2" {
+		t.Fatalf("Resolve fallback failed: %v %q", err, ed)
+	}
 }
 
 func TestOpenTempAndEdit_UsesRunEditor(t *testing.T) {
-    old := RunEditor
-    t.Cleanup(func(){ RunEditor = old })
-    // Ensure Resolve() succeeds
-    t.Setenv("HEXAI_EDITOR", "dummy")
-    var capturedPath string
-    RunEditor = func(editor, path string) error {
-        capturedPath = path
-        // simulate user writing content
-        return os.WriteFile(path, []byte("Hello\nWorld\n"), 0o600)
-    }
-    out, err := OpenTempAndEdit([]byte("# Start\n\n"))
-    if err != nil { t.Fatalf("OpenTempAndEdit: %v", err) }
-    if out != "Hello\nWorld" { t.Fatalf("unexpected content: %q", out) }
-    if filepath.Ext(capturedPath) != ".md" { t.Fatalf("expected .md suffix: %s", capturedPath) }
+	old := RunEditor
+	t.Cleanup(func() { RunEditor = old })
+	// Ensure Resolve() succeeds
+	t.Setenv("HEXAI_EDITOR", "dummy")
+	var capturedPath string
+	RunEditor = func(editor, path string) error {
+		capturedPath = path
+		// simulate user writing content
+		return os.WriteFile(path, []byte("Hello\nWorld\n"), 0o600)
+	}
+	out, err := OpenTempAndEdit([]byte("# Start\n\n"))
+	if err != nil {
+		t.Fatalf("OpenTempAndEdit: %v", err)
+	}
+	if out != "Hello\nWorld" {
+		t.Fatalf("unexpected content: %q", out)
+	}
+	if filepath.Ext(capturedPath) != ".md" {
+		t.Fatalf("expected .md suffix: %s", capturedPath)
+	}
 }
-
diff --git a/internal/hexaiaction/cmdentry.go b/internal/hexaiaction/cmdentry.go
index cf72495..ca33443 100644
--- a/internal/hexaiaction/cmdentry.go
+++ b/internal/hexaiaction/cmdentry.go
@@ -1,149 +1,183 @@
 package hexaiaction
 
 import (
-    "context"
-    "fmt"
-    "io"
-    "os"
-    "path/filepath"
-    "time"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
 
-    "codeberg.org/snonux/hexai/internal/tmux"
-    "golang.org/x/term"
+	"codeberg.org/snonux/hexai/internal/tmux"
+	"golang.org/x/term"
 )
 
 // Options configures the command-line orchestration for hexai-tmux-action.
 type Options struct {
-    Infile       string
-    Outfile      string
-    UIChild      bool
-    TmuxTarget   string
-    TmuxSplit    string // "v" or "h"
-    TmuxPercent  int    // 1-100
+	Infile      string
+	Outfile     string
+	UIChild     bool
+	TmuxTarget  string
+	TmuxSplit   string // "v" or "h"
+	TmuxPercent int    // 1-100
 }
 
 // RunCommand is the CLI orchestrator used by cmd/hexai-tmux-action. It runs in tmux
 // split-pane mode by default, or child mode when -ui-child is set.
 func RunCommand(ctx context.Context, opts Options, stdin io.Reader, stdout, stderr io.Writer) error {
-    if opts.UIChild {
-        return runChild(ctx, opts.Infile, opts.Outfile, stdout, stderr)
-    }
-    // Always use tmux path
-    return runInTmuxParent(stdin, stdout, opts.TmuxTarget, opts.TmuxSplit, opts.TmuxPercent)
+	if opts.UIChild {
+		return runChild(ctx, opts.Infile, opts.Outfile, stdout, stderr)
+	}
+	// Always use tmux path
+	return runInTmuxParent(stdin, stdout, opts.TmuxTarget, opts.TmuxSplit, opts.TmuxPercent)
 }
 
 // seams for unit tests
-var isTTYFn = func(fd uintptr) bool { return term.IsTerminal(int(fd)) }
-var splitRunFn = tmux.SplitRun
-var osExecutableFn = os.Executable
-var runFn = Run
+var (
+	isTTYFn        = func(fd uintptr) bool { return term.IsTerminal(int(fd)) }
+	splitRunFn     = tmux.SplitRun
+	osExecutableFn = os.Executable
+	runFn          = Run
+)
 
 // openIO returns readers/writers for infile/outfile flags with deferred closers.
 func openIO(infile, outfile string) (io.Reader, io.Writer, func(), func(), error) {
-    in := io.Reader(os.Stdin)
-    out := io.Writer(os.Stdout)
-    closeIn := func() {}
-    closeOut := func() {}
-    if path := infile; path != "" {
-        f, err := os.Open(path)
-        if err != nil { return nil, nil, func(){}, func(){}, fmt.Errorf("hexai-tmux-action: cannot open infile: %w", err) }
-        in = f
-        closeIn = func() { _ = f.Close() }
-    }
-    if path := outfile; path != "" {
-        f, err := os.Create(path)
-        if err != nil { return nil, nil, func(){}, func(){}, fmt.Errorf("hexai-tmux-action: cannot open outfile: %w", err) }
-        out = f
-        closeOut = func() { _ = f.Close() }
-    }
-    return in, out, closeIn, closeOut, nil
+	in := io.Reader(os.Stdin)
+	out := io.Writer(os.Stdout)
+	closeIn := func() {}
+	closeOut := func() {}
+	if path := infile; path != "" {
+		f, err := os.Open(path)
+		if err != nil {
+			return nil, nil, func() {}, func() {}, fmt.Errorf("hexai-tmux-action: cannot open infile: %w", err)
+		}
+		in = f
+		closeIn = func() { _ = f.Close() }
+	}
+	if path := outfile; path != "" {
+		f, err := os.Create(path)
+		if err != nil {
+			return nil, nil, func() {}, func() {}, fmt.Errorf("hexai-tmux-action: cannot open outfile: %w", err)
+		}
+		out = f
+		closeOut = func() { _ = f.Close() }
+	}
+	return in, out, closeIn, closeOut, nil
 }
 
 // runChild runs the interactive flow and writes the final output atomically when outfile is set.
 func runChild(ctx context.Context, infile, outfile string, stdout, stderr io.Writer) error {
-    if outfile == "" {
-        // No atomic handoff needed; just run normally to provided stdout
-        var in io.Reader = os.Stdin
-        if infile != "" {
-            f, err := os.Open(infile)
-            if err != nil { return err }
-            defer func(){ _ = f.Close() }()
-            in = f
-        }
-        return runFn(ctx, in, stdout, stderr)
-    }
-    tmp := outfile + ".tmp"
-    in, out, closeIn, closeOut, err := openIO(infile, tmp)
-    if err != nil { return err }
-    defer closeIn()
-    if err := runFn(ctx, in, out, stderr); err != nil {
-        closeOut()
-        if copyErr := echoThrough(infile, tmp, os.Stdin, stdout); copyErr != nil {
-            return fmt.Errorf("hexai-tmux-action child: %v; echo failed: %v", err, copyErr)
-        }
-    } else {
-        closeOut()
-    }
-    return os.Rename(tmp, outfile)
+	if outfile == "" {
+		// No atomic handoff needed; just run normally to provided stdout
+		var in io.Reader = os.Stdin
+		if infile != "" {
+			f, err := os.Open(infile)
+			if err != nil {
+				return err
+			}
+			defer func() { _ = f.Close() }()
+			in = f
+		}
+		return runFn(ctx, in, stdout, stderr)
+	}
+	tmp := outfile + ".tmp"
+	in, out, closeIn, closeOut, err := openIO(infile, tmp)
+	if err != nil {
+		return err
+	}
+	defer closeIn()
+	if err := runFn(ctx, in, out, stderr); err != nil {
+		closeOut()
+		if copyErr := echoThrough(infile, tmp, os.Stdin, stdout); copyErr != nil {
+			return fmt.Errorf("hexai-tmux-action child: %v; echo failed: %v", err, copyErr)
+		}
+	} else {
+		closeOut()
+	}
+	return os.Rename(tmp, outfile)
 }
 
 func runInTmuxParent(stdin io.Reader, stdout io.Writer, target, split string, percent int) error {
-    dir, err := os.MkdirTemp("", "hexai-tmux-action-")
-    if err != nil { return err }
-    defer func() { _ = os.RemoveAll(dir) }()
-    inPath := filepath.Join(dir, "input.txt")
-    outPath := filepath.Join(dir, "reply.txt")
-    if err := persistStdin(inPath, stdin); err != nil { return err }
-    exe, err := osExecutableFn()
-    if err != nil { return err }
-    argv := []string{exe, "-ui-child", "-infile", inPath, "-outfile", outPath}
-    opts := tmux.SplitOpts{Target: target, Vertical: split != "h", Percent: percent}
-    if err := splitRunFn(opts, argv); err != nil { return err }
-    if err := waitForFile(outPath, 60*time.Second); err != nil { return err }
-    return catFileTo(stdout, outPath)
+	dir, err := os.MkdirTemp("", "hexai-tmux-action-")
+	if err != nil {
+		return err
+	}
+	defer func() { _ = os.RemoveAll(dir) }()
+	inPath := filepath.Join(dir, "input.txt")
+	outPath := filepath.Join(dir, "reply.txt")
+	if err := persistStdin(inPath, stdin); err != nil {
+		return err
+	}
+	exe, err := osExecutableFn()
+	if err != nil {
+		return err
+	}
+	argv := []string{exe, "-ui-child", "-infile", inPath, "-outfile", outPath}
+	opts := tmux.SplitOpts{Target: target, Vertical: split != "h", Percent: percent}
+	if err := splitRunFn(opts, argv); err != nil {
+		return err
+	}
+	if err := waitForFile(outPath, 60*time.Second); err != nil {
+		return err
+	}
+	return catFileTo(stdout, outPath)
 }
 
 func persistStdin(path string, stdin io.Reader) error {
-    f, err := os.Create(path)
-    if err != nil { return err }
-    defer func() { _ = f.Close() }()
-    if _, err := io.Copy(f, stdin); err != nil { return err }
-    return f.Sync()
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = f.Close() }()
+	if _, err := io.Copy(f, stdin); err != nil {
+		return err
+	}
+	return f.Sync()
 }
 
 func waitForFile(path string, timeout time.Duration) error {
-    deadline := time.Now().Add(timeout)
-    for {
-        if _, err := os.Stat(path); err == nil { return nil }
-        if time.Now().After(deadline) { return fmt.Errorf("hexai-tmux-action: timeout waiting for reply file") }
-        time.Sleep(200 * time.Millisecond)
-    }
+	deadline := time.Now().Add(timeout)
+	for {
+		if _, err := os.Stat(path); err == nil {
+			return nil
+		}
+		if time.Now().After(deadline) {
+			return fmt.Errorf("hexai-tmux-action: timeout waiting for reply file")
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
 }
 
 func catFileTo(w io.Writer, path string) error {
-    f, err := os.Open(path)
-    if err != nil { return err }
-    defer func() { _ = f.Close() }()
-    _, err = io.Copy(w, f)
-    return err
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = f.Close() }()
+	_, err = io.Copy(w, f)
+	return err
 }
 
 // echoThrough no longer used in tmux-only flow, but kept for potential reuse.
 func echoThrough(infile, outfile string, stdin io.Reader, stdout io.Writer) error {
-    var in io.Reader = stdin
-    var out io.Writer = stdout
-    if infile != "" {
-        f, err := os.Open(infile)
-        if err != nil { return err }
-        defer func() { _ = f.Close() }()
-        in = f
-    }
-    if outfile != "" {
-        f, err := os.Create(outfile)
-        if err != nil { return err }
-        defer func() { _ = f.Close() }()
-        out = f
-    }
-    _, err := io.Copy(out, in)
-    return err
+	var in io.Reader = stdin
+	var out io.Writer = stdout
+	if infile != "" {
+		f, err := os.Open(infile)
+		if err != nil {
+			return err
+		}
+		defer func() { _ = f.Close() }()
+		in = f
+	}
+	if outfile != "" {
+		f, err := os.Create(outfile)
+		if err != nil {
+			return err
+		}
+		defer func() { _ = f.Close() }()
+		out = f
+	}
+	_, err := io.Copy(out, in)
+	return err
 }
diff --git a/internal/hexaiaction/cmdentry_runcommand_test.go b/internal/hexaiaction/cmdentry_runcommand_test.go
index 092e43b..b139bb3 100644
--- a/internal/hexaiaction/cmdentry_runcommand_test.go
+++ b/internal/hexaiaction/cmdentry_runcommand_test.go
@@ -1,53 +1,60 @@
 package hexaiaction
 
 import (
-    "bytes"
-    "context"
-    "io"
-    "os"
-    "path/filepath"
-    "testing"
+	"bytes"
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
 
-    "codeberg.org/snonux/hexai/internal/tmux"
+	"codeberg.org/snonux/hexai/internal/tmux"
 )
 
 func TestRunCommand_UIChild(t *testing.T) {