[fix] Thread context through the git package (#283) (#299)

* [fix] Thread context through git package; drop non-cancellable Run/RunInDir

Thread ctx context.Context (first param) through all git package functions
so SIGINT and MCP per-request deadlines cancel in-flight git subprocesses.

Remove Run/RunInDir from the Runner interface, ExecRunner, and the debug
decorator — the context.Background() shim can no longer be reintroduced.

Recovery/rollback paths (AbortRebase, MergeAbort, StashApply, StashDrop,
MoveWorktree) deliberately stay non-cancellable, each with a doc comment
explaining why: completing them is required to avoid SIGKILL-mid-restore
data loss or stranded worktrees.

Closes #283

* [chore] Rename RunContext→Run, RunInDirContext→RunInDir; fix review issues

Since the context.Background() shims are gone, the Context suffix is no
longer needed to distinguish variants. Rename to the cleaner form.

Also fix code review findings:
- Remove dead Run/RunInDir shim methods from ctxMockRunner in sync_ctx_test.go
- Add non-cancellable doc comment to stashRefBySHA (called only from StashDrop)

* [chore] Address review feedback: drop misleading ctx params, rename stale test fields

- Remove ctx from restoreStash/applyStashToWorktree (non-cancellable recovery paths
  should not accept ctx at all — matches StashApply/StashDrop/MoveWorktree pattern)
- Rename stubRunner fields runContextCalled→runCalled, runInDirCtxCalled→runInDirCalled
  in debug_test.go to match the renamed Run/RunInDir methods

* [chore] Put ctx first in runInitFresh signature (Go convention)

Author: lugassawan

cmd/add.go

@@ -56,7 +56,7 @@ main repo and is not the default branch. --source is not valid in branch: mode.`
 
 		r := newRunner()
 
-		repoRoot, err := git.MainRepoRoot(r)
+		repoRoot, err := git.MainRepoRoot(cmd.Context(), r)
 		if err != nil {
 			return err
 		}

cmd/archive.go

@@ -30,7 +30,7 @@ var archiveCmd = &cobra.Command{
 		task := args[0]
 		r := newRunner()
 
-		wt, err := findWorktree(r, task)
+		wt, err := findWorktree(cmd.Context(), r, task)
 		if err != nil {
 			return err
 		}
@@ -47,7 +47,7 @@ var archiveCmd = &cobra.Command{
 		defer s.Stop()
 
 		s.Start("Archiving worktree...")
-		result, err := operations.ArchiveWorktree(r, operations.ArchiveParams{
+		result, err := operations.ArchiveWorktree(cmd.Context(), r, operations.ArchiveParams{
 			Path:   wt.Path,
 			Branch: wt.Branch,
 			Force:  force,

cmd/clean.go

@@ -74,7 +74,7 @@ func cleanPrune(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
 	defer s.Stop()
 
 	s.Start("Pruning stale references...")
-	out, err := git.Prune(r, dryRun)
+	out, err := git.Prune(ctx, r, dryRun)
 	if err != nil {
 		return err
 	}
@@ -96,7 +96,7 @@ func cleanPrune(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
 // Skips gracefully when there are no remotes; warns and continues on per-remote failure.
 func cleanRemotePrune(ctx context.Context, cmd *cobra.Command, r git.Runner, s *spinner.Spinner, dryRun bool) error {
 	s.Start("Pruning remote-tracking refs...")
-	remotes, err := git.ListRemotes(r)
+	remotes, err := git.ListRemotes(ctx, r)
 	if err != nil {
 		s.Stop()
 		return err
@@ -133,8 +133,8 @@ type hintEntry struct {
 }
 
 // cleanResolveAndHint resolves the main branch and shows relevant flag hints.
-func cleanResolveAndHint(cmd *cobra.Command, r git.Runner, entries []hintEntry) (string, error) {
-	mainBranch, err := resolveMainBranch(r)
+func cleanResolveAndHint(ctx context.Context, cmd *cobra.Command, r git.Runner, entries []hintEntry) (string, error) {
+	mainBranch, err := resolveMainBranch(ctx, r)
 	if err != nil {
 		return "", err
 	}
@@ -207,15 +207,15 @@ func runClean(ctx context.Context, cmd *cobra.Command, r git.Runner, s cleanStra
 }
 
 func cleanMerged(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
-	mainBranch, err := cleanResolveAndHint(cmd, r, []hintEntry{
+	mainBranch, err := cleanResolveAndHint(ctx, cmd, r, []hintEntry{
 		{flagDryRun, hintDryRunClean},
 		{flagForce, hintForce},
 	})
 	if err != nil {
 		return err
 	}
 
-	remotePresent := git.RemoteExists(r, git.DefaultRemote)
+	remotePresent := git.RemoteExists(ctx, r, git.DefaultRemote)
 	var mergeRef string
 	return runClean(ctx, cmd, r, cleanStrategy{
 		label:         "merged",
@@ -229,7 +229,7 @@ func cleanMerged(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
 			return err
 		},
 		find: func(rr git.Runner) ([]operations.CleanCandidate, []string, error) {
-			result, err := operations.FindMergedCandidates(rr, mergeRef, mainBranch)
+			result, err := operations.FindMergedCandidates(ctx, rr, mergeRef, mainBranch)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -242,7 +242,7 @@ func cleanMerged(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
 }
 
 func cleanStale(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
-	mainBranch, err := cleanResolveAndHint(cmd, r, []hintEntry{
+	mainBranch, err := cleanResolveAndHint(ctx, cmd, r, []hintEntry{
 		{flagDryRun, hintDryRunClean},
 		{flagForce, hintForce},
 		{flagStaleDays, "Customize the staleness threshold (default: 14 days)"},
@@ -260,7 +260,7 @@ func cleanStale(ctx context.Context, cmd *cobra.Command, r git.Runner) error {
 		summaryFmt:    "Cleaned %d stale worktree(s).\n",
 		originPresent: false, // stale mode is local-only
 		find: func(rr git.Runner) ([]operations.CleanCandidate, []string, error) {
-			result, err := operations.FindStaleCandidates(rr, mainBranch, staleDays)
+			result, err := operations.FindStaleCandidates(ctx, rr, mainBranch, staleDays)
 			if err != nil {
 				return nil, nil, err
 			}

cmd/completions.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"sort"
 	"strings"
@@ -47,7 +48,7 @@ func init() {
 // completeWorktreeTasks returns task names for shell completion.
 func completeWorktreeTasks(_ *cobra.Command, toComplete string) []string {
 	r := newRunner()
-	entries, err := git.ListWorktrees(r)
+	entries, err := git.ListWorktrees(context.Background(), r)
 	if err != nil {
 		return nil
 	}
@@ -86,10 +87,11 @@ func completeOpenShortcuts(cmd *cobra.Command, toComplete string) []string {
 // completeArchivedTasks returns task names from archived branches (branches not in any active worktree).
 func completeArchivedTasks(_ *cobra.Command, toComplete string) []string {
 	r := newRunner()
+	ctx := context.Background()
 
-	mainBranch, _ := resolveMainBranch(r)
+	mainBranch, _ := resolveMainBranch(ctx, r)
 
-	archived, err := operations.ListArchivedBranches(r, mainBranch)
+	archived, err := operations.ListArchivedBranches(ctx, r, mainBranch)
 	if err != nil {
 		return nil
 	}
@@ -108,7 +110,7 @@ func completeArchivedTasks(_ *cobra.Command, toComplete string) []string {
 // completeBranchNames returns branch names for shell completion.
 func completeBranchNames(_ *cobra.Command, toComplete string) []string {
 	r := newRunner()
-	out, err := r.Run("branch", "--format=%(refname:short)")
+	out, err := r.Run(context.Background(), "branch", "--format=%(refname:short)")
 	if err != nil {
 		return nil
 	}

cmd/conflict_check.go

@@ -39,7 +39,7 @@ var conflictCheckCmd = &cobra.Command{
 
 		r := newRunner()
 
-		worktrees, err := listWorktreeInfos(r)
+		worktrees, err := listWorktreeInfos(cmd.Context(), r)
 		if err != nil {
 			return err
 		}
@@ -68,7 +68,7 @@ var conflictCheckCmd = &cobra.Command{
 		defer s.Stop()
 		s.Start("Collecting file changes...")
 
-		diffs, err := conflict.CollectDiffs(r, cfg.DefaultSource, eligible)
+		diffs, err := conflict.CollectDiffs(cmd.Context(), r, cfg.DefaultSource, eligible)
 		if err != nil {
 			return err
 		}
@@ -79,7 +79,7 @@ var conflictCheckCmd = &cobra.Command{
 		var dryResults []conflict.DryMergeResult
 		if dryMerge {
 			s.Update("Running dry merges...")
-			dryResults, err = conflict.DryMergeAll(r, eligible)
+			dryResults, err = conflict.DryMergeAll(cmd.Context(), r, eligible)
 			if err != nil {
 				return err
 			}

cmd/deps.go

@@ -35,7 +35,7 @@ var depsStatusCmd = &cobra.Command{
 		cfg := config.FromContext(cmd.Context())
 
 		r := newRunner()
-		worktrees, err := listWorktreeInfos(r)
+		worktrees, err := listWorktreeInfos(cmd.Context(), r)
 		if err != nil {
 			return err
 		}
@@ -141,12 +141,12 @@ var depsInstallCmd = &cobra.Command{
 
 		r := newRunner()
 
-		repoRoot, err := git.MainRepoRoot(r)
+		repoRoot, err := git.MainRepoRoot(cmd.Context(), r)
 		if err != nil {
 			return err
 		}
 
-		worktrees, err := listWorktreeInfos(r)
+		worktrees, err := listWorktreeInfos(cmd.Context(), r)
 		if err != nil {
 			return err
 		}

cmd/duplicate.go

@@ -41,13 +41,14 @@ var duplicateCmd = &cobra.Command{
 		cfg := config.FromContext(cmd.Context())
 
 		r := newRunner()
+		ctx := cmd.Context()
 
-		repoRoot, err := git.MainRepoRoot(r)
+		repoRoot, err := git.MainRepoRoot(ctx, r)
 		if err != nil {
 			return err
 		}
 
-		wt, err := findWorktree(r, task)
+		wt, err := findWorktree(ctx, r, task)
 		if err != nil {
 			return err
 		}
@@ -75,7 +76,7 @@ var duplicateCmd = &cobra.Command{
 			for i := 1; i <= maxDuplicateSuffix; i++ {
 				candidate := fmt.Sprintf("%s-%d", task, i)
 				candidateBranch := resolver.FullBranchName(svc, matchedPrefix, candidate)
-				if !git.BranchExists(r, candidateBranch) {
+				if !git.BranchExists(ctx, r, candidateBranch) {
 					newTask = candidate
 					break
 				}
@@ -90,7 +91,7 @@ var duplicateCmd = &cobra.Command{
 		wtPath := resolver.WorktreePath(wtDir, newBranch)
 
 		// Validate
-		if git.BranchExists(r, newBranch) {
+		if git.BranchExists(ctx, r, newBranch) {
 			return fmt.Errorf("branch %q already exists", newBranch)
 		}
 		if _, err := os.Stat(wtPath); err == nil {
@@ -132,7 +133,7 @@ var duplicateCmd = &cobra.Command{
 
 		// Create worktree from source branch
 		s.Start("Creating worktree...")
-		if err := git.AddWorktree(r, wtPath, newBranch, wt.Branch); err != nil {
+		if err := git.AddWorktree(ctx, r, wtPath, newBranch, wt.Branch); err != nil {
 			return err
 		}
 

cmd/exec.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -146,8 +147,9 @@ func execShowHints(cmd *cobra.Command) {
 }
 
 func execSelectWorktrees(cmd *cobra.Command, r git.Runner, s *spinner.Spinner, opts execOpts, prefixes []string) ([]resolver.WorktreeInfo, error) {
-	cfg := config.FromContext(cmd.Context())
-	worktrees, err := listWorktreeInfos(r)
+	ctx := cmd.Context()
+	cfg := config.FromContext(ctx)
+	worktrees, err := listWorktreeInfos(ctx, r)
 	if err != nil {
 		return nil, err
 	}
@@ -161,7 +163,7 @@ func execSelectWorktrees(cmd *cobra.Command, r git.Runner, s *spinner.Spinner, o
 	}
 
 	if opts.dirty {
-		filtered = filterDirtyWorktrees(cmd, r, s, filtered)
+		filtered = filterDirtyWorktrees(ctx, cmd, r, s, filtered)
 	}
 	return filtered, nil
 }
@@ -233,13 +235,13 @@ func init() {
 // filterDirtyWorktrees filters worktrees to only those with uncommitted changes.
 // If IsDirty returns an error for a worktree, it is treated as dirty (included)
 // and a warning is emitted to cmd.ErrOrStderr() so the error is visible.
-func filterDirtyWorktrees(cmd *cobra.Command, r git.Runner, s *spinner.Spinner, worktrees []resolver.WorktreeInfo) []resolver.WorktreeInfo {
+func filterDirtyWorktrees(ctx context.Context, cmd *cobra.Command, r git.Runner, s *spinner.Spinner, worktrees []resolver.WorktreeInfo) []resolver.WorktreeInfo {
 	n := len(worktrees)
 	var done atomic.Int32
 
 	results := parallel.Collect[dirtyResult](n, 8, func(i int) dirtyResult {
 		path := worktrees[i].Path
-		dirty, err := git.IsDirty(r, path)
+		dirty, err := git.IsDirty(ctx, r, path)
 		count := done.Add(1)
 		s.Update(fmt.Sprintf("Checking dirty status... (%d/%d)", count, n))
 		if err != nil {

cmd/exec_test.go

@@ -234,7 +234,7 @@ func TestFilterDirtyWorktrees(t *testing.T) {
 	s := testExecSpinner(cmd)
 	defer s.Stop()
 
-	result := filterDirtyWorktrees(cmd, r, s, worktrees)
+	result := filterDirtyWorktrees(context.Background(), cmd, r, s, worktrees)
 	if len(result) != 1 {
 		t.Fatalf("expected 1 dirty worktree, got %d", len(result))
 	}
@@ -262,7 +262,7 @@ func TestFilterDirtyWorktreesIsDirtyErrorIncludedAndWarned(t *testing.T) {
 	s := testExecSpinner(cmd)
 	defer s.Stop()
 
-	result := filterDirtyWorktrees(cmd, r, s, worktrees)
+	result := filterDirtyWorktrees(context.Background(), cmd, r, s, worktrees)
 
 	if len(result) != 1 {
 		t.Fatalf("expected erroring worktree to be included (treated as dirty), got %d", len(result))

cmd/helpers.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"io"
 
 	"github.com/lugassawan/rimba/internal/config"
@@ -44,8 +45,8 @@ func spinnerOpts(cmd *cobra.Command) spinner.Options {
 }
 
 // resolveMainBranch tries to get the main branch from config, falling back to DefaultBranch.
-func resolveMainBranch(r git.Runner) (string, error) {
-	repoRoot, err := git.MainRepoRoot(r)
+func resolveMainBranch(ctx context.Context, r git.Runner) (string, error) {
+	repoRoot, err := git.MainRepoRoot(ctx, r)
 	if err != nil {
 		return "", err
 	}
@@ -55,21 +56,21 @@ func resolveMainBranch(r git.Runner) (string, error) {
 		configDefault = cfg.DefaultSource
 	}
 
-	return operations.ResolveMainBranch(r, configDefault)
+	return operations.ResolveMainBranch(ctx, r, configDefault)
 }
 
 // listWorktreeInfos converts git worktree entries to resolver-compatible WorktreeInfo slice.
-func listWorktreeInfos(r git.Runner) ([]resolver.WorktreeInfo, error) {
-	return operations.ListWorktreeInfos(r)
+func listWorktreeInfos(ctx context.Context, r git.Runner) ([]resolver.WorktreeInfo, error) {
+	return operations.ListWorktreeInfos(ctx, r)
 }
 
 // findWorktree looks up a worktree by user input (task or service/task).
 // It resolves the input to detect monorepo service names.
-func findWorktree(r git.Runner, input string) (resolver.WorktreeInfo, error) {
-	repoRoot, err := git.MainRepoRoot(r)
+func findWorktree(ctx context.Context, r git.Runner, input string) (resolver.WorktreeInfo, error) {
+	repoRoot, err := git.MainRepoRoot(ctx, r)
 	if err != nil {
-		return operations.FindWorktree(r, "", input)
+		return operations.FindWorktree(ctx, r, "", input)
 	}
 	service, task := operations.ResolveTaskInput(input, repoRoot)
-	return operations.FindWorktree(r, service, task)
+	return operations.FindWorktree(ctx, r, service, task)
 }