diff --git a/cmd/stroppy/commands/help/topic_envs.go b/cmd/stroppy/commands/help/topic_envs.go
index f89477bd..f6b027b7 100644
--- a/cmd/stroppy/commands/help/topic_envs.go
+++ b/cmd/stroppy/commands/help/topic_envs.go
@@ -150,7 +150,18 @@ CONFIG FILE ALTERNATIVE
 
 DEBUG: TRACING ENV RESOLUTION
 
-  To see which env vars are applied and where they came from:
+  Normal run logs show -e/config env entries that were applied:
+
+    stroppy run tpcc/tx -e load_workers=8
+
+    INFO script_runner Applied script env {"source":"cli","env":["LOAD_WORKERS=8"]}
+
+  If an applied env key is not declared by the workload's ENV() calls, Stroppy
+  warns so typos are visible:
+
+    WARN script_runner Script env is not declared by workload {"keys":["LOAD_WROKERS"]}
+
+  To inspect skipped env entries and precedence decisions:
 
     LOG_LEVEL=debug stroppy run <script>
 
diff --git a/cmd/stroppy/commands/k6signals_test.go b/cmd/stroppy/commands/k6signals_test.go
index e9d38031..94c6cd28 100644
--- a/cmd/stroppy/commands/k6signals_test.go
+++ b/cmd/stroppy/commands/k6signals_test.go
@@ -8,6 +8,8 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"go.k6.io/k6/cmd/state"
+
+	"github.com/stroppy-io/stroppy/internal/runner"
 )
 
 func sendInt(t *testing.T) {
@@ -69,3 +71,22 @@ func TestInterceptMiddleware(_ *testing.T) {
 	// SignalStop should not panic and should clean up.
 	gs.SignalStop(ch)
 }
+
+func TestK6SubcommandScopesExitCapture(t *testing.T) {
+	called := false
+	gs := &state.GlobalState{OSExit: func(int) { called = true }}
+
+	K6Subcommand(gs)
+	gs.OSExit(1)
+	require.True(t, called)
+
+	called = false
+
+	stop := runner.BeginK6ExitCapture()
+	defer stop()
+
+	gs = &state.GlobalState{OSExit: func(int) { called = true }}
+	K6Subcommand(gs)
+	gs.OSExit(1)
+	require.False(t, called)
+}
diff --git a/cmd/stroppy/commands/root.go b/cmd/stroppy/commands/root.go
index d619d183..b2a7c9d4 100644
--- a/cmd/stroppy/commands/root.go
+++ b/cmd/stroppy/commands/root.go
@@ -85,7 +85,10 @@ func Root() *cobra.Command {
 
 func K6Subcommand(gs *state.GlobalState) *cobra.Command {
 	inteceptInteruptSignals(gs)
-	gs.OSExit = runner.OSExit // handles exit code
+
+	if runner.K6ExitCaptureEnabled() {
+		gs.OSExit = runner.OSExit
+	}
 
 	return rootCmd
 }
diff --git a/cmd/stroppy/commands/run/run.go b/cmd/stroppy/commands/run/run.go
index fbd7e6a0..3472784c 100644
--- a/cmd/stroppy/commands/run/run.go
+++ b/cmd/stroppy/commands/run/run.go
@@ -10,19 +10,31 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
+	"go.k6.io/k6/errext"
+	"go.k6.io/k6/errext/exitcodes"
 	"go.uber.org/zap"
 
 	"github.com/stroppy-io/stroppy/internal/runner"
 	"github.com/stroppy-io/stroppy/pkg/common/logger"
 )
 
-const consumedPairFlag = 2 // number of tokens consumed for a two-token flag (e.g. "-d pg")
+const (
+	consumedPairFlag = 2 // number of tokens consumed for a two-token flag (e.g. "-d pg")
+	flagSteps        = "--steps"
+	flagNoSteps      = "--no-steps"
+)
 
 var (
-	errNoScript          = errors.New("script argument is required")
-	errFlagRequiresValue = errors.New("flag requires a value")
-	errStepsMutExclusive = errors.New("--steps and --no-steps are mutually exclusive")
-	errBadKeyValue       = errors.New("expected key=value format")
+	errNoScript           = errors.New("script argument is required")
+	errFlagRequiresValue  = errors.New("flag requires a value")
+	errStepsMutExclusive  = errors.New("--steps and --no-steps are mutually exclusive")
+	errBadKeyValue        = errors.New("expected key=value format")
+	errUnknownRunFlag     = errors.New("unknown run flag")
+	errPositionalAfterOpt = errors.New("unexpected positional argument after options")
+	errKeyValuePositional = errors.New("unexpected key=value positional argument")
+	errTooManyPositionals = errors.New(
+		"too many positional arguments; expected script and optional sql_file before --",
+	)
 )
 
 var Cmd = &cobra.Command{
@@ -39,6 +51,7 @@ var Cmd = &cobra.Command{
 Files are searched in: current directory → ~/.stroppy/ → built-in workloads.
 SQL files are auto-derived from the preset/script name unless specified explicitly.
 See 'stroppy help resolution' for details on how files are found.
+The script and optional sql_file positionals must be adjacent before --.
 
 Environment flags:
   -e, --env KEY=VALUE     Set env var for the script (lowercase auto-uppercased)
@@ -81,13 +94,13 @@ Config file flags:
 
 		parsed, err := parseRunArgs(args)
 		if err != nil {
-			return err
+			return invalidConfig(err)
 		}
 
 		// Load config file if -f is specified or stroppy-config.json exists.
 		fileConfig, _, err := runner.LoadRunConfig(parsed.fileArg)
 		if err != nil {
-			return fmt.Errorf("failed to load config file: %w", err)
+			return invalidConfig(fmt.Errorf("failed to load config file: %w", err))
 		}
 
 		// Apply effective values: CLI overrides config file.
@@ -98,7 +111,7 @@ Config file flags:
 		k6RunArgs := runner.EffectiveK6Args(parsed.afterDash, fileConfig)
 
 		if scriptArg == "" {
-			return errNoScript
+			return invalidConfig(errNoScript)
 		}
 
 		// Log override decisions when both CLI and file config are present.
@@ -130,27 +143,29 @@ Config file flags:
 		// Resolve -e overrides (uppercase keys, validate format).
 		envOverrides, err := runner.ResolveEnvOverrides(parsed.envArgs)
 		if err != nil {
-			return err
+			return invalidConfig(err)
 		}
 
 		driverConfigs := runner.DriverCLIConfigs{}
 
 		for idx, presetName := range parsed.driverPresets {
 			if err := applyDriverPreset(driverConfigs, idx, presetName); err != nil {
-				return err
+				return invalidConfig(err)
 			}
 		}
 
 		for idx, opts := range parsed.driverOpts {
 			for _, kv := range opts {
-				applyDriverOpt(driverConfigs, idx, kv[0], kv[1])
+				if err := applyDriverOpt(driverConfigs, idx, kv[0], kv[1]); err != nil {
+					return invalidConfig(err)
+				}
 			}
 		}
 
 		// Resolve files through search path.
 		input, err := runner.ResolveInput(scriptArg, sqlArg)
 		if err != nil {
-			return fmt.Errorf("failed to resolve input: %w", err)
+			return invalidConfig(fmt.Errorf("failed to resolve input: %w", err))
 		}
 
 		scriptRunner, err := runner.NewScriptRunner(
@@ -163,7 +178,7 @@ Config file flags:
 			fileConfig,
 		)
 		if err != nil {
-			return fmt.Errorf("failed to create runner: %w", err)
+			return invalidConfig(fmt.Errorf("failed to create runner: %w", err))
 		}
 
 		err = scriptRunner.Run(context.Background())
@@ -181,6 +196,10 @@ Config file flags:
 	},
 }
 
+func invalidConfig(err error) error {
+	return errext.WithExitCodeIfNone(err, exitcodes.InvalidConfig)
+}
+
 // runArgs holds the result of parseRunArgs.
 type runArgs struct {
 	scriptArg     string
@@ -198,6 +217,14 @@ type runArgs struct {
 // Returns the number of tokens consumed, or 0 if the arg is not this flag.
 type flagParser func(args []string, i int, parsed *runArgs) (int, error)
 
+type positionalState int
+
+const (
+	beforePositionals positionalState = iota
+	inPositionals
+	afterPositionals
+)
+
 // parseRunArgs parses the raw CLI args (after cobra hands them to RunE) and
 // returns the structured result without performing any file or preset resolution.
 func parseRunArgs(args []string) (runArgs, error) {
@@ -219,30 +246,68 @@ func parseRunArgs(args []string) (runArgs, error) {
 		parseDriverFlags,
 	}
 
+	if err := parseRunArgsBeforeDash(positional, parsers, &parsed); err != nil {
+		return runArgs{}, err
+	}
+
+	if len(parsed.steps) > 0 && len(parsed.noSteps) > 0 {
+		return runArgs{}, errStepsMutExclusive
+	}
+
+	return parsed, nil
+}
+
+func parseRunArgsBeforeDash(positional []string, parsers []flagParser, parsed *runArgs) error {
+	state := beforePositionals
+
 	for i := 0; i < len(positional); i++ {
-		consumed, err := dispatchFlag(parsers, positional, i, &parsed)
+		consumed, err := dispatchFlag(parsers, positional, i, parsed)
 		if err != nil {
-			return runArgs{}, err
+			return err
 		}
 
 		if consumed > 0 {
+			if state == inPositionals {
+				state = afterPositionals
+			}
+
 			i += consumed - 1
 
 			continue
 		}
 
-		if parsed.scriptArg == "" {
-			parsed.scriptArg = positional[i]
-		} else {
-			parsed.sqlArg = positional[i]
+		state, err = applyPositionalArg(positional[i], state, parsed)
+		if err != nil {
+			return err
 		}
 	}
 
-	if len(parsed.steps) > 0 && len(parsed.noSteps) > 0 {
-		return runArgs{}, errStepsMutExclusive
+	return nil
+}
+
+func applyPositionalArg(arg string, state positionalState, parsed *runArgs) (positionalState, error) {
+	if strings.HasPrefix(arg, "-") && arg != "-" {
+		return state, fmt.Errorf("%w %q; pass k6 flags after --", errUnknownRunFlag, arg)
 	}
 
-	return parsed, nil
+	if state == afterPositionals {
+		return state, positionalAfterOptionsError(arg)
+	}
+
+	if isKeyValuePositional(arg) {
+		return state, keyValuePositionalError(arg)
+	}
+
+	switch {
+	case parsed.scriptArg == "":
+		parsed.scriptArg = arg
+	case parsed.sqlArg == "":
+		parsed.sqlArg = arg
+	default:
+		return state, fmt.Errorf("%w: %q", errTooManyPositionals, arg)
+	}
+
+	return inPositionals, nil
 }
 
 // dispatchFlag tries each parser in order until one consumes the arg at
@@ -268,13 +333,14 @@ func parseStepsFlag(args []string, i int, parsed *runArgs) (int, error) {
 	arg := args[i]
 
 	switch {
-	case arg == "--steps" || arg == "--no-steps":
-		if i+1 >= len(args) {
-			return 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+	case arg == flagSteps || arg == flagNoSteps:
+		value, err := nextFlagValue(args, i)
+		if err != nil {
+			return 0, err
 		}
 
-		vals := strings.Split(args[i+1], ",")
-		if arg == "--steps" {
+		vals := strings.Split(value, ",")
+		if arg == flagSteps {
 			parsed.steps = append(parsed.steps, vals...)
 		} else {
 			parsed.noSteps = append(parsed.noSteps, vals...)
@@ -282,13 +348,13 @@ func parseStepsFlag(args []string, i int, parsed *runArgs) (int, error) {
 
 		return consumedPairFlag, nil
 
-	case strings.HasPrefix(arg, "--steps="):
-		parsed.steps = append(parsed.steps, strings.Split(strings.TrimPrefix(arg, "--steps="), ",")...)
+	case strings.HasPrefix(arg, flagSteps+"="):
+		parsed.steps = append(parsed.steps, strings.Split(strings.TrimPrefix(arg, flagSteps+"="), ",")...)
 
 		return 1, nil
 
-	case strings.HasPrefix(arg, "--no-steps="):
-		parsed.noSteps = append(parsed.noSteps, strings.Split(strings.TrimPrefix(arg, "--no-steps="), ",")...)
+	case strings.HasPrefix(arg, flagNoSteps+"="):
+		parsed.noSteps = append(parsed.noSteps, strings.Split(strings.TrimPrefix(arg, flagNoSteps+"="), ",")...)
 
 		return 1, nil
 	}
@@ -303,11 +369,12 @@ func parseFileFlag(args []string, i int, parsed *runArgs) (int, error) {
 
 	switch {
 	case arg == "-f" || arg == "--file":
-		if i+1 >= len(args) {
-			return 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+		value, err := nextFlagValue(args, i)
+		if err != nil {
+			return 0, err
 		}
 
-		parsed.fileArg = args[i+1]
+		parsed.fileArg = value
 
 		return consumedPairFlag, nil
 
@@ -332,11 +399,12 @@ func parseEnvFlag(args []string, i int, parsed *runArgs) (int, error) {
 
 	switch {
 	case arg == "-e" || arg == "--env":
-		if i+1 >= len(args) {
-			return 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+		value, err := nextFlagValue(args, i)
+		if err != nil {
+			return 0, err
 		}
 
-		parsed.envArgs = append(parsed.envArgs, args[i+1])
+		parsed.envArgs = append(parsed.envArgs, value)
 
 		return consumedPairFlag, nil
 
@@ -397,11 +465,12 @@ func parseFlagNextArg(
 
 	for _, prefix := range []string{shortPrefix, longPrefix} {
 		if idx, ok := parseShortFlag(arg, prefix); ok {
-			if i+1 >= len(args) {
-				return 0, "", 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+			next, err := nextFlagValue(args, i)
+			if err != nil {
+				return 0, "", 0, err
 			}
 
-			return idx, args[i+1], consumedPairFlag, nil
+			return idx, next, consumedPairFlag, nil
 		}
 	}
 
@@ -472,13 +541,14 @@ func parseDriverOptFlag(args []string, i int) (driverIndex int, key, value strin
 
 	// -D / -D0 / -D1 (short form, two tokens)
 	if idx, ok := parseShortFlag(arg, "-D"); ok {
-		if i+1 >= len(args) {
-			return 0, "", "", 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+		raw, err := nextFlagValue(args, i)
+		if err != nil {
+			return 0, "", "", 0, err
 		}
 
-		key, value, err = splitKeyValue(args[i+1])
+		key, value, err = splitKeyValue(raw)
 		if err != nil {
-			return 0, "", "", 0, fmt.Errorf("%s %s: %w", arg, args[i+1], err)
+			return 0, "", "", 0, fmt.Errorf("%s %s: %w", arg, raw, err)
 		}
 
 		return idx, key, value, consumedPairFlag, nil
@@ -486,13 +556,14 @@ func parseDriverOptFlag(args []string, i int) (driverIndex int, key, value strin
 
 	// --driver-opt / --driver1-opt / --driver0-opt (long form, two tokens)
 	if idx, ok := parseIndexedInfixFlag(arg, "--driver", "-opt"); ok {
-		if i+1 >= len(args) {
-			return 0, "", "", 0, fmt.Errorf("%s: %w", arg, errFlagRequiresValue)
+		raw, err := nextFlagValue(args, i)
+		if err != nil {
+			return 0, "", "", 0, err
 		}
 
-		key, value, err = splitKeyValue(args[i+1])
+		key, value, err = splitKeyValue(raw)
 		if err != nil {
-			return 0, "", "", 0, fmt.Errorf("%s %s: %w", arg, args[i+1], err)
+			return 0, "", "", 0, fmt.Errorf("%s %s: %w", arg, raw, err)
 		}
 
 		return idx, key, value, consumedPairFlag, nil
@@ -619,6 +690,55 @@ func splitKeyValue(s string) (key, val string, err error) {
 	return key, val, nil
 }
 
+func positionalAfterOptionsError(arg string) error {
+	message := "script and sql_file must be adjacent before --"
+	if strings.Contains(arg, "=") {
+		message += "; quote driver/env values that contain spaces"
+	}
+
+	return fmt.Errorf("%w: %q; %s", errPositionalAfterOpt, arg, message)
+}
+
+func keyValuePositionalError(arg string) error {
+	return fmt.Errorf(
+		"%w: %q; key=value arguments must follow -D/--driver-opt or -e/--env; quote values that contain spaces",
+		errKeyValuePositional,
+		arg,
+	)
+}
+
+func isKeyValuePositional(arg string) bool {
+	key, _, ok := strings.Cut(arg, "=")
+	if !ok || key == "" || strings.ContainsAny(arg, " \t\n") {
+		return false
+	}
+
+	for _, r := range key {
+		if r == '_' || r == '-' || r == '.' || r >= '0' && r <= '9' ||
+			r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' {
+			continue
+		}
+
+		return false
+	}
+
+	return true
+}
+
+func nextFlagValue(args []string, i int) (string, error) {
+	flag := args[i]
+	if i+1 >= len(args) {
+		return "", fmt.Errorf("%s: %w", flag, errFlagRequiresValue)
+	}
+
+	next := args[i+1]
+	if strings.HasPrefix(next, "-") && next != "-" {
+		return "", fmt.Errorf("%s: %w", flag, errFlagRequiresValue)
+	}
+
+	return next, nil
+}
+
 // applyDriverPreset loads a preset or parses raw JSON and sets it on the config map.
 // If the value starts with '{', it's treated as a JSON driver config; otherwise as a preset name.
 func applyDriverPreset(configs runner.DriverCLIConfigs, idx int, value string) error {
@@ -645,12 +765,12 @@ func applyDriverPreset(configs runner.DriverCLIConfigs, idx int, value string) e
 }
 
 // applyDriverOpt applies a -D key=value override to the driver at the given index.
-func applyDriverOpt(configs runner.DriverCLIConfigs, idx int, key, value string) {
+func applyDriverOpt(configs runner.DriverCLIConfigs, idx int, key, value string) error {
 	cfg, ok := configs[idx]
 	if !ok {
 		cfg = &runner.DriverCLIConfig{}
 		configs[idx] = cfg
 	}
 
-	cfg.ApplyOverride(key, value)
+	return cfg.ApplyOverride(key, value)
 }
diff --git a/cmd/stroppy/commands/run/run_test.go b/cmd/stroppy/commands/run/run_test.go
index 40c9b80c..794ec511 100644
--- a/cmd/stroppy/commands/run/run_test.go
+++ b/cmd/stroppy/commands/run/run_test.go
@@ -1,6 +1,7 @@
 package run
 
 import (
+	"encoding/json"
 	"errors"
 	"os"
 	"testing"
@@ -50,6 +51,22 @@ func TestParseRunArgs(t *testing.T) {
 			wantScript: "./benchmarks/custom.ts",
 			wantSQL:    "data.sql",
 		},
+		{
+			name:       "third positional returns error",
+			args:       []string{"tpcc", "pg.sql", "extra.sql"},
+			wantErrStr: "too many positional arguments",
+		},
+		{
+			name:       "unknown flag before separator returns error",
+			args:       []string{"tpcc", "--vus", "10"},
+			wantErrStr: "pass k6 flags after --",
+		},
+		{
+			name:        "inline SQL query with spaces and equals is single positional",
+			args:        []string{"select a=1", "-d", "pg"},
+			wantScript:  "select a=1",
+			wantPresets: map[int]string{0: "pg"},
+		},
 
 		// ── Missing script ─────────────────────────────────────────────────
 		{
@@ -82,6 +99,23 @@ func TestParseRunArgs(t *testing.T) {
 			args:     []string{"-f", "myconfig.json"},
 			wantFile: "myconfig.json",
 		},
+		{
+			name:       "-f followed by driver flag returns missing value",
+			args:       []string{"-f", "-d", "pg"},
+			wantErrStr: "-f: flag requires a value",
+		},
+
+		// ── -e / --env ─────────────────────────────────────────────────────
+		{
+			name:       "-e accepts values starting with dash after equals",
+			args:       []string{"tpcc", "-e", "TOKEN=-abc"},
+			wantScript: "tpcc",
+		},
+		{
+			name:       "-e followed by steps flag returns missing value",
+			args:       []string{"tpcc", "-e", "--steps", "load"},
+			wantErrStr: "-e: flag requires a value",
+		},
 
 		// ── --steps / --no-steps ───────────────────────────────────────────
 		{
@@ -123,6 +157,16 @@ func TestParseRunArgs(t *testing.T) {
 			args:       []string{"tpcc", "--no-steps"},
 			wantErrStr: "flag requires a value",
 		},
+		{
+			name:       "--steps followed by known flag returns missing value",
+			args:       []string{"tpcc", "--steps", "-d", "pg"},
+			wantErrStr: "--steps: flag requires a value",
+		},
+		{
+			name:       "--steps followed by unknown flag returns missing value",
+			args:       []string{"tpcc", "--steps", "--vus", "10"},
+			wantErrStr: "--steps: flag requires a value",
+		},
 
 		// ── Driver preset flags ────────────────────────────────────────────
 		{
@@ -183,6 +227,16 @@ func TestParseRunArgs(t *testing.T) {
 			args:       []string{"tpcc", "--driver"},
 			wantErrStr: "flag requires a value",
 		},
+		{
+			name:       "-d followed by driver option flag returns missing value",
+			args:       []string{"tpcc", "-d", "-D", "url=postgres://prod"},
+			wantErrStr: "-d: flag requires a value",
+		},
+		{
+			name:       "--driver followed by steps flag returns missing value",
+			args:       []string{"tpcc", "--driver", "--steps", "load"},
+			wantErrStr: "--driver: flag requires a value",
+		},
 		{
 			name:        "two drivers -d and -d1",
 			args:        []string{"tpcc", "-d", "pg", "-d1", "mysql"},
@@ -197,6 +251,16 @@ func TestParseRunArgs(t *testing.T) {
 			wantScript: "tpcc",
 			wantOpts:   map[int][][2]string{0: {{"url", "postgres://prod:5432"}}},
 		},
+		{
+			name:       "unquoted driver value fragment returns quote hint",
+			args:       []string{"tpcc", "-D", "url=host=localhost", "user=postgres"},
+			wantErrStr: "quote driver/env values",
+		},
+		{
+			name:       "unquoted driver value fragment before script returns key value hint",
+			args:       []string{"-D", "url=host=localhost", "user=postgres", "tpcc"},
+			wantErrStr: "key=value arguments must follow",
+		},
 		{
 			name:       "-D1 key=value",
 			args:       []string{"tpcc", "-D1", "url=mysql://prod:3306"},
@@ -257,6 +321,11 @@ func TestParseRunArgs(t *testing.T) {
 			args:       []string{"tpcc", "--driver-opt"},
 			wantErrStr: "flag requires a value",
 		},
+		{
+			name:       "--driver-opt followed by steps flag returns missing value",
+			args:       []string{"tpcc", "--driver-opt", "--steps", "load"},
+			wantErrStr: "--driver-opt: flag requires a value",
+		},
 		{
 			name:       "-D value without = returns error",
 			args:       []string{"tpcc", "-D", "noequals"},
@@ -298,6 +367,19 @@ func TestParseRunArgs(t *testing.T) {
 			wantSteps:     []string{"load", "run"},
 			wantAfterDash: []string{"--duration", "5m"},
 		},
+		{
+			name:        "flags may wrap adjacent script sql block",
+			args:        []string{"-f", "prod.json", "tpcc", "tpcc/pico", "-d", "pico"},
+			wantScript:  "tpcc",
+			wantSQL:     "tpcc/pico",
+			wantFile:    "prod.json",
+			wantPresets: map[int]string{0: "pico"},
+		},
+		{
+			name:       "positional after option following script returns adjacency error",
+			args:       []string{"tpcc", "-d", "pg", "tpcc/pico"},
+			wantErrStr: "script and sql_file must be adjacent",
+		},
 		{
 			name:        "script + sql + two drivers + driver opt",
 			args:        []string{"tpcc", "tpcc-scale-100", "-d", "pg", "-d1", "mysql", "-D1", "url=mysql://prod"},
@@ -496,6 +578,110 @@ func TestApplyDriverPresetInvalidJSON(t *testing.T) {
 	}
 }
 
+func TestApplyDriverOptDottedPool(t *testing.T) {
+	t.Parallel()
+
+	configs := runner.DriverCLIConfigs{}
+
+	if err := applyDriverOpt(configs, 0, "pool.maxConns", "20"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := applyDriverOpt(configs, 0, "pool.maxConnLifetime", "30m"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := marshalDriverConfig(t, configs[0])
+	pool := objectField(t, got, "pool")
+
+	if pool["maxConns"] != float64(20) {
+		t.Errorf("pool.maxConns: got %v, want 20", pool["maxConns"])
+	}
+
+	if pool["maxConnLifetime"] != "30m" {
+		t.Errorf("pool.maxConnLifetime: got %v, want 30m", pool["maxConnLifetime"])
+	}
+}
+
+func TestApplyDriverOptDottedPoolMergesJSONPreset(t *testing.T) {
+	t.Parallel()
+
+	configs := runner.DriverCLIConfigs{}
+
+	if err := applyDriverPreset(configs, 0, `{"driverType":"postgres","pool":{"minConns":5}}`); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := applyDriverOpt(configs, 0, "pool.maxConns", "20"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := marshalDriverConfig(t, configs[0])
+	pool := objectField(t, got, "pool")
+
+	if pool["minConns"] != float64(5) {
+		t.Errorf("pool.minConns: got %v, want 5", pool["minConns"])
+	}
+
+	if pool["maxConns"] != float64(20) {
+		t.Errorf("pool.maxConns: got %v, want 20", pool["maxConns"])
+	}
+}
+
+func TestApplyDriverOptDottedPoolUnknownField(t *testing.T) {
+	t.Parallel()
+
+	configs := runner.DriverCLIConfigs{}
+
+	if err := applyDriverOpt(configs, 0, "pool.maximum", "20"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := marshalDriverConfig(t, configs[0])
+	pool := objectField(t, got, "pool")
+
+	if pool["maximum"] != float64(20) {
+		t.Errorf("pool.maximum: got %v, want 20", pool["maximum"])
+	}
+}
+
+func TestApplyDriverOptDottedPathIsGeneric(t *testing.T) {
+	t.Parallel()
+
+	configs := runner.DriverCLIConfigs{}
+
+	if err := applyDriverOpt(configs, 0, "custom.deep.value", "1"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	got := marshalDriverConfig(t, configs[0])
+	custom := objectField(t, got, "custom")
+	deep := objectField(t, custom, "deep")
+
+	if deep["value"] != float64(1) {
+		t.Errorf("custom.deep.value: got %v, want 1", deep["value"])
+	}
+}
+
+func TestApplyDriverOptDottedPathConflict(t *testing.T) {
+	t.Parallel()
+
+	configs := runner.DriverCLIConfigs{}
+
+	if err := applyDriverOpt(configs, 0, "pool", "not-object"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	err := applyDriverOpt(configs, 0, "pool.maxConns", "20")
+	if err == nil {
+		t.Fatal("expected structural conflict error")
+	}
+
+	if !contains(err.Error(), "conflicts") {
+		t.Fatalf("got error %q, want conflict", err.Error())
+	}
+}
+
 func TestToEnvVarsRespectsExistingEnv(t *testing.T) {
 	t.Setenv("STROPPY_DRIVER_0", `{"url":"from-env"}`)
 
@@ -533,6 +719,38 @@ func TestToEnvVarsSetsWhenNotInEnv(t *testing.T) {
 	}
 }
 
+func marshalDriverConfig(t *testing.T, cfg *runner.DriverCLIConfig) map[string]any {
+	t.Helper()
+
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("marshal driver config: %v", err)
+	}
+
+	var got map[string]any
+	if err := json.Unmarshal(data, &got); err != nil {
+		t.Fatalf("unmarshal driver config: %v", err)
+	}
+
+	return got
+}
+
+func objectField(t *testing.T, m map[string]any, key string) map[string]any {
+	t.Helper()
+
+	raw, ok := m[key]
+	if !ok {
+		t.Fatalf("missing object field %q in %#v", key, m)
+	}
+
+	obj, ok := raw.(map[string]any)
+	if !ok {
+		t.Fatalf("field %q has type %T, want object", key, raw)
+	}
+
+	return obj
+}
+
 func driverOptMapsEqual(a, b map[int][][2]string) bool {
 	if len(a) == 0 && len(b) == 0 {
 		return true
diff --git a/cmd/xk6air/driver_wrapper.go b/cmd/xk6air/driver_wrapper.go
index 8d1492ca..d5821ef8 100644
--- a/cmd/xk6air/driver_wrapper.go
+++ b/cmd/xk6air/driver_wrapper.go
@@ -102,14 +102,18 @@ func (d *DriverWrapper) InsertSpecBin(specBin []byte) (*stats.Query, error) {
 
 // Begin starts a new transaction with the given isolation level.
 // isolationLevel maps to proto TxIsolationLevel int32 values.
-func (d *DriverWrapper) Begin(isolationLevel int32) (*TxWrapper, error) {
+func (d *DriverWrapper) Begin(isolationLevel int32, txName ...string) (*TxWrapper, error) {
 	d.ensureReady()
 
 	level := stroppy.TxIsolationLevel(isolationLevel)
+	name := ""
+	if len(txName) > 0 {
+		name = txName[0]
+	}
 
 	// NONE mode: no actual transaction, delegate to driver.RunQuery
 	if level == stroppy.TxIsolationLevel_NONE {
-		return &TxWrapper{tx: nil, drv: d, vu: d.vu}, nil
+		return &TxWrapper{tx: nil, drv: d, vu: d.vu, isolation: level, name: name}, nil
 	}
 
 	tx, err := d.drv.Begin(d.vu.Context(), level)
@@ -117,15 +121,17 @@ func (d *DriverWrapper) Begin(isolationLevel int32) (*TxWrapper, error) {
 		return nil, fmt.Errorf("error starting transaction: %w", err)
 	}
 
-	return &TxWrapper{tx: tx, drv: d, vu: d.vu}, nil
+	return &TxWrapper{tx: tx, drv: d, vu: d.vu, isolation: level, name: name}, nil
 }
 
 // TxWrapper wraps a driver.Tx for JS exposure.
 // For NONE mode, tx is nil and queries delegate to the parent driver.
 type TxWrapper struct {
-	tx  driver.Tx
-	drv *DriverWrapper
-	vu  modules.VU
+	tx        driver.Tx
+	drv       *DriverWrapper
+	vu        modules.VU
+	isolation stroppy.TxIsolationLevel
+	name      string
 }
 
 func (t *TxWrapper) RunQuery(sql string, args map[string]any) (*driver.QueryResult, error) {
@@ -143,17 +149,23 @@ func (t *TxWrapper) RunQuery(sql string, args map[string]any) (*driver.QueryResu
 }
 
 func (t *TxWrapper) Commit() error {
-	if t.tx == nil {
-		return nil
+	if t.tx != nil {
+		if err := t.tx.Commit(t.vu.Context()); err != nil {
+			return err
+		}
 	}
 
-	return t.tx.Commit(t.vu.Context())
+	rootModule.txMetrics.record(t.vu, "commit", t.name, t.isolation)
+	return nil
 }
 
 func (t *TxWrapper) Rollback() error {
-	if t.tx == nil {
-		return nil
+	if t.tx != nil {
+		if err := t.tx.Rollback(t.vu.Context()); err != nil {
+			return err
+		}
 	}
 
-	return t.tx.Rollback(t.vu.Context())
+	rootModule.txMetrics.record(t.vu, "rollback", t.name, t.isolation)
+	return nil
 }
diff --git a/cmd/xk6air/go.mod b/cmd/xk6air/go.mod
index 9466f4b6..1d2bf05e 100644
--- a/cmd/xk6air/go.mod
+++ b/cmd/xk6air/go.mod
@@ -94,6 +94,7 @@ require (
 	github.com/tidwall/pretty v1.2.1 // indirect
 	github.com/ydb-platform/ydb-go-genproto v0.0.0-20260311095541-ebbf792c1180 // indirect
 	github.com/ydb-platform/ydb-go-sdk/v3 v3.134.1 // indirect
+	github.com/ydb-platform/ydb-go-yc-metadata v0.6.1 // indirect
 	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
 	go.opentelemetry.io/otel v1.38.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 // indirect
diff --git a/cmd/xk6air/go.sum b/cmd/xk6air/go.sum
index c623ccd9..633dbf72 100644
--- a/cmd/xk6air/go.sum
+++ b/cmd/xk6air/go.sum
@@ -427,6 +427,8 @@ github.com/ydb-platform/ydb-go-genproto v0.0.0-20260311095541-ebbf792c1180 h1:av
 github.com/ydb-platform/ydb-go-genproto v0.0.0-20260311095541-ebbf792c1180/go.mod h1:Er+FePu1dNUieD+XTMDduGpQuCPssK5Q4BjF+IIXJ3I=
 github.com/ydb-platform/ydb-go-sdk/v3 v3.134.1 h1:uMcpCjrRrq3xTZLYJ7N0wbTKdzYu5OtR7giHnrRsNK8=
 github.com/ydb-platform/ydb-go-sdk/v3 v3.134.1/go.mod h1:VYUUkRJkKuQPkIpgtZJj6+58Fa2g8ccAqdmaaK6HP5k=
+github.com/ydb-platform/ydb-go-yc-metadata v0.6.1 h1:9E5q8Nsy2RiJMZDNVy0A3KUrIMBPakJ2VgloeWbcI84=
+github.com/ydb-platform/ydb-go-yc-metadata v0.6.1/go.mod h1:NW4LXW2WhY2tLAwCBHBuHAwRUVF5lsscaSPjdAFKldc=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
diff --git a/cmd/xk6air/metrics.go b/cmd/xk6air/metrics.go
new file mode 100644
index 00000000..76235b22
--- /dev/null
+++ b/cmd/xk6air/metrics.go
@@ -0,0 +1,213 @@
+package xk6air
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/stroppy-io/stroppy/pkg/common/proto/stroppy"
+	"go.k6.io/k6/js/modules"
+	k6metrics "go.k6.io/k6/metrics"
+	"go.uber.org/zap"
+)
+
+const txTPSInterval = time.Second
+
+type txMetrics struct {
+	mu sync.Mutex
+
+	txCount *k6metrics.Metric
+	txTPS   *k6metrics.Metric
+	tags    *k6metrics.TagSet
+
+	total uint64
+
+	started bool
+	stopped bool
+	stopCh  chan struct{}
+	doneCh  chan struct{}
+}
+
+func (m *txMetrics) ensureRegistered(vu modules.VU, lg *zap.Logger) {
+	initEnv := vu.InitEnv()
+	if initEnv == nil {
+		return
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.txCount != nil && m.txTPS != nil {
+		return
+	}
+
+	registry := initEnv.Registry
+	txCount, err := registry.NewMetric("tx_count", k6metrics.Counter)
+	if err != nil {
+		lg.Fatal("can't register tx_count metric", zap.Error(err))
+	}
+	txTPS, err := registry.NewMetric("tx_tps", k6metrics.Trend)
+	if err != nil {
+		lg.Fatal("can't register tx_tps metric", zap.Error(err))
+	}
+
+	m.txCount = txCount
+	m.txTPS = txTPS
+	m.tags = registry.RootTagSet()
+}
+
+func (m *txMetrics) record(vu modules.VU, action, name string, isolation stroppy.TxIsolationLevel) {
+	m.ensureRegistered(vu, rootModule.lg)
+
+	state := vu.State()
+	if state == nil {
+		return
+	}
+
+	m.start(state.Samples, rootModule.ctx)
+	atomic.AddUint64(&m.total, 1)
+
+	txCount, tags, ok := m.snapshotCountMetric()
+	if !ok {
+		return
+	}
+	now := time.Now()
+	tags = tags.With("tx_action", action)
+	if name != "" {
+		tags = tags.With("tx_name", name)
+	}
+	if iso := txIsolationName(isolation); iso != "" {
+		tags = tags.With("tx_isolation", iso)
+	}
+
+	k6metrics.PushIfNotDone(vu.Context(), state.Samples, k6metrics.Sample{
+		TimeSeries: k6metrics.TimeSeries{
+			Metric: txCount,
+			Tags:   tags,
+		},
+		Time:  now,
+		Value: 1,
+	})
+}
+
+func (m *txMetrics) start(samples chan<- k6metrics.SampleContainer, ctx context.Context) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.started || m.stopped || m.txTPS == nil || m.tags == nil {
+		return
+	}
+
+	m.started = true
+	m.stopCh = make(chan struct{})
+	m.doneCh = make(chan struct{})
+	go m.runSampler(ctx, samples, m.txTPS, m.tags, m.stopCh, m.doneCh)
+}
+
+func (m *txMetrics) stop() {
+	m.mu.Lock()
+	if !m.started || m.stopped {
+		m.mu.Unlock()
+		return
+	}
+	stopCh := m.stopCh
+	doneCh := m.doneCh
+	m.stopped = true
+	close(stopCh)
+	m.mu.Unlock()
+
+	select {
+	case <-doneCh:
+	case <-time.After(2 * time.Second):
+	}
+}
+
+func (m *txMetrics) snapshotCountMetric() (*k6metrics.Metric, *k6metrics.TagSet, bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.txCount == nil || m.tags == nil {
+		return nil, nil, false
+	}
+	return m.txCount, m.tags, true
+}
+
+func (m *txMetrics) runSampler(
+	ctx context.Context,
+	samples chan<- k6metrics.SampleContainer,
+	metric *k6metrics.Metric,
+	tags *k6metrics.TagSet,
+	stopCh <-chan struct{},
+	doneCh chan<- struct{},
+) {
+	defer close(doneCh)
+
+	ticker := time.NewTicker(txTPSInterval)
+	defer ticker.Stop()
+
+	prevTotal := atomic.LoadUint64(&m.total)
+	prevTime := time.Now()
+
+	for {
+		select {
+		case now := <-ticker.C:
+			prevTotal, prevTime = m.emitTPS(ctx, samples, metric, tags, prevTotal, prevTime, now, true)
+		case <-stopCh:
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (m *txMetrics) emitTPS(
+	ctx context.Context,
+	samples chan<- k6metrics.SampleContainer,
+	metric *k6metrics.Metric,
+	tags *k6metrics.TagSet,
+	prevTotal uint64,
+	prevTime time.Time,
+	now time.Time,
+	emitZero bool,
+) (uint64, time.Time) {
+	elapsed := now.Sub(prevTime)
+	if elapsed <= 0 {
+		return prevTotal, prevTime
+	}
+
+	total := atomic.LoadUint64(&m.total)
+	delta := total - prevTotal
+	if delta == 0 && !emitZero {
+		return total, now
+	}
+
+	k6metrics.PushIfNotDone(ctx, samples, k6metrics.Sample{
+		TimeSeries: k6metrics.TimeSeries{
+			Metric: metric,
+			Tags:   tags,
+		},
+		Time:  now,
+		Value: float64(delta) / elapsed.Seconds(),
+	})
+
+	return total, now
+}
+
+func txIsolationName(isolation stroppy.TxIsolationLevel) string {
+	switch isolation {
+	case stroppy.TxIsolationLevel_UNSPECIFIED:
+		return "db_default"
+	case stroppy.TxIsolationLevel_READ_UNCOMMITTED:
+		return "read_uncommitted"
+	case stroppy.TxIsolationLevel_READ_COMMITTED:
+		return "read_committed"
+	case stroppy.TxIsolationLevel_REPEATABLE_READ:
+		return "repeatable_read"
+	case stroppy.TxIsolationLevel_SERIALIZABLE:
+		return "serializable"
+	case stroppy.TxIsolationLevel_CONNECTION_ONLY:
+		return "conn"
+	case stroppy.TxIsolationLevel_NONE:
+		return "none"
+	default:
+		return ""
+	}
+}
diff --git a/cmd/xk6air/module.go b/cmd/xk6air/module.go
index 092edd00..f07aaa2c 100644
--- a/cmd/xk6air/module.go
+++ b/cmd/xk6air/module.go
@@ -37,6 +37,7 @@ func init() {
 		instanceTeardown: make(map[*Instance]func() error),
 		sharedSlots:      make(map[uint64]*sharedDriverSlot),
 		steps:            make(map[string]stroppy.StroppyRun_Status),
+		txMetrics:        &txMetrics{},
 	}
 
 	rootModule.runULID, rootModule.cloudClient = NewCloudClient(lg)
@@ -68,11 +69,14 @@ type RootModule struct {
 
 	stepsMu sync.Mutex
 	steps   map[string]stroppy.StroppyRun_Status
+
+	txMetrics *txMetrics
 }
 
 // NewModuleInstance factory method for Instances.
 // One instance creates per VU.
 func (r *RootModule) NewModuleInstance(vu modules.VU) modules.Instance {
+	r.txMetrics.ensureRegistered(vu, r.lg)
 	return NewInstance(vu)
 }
 
@@ -133,6 +137,8 @@ func (r *RootModule) initSharedDriver(
 }
 
 func (r *RootModule) Teardown() error {
+	r.txMetrics.stop()
+
 	var err error
 	r.instanceMu.Lock()
 	for _, teardown := range r.instanceTeardown {
diff --git a/internal/runner/driver_preset.go b/internal/runner/driver_preset.go
index 7f773477..6edaaa6b 100644
--- a/internal/runner/driver_preset.go
+++ b/internal/runner/driver_preset.go
@@ -24,7 +24,17 @@ var pathFields = map[string]bool{
 	"cacertfile": true,
 }
 
-var errUnknownDriver = errors.New("unknown driver")
+var (
+	errUnknownDriver          = errors.New("unknown driver")
+	errInvalidDriverOverride  = errors.New("invalid driver override")
+	errDriverOverrideConflict = errors.New("driver override conflicts with existing non-object value")
+)
+
+const (
+	driverTypeKey          = "drivertype"
+	urlKey                 = "url"
+	defaultInsertMethodKey = "defaultinsertmethod"
+)
 
 // inferType converts a CLI string value to its most specific Go type
 // so that JSON serialization emits a number/bool instead of a quoted string.
@@ -151,27 +161,102 @@ func (d DriverCLIConfig) MarshalJSON() ([]byte, error) {
 
 // ApplyOverride sets a field by key=value. Known fields are set on the struct,
 // unknown fields go into Extra for pass-through to TS.
-func (d *DriverCLIConfig) ApplyOverride(key, value string) {
-	switch strings.ToLower(key) {
-	case "drivertype":
+func (d *DriverCLIConfig) ApplyOverride(key, value string) error {
+	if key == "" {
+		return fmt.Errorf("%w: empty key", errInvalidDriverOverride)
+	}
+
+	switch normalizeKey(key) {
+	case driverTypeKey:
 		d.DriverType = value
-	case "url":
+	case urlKey:
 		d.URL = value
-	case "defaultinsertmethod":
+	case defaultInsertMethodKey:
 		d.DefaultInsertMethod = value
 	default:
-		if d.Extra == nil {
-			d.Extra = make(map[string]any)
+		return d.setExtraPath(strings.Split(key, "."), convertOverrideValue(key, value))
+	}
+
+	return nil
+}
+
+func (d *DriverCLIConfig) setExtraPath(path []string, value any) error {
+	if err := validateOverridePath(path); err != nil {
+		return err
+	}
+
+	if d.Extra == nil {
+		d.Extra = make(map[string]any)
+	}
+
+	target := d.Extra
+	for _, part := range path[:len(path)-1] {
+		next, ok := target[part]
+		if !ok {
+			nested := make(map[string]any)
+			target[part] = nested
+			target = nested
+
+			continue
 		}
 
-		if pathFields[strings.ToLower(key)] {
-			if abs, err := filepath.Abs(value); err == nil {
-				value = abs
-			}
+		nested, ok := next.(map[string]any)
+		if !ok {
+			return fmt.Errorf("%w: %q", errDriverOverrideConflict, part)
+		}
+
+		target = nested
+	}
+
+	last := path[len(path)-1]
+	if existing, exists := target[last]; exists {
+		if _, isObject := existing.(map[string]any); isObject {
+			return fmt.Errorf("%w: %q", errDriverOverrideConflict, last)
 		}
+	}
+
+	target[last] = value
+
+	return nil
+}
+
+func validateOverridePath(path []string) error {
+	for _, part := range path {
+		if part == "" {
+			return fmt.Errorf("%w: empty dotted path segment", errInvalidDriverOverride)
+		}
+	}
+
+	if len(path) > 1 && isDriverCLIField(path[0]) {
+		return fmt.Errorf("%w: %q", errDriverOverrideConflict, path[0])
+	}
+
+	return nil
+}
+
+func isDriverCLIField(key string) bool {
+	switch normalizeKey(key) {
+	case driverTypeKey, urlKey, defaultInsertMethodKey:
+		return true
+	default:
+		return false
+	}
+}
 
-		d.Extra[key] = inferType(value)
+func convertOverrideValue(key, value string) any {
+	if pathFields[normalizeKey(key)] {
+		if abs, err := filepath.Abs(value); err == nil {
+			return abs
+		}
 	}
+
+	return inferType(value)
+}
+
+func normalizeKey(key string) string {
+	replacer := strings.NewReplacer("_", "", "-", "")
+
+	return strings.ToLower(replacer.Replace(key))
 }
 
 // NewDriverCLIConfigFromPreset creates a DriverCLIConfig from a preset.
@@ -196,19 +281,19 @@ func NewDriverCLIConfigFromJSON(raw string) (DriverCLIConfig, error) {
 	for field, val := range m {
 		str, _ := val.(string)
 
-		switch strings.ToLower(field) {
-		case "drivertype":
+		switch normalizeKey(field) {
+		case driverTypeKey:
 			cfg.DriverType = str
-		case "url":
+		case urlKey:
 			cfg.URL = str
-		case "defaultinsertmethod":
+		case defaultInsertMethodKey:
 			cfg.DefaultInsertMethod = str
 		default:
 			if cfg.Extra == nil {
 				cfg.Extra = make(map[string]any)
 			}
 
-			if pathFields[strings.ToLower(field)] {
+			if pathFields[normalizeKey(field)] {
 				if s, ok := val.(string); ok {
 					if abs, err := filepath.Abs(s); err == nil {
 						val = abs
diff --git a/internal/runner/env_log.go b/internal/runner/env_log.go
new file mode 100644
index 00000000..3e02b1cd
--- /dev/null
+++ b/internal/runner/env_log.go
@@ -0,0 +1,148 @@
+package runner
+
+import (
+	"sort"
+	"strings"
+
+	"go.uber.org/zap"
+)
+
+func (r *ScriptRunner) logAppliedScriptEnv(source string, envs []string) {
+	entries := formatScriptEnvEntries(envs)
+
+	r.logger.Info("Applied script env",
+		zap.String("source", source),
+		zap.Strings("env", entries),
+	)
+
+	unknown := unknownScriptEnvKeys(envs, r.config)
+	if len(unknown) == 0 {
+		return
+	}
+
+	r.logger.Warn("Script env is not declared by workload",
+		zap.String("source", source),
+		zap.Strings("keys", unknown),
+		zap.String("hint", "check spelling or inspect the workload with `stroppy probe <script> --envs`"),
+	)
+}
+
+func formatScriptEnvEntries(envs []string) []string {
+	entries := make([]string, 0, len(envs))
+
+	for _, env := range envs {
+		key, value, ok := strings.Cut(env, "=")
+		if !ok || key == "" {
+			continue
+		}
+
+		entries = append(entries, key+"="+maskScriptEnvValue(key, value))
+	}
+
+	sort.Strings(entries)
+
+	return entries
+}
+
+func maskScriptEnvValue(key, value string) string {
+	upper := strings.ToUpper(key)
+	for _, marker := range []string{"PASSWORD", "PASS", "SECRET", "TOKEN", "CREDENTIAL", "AUTH", "URL", "DSN", "_KEY"} {
+		if strings.Contains(upper, marker) {
+			return "<redacted>"
+		}
+	}
+
+	return value
+}
+
+func unknownScriptEnvKeys(envs []string, probe *Probeprint) []string {
+	known := knownScriptEnvNames(probe)
+	if len(known) == 0 {
+		return nil
+	}
+
+	var unknown []string
+
+	for _, env := range envs {
+		key, _, ok := strings.Cut(env, "=")
+		if !ok || key == "" {
+			continue
+		}
+
+		if _, exists := known[key]; !exists {
+			unknown = append(unknown, key)
+		}
+	}
+
+	sort.Strings(unknown)
+
+	return unknown
+}
+
+func knownScriptEnvNames(probe *Probeprint) map[string]struct{} {
+	if probe == nil {
+		return nil
+	}
+
+	known := make(map[string]struct{})
+
+	for _, decl := range probe.EnvDeclarations {
+		for _, name := range decl.Names {
+			known[name] = struct{}{}
+		}
+	}
+
+	for _, name := range probe.Envs {
+		known[name] = struct{}{}
+	}
+
+	if len(known) == 0 {
+		return nil
+	}
+
+	return known
+}
+
+func envKeySet(envs []string) map[string]struct{} {
+	keys := make(map[string]struct{}, len(envs))
+
+	for _, env := range envs {
+		key, _, ok := strings.Cut(env, "=")
+		if ok && key != "" {
+			keys[key] = struct{}{}
+		}
+	}
+
+	return keys
+}
+
+func rememberEnvKeys(keys map[string]struct{}, envs []string) {
+	for _, env := range envs {
+		key, _, ok := strings.Cut(env, "=")
+		if ok && key != "" {
+			keys[key] = struct{}{}
+		}
+	}
+}
+
+func keepNewEnvEntries(envs []string, known map[string]struct{}) (kept, skipped []string) {
+	kept = make([]string, 0, len(envs))
+	for _, env := range envs {
+		key, _, ok := strings.Cut(env, "=")
+		if !ok || key == "" {
+			continue
+		}
+
+		if _, exists := known[key]; exists {
+			skipped = append(skipped, key)
+
+			continue
+		}
+
+		kept = append(kept, env)
+	}
+
+	sort.Strings(skipped)
+
+	return kept, skipped
+}
diff --git a/internal/runner/env_log_test.go b/internal/runner/env_log_test.go
new file mode 100644
index 00000000..4999f389
--- /dev/null
+++ b/internal/runner/env_log_test.go
@@ -0,0 +1,65 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatScriptEnvEntries(t *testing.T) {
+	got := formatScriptEnvEntries([]string{
+		"LOAD_WORKERS=8",
+		"PASSWORD=secret",
+		"DATABASE_URL=postgres://user:pass@localhost/db",
+		"API_KEY=secret",
+	})
+
+	require.Equal(t, []string{
+		"API_KEY=<redacted>",
+		"DATABASE_URL=<redacted>",
+		"LOAD_WORKERS=8",
+		"PASSWORD=<redacted>",
+	}, got)
+}
+
+func TestUnknownScriptEnvKeys(t *testing.T) {
+	probe := &Probeprint{
+		Subprobe: Subprobe{
+			EnvDeclarations: []EnvDeclaration{
+				{Names: []string{"LOAD_WORKERS"}},
+				{Names: []string{"SCALE_FACTOR", "WAREHOUSES"}},
+			},
+			Envs: []string{"LEGACY"},
+		},
+	}
+
+	got := unknownScriptEnvKeys([]string{
+		"LOAD_WORKERS=8",
+		"WAREHOUSES=2",
+		"LEGACY=yes",
+		"TYPO=1",
+	}, probe)
+
+	require.Equal(t, []string{"TYPO"}, got)
+}
+
+func TestUnknownScriptEnvKeysSkipsValidationWithoutProbeData(t *testing.T) {
+	require.Empty(t, unknownScriptEnvKeys([]string{"ANYTHING=1"}, nil))
+	require.Empty(t, unknownScriptEnvKeys([]string{"ANYTHING=1"}, &Probeprint{}))
+}
+
+func TestKeepNewEnvEntries(t *testing.T) {
+	known := map[string]struct{}{
+		"FROM_OS":  {},
+		"FROM_CLI": {},
+	}
+
+	kept, skipped := keepNewEnvEntries([]string{
+		"FROM_CLI=cli",
+		"FROM_FILE=file",
+		"FROM_OS=file",
+	}, known)
+
+	require.Equal(t, []string{"FROM_FILE=file"}, kept)
+	require.Equal(t, []string{"FROM_CLI", "FROM_OS"}, skipped)
+}
diff --git a/internal/runner/k6_exit.go b/internal/runner/k6_exit.go
index 930c4aa9..14cedfa0 100644
--- a/internal/runner/k6_exit.go
+++ b/internal/runner/k6_exit.go
@@ -1,6 +1,10 @@
 package runner
 
-import "fmt"
+import (
+	"fmt"
+	"math"
+	"sync/atomic"
+)
 
 type ExitError struct {
 	Code int
@@ -8,19 +12,51 @@ type ExitError struct {
 
 func (e *ExitError) Error() string { return fmt.Sprintf("k6 exited with code %d", e.Code) }
 
-var exitCode int = -1
+var (
+	captureK6Exit atomic.Bool
+	exitCode      atomic.Int32
+)
+
+func init() {
+	exitCode.Store(-1)
+}
+
+func BeginK6ExitCapture() func() {
+	exitCode.Store(-1)
+	captureK6Exit.Store(true)
+
+	return func() {
+		captureK6Exit.Store(false)
+	}
+}
+
+func K6ExitCaptureEnabled() bool {
+	return captureK6Exit.Load()
+}
 
 func exitCodeToError() error {
-	switch exitCode {
+	switch code := int(exitCode.Load()); code {
 	case -1:
 		panic("unreachable; k6 must to set an exit code")
 	case 0: // do nothing, all correct
 		return nil
 	default:
-		return &ExitError{Code: exitCode}
+		return &ExitError{Code: code}
 	}
 }
 
 func OSExit(i int) {
-	exitCode = i
+	if i > math.MaxInt32 {
+		exitCode.Store(math.MaxInt32)
+
+		return
+	}
+
+	if i < math.MinInt32 {
+		exitCode.Store(math.MinInt32)
+
+		return
+	}
+
+	exitCode.Store(int32(i))
 }
diff --git a/internal/runner/script_runner.go b/internal/runner/script_runner.go
index 74e74845..19857c75 100644
--- a/internal/runner/script_runner.go
+++ b/internal/runner/script_runner.go
@@ -286,15 +286,32 @@ func copyFiles(srcDir, dstDir string, excludeNames []string) (copied []string, e
 // real env > -e overrides > file env > file drivers > CLI drivers > logger/OTEL > sql/steps.
 func (r *ScriptRunner) buildEnvVars() ([]string, error) {
 	envs := os.Environ() // inherit parent environment
+	envKeys := envKeySet(envs)
 
 	// Add -e overrides (real env takes precedence; warns on override).
 	if len(r.envOverrides) > 0 {
-		envs = append(envs, BuildEnvLookup(r.envOverrides, true)...)
+		cliEnvs := BuildEnvLookup(r.envOverrides, true)
+		r.logAppliedScriptEnv("cli", cliEnvs)
+		envs = append(envs, cliEnvs...)
+		rememberEnvKeys(envKeys, cliEnvs)
 	}
 
 	// Config file env overrides (real env takes precedence; silent skip).
 	if r.fileConfig != nil && len(r.fileConfig.GetEnv()) > 0 {
-		envs = append(envs, BuildFileEnvLookup(r.fileConfig.GetEnv())...)
+		fileEnvs := BuildFileEnvLookup(r.fileConfig.GetEnv())
+
+		var skipped []string
+
+		fileEnvs, skipped = keepNewEnvEntries(fileEnvs, envKeys)
+		if len(skipped) > 0 {
+			r.logger.Debug("Config file env skipped: higher-precedence env already set",
+				zap.Strings("keys", skipped),
+			)
+		}
+
+		r.logAppliedScriptEnv("config_file", fileEnvs)
+		envs = append(envs, fileEnvs...)
+		rememberEnvKeys(envKeys, fileEnvs)
 	}
 
 	// File driver configs (skipped if real env or CLI already covers the index).
@@ -474,6 +491,9 @@ func (r *ScriptRunner) runK6(
 	r.logger.Info("Running k6", zap.Strings("args", os.Args))
 
 	// run the test
+	stopExitCapture := BeginK6ExitCapture()
+	defer stopExitCapture()
+
 	k6cmd.Execute()
 
 	defer func() { err = errors.Join(err, exitCodeToError()) }()
diff --git a/internal/static/helpers.ts b/internal/static/helpers.ts
index 503711ee..861d5d25 100644
--- a/internal/static/helpers.ts
+++ b/internal/static/helpers.ts
@@ -333,6 +333,101 @@ export type DriverSetup = Omit<Partial<DriverConfig>, "errorMode" | "driverType"
   sql?: Partial<DriverConfig_SqlConfig>;
 }
 
+const driverSetupKeys = new Set([
+  "url",
+  "driverType",
+  "defaultTxIsolation",
+  "defaultInsertMethod",
+  "errorMode",
+  "pool",
+  "postgres",
+  "sql",
+  "bulkSize",
+  "caCertFile",
+  "authToken",
+  "authUser",
+  "authPassword",
+  "tlsInsecureSkipVerify",
+]);
+
+const nestedDriverSetupKeys: Record<string, Set<string>> = {
+  pool: new Set(["maxConns", "minConns", "maxConnLifetime", "maxConnIdleTime"]),
+  postgres: new Set([
+    "traceLogLevel",
+    "maxConnLifetime",
+    "maxConnIdleTime",
+    "maxConns",
+    "minConns",
+    "minIdleConns",
+    "defaultQueryExecMode",
+    "descriptionCacheCapacity",
+    "statementCacheCapacity",
+  ]),
+  sql: new Set(["maxOpenConns", "maxIdleConns", "connMaxLifetime", "connMaxIdleTime"]),
+};
+
+const driverSetupEnums: Record<string, Set<string>> = {
+  driverType: new Set(Object.keys(driverTypeMap)),
+  defaultTxIsolation: new Set(Object.keys(txIsolationMap)),
+  defaultInsertMethod: new Set(Object.keys(insertMethodMap)),
+  errorMode: new Set(Object.keys(errorModeMap)),
+};
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function allowedList(keys: Set<string>): string {
+  return [...keys].sort().join(", ");
+}
+
+function validateEnum(source: string, path: string, value: unknown, allowed: Set<string>): void {
+  if (value !== undefined && (typeof value !== "string" || !allowed.has(value))) {
+    throw new Error(`${source}: ${path} must be one of: ${allowedList(allowed)}`);
+  }
+}
+
+export function validateDriverSetup(source: string, setup: unknown): asserts setup is DriverSetup {
+  if (!isPlainObject(setup)) {
+    throw new Error(`${source}: driver setup must be object`);
+  }
+
+  for (const [key, value] of Object.entries(setup)) {
+    if (!driverSetupKeys.has(key)) {
+      throw new Error(`${source}: unknown driver option "${key}" (available: ${allowedList(driverSetupKeys)})`);
+    }
+
+    const enumValues = driverSetupEnums[key];
+    if (enumValues) validateEnum(source, key, value, enumValues);
+
+    const nestedKeys = nestedDriverSetupKeys[key];
+    if (!nestedKeys || value === undefined) continue;
+    if (!isPlainObject(value)) {
+      throw new Error(`${source}: ${key} must be object`);
+    }
+
+    for (const nestedKey of Object.keys(value)) {
+      if (!nestedKeys.has(nestedKey)) {
+        throw new Error(`${source}: unknown ${key} option "${nestedKey}" (available: ${allowedList(nestedKeys)})`);
+      }
+    }
+  }
+}
+
+function mergeDriverSetup(defaults: DriverSetup, cli: Partial<DriverSetup>): DriverSetup {
+  const merged: Record<string, unknown> = { ...defaults };
+  for (const [key, value] of Object.entries(cli)) {
+    if (value === undefined) continue;
+    if ((key === "pool" || key === "postgres" || key === "sql") && isPlainObject(value)) {
+      merged[key] = { ...((defaults as Record<string, unknown>)[key] as object | undefined), ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+
+  return merged as DriverSetup;
+}
+
 /** Resolve pool sugar into the appropriate driver-specific config. */
 function resolvePoolConfig(config: DriverSetup): {
   postgres?: Partial<DriverConfig_PostgresConfig>;
@@ -390,29 +485,18 @@ export function declareDriverSetup(index: number, defaults: DriverSetup): Driver
   const raw = __ENV[envKey];
   if (!raw || raw === "") return defaults;
 
+  let cli: unknown;
   try {
-    const cli = JSON.parse(raw) as Partial<DriverSetup>;
-    // Deep merge: CLI fields override defaults, but only if actually set.
-    const merged: DriverSetup = { ...defaults };
-  if (cli.driverType          !== undefined) merged.driverType          = cli.driverType          as DriverTypeName;
-  if (cli.url                 !== undefined) merged.url                 = cli.url;
-  if (cli.defaultTxIsolation  !== undefined) merged.defaultTxIsolation  = cli.defaultTxIsolation  as TxIsolationName;
-  if (cli.defaultInsertMethod !== undefined) merged.defaultInsertMethod = cli.defaultInsertMethod as InsertMethodName;
-  if (cli.errorMode           !== undefined) merged.errorMode           = cli.errorMode           as ErrorModeName;
-  if (cli.pool                !== undefined) merged.pool                = cli.pool;
-  if (cli.postgres            !== undefined) merged.postgres            = cli.postgres;
-  if (cli.sql                 !== undefined) merged.sql                 = cli.sql;
-    if ((cli as any).bulkSize !== undefined) merged.bulkSize = (cli as any).bulkSize;
-  if (cli.caCertFile           !== undefined) merged.caCertFile           = cli.caCertFile;
-  if (cli.authToken            !== undefined) merged.authToken            = cli.authToken;
-  if (cli.authUser             !== undefined) merged.authUser             = cli.authUser;
-  if (cli.authPassword         !== undefined) merged.authPassword         = cli.authPassword;
-  if (cli.tlsInsecureSkipVerify !== undefined) merged.tlsInsecureSkipVerify = cli.tlsInsecureSkipVerify;
-    return merged;
+    cli = JSON.parse(raw);
   } catch (e) {
-    console.error(`[stroppy] failed to parse ${envKey}: ${e}`);
-    return defaults;
+    throw new Error(`[stroppy] failed to parse ${envKey}: ${e}`);
   }
+
+  validateDriverSetup(envKey, cli);
+  const merged = mergeDriverSetup(defaults, cli);
+  validateDriverSetup(`${envKey} merged`, merged);
+
+  return merged;
 }
 
 export class DriverX implements QueryAPI {
@@ -517,7 +601,7 @@ export class DriverX implements QueryAPI {
   /** Start a transaction manually. Call tx.commit() or tx.rollback() when done. */
   begin(options?: { isolation?: TxIsolationName; name?: string }): TxX {
     const level = options?.isolation ?? this._defaultTxIsolation;
-    const tx = this.driver.begin(txIsolationMap[level]);
+    const tx = this.driver.begin(txIsolationMap[level], options?.name ?? "");
     return new TxX(tx, level, () => this._errorMode, options?.name);
   }
 
diff --git a/internal/static/stroppy.d.ts b/internal/static/stroppy.d.ts
index 7f63ba3c..28bb19b8 100644
--- a/internal/static/stroppy.d.ts
+++ b/internal/static/stroppy.d.ts
@@ -68,7 +68,7 @@ declare module "k6/x/stroppy" {
     runQuery(sql: string, args: Record<string, any>): QueryResult;
     /** Start a transaction with the given isolation level (proto TxIsolationLevel enum value).
      *  @throws {Error} if the driver does not support the requested isolation level */
-    begin(isolationLevel: number): Tx;
+    begin(isolationLevel: number, txName?: string): Tx;
     /** Store driver configuration. The driver is lazily dispatched on first use.
      *  If called at init phase (VU state nil): marks driver as shared.
      *  If called at iteration phase: marks driver as per-VU. */
diff --git a/internal/static/tests/tsconfig.json b/internal/static/tests/tsconfig.json
index d2cf8a01..4ecff88e 100644
--- a/internal/static/tests/tsconfig.json
+++ b/internal/static/tests/tsconfig.json
@@ -14,9 +14,12 @@
     "allowImportingTsExtensions": true,
     "noEmit": true,
     "rootDir": "..",
-    "baseUrl": ".."
+    "baseUrl": "..",
+    "paths": {
+      "k6/x/stroppy": ["stroppy.d.ts"],
+      "k6/x/encoding": ["encoding.d.ts"]
+    }
   },
   "include": ["../**/*.ts", "**/*.ts"],
   "exclude": ["node_modules"]
 }
-
diff --git a/internal/static/tests/vitest.config.ts b/internal/static/tests/vitest.config.ts
index e9cbdede..7926bd16 100644
--- a/internal/static/tests/vitest.config.ts
+++ b/internal/static/tests/vitest.config.ts
@@ -14,4 +14,3 @@ export default defineConfig({
     },
   },
 });
-
diff --git a/pkg/common/logger/logger.go b/pkg/common/logger/logger.go
index 30103461..e37688b2 100644
--- a/pkg/common/logger/logger.go
+++ b/pkg/common/logger/logger.go
@@ -52,6 +52,8 @@ func newZapCfg(mod LogMod, logLevel zapcore.Level) zap.Config {
 		cfg.Level.SetLevel(logLevel)
 	}
 
+	cfg.DisableStacktrace = true
+
 	return cfg
 }
 
diff --git a/pkg/common/logger/logger_test.go b/pkg/common/logger/logger_test.go
index fb16942a..f557ddae 100644
--- a/pkg/common/logger/logger_test.go
+++ b/pkg/common/logger/logger_test.go
@@ -45,6 +45,7 @@ func TestNewZapCfg(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			cfg := newZapCfg(tt.mod, tt.level)
 			require.Equal(t, tt.expected, cfg.Level.Level())
+			require.True(t, cfg.DisableStacktrace)
 		})
 	}
 }
diff --git a/workloads/tpcc/procs.ts b/workloads/tpcc/procs.ts
index f6ab5e45..8754e2c6 100644
--- a/workloads/tpcc/procs.ts
+++ b/workloads/tpcc/procs.ts
@@ -74,7 +74,11 @@ const TOTAL_STOCK     = WAREHOUSES * ITEMS;
 // K6 options — weighted dispatch inside default(), VUs/duration set via CLI or k6 defaults.
 export const options: Options = {
   setupTimeout: String(WAREHOUSES * 5) + "m",
-  summaryTrendStats: ["avg", "min", "med", "max", "p(90)", "p(95)", "p(99)"],
+  summaryTrendStats: [
+    "avg", "min", "med", "max",
+    "p(1)", "p(5)", "p(10)",
+    "p(90)", "p(95)", "p(99)",
+  ],
   thresholds: {
     "tpcc_new_order_duration":    ["p(90)<5000"],
     "tpcc_payment_duration":      ["p(90)<5000"],
@@ -883,10 +887,24 @@ export function handleSummary(data: any): Record<string, string> {
     const fmt = (x: any) => (typeof x === "number" ? x.toFixed(1) : "—");
     return `avg=${fmt(v.avg)}  p50=${fmt(v.med)}  p90=${fmt(v["p(90)"])}  p95=${fmt(v["p(95)"])}  p99=${fmt(v["p(99)"])}`;
   };
+  const tpsTrendLines = (name: string): [string, string] => {
+    const v = m[name]?.values ?? {};
+    const fmt = (x: any) => (typeof x === "number" ? x.toFixed(1) : "—");
+    return [
+      `  tx_tps buckets (tx/s): avg=${fmt(v.avg)}  p1=${fmt(v["p(1)"])}  ` +
+        `p5=${fmt(v["p(5)"])}  p10=${fmt(v["p(10)"])}`,
+      `                         p50=${fmt(v.med)}  p90=${fmt(v["p(90)"])}  ` +
+        `p95=${fmt(v["p(95)"])}  p99=${fmt(v["p(99)"])}  (active 1s buckets)`,
+    ];
+  };
   const rateStr = (name: string): string => {
     const v = m[name]?.values?.rate;
     return typeof v === "number" ? (v * 100).toFixed(2) + "%" : "n/a";
   };
+  const counterRateStr = (name: string): string => {
+    const v = m[name]?.values?.rate;
+    return typeof v === "number" ? v.toFixed(2) + "/s" : "n/a";
+  };
 
   const no  = cnt("tpcc_new_order_total");
   const pay = cnt("tpcc_payment_total");
@@ -905,6 +923,7 @@ export function handleSummary(data: any): Record<string, string> {
   const iterDur = m.iteration_duration?.values?.avg;
   const iterDurStr = typeof iterDur === "number" ? iterDur.toFixed(2) + " ms" : "n/a";
   const queries = cnt("run_query_count");
+  const txs = cnt("tx_count");
 
   const lines: string[] = [
     "",
@@ -931,8 +950,12 @@ export function handleSummary(data: any): Record<string, string> {
     `  stock_level  (ceil 20000): ${trendLine("tpcc_stock_level_duration")}`,
     `  delivery     (ceil 80000): ${trendLine("tpcc_delivery_duration")}`,
     "",
-    "===== Driver query / tx timings (from helpers.ts metrics) =====",
+    "===== Driver query / tx metrics =====",
     `  queries executed    : ${queries}`,
+    `  avg query throughput: ${counterRateStr("run_query_count")}`,
+    `  tx attempts         : ${txs}`,
+    `  avg tx throughput   : ${counterRateStr("tx_count")}  (whole run)`,
+    ...tpsTrendLines("tx_tps"),
     `  run_query_duration  : ${trendLine("run_query_duration")}`,
     `  run_query_error_rate: ${rateStr("run_query_error_rate")}`,
     `  tx_total_duration   : ${trendLine("tx_total_duration")}`,
diff --git a/workloads/tpcc/tx.ts b/workloads/tpcc/tx.ts
index e3450d94..b62803d3 100644
--- a/workloads/tpcc/tx.ts
+++ b/workloads/tpcc/tx.ts
@@ -164,10 +164,12 @@ const nurand255Gen = DrawRT.nurand(seedOf("nurand255"), 255, 0, 999);
 // next to each metric — no manual assertion needed on top of handleSummary.
 export const options: Options = {
   setupTimeout: String(WAREHOUSES * 5) + "m",
-  // Include p99 in the per-trend percentiles k6 computes; default is
-  // ["avg","min","med","max","p(90)","p(95)"] — adding p(99) so the
-  // handleSummary breakdown shows the full distribution we advertise.
-  summaryTrendStats: ["avg", "min", "med", "max", "p(90)", "p(95)", "p(99)"],
+  // Include low TPS percentiles plus p99 in the per-trend percentiles k6 computes.
+  summaryTrendStats: [
+    "avg", "min", "med", "max",
+    "p(1)", "p(5)", "p(10)",
+    "p(90)", "p(95)", "p(99)",
+  ],
   thresholds: {
     "tpcc_new_order_duration":    ["p(90)<5000"],
     "tpcc_payment_duration":      ["p(90)<5000"],
@@ -1589,10 +1591,24 @@ export function handleSummary(data: any): Record<string, string> {
     const fmt = (x: any) => (typeof x === "number" ? x.toFixed(1) : "—");
     return `avg=${fmt(v.avg)}  p50=${fmt(v.med)}  p90=${fmt(v["p(90)"])}  p95=${fmt(v["p(95)"])}  p99=${fmt(v["p(99)"])}`;
   };
+  const tpsTrendLines = (name: string): [string, string] => {
+    const v = m[name]?.values ?? {};
+    const fmt = (x: any) => (typeof x === "number" ? x.toFixed(1) : "—");
+    return [
+      `  tx_tps buckets (tx/s): avg=${fmt(v.avg)}  p1=${fmt(v["p(1)"])}  ` +
+        `p5=${fmt(v["p(5)"])}  p10=${fmt(v["p(10)"])}`,
+      `                         p50=${fmt(v.med)}  p90=${fmt(v["p(90)"])}  ` +
+        `p95=${fmt(v["p(95)"])}  p99=${fmt(v["p(99)"])}  (active 1s buckets)`,
+    ];
+  };
   const rateStr = (name: string): string => {
     const v = m[name]?.values?.rate;
     return typeof v === "number" ? (v * 100).toFixed(2) + "%" : "n/a";
   };
+  const counterRateStr = (name: string): string => {
+    const v = m[name]?.values?.rate;
+    return typeof v === "number" ? v.toFixed(2) + "/s" : "n/a";
+  };
 
   const no  = cnt("tpcc_new_order_total");
   const pay = cnt("tpcc_payment_total");
@@ -1614,6 +1630,7 @@ export function handleSummary(data: any): Record<string, string> {
   const iterDur = m.iteration_duration?.values?.avg;
   const iterDurStr = typeof iterDur === "number" ? iterDur.toFixed(2) + " ms" : "n/a";
   const queries = cnt("run_query_count");
+  const txs = cnt("tx_count");
 
   const lines: string[] = [
     "",
@@ -1645,8 +1662,12 @@ export function handleSummary(data: any): Record<string, string> {
     `  stock_level  (ceil 20000): ${trendLine("tpcc_stock_level_duration")}`,
     `  delivery     (ceil 80000): ${trendLine("tpcc_delivery_duration")}`,
     "",
-    "===== Driver query / tx timings (from helpers.ts metrics) =====",
+    "===== Driver query / tx metrics =====",
     `  queries executed    : ${queries}`,
+    `  avg query throughput: ${counterRateStr("run_query_count")}`,
+    `  tx attempts         : ${txs}`,
+    `  avg tx throughput   : ${counterRateStr("tx_count")}  (whole run)`,
+    ...tpsTrendLines("tx_tps"),
     `  run_query_duration  : ${trendLine("run_query_duration")}`,
     `  run_query_error_rate: ${rateStr("run_query_error_rate")}`,
     `  tx_total_duration   : ${trendLine("tx_total_duration")}`,