fix: resolve CI lint failures, add WSL lint to preflight, chain pages deploy

- Fix goconst: extract coalesceCwd constant in store.go
- Fix prealloc: preallocate argv slice in launch_unix.go
- Fix unused: add nolint directive for build-tag stub launchInPlaceUnix
- Add WSL lint step to preflight (now 13 steps) to catch Linux-only
  build-tag file issues that Windows golangci-lint misses
- Add cross-GOOS lint attempt (GOOS=linux) as best-effort fallback
- Chain pages deployment into release workflow (runs after goreleaser)
- Add workflow_call trigger to pages.yml for reusable workflow support

Root cause: golangci-lint on Windows skips //go:build !windows files,
so lint issues in Unix-only code were invisible to local preflight
but caught by CI running on Linux.

Co-authored-by: Copilot <[email protected]>

Author: jongio

.github/workflows/pages.yml

@@ -8,6 +8,7 @@ on:
       - 'README.md'
       - 'CHANGELOG.md'
   workflow_dispatch:
+  workflow_call:
 
 permissions:
   contents: read

.github/workflows/release.yml

@@ -48,3 +48,11 @@ jobs:
           args: release --clean
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  pages:
+    needs: release
+    uses: ./.github/workflows/pages.yml
+    permissions:
+      contents: read
+      pages: write
+      id-token: write

internal/data/store.go

@@ -32,6 +32,9 @@ const (
 
 	// limitClause is the SQL fragment appended to queries with a row cap.
 	limitClause = " LIMIT ?"
+
+	// coalesceCwd normalizes NULL session directories to empty strings.
+	coalesceCwd = "COALESCE(s.cwd, '')"
 )
 
 // Store provides read-only access to the Copilot CLI session store.
@@ -288,15 +291,15 @@ func pivotExpr(p PivotField) string {
 	case PivotByDate:
 		return "SUBSTR(" + lastActiveExpr + ", 1, 10)"
 	default: // PivotByFolder and any unknown value
-		return "COALESCE(s.cwd, '')"
+		return coalesceCwd
 	}
 }
 
 // sessionColumns is the shared SELECT list used by session queries.
 // last_active_at is computed as the most recent turn timestamp, falling
 // back to updated_at then created_at so that reindex-clobbered dates
 // don't make old sessions appear recent.
-var sessionColumns = `s.id, COALESCE(s.cwd,''), COALESCE(s.repository,''), COALESCE(s.branch,''),
+var sessionColumns = `s.id, ` + coalesceCwd + `, COALESCE(s.repository,''), COALESCE(s.branch,''),
 	COALESCE(s.summary,''), COALESCE(s.created_at,''), COALESCE(s.updated_at,''),
 	` + lastActiveExpr + ` AS last_active_at,
 	(SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id) AS turn_count,

internal/platform/launch_unix.go

@@ -41,14 +41,16 @@ func filterEnv(env []string) []string {
 	return result
 }
 
+//nolint:unused // Referenced via build-tagged launch paths; Windows keeps a stub with the same symbol.
 func launchInPlaceUnix(shell ShellInfo, resumeCmd string, cwd string) error {
 	if cwd != "" {
 		// Best-effort: change directory before exec replaces the process.
 		// If chdir fails we still launch from the current directory.
 		_ = os.Chdir(cwd)
 	}
 
-	argv := []string{shell.Path}
+	argv := make([]string, 0, 1+len(shell.Args)+2)
+	argv = append(argv, shell.Path)
 	argv = append(argv, shell.Args...)
 	argv = append(argv, "-c", resumeCmd)
 

magefile.go

@@ -131,26 +131,27 @@ func Build() error {
 	return nil
 }
 
-// Preflight runs all pre-commit checks: format, tidy, vet, lint, build, test,
-// race detection, WSL tests, vulnerability scan, strict formatting, dead code
-// detection, and install verification. If preflight passes, CI will pass.
+// Preflight runs all pre-commit checks: format, tidy, vet, lint, WSL lint,
+// build, test, race detection, WSL tests, vulnerability scan, strict
+// formatting, dead code detection, and install verification. If preflight
+// passes, CI will pass.
 func Preflight() error {
-	fmt.Println("\n=== 1/12 Formatting ===")
+	fmt.Println("\n=== 1/13 Formatting ===")
 	if err := fmtSources(); err != nil {
 		return fmt.Errorf("format: %w", err)
 	}
 
-	fmt.Println("\n=== 2/12 Tidying modules ===")
+	fmt.Println("\n=== 2/13 Tidying modules ===")
 	if err := run("go", "mod", "tidy"); err != nil {
 		return fmt.Errorf("mod tidy: %w", err)
 	}
 
-	fmt.Println("\n=== 3/12 Vetting ===")
+	fmt.Println("\n=== 3/13 Vetting ===")
 	if err := run("go", "vet", "./..."); err != nil {
 		return fmt.Errorf("vet: %w", err)
 	}
 
-	fmt.Println("\n=== 4/12 Linting ===")
+	fmt.Println("\n=== 4/13 Linting ===")
 	if _, err := exec.LookPath("golangci-lint"); err == nil {
 		if out, err := cmdOutput("golangci-lint", "version"); err == nil {
 			if !strings.Contains(out, "golangci-lint has version 2.") {
@@ -160,31 +161,49 @@ func Preflight() error {
 		if err := run("golangci-lint", "run"); err != nil {
 			return fmt.Errorf("lint: %w", err)
 		}
+		fmt.Println("   Attempting GOOS=linux lint to catch Linux-only files seen in CI")
+		if err := runWithEnv(map[string]string{"GOOS": "linux"}, "golangci-lint", "run"); err != nil {
+			fmt.Printf("   WARNING: GOOS=linux golangci-lint run failed on %s: %v\n", runtime.GOOS, err)
+		}
 	} else {
 		fmt.Println("   Skipped (install: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest)")
 	}
 
-	fmt.Println("\n=== 5/12 Building ===")
+	fmt.Println("\n=== 5/13 Linting (WSL / Linux) ===")
+	if _, err := exec.LookPath("wsl"); err == nil {
+		wslPath, err := windowsToWSLPath(projectDir())
+		if err != nil {
+			return fmt.Errorf("WSL path conversion: %w", err)
+		}
+		cmd := fmt.Sprintf("cd %s && golangci-lint run", wslPath)
+		if err := run("wsl", "bash", "-c", cmd); err != nil {
+			return fmt.Errorf("WSL lint: %w", err)
+		}
+	} else {
+		fmt.Println("   Skipped (WSL not available)")
+	}
+
+	fmt.Println("\n=== 6/13 Building ===")
 	if err := run("go", "build", "./..."); err != nil {
 		return fmt.Errorf("build: %w", err)
 	}
 
-	fmt.Println("\n=== 6/12 Testing ===")
+	fmt.Println("\n=== 7/13 Testing ===")
 	if err := run("go", "test", "./...", "-count=1"); err != nil {
 		return fmt.Errorf("test: %w", err)
 	}
 
-	fmt.Println("\n=== 7/12 Testing (race detector) ===")
+	fmt.Println("\n=== 8/13 Testing (race detector) ===")
 	if err := run("go", "test", "-race", "./...", "-count=1"); err != nil {
 		return fmt.Errorf("race test: %w", err)
 	}
 
-	fmt.Println("\n=== 8/12 Testing (WSL) ===")
+	fmt.Println("\n=== 9/13 Testing (WSL) ===")
 	if err := TestWSL(); err != nil {
 		return fmt.Errorf("WSL test: %w", err)
 	}
 
-	fmt.Println("\n=== 9/12 Vulnerability scan ===")
+	fmt.Println("\n=== 10/13 Vulnerability scan ===")
 	if _, err := exec.LookPath("govulncheck"); err == nil {
 		if err := run("govulncheck", "./..."); err != nil {
 			return fmt.Errorf("vulncheck: %w", err)
@@ -193,7 +212,7 @@ func Preflight() error {
 		fmt.Println("   Skipped (install: go install golang.org/x/vuln/cmd/govulncheck@latest)")
 	}
 
-	fmt.Println("\n=== 10/12 Strict formatting (gofumpt) ===")
+	fmt.Println("\n=== 11/13 Strict formatting (gofumpt) ===")
 	if _, err := exec.LookPath("gofumpt"); err == nil {
 		out, _ := cmdOutput("gofumpt", "-l", ".")
 		if files := strings.TrimSpace(out); files != "" {
@@ -203,7 +222,7 @@ func Preflight() error {
 		fmt.Println("   Skipped (install: go install mvdan.cc/gofumpt@latest)")
 	}
 
-	fmt.Println("\n=== 11/12 Dead code detection ===")
+	fmt.Println("\n=== 12/13 Dead code detection ===")
 	if _, err := exec.LookPath("deadcode"); err == nil {
 		if err := runDeadcode(); err != nil {
 			return err
@@ -212,12 +231,12 @@ func Preflight() error {
 		fmt.Println("   Skipped (install: go install golang.org/x/tools/cmd/deadcode@latest)")
 	}
 
-	fmt.Println("\n=== 12/12 Install verification ===")
+	fmt.Println("\n=== 13/13 Install verification ===")
 	if err := Install(); err != nil {
 		return fmt.Errorf("install: %w", err)
 	}
 
-	fmt.Println("\n=== All 12/12 preflight checks passed — ready to commit ===")
+	fmt.Println("\n=== All 13/13 preflight checks passed — ready to commit ===")
 	return nil
 }
 
@@ -434,6 +453,18 @@ func run(name string, args ...string) error {
 	return cmd.Run()
 }
 
+func runWithEnv(env map[string]string, name string, args ...string) error {
+	cmd := exec.Command(name, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Dir = projectDir()
+	cmd.Env = os.Environ()
+	for key, value := range env {
+		cmd.Env = append(cmd.Env, key+"="+value)
+	}
+	return cmd.Run()
+}
+
 func cmdOutput(name string, args ...string) (string, error) {
 	cmd := exec.Command(name, args...)
 	cmd.Dir = projectDir()