feat(fork): add ccx fork command for cross-project session resume

Copy a Claude Code session to a different project directory with a
new session ID, enabling `claude --resume` from any project.

- Rewrites sessionId and cwd on all records
- Drops file-history-snapshot records (sidecar files don't exist for fork)
- Nulls out worktree-state to prevent chdir to original worktree
- Canonicalizes target path via EvalSymlinks (matches Claude Code's realpath)
- Uses Claude Code's exact sanitizePath encoding (keeps leading dash)
- 6 new tests covering rewrite, drop, null, chain preservation

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

Author: lroolle

README.md

@@ -71,6 +71,7 @@ ccx sessions --after=2026-03-01  # Date filtered
 ccx view [session]               # View in terminal
 ccx export -f html --brief       # Export conversation-only HTML
 ccx search "auth bug"            # Search across sessions + memory
+ccx fork abc123                  # Fork session to current project
 ccx doctor                       # Check setup
 ```
 

internal/cmd/fork.go

@@ -0,0 +1,191 @@
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"regexp"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+
+	"github.com/thevibeworks/ccx/internal/config"
+	"github.com/thevibeworks/ccx/internal/provider"
+)
+
+var forkCmd = &cobra.Command{
+	Use:   "fork <session-id>",
+	Short: "Fork a session to the current project for resuming",
+	Long: `Copy a session from any project into the current project directory,
+rewriting the session ID and CWD so you can resume it with 'claude --resume'.
+
+The original session is never modified. The forked copy gets a new UUID
+and points to the target directory.
+
+Examples:
+  ccx fork abc12345              # Fork to current directory
+  ccx fork abc12345 --to /path   # Fork to specific directory`,
+	Args: cobra.ExactArgs(1),
+	RunE: runFork,
+}
+
+var forkTo string
+
+func init() {
+	forkCmd.Flags().StringVar(&forkTo, "to", "", "target directory (default: current working directory)")
+	rootCmd.AddCommand(forkCmd)
+}
+
+func runFork(cmd *cobra.Command, args []string) error {
+	sessionQuery := args[0]
+	backend := provider.Default()
+
+	session, err := backend.FindSession("", sessionQuery)
+	if err != nil {
+		return fmt.Errorf("failed to search sessions: %w", err)
+	}
+	if session == nil {
+		return fmt.Errorf("session not found: %s", sessionQuery)
+	}
+
+	if session.Provider == "codex" {
+		return fmt.Errorf("fork only supports Claude Code sessions (codex uses a different format)")
+	}
+
+	targetDir := forkTo
+	if targetDir == "" {
+		targetDir, err = os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get current directory: %w", err)
+		}
+	}
+	targetDir, err = filepath.Abs(targetDir)
+	if err != nil {
+		return fmt.Errorf("invalid target directory: %w", err)
+	}
+	// Canonicalize via EvalSymlinks to match Claude Code's realpath resolution
+	if resolved, err := filepath.EvalSymlinks(targetDir); err == nil {
+		targetDir = resolved
+	}
+
+	settings := config.Load()
+	encodedTarget := claudeSanitizePath(targetDir)
+	targetProjectDir := filepath.Join(settings.ClaudeHome, "projects", encodedTarget)
+	if err := os.MkdirAll(targetProjectDir, 0755); err != nil {
+		return fmt.Errorf("failed to create target project directory: %w", err)
+	}
+
+	newSessionID := uuid.New().String()
+	targetPath := filepath.Join(targetProjectDir, newSessionID+".jsonl")
+
+	result, err := forkSession(session.FilePath, targetPath, newSessionID, targetDir)
+	if err != nil {
+		return err
+	}
+	lineCount := result.lineCount
+
+	srcID := session.ID
+	if len(srcID) > 8 {
+		srcID = srcID[:8]
+	}
+	newIDShort := newSessionID[:8]
+
+	fmt.Printf("Forked session %s -> %s (%d lines)\n", srcID, newIDShort, lineCount)
+	fmt.Printf("  Source: %s\n", session.FilePath)
+	fmt.Printf("  Target: %s\n", targetPath)
+	fmt.Println()
+	fmt.Println("Resume with:")
+	fmt.Printf("  cd %s && claude --resume %s\n", targetDir, newSessionID)
+
+	return nil
+}
+
+type forkResult struct {
+	lineCount int
+}
+
+func forkSession(srcPath, dstPath, newSessionID, targetDir string) (*forkResult, error) {
+	srcFile, err := os.Open(srcPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open source session: %w", err)
+	}
+	defer srcFile.Close()
+
+	dstFile, err := os.Create(dstPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create target session: %w", err)
+	}
+	defer dstFile.Close()
+
+	writer := bufio.NewWriter(dstFile)
+	scanner := bufio.NewScanner(srcFile)
+	scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024)
+
+	lineCount := 0
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+
+		var record map[string]any
+		if err := json.Unmarshal([]byte(line), &record); err != nil {
+			writer.WriteString(line)
+			writer.WriteByte('\n')
+			lineCount++
+			continue
+		}
+
+		recordType, _ := record["type"].(string)
+
+		if recordType == "file-history-snapshot" {
+			continue
+		}
+
+		if recordType == "worktree-state" {
+			record["worktreeSession"] = nil
+			record["worktreePath"] = nil
+		}
+
+		if _, ok := record["sessionId"]; ok {
+			record["sessionId"] = newSessionID
+		}
+		if _, ok := record["cwd"]; ok {
+			record["cwd"] = targetDir
+		}
+
+		rewritten, err := json.Marshal(record)
+		if err != nil {
+			writer.WriteString(line)
+			writer.WriteByte('\n')
+			lineCount++
+			continue
+		}
+
+		writer.Write(rewritten)
+		writer.WriteByte('\n')
+		lineCount++
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading source session: %w", err)
+	}
+	if err := writer.Flush(); err != nil {
+		return nil, fmt.Errorf("error writing target session: %w", err)
+	}
+
+	return &forkResult{lineCount: lineCount}, nil
+}
+
+var nonAlphanumeric = regexp.MustCompile(`[^a-zA-Z0-9]`)
+
+// claudeSanitizePath matches Claude Code's sanitizePath exactly:
+// replace all non-alphanumeric chars with '-', no stripping.
+// /tmp/foo → -tmp-foo (NOT tmp-foo like parser.EncodePath does)
+func claudeSanitizePath(path string) string {
+	return nonAlphanumeric.ReplaceAllString(path, "-")
+}

internal/cmd/fork_test.go

@@ -0,0 +1,181 @@
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestClaudeSanitizePath(t *testing.T) {
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"/tmp/foo", "-tmp-foo"},
+		{"/Users/eric/src/project", "-Users-eric-src-project"},
+		{"/home/user/my-project", "-home-user-my-project"},
+		{"/tmp/test fork resume", "-tmp-test-fork-resume"},
+		{"C:\\Users\\foo", "C--Users-foo"},
+	}
+	for _, tt := range tests {
+		got := claudeSanitizePath(tt.input)
+		if got != tt.want {
+			t.Errorf("claudeSanitizePath(%q) = %q, want %q", tt.input, got, tt.want)
+		}
+	}
+}
+
+func TestClaudeSanitizePathKeepsLeadingDash(t *testing.T) {
+	got := claudeSanitizePath("/tmp/foo")
+	if !strings.HasPrefix(got, "-") {
+		t.Errorf("should keep leading dash, got %q", got)
+	}
+}
+
+func TestForkRewritesSessionIDAndCWD(t *testing.T) {
+	dir := t.TempDir()
+	srcPath := filepath.Join(dir, "source.jsonl")
+	dstPath := filepath.Join(dir, "target.jsonl")
+
+	lines := []string{
+		`{"type":"user","sessionId":"old-id","cwd":"/old/path","uuid":"u1","message":{"role":"user","content":"hi"}}`,
+		`{"type":"assistant","sessionId":"old-id","cwd":"/old/path","uuid":"a1","parentUuid":"u1","message":{"role":"assistant","content":"hello"}}`,
+		`{"type":"summary","summary":"test session","leafUuid":"a1"}`,
+	}
+	if err := os.WriteFile(srcPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := forkSession(srcPath, dstPath, "new-session-id", "/new/path")
+	if err != nil {
+		t.Fatalf("forkSession() error: %v", err)
+	}
+	if result.lineCount != 3 {
+		t.Errorf("lineCount = %d, want 3", result.lineCount)
+	}
+
+	f, _ := os.Open(dstPath)
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		var record map[string]any
+		json.Unmarshal([]byte(scanner.Text()), &record)
+
+		if sid, ok := record["sessionId"].(string); ok {
+			if sid != "new-session-id" {
+				t.Errorf("sessionId = %q, want new-session-id", sid)
+			}
+		}
+		if cwd, ok := record["cwd"].(string); ok {
+			if cwd != "/new/path" {
+				t.Errorf("cwd = %q, want /new/path", cwd)
+			}
+		}
+		if record["type"] == "summary" {
+			if _, ok := record["sessionId"]; ok {
+				t.Error("summary should not have sessionId added")
+			}
+		}
+	}
+}
+
+func TestForkDropsFileHistorySnapshot(t *testing.T) {
+	dir := t.TempDir()
+	srcPath := filepath.Join(dir, "source.jsonl")
+	dstPath := filepath.Join(dir, "target.jsonl")
+
+	lines := []string{
+		`{"type":"file-history-snapshot","messageId":"m1","snapshot":{}}`,
+		`{"type":"user","sessionId":"old","cwd":"/old","uuid":"u1","message":{"role":"user","content":"hi"}}`,
+		`{"type":"file-history-snapshot","messageId":"m2","snapshot":{},"isSnapshotUpdate":true}`,
+	}
+	os.WriteFile(srcPath, []byte(strings.Join(lines, "\n")+"\n"), 0644)
+
+	result, err := forkSession(srcPath, dstPath, "new-id", "/new")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.lineCount != 1 {
+		t.Errorf("lineCount = %d, want 1 (file-history-snapshot should be dropped)", result.lineCount)
+	}
+
+	content, _ := os.ReadFile(dstPath)
+	if strings.Contains(string(content), "file-history-snapshot") {
+		t.Error("forked output should not contain file-history-snapshot records")
+	}
+}
+
+func TestForkNullsWorktreeState(t *testing.T) {
+	dir := t.TempDir()
+	srcPath := filepath.Join(dir, "source.jsonl")
+	dstPath := filepath.Join(dir, "target.jsonl")
+
+	lines := []string{
+		`{"type":"user","sessionId":"old","cwd":"/old","uuid":"u1","message":{"role":"user","content":"hi"}}`,
+		`{"type":"worktree-state","worktreeSession":{"worktreePath":"/old/worktree"},"worktreePath":"/old/worktree"}`,
+	}
+	os.WriteFile(srcPath, []byte(strings.Join(lines, "\n")+"\n"), 0644)
+
+	_, err := forkSession(srcPath, dstPath, "new-id", "/new")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	f, _ := os.Open(dstPath)
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		var record map[string]any
+		json.Unmarshal([]byte(scanner.Text()), &record)
+		if record["type"] == "worktree-state" {
+			if record["worktreeSession"] != nil {
+				t.Error("worktreeSession should be null in forked output")
+			}
+			if record["worktreePath"] != nil {
+				t.Error("worktreePath should be null in forked output")
+			}
+		}
+	}
+}
+
+func TestForkPreservesParentUUIDChain(t *testing.T) {
+	dir := t.TempDir()
+	srcPath := filepath.Join(dir, "source.jsonl")
+	dstPath := filepath.Join(dir, "target.jsonl")
+
+	lines := []string{
+		`{"type":"user","sessionId":"old","cwd":"/old","uuid":"u1","parentUuid":null,"message":{"role":"user","content":"q"}}`,
+		`{"type":"assistant","sessionId":"old","cwd":"/old","uuid":"a1","parentUuid":"u1","message":{"role":"assistant","content":"a"}}`,
+		`{"type":"user","sessionId":"old","cwd":"/old","uuid":"u2","parentUuid":"a1","message":{"role":"user","content":"q2"}}`,
+	}
+	os.WriteFile(srcPath, []byte(strings.Join(lines, "\n")+"\n"), 0644)
+
+	forkSession(srcPath, dstPath, "new-id", "/new")
+
+	f, _ := os.Open(dstPath)
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+	uuids := []string{}
+	parents := []any{}
+	for scanner.Scan() {
+		var record map[string]any
+		json.Unmarshal([]byte(scanner.Text()), &record)
+		if u, ok := record["uuid"].(string); ok {
+			uuids = append(uuids, u)
+		}
+		parents = append(parents, record["parentUuid"])
+	}
+
+	if uuids[0] != "u1" || uuids[1] != "a1" || uuids[2] != "u2" {
+		t.Errorf("message UUIDs should be preserved, got %v", uuids)
+	}
+	if parents[1] != "u1" {
+		t.Errorf("parentUuid chain broken: a1 parent = %v, want u1", parents[1])
+	}
+	if parents[2] != "a1" {
+		t.Errorf("parentUuid chain broken: u2 parent = %v, want a1", parents[2])
+	}
+}