refactor(test): extract hardlink helpers to internal/testfsutil, add time log

Code review follow-ups:

1. internal/testfsutil/hardlink.go — single source of truth for HardLinkDir
   and CopyFile. Removes three near-identical local copies from repos/
   testhelpers_test.go, mpr/factory_test.go, and executor's fixture helpers.

2. Pre-commit time guard redesign:
   - .test-time-log: append-only history (ISO8601 timestamp, elapsed_s,
     git SHA, branch) committed to git so the full run history is visible
   - .test-time-baseline: last successful run time, committed so the guard
     survives machine changes; updated on every passing run
   - Fail if elapsed > baseline × 1.5; print last 10 log entries on failure
   - Reset command printed on failure for intentional perf changes

3. Remove .test-time-baseline from .gitignore (both files are now committed).

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

Author: claude

.githooks/checks/02-unit-tests.sh

@@ -1,9 +1,28 @@
 #!/bin/sh
 # L1: unit tests — fast, no external deps, no Docker.
-LOG_FILE="$(git rev-parse --show-toplevel)/.test-fail.log"
+#
+# Time guard: each successful run is appended to .test-time-log and the
+# elapsed time is compared against .test-time-baseline. Both files are
+# committed so the history is visible and shared.
+#
+# .test-time-baseline  — last recorded elapsed time (seconds), updated on
+#                        every pass. Fail if current > baseline * 1.5.
+# .test-time-log       — append-only history: one line per run, format:
+#                          ISO8601  elapsed_s  git_sha  branch
+#
+# To reset the baseline after intentional perf change:
+#   echo <new_seconds> > .test-time-baseline
+#   git add .test-time-baseline .test-time-log && git commit -m "perf: reset test baseline"
+
+REPO="$(git rev-parse --show-toplevel)"
+LOG_FILE="${REPO}/.test-fail.log"
+BASELINE_FILE="${REPO}/.test-time-baseline"
+TIMELOG_FILE="${REPO}/.test-time-log"
 rm -f "$LOG_FILE"
 
 echo "pre-commit: running unit tests..."
+
+START=$(date +%s)
 if ! CGO_ENABLED=0 go test -timeout 180s -p "$(nproc)" -parallel "$(nproc)" ./... > "$LOG_FILE" 2>&1; then
     echo "" >&2
     echo "COMMIT BLOCKED: unit tests failed." >&2
@@ -13,6 +32,34 @@ if ! CGO_ENABLED=0 go test -timeout 180s -p "$(nproc)" -parallel "$(nproc)" ./..
     echo "CONTEXT: LOG_FILE=${LOG_FILE}" >&2
     exit 1
 fi
-
+END=$(date +%s)
+ELAPSED=$((END - START))
 rm -f "$LOG_FILE"
-echo "pre-commit: unit tests passed."
+
+# Append to time log.
+SHA=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+printf "%s\t%ss\t%s\t%s\n" "$TS" "$ELAPSED" "$SHA" "$BRANCH" >> "$TIMELOG_FILE"
+
+# Time guard: compare against last successful run.
+if [ -f "$BASELINE_FILE" ]; then
+    BASELINE=$(cat "$BASELINE_FILE")
+    THRESHOLD=$((BASELINE + BASELINE / 2))   # 150% of baseline
+    if [ "$ELAPSED" -gt "$THRESHOLD" ]; then
+        echo "" >&2
+        echo "COMMIT BLOCKED: test time regression." >&2
+        echo "  Current:  ${ELAPSED}s" >&2
+        echo "  Baseline: ${BASELINE}s  (limit: ${THRESHOLD}s = baseline × 1.5)" >&2
+        echo "" >&2
+        tail -10 "$TIMELOG_FILE" | awk -F'\t' '{printf "  %s\t%s\n", $1, $2}' >&2
+        echo "" >&2
+        echo "To reset: echo ${ELAPSED} > .test-time-baseline" >&2
+        exit 1
+    fi
+fi
+
+# Update baseline to the current run so the guard tracks recent history.
+echo "$ELAPSED" > "$BASELINE_FILE"
+
+echo "pre-commit: unit tests passed (${ELAPSED}s)."

.test-time-baseline

@@ -0,0 +1 @@
+60

.test-time-log

@@ -0,0 +1 @@
+2026-05-27T19:55:24Z	inits	a37613d4	pr/mpr-pack-expr-testdata

internal/testfsutil/hardlink.go

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// Package testfsutil provides filesystem helpers for test fixture isolation.
+package testfsutil
+
+import (
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"syscall"
+)
+
+// HardLinkDir mirrors src into dst by hard-linking regular files when
+// possible, falling back to byte copying on cross-device setups (EXDEV).
+//
+// Hard links are O(1) — no data is transferred. They are safe for
+// mprcontents/ fixture trees because the Writer never modifies existing
+// .mxunit files in place; it only creates new files with fresh UUIDs
+// (and updateUnit now uses atomic rename, not direct WriteFile).
+//
+// Falls back transparently to CopyFile on cross-device setups so tests
+// work correctly regardless of where /tmp is mounted relative to testdata.
+func HardLinkDir(src, dst string) error {
+	return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		rel, err := filepath.Rel(src, p)
+		if err != nil {
+			return err
+		}
+		target := filepath.Join(dst, rel)
+		if d.IsDir() {
+			return os.MkdirAll(target, 0o755)
+		}
+		if linkErr := os.Link(p, target); linkErr != nil {
+			if errors.Is(linkErr, syscall.EXDEV) {
+				return CopyFile(p, target)
+			}
+			return linkErr
+		}
+		return nil
+	})
+}
+
+// CopyFile copies src to dst using io.Copy.
+func CopyFile(src, dst string) error {
+	in, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+		return err
+	}
+	out, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+	if _, err := io.Copy(out, in); err != nil {
+		return err
+	}
+	return nil
+}

mdl/backend/mpr/factory_test.go

@@ -3,15 +3,12 @@
 package mprbackend
 
 import (
-	"errors"
-	"io"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"runtime"
-	"syscall"
 	"testing"
 
+	"github.com/mendixlabs/mxcli/internal/testfsutil"
 	mmpr "github.com/mendixlabs/mxcli/modelsdk/mpr"
 )
 
@@ -338,7 +335,7 @@ func TestNewExecutorContextWithReferences_BothServicesWired(t *testing.T) {
 	}
 }
 
-// --- helpers (mirror mdl/backend/mpr/repos/testhelpers_test.go) ---
+// --- fixture helpers ---
 
 func copyFixture(t *testing.T, srcMPR, dstDir string) string {
 	t.Helper()
@@ -351,76 +348,15 @@ func copyFixture(t *testing.T, srcMPR, dstDir string) string {
 
 func copyMPRTree(srcMPR, dstDir string) (string, error) {
 	dstMPR := filepath.Join(dstDir, filepath.Base(srcMPR))
-	if err := copyOneFile(srcMPR, dstMPR); err != nil {
+	if err := testfsutil.CopyFile(srcMPR, dstMPR); err != nil {
 		return "", err
 	}
 	srcContents := filepath.Join(filepath.Dir(srcMPR), "mprcontents")
 	if info, err := os.Stat(srcContents); err == nil && info.IsDir() {
 		dstContents := filepath.Join(dstDir, "mprcontents")
-		if err := hardLinkDir(srcContents, dstContents); err != nil {
+		if err := testfsutil.HardLinkDir(srcContents, dstContents); err != nil {
 			return "", err
 		}
 	}
 	return dstMPR, nil
 }
-
-// hardLinkDir mirrors src into dst using hard links; falls back to copy on EXDEV.
-func hardLinkDir(src, dst string) error {
-	return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(src, p)
-		if err != nil {
-			return err
-		}
-		target := filepath.Join(dst, rel)
-		if d.IsDir() {
-			return os.MkdirAll(target, 0o755)
-		}
-		if linkErr := os.Link(p, target); linkErr != nil {
-			if errors.Is(linkErr, syscall.EXDEV) {
-				return copyOneFile(p, target)
-			}
-			return linkErr
-		}
-		return nil
-	})
-}
-
-func copyOneFile(src, dst string) error {
-	in, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer in.Close()
-	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
-		return err
-	}
-	out, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-	if _, err := io.Copy(out, in); err != nil {
-		return err
-	}
-	return nil
-}
-
-func copyDir(src, dst string) error {
-	return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(src, p)
-		if err != nil {
-			return err
-		}
-		target := filepath.Join(dst, rel)
-		if d.IsDir() {
-			return os.MkdirAll(target, 0o755)
-		}
-		return copyOneFile(p, target)
-	})
-}

mdl/backend/mpr/repos/testhelpers_test.go

@@ -3,20 +3,17 @@
 package mprrepos
 
 import (
-	"errors"
-	"io"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"runtime"
-	"syscall"
 	"testing"
 
+	"github.com/mendixlabs/mxcli/internal/testfsutil"
 	"github.com/mendixlabs/mxcli/model"
 	mmpr "github.com/mendixlabs/mxcli/modelsdk/mpr"
 )
 
-// fixtureOpenSem limits concurrent fixture open operations at GOMAXPROCS
+// fixtureOpenSem limits concurrent fixture open operations to GOMAXPROCS
 // to prevent I/O storms when many tests run in parallel.
 var fixtureOpenSem = make(chan struct{}, runtime.GOMAXPROCS(0))
 
@@ -28,16 +25,12 @@ func typedID(s string) model.ID { return model.ID(s) }
 // relative to test files in mdl/backend/mpr/repos/.
 const fixturePath = "../../../../testdata/expr-checker/minimal.mpr"
 
-// openTestWriter sets up an isolated writable copy of the fixture for
-// a test and opens it as a *mmpr.Writer.
+// openTestWriter sets up an isolated writable copy of the fixture and
+// opens it as a *mmpr.Writer.
 //
-// Isolation strategy for mprcontents/ (370 immutable .mxunit files):
-//   - Hard-link instead of copy: O(1) per file, no data written
-//   - The Writer never modifies existing .mxunit files; it only creates
-//     new ones with fresh UUIDs, so hard links are safe
-//
-// The .mpr SQLite file (68 KB) must be a real copy because the Writer
-// commits WAL changes back into it.
+// The .mpr SQLite file is real-copied (Writer writes WAL back to it).
+// mprcontents/ is hard-linked via testfsutil.HardLinkDir — O(1) per
+// file with automatic EXDEV fallback to byte-copy on cross-device setups.
 func openTestWriter(t *testing.T) *mmpr.Writer {
 	t.Helper()
 	t.Parallel()
@@ -61,86 +54,17 @@ func copyFixture(t *testing.T, srcMPR, dstDir string) string {
 	return dst
 }
 
-// copyMPRTree copies the .mpr SQLite file and hard-links the mprcontents/
-// directory tree into dstDir. Hard links are used for mprcontents/ because
-// those files are immutable once written — the Writer adds new files rather
-// than modifying existing ones.
 func copyMPRTree(srcMPR, dstDir string) (string, error) {
 	dstMPR := filepath.Join(dstDir, filepath.Base(srcMPR))
-	if err := copyOneFile(srcMPR, dstMPR); err != nil {
+	if err := testfsutil.CopyFile(srcMPR, dstMPR); err != nil {
 		return "", err
 	}
 	srcContents := filepath.Join(filepath.Dir(srcMPR), "mprcontents")
 	if info, err := os.Stat(srcContents); err == nil && info.IsDir() {
 		dstContents := filepath.Join(dstDir, "mprcontents")
-		if err := hardLinkDir(srcContents, dstContents); err != nil {
+		if err := testfsutil.HardLinkDir(srcContents, dstContents); err != nil {
 			return "", err
 		}
 	}
 	return dstMPR, nil
 }
-
-// hardLinkDir mirrors src into dst using hard links when possible.
-// Falls back to copyOneFile on cross-device setups (EXDEV). Hard links
-// are safe for mprcontents/ because the Writer only creates new files
-// with fresh UUIDs — it never modifies existing .mxunit files in place.
-func hardLinkDir(src, dst string) error {
-	return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(src, p)
-		if err != nil {
-			return err
-		}
-		target := filepath.Join(dst, rel)
-		if d.IsDir() {
-			return os.MkdirAll(target, 0o755)
-		}
-		if linkErr := os.Link(p, target); linkErr != nil {
-			if errors.Is(linkErr, syscall.EXDEV) {
-				return copyOneFile(p, target)
-			}
-			return linkErr
-		}
-		return nil
-	})
-}
-
-func copyOneFile(src, dst string) error {
-	in, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer in.Close()
-	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
-		return err
-	}
-	out, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-	if _, err := io.Copy(out, in); err != nil {
-		return err
-	}
-	return nil
-}
-
-// copyDir is retained for tests that explicitly need a real on-disk copy.
-func copyDir(src, dst string) error {
-	return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(src, p)
-		if err != nil {
-			return err
-		}
-		target := filepath.Join(dst, rel)
-		if d.IsDir() {
-			return os.MkdirAll(target, 0o755)
-		}
-		return copyOneFile(p, target)
-	})
-}