Adding multi root support for multiple git root

.changeset/legal-shirts-drop.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added checkpoints warning when users start a multiroot task

.changeset/slick-seas-love.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added markdown support to focus chain text, allowing the model to display more interesting focus chains

.github/workflows/test.yml

@@ -103,38 +103,53 @@ jobs:
 
             # Build the extension and tests (without redundant checks)
             - name: Build Tests and Extension
-              id: build_step
               run: npm run ci:build
 
             - name: Unit Tests with coverage - Linux
               id: unit_tests_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+              continue-on-error: true
+              if: runner.os == 'Linux'
               run: |
                   npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
 
             - name: Unit Tests - Non-Linux
               id: unit_tests_non_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              continue-on-error: true
+              if: runner.os != 'Linux'
               run: |
                   npm run test:unit
 
             - name: Extension Integration Tests - Linux
               id: integration_tests_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+              continue-on-error: true
+              if: runner.os == 'Linux'
               run: xvfb-run -a npm run test:coverage
 
             - name: Extension Integration Tests - Non-Linux
               id: integration_tests_non_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              continue-on-error: true
+              if: runner.os != 'Linux'
               run: npm run test:integration
 
             - name: Webview Tests with Coverage
               id: webview_tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              continue-on-error: true
               run: |
                   cd webview-ui
                   npm run test:coverage
 
+            - name: Check Test Results
+              if: always()
+              run: |
+                  failed=""
+                  [[ "${{ steps.unit_tests_linux.outcome }}" == "failure" && "${{ runner.os }}" == "Linux" ]] && failed="$failed unit_tests_linux"
+                  [[ "${{ steps.unit_tests_non_linux.outcome }}" == "failure" && "${{ runner.os }}" != "Linux" ]] && failed="$failed unit_tests_non_linux"
+                  [[ "${{ steps.integration_tests_linux.outcome }}" == "failure" && "${{ runner.os }}" == "Linux" ]] && failed="$failed integration_tests_linux"
+                  [[ "${{ steps.integration_tests_non_linux.outcome }}" == "failure" && "${{ runner.os }}" != "Linux" ]] && failed="$failed integration_tests_non_linux"
+                  [[ "${{ steps.webview_tests.outcome }}" == "failure" ]] && failed="$failed webview_tests"
+                  [[ -n "$failed" ]] && { echo "❌ The following test suites failed:$failed"; exit 1; }
+                  echo "✅ All tests passed"
+
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
               # Only upload artifacts on Linux - We only need coverage from one OS

.gitignore

@@ -34,3 +34,6 @@ webview-ui/src/services/grpc-client.ts
 
 # E2E Tests
 test-results
+
+## CLI pre-release  ##
+/cli 

CHANGELOG.md

@@ -1,11 +1,5 @@
 # Changelog
 
-## [3.32.6]
-
-- Add experimental support for VSCode multi root workspaces
-- Add Claude Sonnet 4.5 to Claude Code provider
-- Add Glm 4.6 to Z AI provider 
-
 ## [3.32.5]
 
 - Improve thinking budget slider UI to take up less space

cli/.gitignore

@@ -1,2 +0,0 @@
-cline-core-debug.log
-bin/*

cli/cline-text-logo.txt

@@ -1,6 +0,0 @@
-/_____/\ /_/\      /_______/\/__/\ /__/\ /_____/\     
-\:::__\/ \:\ \     \__.::._\/\::\_\\  \ \\::::_\/_    
- \:\ \  __\:\ \       \::\ \  \:. `-\  \ \\:\/___/\   
-  \:\ \/_/\\:\ \____  _\::\ \__\:. _    \ \\::___\/_  
-   \:\_\ \ \\:\/___/\/__\::\__/\\. \`-\  \ \\:\____/\ 
-    \_____\/ \_____\/\________\/ \__\/ \__\/ \_____\/ 

cli/cmd/cline-host/main.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/spf13/cobra"
-
-	"github.com/cline/cli/pkg/hostbridge"
-)
-
-var (
-	port    int
-	verbose bool
-)
-
-func main() {
-	rootCmd := &cobra.Command{
-		Use:   "cline-host",
-		Short: "Cline Host Bridge Service",
-		Long:  `A simple host bridge service that provides host operations for Cline Core.`,
-		RunE:  runServer,
-	}
-
-	rootCmd.Flags().IntVarP(&port, "port", "p", 51052, "port to listen on")
-	rootCmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "verbose logging")
-
-	if err := rootCmd.Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func runServer(cmd *cobra.Command, args []string) error {
-	ctx := cmd.Context()
-
-	// Create gRPC hostbridge service
-	service := hostbridge.NewGrpcServer(port, verbose)
-
-	// Handle graceful shutdown
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	go func() {
-		sigChan := make(chan os.Signal, 1)
-		signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-		<-sigChan
-
-		if verbose {
-			log.Println("Shutting down hostbridge server...")
-		}
-
-		cancel()
-	}()
-
-	// Start server
-	if verbose {
-		log.Printf("Starting Cline Host Bridge on port %d", port)
-	}
-
-	// Run the service
-	if err := service.Start(ctx); err != nil {
-		return fmt.Errorf("failed to run service: %w", err)
-	}
-
-	return nil
-}

cli/cmd/cline/main.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/cline/cli/pkg/cli"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/common"
-	"github.com/spf13/cobra"
-)
-
-var (
-	coreAddress  string
-	cfgFile      string
-	verbose      bool
-	outputFormat string
-)
-
-func main() {
-	rootCmd := &cobra.Command{
-		Use:   "cline",
-		Short: "Cline CLI - AI-powered coding assistant",
-		Long: `A command-line interface for interacting with Cline AI coding assistant.
-
-This CLI provides access to Cline's task management, configuration, and
-monitoring capabilities from the terminal.`,
-		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			if outputFormat != "rich" && outputFormat != "json" && outputFormat != "plain" {
-				return fmt.Errorf("invalid output format '%s': must be one of 'rich', 'json', or 'plain'", outputFormat)
-			}
-
-			return global.InitializeGlobalConfig(&global.GlobalConfig{
-				ConfigPath:   cfgFile,
-				Verbose:      verbose,
-				OutputFormat: outputFormat,
-				CoreAddress:  coreAddress,
-			})
-		},
-	}
-
-	rootCmd.PersistentFlags().StringVar(&coreAddress, "address", fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT), "Cline Core gRPC address")
-	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cline/config.yaml)")
-	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose output")
-	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "rich", "output format (rich|json|plain)")
-
-	rootCmd.AddCommand(cli.NewTaskCommand())
-	rootCmd.AddCommand(cli.NewInstanceCommand())
-	rootCmd.AddCommand(cli.NewVersionCommand())
-	rootCmd.AddCommand(cli.NewAuthCommand())
-
-	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}

cli/e2e/default_update_test.go

@@ -1,154 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-
-	"github.com/cline/cli/pkg/common"
-)
-
-// 2. Multi-instance start: default_instance remains the first started.
-func TestMultiInstanceDefaultUnchanged(t *testing.T) {
-	_ = setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start first instance and wait healthy
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out1 := listInstancesJSON(ctx, t)
-	if len(out1.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out1.CoreInstances))
-	}
-	firstAddr := out1.CoreInstances[0].Address
-	waitForAddressHealthy(t, firstAddr, defaultTimeout)
-
-	// Start second instance
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out2 := listInstancesJSON(ctx, t)
-	if len(out2.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out2.CoreInstances))
-	}
-
-	// Default should remain the first started address
-	if out2.DefaultInstance != firstAddr {
-		t.Fatalf("default changed; expected %s, got %s", firstAddr, out2.DefaultInstance)
-	}
-}
-
-// 6. Default.json update after removal of current default
-func TestDefaultJsonUpdateAfterRemoval(t *testing.T) {
-	_ = setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start two instances
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out.CoreInstances))
-	}
-
-	// Choose second as new default
-	target := out.CoreInstances[1]
-	waitForAddressHealthy(t, target.Address, defaultTimeout)
-
-	// Set as default
-	_ = mustRunCLI(ctx, t, "instance", "use", target.Address)
-
-	// Verify default switched
-	out = listInstancesJSON(ctx, t)
-	if out.DefaultInstance != target.Address {
-		t.Fatalf("default_instance not updated to %s (got %s)", target.Address, out.DefaultInstance)
-	}
-
-	// Kill the default instance using runtime PID discovery
-	corePID := getCorePID(t, target.Address)
-	if corePID <= 0 {
-		t.Fatalf("could not find PID for core process at %s", target.Address)
-	}
-	t.Logf("Killing cline-core process PID %d for instance %s", corePID, target.Address)
-	if err := syscall.Kill(corePID, syscall.SIGKILL); err != nil {
-		t.Fatalf("kill pid %d: %v", corePID, err)
-	}
-
-	// Wait for removal
-	waitForAddressRemoved(t, target.Address, longTimeout)
-
-	// Clean up dangling host process (SIGKILL leaves these behind by design)
-	t.Logf("Cleaning up dangling host process on port %d", target.HostPort())
-	findAndKillHostProcess(t, target.HostPort())
-
-	// Ensure default_instance updated to another available instance (or removed if none remain)
-	out = listInstancesJSON(ctx, t)
-
-	// If there are instances left, default_instance must be one of them
-	if len(out.CoreInstances) > 0 {
-		found := false
-		for _, it := range out.CoreInstances {
-			if out.DefaultInstance == it.Address {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Fatalf("default_instance %s not set to an existing instance after removal", out.DefaultInstance)
-		}
-	} else {
-		// No instances remain; cli-default-instance.json should be removed
-		clineDir := getClineDir(t)
-		defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-		if _, err := os.Stat(defPath); err == nil {
-			t.Fatalf("expected cli-default-instance.json removed when no instances remain")
-		}
-	}
-
-	// Also verify cli-default-instance.json on disk reflects the in-memory default (if any)
-	clineDir := getClineDir(t)
-	defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-	if len(out.CoreInstances) > 0 {
-		raw, err := os.ReadFile(defPath)
-		if err != nil {
-			t.Fatalf("read cli-default-instance.json: %v", err)
-		}
-		var tmp struct {
-			DefaultInstance string `json:"default_instance"`
-		}
-		if err := json.Unmarshal(raw, &tmp); err != nil {
-			t.Fatalf("unmarshal cli-default-instance.json: %v", err)
-		}
-		if tmp.DefaultInstance != out.DefaultInstance {
-			t.Fatalf("cli-default-instance.json mismatch: file=%s list=%s", tmp.DefaultInstance, out.DefaultInstance)
-		}
-	}
-}
-
-// 11. SQLite database missing (edge): list succeeds and returns empty set
-func TestRegistryDirMissingEdge(t *testing.T) {
-	clineDir := setTempClineDir(t)
-
-	// Remove the settings directory entirely (which contains locks.db)
-	settingsDir := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER)
-	if err := os.RemoveAll(settingsDir); err != nil {
-		t.Fatalf("RemoveAll(%s): %v", common.SETTINGS_SUBFOLDER, err)
-	}
-
-	// Listing should succeed and return empty results
-	ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
-	defer cancel()
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) != 0 {
-		t.Fatalf("expected 0 instances after removing %s dir, got %d", common.SETTINGS_SUBFOLDER, len(out.CoreInstances))
-	}
-
-	// Ensure cli-default-instance.json not present
-	defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-	if _, err := os.Stat(defPath); err == nil {
-		t.Fatalf("expected no cli-default-instance.json after removing %s dir", common.SETTINGS_SUBFOLDER)
-	}
-}

cli/e2e/helpers_test.go

@@ -1,378 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/cline"
-)
-
-const (
-	defaultTimeout  = 30 * time.Second
-	longTimeout     = 60 * time.Second
-	pollInterval    = 250 * time.Millisecond
-	instancesBinRel = "../bin/cline"
-)
-
-func repoAwareBinPath(t *testing.T) string {
-	// Tests live in repoRoot/cli/e2e. Binary is at repoRoot/cli/bin/cline
-	t.Helper()
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("Getwd error: %v", err)
-	}
-	// cli/e2e -> cli/bin/cline
-	p := filepath.Clean(filepath.Join(wd, instancesBinRel))
-	if _, err := os.Stat(p); err != nil {
-		t.Fatalf("CLI binary not found at %s; run `npm run compile-cli` first: %v", p, err)
-	}
-	return p
-}
-
-func setTempClineDir(t *testing.T) string {
-	t.Helper()
-	dir := t.TempDir()
-	clineDir := filepath.Join(dir, ".cline")
-	if err := os.MkdirAll(clineDir, 0o755); err != nil {
-		t.Fatalf("mkdir clineDir: %v", err)
-	}
-	t.Setenv("CLINE_DIR", clineDir)
-	return clineDir
-}
-
-func runCLI(ctx context.Context, t *testing.T, args ...string) (string, string, int) {
-	t.Helper()
-	bin := repoAwareBinPath(t)
-
-	// Ensure CLI uses the same CLINE_DIR as the tests by passing --config=<CLINE_DIR>
-	// (InitializeGlobalConfig uses ConfigPath as the base directory for registry.)
-	if clineDir := os.Getenv("CLINE_DIR"); clineDir != "" && !contains(args, "--config") {
-		// Prepend persistent flag so Cobra sees it regardless of subcommand position
-		args = append([]string{"--config", clineDir}, args...)
-	}
-
-	cmd := exec.CommandContext(ctx, bin, args...)
-	// Run CLI from repo root so relative paths inside CLI (./cli/bin/...) resolve
-	if wd, err := os.Getwd(); err == nil {
-		repoRoot := filepath.Clean(filepath.Join(wd, "..", ".."))
-		cmd.Dir = repoRoot
-	}
-	// propagate env including CLINE_DIR
-	cmd.Env = os.Environ()
-	outB, errB := &strings.Builder{}, &strings.Builder{}
-	cmd.Stdout = outB
-	cmd.Stderr = errB
-	err := cmd.Run()
-	exit := 0
-	if err != nil {
-		// Extract exit code if possible
-		if ee, ok := err.(*exec.ExitError); ok {
-			exit = ee.ExitCode()
-		} else {
-			exit = -1
-		}
-	}
-	return outB.String(), errB.String(), exit
-}
-
-func mustRunCLI(ctx context.Context, t *testing.T, args ...string) string {
-	t.Helper()
-	out, errOut, exit := runCLI(ctx, t, args...)
-	if exit != 0 {
-		t.Fatalf("cline %v failed (exit=%d)\nstdout:\n%s\nstderr:\n%s", args, exit, out, errOut)
-	}
-	return out
-}
-
-func listInstancesJSON(ctx context.Context, t *testing.T) common.InstancesOutput {
-	t.Helper()
-	// Trigger CLI to perform cleanup/health by invoking list (table output is ignored)
-	_ = mustRunCLI(ctx, t, "instance", "list")
-
-	// Read from SQLite locks database to build structured output
-	clineDir := getClineDir(t)
-
-	// Load default instance from settings file
-	defaultInstance := readDefaultInstanceFromSettings(t, clineDir)
-
-	// Load instances from SQLite
-	instances := readInstancesFromSQLite(t, clineDir)
-
-	return common.InstancesOutput{
-		DefaultInstance: defaultInstance,
-		CoreInstances:   instances,
-	}
-}
-
-func hasAddress(in common.InstancesOutput, addr string) bool {
-	for _, it := range in.CoreInstances {
-		if it.Address == addr {
-			return true
-		}
-	}
-	return false
-}
-
-func getByAddress(in common.InstancesOutput, addr string) (common.CoreInstanceInfo, bool) {
-	for _, it := range in.CoreInstances {
-		if it.Address == addr {
-			return it, true
-		}
-	}
-	return common.CoreInstanceInfo{}, false
-}
-
-func waitFor(t *testing.T, timeout time.Duration, cond func() (bool, string)) {
-	t.Helper()
-	deadline := time.Now().Add(timeout)
-	for {
-		ok, msg := cond()
-		if ok {
-			return
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("waitFor timeout: %s", msg)
-		}
-		time.Sleep(pollInterval)
-	}
-}
-
-func waitForAddressHealthy(t *testing.T, addr string, timeout time.Duration) {
-	t.Helper()
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	t.Logf("Waiting for gRPC health check on %s...", addr)
-
-	waitFor(t, timeout, func() (bool, string) {
-		if common.IsInstanceHealthy(ctx, addr) {
-			return true, ""
-		}
-		return false, fmt.Sprintf("gRPC health check failed for %s", addr)
-	})
-
-	t.Logf("gRPC health check passed for %s", addr)
-}
-
-func waitForAddressRemoved(t *testing.T, addr string, timeout time.Duration) {
-	t.Helper()
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	waitFor(t, timeout, func() (bool, string) {
-		out := listInstancesJSON(ctx, t)
-		if hasAddress(out, addr) {
-			return false, fmt.Sprintf("address %s still present", addr)
-		}
-		return true, ""
-	})
-}
-
-func findFreePort(t *testing.T) int {
-	t.Helper()
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("listen 127.0.0.1:0: %v", err)
-	}
-	defer l.Close()
-	_, portStr, _ := net.SplitHostPort(l.Addr().String())
-	var port int
-	fmt.Sscanf(portStr, "%d", &port)
-	return port
-}
-
-func getClineDir(t *testing.T) string {
-	t.Helper()
-	clineDir := os.Getenv("CLINE_DIR")
-	if clineDir == "" {
-		t.Fatalf("CLINE_DIR not set")
-	}
-	return clineDir
-}
-
-// isPortInUse checks if a port is currently in use by any process
-func isPortInUse(port int) bool {
-	conn, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-	if err != nil {
-		return true // Port is in use
-	}
-	conn.Close()
-	return false // Port is free
-}
-
-// waitForPortClosed waits for a port to become free (no process listening)
-func waitForPortClosed(t *testing.T, port int, timeout time.Duration) {
-	t.Helper()
-	waitFor(t, timeout, func() (bool, string) {
-		if isPortInUse(port) {
-			return false, fmt.Sprintf("port %d still in use", port)
-		}
-		return true, ""
-	})
-}
-
-// waitForPortsClosed waits for both core and host ports to become free
-func waitForPortsClosed(t *testing.T, corePort, hostPort int, timeout time.Duration) {
-	t.Helper()
-	waitFor(t, timeout, func() (bool, string) {
-		if isPortInUse(corePort) {
-			return false, fmt.Sprintf("core port %d still in use", corePort)
-		}
-		if isPortInUse(hostPort) {
-			return false, fmt.Sprintf("host port %d still in use", hostPort)
-		}
-		return true, ""
-	})
-}
-
-// findAndKillHostProcess finds and kills any process listening on the host port
-// This is used to clean up dangling host processes after SIGKILL tests
-func findAndKillHostProcess(t *testing.T, hostPort int) {
-	t.Helper()
-	// Use lsof to find process listening on the host port
-	cmd := exec.Command("lsof", "-ti", fmt.Sprintf(":%d", hostPort))
-	output, err := cmd.Output()
-	if err != nil {
-		// No process found on port - that's fine
-		return
-	}
-
-	pidStr := strings.TrimSpace(string(output))
-	if pidStr == "" {
-		return
-	}
-
-	var pid int
-	if _, err := fmt.Sscanf(pidStr, "%d", &pid); err != nil {
-		t.Logf("Warning: could not parse PID from lsof output: %s", pidStr)
-		return
-	}
-
-	if pid > 0 {
-		t.Logf("Cleaning up dangling host process PID %d on port %d", pid, hostPort)
-		if err := syscall.Kill(pid, syscall.SIGKILL); err != nil {
-			t.Logf("Warning: failed to kill dangling host process %d: %v", pid, err)
-		}
-	}
-}
-
-// getPIDByPort returns the PID of the process listening on the specified port (fallback method)
-func getPIDByPort(t *testing.T, port int) int {
-	t.Helper()
-	cmd := exec.Command("lsof", "-ti", fmt.Sprintf(":%d", port))
-	output, err := cmd.Output()
-	if err != nil {
-		return 0 // Process not found
-	}
-
-	pidStr := strings.TrimSpace(string(output))
-	if pidStr == "" {
-		return 0
-	}
-
-	pid, err := strconv.Atoi(pidStr)
-	if err != nil {
-		t.Logf("Warning: could not parse PID from lsof output: %s", pidStr)
-		return 0
-	}
-
-	return pid
-}
-
-// getCorePIDViaRPC returns the PID of the cline-core process using RPC (preferred method)
-func getCorePIDViaRPC(t *testing.T, address string) int {
-	t.Helper()
-
-	// Initialize global config to access registry
-	clineDir := os.Getenv("CLINE_DIR")
-	if clineDir == "" {
-		t.Logf("Warning: CLINE_DIR not set, falling back to lsof")
-		return getCorePIDViaLsof(t, address)
-	}
-
-	cfg := &global.GlobalConfig{
-		ConfigPath: clineDir,
-	}
-
-	if err := global.InitializeGlobalConfig(cfg); err != nil {
-		t.Logf("Warning: failed to initialize global config, falling back to lsof: %v", err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	// Get client for the address
-	client, err := global.Clients.GetRegistry().GetClient(ctx, address)
-	if err != nil {
-		t.Logf("Warning: failed to get client for %s, falling back to lsof: %v", address, err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	// Call GetProcessInfo RPC
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		t.Logf("Warning: GetProcessInfo RPC failed for %s, falling back to lsof: %v", address, err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	return int(processInfo.ProcessId)
-}
-
-// getCorePIDViaLsof returns the PID using lsof (fallback method)
-func getCorePIDViaLsof(t *testing.T, address string) int {
-	t.Helper()
-	_, portStr, err := net.SplitHostPort(address)
-	if err != nil {
-		t.Logf("Warning: invalid address format %s", address)
-		return 0
-	}
-
-	port, err := strconv.Atoi(portStr)
-	if err != nil {
-		t.Logf("Warning: invalid port in address %s", address)
-		return 0
-	}
-
-	return getPIDByPort(t, port)
-}
-
-// getCorePID returns the PID of the cline-core process for the given address
-// Uses RPC first, falls back to lsof if RPC fails
-func getCorePID(t *testing.T, address string) int {
-	t.Helper()
-
-	// Try RPC first (preferred method)
-	if pid := getCorePIDViaRPC(t, address); pid > 0 {
-		return pid
-	}
-
-	// Fall back to lsof if RPC fails
-	return getCorePIDViaLsof(t, address)
-}
-
-// getHostPID returns the PID of the cline-host process for the given host port
-func getHostPID(t *testing.T, hostPort int) int {
-	t.Helper()
-	return getPIDByPort(t, hostPort)
-}
-
-// contains reports whether slice has the target string.
-func contains(slice []string, target string) bool {
-	for _, s := range slice {
-		if s == target {
-			return true
-		}
-	}
-	return false
-}

cli/e2e/main_test.go

@@ -1,47 +0,0 @@
-package e2e
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// TestMain validates required artifacts exist before running E2E tests.
-// It does NOT build artifacts. Build manually via:
-//
-//	npm run compile-standalone
-//	npm run compile-cli
-func TestMain(m *testing.M) {
-	// Determine repo root from cli/e2e
-	wd, err := os.Getwd()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "getwd: %v\n", err)
-		os.Exit(2)
-	}
-	repoRoot := filepath.Clean(filepath.Join(wd, "..", ".."))
-
-	cliBin := filepath.Join(repoRoot, "cli", "bin", "cline")
-	coreJS := filepath.Join(repoRoot, "dist-standalone", "cline-core.js")
-
-	missing := []string{}
-	if _, err := os.Stat(cliBin); err != nil {
-		missing = append(missing, cliBin)
-	}
-	if _, err := os.Stat(coreJS); err != nil {
-		missing = append(missing, coreJS)
-	}
-
-	if len(missing) > 0 {
-		if testing.Short() {
-			// Optional quality-of-life: allow skipping with -short when artifacts are absent
-			fmt.Fprintf(os.Stderr, "[e2e] skipping (-short) due to missing artifacts:\n  %s\n", strings.Join(missing, "\n  "))
-			os.Exit(0)
-		}
-		fmt.Fprintf(os.Stderr, "Missing required build artifacts for E2E tests:\n  %s\n\nPlease build them first:\n  npm run compile-standalone\n  npm run compile-cli\n", strings.Join(missing, "\n  "))
-		os.Exit(2)
-	}
-
-	os.Exit(m.Run())
-}

cli/e2e/mixed_stress_test.go

@@ -1,120 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-
-	"github.com/cline/cli/pkg/common"
-)
-
-// 9. Mixed localhost vs 127.0.0.1 addresses coexist and are both healthy
-func TestMixedLocalhostVs127Coexist(t *testing.T) {
-	clineDir := setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start one instance
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	// Get the running instance and its port/PID
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) == 0 {
-		t.Fatalf("expected at least 1 instance")
-	}
-	inst := out.CoreInstances[0]
-	waitForAddressHealthy(t, inst.Address, defaultTimeout)
-
-	// Manually add a SQLite entry for the same port but 127.0.0.1 host
-	addr127 := fmt.Sprintf("127.0.0.1:%d", inst.CorePort())
-	dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-
-	if err := insertRemoteInstanceIntoSQLite(t, dbPath, addr127, inst.CorePort(), inst.HostPort()); err != nil {
-		t.Fatalf("insert 127 alias entry: %v", err)
-	}
-
-	// Verify both addresses appear and are healthy
-	waitForAddressHealthy(t, inst.Address, defaultTimeout)
-	waitForAddressHealthy(t, addr127, defaultTimeout)
-
-	out = listInstancesJSON(ctx, t)
-	if !hasAddress(out, inst.Address) || !hasAddress(out, addr127) {
-		t.Fatalf("expected both %s and %s present", inst.Address, addr127)
-	}
-}
-
-// 10. Start-stop stress: loop starting then killing instances; ensure no leftovers
-func TestStartStopStress(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	for i := 0; i < 3; i++ { // keep small for CI time
-		ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-		defer cancel()
-
-		// Snapshot current addresses
-		before := listInstancesJSON(ctx, t)
-		beforeSet := map[string]struct{}{}
-		for _, it := range before.CoreInstances {
-			beforeSet[it.Address] = struct{}{}
-		}
-
-		// Start a new instance
-		_ = mustRunCLI(ctx, t, "instance", "new")
-
-		// Find the new instance address
-		var newAddr string
-		waitFor(t, defaultTimeout, func() (bool, string) {
-			after := listInstancesJSON(ctx, t)
-			for _, it := range after.CoreInstances {
-				if _, ok := beforeSet[it.Address]; !ok {
-					newAddr = it.Address
-					return true, ""
-				}
-			}
-			return false, "new instance address not detected yet"
-		})
-
-		// Wait healthy
-		waitForAddressHealthy(t, newAddr, defaultTimeout)
-
-		// Get PID using runtime discovery and kill it
-		after := listInstancesJSON(ctx, t)
-		info, ok := getByAddress(after, newAddr)
-		if !ok {
-			t.Fatalf("new instance %s missing", newAddr)
-		}
-
-		// Get PID using runtime discovery
-		corePID := getCorePID(t, info.Address)
-		if corePID <= 0 {
-			t.Fatalf("could not find PID for new instance at %s", info.Address)
-		}
-
-		t.Logf("Killing new instance %s (PID %d) for iteration %d", info.Address, corePID, i)
-		if err := syscall.Kill(corePID, syscall.SIGKILL); err != nil {
-			t.Fatalf("kill pid %d: %v", corePID, err)
-		}
-
-		// Wait removed from SQLite database
-		waitForAddressRemoved(t, newAddr, longTimeout)
-
-		// Verify instance is removed from SQLite database
-		clineDir := os.Getenv("CLINE_DIR")
-		if clineDir != "" {
-			dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-			if verifyInstanceExistsInSQLite(t, dbPath, newAddr) {
-				t.Fatalf("expected instance removed from SQLite database: %s", newAddr)
-			}
-		}
-
-		// Clean up dangling host process (SIGKILL leaves these behind by design)
-		t.Logf("Cleaning up dangling host process on port %d for iteration %d", info.HostPort(), i)
-		findAndKillHostProcess(t, info.HostPort())
-
-		// Verify both ports are now free
-		waitForPortsClosed(t, info.CorePort(), info.HostPort(), defaultTimeout)
-	}
-}

cli/e2e/sqlite_helper.go

@@ -1,161 +0,0 @@
-package e2e
-
-import (
-	"database/sql"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/cline/cli/pkg/common"
-	_ "github.com/mattn/go-sqlite3"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// readInstancesFromSQLite reads instances directly from the SQLite database for testing
-func readInstancesFromSQLite(t *testing.T, clineDir string) []common.CoreInstanceInfo {
-	t.Helper()
-
-	dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-
-	// Check if database exists
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		return []common.CoreInstanceInfo{}
-	}
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		t.Logf("Warning: Failed to open SQLite database: %v", err)
-		return []common.CoreInstanceInfo{}
-	}
-	defer db.Close()
-
-	// Query instance locks
-	query := common.SelectInstanceLockHoldersAscSQL
-
-	rows, err := db.Query(query)
-	if err != nil {
-		t.Logf("Warning: Failed to query instance locks: %v", err)
-		return []common.CoreInstanceInfo{}
-	}
-	defer rows.Close()
-
-	var instances []common.CoreInstanceInfo
-	for rows.Next() {
-		var heldBy, lockTarget string
-		var lockedAt int64
-
-		err := rows.Scan(&heldBy, &lockTarget, &lockedAt)
-		if err != nil {
-			t.Logf("Warning: Failed to scan lock row: %v", err)
-			continue
-		}
-
-		// Create InstanceInfo
-		info := common.CoreInstanceInfo{
-			Address:            heldBy,
-			HostServiceAddress: lockTarget,
-			Status:             grpc_health_v1.HealthCheckResponse_UNKNOWN, // Will be updated by health check
-			LastSeen:           time.Unix(lockedAt/1000, 0),                // Convert from milliseconds
-		}
-
-		instances = append(instances, info)
-	}
-
-	return instances
-}
-
-// readDefaultInstanceFromSettings reads the default instance from the settings file
-func readDefaultInstanceFromSettings(t *testing.T, clineDir string) string {
-	t.Helper()
-
-	settingsPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-
-	data, err := os.ReadFile(settingsPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return ""
-		}
-		t.Logf("Warning: Failed to read default instance file: %v", err)
-		return ""
-	}
-
-	var tmp struct {
-		DefaultInstance string `json:"default_instance"`
-	}
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		t.Logf("Warning: Failed to parse default instance file: %v", err)
-		return ""
-	}
-
-	return tmp.DefaultInstance
-}
-
-// insertRemoteInstanceIntoSQLite inserts a remote instance entry directly into SQLite for testing
-func insertRemoteInstanceIntoSQLite(t *testing.T, dbPath, address string, corePort, hostPort int) error {
-	t.Helper()
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	// Initialize database schema for testing
-	createTableSQL := `
-		CREATE TABLE IF NOT EXISTS locks (
-			id INTEGER PRIMARY KEY,
-			held_by TEXT NOT NULL,
-			lock_type TEXT NOT NULL CHECK (lock_type IN ('file', 'instance', 'folder')),
-			lock_target TEXT NOT NULL,
-			locked_at INTEGER NOT NULL,
-			UNIQUE(lock_type, lock_target)
-		);
-	`
-	createIndexesSQL := `
-		CREATE INDEX IF NOT EXISTS idx_locks_held_by ON locks(held_by);
-		CREATE INDEX IF NOT EXISTS idx_locks_type ON locks(lock_type);
-		CREATE INDEX IF NOT EXISTS idx_locks_target ON locks(lock_target);
-	`
-
-	if _, err := db.Exec(createTableSQL); err != nil {
-		return err
-	}
-	if _, err := db.Exec(createIndexesSQL); err != nil {
-		return err
-	}
-
-	// Insert the remote instance
-	hostAddress := "remote.example.com:0"
-	if hostPort != 0 {
-		hostAddress = "remote.example.com:" + strconv.Itoa(hostPort)
-	}
-
-	insertSQL := `INSERT INTO locks (held_by, lock_type, lock_target, locked_at) VALUES (?, 'instance', ?, ?)`
-	_, err = db.Exec(insertSQL, address, hostAddress, time.Now().Unix()*1000)
-	return err
-}
-
-// verifyInstanceExistsInSQLite checks if an instance exists in the SQLite database
-func verifyInstanceExistsInSQLite(t *testing.T, dbPath, address string) bool {
-	t.Helper()
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		t.Logf("Failed to open database: %v", err)
-		return false
-	}
-	defer db.Close()
-
-	query := `SELECT COUNT(*) FROM locks WHERE held_by = ? AND lock_type = 'instance'`
-	var count int
-	err = db.QueryRow(query, address).Scan(&count)
-	if err != nil {
-		t.Logf("Failed to query database: %v", err)
-		return false
-	}
-
-	return count > 0
-}

cli/e2e/start_list_test.go

@@ -1,178 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"syscall"
-	"testing"
-)
-
-// TestStartAndList verifies self-registration and default.json semantics in a fresh CLINE_DIR.
-func TestStartAndList(t *testing.T) {
-	clineDir := setTempClineDir(t)
-	t.Logf("Using temp CLINE_DIR: %s", clineDir)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	t.Logf("Starting new instance...")
-	// Start a new instance
-	startOutput := mustRunCLI(ctx, t, "instance", "new")
-	t.Logf("Instance start output: %s", startOutput)
-
-	t.Logf("Listing instances to check registration...")
-	// It should appear healthy in list JSON and be the default.
-	out := listInstancesJSON(ctx, t)
-	t.Logf("Found %d instances after start", len(out.CoreInstances))
-
-	if len(out.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out.CoreInstances))
-	}
-
-	addr := out.CoreInstances[0].Address
-	t.Logf("Instance address: %s, status: %s", addr, out.CoreInstances[0].Status)
-
-	t.Logf("Waiting for address %s to become healthy...", addr)
-	waitForAddressHealthy(t, addr, defaultTimeout)
-	t.Logf("Address %s is now healthy", addr)
-
-	t.Logf("Checking default instance configuration...")
-	// Default should be set to the new instance.
-	out = listInstancesJSON(ctx, t)
-	t.Logf("Default instance: %s", out.DefaultInstance)
-
-	if out.DefaultInstance == "" {
-		t.Fatalf("default_instance not set")
-	}
-	if out.DefaultInstance != out.CoreInstances[0].Address {
-		t.Fatalf("expected default_instance=%s, got %s", out.CoreInstances[0].Address, out.DefaultInstance)
-	}
-
-	t.Logf("TestStartAndList completed successfully")
-}
-
-// TestTaskNewDefault ensures tasks route to default instance.
-func TestTaskNewDefault(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start one instance and wait for healthy
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out.CoreInstances))
-	}
-	addr := out.CoreInstances[0].Address
-	waitForAddressHealthy(t, addr, defaultTimeout)
-
-	// Create a new task at default (success is sufficient)
-	_ = mustRunCLI(ctx, t, "task", "new", "hello world")
-}
-
-// TestExplicitAddressAutoStart verifies that giving an explicit address auto-starts an instance and routes the task.
-func TestExplicitAddressAutoStart(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Find a free port and use explicit address. This should auto-start an instance.
-	port := findFreePort(t)
-	addr := "localhost:" + itoa(port)
-
-	// Run a task at explicit address (auto-start path)
-	_ = mustRunCLI(ctx, t, "task", "new", "--address", "localhost:"+itoa(port), "explicit address task")
-
-	// Verify the instance is present and healthy
-	waitForAddressHealthy(t, addr, defaultTimeout)
-}
-
-// TestCrashCleanup verifies that after SIGKILL of a local core, the cleanup removes the registry entry.
-// Also tests graceful shutdown (SIGTERM) vs crash cleanup and ensures no dangling host processes.
-func TestCrashCleanup(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start two instances for testing both graceful and crash scenarios
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out.CoreInstances))
-	}
-
-	// Test 1: Graceful shutdown (SIGTERM) - should clean up both processes
-	gracefulTarget := out.CoreInstances[0]
-	waitForAddressHealthy(t, gracefulTarget.Address, defaultTimeout)
-
-	// Get PID using runtime discovery
-	gracefulPID := getCorePID(t, gracefulTarget.Address)
-	if gracefulPID <= 0 {
-		t.Fatalf("could not find PID for graceful target at %s", gracefulTarget.Address)
-	}
-
-	t.Logf("Testing graceful shutdown (SIGTERM) for instance %s (PID %d)", gracefulTarget.Address, gracefulPID)
-	if err := syscall.Kill(gracefulPID, syscall.SIGTERM); err != nil {
-		t.Fatalf("kill SIGTERM pid %d: %v", gracefulPID, err)
-	}
-
-	// Wait for registry cleanup
-	waitForAddressRemoved(t, gracefulTarget.Address, longTimeout)
-
-	// Verify both core and host ports are freed (no dangling processes)
-	waitForPortsClosed(t, gracefulTarget.CorePort(), gracefulTarget.HostPort(), defaultTimeout)
-
-	// Verify the instance is removed from SQLite (no file to check anymore)
-	// The waitForAddressRemoved already confirms the instance is gone from the registry
-
-	// Test 2: Crash cleanup (SIGKILL) - creates dangling host process that we must clean up
-	crashTarget := out.CoreInstances[1]
-	waitForAddressHealthy(t, crashTarget.Address, defaultTimeout)
-
-	// Get PID using runtime discovery
-	crashPID := getCorePID(t, crashTarget.Address)
-	if crashPID <= 0 {
-		t.Fatalf("could not find PID for crash target at %s", crashTarget.Address)
-	}
-
-	t.Logf("Testing crash cleanup (SIGKILL) for instance %s (PID %d)", crashTarget.Address, crashPID)
-	if err := syscall.Kill(crashPID, syscall.SIGKILL); err != nil {
-		t.Fatalf("kill SIGKILL pid %d: %v", crashPID, err)
-	}
-
-	// Wait for registry cleanup
-	waitForAddressRemoved(t, crashTarget.Address, longTimeout)
-
-	// Verify the instance is removed from SQLite (no file to check anymore)
-	// The waitForAddressRemoved already confirms the instance is gone from the registry
-
-	// Clean up dangling host process (SIGKILL leaves these behind by design)
-	t.Logf("Cleaning up dangling host process %s", crashTarget.HostServiceAddress)
-	findAndKillHostProcess(t, crashTarget.HostPort())
-
-	// Verify both ports are now free
-	waitForPortsClosed(t, crashTarget.CorePort(), crashTarget.HostPort(), defaultTimeout)
-}
-
-// itoa is a small helper for readability
-func itoa(i int) string {
-	return strconvItoa(i)
-}
-
-// minimal inline int->string to avoid extra imports in helpers
-func strconvItoa(i int) string {
-	// simple fast path
-	return fmtInt(i)
-}
-
-func fmtInt(i int) string {
-	// allocate small buffer; ints here are short
-	return (func(n int) string {
-		return fmt.Sprintf("%d", n)
-	})(i)
-}

cli/go.mod

@@ -1,22 +0,0 @@
-module github.com/cline/cli
-
-go 1.23.0
-
-require (
-	github.com/cline/grpc-go v0.0.0
-	github.com/mattn/go-sqlite3 v1.14.24
-	github.com/spf13/cobra v1.8.0
-	google.golang.org/grpc v1.75.0
-)
-
-replace github.com/cline/grpc-go => ../src/generated/grpc-go
-
-require (
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
-	golang.org/x/net v0.41.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.26.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 // indirect
-	google.golang.org/protobuf v1.36.6 // indirect
-)

cli/go.sum

@@ -1,48 +0,0 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
-github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
-github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
-github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
-go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
-gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
-gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 h1:pFyd6EwwL2TqFf8emdthzeX+gZE1ElRq3iM8pui4KBY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
-google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
-google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cli/pkg/cli/auth.go

@@ -1,125 +0,0 @@
-package cli
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/grpc-go/cline"
-	"github.com/spf13/cobra"
-)
-
-var isSessionAuthenticated bool
-
-func NewAuthCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:   "auth",
-		Short: "Sign in to Cline",
-		Long:  `Complete the authentication flow in browser to sign in to Cline.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return handleAuthCommand(cmd.Context())
-		},
-	}
-}
-
-func handleAuthCommand(ctx context.Context) error {
-	fmt.Print("Authenticating with Cline...\n")
-	if IsAuthenticated(ctx) {
-		return signOutDialog(ctx)
-	}
-
-	if err := signIn(ctx); err != nil {
-		return err
-	}
-	
-	fmt.Println("You are signed in!")
-	return nil
-}
-
-func signOut(ctx context.Context) error {
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return err
-	}
-
-	if _, err = client.Account.AccountLogoutClicked(ctx, &cline.EmptyRequest{}); err != nil {
-		return err
-	}
-
-	isSessionAuthenticated = false
-	fmt.Println("You have been signed out of Cline.")
-	return nil
-}
-
-func signOutDialog(ctx context.Context) error {
-	fmt.Print("You are already signed in to Cline.\nWould you like to sign out? (y/N): ")
-
-	scanner := bufio.NewScanner(os.Stdin)
-	if !scanner.Scan() {
-		return nil
-	}
-
-	response := strings.ToLower(strings.TrimSpace(scanner.Text()))
-	if response == "y" || response == "yes" {
-		if err := signOut(ctx); err != nil {
-			fmt.Printf("Failed to sign out: %v\n", err)
-			return err
-		}
-	}
-	return nil
-}
-
-func signIn(ctx context.Context) error {
-	if IsAuthenticated(ctx) {
-		return nil
-	}
-
-	verboseLog("Ensuring default instance exists...")
-	if err := ensureDefaultInstance(ctx); err != nil {
-		verboseLog("Failed to ensure default instance: %v", err)
-		return err
-	}
-
-	verboseLog("Default instance ensured successfully.")
-	time.Sleep(2 * time.Second) // Allow services to start
-
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		verboseLog("Failed to obtain client: %v", err)
-		return err
-	}
-
-	_, err = client.Account.AccountLoginClicked(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		verboseLog("Failed to login: %v", err)
-		return err
-	}
-
-	isSessionAuthenticated = true
-	verboseLog("Login successful")
-	return nil
-}
-
-func IsAuthenticated(ctx context.Context) bool {
-	if isSessionAuthenticated {
-		return true
-	}
-
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return false
-	}
-
-	_, err = client.Account.GetUserCredits(ctx, &cline.EmptyRequest{})
-	return err == nil
-}
-
-func verboseLog(format string, args ...interface{}) {
-	if global.Config != nil && global.Config.Verbose {
-		fmt.Printf("[VERBOSE] "+format+"\n", args...)
-	}
-}

cli/pkg/cli/display/deduplicator.go

@@ -1,95 +0,0 @@
-package display
-
-import (
-	"crypto/md5"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// MessageDeduplicator handles message deduplication to prevent duplicate displays
-type MessageDeduplicator struct {
-	mu            sync.RWMutex
-	seenMessages  map[string]time.Time
-	maxAge        time.Duration
-	cleanupTicker *time.Ticker
-}
-
-// NewMessageDeduplicator creates a new message deduplicator
-func NewMessageDeduplicator() *MessageDeduplicator {
-	d := &MessageDeduplicator{
-		seenMessages:  make(map[string]time.Time),
-		maxAge:        5 * time.Minute,                 // Keep messages for 5 minutes
-		cleanupTicker: time.NewTicker(1 * time.Minute), // Cleanup every minute
-	}
-
-	// Start cleanup goroutine
-	go d.cleanup()
-
-	return d
-}
-
-// IsDuplicate checks if a message is a duplicate
-func (d *MessageDeduplicator) IsDuplicate(msg *types.ClineMessage) bool {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	// Create a hash of the message content
-	hash := d.hashMessage(msg)
-
-	// Check if we've seen this message recently
-	if lastSeen, exists := d.seenMessages[hash]; exists {
-		// If we've seen it within the last few seconds, it's a duplicate
-		if time.Since(lastSeen) < 2*time.Second {
-			return true
-		}
-	}
-
-	// Mark this message as seen
-	d.seenMessages[hash] = time.Now()
-	return false
-}
-
-// hashMessage creates a hash of the message for deduplication
-func (d *MessageDeduplicator) hashMessage(msg *types.ClineMessage) string {
-	// Create a hash based on message content, type, and timestamp
-	content := fmt.Sprintf("%s|%s|%s|%d",
-		string(msg.Type),
-		msg.Say,
-		msg.Ask,
-		msg.Timestamp)
-
-	// For partial messages, include the text content in the hash
-	if msg.Partial {
-		content += "|" + msg.Text
-	}
-
-	hash := md5.Sum([]byte(content))
-	return fmt.Sprintf("%x", hash)
-}
-
-// cleanup removes old entries from the seen messages map
-func (d *MessageDeduplicator) cleanup() {
-	for range d.cleanupTicker.C {
-		d.mu.Lock()
-		now := time.Now()
-
-		// Remove entries older than maxAge
-		for hash, timestamp := range d.seenMessages {
-			if now.Sub(timestamp) > d.maxAge {
-				delete(d.seenMessages, hash)
-			}
-		}
-
-		d.mu.Unlock()
-	}
-}
-
-// Stop stops the cleanup goroutine
-func (d *MessageDeduplicator) Stop() {
-	if d.cleanupTicker != nil {
-		d.cleanupTicker.Stop()
-	}
-}

cli/pkg/cli/display/renderer.go

@@ -1,176 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/types"
-	"github.com/cline/grpc-go/cline"
-)
-
-type Renderer struct {
-	typewriter *TypewriterPrinter
-}
-
-func NewRenderer() *Renderer {
-	return &Renderer{
-		typewriter: NewTypewriterPrinter(DefaultTypewriterConfig()),
-	}
-}
-
-// RenderMessage renders a message with timestamp and prefix
-func (r *Renderer) RenderMessage(timestamp, prefix, text string) error {
-	if text == "" {
-		return nil
-	}
-
-	cleanText := r.sanitizeText(text)
-	if cleanText == "" {
-		return nil
-	}
-
-	r.typewriter.PrintMessageLine(timestamp, prefix, cleanText)
-	return nil
-}
-
-// RenderCommand renders a command execution
-func (r *Renderer) RenderCommand(timestamp, command string, isExecuting bool) error {
-	if isExecuting {
-		r.typewriter.PrintMessageLine(timestamp, "EXEC", command)
-	} else {
-		r.typewriter.PrintMessageLine(timestamp, "CMD", command)
-	}
-	return nil
-}
-
-// formatNumber formats numbers with k/m abbreviations
-func formatNumber(n int) string {
-	if n >= 1000000 {
-		return fmt.Sprintf("%.1fm", float64(n)/1000000.0)
-	} else if n >= 1000 {
-		return fmt.Sprintf("%.1fk", float64(n)/1000.0)
-	}
-	return fmt.Sprintf("%d", n)
-}
-
-// formatUsageInfo formats token usage information (extracted from RenderAPI)
-func (r *Renderer) formatUsageInfo(tokensIn, tokensOut, cacheReads, cacheWrites int, cost float64) string {
-	tokenDetails := fmt.Sprintf("[tokens in: %s, out: %s; cache read: %s, write: %s]",
-		formatNumber(tokensIn),
-		formatNumber(tokensOut),
-		formatNumber(cacheReads),
-		formatNumber(cacheWrites))
-
-	return fmt.Sprintf("%s ($%.4f)", tokenDetails, cost)
-}
-
-// RenderAPI renders API request information
-func (r *Renderer) RenderAPI(timestamp, status string, apiInfo *types.APIRequestInfo) error {
-	if apiInfo.Cost >= 0 {
-		message := fmt.Sprintf("%s %s", status, r.formatUsageInfo(apiInfo.TokensIn, apiInfo.TokensOut, apiInfo.CacheReads, apiInfo.CacheWrites, apiInfo.Cost))
-		r.typewriter.PrintMessageLine(timestamp, "API INFO", message)
-	} else {
-		r.typewriter.PrintMessageLine(timestamp, "API INFO", status)
-	}
-	return nil
-}
-
-// RenderRetry renders retry information
-func (r *Renderer) RenderRetry(timestamp string, attempt, maxAttempts, delaySec int) error {
-	message := fmt.Sprintf("Retrying failed attempt %d/%d", attempt, maxAttempts)
-	if delaySec > 0 {
-		message += fmt.Sprintf(" in %d seconds", delaySec)
-	}
-	message += "..."
-	r.typewriter.PrintMessageLine(timestamp, "API INFO", message)
-	return nil
-}
-
-// RenderTaskList displays task history with improved formatting
-func (r *Renderer) RenderTaskList(tasks []*cline.TaskItem) error {
-	const maxTasks = 20
-
-	startIndex := 0
-	if len(tasks) > maxTasks {
-		startIndex = len(tasks) - maxTasks
-	}
-
-	recentTasks := tasks[startIndex:]
-
-	r.typewriter.PrintfLn("=== Task History (showing last %d of %d total tasks) ===\n", len(recentTasks), len(tasks))
-
-	for i, task := range recentTasks {
-		r.typewriter.PrintfLn("Task ID: %s", task.Id)
-
-		description := task.Task
-		if len(description) > 1000 {
-			description = description[:1000] + "..."
-		}
-		r.typewriter.PrintfLn("Message: %s", description)
-
-		usageInfo := r.formatUsageInfo(int(task.TokensIn), int(task.TokensOut), int(task.CacheReads), int(task.CacheWrites), task.TotalCost)
-		r.typewriter.PrintfLn("Usage  : %s", usageInfo)
-
-		// Single space between tasks (except last)
-		if i < len(recentTasks)-1 {
-			r.typewriter.PrintfLn("")
-		}
-	}
-
-	return nil
-}
-
-func (r *Renderer) RenderDebug(format string, args ...interface{}) error {
-	if global.Config.Verbose {
-		timestamp := time.Now().Format("15:04:05")
-		message := fmt.Sprintf(format, args...)
-		r.typewriter.PrintMessageLine(timestamp, "[DEBUG]", message)
-	}
-	return nil
-}
-
-func (r *Renderer) ClearLine() {
-	fmt.Print("\r\033[K")
-}
-
-func (r *Renderer) MoveCursorUp(n int) {
-	fmt.Printf("\033[%dA", n)
-}
-
-func (r *Renderer) sanitizeText(text string) string {
-	text = strings.TrimSpace(text)
-
-	if text == "" {
-		return ""
-	}
-
-	// Remove control characters and escape sequences
-	var result strings.Builder
-	for _, r := range text {
-		// Keep printable characters, spaces, tabs, and newlines
-		if r >= 32 || r == '\t' || r == '\n' || r == '\r' {
-			result.WriteRune(r)
-		}
-		// Skip control characters (0-31 except tab, newline, carriage return)
-	}
-
-	return result.String()
-}
-
-func (r *Renderer) SetTypewriterEnabled(enabled bool) {
-	r.typewriter.SetEnabled(enabled)
-}
-
-func (r *Renderer) IsTypewriterEnabled() bool {
-	return r.typewriter.IsEnabled()
-}
-
-func (r *Renderer) SetTypewriterSpeed(multiplier float64) {
-	r.typewriter.SetSpeed(multiplier)
-}
-
-func (r *Renderer) GetTypewriter() *TypewriterPrinter {
-	return r.typewriter
-}

cli/pkg/cli/display/streaming.go

@@ -1,449 +0,0 @@
-package display
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// StreamingDisplay manages streaming message display with deduplication
-type StreamingDisplay struct {
-	mu       sync.RWMutex
-	state    *types.ConversationState
-	renderer *Renderer
-	dedupe   *MessageDeduplicator
-}
-
-// NewStreamingDisplay creates a new streaming display manager
-func NewStreamingDisplay(state *types.ConversationState, renderer *Renderer) *StreamingDisplay {
-	return &StreamingDisplay{
-		state:    state,
-		renderer: renderer,
-		dedupe:   NewMessageDeduplicator(),
-	}
-}
-
-// HandlePartialMessage processes partial messages with streaming support
-func (s *StreamingDisplay) HandlePartialMessage(msg *types.ClineMessage) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	messageKey := fmt.Sprintf("%d", msg.Timestamp)
-	timestamp := msg.GetTimestamp()
-
-	// Check for deduplication
-	if s.dedupe.IsDuplicate(msg) {
-		return nil
-	}
-
-	// Get current streaming state
-	streamingMsg := s.state.GetStreamingMessage()
-
-	switch msg.Type {
-	case types.MessageTypeAsk:
-		return s.handleStreamingAsk(msg, messageKey, timestamp, streamingMsg)
-	case types.MessageTypeSay:
-		return s.handleStreamingSay(msg, messageKey, timestamp, streamingMsg)
-	default:
-		return s.renderer.RenderMessage(timestamp, "🤖", msg.Text)
-	}
-}
-
-// handleStreamingAsk handles streaming ASK messages
-func (s *StreamingDisplay) handleStreamingAsk(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	// Check if this is an update to the same ASK message
-	if streamingMsg.CurrentKey == messageKey {
-		// This is an update to the same ASK message - stream the changes
-		if cleanText != streamingMsg.LastText {
-			s.streamAskMessageUpdate(cleanText, streamingMsg.LastText, timestamp)
-			s.state.SetStreamingMessage(messageKey, cleanText)
-		}
-	} else {
-		// This is a new ASK message
-		s.finishCurrentStream()
-		s.streamAskMessage(cleanText, timestamp, true)
-		s.state.SetStreamingMessage(messageKey, cleanText)
-	}
-
-	return nil
-}
-
-// handleStreamingSay handles streaming SAY messages
-func (s *StreamingDisplay) handleStreamingSay(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	switch msg.Say {
-	case string(types.SayTypeText), string(types.SayTypeCompletionResult):
-		return s.handleStreamingText(msg, messageKey, timestamp, streamingMsg)
-	case string(types.SayTypeCommand):
-		return s.handleStreamingCommand(msg, messageKey, timestamp, streamingMsg)
-	case string(types.SayTypeCommandOutput):
-		return s.handleStreamingCommandOutput(msg, messageKey, timestamp, streamingMsg)
-	case string(types.SayTypeTool):
-		return s.handleStreamingTool(msg, messageKey, timestamp, streamingMsg)
-	case string(types.SayTypeShellIntegrationWarning):
-		return s.handleShellIntegrationWarning(msg, messageKey, timestamp, streamingMsg)
-	default:
-		// For non-streaming message types, use regular display
-		return s.renderer.RenderMessage(timestamp, s.getMessagePrefix(msg.Say), msg.Text)
-	}
-}
-
-// handleStreamingText handles streaming text messages
-func (s *StreamingDisplay) handleStreamingText(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	// Check if we've already displayed this exact message
-	if streamingMsg.CurrentKey == messageKey && streamingMsg.LastText == cleanText {
-		return nil // Duplicate - ignore it
-	}
-
-	// Check if this is an update to the same message
-	if streamingMsg.CurrentKey == messageKey {
-		// Show incremental changes
-		if len(cleanText) > len(streamingMsg.LastText) && strings.HasPrefix(cleanText, streamingMsg.LastText) {
-			// Show only the new characters with typewriter effect
-			newChars := cleanText[len(streamingMsg.LastText):]
-			s.typewriterPrint(newChars)
-			s.state.SetStreamingMessage(messageKey, cleanText)
-		} else {
-			// Text changed in a non-incremental way - replace the line
-			s.renderer.ClearLine()
-			prefix := s.getMessagePrefix(msg.Say)
-			s.renderer.typewriter.PrintfInstant("[%s] %s: ", timestamp, prefix)
-			s.typewriterPrint(cleanText)
-			s.state.SetStreamingMessage(messageKey, cleanText)
-		}
-	} else {
-		// This is a new message
-		s.finishCurrentStream()
-		prefix := s.getMessagePrefix(msg.Say)
-		s.renderer.typewriter.PrintfInstant("[%s] %s: ", timestamp, prefix)
-
-		// Add typewriter animation for new messages
-		s.typewriterPrint(cleanText)
-
-		s.state.SetStreamingMessage(messageKey, cleanText)
-	}
-
-	// If message is complete, add newline
-	if !msg.Partial {
-		fmt.Println()
-		s.state.SetStreamingMessage("", "")
-	}
-
-	return nil
-}
-
-// handleStreamingCommand handles command execution messages
-func (s *StreamingDisplay) handleStreamingCommand(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	// Show command being executed with typewriter effect
-	s.finishCurrentStream()
-	s.renderer.typewriter.PrintfInstant("[%s] 🖥️  CMD: ", timestamp)
-	s.typewriterPrint(cleanText)
-	fmt.Println()
-
-	return nil
-}
-
-// handleStreamingCommandOutput handles streaming command output
-func (s *StreamingDisplay) handleStreamingCommandOutput(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	// Check if we've already displayed this exact message
-	if streamingMsg.CurrentKey == messageKey && streamingMsg.LastText == cleanText {
-		return nil
-	}
-
-	// Check if this is an update to the same message
-	if streamingMsg.CurrentKey == messageKey {
-		// Show incremental changes with typewriter effect
-		if len(cleanText) > len(streamingMsg.LastText) && strings.HasPrefix(cleanText, streamingMsg.LastText) {
-			newChars := cleanText[len(streamingMsg.LastText):]
-			s.typewriterPrint(newChars)
-			s.state.SetStreamingMessage(messageKey, cleanText)
-		} else {
-			// Non-incremental change - replace the line
-			s.renderer.ClearLine()
-			s.renderer.typewriter.PrintfInstant("[%s] 🖥️  OUT: ", timestamp)
-			s.typewriterPrint(cleanText)
-			s.state.SetStreamingMessage(messageKey, cleanText)
-		}
-	} else {
-		// New command output message
-		s.finishCurrentStream()
-		s.renderer.typewriter.PrintfInstant("[%s] 🖥️  OUT: ", timestamp)
-		s.typewriterPrint(cleanText)
-		s.state.SetStreamingMessage(messageKey, cleanText)
-	}
-
-	// If message is complete, add newline
-	if !msg.Partial {
-		fmt.Println()
-		s.state.SetStreamingMessage("", "")
-	}
-
-	return nil
-}
-
-// handleShellIntegrationWarning handles shell integration warning messages
-func (s *StreamingDisplay) handleShellIntegrationWarning(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	// Show a more concise shell integration warning
-	s.finishCurrentStream()
-	s.renderer.typewriter.PrintfInstant("[%s] ℹ️  NOTE: ", timestamp)
-	s.typewriterPrint("Command executed (output not streamed due to shell integration)")
-	fmt.Println()
-
-	return nil
-}
-
-// handleStreamingTool handles streaming tool messages with deduplication
-func (s *StreamingDisplay) handleStreamingTool(msg *types.ClineMessage, messageKey, timestamp string, streamingMsg *types.StreamingMessage) error {
-	cleanText := s.renderer.sanitizeText(msg.Text)
-	if cleanText == "" {
-		return nil
-	}
-
-	formattedTool := s.formatToolMessage(cleanText)
-
-	// Check if this is the exact same tool message we just displayed
-	if streamingMsg.LastToolMessage == formattedTool {
-		return nil // Exact duplicate - ignore it
-	}
-
-	// Check if this is a very similar tool message
-	if streamingMsg.LastToolMessage != "" && s.isSimilarToolMessage(streamingMsg.LastToolMessage, formattedTool) {
-		return nil // Similar duplicate - ignore it
-	}
-
-	// This is a genuinely new/different tool message
-	s.finishCurrentStream()
-	fmt.Printf("[%s] 🔧 TOOL: %s\n", timestamp, formattedTool)
-
-	// Store the formatted tool message for deduplication
-	s.state.StreamingMessage.LastToolMessage = formattedTool
-
-	return nil
-}
-
-// streamAskMessage streams an ASK message in a natural format
-func (s *StreamingDisplay) streamAskMessage(text, timestamp string, isNew bool) {
-	// Try to parse as JSON
-	var askData types.AskData
-	if err := s.parseJSON(text, &askData); err != nil {
-		// Display as text but sanitized
-		fmt.Printf("[%s] 🤖 ASK: %s", timestamp, text)
-		return
-	}
-
-	fmt.Printf("[%s] 🤖 ASK: %s", timestamp, askData.Response)
-
-	// Display options if available
-	if len(askData.Options) > 0 {
-		fmt.Print("\n\nOptions:")
-		for i, option := range askData.Options {
-			fmt.Printf("\n%d. %s", i+1, option)
-		}
-	}
-}
-
-// streamAskMessageUpdate handles updates to an existing ASK message
-func (s *StreamingDisplay) streamAskMessageUpdate(newText, oldText, timestamp string) {
-	var oldAskData, newAskData types.AskData
-
-	oldErr := s.parseJSON(oldText, &oldAskData)
-	newErr := s.parseJSON(newText, &newAskData)
-
-	if oldErr != nil || newErr != nil {
-		// Handle plain text incremental updates
-		if len(newText) > len(oldText) && strings.HasPrefix(newText, oldText) {
-			newChars := newText[len(oldText):]
-			fmt.Print(newChars)
-		} else {
-			// Non-incremental change - clear line and reprint everything
-			s.renderer.ClearLine()
-			fmt.Printf("[%s] 🤖 ASK: %s", timestamp, newText)
-		}
-		return
-	}
-
-	// Handle structured updates
-	if len(newAskData.Response) > len(oldAskData.Response) && strings.HasPrefix(newAskData.Response, oldAskData.Response) {
-		newChars := newAskData.Response[len(oldAskData.Response):]
-		fmt.Print(newChars)
-	} else if oldAskData.Response != newAskData.Response {
-		s.renderer.ClearLine()
-		fmt.Printf("[%s] 🤖 ASK: %s", timestamp, newAskData.Response)
-	}
-
-	// Handle options changes
-	if len(newAskData.Options) > len(oldAskData.Options) {
-		if len(oldAskData.Options) == 0 {
-			fmt.Print("\n\nOptions:")
-		}
-
-		for i := len(oldAskData.Options); i < len(newAskData.Options); i++ {
-			fmt.Printf("\n%d. %s", i+1, newAskData.Options[i])
-		}
-	}
-}
-
-// typewriterPrint displays text with a typewriter animation effect
-func (s *StreamingDisplay) typewriterPrint(text string) {
-	// Use the renderer's typewriter for consistent animation
-	s.renderer.typewriter.Print(text)
-}
-
-// finishCurrentStream completes any ongoing streaming message
-func (s *StreamingDisplay) finishCurrentStream() {
-	streamingMsg := s.state.GetStreamingMessage()
-	if streamingMsg.CurrentKey != "" {
-		//fmt.Println() // Add newline to finish the current streaming message
-		s.state.SetStreamingMessage("", "")
-	}
-}
-
-// getMessagePrefix returns the appropriate prefix for a message type
-func (s *StreamingDisplay) getMessagePrefix(say string) string {
-	switch say {
-	case string(types.SayTypeCompletionResult):
-		return "✅ RESULT"
-	case string(types.SayTypeText):
-		return "🤖"
-	default:
-		return "🤖"
-	}
-}
-
-// formatToolMessage formats tool call messages for better readability
-func (s *StreamingDisplay) formatToolMessage(text string) string {
-	var toolCall map[string]interface{}
-	if err := s.parseJSON(text, &toolCall); err == nil {
-		if tool, ok := toolCall["tool"].(string); ok {
-			parts := []string{tool}
-
-			if path, ok := toolCall["path"].(string); ok && path != "" {
-				parts = append(parts, fmt.Sprintf("path=%s", path))
-			}
-
-			if content, ok := toolCall["content"].(string); ok && content != "" {
-				if len(content) > 50 {
-					parts = append(parts, fmt.Sprintf("content=%s...", content[:50]))
-				} else {
-					parts = append(parts, fmt.Sprintf("content=%s", content))
-				}
-			}
-
-			return strings.Join(parts, " ")
-		}
-	}
-
-	// If not JSON or doesn't have expected structure, return truncated
-	if len(text) > 100 {
-		return text[:100] + "..."
-	}
-	return text
-}
-
-// isSimilarToolMessage checks if two tool messages are similar enough to be considered duplicates
-func (s *StreamingDisplay) isSimilarToolMessage(msg1, msg2 string) bool {
-	parts1 := strings.Fields(msg1)
-	parts2 := strings.Fields(msg2)
-
-	if len(parts1) == 0 || len(parts2) == 0 {
-		return false
-	}
-
-	// If the first word (tool name) is the same, check for similarity
-	if parts1[0] == parts2[0] {
-		// For file operations, check if the path is the same
-		if strings.Contains(msg1, "path=") && strings.Contains(msg2, "path=") {
-			path1 := s.extractPathFromToolMessage(msg1)
-			path2 := s.extractPathFromToolMessage(msg2)
-
-			if path1 != "" && path1 == path2 {
-				return true
-			}
-		}
-
-		// For very similar content (>80% similarity), consider them duplicates
-		similarity := s.calculateStringSimilarity(msg1, msg2)
-		return similarity > 0.8
-	}
-
-	return false
-}
-
-// extractPathFromToolMessage extracts the path parameter from a tool message
-func (s *StreamingDisplay) extractPathFromToolMessage(msg string) string {
-	parts := strings.Fields(msg)
-	for _, part := range parts {
-		if strings.HasPrefix(part, "path=") {
-			return strings.TrimPrefix(part, "path=")
-		}
-	}
-	return ""
-}
-
-// calculateStringSimilarity calculates a simple similarity ratio between two strings
-func (s *StreamingDisplay) calculateStringSimilarity(s1, s2 string) float64 {
-	if s1 == s2 {
-		return 1.0
-	}
-
-	if len(s1) == 0 || len(s2) == 0 {
-		return 0.0
-	}
-
-	shorter, longer := s1, s2
-	if len(s1) > len(s2) {
-		shorter, longer = s2, s1
-	}
-
-	matches := 0
-	for i, r := range shorter {
-		if i < len(longer) && rune(longer[i]) == r {
-			matches++
-		}
-	}
-
-	return float64(matches) / float64(len(longer))
-}
-
-// parseJSON is a helper function to parse JSON with error handling
-func (s *StreamingDisplay) parseJSON(text string, v interface{}) error {
-	return json.Unmarshal([]byte(text), v)
-}
-
-// Cleanup cleans up streaming display resources
-func (s *StreamingDisplay) Cleanup() {
-	if s.dedupe != nil {
-		s.dedupe.Stop()
-	}
-}

cli/pkg/cli/display/typewriter.go

@@ -1,214 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"os"
-	"time"
-)
-
-// TypewriterConfig holds configuration for the typewriter effect
-type TypewriterConfig struct {
-	BaseDelay    time.Duration // Base delay between characters
-	FastDelay    time.Duration // Faster delay for common characters
-	SlowDelay    time.Duration // Slower delay for punctuation
-	PauseDelay   time.Duration // Pause after sentences
-	Enabled      bool          // Whether typewriter effect is enabled
-	RandomFactor float64       // Randomness factor (0.0 to 1.0)
-}
-
-// DefaultTypewriterConfig returns the default typewriter configuration
-func DefaultTypewriterConfig() *TypewriterConfig {
-	return &TypewriterConfig{
-		BaseDelay:    15 * time.Millisecond,
-		FastDelay:    8 * time.Millisecond,
-		SlowDelay:    25 * time.Millisecond,
-		PauseDelay:   150 * time.Millisecond,
-		Enabled:      false,
-		RandomFactor: 0.3,
-	}
-}
-
-// TypewriterPrinter handles typewriter-style output
-type TypewriterPrinter struct {
-	config *TypewriterConfig
-}
-
-// NewTypewriterPrinter creates a new typewriter printer
-func NewTypewriterPrinter(config *TypewriterConfig) *TypewriterPrinter {
-	if config == nil {
-		config = DefaultTypewriterConfig()
-	}
-	return &TypewriterPrinter{
-		config: config,
-	}
-}
-
-// Print prints text with typewriter effect
-func (tp *TypewriterPrinter) Print(text string) {
-	if !tp.config.Enabled {
-		fmt.Print(text)
-		return
-	}
-
-	tp.typewriterPrint(text)
-}
-
-// Printf prints formatted text with typewriter effect
-func (tp *TypewriterPrinter) Printf(format string, args ...interface{}) {
-	text := fmt.Sprintf(format, args...)
-	tp.Print(text)
-}
-
-// Println prints text with typewriter effect and adds a newline
-func (tp *TypewriterPrinter) Println(text string) {
-	tp.Print(text + "\n")
-}
-
-// PrintfLn prints formatted text with typewriter effect and adds a newline
-func (tp *TypewriterPrinter) PrintfLn(format string, args ...interface{}) {
-	text := fmt.Sprintf(format, args...)
-	tp.Println(text)
-}
-
-// PrintInstant prints text immediately without typewriter effect
-func (tp *TypewriterPrinter) PrintInstant(text string) {
-	fmt.Print(text)
-}
-
-// PrintfInstant prints formatted text immediately without typewriter effect
-func (tp *TypewriterPrinter) PrintfInstant(format string, args ...interface{}) {
-	fmt.Printf(format, args...)
-}
-
-// typewriterPrint displays text with a typewriter animation effect
-func (tp *TypewriterPrinter) typewriterPrint(text string) {
-	// Convert string to runes to handle Unicode properly
-	runes := []rune(text)
-
-	for i, r := range runes {
-		// Print the character
-		fmt.Print(string(r))
-		os.Stdout.Sync() // Force immediate output
-
-		// Don't add delay after the last character
-		if i == len(runes)-1 {
-			break
-		}
-
-		// Determine delay based on character type
-		delay := tp.getDelayForCharacter(r, i)
-
-		// Sleep for the calculated delay
-		time.Sleep(delay)
-	}
-}
-
-// getDelayForCharacter returns the appropriate delay for a character
-func (tp *TypewriterPrinter) getDelayForCharacter(r rune, position int) time.Duration {
-	var baseDelay time.Duration
-
-	switch {
-	case r == '.' || r == '!' || r == '?':
-		// Longer pause after sentence endings
-		baseDelay = tp.config.PauseDelay
-	case r == ',' || r == ';' || r == ':':
-		// Medium pause after punctuation
-		baseDelay = tp.config.SlowDelay
-	case r == ' ':
-		// Slightly faster for spaces
-		baseDelay = tp.config.FastDelay
-	case r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z':
-		// Fast for common letters
-		baseDelay = tp.config.FastDelay
-	case r == '\n':
-		// No delay for newlines
-		return 0
-	default:
-		// Base delay for other characters
-		baseDelay = tp.config.BaseDelay
-	}
-
-	// Add randomness to make it feel more natural
-	if tp.config.RandomFactor > 0 {
-		// Simple pseudo-random based on position to ensure consistency
-		randomFactor := 0.7 + (tp.config.RandomFactor * float64(position%7) / 6.0)
-		baseDelay = time.Duration(float64(baseDelay) * randomFactor)
-	}
-
-	return baseDelay
-}
-
-// SetEnabled enables or disables the typewriter effect
-func (tp *TypewriterPrinter) SetEnabled(enabled bool) {
-	tp.config.Enabled = enabled
-}
-
-// IsEnabled returns whether the typewriter effect is enabled
-func (tp *TypewriterPrinter) IsEnabled() bool {
-	return tp.config.Enabled
-}
-
-// SetSpeed adjusts the typewriter speed (multiplier: 0.1 = very slow, 1.0 = normal, 2.0 = fast)
-func (tp *TypewriterPrinter) SetSpeed(multiplier float64) {
-	if multiplier <= 0 {
-		multiplier = 1.0
-	}
-
-	tp.config.BaseDelay = time.Duration(float64(15*time.Millisecond) / multiplier)
-	tp.config.FastDelay = time.Duration(float64(8*time.Millisecond) / multiplier)
-	tp.config.SlowDelay = time.Duration(float64(25*time.Millisecond) / multiplier)
-	tp.config.PauseDelay = time.Duration(float64(150*time.Millisecond) / multiplier)
-}
-
-// PrintMessageLine prints a complete message line with typewriter effect
-func (tp *TypewriterPrinter) PrintMessageLine(timestamp, prefix, text string) {
-	// Print the timestamp and prefix with 10-char padding
-	tp.PrintfInstant("[%s] %-10s: ", timestamp, prefix)
-	// Print the message text with typewriter effect
-	tp.Println(text)
-}
-
-// Global typewriter printer instance
-var globalTypewriter = NewTypewriterPrinter(DefaultTypewriterConfig())
-
-// Global convenience functions that use the global typewriter instance
-
-// TypewriterPrint prints text with typewriter effect using the global instance
-func TypewriterPrint(text string) {
-	globalTypewriter.Print(text)
-}
-
-// TypewriterPrintf prints formatted text with typewriter effect using the global instance
-func TypewriterPrintf(format string, args ...interface{}) {
-	globalTypewriter.Printf(format, args...)
-}
-
-// TypewriterPrintln prints text with typewriter effect and newline using the global instance
-func TypewriterPrintln(text string) {
-	globalTypewriter.Println(text)
-}
-
-// TypewriterPrintfLn prints formatted text with typewriter effect and newline using the global instance
-func TypewriterPrintfLn(format string, args ...interface{}) {
-	globalTypewriter.PrintfLn(format, args...)
-}
-
-// TypewriterPrintMessageLine prints a message line with typewriter effect using the global instance
-func TypewriterPrintMessageLine(timestamp, prefix, text string) {
-	globalTypewriter.PrintMessageLine(timestamp, prefix, text)
-}
-
-// SetGlobalTypewriterEnabled enables or disables the global typewriter effect
-func SetGlobalTypewriterEnabled(enabled bool) {
-	globalTypewriter.SetEnabled(enabled)
-}
-
-// SetGlobalTypewriterSpeed sets the speed of the global typewriter effect
-func SetGlobalTypewriterSpeed(multiplier float64) {
-	globalTypewriter.SetSpeed(multiplier)
-}
-
-// GetGlobalTypewriter returns the global typewriter instance
-func GetGlobalTypewriter() *TypewriterPrinter {
-	return globalTypewriter
-}

cli/pkg/cli/global/cline-clients.go

@@ -1,274 +0,0 @@
-package global
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"time"
-
-	"github.com/cline/cli/pkg/common"
-)
-
-// ClineClients manages Cline instances using the new registry system
-type ClineClients struct {
-	registry *ClientRegistry
-}
-
-// NewClineClients creates a new ClineClients instance
-func NewClineClients(configPath string) *ClineClients {
-	registry := NewClientRegistry(configPath)
-	return &ClineClients{
-		registry: registry,
-	}
-}
-
-// Initialize performs cleanup of stale instances
-func (c *ClineClients) Initialize(ctx context.Context) error {
-	// Clean up stale entries (direct SQLite operations)
-	_ = c.registry.CleanupStaleInstances(ctx)
-
-	return nil
-}
-
-// StartNewInstance starts a new Cline instance and waits for cline-core to self-register
-func (c *ClineClients) StartNewInstance(ctx context.Context) (*common.CoreInstanceInfo, error) {
-	// Find available ports
-	corePort, hostPort, err := common.FindAvailablePortPair()
-	if err != nil {
-		return nil, fmt.Errorf("failed to find available ports: %w", err)
-	}
-
-	fmt.Printf("Starting new Cline instance on ports %d (core) and %d (host bridge)\n", corePort, hostPort)
-
-	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, corePort)
-	if err != nil {
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	// Start cline-core (it will register itself in SQLite locks database)
-	coreCmd, err := startClineCore(corePort, hostPort)
-	if err != nil {
-		// Clean up host process if core fails to start
-		if hostCmd != nil && hostCmd.Process != nil {
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	fullAddress := fmt.Sprintf("localhost:%d", corePort)
-	fmt.Println("Waiting for services to start and self-register in SQLite...")
-
-	// Use RetryOperation to wait for instance to be ready
-	var instance *common.CoreInstanceInfo
-	err = common.RetryOperation(12, 5*time.Second, func() error {
-		// Check if instance registered itself in SQLite
-		foundInstance, err := c.registry.GetInstance(fullAddress)
-		if err != nil || foundInstance == nil {
-			return fmt.Errorf("instance not found in registry: %v", err)
-		}
-
-		// Verify instance is healthy
-		if !common.IsInstanceHealthy(ctx, fullAddress) {
-			return fmt.Errorf("instance is registered but not healthy")
-		}
-
-		// Success - store the instance for return
-		instance = foundInstance
-		return nil
-	})
-
-	if err != nil {
-		// Clean up both processes on failure
-		if coreCmd != nil && coreCmd.Process != nil {
-			fmt.Printf("Cleaning up core process (PID: %d)\n", coreCmd.Process.Pid)
-			coreCmd.Process.Kill()
-		}
-		if hostCmd != nil && hostCmd.Process != nil {
-			fmt.Printf("Cleaning up host process (PID: %d)\n", hostCmd.Process.Pid)
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start instance: %w", err)
-	}
-
-	fmt.Println("✅ Services started and registered successfully!")
-	fmt.Printf("  Address: %s\n", instance.Address)
-	fmt.Printf("  Core Port: %d\n", instance.CorePort())
-	fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
-	fmt.Printf("  Process PID: %d\n", coreCmd.Process.Pid)
-	return instance, nil
-}
-
-// StartNewInstanceAtPort starts a new Cline instance at the specified port and waits for self-registration
-func (c *ClineClients) StartNewInstanceAtPort(ctx context.Context, corePort int) (*common.CoreInstanceInfo, error) {
-	// Find available host port (core port + 1000)
-	hostPort := corePort + 1000
-	coreAddress := fmt.Sprintf("localhost:%d", corePort)
-
-	// Check if the specified core port is available
-	if common.IsInstanceHealthy(ctx, coreAddress) {
-		return nil, fmt.Errorf("port %d is already in use by another Cline instance", corePort)
-	}
-
-	fmt.Printf("Starting new Cline instance on ports %d (core) and %d (host bridge)\n", corePort, hostPort)
-
-	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, corePort)
-	if err != nil {
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	// Start cline-core (it will register itself in SQLite locks database)
-	coreCmd, err := startClineCore(corePort, hostPort)
-	if err != nil {
-		// Clean up host process if core fails to start
-		if hostCmd != nil && hostCmd.Process != nil {
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	fullAddress := fmt.Sprintf("localhost:%d", corePort)
-	fmt.Println("Waiting for services to start and self-register in SQLite...")
-
-	// Use RetryOperation to wait for instance to be ready
-	var instance *common.CoreInstanceInfo
-	err = common.RetryOperation(12, 5*time.Second, func() error {
-		// Check if instance registered itself in SQLite
-		foundInstance, err := c.registry.GetInstance(fullAddress)
-		if err != nil || foundInstance == nil {
-			return fmt.Errorf("instance not found in registry: %v", err)
-		}
-
-		// Verify instance is healthy
-		if !common.IsInstanceHealthy(ctx, fullAddress) {
-			return fmt.Errorf("instance is registered but not healthy")
-		}
-
-		// Success - store the instance for return
-		instance = foundInstance
-		return nil
-	})
-
-	if err != nil {
-		// Clean up both processes on failure
-		if coreCmd != nil && coreCmd.Process != nil {
-			fmt.Printf("Cleaning up core process (PID: %d)\n", coreCmd.Process.Pid)
-			coreCmd.Process.Kill()
-		}
-		if hostCmd != nil && hostCmd.Process != nil {
-			fmt.Printf("Cleaning up host process (PID: %d)\n", hostCmd.Process.Pid)
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start instance at port %d: %w", corePort, err)
-	}
-
-	fmt.Println("✅ Services started and registered successfully!")
-	fmt.Printf("  Address: %s\n", instance.Address)
-	fmt.Printf("  Core Port: %d\n", instance.CorePort())
-	fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
-	fmt.Printf("  Process PID: %d\n", coreCmd.Process.Pid)
-	return instance, nil
-}
-
-// GetRegistry returns the client registry
-func (c *ClineClients) GetRegistry() *ClientRegistry {
-	return c.registry
-}
-
-// EnsureInstanceAtAddress ensures an instance exists at the given address, starting one if needed
-func (c *ClineClients) EnsureInstanceAtAddress(ctx context.Context, address string) error {
-	// Expect host:port everywhere
-	normalized := address
-	if normalized == "" {
-		normalized = fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT)
-	}
-
-	// Check if instance already exists at this address
-	if c.registry.HasInstanceAtAddress(normalized) {
-		return nil
-	}
-
-	// Parse host:port
-	host, port, err := common.ParseHostPort(normalized)
-	if err != nil {
-		return fmt.Errorf("invalid address format %s", address)
-	}
-
-	// Use IPv6-compatible localhost detection
-	if common.IsLocalAddress(host) {
-		_, err := c.StartNewInstanceAtPort(ctx, port)
-		if err != nil {
-			return fmt.Errorf("failed to start new instance at %s: %w", normalized, err)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("cannot start remote instance at %s", normalized)
-}
-
-func startClineHost(hostPort, corePort int) (*exec.Cmd, error) {
-	fmt.Printf("Starting cline-host on port %d\n", hostPort)
-
-	// Start the cline-host process
-	cmd := exec.Command("./cli/bin/cline-host",
-		"--verbose",
-		"--port", fmt.Sprintf("%d", hostPort))
-
-	if err := cmd.Start(); err != nil {
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	fmt.Printf("Started cline-host (PID: %d)\n", cmd.Process.Pid)
-	return cmd, nil
-}
-
-func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
-	fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
-
-	// Create port-tagged log file in OS temp directory with full address
-	logFileName := fmt.Sprintf("cline-core-debug-localhost-%d.log", corePort)
-	logFilePath := fmt.Sprintf("%s/%s", os.TempDir(), logFileName)
-	logFile, err := os.Create(logFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create log file: %w", err)
-	}
-
-	// Start the cline-core process with --config flag instead of CLINE_DIR env var
-	args := []string{"cline-core.js",
-		"--port", fmt.Sprintf("%d", corePort),
-		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
-		"--config", Config.ConfigPath}
-
-	fmt.Printf("DEBUG: Starting cline-core with command: node %v\n", args)
-	fmt.Printf("DEBUG: Working directory: ./dist-standalone\n")
-	fmt.Printf("DEBUG: Config path: %s\n", Config.ConfigPath)
-
-	cmd := exec.Command("node", args...)
-
-	// Set working directory to dist-standalone (relative to project root)
-	cmd.Dir = "./dist-standalone"
-
-	// Redirect stdout and stderr to log file
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	// Set environment variables (removed CLINE_DIR)
-	env := os.Environ()
-	env = append(env,
-		"GRPC_TRACE=all",
-		"GRPC_VERBOSITY=DEBUG",
-		"NODE_ENV=development",
-	)
-	cmd.Env = env
-
-	if err := cmd.Start(); err != nil {
-		logFile.Close()
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	fmt.Printf("Started cline-core (PID: %d)\n", cmd.Process.Pid)
-	fmt.Printf("Logging cline-core output to: %s\n", logFilePath)
-	return cmd, nil
-}

cli/pkg/cli/global/global.go

@@ -1,67 +0,0 @@
-package global
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/client"
-)
-
-type Port uint16
-
-type GlobalConfig struct {
-	ConfigPath   string
-	Verbose      bool
-	OutputFormat string
-	CoreAddress  string
-}
-
-var (
-	Config  *GlobalConfig
-	Clients *ClineClients
-)
-
-func InitializeGlobalConfig(cfg *GlobalConfig) error {
-	if cfg.ConfigPath == "" {
-		homeDir, err := os.UserHomeDir()
-		if err != nil {
-			return fmt.Errorf("failed to get home directory: %w", err)
-		}
-		cfg.ConfigPath = filepath.Join(homeDir, ".cline")
-	}
-
-	// Ensure .cline directory exists
-	if err := os.MkdirAll(cfg.ConfigPath, 0755); err != nil {
-		return fmt.Errorf("failed to create config directory: %w", err)
-	}
-
-	Config = cfg
-	Clients = NewClineClients(cfg.ConfigPath)
-
-	// Initialize the clients registry
-	ctx := context.Background()
-	if err := Clients.Initialize(ctx); err != nil {
-		return fmt.Errorf("failed to initialize clients: %w", err)
-	}
-
-	return nil
-}
-
-// GetDefaultClient returns a client for the default instance or the address override
-func GetDefaultClient(ctx context.Context) (*client.ClineClient, error) {
-	if Config.CoreAddress != "" && Config.CoreAddress != fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT) {
-		// User specified a specific address, use that
-		return Clients.GetRegistry().GetClient(ctx, Config.CoreAddress)
-	}
-
-	// Use the default instance from registry
-	return Clients.GetRegistry().GetDefaultClient(ctx)
-}
-
-// GetClientForAddress returns a client for a specific address
-func GetClientForAddress(ctx context.Context, address string) (*client.ClineClient, error) {
-	return Clients.GetRegistry().GetClient(ctx, address)
-}

cli/pkg/cli/global/registry.go

@@ -1,267 +0,0 @@
-package global
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/sqlite"
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/client"
-	"github.com/cline/grpc-go/cline"
-	"github.com/cline/grpc-go/host"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// ClientRegistry manages Cline client connections using direct SQLite operations
-type ClientRegistry struct {
-	lockManager *sqlite.LockManager
-	configPath  string
-}
-
-// NewClientRegistry creates a new client registry
-func NewClientRegistry(configPath string) *ClientRegistry {
-	lockManager, err := sqlite.NewLockManager(configPath)
-	if err != nil {
-		// Log error but continue - we can still function without SQLite
-		log.Fatalf("Warning: Failed to initialize SQLite lock manager: %v\n", err)
-	}
-
-	return &ClientRegistry{
-		lockManager: lockManager,
-		configPath:  configPath,
-	}
-}
-
-// GetDefaultInstance returns the default instance address from settings file
-func (r *ClientRegistry) GetDefaultInstance() string {
-	defaultAddr, err := sqlite.GetDefaultInstance(r.configPath)
-	if err != nil {
-		return ""
-	}
-	return defaultAddr
-}
-
-// SetDefaultInstance sets the default instance (writes default.json)
-func (r *ClientRegistry) SetDefaultInstance(address string) error {
-	// Verify the instance exists in SQLite
-	if r.lockManager != nil {
-		exists, err := r.lockManager.HasInstanceAtAddress(address)
-		if err != nil {
-			return fmt.Errorf("failed to check instance existence: %w", err)
-		}
-		if !exists {
-			return fmt.Errorf("instance %s not found in registry", address)
-		}
-	}
-
-	return sqlite.SetDefaultInstance(r.configPath, address)
-}
-
-// GetInstance returns instance information directly from SQLite
-func (r *ClientRegistry) GetInstance(address string) (*common.CoreInstanceInfo, error) {
-	if r.lockManager == nil {
-		return nil, fmt.Errorf("lock manager not available")
-	}
-
-	return r.lockManager.GetInstanceInfo(address)
-}
-
-// GetClient returns a connected client for the given address (created on-demand)
-func (r *ClientRegistry) GetClient(ctx context.Context, address string) (*client.ClineClient, error) {
-	// Verify instance exists in SQLite
-	if r.lockManager != nil {
-		exists, err := r.lockManager.HasInstanceAtAddress(address)
-		if err != nil {
-			return nil, fmt.Errorf("failed to check instance existence: %w", err)
-		}
-		if !exists {
-			return nil, fmt.Errorf("instance %s not found", address)
-		}
-	}
-
-	// Create client on-demand (no caching)
-	target, err := common.NormalizeAddressForGRPC(address)
-	if err != nil {
-		return nil, fmt.Errorf("invalid address %s: %w", address, err)
-	}
-
-	cl, err := client.NewClineClient(target)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create client for %s: %w", target, err)
-	}
-
-	if err := cl.Connect(ctx); err != nil {
-		return nil, fmt.Errorf("failed to connect to %s: %w", target, err)
-	}
-
-	return cl, nil
-}
-
-// GetDefaultClient returns a client for the default instance
-func (r *ClientRegistry) GetDefaultClient(ctx context.Context) (*client.ClineClient, error) {
-	defaultAddr := r.GetDefaultInstance()
-	if defaultAddr == "" {
-		return nil, fmt.Errorf("no default instance configured")
-	}
-
-	return r.GetClient(ctx, defaultAddr)
-}
-
-// ListInstances returns all registered instances directly from SQLite
-func (r *ClientRegistry) ListInstances() []*common.CoreInstanceInfo {
-	if r.lockManager == nil {
-		return []*common.CoreInstanceInfo{}
-	}
-
-	// Use context with timeout for health checks
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	instances, err := r.lockManager.ListInstancesWithHealthCheck(ctx)
-	if err != nil {
-		fmt.Printf("Warning: Failed to list instances: %v\n", err)
-		return []*common.CoreInstanceInfo{}
-	}
-
-	return instances
-}
-
-// HasInstanceAtAddress checks if an instance exists at the given address (delegates to SQLite)
-func (r *ClientRegistry) HasInstanceAtAddress(address string) bool {
-	if r.lockManager == nil {
-		return false
-	}
-
-	exists, err := r.lockManager.HasInstanceAtAddress(address)
-	if err != nil {
-		fmt.Printf("Warning: Failed to check instance existence: %v\n", err)
-		return false
-	}
-
-	return exists
-}
-
-// CleanupStaleInstances removes stale instances using direct SQLite operations
-func (r *ClientRegistry) CleanupStaleInstances(ctx context.Context) error {
-	if r.lockManager == nil {
-		return nil
-	}
-
-	// Get all instances with health checks
-	instances, err := r.lockManager.ListInstancesWithHealthCheck(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to list instances for cleanup: %w", err)
-	}
-
-	// Clean up all stale instances
-	for _, instance := range instances {
-		if instance.Status != grpc_health_v1.HealthCheckResponse_SERVING {
-			// Try to gracefully shutdown the paired host process before cleanup
-
-			fmt.Printf("Attempting to shutdown dangling host service %s for stale cline core instance %s\n",
-				instance.HostServiceAddress, instance.Address)
-			r.tryShutdownHostProcess(instance.HostServiceAddress)
-
-			// Remove from SQLite database
-			if err := r.lockManager.RemoveInstanceLock(instance.Address); err != nil {
-				return fmt.Errorf("failed to remove stale instance %s: %w", instance.Address, err)
-			}
-
-			fmt.Printf("Removed stale instance: %s\n", instance.Address)
-		}
-	}
-
-	return nil
-}
-
-// tryShutdownHostProcess attempts to gracefully shutdown a host process via RPC
-// Best effort, don't throw errors i guess
-func (r *ClientRegistry) tryShutdownHostProcess(hostServiceAddress string) {
-	err := common.RetryOperation(3, 2*time.Second, func() error {
-		// Create context with timeout
-		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-		defer cancel()
-
-		// Create gRPC connection to host bridge
-		conn, err := grpc.DialContext(ctx, hostServiceAddress,
-			grpc.WithTransportCredentials(insecure.NewCredentials()),
-			grpc.WithBlock())
-		if err != nil {
-			return fmt.Errorf("connection failed: %w", err)
-		}
-		defer conn.Close()
-
-		// Create env service client and call shutdown
-		envClient := host.NewEnvServiceClient(conn)
-		_, err = envClient.Shutdown(ctx, &cline.EmptyRequest{})
-		if err != nil {
-			return fmt.Errorf("RPC failed: %w", err)
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		fmt.Printf("Warning: Failed to request host bridge shutdown on port %s: %v\n", hostServiceAddress, err)
-	} else {
-		fmt.Printf("Host bridge shutdown requested successfully on port %s\n", hostServiceAddress)
-	}
-}
-
-// ListInstancesCleaned performs cleanup and returns instances with health checks
-func (r *ClientRegistry) ListInstancesCleaned(ctx context.Context) ([]*common.CoreInstanceInfo, error) {
-	// 1. Clean up stale entries (best-effort)
-	_ = r.CleanupStaleInstances(ctx)
-
-	// 2. Get all instances with real-time health checks
-	instances := r.ListInstances()
-
-	// 3. Ensure default is set if instances exist
-	if err := r.ensureDefaultInstance(instances); err != nil {
-		fmt.Printf("Warning: Failed to ensure default instance: %v\n", err)
-	}
-
-	return instances, nil
-}
-
-// ensureDefaultInstance ensures a default instance is set if instances exist but no default is configured
-func (r *ClientRegistry) ensureDefaultInstance(instances []*common.CoreInstanceInfo) error {
-	currentDefault := r.GetDefaultInstance()
-
-	// If we have no instances, clear any stale default and remove settings file
-	if len(instances) == 0 {
-		if currentDefault != "" {
-			// Remove the settings file since no instances exist
-			settingsPath := filepath.Join(r.configPath, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-			_ = os.Remove(settingsPath)
-		}
-		return nil
-	}
-
-	// If we have instances but no default, pick the first one
-	if currentDefault == "" {
-		return sqlite.SetDefaultInstance(r.configPath, instances[0].Address)
-	}
-
-	// Validate current default still exists in the instances
-	defaultExists := false
-	for _, instance := range instances {
-		if instance.Address == currentDefault {
-			defaultExists = true
-			break
-		}
-	}
-
-	if !defaultExists {
-		// Current default doesn't exist, pick a new one from available instances
-		return sqlite.SetDefaultInstance(r.configPath, instances[0].Address)
-	}
-
-	return nil
-}

cli/pkg/cli/handlers/ask_handlers.go

@@ -1,354 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// AskHandler handles ASK type messages
-type AskHandler struct {
-	*BaseHandler
-}
-
-// NewAskHandler creates a new ASK handler
-func NewAskHandler() *AskHandler {
-	return &AskHandler{
-		BaseHandler: NewBaseHandler("ask", PriorityHigh),
-	}
-}
-
-// CanHandle returns true if this is an ASK message
-func (h *AskHandler) CanHandle(msg *types.ClineMessage) bool {
-	return msg.IsAsk()
-}
-
-// Handle processes ASK messages
-func (h *AskHandler) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
-	timestamp := msg.GetTimestamp()
-
-	switch msg.Ask {
-	case string(types.AskTypeFollowup):
-		return h.handleFollowup(msg, dc, timestamp)
-	case string(types.AskTypePlanModeRespond):
-		return h.handlePlanModeRespond(msg, dc, timestamp)
-	case string(types.AskTypeCommand):
-		return h.handleCommand(msg, dc, timestamp)
-	case string(types.AskTypeCommandOutput):
-		return h.handleCommandOutput(msg, dc, timestamp)
-	case string(types.AskTypeCompletionResult):
-		return h.handleCompletionResult(msg, dc, timestamp)
-	case string(types.AskTypeTool):
-		return h.handleTool(msg, dc, timestamp)
-	case string(types.AskTypeAPIReqFailed):
-		return h.handleAPIReqFailed(msg, dc, timestamp)
-	case string(types.AskTypeResumeTask):
-		return h.handleResumeTask(msg, dc, timestamp)
-	case string(types.AskTypeResumeCompletedTask):
-		return h.handleResumeCompletedTask(msg, dc, timestamp)
-	case string(types.AskTypeMistakeLimitReached):
-		return h.handleMistakeLimitReached(msg, dc, timestamp)
-	case string(types.AskTypeAutoApprovalMaxReached):
-		return h.handleAutoApprovalMaxReached(msg, dc, timestamp)
-	case string(types.AskTypeBrowserActionLaunch):
-		return h.handleBrowserActionLaunch(msg, dc, timestamp)
-	case string(types.AskTypeUseMcpServer):
-		return h.handleUseMcpServer(msg, dc, timestamp)
-	case string(types.AskTypeNewTask):
-		return h.handleNewTask(msg, dc, timestamp)
-	case string(types.AskTypeCondense):
-		return h.handleCondense(msg, dc, timestamp)
-	case string(types.AskTypeReportBug):
-		return h.handleReportBug(msg, dc, timestamp)
-	default:
-		return h.handleDefault(msg, dc, timestamp)
-	}
-}
-
-// handleFollowup handles followup questions
-func (h *AskHandler) handleFollowup(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	var question string
-	var options []string
-
-	var askData types.AskData
-	if err := json.Unmarshal([]byte(msg.Text), &askData); err == nil {
-		question = askData.Question
-		options = askData.Options
-	} else {
-		question = msg.Text
-	}
-
-	if question == "" {
-		return nil
-	}
-
-	err := dc.Renderer.RenderMessage(timestamp, "QUESTION", question)
-	if err != nil {
-		return err
-	}
-
-	// Display options if available
-	if len(options) > 0 {
-		fmt.Println("\nOptions:")
-		for i, option := range options {
-			fmt.Printf("%d. %s\n", i+1, option)
-		}
-	}
-
-	return nil
-}
-
-// handlePlanModeRespond handles plan mode responses
-func (h *AskHandler) handlePlanModeRespond(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	var response string
-	var options []string
-
-	// Try to parse as JSON
-	type PlanModeResponse struct {
-		Response string   `json:"response"`
-		Options  []string `json:"options,omitempty"`
-	}
-
-	var planData PlanModeResponse
-	if err := json.Unmarshal([]byte(msg.Text), &planData); err == nil {
-		response = planData.Response
-		options = planData.Options
-	} else {
-		response = msg.Text
-	}
-
-	if response == "" {
-		return nil
-	}
-
-	err := dc.Renderer.RenderMessage(timestamp, "ASST PLAN", response)
-	if err != nil {
-		return err
-	}
-
-	// Display options if available
-	if len(options) > 0 {
-		fmt.Println("\nOptions:")
-		for i, option := range options {
-			fmt.Printf("%d. %s\n", i+1, option)
-		}
-	}
-
-	return nil
-}
-
-// handleCommand handles command execution requests
-func (h *AskHandler) handleCommand(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	command := msg.Text
-
-	// Check if this command was flagged despite auto-approval settings turned on for safe commands
-	hasAutoApprovalConflict := strings.HasSuffix(command, "REQ_APP")
-	if hasAutoApprovalConflict {
-		command = strings.TrimSuffix(command, "REQ_APP")
-	}
-
-	err := dc.Renderer.RenderMessage(timestamp, "TERMINAL", "Cline wants to execute this command:")
-	if err != nil {
-		return fmt.Errorf("failed to render handleCommand: %w", err)
-	}
-
-	fmt.Printf("\n```shell\n%s\n```\n", strings.TrimSpace(command))
-
-	if hasAutoApprovalConflict {
-		fmt.Printf("\nThe model has determined this command requires explicit approval.\n")
-	} else {
-		fmt.Printf("\nApproval required for this command.\n")
-	}
-
-	return nil
-}
-
-// handleCommandOutput handles command output requests
-func (h *AskHandler) handleCommandOutput(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	commandOutput := msg.Text
-
-	err := dc.Renderer.RenderMessage(timestamp, "TERMINAL", fmt.Sprintf("Current terminal output: %s", commandOutput))
-	if err != nil {
-		return fmt.Errorf("failed to render handleCommandOutput: %w", err)
-	}
-
-	fmt.Printf("\nApprove to proceed while this command runs in the background.\n")
-
-	return nil
-}
-
-// handleCompletionResult handles completion result requests
-func (h *AskHandler) handleCompletionResult(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return nil
-}
-
-// handleTool handles tool execution requests
-func (h *AskHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	// Parse tool message
-	var tool types.ToolMessage
-	if err := json.Unmarshal([]byte(msg.Text), &tool); err != nil {
-		// Fallback to simple display
-		return dc.Renderer.RenderMessage(timestamp, "TOOL", msg.Text)
-	}
-
-	return h.renderToolMessage(&tool, dc, timestamp)
-}
-
-// renderToolMessage renders a tool message with appropriate formatting
-func (h *AskHandler) renderToolMessage(tool *types.ToolMessage, dc *DisplayContext, timestamp string) error {
-	switch tool.Tool {
-	case string(types.ToolTypeEditedExistingFile):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to edit file: %s", tool.Path))
-	case string(types.ToolTypeNewFileCreated):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to create file: %s", tool.Path))
-	case string(types.ToolTypeReadFile):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to read file: %s", tool.Path))
-	case string(types.ToolTypeListFilesTopLevel):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to list files in: %s", tool.Path))
-	case string(types.ToolTypeListFilesRecursive):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to recursively list files in: %s", tool.Path))
-	case string(types.ToolTypeSearchFiles):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to search for '%s' in: %s", tool.Regex, tool.Path))
-	case string(types.ToolTypeWebFetch):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to fetch URL: %s", tool.Path))
-	case string(types.ToolTypeListCodeDefinitionNames):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to list code definitions for: %s", tool.Path))
-	default:
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline wants to use tool: %s", tool.Tool))
-	}
-
-	// Skip content preview for readFile and webFetch tools
-	if tool.Tool == string(types.ToolTypeReadFile) || tool.Tool == string(types.ToolTypeWebFetch) {
-		return nil
-	}
-
-	// Show content preview, truncating if necessary
-	preview := tool.Content
-	if preview != "" {
-		preview = strings.TrimSpace(tool.Content)
-		if len(preview) > 1000 {
-			preview = preview[:1000] + "..."
-		}
-
-		fmt.Printf("Preview: %s\n", preview)
-	}
-
-	fmt.Printf("\nApproval required.\n")
-
-	return nil
-}
-
-// handleAPIReqFailed handles API request failures
-func (h *AskHandler) handleAPIReqFailed(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "ERROR", fmt.Sprintf("API Request Failed: %s. Approve to retry request.", msg.Text))
-}
-
-// handleResumeTask handles resume task requests
-func (h *AskHandler) handleResumeTask(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "GEN INFO", "Resuming interrupted task.")
-}
-
-// handleResumeCompletedTask handles resume completed task requests
-func (h *AskHandler) handleResumeCompletedTask(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "GEN INFO", "Resuming completed task.")
-}
-
-// handleMistakeLimitReached handles mistake limit reached
-func (h *AskHandler) handleMistakeLimitReached(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "ERROR", fmt.Sprintf("Mistake Limit Reached: %s. Approval required.", msg.Text))
-}
-
-// handleAutoApprovalMaxReached handles auto-approval max reached
-func (h *AskHandler) handleAutoApprovalMaxReached(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "WARNING", fmt.Sprintf("Auto-approval limit reached: %s. Approval required.", msg.Text))
-}
-
-// handleBrowserActionLaunch handles browser action launch requests
-func (h *AskHandler) handleBrowserActionLaunch(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	url := strings.TrimSpace(msg.Text)
-	return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Cline wants to launch browser and navigate to: %s. Approval required.", url))
-}
-
-// handleUseMcpServer handles MCP server usage requests
-func (h *AskHandler) handleUseMcpServer(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	// Parse MCP server usage request
-	type McpServerRequest struct {
-		ServerName string `json:"serverName"`
-		Type       string `json:"type"`
-		ToolName   string `json:"toolName,omitempty"`
-		Arguments  string `json:"arguments,omitempty"`
-		URI        string `json:"uri,omitempty"`
-	}
-
-	var mcpReq McpServerRequest
-	if err := json.Unmarshal([]byte(msg.Text), &mcpReq); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "MCP", msg.Text)
-	}
-
-	var operation string
-	if mcpReq.Type == "access_mcp_resource" {
-		operation = "access a resource"
-	} else {
-		operation = fmt.Sprintf("use a tool (%s)", mcpReq.ToolName)
-		if mcpReq.Arguments != "" {
-			operation = fmt.Sprintf("%s with args (%s)", operation, mcpReq.Arguments)
-		}
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, "MCP",
-		fmt.Sprintf("Cline wants to %s on the %s MCP server", operation, mcpReq.ServerName))
-}
-
-// handleNewTask handles new task creation requests
-func (h *AskHandler) handleNewTask(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "NEW TASK", fmt.Sprintf("Cline wants to start a new task: %s. Approval required.", msg.Text))
-}
-
-// handleCondense handles conversation condensing requests
-func (h *AskHandler) handleCondense(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "CONDENSE", fmt.Sprintf("Cline wants to condense the conversation: %s. Approval required.", msg.Text))
-}
-
-// handleReportBug handles bug report requests
-func (h *AskHandler) handleReportBug(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	var bugData struct {
-		Title             string `json:"title"`
-		WhatHappened      string `json:"what_happened"`
-		StepsToReproduce  string `json:"steps_to_reproduce"`
-		APIRequestOutput  string `json:"api_request_output"`
-		AdditionalContext string `json:"additional_context"`
-	}
-
-	if err := json.Unmarshal([]byte(msg.Text), &bugData); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "BUG REPORT", fmt.Sprintf("Cline wants to create a GitHub issue: %s. Approval required.", msg.Text))
-	}
-
-	err := dc.Renderer.RenderMessage(timestamp, "BUG REPORT", "Cline wants to create a GitHub issue:")
-	if err != nil {
-		return fmt.Errorf("failed to render handleReportBug: %w", err)
-	}
-
-	fmt.Printf("\n**Title**: %s\n", bugData.Title)
-	fmt.Printf("**What Happened**: %s\n", bugData.WhatHappened)
-	fmt.Printf("**Steps to Reproduce**: %s\n", bugData.StepsToReproduce)
-	fmt.Printf("**API Request Output**: %s\n", bugData.APIRequestOutput)
-	fmt.Printf("**Additional Context**: %s\n", bugData.AdditionalContext)
-	fmt.Printf("\nApprove to create a GitHub issue.\n")
-
-	return nil
-}
-
-// handleDefault handles unknown ASK message types
-func (h *AskHandler) handleDefault(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "ASK", msg.Text)
-}

cli/pkg/cli/handlers/handler.go

@@ -1,128 +0,0 @@
-package handlers
-
-import (
-	"github.com/cline/cli/pkg/cli/display"
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// MessageHandler defines the interface for handling different message types
-type MessageHandler interface {
-	// CanHandle returns true if this handler can process the given message
-	CanHandle(msg *types.ClineMessage) bool
-
-	// Handle processes the message and renders it using the display context
-	Handle(msg *types.ClineMessage, dc *DisplayContext) error
-
-	// GetPriority returns the priority of this handler (higher = more priority)
-	GetPriority() int
-
-	// GetName returns a human-readable name for this handler
-	GetName() string
-}
-
-// DisplayContext provides context and utilities for message handlers
-type DisplayContext struct {
-	State        *types.ConversationState
-	Renderer     *display.Renderer
-	IsLast       bool
-	IsPartial    bool
-	Verbose      bool
-	MessageIndex int
-}
-
-// BaseHandler provides common functionality for message handlers
-type BaseHandler struct {
-	name     string
-	priority int
-}
-
-// NewBaseHandler creates a new base handler
-func NewBaseHandler(name string, priority int) *BaseHandler {
-	return &BaseHandler{
-		name:     name,
-		priority: priority,
-	}
-}
-
-// GetName returns the handler name
-func (h *BaseHandler) GetName() string {
-	return h.name
-}
-
-// GetPriority returns the handler priority
-func (h *BaseHandler) GetPriority() int {
-	return h.priority
-}
-
-// HandlerRegistry manages a collection of message handlers
-type HandlerRegistry struct {
-	handlers []MessageHandler
-}
-
-// NewHandlerRegistry creates a new handler registry
-func NewHandlerRegistry() *HandlerRegistry {
-	return &HandlerRegistry{
-		handlers: make([]MessageHandler, 0),
-	}
-}
-
-// Register adds a handler to the registry
-func (r *HandlerRegistry) Register(handler MessageHandler) {
-	r.handlers = append(r.handlers, handler)
-
-	// Sort handlers by priority (highest first)
-	for i := len(r.handlers) - 1; i > 0; i-- {
-		if r.handlers[i].GetPriority() > r.handlers[i-1].GetPriority() {
-			r.handlers[i], r.handlers[i-1] = r.handlers[i-1], r.handlers[i]
-		} else {
-			break
-		}
-	}
-}
-
-// Handle finds the appropriate handler and processes the message
-func (r *HandlerRegistry) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
-	for _, handler := range r.handlers {
-		if handler.CanHandle(msg) {
-			return handler.Handle(msg, dc)
-		}
-	}
-
-	// If no specific handler found, use default text handler
-	return r.handleDefault(msg, dc)
-}
-
-// handleDefault provides default handling for unrecognized messages
-func (r *HandlerRegistry) handleDefault(msg *types.ClineMessage, dc *DisplayContext) error {
-	timestamp := msg.GetTimestamp()
-
-	if msg.Text == "" {
-		return nil
-	}
-
-	prefix := "RESPONSE:"
-
-	return dc.Renderer.RenderMessage(timestamp, prefix, msg.Text)
-}
-
-// GetHandlers returns all registered handlers
-func (r *HandlerRegistry) GetHandlers() []MessageHandler {
-	return r.handlers
-}
-
-// GetHandlerByName finds a handler by name
-func (r *HandlerRegistry) GetHandlerByName(name string) MessageHandler {
-	for _, handler := range r.handlers {
-		if handler.GetName() == name {
-			return handler
-		}
-	}
-	return nil
-}
-
-// HandlerPriorities defines standard priority levels for handlers
-const (
-	PriorityHigh   = 100
-	PriorityNormal = 50
-	PriorityLow    = 10
-)

cli/pkg/cli/handlers/say_handlers.go

@@ -1,418 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// SayHandler handles SAY type messages
-type SayHandler struct {
-	*BaseHandler
-}
-
-// NewSayHandler creates a new SAY handler
-func NewSayHandler() *SayHandler {
-	return &SayHandler{
-		BaseHandler: NewBaseHandler("say", PriorityNormal),
-	}
-}
-
-// CanHandle returns true if this is a SAY message
-func (h *SayHandler) CanHandle(msg *types.ClineMessage) bool {
-	return msg.IsSay()
-}
-
-// Handle processes SAY messages
-func (h *SayHandler) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
-	timestamp := msg.GetTimestamp()
-
-	switch msg.Say {
-	case string(types.SayTypeTask):
-		return h.handleTask(msg, dc, timestamp)
-	case string(types.SayTypeError):
-		return h.handleError(msg, dc, timestamp)
-	case string(types.SayTypeAPIReqStarted):
-		return h.handleAPIReqStarted(msg, dc, timestamp)
-	case string(types.SayTypeAPIReqFinished):
-		return h.handleAPIReqFinished(msg, dc, timestamp)
-	case string(types.SayTypeText):
-		return h.handleText(msg, dc, timestamp)
-	case string(types.SayTypeReasoning):
-		return h.handleReasoning(msg, dc, timestamp)
-	case string(types.SayTypeCompletionResult):
-		return h.handleCompletionResult(msg, dc, timestamp)
-	case string(types.SayTypeUserFeedback):
-		return h.handleUserFeedback(msg, dc, timestamp)
-	case string(types.SayTypeUserFeedbackDiff):
-		return h.handleUserFeedbackDiff(msg, dc, timestamp)
-	case string(types.SayTypeAPIReqRetried):
-		return h.handleAPIReqRetried(msg, dc, timestamp)
-	case string(types.SayTypeCommand):
-		return h.handleCommand(msg, dc, timestamp)
-	case string(types.SayTypeCommandOutput):
-		return h.handleCommandOutput(msg, dc, timestamp)
-	case string(types.SayTypeTool):
-		return h.handleTool(msg, dc, timestamp)
-	case string(types.SayTypeShellIntegrationWarning):
-		return h.handleShellIntegrationWarning(msg, dc, timestamp)
-	case string(types.SayTypeBrowserActionLaunch):
-		return h.handleBrowserActionLaunch(msg, dc, timestamp)
-	case string(types.SayTypeBrowserAction):
-		return h.handleBrowserAction(msg, dc, timestamp)
-	case string(types.SayTypeBrowserActionResult):
-		return h.handleBrowserActionResult(msg, dc, timestamp)
-	case string(types.SayTypeMcpServerRequestStarted):
-		return h.handleMcpServerRequestStarted(msg, dc, timestamp)
-	case string(types.SayTypeMcpServerResponse):
-		return h.handleMcpServerResponse(msg, dc, timestamp)
-	case string(types.SayTypeMcpNotification):
-		return h.handleMcpNotification(msg, dc, timestamp)
-	case string(types.SayTypeUseMcpServer):
-		return h.handleUseMcpServer(msg, dc, timestamp)
-	case string(types.SayTypeDiffError):
-		return h.handleDiffError(msg, dc, timestamp)
-	case string(types.SayTypeDeletedAPIReqs):
-		return h.handleDeletedAPIReqs(msg, dc, timestamp)
-	case string(types.SayTypeClineignoreError):
-		return h.handleClineignoreError(msg, dc, timestamp)
-	case string(types.SayTypeCheckpointCreated):
-		return h.handleCheckpointCreated(msg, dc, timestamp)
-	case string(types.SayTypeLoadMcpDocumentation):
-		return h.handleLoadMcpDocumentation(msg, dc, timestamp)
-	case string(types.SayTypeInfo):
-		return h.handleInfo(msg, dc, timestamp)
-	case string(types.SayTypeTaskProgress):
-		return h.handleTaskProgress(msg, dc, timestamp)
-	default:
-		return h.handleDefault(msg, dc, timestamp)
-	}
-}
-
-// handleTask handles task messages
-func (h *SayHandler) handleTask(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return nil
-}
-
-// handleError handles error messages
-func (h *SayHandler) handleError(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "ERROR", msg.Text)
-}
-
-// handleAPIReqStarted handles API request started messages
-func (h *SayHandler) handleAPIReqStarted(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	// Parse API request info
-	apiInfo := types.APIRequestInfo{Cost: -1}
-	if err := json.Unmarshal([]byte(msg.Text), &apiInfo); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "API INFO", msg.Text)
-	}
-
-	// Handle different API request states
-	if apiInfo.CancelReason != "" {
-		if apiInfo.CancelReason == "user_cancelled" {
-			return dc.Renderer.RenderMessage(timestamp, "API INFO", "Request Cancelled")
-		} else if apiInfo.CancelReason == "retries_exhausted" {
-			return dc.Renderer.RenderMessage(timestamp, "API INFO", "Request Failed (Retries Exhausted)")
-		}
-		return dc.Renderer.RenderMessage(timestamp, "API INFO", "Streaming Failed")
-	}
-
-	if apiInfo.Cost >= 0 {
-		return dc.Renderer.RenderAPI(timestamp, "Request completed", &apiInfo)
-	}
-
-	// Check for retry status
-	if apiInfo.RetryStatus != nil {
-		return dc.Renderer.RenderRetry(timestamp,
-			apiInfo.RetryStatus.Attempt,
-			apiInfo.RetryStatus.MaxAttempts,
-			apiInfo.RetryStatus.DelaySec)
-	}
-
-	return dc.Renderer.RenderAPI(timestamp, "Processing request", &apiInfo)
-}
-
-// handleAPIReqFinished handles API request finished messages
-func (h *SayHandler) handleAPIReqFinished(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	// This message type is typically not displayed as it's handled by the started message
-	return nil
-}
-
-// handleText handles regular text messages
-func (h *SayHandler) handleText(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	// Special case for the user's task input
-	prefix := "ASST TEXT"
-	if dc.MessageIndex == 0 {
-		prefix = "USER"
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, prefix, msg.Text)
-}
-
-// handleReasoning handles reasoning messages
-func (h *SayHandler) handleReasoning(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, "THINKING", msg.Text)
-}
-
-func (h *SayHandler) handleCompletionResult(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	text := msg.Text
-
-	if strings.HasSuffix(text, "HAS_CHANGES") {
-		text = strings.TrimSuffix(text, "HAS_CHANGES")
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, "RESULT", text)
-}
-
-// handleUserFeedback handles user feedback messages
-func (h *SayHandler) handleUserFeedback(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text != "" {
-		return dc.Renderer.RenderMessage(timestamp, "USER", msg.Text)
-	} else {
-		return dc.Renderer.RenderMessage(timestamp, "USER", "[Provided feedback without text]")
-	}
-}
-
-// handleUserFeedbackDiff handles user feedback diff messages
-func (h *SayHandler) handleUserFeedbackDiff(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	var toolMsg types.ToolMessage
-	if err := json.Unmarshal([]byte(msg.Text), &toolMsg); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "USER DIFF", msg.Text)
-	}
-
-	message := fmt.Sprintf("User manually edited: %s\n\nDiff:\n%s",
-		toolMsg.Path,
-		toolMsg.Diff)
-
-	return dc.Renderer.RenderMessage(timestamp, "USER DIFF", message)
-}
-
-// handleAPIReqRetried handles API request retry messages
-func (h *SayHandler) handleAPIReqRetried(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "API INFO", "Retrying request")
-}
-
-// handleCommand handles command execution announcements
-func (h *SayHandler) handleCommand(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	command := strings.TrimSpace(msg.Text)
-
-	err := dc.Renderer.RenderMessage(timestamp, "TERMINAL", "Running command:")
-	if err != nil {
-		return fmt.Errorf("failed to render handleCommand: %w", err)
-	}
-
-	fmt.Printf("\n```shell\n%s\n```\n", command)
-
-	return nil
-}
-
-// handleCommandOutput handles command output messages
-func (h *SayHandler) handleCommandOutput(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	commandOutput := msg.Text
-	return dc.Renderer.RenderMessage(timestamp, "TERMINAL", fmt.Sprintf("Current terminal output: %s", commandOutput))
-}
-
-func (h *SayHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	var tool types.ToolMessage
-	if err := json.Unmarshal([]byte(msg.Text), &tool); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "TOOL", msg.Text)
-	}
-
-	return h.renderToolMessage(&tool, dc, timestamp)
-}
-
-func (h *SayHandler) renderToolMessage(tool *types.ToolMessage, dc *DisplayContext, timestamp string) error {
-	switch tool.Tool {
-	case string(types.ToolTypeEditedExistingFile):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline edited file: %s", tool.Path))
-	case string(types.ToolTypeNewFileCreated):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline created file: %s", tool.Path))
-	case string(types.ToolTypeReadFile):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline read file: %s", tool.Path))
-	case string(types.ToolTypeListFilesTopLevel):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline listed files in: %s", tool.Path))
-	case string(types.ToolTypeListFilesRecursive):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline recursively listed files in: %s", tool.Path))
-	case string(types.ToolTypeSearchFiles):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline searched for '%s' in: %s", tool.Regex, tool.Path))
-	case string(types.ToolTypeWebFetch):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline fetched URL: %s", tool.Path))
-	case string(types.ToolTypeListCodeDefinitionNames):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline listed code definitions for: %s", tool.Path))
-	case string(types.ToolTypeSummarizeTask):
-		dc.Renderer.RenderMessage(timestamp, "TOOL", "Cline condensed the conversation")
-	default:
-		dc.Renderer.RenderMessage(timestamp, "TOOL", fmt.Sprintf("Cline executed tool: %s", tool.Tool))
-	}
-
-	// Skip content preview for readFile and webFetch tools
-	if tool.Tool == string(types.ToolTypeReadFile) || tool.Tool == string(types.ToolTypeWebFetch) {
-		return nil
-	}
-
-	// Show content preview, truncating if necessary
-	preview := tool.Content
-	if preview != "" {
-		preview = strings.TrimSpace(tool.Content)
-		if len(preview) > 1000 {
-			preview = preview[:1000] + "..."
-		}
-		fmt.Printf("Content: %s\n", preview)
-	}
-
-	return nil
-}
-
-// handleShellIntegrationWarning handles shell integration warning messages
-func (h *SayHandler) handleShellIntegrationWarning(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "WARNING", "Shell Integration Unavailable - Cline won't be able to view the command's output.")
-}
-
-// handleBrowserActionLaunch handles browser action launch messages
-func (h *SayHandler) handleBrowserActionLaunch(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	url := msg.Text
-	if url == "" {
-		return nil
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Launching browser at: %s", url))
-}
-
-// handleBrowserAction handles browser action messages
-func (h *SayHandler) handleBrowserAction(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	type BrowserActionData struct {
-		Action     string `json:"action"`
-		Coordinate string `json:"coordinate,omitempty"`
-		Text       string `json:"text,omitempty"`
-	}
-
-	var actionData BrowserActionData
-	if err := json.Unmarshal([]byte(msg.Text), &actionData); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "BROWSER", msg.Text)
-	}
-
-	// Special handling for type action
-	if actionData.Action == "type" && actionData.Text != "" {
-		actionText := fmt.Sprintf("type '%s'", actionData.Text)
-		return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Next action: %s", actionText))
-	}
-
-	// Special handling for click action
-	if actionData.Action == "click" && actionData.Coordinate != "" {
-		actionText := fmt.Sprintf("click (%s)", actionData.Coordinate)
-		return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Next action: %s", actionText))
-	}
-
-	// Generic handling for all other actions
-	return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Next action: %s", actionData.Action))
-}
-
-// handleBrowserActionResult handles browser action result messages
-func (h *SayHandler) handleBrowserActionResult(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	type BrowserActionResult struct {
-		Screenshot           string `json:"screenshot,omitempty"`
-		Logs                 string `json:"logs,omitempty"`
-		CurrentUrl           string `json:"currentUrl,omitempty"`
-		CurrentMousePosition string `json:"currentMousePosition,omitempty"`
-	}
-
-	var result BrowserActionResult
-	if err := json.Unmarshal([]byte(msg.Text), &result); err != nil {
-		return dc.Renderer.RenderMessage(timestamp, "BROWSER", "Action completed")
-	}
-
-	// If we have logs, include them in the message
-	if result.Logs != "" {
-		return dc.Renderer.RenderMessage(timestamp, "BROWSER", fmt.Sprintf("Action completed with logs: '%s'", result.Logs))
-	}
-
-	// Default case
-	return dc.Renderer.RenderMessage(timestamp, "BROWSER", "Action completed")
-}
-
-// handleMcpServerRequestStarted handles MCP server request started messages
-func (h *SayHandler) handleMcpServerRequestStarted(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "MCP", "Sending request to server")
-}
-
-// handleMcpServerResponse handles MCP server response messages
-func (h *SayHandler) handleMcpServerResponse(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "MCP", fmt.Sprintf("Server response: %s", msg.Text))
-}
-
-// handleMcpNotification handles MCP notification messages
-func (h *SayHandler) handleMcpNotification(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "MCP", fmt.Sprintf("Server notification: %s", msg.Text))
-}
-
-// handleUseMcpServer handles MCP server usage messages
-func (h *SayHandler) handleUseMcpServer(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "MCP", "Server operation approved")
-}
-
-// handleDiffError handles diff error messages
-func (h *SayHandler) handleDiffError(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "WARNING", "Diff Edit Failure - The model used an invalid diff edit format or used search patterns that don't match anything in the file.")
-}
-
-// handleDeletedAPIReqs handles deleted API requests messages
-func (h *SayHandler) handleDeletedAPIReqs(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	// This message includes api metrics of deleted messages, which we do not log
-	return dc.Renderer.RenderMessage(timestamp, "GEN INFO", "Checkpoint restored")
-}
-
-// handleClineignoreError handles .clineignore error messages
-func (h *SayHandler) handleClineignoreError(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "WARNING", fmt.Sprintf("Access Denied - Cline tried to access %s which is blocked by the .clineignore file", msg.Text))
-}
-
-// handleCheckpointCreated handles checkpoint created messages
-func (h *SayHandler) handleCheckpointCreated(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "GEN INFO", "Checkpoint created")
-}
-
-// handleLoadMcpDocumentation handles load MCP documentation messages
-func (h *SayHandler) handleLoadMcpDocumentation(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "GEN INFO", "Loading MCP documentation")
-}
-
-// handleInfo handles info messages
-func (h *SayHandler) handleInfo(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return nil
-}
-
-// handleTaskProgress handles task progress messages
-func (h *SayHandler) handleTaskProgress(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	if msg.Text == "" {
-		return nil
-	}
-
-	return dc.Renderer.RenderMessage(timestamp, "PROGRESS", fmt.Sprintf("Task Checklist: %s", msg.Text))
-}
-
-// handleDefault handles unknown SAY message types
-func (h *SayHandler) handleDefault(msg *types.ClineMessage, dc *DisplayContext, timestamp string) error {
-	return dc.Renderer.RenderMessage(timestamp, "SAY", msg.Text)
-}

cli/pkg/cli/instances.go

@@ -1,388 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"syscall"
-	"text/tabwriter"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/grpc-go/cline"
-	"github.com/spf13/cobra"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-func NewInstanceCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "instance",
-		Aliases: []string{"i"},
-		Short:   "Manage Cline instances",
-		Long:    `List and manage multiple Cline instances similar to kubectl contexts.`,
-	}
-
-	cmd.AddCommand(newInstanceListCommand())
-	cmd.AddCommand(newInstanceUseCommand())
-	cmd.AddCommand(newInstanceNewCommand())
-	cmd.AddCommand(newInstanceKillCommand())
-
-	return cmd
-}
-
-func newInstanceKillCommand() *cobra.Command {
-	var killAll bool
-
-	cmd := &cobra.Command{
-		Use:     "kill <address>",
-		Aliases: []string{"k"},
-		Short:   "Kill a Cline instance by address",
-		Long:    `Kill a running Cline instance and clean up its registry entry.`,
-		Args: func(cmd *cobra.Command, args []string) error {
-			if killAll && len(args) > 0 {
-				return fmt.Errorf("cannot specify both --all flag and address argument")
-			}
-			if !killAll && len(args) != 1 {
-				return fmt.Errorf("requires exactly one address argument when --all is not specified")
-			}
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if global.Clients == nil {
-				return fmt.Errorf("clients not initialized")
-			}
-
-			ctx := cmd.Context()
-			registry := global.Clients.GetRegistry()
-
-			if killAll {
-				return killAllInstances(ctx, registry)
-			} else {
-				return killSingleInstance(ctx, registry, args[0])
-			}
-		},
-	}
-
-	cmd.Flags().BoolVar(&killAll, "all", false, "kill all running instances")
-
-	return cmd
-}
-
-func killSingleInstance(ctx context.Context, registry *global.ClientRegistry, address string) error {
-	// Check if the instance exists in the registry
-	_, err := registry.GetInstance(address)
-	if err != nil {
-		return fmt.Errorf("instance %s not found in registry", address)
-	}
-
-	fmt.Printf("Killing instance: %s\n", address)
-
-	// Get gRPC client and process info
-	client, err := registry.GetClient(ctx, address)
-	if err != nil {
-		return fmt.Errorf("failed to connect to instance %s: %w", address, err)
-	}
-
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get process info for instance %s: %w", address, err)
-	}
-
-	pid := int(processInfo.ProcessId)
-	fmt.Printf("Terminating process PID %d...\n", pid)
-
-	// Kill the process
-	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-		return fmt.Errorf("failed to kill process %d: %w", pid, err)
-	}
-
-	// Wait for the instance to remove itself from registry
-	fmt.Printf("Waiting for instance to clean up registry entry...\n")
-	for i := 0; i < 5; i++ {
-		time.Sleep(1 * time.Second)
-		if !registry.HasInstanceAtAddress(address) {
-			fmt.Printf("Instance %s successfully killed and removed from registry.\n", address)
-
-			// Update default instance if needed
-			instances, err := registry.ListInstancesCleaned(ctx)
-			if err == nil && len(instances) > 0 {
-				// ensureDefaultInstance logic will handle setting a new default
-				defaultInstance := registry.GetDefaultInstance()
-				if defaultInstance == address || defaultInstance == "" {
-					if len(instances) > 0 {
-						if err := registry.SetDefaultInstance(instances[0].Address); err == nil {
-							fmt.Printf("Updated default instance to: %s\n", instances[0].Address)
-						}
-					}
-				}
-			}
-
-			return nil
-		}
-	}
-
-	return fmt.Errorf("instance killed but failed to remove itself from registry within 5 seconds")
-}
-
-func killAllInstances(ctx context.Context, registry *global.ClientRegistry) error {
-	// Get all instances from registry
-	instances, err := registry.ListInstancesCleaned(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to list instances: %w", err)
-	}
-
-	if len(instances) == 0 {
-		fmt.Println("No Cline instances found to kill.")
-		return nil
-	}
-
-	fmt.Printf("Killing %d instances...\n", len(instances))
-
-	var killResults []killResult
-
-	// Kill all instances
-	for _, instance := range instances {
-		result := killInstanceProcess(ctx, registry, instance.Address)
-		killResults = append(killResults, result)
-
-		if result.err != nil {
-			fmt.Printf("✗ Failed to kill %s: %v\n", instance.Address, result.err)
-		} else if result.alreadyDead {
-			fmt.Printf("⚠ Instance %s appears to be already dead\n", instance.Address)
-		} else {
-			fmt.Printf("✓ Killed %s (PID %d)\n", instance.Address, result.pid)
-		}
-	}
-
-	// Wait for all instances to clean up their registry entries
-	fmt.Printf("Waiting for instances to clean up registry entries...\n")
-
-	maxWaitTime := 10 // seconds
-	for i := 0; i < maxWaitTime; i++ {
-		time.Sleep(1 * time.Second)
-
-		remainingInstances, err := registry.ListInstancesCleaned(ctx)
-		if err != nil {
-			fmt.Printf("Warning: failed to check registry status: %v\n", err)
-			continue
-		}
-
-		if len(remainingInstances) == 0 {
-			fmt.Printf("✓ All instances successfully removed from registry.\n")
-			break
-		}
-
-		if i == maxWaitTime-1 {
-			fmt.Printf("⚠ %d instances still in registry after %d seconds\n", len(remainingInstances), maxWaitTime)
-			for _, remaining := range remainingInstances {
-				fmt.Printf("  - %s\n", remaining.Address)
-			}
-		}
-	}
-
-	// Print summary
-	successful := 0
-	failed := 0
-	alreadyDead := 0
-
-	for _, result := range killResults {
-		if result.err != nil {
-			failed++
-		} else if result.alreadyDead {
-			alreadyDead++
-		} else {
-			successful++
-		}
-	}
-
-	fmt.Printf("\nSummary: ")
-	if successful > 0 {
-		fmt.Printf("Successfully killed %d instances. ", successful)
-	}
-	if alreadyDead > 0 {
-		fmt.Printf("%d were already dead. ", alreadyDead)
-	}
-	if failed > 0 {
-		fmt.Printf("%d failures.", failed)
-		return fmt.Errorf("failed to kill %d out of %d instances", failed, len(instances))
-	}
-	fmt.Println()
-
-	return nil
-}
-
-type killResult struct {
-	address     string
-	pid         int
-	alreadyDead bool
-	err         error
-}
-
-func killInstanceProcess(ctx context.Context, registry *global.ClientRegistry, address string) killResult {
-	// Get gRPC client and process info
-	client, err := registry.GetClient(ctx, address)
-	if err != nil {
-		return killResult{address: address, alreadyDead: true, err: nil}
-	}
-
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return killResult{address: address, alreadyDead: true, err: nil}
-	}
-
-	pid := int(processInfo.ProcessId)
-
-	// Kill the process
-	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-		return killResult{address: address, pid: pid, err: err}
-	}
-
-	return killResult{address: address, pid: pid, err: nil}
-}
-
-func newInstanceListCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"l"},
-		Short:   "List all registered Cline instances",
-		Long:    `List all registered Cline instances with their status and connection details.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if global.Clients == nil {
-				return fmt.Errorf("clients not initialized")
-			}
-
-			ctx := cmd.Context()
-			registry := global.Clients.GetRegistry()
-
-			// Load, cleanup stale local entries, and update health
-			instances, err := registry.ListInstancesCleaned(ctx)
-			if err != nil {
-				return fmt.Errorf("failed to list instances: %w", err)
-			}
-			defaultInstance := registry.GetDefaultInstance()
-
-			if len(instances) == 0 {
-				fmt.Println("No Cline instances found.")
-				fmt.Println("Run 'cline instance new' to start a new instance, or 'cline task new \"...\"' to auto-start one.")
-				return nil
-			}
-
-			// Always output a table
-			w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-			fmt.Fprintln(w, "ADDRESS\tSTATUS\tVERSION\tLAST SEEN\tPID\tDEFAULT")
-
-			for _, instance := range instances {
-				isDefault := ""
-				if instance.Address == defaultInstance {
-					isDefault = "*"
-				}
-
-				lastSeen := instance.LastSeen.Format("15:04:05")
-				if time.Since(instance.LastSeen) > 24*time.Hour {
-					lastSeen = instance.LastSeen.Format("2006-01-02")
-				}
-
-				// Get PID via RPC if instance is healthy
-				pid := "N/A"
-				if instance.Status == grpc_health_v1.HealthCheckResponse_SERVING {
-					if client, err := registry.GetClient(ctx, instance.Address); err == nil {
-						if processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{}); err == nil {
-							pid = fmt.Sprintf("%d", processInfo.ProcessId)
-							// Update version from RPC if available
-							if processInfo.Version != nil && *processInfo.Version != "" && *processInfo.Version != "unknown" {
-								instance.Version = *processInfo.Version
-							}
-						}
-					}
-				}
-
-				fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n",
-					instance.Address,
-					instance.Status,
-					instance.Version,
-					lastSeen,
-					pid,
-					isDefault,
-				)
-			}
-
-			w.Flush()
-			return nil
-		},
-	}
-
-	return cmd
-}
-
-func newInstanceUseCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "use <address>",
-		Aliases: []string{"u"},
-		Short:   "Set the default Cline instance",
-		Long:    `Set the default Cline instance to use for subsequent commands.`,
-		Args:    cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			address := args[0]
-
-			if global.Clients == nil {
-				return fmt.Errorf("clients not initialized")
-			}
-
-			registry := global.Clients.GetRegistry()
-
-			// Verify the instance exists
-			_, err := registry.GetInstance(address)
-			if err != nil {
-				return fmt.Errorf("instance %s not found. Run 'cline instance list' to see available instances", address)
-			}
-
-			// Set as default
-			if err := registry.SetDefaultInstance(address); err != nil {
-				return fmt.Errorf("failed to set default instance: %w", err)
-			}
-
-			fmt.Printf("Switched to instance: %s\n", address)
-			return nil
-		},
-	}
-
-	return cmd
-}
-
-func newInstanceNewCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "new",
-		Aliases: []string{"n"},
-		Short:   "Create a new Cline instance",
-		Long:    `Create a new Cline instance with automatically assigned ports.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			if global.Clients == nil {
-				return fmt.Errorf("clients not initialized")
-			}
-
-			fmt.Println("Starting new Cline instance...")
-
-			instance, err := global.Clients.StartNewInstance(ctx)
-			if err != nil {
-				return fmt.Errorf("failed to start instance: %w", err)
-			}
-
-			fmt.Printf("Successfully started new instance:\n")
-			fmt.Printf("  Address: %s\n", instance.Address)
-			fmt.Printf("  Core Port: %d\n", instance.CorePort())
-			fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
-
-			// Check if this is now the default instance
-			registry := global.Clients.GetRegistry()
-			if registry.GetDefaultInstance() == instance.Address {
-				fmt.Printf("  Status: Default instance\n")
-			}
-
-			return nil
-		},
-	}
-
-	return cmd
-}

cli/pkg/cli/sqlite/locks.go

@@ -1,366 +0,0 @@
-package sqlite
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"net"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/cline/cli/pkg/common"
-	_ "github.com/mattn/go-sqlite3"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// normalizeAddressVariants returns address variants to try when querying SQLite.
-// Handles localhost/127.0.0.1 equivalence by returning both forms.
-func normalizeAddressVariants(address string) []string {
-	variants := []string{address}
-	
-	// Extract host and port
-	host, port, err := net.SplitHostPort(address)
-	if err != nil {
-		return variants
-	}
-	
-	// Add the alternate form for localhost/127.0.0.1
-	if host == "localhost" {
-		variants = append(variants, net.JoinHostPort("127.0.0.1", port))
-	} else if host == "127.0.0.1" {
-		variants = append(variants, net.JoinHostPort("localhost", port))
-	}
-	
-	return variants
-}
-
-// LockManager provides access to the SQLite locks database
-type LockManager struct {
-	dbPath string
-	db     *sql.DB
-}
-
-// NewLockManager creates a new lock manager
-func NewLockManager(clineDir string) (*LockManager, error) {
-	dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-
-	// Ensure the directory exists (for future DB creation by cline-core)
-	dbDir := filepath.Dir(dbPath)
-	if err := os.MkdirAll(dbDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create database directory: %w", err)
-	}
-
-	// Check if database exists
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		// Database doesn't exist - return manager with nil db
-		// All methods already handle this gracefully!
-		return &LockManager{dbPath: dbPath, db: nil}, nil
-	}
-
-	// Database exists - open it normally (no schema creation)
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		// If we can't open existing database, return nil db manager
-		return &LockManager{dbPath: dbPath, db: nil}, nil
-	}
-
-	// Test the connection
-	if err := db.Ping(); err != nil {
-		db.Close()
-		// If connection fails, return nil db manager
-		return &LockManager{dbPath: dbPath, db: nil}, nil
-	}
-
-	return &LockManager{
-		dbPath: dbPath,
-		db:     db,
-	}, nil
-}
-
-// ensureConnection attempts to establish a database connection if one doesn't exist
-func (lm *LockManager) ensureConnection() error {
-	// If we already have a connection, we're done
-	if lm.db != nil {
-		return nil
-	}
-
-	// Check if database exists now (created by cline-core)
-	if _, err := os.Stat(lm.dbPath); os.IsNotExist(err) {
-		return fmt.Errorf("database not available")
-	}
-
-	// Database exists, try to connect
-	db, err := sql.Open("sqlite3", lm.dbPath)
-	if err != nil {
-		return fmt.Errorf("failed to connect to database: %w", err)
-	}
-
-	if err := db.Ping(); err != nil {
-		db.Close()
-		return fmt.Errorf("database connection failed: %w", err)
-	}
-
-	// Success! Update our connection permanently
-	lm.db = db
-	return nil
-}
-
-// Close closes the database connection
-func (lm *LockManager) Close() error {
-	if lm.db != nil {
-		return lm.db.Close()
-	}
-	return nil
-}
-
-// GetInstanceLocks returns all instance locks
-func (lm *LockManager) GetInstanceLocks() ([]common.LockRow, error) {
-	if err := lm.ensureConnection(); err != nil {
-		return []common.LockRow{}, nil
-	}
-
-	query := common.SelectInstanceLocksSQL
-
-	rows, err := lm.db.Query(query)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query instance locks: %w", err)
-	}
-	defer rows.Close()
-
-	var locks []common.LockRow
-	for rows.Next() {
-		var lock common.LockRow
-		err := rows.Scan(&lock.ID, &lock.HeldBy, &lock.LockType, &lock.LockTarget, &lock.LockedAt)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan lock row: %w", err)
-		}
-		locks = append(locks, lock)
-	}
-
-	return locks, nil
-}
-
-// RemoveInstanceLock removes an instance lock by address
-func (lm *LockManager) RemoveInstanceLock(address string) error {
-	if err := lm.ensureConnection(); err != nil {
-		return nil // Gracefully handle missing database for cleanup operations
-	}
-
-	query := common.DeleteInstanceLockSQL
-	_, err := lm.db.Exec(query, address)
-	if err != nil {
-		return fmt.Errorf("failed to remove instance lock: %w", err)
-	}
-
-	return nil
-}
-
-// HasInstanceAtAddress checks if an instance exists at the given address
-func (lm *LockManager) HasInstanceAtAddress(address string) (bool, error) {
-	if err := lm.ensureConnection(); err != nil {
-		return false, nil
-	}
-
-	query := common.CountInstanceLockSQL
-	var count int
-	err := lm.db.QueryRow(query, address).Scan(&count)
-	if err != nil {
-		return false, fmt.Errorf("failed to check instance existence: %w", err)
-	}
-
-	return count > 0, nil
-}
-
-// GetInstanceInfo returns instance information directly from SQLite.
-// Handles localhost/127.0.0.1 equivalence by trying both variants.
-func (lm *LockManager) GetInstanceInfo(address string) (*common.CoreInstanceInfo, error) {
-	if err := lm.ensureConnection(); err != nil {
-		return nil, err
-	}
-
-	query := common.SelectInstanceLockByHolderSQL
-	variants := normalizeAddressVariants(address)
-	
-	var heldBy, lockTarget string
-	var lockedAt int64
-	var lastErr error
-
-	// Try each address variant (e.g., localhost:50607 and 127.0.0.1:50607)
-	for _, variant := range variants {
-		err := lm.db.QueryRow(query, variant).Scan(&heldBy, &lockTarget, &lockedAt)
-		if err == nil {
-			// Found it!
-			return &common.CoreInstanceInfo{
-				Address:            heldBy,
-				HostServiceAddress: lockTarget,
-				Status:             grpc_health_v1.HealthCheckResponse_UNKNOWN,
-				LastSeen:           time.Unix(lockedAt/1000, 0),
-			}, nil
-		}
-		if err != sql.ErrNoRows {
-			// Real error (not just "not found"), save it
-			lastErr = err
-		}
-	}
-	
-	// None of the variants were found
-	if lastErr != nil {
-		return nil, fmt.Errorf("failed to query instance: %w", lastErr)
-	}
-	return nil, fmt.Errorf("instance %s not found", address)
-}
-
-// ListInstancesWithHealthCheck returns all instances with real-time health checks
-func (lm *LockManager) ListInstancesWithHealthCheck(ctx context.Context) ([]*common.CoreInstanceInfo, error) {
-	if err := lm.ensureConnection(); err != nil {
-		return []*common.CoreInstanceInfo{}, nil
-	}
-
-	// Get all instance locks
-	locks, err := lm.GetInstanceLocks()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get instance locks: %w", err)
-	}
-
-	var instances []*common.CoreInstanceInfo
-
-	for _, lock := range locks {
-		// Create instance info using actual SQLite data
-		status, err := common.PerformHealthCheck(ctx, lock.HeldBy)
-		if status != grpc_health_v1.HealthCheckResponse_SERVING || err != nil {
-			time.Sleep(1 * time.Second)
-			status, err = common.PerformHealthCheck(ctx, lock.HeldBy)
-		}
-
-		info := &common.CoreInstanceInfo{
-			Address:            lock.HeldBy,
-			HostServiceAddress: lock.LockTarget,
-			Status:             status,
-			LastSeen:           time.Unix(lock.LockedAt/1000, 0),
-		}
-
-		instances = append(instances, info)
-	}
-
-	return instances, nil
-}
-
-// GetDefaultInstance reads the default instance from the settings file
-func GetDefaultInstance(clineDir string) (string, error) {
-	settingsPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-
-	data, err := os.ReadFile(settingsPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return "", nil
-		}
-		return "", fmt.Errorf("failed to read default instance file: %w", err)
-	}
-
-	var defaultInstance common.DefaultCoreInstance
-	if err := json.Unmarshal(data, &defaultInstance); err != nil {
-		return "", fmt.Errorf("failed to parse default instance JSON: %w", err)
-	}
-
-	if defaultInstance.Address == "" {
-		return "", fmt.Errorf("default instance not set in settings file")
-	}
-
-	return defaultInstance.Address, nil
-}
-
-// SetDefaultInstance writes the default instance to the settings file with proper locking
-func SetDefaultInstance(clineDir, address string) error {
-	// Create lock manager for this operation
-	lockManager, err := NewLockManager(clineDir)
-	if err != nil {
-		return fmt.Errorf("Warning: SQLite unavailable, writing without lock: %v\n", err)
-	}
-	defer lockManager.Close()
-
-	settingsPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-
-	// Generate a unique identifier for this CLI process
-	heldBy := fmt.Sprintf("cli-process-%d", os.Getpid())
-
-	// Use file lock for the write operation
-	return lockManager.WithFileLock(settingsPath, heldBy, func() error {
-		return writeDefaultInstanceJSONToDisk(clineDir, address)
-	})
-}
-
-func writeDefaultInstanceJSONToDisk(clineDir, address string) error {
-	settingsDir := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings")
-	if err := os.MkdirAll(settingsDir, 0755); err != nil {
-		return fmt.Errorf("failed to create settings directory: %w", err)
-	}
-
-	settingsPath := filepath.Join(settingsDir, "cli-default-instance.json")
-
-	payload := common.DefaultCoreInstance{
-		Address:     address,
-		LastUpdated: time.Now().Format(time.RFC3339),
-	}
-
-	data, err := json.MarshalIndent(payload, "", "  ")
-	if err != nil {
-		return fmt.Errorf("failed to marshal default instance JSON: %w", err)
-	}
-
-	if err := os.WriteFile(settingsPath, data, 0644); err != nil {
-		return fmt.Errorf("failed to write default instance file: %w", err)
-	}
-
-	return nil
-}
-
-// AcquireFileLock attempts to acquire a file lock
-func (lm *LockManager) AcquireFileLock(filePath, heldBy string) error {
-	if err := lm.ensureConnection(); err != nil {
-		return err
-	}
-
-	now := time.Now().Unix() * 1000 // Convert to milliseconds
-
-	query := common.InsertFileLockSQL
-
-	_, err := lm.db.Exec(query, heldBy, filePath, now)
-	if err != nil {
-		return fmt.Errorf("failed to acquire file lock for %s: %w", filePath, err)
-	}
-
-	return nil
-}
-
-// ReleaseFileLock releases a file lock
-func (lm *LockManager) ReleaseFileLock(filePath, heldBy string) error {
-	if lm.db == nil {
-		return nil
-	}
-
-	query := common.DeleteFileLockSQL
-
-	_, err := lm.db.Exec(query, heldBy, filePath)
-	if err != nil {
-		return fmt.Errorf("failed to release file lock for %s: %w", filePath, err)
-	}
-
-	return nil
-}
-
-// WithFileLock executes a function while holding a file lock
-func (lm *LockManager) WithFileLock(filePath, heldBy string, fn func() error) error {
-	if err := lm.AcquireFileLock(filePath, heldBy); err != nil {
-		return err
-	}
-
-	defer func() {
-		if releaseErr := lm.ReleaseFileLock(filePath, heldBy); releaseErr != nil {
-			fmt.Printf("Warning: Failed to release file lock for %s: %v\n", filePath, releaseErr)
-		}
-	}()
-
-	return fn()
-}

cli/pkg/cli/task.go

@@ -1,444 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/spf13/cobra"
-)
-
-func NewTaskCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "task",
-		Aliases: []string{"t"},
-		Short:   "Manage Cline tasks",
-		Long:    `Create, monitor, and manage Cline AI tasks.`,
-	}
-
-	cmd.AddCommand(newTaskNewCommand())
-	cmd.AddCommand(newTaskCancelCommand())
-	cmd.AddCommand(newTaskFollowCommand())
-	cmd.AddCommand(newTaskSendCommand())
-	cmd.AddCommand(newTaskViewCommand())
-	cmd.AddCommand(newTaskListCommand())
-	cmd.AddCommand(newTaskResumeCommand())
-
-	return cmd
-}
-
-var taskManager *task.Manager
-
-func ensureTaskManager(ctx context.Context, address string) error {
-	if taskManager == nil || (address != "" && taskManager.GetCurrentInstance() != address) {
-		var err error
-		var instanceAddress string
-
-		if address != "" {
-			// Ensure instance exists at the specified address
-			if err := ensureInstanceAtAddress(ctx, address); err != nil {
-				return fmt.Errorf("failed to ensure instance at address %s: %w", address, err)
-			}
-			taskManager, err = task.NewManagerForAddress(ctx, address)
-			instanceAddress = address
-		} else {
-			// Ensure default instance exists
-			if err := ensureDefaultInstance(ctx); err != nil {
-				return fmt.Errorf("failed to ensure default instance: %w", err)
-			}
-			taskManager, err = task.NewManagerForDefault(ctx)
-			if err == nil {
-				instanceAddress = taskManager.GetCurrentInstance()
-			}
-		}
-
-		if err != nil {
-			return fmt.Errorf("failed to create task manager: %w", err)
-		}
-
-		// Always set the instance we're using as the default
-		registry := global.Clients.GetRegistry()
-		if err := registry.SetDefaultInstance(instanceAddress); err != nil {
-			// Log warning but don't fail - this is not critical
-			fmt.Printf("Warning: failed to set default instance: %v\n", err)
-		}
-	}
-	return nil
-}
-
-// ensureInstanceAtAddress ensures an instance exists at the given address
-func ensureInstanceAtAddress(ctx context.Context, address string) error {
-	if global.Clients == nil {
-		return fmt.Errorf("global clients not initialized")
-	}
-	return global.Clients.EnsureInstanceAtAddress(ctx, address)
-}
-
-// ensureDefaultInstance ensures a default instance exists
-func ensureDefaultInstance(ctx context.Context) error {
-	if global.Clients == nil {
-		return fmt.Errorf("global clients not initialized")
-	}
-
-	// Check if we have any instances in the registry
-	registry := global.Clients.GetRegistry()
-	if registry.GetDefaultInstance() == "" {
-		// No default instance, start a new one
-		instance, err := global.Clients.StartNewInstance(ctx)
-		if err != nil {
-			return fmt.Errorf("failed to start new default instance: %w", err)
-		}
-
-		// Set the new instance as default
-		if err := registry.SetDefaultInstance(instance.Address); err != nil {
-			return fmt.Errorf("failed to set default instance: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func newTaskNewCommand() *cobra.Command {
-	var (
-		images     []string
-		files      []string
-		wait       bool
-		workspaces []string
-		address    string
-		mode       string
-	)
-
-	cmd := &cobra.Command{
-		Use:     "new <prompt>",
-		Aliases: []string{"n"},
-		Short:   "Create a new task",
-		Long:    `Create a new Cline task with the specified prompt. If no Cline instance exists at the specified address, a new one will be started automatically.`,
-		Args:    cobra.MinimumNArgs(0),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Get content from both args and stdin
-			prompt, err := getContentFromStdinAndArgs(args)
-			if err != nil {
-				return fmt.Errorf("failed to read prompt: %w", err)
-			}
-
-			// Validate that prompt is passed in call
-			if prompt == "" {
-				return fmt.Errorf("prompt required: provide as argument or pipe via stdin")
-			}
-
-			// Ensure task manager is initialized
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			// Set mode if provided
-			if mode != "" {
-				if err := taskManager.SetMode(ctx, mode, nil, nil, nil); err != nil {
-					return fmt.Errorf("failed to set mode: %w", err)
-				}
-				fmt.Printf("Mode set to: %s\n", mode)
-			}
-
-			// Create the task
-			taskID, err := taskManager.CreateTask(ctx, prompt, images, files, workspaces)
-			if err != nil {
-				return fmt.Errorf("failed to create task: %w", err)
-			}
-
-			fmt.Printf("Task created successfully with ID: %s\n", taskID)
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			// Wait for completion if requested
-			if wait {
-				fmt.Println("Following task conversation...")
-				return taskManager.FollowConversation(ctx)
-			}
-
-			return nil
-		},
-	}
-
-	cmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
-	cmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	cmd.Flags().BoolVar(&wait, "wait", false, "wait for task completion")
-	cmd.Flags().StringSliceVarP(&workspaces, "workdir", "w", nil, "workdir directory paths")
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	cmd.Flags().StringVarP(&mode, "mode", "m", "", "mode (act|plan)")
-
-	return cmd
-}
-
-func newTaskCancelCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "cancel",
-		Aliases: []string{"c"},
-		Short:   "Cancel the current task",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			if err := taskManager.CancelTask(ctx); err != nil {
-				return err
-			}
-
-			fmt.Println("Task cancelled successfully")
-			fmt.Printf("Instance: %s\n", taskManager.GetCurrentInstance())
-			return nil
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}
-
-func newTaskSendCommand() *cobra.Command {
-	var (
-		images  []string
-		files   []string
-		address string
-		mode    string
-		approve string
-	)
-
-	cmd := &cobra.Command{
-		Use:     "send [message]",
-		Aliases: []string{"s"},
-		Short:   "Send a followup message to the current task and/or update mode/approve",
-		Long:    `Send a followup message to continue the conversation with the current task and/or update mode/approve.`,
-		Args:    cobra.MinimumNArgs(0),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Get content from both args and stdin
-			message, err := getContentFromStdinAndArgs(args)
-			if err != nil {
-				return fmt.Errorf("failed to read message: %w", err)
-			}
-
-			if message == "" && len(images) == 0 && len(files) == 0 && mode == "" && approve == "" {
-				return fmt.Errorf("content (message, files, images) required unless using --mode or --approve flags")
-			}
-
-			if approve != "" && approve != "true" && approve != "false" {
-				return fmt.Errorf("--approve must be 'true' or 'false'")
-			}
-
-			if approve != "" && mode != "" {
-				return fmt.Errorf("cannot use --approve and --mode together")
-			}
-
-			// Ensure task manager is initialized
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			sendDisabled, err := taskManager.CheckSendDisabled(ctx)
-
-			if err != nil {
-				return fmt.Errorf("failed to check if message can be sent: %w", err)
-			}
-
-			if sendDisabled {
-				fmt.Println("Cannot send message: task is currently busy")
-				return nil
-			}
-
-			if mode != "" {
-				if err := taskManager.SetModeAndSendMessage(ctx, mode, message, images, files); err != nil {
-					return fmt.Errorf("failed to set mode and send message: %w", err)
-				}
-				fmt.Printf("Mode set to %s and message sent successfully.\n", mode)
-
-			} else {
-				if err := taskManager.SendMessage(ctx, message, images, files, approve); err != nil {
-					return err
-				}
-				fmt.Printf("Message sent successfully.\n")
-			}
-
-			fmt.Printf("Instance: %s\n", taskManager.GetCurrentInstance())
-			return nil
-		},
-	}
-
-	cmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
-	cmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	cmd.Flags().StringVarP(&mode, "mode", "m", "", "mode (act|plan)")
-	cmd.Flags().StringVarP(&approve, "approve", "a", "", "approve (true) or deny (false) pending request")
-
-	return cmd
-}
-
-func newTaskFollowCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "follow",
-		Aliases: []string{"f"},
-		Short:   "Follow current task conversation in real-time",
-		Long:    `Follow the current task conversation, displaying new messages as they arrive in real-time.`,
-		Args:    cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			return taskManager.FollowConversation(ctx)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-
-	return cmd
-}
-
-func newTaskViewCommand() *cobra.Command {
-	var (
-		current bool
-		summary bool
-		address string
-	)
-
-	cmd := &cobra.Command{
-		Use:     "view",
-		Aliases: []string{"v"},
-		Short:   "View task conversation",
-		Long:    `Output conversation until next completion, with options for current state or summary only.`,
-		Args:    cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			if current {
-				return taskManager.ShowConversation(ctx)
-			} else if summary {
-				return taskManager.GatherFinalSummary(ctx)
-			} else {
-				return taskManager.FollowConversationUntilCompletion(ctx)
-			}
-		},
-	}
-
-	cmd.Flags().BoolVarP(&current, "current", "c", false, "output current conversation without following")
-	cmd.Flags().BoolVarP(&summary, "summary", "s", false, "outputs only the completion summary")
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-
-	return cmd
-}
-
-func newTaskListCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"l"},
-		Short:   "List recent task history",
-		Long:    `Display recent tasks from task history.`,
-		Args:    cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Ensure task manager is initialized
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			return taskManager.ListTasks(ctx)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}
-
-func newTaskResumeCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "resume <task-id>",
-		Aliases: []string{"r"},
-		Short:   "Resume a task by ID",
-		Long:    `Resume an existing task by ID.`,
-		Args:    cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-			taskID := args[0]
-
-			// Ensure task manager is initialized
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			return taskManager.ResumeTask(ctx, taskID)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}
-
-// getContentFromStdinAndArgs reads content from both command line args and stdin, and combines them
-func getContentFromStdinAndArgs(args []string) (string, error) {
-	var content strings.Builder
-
-	// Add command line args first (if any)
-	if len(args) > 0 {
-		content.WriteString(strings.Join(args, " "))
-	}
-
-	// Check if stdin has data
-	stat, err := os.Stdin.Stat()
-	if err != nil {
-		return "", fmt.Errorf("failed to stat stdin: %w", err)
-	}
-
-	// Check if data is being piped to stdin
-	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		stdinBytes, err := io.ReadAll(os.Stdin)
-		if err != nil {
-			return "", fmt.Errorf("failed to read from stdin: %w", err)
-		}
-
-		stdinContent := strings.TrimSpace(string(stdinBytes))
-		if stdinContent != "" {
-			if content.Len() > 0 {
-				content.WriteString(" ")
-			}
-			content.WriteString(stdinContent)
-		}
-	}
-
-	return content.String(), nil
-}
-
-// CleanupTaskManager cleans up the task manager resources
-func CleanupTaskManager() {
-	if taskManager != nil {
-		taskManager.Cleanup()
-	}
-}

cli/pkg/cli/task/manager.go

@@ -1,946 +0,0 @@
-package task
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/display"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/handlers"
-	"github.com/cline/cli/pkg/cli/types"
-	"github.com/cline/grpc-go/client"
-	"github.com/cline/grpc-go/cline"
-)
-
-// Manager handles task execution and message display
-type Manager struct {
-	mu               sync.RWMutex
-	client           *client.ClineClient
-	clientAddress    string
-	state            *types.ConversationState
-	renderer         *display.Renderer
-	streamingDisplay *display.StreamingDisplay
-	handlerRegistry  *handlers.HandlerRegistry
-}
-
-// NewManager creates a new task manager
-func NewManager(client *client.ClineClient) *Manager {
-	state := types.NewConversationState()
-	renderer := display.NewRenderer()
-	streamingDisplay := display.NewStreamingDisplay(state, renderer)
-
-	// Create handler registry and register handlers
-	registry := handlers.NewHandlerRegistry()
-	registry.Register(handlers.NewAskHandler())
-	registry.Register(handlers.NewSayHandler())
-
-	return &Manager{
-		client:           client,
-		clientAddress:    "", // Will be set when client is provided
-		state:            state,
-		renderer:         renderer,
-		streamingDisplay: streamingDisplay,
-		handlerRegistry:  registry,
-	}
-}
-
-// NewManagerForAddress creates a new task manager for a specific instance address
-func NewManagerForAddress(ctx context.Context, address string) (*Manager, error) {
-	client, err := global.GetClientForAddress(ctx, address)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get client for address %s: %w", address, err)
-	}
-
-	manager := NewManager(client)
-	manager.clientAddress = address
-	return manager, nil
-}
-
-// NewManagerForDefault creates a new task manager using the default instance
-func NewManagerForDefault(ctx context.Context) (*Manager, error) {
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get default client: %w", err)
-	}
-
-	manager := NewManager(client)
-
-	// Get the default instance address
-	if global.Clients != nil {
-		manager.clientAddress = global.Clients.GetRegistry().GetDefaultInstance()
-	}
-
-	return manager, nil
-}
-
-// SwitchToInstance switches the manager to use a different Cline instance
-func (m *Manager) SwitchToInstance(ctx context.Context, address string) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	// Get client for the new address
-	newClient, err := global.GetClientForAddress(ctx, address)
-	if err != nil {
-		return fmt.Errorf("failed to get client for address %s: %w", address, err)
-	}
-
-	// Update the client and address
-	m.client = newClient
-	m.clientAddress = address
-
-	if global.Config.Verbose {
-		m.renderer.RenderDebug("Switched to instance: %s", address)
-	}
-
-	return nil
-}
-
-// GetCurrentInstance returns the address of the current instance
-func (m *Manager) GetCurrentInstance() string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.clientAddress
-}
-
-// CreateTask creates a new task
-func (m *Manager) CreateTask(ctx context.Context, prompt string, images, files []string, workspacePaths []string) (string, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if global.Config.Verbose {
-		m.renderer.RenderDebug("Creating task: %s", prompt)
-		if len(files) > 0 {
-			m.renderer.RenderDebug("Files: %v", files)
-		}
-		if len(images) > 0 {
-			m.renderer.RenderDebug("Images: %v", images)
-		}
-		if len(workspacePaths) > 0 {
-			m.renderer.RenderDebug("Workspaces: %v", workspacePaths)
-		}
-	}
-
-	// Check if there's an active task and cancel it first
-	if err := m.cancelExistingTaskIfNeeded(ctx); err != nil {
-		return "", fmt.Errorf("failed to cancel existing task: %w", err)
-	}
-
-	// Create task request
-	req := &cline.NewTaskRequest{
-		Text:           prompt,
-		Images:         images,
-		Files:          files,
-	}
-
-	resp, err := m.client.Task.NewTask(ctx, req)
-	if err != nil {
-		return "", fmt.Errorf("failed to create task: %w", err)
-	}
-
-	taskID := resp.Value
-
-	return taskID, nil
-}
-
-// cancelExistingTaskIfNeeded checks if there's an active task and cancels it
-func (m *Manager) cancelExistingTaskIfNeeded(ctx context.Context) error {
-	// Try to get the current state to check if there's an active task
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		// If we can't get state, assume no active task and continue
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("Could not get state to check for active task: %v", err)
-		}
-		return nil
-	}
-
-	// Properly parse the state to check if there's actually an active task
-	if state.StateJson != "" {
-		var stateData types.ExtensionState
-		if err := json.Unmarshal([]byte(state.StateJson), &stateData); err != nil {
-			// If we can't parse state, assume no active task
-			if global.Config.Verbose {
-				m.renderer.RenderDebug("Could not parse state JSON: %v", err)
-			}
-			return nil
-		}
-
-		// Check if there's actually an active task
-		if stateData.CurrentTaskItem != nil && stateData.CurrentTaskItem.Id != "" {
-			if global.Config.Verbose {
-				m.renderer.RenderDebug("Found active task %s, cancelling...", stateData.CurrentTaskItem.Id)
-			}
-
-			// Cancel the existing task
-			_, err := m.client.Task.CancelTask(ctx, &cline.EmptyRequest{})
-			if err != nil {
-				if global.Config.Verbose {
-					m.renderer.RenderDebug("Cancel task returned error: %v", err)
-				}
-			} else {
-				fmt.Println("Cancelled existing task to start new one")
-			}
-		}
-	} 
-
-	return nil
-}
-
-// CheckSendDisabled determines if we can send a message to the current task
-// We duplicate the logic from buttonConfig::getButtonConfig
-func (m *Manager) CheckSendDisabled(ctx context.Context) (bool, error) {
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return false, fmt.Errorf("failed to get latest state: %w", err)
-	}
-
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return false, fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	if len(messages) == 0 {
-		return false, nil
-	}
-
-	// Use final message to perform validation
-	lastMessage := messages[len(messages)-1]
-
-	// Error types which we allow sending on
-	errorTypes := []string{
-		string(types.AskTypeAPIReqFailed),           // "api_req_failed"
-		string(types.AskTypeMistakeLimitReached),    // "mistake_limit_reached"
-		string(types.AskTypeAutoApprovalMaxReached), // "auto_approval_max_req_reached"
-	}
-
-	isError := false
-
-	// Check if message is an error type
-	if lastMessage.Type == types.MessageTypeAsk {
-		for _, errType := range errorTypes {
-			if lastMessage.Ask == errType {
-				isError = true
-				break
-			}
-		}
-	}
-
-	// Streaming and error check
-	if lastMessage.Partial && !isError {
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("Send disabled: task is streaming and non-error")
-		}
-		return true, nil
-	}
-
-	// All ask messages allow sending
-	if lastMessage.Type == types.MessageTypeAsk {
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("Send enabled: ask message")
-		}
-		return false, nil
-	}
-
-	// Technically unnecessary but implements getButtonConfig 1-1
-	if lastMessage.Type == types.MessageTypeSay && lastMessage.Say == string(types.SayTypeAPIReqStarted) {
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("Send disabled: API request is active")
-		}
-		return true, nil
-	}
-
-	if global.Config.Verbose {
-		m.renderer.RenderDebug("Send disabled: default fallback")
-	}
-
-	return true, nil
-}
-
-// SendMessage sends a followup message to the current task
-func (m *Manager) SendMessage(ctx context.Context, message string, images, files []string, approve string) error {
-	responseType := "messageResponse"
-
-	if approve == "true" {
-		responseType = "yesButtonClicked"
-	}
-
-	if approve == "false" {
-		responseType = "noButtonClicked"
-	}
-
-	if global.Config.Verbose {
-		m.renderer.RenderDebug("Sending message: %s", message)
-		if len(files) > 0 {
-			m.renderer.RenderDebug("Files: %v", files)
-		}
-		if len(images) > 0 {
-			m.renderer.RenderDebug("Images: %v", images)
-		}
-	}
-
-	// Send the followup message using AskResponse
-	req := &cline.AskResponseRequest{
-		ResponseType: responseType,
-		Text:         message,
-		Images:       images,
-		Files:        files,
-	}
-
-	_, err := m.client.Task.AskResponse(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
-	}
-
-	return nil
-}
-
-// SetMode sets the Plan/Act mode for the current Cline instance and optionally sends message
-func (m *Manager) SetMode(ctx context.Context, mode string, message *string, images, files []string) error {
-	if mode != "act" && mode != "plan" {
-		return fmt.Errorf("invalid mode '%s': must be 'act' or 'plan'", mode)
-	}
-
-	var protoMode cline.PlanActMode
-	if mode == "plan" {
-		protoMode = cline.PlanActMode_PLAN
-	} else {
-		protoMode = cline.PlanActMode_ACT
-	}
-
-	req := &cline.TogglePlanActModeRequest{
-		Metadata: &cline.Metadata{},
-		Mode:     protoMode,
-	}
-
-	if message != nil {
-		req.ChatContent = &cline.ChatContent{
-			Message: message,
-			Images:  images,
-			Files:   files,
-		}
-	}
-
-	_, err := m.client.State.TogglePlanActModeProto(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to set mode to '%s': %w", mode, err)
-	}
-
-	return nil
-}
-
-// SetModeAndSendMessage sets the mode and sends a message in one operation
-// Handles task restoration internally if the mode switch cancels the current task
-func (m *Manager) SetModeAndSendMessage(ctx context.Context, mode, message string, images, files []string) error {
-	if mode != "act" && mode != "plan" {
-		return fmt.Errorf("invalid mode '%s': must be 'act' or 'plan'", mode)
-	}
-
-	taskId, err := m.getCurrentTaskId(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get current task ID: %w", err)
-	}
-	fmt.Printf("Current task ID: %s\n", taskId)
-
-	var protoMode cline.PlanActMode
-	if mode == "plan" {
-		protoMode = cline.PlanActMode_PLAN
-	} else {
-		protoMode = cline.PlanActMode_ACT
-	}
-
-	req := &cline.TogglePlanActModeRequest{
-		Metadata: &cline.Metadata{},
-		Mode:     protoMode,
-		ChatContent: &cline.ChatContent{
-			Message: &message,
-			Images:  images,
-			Files:   files,
-		},
-	}
-
-	result, err := m.client.State.TogglePlanActModeProto(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to set mode to '%s': %w", mode, err)
-	}
-
-	taskPreserved := result.Value
-
-	if taskPreserved {
-		fmt.Printf("Message sent as part of mode change\n")
-		return nil
-	} else {
-		if message != "" || len(images) > 0 || len(files) > 0 {
-			fmt.Printf("Task was cancelled, restoring task ID: %s\n", taskId)
-
-			err = m.ReinitExistingTaskFromId(ctx, taskId)
-			if err != nil {
-				return fmt.Errorf("Failed to restore task: %w", err)
-			}
-			fmt.Printf("Task restored successfully\n")
-
-			// Hardcoded sleep should be replaced with a way to fetch whether task is ready algorithmically
-			time.Sleep(1 * time.Second)
-
-			err = m.SendMessage(ctx, message, images, files, "")
-			if err != nil {
-				return fmt.Errorf("Failed to send message: %w", err)
-			}
-			fmt.Printf("Message sent to restored task\n")
-		}
-	}
-
-	return nil
-}
-
-// getCurrentTaskId extracts the current task ID from the server state
-func (m *Manager) getCurrentTaskId(ctx context.Context) (string, error) {
-	// Get the latest state
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return "", fmt.Errorf("failed to get state: %w", err)
-	}
-
-	// Parse the server state JSON
-	var stateData types.ExtensionState
-	if err := json.Unmarshal([]byte(state.StateJson), &stateData); err != nil {
-		return "", fmt.Errorf("failed to parse state JSON: %w", err)
-	}
-
-	// Extract current task ID
-	if stateData.CurrentTaskItem != nil && stateData.CurrentTaskItem.Id != "" {
-		return stateData.CurrentTaskItem.Id, nil
-	}
-
-	return "", fmt.Errorf("no current task found in state")
-}
-
-// ReinitExistingTaskFromId reinitializes an existing task from the given task ID
-func (m *Manager) ReinitExistingTaskFromId(ctx context.Context, taskId string) error {
-	req := &cline.StringRequest{Value: taskId}
-	resp, err := m.client.Task.ShowTaskWithId(ctx, req)
-	if err != nil {
-		return fmt.Errorf("Failed to reinitialize task %s: %w", taskId, err)
-	}
-
-	fmt.Printf("Successfully reinitialized task: %s (ID: %s)\n", taskId, resp.Id)
-
-	return nil
-}
-
-// ResumeTask resumes an existing task by ID
-func (m *Manager) ResumeTask(ctx context.Context, taskID string) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if global.Config.Verbose {
-		m.renderer.RenderDebug("Resuming task: %s", taskID)
-	}
-
-	// This call handles cancellation of any active task
-	if err := m.ReinitExistingTaskFromId(ctx, taskID); err != nil {
-		return fmt.Errorf("failed to resume task %s: %w", taskID, err)
-	}
-
-	fmt.Printf("Task %s resumed successfully\n", taskID)
-
-	return nil
-}
-
-// CancelTask cancels the current task
-func (m *Manager) CancelTask(ctx context.Context) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	_, err := m.client.Task.CancelTask(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to cancel task: %w", err)
-	}
-
-	return nil
-}
-
-// ListTasks retrieves and displays task history
-func (m *Manager) ListTasks(ctx context.Context) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	req := &cline.GetTaskHistoryRequest{
-		FavoritesOnly:        false,
-		SearchQuery:          "",
-		SortBy:               "oldest",
-		CurrentWorkspaceOnly: false,
-	}
-
-	resp, err := m.client.Task.GetTaskHistory(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to get task history: %w", err)
-	}
-
-	if len(resp.Tasks) == 0 {
-		fmt.Println("No task history found.")
-		return nil
-	}
-
-	return m.renderer.RenderTaskList(resp.Tasks)
-}
-
-// GatherFinalSummary attempts to gather the latest completion_result output and display it
-func (m *Manager) GatherFinalSummary(ctx context.Context) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get state: %w", err)
-	}
-
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	for i := len(messages) - 1; i >= 0; i-- {
-		msg := messages[i]
-
-		// Check if this is a completion result SAY message
-		if msg.IsSay() && msg.Say == string(types.SayTypeCompletionResult) {
-			return m.displayMessage(msg, false, false, i)
-		}
-	}
-
-	return nil
-}
-
-// ShowConversation displays the current conversation
-func (m *Manager) ShowConversation(ctx context.Context) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	// Get the latest state which contains messages
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get state: %w", err)
-	}
-
-	// Parse the state JSON to extract messages
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	if len(messages) == 0 {
-		fmt.Println("No conversation history found.")
-		return nil
-	}
-
-	// Display messages
-	for i, msg := range messages {
-		m.displayMessage(msg, false, false, i)
-	}
-
-	return nil
-}
-
-func (m *Manager) FollowConversation(ctx context.Context) error {
-	fmt.Println("Following task conversation... (Press Ctrl+C to exit)")
-
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	// Create stream coordinator
-	coordinator := NewStreamCoordinator()
-
-	// Load history first
-	totalMessageCount, err := m.loadAndDisplayRecentHistory(ctx)
-	if err != nil {
-		m.renderer.RenderDebug("Warning: Failed to load conversation history: %v", err)
-		totalMessageCount = 0
-	}
-	coordinator.SetConversationTurnStartIndex(totalMessageCount)
-
-	fmt.Println("\n--- Live updates ---")
-
-	// Start both streams concurrently
-	errChan := make(chan error, 2)
-
-	if global.Config.OutputFormat == "json" {
-		go m.handleStateStream(ctx, coordinator, errChan, nil)
-	} else {
-		go m.handleStateStream(ctx, coordinator, errChan, nil)
-		go m.handlePartialMessageStream(ctx, coordinator, errChan)
-	}
-
-	// Wait for either stream to error or context cancellation
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case err := <-errChan:
-		cancel()
-		return err
-	}
-}
-
-// FollowConversationUntilCompletion streams conversation updates until task completion
-func (m *Manager) FollowConversationUntilCompletion(ctx context.Context) error {
-	fmt.Println("Streaming conversation until completion... (Press Ctrl+C to exit)")
-
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	// Create stream coordinator
-	coordinator := NewStreamCoordinator()
-
-	// Get current message count without displaying history
-	totalMessageCount, err := m.getCurrentMessageCount(ctx)
-	if err != nil {
-		m.renderer.RenderDebug("Warning: Failed to get current message count: %v", err)
-		totalMessageCount = 0
-	}
-	coordinator.SetConversationTurnStartIndex(totalMessageCount)
-
-	// Start both streams concurrently
-	errChan := make(chan error, 2)
-	completionChan := make(chan bool, 1)
-
-	if global.Config.OutputFormat == "json" {
-		go m.handleStateStream(ctx, coordinator, errChan, completionChan)
-	} else {
-		go m.handleStateStream(ctx, coordinator, errChan, completionChan)
-		go m.handlePartialMessageStream(ctx, coordinator, errChan)
-	}
-
-	// Wait for completion, error, or context cancellation
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-completionChan:
-		cancel()
-		return nil
-	case err := <-errChan:
-		cancel()
-		return err
-	}
-}
-
-// handleStateStream handles the SubscribeToState stream
-func (m *Manager) handleStateStream(ctx context.Context, coordinator *StreamCoordinator, errChan chan error, completionChan chan bool) {
-	stateStream, err := m.client.State.SubscribeToState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		errChan <- fmt.Errorf("failed to subscribe to state: %w", err)
-		return
-	}
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			stateUpdate, err := stateStream.Recv()
-			if err != nil {
-				m.renderer.RenderDebug("State stream receive error: %v", err)
-				errChan <- fmt.Errorf("failed to receive state update: %w", err)
-				return
-			}
-
-			var pErr error
-
-			if global.Config.OutputFormat == "json" {
-				pErr = m.processStateUpdateJsonMode(stateUpdate, coordinator, completionChan)
-			} else {
-				pErr = m.processStateUpdate(stateUpdate, coordinator, completionChan)
-			}
-
-			if pErr != nil {
-				m.renderer.RenderDebug("State processing error: %v", pErr)
-			}
-		}
-	}
-}
-
-func (m *Manager) processStateUpdateJsonMode(stateUpdate *cline.State, coordinator *StreamCoordinator, completionChan chan bool) error {
-	messages, err := m.extractMessagesFromState(stateUpdate.StateJson)
-	if err != nil {
-		return err
-	}
-
-	// Process messages from current conversation turn onwards
-	startIndex := coordinator.GetConversationTurnStartIndex()
-
-	var foundCompletion bool
-	var displayedUsage bool
-
-	for i := startIndex; i < len(messages); i++ {
-		msg := messages[i]
-
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("State message %d: type=%s, say=%s", i, msg.Type, msg.Say)
-		}
-
-		// Exit after we've seen a task completion & printed out the usage info
-		if msg.Say == string(types.SayTypeCompletionResult) {
-			foundCompletion = true
-		}
-
-		// Determine if message is ready to be displayed now
-		shouldDisplay := true
-
-		switch {
-		case msg.Say == string(types.SayTypeAPIReqStarted):
-			shouldDisplay = false
-			apiInfo := types.APIRequestInfo{Cost: -1}
-			if err := json.Unmarshal([]byte(msg.Text), &apiInfo); err == nil && apiInfo.Cost >= 0 {
-				shouldDisplay = true
-				displayedUsage = true
-			}
-		}
-
-		// Skip if message is partial, except for a specific edge case
-		if msg.Partial {
-			// Exception: display if type=say, text="", say="text"
-			if msg.IsSay() && msg.Text == "" && msg.Say == string(types.SayTypeText) {
-				shouldDisplay = true
-			} else {
-				shouldDisplay = false
-			}
-		}
-
-		// Display valid messages, exit as soon as we hit a non-valid message
-		if shouldDisplay {
-			coordinator.CompleteTurn(i + 1) // Mark the message as complete as soon as we print it
-			m.displayMessage(msg, false, false, i)
-		} else {
-			break
-		}
-	}
-
-	// We only want to exit after we've displayed the usage, for the case of seeing completion result
-	if completionChan != nil && foundCompletion && displayedUsage {
-		completionChan <- true
-	}
-
-	return nil
-}
-
-// processStateUpdate processes state updates and supports logic for handling task competion markers
-func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *StreamCoordinator, completionChan chan bool) error {
-	messages, err := m.extractMessagesFromState(stateUpdate.StateJson)
-	if err != nil {
-		return err
-	}
-
-	// Process messages from current conversation turn onwards
-	startIndex := coordinator.GetConversationTurnStartIndex()
-
-	var foundCompletion bool
-	var displayedUsage bool
-
-	for i := startIndex; i < len(messages); i++ {
-		msg := messages[i]
-
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("State message %d: type=%s, say=%s", i, msg.Type, msg.Say)
-		}
-
-		// Exit after we've seen a task completion & printed out the usage info
-		if msg.Say == string(types.SayTypeCompletionResult) {
-			foundCompletion = true
-		}
-
-		// Currently handling a subset of message types for displaying
-		switch {
-		case msg.Say == string(types.SayTypeUserFeedback):
-			if !coordinator.IsProcessedInCurrentTurn("user_msg") {
-				m.displayMessage(msg, false, false, i)
-				coordinator.MarkProcessedInCurrentTurn("user_msg")
-			}
-
-		case msg.Say == string(types.SayTypeCheckpointCreated):
-			if !coordinator.IsProcessedInCurrentTurn("checkpoint") {
-				m.displayMessage(msg, false, false, i)
-				coordinator.MarkProcessedInCurrentTurn("checkpoint")
-			}
-
-		case msg.Say == string(types.SayTypeAPIReqStarted):
-			apiInfo := types.APIRequestInfo{Cost: -1}
-			if err := json.Unmarshal([]byte(msg.Text), &apiInfo); err == nil && apiInfo.Cost >= 0 {
-				fmt.Println() // adds a separator between cline message and usage message
-				m.displayMessage(msg, false, false, i)
-				coordinator.CompleteTurn(len(messages))
-				displayedUsage = true
-			}
-		}
-	}
-
-	// We only want to exit after we've displayed the usage, for the case of seeing completion result
-	if completionChan != nil && foundCompletion && displayedUsage {
-		completionChan <- true
-	}
-
-	return nil
-}
-
-// handlePartialMessageStream handles the SubscribeToPartialMessage stream for streaming assistant text
-func (m *Manager) handlePartialMessageStream(ctx context.Context, coordinator *StreamCoordinator, errChan chan error) {
-	partialStream, err := m.client.Ui.SubscribeToPartialMessage(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		errChan <- fmt.Errorf("failed to subscribe to partial messages: %w", err)
-		return
-	}
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			protoMsg, err := partialStream.Recv()
-			if err != nil {
-				m.renderer.RenderDebug("Partial stream receive error: %v", err)
-				errChan <- fmt.Errorf("failed to receive partial message: %w", err)
-				return
-			}
-
-			// Convert proto message to our Message struct
-			msg := types.ConvertProtoToMessage(protoMsg)
-
-			// Debug: Log received message (always show for debugging)
-			m.renderer.RenderDebug("Received streaming message: type=%s, partial=%v, text_len=%d",
-				msg.Type, msg.Partial, len(msg.Text))
-
-			// Handle the message with streaming support for de-dupping
-			if err := m.handleStreamingMessage(msg); err != nil {
-				m.renderer.RenderDebug("Error handling streaming message: %v", err)
-			}
-		}
-	}
-}
-
-// handleStreamingMessage handles a streaming message
-func (m *Manager) handleStreamingMessage(msg *types.ClineMessage) error {
-	// Debug: Always log what we're processing
-	m.renderer.RenderDebug("Processing message: timestamp=%d, partial=%v, type=%s, text_preview=%s",
-		msg.Timestamp, msg.Partial, msg.Type, m.truncateText(msg.Text, 50))
-
-	// Use streaming display which handles deduplication internally
-	if err := m.streamingDisplay.HandlePartialMessage(msg); err != nil {
-		m.renderer.RenderDebug("Streaming display failed, using fallback: %v", err)
-		// Fallback to regular display
-		return m.displayMessage(msg, true, false, -1)
-	}
-
-	return nil
-}
-
-// truncateText truncates text for debug display
-func (m *Manager) truncateText(text string, maxLen int) string {
-	if len(text) <= maxLen {
-		return text
-	}
-	return text[:maxLen] + "..."
-}
-
-// displayMessage displays a single message using the handler system
-func (m *Manager) displayMessage(msg *types.ClineMessage, isLast, isPartial bool, messageIndex int) error {
-	if global.Config.OutputFormat == "json" {
-		return m.outputMessageAsJSON(msg)
-	} else {
-		dc := &handlers.DisplayContext{
-			State:        m.state,
-			Renderer:     m.renderer,
-			IsLast:       isLast,
-			IsPartial:    isPartial,
-			MessageIndex: messageIndex,
-		}
-
-		return m.handlerRegistry.Handle(msg, dc)
-	}
-}
-
-// outputMessageAsJSON prints a single cline message as json
-func (m *Manager) outputMessageAsJSON(msg *types.ClineMessage) error {
-	jsonBytes, err := json.MarshalIndent(msg, "", "  ")
-	if err != nil {
-		return fmt.Errorf("failed to marshal message as JSON: %w", err)
-	}
-
-	fmt.Println(string(jsonBytes))
-	return nil
-}
-
-// getCurrentMessageCount gets the current message count without displaying messages
-func (m *Manager) getCurrentMessageCount(ctx context.Context) (int, error) {
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return 0, fmt.Errorf("failed to get state: %w", err)
-	}
-
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return 0, fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	return len(messages), nil
-}
-
-// loadAndDisplayRecentHistory loads and displays recent conversation history and returns the total number of existing messages
-func (m *Manager) loadAndDisplayRecentHistory(ctx context.Context) (int, error) {
-	// Get the latest state which contains messages
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return 0, fmt.Errorf("failed to get state: %w", err)
-	}
-
-	// Parse the state JSON to extract messages
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return 0, fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	if len(messages) == 0 {
-		fmt.Println("No conversation history found.")
-		return 0, nil
-	}
-
-	// Show only the last 100 messages by default
-	const maxHistoryMessages = 100
-	totalMessages := len(messages)
-	startIndex := 0
-
-	if totalMessages > maxHistoryMessages {
-		startIndex = totalMessages - maxHistoryMessages
-		fmt.Printf("--- Conversation history (%d of %d messages) ---\n", maxHistoryMessages, totalMessages)
-	} else {
-		fmt.Printf("--- Conversation history (%d messages) ---\n", totalMessages)
-	}
-
-	// Display recent messages
-	for i := startIndex; i < len(messages); i++ {
-		msg := messages[i]
-
-		// Display the message
-		m.displayMessage(msg, false, false, i)
-	}
-
-	// Return the total number of messages in the conversation
-	return totalMessages, nil
-}
-
-// extractMessagesFromState parses the state JSON and extracts messages
-func (m *Manager) extractMessagesFromState(stateJson string) ([]*types.ClineMessage, error) {
-	return types.ExtractMessagesFromStateJSON(stateJson)
-}
-
-// GetState returns the current conversation state
-func (m *Manager) GetState() *types.ConversationState {
-	return m.state
-}
-
-// Cleanup cleans up resources
-func (m *Manager) Cleanup() {
-	// Clean up streaming display resources if needed
-	if m.streamingDisplay != nil {
-		m.streamingDisplay.Cleanup()
-	}
-}

cli/pkg/cli/task/stream_coordinator.go

@@ -1,41 +0,0 @@
-package task
-
-// StreamCoordinator manages coordination between SubscribeToState and SubscribeToPartialMessage streams
-type StreamCoordinator struct {
-	conversationTurnStartIndex int             // First message index of current turn
-	processedInCurrentTurn     map[string]bool // What we've handled in THIS turn
-}
-
-// NewStreamCoordinator creates a new stream coordinator
-func NewStreamCoordinator() *StreamCoordinator {
-	return &StreamCoordinator{
-		conversationTurnStartIndex: 0,
-		processedInCurrentTurn:     make(map[string]bool),
-	}
-}
-
-// SetConversationTurnStartIndex sets the starting index for the current conversation turn
-func (sc *StreamCoordinator) SetConversationTurnStartIndex(index int) {
-	sc.conversationTurnStartIndex = index
-}
-
-// GetConversationTurnStartIndex returns the starting index for the current conversation turn
-func (sc *StreamCoordinator) GetConversationTurnStartIndex() int {
-	return sc.conversationTurnStartIndex
-}
-
-// MarkProcessedInCurrentTurn marks an item as processed in the current turn
-func (sc *StreamCoordinator) MarkProcessedInCurrentTurn(key string) {
-	sc.processedInCurrentTurn[key] = true
-}
-
-// IsProcessedInCurrentTurn checks if an item has been processed in the current turn
-func (sc *StreamCoordinator) IsProcessedInCurrentTurn(key string) bool {
-	return sc.processedInCurrentTurn[key]
-}
-
-// CompleteTurn resets the coordinator for the next conversation turn
-func (sc *StreamCoordinator) CompleteTurn(totalMessages int) {
-	sc.conversationTurnStartIndex = totalMessages
-	sc.processedInCurrentTurn = make(map[string]bool)
-}

cli/pkg/cli/types/messages.go

@@ -1,321 +0,0 @@
-package types
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-    "strconv"
-	"github.com/cline/grpc-go/cline"
-)
-
-// ClineMessage represents a conversation message in the CLI
-type ClineMessage struct {
-	Type      MessageType `json:"type"`
-	Text      string      `json:"text"`
-	Timestamp int64       `json:"ts"`
-	Reasoning string      `json:"reasoning,omitempty"`
-	Say       string      `json:"say,omitempty"`
-	Ask       string      `json:"ask,omitempty"`
-	Partial   bool        `json:"partial,omitempty"`
-	Images    []string    `json:"images,omitempty"`
-	Files     []string    `json:"files,omitempty"`
-}
-
-// MessageType represents the type of message
-type MessageType string
-
-const (
-	MessageTypeAsk MessageType = "ask"
-	MessageTypeSay MessageType = "say"
-)
-
-// AskType represents different types of ASK messages
-type AskType string
-
-const (
-	AskTypeFollowup               AskType = "followup"
-	AskTypePlanModeRespond        AskType = "plan_mode_respond"
-	AskTypeCommand                AskType = "command"
-	AskTypeCommandOutput          AskType = "command_output"
-	AskTypeCompletionResult       AskType = "completion_result"
-	AskTypeTool                   AskType = "tool"
-	AskTypeAPIReqFailed           AskType = "api_req_failed"
-	AskTypeResumeTask             AskType = "resume_task"
-	AskTypeResumeCompletedTask    AskType = "resume_completed_task"
-	AskTypeMistakeLimitReached    AskType = "mistake_limit_reached"
-	AskTypeAutoApprovalMaxReached AskType = "auto_approval_max_req_reached"
-	AskTypeBrowserActionLaunch    AskType = "browser_action_launch"
-	AskTypeUseMcpServer           AskType = "use_mcp_server"
-	AskTypeNewTask                AskType = "new_task"
-	AskTypeCondense               AskType = "condense"
-	AskTypeReportBug              AskType = "report_bug"
-)
-
-// SayType represents different types of SAY messages
-type SayType string
-
-const (
-	SayTypeTask                    SayType = "task"
-	SayTypeError                   SayType = "error"
-	SayTypeAPIReqStarted           SayType = "api_req_started"
-	SayTypeAPIReqFinished          SayType = "api_req_finished"
-	SayTypeText                    SayType = "text"
-	SayTypeReasoning               SayType = "reasoning"
-	SayTypeCompletionResult        SayType = "completion_result"
-	SayTypeUserFeedback            SayType = "user_feedback"
-	SayTypeUserFeedbackDiff        SayType = "user_feedback_diff"
-	SayTypeAPIReqRetried           SayType = "api_req_retried"
-	SayTypeCommand                 SayType = "command"
-	SayTypeCommandOutput           SayType = "command_output"
-	SayTypeTool                    SayType = "tool"
-	SayTypeShellIntegrationWarning SayType = "shell_integration_warning"
-	SayTypeBrowserActionLaunch     SayType = "browser_action_launch"
-	SayTypeBrowserAction           SayType = "browser_action"
-	SayTypeBrowserActionResult     SayType = "browser_action_result"
-	SayTypeMcpServerRequestStarted SayType = "mcp_server_request_started"
-	SayTypeMcpServerResponse       SayType = "mcp_server_response"
-	SayTypeMcpNotification         SayType = "mcp_notification"
-	SayTypeUseMcpServer            SayType = "use_mcp_server"
-	SayTypeDiffError               SayType = "diff_error"
-	SayTypeDeletedAPIReqs          SayType = "deleted_api_reqs"
-	SayTypeClineignoreError        SayType = "clineignore_error"
-	SayTypeCheckpointCreated       SayType = "checkpoint_created"
-	SayTypeLoadMcpDocumentation    SayType = "load_mcp_documentation"
-	SayTypeInfo                    SayType = "info"
-	SayTypeTaskProgress            SayType = "task_progress"
-)
-
-// ToolMessage represents a tool-related message
-type ToolMessage struct {
-	Tool                          string `json:"tool"`
-	Path                          string `json:"path,omitempty"`
-	Content                       string `json:"content,omitempty"`
-	Diff                          string `json:"diff,omitempty"`
-	Regex                         string `json:"regex,omitempty"`
-	FilePattern                   string `json:"filePattern,omitempty"`
-	OperationIsLocatedInWorkspace *bool  `json:"operationIsLocatedInWorkspace,omitempty"`
-}
-
-// ToolType represents different types of tools
-type ToolType string
-
-const (
-	ToolTypeEditedExistingFile      ToolType = "editedExistingFile"
-	ToolTypeNewFileCreated          ToolType = "newFileCreated"
-	ToolTypeReadFile                ToolType = "readFile"
-	ToolTypeListFilesTopLevel       ToolType = "listFilesTopLevel"
-	ToolTypeListFilesRecursive      ToolType = "listFilesRecursive"
-	ToolTypeListCodeDefinitionNames ToolType = "listCodeDefinitionNames"
-	ToolTypeSearchFiles             ToolType = "searchFiles"
-	ToolTypeWebFetch                ToolType = "webFetch"
-	ToolTypeSummarizeTask           ToolType = "summarizeTask"
-)
-
-// AskData represents the parsed structure of an ASK message
-type AskData struct {
-	Question string   `json:"question"`
-	Response string   `json:"response"`
-	Options  []string `json:"options,omitempty"`
-}
-
-// APIRequestInfo represents API request information
-type APIRequestInfo struct {
-	Request                string                 `json:"request,omitempty"`
-	TokensIn               int                    `json:"tokensIn,omitempty"`
-	TokensOut              int                    `json:"tokensOut,omitempty"`
-	CacheWrites            int                    `json:"cacheWrites,omitempty"`
-	CacheReads             int                    `json:"cacheReads,omitempty"`
-	Cost                   float64                `json:"cost,omitempty"`
-	CancelReason           string                 `json:"cancelReason,omitempty"`
-	StreamingFailedMessage string                 `json:"streamingFailedMessage,omitempty"`
-	RetryStatus            *APIRequestRetryStatus `json:"retryStatus,omitempty"`
-}
-
-// APIRequestRetryStatus represents retry status information
-type APIRequestRetryStatus struct {
-	Attempt      int    `json:"attempt"`
-	MaxAttempts  int    `json:"maxAttempts"`
-	DelaySec     int    `json:"delaySec"`
-	ErrorSnippet string `json:"errorSnippet,omitempty"`
-}
-
-// GetTimestamp returns a formatted timestamp string
-func (m *ClineMessage) GetTimestamp() string {
-	return time.Unix(m.Timestamp/1000, 0).Format("15:04:05")
-}
-
-// IsAsk returns true if this is an ASK message
-func (m *ClineMessage) IsAsk() bool {
-	return m.Type == MessageTypeAsk
-}
-
-// IsSay returns true if this is a SAY message
-func (m *ClineMessage) IsSay() bool {
-	return m.Type == MessageTypeSay
-}
-
-// GetMessageKey returns a unique key for this message based on timestamp
-func (m *ClineMessage) GetMessageKey() string {
-	return strconv.FormatInt(m.Timestamp, 10)
-}
-
-// ExtractMessagesFromStateJSON parses the state JSON and extracts messages
-func ExtractMessagesFromStateJSON(stateJson string) ([]*ClineMessage, error) {
-	// Parse the state JSON to extract clineMessages
-	var rawState map[string]interface{}
-	if err := json.Unmarshal([]byte(stateJson), &rawState); err != nil {
-		return nil, fmt.Errorf("failed to parse state JSON: %w", err)
-	}
-
-	// Try to extract clineMessages
-	clineMessagesRaw, exists := rawState["clineMessages"]
-	if !exists {
-		return []*ClineMessage{}, nil
-	}
-
-	// Convert to JSON and back to get proper Message structs
-	clineMessagesJson, err := json.Marshal(clineMessagesRaw)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal clineMessages: %w", err)
-	}
-
-	var messages []*ClineMessage
-	if err := json.Unmarshal(clineMessagesJson, &messages); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal clineMessages: %w", err)
-	}
-
-	return messages, nil
-}
-
-// ConvertProtoToMessage converts a protobuf ClineMessage to our local Message struct
-func ConvertProtoToMessage(protoMsg *cline.ClineMessage) *ClineMessage {
-	var msgType MessageType
-	var say, ask string
-
-	// Convert message type
-	switch protoMsg.Type {
-	case cline.ClineMessageType_ASK:
-		msgType = MessageTypeAsk
-		ask = convertProtoAskType(protoMsg.Ask)
-	case cline.ClineMessageType_SAY:
-		msgType = MessageTypeSay
-		say = convertProtoSayType(protoMsg.Say)
-	default:
-		msgType = MessageTypeSay
-		say = "unknown"
-	}
-
-	return &ClineMessage{
-		Type:      msgType,
-		Text:      protoMsg.Text,
-		Timestamp: protoMsg.Ts,
-		Reasoning: protoMsg.Reasoning,
-		Say:       say,
-		Ask:       ask,
-		Partial:   protoMsg.Partial,
-	}
-}
-
-// convertProtoAskType converts protobuf ask type to string
-func convertProtoAskType(askType cline.ClineAsk) string {
-	switch askType {
-	case cline.ClineAsk_FOLLOWUP:
-		return string(AskTypeFollowup)
-	case cline.ClineAsk_PLAN_MODE_RESPOND:
-		return string(AskTypePlanModeRespond)
-	case cline.ClineAsk_COMMAND:
-		return string(AskTypeCommand)
-	case cline.ClineAsk_COMMAND_OUTPUT:
-		return string(AskTypeCommandOutput)
-	case cline.ClineAsk_COMPLETION_RESULT:
-		return string(AskTypeCompletionResult)
-	case cline.ClineAsk_TOOL:
-		return string(AskTypeTool)
-	case cline.ClineAsk_API_REQ_FAILED:
-		return string(AskTypeAPIReqFailed)
-	case cline.ClineAsk_RESUME_TASK:
-		return string(AskTypeResumeTask)
-	case cline.ClineAsk_RESUME_COMPLETED_TASK:
-		return string(AskTypeResumeCompletedTask)
-	case cline.ClineAsk_MISTAKE_LIMIT_REACHED:
-		return string(AskTypeMistakeLimitReached)
-	case cline.ClineAsk_AUTO_APPROVAL_MAX_REQ_REACHED:
-		return string(AskTypeAutoApprovalMaxReached)
-	case cline.ClineAsk_BROWSER_ACTION_LAUNCH:
-		return string(AskTypeBrowserActionLaunch)
-	case cline.ClineAsk_USE_MCP_SERVER:
-		return string(AskTypeUseMcpServer)
-	case cline.ClineAsk_NEW_TASK:
-		return string(AskTypeNewTask)
-	case cline.ClineAsk_CONDENSE:
-		return string(AskTypeCondense)
-	case cline.ClineAsk_REPORT_BUG:
-		return string(AskTypeReportBug)
-	default:
-		return "unknown"
-	}
-}
-
-// convertProtoSayType converts protobuf say type to string
-func convertProtoSayType(sayType cline.ClineSay) string {
-	switch sayType {
-	case cline.ClineSay_TASK:
-		return string(SayTypeTask)
-	case cline.ClineSay_ERROR:
-		return string(SayTypeError)
-	case cline.ClineSay_API_REQ_STARTED:
-		return string(SayTypeAPIReqStarted)
-	case cline.ClineSay_API_REQ_FINISHED:
-		return string(SayTypeAPIReqFinished)
-	case cline.ClineSay_TEXT:
-		return string(SayTypeText)
-	case cline.ClineSay_REASONING:
-		return string(SayTypeReasoning)
-	case cline.ClineSay_COMPLETION_RESULT_SAY:
-		return string(SayTypeCompletionResult)
-	case cline.ClineSay_USER_FEEDBACK:
-		return string(SayTypeUserFeedback)
-	case cline.ClineSay_USER_FEEDBACK_DIFF:
-		return string(SayTypeUserFeedbackDiff)
-	case cline.ClineSay_API_REQ_RETRIED:
-		return string(SayTypeAPIReqRetried)
-	case cline.ClineSay_COMMAND_SAY:
-		return string(SayTypeCommand)
-	case cline.ClineSay_COMMAND_OUTPUT_SAY:
-		return string(SayTypeCommandOutput)
-	case cline.ClineSay_TOOL_SAY:
-		return string(SayTypeTool)
-	case cline.ClineSay_SHELL_INTEGRATION_WARNING:
-		return string(SayTypeShellIntegrationWarning)
-	case cline.ClineSay_BROWSER_ACTION_LAUNCH_SAY:
-		return string(SayTypeBrowserActionLaunch)
-	case cline.ClineSay_BROWSER_ACTION:
-		return string(SayTypeBrowserAction)
-	case cline.ClineSay_BROWSER_ACTION_RESULT:
-		return string(SayTypeBrowserActionResult)
-	case cline.ClineSay_MCP_SERVER_REQUEST_STARTED:
-		return string(SayTypeMcpServerRequestStarted)
-	case cline.ClineSay_MCP_SERVER_RESPONSE:
-		return string(SayTypeMcpServerResponse)
-	case cline.ClineSay_MCP_NOTIFICATION:
-		return string(SayTypeMcpNotification)
-	case cline.ClineSay_USE_MCP_SERVER_SAY:
-		return string(SayTypeUseMcpServer)
-	case cline.ClineSay_DIFF_ERROR:
-		return string(SayTypeDiffError)
-	case cline.ClineSay_DELETED_API_REQS:
-		return string(SayTypeDeletedAPIReqs)
-	case cline.ClineSay_CLINEIGNORE_ERROR:
-		return string(SayTypeClineignoreError)
-	case cline.ClineSay_CHECKPOINT_CREATED:
-		return string(SayTypeCheckpointCreated)
-	case cline.ClineSay_LOAD_MCP_DOCUMENTATION:
-		return string(SayTypeLoadMcpDocumentation)
-	case cline.ClineSay_INFO:
-		return string(SayTypeInfo)
-	case cline.ClineSay_TASK_PROGRESS:
-		return string(SayTypeTaskProgress)
-	default:
-		return "unknown"
-	}
-}

cli/pkg/cli/types/state.go

@@ -1,61 +0,0 @@
-package types
-
-import (
-	"sync"
-)
-
-// ConversationState manages the state of the conversation
-type ConversationState struct {
-	mu               sync.RWMutex
-	StreamingMessage *StreamingMessage `json:"streamingMessage,omitempty"`
-}
-
-// StreamingMessage manages state for streaming message display
-type StreamingMessage struct {
-	CurrentKey      string `json:"currentKey"`
-	LastText        string `json:"lastText"`
-	LastToolMessage string `json:"lastToolMessage,omitempty"`
-}
-
-// NewConversationState creates a new conversation state
-func NewConversationState() *ConversationState {
-	return &ConversationState{
-		StreamingMessage: &StreamingMessage{},
-	}
-}
-
-// SetStreamingMessage updates the streaming message state
-func (cs *ConversationState) SetStreamingMessage(key, text string) {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	cs.StreamingMessage.CurrentKey = key
-	cs.StreamingMessage.LastText = text
-}
-
-// GetStreamingMessage returns the current streaming message state
-func (cs *ConversationState) GetStreamingMessage() *StreamingMessage {
-	cs.mu.RLock()
-	defer cs.mu.RUnlock()
-	return &StreamingMessage{
-		CurrentKey:      cs.StreamingMessage.CurrentKey,
-		LastText:        cs.StreamingMessage.LastText,
-		LastToolMessage: cs.StreamingMessage.LastToolMessage,
-	}
-}
-
-// Clear resets state
-func (cs *ConversationState) Clear() {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	cs.StreamingMessage = &StreamingMessage{}
-}
-
-// ExtensionState represents the server-side extension state structure
-type ExtensionState struct {
-	CurrentTaskItem *CurrentTaskItem `json:"currentTaskItem,omitempty"`
-}
-
-// CurrentTaskItem - minimal struct with just what we need
-type CurrentTaskItem struct {
-	Id string `json:"id"`
-}

cli/pkg/cli/version.go

@@ -1,47 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"runtime"
-
-	"github.com/spf13/cobra"
-)
-
-var (
-	// These will be set at build time via ldflags
-	Version   = "dev"
-	Commit    = "unknown"
-	Date      = "unknown"
-	BuiltBy   = "unknown"
-)
-
-// NewVersionCommand creates the version command
-func NewVersionCommand() *cobra.Command {
-	var short bool
-
-	cmd := &cobra.Command{
-		Use:   "version",
-		Short: "Show version information",
-		Long:  `Display version information for the Cline Go host.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if short {
-				fmt.Println(Version)
-				return nil
-			}
-
-			fmt.Printf("Cline Go Host\n")
-			fmt.Printf("Version:    %s\n", Version)
-			fmt.Printf("Commit:     %s\n", Commit)
-			fmt.Printf("Built:      %s\n", Date)
-			fmt.Printf("Built by:   %s\n", BuiltBy)
-			fmt.Printf("Go version: %s\n", runtime.Version())
-			fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
-
-			return nil
-		},
-	}
-
-	cmd.Flags().BoolVar(&short, "short", false, "show only version number")
-
-	return cmd
-}

cli/pkg/common/constants.go

@@ -1,6 +0,0 @@
-package common
-
-// WE WILL HAVE TO MIGRATE THIS FROM DATA TO v1 LATER
-const SETTINGS_SUBFOLDER = "data"
-
-const DEFAULT_CLINE_CORE_PORT = 50052

cli/pkg/common/schema.go

@@ -1,54 +0,0 @@
-package common
-
-// Database query constants for the SQLite locks database
-const (
-
-	// SelectInstanceLocksSQL selects all instance locks ordered by creation time
-	SelectInstanceLocksSQL = `
-		SELECT id, held_by, lock_type, lock_target, locked_at 
-		FROM locks 
-		WHERE lock_type = 'instance' 
-		ORDER BY locked_at ASC
-	`
-
-	SelectInstanceLockByHolderSQL = `
-		SELECT held_by, lock_target, locked_at 
-		FROM locks 
-		WHERE held_by = ? AND lock_type = 'instance'
-	`
-	SelectInstanceLockHoldersAscSQL = `
-		SELECT held_by, lock_target, locked_at 
-		FROM locks 
-		WHERE lock_type = 'instance' 
-		ORDER BY locked_at ASC
-	`
-
-	// DeleteInstanceLockSQL deletes an instance lock by address
-	DeleteInstanceLockSQL = `
-		DELETE FROM locks 
-		WHERE held_by = ? AND lock_type = 'instance'
-	`
-
-	InsertFileLockSQL = `
-		INSERT INTO locks (held_by, lock_type, lock_target, locked_at)
-		VALUES (?, 'file', ?, ?)
-	`
-
-	// DeleteFileLockSQL deletes a file lock by holder and target
-	DeleteFileLockSQL = `
-		DELETE FROM locks 
-		WHERE held_by = ? AND lock_type = 'file' AND lock_target = ?
-		`
-
-	// CountInstanceLockSQL counts instance locks for a given address
-	CountInstanceLockSQL = `
-		SELECT COUNT(*) FROM locks 
-		WHERE held_by = ? AND lock_type = 'instance'
-	`
-
-	// InsertInstanceLockSQL inserts or replaces an instance lock
-	InsertInstanceLockSQL = `
-		INSERT OR REPLACE INTO locks (held_by, lock_type, lock_target, locked_at)
-		VALUES (?, 'instance', ?, ?)
-	`
-)

cli/pkg/common/types.go

@@ -1,54 +0,0 @@
-package common
-
-import (
-	"time"
-
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// CoreInstanceInfo represents a discovered Cline instance
-// This is the canonical definition used across all CLI packages
-type CoreInstanceInfo struct {
-	// Full core address including port
-	Address string `json:"address"`
-	// Host bridge service address that core holds (host is ALWAYS running on localhost FYI)
-	HostServiceAddress string                                           `json:"host_port"`
-	Status             grpc_health_v1.HealthCheckResponse_ServingStatus `json:"status"`
-	LastSeen           time.Time                                        `json:"last_seen"`
-	ProcessPID         int                                              `json:"process_pid,omitempty"`
-	Version            string                                           `json:"version,omitempty"`
-}
-
-func (c *CoreInstanceInfo) CorePort() int {
-	_, port, _ := ParseHostPort(c.Address)
-	return port
-}
-
-func (c *CoreInstanceInfo) HostPort() int {
-	_, port, _ := ParseHostPort(c.HostServiceAddress)
-	return port
-}
-
-func (c *CoreInstanceInfo) StatusString() string {
-	return c.Status.String()
-}
-
-// LockRow represents a row in the locks table
-type LockRow struct {
-	ID         int64  `json:"id"`
-	HeldBy     string `json:"held_by"`
-	LockType   string `json:"lock_type"`
-	LockTarget string `json:"lock_target"`
-	LockedAt   int64  `json:"locked_at"`
-}
-
-// InstancesOutput represents the JSON output format for instance listing
-type InstancesOutput struct {
-	DefaultInstance string             `json:"default_instance"`
-	CoreInstances   []CoreInstanceInfo `json:"instances"`
-}
-
-type DefaultCoreInstance struct {
-	Address     string `json:"default_instance"`
-	LastUpdated string `json:"last_updated"`
-}

cli/pkg/common/utils.go

@@ -1,159 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"strconv"
-	"time"
-
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// ParseHostPort parses a host:port address and returns the host and port separately
-func ParseHostPort(address string) (string, int, error) {
-	host, portStr, err := net.SplitHostPort(address)
-	if err != nil {
-		return "", 0, err
-	}
-	port, err := strconv.Atoi(portStr)
-	if err != nil {
-		return "", 0, err
-	}
-	return host, port, nil
-}
-
-// IsLocalAddress checks if the given host is a local/loopback address
-// Supports both IPv4 (localhost, 127.0.0.1) and IPv6 (::1) addresses
-func IsLocalAddress(host string) bool {
-	// Handle common localhost names
-	if host == "localhost" {
-		return true
-	}
-
-	// Parse as IP and check if it's a loopback
-	if ip := net.ParseIP(host); ip != nil {
-		return ip.IsLoopback()
-	}
-
-	return false
-}
-
-// PerformHealthCheck performs a gRPC health check on the given address
-// Will return UNKNOWN if the service is unreachable (error)
-func PerformHealthCheck(ctx context.Context, address string) (grpc_health_v1.HealthCheckResponse_ServingStatus, error) {
-	conn, err := grpc.DialContext(ctx, address, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	if err != nil {
-		return grpc_health_v1.HealthCheckResponse_UNKNOWN, err
-	}
-	defer conn.Close()
-
-	healthClient := grpc_health_v1.NewHealthClient(conn)
-	resp, err := healthClient.Check(ctx, &grpc_health_v1.HealthCheckRequest{})
-	if err != nil {
-		return grpc_health_v1.HealthCheckResponse_UNKNOWN, err
-	}
-
-	return resp.Status, nil
-}
-
-// It's healthy if we can reach it and it responds with SERVING
-func IsInstanceHealthy(ctx context.Context, address string) bool {
-	status, err := PerformHealthCheck(ctx, address)
-	return err == nil && status == grpc_health_v1.HealthCheckResponse_SERVING
-}
-
-// It's (likely) our instance if we can reach it and it responds to health checks
-func IsInstanceOurs(ctx context.Context, address string) bool {
-	_, err := PerformHealthCheck(ctx, address)
-	return err != nil
-}
-
-// (unreachable or not serving)
-func IsInstanceStale(ctx context.Context, address string) (grpc_health_v1.HealthCheckResponse_ServingStatus, bool, error) {
-	status, err := PerformHealthCheck(ctx, address)
-	isStale := err != nil || status != grpc_health_v1.HealthCheckResponse_SERVING
-	return status, isStale, err
-}
-
-// IsPortAvailable checks if a port is available for binding
-func IsPortAvailable(port int) bool {
-	address := fmt.Sprintf("localhost:%d", port)
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		return false
-	}
-	listener.Close()
-	return true
-}
-
-// FindAvailablePortPair finds two available ports by letting the OS allocate them
-func FindAvailablePortPair() (corePort, hostPort int, err error) {
-	coreListener, err := net.Listen("tcp", ":0")
-	if err != nil {
-		return 0, 0, err
-	}
-	defer coreListener.Close()
-
-	hostListener, err := net.Listen("tcp", ":0")
-	if err != nil {
-		return 0, 0, err
-	}
-	defer hostListener.Close()
-
-	corePort = coreListener.Addr().(*net.TCPAddr).Port
-	hostPort = hostListener.Addr().(*net.TCPAddr).Port
-
-	return corePort, hostPort, nil
-}
-
-// NormalizeAddressForGRPC converts address to host:port for grpc client with proper normalization
-func NormalizeAddressForGRPC(address string) (string, error) {
-	host, port, err := ParseHostPort(address)
-	if err != nil {
-		return "", err
-	}
-
-	// Normalize local addresses to localhost for gRPC compatibility
-	if IsLocalAddress(host) {
-		return fmt.Sprintf("localhost:%d", port), nil
-	}
-
-	return address, nil
-}
-
-// RetryOperation performs an operation with retry logic
-func RetryOperation(maxRetries int, timeoutPerAttempt time.Duration, operation func() error) error {
-	var lastErr error
-
-	for attempt := 1; attempt <= maxRetries; attempt++ {
-		ctx, cancel := context.WithTimeout(context.Background(), timeoutPerAttempt)
-
-		// Create a channel to capture the operation result
-		done := make(chan error, 1)
-		go func() {
-			done <- operation()
-		}()
-
-		select {
-		case err := <-done:
-			cancel()
-			if err == nil {
-				return nil // Success
-			}
-			lastErr = err
-		case <-ctx.Done():
-			cancel()
-			lastErr = ctx.Err()
-		}
-
-		// Add delay between attempts (except for the last one)
-		if attempt < maxRetries {
-			time.Sleep(1 * time.Second)
-		}
-	}
-
-	return fmt.Errorf("operation failed after %d attempts: %w", maxRetries, lastErr)
-}

cli/pkg/hostbridge/diff.go

@@ -1,351 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-
-	proto "github.com/cline/grpc-go/host"
-)
-
-// diffSession represents an in-memory diff editing session
-type diffSession struct {
-	originalPath    string   // File path from OpenDiff request
-	originalContent []byte   // Original file content (for comparison)
-	currentContent  []byte   // Current modified content
-	lines           []string // Current content split into lines
-	encoding        string   // File encoding (default: utf8)
-}
-
-// DiffService implements the proto.DiffServiceServer interface
-type DiffService struct {
-	proto.UnimplementedDiffServiceServer
-	verbose  bool
-	sessions *sync.Map // thread-safe: diffId -> *diffSession
-	counter  *int64    // atomic counter for unique IDs
-}
-
-// NewDiffService creates a new DiffService
-func NewDiffService(verbose bool) *DiffService {
-	counter := int64(0)
-	return &DiffService{
-		verbose:  verbose,
-		sessions: &sync.Map{},
-		counter:  &counter,
-	}
-}
-
-// generateDiffID creates a unique diff ID
-func (s *DiffService) generateDiffID() string {
-	id := atomic.AddInt64(s.counter, 1)
-	return fmt.Sprintf("diff_%d_%d", os.Getpid(), id)
-}
-
-// splitLines splits content into lines, preserving line ending information
-func splitLines(content string) []string {
-	if content == "" {
-		return []string{}
-	}
-
-	lines := []string{}
-	current := ""
-
-	for _, char := range content {
-		if char == '\n' {
-			lines = append(lines, current)
-			current = ""
-		} else if char != '\r' { // Skip \r characters, handle \r\n as \n
-			current += string(char)
-		}
-	}
-
-	// Add the last line if it doesn't end with newline
-	if current != "" {
-		lines = append(lines, current)
-	}
-
-	return lines
-}
-
-// joinLines joins lines back into content with newlines
-func joinLines(lines []string) string {
-	if len(lines) == 0 {
-		return ""
-	}
-	return strings.Join(lines, "\n")
-}
-
-// OpenDiff opens a diff view for the specified file
-func (s *DiffService) OpenDiff(ctx context.Context, req *proto.OpenDiffRequest) (*proto.OpenDiffResponse, error) {
-	if s.verbose {
-		log.Printf("OpenDiff called for path: %s", req.GetPath())
-	}
-
-	diffID := s.generateDiffID()
-
-	var originalContent []byte
-
-	// Check if file exists and read original content
-	if req.GetPath() != "" {
-		if _, err := os.Stat(req.GetPath()); err == nil {
-			// File exists, read its content
-			var readErr error
-			originalContent, readErr = ioutil.ReadFile(req.GetPath())
-			if readErr != nil {
-				return nil, fmt.Errorf("failed to read original file: %w", readErr)
-			}
-		} else {
-			// File doesn't exist, use empty content
-			originalContent = []byte{}
-		}
-	}
-
-	// Use provided content as the initial current content
-	currentContent := []byte(req.GetContent())
-
-	// Create the diff session
-	session := &diffSession{
-		originalPath:    req.GetPath(),
-		originalContent: originalContent,
-		currentContent:  currentContent,
-		lines:           splitLines(req.GetContent()),
-		encoding:        "utf8", // Default encoding
-	}
-
-	// Store the session
-	s.sessions.Store(diffID, session)
-
-	if s.verbose {
-		log.Printf("Created diff session: %s (original: %d bytes, current: %d bytes)",
-			diffID, len(originalContent), len(currentContent))
-	}
-
-	return &proto.OpenDiffResponse{
-		DiffId: &diffID,
-	}, nil
-}
-
-// GetDocumentText returns the current content of the diff document
-func (s *DiffService) GetDocumentText(ctx context.Context, req *proto.GetDocumentTextRequest) (*proto.GetDocumentTextResponse, error) {
-	if s.verbose {
-		log.Printf("GetDocumentText called for diff ID: %s", req.GetDiffId())
-	}
-
-	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
-	if !exists {
-		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
-	}
-
-	session := sessionInterface.(*diffSession)
-	content := string(session.currentContent)
-
-	return &proto.GetDocumentTextResponse{
-		Content: &content,
-	}, nil
-}
-
-// ReplaceText replaces text in the diff document using line-based operations
-func (s *DiffService) ReplaceText(ctx context.Context, req *proto.ReplaceTextRequest) (*proto.ReplaceTextResponse, error) {
-	if s.verbose {
-		log.Printf("ReplaceText called for diff ID: %s, lines %d-%d",
-			req.GetDiffId(), req.GetStartLine(), req.GetEndLine())
-	}
-
-	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
-	if !exists {
-		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
-	}
-
-	session := sessionInterface.(*diffSession)
-
-	startLine := int(req.GetStartLine())
-	endLine := int(req.GetEndLine())
-	newContent := req.GetContent()
-
-	// Validate line ranges
-	if startLine < 0 {
-		startLine = 0
-	}
-	if endLine < startLine {
-		endLine = startLine
-	}
-
-	// Split new content into lines
-	newLines := splitLines(newContent)
-
-	// Ensure we have enough lines in the current content
-	for len(session.lines) < endLine {
-		session.lines = append(session.lines, "")
-	}
-
-	// Replace the specified line range
-	if endLine > len(session.lines) {
-		// Extending beyond current content - append new lines
-		session.lines = append(session.lines[:startLine], newLines...)
-	} else {
-		// Replace within existing content
-		result := make([]string, 0, len(session.lines)-endLine+startLine+len(newLines))
-		result = append(result, session.lines[:startLine]...)
-		result = append(result, newLines...)
-		result = append(result, session.lines[endLine:]...)
-		session.lines = result
-	}
-
-	// Update current content
-	session.currentContent = []byte(joinLines(session.lines))
-
-	// Store the updated session
-	s.sessions.Store(req.GetDiffId(), session)
-
-	if s.verbose {
-		log.Printf("Updated diff session %s: %d lines, %d bytes",
-			req.GetDiffId(), len(session.lines), len(session.currentContent))
-	}
-
-	return &proto.ReplaceTextResponse{}, nil
-}
-
-// ScrollDiff scrolls the diff view to a specific line (no-op for CLI)
-func (s *DiffService) ScrollDiff(ctx context.Context, req *proto.ScrollDiffRequest) (*proto.ScrollDiffResponse, error) {
-	if s.verbose {
-		log.Printf("ScrollDiff called for diff ID: %s, line: %d", req.GetDiffId(), req.GetLine())
-	}
-
-	// Verify session exists
-	if _, exists := s.sessions.Load(req.GetDiffId()); !exists {
-		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
-	}
-
-	// In a CLI implementation, scrolling is a no-op
-	// In a GUI implementation, this would scroll the view to the specified line
-	return &proto.ScrollDiffResponse{}, nil
-}
-
-// TruncateDocument truncates the diff document at the specified line
-func (s *DiffService) TruncateDocument(ctx context.Context, req *proto.TruncateDocumentRequest) (*proto.TruncateDocumentResponse, error) {
-	if s.verbose {
-		log.Printf("TruncateDocument called for diff ID: %s, end line: %d", req.GetDiffId(), req.GetEndLine())
-	}
-
-	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
-	if !exists {
-		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
-	}
-
-	session := sessionInterface.(*diffSession)
-	endLine := int(req.GetEndLine())
-
-	// Truncate lines at the specified position
-	if endLine >= 0 && endLine < len(session.lines) {
-		session.lines = session.lines[:endLine]
-		session.currentContent = []byte(joinLines(session.lines))
-
-		// Store the updated session
-		s.sessions.Store(req.GetDiffId(), session)
-
-		if s.verbose {
-			log.Printf("Truncated diff session %s to %d lines", req.GetDiffId(), len(session.lines))
-		}
-	}
-
-	return &proto.TruncateDocumentResponse{}, nil
-}
-
-// SaveDocument saves the diff document to the original file
-func (s *DiffService) SaveDocument(ctx context.Context, req *proto.SaveDocumentRequest) (*proto.SaveDocumentResponse, error) {
-	if s.verbose {
-		log.Printf("SaveDocument called for diff ID: %s", req.GetDiffId())
-	}
-
-	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
-	if !exists {
-		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
-	}
-
-	session := sessionInterface.(*diffSession)
-
-	if session.originalPath == "" {
-		return nil, fmt.Errorf("no file path specified for diff session: %s", req.GetDiffId())
-	}
-
-	// Create parent directories if they don't exist
-	dir := filepath.Dir(session.originalPath)
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create directories: %w", err)
-	}
-
-	// Write the current content to the original file
-	if err := ioutil.WriteFile(session.originalPath, session.currentContent, 0644); err != nil {
-		return nil, fmt.Errorf("failed to save file: %w", err)
-	}
-
-	if s.verbose {
-		log.Printf("Saved diff session %s to file: %s (%d bytes)",
-			req.GetDiffId(), session.originalPath, len(session.currentContent))
-	}
-
-	return &proto.SaveDocumentResponse{}, nil
-}
-
-// CloseAllDiffs closes all diff views and cleans up all sessions
-func (s *DiffService) CloseAllDiffs(ctx context.Context, req *proto.CloseAllDiffsRequest) (*proto.CloseAllDiffsResponse, error) {
-	if s.verbose {
-		log.Printf("CloseAllDiffs called")
-	}
-
-	var count int64
-
-	s.sessions.Range(func(key, value any) bool {
-		// Optional: attempt to close if the value supports it
-		if c, ok := value.(interface{ Close() error }); ok {
-			_ = c.Close() // best-effort; ignore error
-		}
-
-		s.sessions.Delete(key)
-		atomic.AddInt64(&count, 1)
-		return true
-	})
-
-	if s.verbose {
-		log.Printf("Closed %d diff sessions", count)
-	}
-
-	return &proto.CloseAllDiffsResponse{}, nil
-}
-
-// OpenMultiFileDiff displays a diff view comparing before/after states for multiple files
-func (s *DiffService) OpenMultiFileDiff(ctx context.Context, req *proto.OpenMultiFileDiffRequest) (*proto.OpenMultiFileDiffResponse, error) {
-	if s.verbose {
-		log.Printf("OpenMultiFileDiff called with title: %s, %d files", req.GetTitle(), len(req.GetDiffs()))
-	}
-
-	// In a CLI implementation, we could display the diffs to console
-	// For now, we'll just log the information
-	title := req.GetTitle()
-	if title == "" {
-		title = "Multi-file diff"
-	}
-
-	if s.verbose {
-		log.Printf("=== %s ===", title)
-		for i, diff := range req.GetDiffs() {
-			log.Printf("File %d: %s", i+1, diff.GetFilePath())
-			log.Printf("  Left content: %d bytes", len(diff.GetLeftContent()))
-			log.Printf("  Right content: %d bytes", len(diff.GetRightContent()))
-		}
-	}
-
-	// In a more sophisticated CLI implementation, we could:
-	// 1. Use a diff library to generate unified diffs
-	// 2. Display them with colors
-	// 3. Allow navigation between files
-	// For now, this is a no-op that just acknowledges the request
-
-	return &proto.OpenMultiFileDiffResponse{}, nil
-}

cli/pkg/hostbridge/disabled/watch.go

@@ -1,39 +0,0 @@
-package hostbridge
-
-import (
-	"log"
-
-	"github.com/cline/grpc-go/host"
-)
-
-// WatchService implements the host.WatchServiceServer interface
-type WatchService struct {
-	host.UnimplementedWatchServiceServer
-	coreAddress string
-	verbose     bool
-}
-
-// NewWatchService creates a new WatchService
-func NewWatchService(coreAddress string, verbose bool) *WatchService {
-	return &WatchService{
-		coreAddress: coreAddress,
-		verbose:     verbose,
-	}
-}
-
-// SubscribeToFile subscribes to file change notifications
-func (s *WatchService) SubscribeToFile(req *host.SubscribeToFileRequest, stream host.WatchService_SubscribeToFileServer) error {
-	if s.verbose {
-		log.Printf("SubscribeToFile called for path: %s", req.GetPath())
-	}
-
-	// For console implementation, we'll just log that we would watch the file
-	// In a real implementation, we'd use fsnotify or similar to watch file changes
-	log.Printf("[Cline] Would watch file: %s", req.GetPath())
-
-	// Keep the stream open but don't send any events for now
-	// In a real implementation, we'd send FileChangeEvent messages when files change
-	<-stream.Context().Done()
-
-	return nil
-}

cli/pkg/hostbridge/disabled/window.go

@@ -1,63 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	proto "github.com/cline/grpc-go/host"
-)
-
-// WindowService implements the proto.WindowServiceServer interface
-type WindowService struct {
-	proto.UnimplementedWindowServiceServer
-	coreAddress string
-	verbose     bool
-}
-
-// NewWindowService creates a new WindowService
-func NewWindowService(coreAddress string, verbose bool) *WindowService {
-	return &WindowService{
-		coreAddress: coreAddress,
-		verbose:     verbose,
-	}
-}
-
-// ShowTextDocument opens a text document for viewing/editing
-func (s *WindowService) ShowTextDocument(ctx context.Context, req *proto.ShowTextDocumentRequest) (*proto.TextEditorInfo, error) {
-	if s.verbose {
-		log.Printf("ShowTextDocument called for path: %s", req.GetPath())
-	}
-
-	// For console implementation, we'll just log that we would open the document
-	fmt.Printf("[Cline] Would open document: %s\n", req.GetPath())
-
-	return &proto.TextEditorInfo{
-		DocumentPath: req.GetPath(),
-		IsActive:     true,
-	}, nil
-}
-
-// ShowOpenDialogue shows a file open dialog
-func (s *WindowService) ShowOpenDialogue(ctx context.Context, req *proto.ShowOpenDialogueRequest) (*proto.SelectedResources, error) {
-	if s.verbose {
-		log.Printf("ShowOpenDialogue called")
-	}
-
-	// For console implementation, return empty list (user cancelled)
-	return &proto.SelectedResources{
-		Paths: []string{},
-	}, nil
-}
-
-// ShowMessage displays a message to the user
-func (s *WindowService) ShowMessage(ctx context.Context, req *proto.ShowMessageRequest) (*proto.SelectedResponse, error) {
-	if s.verbose {
-		log.Printf("ShowMessage called: %s", req.GetMessage())
-	}
-
-	// Display message to console
-	fmt.Printf("[Cline] %s\n", req.GetMessage())
-
-	return &proto.SelectedResponse{}, nil
-}

cli/pkg/hostbridge/disabled/workspace.go

@@ -1,66 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"log"
-	"os"
-
-	"github.com/cline/grpc-go/host"
-)
-
-// WorkspaceService implements the host.WorkspaceServiceServer interface
-type WorkspaceService struct {
-	host.UnimplementedWorkspaceServiceServer
-	coreAddress string
-	verbose     bool
-}
-
-// NewWorkspaceService creates a new WorkspaceService
-func NewWorkspaceService(coreAddress string, verbose bool) *WorkspaceService {
-	return &WorkspaceService{
-		coreAddress: coreAddress,
-		verbose:     verbose,
-	}
-}
-
-// GetWorkspacePaths returns the workspace directory paths
-func (s *WorkspaceService) GetWorkspacePaths(ctx context.Context, req *host.GetWorkspacePathsRequest) (*host.GetWorkspacePathsResponse, error) {
-	if s.verbose {
-		log.Printf("GetWorkspacePaths called")
-	}
-
-	// Get current working directory as the workspace
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, err
-	}
-
-	return &host.GetWorkspacePathsResponse{
-		Paths: []string{cwd},
-	}, nil
-}
-
-// SaveOpenDocumentIfDirty saves an open document if it has unsaved changes
-func (s *WorkspaceService) SaveOpenDocumentIfDirty(ctx context.Context, req *host.SaveOpenDocumentIfDirtyRequest) (*host.SaveOpenDocumentIfDirtyResponse, error) {
-	if s.verbose {
-		log.Printf("SaveOpenDocumentIfDirty called for path: %s", req.GetPath())
-	}
-
-	// For console implementation, we'll assume the document is already saved
-	// In a real implementation, we'd check if the file has unsaved changes
-	return &host.SaveOpenDocumentIfDirtyResponse{
-		WasSaved: false, // Assume no changes to save
-	}, nil
-}
-
-// GetDiagnostics returns diagnostic information for a file
-func (s *WorkspaceService) GetDiagnostics(ctx context.Context, req *host.GetDiagnosticsRequest) (*host.GetDiagnosticsResponse, error) {
-	if s.verbose {
-		log.Printf("GetDiagnostics called for path: %s", req.GetPath())
-	}
-
-	// For console implementation, return empty diagnostics
-	return &host.GetDiagnosticsResponse{
-		Diagnostics: []*host.Diagnostic{},
-	}, nil
-}

cli/pkg/hostbridge/env.go

@@ -1,98 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"log"
-
-	"github.com/cline/grpc-go/cline"
-	"github.com/cline/grpc-go/host"
-)
-
-// Global shutdown channel - simple approach
-var globalShutdownCh chan struct{}
-
-func init() {
-	globalShutdownCh = make(chan struct{})
-}
-
-// EnvService implements the host.EnvServiceServer interface
-type EnvService struct {
-	host.UnimplementedEnvServiceServer
-	verbose bool
-}
-
-// NewEnvService creates a new EnvService
-func NewEnvService(verbose bool) *EnvService {
-	return &EnvService{
-		verbose: verbose,
-	}
-}
-
-// ClipboardWriteText writes text to the system clipboard
-func (s *EnvService) ClipboardWriteText(ctx context.Context, req *cline.StringRequest) (*cline.Empty, error) {
-	if s.verbose {
-		log.Printf("ClipboardWriteText called with: %s", req.GetValue())
-	}
-
-	// TODO: Implement actual clipboard functionality
-	// For now, just return success
-	return &cline.Empty{}, nil
-}
-
-// ClipboardReadText reads text from the system clipboard
-func (s *EnvService) ClipboardReadText(ctx context.Context, req *cline.EmptyRequest) (*cline.String, error) {
-	if s.verbose {
-		log.Printf("ClipboardReadText called")
-	}
-
-	// TODO: Implement actual clipboard functionality
-	// For now, return empty string
-	return &cline.String{
-		Value: "",
-	}, nil
-}
-
-// GetMachineId returns a stable machine identifier for telemetry distinctId purposes
-func (s *EnvService) GetMachineId(ctx context.Context, req *cline.EmptyRequest) (*cline.String, error) {
-	if s.verbose {
-		log.Printf("GetMachineId called")
-	}
-
-	// TODO: Implement actual machine ID functionality
-	// For now, return empty string
-	return &cline.String{
-		Value: "",
-	}, nil
-}
-
-// GetHostVersion returns the host platform name and version
-func (s *EnvService) GetHostVersion(ctx context.Context, req *cline.EmptyRequest) (*host.GetHostVersionResponse, error) {
-	if s.verbose {
-		log.Printf("GetHostVersion called")
-	}
-
-	// TODO: Implement actual host version functionality
-	// For now, return empty response
-	return &host.GetHostVersionResponse{}, nil
-}
-
-// Shutdown initiates a graceful shutdown of the host bridge service
-func (s *EnvService) Shutdown(ctx context.Context, req *cline.EmptyRequest) (*cline.Empty, error) {
-	if s.verbose {
-		log.Printf("Shutdown requested via RPC")
-	}
-
-	// Trigger global shutdown signal
-	select {
-	case globalShutdownCh <- struct{}{}:
-		if s.verbose {
-			log.Printf("Shutdown signal sent successfully")
-		}
-	default:
-		if s.verbose {
-			log.Printf("Shutdown signal already pending")
-		}
-	}
-
-	return &cline.Empty{}, nil
-}

cli/pkg/hostbridge/grpc_server.go

@@ -1,113 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"net"
-
-	"github.com/cline/grpc-go/host"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/health"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// GrpcServer provides gRPC hostbridge functionality
-type GrpcServer struct {
-	port       int
-	verbose    bool
-	server     *grpc.Server
-	shutdownCh chan struct{}
-}
-
-// NewGrpcServer creates a new GrpcServer
-func NewGrpcServer(port int, verbose bool) *GrpcServer {
-	return &GrpcServer{
-		port:       port,
-		verbose:    verbose,
-		shutdownCh: make(chan struct{}),
-	}
-}
-
-// Start starts the gRPC hostbridge server
-func (s *GrpcServer) Start(ctx context.Context) error {
-	if s.verbose {
-		log.Printf("Starting gRPC hostbridge server on port %d", s.port)
-	}
-
-	// Create listener
-	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.port))
-	if err != nil {
-		return fmt.Errorf("failed to listen on port %d: %w", s.port, err)
-	}
-
-	// Create gRPC server
-	s.server = grpc.NewServer()
-
-	// Register health service
-	healthServer := health.NewServer()
-	healthServer.SetServingStatus("", grpc_health_v1.HealthCheckResponse_SERVING)
-	grpc_health_v1.RegisterHealthServer(s.server, healthServer)
-
-	// Register services
-	workspaceService := NewSimpleWorkspaceService(s.verbose)
-	host.RegisterWorkspaceServiceServer(s.server, workspaceService)
-
-	windowService := NewWindowService(s.verbose)
-	host.RegisterWindowServiceServer(s.server, windowService)
-
-	diffService := NewDiffService(s.verbose)
-	host.RegisterDiffServiceServer(s.server, diffService)
-
-	envService := NewEnvService(s.verbose)
-	host.RegisterEnvServiceServer(s.server, envService)
-
-	if s.verbose {
-		log.Printf("Registered HealthService")
-		log.Printf("Registered WorkspaceService")
-		log.Printf("Registered WindowService")
-		log.Printf("Registered DiffService")
-		log.Printf("Registered EnvService")
-	}
-
-	// Start server in goroutine
-	go func() {
-		if s.verbose {
-			log.Printf("gRPC server listening on :%d", s.port)
-		}
-		if err := s.server.Serve(lis); err != nil {
-			log.Printf("gRPC server error: %v", err)
-		}
-	}()
-
-	// Wait for context cancellation or global shutdown signal
-	select {
-	case <-ctx.Done():
-		if s.verbose {
-			log.Println("Context cancelled, shutting down gRPC hostbridge server...")
-		}
-	case <-globalShutdownCh:
-		if s.verbose {
-			log.Println("Shutdown requested via RPC, shutting down gRPC hostbridge server...")
-		}
-	}
-
-	// Graceful shutdown
-	s.server.GracefulStop()
-
-	if s.verbose {
-		log.Println("gRPC hostbridge server stopped")
-	}
-
-	return nil
-}
-
-// TriggerShutdown triggers a graceful shutdown of the server
-func (s *GrpcServer) TriggerShutdown() {
-	select {
-	case s.shutdownCh <- struct{}{}:
-		// Shutdown signal sent
-	default:
-		// Channel already has a signal or is closed
-	}
-}

cli/pkg/hostbridge/simple.go

@@ -1,43 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"fmt"
-	"log"
-)
-
-// Simple implementations that don't rely on proto files for now
-// This allows us to test the basic hostbridge structure
-
-// SimpleService provides basic hostbridge functionality
-type SimpleService struct {
-	coreAddress string
-	verbose     bool
-}
-
-// NewSimpleService creates a new SimpleService
-func NewSimpleService(coreAddress string, verbose bool) *SimpleService {
-	return &SimpleService{
-		coreAddress: coreAddress,
-		verbose:     verbose,
-	}
-}
-
-// Start starts the simple hostbridge service
-func (s *SimpleService) Start(ctx context.Context) error {
-	if s.verbose {
-		log.Printf("Starting simple hostbridge service (connecting to core at %s)", s.coreAddress)
-	}
-
-	// For now, just log that we're running
-	fmt.Printf("[Cline Host Bridge] Service started on core address: %s\n", s.coreAddress)
-
-	// Keep running until context is cancelled
-	<-ctx.Done()
-
-	if s.verbose {
-		log.Println("Simple hostbridge service stopped")
-	}
-
-	return nil
-}

cli/pkg/hostbridge/simple_workspace.go

@@ -1,65 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"log"
-	"os"
-
-	"github.com/cline/grpc-go/cline"
-	"github.com/cline/grpc-go/host"
-)
-
-// SimpleWorkspaceService implements a basic workspace service without complex dependencies
-type SimpleWorkspaceService struct {
-	host.UnimplementedWorkspaceServiceServer
-	verbose bool
-}
-
-// NewSimpleWorkspaceService creates a new SimpleWorkspaceService
-func NewSimpleWorkspaceService(verbose bool) *SimpleWorkspaceService {
-	return &SimpleWorkspaceService{
-		verbose: verbose,
-	}
-}
-
-// GetWorkspacePaths returns the workspace directory paths
-func (s *SimpleWorkspaceService) GetWorkspacePaths(ctx context.Context, req *host.GetWorkspacePathsRequest) (*host.GetWorkspacePathsResponse, error) {
-	if s.verbose {
-		log.Printf("GetWorkspacePaths called")
-	}
-
-	// Get current working directory as the workspace
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, err
-	}
-
-	return &host.GetWorkspacePathsResponse{
-		Paths: []string{cwd},
-	}, nil
-}
-
-// SaveOpenDocumentIfDirty saves an open document if it has unsaved changes
-func (s *SimpleWorkspaceService) SaveOpenDocumentIfDirty(ctx context.Context, req *host.SaveOpenDocumentIfDirtyRequest) (*host.SaveOpenDocumentIfDirtyResponse, error) {
-	if s.verbose {
-		log.Printf("SaveOpenDocumentIfDirty called for path: %s", req.GetFilePath())
-	}
-
-	// For console implementation, we'll assume the document is already saved
-	wasSaved := false
-	return &host.SaveOpenDocumentIfDirtyResponse{
-		WasSaved: &wasSaved,
-	}, nil
-}
-
-// GetDiagnostics returns diagnostic information for a file - simplified version
-func (s *SimpleWorkspaceService) GetDiagnostics(ctx context.Context, req *host.GetDiagnosticsRequest) (*host.GetDiagnosticsResponse, error) {
-	if s.verbose {
-		log.Printf("GetDiagnostics called")
-	}
-
-	// For console implementation, return empty diagnostics
-	return &host.GetDiagnosticsResponse{
-		FileDiagnostics: []*cline.FileDiagnostics{},
-	}, nil
-}

cli/pkg/hostbridge/window.go

@@ -1,129 +0,0 @@
-package hostbridge
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	proto "github.com/cline/grpc-go/host"
-)
-
-// WindowService implements the proto.WindowServiceServer interface
-type WindowService struct {
-	proto.UnimplementedWindowServiceServer
-	verbose bool
-}
-
-// NewWindowService creates a new WindowService
-func NewWindowService(verbose bool) *WindowService {
-	return &WindowService{
-		verbose: verbose,
-	}
-}
-
-// ShowTextDocument opens a text document for viewing/editing
-func (s *WindowService) ShowTextDocument(ctx context.Context, req *proto.ShowTextDocumentRequest) (*proto.TextEditorInfo, error) {
-	if s.verbose {
-		log.Printf("ShowTextDocument called for path: %s", req.GetPath())
-	}
-
-	// For console implementation, we'll just log that we would open the document
-	fmt.Printf("[Cline] Would open document: %s\n", req.GetPath())
-
-	return &proto.TextEditorInfo{
-		DocumentPath: req.GetPath(),
-		IsActive:     true,
-	}, nil
-}
-
-// ShowOpenDialogue shows a file open dialog
-func (s *WindowService) ShowOpenDialogue(ctx context.Context, req *proto.ShowOpenDialogueRequest) (*proto.SelectedResources, error) {
-	if s.verbose {
-		log.Printf("ShowOpenDialogue called")
-	}
-
-	// For console implementation, return empty list (user cancelled)
-	return &proto.SelectedResources{
-		Paths: []string{},
-	}, nil
-}
-
-// ShowMessage displays a message to the user
-func (s *WindowService) ShowMessage(ctx context.Context, req *proto.ShowMessageRequest) (*proto.SelectedResponse, error) {
-	if s.verbose {
-		log.Printf("ShowMessage called: %s", req.GetMessage())
-	}
-
-	// Display message to console
-	fmt.Printf("[Cline] %s\n", req.GetMessage())
-
-	return &proto.SelectedResponse{}, nil
-}
-
-// ShowInputBox shows an input dialog to the user
-func (s *WindowService) ShowInputBox(ctx context.Context, req *proto.ShowInputBoxRequest) (*proto.ShowInputBoxResponse, error) {
-	if s.verbose {
-		log.Printf("ShowInputBox called: %s", req.GetTitle())
-	}
-
-	// For console implementation, return empty response (user cancelled)
-	return &proto.ShowInputBoxResponse{}, nil
-}
-
-// ShowSaveDialog shows a save file dialog
-func (s *WindowService) ShowSaveDialog(ctx context.Context, req *proto.ShowSaveDialogRequest) (*proto.ShowSaveDialogResponse, error) {
-	if s.verbose {
-		log.Printf("ShowSaveDialog called")
-	}
-
-	// For console implementation, return empty response (user cancelled)
-	return &proto.ShowSaveDialogResponse{}, nil
-}
-
-// OpenFile opens a file in the editor
-func (s *WindowService) OpenFile(ctx context.Context, req *proto.OpenFileRequest) (*proto.OpenFileResponse, error) {
-	if s.verbose {
-		log.Printf("OpenFile called for path: %s", req.GetFilePath())
-	}
-
-	// For console implementation, just log that we would open the file
-	fmt.Printf("[Cline] Would open file: %s\n", req.GetFilePath())
-
-	return &proto.OpenFileResponse{}, nil
-}
-
-// GetOpenTabs returns a list of currently open tabs
-func (s *WindowService) GetOpenTabs(ctx context.Context, req *proto.GetOpenTabsRequest) (*proto.GetOpenTabsResponse, error) {
-	if s.verbose {
-		log.Printf("GetOpenTabs called")
-	}
-
-	// For console implementation, return empty list
-	return &proto.GetOpenTabsResponse{
-		Paths: []string{},
-	}, nil
-}
-
-// GetVisibleTabs returns a list of currently visible tabs
-func (s *WindowService) GetVisibleTabs(ctx context.Context, req *proto.GetVisibleTabsRequest) (*proto.GetVisibleTabsResponse, error) {
-	if s.verbose {
-		log.Printf("GetVisibleTabs called")
-	}
-
-	// For console implementation, return empty list
-	return &proto.GetVisibleTabsResponse{
-		Paths: []string{},
-	}, nil
-}
-
-// GetActiveEditor returns information about the current active editor
-func (s *WindowService) GetActiveEditor(ctx context.Context, req *proto.GetActiveEditorRequest) (*proto.GetActiveEditorResponse, error) {
-	if s.verbose {
-		log.Printf("GetActiveEditor called")
-	}
-
-	// Return empty response (no active file)
-	return &proto.GetActiveEditorResponse{
-		FilePath: nil,
-	}, nil
-}

docs/exploring-clines-tools/new-task-tool.mdx

@@ -105,11 +105,11 @@ Below is an example `.clinerules` file focused specifically on using `new_task`
 ````markdown
 # You MUST use the `new_task` tool: Task Handoff Strategy Guide
 
-**CRITICAL INSTRUCTIONS - YOU MUST FOLLOW THESE GUIDELINES**
+**⚠️ CRITICAL INSTRUCTIONS - YOU MUST FOLLOW THESE GUIDELINES ⚠️**
 
 This guide provides **MANDATORY** instructions for effectively breaking down complex tasks and implementing a smooth handoff process between tasks. You **MUST** follow these guidelines to ensure continuity, context preservation, and efficient task completion.
 
-## CONTEXT WINDOW MONITORING - MANDATORY ACTION REQUIRED
+## ⚠️ CONTEXT WINDOW MONITORING - MANDATORY ACTION REQUIRED ⚠️
 
 You **MUST** monitor the context window usage displayed in the environment details. When usage exceeds 50% of the available context window, you **MUST** initiate a task handoff using the `new_task` tool.
 
@@ -370,7 +370,7 @@ You **MUST** initiate task handoffs in these scenarios:
 5. **When switching focus areas** within a larger project
 6. **When different expertise** might be beneficial for different parts of the task
 
-**FINAL REMINDER - CRITICAL INSTRUCTION**
+**⚠️ FINAL REMINDER - CRITICAL INSTRUCTION ⚠️**
 
 You **MUST** monitor the context window usage in the environment details section. When it exceeds 50% (e.g., "105,000 / 200,000 tokens (53%)"), you **MUST** proactively initiate the task handoff process using the `ask_followup_question` tool followed by the `new_task` tool. You MUST use the `new_task` tool.
 

docs/mcp/mcp-server-development-protocol.mdx

@@ -3,7 +3,7 @@ title: "MCP Server Development Protocol"
 description: "This protocol is designed to streamline the development process of building MCP servers with Cline."
 ---
 
-> **Build and share your MCP servers with the world.** Once you've created a great MCP server, submit it to the [Cline MCP Marketplace](https://github.com/cline/mcp-marketplace) to make it discoverable and one-click installable by thousands of developers.
+> 🚀 **Build and share your MCP servers with the world.** Once you've created a great MCP server, submit it to the [Cline MCP Marketplace](https://github.com/cline/mcp-marketplace) to make it discoverable and one-click installable by thousands of developers.
 
 ## What Are MCP Servers?
 
@@ -35,7 +35,7 @@ Here's the complete MCP Server Development Protocol that should be placed in you
 ````markdown
 # MCP Server Development Protocol
 
-CRITICAL: DO NOT USE attempt_completion BEFORE TESTING
+⚠️ CRITICAL: DO NOT USE attempt_completion BEFORE TESTING ⚠️
 
 ## Step 1: Planning (PLAN MODE)
 
@@ -141,7 +141,7 @@ If ANY answer is "no", I MUST NOT use attempt_completion.
 1. Test Each Tool (REQUIRED)
    □ Test each tool with valid inputs
    □ Verify output format is correct
-   DO NOT PROCEED UNTIL ALL TOOLS TESTED
+   ⚠️ DO NOT PROCEED UNTIL ALL TOOLS TESTED
 
 ## Step 4: Completion
 
@@ -157,7 +157,7 @@ Only after ALL tools have been tested can attempt_completion be used.
 -   ✓ Must have comprehensive logging
 -   ✓ Must test each tool individually
 -   ✓ Must handle errors gracefully
--   NEVER skip testing before completion
+-   ⛔️ NEVER skip testing before completion
 ````
 
 When this `.clinerules` file is present in your working directory, Cline will:
@@ -171,7 +171,7 @@ When this `.clinerules` file is present in your working directory, Cline will:
 
 Creating an MCP server requires just a few simple steps to get started:
 
-### 1. Create a `.clinerules` file (IMPORTANT)
+### 1. Create a `.clinerules` file (🚨 IMPORTANT)
 
 First, add a `.clinerules` file to the root of your MCP working directory using the protocol above. This file configures Cline to use the MCP development protocol when working in this folder.
 

docs/prompting/prompt-engineering-guide.mdx

@@ -47,7 +47,7 @@ node_modules/
 *.xlsx
 ```
 
-## Prompting Cline
+## Prompting Cline 💬
 
 **Prompting is how you communicate your needs for a given task in the back-and-forth chat with Cline.** Cline understands natural language, so write conversationally.
 
@@ -88,9 +88,9 @@ Effective prompting involves:
 
 Here are some prompting tips that users have found helpful for working with Cline:
 
-## Our Community's Favorite Prompts
+## Our Community's Favorite Prompts 🌟
 
-### Memory and Confidence Checks
+### Memory and Confidence Checks 🧠
 
 -   **Memory Check** - _pacnpal_
 
@@ -108,7 +108,7 @@ Here are some prompting tips that users have found helpful for working with Clin
 
     Encourages critical thinking and makes decision-making transparent.
 
-### Code Quality Prompts
+### Code Quality Prompts 💻
 
 -   **Prevent Code Truncation**
 
@@ -126,7 +126,7 @@ Here are some prompting tips that users have found helpful for working with Clin
 
     Reinforces adherence to your settings dial ⚙️ configuration.
 
-### Code Organization
+### Code Organization 📋
 
 -   **Large File Refactoring** - _icklebil_
 
@@ -144,7 +144,7 @@ Here are some prompting tips that users have found helpful for working with Clin
 
     Ensures documentation stays in sync with code changes.
 
-### Analysis and Planning
+### Analysis and Planning 🔍
 
 -   **Structured Development** - _yellow_bat_coffee_
 
@@ -174,7 +174,7 @@ Here are some prompting tips that users have found helpful for working with Clin
 
     Identifies potential issues early in development.
 
-### Thoughtful Development
+### Thoughtful Development 🤔
 
 -   **Pause and Reflect** - _nickbaumann98_
 
@@ -200,7 +200,7 @@ Here are some prompting tips that users have found helpful for working with Clin
 
     Maintains quality through self-assessment.
 
-### Best Practices
+### Best Practices 🎯
 
 -   **Project Structure** - _kvs007_
 

docs/provider-config/sap-aicore.mdx

@@ -8,9 +8,10 @@ SAP AI Core and the generative AI hub help you to integrate LLMs and AI into new
 **Website:** [SAP Help Portal](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/what-is-sap-ai-core)
 
 
-<Info>
-SAP AI Core, and Generative AI Hub, are offerings from SAP BTP. You need an active SAP BTP contract and a existing subaccount with a SAP AI Core instance with the `extended` service plan (For more details about SAP AI Core service plans and their capabilities, see the [Service Plans documentation](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/service-plans)) to perform these steps.
-</Info>
+> 💡 **Information**
+>
+> SAP AI Core, and Generative AI Hub, are offerings from SAP BTP.
+> You need an active SAP BTP contract and a existing subaccount with a SAP AI Core instance with the `extended` service plan (For more details about SAP AI Core service plans and their capabilities, see the [Service Plans documentation](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/service-plans)) to perform these steps.
 
 ### Getting a Service Binding
 
@@ -69,6 +70,7 @@ When using OpenAI reasoning models (such as o1, o3, o3-mini, o4-mini) through SA
    - **Medium:** Balanced performance and token usage for most tasks
    - **High:** More thorough analysis with higher token usage, better for complex reasoning tasks
 
-<Note>
-This setting only applies when using OpenAI reasoning models (o1, o3, o3-mini, o4-mini, gpt-5, etc.) deployed through SAP AI Core. Other models will ignore this setting.
-</Note>
+> 💡 **Note**
+>
+> This setting only applies when using OpenAI reasoning models (o1, o3, o3-mini, o4-mini, gpt-5, etc.) deployed through SAP AI Core. Other models will ignore this setting.
+

docs/running-models-locally/lm-studio.mdx

@@ -3,16 +3,16 @@ title: "LM Studio"
 description: "A quick guide to setting up LM Studio for local AI model execution with Cline."
 ---
 
-## Setting Up LM Studio with Cline
+## 🤖 Setting Up LM Studio with Cline
 
 Run AI models locally using LM Studio with Cline.
 
-### Prerequisites
+### 📋 Prerequisites
 
 -   Windows, macOS, or Linux computer with AVX2 support
 -   Cline installed in VS Code
 
-### Setup Steps
+### 🚀 Setup Steps
 
 #### 1. Install LM Studio
 
@@ -75,45 +75,14 @@ Run AI models locally using LM Studio with Cline.
 	/>
 </Frame>
 
-### Recommended Model and Settings
-
-For the best experience with Cline, use **Qwen3 Coder 30B A3B Instruct**. This model delivers strong coding performance and reliable tool use.
-
-#### Critical Settings
-
-After loading your model in the Developer tab, configure these settings:
-
-1. **Context Length**: Set to 262,144 (the model's maximum)
-2. **KV Cache Quantization**: Leave unchecked (critical for consistent performance)
-3. **Flash Attention**: Enable if available (improves performance)
-
-#### Quantization Guide
-
-Choose quantization based on your RAM:
-
-- **32GB RAM**: Use 4-bit quantization (~17GB download)
-- **64GB RAM**: Use 8-bit quantization (~32GB download) for better quality
-- **128GB+ RAM**: Consider full precision or larger models
-
-#### Model Format
-
-- **Mac (Apple Silicon)**: Use MLX format for optimized performance
-- **Windows/Linux**: Use GGUF format
-
-### Enable Compact Prompts
-
-For optimal performance with local models, enable compact prompts in Cline settings. This reduces the prompt size by 90% while maintaining core functionality.
-
-Navigate to Cline Settings → Features → Use Compact Prompt and toggle it on.
-
-### Important Notes
+### ⚠️ Important Notes
 
 -   Start LM Studio before using with Cline
 -   Keep LM Studio running in background
 -   First model download may take several minutes depending on size
 -   Models are stored locally after download
 
-### Troubleshooting
+### 🔧 Troubleshooting
 
 1. If Cline can't connect to LM Studio:
 2. Verify LM Studio server is running (check Developer tab)

docs/running-models-locally/ollama.mdx

@@ -3,12 +3,12 @@ title: "Ollama"
 description: "A quick guide to setting up Ollama for local AI model execution with Cline."
 ---
 
-### Prerequisites
+### 📋 Prerequisites
 
 -   Windows, macOS, or Linux computer
 -   Cline installed in VS Code
 
-### Setup Steps
+### 🚀 Setup Steps
 
 #### 1. Install Ollama
 
@@ -53,50 +53,31 @@ description: "A quick guide to setting up Ollama for local AI model execution wi
 	/>
 </Frame>
 
-Your model is now ready to use within Cline.
+**✨ Your model is now ready to use within Cline!**
 
 #### 3. Configure Cline
 
+1. Open VS Code
+2. Click Cline settings icon
+3. Select "Ollama" as API provider
+4. Enter configuration:
+    - Base URL: `http://localhost:11434/` (default value, can be left as is)
+    - Select the model from your available options
+
 <Frame>
 	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/ollama-setup.gif"
-		alt="Complete Ollama setup process"
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/selecting-ollama-model-cline%20(3).gif"
+		alt="Configuring Cline with Ollama"
 	/>
 </Frame>
 
-Open VS Code and configure Cline:
-
-1. Click the Cline settings icon
-2. Select "Ollama" as your API provider
-3. Base URL: `http://localhost:11434/` (default, usually no need to change)
-4. Select your model from the dropdown
-
-### Recommended Models
-
-For the best experience with Cline, use **Qwen3 Coder 30B**. This model provides strong coding capabilities and reliable tool use for local development.
-
-To download it:
-```bash
-ollama run qwen3-coder-30b
-```
-
-Other capable models include:
-- `mistral-small` - Good balance of performance and speed
-- `devstral-small` - Optimized for coding tasks
-
-### Important Notes
+### ⚠️ Important Notes
 
 -   Start Ollama before using with Cline
 -   Keep Ollama running in background
 -   First model download may take several minutes
 
-### Enable Compact Prompts
-
-For better performance with local models, enable compact prompts in Cline settings. This reduces the prompt size by 90% while maintaining core functionality.
-
-Navigate to Cline Settings → Features → Use Compact Prompt and toggle it on.
-
-### Troubleshooting
+### 🔧 Troubleshooting
 
 If Cline can't connect to Ollama:
 

docs/running-models-locally/read-me-first.mdx

@@ -2,153 +2,108 @@
 title: "Read Me First"
 ---
 
-## Running Local Models with Cline
+## Running Local Models with Cline: What You Need to Know 🤖
 
-Local models have reached a turning point. For the first time, you can run Cline completely offline with genuinely capable models. No API costs, no data leaving your machine, no internet dependency.
+Cline is a powerful AI coding assistant that uses tool-calling to help you write, analyze, and modify code. While running models locally can save on API costs, there's an important trade-off: local models are significantly less reliable at using these essential tools.
 
-The key is choosing the right model for your hardware and configuring it properly.
+## Why Local Models Are Different 🔬
 
-## What You Need to Know
+When you run a "local version" of a model, you're actually running a drastically simplified copy of the original. This process, called distillation, is like trying to compress a professional chef's knowledge into a basic cookbook – you keep the simple recipes but lose the complex techniques and intuition.
 
-### Hardware Requirements
+Local models are created by training a smaller model to imitate a larger one, but they typically only retain 1-26% of the original model's capacity. This massive reduction means:
 
-Your RAM determines which models you can run:
+-   Less ability to understand complex contexts
+-   Reduced capability for multi-step reasoning
+-   Limited tool-use abilities
+-   Simplified decision-making process
 
-| RAM Tier | Recommended Model | Quantization | What You Get |
-| --- | --- | --- | --- |
-| 32GB | Qwen3 Coder 30B | 4-bit | Entry-level local coding |
-| 64GB | Qwen3 Coder 30B | 8-bit | Full Cline features |
-| 128GB+ | GLM-4.5-Air | 4-bit | Cloud-competitive performance |
+Think of it like running your development environment on a calculator instead of a computer – it might handle basic tasks, but complex operations become unreliable or impossible.
 
-### The Model That Works: Qwen3 Coder 30B
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(4).png"
+		alt="Local model comparison diagram"
+	/>
+</Frame>
 
-After extensive testing, **Qwen3 Coder 30B** is the only model under 70B parameters that reliably works with Cline. It brings:
+### What Actually Happens
 
-- 256K native context window
-- Strong tool-use capabilities
-- Repository-scale understanding
-- Reliable command execution
+When you run a local model with Cline:
 
-Most smaller models (7B-20B) fail with Cline. They produce broken outputs, refuse to execute commands, or can't handle tool use properly.
+#### Performance Impact 📉
 
-### Critical Configuration
+-   Responses are 5-10x slower than cloud services
+-   System resources (CPU, GPU, RAM) get heavily utilized
+-   Your computer may become less responsive for other tasks
 
-Getting local models to work requires specific settings:
+#### Tool Reliability Issues 🛠️
 
-**For LM Studio:**
-1. Context Length: 262,144 (maximum)
-2. KV Cache Quantization: OFF (critical)
-3. Flash Attention: ON (if available)
+-   Code analysis becomes less accurate
+-   File operations may be unreliable
+-   Browser automation capabilities are reduced
+-   Terminal commands might fail more often
+-   Complex multi-step tasks often break down
 
-**For All Local Models:**
-- Enable "Use Compact Prompt" in Cline settings
-- This reduces prompt size by 90% while maintaining core functionality
-- Essential for local inference performance
+### Hardware Requirements 💻
 
-### Quantization Explained
+You'll need at minimum:
 
-Quantization reduces model precision to fit on consumer hardware. Think of it as compression:
+-   Modern GPU with 8GB+ VRAM (RTX 3070 or better)
+-   32GB+ system RAM
+-   Fast SSD storage
+-   Good cooling solution
 
-- **4-bit**: ~75% size reduction. Completely usable for coding tasks.
-- **8-bit**: ~50% size reduction. Better quality, more nuanced responses.
-- **16-bit**: Full precision. Matches cloud APIs but requires 4x the memory.
+Even with this hardware, you'll be running smaller, less capable versions of models:
 
-For Qwen3 Coder 30B:
-- 4-bit: ~17GB download
-- 8-bit: ~32GB download
-- 16-bit: ~60GB download
+| Model Size | What You Get                                            |
+| ---------- | ------------------------------------------------------- |
+| 7B models  | Basic coding, limited tool use                          |
+| 14B models | Better coding, unstable tool use                        |
+| 32B models | Good coding, inconsistent tool use                      |
+| 70B models | Best local performance, but requires expensive hardware |
 
-### Model Format
+Put simply, the cloud (API) versions of these models are the full-bore version of the model. The full version of DeepSeek-R1 is 671B. These distilled models are essentially "watered-down" versions of the cloud model.
 
-Choose based on your platform:
+### Practical Recommendations 💡
 
-**MLX (Mac only)**
-- Optimized for Apple Silicon
-- Leverages Metal and AMX acceleration
-- Faster inference on M1/M2/M3 chips
+#### Consider This Approach
 
-**GGUF (Universal)**
-- Works on Windows, Linux, and Mac
-- Extensive quantization options
-- Broader tool compatibility
+1. Use cloud models for:
+    - Complex development tasks
+    - When tool reliability is crucial
+    - Multi-step operations
+    - Critical code changes
+2. Use local models for:
+    - Simple code completion
+    - Basic documentation
+    - When privacy is paramount
+    - Learning and experimentation
 
-## Performance Characteristics
+#### If You Must Go Local
 
-Local models perform differently than cloud APIs:
+-   Start with smaller models
+-   Keep tasks simple and focused
+-   Save work frequently
+-   Be prepared to switch to cloud models for complex operations
+-   Monitor system resources
 
-**Expect:**
-- Warmup time when first loading (normal, happens once)
-- Slower inference than cloud models
-- Context ingestion slows with very large repositories
+### Common Issues 🚨
 
-**Don't Expect:**
-- Instant responses like cloud APIs
-- Unlimited context processing speed
-- Zero configuration
+-   **"Tool execution failed":** Local models often struggle with complex tool chains. Simplify your prompt.
+-   **"No connection could be made because the target machine actively refused it":** This usually means that the Ollama or LM Studio server isn't running, or is running on a different port/address than Cline is configured to use. Double-check the Base URL address in your API Provider settings.
+-   **"Cline is having trouble...":** Increase your model's context length to its maximum size.
+-   **Slow or incomplete responses:** Local models can be slower than cloud-based models, especially on less powerful hardware. If performance is an issue, try using a smaller model. Expect significantly longer processing times.
+-   **System stability:** Watch for high GPU/CPU usage and temperature
+-   **Context limitations:** Local models often have smaller context windows than cloud models. Break tasks down into smaller pieces.
 
-## When Local Models Excel
+### Looking Ahead 🔮
 
-Use local models for:
+Local model capabilities are improving, but they're not yet a complete replacement for cloud services, especially for Cline's tool-based functionality. Consider your specific needs and hardware capabilities carefully before committing to a local-only approach.
 
-- Offline development where internet is unreliable
-- Privacy-sensitive projects where code can't leave your environment
-- Cost-conscious development where API usage would be prohibitive
-- Learning and experimentation with unlimited usage
+### Need Help? 🤝
 
-## When to Use Cloud Models
+-   Join our [Discord](https://discord.gg/cline) community and [r/cline](https://www.reddit.com/r/CLine/)
+-   Check the latest compatibility guides
+-   Share your experiences with other developers
 
-Cloud models still have advantages for:
-
-- Very large repositories exceeding local context limits
-- Multi-hour refactoring sessions needing maximum context
-- Teams requiring consistent performance across different hardware
-- Tasks requiring the absolute latest model capabilities
-
-## Common Issues
-
-**"Shell integration unavailable" or command execution fails**
-
-Switch to a simpler shell in Cline settings. Go to Cline Settings → Terminal → Default Terminal Profile and select "bash". This resolves 90% of terminal integration problems.
-
-**"No connection could be made"**
-
-Your local server (Ollama or LM Studio) isn't running, or is running on a different port. Check that:
-- The server is actually running
-- The Base URL in Cline settings matches your server's address
-- No firewall is blocking the connection
-
-**Slow or incomplete responses**
-
-This is normal for local models. They're significantly slower than cloud APIs. If it's too slow:
-- Try a smaller quantization (4-bit instead of 8-bit)
-- Reduce context window size
-- Enable compact prompts if you haven't already
-
-**Model seems confused or makes errors**
-
-Ensure you have:
-- Compact prompts enabled
-- KV Cache Quantization disabled (LM Studio)
-- Context length set to maximum
-- Sufficient RAM for your chosen quantization
-
-## Getting Started
-
-1. **Choose your runtime**: [LM Studio](/running-models-locally/lm-studio) or [Ollama](/running-models-locally/ollama)
-2. **Download Qwen3 Coder 30B** in the appropriate quantization for your RAM
-3. **Configure critical settings** as outlined above
-4. **Enable compact prompts** in Cline settings
-5. **Start coding** offline
-
-## The Reality of Local Models
-
-Local models are now genuinely useful for coding tasks, but they're not magic. You're trading some convenience and speed for privacy and cost savings. The setup requires attention to detail, and performance won't match top-tier cloud APIs.
-
-But for the first time, you can run a capable coding agent entirely on your laptop. That's a significant milestone.
-
-## Need Help?
-
-- Join our [Discord](https://discord.gg/cline) community
-- Visit [r/cline](https://www.reddit.com/r/CLine/) on Reddit
-- Check the [LM Studio guide](/running-models-locally/lm-studio) for detailed setup
-- See the [Ollama guide](/running-models-locally/ollama) for alternative setup
+Remember: When in doubt, prioritize reliability over cost savings for important development work.

go.work

@@ -1,3 +0,0 @@
-go 1.24.7
-
-use ./cli

go.work.sum

@@ -1,23 +0,0 @@
-cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw=
-cloud.google.com/go/compute/metadata v0.7.0/go.mod h1:j5MvL9PprKL39t166CoB1uVHfQMs4tFQZZcKwksXUjo=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.29.0/go.mod h1:Cz6ft6Dkn3Et6l2v2a9/RpN7epQ1GtDlO6lj8bEcOvw=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8=
-github.com/envoyproxy/go-control-plane v0.13.4/go.mod h1:kDfuBlDVsSj2MjrLEtRWtHlsWIFcGyB2RMO44Dc5GZA=
-github.com/envoyproxy/go-control-plane/envoy v1.32.4/go.mod h1:Gzjc5k8JcJswLjAx1Zm+wSYE20UrLtt7JZMWiWQXQEw=
-github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4=
-github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU=
-github.com/go-jose/go-jose/v4 v4.1.1/go.mod h1:BdsZGqgdO3b6tTc6LSE56wcDbMMLuPsw5d4ZD5f94kA=
-github.com/golang/glog v1.2.5/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
-github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g=
-github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4=
-go.opentelemetry.io/contrib/detectors/gcp v1.36.0/go.mod h1:IbBN8uAIIx734PTonTPxAxnjc2pQTxWNkwfstZ+6H2k=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/api v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:kXqgZtrWaf6qS3jZOCnCH7WYfrvFjkC51bM8fz3RsCA=

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "claude-dev",
-	"version": "3.32.6",
+	"version": "3.32.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "claude-dev",
-			"version": "3.32.6",
+			"version": "3.32.0",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.37.0",
@@ -36,7 +36,6 @@
 				"@vscode/codicons": "^0.0.36",
 				"archiver": "^7.0.1",
 				"axios": "^1.12.0",
-				"better-sqlite3": "^12.4.1",
 				"cheerio": "^1.0.0",
 				"chokidar": "^4.0.1",
 				"chrome-launcher": "^1.1.2",
@@ -107,7 +106,6 @@
 				"c8": "^10.1.3",
 				"chai": "^4.3.10",
 				"chalk": "5.6.2",
-				"cross-env": "^10.1.0",
 				"esbuild": "^0.25.0",
 				"grpc-tools": "^1.13.0",
 				"husky": "^9.1.7",
@@ -2110,13 +2108,6 @@
 				"kuler": "^2.0.0"
 			}
 		},
-		"node_modules/@epic-web/invariant": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/@epic-web/invariant/-/invariant-1.0.0.tgz",
-			"integrity": "sha512-lrTPqgvfFQtR/eY/qkIzp98OGdNJu0m5ji3q/nJI8v3SXkRKEnWiOxMmbvcSoAIzv/cGiuvRy57k4suKQSAdwA==",
-			"dev": true,
-			"license": "MIT"
-		},
 		"node_modules/@esbuild/darwin-arm64": {
 			"version": "0.25.0",
 			"cpu": [
@@ -6732,20 +6723,6 @@
 				"node": ">=4"
 			}
 		},
-		"node_modules/better-sqlite3": {
-			"version": "12.4.1",
-			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
-			"integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
-			"hasInstallScript": true,
-			"license": "MIT",
-			"dependencies": {
-				"bindings": "^1.5.0",
-				"prebuild-install": "^7.1.1"
-			},
-			"engines": {
-				"node": "20.x || 22.x || 23.x || 24.x"
-			}
-		},
 		"node_modules/big-integer": {
 			"version": "1.6.52",
 			"license": "Unlicense",
@@ -6793,15 +6770,6 @@
 				"url": "https://bevry.me/fund"
 			}
 		},
-		"node_modules/bindings": {
-			"version": "1.5.0",
-			"resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
-			"integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
-			"license": "MIT",
-			"dependencies": {
-				"file-uri-to-path": "1.0.0"
-			}
-		},
 		"node_modules/bluebird": {
 			"version": "3.4.7",
 			"license": "MIT"
@@ -7745,24 +7713,6 @@
 			"dev": true,
 			"license": "MIT"
 		},
-		"node_modules/cross-env": {
-			"version": "10.1.0",
-			"resolved": "https://registry.npmjs.org/cross-env/-/cross-env-10.1.0.tgz",
-			"integrity": "sha512-GsYosgnACZTADcmEyJctkJIoqAhHjttw7RsFrVoJNXbsWWqaq6Ym+7kZjq6mS45O0jij6vtiReppKQEtqWy6Dw==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@epic-web/invariant": "^1.0.0",
-				"cross-spawn": "^7.0.6"
-			},
-			"bin": {
-				"cross-env": "dist/bin/cross-env.js",
-				"cross-env-shell": "dist/bin/cross-env-shell.js"
-			},
-			"engines": {
-				"node": ">=20"
-			}
-		},
 		"node_modules/cross-spawn": {
 			"version": "7.0.6",
 			"license": "MIT",
@@ -7886,6 +7836,7 @@
 		},
 		"node_modules/decompress-response": {
 			"version": "6.0.0",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"mimic-response": "^3.1.0"
@@ -7899,6 +7850,7 @@
 		},
 		"node_modules/decompress-response/node_modules/mimic-response": {
 			"version": "3.1.0",
+			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=10"
@@ -7920,6 +7872,7 @@
 		},
 		"node_modules/deep-extend": {
 			"version": "0.6.0",
+			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=4.0.0"
@@ -8911,6 +8864,7 @@
 		},
 		"node_modules/expand-template": {
 			"version": "2.0.3",
+			"dev": true,
 			"license": "(MIT OR WTFPL)",
 			"engines": {
 				"node": ">=6"
@@ -9179,12 +9133,6 @@
 				"url": "https://github.com/sponsors/sindresorhus"
 			}
 		},
-		"node_modules/file-uri-to-path": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
-			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
-			"license": "MIT"
-		},
 		"node_modules/fill-keys": {
 			"version": "1.0.2",
 			"dev": true,
@@ -9839,6 +9787,7 @@
 		},
 		"node_modules/github-from-package": {
 			"version": "0.0.0",
+			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/glob": {
@@ -10312,6 +10261,7 @@
 		},
 		"node_modules/ini": {
 			"version": "1.3.8",
+			"dev": true,
 			"license": "ISC"
 		},
 		"node_modules/internal-slot": {
@@ -12051,6 +12001,7 @@
 		},
 		"node_modules/mkdirp-classic": {
 			"version": "0.5.3",
+			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/mocha": {
@@ -12278,6 +12229,7 @@
 		},
 		"node_modules/napi-build-utils": {
 			"version": "2.0.0",
+			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/negotiator": {
@@ -12340,6 +12292,7 @@
 		},
 		"node_modules/node-abi": {
 			"version": "3.75.0",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"semver": "^7.3.5"
@@ -13914,6 +13867,7 @@
 			"version": "7.1.3",
 			"resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
 			"integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"detect-libc": "^2.0.0",
@@ -13938,6 +13892,7 @@
 		},
 		"node_modules/prebuild-install/node_modules/bl": {
 			"version": "4.1.0",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"buffer": "^5.5.0",
@@ -13947,6 +13902,7 @@
 		},
 		"node_modules/prebuild-install/node_modules/buffer": {
 			"version": "5.7.1",
+			"dev": true,
 			"funding": [
 				{
 					"type": "github",
@@ -13969,10 +13925,12 @@
 		},
 		"node_modules/prebuild-install/node_modules/chownr": {
 			"version": "1.1.4",
+			"dev": true,
 			"license": "ISC"
 		},
 		"node_modules/prebuild-install/node_modules/detect-libc": {
 			"version": "2.0.4",
+			"dev": true,
 			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=8"
@@ -13980,6 +13938,7 @@
 		},
 		"node_modules/prebuild-install/node_modules/readable-stream": {
 			"version": "3.6.2",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"inherits": "^2.0.3",
@@ -13992,6 +13951,7 @@
 		},
 		"node_modules/prebuild-install/node_modules/tar-fs": {
 			"version": "2.1.3",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"chownr": "^1.1.1",
@@ -14002,6 +13962,7 @@
 		},
 		"node_modules/prebuild-install/node_modules/tar-stream": {
 			"version": "2.2.0",
+			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"bl": "^4.0.3",
@@ -14259,6 +14220,7 @@
 		},
 		"node_modules/rc": {
 			"version": "1.2.8",
+			"dev": true,
 			"license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
 			"dependencies": {
 				"deep-extend": "^0.6.0",
@@ -14283,6 +14245,7 @@
 		},
 		"node_modules/rc/node_modules/strip-json-comments": {
 			"version": "2.0.1",
+			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=0.10.0"
@@ -15182,6 +15145,7 @@
 		},
 		"node_modules/simple-concat": {
 			"version": "1.0.1",
+			"dev": true,
 			"funding": [
 				{
 					"type": "github",
@@ -15200,6 +15164,7 @@
 		},
 		"node_modules/simple-get": {
 			"version": "4.0.1",
+			"dev": true,
 			"funding": [
 				{
 					"type": "github",
@@ -16221,6 +16186,7 @@
 		},
 		"node_modules/tunnel-agent": {
 			"version": "0.6.0",
+			"dev": true,
 			"license": "Apache-2.0",
 			"dependencies": {
 				"safe-buffer": "^5.0.1"

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.32.6",
+	"version": "3.32.5",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -168,10 +168,7 @@
 				"command": "cline.generateGitCommitMessage",
 				"title": "Generate Commit Message with Cline",
 				"category": "Cline",
-				"icon": {
-					"light": "assets/icons/robot_panel_light.png",
-					"dark": "assets/icons/robot_panel_dark.png"
-				}
+				"icon": "$(robot)"
 			},
 			{
 				"command": "cline.abortGitCommitMessage",
@@ -295,15 +292,12 @@
 		"vscode:prepublish": "npm run package",
 		"compile": "npm run check-types && npm run lint && node esbuild.mjs",
 		"compile-standalone": "npm run check-types && npm run lint && node esbuild.mjs --standalone",
-		"compile-cli": "scripts/build-cli.sh",
-		"dev:cli": "npm run compile-standalone && npm run compile-cli && ./cli/bin/cline instance kill --all && ./cli/bin/cline instance new",
 		"postcompile-standalone": "node scripts/package-standalone.mjs",
 		"watch": "npm-run-all -p watch:*",
 		"watch:esbuild": "node esbuild.mjs --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
 		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.mjs --production",
 		"protos": "node scripts/build-proto.mjs",
-		"protos-go": "node scripts/build-go-proto.mjs",
 		"postprotos": "biome format src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --no-errors-on-unmatched",
 		"clean:build": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"clean:deps": "rimraf node_modules webview-ui/node_modules",
@@ -320,7 +314,7 @@
 		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
 		"test": "npm-run-all test:unit test:integration",
 		"test:integration": "vscode-test",
-		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha",
+		"test:unit": "TS_NODE_PROJECT='./tsconfig.unit-test.json' mocha",
 		"test:coverage": "vscode-test --coverage",
 		"test:sca-server": "npx tsx watch scripts/test-standalone-core-api-server.ts",
 		"test:tp-orchestrator": "npx tsx scripts/testing-platform-orchestrator.ts",
@@ -372,7 +366,6 @@
 		"c8": "^10.1.3",
 		"chai": "^4.3.10",
 		"chalk": "5.6.2",
-		"cross-env": "^10.1.0",
 		"esbuild": "^0.25.0",
 		"grpc-tools": "^1.13.0",
 		"husky": "^9.1.7",
@@ -420,7 +413,6 @@
 		"@vscode/codicons": "^0.0.36",
 		"archiver": "^7.0.1",
 		"axios": "^1.12.0",
-		"better-sqlite3": "^12.4.1",
 		"cheerio": "^1.0.0",
 		"chokidar": "^4.0.1",
 		"chrome-launcher": "^1.1.2",

proto/cline/account.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/browser.proto

@@ -3,7 +3,6 @@ syntax = "proto3";
 package cline;
 import "cline/common.proto";
 import "cline/state.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/checkpoints.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/commands.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/common.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package cline;
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/dictation.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -39,4 +38,4 @@ message RecordingStatus {
 message Transcription {
   string text = 1;
   string error = 2;
-}
+}

proto/cline/file.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/mcp.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/models.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/oca_account.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/slash.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/state.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 package cline;
 import "cline/common.proto";
 import "cline/models.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -21,7 +20,6 @@ service StateService {
   rpc setWelcomeViewCompleted(BooleanRequest) returns (Empty);
   rpc updateInfoBannerVersion(Int64Request) returns (Empty);
   rpc updateModelBannerVersion(Int64Request) returns (Empty);
-  rpc getProcessInfo(EmptyRequest) returns (ProcessInfo);
 }
 message DictationSettings {
   bool feature_enabled = 1;
@@ -305,10 +303,3 @@ message Viewport {
 message UpdateTerminalConnectionTimeoutResponse {
   optional int32 timeout_ms = 1;
 }
-
-
-message ProcessInfo {
-  int32 process_id = 1;
-  optional string version = 2;
-  optional int64 uptime_ms = 3;
-}

proto/cline/task.proto

@@ -2,34 +2,9 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-import "cline/state.proto";
-import "cline/models.proto";
-import "cline/browser.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-message AutoApprovalActions {
-  bool read_files = 1;
-  bool read_files_externally = 2;
-  bool edit_files = 3;
-  bool edit_files_externally = 4;
-  bool execute_safe_commands = 5;
-  bool execute_all_commands = 6;
-  bool use_browser = 7;
-  bool use_mcp = 8;
-}
-
-// Auto approval settings for task execution
-message AutoApprovalSettings {
-  int32 version = 1;
-  bool enabled = 2;
-  AutoApprovalActions actions = 3;
-  int32 max_requests = 4;
-  bool enable_notifications = 5;
-  repeated string favorites = 6;
-}
-
 service TaskService {
   // Cancels the currently running task
   rpc cancelTask(EmptyRequest) returns (Empty);
@@ -40,7 +15,7 @@ service TaskService {
   // Deletes multiple tasks with the given IDs
   rpc deleteTasksWithIds(StringArrayRequest) returns (Empty);
   // Creates a new task with the given text and optional images
-  rpc newTask(NewTaskRequest) returns (String);
+  rpc newTask(NewTaskRequest) returns (Empty);
   // Shows a task with the specified ID
   rpc showTaskWithId(StringRequest) returns (TaskResponse);
   // Exports a task with the given ID to markdown
@@ -61,138 +36,12 @@ service TaskService {
   rpc deleteAllTaskHistory(EmptyRequest) returns (DeleteAllTaskHistoryCount);
 }
 
-// Task-specific settings
-message TaskSettings {
-   string aws_region = 1;
-   bool aws_use_cross_region_inference = 2;
-   bool aws_bedrock_use_prompt_cache = 3;
-   string aws_bedrock_endpoint = 4;
-   string aws_profile = 5;
-   string aws_authentication = 6;
-   bool aws_use_profile = 7;
-   string vertex_project_id = 8;
-   string vertex_region = 9;
-   string requesty_base_url = 10;
-   string open_ai_base_url = 11;
-  // map<string, string> open_ai_headers = 12;
-   string ollama_base_url = 13;
-   string ollama_api_options_ctx_num = 14;
-   string lm_studio_base_url = 15;
-   string lm_studio_max_tokens = 16;
-   string anthropic_base_url = 17;
-   string gemini_base_url = 18;
-   string azure_api_version = 19;
-   string open_router_provider_sorting = 20;
-   AutoApprovalSettings auto_approval_settings = 21;
-   BrowserSettings browser_settings = 24;
-   string lite_llm_base_url = 25;
-   bool lite_llm_use_prompt_cache = 26;
-   int32 fireworks_model_max_completion_tokens = 27;
-   int32 fireworks_model_max_tokens = 28;
-   string qwen_api_line = 29;
-   string moonshot_api_line = 30;
-   string zai_api_line = 31;
-   string telemetry_setting = 32;
-   string asksage_api_url = 33;
-   bool plan_act_separate_models_setting = 34;
-   bool enable_checkpoints_setting = 35;
-   int32 request_timeout_ms = 36;
-   int32 shell_integration_timeout = 37;
-   string default_terminal_profile = 38;
-   int32 terminal_output_line_limit = 39;
-   string sap_ai_core_token_url = 40;
-   string sap_ai_core_base_url = 41;
-   string sap_ai_resource_group = 42;
-   bool sap_ai_core_use_orchestration_mode = 43;
-   string claude_code_path = 44;
-   string qwen_code_oauth_path = 45;
-   bool strict_plan_mode_enabled = 46;
-   bool yolo_mode_toggled = 47;
-   bool use_auto_condense = 48;
-   string preferred_language = 49;
-   OpenaiReasoningEffort openai_reasoning_effort = 50;
-   PlanActMode mode = 51;
-   DictationSettings dictation_settings = 52;
-   FocusChainSettings focus_chain_settings = 53;
-   string custom_prompt = 54;
-   string dify_base_url = 55;
-   double auto_condense_threshold = 56;
-   string oca_base_url = 57;
-   ApiProvider plan_mode_api_provider = 58;
-   string plan_mode_api_model_id = 59;
-   int64 plan_mode_thinking_budget_tokens = 60;
-   string plan_mode_reasoning_effort = 61;
-   LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 62;
-   bool plan_mode_aws_bedrock_custom_selected = 63;
-   string plan_mode_aws_bedrock_custom_model_base_id = 64;
-   string plan_mode_open_router_model_id = 65;
-   OpenRouterModelInfo plan_mode_open_router_model_info = 66;
-   string plan_mode_open_ai_model_id = 67;
-   OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 68;
-   string plan_mode_ollama_model_id = 69;
-   string plan_mode_lm_studio_model_id = 70;
-   string plan_mode_lite_llm_model_id = 71;
-   LiteLLMModelInfo plan_mode_lite_llm_model_info = 72;
-   string plan_mode_requesty_model_id = 73;
-   OpenRouterModelInfo plan_mode_requesty_model_info = 74;
-   string plan_mode_together_model_id = 75;
-   string plan_mode_fireworks_model_id = 76;
-   string plan_mode_sap_ai_core_model_id = 77;
-   string plan_mode_sap_ai_core_deployment_id = 78;
-   string plan_mode_groq_model_id = 79;
-   OpenRouterModelInfo plan_mode_groq_model_info = 80;
-   string plan_mode_baseten_model_id = 81;
-   OpenRouterModelInfo plan_mode_baseten_model_info = 82;
-   string plan_mode_hugging_face_model_id = 83;
-   OpenRouterModelInfo plan_mode_hugging_face_model_info = 84;
-   string plan_mode_huawei_cloud_maas_model_id = 85;
-   OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 86;
-   string plan_mode_oca_model_id = 87;
-   OcaModelInfo plan_mode_oca_model_info = 88;
-   ApiProvider act_mode_api_provider = 89;
-   string act_mode_api_model_id = 90;
-   int64 act_mode_thinking_budget_tokens = 91;
-   string act_mode_reasoning_effort = 92;
-   LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 93;
-   bool act_mode_aws_bedrock_custom_selected = 94;
-   string act_mode_aws_bedrock_custom_model_base_id = 95;
-   string act_mode_open_router_model_id = 96;
-   OpenRouterModelInfo act_mode_open_router_model_info = 97;
-   string act_mode_open_ai_model_id = 98;
-   OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 99;
-   string act_mode_ollama_model_id = 100;
-   string act_mode_lm_studio_model_id = 101;
-   string act_mode_lite_llm_model_id = 102;
-   LiteLLMModelInfo act_mode_lite_llm_model_info = 103;
-   string act_mode_requesty_model_id = 104;
-   OpenRouterModelInfo act_mode_requesty_model_info = 105;
-   string act_mode_together_model_id = 106;
-   string act_mode_fireworks_model_id = 107;
-   string act_mode_sap_ai_core_model_id = 108;
-   string act_mode_sap_ai_core_deployment_id = 109;
-   string act_mode_groq_model_id = 110;
-   OpenRouterModelInfo act_mode_groq_model_info = 111;
-   string act_mode_baseten_model_id = 112;
-   OpenRouterModelInfo act_mode_baseten_model_info = 113;
-   string act_mode_hugging_face_model_id = 114;
-   OpenRouterModelInfo act_mode_hugging_face_model_info = 115;
-   string act_mode_huawei_cloud_maas_model_id = 116;
-   OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 117;
-   string plan_mode_vercel_ai_gateway_model_id = 118;
-   OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 119;
-   string act_mode_vercel_ai_gateway_model_id = 120;
-   OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 121;
-   string act_mode_oca_model_id = 122;
-   OcaModelInfo act_mode_oca_model_info = 123;
-}
-
 // Request message for creating a new task
 message NewTaskRequest {
   Metadata metadata = 1;
   string text = 2;
   repeated string images = 3;
   repeated string files = 4;
-  optional TaskSettings task_settings = 5;
 }
 
 // Request message for toggling task favorite status

proto/cline/ui.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/web.proto

@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package cline;
 import "cline/common.proto";
-option go_package = "github.com/cline/grpc-go/cline";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/host/diff.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package host;
-option go_package = "github.com/cline/grpc-go/host";
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 

proto/host/env.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package host;
-option go_package = "github.com/cline/grpc-go/host";
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
@@ -32,9 +31,6 @@ service EnvService {
 
   // Returns events when the telemetry settings change.
   rpc subscribeToTelemetrySettings(cline.EmptyRequest) returns (stream TelemetrySettingsEvent);
-
-  // Initiates a graceful shutdown of the host bridge service.
-  rpc shutdown(cline.EmptyRequest) returns (cline.Empty);
 }
 
 message GetHostVersionResponse {

proto/host/testing.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package host;
-option go_package = "github.com/cline/grpc-go/host";
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 

proto/host/window.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package host;
-option go_package = "github.com/cline/grpc-go/host";
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 

proto/host/workspace.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package host;
-option go_package = "github.com/cline/grpc-go/host";
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 

scripts/build-cli.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-set -eux
-
-npm run protos
-npm run protos-go
-
-mkdir -p dist-standalone/extension
-cp package.json dist-standalone/extension 
-
-cd cli
-GO111MODULE=on go build -o bin/cline ./cmd/cline 
-echo '🖥️ cli/bin/cline built'
-GO111MODULE=on go build -o bin/cline-host ./cmd/cline-host
-
-echo '🖥️ cli/bin/cline-host built'

scripts/build-go-proto.mjs

@@ -1,599 +0,0 @@
-#!/usr/bin/env node
-
-import chalk from "chalk"
-import { execSync } from "child_process"
-import * as fs from "fs/promises"
-import { globby } from "globby"
-import { createRequire } from "module"
-import * as path from "path"
-import { fileURLToPath } from "url"
-import { createServiceNameMap, parseProtoForServices } from "./proto-shared-utils.mjs"
-
-const require = createRequire(import.meta.url)
-const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
-const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
-const PROTO_DIR = path.resolve(ROOT_DIR, "proto")
-const GO_PROTO_DIR = path.join(ROOT_DIR, "src", "generated", "grpc-go")
-const GO_CLIENT_DIR = path.join(GO_PROTO_DIR, "client")
-const GO_SERVICE_CLIENT_DIR = path.join(GO_CLIENT_DIR, "services")
-
-const COMMON_TYPES = ["StringRequest", "EmptyRequest", "Empty", "String", "Int64Request", "KeyValuePair"]
-
-// Check if Go is installed
-function checkGoInstallation() {
-	try {
-		execSync("go version", { stdio: "pipe" })
-		return true
-	} catch (error) {
-		return false
-	}
-}
-
-// Check if a Go tool is available
-function checkGoTool(toolName) {
-	try {
-		execSync(`which ${toolName}`, { stdio: "pipe" })
-		return true
-	} catch (error) {
-		// On Windows, 'which' might not be available, try 'where'
-		try {
-			execSync(`where ${toolName}`, { stdio: "pipe" })
-			return true
-		} catch (windowsError) {
-			return false
-		}
-	}
-}
-
-// Install Go protobuf tools
-function installGoTools() {
-	console.log(chalk.yellow("Installing Go protobuf tools..."))
-
-	const tools = ["google.golang.org/protobuf/cmd/protoc-gen-go@latest", "google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest"]
-
-	for (const tool of tools) {
-		try {
-			console.log(chalk.cyan(`Installing ${tool}...`))
-			execSync(`GO111MODULE=on go install ${tool}`, {
-				stdio: "inherit",
-				env: { ...process.env, GO111MODULE: "on" },
-			})
-		} catch (error) {
-			console.error(chalk.red(`Failed to install ${tool}:`), error.message)
-			process.exit(1)
-		}
-	}
-
-	console.log(chalk.green("Go protobuf tools installed successfully!"))
-}
-
-// Check if tools are in PATH and provide guidance
-function checkToolsInPath() {
-	const tools = ["protoc-gen-go", "protoc-gen-go-grpc"]
-	const missingTools = []
-
-	for (const tool of tools) {
-		if (!checkGoTool(tool)) {
-			missingTools.push(tool)
-		}
-	}
-
-	if (missingTools.length > 0) {
-		console.log(chalk.yellow("Warning: Some Go protobuf tools are not in your PATH:"))
-		missingTools.forEach((tool) => console.log(chalk.yellow(`  - ${tool}`)))
-		console.log()
-		console.log(chalk.cyan("To fix this, add your Go bin directory to your PATH:"))
-
-		// Get GOPATH and GOBIN
-		let goPath, goBin
-		try {
-			goPath = execSync("go env GOPATH", { encoding: "utf8" }).trim()
-			goBin = execSync("go env GOBIN", { encoding: "utf8" }).trim()
-		} catch (error) {
-			console.log(chalk.red("Could not determine Go paths. Please check your Go installation."))
-			process.exit(1)
-		}
-
-		const binPath = goBin || path.join(goPath, "bin")
-
-		if (process.platform === "win32") {
-			console.log(chalk.cyan(`  Windows (Command Prompt): set PATH=%PATH%;${binPath}`))
-			console.log(chalk.cyan(`  Windows (PowerShell): $env:PATH += ";${binPath}"`))
-			console.log(chalk.cyan(`  Or add "${binPath}" to your system PATH through System Properties`))
-		} else {
-			console.log(chalk.cyan(`  Add this to your shell profile (~/.bashrc, ~/.zshrc, etc.):`))
-			console.log(chalk.cyan(`  export PATH="$PATH:${binPath}"`))
-			console.log(chalk.cyan(`  Then run: source ~/.bashrc (or restart your terminal)`))
-		}
-		console.log()
-
-		// Try to continue anyway, as the tools might still work
-		console.log(chalk.yellow("Attempting to continue anyway..."))
-	}
-}
-
-// Setup Go dependencies
-async function setupGoDependencies() {
-	console.log(chalk.cyan("Checking Go dependencies..."))
-
-	// Check if Go is installed
-	if (!checkGoInstallation()) {
-		console.error(chalk.red("Error: Go is not installed or not in PATH."))
-		console.error(chalk.red("Please install Go from https://golang.org/dl/ and ensure it's in your PATH."))
-		process.exit(1)
-	}
-
-	console.log(chalk.green("✓ Go is installed"))
-
-	// Check if protobuf tools are available
-	const tools = ["protoc-gen-go", "protoc-gen-go-grpc"]
-	const missingTools = tools.filter((tool) => !checkGoTool(tool))
-
-	if (missingTools.length > 0) {
-		console.log(chalk.yellow(`Missing Go protobuf tools: ${missingTools.join(", ")}`))
-		installGoTools()
-	} else {
-		console.log(chalk.green("✓ Go protobuf tools are available"))
-	}
-
-	// Verify tools are in PATH
-	checkToolsInPath()
-}
-
-export async function goProtoc(outDir, protoFiles) {
-	// Setup dependencies first
-	await setupGoDependencies()
-
-	// Create output directory if it doesn't exist
-	await fs.mkdir(outDir, { recursive: true })
-
-	// Simple protoc command - proto files now have correct go_package paths
-	const goProtocCommand = [
-		PROTOC,
-		`--proto_path="${PROTO_DIR}"`,
-		`--go_out="${outDir}"`,
-		`--go_opt=module=github.com/cline/grpc-go`,
-		`--go-grpc_out="${outDir}"`,
-		`--go-grpc_opt=module=github.com/cline/grpc-go`,
-		...protoFiles,
-	].join(" ")
-
-	try {
-		console.log(chalk.cyan(`Generating Go code in ${outDir}...`))
-		execSync(goProtocCommand, { stdio: "inherit" })
-	} catch (error) {
-		console.error(chalk.red("Error generating Go code:"), error)
-
-		// Provide additional help if the error might be related to missing tools
-		if (error.message.includes("protoc-gen-go")) {
-			console.log()
-			console.log(chalk.yellow("This error might be caused by Go protobuf tools not being in your PATH."))
-			console.log(chalk.yellow("Please ensure the tools are properly installed and accessible."))
-		}
-
-		process.exit(1)
-	}
-
-	await generateGoMod()
-	await generateGoConnection()
-	await generateGoClient()
-	await generateGoServiceClients()
-}
-
-async function generateGoMod() {
-	console.log(chalk.cyan("Generating Go module file..."))
-
-	const goModContent = `module github.com/cline/grpc-go
-
-go 1.21
-
-require (
-	google.golang.org/grpc v1.65.0
-	google.golang.org/protobuf v1.34.2
-)
-
-require (
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117 // indirect
-)
-`
-
-	const goModPath = path.join(GO_PROTO_DIR, "go.mod")
-	await fs.writeFile(goModPath, goModContent)
-	console.log(chalk.green(`Generated Go module file at ${goModPath}`))
-}
-
-async function generateGoConnection() {
-	console.log(chalk.cyan("Generating Go connection manager..."))
-
-	// Create client directory if it doesn't exist
-	await fs.mkdir(GO_CLIENT_DIR, { recursive: true })
-
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by scripts/build-go-proto.mjs
-
-package client
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-)
-
-// ConnectionConfig holds configuration for gRPC connection
-type ConnectionConfig struct {
-	Address string
-	Timeout time.Duration
-}
-
-// ConnectionManager manages gRPC connections
-type ConnectionManager struct {
-	config *ConnectionConfig
-	conn   *grpc.ClientConn
-	mutex  sync.RWMutex
-}
-
-// NewConnectionManager creates a new connection manager
-func NewConnectionManager(config *ConnectionConfig) *ConnectionManager {
-	if config.Timeout == 0 {
-		config.Timeout = 30 * time.Second
-	}
-
-	return &ConnectionManager{
-		config: config,
-	}
-}
-
-// Connect establishes a gRPC connection
-func (cm *ConnectionManager) Connect(ctx context.Context) error {
-	cm.mutex.Lock()
-	defer cm.mutex.Unlock()
-
-	if cm.conn != nil {
-		return nil // Already connected
-	}
-
-	// Create context with timeout
-	connectCtx, cancel := context.WithTimeout(ctx, cm.config.Timeout)
-	defer cancel()
-
-	// Establish gRPC connection
-	conn, err := grpc.DialContext(connectCtx, cm.config.Address,
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
-		grpc.WithBlock(),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to connect to %s: %w", cm.config.Address, err)
-	}
-
-	cm.conn = conn
-	return nil
-}
-
-// Disconnect closes the gRPC connection
-func (cm *ConnectionManager) Disconnect() error {
-	cm.mutex.Lock()
-	defer cm.mutex.Unlock()
-
-	if cm.conn == nil {
-		return nil // Already disconnected
-	}
-
-	err := cm.conn.Close()
-	cm.conn = nil
-	return err
-}
-
-// GetConnection returns the current gRPC connection
-func (cm *ConnectionManager) GetConnection() *grpc.ClientConn {
-	cm.mutex.RLock()
-	defer cm.mutex.RUnlock()
-	return cm.conn
-}
-
-// IsConnected returns true if connected
-func (cm *ConnectionManager) IsConnected() bool {
-	cm.mutex.RLock()
-	defer cm.mutex.RUnlock()
-	return cm.conn != nil
-}
-`
-
-	const connectionPath = path.join(GO_CLIENT_DIR, "connection.go")
-	await fs.writeFile(connectionPath, content)
-	console.log(chalk.green(`Generated Go connection manager at ${connectionPath}`))
-}
-
-async function generateGoClient() {
-	console.log(chalk.cyan("Generating Go client..."))
-
-	// Create client directory if it doesn't exist
-	await fs.mkdir(GO_CLIENT_DIR, { recursive: true })
-
-	// Get all proto files and parse services
-	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR })
-	const services = await parseProtoForServices(protoFiles, PROTO_DIR)
-	const serviceNameMap = createServiceNameMap(services)
-
-	const serviceClients = Object.keys(serviceNameMap)
-		.map(
-			(name) =>
-				`\t${name.charAt(0).toUpperCase() + name.slice(1)} *services.${name.charAt(0).toUpperCase() + name.slice(1)}Client`,
-		)
-		.join("\n")
-
-	const serviceInitializers = Object.keys(serviceNameMap)
-		.map(
-			(name) =>
-				`\tc.${name.charAt(0).toUpperCase() + name.slice(1)} = services.New${name.charAt(0).toUpperCase() + name.slice(1)}Client(conn)`,
-		)
-		.join("\n")
-
-	const serviceNilOut = Object.keys(serviceNameMap)
-		.map((name) => `\tc.${name.charAt(0).toUpperCase() + name.slice(1)} = nil`)
-		.join("\n")
-
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by scripts/build-go-proto.mjs
-
-package client
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"google.golang.org/grpc"
-	"github.com/cline/grpc-go/client/services"
-)
-
-// ClineClient provides a unified interface to all Cline services
-type ClineClient struct {
-	connManager *ConnectionManager
-	
-	// Service clients
-${serviceClients}
-	
-	// Connection state
-	mutex     sync.RWMutex
-	connected bool
-}
-
-// NewClineClient creates a new unified Cline client
-func NewClineClient(address string) (*ClineClient, error) {
-	config := &ConnectionConfig{
-		Address: address,
-	}
-	
-	connManager := NewConnectionManager(config)
-	
-	return &ClineClient{
-		connManager: connManager,
-	}, nil
-}
-
-// NewClineClientWithConfig creates a new Cline client with custom configuration
-func NewClineClientWithConfig(config *ConnectionConfig) (*ClineClient, error) {
-	connManager := NewConnectionManager(config)
-	
-	return &ClineClient{
-		connManager: connManager,
-	}, nil
-}
-
-// Connect establishes connection to Cline Core and initializes service clients
-func (c *ClineClient) Connect(ctx context.Context) error {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-	
-	if c.connected {
-		return nil
-	}
-	
-	// Establish gRPC connection
-	if err := c.connManager.Connect(ctx); err != nil {
-		return fmt.Errorf("failed to connect: %w", err)
-	}
-	
-	// Initialize service clients
-	conn := c.connManager.GetConnection()
-${serviceInitializers}
-	
-	c.connected = true
-	return nil
-}
-
-// Disconnect closes the connection to Cline Core
-func (c *ClineClient) Disconnect() error {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-	
-	if !c.connected {
-		return nil
-	}
-	
-	err := c.connManager.Disconnect()
-	c.connected = false
-	
-	// Clear service clients
-${serviceNilOut}
-	
-	return err
-}
-
-// IsConnected returns true if the client is connected to Cline Core
-func (c *ClineClient) IsConnected() bool {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-	return c.connected
-}
-
-// Reconnect closes the current connection and establishes a new one
-func (c *ClineClient) Reconnect(ctx context.Context) error {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-	
-	// Disconnect first
-	if c.connected {
-		if err := c.connManager.Disconnect(); err != nil {
-			return fmt.Errorf("failed to disconnect: %w", err)
-		}
-		c.connected = false
-	}
-	
-	// Reconnect
-	if err := c.connManager.Connect(ctx); err != nil {
-		return fmt.Errorf("failed to reconnect: %w", err)
-	}
-	
-	// Reinitialize service clients
-	conn := c.connManager.GetConnection()
-${serviceInitializers}
-	
-	c.connected = true
-	return nil
-}
-
-// GetConnection returns the underlying gRPC connection
-func (c *ClineClient) GetConnection() *grpc.ClientConn {
-	return c.connManager.GetConnection()
-}
-`
-	const clientPath = path.join(GO_CLIENT_DIR, "cline_client.go")
-	await fs.writeFile(clientPath, content)
-	console.log(chalk.green(`Generated Go client at ${clientPath}`))
-}
-
-async function generateGoServiceClients() {
-	console.log(chalk.cyan("Generating Go service clients..."))
-	await fs.mkdir(GO_SERVICE_CLIENT_DIR, { recursive: true })
-
-	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR })
-	const services = await parseProtoForServices(protoFiles, PROTO_DIR)
-
-	for (const [serviceName, serviceDef] of Object.entries(services)) {
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1)
-		const clientFileName = `${serviceName}_client.go`
-		const clientPath = path.join(GO_SERVICE_CLIENT_DIR, clientFileName)
-
-		const methods = serviceDef.methods
-			.map((method) => {
-				const capitalizedMethodName = method.name.charAt(0).toUpperCase() + method.name.slice(1)
-
-				// Determine if types are from cline package (common types) or proto package (service-specific types)
-				const requestTypeName = method.requestType.split(".").pop()
-				const responseTypeName = method.responseType.split(".").pop()
-
-				// Common types like StringRequest, Empty, etc. are in the cline package
-				const requestType = COMMON_TYPES.includes(requestTypeName)
-					? `*cline.${requestTypeName}`
-					: `*proto.${requestTypeName}`
-				const responseType = COMMON_TYPES.includes(responseTypeName)
-					? `*cline.${responseTypeName}`
-					: `*proto.${responseTypeName}`
-
-				if (method.isResponseStreaming) {
-					return `
-// ${capitalizedMethodName} subscribes to ${method.name} updates and returns a stream
-func (sc *${capitalizedServiceName}Client) ${capitalizedMethodName}(ctx context.Context, req ${requestType}) (proto.${serviceDef.name}_${capitalizedMethodName}Client, error) {
-	stream, err := sc.client.${capitalizedMethodName}(ctx, req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to subscribe to ${method.name}: %w", err)
-	}
-
-	return stream, nil
-}`
-				} else {
-					return `
-// ${capitalizedMethodName} retrieves the current application ${method.name}
-func (sc *${capitalizedServiceName}Client) ${capitalizedMethodName}(ctx context.Context, req ${requestType}) (${responseType}, error) {
-	resp, err := sc.client.${capitalizedMethodName}(ctx, req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get latest ${method.name}: %w", err)
-	}
-
-	return resp, nil
-}`
-				}
-			})
-			.join("\n")
-
-		// Determine the correct proto import path based on the service location
-		const protoImportPath =
-			serviceDef.protoPackage === "host" ? '"github.com/cline/grpc-go/host"' : '"github.com/cline/grpc-go/cline"'
-
-		// Check if we need to import cline package for common types
-		const needsClineImport = serviceDef.methods.some((method) => {
-			const requestTypeName = method.requestType.split(".").pop()
-			const responseTypeName = method.responseType.split(".").pop()
-			const commonTypes = ["StringRequest", "EmptyRequest", "Empty", "String", "Int64Request", "KeyValuePair"]
-			return commonTypes.includes(requestTypeName) || commonTypes.includes(responseTypeName)
-		})
-
-		// Always import cline package if we need common types, regardless of service package
-		const clineImport = needsClineImport ? '	cline "github.com/cline/grpc-go/cline"\n' : ""
-
-		const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by scripts/build-go-proto.mjs
-
-package services
-
-import (
-	"context"
-	"fmt"
-
-${clineImport}	proto ${protoImportPath}
-	"google.golang.org/grpc"
-)
-
-// ${capitalizedServiceName}Client wraps the generated ${serviceDef.name} gRPC client
-type ${capitalizedServiceName}Client struct {
-	client proto.${serviceDef.name}Client
-}
-
-// New${capitalizedServiceName}Client creates a new ${capitalizedServiceName}Client
-func New${capitalizedServiceName}Client(conn *grpc.ClientConn) *${capitalizedServiceName}Client {
-	return &${capitalizedServiceName}Client{
-		client: proto.New${serviceDef.name}Client(conn),
-	}
-}
-${methods}
-`
-		await fs.writeFile(clientPath, content)
-		console.log(chalk.green(`Generated Go service client at ${clientPath}`))
-	}
-}
-
-// Main execution block - run if this script is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-	async function main() {
-		try {
-			console.log(chalk.cyan("Starting Go protobuf code generation..."))
-
-			// Get all proto files
-			const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR })
-			console.log(chalk.cyan(`Found ${protoFiles.length} proto files`))
-
-			// Set output directory for Go code - use the new location
-			const goOutDir = GO_PROTO_DIR
-
-			// Call the goProtoc function
-			await goProtoc(goOutDir, protoFiles)
-
-			console.log(chalk.green("✓ Go protobuf code generation completed successfully!"))
-		} catch (error) {
-			console.error(chalk.red("Error during Go protobuf generation:"), error)
-			process.exit(1)
-		}
-	}
-
-	main()
-}

scripts/proto-shared-utils.mjs

@@ -1,66 +0,0 @@
-import * as fs from "fs/promises"
-import * as path from "path"
-
-/**
- * Parse proto files to extract service definitions
- * @param {string[]} protoFilePaths - Array of proto file paths
- * @param {string} protoDir - Base proto directory
- * @returns {Promise<Object>} Services object with service definitions
- */
-export async function parseProtoForServices(protoFilePaths, protoDir) {
-	const services = {}
-
-	for (const protoFilePath of protoFilePaths) {
-		const content = await fs.readFile(path.join(protoDir, protoFilePath), "utf8")
-		const serviceMatches = content.matchAll(/service\s+(\w+Service)\s*\{([\s\S]*?)\}/g)
-
-		// Determine proto package from file path
-		const protoPackage = protoFilePath.startsWith("host/") ? "host" : "cline"
-
-		for (const serviceMatch of serviceMatches) {
-			const serviceName = serviceMatch[1]
-			const serviceKey = serviceName.replace("Service", "").toLowerCase()
-			const serviceBody = serviceMatch[2]
-			const methodMatches = serviceBody.matchAll(
-				/rpc\s+(\w+)\s*\((stream\s)?([\w.]+)\)\s*returns\s*\((stream\s)?([\w.]+)\)/g,
-			)
-
-			const methods = []
-			for (const methodMatch of methodMatches) {
-				methods.push({
-					name: methodMatch[1],
-					requestType: methodMatch[3],
-					responseType: methodMatch[5],
-					isRequestStreaming: !!methodMatch[2],
-					isResponseStreaming: !!methodMatch[4],
-				})
-			}
-			services[serviceKey] = { name: serviceName, methods, protoPackage }
-		}
-	}
-	return services
-}
-
-/**
- * Create service name map from parsed services
- * @param {Object} services - Services object from parseProtoForServices
- * @returns {Object} Service name map
- */
-export function createServiceNameMap(services) {
-	const serviceNameMap = {}
-	for (const [serviceKey, serviceDef] of Object.entries(services)) {
-		const packagePrefix = serviceDef.protoPackage === "host" ? "host" : "cline"
-		serviceNameMap[serviceKey] = `${packagePrefix}.${serviceDef.name}`
-	}
-	return serviceNameMap
-}
-
-/**
- * Log message only if verbose flag is set
- * @param {string} message - Message to log
- */
-export function logVerbose(message) {
-	if (process.argv.includes("-v") || process.argv.includes("--verbose")) {
-		console.log(message)
-	}
-}

scripts/runclinecore.sh

@@ -25,26 +25,6 @@ unp $ZIP_FILE > /dev/null
 
 pkill -f cline-core.js || true
 
-# Detect platform name using the same logic as ClineDirs.kt in the plugin.
-OS=$(uname -s | tr '[:upper:]' '[:lower:]')
-ARCH=$(uname -m)
-
-if [[ "$OS" == "darwin" && "$ARCH" == "x86_64" ]]; then
-    PLATFORM_NAME="darwin-x64"
-elif [[ "$OS" == "darwin" && "$ARCH" == "arm64" ]]; then
-    PLATFORM_NAME="darwin-arm64"
-elif [[ "$OS" == *"mingw"* || "$OS" == *"cygwin"* || "$OS" == *"msys"* ]] && [[ "$ARCH" == "x86_64" || "$ARCH" == "amd64" ]]; then
-    # Note: This script requires a bash-compatible environment on Windows (Git Bash, MSYS2, Cygwin)
-    PLATFORM_NAME="win-x64"
-elif [[ "$OS" == "linux" && ("$ARCH" == "x86_64" || "$ARCH" == "amd64") ]]; then
-    PLATFORM_NAME="linux-x64"
-else
-    echo "Unsupported platform: $OS $ARCH"
-    exit 1
-fi
-
-BINARY_MODULES_DIR="./binaries/$PLATFORM_NAME/node_modules"
-
 echo pwd: $(pwd)
 set -x
-NODE_PATH=$BINARY_MODULES_DIR:./node_modules DEV_WORKSPACE_FOLDER=/tmp/ node cline-core.js 2>&1 | tee $LOG_FILE
+NODE_PATH=./node_modules DEV_WORKSPACE_FOLDER=/tmp/ node cline-core.js 2>&1 | tee $LOG_FILE

src/common.ts

@@ -11,7 +11,6 @@ import "./utils/path" // necessary to have access to String.prototype.toPosix
 
 import { HostProvider } from "@/hosts/host-provider"
 import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
-import { StateManager } from "./core/storage/StateManager"
 import { ExtensionRegistryInfo } from "./registry"
 import { audioRecordingService } from "./services/dictation/AudioRecordingService"
 import { ErrorService } from "./services/error"
@@ -28,16 +27,6 @@ import { getLatestAnnouncementId } from "./utils/announcements"
  * @returns The webview provider
  */
 export async function initialize(context: vscode.ExtensionContext): Promise<WebviewProvider> {
-	try {
-		await StateManager.initialize(context)
-	} catch (error) {
-		console.error("[Controller] CRITICAL: Failed to initialize StateManager - extension may not function properly:", error)
-		HostProvider.window.showMessage({
-			type: ShowMessageType.ERROR,
-			message: "Failed to initialize Cline's application state. Please restart the extension.",
-		})
-	}
-
 	// Set the distinct ID for logging and telemetry
 	await initializeDistinctId(context)
 

src/core/api/providers/__tests__/claude-code.test.ts

@@ -12,7 +12,7 @@ describe("ClaudeCodeHandler", () => {
 		sandbox = sinon.createSandbox()
 		handler = new ClaudeCodeHandler({
 			claudeCodePath: "/mock/path",
-			apiModelId: "claude-opus-4-1-20250805",
+			apiModelId: "claude-3-5-sonnet-20241022",
 		})
 	})
 
@@ -229,11 +229,11 @@ describe("ClaudeCodeHandler", () => {
 	describe("getModel", () => {
 		it("should return the correct model when specified", () => {
 			const handler = new ClaudeCodeHandler({
-				apiModelId: "claude-sonnet-4-5-20250929",
+				apiModelId: "claude-3-5-sonnet-20241022",
 			})
 
 			const model = handler.getModel()
-			model.id.should.equal("claude-sonnet-4-5-20250929")
+			model.id.should.equal("claude-3-5-sonnet-20241022")
 		})
 
 		it("should return default model when not specified", () => {

src/core/controller/file/searchFiles.ts

@@ -1,5 +1,4 @@
 import { searchWorkspaceFiles } from "@services/search/file-search"
-import { telemetryService } from "@services/telemetry"
 import { FileSearchRequest, FileSearchResults, FileSearchType } from "@shared/proto/cline/file"
 import { convertSearchResultsToProtoFileInfos } from "@shared/proto-conversions/file/search-result-conversion"
 import { getWorkspacePath } from "@utils/path"
@@ -17,10 +16,6 @@ export async function searchFiles(_controller: Controller, request: FileSearchRe
 	if (!workspacePath) {
 		// Handle case where workspace path is not available
 		console.error("Error in searchFiles: No workspace path available")
-
-		// Track as a specific failure type - no workspace available
-		await telemetryService.captureMentionFailed("folder", "not_found", "No workspace path available")
-
 		return { results: [], mentionsRequestId: request.mentionsRequestId }
 	}
 
@@ -44,42 +39,12 @@ export async function searchFiles(_controller: Controller, request: FileSearchRe
 		// Convert search results to proto FileInfo objects using the conversion function
 		const protoResults = convertSearchResultsToProtoFileInfos(searchResults)
 
-		// Track search results telemetry
-		// Determine search type for telemetry
-		let searchType: "file" | "folder" | "all" = "all"
-		if (request.selectedType === FileSearchType.FILE) {
-			searchType = "file"
-		} else if (request.selectedType === FileSearchType.FOLDER) {
-			searchType = "folder"
-		}
-
-		await telemetryService.captureMentionSearchResults(
-			request.query || "",
-			protoResults.length,
-			searchType,
-			protoResults.length === 0,
-		)
-
 		// Return successful results
 		return { results: protoResults, mentionsRequestId: request.mentionsRequestId }
 	} catch (error) {
 		// Log the error but don't include it in the response, following the pattern in searchCommits
 		console.error("Error in searchFiles:", error)
 
-		// Track as a search execution error with appropriate error type
-		const errorMessage = error instanceof Error ? error.message : String(error)
-		const errorType = error instanceof Error && error.message.includes("permission") ? "permission_denied" : "unknown"
-
-		// Determine mention type based on the search request
-		const mentionType =
-			request.selectedType === FileSearchType.FILE
-				? "file"
-				: request.selectedType === FileSearchType.FOLDER
-					? "folder"
-					: "folder" // Default to folder for "all" searches
-
-		await telemetryService.captureMentionFailed(mentionType, errorType, errorMessage)
-
 		// Return empty results without error message
 		return { results: [], mentionsRequestId: request.mentionsRequestId }
 	}

src/core/controller/index.ts

@@ -40,7 +40,6 @@ import {
 	GlobalFileNames,
 } from "../storage/disk"
 import { PersistenceErrorEvent, StateManager } from "../storage/StateManager"
-import { Settings } from "../storage/state-keys"
 import { Task } from "../task"
 import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
 import { appendClineStealthModels } from "./models/refreshOpenRouterModels"
@@ -68,34 +67,50 @@ export class Controller {
 	constructor(readonly context: vscode.ExtensionContext) {
 		PromptRegistry.getInstance() // Ensure prompts and tools are registered
 		HostProvider.get().logToChannel("ClineProvider instantiated")
-		this.stateManager = StateManager.get()
+		this.stateManager = new StateManager(context)
 		this.authService = AuthService.getInstance(this)
 		this.ocaAuthService = OcaAuthService.initialize(this)
 		this.accountService = ClineAccountService.getInstance()
-		this.authService.restoreRefreshTokenAndRetrieveAuthInfo()
 
-		StateManager.get().registerCallbacks({
-			onPersistenceError: async ({ error }: PersistenceErrorEvent) => {
-				console.error("[Controller] Cache persistence failed, recovering:", error)
-				try {
-					await StateManager.get().reInitialize(this.task?.taskId)
-					await this.postStateToWebview()
-					HostProvider.window.showMessage({
-						type: ShowMessageType.WARNING,
-						message: "Saving settings to storage failed.",
-					})
-				} catch (recoveryError) {
-					console.error("[Controller] Cache recovery failed:", recoveryError)
-					HostProvider.window.showMessage({
-						type: ShowMessageType.ERROR,
-						message: "Failed to save settings. Please restart the extension.",
-					})
-				}
-			},
-			onSyncExternalChange: async () => {
+		// Initialize cache service asynchronously - critical for extension functionality
+		this.stateManager
+			.initialize()
+			.then(() => {
+				this.authService.restoreRefreshTokenAndRetrieveAuthInfo()
+			})
+			.catch((error) => {
+				console.error(
+					"[Controller] CRITICAL: Failed to initialize StateManager - extension may not function properly:",
+					error,
+				)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: "Failed to initialize Cline's application state. Please restart the extension.",
+				})
+			})
+
+		// Set up persistence error recovery
+		this.stateManager.onPersistenceError = async ({ error }: PersistenceErrorEvent) => {
+			console.error("[Controller] Cache persistence failed, recovering:", error)
+			try {
+				await this.stateManager.reInitialize(this.task?.taskId)
 				await this.postStateToWebview()
-			},
-		})
+				HostProvider.window.showMessage({
+					type: ShowMessageType.WARNING,
+					message: "Saving settings to storage failed.",
+				})
+			} catch (recoveryError) {
+				console.error("[Controller] Cache recovery failed:", recoveryError)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: "Failed to save settings. Please restart the extension.",
+				})
+			}
+		}
+
+		this.stateManager.onSyncExternalChange = async () => {
+			await this.postStateToWebview()
+		}
 
 		this.mcpHub = new McpHub(
 			() => ensureMcpServersDirectoryExists(),
@@ -172,13 +187,7 @@ export class Controller {
 		this.stateManager.setGlobalState("userInfo", info)
 	}
 
-	async initTask(
-		task?: string,
-		images?: string[],
-		files?: string[],
-		historyItem?: HistoryItem,
-		taskSettings?: Partial<Settings>,
-	) {
+	async initTask(task?: string, images?: string[], files?: string[], historyItem?: HistoryItem) {
 		await this.clearTask() // ensures that an existing task doesn't exist before starting a new one, although this shouldn't be possible since user must clear task before starting a new one
 
 		const autoApprovalSettings = this.stateManager.getGlobalSettingsKey("autoApprovalSettings")
@@ -213,13 +222,6 @@ export class Controller {
 
 		const cwd = this.workspaceManager?.getPrimaryRoot()?.path || (await getCwd(getDesktopDir()))
 
-		const taskId = historyItem?.id || Date.now().toString()
-
-		await this.stateManager.loadTaskSettings(taskId)
-		if (taskSettings) {
-			this.stateManager.setTaskSettingsBatch(taskId, taskSettings)
-		}
-
 		this.task = new Task({
 			controller: this,
 			mcpHub: this.mcpHub,
@@ -238,10 +240,12 @@ export class Controller {
 			images,
 			files,
 			historyItem,
-			taskId,
 		})
 
-		return this.task.taskId
+		// Load task settings after task creation
+		if (this.task.taskId) {
+			await this.stateManager.loadTaskSettings(this.task.taskId)
+		}
 	}
 
 	async reinitExistingTaskFromId(taskId: string) {
@@ -799,7 +803,7 @@ export class Controller {
 	async clearTask() {
 		if (this.task) {
 			// Clear task settings cache when task ends
-			await this.stateManager.clearTaskSettings()
+			await this.stateManager.clearTaskSettings(this.task.taskId)
 		}
 		await this.task?.abortTask()
 		this.task = undefined // removes reference to it, so once promises end it will be garbage collected

src/core/controller/state/getProcessInfo.ts

@@ -1,20 +0,0 @@
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { ProcessInfo } from "@shared/proto/cline/state"
-import { Controller } from ".."
-
-/**
- * Gets process information including PID, version, and uptime
- * @param controller The controller instance
- * @param request Empty request
- * @returns ProcessInfo with process details
- */
-export async function getProcessInfo(controller: Controller, request: EmptyRequest): Promise<ProcessInfo> {
-	// Get the current state to access the version (same source as webview)
-	const state = await controller.getStateToPostToWebview()
-
-	return ProcessInfo.create({
-		processId: process.pid,
-		version: state.version || "unknown",
-		uptimeMs: Math.floor(process.uptime() * 1000), // Convert seconds to milliseconds
-	})
-}

src/core/controller/task/newTask.ts

@@ -1,75 +1,14 @@
-import { String } from "@shared/proto/cline/common"
-import { PlanActMode, OpenaiReasoningEffort as ProtoOpenaiReasoningEffort } from "@shared/proto/cline/state"
+import { Empty } from "@shared/proto/cline/common"
 import { NewTaskRequest } from "@shared/proto/cline/task"
-import { Settings } from "@/core/storage/state-keys"
-import { convertProtoToApiProvider } from "@/shared/proto-conversions/models/api-configuration-conversion"
-import { DEFAULT_BROWSER_SETTINGS } from "../../../shared/BrowserSettings"
-import { convertProtoToAutoApprovalSettings } from "../../../shared/proto-conversions/models/auto-approval-settings-conversion"
 import { Controller } from ".."
 
 /**
  * Creates a new task with the given text and optional images
  * @param controller The controller instance
- * @param request The new task request containing text and optional images, and optional task settings
+ * @param request The new task request containing text and optional images
  * @returns Empty response
  */
-export async function newTask(controller: Controller, request: NewTaskRequest): Promise<String> {
-	const convertOpenaiReasoningEffort = (effort: ProtoOpenaiReasoningEffort): string => {
-		switch (effort) {
-			case ProtoOpenaiReasoningEffort.LOW:
-				return "low"
-			case ProtoOpenaiReasoningEffort.MEDIUM:
-				return "medium"
-			case ProtoOpenaiReasoningEffort.HIGH:
-				return "high"
-			case ProtoOpenaiReasoningEffort.MINIMAL:
-				return "minimal"
-			default:
-				return "medium"
-		}
-	}
-
-	const convertPlanActMode = (mode: PlanActMode): string => {
-		return mode === PlanActMode.PLAN ? "plan" : "act"
-	}
-
-	const filteredTaskSettings: Partial<Settings> = Object.fromEntries(
-		Object.entries({
-			...request.taskSettings,
-			...(request.taskSettings?.autoApprovalSettings && {
-				autoApprovalSettings: convertProtoToAutoApprovalSettings({
-					...request.taskSettings.autoApprovalSettings,
-					metadata: {},
-				}),
-			}),
-			...(request.taskSettings?.browserSettings && {
-				browserSettings: {
-					viewport: request.taskSettings.browserSettings.viewport || DEFAULT_BROWSER_SETTINGS.viewport,
-					remoteBrowserHost: request.taskSettings.browserSettings.remoteBrowserHost,
-					remoteBrowserEnabled: request.taskSettings.browserSettings.remoteBrowserEnabled,
-					chromeExecutablePath: request.taskSettings.browserSettings.chromeExecutablePath,
-					disableToolUse: request.taskSettings.browserSettings.disableToolUse,
-					customArgs: request.taskSettings.browserSettings.customArgs,
-				},
-			}),
-			...(request.taskSettings?.openaiReasoningEffort !== undefined && {
-				openaiReasoningEffort: convertOpenaiReasoningEffort(request.taskSettings.openaiReasoningEffort),
-			}),
-			...(request.taskSettings?.mode !== undefined && {
-				mode: convertPlanActMode(request.taskSettings.mode),
-			}),
-			...(request.taskSettings?.customPrompt === "compact" && {
-				customPrompt: "compact",
-			}),
-			...(request.taskSettings?.planModeApiProvider !== undefined && {
-				planModeApiProvider: convertProtoToApiProvider(request.taskSettings.planModeApiProvider),
-			}),
-			...(request.taskSettings?.actModeApiProvider !== undefined && {
-				actModeApiProvider: convertProtoToApiProvider(request.taskSettings.actModeApiProvider),
-			}),
-		}).filter(([_, value]) => value !== undefined),
-	)
-
-	const taskId = await controller.initTask(request.text, request.images, request.files, undefined, filteredTaskSettings)
-	return String.create({ value: taskId || "" })
+export async function newTask(controller: Controller, request: NewTaskRequest): Promise<Empty> {
+	await controller.initTask(request.text, request.images, request.files)
+	return Empty.create()
 }

src/core/locks/SqliteLockManager.ts

@@ -1,220 +0,0 @@
-import Database from "better-sqlite3"
-import * as fs from "fs"
-import { existsSync, mkdirSync, unlinkSync } from "fs"
-import * as path from "path"
-import type { SqliteLockManagerOptions } from "./types"
-export class SqliteLockManager {
-	private db!: Database.Database
-	private instanceAddress: string
-	private dbPath: string
-	private readonly STALE_LOCK_TIMEOUT = 1 * 60 * 1000 // 1 minute in milliseconds
-
-	constructor(options: SqliteLockManagerOptions) {
-		this.instanceAddress = options.instanceAddress
-		this.dbPath = options.dbPath
-
-		// Ensure the directory exists before creating the database
-		const dbDir = path.dirname(this.dbPath)
-		try {
-			mkdirSync(dbDir, { recursive: true })
-		} catch (error) {
-			console.error(`CRITICAL ERROR: Failed to create SQLite database directory ${dbDir}:`, error)
-			throw new Error(`Failed to create SQLite database directory: ${error}`)
-		}
-
-		try {
-			this.initializeDatabaseWithLockSync()
-		} catch (error) {
-			console.error(`CRITICAL ERROR: Failed to initialize SQLite database at ${this.dbPath}:`, error)
-			throw new Error(`Failed to initialize SQLite database: ${error}`)
-		}
-	}
-
-	private initializeDatabaseWithLockSync(): void {
-		const lockFile = `${this.dbPath}.lock`
-
-		// Clean up stale lock files first
-		this.cleanupStaleLockSync(lockFile)
-
-		try {
-			// Try to acquire exclusive file lock for database creation
-			let fd: number | null = null
-
-			try {
-				fd = fs.openSync(lockFile, "wx") // Exclusive creation - fails if file exists
-
-				// Write timestamp to lock file for stale lock detection
-				fs.writeFileSync(fd, Date.now().toString())
-
-				// Check if database already exists
-				const dbExists = existsSync(this.dbPath)
-
-				if (!dbExists) {
-					// Database doesn't exist, create it
-					this.db = new Database(this.dbPath)
-					this.initializeDatabase()
-				} else {
-					// Database exists, just open it
-					this.db = new Database(this.dbPath)
-				}
-			} finally {
-				// Always clean up the lock file
-				if (fd !== null) {
-					fs.closeSync(fd)
-				}
-				try {
-					unlinkSync(lockFile)
-				} catch {} // Ignore errors if file was already deleted
-			}
-		} catch (error: any) {
-			if (error.code === "EEXIST") {
-				// Another process is initializing the database, wait and retry
-				const delay = 100 + Math.random() * 100 // Add jitter
-				this.sleepSync(delay)
-				this.initializeDatabaseWithLockSync()
-				return
-			}
-			throw error
-		}
-	}
-
-	private sleepSync(ms: number) {
-		// Non-spinning, synchronous sleep using Atomics.wait
-		// Works in Node main thread (since v12.16+) and worker threads.
-		const sab = new SharedArrayBuffer(4)
-		const ia = new Int32Array(sab)
-		Atomics.wait(ia, 0, 0, Math.max(0, Math.floor(ms)))
-	}
-
-	private cleanupStaleLockSync(lockFile: string): void {
-		try {
-			if (!existsSync(lockFile)) {
-				return // Lock file doesn't exist, nothing to clean up
-			}
-
-			try {
-				const timestampStr = fs.readFileSync(lockFile, "utf8").trim()
-				const timestamp = parseInt(timestampStr, 10)
-
-				if (isNaN(timestamp) || Date.now() - timestamp > this.STALE_LOCK_TIMEOUT) {
-					// Stale lock, remove it
-					unlinkSync(lockFile)
-					console.warn(`Removed stale database lock file: ${lockFile}`)
-				}
-			} catch (readError) {
-				// If we can't read the timestamp, assume it's stale
-				unlinkSync(lockFile)
-				console.warn(`Removed unreadable database lock file: ${lockFile}`)
-			}
-		} catch (error: any) {
-			if (error.code !== "ENOENT") {
-				// Lock file doesn't exist, which is fine
-				console.warn(`Error checking lock file ${lockFile}:`, error)
-			}
-		}
-	}
-
-	private initializeDatabase() {
-		// Create the locks table with the unified schema (matches cli/pkg/common/schema.go)
-		this.db.exec(`
-			CREATE TABLE IF NOT EXISTS locks (
-				id INTEGER PRIMARY KEY,
-				held_by TEXT NOT NULL,
-				lock_type TEXT NOT NULL CHECK (lock_type IN ('file', 'instance', 'folder')),
-				lock_target TEXT NOT NULL,
-				locked_at INTEGER NOT NULL,
-				UNIQUE(lock_type, lock_target)
-			);
-		`)
-
-		// Create indexes for performance (matches cli/pkg/common/schema.go)
-		this.db.exec(`
-			CREATE INDEX IF NOT EXISTS idx_locks_held_by ON locks(held_by);
-			CREATE INDEX IF NOT EXISTS idx_locks_type ON locks(lock_type);
-			CREATE INDEX IF NOT EXISTS idx_locks_target ON locks(lock_target);
-		`)
-	}
-
-	/**
-	 * Register this instance in the locks table
-	 */
-	async registerInstance(data: { hostAddress: string }): Promise<void> {
-		const now = Date.now()
-
-		// Create instance lock entry
-		const insertLock = this.db.prepare(`
-			INSERT OR REPLACE INTO locks (held_by, lock_type, lock_target, locked_at)
-			VALUES (?, 'instance', ?, ?)
-		`)
-
-		insertLock.run(this.instanceAddress, data.hostAddress, now)
-	}
-
-	/**
-	 * Update the timestamp for this instance (touch)
-	 */
-	touchInstance(): void {
-		const now = Date.now()
-		const updateLock = this.db.prepare(`
-			UPDATE locks 
-			SET locked_at = ? 
-			WHERE held_by = ? AND lock_type = 'instance'
-		`)
-
-		updateLock.run(now, this.instanceAddress)
-	}
-
-	/**
-	 * Remove this instance from the locks table
-	 */
-	unregisterInstance(): void {
-		const deleteLock = this.db.prepare(`
-			DELETE FROM locks 
-			WHERE held_by = ? AND lock_type = 'instance'
-		`)
-
-		deleteLock.run(this.instanceAddress)
-	}
-
-	/**
-	 * Query the registry for any instance registered on the given port
-	 */
-	getInstanceByPort(port: number): { instanceAddress: string; hostAddress: string } | null {
-		const query = this.db.prepare(`
-			SELECT held_by, lock_target 
-			FROM locks 
-			WHERE lock_type = 'instance' 
-			AND (held_by LIKE '%:' || ? OR lock_target LIKE '%:' || ?)
-		`)
-
-		const result = query.get(port, port) as { held_by: string; lock_target: string } | undefined
-
-		if (result) {
-			return {
-				instanceAddress: result.held_by,
-				hostAddress: result.lock_target,
-			}
-		}
-
-		return null
-	}
-
-	/**
-	 * Remove a specific instance entry from the registry
-	 */
-	removeInstanceByAddress(instanceAddress: string): void {
-		const deleteLock = this.db.prepare(`
-			DELETE FROM locks 
-			WHERE held_by = ? AND lock_type = 'instance'
-		`)
-
-		deleteLock.run(instanceAddress)
-	}
-
-	/**
-	 * Close the database connection
-	 */
-	close(): void {
-		this.db.close()
-	}
-}

src/core/locks/types.ts

@@ -1,14 +0,0 @@
-export type LockType = "file" | "instance" | "folder"
-
-export interface LockRow {
-	id: number
-	held_by: string
-	lock_type: LockType
-	lock_target: string // varies by type: file path, host address, or folder path
-	locked_at: number
-}
-
-export interface SqliteLockManagerOptions {
-	dbPath: string
-	instanceAddress: string // cline core address
-}

src/core/mentions/index.ts

@@ -3,7 +3,6 @@ import { extractTextFromFile } from "@integrations/misc/extract-text"
 import { openFile } from "@integrations/misc/open-file"
 import { getLatestTerminalOutput } from "@integrations/terminal/get-latest-output"
 import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
-import { telemetryService } from "@services/telemetry"
 import { mentionRegexGlobal } from "@shared/context-mentions"
 import { openExternal } from "@utils/env"
 import { getCommitInfo, getWorkingState } from "@utils/git"
@@ -111,28 +110,21 @@ export async function parseMentions(
 			let result: string
 			if (launchBrowserError) {
 				result = `Error fetching content: ${launchBrowserError.message}`
-				// Track failed URL mention
-				telemetryService.captureMentionFailed("url", "network_error", launchBrowserError?.message || "")
 			} else {
 				try {
 					const markdown = await urlContentFetcher.urlToMarkdown(mention)
 					result = markdown
-					// Track successful URL mention
-					telemetryService.captureMentionUsed("url", markdown.length)
 				} catch (error) {
 					HostProvider.window.showMessage({
 						type: ShowMessageType.ERROR,
 						message: `Error fetching content for ${mention}: ${error.message}`,
 					})
 					result = `Error fetching content: ${error.message}`
-					// Track failed URL mention
-					telemetryService.captureMentionFailed("url", "network_error", error.message)
 				}
 			}
 			parsedText += `\n\n<url_content url="${mention}">\n${result}\n</url_content>`
 		} else if (isFileMention(mention)) {
 			const mentionPath = getFilePathFromMention(mention)
-			const mentionType = mention.endsWith("/") ? "folder" : "file"
 			try {
 				const content = await getFileOrFolderContent(mentionPath, cwd)
 				if (mention.endsWith("/")) {
@@ -144,67 +136,40 @@ export async function parseMentions(
 						await fileContextTracker.trackFileContext(mentionPath, "file_mentioned")
 					}
 				}
-				// Track successful file/folder mention
-				telemetryService.captureMentionUsed(mentionType, content.length)
 			} catch (error) {
 				if (mention.endsWith("/")) {
 					parsedText += `\n\n<folder_content path="${mentionPath}">\nError fetching content: ${error.message}\n</folder_content>`
 				} else {
 					parsedText += `\n\n<file_content path="${mentionPath}">\nError fetching content: ${error.message}\n</file_content>`
 				}
-				// Track failed file/folder mention
-				// Map file access errors to appropriate error types
-				let errorType: "not_found" | "permission_denied" | "unknown" = "unknown"
-				if (error.message.includes("ENOENT") || error.message.includes("Failed to access")) {
-					errorType = "not_found"
-				} else if (error.message.includes("EACCES") || error.message.includes("permission")) {
-					errorType = "permission_denied"
-				}
-				telemetryService.captureMentionFailed(mentionType, errorType, error.message)
 			}
 		} else if (mention === "problems") {
 			try {
 				const problems = await getWorkspaceProblems()
 				parsedText += `\n\n<workspace_diagnostics>\n${problems}\n</workspace_diagnostics>`
-				// Track successful problems mention
-				telemetryService.captureMentionUsed("problems", problems.length)
 			} catch (error) {
 				parsedText += `\n\n<workspace_diagnostics>\nError fetching diagnostics: ${error.message}\n</workspace_diagnostics>`
-				// Track failed problems mention
-				telemetryService.captureMentionFailed("problems", "unknown", error.message)
 			}
 		} else if (mention === "terminal") {
 			try {
 				const terminalOutput = await getLatestTerminalOutput()
 				parsedText += `\n\n<terminal_output>\n${terminalOutput}\n</terminal_output>`
-				// Track successful terminal mention
-				telemetryService.captureMentionUsed("terminal", terminalOutput.length)
 			} catch (error) {
 				parsedText += `\n\n<terminal_output>\nError fetching terminal output: ${error.message}\n</terminal_output>`
-				// Track failed terminal mention
-				telemetryService.captureMentionFailed("terminal", "unknown", error.message)
 			}
 		} else if (mention === "git-changes") {
 			try {
 				const workingState = await getWorkingState(cwd)
 				parsedText += `\n\n<git_working_state>\n${workingState}\n</git_working_state>`
-				// Track successful git-changes mention
-				telemetryService.captureMentionUsed("git-changes", workingState.length)
 			} catch (error) {
 				parsedText += `\n\n<git_working_state>\nError fetching working state: ${error.message}\n</git_working_state>`
-				// Track failed git-changes mention
-				telemetryService.captureMentionFailed("git-changes", "unknown", error.message)
 			}
 		} else if (/^[a-f0-9]{7,40}$/.test(mention)) {
 			try {
 				const commitInfo = await getCommitInfo(mention, cwd)
 				parsedText += `\n\n<git_commit hash="${mention}">\n${commitInfo}\n</git_commit>`
-				// Track successful commit mention
-				telemetryService.captureMentionUsed("commit", commitInfo.length)
 			} catch (error) {
 				parsedText += `\n\n<git_commit hash="${mention}">\nError fetching commit info: ${error.message}\n</git_commit>`
-				// Track failed commit mention
-				telemetryService.captureMentionFailed("commit", "unknown", error.message)
 			}
 		}
 	}

src/core/storage/StateManager.ts

@@ -33,8 +33,6 @@ export interface PersistenceErrorEvent {
  * Provides immediate reads/writes with async disk persistence
  */
 export class StateManager {
-	private static instance: StateManager | null = null
-
 	private globalStateCache: GlobalStateAndSettings = {} as GlobalStateAndSettings
 	private taskStateCache: Partial<Settings> = {}
 	private secretsCache: Secrets = {} as Secrets
@@ -44,7 +42,7 @@ export class StateManager {
 
 	// Debounced persistence state
 	private pendingGlobalState = new Set<GlobalStateAndSettingsKey>()
-	private pendingTaskState = new Map<string, Set<SettingsKey>>()
+	private pendingTaskState = new Set<SettingsKey>()
 	private pendingSecrets = new Set<SecretKey>()
 	private pendingWorkspaceState = new Set<LocalStateKey>()
 	private persistenceTimeout: NodeJS.Timeout | null = null
@@ -57,64 +55,32 @@ export class StateManager {
 	// Callback to sync external state changes with the UI client
 	onSyncExternalChange?: () => void | Promise<void>
 
-	private constructor(context: ExtensionContext) {
+	constructor(context: ExtensionContext) {
 		this.context = context
 	}
 
 	/**
 	 * Initialize the cache by loading data from disk
 	 */
-	public static async initialize(context: ExtensionContext): Promise<StateManager> {
-		if (!StateManager.instance) {
-			StateManager.instance = new StateManager(context)
-		}
-
-		if (StateManager.instance.isInitialized) {
-			throw new Error("StateManager has already been initialized.")
-		}
-
+	async initialize(): Promise<void> {
 		try {
 			// Load all extension state from disk
-			const globalState = await readGlobalStateFromDisk(StateManager.instance.context)
-			const secrets = await readSecretsFromDisk(StateManager.instance.context)
-			const workspaceState = await readWorkspaceStateFromDisk(StateManager.instance.context)
+			const globalState = await readGlobalStateFromDisk(this.context)
+			const secrets = await readSecretsFromDisk(this.context)
+			const workspaceState = await readWorkspaceStateFromDisk(this.context)
 
 			// Populate the cache with all extension state and secrets fields
 			// Use populate method to avoid triggering persistence during initialization
-			StateManager.instance.populateCache(globalState, secrets, workspaceState)
+			this.populateCache(globalState, secrets, workspaceState)
+
+			this.isInitialized = true
 
 			// Start watcher for taskHistory.json so external edits update cache (no persist loop)
-			await StateManager.instance.setupTaskHistoryWatcher()
-
-			StateManager.instance.isInitialized = true
+			await this.setupTaskHistoryWatcher()
 		} catch (error) {
 			console.error("[StateManager] Failed to initialize:", error)
 			throw error
 		}
-
-		return StateManager.instance
-	}
-
-	public static get(): StateManager {
-		if (!StateManager.instance) {
-			throw new Error("StateManager has not been initialized")
-		}
-		return StateManager.instance
-	}
-
-	/**
-	 * Register callbacks for state manager events
-	 */
-	public registerCallbacks(callbacks: {
-		onPersistenceError?: (event: PersistenceErrorEvent) => void | Promise<void>
-		onSyncExternalChange?: () => void | Promise<void>
-	}): void {
-		if (callbacks.onPersistenceError) {
-			this.onPersistenceError = callbacks.onPersistenceError
-		}
-		if (callbacks.onSyncExternalChange) {
-			this.onSyncExternalChange = callbacks.onSyncExternalChange
-		}
 	}
 
 	/**
@@ -166,11 +132,8 @@ export class StateManager {
 		this.taskStateCache[key] = value
 
 		// Add to pending persistence set and schedule debounced write
-		if (!this.pendingTaskState.has(taskId)) {
-			this.pendingTaskState.set(taskId, new Set())
-		}
-		this.pendingTaskState.get(taskId)!.add(key)
-		this.scheduleDebouncedPersistence()
+		this.pendingTaskState.add(key)
+		this.scheduleDebouncedPersistence(taskId)
 	}
 
 	/**
@@ -185,15 +148,12 @@ export class StateManager {
 		Object.assign(this.taskStateCache, updates)
 
 		// Then track the keys for persistence
-		if (!this.pendingTaskState.has(taskId)) {
-			this.pendingTaskState.set(taskId, new Set())
-		}
 		Object.keys(updates).forEach((key) => {
-			this.pendingTaskState.get(taskId)!.add(key as SettingsKey)
+			this.pendingTaskState.add(key as SettingsKey)
 		})
 
 		// Schedule debounced persistence
-		this.scheduleDebouncedPersistence()
+		this.scheduleDebouncedPersistence(taskId)
 	}
 
 	/**
@@ -222,12 +182,12 @@ export class StateManager {
 	/**
 	 * Clear task settings cache - ensures pending changes are persisted first
 	 */
-	async clearTaskSettings(): Promise<void> {
+	async clearTaskSettings(taskId?: string): Promise<void> {
 		// If there are pending task settings, persist them first
-		if (this.pendingTaskState.size > 0) {
+		if (this.pendingTaskState.size > 0 && taskId) {
 			try {
 				// Persist pending task state immediately
-				await this.persistTaskStateBatch(this.pendingTaskState)
+				await this.persistTaskStateBatch(this.pendingTaskState, taskId)
 				// Clear pending set after successful persistence
 				this.pendingTaskState.clear()
 			} catch (error) {
@@ -725,7 +685,7 @@ export class StateManager {
 		this.dispose()
 
 		// Reinitialize from disk
-		await StateManager.initialize(this.context)
+		await this.initialize()
 
 		// If there's an active task, reload its settings
 		if (currentTaskId) {
@@ -763,7 +723,7 @@ export class StateManager {
 	/**
 	 * Schedule debounced persistence - simple timeout-based persistence
 	 */
-	private scheduleDebouncedPersistence(): void {
+	private scheduleDebouncedPersistence(taskId?: string): void {
 		// Clear existing timeout if one is pending
 		if (this.persistenceTimeout) {
 			clearTimeout(this.persistenceTimeout)
@@ -776,7 +736,7 @@ export class StateManager {
 					this.persistGlobalStateBatch(this.pendingGlobalState),
 					this.persistSecretsBatch(this.pendingSecrets),
 					this.persistWorkspaceStateBatch(this.pendingWorkspaceState),
-					this.persistTaskStateBatch(this.pendingTaskState),
+					this.persistTaskStateBatch(this.pendingTaskState, taskId),
 				])
 
 				// Clear pending sets on successful persistence
@@ -816,27 +776,16 @@ export class StateManager {
 	}
 
 	/**
-	 * Private method to batch persist task state keys with a single write operation
+	 * Private method to batch persist task state keys with Promise.all
 	 */
-	private async persistTaskStateBatch(pendingTaskStates: Map<string, Set<SettingsKey>>): Promise<void> {
-		if (pendingTaskStates.size === 0) {
+	private async persistTaskStateBatch(keys: Set<SettingsKey>, taskId: string | undefined): Promise<void> {
+		if (!taskId) {
 			return
 		}
 		try {
-			// Persist each task's settings
 			await Promise.all(
-				Array.from(pendingTaskStates.entries()).map(([taskId, keys]) => {
-					if (keys.size === 0) {
-						return Promise.resolve()
-					}
-					const settingsToWrite: Record<string, any> = {}
-					for (const key of keys) {
-						const value = this.taskStateCache[key]
-						if (value !== undefined) {
-							settingsToWrite[key] = value
-						}
-					}
-					return writeTaskSettingsToStorage(taskId, settingsToWrite)
+				Array.from(keys).map((key) => {
+					return writeTaskSettingsToStorage(taskId, { [key]: this.taskStateCache[key] })
 				}),
 			)
 		} catch (error) {

src/core/storage/disk.ts

@@ -8,7 +8,7 @@ import fs from "fs/promises"
 import os from "os"
 import * as path from "path"
 import { HostProvider } from "@/hosts/host-provider"
-import { GlobalState, Settings } from "./state-keys"
+import { GlobalState } from "./state-keys"
 
 export const GlobalFileNames = {
 	apiConversationHistory: "api_conversation_history.json",
@@ -242,7 +242,7 @@ export async function readTaskSettingsFromStorage(taskId: string): Promise<Parti
 	}
 }
 
-export async function writeTaskSettingsToStorage(taskId: string, settings: Partial<Settings>) {
+export async function writeTaskSettingsToStorage(taskId: string, settings: Partial<GlobalState>) {
 	try {
 		const taskDirectoryFilePath = await ensureTaskDirectoryExists(taskId)
 		const settingsFilePath = path.join(taskDirectoryFilePath, "settings.json")

src/core/storage/state-migrations.ts

@@ -3,6 +3,7 @@ import path from "path"
 import * as vscode from "vscode"
 import { HistoryItem } from "@/shared/HistoryItem"
 import { ensureRulesDirectoryExists, readTaskHistoryFromState, writeTaskHistoryToState } from "./disk"
+import { StateManager } from "./StateManager"
 
 export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionContext) {
 	// Keys to migrate from workspace storage back to global storage
@@ -565,68 +566,44 @@ export async function migrateWelcomeViewCompleted(context: vscode.ExtensionConte
 		if (welcomeViewCompleted === undefined) {
 			console.log("Migrating welcomeViewCompleted setting...")
 
-			// Fetch API keys directly from secrets
-			const apiKey = await context.secrets.get("apiKey")
-			const openRouterApiKey = await context.secrets.get("openRouterApiKey")
-			const clineAccountId = await context.secrets.get("clineAccountId")
-			const openAiApiKey = await context.secrets.get("openAiApiKey")
-			const ollamaApiKey = await context.secrets.get("ollamaApiKey")
-			const liteLlmApiKey = await context.secrets.get("liteLlmApiKey")
-			const geminiApiKey = await context.secrets.get("geminiApiKey")
-			const openAiNativeApiKey = await context.secrets.get("openAiNativeApiKey")
-			const deepSeekApiKey = await context.secrets.get("deepSeekApiKey")
-			const requestyApiKey = await context.secrets.get("requestyApiKey")
-			const togetherApiKey = await context.secrets.get("togetherApiKey")
-			const qwenApiKey = await context.secrets.get("qwenApiKey")
-			const doubaoApiKey = await context.secrets.get("doubaoApiKey")
-			const mistralApiKey = await context.secrets.get("mistralApiKey")
-			const asksageApiKey = await context.secrets.get("asksageApiKey")
-			const xaiApiKey = await context.secrets.get("xaiApiKey")
-			const sambanovaApiKey = await context.secrets.get("sambanovaApiKey")
-			const sapAiCoreClientId = await context.secrets.get("sapAiCoreClientId")
-			const difyApiKey = await context.secrets.get("difyApiKey")
+			// Get all extension state to check for existing API keys
+			const stateManager = new StateManager(context)
+			await stateManager.initialize()
+			const config = stateManager.getApiConfiguration()
 
-			// Fetch configuration values from global state
-			const awsRegion = context.globalState.get("awsRegion")
-			const vertexProjectId = context.globalState.get("vertexProjectId")
-			const planModeOllamaModelId = context.globalState.get("planModeOllamaModelId")
-			const planModeLmStudioModelId = context.globalState.get("planModeLmStudioModelId")
-			const actModeOllamaModelId = context.globalState.get("actModeOllamaModelId")
-			const actModeLmStudioModelId = context.globalState.get("actModeLmStudioModelId")
-			const planModeVsCodeLmModelSelector = context.globalState.get("planModeVsCodeLmModelSelector")
-			const actModeVsCodeLmModelSelector = context.globalState.get("actModeVsCodeLmModelSelector")
-
-			// This is the original logic used for checking if the welcome view should be shown
+			// This is the original logic used for checking is the welcome view should be shown
 			// It was located in the ExtensionStateContextProvider
-			const hasKey = [
-				apiKey,
-				openRouterApiKey,
-				awsRegion,
-				vertexProjectId,
-				openAiApiKey,
-				ollamaApiKey,
-				planModeOllamaModelId,
-				planModeLmStudioModelId,
-				actModeOllamaModelId,
-				actModeLmStudioModelId,
-				liteLlmApiKey,
-				geminiApiKey,
-				openAiNativeApiKey,
-				deepSeekApiKey,
-				requestyApiKey,
-				togetherApiKey,
-				qwenApiKey,
-				doubaoApiKey,
-				mistralApiKey,
-				planModeVsCodeLmModelSelector,
-				actModeVsCodeLmModelSelector,
-				clineAccountId,
-				asksageApiKey,
-				xaiApiKey,
-				sambanovaApiKey,
-				sapAiCoreClientId,
-				difyApiKey,
-			].some((key) => key !== undefined)
+			const hasKey = config
+				? [
+						config.apiKey,
+						config.openRouterApiKey,
+						config.awsRegion,
+						config.vertexProjectId,
+						config.openAiApiKey,
+						config.ollamaApiKey,
+						config.planModeOllamaModelId,
+						config.planModeLmStudioModelId,
+						config.actModeOllamaModelId,
+						config.actModeLmStudioModelId,
+						config.liteLlmApiKey,
+						config.geminiApiKey,
+						config.openAiNativeApiKey,
+						config.deepSeekApiKey,
+						config.requestyApiKey,
+						config.togetherApiKey,
+						config.qwenApiKey,
+						config.doubaoApiKey,
+						config.mistralApiKey,
+						config.planModeVsCodeLmModelSelector,
+						config.actModeVsCodeLmModelSelector,
+						config.clineAccountId,
+						config.asksageApiKey,
+						config.xaiApiKey,
+						config.sambanovaApiKey,
+						config.sapAiCoreClientId,
+						config.difyApiKey,
+					].some((key) => key !== undefined)
+				: false
 
 			// Set welcomeViewCompleted based on whether user has keys
 			await context.globalState.update("welcomeViewCompleted", hasKey)

src/core/task/index.ts

@@ -31,7 +31,6 @@ import {
 	getSavedApiConversationHistory,
 	getSavedClineMessages,
 } from "@core/storage/disk"
-import { isMultiRootEnabled } from "@core/workspace/multi-root-utils"
 import { WorkspaceRootManager } from "@core/workspace/WorkspaceRootManager"
 import { buildCheckpointManager, shouldUseMultiRoot } from "@integrations/checkpoints/factory"
 import { ensureCheckpointInitialized } from "@integrations/checkpoints/initializer"
@@ -44,7 +43,6 @@ import { TerminalManager } from "@integrations/terminal/TerminalManager"
 import { BrowserSession } from "@services/browser/BrowserSession"
 import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
 import { listFiles } from "@services/glob/list-files"
-import { Logger } from "@services/logging/Logger"
 import { McpHub } from "@services/mcp/McpHub"
 import { ApiConfiguration } from "@shared/api"
 import { findLast, findLastIndex } from "@shared/array"
@@ -56,11 +54,10 @@ import { DEFAULT_LANGUAGE_SETTINGS, getLanguageKey, LanguageDisplay } from "@sha
 import { convertClineMessageToProto } from "@shared/proto-conversions/cline-message"
 import { ClineDefaultTool } from "@shared/tools"
 import { ClineAskResponse } from "@shared/WebviewMessage"
+import { getGitRemoteUrls, getLatestGitCommitHash } from "@utils/git"
 import { isLocalModel, isNextGenModelFamily } from "@utils/model-utils"
 import { arePathsEqual, getDesktopDir } from "@utils/path"
-import { filterExistingFiles } from "@utils/tabFiltering"
 import cloneDeep from "clone-deep"
-import { execa } from "execa"
 import pWaitFor from "p-wait-for"
 import * as path from "path"
 import { ulid } from "ulid"
@@ -69,20 +66,23 @@ import type { SystemPromptContext } from "@/core/prompts/system-prompt"
 import { getSystemPrompt } from "@/core/prompts/system-prompt"
 import { HostProvider } from "@/hosts/host-provider"
 import { ErrorService } from "@/services/error"
-import { TerminalHangStage, TerminalUserInterventionAction, telemetryService } from "@/services/telemetry"
+import { featureFlagsService } from "@/services/feature-flags"
+import { telemetryService } from "@/services/telemetry"
 import { ShowMessageType } from "@/shared/proto/index.host"
-import { isInTestMode } from "../../services/test/TestMode"
 import { ensureLocalClineDirExists } from "../context/instructions/user-instructions/rule-helpers"
 import { refreshWorkflowToggles } from "../context/instructions/user-instructions/workflows"
 import { Controller } from "../controller"
 import { StateManager } from "../storage/StateManager"
 import { FocusChainManager } from "./focus-chain"
 import { MessageStateHandler } from "./message-state"
+import { CommandRunner } from "./runtime/CommandRunner"
 import { TaskState } from "./TaskState"
 import { ToolExecutor } from "./ToolExecutor"
+
+export type { ToolResponse } from "./types"
+
 import { detectAvailableCliTools, updateApiReqMsg } from "./utils"
 
-export type ToolResponse = string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam>
 type UserContent = Array<Anthropic.ContentBlockParam>
 
 type TaskParams = {
@@ -103,7 +103,6 @@ type TaskParams = {
 	images?: string[]
 	files?: string[]
 	historyItem?: HistoryItem
-	taskId: string
 }
 
 export class Task {
@@ -130,6 +129,7 @@ export class Task {
 	public checkpointManager?: ICheckpointManager
 	private clineIgnoreController: ClineIgnoreController
 	private toolExecutor: ToolExecutor
+	private commandRunner: CommandRunner
 
 	// Metadata tracking
 	private fileContextTracker: FileContextTracker
@@ -172,7 +172,6 @@ export class Task {
 			images,
 			files,
 			historyItem,
-			taskId,
 		} = params
 
 		this.taskInitializationStartTime = performance.now()
@@ -216,10 +215,9 @@ export class Task {
 			await this.say("mcp_notification", `[${serverName}] ${message}`)
 		})
 
-		this.taskId = taskId
-
 		// Initialize taskId first
 		if (historyItem) {
+			this.taskId = historyItem.id
 			this.ulid = historyItem.ulid ?? ulid()
 			this.taskIsFavorited = historyItem.isFavorited
 			this.taskState.conversationHistoryDeletedRange = historyItem.conversationHistoryDeletedRange
@@ -227,6 +225,7 @@ export class Task {
 				this.taskState.checkpointManagerErrorMessage = historyItem.checkpointManagerErrorMessage
 			}
 		} else if (task || images || files) {
+			this.taskId = Date.now().toString()
 			this.ulid = ulid()
 		} else {
 			throw new Error("Either historyItem or task/images must be provided")
@@ -258,57 +257,45 @@ export class Task {
 			})
 		}
 
-		// Check for multiroot workspace and warn about checkpoints
-		const isMultiRootWorkspace = this.workspaceManager && this.workspaceManager.getRoots().length > 1
-		const checkpointsEnabled = this.stateManager.getGlobalSettingsKey("enableCheckpointsSetting")
-
-		if (isMultiRootWorkspace && checkpointsEnabled) {
-			// Set checkpoint manager error message to display warning in TaskHeader
-			this.taskState.checkpointManagerErrorMessage = "Checkpoints are not currently supported in multi-root workspaces."
-		}
-
 		// Initialize checkpoint manager based on workspace configuration
-		if (!isMultiRootWorkspace) {
-			try {
-				this.checkpointManager = buildCheckpointManager({
-					taskId: this.taskId,
-					messageStateHandler: this.messageStateHandler,
-					fileContextTracker: this.fileContextTracker,
-					diffViewProvider: this.diffViewProvider,
-					taskState: this.taskState,
-					workspaceManager: this.workspaceManager,
-					updateTaskHistory: this.updateTaskHistory,
-					say: this.say.bind(this),
-					cancelTask: this.cancelTask,
-					postStateToWebview: this.postStateToWebview,
-					initialConversationHistoryDeletedRange: this.taskState.conversationHistoryDeletedRange,
-					initialCheckpointManagerErrorMessage: this.taskState.checkpointManagerErrorMessage,
-					stateManager: this.stateManager,
-				})
+		try {
+			this.checkpointManager = buildCheckpointManager({
+				taskId: this.taskId,
+				messageStateHandler: this.messageStateHandler,
+				fileContextTracker: this.fileContextTracker,
+				diffViewProvider: this.diffViewProvider,
+				taskState: this.taskState,
+				workspaceManager: this.workspaceManager,
+				updateTaskHistory: this.updateTaskHistory,
+				say: this.say.bind(this),
+				cancelTask: this.cancelTask,
+				postStateToWebview: this.postStateToWebview,
+				initialConversationHistoryDeletedRange: this.taskState.conversationHistoryDeletedRange,
+				initialCheckpointManagerErrorMessage: this.taskState.checkpointManagerErrorMessage,
+				stateManager: this.stateManager,
+			})
 
-				// If multi-root, kick off non-blocking initialization
-				// Unreachable for now, leaving in for future multi-root checkpoint support
-				if (
-					shouldUseMultiRoot({
-						workspaceManager: this.workspaceManager,
-						enableCheckpoints: this.stateManager.getGlobalSettingsKey("enableCheckpointsSetting"),
-						stateManager: this.stateManager,
-					})
-				) {
-					this.checkpointManager.initialize?.().catch((error: Error) => {
-						console.error("Failed to initialize multi-root checkpoint manager:", error)
-						this.taskState.checkpointManagerErrorMessage = error?.message || String(error)
-					})
-				}
-			} catch (error) {
-				console.error("Failed to initialize checkpoint manager:", error)
-				if (this.stateManager.getGlobalSettingsKey("enableCheckpointsSetting")) {
-					const errorMessage = error instanceof Error ? error.message : "Unknown error"
-					HostProvider.window.showMessage({
-						type: ShowMessageType.ERROR,
-						message: `Failed to initialize checkpoint manager: ${errorMessage}`,
-					})
-				}
+			// If multi-root, kick off non-blocking initialization
+			if (
+				shouldUseMultiRoot({
+					workspaceManager: this.workspaceManager,
+					enableCheckpoints: this.stateManager.getGlobalSettingsKey("enableCheckpointsSetting"),
+					isMultiRootEnabled: featureFlagsService.getMultiRootEnabled(),
+				})
+			) {
+				this.checkpointManager.initialize?.().catch((error: Error) => {
+					console.error("Failed to initialize multi-root checkpoint manager:", error)
+					this.taskState.checkpointManagerErrorMessage = error?.message || String(error)
+				})
+			}
+		} catch (error) {
+			console.error("Failed to initialize checkpoint manager:", error)
+			if (this.stateManager.getGlobalSettingsKey("enableCheckpointsSetting")) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error"
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: `Failed to initialize checkpoint manager: ${errorMessage}`,
+				})
 			}
 		}
 
@@ -391,6 +378,8 @@ export class Task {
 			telemetryService.captureTaskCreated(this.ulid, currentProvider)
 		}
 
+		this.commandRunner = new CommandRunner(this.cwd, this.terminalManager, this.ask.bind(this), this.say.bind(this))
+
 		this.toolExecutor = new ToolExecutor(
 			this.controller.context,
 			this.taskState,
@@ -408,13 +397,13 @@ export class Task {
 			this.taskId,
 			this.ulid,
 			this.workspaceManager,
-			isMultiRootEnabled(this.stateManager),
+			featureFlagsService.getMultiRootEnabled(),
 			this.say.bind(this),
 			this.ask.bind(this),
 			this.saveCheckpointCallback.bind(this),
 			this.sayAndCreateMissingParamError.bind(this),
 			this.removeLastPartialMessageIfExistsWithType.bind(this),
-			this.executeCommandTool.bind(this),
+			this.commandRunner.execute.bind(this.commandRunner),
 			() => this.checkpointManager?.doesLatestTaskCompletionHaveNewChanges() ?? Promise.resolve(false),
 			this.FocusChainManager?.updateFCListFromToolResponse.bind(this.FocusChainManager) || (async () => {}),
 			this.switchToActModeCallback.bind(this),
@@ -955,314 +944,6 @@ export class Task {
 		}
 	}
 
-	// Tools
-
-	/**
-	 * Executes a command directly in Node.js using execa
-	 * This is used in test mode to capture the full output without using the VS Code terminal
-	 * Commands are automatically terminated after 30 seconds using Promise.race
-	 */
-	private async executeCommandInNode(command: string): Promise<[boolean, ToolResponse]> {
-		try {
-			// Create a child process
-			const childProcess = execa(command, {
-				shell: true,
-				cwd: this.cwd,
-				reject: false,
-				all: true, // Merge stdout and stderr
-			})
-
-			// Set up variables to collect output
-			let output = ""
-
-			// Collect output in real-time
-			if (childProcess.all) {
-				childProcess.all.on("data", (data) => {
-					output += data.toString()
-				})
-			}
-
-			// Create a timeout promise that rejects after 30 seconds
-			const timeoutPromise = new Promise<never>((_, reject) => {
-				setTimeout(() => {
-					if (childProcess.pid) {
-						childProcess.kill("SIGKILL") // Use SIGKILL for more forceful termination
-					}
-					reject(new Error("Command timeout after 30s"))
-				}, 30000)
-			})
-
-			// Race between command completion and timeout
-			const result = await Promise.race([childProcess, timeoutPromise]).catch((_error) => {
-				// If we get here due to timeout, return a partial result with timeout flag
-				Logger.info(`Command timed out after 30s: ${command}`)
-				return {
-					stdout: "",
-					stderr: "",
-					exitCode: 124, // Standard timeout exit code
-					timedOut: true,
-				}
-			})
-
-			// Check if timeout occurred
-			const wasTerminated = result.timedOut === true
-
-			// Use collected output or result output
-			if (!output) {
-				output = result.stdout || result.stderr || ""
-			}
-
-			Logger.info(`Command executed in Node: ${command}\nOutput:\n${output}`)
-
-			// Add termination message if the command was terminated
-			if (wasTerminated) {
-				output += "\nCommand was taking a while to run so it was auto terminated after 30s"
-			}
-
-			// Format the result similar to terminal output
-			return [
-				false,
-				`Command executed${wasTerminated ? " (terminated after 30s)" : ""} with exit code ${
-					result.exitCode
-				}.${output.length > 0 ? `\nOutput:\n${output}` : ""}`,
-			]
-		} catch (error) {
-			// Handle any errors that might occur
-			const errorMessage = error instanceof Error ? error.message : String(error)
-			return [false, `Error executing command: ${errorMessage}`]
-		}
-	}
-
-	async executeCommandTool(command: string, timeoutSeconds: number | undefined): Promise<[boolean, ToolResponse]> {
-		Logger.info("IS_TEST: " + isInTestMode())
-
-		// Check if we're in test mode
-		if (isInTestMode()) {
-			// In test mode, execute the command directly in Node
-			Logger.info("Executing command in Node: " + command)
-			return this.executeCommandInNode(command)
-		}
-		Logger.info("Executing command in terminal: " + command)
-
-		const terminalInfo = await this.terminalManager.getOrCreateTerminal(this.cwd)
-		terminalInfo.terminal.show() // weird visual bug when creating new terminals (even manually) where there's an empty space at the top.
-		const process = this.terminalManager.runCommand(terminalInfo, command)
-
-		let userFeedback: { text?: string; images?: string[]; files?: string[] } | undefined
-		let didContinue = false
-
-		// Chunked terminal output buffering
-		const CHUNK_LINE_COUNT = 20
-		const CHUNK_BYTE_SIZE = 2048 // 2KB
-		const CHUNK_DEBOUNCE_MS = 100
-
-		let outputBuffer: string[] = []
-		let outputBufferSize: number = 0
-		let chunkTimer: NodeJS.Timeout | null = null
-
-		// Track if buffer gets stuck (correlated with PROCESS_WHILE_RUNNING to indicate genuine technical issues)
-		let bufferStuckTimer: NodeJS.Timeout | null = null
-		const BUFFER_STUCK_TIMEOUT_MS = 6000 // 6 seconds
-
-		const flushBuffer = async (force = false) => {
-			if (outputBuffer.length === 0) {
-				if (force) {
-					// If force is true, flush anyway
-				} else {
-					return
-				}
-			}
-			const chunk = outputBuffer.join("\n")
-			outputBuffer = []
-			outputBufferSize = 0
-
-			// Start timer to detect if buffer gets stuck
-			bufferStuckTimer = setTimeout(() => {
-				telemetryService.captureTerminalHang(TerminalHangStage.BUFFER_STUCK)
-				bufferStuckTimer = null
-			}, BUFFER_STUCK_TIMEOUT_MS)
-
-			try {
-				const { response, text, images, files } = await this.ask("command_output", chunk)
-				if (response === "yesButtonClicked") {
-					// Track when user clicks "Process while Running"
-					telemetryService.captureTerminalUserIntervention(TerminalUserInterventionAction.PROCESS_WHILE_RUNNING)
-					// proceed while running - but still capture user feedback if provided
-					if (text || (images && images.length > 0) || (files && files.length > 0)) {
-						userFeedback = { text, images, files }
-					}
-				} else {
-					userFeedback = { text, images, files }
-				}
-				didContinue = true
-				process.continue()
-
-				// If more output accumulated, flush again
-				if (outputBuffer.length > 0) {
-					await flushBuffer()
-				}
-			} catch {
-				Logger.error("Error while asking for command output")
-			} finally {
-				// If the command finishes execution before the 'command_output' ask promise resolves (in other words before the user responded to the ask, which is expected when the command finishes execution first), this block is reached. This is expected and safe to ignore, as no further handling is required.
-
-				// Clear the stuck timer
-				if (bufferStuckTimer) {
-					clearTimeout(bufferStuckTimer)
-					bufferStuckTimer = null
-				}
-			}
-		}
-
-		const scheduleFlush = () => {
-			if (chunkTimer) {
-				clearTimeout(chunkTimer)
-			}
-			chunkTimer = setTimeout(async () => await flushBuffer(), CHUNK_DEBOUNCE_MS)
-		}
-
-		const outputLines: string[] = []
-		process.on("line", async (line) => {
-			outputLines.push(line)
-
-			if (!didContinue) {
-				outputBuffer.push(line)
-				outputBufferSize += Buffer.byteLength(line, "utf8")
-				// Flush if buffer is large enough
-				if (outputBuffer.length >= CHUNK_LINE_COUNT || outputBufferSize >= CHUNK_BYTE_SIZE) {
-					await flushBuffer()
-				} else {
-					scheduleFlush()
-				}
-			} else {
-				this.say("command_output", line)
-			}
-		})
-
-		let completed = false
-		let completionTimer: NodeJS.Timeout | null = null
-		const COMPLETION_TIMEOUT_MS = 6000 // 6 seconds
-
-		// Start timer to detect if waiting for completion takes too long
-		completionTimer = setTimeout(() => {
-			if (!completed) {
-				telemetryService.captureTerminalHang(TerminalHangStage.WAITING_FOR_COMPLETION)
-				completionTimer = null
-			}
-		}, COMPLETION_TIMEOUT_MS)
-
-		process.once("completed", async () => {
-			completed = true
-			// Clear the completion timer
-			if (completionTimer) {
-				clearTimeout(completionTimer)
-				completionTimer = null
-			}
-			// Flush any remaining buffered output
-			if (!didContinue && outputBuffer.length > 0) {
-				if (chunkTimer) {
-					clearTimeout(chunkTimer)
-					chunkTimer = null
-				}
-				await flushBuffer(true)
-			}
-		})
-
-		process.once("no_shell_integration", async () => {
-			await this.say("shell_integration_warning")
-		})
-
-		//await process
-
-		if (timeoutSeconds) {
-			const timeoutPromise = new Promise<never>((_, reject) => {
-				setTimeout(() => {
-					reject(new Error("COMMAND_TIMEOUT"))
-				}, timeoutSeconds * 1000)
-			})
-
-			try {
-				await Promise.race([process, timeoutPromise])
-			} catch (error) {
-				// This will continue running the command in the background
-				didContinue = true
-				process.continue()
-
-				// Clear all our timers
-				if (chunkTimer) {
-					clearTimeout(chunkTimer)
-					chunkTimer = null
-				}
-				if (completionTimer) {
-					clearTimeout(completionTimer)
-					completionTimer = null
-				}
-
-				// Process any output we captured before timeout
-				await setTimeoutPromise(50)
-				const result = this.terminalManager.processOutput(outputLines)
-
-				if (error.message === "COMMAND_TIMEOUT") {
-					return [
-						false,
-						`Command execution timed out after ${timeoutSeconds} seconds. The command may still be running in the terminal.${result.length > 0 ? `\nOutput so far:\n${result}` : ""}`,
-					]
-				}
-
-				// Re-throw other errors
-				throw error
-			}
-		} else {
-			await process
-		}
-
-		// Clear timer if process completes normally
-		if (completionTimer) {
-			clearTimeout(completionTimer)
-			completionTimer = null
-		}
-
-		// Wait for a short delay to ensure all messages are sent to the webview
-		// This delay allows time for non-awaited promises to be created and
-		// for their associated messages to be sent to the webview, maintaining
-		// the correct order of messages (although the webview is smart about
-		// grouping command_output messages despite any gaps anyways)
-		await setTimeoutPromise(50)
-
-		const result = this.terminalManager.processOutput(outputLines)
-
-		if (userFeedback) {
-			await this.say("user_feedback", userFeedback.text, userFeedback.images, userFeedback.files)
-
-			let fileContentString = ""
-			if (userFeedback.files && userFeedback.files.length > 0) {
-				fileContentString = await processFilesIntoText(userFeedback.files)
-			}
-
-			return [
-				true,
-				formatResponse.toolResult(
-					`Command is still running in the user's terminal.${
-						result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
-					}\n\nThe user provided the following feedback:\n<feedback>\n${userFeedback.text}\n</feedback>`,
-					userFeedback.images,
-					fileContentString,
-				),
-			]
-		}
-
-		if (completed) {
-			return [false, `Command executed.${result.length > 0 ? `\nOutput:\n${result}` : ""}`]
-		} else {
-			return [
-				false,
-				`Command is still running in the user's terminal.${
-					result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
-				}\n\nYou will be updated on the terminal status and new output in the future.`,
-			]
-		}
-	}
-
 	/**
 	 * Migrates the disableBrowserTool setting from VSCode configuration to browserSettings
 	 */
@@ -1358,8 +1039,8 @@ export class Task {
 
 		// Prepare multi-root workspace information if enabled
 		let workspaceRoots: Array<{ path: string; name: string; vcs?: string }> | undefined
-		const multiRootEnabled = isMultiRootEnabled(this.stateManager)
-		if (multiRootEnabled && this.workspaceManager) {
+		const isMultiRootEnabled = featureFlagsService.getMultiRootEnabled()
+		if (isMultiRootEnabled && this.workspaceManager) {
 			workspaceRoots = this.workspaceManager.getRoots().map((root) => ({
 				path: root.path,
 				name: root.name || path.basename(root.path), // Fallback to basename if name is undefined
@@ -1383,7 +1064,7 @@ export class Task {
 			preferredLanguageInstructions,
 			browserSettings: this.stateManager.getGlobalSettingsKey("browserSettings"),
 			yoloModeToggled: this.stateManager.getGlobalSettingsKey("yoloModeToggled"),
-			isMultiRootEnabled: multiRootEnabled,
+			isMultiRootEnabled,
 			workspaceRoots,
 		}
 
@@ -2387,12 +2068,12 @@ export class Task {
 	 * Format workspace roots section for multi-root workspaces
 	 */
 	private formatWorkspaceRootsSection(): string {
-		const multiRootEnabled = isMultiRootEnabled(this.stateManager)
+		const isMultiRootEnabled = featureFlagsService.getMultiRootEnabled()
 		const hasWorkspaceManager = !!this.workspaceManager
 		const roots = hasWorkspaceManager ? this.workspaceManager!.getRoots() : []
 
 		// Only show workspace roots if multi-root is enabled and there are multiple roots
-		if (!multiRootEnabled || roots.length <= 1) {
+		if (!isMultiRootEnabled || roots.length <= 1) {
 			return ""
 		}
 
@@ -2430,10 +2111,10 @@ export class Task {
 	 * Format the file details header based on workspace configuration
 	 */
 	private formatFileDetailsHeader(): string {
-		const multiRootEnabled = isMultiRootEnabled(this.stateManager)
+		const isMultiRootEnabled = featureFlagsService.getMultiRootEnabled()
 		const roots = this.workspaceManager?.getRoots() || []
 
-		if (multiRootEnabled && roots.length > 1) {
+		if (isMultiRootEnabled && roots.length > 1) {
 			const primary = this.workspaceManager?.getPrimaryRoot()
 			const primaryName = this.getPrimaryWorkspaceName(primary)
 			return `\n\n# Current Working Directory (Primary: ${primaryName}) Files\n`
@@ -2451,9 +2132,9 @@ export class Task {
 
 		// It could be useful for cline to know if the user went from one or no file to another between messages, so we always include this context
 		details += `\n\n# ${host.platform} Visible Files`
-		const rawVisiblePaths = (await HostProvider.window.getVisibleTabs({})).paths
-		const filteredVisiblePaths = await filterExistingFiles(rawVisiblePaths)
-		const visibleFilePaths = filteredVisiblePaths.map((absolutePath) => path.relative(this.cwd, absolutePath))
+		const visibleFilePaths = (await HostProvider.window.getVisibleTabs({})).paths.map((absolutePath) =>
+			path.relative(this.cwd, absolutePath),
+		)
 
 		// Filter paths through clineIgnoreController
 		const allowedVisibleFiles = this.clineIgnoreController
@@ -2468,9 +2149,9 @@ export class Task {
 		}
 
 		details += `\n\n# ${host.platform} Open Tabs`
-		const rawOpenTabPaths = (await HostProvider.window.getOpenTabs({})).paths
-		const filteredOpenTabPaths = await filterExistingFiles(rawOpenTabPaths)
-		const openTabPaths = filteredOpenTabPaths.map((absolutePath) => path.relative(this.cwd, absolutePath))
+		const openTabPaths = (await HostProvider.window.getOpenTabs({})).paths.map((absolutePath) =>
+			path.relative(this.cwd, absolutePath),
+		)
 
 		// Filter paths through clineIgnoreController
 		const allowedOpenTabs = this.clineIgnoreController
@@ -2583,12 +2264,15 @@ export class Task {
 				details += result
 			}
 
-			// Add workspace information in JSON format
-			if (this.workspaceManager) {
-				const workspacesJson = await this.workspaceManager.buildWorkspacesJson()
-				if (workspacesJson) {
-					details += `\n\n# Workspace Configuration\n${workspacesJson}`
-				}
+			// Add git remote URLs section
+			const gitRemotes = await getGitRemoteUrls(this.cwd)
+			if (gitRemotes.length > 0) {
+				details += `\n\n# Git Remote URLs\n${gitRemotes.join("\n")}`
+			}
+
+			const latestGitHash = await getLatestGitCommitHash(this.cwd)
+			if (latestGitHash) {
+				details += `\n\n# Latest Git Commit Hash\n${latestGitHash}`
 			}
 
 			// Add detected CLI tools

src/core/task/runtime/CommandRunner.ts

@@ -0,0 +1,289 @@
+import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+
+import { formatResponse } from "@core/prompts/responses"
+import { processFilesIntoText } from "@integrations/misc/extract-text"
+import { TerminalManager } from "@integrations/terminal/TerminalManager"
+import { Logger } from "@services/logging/Logger"
+import { execa } from "execa"
+import { TerminalHangStage, TerminalUserInterventionAction, telemetryService } from "@/services/telemetry"
+import { isInTestMode } from "@/services/test/TestMode"
+
+import type { AskFn, CommandRunnerResult, SayFn } from "../types"
+
+export class CommandRunner {
+	constructor(
+		private readonly cwd: string,
+		private readonly terminalManager: TerminalManager,
+		private readonly ask: AskFn,
+		private readonly say: SayFn,
+	) {}
+
+	private async executeInNode(command: string): Promise<CommandRunnerResult> {
+		try {
+			const childProcess = execa(command, {
+				shell: true,
+				cwd: this.cwd,
+				reject: false,
+				all: true,
+			})
+
+			let output = ""
+
+			if (childProcess.all) {
+				childProcess.all.on("data", (data) => {
+					output += data.toString()
+				})
+			}
+
+			const timeoutPromise = new Promise<never>((_, reject) => {
+				setTimeout(() => {
+					if (childProcess.pid) {
+						childProcess.kill("SIGKILL")
+					}
+					reject(new Error("Command timeout after 30s"))
+				}, 30000)
+			})
+
+			const result = await Promise.race([childProcess, timeoutPromise]).catch((_error) => {
+				Logger.info(`Command timed out after 30s: ${command}`)
+				return {
+					stdout: "",
+					stderr: "",
+					exitCode: 124,
+					timedOut: true,
+				}
+			})
+
+			const wasTerminated = result.timedOut === true
+
+			if (!output) {
+				output = result.stdout || result.stderr || ""
+			}
+
+			Logger.info(`Command executed in Node: ${command}\nOutput:\n${output}`)
+
+			if (wasTerminated) {
+				output += "\nCommand was taking a while to run so it was auto terminated after 30s"
+			}
+
+			return [
+				false,
+				`Command executed${wasTerminated ? " (terminated after 30s)" : ""} with exit code ${
+					result.exitCode
+				}.${output.length > 0 ? `\nOutput:\n${output}` : ""}`,
+			]
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error)
+			return [false, `Error executing command: ${errorMessage}`]
+		}
+	}
+
+	async execute(command: string, timeoutSeconds: number | undefined): Promise<CommandRunnerResult> {
+		Logger.info("IS_TEST: " + isInTestMode())
+
+		if (isInTestMode()) {
+			Logger.info("Executing command in Node: " + command)
+			return this.executeInNode(command)
+		}
+
+		Logger.info("Executing command in terminal: " + command)
+
+		const terminalInfo = await this.terminalManager.getOrCreateTerminal(this.cwd)
+		terminalInfo.terminal.show()
+		const terminalProcess = this.terminalManager.runCommand(terminalInfo, command)
+
+		let userFeedback: { text?: string; images?: string[]; files?: string[] } | undefined
+		let didContinue = false
+
+		const CHUNK_LINE_COUNT = 20
+		const CHUNK_BYTE_SIZE = 2048
+		const CHUNK_DEBOUNCE_MS = 100
+
+		let outputBuffer: string[] = []
+		let outputBufferSize = 0
+		let chunkTimer: NodeJS.Timeout | null = null
+		let chunkEnroute = false
+
+		let bufferStuckTimer: NodeJS.Timeout | null = null
+		const BUFFER_STUCK_TIMEOUT_MS = 6000
+
+		const flushBuffer = async (force = false): Promise<void> => {
+			if (chunkEnroute || outputBuffer.length === 0) {
+				if (force && !chunkEnroute && outputBuffer.length > 0) {
+					// fallthrough to flush
+				} else {
+					return
+				}
+			}
+
+			const chunk = outputBuffer.join("\n")
+			outputBuffer = []
+			outputBufferSize = 0
+			chunkEnroute = true
+
+			bufferStuckTimer = setTimeout(() => {
+				telemetryService.captureTerminalHang(TerminalHangStage.BUFFER_STUCK)
+				bufferStuckTimer = null
+			}, BUFFER_STUCK_TIMEOUT_MS)
+
+			try {
+				const { response, text, images, files } = await this.ask("command_output", chunk)
+				if (response === "yesButtonClicked") {
+					telemetryService.captureTerminalUserIntervention(TerminalUserInterventionAction.PROCESS_WHILE_RUNNING)
+					if (text || (images && images.length > 0) || (files && files.length > 0)) {
+						userFeedback = { text, images, files }
+					}
+				} else {
+					userFeedback = { text, images, files }
+				}
+				didContinue = true
+				terminalProcess.continue()
+			} catch {
+				Logger.error("Error while asking for command output")
+			} finally {
+				if (bufferStuckTimer) {
+					clearTimeout(bufferStuckTimer)
+					bufferStuckTimer = null
+				}
+				chunkEnroute = false
+				if (outputBuffer.length > 0) {
+					await flushBuffer()
+				}
+			}
+		}
+
+		const scheduleFlush = () => {
+			if (chunkTimer) {
+				clearTimeout(chunkTimer)
+			}
+			chunkTimer = setTimeout(async () => await flushBuffer(), CHUNK_DEBOUNCE_MS)
+		}
+
+		const outputLines: string[] = []
+		terminalProcess.on("line", async (line) => {
+			outputLines.push(line)
+
+			if (!didContinue) {
+				outputBuffer.push(line)
+				outputBufferSize += Buffer.byteLength(line, "utf8")
+				if (outputBuffer.length >= CHUNK_LINE_COUNT || outputBufferSize >= CHUNK_BYTE_SIZE) {
+					await flushBuffer()
+				} else {
+					scheduleFlush()
+				}
+			} else {
+				void this.say("command_output", line)
+			}
+		})
+
+		let completed = false
+		let completionTimer: NodeJS.Timeout | null = null
+		const COMPLETION_TIMEOUT_MS = 6000
+
+		completionTimer = setTimeout(() => {
+			if (!completed) {
+				telemetryService.captureTerminalHang(TerminalHangStage.WAITING_FOR_COMPLETION)
+				completionTimer = null
+			}
+		}, COMPLETION_TIMEOUT_MS)
+
+		terminalProcess.once("completed", async () => {
+			completed = true
+			if (completionTimer) {
+				clearTimeout(completionTimer)
+				completionTimer = null
+			}
+			if (!didContinue && outputBuffer.length > 0) {
+				if (chunkTimer) {
+					clearTimeout(chunkTimer)
+					chunkTimer = null
+				}
+				await flushBuffer(true)
+			}
+		})
+
+		terminalProcess.once("no_shell_integration", async () => {
+			await this.say("shell_integration_warning")
+		})
+
+		if (timeoutSeconds) {
+			const timeoutPromise = new Promise<never>((_, reject) => {
+				setTimeout(() => {
+					reject(new Error("COMMAND_TIMEOUT"))
+				}, timeoutSeconds * 1000)
+			})
+
+			try {
+				await Promise.race([terminalProcess, timeoutPromise])
+			} catch (error) {
+				didContinue = true
+				terminalProcess.continue()
+
+				if (chunkTimer) {
+					clearTimeout(chunkTimer)
+					chunkTimer = null
+				}
+				if (completionTimer) {
+					clearTimeout(completionTimer)
+					completionTimer = null
+				}
+
+				await setTimeoutPromise(50)
+				const result = this.terminalManager.processOutput(outputLines)
+
+				if (error instanceof Error && error.message === "COMMAND_TIMEOUT") {
+					return [
+						false,
+						`Command execution timed out after ${timeoutSeconds} seconds. The command may still be running in the terminal.${
+							result.length > 0 ? `\nOutput so far:\n${result}` : ""
+						}`,
+					]
+				}
+
+				throw error
+			}
+		} else {
+			await terminalProcess
+		}
+
+		if (completionTimer) {
+			clearTimeout(completionTimer)
+			completionTimer = null
+		}
+
+		await setTimeoutPromise(50)
+
+		const result = this.terminalManager.processOutput(outputLines)
+
+		if (userFeedback) {
+			await this.say("user_feedback", userFeedback.text, userFeedback.images, userFeedback.files)
+
+			let fileContentString = ""
+			if (userFeedback.files && userFeedback.files.length > 0) {
+				fileContentString = await processFilesIntoText(userFeedback.files)
+			}
+
+			return [
+				true,
+				formatResponse.toolResult(
+					`Command is still running in the user's terminal.${
+						result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
+					}\n\nThe user provided the following feedback:\n<feedback>\n${userFeedback.text}\n</feedback>`,
+					userFeedback.images,
+					fileContentString,
+				),
+			]
+		}
+
+		if (completed) {
+			return [false, `Command executed.${result.length > 0 ? `\nOutput:\n${result}` : ""}`]
+		}
+
+		return [
+			false,
+			`Command is still running in the user's terminal.${
+				result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
+			}\n\nYou will be updated on the terminal status and new output in the future.`,
+		]
+	}
+}

src/core/task/tools/autoApprove.ts

@@ -1,8 +1,8 @@
 import { resolveWorkspacePath } from "@core/workspace"
-import { isMultiRootEnabled } from "@core/workspace/multi-root-utils"
 import { ClineDefaultTool } from "@shared/tools"
 import { StateManager } from "@/core/storage/StateManager"
 import { HostProvider } from "@/hosts/host-provider"
+import { featureFlagsService } from "@/services/feature-flags"
 import { getCwd, getDesktopDir, isLocatedInPath, isLocatedInWorkspace } from "@/utils/path"
 
 export class AutoApprove {
@@ -28,7 +28,7 @@ export class AutoApprove {
 		if (this.workspacePathsCache === null || this.isMultiRootScenarioCache === null) {
 			// First time - fetch and cache for the lifetime of this task
 			this.workspacePathsCache = await HostProvider.workspace.getWorkspacePaths({})
-			this.isMultiRootScenarioCache = isMultiRootEnabled(this.stateManager) && this.workspacePathsCache.paths.length > 1
+			this.isMultiRootScenarioCache = featureFlagsService.getMultiRootEnabled() && this.workspacePathsCache.paths.length > 1
 		}
 
 		return {

src/core/task/tools/handlers/ExecuteCommandToolHandler.ts

@@ -4,7 +4,6 @@ import { WorkspacePathAdapter } from "@core/workspace/WorkspacePathAdapter"
 import { showSystemNotification } from "@integrations/notifications"
 import { COMMAND_REQ_APP_STRING } from "@shared/combineCommandSequences"
 import { ClineAsk } from "@shared/ExtensionMessage"
-import { arePathsEqual } from "@utils/path"
 import { fixModelHtmlEscaping } from "@utils/string"
 import { telemetryService } from "@/services/telemetry"
 import { ClineDefaultTool } from "@/shared/tools"
@@ -82,17 +81,13 @@ export class ExecuteCommandToolHandler implements IFullyManagedTool {
 		let executionDir: string = config.cwd
 		let actualCommand: string = command
 
-		let workspaceHintUsed = false
-		let workspaceHint: string | undefined
-
 		if (config.isMultiRootEnabled && config.workspaceManager) {
 			// Check if command has a workspace hint prefix
 			// e.g., "@backend:npm install" or just "npm install"
 			const commandMatch = command.match(/^@(\w+):(.+)$/)
 
 			if (commandMatch) {
-				workspaceHintUsed = true
-				workspaceHint = commandMatch[1]
+				const workspaceHint = commandMatch[1]
 				actualCommand = commandMatch[2].trim()
 
 				// Find the workspace root for this hint
@@ -127,35 +122,13 @@ export class ExecuteCommandToolHandler implements IFullyManagedTool {
 			? autoApproveResult
 			: [autoApproveResult, false]
 
-		// Determine workspace context for telemetry
-		const resolvedToNonPrimary = !arePathsEqual(executionDir, config.cwd)
-		const workspaceContext = {
-			isMultiRootEnabled: config.isMultiRootEnabled || false,
-			usedWorkspaceHint: workspaceHintUsed,
-			resolvedToNonPrimary,
-			resolutionMethod: (workspaceHintUsed ? "hint" : "primary_fallback") as "hint" | "primary_fallback",
-		}
-
-		// Capture workspace path resolution telemetry
-		if (config.isMultiRootEnabled && config.workspaceManager) {
-			telemetryService.captureWorkspacePathResolved(
-				config.ulid,
-				"ExecuteCommandToolHandler",
-				workspaceHintUsed ? "hint_provided" : "fallback_to_primary",
-				workspaceHintUsed ? "workspace_name" : undefined,
-				resolvedToNonPrimary, // resolution success = resolved to different workspace
-				undefined, // TODO: could calculate workspace index if needed
-				true,
-			)
-		}
-
 		if ((!requiresApprovalPerLLM && autoApproveSafe) || (requiresApprovalPerLLM && autoApproveSafe && autoApproveAll)) {
 			// Auto-approve flow
 			await config.callbacks.removeLastPartialMessageIfExistsWithType("ask", "command")
 			await config.callbacks.say("command", actualCommand, undefined, undefined, false)
 			config.taskState.consecutiveAutoApprovedRequestsCount++
 			didAutoApprove = true
-			telemetryService.captureToolUsage(config.ulid, block.name, config.api.getModel().id, true, true, workspaceContext)
+			telemetryService.captureToolUsage(config.ulid, block.name, config.api.getModel().id, true, true)
 		} else {
 			// Manual approval flow
 			showNotificationForApprovalIfAutoApprovalEnabled(
@@ -170,17 +143,10 @@ export class ExecuteCommandToolHandler implements IFullyManagedTool {
 				config,
 			)
 			if (!didApprove) {
-				telemetryService.captureToolUsage(
-					config.ulid,
-					block.name,
-					config.api.getModel().id,
-					false,
-					false,
-					workspaceContext,
-				)
+				telemetryService.captureToolUsage(config.ulid, block.name, config.api.getModel().id, false, false)
 				return formatResponse.toolDenied()
 			}
-			telemetryService.captureToolUsage(config.ulid, block.name, config.api.getModel().id, false, true, workspaceContext)
+			telemetryService.captureToolUsage(config.ulid, block.name, config.api.getModel().id, false, true)
 		}
 
 		// Setup timeout notification for long-running auto-approved commands