docs: master roadmap + P2–P7 TDD migration plans to 100% parity

cmd/claude/main.go

@@ -33,6 +33,7 @@ import (
 	remotepkg "ccgo/internal/remote"
 	"ccgo/internal/session"
 	"ccgo/internal/tool"
+	"ccgo/internal/repl"
 	filetools "ccgo/internal/tools/file"
 	tasktools "ccgo/internal/tools/task"
 )
@@ -266,12 +267,40 @@ func run(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int
 		}
 		return 0
 	}
-	if _, err := state.ConversationRunner(); err != nil {
+	effectiveMode, err := effectivePermissionMode(*permissionMode, *skipPermissions)
+	if err != nil {
+		fmt.Fprintf(stderr, "ccgo: %v\n", err)
+		return 1
+	}
+	ctx := context.Background()
+	runner, err := interactiveRunner(ctx, state, cliOptions{
+		Model:           *modelName,
+		MaxTokens:       *maxTokens,
+		MaxTurns:        *maxTurns,
+		PermissionMode:  effectiveMode,
+		SkipPermissions: *skipPermissions,
+		MCPConfig:       *mcpConfig,
+		Stream:          *stream,
+		SystemPrompt:    *systemPrompt,
+		AppendSystem:    *appendSystemPrompt,
+		AllowedTools:    append([]string(nil), allowedTools...),
+		DeniedTools:     append([]string(nil), deniedTools...),
+		AddDirs:         append([]string(nil), addDirs...),
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ccgo: %v\n", err)
+		return 1
+	}
+	history, err := resumeHistory(state, &runner, cliOptions{Resume: *resume, Continue: *continueMode})
+	if err != nil {
+		fmt.Fprintf(stderr, "ccgo: %v\n", err)
+		return 1
+	}
+	term := repl.NewOSTerminal(os.Stdin, os.Stdout)
+	if err := repl.RunInteractive(ctx, term, runner, history); err != nil {
 		fmt.Fprintf(stderr, "ccgo: %v\n", err)
 		return 1
 	}
-
-	fmt.Fprintf(stdout, "ccgo scaffold ready\nsession_id=%s\ncwd=%s\n", state.SessionID(), state.CWD())
 	return 0
 }
 
@@ -3205,6 +3234,13 @@ func normalizeCLIFormatValue(raw string) string {
 	}
 }
 
+// interactiveRunner builds a fully-wired runner for the interactive REPL.
+// It delegates to headlessRunner; kept as a separate seam for future
+// interactive-only wiring (e.g., interactive default permission mode).
+func interactiveRunner(ctx context.Context, state *bootstrap.State, options cliOptions) (conversation.Runner, error) {
+	return headlessRunner(ctx, state, options)
+}
+
 func headlessRunner(ctx context.Context, state *bootstrap.State, options cliOptions) (conversation.Runner, error) {
 	runner, err := state.ConversationRunner()
 	if err != nil {

cmd/claude/main_test.go

@@ -984,25 +984,25 @@ func TestRunHelpExitsSuccessfully(t *testing.T) {
 	}
 }
 
-func TestRunCWDFlagSetsScaffoldWorkingDirectory(t *testing.T) {
+func TestRunInteractiveWithoutCredentialsFails(t *testing.T) {
 	project := t.TempDir()
-	resolvedProject, err := filepath.EvalSymlinks(project)
-	if err != nil {
-		t.Fatal(err)
-	}
 	t.Setenv("CLAUDE_CONFIG_DIR", t.TempDir())
+	// Clear every credential env var the auth path reads:
+	t.Setenv("ANTHROPIC_API_KEY", "")
+	t.Setenv("CLAUDE_CODE_OAUTH_REFRESH_TOKEN", "")
+	t.Setenv("CLAUDE_CODE_OAUTH_SCOPES", "")
 
 	var stdout, stderr bytes.Buffer
 	code := run([]string{"--cwd", project}, strings.NewReader(""), &stdout, &stderr)
-	if code != 0 {
-		t.Fatalf("exit = %d stderr=%s", code, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), "cwd="+resolvedProject) {
-		t.Fatalf("stdout = %q", stdout.String())
+	if code != 1 {
+		t.Fatalf("exit = %d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
 	}
-	if stderr.Len() != 0 {
+	if !strings.Contains(stderr.String(), "missing Anthropic credentials") {
 		t.Fatalf("stderr = %q", stderr.String())
 	}
+	if strings.Contains(stdout.String(), "scaffold ready") {
+		t.Fatalf("scaffold stub should be gone, got stdout = %q", stdout.String())
+	}
 }
 
 func TestRunPrintReadsPromptFromStdinAndSettingsModel(t *testing.T) {