fix: helpful error when jj commits are immutable

When GetLocalCommitStack encounters a commit without a commit-id
trailer and jj describe fails (e.g. because the commit is immutable
due to untracked remote bookmarks), spr now panics with an actionable
message: which commit is affected, why it is likely immutable, and
how to fix it (jj bookmark track).

Also adds error response support to the jj mock and injects the
commit-id generator for test determinism.

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

Author: jucor

vcs/jj_ops.go

@@ -14,14 +14,20 @@ import (
 // JjOps implements VCSOperations using jj (Jujutsu) commands.
 // Git commands are still used for push operations (via gitcmd).
 type JjOps struct {
-	cfg    *config.Config
-	jjcmd  JjInterface
-	gitcmd git.GitInterface
+	cfg         *config.Config
+	jjcmd       JjInterface
+	gitcmd      git.GitInterface
+	genCommitID func() string
 }
 
 // NewJjOps creates a jj-based VCSOperations implementation.
 func NewJjOps(cfg *config.Config, jjcmd JjInterface, gitcmd git.GitInterface) *JjOps {
-	return &JjOps{cfg: cfg, jjcmd: jjcmd, gitcmd: gitcmd}
+	return &JjOps{
+		cfg:         cfg,
+		jjcmd:       jjcmd,
+		gitcmd:      gitcmd,
+		genCommitID: func() string { return uuid.New().String()[:8] },
+	}
 }
 
 // FetchAndRebase fetches from remote and rebases using jj commands.
@@ -61,12 +67,21 @@ func (j *JjOps) GetLocalCommitStack(cfg *config.Config, gitcmd git.GitInterface)
 		// Add commit-id trailers to commits that lack them
 		for i, p := range parsed {
 			if p.sprCommitID == "" && !p.empty {
-				newID := uuid.New().String()[:8]
+				newID := j.genCommitID()
 				newDesc := strings.TrimRight(p.description, "\n")
 				newDesc += "\n\ncommit-id:" + newID
 				err := j.jjcmd.JjArgs([]string{"describe", "-r", p.changeID, "-m", newDesc}, nil)
 				if err != nil {
-					panic(fmt.Sprintf("failed to add commit-id to %s: %v", p.changeID, err))
+					panic(fmt.Sprintf(
+						"error: cannot add commit-id trailer to %s (%s) — commit is likely immutable\n\n"+
+							"This happens when an untracked remote bookmark points at this commit\n"+
+							"(or one of its descendants), making the entire chain immutable.\n\n"+
+							"To fix, track the remote bookmarks that cover this commit:\n"+
+							"  jj bookmark track <bookmark> --remote <remote>\n\n"+
+							"To find which bookmarks are involved:\n"+
+							"  jj log -r '%s::' -T 'change_id.short() ++ \" \" ++ remote_bookmarks ++ \"\\n\"'\n\n"+
+							"Underlying error: %v",
+						p.changeID, p.subject, p.changeID, err))
 				}
 				parsed[i].sprCommitID = newID
 			}

vcs/jj_ops_test.go

@@ -2,6 +2,7 @@ package vcs
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -102,6 +103,36 @@ func TestJjOpsGetLocalCommitStack_WIPCommit(t *testing.T) {
 	jjmock.ExpectationsMet()
 }
 
+func TestJjOpsGetLocalCommitStack_ImmutableCommitError(t *testing.T) {
+	cfg := makeJjTestConfig()
+	jjmock := mockjj.NewMockJj(t)
+	ops := NewJjOps(cfg, jjmock, nil)
+	ops.genCommitID = func() string { return "deadbeef" }
+
+	// Commit without commit-id trailer — triggers jj describe attempt
+	c1 := &git.Commit{
+		CommitHash: "c100000000000000000000000000000000000000",
+		ChangeID:   "jjchangeimmutable",
+		Subject:    "feat: some old commit",
+		// No CommitID
+	}
+
+	jjmock.ExpectLogAndRespond([]*git.Commit{c1})
+	jjmock.ExpectDescribeAndFail("jjchangeimmutable",
+		"feat: some old commit\n\ncommit-id:deadbeef",
+		fmt.Errorf("Error: Commit abc123 is immutable"))
+
+	defer func() {
+		r := recover()
+		require.NotNil(t, r, "expected panic for immutable commit")
+		msg := fmt.Sprintf("%v", r)
+		assert.Contains(t, msg, "jjchangeimmutable")
+		assert.Contains(t, msg, "immutable")
+		assert.Contains(t, msg, "jj bookmark track")
+	}()
+	ops.GetLocalCommitStack(cfg, nil)
+}
+
 // --- AmendInto ---
 
 func TestJjOpsAmendInto(t *testing.T) {

vcs/mockjj/mockjj.go

@@ -34,16 +34,20 @@ func (m *Mock) Jj(args string, output *string) error {
 	actual := "jj " + args
 	m.assert.Equal(expected, actual)
 
-	if m.response[0].Valid() {
+	resp := m.response[0]
+	m.expectedCmd = m.expectedCmd[1:]
+	m.response = m.response[1:]
+
+	if resp.Err() != nil {
+		return resp.Err()
+	}
+	if resp.Valid() {
 		m.assert.NotNil(output)
-		*output = m.response[0].Output()
+		*output = resp.Output()
 	} else if output != nil {
 		*output = ""
 	}
 
-	m.expectedCmd = m.expectedCmd[1:]
-	m.response = m.response[1:]
-
 	return nil
 }
 
@@ -137,18 +141,37 @@ func (m *Mock) respond(response string) {
 	}
 }
 
+func (m *Mock) respondWithError(err error) {
+	m.response[len(m.response)-1] = &errResponse{err: err}
+}
+
+// ExpectDescribeAndFail expects a jj describe command and returns an error.
+func (m *Mock) ExpectDescribeAndFail(changeID, message string, err error) {
+	m.expect(fmt.Sprintf("jj describe -r %s -m %s", changeID, message)).respondWithError(err)
+}
+
 type responder interface {
 	Valid() bool
 	Output() string
+	Err() error
 }
 
 type stringResponse struct {
 	valid  bool
 	output string
 }
 
-func (r *stringResponse) Valid() bool  { return r.valid }
+func (r *stringResponse) Valid() bool    { return r.valid }
 func (r *stringResponse) Output() string { return r.output }
+func (r *stringResponse) Err() error     { return nil }
+
+type errResponse struct {
+	err error
+}
+
+func (r *errResponse) Valid() bool    { return false }
+func (r *errResponse) Output() string { return "" }
+func (r *errResponse) Err() error     { return r.err }
 
 // formatJjLogResponse formats commits as jj log output with field/record separators.
 func formatJjLogResponse(commits []*git.Commit) string {