Update dataset (part 3)

harbor/tasks/pomerium_route_order_contract/environment/Dockerfile

@@ -0,0 +1,24 @@
+FROM ec-swe-pomerium:source-v10 AS sanitized
+USER root
+COPY sanitize.py capture.py capture_submission.py /opt/task-tools/
+RUN HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 /opt/hudvenv/bin/python /opt/task-tools/sanitize.py
+FROM scratch
+COPY --from=sanitized / /
+ENV PATH="/usr/local/go/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+ENV GOTOOLCHAIN="local"
+ENV CGO_ENABLED="1"
+ENV GOWORK="off"
+ENV GOFLAGS="-mod=mod"
+ENV GOPATH="/go"
+ENV GOMODCACHE="/go/pkg/mod"
+ENV GOMEMLIMIT="1GiB"
+ENV GOPROXY="off"
+ENV GOMAXPROCS="2"
+ENV HOME="/tmp/agent-home"
+ENV GOCACHE="/tmp/agent-home/.cache/go-build"
+ENV HUD_TELEMETRY_ENABLED="false"
+ENV HUD_CLI_ANALYTICS_ENABLED="0"
+WORKDIR /workspace/repo
+USER 1000:1000
+CMD ["sleep", "infinity"]

harbor/tasks/pomerium_route_order_contract/environment/capture.py

@@ -0,0 +1,28 @@
+"""Capture a patch against protected baseline history inside the agent sandbox."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, "/opt/task-tools")
+from capture_submission import capture_submission  # noqa: E402
+
+with tempfile.TemporaryDirectory(prefix="capture-") as directory:
+    git_dir = Path(directory) / "git"
+    shutil.copytree("/opt/task-tools/baseline.git", git_dir)
+    os.environ.update(
+        GIT_DIR=str(git_dir),
+        GIT_WORK_TREE="/workspace/repo",
+        GIT_CONFIG_NOSYSTEM="1",
+        GIT_CONFIG_GLOBAL="/dev/null",
+    )
+    print(
+        json.dumps(
+            capture_submission(
+                Path("/workspace/repo"), Path("/workspace/submissions/submitted.patch")
+            )
+        )
+    )

harbor/tasks/pomerium_route_order_contract/environment/capture_submission.py

@@ -0,0 +1,157 @@
+"""Capture tracked and new SWE files without changing the agent's Git index."""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+MAX_SUBMISSION_BYTES = 32 * 1024 * 1024
+
+
+def capture_submission(
+    repository: Path, output: Path, *, max_bytes: int = MAX_SUBMISSION_BYTES
+) -> dict[str, object]:
+    """Write a bounded binary patch including nonignored new files.
+
+    Parameters
+    ----------
+    repository : Path
+        Git checkout root. HEAD must remain the task's initial commit.
+    output : Path
+        Submission path outside the checkout. Replaces any prior submission.
+    max_bytes : int, default: 33554432
+        Maximum emitted patch size. Oversized submissions fail without a patch.
+
+    Returns
+    -------
+    dict
+        Patch size, SHA-256, base commit and capture format for trial evidence.
+
+    Raises
+    ------
+    ValueError
+        If paths or the limit are invalid, or the patch exceeds the limit.
+    OSError, subprocess.CalledProcessError, RuntimeError
+        If capture fails. No partial patch is published.
+
+    Notes
+    -----
+    Uses a temporary index to combine staged, unstaged and untracked changes.
+    Ignored untracked files are excluded. This is a capture bound, not a total
+    sandbox disk quota or a security boundary against a malicious Git runtime.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    repository = repository.resolve(strict=True)
+    if output.is_symlink():
+        raise ValueError("Submission output must not be a symlink")
+    output = output.resolve()
+    if output.is_relative_to(repository):
+        raise ValueError("Submission output must be outside the repository")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.unlink(missing_ok=True)
+    root = subprocess.check_output(
+        ["git", "rev-parse", "--show-toplevel"], cwd=repository, text=True
+    ).strip()
+    if Path(root).resolve() != repository:
+        raise ValueError("repository must be the Git checkout root")
+    base = subprocess.check_output(
+        ["git", "rev-parse", "--verify", "HEAD^{commit}"], cwd=repository, text=True
+    ).strip()
+    with tempfile.TemporaryDirectory(prefix="submission-", dir=output.parent) as directory:
+        temporary = Path(directory)
+        env = {**os.environ, "GIT_INDEX_FILE": str(temporary / "index")}
+        for arguments in (["read-tree", base], ["add", "--all", "--", "."]):
+            subprocess.run(["git", *arguments], cwd=repository, env=env, check=True)
+        patch = temporary / "patch"
+        size = 0
+        digest = hashlib.sha256()
+        with (
+            patch.open("wb") as stream,
+            tempfile.TemporaryFile() as errors,
+            subprocess.Popen(
+                [
+                    "git",
+                    "diff",
+                    "--cached",
+                    "--binary",
+                    "--full-index",
+                    "--no-renames",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                    base,
+                ],
+                cwd=repository,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=errors,
+            ) as process,
+        ):
+            assert process.stdout is not None
+            try:
+                while chunk := process.stdout.read(65536):
+                    size += len(chunk)
+                    if size > max_bytes:
+                        raise ValueError(f"Submission exceeds {max_bytes} bytes")
+                    stream.write(chunk)
+                    digest.update(chunk)
+            except BaseException:
+                process.kill()
+                process.wait()
+                raise
+            if process.wait():
+                errors.seek(0)
+                raise RuntimeError(
+                    "Git patch capture failed: " + errors.read(4096).decode(errors="replace")
+                )
+        patch.replace(output)
+    return {
+        "bytes": size,
+        "sha256": digest.hexdigest(),
+        "base_commit": base,
+        "format": "git-binary-v1",
+    }
+
+
+def submission_command(*, max_bytes: int = MAX_SUBMISSION_BYTES) -> str:
+    """Build the trusted command recorded before Harbor collects artifacts.
+
+    Parameters
+    ----------
+    max_bytes : int, default: 33554432
+        Maximum emitted patch bytes.
+
+    Returns
+    -------
+    str
+        Shell command carrying this exact helper into the solver runtime.
+
+    Raises
+    ------
+    ValueError
+        If the size limit is invalid.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    return "python -c " + shlex.quote(Path(__file__).read_text()) + f" --max-bytes {max_bytes}"
+
+
+def main() -> None:
+    """Capture the submission and print its identity as trial evidence."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=Path("/testbed"))
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submitted.patch"))
+    parser.add_argument("--max-bytes", type=int, default=MAX_SUBMISSION_BYTES)
+    args = parser.parse_args()
+    print(json.dumps(capture_submission(args.repository, args.output, max_bytes=args.max_bytes)))
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/pomerium_route_order_contract/environment/docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  main:
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - type: tmpfs
+        target: /logs/verifier
+        tmpfs:
+          mode: 448
+          size: 1048576

harbor/tasks/pomerium_route_order_contract/environment/sanitize.py

@@ -0,0 +1,25 @@
+"""Remove private task assets and history when building the agent-only image."""
+
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/app")
+from env import _setup  # noqa: E402
+
+asyncio.run(_setup())
+# The new history contains only the public baseline. Preserve a root-owned
+# copy so capture can ignore agent-controlled refs, hooks and Git configuration.
+shutil.copytree("/workspace/repo/.git", "/opt/task-tools/baseline.git")
+for path in Path("/opt/task-tools/baseline.git").rglob("*"):
+    os.chown(path, 0, 0)
+    path.chmod(0o755 if path.is_dir() else 0o644)
+for name in ("/hud", "/app", "/root/.cache", "/root/.hud"):
+    if Path(name).exists():
+        shutil.rmtree(name)
+# Capture runs on the base interpreter under one name, whatever the image calls it.
+os.symlink(os.path.realpath(sys.executable), "/opt/task-tools/python")
+Path("/workspace/submissions").mkdir()
+os.chown("/workspace/submissions", 1000, 1000)

harbor/tasks/pomerium_route_order_contract/instruction.md

@@ -0,0 +1,7 @@
+Please make your changes directly in /workspace/repo.
+
+# Ticket
+
+Requests land on wrong routes and configuration order takes the blame: priority settles overlapping regex routes; a from address without a port serves every port, one naming a port only that port, spelled or implied; host names carry no case, on the address and in the request alike; wildcard routes still serve hosts that own routes, which win where they match; in-process lookups match the proxy. Keep the suite green without editing tests.
+
+Finish with a final response when your changes are ready.

harbor/tasks/pomerium_route_order_contract/solution/reference.patch

@@ -0,0 +1,537 @@
+diff --git a/config/envoyconfig/route_configurations.go b/config/envoyconfig/route_configurations.go
+index 2aa0752..c43de28 100644
+--- a/config/envoyconfig/route_configurations.go
++++ b/config/envoyconfig/route_configurations.go
+@@ -85,12 +85,18 @@ func (b *Builder) buildMainRouteConfiguration(
+ 		return nil, err
+ 	}
+ 
++	explicitPortOnly := explicitPortOnlyHosts(cfg.Options)
++
+ 	var virtualHosts []*envoy_config_route_v3.VirtualHost
+ 	for _, host := range allHosts {
+ 		vh, err := b.buildVirtualHost(cfg.Options, host, host, mcpHosts[host])
+ 		if err != nil {
+ 			return nil, err
+ 		}
++		if explicitPortOnly[host] {
++			// every route of this host names its port: it is not served on any port
++			vh.Domains = []string{host}
++		}
+ 
+ 		if cfg.Options.Addr == cfg.Options.GetGRPCAddr() {
+ 			// if this is a gRPC service domain and we're supposed to handle that, add those routes
+@@ -212,11 +218,15 @@ func getAllRouteableHosts(options *config.Options, addr string) ([]string, map[s
+ 		if err != nil {
+ 			return nil, nil, err
+ 		}
+-		allHosts.InsertSlice(hosts)
++		// host names carry no case: two from addresses that spell one host
++		// differently are one virtual host, not two envoy would reject
++		for _, host := range hosts {
++			allHosts.Insert(strings.ToLower(host))
++		}
+ 		// Merge any MCP hosts
+ 		for host, isMCP := range hostsMCP {
+ 			if isMCP {
+-				mcpHosts[host] = true
++				mcpHosts[strings.ToLower(host)] = true
+ 			}
+ 		}
+ 	}
+@@ -226,7 +236,9 @@ func getAllRouteableHosts(options *config.Options, addr string) ([]string, map[s
+ 		if err != nil {
+ 			return nil, nil, err
+ 		}
+-		allHosts.InsertSlice(hosts)
++		for _, host := range hosts {
++			allHosts.Insert(strings.ToLower(host))
++		}
+ 	}
+ 
+ 	var filtered []string
+@@ -256,6 +268,31 @@ func urlsMatchHost(urls []*url.URL, host string) bool {
+ 	return false
+ }
+ 
++// explicitPortOnlyHosts returns the hosts whose policy from URLs all carry a port.
++func explicitPortOnlyHosts(options *config.Options) map[string]bool {
++	withPort, withoutPort := map[string]bool{}, map[string]bool{}
++	for p := range options.GetAllPolicies() {
++		if p.IsSSH() {
++			continue
++		}
++		u, err := urlutil.ParseAndValidateURL(p.From)
++		if err != nil || strings.Contains(u.Host, "*") {
++			continue
++		}
++		if u.Port() != "" {
++			withPort[strings.ToLower(u.Hostname())] = true
++		} else {
++			withoutPort[strings.ToLower(u.Hostname())] = true
++		}
++	}
++	for h := range withoutPort {
++		delete(withPort, h)
++	}
++	return withPort
++}
++
+ func urlMatchesHost(u *url.URL, host string) bool {
+-	return slices.Contains(urlutil.GetDomainsForURL(u, true), host)
++	return slices.ContainsFunc(urlutil.GetDomainsForURL(u, true), func(domain string) bool {
++		return strings.EqualFold(domain, host)
++	})
+ }
+diff --git a/config/envoyconfig/route_order_test.go b/config/envoyconfig/route_order_test.go
+new file mode 100644
+index 0000000..85148c2
+--- /dev/null
++++ b/config/envoyconfig/route_order_test.go
+@@ -0,0 +1,56 @@
++package envoyconfig
++
++import (
++	"testing"
++
++	envoy_config_route_v3 "github.com/envoyproxy/go-control-plane/envoy/config/route/v3"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/pomerium/pomerium/config"
++	"github.com/pomerium/pomerium/config/envoyconfig/filemgr"
++)
++
++func TestBuilder_buildMainRouteConfiguration_RouteOrder(t *testing.T) {
++	t.Parallel()
++
++	prio := func(v int64) *int64 { return &v }
++	opts := config.NewDefaultOptions()
++	opts.Services = "proxy"
++	opts.Policies = []config.Policy{
++		{From: "https://*.example.com", To: mustParseWeightedURLs(t, "https://wild.internal")},
++		{From: "https://own.example.com", Path: "/own", To: mustParseWeightedURLs(t, "https://own.internal")},
++		{From: "https://own.example.com", Regex: "^/a/.*$", RegexPriorityOrder: prio(1), To: mustParseWeightedURLs(t, "https://low.internal")},
++		{From: "https://own.example.com", Regex: "^/a/b/.*$", RegexPriorityOrder: prio(2), To: mustParseWeightedURLs(t, "https://high.internal")},
++		{From: "https://pinned.example.com:443", To: mustParseWeightedURLs(t, "https://pinned.internal")},
++	}
++	b := New("connect", "grpc", "http", "debug", "metrics", filemgr.NewManager(), nil, true)
++	rc, err := b.buildMainRouteConfiguration(t.Context(), config.New(opts))
++	require.NoError(t, err)
++
++	vhosts := map[string]*envoy_config_route_v3.VirtualHost{}
++	for _, vh := range rc.GetVirtualHosts() {
++		vhosts[vh.GetName()] = vh
++	}
++	policyRoutes := func(vh *envoy_config_route_v3.VirtualHost) []string {
++		var names []string
++		for _, r := range vh.GetRoutes() {
++			if len(r.GetName()) > len("policy-") && r.GetName()[:len("policy-")] == "policy-" {
++				names = append(names, r.GetName())
++			}
++		}
++		return names
++	}
++
++	own := vhosts["own.example.com"]
++	require.NotNil(t, own)
++	// higher priority first, then the rest of the host's own routes, then the
++	// wildcard routes (one per wildcard domain)
++	assert.Equal(t, []string{"policy-3", "policy-2", "policy-1", "policy-0"}, policyRoutes(own))
++	assert.Equal(t, []string{"own.example.com", "own.example.com:*"}, own.GetDomains())
++
++	pinned := vhosts["pinned.example.com"]
++	require.NotNil(t, pinned)
++	assert.Equal(t, []string{"pinned.example.com"}, pinned.GetDomains())
++	assert.NotNil(t, vhosts["pinned.example.com:443"])
++}
+diff --git a/config/envoyconfig/routes.go b/config/envoyconfig/routes.go
+index f8c1d5a..5e7c3cf 100644
+--- a/config/envoyconfig/routes.go
++++ b/config/envoyconfig/routes.go
+@@ -3,7 +3,9 @@ package envoyconfig
+ import (
+ 	"encoding/json"
+ 	"fmt"
++	"net"
+ 	"net/url"
++	"regexp"
+ 	"slices"
+ 	"sort"
+ 	"strings"
+@@ -195,32 +197,100 @@ func (b *Builder) buildRoutesForPoliciesWithHost(
+ 	host string,
+ ) ([]*envoy_config_route_v3.Route, error) {
+ 	var routes []*envoy_config_route_v3.Route
+-	for i, p := range cfg.Options.GetAllPoliciesIndexed() {
+-		policy := p
+-		fromURL, err := urlutil.ParseAndValidateURL(policy.From)
+-		if err != nil {
+-			return nil, err
+-		}
++	// the host's own routes come first, then the wildcard routes that match the
++	// host: envoy never consults the catch-all virtual host for a host that has
++	// a virtual host of its own
++	for _, wildcard := range []bool{false, true} {
++		for i, policy := range cfg.Options.GetAllPoliciesInRouteOrder() {
++			fromURL, err := urlutil.ParseAndValidateURL(policy.From)
++			if err != nil {
++				return nil, err
++			}
+ 
+-		if !urlMatchesHost(fromURL, host) {
+-			continue
+-		}
++			if strings.Contains(fromURL.Host, "*") != wildcard {
++				continue
++			}
++			if wildcard && !wildcardURLMatchesHost(cfg.Options, fromURL, host) {
++				continue
++			}
++			// a route whose from address names a port answers only on that port,
++			// even on a host that other routes serve on every port
++			var onlyAuthority string
++			if !wildcard {
++				switch {
++				case urlMatchesHost(fromURL, host):
++					if fromURL.Port() != "" && !config.HasPort(host) {
++						onlyAuthority = "(?i)^" + regexp.QuoteMeta(fromURL.Hostname()) + "(:" + fromURL.Port() + ")?$"
++					}
++				case portlessURLServesHostPort(cfg.Options, fromURL, host):
++					// a from address without a port serves this port as well
++				default:
++					continue
++				}
++			}
+ 
+-		policyRoutes, err := b.buildRoutesForPolicy(cfg, policy, fmt.Sprintf("policy-%d", i))
+-		if err != nil {
+-			return nil, err
+-		}
++			policyRoutes, err := b.buildRoutesForPolicy(cfg, policy, fmt.Sprintf("policy-%d", i))
++			if err != nil {
++				return nil, err
++			}
++			if onlyAuthority != "" {
++				for _, r := range policyRoutes {
++					r.Match.Headers = append(r.Match.Headers, &envoy_config_route_v3.HeaderMatcher{
++						Name: ":authority",
++						HeaderMatchSpecifier: &envoy_config_route_v3.HeaderMatcher_StringMatch{
++							StringMatch: &envoy_type_matcher_v3.StringMatcher{
++								MatchPattern: &envoy_type_matcher_v3.StringMatcher_SafeRegex{
++									SafeRegex: &envoy_type_matcher_v3.RegexMatcher{Regex: onlyAuthority},
++								},
++							},
++						},
++					})
++				}
++			}
+ 
+-		routes = append(routes, policyRoutes...)
++			routes = append(routes, policyRoutes...)
++		}
+ 	}
+ 	return routes, nil
+ }
+ 
++// portlessURLServesHostPort reports whether a from URL without a port serves a
++// virtual host that names a port: such a route serves every port of its host.
++func portlessURLServesHostPort(options *config.Options, u *url.URL, host string) bool {
++	if !options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) || u.Port() != "" ||
++		strings.Contains(u.Host, "*") || !config.HasPort(host) {
++		return false
++	}
++	hostname, _, err := net.SplitHostPort(host)
++	return err == nil && strings.EqualFold(u.Hostname(), hostname)
++}
++
++func wildcardURLMatchesHost(options *config.Options, u *url.URL, host string) bool {
++	stripPort := options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)
++	anyPort := stripPort && u.Port() == ""
++	host = strings.ToLower(host)
++	for _, domain := range urlutil.GetDomainsForURL(u, !anyPort) {
++		domain = strings.ToLower(domain)
++		if stripPort && !config.HasPort(host) {
++			// this virtual host serves its host on every port: a wildcard that
++			// names a port belongs in it too, its :authority match keeps it to
++			// that port
++			if hostname, _, err := net.SplitHostPort(domain); err == nil {
++				domain = hostname
++			}
++		}
++		if regexp.MustCompile(config.WildcardToRegex(domain, anyPort)).MatchString(host) {
++			return true
++		}
++	}
++	return false
++}
++
+ func (b *Builder) buildRoutesForPoliciesWithCatchAll(
+ 	cfg *config.Config,
+ ) ([]*envoy_config_route_v3.Route, error) {
+ 	var routes []*envoy_config_route_v3.Route
+-	for i, policy := range cfg.Options.GetAllPoliciesIndexed() {
++	for i, policy := range cfg.Options.GetAllPoliciesInRouteOrder() {
+ 		fromURL, err := urlutil.ParseAndValidateURL(policy.From)
+ 		if err != nil {
+ 			return nil, err
+@@ -252,9 +322,12 @@ func (b *Builder) buildRoutesForPolicy(
+ 
+ 	var routes []*envoy_config_route_v3.Route
+ 	if strings.Contains(fromURL.Host, "*") {
+-		// we have to match '*.example.com' and '*.example.com:443', so there are two routes
+-		for _, host := range urlutil.GetDomainsForURL(fromURL, !cfg.Options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)) {
+-			route, err := b.buildRouteForPolicyAndMatch(cfg, policy, name, mkRouteMatchForHost(cfg.Options, policy, host))
++		// we have to match '*.example.com' and '*.example.com:443', so there are two routes;
++		// a wildcard address that names its port, the default one included, keeps
++		// both and is served on that port only
++		anyPort := cfg.Options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) && fromURL.Port() == ""
++		for _, host := range urlutil.GetDomainsForURL(fromURL, !anyPort) {
++			route, err := b.buildRouteForPolicyAndMatch(cfg, policy, name, mkRouteMatchForHost(cfg.Options, policy, host, anyPort))
+ 			if err != nil {
+ 				return nil, err
+ 			}
+@@ -560,15 +633,22 @@ func mkRouteMatchForHost(
+ 	options *config.Options,
+ 	policy *config.Policy,
+ 	host string,
++	anyPort bool,
+ ) *envoy_config_route_v3.RouteMatch {
+ 	match := mkRouteMatch(policy)
++	// the expression is written in lower case, the way a host name is compared
++	regex := config.WildcardToRegex(strings.ToLower(host), anyPort)
++	if options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) {
++		// a host name carries no case, however the request spells it
++		regex = "(?i)" + regex
++	}
+ 	match.Headers = append(match.Headers, &envoy_config_route_v3.HeaderMatcher{
+ 		Name: ":authority",
+ 		HeaderMatchSpecifier: &envoy_config_route_v3.HeaderMatcher_StringMatch{
+ 			StringMatch: &envoy_type_matcher_v3.StringMatcher{
+ 				MatchPattern: &envoy_type_matcher_v3.StringMatcher_SafeRegex{
+ 					SafeRegex: &envoy_type_matcher_v3.RegexMatcher{
+-						Regex: config.WildcardToRegex(host, options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)),
++						Regex: regex,
+ 					},
+ 				},
+ 			},
+diff --git a/config/from.go b/config/from.go
+index c5d5cd9..09944d5 100644
+--- a/config/from.go
++++ b/config/from.go
+@@ -10,8 +10,22 @@ import (
+ 
+ // FromURLMatchesRequestURL returns true if the from URL matches the request URL.
+ func FromURLMatchesRequestURL(fromURL, requestURL *url.URL, stripPort bool) bool {
++	// host names are not case sensitive: fold both sides before comparing, so
++	// that a from address and a request naming the same host agree however
++	// either of them happens to be spelled
++	reqHost := strings.ToLower(requestURL.Host)
++	reqHostname := strings.ToLower(requestURL.Hostname())
++
++	// a from URL without a port matches any port
++	if stripPort && fromURL.Port() == "" && !strings.Contains(fromURL.Host, "*") &&
++		!strings.HasPrefix(fromURL.Scheme, "tcp+") && !strings.HasPrefix(fromURL.Scheme, "udp+") &&
++		strings.ToLower(fromURL.Hostname()) == reqHostname {
++		return true
++	}
++
+ 	for _, domain := range urlutil.GetDomainsForURL(fromURL, true) {
+-		if domain == requestURL.Host {
++		domain = strings.ToLower(domain)
++		if domain == reqHost {
+ 			return true
+ 		}
+ 
+@@ -19,9 +33,16 @@ func FromURLMatchesRequestURL(fromURL, requestURL *url.URL, stripPort bool) bool
+ 			continue
+ 		}
+ 
+-		reStr := WildcardToRegex(domain, stripPort)
++		// a wildcard address that names a port answers on that port only
++		reStr := WildcardToRegex(domain, stripPort && fromURL.Port() == "")
+ 		re := regexp.MustCompile(reStr)
+-		if re.MatchString(requestURL.Host) {
++		// the proxy folds the case of a request only where it serves any port:
++		// elsewhere the lookup reads the request the way the proxy does
++		host := reqHost
++		if !stripPort {
++			host = requestURL.Host
++		}
++		if re.MatchString(host) {
+ 			return true
+ 		}
+ 	}
+diff --git a/config/identity.go b/config/identity.go
+index 2117b5f..5e1c7cb 100644
+--- a/config/identity.go
++++ b/config/identity.go
+@@ -3,6 +3,7 @@ package config
+ import (
+ 	"context"
+ 	"slices"
++	"strings"
+ 
+ 	oteltrace "go.opentelemetry.io/otel/trace"
+ 
+@@ -91,12 +92,23 @@ func (o *Options) GetIdentityProviderForRequestURL(requestURL string) (*identity
+ 		return nil, err
+ 	}
+ 
+-	for p := range o.GetAllPolicies() {
+-		if p.Matches(u, o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort)) {
+-			return o.GetIdentityProviderForPolicy(p)
++	// the same order the proxy matches in: route order, and a host's own
++	// routes before wildcard routes
++	stripPort := o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort)
++	var wildcard *Policy
++	for _, p := range o.GetAllPoliciesInRouteOrder() {
++		if !p.Matches(u, stripPort) {
++			continue
++		}
++		if strings.Contains(p.From, "*") {
++			if wildcard == nil {
++				wildcard = p
++			}
++			continue
+ 		}
++		return o.GetIdentityProviderForPolicy(p)
+ 	}
+-	return o.GetIdentityProviderForPolicy(nil)
++	return o.GetIdentityProviderForPolicy(wildcard)
+ }
+ 
+ // GetAuthenticator gets the authenticator for the given IDP id.
+diff --git a/config/options.go b/config/options.go
+index ad93c0a..74c7541 100644
+--- a/config/options.go
++++ b/config/options.go
+@@ -1075,6 +1075,40 @@ func (o *Options) GetAllPoliciesIndexed() iter.Seq2[int, *Policy] {
+ 	}
+ }
+ 
++// GetAllPoliciesInRouteOrder returns all the policies, with their configuration
++// index, in the order requests are matched against them: configuration order,
++// except that a policy with a higher regex_priority_order comes first.
++func (o *Options) GetAllPoliciesInRouteOrder() iter.Seq2[int, *Policy] {
++	type indexedPolicy struct {
++		index  int
++		policy *Policy
++	}
++	var all []indexedPolicy
++	for i, p := range o.GetAllPoliciesIndexed() {
++		all = append(all, indexedPolicy{i, p})
++	}
++	slices.SortStableFunc(all, func(a, b indexedPolicy) int {
++		x, y := a.policy.RegexPriorityOrder, b.policy.RegexPriorityOrder
++		switch {
++		case x == nil && y == nil:
++			return 0
++		case x == nil:
++			return 1
++		case y == nil:
++			return -1
++		default:
++			return cmp.Compare(*y, *x)
++		}
++	})
++	return func(yield func(int, *Policy) bool) {
++		for _, e := range all {
++			if !yield(e.index, e.policy) {
++				return
++			}
++		}
++	}
++}
++
+ func (o *Options) NumPolicies() int {
+ 	return len(o.Policies) + len(o.Routes) + len(o.AdditionalPolicies)
+ }
+@@ -1373,7 +1407,8 @@ func (o *Options) GetAllRouteableHTTPHosts() ([]string, map[string]bool, error)
+ 				return nil, nil, err
+ 			}
+ 
+-			domains := urlutil.GetDomainsForURL(fromURL, !o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort))
++			// a from URL with a port is served on that port, so it keeps it
++			domains := urlutil.GetDomainsForURL(fromURL, !o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort) || fromURL.Port() != "")
+ 			hosts.InsertSlice(domains)
+ 
+ 			// Track if the domains are associated with an MCP policy
+diff --git a/config/route_order_test.go b/config/route_order_test.go
+new file mode 100644
+index 0000000..c2ebd62
+--- /dev/null
++++ b/config/route_order_test.go
+@@ -0,0 +1,72 @@
++package config
++
++import (
++	"testing"
++
++	"github.com/stretchr/testify/assert"
++)
++
++func TestGetIdentityProviderForRequestURL_RouteOrder(t *testing.T) {
++	t.Parallel()
++
++	prio := func(v int64) *int64 { return &v }
++	opts := func(policies ...Policy) *Options {
++		o := NewDefaultOptions()
++		o.AuthenticateURLString = "https://authenticate.example.com"
++		o.ClientID = "default"
++		o.ClientSecret = "secret"
++		o.Provider = "oidc"
++		o.ProviderURL = "https://idp.example.com"
++		o.Policies = policies
++		for i := range o.Policies {
++			assert.NoError(t, o.Policies[i].Validate())
++		}
++		return o
++	}
++	lookup := func(o *Options, u string) string {
++		idp, err := o.GetIdentityProviderForRequestURL(u)
++		if !assert.NoError(t, err) {
++			return ""
++		}
++		return idp.GetClientId()
++	}
++	to := mustParseWeightedURLs(t, "https://to.example.com")
++
++	t.Run("ports", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://any.example.com", To: to, IDPClientID: "any"},
++			Policy{From: "https://pinned.example.com:443", To: to, IDPClientID: "pinned"},
++			Policy{From: "https://*.wild443.example.com:443", To: to, IDPClientID: "wild443"},
++			Policy{From: "https://*.wild8443.example.com:8443", To: to, IDPClientID: "wild8443"},
++		)
++		assert.Equal(t, "any", lookup(o, "https://any.example.com:8443/x"))
++		assert.Equal(t, "any", lookup(o, "https://any.example.com/x"))
++		assert.Equal(t, "pinned", lookup(o, "https://pinned.example.com/x"))
++		assert.Equal(t, "default", lookup(o, "https://pinned.example.com:8443/x"))
++		assert.Equal(t, "wild443", lookup(o, "https://a.wild443.example.com/x"))
++		assert.Equal(t, "wild443", lookup(o, "https://a.wild443.example.com:443/x"))
++		assert.Equal(t, "default", lookup(o, "https://a.wild443.example.com:8443/x"))
++		assert.Equal(t, "wild8443", lookup(o, "https://a.wild8443.example.com:8443/x"))
++		assert.Equal(t, "default", lookup(o, "https://a.wild8443.example.com/x"))
++	})
++	t.Run("own route before wildcard", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://*.example.com", To: to, IDPClientID: "wild"},
++			Policy{From: "https://own.example.com", Path: "/own", To: to, IDPClientID: "own"},
++		)
++		assert.Equal(t, "own", lookup(o, "https://own.example.com/own"))
++		assert.Equal(t, "wild", lookup(o, "https://own.example.com/other"))
++		assert.Equal(t, "wild", lookup(o, "https://else.example.com/own"))
++	})
++	t.Run("regex priority", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://re.example.com", Regex: "^/a/.*$", RegexPriorityOrder: prio(1), To: to, IDPClientID: "low"},
++			Policy{From: "https://re.example.com", Regex: "^/a/b/.*$", RegexPriorityOrder: prio(2), To: to, IDPClientID: "high"},
++		)
++		assert.Equal(t, "high", lookup(o, "https://re.example.com/a/b/c"))
++		assert.Equal(t, "low", lookup(o, "https://re.example.com/a/c"))
++	})
++}

harbor/tasks/pomerium_route_order_contract/solution/solve.sh

@@ -0,0 +1,543 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/config/envoyconfig/route_configurations.go b/config/envoyconfig/route_configurations.go
+index 2aa0752..c43de28 100644
+--- a/config/envoyconfig/route_configurations.go
++++ b/config/envoyconfig/route_configurations.go
+@@ -85,12 +85,18 @@ func (b *Builder) buildMainRouteConfiguration(
+ 		return nil, err
+ 	}
+ 
++	explicitPortOnly := explicitPortOnlyHosts(cfg.Options)
++
+ 	var virtualHosts []*envoy_config_route_v3.VirtualHost
+ 	for _, host := range allHosts {
+ 		vh, err := b.buildVirtualHost(cfg.Options, host, host, mcpHosts[host])
+ 		if err != nil {
+ 			return nil, err
+ 		}
++		if explicitPortOnly[host] {
++			// every route of this host names its port: it is not served on any port
++			vh.Domains = []string{host}
++		}
+ 
+ 		if cfg.Options.Addr == cfg.Options.GetGRPCAddr() {
+ 			// if this is a gRPC service domain and we're supposed to handle that, add those routes
+@@ -212,11 +218,15 @@ func getAllRouteableHosts(options *config.Options, addr string) ([]string, map[s
+ 		if err != nil {
+ 			return nil, nil, err
+ 		}
+-		allHosts.InsertSlice(hosts)
++		// host names carry no case: two from addresses that spell one host
++		// differently are one virtual host, not two envoy would reject
++		for _, host := range hosts {
++			allHosts.Insert(strings.ToLower(host))
++		}
+ 		// Merge any MCP hosts
+ 		for host, isMCP := range hostsMCP {
+ 			if isMCP {
+-				mcpHosts[host] = true
++				mcpHosts[strings.ToLower(host)] = true
+ 			}
+ 		}
+ 	}
+@@ -226,7 +236,9 @@ func getAllRouteableHosts(options *config.Options, addr string) ([]string, map[s
+ 		if err != nil {
+ 			return nil, nil, err
+ 		}
+-		allHosts.InsertSlice(hosts)
++		for _, host := range hosts {
++			allHosts.Insert(strings.ToLower(host))
++		}
+ 	}
+ 
+ 	var filtered []string
+@@ -256,6 +268,31 @@ func urlsMatchHost(urls []*url.URL, host string) bool {
+ 	return false
+ }
+ 
++// explicitPortOnlyHosts returns the hosts whose policy from URLs all carry a port.
++func explicitPortOnlyHosts(options *config.Options) map[string]bool {
++	withPort, withoutPort := map[string]bool{}, map[string]bool{}
++	for p := range options.GetAllPolicies() {
++		if p.IsSSH() {
++			continue
++		}
++		u, err := urlutil.ParseAndValidateURL(p.From)
++		if err != nil || strings.Contains(u.Host, "*") {
++			continue
++		}
++		if u.Port() != "" {
++			withPort[strings.ToLower(u.Hostname())] = true
++		} else {
++			withoutPort[strings.ToLower(u.Hostname())] = true
++		}
++	}
++	for h := range withoutPort {
++		delete(withPort, h)
++	}
++	return withPort
++}
++
+ func urlMatchesHost(u *url.URL, host string) bool {
+-	return slices.Contains(urlutil.GetDomainsForURL(u, true), host)
++	return slices.ContainsFunc(urlutil.GetDomainsForURL(u, true), func(domain string) bool {
++		return strings.EqualFold(domain, host)
++	})
+ }
+diff --git a/config/envoyconfig/route_order_test.go b/config/envoyconfig/route_order_test.go
+new file mode 100644
+index 0000000..85148c2
+--- /dev/null
++++ b/config/envoyconfig/route_order_test.go
+@@ -0,0 +1,56 @@
++package envoyconfig
++
++import (
++	"testing"
++
++	envoy_config_route_v3 "github.com/envoyproxy/go-control-plane/envoy/config/route/v3"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/pomerium/pomerium/config"
++	"github.com/pomerium/pomerium/config/envoyconfig/filemgr"
++)
++
++func TestBuilder_buildMainRouteConfiguration_RouteOrder(t *testing.T) {
++	t.Parallel()
++
++	prio := func(v int64) *int64 { return &v }
++	opts := config.NewDefaultOptions()
++	opts.Services = "proxy"
++	opts.Policies = []config.Policy{
++		{From: "https://*.example.com", To: mustParseWeightedURLs(t, "https://wild.internal")},
++		{From: "https://own.example.com", Path: "/own", To: mustParseWeightedURLs(t, "https://own.internal")},
++		{From: "https://own.example.com", Regex: "^/a/.*$", RegexPriorityOrder: prio(1), To: mustParseWeightedURLs(t, "https://low.internal")},
++		{From: "https://own.example.com", Regex: "^/a/b/.*$", RegexPriorityOrder: prio(2), To: mustParseWeightedURLs(t, "https://high.internal")},
++		{From: "https://pinned.example.com:443", To: mustParseWeightedURLs(t, "https://pinned.internal")},
++	}
++	b := New("connect", "grpc", "http", "debug", "metrics", filemgr.NewManager(), nil, true)
++	rc, err := b.buildMainRouteConfiguration(t.Context(), config.New(opts))
++	require.NoError(t, err)
++
++	vhosts := map[string]*envoy_config_route_v3.VirtualHost{}
++	for _, vh := range rc.GetVirtualHosts() {
++		vhosts[vh.GetName()] = vh
++	}
++	policyRoutes := func(vh *envoy_config_route_v3.VirtualHost) []string {
++		var names []string
++		for _, r := range vh.GetRoutes() {
++			if len(r.GetName()) > len("policy-") && r.GetName()[:len("policy-")] == "policy-" {
++				names = append(names, r.GetName())
++			}
++		}
++		return names
++	}
++
++	own := vhosts["own.example.com"]
++	require.NotNil(t, own)
++	// higher priority first, then the rest of the host's own routes, then the
++	// wildcard routes (one per wildcard domain)
++	assert.Equal(t, []string{"policy-3", "policy-2", "policy-1", "policy-0"}, policyRoutes(own))
++	assert.Equal(t, []string{"own.example.com", "own.example.com:*"}, own.GetDomains())
++
++	pinned := vhosts["pinned.example.com"]
++	require.NotNil(t, pinned)
++	assert.Equal(t, []string{"pinned.example.com"}, pinned.GetDomains())
++	assert.NotNil(t, vhosts["pinned.example.com:443"])
++}
+diff --git a/config/envoyconfig/routes.go b/config/envoyconfig/routes.go
+index f8c1d5a..5e7c3cf 100644
+--- a/config/envoyconfig/routes.go
++++ b/config/envoyconfig/routes.go
+@@ -3,7 +3,9 @@ package envoyconfig
+ import (
+ 	"encoding/json"
+ 	"fmt"
++	"net"
+ 	"net/url"
++	"regexp"
+ 	"slices"
+ 	"sort"
+ 	"strings"
+@@ -195,32 +197,100 @@ func (b *Builder) buildRoutesForPoliciesWithHost(
+ 	host string,
+ ) ([]*envoy_config_route_v3.Route, error) {
+ 	var routes []*envoy_config_route_v3.Route
+-	for i, p := range cfg.Options.GetAllPoliciesIndexed() {
+-		policy := p
+-		fromURL, err := urlutil.ParseAndValidateURL(policy.From)
+-		if err != nil {
+-			return nil, err
+-		}
++	// the host's own routes come first, then the wildcard routes that match the
++	// host: envoy never consults the catch-all virtual host for a host that has
++	// a virtual host of its own
++	for _, wildcard := range []bool{false, true} {
++		for i, policy := range cfg.Options.GetAllPoliciesInRouteOrder() {
++			fromURL, err := urlutil.ParseAndValidateURL(policy.From)
++			if err != nil {
++				return nil, err
++			}
+ 
+-		if !urlMatchesHost(fromURL, host) {
+-			continue
+-		}
++			if strings.Contains(fromURL.Host, "*") != wildcard {
++				continue
++			}
++			if wildcard && !wildcardURLMatchesHost(cfg.Options, fromURL, host) {
++				continue
++			}
++			// a route whose from address names a port answers only on that port,
++			// even on a host that other routes serve on every port
++			var onlyAuthority string
++			if !wildcard {
++				switch {
++				case urlMatchesHost(fromURL, host):
++					if fromURL.Port() != "" && !config.HasPort(host) {
++						onlyAuthority = "(?i)^" + regexp.QuoteMeta(fromURL.Hostname()) + "(:" + fromURL.Port() + ")?$"
++					}
++				case portlessURLServesHostPort(cfg.Options, fromURL, host):
++					// a from address without a port serves this port as well
++				default:
++					continue
++				}
++			}
+ 
+-		policyRoutes, err := b.buildRoutesForPolicy(cfg, policy, fmt.Sprintf("policy-%d", i))
+-		if err != nil {
+-			return nil, err
+-		}
++			policyRoutes, err := b.buildRoutesForPolicy(cfg, policy, fmt.Sprintf("policy-%d", i))
++			if err != nil {
++				return nil, err
++			}
++			if onlyAuthority != "" {
++				for _, r := range policyRoutes {
++					r.Match.Headers = append(r.Match.Headers, &envoy_config_route_v3.HeaderMatcher{
++						Name: ":authority",
++						HeaderMatchSpecifier: &envoy_config_route_v3.HeaderMatcher_StringMatch{
++							StringMatch: &envoy_type_matcher_v3.StringMatcher{
++								MatchPattern: &envoy_type_matcher_v3.StringMatcher_SafeRegex{
++									SafeRegex: &envoy_type_matcher_v3.RegexMatcher{Regex: onlyAuthority},
++								},
++							},
++						},
++					})
++				}
++			}
+ 
+-		routes = append(routes, policyRoutes...)
++			routes = append(routes, policyRoutes...)
++		}
+ 	}
+ 	return routes, nil
+ }
+ 
++// portlessURLServesHostPort reports whether a from URL without a port serves a
++// virtual host that names a port: such a route serves every port of its host.
++func portlessURLServesHostPort(options *config.Options, u *url.URL, host string) bool {
++	if !options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) || u.Port() != "" ||
++		strings.Contains(u.Host, "*") || !config.HasPort(host) {
++		return false
++	}
++	hostname, _, err := net.SplitHostPort(host)
++	return err == nil && strings.EqualFold(u.Hostname(), hostname)
++}
++
++func wildcardURLMatchesHost(options *config.Options, u *url.URL, host string) bool {
++	stripPort := options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)
++	anyPort := stripPort && u.Port() == ""
++	host = strings.ToLower(host)
++	for _, domain := range urlutil.GetDomainsForURL(u, !anyPort) {
++		domain = strings.ToLower(domain)
++		if stripPort && !config.HasPort(host) {
++			// this virtual host serves its host on every port: a wildcard that
++			// names a port belongs in it too, its :authority match keeps it to
++			// that port
++			if hostname, _, err := net.SplitHostPort(domain); err == nil {
++				domain = hostname
++			}
++		}
++		if regexp.MustCompile(config.WildcardToRegex(domain, anyPort)).MatchString(host) {
++			return true
++		}
++	}
++	return false
++}
++
+ func (b *Builder) buildRoutesForPoliciesWithCatchAll(
+ 	cfg *config.Config,
+ ) ([]*envoy_config_route_v3.Route, error) {
+ 	var routes []*envoy_config_route_v3.Route
+-	for i, policy := range cfg.Options.GetAllPoliciesIndexed() {
++	for i, policy := range cfg.Options.GetAllPoliciesInRouteOrder() {
+ 		fromURL, err := urlutil.ParseAndValidateURL(policy.From)
+ 		if err != nil {
+ 			return nil, err
+@@ -252,9 +322,12 @@ func (b *Builder) buildRoutesForPolicy(
+ 
+ 	var routes []*envoy_config_route_v3.Route
+ 	if strings.Contains(fromURL.Host, "*") {
+-		// we have to match '*.example.com' and '*.example.com:443', so there are two routes
+-		for _, host := range urlutil.GetDomainsForURL(fromURL, !cfg.Options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)) {
+-			route, err := b.buildRouteForPolicyAndMatch(cfg, policy, name, mkRouteMatchForHost(cfg.Options, policy, host))
++		// we have to match '*.example.com' and '*.example.com:443', so there are two routes;
++		// a wildcard address that names its port, the default one included, keeps
++		// both and is served on that port only
++		anyPort := cfg.Options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) && fromURL.Port() == ""
++		for _, host := range urlutil.GetDomainsForURL(fromURL, !anyPort) {
++			route, err := b.buildRouteForPolicyAndMatch(cfg, policy, name, mkRouteMatchForHost(cfg.Options, policy, host, anyPort))
+ 			if err != nil {
+ 				return nil, err
+ 			}
+@@ -560,15 +633,22 @@ func mkRouteMatchForHost(
+ 	options *config.Options,
+ 	policy *config.Policy,
+ 	host string,
++	anyPort bool,
+ ) *envoy_config_route_v3.RouteMatch {
+ 	match := mkRouteMatch(policy)
++	// the expression is written in lower case, the way a host name is compared
++	regex := config.WildcardToRegex(strings.ToLower(host), anyPort)
++	if options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort) {
++		// a host name carries no case, however the request spells it
++		regex = "(?i)" + regex
++	}
+ 	match.Headers = append(match.Headers, &envoy_config_route_v3.HeaderMatcher{
+ 		Name: ":authority",
+ 		HeaderMatchSpecifier: &envoy_config_route_v3.HeaderMatcher_StringMatch{
+ 			StringMatch: &envoy_type_matcher_v3.StringMatcher{
+ 				MatchPattern: &envoy_type_matcher_v3.StringMatcher_SafeRegex{
+ 					SafeRegex: &envoy_type_matcher_v3.RegexMatcher{
+-						Regex: config.WildcardToRegex(host, options.IsRuntimeFlagSet(config.RuntimeFlagMatchAnyIncomingPort)),
++						Regex: regex,
+ 					},
+ 				},
+ 			},
+diff --git a/config/from.go b/config/from.go
+index c5d5cd9..09944d5 100644
+--- a/config/from.go
++++ b/config/from.go
+@@ -10,8 +10,22 @@ import (
+ 
+ // FromURLMatchesRequestURL returns true if the from URL matches the request URL.
+ func FromURLMatchesRequestURL(fromURL, requestURL *url.URL, stripPort bool) bool {
++	// host names are not case sensitive: fold both sides before comparing, so
++	// that a from address and a request naming the same host agree however
++	// either of them happens to be spelled
++	reqHost := strings.ToLower(requestURL.Host)
++	reqHostname := strings.ToLower(requestURL.Hostname())
++
++	// a from URL without a port matches any port
++	if stripPort && fromURL.Port() == "" && !strings.Contains(fromURL.Host, "*") &&
++		!strings.HasPrefix(fromURL.Scheme, "tcp+") && !strings.HasPrefix(fromURL.Scheme, "udp+") &&
++		strings.ToLower(fromURL.Hostname()) == reqHostname {
++		return true
++	}
++
+ 	for _, domain := range urlutil.GetDomainsForURL(fromURL, true) {
+-		if domain == requestURL.Host {
++		domain = strings.ToLower(domain)
++		if domain == reqHost {
+ 			return true
+ 		}
+ 
+@@ -19,9 +33,16 @@ func FromURLMatchesRequestURL(fromURL, requestURL *url.URL, stripPort bool) bool
+ 			continue
+ 		}
+ 
+-		reStr := WildcardToRegex(domain, stripPort)
++		// a wildcard address that names a port answers on that port only
++		reStr := WildcardToRegex(domain, stripPort && fromURL.Port() == "")
+ 		re := regexp.MustCompile(reStr)
+-		if re.MatchString(requestURL.Host) {
++		// the proxy folds the case of a request only where it serves any port:
++		// elsewhere the lookup reads the request the way the proxy does
++		host := reqHost
++		if !stripPort {
++			host = requestURL.Host
++		}
++		if re.MatchString(host) {
+ 			return true
+ 		}
+ 	}
+diff --git a/config/identity.go b/config/identity.go
+index 2117b5f..5e1c7cb 100644
+--- a/config/identity.go
++++ b/config/identity.go
+@@ -3,6 +3,7 @@ package config
+ import (
+ 	"context"
+ 	"slices"
++	"strings"
+ 
+ 	oteltrace "go.opentelemetry.io/otel/trace"
+ 
+@@ -91,12 +92,23 @@ func (o *Options) GetIdentityProviderForRequestURL(requestURL string) (*identity
+ 		return nil, err
+ 	}
+ 
+-	for p := range o.GetAllPolicies() {
+-		if p.Matches(u, o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort)) {
+-			return o.GetIdentityProviderForPolicy(p)
++	// the same order the proxy matches in: route order, and a host's own
++	// routes before wildcard routes
++	stripPort := o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort)
++	var wildcard *Policy
++	for _, p := range o.GetAllPoliciesInRouteOrder() {
++		if !p.Matches(u, stripPort) {
++			continue
++		}
++		if strings.Contains(p.From, "*") {
++			if wildcard == nil {
++				wildcard = p
++			}
++			continue
+ 		}
++		return o.GetIdentityProviderForPolicy(p)
+ 	}
+-	return o.GetIdentityProviderForPolicy(nil)
++	return o.GetIdentityProviderForPolicy(wildcard)
+ }
+ 
+ // GetAuthenticator gets the authenticator for the given IDP id.
+diff --git a/config/options.go b/config/options.go
+index ad93c0a..74c7541 100644
+--- a/config/options.go
++++ b/config/options.go
+@@ -1075,6 +1075,40 @@ func (o *Options) GetAllPoliciesIndexed() iter.Seq2[int, *Policy] {
+ 	}
+ }
+ 
++// GetAllPoliciesInRouteOrder returns all the policies, with their configuration
++// index, in the order requests are matched against them: configuration order,
++// except that a policy with a higher regex_priority_order comes first.
++func (o *Options) GetAllPoliciesInRouteOrder() iter.Seq2[int, *Policy] {
++	type indexedPolicy struct {
++		index  int
++		policy *Policy
++	}
++	var all []indexedPolicy
++	for i, p := range o.GetAllPoliciesIndexed() {
++		all = append(all, indexedPolicy{i, p})
++	}
++	slices.SortStableFunc(all, func(a, b indexedPolicy) int {
++		x, y := a.policy.RegexPriorityOrder, b.policy.RegexPriorityOrder
++		switch {
++		case x == nil && y == nil:
++			return 0
++		case x == nil:
++			return 1
++		case y == nil:
++			return -1
++		default:
++			return cmp.Compare(*y, *x)
++		}
++	})
++	return func(yield func(int, *Policy) bool) {
++		for _, e := range all {
++			if !yield(e.index, e.policy) {
++				return
++			}
++		}
++	}
++}
++
+ func (o *Options) NumPolicies() int {
+ 	return len(o.Policies) + len(o.Routes) + len(o.AdditionalPolicies)
+ }
+@@ -1373,7 +1407,8 @@ func (o *Options) GetAllRouteableHTTPHosts() ([]string, map[string]bool, error)
+ 				return nil, nil, err
+ 			}
+ 
+-			domains := urlutil.GetDomainsForURL(fromURL, !o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort))
++			// a from URL with a port is served on that port, so it keeps it
++			domains := urlutil.GetDomainsForURL(fromURL, !o.IsRuntimeFlagSet(RuntimeFlagMatchAnyIncomingPort) || fromURL.Port() != "")
+ 			hosts.InsertSlice(domains)
+ 
+ 			// Track if the domains are associated with an MCP policy
+diff --git a/config/route_order_test.go b/config/route_order_test.go
+new file mode 100644
+index 0000000..c2ebd62
+--- /dev/null
++++ b/config/route_order_test.go
+@@ -0,0 +1,72 @@
++package config
++
++import (
++	"testing"
++
++	"github.com/stretchr/testify/assert"
++)
++
++func TestGetIdentityProviderForRequestURL_RouteOrder(t *testing.T) {
++	t.Parallel()
++
++	prio := func(v int64) *int64 { return &v }
++	opts := func(policies ...Policy) *Options {
++		o := NewDefaultOptions()
++		o.AuthenticateURLString = "https://authenticate.example.com"
++		o.ClientID = "default"
++		o.ClientSecret = "secret"
++		o.Provider = "oidc"
++		o.ProviderURL = "https://idp.example.com"
++		o.Policies = policies
++		for i := range o.Policies {
++			assert.NoError(t, o.Policies[i].Validate())
++		}
++		return o
++	}
++	lookup := func(o *Options, u string) string {
++		idp, err := o.GetIdentityProviderForRequestURL(u)
++		if !assert.NoError(t, err) {
++			return ""
++		}
++		return idp.GetClientId()
++	}
++	to := mustParseWeightedURLs(t, "https://to.example.com")
++
++	t.Run("ports", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://any.example.com", To: to, IDPClientID: "any"},
++			Policy{From: "https://pinned.example.com:443", To: to, IDPClientID: "pinned"},
++			Policy{From: "https://*.wild443.example.com:443", To: to, IDPClientID: "wild443"},
++			Policy{From: "https://*.wild8443.example.com:8443", To: to, IDPClientID: "wild8443"},
++		)
++		assert.Equal(t, "any", lookup(o, "https://any.example.com:8443/x"))
++		assert.Equal(t, "any", lookup(o, "https://any.example.com/x"))
++		assert.Equal(t, "pinned", lookup(o, "https://pinned.example.com/x"))
++		assert.Equal(t, "default", lookup(o, "https://pinned.example.com:8443/x"))
++		assert.Equal(t, "wild443", lookup(o, "https://a.wild443.example.com/x"))
++		assert.Equal(t, "wild443", lookup(o, "https://a.wild443.example.com:443/x"))
++		assert.Equal(t, "default", lookup(o, "https://a.wild443.example.com:8443/x"))
++		assert.Equal(t, "wild8443", lookup(o, "https://a.wild8443.example.com:8443/x"))
++		assert.Equal(t, "default", lookup(o, "https://a.wild8443.example.com/x"))
++	})
++	t.Run("own route before wildcard", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://*.example.com", To: to, IDPClientID: "wild"},
++			Policy{From: "https://own.example.com", Path: "/own", To: to, IDPClientID: "own"},
++		)
++		assert.Equal(t, "own", lookup(o, "https://own.example.com/own"))
++		assert.Equal(t, "wild", lookup(o, "https://own.example.com/other"))
++		assert.Equal(t, "wild", lookup(o, "https://else.example.com/own"))
++	})
++	t.Run("regex priority", func(t *testing.T) {
++		t.Parallel()
++		o := opts(
++			Policy{From: "https://re.example.com", Regex: "^/a/.*$", RegexPriorityOrder: prio(1), To: to, IDPClientID: "low"},
++			Policy{From: "https://re.example.com", Regex: "^/a/b/.*$", RegexPriorityOrder: prio(2), To: to, IDPClientID: "high"},
++		)
++		assert.Equal(t, "high", lookup(o, "https://re.example.com/a/b/c"))
++		assert.Equal(t, "low", lookup(o, "https://re.example.com/a/c"))
++	})
++}
+
+REFERENCE_PATCH

harbor/tasks/pomerium_route_order_contract/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "pomerium_route_order_contract"
+validation_revision = "coding-rubric-v2"
+[agent]
+timeout_sec = 1800
+user = "1000:1000"
+[environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[verifier]
+timeout_sec = 7200
+user = "0"
+environment_mode = "separate"
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/pomerium_route_order_contract/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-pomerium:source-v10
+USER root
+RUN grep -q '^[^:]*:[^:]*:1000:' /etc/passwd || echo 'grader:x:1000:1000::/tmp/agent-home:/bin/sh' >> /etc/passwd; grep -q '^[^:]*:[^:]*:1000:' /etc/group || echo 'grader:x:1000:' >> /etc/group
+ENV HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 HUD_FILE_TRACKING_ENABLED=false
+RUN rm -f /hud/gold.diff
+COPY verify.py evidence.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/pomerium_route_order_contract/tests/config.json

@@ -0,0 +1,112 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "pomerium_route_order_contract",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-pomerium:source-v10",
+  "source_image_id": "sha256:fd5dc4a78767a4430c8fc7c261dcecd3feb49e992bdc1d1f0c307caa7caa1193",
+  "provenance": {
+    "repository": "pomerium/pomerium",
+    "environment_id": "27189e2e-0d13-4bdf-83c7-7e5b413706f2",
+    "build": 10,
+    "build_id": "8d4d701f-12e8-44da-b079-95a78cafd767",
+    "hosted_task": "pomerium_route_order_contract",
+    "task_version": "abdcd9d0-572f-46b4-8b17-d67e4d4fa19e",
+    "source_archive_sha256": "669b8e3af43969044d3b0751e602888447e1e33bdc8649f0a9121848cecd3a84",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "explicit_port_route_serves_only_that_port",
+      0.28,
+      true,
+      "bash",
+      900
+    ],
+    [
+      "regex_priority_settles_routes_that_name_the_port_in_any_case",
+      0.1,
+      true,
+      "bash",
+      900
+    ],
+    [
+      "wildcard_route_serves_host_with_own_routes_in_any_case",
+      0.1525,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "explicit_port_from_written_in_capitals_serves_only_that_port",
+      0.1525,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "regex_priority_and_wildcard_fallback_in_any_case",
+      0.1525,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "inproc_lookup_matches_the_proxy_in_any_case",
+      0.1525,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.01,
+      true,
+      "bash",
+      1800
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "weighted_cap",
+  "local_hostname": false,
+  "fault_exit": 3,
+  "grader_readable": [],
+  "grader_writable": [],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/tasks.py": "a87312ea210c0d54280553db17370d4ad59f6d77d5662c8c12a947b95c3decd9",
+    "/app/env.py": "b53cd954bff21786840b391bd1dbb88b4c222accf24b33610e216f5780a3aa04",
+    "/app/task/prompt.md": "2720511effd9d9b30f1f5c560be72adf7e95199479660ea3d117d78c71393e03",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/hud/grader/suite_gate.py": "b6fc04b43d5ea6b5a88dc82d6f08ef1d370b81018de5590aa48678c1d7ff7f79",
+    "/hud/grader/run_grading.sh": "0d6c87859be96d31252cec64945db1cd90066186686526a018ce0316e596a50c",
+    "/hud/grader/cells/cells_test.go": "e7eb2cf03dd31cf00088b2713612aa0ccd7da8909cedc65bf5ddd2ef4c0c0e85"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'go version' || go version"
+    ],
+    [
+      "/usr/local/bin/python3",
+      "--version"
+    ]
+  ]
+}

harbor/tasks/pomerium_route_order_contract/tests/docker-compose.yaml

@@ -0,0 +1,6 @@
+services:
+  main:
+    network_mode: none
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true

harbor/tasks/pomerium_route_order_contract/tests/evidence.py

@@ -0,0 +1,123 @@
+"""Validate complete coding-rubric evidence without importing the grader library or Harbor."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REVISION = "coding-rubric-v2"
+
+
+def _number(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise ValueError("Expected numeric rubric evidence")
+    if not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValueError("Rubric values must be finite and within [0, 1]")
+    return float(value)
+
+
+def validate_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check provenance, criterion coverage, weights, caps and command outcomes.
+
+    Parameters
+    ----------
+    report, config : dict
+        Fresh verifier evidence and the trusted prepared task configuration.
+    digest : str
+        SHA-256 of the submission collected by Harbor.
+
+    Raises
+    ------
+    ValueError
+        If evidence is missing, inconsistent or reports infrastructure failure.
+    """
+    if (
+        report.get("revision") != REVISION
+        or report.get("task_id") != config["task_id"]
+        or report.get("patch_sha256") != digest
+        or report.get("grader_version") != config["grader_version"]
+    ):
+        raise ValueError("Verifier evidence provenance mismatch")
+    result = report.get("result", {})
+    reward = _number(result.get("reward"))
+    # A rubric may flag its own result when a grader could not judge. That is
+    # admitted only together with proof, checked below, that the same grader
+    # reaches a verdict on the untouched repository.
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in report.get("commands", [])
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    flagged = result.get("isError", False)
+    if (flagged and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    status = report.get("status")
+    if status == "rejected_patch":
+        if reward != 0 or not report.get("patch_error") or result.get("subscores"):
+            raise ValueError("Invalid rejected-patch evidence")
+        return
+    if status == "empty_patch":
+        credited = any(_number(row["value"]) for row in result.get("subscores") or [])
+        if reward != 0 or digest != config["empty_sha256"] or report.get("commands") or credited:
+            raise ValueError("Invalid empty-patch evidence")
+        return
+    if status != "graded":
+        raise ValueError("Verifier did not complete")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    if not isinstance(scores, list) or len(scores) != len(expected):
+        raise ValueError("Missing rubric criteria")
+    names = [row["name"] for row in scores]
+    if len(set(names)) != len(names) or set(names) != set(expected):
+        raise ValueError("Duplicate or unexpected rubric criteria")
+    raw = 0.0
+    values = {}
+    for score in scores:
+        name = score["name"]
+        value, weight = _number(score["value"]), _number(score["weight"])
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    commands = report.get("commands", [])
+    command_names = [row["name"] for row in commands]
+    expected_commands = set(expected) | set(config["gates"])
+    if len(command_names) != len(set(command_names)) or set(command_names) != expected_commands:
+        raise ValueError("Missing or duplicate grader command evidence")
+    for command in commands:
+        info = command.get("info") or {}
+        code = info.get("exit_code")
+        verdict = type(code) is int and (code in (0, 1) or command["name"] in faults)
+        if not verdict or info.get("timed_out"):
+            raise ValueError("Grader command failed outside its verdict contract")
+        if _number(command["value"]) != float(code == 0):
+            raise ValueError("Command exit code disagrees with score")
+    probes = {row["name"]: row for row in report.get("fault_probes") or []}
+    if set(probes) != faults or any(
+        row.get("timed_out") or row.get("exit_code") not in (0, 1) for row in probes.values()
+    ):
+        raise ValueError(
+            "A grader could not judge and the untouched repository does not explain it"
+        )
+    if any(values.get(name, 0) for name in faults):
+        raise ValueError("A criterion its grader could not judge is credited")
+    info = result.get("info") or {}
+    if info.get("aggregate_mismatch") or info.get("git_apply"):
+        raise ValueError("Grader reported inconsistent grading")
+    if config.get("reward_rule") == "authored":
+        # The task's own function decides the reward. It may take credit away
+        # (a cap, a criterion that pays only with progress) but never add any.
+        passed = {row["name"]: row["value"] for row in commands}
+        if any(values[name] > passed[name] for name in expected):
+            raise ValueError("A criterion is credited although its command failed")
+        if reward > raw + 1e-9:
+            raise ValueError("Grader reward exceeds its weighted criteria")
+        return
+    failed = {name for name, row in expected.items() if row[2] and values[name] < 1}
+    gate_failed = {
+        row["name"] for row in commands if row["name"] in config["gates"] and row["value"] < 1
+    }
+    expected_reward = min(raw, config["blocker_cap"]) if failed or gate_failed else raw
+    if not math.isclose(reward, expected_reward, abs_tol=1e-9):
+        raise ValueError("Grader reward disagrees with original weights and blocker cap")

harbor/tasks/pomerium_route_order_contract/tests/test.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -euo pipefail
+echo '127.0.0.1 localhost.pomerium.io api.localhost.pomerium.io api-a.localhost.pomerium.io api-b.localhost.pomerium.io api-k3s.localhost.pomerium.io authenticate.localhost.pomerium.io bench-h1.localhost.pomerium.io bench-h2.localhost.pomerium.io echo.localhost.pomerium.io foo.localhost.pomerium.io grpc-h2c.localhost.pomerium.io grpc-http.localhost.pomerium.io grpc1.localhost.pomerium.io h1.localhost.pomerium.io h2.localhost.pomerium.io http.localhost.pomerium.io http1.localhost.pomerium.io mock-idp.localhost.pomerium.io sampling-50pct.localhost.pomerium.io test.localhost.pomerium.io ws-mid.localhost.pomerium.io ws-test.localhost.pomerium.io ws-test-denied.localhost.pomerium.io' >> /etc/hosts
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/pomerium_route_order_contract/tests/verify.py

@@ -0,0 +1,235 @@
+"""Run the original trusted coding rubric in a fresh, offline verifier container."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from evidence import REVISION, validate_report
+
+OUT = Path("/logs/verifier")
+PRIVATE = Path("/var/lib/task-evidence")
+CONFIG = Path("/tests/config.json")
+PATCH = Path("/workspace/submissions/submitted.patch")
+GRADER_HOME = "/tmp/agent-home"
+
+
+def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs)
+
+
+def _preflight(config: dict[str, Any]) -> None:
+    if importlib.metadata.version("hud") != config["grader_version"]:
+        raise RuntimeError("Grader library version does not match the task")
+    for filename, expected in config["verifier_files"].items():
+        if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Verifier source changed: {filename}")
+    for command in config["preflight"]:
+        completed = _run(command, cwd="/workspace/repo")
+        if completed.returncode:
+            raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}")
+
+
+def _readable_mode(path: Path) -> int:
+    # World-readable, keeping what is executable so: a grader may ship tools.
+    return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644
+
+
+def _permissions() -> None:
+    # The orchestrator owns reports and rubric definitions. Grader commands,
+    # and so the candidate's code, run as uid 1000: the user the task installed
+    # its toolchain and caches for. They cannot read gold/vault or overwrite
+    # the rubric or the result files, which stay root's.
+    Path("/hud").chmod(0o711)
+    for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")):
+        if root.exists():
+            root.chmod(0o755)
+            for path in root.rglob("*"):
+                if not path.is_symlink():
+                    path.chmod(_readable_mode(path))
+    home = Path(GRADER_HOME)
+    home.mkdir(parents=True, exist_ok=True)
+    os.chown(home, 1000, 1000)
+    for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"):
+        path = Path(directory)
+        path.mkdir(parents=True, exist_ok=True)
+        for item in (path, *path.rglob("*")):
+            if not item.is_symlink():
+                os.chown(item, 1000, 1000)
+                item.chmod(_readable_mode(item))
+
+
+def _hand_over_checkout() -> None:
+    # The original grader runs as root and may run the candidate's own suite in
+    # place, which writes into the tree. The rubric resets and re-applies the
+    # candidate as root, so give what root touched back to the grading user.
+    # Installed dependency trees are large and already that user's.
+    subprocess.run(
+        [
+            "find",
+            "/workspace/repo",
+            "-path",
+            "*/node_modules",
+            "-prune",
+            "-o",
+            "!",
+            "-user",
+            "1000",
+            "-exec",
+            "chown",
+            "-h",
+            "1000:1000",
+            "{}",
+            "+",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=3600,
+    )
+
+
+async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None:
+    _preflight(config)
+    sys.path.insert(0, "/app")
+    task: Any = importlib.import_module("tasks")
+    await task._setup()
+    _permissions()
+    patch = PATCH.read_bytes()
+    if patch:
+        checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo")
+        if checked.returncode:
+            record.update(
+                status="rejected_patch",
+                patch_error=checked.stderr[-4000:],
+                result={"reward": 0.0, "subscores": None},
+            )
+            return
+        _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True)
+    original = task.BashGrader
+    fault_exit = config.get("fault_exit")
+    faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = []
+
+    class ObservedGrader:
+        @classmethod
+        async def grade(cls, *args: Any, **kwargs: Any) -> Any:
+            command = kwargs["command"]
+            _hand_over_checkout()
+            kwargs["command"] = (
+                "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs "
+                f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command)
+            )
+            score = await original.grade(*args, **kwargs)
+            snapshot = score.model_dump(mode="json")
+            record["commands"].append(snapshot)
+            (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2))
+            info = snapshot.get("info") or {}
+            if info.get("timed_out") or type(info.get("exit_code")) is not int:
+                raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}")
+            if fault_exit is not None and info["exit_code"] == fault_exit:
+                # The grader says it could not judge. Whether the submission or
+                # the environment is the reason is settled after grading.
+                faulted.append((args, dict(kwargs), snapshot["name"]))
+            elif info["exit_code"] not in (0, 1):
+                raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}")
+            return score
+
+    task.BashGrader = ObservedGrader
+    result = await task._grade(None)
+    if faulted:
+        # Ask the same commands about the untouched repository. A verdict there
+        # means the grader works here and the submission is what it could not
+        # judge, so the criterion stays unmet. No verdict there means the
+        # environment is at fault, and the attempt is invalid.
+        await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD")
+        await task.repo_lib.git(task.REPO_DIR, "clean", "-fd")
+        # Graders keep state between criteria, some of them a copy of the tree
+        # they judged. It describes the submission, so it goes too.
+        for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir():
+            if leftover.is_dir() and not leftover.is_symlink():
+                shutil.rmtree(leftover)
+            else:
+                leftover.unlink()
+        record["fault_probes"] = []
+        for args, kwargs, name in faulted:
+            _hand_over_checkout()
+            probe = (await original.grade(*args, **kwargs)).model_dump(mode="json")
+            info = probe.get("info") or {}
+            record["fault_probes"].append(
+                {
+                    "name": name,
+                    "exit_code": info.get("exit_code"),
+                    "timed_out": info.get("timed_out"),
+                    "stdout": (info.get("stdout") or "")[-2000:],
+                }
+            )
+            (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2))
+            if info.get("timed_out") or info.get("exit_code") not in (0, 1):
+                raise RuntimeError(f"Grader cannot judge the untouched repository: {name}")
+    record["result"] = result.model_dump(mode="json")
+    # A rubric may answer an empty change without running any criterion.
+    record["status"] = "empty_patch" if not patch and not record["commands"] else "graded"
+
+
+def _stop_candidate_processes() -> None:
+    # A candidate may fork. End its UID's processes before publishing evidence
+    # to a host bind mount, whose permissions may differ on Docker Desktop.
+    for directory in Path("/proc").iterdir():
+        if not directory.name.isdecimal():
+            continue
+        try:
+            status = (directory / "status").read_text()
+            uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:"))
+            if uid == "1000":
+                os.kill(int(directory.name), signal.SIGKILL)
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+
+
+def main() -> None:
+    """Persist structured evidence and publish reward only after validation."""
+    OUT.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+    PRIVATE.chmod(0o700)
+    reward_path = OUT / "reward.txt"
+    reward_path.unlink(missing_ok=True)
+    config = json.loads(CONFIG.read_text())
+    shutil.copy2(CONFIG, OUT / "config.json")
+    record: dict[str, Any] = {
+        "revision": REVISION,
+        "task_id": config["task_id"],
+        "grader_version": importlib.metadata.version("hud"),
+        "commands": [],
+        "status": "error",
+    }
+    try:
+        if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024:
+            raise ValueError("Missing, oversized or symlink submission")
+        record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest()
+        try:
+            asyncio.run(_grade(config, record))
+        finally:
+            _stop_candidate_processes()
+        reward_path.unlink(missing_ok=True)
+        validate_report(record, config, record["patch_sha256"])
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        reward_path.write_text(str(record["result"]["reward"]) + "\n")
+    except BaseException as error:
+        reward_path.unlink(missing_ok=True)
+        record.update(status="error", error={"type": type(error).__name__, "message": str(error)})
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        raise
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/shared_handle_abandoned_operations/environment/Dockerfile

@@ -0,0 +1,20 @@
+FROM ec-swe-rust-postgres:source-v6 AS sanitized
+USER root
+COPY sanitize.py capture.py capture_submission.py /opt/task-tools/
+RUN HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 /opt/hudvenv/bin/python /opt/task-tools/sanitize.py
+FROM scratch
+COPY --from=sanitized / /
+ENV PATH="/cargo/bin:/usr/lib/postgresql/18/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+ENV CARGO_NET_OFFLINE="true"
+ENV CARGO_TARGET_DIR="/agent-target"
+ENV CARGO_HOME="/cargo"
+ENV CARGO_BUILD_JOBS="2"
+ENV RUSTUP_HOME="/usr/local/rustup"
+ENV HOME="/tmp/agent-home"
+ENV GOCACHE="/tmp/agent-home/.cache/go-build"
+ENV HUD_TELEMETRY_ENABLED="false"
+ENV HUD_CLI_ANALYTICS_ENABLED="0"
+WORKDIR /workspace/repo
+USER 1000:1000
+CMD ["sleep", "infinity"]

harbor/tasks/shared_handle_abandoned_operations/environment/capture.py

@@ -0,0 +1,28 @@
+"""Capture a patch against protected baseline history inside the agent sandbox."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, "/opt/task-tools")
+from capture_submission import capture_submission  # noqa: E402
+
+with tempfile.TemporaryDirectory(prefix="capture-") as directory:
+    git_dir = Path(directory) / "git"
+    shutil.copytree("/opt/task-tools/baseline.git", git_dir)
+    os.environ.update(
+        GIT_DIR=str(git_dir),
+        GIT_WORK_TREE="/workspace/repo",
+        GIT_CONFIG_NOSYSTEM="1",
+        GIT_CONFIG_GLOBAL="/dev/null",
+    )
+    print(
+        json.dumps(
+            capture_submission(
+                Path("/workspace/repo"), Path("/workspace/submissions/submitted.patch")
+            )
+        )
+    )

harbor/tasks/shared_handle_abandoned_operations/environment/capture_submission.py

@@ -0,0 +1,157 @@
+"""Capture tracked and new SWE files without changing the agent's Git index."""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+MAX_SUBMISSION_BYTES = 32 * 1024 * 1024
+
+
+def capture_submission(
+    repository: Path, output: Path, *, max_bytes: int = MAX_SUBMISSION_BYTES
+) -> dict[str, object]:
+    """Write a bounded binary patch including nonignored new files.
+
+    Parameters
+    ----------
+    repository : Path
+        Git checkout root. HEAD must remain the task's initial commit.
+    output : Path
+        Submission path outside the checkout. Replaces any prior submission.
+    max_bytes : int, default: 33554432
+        Maximum emitted patch size. Oversized submissions fail without a patch.
+
+    Returns
+    -------
+    dict
+        Patch size, SHA-256, base commit and capture format for trial evidence.
+
+    Raises
+    ------
+    ValueError
+        If paths or the limit are invalid, or the patch exceeds the limit.
+    OSError, subprocess.CalledProcessError, RuntimeError
+        If capture fails. No partial patch is published.
+
+    Notes
+    -----
+    Uses a temporary index to combine staged, unstaged and untracked changes.
+    Ignored untracked files are excluded. This is a capture bound, not a total
+    sandbox disk quota or a security boundary against a malicious Git runtime.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    repository = repository.resolve(strict=True)
+    if output.is_symlink():
+        raise ValueError("Submission output must not be a symlink")
+    output = output.resolve()
+    if output.is_relative_to(repository):
+        raise ValueError("Submission output must be outside the repository")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.unlink(missing_ok=True)
+    root = subprocess.check_output(
+        ["git", "rev-parse", "--show-toplevel"], cwd=repository, text=True
+    ).strip()
+    if Path(root).resolve() != repository:
+        raise ValueError("repository must be the Git checkout root")
+    base = subprocess.check_output(
+        ["git", "rev-parse", "--verify", "HEAD^{commit}"], cwd=repository, text=True
+    ).strip()
+    with tempfile.TemporaryDirectory(prefix="submission-", dir=output.parent) as directory:
+        temporary = Path(directory)
+        env = {**os.environ, "GIT_INDEX_FILE": str(temporary / "index")}
+        for arguments in (["read-tree", base], ["add", "--all", "--", "."]):
+            subprocess.run(["git", *arguments], cwd=repository, env=env, check=True)
+        patch = temporary / "patch"
+        size = 0
+        digest = hashlib.sha256()
+        with (
+            patch.open("wb") as stream,
+            tempfile.TemporaryFile() as errors,
+            subprocess.Popen(
+                [
+                    "git",
+                    "diff",
+                    "--cached",
+                    "--binary",
+                    "--full-index",
+                    "--no-renames",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                    base,
+                ],
+                cwd=repository,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=errors,
+            ) as process,
+        ):
+            assert process.stdout is not None
+            try:
+                while chunk := process.stdout.read(65536):
+                    size += len(chunk)
+                    if size > max_bytes:
+                        raise ValueError(f"Submission exceeds {max_bytes} bytes")
+                    stream.write(chunk)
+                    digest.update(chunk)
+            except BaseException:
+                process.kill()
+                process.wait()
+                raise
+            if process.wait():
+                errors.seek(0)
+                raise RuntimeError(
+                    "Git patch capture failed: " + errors.read(4096).decode(errors="replace")
+                )
+        patch.replace(output)
+    return {
+        "bytes": size,
+        "sha256": digest.hexdigest(),
+        "base_commit": base,
+        "format": "git-binary-v1",
+    }
+
+
+def submission_command(*, max_bytes: int = MAX_SUBMISSION_BYTES) -> str:
+    """Build the trusted command recorded before Harbor collects artifacts.
+
+    Parameters
+    ----------
+    max_bytes : int, default: 33554432
+        Maximum emitted patch bytes.
+
+    Returns
+    -------
+    str
+        Shell command carrying this exact helper into the solver runtime.
+
+    Raises
+    ------
+    ValueError
+        If the size limit is invalid.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    return "python -c " + shlex.quote(Path(__file__).read_text()) + f" --max-bytes {max_bytes}"
+
+
+def main() -> None:
+    """Capture the submission and print its identity as trial evidence."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=Path("/testbed"))
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submitted.patch"))
+    parser.add_argument("--max-bytes", type=int, default=MAX_SUBMISSION_BYTES)
+    args = parser.parse_args()
+    print(json.dumps(capture_submission(args.repository, args.output, max_bytes=args.max_bytes)))
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/shared_handle_abandoned_operations/environment/docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  main:
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - type: tmpfs
+        target: /logs/verifier
+        tmpfs:
+          mode: 448
+          size: 1048576

harbor/tasks/shared_handle_abandoned_operations/environment/sanitize.py

@@ -0,0 +1,25 @@
+"""Remove private task assets and history when building the agent-only image."""
+
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/app")
+from env import _setup  # noqa: E402
+
+asyncio.run(_setup())
+# The new history contains only the public baseline. Preserve a root-owned
+# copy so capture can ignore agent-controlled refs, hooks and Git configuration.
+shutil.copytree("/workspace/repo/.git", "/opt/task-tools/baseline.git")
+for path in Path("/opt/task-tools/baseline.git").rglob("*"):
+    os.chown(path, 0, 0)
+    path.chmod(0o755 if path.is_dir() else 0o644)
+for name in ("/hud", "/app", "/root/.cache", "/root/.hud"):
+    if Path(name).exists():
+        shutil.rmtree(name)
+# Capture runs on the base interpreter under one name, whatever the image calls it.
+os.symlink(os.path.realpath(sys.executable), "/opt/task-tools/python")
+Path("/workspace/submissions").mkdir()
+os.chown("/workspace/submissions", 1000, 1000)

harbor/tasks/shared_handle_abandoned_operations/instruction.md

@@ -0,0 +1,9 @@
+Please make your changes directly in /workspace/repo.
+
+# Ticket
+
+A connection handle is shared by many concurrent tasks, and any of them may give up on an operation partway through; whatever the server had already set up on that operation's behalf must then be taken back, and the tasks still using the handle must not be able to tell it ever happened.
+
+Two things this change is held to. The crate's existing tests stay exactly as they are; anything you want to check goes into a file of your own. And keep the existing design: what a prepared query or a cursor already does today when it is dropped comes out byte for byte unchanged; add the new cleanup beside that path rather than reworking it into a shared helper.
+
+Finish with a final response when your changes are ready.

harbor/tasks/shared_handle_abandoned_operations/solution/reference.patch

@@ -0,0 +1,180 @@
+diff --git a/tokio-postgres/src/bind.rs b/tokio-postgres/src/bind.rs
+index 06cd14d2..ac1a4f90 100644
+--- a/tokio-postgres/src/bind.rs
++++ b/tokio-postgres/src/bind.rs
+@@ -10,6 +10,34 @@ use std::sync::atomic::{AtomicUsize, Ordering};
+ 
+ static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+ 
++/// Closes the named portal on the server if the `bind` future is dropped before
++/// the `Portal` handle (whose own `Drop` performs the close) has been constructed.
++struct CloseOnDrop<'a> {
++    client: &'a Arc<InnerClient>,
++    name: Option<String>,
++}
++
++impl CloseOnDrop<'_> {
++    fn disarm(mut self) -> String {
++        self.name.take().expect("guard already disarmed")
++    }
++}
++
++impl Drop for CloseOnDrop<'_> {
++    fn drop(&mut self) {
++        if let Some(name) = self.name.take() {
++            let buf = self.client.with_buf(|buf| {
++                frontend::close(b'P', &name, buf).unwrap();
++                frontend::sync(buf);
++                buf.split().freeze()
++            });
++            let _ = self
++                .client
++                .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++        }
++    }
++}
++
+ pub async fn bind<P, I>(
+     client: &Arc<InnerClient>,
+     statement: Statement,
+@@ -28,11 +56,15 @@ where
+     })?;
+ 
+     let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
++    let guard = CloseOnDrop {
++        client,
++        name: Some(name),
++    };
+ 
+     match responses.next().await? {
+         Message::BindComplete => {}
+         _ => return Err(Error::unexpected_message()),
+     }
+ 
+-    Ok(Portal::new(client, name, statement))
++    Ok(Portal::new(client, guard.disarm(), statement))
+ }
+diff --git a/tokio-postgres/src/client.rs b/tokio-postgres/src/client.rs
+index 6d3b03d3..e4136665 100644
+--- a/tokio-postgres/src/client.rs
++++ b/tokio-postgres/src/client.rs
+@@ -786,6 +786,17 @@ impl Client {
+             .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
+     }
+ 
++    #[doc(hidden)]
++    pub fn __private_api_release_savepoint(&self, name: &str) {
++        let buf = self.inner().with_buf(|buf| {
++            frontend::query(&format!("RELEASE {name}"), buf).unwrap();
++            buf.split().freeze()
++        });
++        let _ = self
++            .inner()
++            .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++    }
++
+     #[doc(hidden)]
+     pub fn __private_api_close(&mut self) {
+         self.inner.sender.close_channel()
+diff --git a/tokio-postgres/src/prepare.rs b/tokio-postgres/src/prepare.rs
+index 8484fa33..ad673a4c 100644
+--- a/tokio-postgres/src/prepare.rs
++++ b/tokio-postgres/src/prepare.rs
+@@ -58,6 +58,35 @@ ORDER BY attnum
+ 
+ static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+ 
++/// Closes the named statement on the server if the `prepare` future is dropped
++/// before the `Statement` handle (whose own `Drop` performs the close) has been
++/// constructed.
++struct CloseOnDrop<'a> {
++    client: &'a Arc<InnerClient>,
++    name: Option<String>,
++}
++
++impl CloseOnDrop<'_> {
++    fn disarm(mut self) -> String {
++        self.name.take().expect("guard already disarmed")
++    }
++}
++
++impl Drop for CloseOnDrop<'_> {
++    fn drop(&mut self) {
++        if let Some(name) = self.name.take() {
++            let buf = self.client.with_buf(|buf| {
++                frontend::close(b'S', &name, buf).unwrap();
++                frontend::sync(buf);
++                buf.split().freeze()
++            });
++            let _ = self
++                .client
++                .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++        }
++    }
++}
++
+ pub async fn prepare(
+     client: &Arc<InnerClient>,
+     query: &str,
+@@ -66,6 +95,12 @@ pub async fn prepare(
+     let name = format!("s{}", NEXT_ID.fetch_add(1, Ordering::SeqCst));
+     let buf = encode(client, &name, query, types)?;
+     let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
++    // From this point on the server may own a statement named `name`; make sure
++    // it is closed if this future is abandoned before `Statement` takes over.
++    let guard = CloseOnDrop {
++        client,
++        name: Some(name),
++    };
+ 
+     match responses.next().await? {
+         Message::ParseComplete => {}
+@@ -106,7 +141,7 @@ pub async fn prepare(
+         }
+     }
+ 
+-    Ok(Statement::new(client, name, parameters, columns))
++    Ok(Statement::new(client, guard.disarm(), parameters, columns))
+ }
+ 
+ fn prepare_rec<'a>(
+diff --git a/tokio-postgres/src/transaction.rs b/tokio-postgres/src/transaction.rs
+index 81e8036b..d901764e 100644
+--- a/tokio-postgres/src/transaction.rs
++++ b/tokio-postgres/src/transaction.rs
+@@ -332,7 +332,34 @@ impl<'a> Transaction<'a> {
+         let depth = self.savepoint.as_ref().map_or(0, |sp| sp.depth) + 1;
+         let name = name.unwrap_or_else(|| format!("sp_{depth}"));
+         let query = format!("SAVEPOINT {name}");
+-        self.batch_execute(&query).await?;
++
++        struct ReleaseIfNotDone<'me> {
++            client: &'me Client,
++            name: &'me str,
++            done: bool,
++        }
++
++        impl Drop for ReleaseIfNotDone<'_> {
++            fn drop(&mut self) {
++                if self.done {
++                    return;
++                }
++
++                // The future was dropped after `SAVEPOINT` was sent but before the
++                // nested `Transaction` (which would roll it back on drop) was created.
++                self.client.__private_api_release_savepoint(self.name);
++            }
++        }
++
++        {
++            let mut cleaner = ReleaseIfNotDone {
++                client: self.client,
++                name: &name,
++                done: false,
++            };
++            self.client.batch_execute(&query).await?;
++            cleaner.done = true;
++        }
+ 
+         Ok(Transaction {
+             client: self.client,

harbor/tasks/shared_handle_abandoned_operations/solution/solve.sh

@@ -0,0 +1,186 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/tokio-postgres/src/bind.rs b/tokio-postgres/src/bind.rs
+index 06cd14d2..ac1a4f90 100644
+--- a/tokio-postgres/src/bind.rs
++++ b/tokio-postgres/src/bind.rs
+@@ -10,6 +10,34 @@ use std::sync::atomic::{AtomicUsize, Ordering};
+ 
+ static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+ 
++/// Closes the named portal on the server if the `bind` future is dropped before
++/// the `Portal` handle (whose own `Drop` performs the close) has been constructed.
++struct CloseOnDrop<'a> {
++    client: &'a Arc<InnerClient>,
++    name: Option<String>,
++}
++
++impl CloseOnDrop<'_> {
++    fn disarm(mut self) -> String {
++        self.name.take().expect("guard already disarmed")
++    }
++}
++
++impl Drop for CloseOnDrop<'_> {
++    fn drop(&mut self) {
++        if let Some(name) = self.name.take() {
++            let buf = self.client.with_buf(|buf| {
++                frontend::close(b'P', &name, buf).unwrap();
++                frontend::sync(buf);
++                buf.split().freeze()
++            });
++            let _ = self
++                .client
++                .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++        }
++    }
++}
++
+ pub async fn bind<P, I>(
+     client: &Arc<InnerClient>,
+     statement: Statement,
+@@ -28,11 +56,15 @@ where
+     })?;
+ 
+     let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
++    let guard = CloseOnDrop {
++        client,
++        name: Some(name),
++    };
+ 
+     match responses.next().await? {
+         Message::BindComplete => {}
+         _ => return Err(Error::unexpected_message()),
+     }
+ 
+-    Ok(Portal::new(client, name, statement))
++    Ok(Portal::new(client, guard.disarm(), statement))
+ }
+diff --git a/tokio-postgres/src/client.rs b/tokio-postgres/src/client.rs
+index 6d3b03d3..e4136665 100644
+--- a/tokio-postgres/src/client.rs
++++ b/tokio-postgres/src/client.rs
+@@ -786,6 +786,17 @@ impl Client {
+             .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
+     }
+ 
++    #[doc(hidden)]
++    pub fn __private_api_release_savepoint(&self, name: &str) {
++        let buf = self.inner().with_buf(|buf| {
++            frontend::query(&format!("RELEASE {name}"), buf).unwrap();
++            buf.split().freeze()
++        });
++        let _ = self
++            .inner()
++            .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++    }
++
+     #[doc(hidden)]
+     pub fn __private_api_close(&mut self) {
+         self.inner.sender.close_channel()
+diff --git a/tokio-postgres/src/prepare.rs b/tokio-postgres/src/prepare.rs
+index 8484fa33..ad673a4c 100644
+--- a/tokio-postgres/src/prepare.rs
++++ b/tokio-postgres/src/prepare.rs
+@@ -58,6 +58,35 @@ ORDER BY attnum
+ 
+ static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+ 
++/// Closes the named statement on the server if the `prepare` future is dropped
++/// before the `Statement` handle (whose own `Drop` performs the close) has been
++/// constructed.
++struct CloseOnDrop<'a> {
++    client: &'a Arc<InnerClient>,
++    name: Option<String>,
++}
++
++impl CloseOnDrop<'_> {
++    fn disarm(mut self) -> String {
++        self.name.take().expect("guard already disarmed")
++    }
++}
++
++impl Drop for CloseOnDrop<'_> {
++    fn drop(&mut self) {
++        if let Some(name) = self.name.take() {
++            let buf = self.client.with_buf(|buf| {
++                frontend::close(b'S', &name, buf).unwrap();
++                frontend::sync(buf);
++                buf.split().freeze()
++            });
++            let _ = self
++                .client
++                .send(RequestMessages::Single(FrontendMessage::Raw(buf)));
++        }
++    }
++}
++
+ pub async fn prepare(
+     client: &Arc<InnerClient>,
+     query: &str,
+@@ -66,6 +95,12 @@ pub async fn prepare(
+     let name = format!("s{}", NEXT_ID.fetch_add(1, Ordering::SeqCst));
+     let buf = encode(client, &name, query, types)?;
+     let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
++    // From this point on the server may own a statement named `name`; make sure
++    // it is closed if this future is abandoned before `Statement` takes over.
++    let guard = CloseOnDrop {
++        client,
++        name: Some(name),
++    };
+ 
+     match responses.next().await? {
+         Message::ParseComplete => {}
+@@ -106,7 +141,7 @@ pub async fn prepare(
+         }
+     }
+ 
+-    Ok(Statement::new(client, name, parameters, columns))
++    Ok(Statement::new(client, guard.disarm(), parameters, columns))
+ }
+ 
+ fn prepare_rec<'a>(
+diff --git a/tokio-postgres/src/transaction.rs b/tokio-postgres/src/transaction.rs
+index 81e8036b..d901764e 100644
+--- a/tokio-postgres/src/transaction.rs
++++ b/tokio-postgres/src/transaction.rs
+@@ -332,7 +332,34 @@ impl<'a> Transaction<'a> {
+         let depth = self.savepoint.as_ref().map_or(0, |sp| sp.depth) + 1;
+         let name = name.unwrap_or_else(|| format!("sp_{depth}"));
+         let query = format!("SAVEPOINT {name}");
+-        self.batch_execute(&query).await?;
++
++        struct ReleaseIfNotDone<'me> {
++            client: &'me Client,
++            name: &'me str,
++            done: bool,
++        }
++
++        impl Drop for ReleaseIfNotDone<'_> {
++            fn drop(&mut self) {
++                if self.done {
++                    return;
++                }
++
++                // The future was dropped after `SAVEPOINT` was sent but before the
++                // nested `Transaction` (which would roll it back on drop) was created.
++                self.client.__private_api_release_savepoint(self.name);
++            }
++        }
++
++        {
++            let mut cleaner = ReleaseIfNotDone {
++                client: self.client,
++                name: &name,
++                done: false,
++            };
++            self.client.batch_execute(&query).await?;
++            cleaner.done = true;
++        }
+ 
+         Ok(Transaction {
+             client: self.client,
+
+REFERENCE_PATCH

harbor/tasks/shared_handle_abandoned_operations/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "shared_handle_abandoned_operations"
+validation_revision = "coding-rubric-v2"
+[agent]
+timeout_sec = 1800
+user = "1000:1000"
+[environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[verifier]
+timeout_sec = 7200
+user = "0"
+environment_mode = "separate"
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/shared_handle_abandoned_operations/tests/Dockerfile

@@ -0,0 +1,12 @@
+FROM ec-swe-rust-postgres:source-v6
+USER root
+RUN grep -q '^[^:]*:[^:]*:1000:' /etc/passwd || echo 'grader:x:1000:1000::/tmp/agent-home:/bin/sh' >> /etc/passwd; grep -q '^[^:]*:[^:]*:1000:' /etc/group || echo 'grader:x:1000:' >> /etc/group
+RUN chmod -R a+rX /hud/cells.lock
+RUN chown -R 1000:1000 /hud/cellstarget
+RUN chown -R 1000:1000 /hud/repotarget
+ENV HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 HUD_FILE_TRACKING_ENABLED=false
+RUN rm -f /hud/gold.diff
+COPY verify.py evidence.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/shared_handle_abandoned_operations/tests/config.json

@@ -0,0 +1,234 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "shared_handle_abandoned_operations",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-rust-postgres:source-v6",
+  "source_image_id": "sha256:6e0d4eab87a320005c9028f5675dcd876909c4d8cd02a9297293704c0575cd41",
+  "provenance": {
+    "repository": "sfackler/rust-postgres",
+    "environment_id": "ce1cbe36-00e5-4fde-a2bf-6137d3414ec4",
+    "build": 6,
+    "build_id": "0b011ade-1ef8-4251-baa2-17dfb2c7c7b1",
+    "hosted_task": "shared_handle_abandoned_operations",
+    "task_version": "56f75a82-9a24-4f78-afef-d9c65188b941",
+    "source_archive_sha256": "6499ba0fcd581626bc1052f09d38ac28476ab1a033d2c14da820087b02b3a36f",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "abandoned_rollback_point_not_left_set",
+      0.1342,
+      true,
+      "bash",
+      900
+    ],
+    [
+      "rule_existing_teardown_kept",
+      0.25,
+      true,
+      "bash",
+      120
+    ],
+    [
+      "same_with_the_outer_transaction_intact",
+      0.067,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_one_level_down",
+      0.0596,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "automatic_name_at_depth_not_left_set",
+      0.067,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "inner_point_gone_with_the_enclosing_one_kept",
+      0.0819,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "the_name_is_free_for_the_next_nested_transaction",
+      0.0745,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "a_neighbours_work_survives_the_cleanup",
+      0.067,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_when_the_point_carried_a_name",
+      0.0313,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "abandoned_prepare_leaves_no_server_object",
+      0.0223,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_under_implicit_preparation",
+      0.0164,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_under_typed_preparation",
+      0.0112,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_under_direct_execution",
+      0.0089,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "abandonment_at_the_first_suspension_point",
+      0.0127,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "eight_tasks_on_one_handle",
+      0.0127,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "nothing_left_and_concurrent_readers_correct",
+      0.0164,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "four_abandoning_tasks_and_two_hundred_controls",
+      0.0112,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "same_text_prepared_again_afterwards",
+      0.006,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "micro_timeout_boundary",
+      0.006,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "streaming_upload_path",
+      0.0074,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "streaming_download_path",
+      0.0074,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "abandoned_binding_leaves_no_portal",
+      0.0089,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.02,
+      true,
+      "bash",
+      900
+    ]
+  ],
+  "gates": [
+    "gate_repo_suite_green_and_tests_untouched"
+  ],
+  "reward_rule": "weighted_cap",
+  "local_hostname": false,
+  "fault_exit": 3,
+  "grader_readable": [
+    "/hud/cells.lock"
+  ],
+  "grader_writable": [
+    "/hud/cellstarget",
+    "/hud/repotarget"
+  ],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/tasks.py": "838544623b6da7045315c41477f67c3ae57caf9d9fcef5264f18a08af7b0f8a4",
+    "/app/env.py": "e79c321d2b08a004f496ad793c37c7e8bbf7d5bfb1f4ca1ea4def83fb46f7271",
+    "/app/task/prompt.md": "e672293afc73702ab05be8b72bcc2f17ca5e3ff4d8a4fea2ec887e11343856fd",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/hud/grader/calibrate_host.sh": "934b41dad85689de0ba025554156de437b22d33913dc9d8600b1717570050054",
+    "/hud/grader/board.json": "a23fbce57b1533a55075004fb0117ae6a9c6380ce6d249aa5db5d9a260bf02f5",
+    "/hud/grader/run_grading.sh": "e4a65c915709d5032115fda9f4551dba9cacb8d4827e5261ae892d7b77b798c9",
+    "/hud/grader/score_board.py": "8162554f843ee7500ad0157e823bb5637fafb7eaca21074816a929ac25d096a3",
+    "/hud/grader/cells/Cargo.toml.tmpl": "87e7c6a1e48a963d2097bb05be32e351db106298f16f20175c3cf7bdb76d285a",
+    "/hud/grader/cells/src/main.rs": "b1ad195a3e2411e640e69a819c90edb1cd39b4b10d613f96f7a5b3db24a9531a"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'cargo --version' || cargo --version"
+    ],
+    [
+      "/usr/local/bin/python3",
+      "--version"
+    ]
+  ]
+}

harbor/tasks/shared_handle_abandoned_operations/tests/docker-compose.yaml

@@ -0,0 +1,6 @@
+services:
+  main:
+    network_mode: none
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true

harbor/tasks/shared_handle_abandoned_operations/tests/evidence.py

@@ -0,0 +1,123 @@
+"""Validate complete coding-rubric evidence without importing the grader library or Harbor."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REVISION = "coding-rubric-v2"
+
+
+def _number(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise ValueError("Expected numeric rubric evidence")
+    if not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValueError("Rubric values must be finite and within [0, 1]")
+    return float(value)
+
+
+def validate_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check provenance, criterion coverage, weights, caps and command outcomes.
+
+    Parameters
+    ----------
+    report, config : dict
+        Fresh verifier evidence and the trusted prepared task configuration.
+    digest : str
+        SHA-256 of the submission collected by Harbor.
+
+    Raises
+    ------
+    ValueError
+        If evidence is missing, inconsistent or reports infrastructure failure.
+    """
+    if (
+        report.get("revision") != REVISION
+        or report.get("task_id") != config["task_id"]
+        or report.get("patch_sha256") != digest
+        or report.get("grader_version") != config["grader_version"]
+    ):
+        raise ValueError("Verifier evidence provenance mismatch")
+    result = report.get("result", {})
+    reward = _number(result.get("reward"))
+    # A rubric may flag its own result when a grader could not judge. That is
+    # admitted only together with proof, checked below, that the same grader
+    # reaches a verdict on the untouched repository.
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in report.get("commands", [])
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    flagged = result.get("isError", False)
+    if (flagged and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    status = report.get("status")
+    if status == "rejected_patch":
+        if reward != 0 or not report.get("patch_error") or result.get("subscores"):
+            raise ValueError("Invalid rejected-patch evidence")
+        return
+    if status == "empty_patch":
+        credited = any(_number(row["value"]) for row in result.get("subscores") or [])
+        if reward != 0 or digest != config["empty_sha256"] or report.get("commands") or credited:
+            raise ValueError("Invalid empty-patch evidence")
+        return
+    if status != "graded":
+        raise ValueError("Verifier did not complete")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    if not isinstance(scores, list) or len(scores) != len(expected):
+        raise ValueError("Missing rubric criteria")
+    names = [row["name"] for row in scores]
+    if len(set(names)) != len(names) or set(names) != set(expected):
+        raise ValueError("Duplicate or unexpected rubric criteria")
+    raw = 0.0
+    values = {}
+    for score in scores:
+        name = score["name"]
+        value, weight = _number(score["value"]), _number(score["weight"])
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    commands = report.get("commands", [])
+    command_names = [row["name"] for row in commands]
+    expected_commands = set(expected) | set(config["gates"])
+    if len(command_names) != len(set(command_names)) or set(command_names) != expected_commands:
+        raise ValueError("Missing or duplicate grader command evidence")
+    for command in commands:
+        info = command.get("info") or {}
+        code = info.get("exit_code")
+        verdict = type(code) is int and (code in (0, 1) or command["name"] in faults)
+        if not verdict or info.get("timed_out"):
+            raise ValueError("Grader command failed outside its verdict contract")
+        if _number(command["value"]) != float(code == 0):
+            raise ValueError("Command exit code disagrees with score")
+    probes = {row["name"]: row for row in report.get("fault_probes") or []}
+    if set(probes) != faults or any(
+        row.get("timed_out") or row.get("exit_code") not in (0, 1) for row in probes.values()
+    ):
+        raise ValueError(
+            "A grader could not judge and the untouched repository does not explain it"
+        )
+    if any(values.get(name, 0) for name in faults):
+        raise ValueError("A criterion its grader could not judge is credited")
+    info = result.get("info") or {}
+    if info.get("aggregate_mismatch") or info.get("git_apply"):
+        raise ValueError("Grader reported inconsistent grading")
+    if config.get("reward_rule") == "authored":
+        # The task's own function decides the reward. It may take credit away
+        # (a cap, a criterion that pays only with progress) but never add any.
+        passed = {row["name"]: row["value"] for row in commands}
+        if any(values[name] > passed[name] for name in expected):
+            raise ValueError("A criterion is credited although its command failed")
+        if reward > raw + 1e-9:
+            raise ValueError("Grader reward exceeds its weighted criteria")
+        return
+    failed = {name for name, row in expected.items() if row[2] and values[name] < 1}
+    gate_failed = {
+        row["name"] for row in commands if row["name"] in config["gates"] and row["value"] < 1
+    }
+    expected_reward = min(raw, config["blocker_cap"]) if failed or gate_failed else raw
+    if not math.isclose(reward, expected_reward, abs_tol=1e-9):
+        raise ValueError("Grader reward disagrees with original weights and blocker cap")

harbor/tasks/shared_handle_abandoned_operations/tests/test.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -euo pipefail
+/usr/local/bin/hud-pg.sh start
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/shared_handle_abandoned_operations/tests/verify.py

@@ -0,0 +1,235 @@
+"""Run the original trusted coding rubric in a fresh, offline verifier container."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from evidence import REVISION, validate_report
+
+OUT = Path("/logs/verifier")
+PRIVATE = Path("/var/lib/task-evidence")
+CONFIG = Path("/tests/config.json")
+PATCH = Path("/workspace/submissions/submitted.patch")
+GRADER_HOME = "/tmp/agent-home"
+
+
+def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs)
+
+
+def _preflight(config: dict[str, Any]) -> None:
+    if importlib.metadata.version("hud") != config["grader_version"]:
+        raise RuntimeError("Grader library version does not match the task")
+    for filename, expected in config["verifier_files"].items():
+        if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Verifier source changed: {filename}")
+    for command in config["preflight"]:
+        completed = _run(command, cwd="/workspace/repo")
+        if completed.returncode:
+            raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}")
+
+
+def _readable_mode(path: Path) -> int:
+    # World-readable, keeping what is executable so: a grader may ship tools.
+    return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644
+
+
+def _permissions() -> None:
+    # The orchestrator owns reports and rubric definitions. Grader commands,
+    # and so the candidate's code, run as uid 1000: the user the task installed
+    # its toolchain and caches for. They cannot read gold/vault or overwrite
+    # the rubric or the result files, which stay root's.
+    Path("/hud").chmod(0o711)
+    for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")):
+        if root.exists():
+            root.chmod(0o755)
+            for path in root.rglob("*"):
+                if not path.is_symlink():
+                    path.chmod(_readable_mode(path))
+    home = Path(GRADER_HOME)
+    home.mkdir(parents=True, exist_ok=True)
+    os.chown(home, 1000, 1000)
+    for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"):
+        path = Path(directory)
+        path.mkdir(parents=True, exist_ok=True)
+        for item in (path, *path.rglob("*")):
+            if not item.is_symlink():
+                os.chown(item, 1000, 1000)
+                item.chmod(_readable_mode(item))
+
+
+def _hand_over_checkout() -> None:
+    # The original grader runs as root and may run the candidate's own suite in
+    # place, which writes into the tree. The rubric resets and re-applies the
+    # candidate as root, so give what root touched back to the grading user.
+    # Installed dependency trees are large and already that user's.
+    subprocess.run(
+        [
+            "find",
+            "/workspace/repo",
+            "-path",
+            "*/node_modules",
+            "-prune",
+            "-o",
+            "!",
+            "-user",
+            "1000",
+            "-exec",
+            "chown",
+            "-h",
+            "1000:1000",
+            "{}",
+            "+",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=3600,
+    )
+
+
+async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None:
+    _preflight(config)
+    sys.path.insert(0, "/app")
+    task: Any = importlib.import_module("tasks")
+    await task._setup()
+    _permissions()
+    patch = PATCH.read_bytes()
+    if patch:
+        checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo")
+        if checked.returncode:
+            record.update(
+                status="rejected_patch",
+                patch_error=checked.stderr[-4000:],
+                result={"reward": 0.0, "subscores": None},
+            )
+            return
+        _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True)
+    original = task.BashGrader
+    fault_exit = config.get("fault_exit")
+    faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = []
+
+    class ObservedGrader:
+        @classmethod
+        async def grade(cls, *args: Any, **kwargs: Any) -> Any:
+            command = kwargs["command"]
+            _hand_over_checkout()
+            kwargs["command"] = (
+                "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs "
+                f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command)
+            )
+            score = await original.grade(*args, **kwargs)
+            snapshot = score.model_dump(mode="json")
+            record["commands"].append(snapshot)
+            (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2))
+            info = snapshot.get("info") or {}
+            if info.get("timed_out") or type(info.get("exit_code")) is not int:
+                raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}")
+            if fault_exit is not None and info["exit_code"] == fault_exit:
+                # The grader says it could not judge. Whether the submission or
+                # the environment is the reason is settled after grading.
+                faulted.append((args, dict(kwargs), snapshot["name"]))
+            elif info["exit_code"] not in (0, 1):
+                raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}")
+            return score
+
+    task.BashGrader = ObservedGrader
+    result = await task._grade(None)
+    if faulted:
+        # Ask the same commands about the untouched repository. A verdict there
+        # means the grader works here and the submission is what it could not
+        # judge, so the criterion stays unmet. No verdict there means the
+        # environment is at fault, and the attempt is invalid.
+        await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD")
+        await task.repo_lib.git(task.REPO_DIR, "clean", "-fd")
+        # Graders keep state between criteria, some of them a copy of the tree
+        # they judged. It describes the submission, so it goes too.
+        for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir():
+            if leftover.is_dir() and not leftover.is_symlink():
+                shutil.rmtree(leftover)
+            else:
+                leftover.unlink()
+        record["fault_probes"] = []
+        for args, kwargs, name in faulted:
+            _hand_over_checkout()
+            probe = (await original.grade(*args, **kwargs)).model_dump(mode="json")
+            info = probe.get("info") or {}
+            record["fault_probes"].append(
+                {
+                    "name": name,
+                    "exit_code": info.get("exit_code"),
+                    "timed_out": info.get("timed_out"),
+                    "stdout": (info.get("stdout") or "")[-2000:],
+                }
+            )
+            (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2))
+            if info.get("timed_out") or info.get("exit_code") not in (0, 1):
+                raise RuntimeError(f"Grader cannot judge the untouched repository: {name}")
+    record["result"] = result.model_dump(mode="json")
+    # A rubric may answer an empty change without running any criterion.
+    record["status"] = "empty_patch" if not patch and not record["commands"] else "graded"
+
+
+def _stop_candidate_processes() -> None:
+    # A candidate may fork. End its UID's processes before publishing evidence
+    # to a host bind mount, whose permissions may differ on Docker Desktop.
+    for directory in Path("/proc").iterdir():
+        if not directory.name.isdecimal():
+            continue
+        try:
+            status = (directory / "status").read_text()
+            uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:"))
+            if uid == "1000":
+                os.kill(int(directory.name), signal.SIGKILL)
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+
+
+def main() -> None:
+    """Persist structured evidence and publish reward only after validation."""
+    OUT.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+    PRIVATE.chmod(0o700)
+    reward_path = OUT / "reward.txt"
+    reward_path.unlink(missing_ok=True)
+    config = json.loads(CONFIG.read_text())
+    shutil.copy2(CONFIG, OUT / "config.json")
+    record: dict[str, Any] = {
+        "revision": REVISION,
+        "task_id": config["task_id"],
+        "grader_version": importlib.metadata.version("hud"),
+        "commands": [],
+        "status": "error",
+    }
+    try:
+        if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024:
+            raise ValueError("Missing, oversized or symlink submission")
+        record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest()
+        try:
+            asyncio.run(_grade(config, record))
+        finally:
+            _stop_candidate_processes()
+        reward_path.unlink(missing_ok=True)
+        validate_report(record, config, record["patch_sha256"])
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        reward_path.write_text(str(record["result"]["reward"]) + "\n")
+    except BaseException as error:
+        reward_path.unlink(missing_ok=True)
+        record.update(status="error", error={"type": type(error).__name__, "message": str(error)})
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        raise
+
+
+if __name__ == "__main__":
+    main()