diff --git a/internal/testdrive/format.go b/internal/testdrive/format.go
deleted file mode 100644
index a315d2fd..00000000
--- a/internal/testdrive/format.go
+++ /dev/null
@@ -1,66 +0,0 @@
-package testdrive
-
-import (
-	"github.com/DataDog/ddtest/internal/testdrive/intake"
-	"strings"
-	"time"
-)
-
-func testDisplayStatus(test intake.Test) (string, string) {
-	status := test.Status
-	sawPass := status == "pass"
-	sawFailure := status == "fail"
-	for _, attempt := range test.Attempts {
-		sawPass = sawPass || attempt.Status == "pass"
-		sawFailure = sawFailure || attempt.Status == "fail"
-	}
-	if sawPass && sawFailure {
-		return "Flaky", "attention"
-	}
-	if status == "" && len(test.Attempts) > 0 {
-		status = test.Attempts[len(test.Attempts)-1].Status
-	}
-	return displayStatus(status), attemptTone(status)
-}
-
-func attemptTone(status string) string {
-	if status == "pass" {
-		return "good"
-	}
-	return "attention"
-}
-
-func findingDuration(test intake.Test) time.Duration {
-	if test.Duration != 0 || len(test.Attempts) == 0 {
-		return test.Duration
-	}
-	return test.Attempts[0].Duration
-}
-
-func passedFailed(passed bool) string {
-	if passed {
-		return "Passed"
-	}
-	return "Failed"
-}
-
-func displayStatus(status string) string {
-	if status == "" {
-		return "Unknown"
-	}
-	return strings.ToUpper(status[:1]) + status[1:]
-}
-
-func formatDuration(duration time.Duration) string {
-	if duration < time.Millisecond {
-		return duration.Round(time.Microsecond).String()
-	}
-	return duration.Round(time.Millisecond).String()
-}
-
-func plural(count int, singular, plural string) string {
-	if count == 1 {
-		return singular
-	}
-	return plural
-}
diff --git a/internal/testdrive/intake/findings.go b/internal/testdrive/intake/findings.go
index a95fa68b..1a5a7252 100644
--- a/internal/testdrive/intake/findings.go
+++ b/internal/testdrive/intake/findings.go
@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	minimumSlowDuration       = 100 * time.Millisecond
+	minimumSlowDuration       = 5 * time.Second
 	minimumBroadCoverageFiles = 5
 )
 
@@ -215,11 +215,10 @@ func slowTests(tests []Test) ([]Test, time.Duration) {
 		return nil, medianTestDuration(tests)
 	}
 	median := medianTestDuration(tests)
-	threshold := max(minimumSlowDuration, median*2)
 
 	slow := make([]Test, 0)
 	for _, test := range tests {
-		if test.Duration >= threshold && test.Duration > median {
+		if test.Duration > minimumSlowDuration && test.Duration >= median*5 {
 			slow = append(slow, test)
 		}
 	}
diff --git a/internal/testdrive/intake/findings_test.go b/internal/testdrive/intake/findings_test.go
index 80998472..45177c60 100644
--- a/internal/testdrive/intake/findings_test.go
+++ b/internal/testdrive/intake/findings_test.go
@@ -21,7 +21,7 @@ func TestAnalyzeTestsFindsFailuresRetriesAndSlowTests(t *testing.T) {
 		{name: "fast", suite: "one.test.js", status: "pass", duration: 10 * time.Millisecond},
 		{name: "flaky", suite: "one.test.js", status: "fail", duration: 20 * time.Millisecond},
 		{name: "flaky", suite: "one.test.js", status: "pass", duration: 30 * time.Millisecond, isRetry: true},
-		{name: "slow", suite: "two.test.js", status: "pass", duration: 400 * time.Millisecond},
+		{name: "slow", suite: "two.test.js", status: "pass", duration: 6 * time.Second},
 		{name: "broken", suite: "two.test.js", status: "fail", duration: 15 * time.Millisecond},
 	}
 
@@ -40,12 +40,44 @@ func TestAnalyzeTestsFindsFailuresRetriesAndSlowTests(t *testing.T) {
 		},
 	}}, flaky)
 	require.Equal(t, []Test{{
-		Name: "slow", Suite: "two.test.js", Status: "pass", Duration: 400 * time.Millisecond,
-		Attempts: []TestRun{{Status: "pass", Duration: 400 * time.Millisecond}},
+		Name: "slow", Suite: "two.test.js", Status: "pass", Duration: 6 * time.Second,
+		Attempts: []TestRun{{Status: "pass", Duration: 6 * time.Second}},
 	}}, slow)
 	require.Equal(t, 17500*time.Microsecond, median)
 }
 
+func TestAnalyzeTestsSlowThresholds(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		median   time.Duration
+		duration time.Duration
+		wantSlow bool
+	}{
+		{name: "fast outlier", median: 10 * time.Millisecond, duration: 400 * time.Millisecond},
+		{name: "exactly five seconds", median: time.Second, duration: 5 * time.Second},
+		{name: "above five seconds", median: time.Second, duration: 5*time.Second + time.Nanosecond, wantSlow: true},
+		{name: "below five times median", median: 2 * time.Second, duration: 10*time.Second - time.Nanosecond},
+		{name: "exactly five times median", median: 2 * time.Second, duration: 10 * time.Second, wantSlow: true},
+		{name: "above five times median", median: 2 * time.Second, duration: 11 * time.Second, wantSlow: true},
+		{name: "uniformly slow tests", median: 6 * time.Second, duration: 6 * time.Second},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			_, _, _, slow, median := analyzeTests([]testReference{
+				{name: "baseline one", status: "pass", duration: tc.median},
+				{name: "baseline two", status: "pass", duration: tc.median},
+				{name: "candidate", status: "pass", duration: tc.duration},
+			}, nil, "")
+			require.Equal(t, tc.median, median)
+			if tc.wantSlow {
+				require.Len(t, slow, 1)
+				require.Equal(t, "candidate", slow[0].Name)
+			} else {
+				require.Empty(t, slow)
+			}
+		})
+	}
+}
+
 func TestAnalyzeTestsUsesFinalStatusAndMarksMixedOutcomesFlaky(t *testing.T) {
 	tests := []testReference{
 		{name: "flaky", suite: "one.test.js", status: "pass", finalStatus: "pass", duration: 10 * time.Millisecond},
@@ -250,7 +282,7 @@ func TestFindingsPreservesCoverageInEveryCategory(t *testing.T) {
 				}
 				duration := time.Millisecond
 				if name == "" {
-					duration = time.Second
+					duration = 6 * time.Second
 				}
 				events = append(events, map[string]any{"type": "test", "content": map[string]any{
 					"test_session_id": 1, "test_suite_id": 2, "span_id": i + 1, "duration": int64(duration),
diff --git a/internal/testdrive/report.go b/internal/testdrive/report.go
new file mode 100644
index 00000000..1887cdde
--- /dev/null
+++ b/internal/testdrive/report.go
@@ -0,0 +1,192 @@
+package testdrive
+
+import (
+	"errors"
+	"fmt"
+	"github.com/DataDog/ddtest/internal/testdrive/intake"
+	"html/template"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const reportFilename = "report.html"
+
+type reportRuntime struct{ Framework, Tracer string }
+type reportFact struct{ Label, Value string }
+type reportCard struct {
+	Title, Context string
+	Tests          []intake.Test
+	Coverages      []intake.CoverageFact
+}
+type reportModel struct {
+	Headline, Summary string
+	Facts             []reportFact
+	Cards             []reportCard
+}
+
+func writeReport(repositoryRoot, sessionDirectory string, findings intake.Facts, commandFailed bool, runtime ...reportRuntime) (string, error) {
+	path := filepath.Join(sessionDirectory, reportFilename)
+	file, err := os.Create(path)
+	if err != nil {
+		return "", fmt.Errorf("create testdrive report: %w", err)
+	}
+	executeErr := testdriveReport.Execute(file, buildReport(repositoryRoot, findings, commandFailed, runtime...))
+	if err := errors.Join(executeErr, file.Close()); err != nil {
+		return "", fmt.Errorf("write testdrive report: %w", err)
+	}
+	return path, nil
+}
+func buildReport(_ string, findings intake.Facts, commandFailed bool, runtime ...reportRuntime) reportModel {
+	info := reportRuntime{Framework: "Test command", Tracer: "Isolated installation"}
+	if len(runtime) > 0 {
+		info = runtime[0]
+	}
+	coverage := "Not reported"
+	if findings.CoveredTestCount > 0 {
+		coverage = fmt.Sprintf("%d / %d", findings.CoveredTestCount, findings.TestCount)
+	}
+	status := passedFailed(!commandFailed)
+	if findings.TestEventCount == 0 {
+		status = "No test results received"
+	}
+	model := reportModel{Headline: "Test events received.", Summary: "No findings.", Facts: []reportFact{
+		{"Test events", fmt.Sprint(findings.TestEventCount)},
+		{"Tests with coverage", coverage},
+		{info.Framework, status},
+		{"Datadog library", info.Tracer},
+	}}
+	if findings.TestEventCount == 0 {
+		model.Headline = "No test events received."
+		model.Summary = "Check the instrumentation setup."
+	}
+	if findings.EmptyCoverageEntryCount > 0 {
+		model.Cards = append(model.Cards, reportCard{
+			Title:   "Tracer error: empty coverage entries",
+			Context: fmt.Sprintf("%d coverage entries had an empty files list. Affected payloads were excluded from coverage counts. Inspect the captured traffic.", findings.EmptyCoverageEntryCount),
+		})
+	}
+	if len(findings.FailedTests) > 0 {
+		model.Cards = append(model.Cards, reportCard{Title: "Any tests failed?", Tests: findings.FailedTests})
+	}
+	if len(findings.FlakyTests) > 0 {
+		model.Cards = append(model.Cards, reportCard{Title: "Any flaky tests?", Tests: findings.FlakyTests})
+	}
+	if len(findings.SlowTests) > 0 {
+		model.Cards = append(model.Cards, reportCard{Title: "Any tests slower than the others?", Context: "Median test time · " + formatDuration(findings.TestDurationMedian), Tests: findings.SlowTests})
+	}
+	if len(findings.BroadCoverage) > 0 {
+		model.Cards = append(model.Cards, reportCard{Title: "Any unusually broad test coverage?", Context: fmt.Sprintf("Median covered files · %d", findings.CoveredFilesMedian), Coverages: findings.BroadCoverage})
+	}
+	count := len(findings.ConfigurationErrors) + findings.EmptyCoverageEntryCount
+	for _, size := range []int{
+		len(findings.FailedTests), len(findings.FlakyTests), len(findings.SlowTests), len(findings.BroadCoverage),
+	} {
+		count += size
+	}
+	if count > 0 {
+		model.Summary = fmt.Sprintf("%d %s.", count, plural(count, "finding", "findings"))
+	}
+	if len(findings.ConfigurationErrors) > 0 {
+		model.Summary += " Tracer configuration errors: " + strings.Join(findings.ConfigurationErrors, ", ") + ". Inspect the captured traffic and test output."
+	}
+	return model
+}
+
+var testdriveReport = template.Must(template.New("testdrive-report").Parse(`<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>DDTest report</title>
+<style>body{font:16px system-ui;max-width:900px;margin:3rem auto;padding:1rem}article,section{margin:2rem 0}li{margin:.5rem 0}</style></head><body>
+<h1>{{.Headline}}</h1><p>{{.Summary}}</p>
+{{range .Cards}}<article class="problem-card"><h2>{{.Title}}</h2><p>{{.Context}}</p><ul>{{range .Tests}}<li>{{.Suite}} · {{.Name}}</li>{{end}}{{range .Coverages}}<li>{{.Name}} · {{.FileCount}} files</li>{{end}}</ul></article>{{end}}
+<section><h2>Run details</h2><dl>{{range .Facts}}<dt>{{.Label}}</dt><dd>{{.Value}}</dd>{{end}}</dl></section>
+<section><h2>Artifacts</h2><ul><li><a href="intake/">JSON traffic</a></li><li><a href="test-output.txt">Test output</a></li></ul></section></body></html>`))
+
+func testDisplayStatus(test intake.Test) (string, string) {
+	status := test.Status
+	sawPass := status == "pass"
+	sawFailure := status == "fail"
+	for _, attempt := range test.Attempts {
+		sawPass = sawPass || attempt.Status == "pass"
+		sawFailure = sawFailure || attempt.Status == "fail"
+	}
+	if sawPass && sawFailure {
+		return "Flaky", "attention"
+	}
+	if status == "" && len(test.Attempts) > 0 {
+		status = test.Attempts[len(test.Attempts)-1].Status
+	}
+	return displayStatus(status), attemptTone(status)
+}
+
+func attemptTone(status string) string {
+	if status == "pass" {
+		return "good"
+	}
+	return "attention"
+}
+
+func findingDuration(test intake.Test) time.Duration {
+	if test.Duration != 0 || len(test.Attempts) == 0 {
+		return test.Duration
+	}
+	return test.Attempts[0].Duration
+}
+
+func passedFailed(passed bool) string {
+	if passed {
+		return "Passed"
+	}
+	return "Failed"
+}
+
+func displayStatus(status string) string {
+	if status == "" {
+		return "Unknown"
+	}
+	return strings.ToUpper(status[:1]) + status[1:]
+}
+
+func formatDuration(duration time.Duration) string {
+	if duration < time.Millisecond {
+		return duration.Round(time.Microsecond).String()
+	}
+	return duration.Round(time.Millisecond).String()
+}
+
+func plural(count int, singular, plural string) string {
+	if count == 1 {
+		return singular
+	}
+	return plural
+}
+
+func fileURL(path string) (string, error) {
+	absolutePath, err := filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+	return absoluteFileURL(absolutePath), nil
+}
+
+func absoluteFileURL(absolutePath string) string {
+	slashPath := absolutePath
+	// A backslash is a valid filename character in an absolute Unix path.
+	if !strings.HasPrefix(absolutePath, "/") {
+		slashPath = strings.ReplaceAll(absolutePath, `\`, "/")
+	}
+	if strings.HasPrefix(absolutePath, `\\`) {
+		hostAndPath := strings.TrimPrefix(slashPath, "//")
+		host, path, _ := strings.Cut(hostAndPath, "/")
+		return (&url.URL{Scheme: "file", Host: host, Path: "/" + path}).String()
+	}
+	if len(slashPath) >= 2 && slashPath[1] == ':' {
+		slashPath = "/" + slashPath
+	}
+	return (&url.URL{Scheme: "file", Path: slashPath}).String()
+}
+
+func terminalLink(target, label string) string {
+	return "\x1b]8;;" + target + "\x1b\\" + label + "\x1b]8;;\x1b\\"
+}
diff --git a/internal/testdrive/report_test.go b/internal/testdrive/report_test.go
new file mode 100644
index 00000000..b7e71ab0
--- /dev/null
+++ b/internal/testdrive/report_test.go
@@ -0,0 +1,139 @@
+package testdrive
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/DataDog/ddtest/internal/testdrive/intake"
+)
+
+func TestReportCountsIndividualFindings(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		facts intake.Facts
+		want  string
+	}{
+		{"single", intake.Facts{TestEventCount: 1, FailedTests: []intake.Test{{Name: "failed"}}}, "1 finding."},
+		{"multiple in one card", intake.Facts{TestEventCount: 2, FailedTests: []intake.Test{{Name: "one"}, {Name: "two"}}}, "2 findings."},
+		{"empty coverage without events", intake.Facts{EmptyCoverageEntryCount: 2}, "2 findings."},
+		{"configuration error without events", intake.Facts{ConfigurationErrors: []string{"skippable_tests"}}, "1 finding."},
+		{"combined", intake.Facts{
+			TestEventCount: 2, EmptyCoverageEntryCount: 2, ConfigurationErrors: []string{"skippable_tests"},
+			FailedTests: []intake.Test{{Name: "failed"}}, FlakyTests: []intake.Test{{Name: "flaky"}},
+			SlowTests: []intake.Test{{Name: "slow"}}, BroadCoverage: []intake.CoverageFact{{Name: "broad"}},
+		}, "7 findings."},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			model := buildReport(t.TempDir(), tc.facts, false)
+			if !strings.HasPrefix(model.Summary, tc.want) {
+				t.Fatalf("summary = %q, want prefix %q", model.Summary, tc.want)
+			}
+			var console bytes.Buffer
+			writeFindings(&console, tc.facts)
+			if !strings.Contains(console.String(), tc.want+"\n") {
+				t.Fatalf("report and terminal counts differ: report %q, terminal %q", model.Summary, console.String())
+			}
+			if len(tc.facts.ConfigurationErrors) > 0 && !strings.Contains(model.Summary, "Tracer configuration errors: skippable_tests.") {
+				t.Fatalf("summary hides configuration errors: %q", model.Summary)
+			}
+		})
+	}
+}
+
+func TestStaticReportEscapesFindingsAndDescribesMissingCoverage(t *testing.T) {
+	path, err := writeReport(t.TempDir(), t.TempDir(), intake.Facts{TestEventCount: 1, TestCount: 1, FailedTests: []intake.Test{{Name: "<script>alert(1)</script>"}}}, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"&lt;script&gt;", "Not reported", "Failed", "intake/", "test-output.txt"} {
+		if !strings.Contains(string(data), want) {
+			t.Errorf("missing %q", want)
+		}
+	}
+	if strings.Contains(string(data), "<script>alert") {
+		t.Fatal("unescaped test name")
+	}
+	model := buildReport(t.TempDir(), intake.Facts{}, false)
+	if model.Headline != "No test events received." {
+		t.Fatal(model.Headline)
+	}
+}
+
+func TestReportSurfacesConfigurationErrorsDespiteReceivedTests(t *testing.T) {
+	model := buildReport(t.TempDir(), intake.Facts{TestEventCount: 1, FailedTests: []intake.Test{{Name: "fails"}}, ConfigurationErrors: []string{"skippable_tests"}}, false)
+	if model.Headline != "Test events received." {
+		t.Fatalf("headline overstates verification: %s", model.Headline)
+	}
+	if !strings.Contains(model.Summary, "Tracer configuration errors: skippable_tests.") {
+		t.Fatalf("missing configuration error: %s", model.Summary)
+	}
+}
+
+func TestReportSurfacesEmptyCoverageAsTracerError(t *testing.T) {
+	path, err := writeReport(t.TempDir(), t.TempDir(), intake.Facts{TestEventCount: 1, TestCount: 1, EmptyCoverageEntryCount: 2}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []string{"Tracer error: empty coverage entries", "2 coverage entries had an empty files list", "Affected payloads were excluded", "Inspect the captured traffic"} {
+		if !strings.Contains(string(data), expected) {
+			t.Errorf("missing %q in report", expected)
+		}
+	}
+	if strings.Contains(string(data), "No findings.") {
+		t.Fatal("report hides tracer error as no findings")
+	}
+}
+
+func TestReportRuntimeFacts(t *testing.T) {
+	for _, tc := range []struct {
+		name          string
+		events        int
+		commandFailed bool
+		tracer        string
+		wantStatus    string
+	}{
+		{"passing with reused tracer", 1, false, "dd-trace@6.15.0 · reused", "Passed"},
+		{"failing with isolated tracer", 1, true, "dd-trace@6.15.0 · isolated", "Failed"},
+		{"successful command without events", 0, false, "dd-trace@6.15.0 · reused", "No test results received"},
+		{"failed command without events", 0, true, "dd-trace@6.15.0 · isolated", "No test results received"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			model := buildReport(t.TempDir(), intake.Facts{TestEventCount: tc.events}, tc.commandFailed, reportRuntime{Framework: "Jest", Tracer: tc.tracer})
+			facts := make(map[string]string)
+			for _, fact := range model.Facts {
+				facts[fact.Label] = fact.Value
+			}
+			if facts["Jest"] != tc.wantStatus || facts["Datadog library"] != tc.tracer {
+				t.Fatalf("incorrect runtime facts: %v", facts)
+			}
+			if tc.events == 0 && (model.Headline != "No test events received." || strings.Contains(model.Summary, "No findings.")) {
+				t.Fatalf("report implies successful instrumentation without events: %+v", model)
+			}
+		})
+	}
+}
+
+func TestAbsoluteFileURL(t *testing.T) {
+	for path, want := range map[string]string{
+		`C:\repo\report.html`:                "file:///C:/repo/report.html",
+		`C:\project space\report.html`:       "file:///C:/project%20space/report.html",
+		`\\server\share\report.html`:         "file://server/share/report.html",
+		`\\server\share space\report#1.html`: "file://server/share%20space/report%231.html",
+		`/repo space/report#1.html`:          "file:///repo%20space/report%231.html",
+		`/repo\name/report.html`:             "file:///repo%5Cname/report.html",
+	} {
+		if got := absoluteFileURL(path); got != want {
+			t.Errorf("absoluteFileURL(%q) = %q, want %q", path, got, want)
+		}
+	}
+}
diff --git a/internal/testdrive/testdrive.go b/internal/testdrive/testdrive.go
index 645e1800..ac13eb82 100644
--- a/internal/testdrive/testdrive.go
+++ b/internal/testdrive/testdrive.go
@@ -115,6 +115,9 @@ func displayName(name string) string {
 func (t *Testdrive) Preview(output io.Writer) {
 	command, args := t.command, t.args
 	directory := t.session.Directory()
+	if relative, err := filepath.Rel(t.repositoryRoot, directory); err == nil {
+		directory = relative
+	}
 
 	_, _ = fmt.Fprintf(output, "DDTest found %s and %s.\n", displayName(t.language), displayName(t.framework.Name()))
 	_, _ = fmt.Fprintln(output)
@@ -123,13 +126,40 @@ func (t *Testdrive) Preview(output io.Writer) {
 	if t.projectTracer != "" {
 		_, _ = fmt.Fprintf(output, "  - reuse installed %s; no installation is needed\n", t.installedTracerLabel(t.projectTracer))
 	} else {
-		_, _ = fmt.Fprintf(output, "  - install %s: %s\n", t.tracerLabel, shellquote.Join(append([]string{t.installCommand}, t.installArgs...)...))
+		install := append([]string{t.installCommand}, t.installArgs...)
+		for i, arg := range install {
+			install[i] = strings.ReplaceAll(arg, t.session.Directory(), directory)
+		}
+		_, _ = fmt.Fprintf(output, "  - install %s: %s\n", t.tracerLabel, shellquote.Join(install...))
 	}
 
 	_, _ = fmt.Fprintf(output, "  - run: %s\n", shellquote.Join(append([]string{command}, args...)...))
-	_, _ = fmt.Fprintf(output, "  - save captured traffic in %s and test output in %s\n", filepath.Join(directory, "intake"), filepath.Join(directory, testOutputFilename))
 	_, _ = fmt.Fprintln(output)
-	_, _ = fmt.Fprintln(output, "It will not change package.json, Gemfile, Python dependency files, or a lockfile in your project.")
+	patterns := map[string][]string{
+		"javascript": {"package.json", "package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "pnpm-lock.yaml", "bun.lock", "bun.lockb"},
+		"python":     {"pyproject.toml", "setup.py", "setup.cfg", "requirements*.txt", "requirements*.in", "Pipfile", "Pipfile.lock", "poetry.lock", "uv.lock", "pdm.lock", "pylock.toml"},
+		"ruby":       {"Gemfile", "Gemfile.lock", "gems.rb", "gems.locked"},
+	}[t.language]
+	entries, _ := os.ReadDir(t.repositoryRoot)
+	var files []string
+	for _, pattern := range patterns {
+		for _, entry := range entries {
+			matched, _ := filepath.Match(pattern, entry.Name())
+			if !matched {
+				continue
+			}
+			if info, err := os.Stat(filepath.Join(t.repositoryRoot, entry.Name())); err == nil && !info.IsDir() {
+				files = append(files, entry.Name())
+			}
+		}
+	}
+	if len(files) > 0 {
+		names := files[0]
+		if len(files) > 1 {
+			names = strings.Join(files[:len(files)-1], ", ") + " or " + files[len(files)-1]
+		}
+		_, _ = fmt.Fprintf(output, "It will not change %s.\n", names)
+	}
 }
 
 // Run prepares the tracer and executes the detected test suite.
@@ -180,6 +210,26 @@ func (t *Testdrive) Run(ctx context.Context, output io.Writer) (runErr error) {
 	if err := os.WriteFile(testOutputPath, testOutput, 0644); err != nil {
 		return fmt.Errorf("save test output: %w", err)
 	}
+	if testErr != nil {
+		_, _ = fmt.Fprintf(output, "\n%s command output:\n", displayName(t.framework.Name()))
+		captured := strings.TrimSpace(string(testOutput))
+		lines := strings.Split(captured, "\n")
+		switch {
+		case captured == "":
+			_, _ = fmt.Fprintln(output, "The command produced no output.")
+		case len(lines) > 80:
+			_, _ = fmt.Fprintln(output, strings.Join(lines[:40], "\n"))
+			_, _ = fmt.Fprintf(output, "\n... %d %s omitted; see the full test output below ...\n\n", len(lines)-80, plural(len(lines)-80, "line", "lines"))
+			_, _ = fmt.Fprintln(output, strings.Join(lines[len(lines)-40:], "\n"))
+		default:
+			_, _ = fmt.Fprintln(output, captured)
+		}
+		outputLabel, err := filepath.Rel(t.repositoryRoot, testOutputPath)
+		if err != nil {
+			outputLabel = testOutputPath
+		}
+		_, _ = fmt.Fprintf(output, "\nFull test output: %s\n", outputLabel)
+	}
 
 	// Drain the intake before taking the snapshot used by the report.
 	closeErr := server.Close()
@@ -191,6 +241,14 @@ func (t *Testdrive) Run(ctx context.Context, output io.Writer) (runErr error) {
 	if err != nil {
 		return err
 	}
+	reportPath, err := writeReport(t.repositoryRoot, session.Directory(), findings, testErr != nil, reportRuntime{Framework: displayName(t.framework.Name()), Tracer: tracerLabel})
+	if err != nil {
+		return err
+	}
+	reportURL, err := fileURL(reportPath)
+	if err != nil {
+		return fmt.Errorf("create report link: %w", err)
+	}
 
 	_, _ = fmt.Fprintln(output)
 	if findings.TestEventCount > 0 {
@@ -214,8 +272,12 @@ func (t *Testdrive) Run(ctx context.Context, output io.Writer) (runErr error) {
 		status = "No test results received"
 	}
 	_, _ = fmt.Fprintf(output, "  %s: %s\n", displayName(t.framework.Name()), status)
-	_, _ = fmt.Fprintf(output, "  Tracer: %s\n", tracerLabel)
-	_, _ = fmt.Fprintf(output, "\nRun artifacts: %s\n", session.Directory())
+	_, _ = fmt.Fprintf(output, "  Datadog library: %s\n", tracerLabel)
+	reportLabel, err := filepath.Rel(t.repositoryRoot, reportPath)
+	if err != nil {
+		reportLabel = reportPath
+	}
+	_, _ = fmt.Fprintf(output, "\nOpen report: %s\n", terminalLink(reportURL, reportLabel))
 
 	if testErr != nil {
 		return fmt.Errorf("%s failed after sending %d test event(s): %w", t.framework.Name(), findings.TestEventCount, testErr)
diff --git a/internal/testdrive/testdrive_test.go b/internal/testdrive/testdrive_test.go
index c5079cc0..d95fed47 100644
--- a/internal/testdrive/testdrive_test.go
+++ b/internal/testdrive/testdrive_test.go
@@ -12,6 +12,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -80,7 +81,10 @@ func writeJestManifest(t *testing.T, repositoryRoot string) {
 }
 
 func TestPrepareAndPreviewJest(t *testing.T) {
-	repositoryRoot := t.TempDir()
+	repositoryRoot := filepath.Join(t.TempDir(), "project space")
+	if err := os.Mkdir(repositoryRoot, 0755); err != nil {
+		t.Fatal(err)
+	}
 	writeJestManifest(t, repositoryRoot)
 
 	t.Chdir(repositoryRoot)
@@ -95,13 +99,65 @@ func TestPrepareAndPreviewJest(t *testing.T) {
 		"found JavaScript and Jest",
 		"dd-trace@",
 		"npx jest",
-		filepath.Join(repositoryRoot, ".testoptimization", "testdrive"),
+		filepath.Join(".testoptimization", "testdrive"),
 		"will not change package.json",
 	} {
 		if !strings.Contains(output.String(), expected) {
 			t.Errorf("Preview() output does not contain %q:\n%s", expected, output.String())
 		}
 	}
+	for _, unwanted := range []string{repositoryRoot, "save a clickable report", "save captured traffic"} {
+		if strings.Contains(output.String(), unwanted) {
+			t.Errorf("Preview() contains %q:\n%s", unwanted, output.String())
+		}
+	}
+}
+
+func TestPreviewNamesOnlyDiscoveredDependencyFiles(t *testing.T) {
+	for _, tc := range []struct {
+		name, language string
+		framework      framework.Framework
+		files          []string
+		want           string
+	}{
+		{"manifest only", "javascript", framework.NewJest(), []string{"package.json"}, "It will not change package.json."},
+		{"npm", "javascript", framework.NewJest(), []string{"package.json", "package-lock.json"}, "It will not change package.json or package-lock.json."},
+		{"pnpm with other languages", "javascript", framework.NewJest(), []string{"package.json", "pnpm-lock.yaml", "Gemfile", "pyproject.toml"}, "It will not change package.json or pnpm-lock.yaml."},
+		{"yarn", "javascript", framework.NewJest(), []string{"package.json", "yarn.lock"}, "It will not change package.json or yarn.lock."},
+		{"bun", "javascript", framework.NewJest(), []string{"package.json", "bun.lock"}, "It will not change package.json or bun.lock."},
+		{"uv", "python", framework.NewPytest(), []string{"pyproject.toml", "uv.lock", "package.json"}, "It will not change pyproject.toml or uv.lock."},
+		{"pip", "python", framework.NewPytest(), []string{"requirements.txt", "requirements-dev.txt"}, "It will not change requirements-dev.txt or requirements.txt."},
+		{"poetry", "python", framework.NewPytest(), []string{"pyproject.toml", "poetry.lock"}, "It will not change pyproject.toml or poetry.lock."},
+		{"ruby reused", "ruby", framework.NewRSpec(), []string{"Gemfile", "Gemfile.lock", "package.json"}, "It will not change Gemfile or Gemfile.lock."},
+		{"multiple locks", "javascript", framework.NewJest(), []string{"package.json", "package-lock.json", "yarn.lock"}, "It will not change package.json, package-lock.json or yarn.lock."},
+		{"no dependency files", "python", framework.NewPytest(), []string{"pytest.ini"}, ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			root := filepath.Join(t.TempDir(), "project [space]")
+			if err := os.Mkdir(root, 0755); err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range tc.files {
+				requireWriteFile(t, filepath.Join(root, name), "")
+			}
+			// A directory with a dependency filename is not a discovered file.
+			if err := os.Mkdir(filepath.Join(root, "bun.lockb"), 0755); err != nil {
+				t.Fatal(err)
+			}
+			drive := &Testdrive{repositoryRoot: root, language: tc.language, framework: tc.framework, session: planSession(root), projectTracer: "installed"}
+			var output bytes.Buffer
+			drive.Preview(&output)
+			var notice string
+			for line := range strings.SplitSeq(output.String(), "\n") {
+				if strings.HasPrefix(line, "It will not change") {
+					notice = line
+				}
+			}
+			if notice != tc.want {
+				t.Fatalf("dependency notice = %q, want %q", notice, tc.want)
+			}
+		})
+	}
 }
 
 func TestPrepareRejectsUnsupportedRepository(t *testing.T) {
@@ -208,7 +264,9 @@ func TestRunReportsCapturedTestsAndCoverage(t *testing.T) {
 		"Test events: 2",
 		"Tests with coverage: 2 / 2",
 		"Jest: Passed",
-		"Tracer: dd-trace@latest · isolated",
+		"Datadog library: dd-trace@latest · isolated",
+		"\x1b]8;;file://",
+		"\x1b\\" + filepath.Join(".testoptimization", "testdrive", filepath.Base(installer.sessionDirectory), "report.html") + "\x1b]8;;",
 	} {
 		if !strings.Contains(output.String(), expected) {
 			t.Errorf("Run() output does not contain %q:\n%s", expected, output.String())
@@ -229,7 +287,32 @@ func TestRunReportsCapturedTestsAndCoverage(t *testing.T) {
 	if strings.Contains(output.String(), "PASS one.test.js") {
 		t.Fatalf("Run() leaked detailed Jest output:\n%s", output.String())
 	}
-
+	report, err := os.ReadFile(filepath.Join(installer.sessionDirectory, reportFilename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []string{
+		"Test events received",
+		"Any tests slower than the others?",
+		"Median test time · 1s",
+		"slow test",
+		"Run details",
+		"Tests with coverage",
+		"2 / 2",
+		"dd-trace@",
+		`href="intake/"`,
+		`href="test-output.txt"`,
+		`<article class="problem-card">`,
+	} {
+		if !strings.Contains(string(report), expected) {
+			t.Errorf("report does not contain %q", expected)
+		}
+	}
+	for _, hiddenCard := range []string{"Any tests failed?", "Any flaky tests?", "Any unusually broad test coverage?"} {
+		if strings.Contains(string(report), hiddenCard) {
+			t.Errorf("report contains no-problem card %q", hiddenCard)
+		}
+	}
 	for _, environmentVariable := range []string{
 		"DD_CIVISIBILITY_ITR_ENABLED",
 		"DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED",
@@ -246,40 +329,76 @@ func TestRunReportsCapturedTestsAndCoverage(t *testing.T) {
 }
 
 func TestRunStillReportsEventsWhenJestFails(t *testing.T) {
-	repositoryRoot := t.TempDir()
-	writeJestManifest(t, repositoryRoot)
-	t.Chdir(repositoryRoot)
-	testdrive, err := Prepare("latest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testdrive.platform = &fakeTracer{preloadPath: "/tmp/dd-trace/ci/init.js"}
-	testdrive.executor = &fakeTestdriveExecutor{output: []byte("FAIL one.test.js\n"), err: errors.New("exit status 1")}
-	testdrive.startIntake = func(string) (localIntake, error) {
-		return &fakeIntake{
-			url: "http://127.0.0.1:1234",
-			findings: intake.Facts{
-				TestCount:      1,
-				TestEventCount: 1,
-				FailedTests: []intake.Test{{
-					Name: "fails", Suite: "one.test.js", Status: "fail",
-					Attempts: []intake.TestRun{{Status: "fail", Duration: time.Millisecond}},
-				}},
-			},
-		}, nil
-	}
-
-	var output bytes.Buffer
-	err = testdrive.Run(t.Context(), &output)
-	if err == nil || !strings.Contains(err.Error(), "jest failed after sending 1 test event") {
-		t.Fatalf("Run() error = %v", err)
-	}
-	if !strings.Contains(output.String(), "Test events received.") {
-		t.Fatalf("Run() did not report working instrumentation:\n%s", output.String())
-	}
-	if !strings.Contains(output.String(), "Failed tests (1):") || !strings.Contains(output.String(), "one.test.js › fails · Fail · 1ms") || !strings.Contains(output.String(), "Jest: Failed") {
-		t.Fatalf("Run() did not report the failure and report link:\n%s", output.String())
+	for _, tc := range []struct {
+		name   string
+		output string
+		events int
+		want   string
+	}{
+		{name: "assertion failure", output: "FAIL one.test.js\nExpected: true\nReceived: false\n    at one.test.js:4:18\n", events: 1, want: "Expected: true\nReceived: false\n    at one.test.js:4:18"},
+		{name: "suite setup failure without failed events", output: "Cannot find module './missing' from 'setup.js'\n", events: 1363, want: "Cannot find module './missing'"},
+		{name: "no events", output: "SyntaxError: unexpected token in jest.config.js\n", want: "SyntaxError: unexpected token"},
+		{name: "empty output", events: 1, want: "The command produced no output."},
+		{name: "80 lines", output: strings.Repeat("log line\n", 79) + "final failure", events: 1, want: "final failure"},
+		{name: "long output", output: "initial failure\n" + strings.Repeat("log line\n", 79) + "final failure\n", events: 1, want: "... 1 line omitted; see the full test output below ..."},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			repositoryRoot := filepath.Join(t.TempDir(), "project space")
+			if err := os.Mkdir(repositoryRoot, 0755); err != nil {
+				t.Fatal(err)
+			}
+			writeJestManifest(t, repositoryRoot)
+			t.Chdir(repositoryRoot)
+			testdrive, err := Prepare("latest")
+			if err != nil {
+				t.Fatal(err)
+			}
+			installer := &fakeTracer{preloadPath: "/tmp/dd-trace/ci/init.js"}
+			testdrive.platform = installer
+			failure := errors.New("exit status 1")
+			testdrive.executor = &fakeTestdriveExecutor{output: []byte(tc.output), err: failure}
+			findings := intake.Facts{TestCount: tc.events, TestEventCount: tc.events}
+			if tc.name == "assertion failure" {
+				findings.FailedTests = []intake.Test{{Name: "fails", Suite: "one.test.js", Status: "fail", Attempts: []intake.TestRun{{Status: "fail", Duration: time.Millisecond}}}}
+			}
+			testdrive.startIntake = func(string) (localIntake, error) {
+				return &fakeIntake{url: "http://127.0.0.1:1234", findings: findings}, nil
+			}
+			var output bytes.Buffer
+			err = testdrive.Run(t.Context(), &output)
+			if !errors.Is(err, failure) {
+				t.Fatalf("Run() error = %v", err)
+			}
+			label := filepath.Join(".testoptimization", "testdrive", filepath.Base(installer.sessionDirectory), testOutputFilename)
+			for _, expected := range []string{"Jest command output:", tc.want, "Full test output: " + label, "Open report:"} {
+				if !strings.Contains(output.String(), expected) {
+					t.Errorf("missing %q in output:\n%s", expected, output.String())
+				}
+			}
+			if tc.events > 0 && !strings.Contains(output.String(), "Test events received.") {
+				t.Fatal(output.String())
+			}
+			if tc.name == "assertion failure" && !strings.Contains(output.String(), "one.test.js › fails · Fail · 1ms") {
+				t.Fatal(output.String())
+			}
+			if tc.name == "long output" {
+				if !strings.Contains(output.String(), "initial failure") || !strings.Contains(output.String(), "final failure") || strings.Count(output.String(), "log line") != 78 {
+					t.Fatal(output.String())
+				}
+			} else if strings.Contains(output.String(), "lines omitted") {
+				t.Fatal(output.String())
+			}
+			contents, err := os.ReadFile(label)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(contents) != tc.output {
+				t.Fatalf("saved output changed: %q", contents)
+			}
+			if strings.Contains(output.String(), "Full test output: "+repositoryRoot) {
+				t.Fatal("output path is absolute")
+			}
+		})
 	}
 }
 
@@ -500,7 +619,7 @@ func TestRunReportsProjectTracer(t *testing.T) {
 	if installer.options.Version != "git:ignored-for-existing-tracer" || installer.options.Command != drive.command {
 		t.Fatal(installer.options)
 	}
-	if !strings.Contains(output.String(), "Tracer: dd-trace · reused") {
+	if !strings.Contains(output.String(), "Datadog library: dd-trace · reused") {
 		t.Fatal(output.String())
 	}
 	if !strings.Contains(executor.env["NODE_OPTIONS"], installer.preloadPath) {
@@ -551,9 +670,13 @@ func TestPreviewChoosesTracerBeforeConfirmation(t *testing.T) {
 					t.Fatal(err)
 				}
 			} else {
-				if !strings.Contains(preview, "npm install --prefix "+drive.session.Directory()+" --global=false --no-save --package-lock=false --no-audit --no-fund dd-trace@6.15.0") {
+				directory := filepath.Join(".testoptimization", "testdrive", drive.session.ID())
+				if !strings.Contains(preview, "npm install --prefix "+directory+" --global=false --no-save --package-lock=false --no-audit --no-fund dd-trace@6.15.0") {
 					t.Fatal(preview)
 				}
+				if !slices.Contains(drive.installArgs, drive.session.Directory()) {
+					t.Fatalf("preview changed the actual installation path: %v", drive.installArgs)
+				}
 			}
 		})
 	}
diff --git a/main.go b/main.go
index 8c22910e..0d435b77 100644
--- a/main.go
+++ b/main.go
@@ -36,7 +36,7 @@ func run(execute func() error) int {
 	_ = os.Setenv("DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED", "0")
 
 	if err := execute(); err != nil {
-		slog.Error("FAILURE", "error", err)
+		// Cobra has already printed the error.
 		var exitErr *exec.ExitError
 		if errors.As(err, &exitErr) {
 			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok && status.Signaled() {
diff --git a/main_test.go b/main_test.go
index 8e98b85b..4e0cfd47 100644
--- a/main_test.go
+++ b/main_test.go
@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"runtime"
+	"strings"
 	"testing"
 )
 
@@ -70,3 +71,29 @@ func TestRunPreservesProcessSignal(t *testing.T) {
 		t.Fatalf("run() exit code = %d, want 143", code)
 	}
 }
+
+func TestCLIPrintsErrorsOnce(t *testing.T) {
+	if scenario := os.Getenv("DDTEST_ERROR_HELPER"); scenario != "" {
+		os.Args = []string{"ddtest", "testdrive", scenario}
+		os.Exit(run(executeCommand))
+	}
+	executable, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, scenario := range []string{"--unknown", "--yes"} {
+		t.Run(scenario, func(t *testing.T) {
+			command := exec.Command(executable, "-test.run=^TestCLIPrintsErrorsOnce$")
+			command.Dir = t.TempDir()
+			command.Env = append(os.Environ(), "DDTEST_ERROR_HELPER="+scenario)
+			output, err := command.CombinedOutput()
+			var exitErr *exec.ExitError
+			if !errors.As(err, &exitErr) || exitErr.ExitCode() != 1 {
+				t.Fatalf("error = %v, output = %s", err, output)
+			}
+			if strings.Count(string(output), "Error:") != 1 || strings.Contains(string(output), "FAILURE") {
+				t.Fatalf("expected one error, got:\n%s", output)
+			}
+		})
+	}
+}