test(ci): measure cross-package coverage and add unit tests

Taskfile.yml

@@ -823,7 +823,10 @@ tasks:
       MIN_COVERAGE: '{{.MIN_COVERAGE | default "72"}}'
     cmds:
       - |
-        test -f profile.cov || go test -coverprofile=profile.cov ./cmd/forst/... ./internal/... -count=1
+        if [ ! -f profile.cov ]; then
+          PKGS=$(go list ./cmd/forst/... ./internal/... ./nodert/... | paste -sd, -)
+          go test -coverprofile=profile.cov -coverpkg="$PKGS" ./cmd/forst/... ./internal/... ./nodert/... -count=1
+        fi
       - bash scripts/check_coverage_threshold.sh profile.cov {{.MIN_COVERAGE}}
 
   test:go:short:
@@ -839,7 +842,9 @@ tasks:
     deps: [build:node-runtime]
     cmds:
       - task: build:vscode
-      - go test -race -covermode atomic -coverprofile=profile.cov -timeout=10m ./cmd/forst/... ./internal/... ./nodert/...
+      - |
+        PKGS=$(go list ./cmd/forst/... ./internal/... ./nodert/... | paste -sd, -)
+        go test -race -covermode atomic -coverpkg="$PKGS" -coverprofile=profile.cov -timeout=10m ./cmd/forst/... ./internal/... ./nodert/...
 
   ci:e2e:
     desc: Run CI E2E suite (runtime examples, node interop, sidecar, providers)

forst/cmd/forst/lsp/health.go

@@ -16,12 +16,13 @@ func (s *LSPServer) handleHealth(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)
 
+	meta := buildMetadataSnapshot()
 	response := map[string]any{
 		"status":    "healthy",
 		"service":   "forst-lsp",
-		"version":   Version,
-		"commit":    Commit,
-		"date":      Date,
+		"version":   meta.version,
+		"commit":    meta.commit,
+		"date":      meta.date,
 		"timestamp": time.Now().UTC().Format(time.RFC3339),
 	}
 

forst/cmd/forst/lsp/initialize.go

@@ -43,16 +43,18 @@ func (s *LSPServer) handleInitialize(request LSPRequest) LSPServerResponse {
 		},
 	}
 
+	meta := buildMetadataSnapshot()
+
 	return LSPServerResponse{
 		JSONRPC: "2.0",
 		ID:      request.ID,
 		Result: map[string]any{
 			"capabilities": capabilities,
 			"serverInfo": map[string]any{
 				"name":    "forst-lsp",
-				"version": Version,
-				"commit":  Commit,
-				"date":    Date,
+				"version": meta.version,
+				"commit":  meta.commit,
+				"date":    meta.date,
 			},
 		},
 	}

forst/cmd/forst/lsp/server.go

@@ -76,16 +76,6 @@ type peerAnalysisCacheEntry struct {
 	ctx     *forstDocumentContext
 }
 
-// Version information for LSP server
-var (
-	// Version is the current version of Forst
-	Version = "dev"
-	// Commit is the git commit hash
-	Commit = "unknown"
-	// Date is the build date
-	Date = "unknown"
-)
-
 // NewLSPServer creates a new LSP server
 func NewLSPServer(port string, log *logrus.Logger) *LSPServer {
 	debugger := NewCompilerDebugger(true)

forst/cmd/forst/lsp/version.go

@@ -1,18 +1,52 @@
 package lsp
 
-import "github.com/sirupsen/logrus"
+import (
+	"sync"
+
+	"github.com/sirupsen/logrus"
+)
+
+type buildMetadata struct {
+	version string
+	commit  string
+	date    string
+}
+
+var (
+	buildInfoMu sync.RWMutex
+	buildInfo   = buildMetadata{
+		version: "dev",
+		commit:  "unknown",
+		date:    "unknown",
+	}
+)
+
+// SetBuildMetadata sets injected compiler build metadata (version, commit, date).
+func SetBuildMetadata(version, commit, date string) {
+	buildInfoMu.Lock()
+	buildInfo = buildMetadata{version: version, commit: commit, date: date}
+	buildInfoMu.Unlock()
+}
+
+func buildMetadataSnapshot() buildMetadata {
+	buildInfoMu.RLock()
+	defer buildInfoMu.RUnlock()
+	return buildInfo
+}
 
 // BuildInfo returns injected compiler build metadata (version, commit, date).
 func BuildInfo() (version, commit, date string) {
-	return Version, Commit, Date
+	meta := buildMetadataSnapshot()
+	return meta.version, meta.commit, meta.date
 }
 
 // BuildInfoMap returns build metadata as a JSON-friendly map.
 func BuildInfoMap() map[string]string {
+	meta := buildMetadataSnapshot()
 	return map[string]string{
-		"version": Version,
-		"commit":  Commit,
-		"date":    Date,
+		"version": meta.version,
+		"commit":  meta.commit,
+		"date":    meta.date,
 	}
 }
 
@@ -21,5 +55,6 @@ func LogBuildInfo(log *logrus.Logger) {
 	if log == nil {
 		return
 	}
-	log.Infof("forst %s %s %s", Version, Commit, Date)
+	meta := buildMetadataSnapshot()
+	log.Infof("forst %s %s %s", meta.version, meta.commit, meta.date)
 }

forst/cmd/forst/lsp/version_test.go

@@ -10,13 +10,10 @@ import (
 
 func TestLogBuildInfo_logsVersionCommitDate(t *testing.T) {
 	t.Parallel()
-	Version = "1.2.3"
-	Commit = "abc123"
-	Date = "2026-07-08"
+	origVersion, origCommit, origDate := BuildInfo()
+	SetBuildMetadata("1.2.3", "abc123", "2026-07-08")
 	t.Cleanup(func() {
-		Version = "dev"
-		Commit = "unknown"
-		Date = "unknown"
+		SetBuildMetadata(origVersion, origCommit, origDate)
 	})
 
 	var buf bytes.Buffer
@@ -35,13 +32,10 @@ func TestLogBuildInfo_logsVersionCommitDate(t *testing.T) {
 
 func TestBuildInfoMap(t *testing.T) {
 	t.Parallel()
-	Version = "v"
-	Commit = "c"
-	Date = "d"
+	origVersion, origCommit, origDate := BuildInfo()
+	SetBuildMetadata("v", "c", "d")
 	t.Cleanup(func() {
-		Version = "dev"
-		Commit = "unknown"
-		Date = "unknown"
+		SetBuildMetadata(origVersion, origCommit, origDate)
 	})
 	m := BuildInfoMap()
 	if m["version"] != "v" || m["commit"] != "c" || m["date"] != "d" {

forst/cmd/forst/main.go

@@ -143,9 +143,7 @@ func runMain(argv []string) int {
 		setLogLevel(log, *logLevel)
 
 		// Set version information in LSP package
-		lsp.Version = Version
-		lsp.Commit = Commit
-		lsp.Date = Date
+		lsp.SetBuildMetadata(Version, Commit, Date)
 
 		if err := startLSPFunc(*port, log); err != nil {
 			return 1
@@ -176,9 +174,7 @@ func runMain(argv []string) int {
 		}
 
 		// Set version information in LSP package
-		lsp.Version = Version
-		lsp.Commit = Commit
-		lsp.Date = Date
+		lsp.SetBuildMetadata(Version, Commit, Date)
 
 		if err := handleDumpCommand(*filePath, *compression, *format, *phase, *summary, log); err != nil {
 			log.Error(err)

forst/cmd/forst/main_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"forst/cmd/forst/lsp"
 	"forst/internal/compiler"
 	"forst/internal/ftconfig"
 	"io"
@@ -329,25 +330,14 @@ func TestCompilerArgsParsing(t *testing.T) {
 
 func TestLSPVersionInjection(t *testing.T) {
 	// Test that version information is correctly injected into LSP package
-	originalVersion := Version
-	originalCommit := Commit
-	originalDate := Date
-	defer func() {
-		Version = originalVersion
-		Commit = originalCommit
-		Date = originalDate
-	}()
+	origVersion, origCommit, origDate := lsp.BuildInfo()
+	t.Cleanup(func() {
+		lsp.SetBuildMetadata(origVersion, origCommit, origDate)
+	})
 
-	// Set test values
-	Version = "test-version"
-	Commit = "test-commit"
-	Date = "test-date"
+	lsp.SetBuildMetadata("test-version", "test-commit", "test-date")
 
-	// Test the version injection logic that would be used in main
-	// This simulates the logic: lsp.Version = Version, etc.
-	lspVersion := Version
-	lspCommit := Commit
-	lspDate := Date
+	lspVersion, lspCommit, lspDate := lsp.BuildInfo()
 
 	if lspVersion != "test-version" {
 		t.Errorf("Expected LSP version test-version, got %s", lspVersion)

forst/internal/gowork/plan_test.go

@@ -392,7 +392,7 @@ func TestWriteRunGoMod_absoluteReplaceWhenCrossTree(t *testing.T) {
 	if !strings.Contains(s, want) {
 		t.Fatalf("missing absolute replace forst => %s:\n%s", compilerDir, s)
 	}
-	if _, err := exec.LookPath("go"); err == nil {
+		if _, err := exec.LookPath("go"); err == nil {
 		cmd := exec.Command("go", "mod", "tidy")
 		cmd.Dir = sandbox
 		cmd.Env = append(os.Environ(), "GOWORK=off")
@@ -401,3 +401,135 @@ func TestWriteRunGoMod_absoluteReplaceWhenCrossTree(t *testing.T) {
 		}
 	}
 }
+
+func TestAppendGoModReplaces_appendsAndDedupes(t *testing.T) {
+	dir := t.TempDir()
+	pkgDir := filepath.Join(dir, "gen", "api")
+	if err := os.MkdirAll(pkgDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(dir, "go.mod")
+	if err := os.WriteFile(path, []byte("module example.com/app\n\ngo 1.26.0\n\nreplace demo/api => ./old\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	replaces := []PackageReplace{
+		{ImportPath: "demo/api", Dir: pkgDir},
+		{ImportPath: "demo/auth", Dir: filepath.Join(dir, "gen", "auth")},
+	}
+	if err := AppendGoModReplaces(path, replaces); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(data)
+	if strings.Contains(s, "replace demo/api =>") && strings.Count(s, "replace demo/api =>") > 1 {
+		t.Fatalf("duplicate demo/api replace:\n%s", s)
+	}
+	if !strings.Contains(s, "replace demo/auth =>") {
+		t.Fatalf("missing demo/auth replace:\n%s", s)
+	}
+}
+
+func TestAppendGoModReplaces_emptySliceNoOp(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "go.mod")
+	if err := os.WriteFile(path, []byte("module m\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := AppendGoModReplaces(path, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestAppendGoModReplaces_missingFileErrors(t *testing.T) {
+	if err := AppendGoModReplaces(filepath.Join(t.TempDir(), "missing.mod"), []PackageReplace{
+		{ImportPath: "x", Dir: t.TempDir()},
+	}); err == nil {
+		t.Fatal("expected error for missing go.mod")
+	}
+}
+
+func TestAppendGoModReplaces_relativePathGetsDotPrefix(t *testing.T) {
+	dir := t.TempDir()
+	pkgDir := filepath.Join(dir, "pkg")
+	if err := os.MkdirAll(pkgDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(dir, "go.mod")
+	if err := os.WriteFile(path, []byte("module m\n\ngo 1.26.0\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := AppendGoModReplaces(path, []PackageReplace{{ImportPath: "demo/pkg", Dir: pkgDir}}); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "replace demo/pkg => ./pkg") {
+		t.Fatalf("expected ./pkg prefix:\n%s", data)
+	}
+}
+
+func TestWorkspaceUseDirs(t *testing.T) {
+	t.Parallel()
+	_, err := WorkspaceUseDirs("/root", "/session", ForstRuntimeLink{})
+	if err == nil {
+		t.Fatal("expected error when ReplaceDir empty")
+	}
+	uses, err := WorkspaceUseDirs("/root", "/session", ForstRuntimeLink{ReplaceDir: "/forst"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(uses) != 2 || uses[0] != "/session" || uses[1] != "/forst" {
+		t.Fatalf("uses = %#v", uses)
+	}
+}
+
+func TestWriteGoWork_emptyUseDirsErrors(t *testing.T) {
+	if err := WriteGoWork(filepath.Join(t.TempDir(), "go.work"), nil); err == nil {
+		t.Fatal("expected error for empty use dirs")
+	}
+}
+
+func TestChildEnv_workspaceModeSetsGOWORK(t *testing.T) {
+	work := filepath.Join(t.TempDir(), "go.work")
+	env := ChildEnv([]string{"GOWORK=/parent/go.work"}, LinkPlan{
+		Mode:      LinkWorkspace,
+		Workspace: work,
+	}, "/app")
+	found := false
+	for _, e := range env {
+		if e == "GOWORK="+work {
+			found = true
+		}
+		if strings.HasPrefix(e, "GOWORK=") && e != "GOWORK="+work {
+			t.Fatalf("unexpected GOWORK: %s", e)
+		}
+	}
+	if !found {
+		t.Fatalf("expected GOWORK=%s in %v", work, env)
+	}
+}
+
+func TestChildEnv_stripsReadonlyGOFLAGS(t *testing.T) {
+	env := ChildEnv([]string{"GOFLAGS=-mod=readonly -v"}, LinkPlan{Mode: LinkReplace}, "")
+	for _, e := range env {
+		if strings.Contains(e, "-mod=readonly") {
+			t.Fatalf("readonly GOFLAGS leaked: %s", e)
+		}
+	}
+}
+
+func TestGoModReplaceNeedsAbsolute(t *testing.T) {
+	if !goModReplaceNeedsAbsolute("/private/var/tmp", "/home/example/module") {
+		t.Fatal("expected absolute replace when sandbox is under /private and target is not")
+	}
+	if goModReplaceNeedsAbsolute("/a/b", "relative") {
+		t.Fatal("relative target should not need absolute")
+	}
+	if !goModReplaceNeedsAbsolute("/a/b", "/c/d") {
+		t.Fatal("expected absolute replace when mod and target roots differ")
+	}
+}