Update dataset (part 2)

harbor/tasks/kratos_cleanup_stale_flows_courier_contract/environment/Dockerfile

@@ -0,0 +1,24 @@
+FROM ec-swe-kratos: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/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_contract/instruction.md

@@ -0,0 +1,17 @@
+Please make your changes directly in /workspace/repo.
+
+# Ticket
+
+Two reports about the courier came in after the last deploy.
+
+The first one is about the restart. The deploy stopped the workers in the middle of their batches, and the mail they had picked up stayed in processing; the new workers never touched it. Mail a dead or stopped worker claimed over an hour ago is retried as usual, and one a live worker just claimed is never taken by another. No user should see the same email twice.
+
+There is a second half to that report. A worker takes several messages at once, and when one of them cannot be handed over, everything else it had taken is put back for anyone to pick up while the worker is still going through the batch; a second worker then starts on that same mail before the first one has finished with it. Only the message that could not be handed over belongs back in the queue. The rest stay with the worker that took them until it has sent them or given up on them, no other worker sends them or is handed them in the meantime, and each of them still arrives exactly once.
+
+The second one is about disk. `cleanup sql` purges expired flows as it always has, but sent and abandoned mail past retention, with its delivery attempts, is never removed, while mail that is queued or being sent has to stay. Every other table the command cleans is a single step that follows its batch size and network, and courier history should be no different.
+
+We checked: none of this needs a schema change, a new dependency, or a new flag or config key.
+
+Existing tests stay green and unedited.
+
+Finish with a final response when your changes are ready.

harbor/tasks/kratos_cleanup_stale_flows_courier_contract/solution/reference.patch

@@ -0,0 +1,510 @@
+diff --git a/courier/courier_dispatcher.go b/courier/courier_dispatcher.go
+index 288d1f30..8e3da6f6 100644
+--- a/courier/courier_dispatcher.go
++++ b/courier/courier_dispatcher.go
+@@ -113,6 +113,13 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 	span.SetAttributes(attribute.Int("messages_count", len(messages)))
+ 
+ 	for k, msg := range messages {
++		if ctx.Err() != nil {
++			// The worker is being stopped: hand the messages it has not
++			// attempted yet back to the queue instead of leaving them claimed.
++			c.requeue(ctx, messages[k:])
++			return nil
++		}
++
+ 		logger := c.deps.Logger().
+ 			WithField("message_id", msg.ID).
+ 			WithField("message_nid", msg.NID).
+@@ -125,6 +132,9 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 				logger.
+ 					WithError(err).
+ 					Error(`Unable to set the retried message's status to "abandoned".`)
++				if ctx.Err() != nil {
++					c.requeue(ctx, messages[k:])
++				}
+ 				return err
+ 			}
+ 
+@@ -138,27 +148,33 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 			logger.
+ 				WithError(err).
+ 				Warn(`Unable to dispatch message.`)
+-			if err := c.deps.CourierPersister().RecordDispatch(ctx, msg.ID, CourierMessageDispatchStatusFailed, err); err != nil {
++			// The failure is recorded and only THIS message goes back to the
++			// queue. The rest of the batch is still claimed by this worker and
++			// is sent below; putting it back as well would let another worker
++			// pick it up while this one is sending it.
++			storeCtx := context.WithoutCancel(ctx)
++			if err := c.deps.CourierPersister().RecordDispatch(storeCtx, msg.ID, CourierMessageDispatchStatusFailed, err); err != nil {
+ 				logger.
+ 					WithError(err).
+ 					Error(`Unable to record failure log entry.`)
+ 				if c.failOnDispatchError {
++					c.requeue(ctx, messages[k:])
+ 					return err
+ 				}
+ 			}
+ 
+-			for _, replace := range messages[k:] {
+-				if err := c.deps.CourierPersister().SetMessageStatus(ctx, replace.ID, MessageStatusQueued); err != nil {
+-					logger.
+-						WithError(err).
+-						Error(`Unable to reset the failed message's status to "queued".`)
+-					if c.failOnDispatchError {
+-						return err
+-					}
++			if err := c.deps.CourierPersister().SetMessageStatus(storeCtx, msg.ID, MessageStatusQueued); err != nil {
++				logger.
++					WithError(err).
++					Error(`Unable to reset the failed message's status to "queued".`)
++				if c.failOnDispatchError {
++					c.requeue(ctx, messages[k+1:])
++					return err
+ 				}
+ 			}
+ 
+ 			if c.failOnDispatchError {
++				c.requeue(ctx, messages[k+1:])
+ 				return err
+ 			}
+ 		} else if err := c.deps.CourierPersister().RecordDispatch(ctx, msg.ID, CourierMessageDispatchStatusSuccess, nil); err != nil {
+@@ -171,3 +187,17 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 
+ 	return nil
+ }
++
++// requeue puts claimed messages that this worker will not attempt back into the
++// queue. It must work while the worker's context is being canceled.
++func (c *courier) requeue(ctx context.Context, messages []Message) {
++	storeCtx := context.WithoutCancel(ctx)
++	for _, m := range messages {
++		if err := c.deps.CourierPersister().SetMessageStatus(storeCtx, m.ID, MessageStatusQueued); err != nil {
++			c.deps.Logger().
++				WithError(err).
++				WithField("message_id", m.ID).
++				Error(`Unable to reset the message's status to "queued".`)
++		}
++	}
++}
+diff --git a/courier/courier_dispatcher_claims_test.go b/courier/courier_dispatcher_claims_test.go
+new file mode 100644
+index 00000000..68735f49
+--- /dev/null
++++ b/courier/courier_dispatcher_claims_test.go
+@@ -0,0 +1,193 @@
++// Copyright © 2026 Ory Corp
++// SPDX-License-Identifier: Apache-2.0
++
++package courier_test
++
++import (
++	"context"
++	"encoding/base64"
++	"encoding/json"
++	"fmt"
++	"io"
++	"net/http"
++	"net/http/httptest"
++	"sync"
++	"testing"
++	"time"
++
++	"github.com/gofrs/uuid"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/ory/kratos/courier"
++	templates "github.com/ory/kratos/courier/template/email"
++	"github.com/ory/kratos/driver"
++	"github.com/ory/kratos/driver/config"
++	"github.com/ory/kratos/pkg"
++	"github.com/ory/x/configx"
++)
++
++type subjectRelay struct {
++	mu     sync.Mutex
++	sent   map[string]int
++	handle func(subject string) int
++}
++
++func newSubjectRelay(t *testing.T) (*subjectRelay, *httptest.Server) {
++	r := &subjectRelay{sent: map[string]int{}}
++	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
++		raw, _ := io.ReadAll(req.Body)
++		var body struct {
++			Subject string `json:"subject"`
++		}
++		_ = json.Unmarshal(raw, &body)
++		code := http.StatusOK
++		if r.handle != nil {
++			code = r.handle(body.Subject)
++		}
++		if code == http.StatusOK {
++			r.mu.Lock()
++			r.sent[body.Subject]++
++			r.mu.Unlock()
++		}
++		w.WriteHeader(code)
++	}))
++	t.Cleanup(srv.Close)
++	return r, srv
++}
++
++func (r *subjectRelay) count(s string) int {
++	r.mu.Lock()
++	defer r.mu.Unlock()
++	return r.sent[s]
++}
++
++func claimsRegistry(t *testing.T, url string) *driver.RegistryDefault {
++	body := base64.StdEncoding.EncodeToString([]byte(`function(ctx) { subject: ctx.template_data.subject }`))
++	_, reg := pkg.NewRegistryDefaultWithDSN(t, "", configx.WithValues(map[string]any{
++		config.ViperKeyCourierDeliveryStrategy:  "http",
++		config.ViperKeyCourierHTTPRequestConfig: fmt.Sprintf(`{"url": "%s", "method": "POST", "body": "base64://%s"}`, url, body),
++		config.ViperKeyCourierMessageRetries:    5,
++		config.ViperKeyCourierWorkerPullCount:   10,
++	}))
++	return reg
++}
++
++func queueSubject(t *testing.T, c courier.Courier, subject string) uuid.UUID {
++	id, err := c.QueueEmail(t.Context(), templates.NewTestStub(&templates.TestStubModel{
++		To: subject + "@example.org", Subject: subject, Body: subject,
++	}))
++	require.NoError(t, err)
++	return id
++}
++
++func moveTimes(t *testing.T, reg *driver.RegistryDefault, id uuid.UUID, created, updated time.Time) {
++	require.NoError(t, reg.Persister().GetConnection(t.Context()).RawQuery(
++		"UPDATE courier_messages SET created_at = ?, updated_at = ? WHERE id = ?",
++		created.UTC(), updated.UTC(), id).Exec())
++}
++
++func TestDispatchQueueReclaimsAbandonedClaims(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	stale := queueSubject(t, c, "stale")
++	claimed, err := reg.CourierPersister().NextMessages(t.Context(), 10)
++	require.NoError(t, err)
++	require.Len(t, claimed, 1)
++
++	live := queueSubject(t, c, "live")
++	now := time.Now()
++	moveTimes(t, reg, live, now.Add(-4*time.Hour), now.Add(-4*time.Hour))
++	claimed, err = reg.CourierPersister().NextMessages(t.Context(), 10)
++	require.NoError(t, err)
++	require.Len(t, claimed, 1)
++	require.Equal(t, live, claimed[0].ID)
++
++	moveTimes(t, reg, stale, now.Add(-3*time.Hour), now.Add(-2*time.Hour))
++
++	require.NoError(t, c.DispatchQueue(t.Context()))
++	require.NoError(t, c.DispatchQueue(t.Context()))
++
++	assert.Equal(t, 1, relay.count("stale"))
++	assert.Equal(t, 0, relay.count("live"))
++	m, err := reg.CourierPersister().FetchMessage(t.Context(), live)
++	require.NoError(t, err)
++	assert.Equal(t, courier.MessageStatusProcessing, m.Status)
++}
++
++func TestDispatchQueueKeepsTheRestOfTheBatchClaimedAfterAFailure(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	now := time.Now()
++	var ids []uuid.UUID
++	for i, s := range []string{"first", "second", "third"} {
++		id := queueSubject(t, c, s)
++		moveTimes(t, reg, id, now.Add(time.Duration(i-3)*time.Minute), now.Add(time.Duration(i-3)*time.Minute))
++		ids = append(ids, id)
++	}
++
++	var thirdWhileSecond courier.MessageStatus
++	relay.handle = func(subject string) int {
++		switch subject {
++		case "first":
++			return http.StatusServiceUnavailable
++		case "second":
++			m, err := reg.CourierPersister().FetchMessage(context.Background(), ids[2])
++			if err == nil {
++				thirdWhileSecond = m.Status
++			}
++		}
++		return http.StatusOK
++	}
++	require.NoError(t, c.DispatchQueue(t.Context()))
++
++	assert.Equal(t, courier.MessageStatusProcessing, thirdWhileSecond,
++		"a message the worker still has to send must stay claimed")
++	assert.Equal(t, 1, relay.count("second"))
++	assert.Equal(t, 1, relay.count("third"))
++
++	m, err := reg.CourierPersister().FetchMessage(t.Context(), ids[0])
++	require.NoError(t, err)
++	assert.Equal(t, courier.MessageStatusQueued, m.Status)
++}
++
++func TestDispatchQueueRequeuesWhenStopped(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	now := time.Now()
++	var ids []uuid.UUID
++	for i, s := range []string{"a", "b", "c"} {
++		id := queueSubject(t, c, s)
++		moveTimes(t, reg, id, now.Add(time.Duration(i-3)*time.Minute), now.Add(time.Duration(i-3)*time.Minute))
++		ids = append(ids, id)
++	}
++
++	ctx, cancel := context.WithCancel(t.Context())
++	defer cancel()
++	relay.handle = func(subject string) int {
++		if subject == "a" {
++			cancel()
++		}
++		return http.StatusOK
++	}
++	_ = c.DispatchQueue(ctx)
++
++	for _, id := range ids[1:] {
++		m, err := reg.CourierPersister().FetchMessage(t.Context(), id)
++		require.NoError(t, err)
++		assert.Equal(t, courier.MessageStatusQueued, m.Status)
++	}
++	relay.handle = nil
++	require.NoError(t, c.DispatchQueue(t.Context()))
++	assert.Equal(t, 1, relay.count("b"))
++	assert.Equal(t, 1, relay.count("c"))
++}
+diff --git a/persistence/sql/persister.go b/persistence/sql/persister.go
+index 92c3460f..5d72fb8f 100644
+--- a/persistence/sql/persister.go
++++ b/persistence/sql/persister.go
+@@ -231,6 +231,12 @@ func (p *Persister) CleanupDatabase(ctx context.Context, wait time.Duration, old
+ 	}
+ 	time.Sleep(wait)
+ 
++	p.r.Logger().Println("Cleaning up old courier messages")
++	if err := p.DeleteOldCourierMessages(ctx, currentTime, batchSize); err != nil {
++		return err
++	}
++	time.Sleep(wait)
++
+ 	p.r.Logger().Println("Successfully cleaned up the latest batch of the SQL database! " +
+ 		"This should be re-run periodically, to be sure that all expired data is purged.")
+ 	return nil
+diff --git a/persistence/sql/persister_courier.go b/persistence/sql/persister_courier.go
+index a66218ad..c3e8d2db 100644
+--- a/persistence/sql/persister_courier.go
++++ b/persistence/sql/persister_courier.go
+@@ -7,6 +7,8 @@ import (
+ 	"context"
+ 	"database/sql"
+ 	"encoding/json"
++	"fmt"
++	"strings"
+ 	"time"
+ 
+ 	"github.com/gofrs/uuid"
+@@ -25,6 +27,10 @@ import (
+ 
+ var _ courier.Persister = new(Persister)
+ 
++// courierProcessingLease is how long a claimed message may stay "processing"
++// before it is considered abandoned by its worker and handed out again.
++const courierProcessingLease = time.Hour
++
+ func (p *Persister) AddMessage(ctx context.Context, m *courier.Message) (err error) {
+ 	ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.AddMessage")
+ 	defer otelx.End(span, &err)
+@@ -71,9 +77,15 @@ func (p *Persister) NextMessages(ctx context.Context, limit uint8) (messages []c
+ 	defer otelx.End(span, &err)
+ 
+ 	if err := p.Transaction(ctx, func(ctx context.Context, tx *pop.Connection) error {
+-		q := tx.Where("nid = ? AND status = ?",
++		now := time.Now().UTC()
++		// A message stays "processing" only while the worker that claimed it is
++		// alive. One whose claim is older than the lease was left behind by a
++		// worker that crashed or was stopped, and is taken up again.
++		q := tx.Where("nid = ? AND (status = ? OR (status = ? AND updated_at < ?))",
+ 			p.NetworkID(ctx),
+ 			courier.MessageStatusQueued,
++			courier.MessageStatusProcessing,
++			now.Add(-courierProcessingLease),
+ 		)
+ 		if tx.Dialect.Name() == dbal.DriverCockroachDB {
+ 			// On CockroachDB, exclude messages enqueued within the last second.
+@@ -102,7 +114,8 @@ func (p *Persister) NextMessages(ctx context.Context, limit uint8) (messages []c
+ 		for i := range m {
+ 			message := &m[i]
+ 			message.Status = courier.MessageStatusProcessing
+-			if err := update.Generic(ctx, tx, p.r.Tracer(ctx).Tracer(), message, "status"); err != nil {
++			message.UpdatedAt = now
++			if err := update.Generic(ctx, tx, p.r.Tracer(ctx).Tracer(), message, "status", "updated_at"); err != nil {
+ 				return err
+ 			}
+ 		}
+@@ -149,8 +162,9 @@ func (p *Persister) SetMessageStatus(ctx context.Context, id uuid.UUID, ms couri
+ 	defer otelx.End(span, &err)
+ 
+ 	count, err := p.GetConnection(ctx).RawQuery(
+-		"UPDATE courier_messages SET status = ? WHERE id = ? AND nid = ?",
++		"UPDATE courier_messages SET status = ?, updated_at = ? WHERE id = ? AND nid = ?",
+ 		ms,
++		time.Now().UTC(),
+ 		id,
+ 		p.NetworkID(ctx),
+ 	).ExecWithCount()
+@@ -170,7 +184,8 @@ func (p *Persister) IncrementMessageSendCount(ctx context.Context, id uuid.UUID)
+ 	defer otelx.End(span, &err)
+ 
+ 	count, err := p.GetConnection(ctx).RawQuery(
+-		"UPDATE courier_messages SET send_count = send_count + 1 WHERE id = ? AND nid = ?",
++		"UPDATE courier_messages SET send_count = send_count + 1, updated_at = ? WHERE id = ? AND nid = ?",
++		time.Now().UTC(),
+ 		id,
+ 		p.NetworkID(ctx),
+ 	).ExecWithCount()
+@@ -227,3 +242,52 @@ func (p *Persister) RecordDispatch(ctx context.Context, msgID uuid.UUID, status
+ 
+ 	return nil
+ }
++
++// DeleteOldCourierMessages removes up to limit messages that are finished
++// (sent or abandoned) and were created before olderThan, together with their
++// dispatch attempts. Queued and processing messages are never removed.
++func (p *Persister) DeleteOldCourierMessages(ctx context.Context, olderThan time.Time, limit int) (err error) {
++	ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.DeleteOldCourierMessages")
++	defer otelx.End(span, &err)
++
++	return p.Transaction(ctx, func(ctx context.Context, tx *pop.Connection) error {
++		var finished []courier.Message
++		if err := tx.
++			Select("id").
++			Where("nid = ? AND status IN (?, ?) AND created_at <= ?",
++				p.NetworkID(ctx),
++				courier.MessageStatusSent,
++				courier.MessageStatusAbandoned,
++				olderThan.UTC(),
++			).
++			Order("created_at ASC, id ASC").
++			Limit(limit).
++			All(&finished); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		if len(finished) == 0 {
++			return nil
++		}
++
++		args := make([]any, 0, len(finished)+1)
++		args = append(args, p.NetworkID(ctx))
++		for _, m := range finished {
++			args = append(args, m.ID)
++		}
++		in := strings.TrimSuffix(strings.Repeat("?, ", len(finished)), ", ")
++
++		//#nosec G201 -- only placeholders are formatted into the statement
++		if err := tx.RawQuery(fmt.Sprintf(
++			"DELETE FROM courier_message_dispatches WHERE nid = ? AND message_id IN (%s)", in,
++		), args...).Exec(); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		//#nosec G201 -- only placeholders are formatted into the statement
++		if err := tx.RawQuery(fmt.Sprintf(
++			"DELETE FROM courier_messages WHERE nid = ? AND id IN (%s)", in,
++		), args...).Exec(); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		return nil
++	})
++}
+diff --git a/persistence/sql/persister_courier_cleanup_test.go b/persistence/sql/persister_courier_cleanup_test.go
+new file mode 100644
+index 00000000..e91afcf1
+--- /dev/null
++++ b/persistence/sql/persister_courier_cleanup_test.go
+@@ -0,0 +1,74 @@
++// Copyright © 2026 Ory Corp
++// SPDX-License-Identifier: Apache-2.0
++
++package sql_test
++
++import (
++	"context"
++	"testing"
++	"time"
++
++	"github.com/gofrs/uuid"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/ory/kratos/courier"
++	"github.com/ory/kratos/pkg"
++	"github.com/ory/kratos/pkg/testhelpers"
++	"github.com/ory/kratos/persistence"
++)
++
++func TestPersister_CourierMessages_Cleanup(t *testing.T) {
++	t.Parallel()
++
++	_, reg := pkg.NewFastRegistryWithMocks(t)
++	ctx := context.Background()
++	p := reg.Persister()
++	now := time.Now()
++	old := now.Add(-48 * time.Hour)
++
++	add := func(p persistence.Persister, st courier.MessageStatus, created time.Time, attempts int) uuid.UUID {
++		m := courier.Message{Type: courier.MessageTypeEmail, Recipient: "a@example.org", Subject: "s", Body: "b", TemplateType: "stub"}
++		require.NoError(t, p.AddMessage(ctx, &m))
++		for range attempts {
++			require.NoError(t, p.RecordDispatch(ctx, m.ID, courier.CourierMessageDispatchStatusSuccess, nil))
++		}
++		require.NoError(t, p.GetConnection(ctx).RawQuery(
++			"UPDATE courier_messages SET status = ?, created_at = ?, updated_at = ? WHERE id = ?",
++			st, created.UTC(), created.UTC(), m.ID).Exec())
++		return m.ID
++	}
++	exists := func(id uuid.UUID) bool {
++		n, err := p.GetConnection(ctx).Where("id = ?", id).Count(&courier.Message{})
++		require.NoError(t, err)
++		return n == 1
++	}
++	attempts := func(id uuid.UUID) int {
++		n, err := p.GetConnection(ctx).Where("message_id = ?", id).Count(&courier.MessageDispatch{})
++		require.NoError(t, err)
++		return n
++	}
++
++	sent := add(p, courier.MessageStatusSent, old, 1)
++	abandoned := add(p, courier.MessageStatusAbandoned, old.Add(time.Minute), 2)
++	queued := add(p, courier.MessageStatusQueued, old, 1)
++	processing := add(p, courier.MessageStatusProcessing, old, 0)
++	recent := add(p, courier.MessageStatusSent, now.Add(-time.Hour), 1)
++
++	_, other := testhelpers.NewNetwork(t, ctx, p)
++	foreign := add(other, courier.MessageStatusSent, old, 1)
++
++	require.NoError(t, p.CleanupDatabase(ctx, 0, 24*time.Hour, 1))
++	assert.False(t, exists(sent), "the oldest finished message goes first")
++	assert.True(t, exists(abandoned), "one batch of size 1")
++
++	require.NoError(t, p.CleanupDatabase(ctx, 0, 24*time.Hour, 100))
++	assert.False(t, exists(abandoned))
++	assert.Zero(t, attempts(sent))
++	assert.Zero(t, attempts(abandoned))
++	assert.True(t, exists(queued))
++	assert.Equal(t, 1, attempts(queued))
++	assert.True(t, exists(processing))
++	assert.True(t, exists(recent))
++	assert.True(t, exists(foreign))
++}

harbor/tasks/kratos_cleanup_stale_flows_courier_contract/solution/solve.sh

@@ -0,0 +1,516 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/courier/courier_dispatcher.go b/courier/courier_dispatcher.go
+index 288d1f30..8e3da6f6 100644
+--- a/courier/courier_dispatcher.go
++++ b/courier/courier_dispatcher.go
+@@ -113,6 +113,13 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 	span.SetAttributes(attribute.Int("messages_count", len(messages)))
+ 
+ 	for k, msg := range messages {
++		if ctx.Err() != nil {
++			// The worker is being stopped: hand the messages it has not
++			// attempted yet back to the queue instead of leaving them claimed.
++			c.requeue(ctx, messages[k:])
++			return nil
++		}
++
+ 		logger := c.deps.Logger().
+ 			WithField("message_id", msg.ID).
+ 			WithField("message_nid", msg.NID).
+@@ -125,6 +132,9 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 				logger.
+ 					WithError(err).
+ 					Error(`Unable to set the retried message's status to "abandoned".`)
++				if ctx.Err() != nil {
++					c.requeue(ctx, messages[k:])
++				}
+ 				return err
+ 			}
+ 
+@@ -138,27 +148,33 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 			logger.
+ 				WithError(err).
+ 				Warn(`Unable to dispatch message.`)
+-			if err := c.deps.CourierPersister().RecordDispatch(ctx, msg.ID, CourierMessageDispatchStatusFailed, err); err != nil {
++			// The failure is recorded and only THIS message goes back to the
++			// queue. The rest of the batch is still claimed by this worker and
++			// is sent below; putting it back as well would let another worker
++			// pick it up while this one is sending it.
++			storeCtx := context.WithoutCancel(ctx)
++			if err := c.deps.CourierPersister().RecordDispatch(storeCtx, msg.ID, CourierMessageDispatchStatusFailed, err); err != nil {
+ 				logger.
+ 					WithError(err).
+ 					Error(`Unable to record failure log entry.`)
+ 				if c.failOnDispatchError {
++					c.requeue(ctx, messages[k:])
+ 					return err
+ 				}
+ 			}
+ 
+-			for _, replace := range messages[k:] {
+-				if err := c.deps.CourierPersister().SetMessageStatus(ctx, replace.ID, MessageStatusQueued); err != nil {
+-					logger.
+-						WithError(err).
+-						Error(`Unable to reset the failed message's status to "queued".`)
+-					if c.failOnDispatchError {
+-						return err
+-					}
++			if err := c.deps.CourierPersister().SetMessageStatus(storeCtx, msg.ID, MessageStatusQueued); err != nil {
++				logger.
++					WithError(err).
++					Error(`Unable to reset the failed message's status to "queued".`)
++				if c.failOnDispatchError {
++					c.requeue(ctx, messages[k+1:])
++					return err
+ 				}
+ 			}
+ 
+ 			if c.failOnDispatchError {
++				c.requeue(ctx, messages[k+1:])
+ 				return err
+ 			}
+ 		} else if err := c.deps.CourierPersister().RecordDispatch(ctx, msg.ID, CourierMessageDispatchStatusSuccess, nil); err != nil {
+@@ -171,3 +187,17 @@ func (c *courier) DispatchQueue(ctx context.Context) (err error) {
+ 
+ 	return nil
+ }
++
++// requeue puts claimed messages that this worker will not attempt back into the
++// queue. It must work while the worker's context is being canceled.
++func (c *courier) requeue(ctx context.Context, messages []Message) {
++	storeCtx := context.WithoutCancel(ctx)
++	for _, m := range messages {
++		if err := c.deps.CourierPersister().SetMessageStatus(storeCtx, m.ID, MessageStatusQueued); err != nil {
++			c.deps.Logger().
++				WithError(err).
++				WithField("message_id", m.ID).
++				Error(`Unable to reset the message's status to "queued".`)
++		}
++	}
++}
+diff --git a/courier/courier_dispatcher_claims_test.go b/courier/courier_dispatcher_claims_test.go
+new file mode 100644
+index 00000000..68735f49
+--- /dev/null
++++ b/courier/courier_dispatcher_claims_test.go
+@@ -0,0 +1,193 @@
++// Copyright © 2026 Ory Corp
++// SPDX-License-Identifier: Apache-2.0
++
++package courier_test
++
++import (
++	"context"
++	"encoding/base64"
++	"encoding/json"
++	"fmt"
++	"io"
++	"net/http"
++	"net/http/httptest"
++	"sync"
++	"testing"
++	"time"
++
++	"github.com/gofrs/uuid"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/ory/kratos/courier"
++	templates "github.com/ory/kratos/courier/template/email"
++	"github.com/ory/kratos/driver"
++	"github.com/ory/kratos/driver/config"
++	"github.com/ory/kratos/pkg"
++	"github.com/ory/x/configx"
++)
++
++type subjectRelay struct {
++	mu     sync.Mutex
++	sent   map[string]int
++	handle func(subject string) int
++}
++
++func newSubjectRelay(t *testing.T) (*subjectRelay, *httptest.Server) {
++	r := &subjectRelay{sent: map[string]int{}}
++	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
++		raw, _ := io.ReadAll(req.Body)
++		var body struct {
++			Subject string `json:"subject"`
++		}
++		_ = json.Unmarshal(raw, &body)
++		code := http.StatusOK
++		if r.handle != nil {
++			code = r.handle(body.Subject)
++		}
++		if code == http.StatusOK {
++			r.mu.Lock()
++			r.sent[body.Subject]++
++			r.mu.Unlock()
++		}
++		w.WriteHeader(code)
++	}))
++	t.Cleanup(srv.Close)
++	return r, srv
++}
++
++func (r *subjectRelay) count(s string) int {
++	r.mu.Lock()
++	defer r.mu.Unlock()
++	return r.sent[s]
++}
++
++func claimsRegistry(t *testing.T, url string) *driver.RegistryDefault {
++	body := base64.StdEncoding.EncodeToString([]byte(`function(ctx) { subject: ctx.template_data.subject }`))
++	_, reg := pkg.NewRegistryDefaultWithDSN(t, "", configx.WithValues(map[string]any{
++		config.ViperKeyCourierDeliveryStrategy:  "http",
++		config.ViperKeyCourierHTTPRequestConfig: fmt.Sprintf(`{"url": "%s", "method": "POST", "body": "base64://%s"}`, url, body),
++		config.ViperKeyCourierMessageRetries:    5,
++		config.ViperKeyCourierWorkerPullCount:   10,
++	}))
++	return reg
++}
++
++func queueSubject(t *testing.T, c courier.Courier, subject string) uuid.UUID {
++	id, err := c.QueueEmail(t.Context(), templates.NewTestStub(&templates.TestStubModel{
++		To: subject + "@example.org", Subject: subject, Body: subject,
++	}))
++	require.NoError(t, err)
++	return id
++}
++
++func moveTimes(t *testing.T, reg *driver.RegistryDefault, id uuid.UUID, created, updated time.Time) {
++	require.NoError(t, reg.Persister().GetConnection(t.Context()).RawQuery(
++		"UPDATE courier_messages SET created_at = ?, updated_at = ? WHERE id = ?",
++		created.UTC(), updated.UTC(), id).Exec())
++}
++
++func TestDispatchQueueReclaimsAbandonedClaims(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	stale := queueSubject(t, c, "stale")
++	claimed, err := reg.CourierPersister().NextMessages(t.Context(), 10)
++	require.NoError(t, err)
++	require.Len(t, claimed, 1)
++
++	live := queueSubject(t, c, "live")
++	now := time.Now()
++	moveTimes(t, reg, live, now.Add(-4*time.Hour), now.Add(-4*time.Hour))
++	claimed, err = reg.CourierPersister().NextMessages(t.Context(), 10)
++	require.NoError(t, err)
++	require.Len(t, claimed, 1)
++	require.Equal(t, live, claimed[0].ID)
++
++	moveTimes(t, reg, stale, now.Add(-3*time.Hour), now.Add(-2*time.Hour))
++
++	require.NoError(t, c.DispatchQueue(t.Context()))
++	require.NoError(t, c.DispatchQueue(t.Context()))
++
++	assert.Equal(t, 1, relay.count("stale"))
++	assert.Equal(t, 0, relay.count("live"))
++	m, err := reg.CourierPersister().FetchMessage(t.Context(), live)
++	require.NoError(t, err)
++	assert.Equal(t, courier.MessageStatusProcessing, m.Status)
++}
++
++func TestDispatchQueueKeepsTheRestOfTheBatchClaimedAfterAFailure(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	now := time.Now()
++	var ids []uuid.UUID
++	for i, s := range []string{"first", "second", "third"} {
++		id := queueSubject(t, c, s)
++		moveTimes(t, reg, id, now.Add(time.Duration(i-3)*time.Minute), now.Add(time.Duration(i-3)*time.Minute))
++		ids = append(ids, id)
++	}
++
++	var thirdWhileSecond courier.MessageStatus
++	relay.handle = func(subject string) int {
++		switch subject {
++		case "first":
++			return http.StatusServiceUnavailable
++		case "second":
++			m, err := reg.CourierPersister().FetchMessage(context.Background(), ids[2])
++			if err == nil {
++				thirdWhileSecond = m.Status
++			}
++		}
++		return http.StatusOK
++	}
++	require.NoError(t, c.DispatchQueue(t.Context()))
++
++	assert.Equal(t, courier.MessageStatusProcessing, thirdWhileSecond,
++		"a message the worker still has to send must stay claimed")
++	assert.Equal(t, 1, relay.count("second"))
++	assert.Equal(t, 1, relay.count("third"))
++
++	m, err := reg.CourierPersister().FetchMessage(t.Context(), ids[0])
++	require.NoError(t, err)
++	assert.Equal(t, courier.MessageStatusQueued, m.Status)
++}
++
++func TestDispatchQueueRequeuesWhenStopped(t *testing.T) {
++	relay, srv := newSubjectRelay(t)
++	reg := claimsRegistry(t, srv.URL)
++	c, err := reg.Courier(t.Context())
++	require.NoError(t, err)
++
++	now := time.Now()
++	var ids []uuid.UUID
++	for i, s := range []string{"a", "b", "c"} {
++		id := queueSubject(t, c, s)
++		moveTimes(t, reg, id, now.Add(time.Duration(i-3)*time.Minute), now.Add(time.Duration(i-3)*time.Minute))
++		ids = append(ids, id)
++	}
++
++	ctx, cancel := context.WithCancel(t.Context())
++	defer cancel()
++	relay.handle = func(subject string) int {
++		if subject == "a" {
++			cancel()
++		}
++		return http.StatusOK
++	}
++	_ = c.DispatchQueue(ctx)
++
++	for _, id := range ids[1:] {
++		m, err := reg.CourierPersister().FetchMessage(t.Context(), id)
++		require.NoError(t, err)
++		assert.Equal(t, courier.MessageStatusQueued, m.Status)
++	}
++	relay.handle = nil
++	require.NoError(t, c.DispatchQueue(t.Context()))
++	assert.Equal(t, 1, relay.count("b"))
++	assert.Equal(t, 1, relay.count("c"))
++}
+diff --git a/persistence/sql/persister.go b/persistence/sql/persister.go
+index 92c3460f..5d72fb8f 100644
+--- a/persistence/sql/persister.go
++++ b/persistence/sql/persister.go
+@@ -231,6 +231,12 @@ func (p *Persister) CleanupDatabase(ctx context.Context, wait time.Duration, old
+ 	}
+ 	time.Sleep(wait)
+ 
++	p.r.Logger().Println("Cleaning up old courier messages")
++	if err := p.DeleteOldCourierMessages(ctx, currentTime, batchSize); err != nil {
++		return err
++	}
++	time.Sleep(wait)
++
+ 	p.r.Logger().Println("Successfully cleaned up the latest batch of the SQL database! " +
+ 		"This should be re-run periodically, to be sure that all expired data is purged.")
+ 	return nil
+diff --git a/persistence/sql/persister_courier.go b/persistence/sql/persister_courier.go
+index a66218ad..c3e8d2db 100644
+--- a/persistence/sql/persister_courier.go
++++ b/persistence/sql/persister_courier.go
+@@ -7,6 +7,8 @@ import (
+ 	"context"
+ 	"database/sql"
+ 	"encoding/json"
++	"fmt"
++	"strings"
+ 	"time"
+ 
+ 	"github.com/gofrs/uuid"
+@@ -25,6 +27,10 @@ import (
+ 
+ var _ courier.Persister = new(Persister)
+ 
++// courierProcessingLease is how long a claimed message may stay "processing"
++// before it is considered abandoned by its worker and handed out again.
++const courierProcessingLease = time.Hour
++
+ func (p *Persister) AddMessage(ctx context.Context, m *courier.Message) (err error) {
+ 	ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.AddMessage")
+ 	defer otelx.End(span, &err)
+@@ -71,9 +77,15 @@ func (p *Persister) NextMessages(ctx context.Context, limit uint8) (messages []c
+ 	defer otelx.End(span, &err)
+ 
+ 	if err := p.Transaction(ctx, func(ctx context.Context, tx *pop.Connection) error {
+-		q := tx.Where("nid = ? AND status = ?",
++		now := time.Now().UTC()
++		// A message stays "processing" only while the worker that claimed it is
++		// alive. One whose claim is older than the lease was left behind by a
++		// worker that crashed or was stopped, and is taken up again.
++		q := tx.Where("nid = ? AND (status = ? OR (status = ? AND updated_at < ?))",
+ 			p.NetworkID(ctx),
+ 			courier.MessageStatusQueued,
++			courier.MessageStatusProcessing,
++			now.Add(-courierProcessingLease),
+ 		)
+ 		if tx.Dialect.Name() == dbal.DriverCockroachDB {
+ 			// On CockroachDB, exclude messages enqueued within the last second.
+@@ -102,7 +114,8 @@ func (p *Persister) NextMessages(ctx context.Context, limit uint8) (messages []c
+ 		for i := range m {
+ 			message := &m[i]
+ 			message.Status = courier.MessageStatusProcessing
+-			if err := update.Generic(ctx, tx, p.r.Tracer(ctx).Tracer(), message, "status"); err != nil {
++			message.UpdatedAt = now
++			if err := update.Generic(ctx, tx, p.r.Tracer(ctx).Tracer(), message, "status", "updated_at"); err != nil {
+ 				return err
+ 			}
+ 		}
+@@ -149,8 +162,9 @@ func (p *Persister) SetMessageStatus(ctx context.Context, id uuid.UUID, ms couri
+ 	defer otelx.End(span, &err)
+ 
+ 	count, err := p.GetConnection(ctx).RawQuery(
+-		"UPDATE courier_messages SET status = ? WHERE id = ? AND nid = ?",
++		"UPDATE courier_messages SET status = ?, updated_at = ? WHERE id = ? AND nid = ?",
+ 		ms,
++		time.Now().UTC(),
+ 		id,
+ 		p.NetworkID(ctx),
+ 	).ExecWithCount()
+@@ -170,7 +184,8 @@ func (p *Persister) IncrementMessageSendCount(ctx context.Context, id uuid.UUID)
+ 	defer otelx.End(span, &err)
+ 
+ 	count, err := p.GetConnection(ctx).RawQuery(
+-		"UPDATE courier_messages SET send_count = send_count + 1 WHERE id = ? AND nid = ?",
++		"UPDATE courier_messages SET send_count = send_count + 1, updated_at = ? WHERE id = ? AND nid = ?",
++		time.Now().UTC(),
+ 		id,
+ 		p.NetworkID(ctx),
+ 	).ExecWithCount()
+@@ -227,3 +242,52 @@ func (p *Persister) RecordDispatch(ctx context.Context, msgID uuid.UUID, status
+ 
+ 	return nil
+ }
++
++// DeleteOldCourierMessages removes up to limit messages that are finished
++// (sent or abandoned) and were created before olderThan, together with their
++// dispatch attempts. Queued and processing messages are never removed.
++func (p *Persister) DeleteOldCourierMessages(ctx context.Context, olderThan time.Time, limit int) (err error) {
++	ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.DeleteOldCourierMessages")
++	defer otelx.End(span, &err)
++
++	return p.Transaction(ctx, func(ctx context.Context, tx *pop.Connection) error {
++		var finished []courier.Message
++		if err := tx.
++			Select("id").
++			Where("nid = ? AND status IN (?, ?) AND created_at <= ?",
++				p.NetworkID(ctx),
++				courier.MessageStatusSent,
++				courier.MessageStatusAbandoned,
++				olderThan.UTC(),
++			).
++			Order("created_at ASC, id ASC").
++			Limit(limit).
++			All(&finished); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		if len(finished) == 0 {
++			return nil
++		}
++
++		args := make([]any, 0, len(finished)+1)
++		args = append(args, p.NetworkID(ctx))
++		for _, m := range finished {
++			args = append(args, m.ID)
++		}
++		in := strings.TrimSuffix(strings.Repeat("?, ", len(finished)), ", ")
++
++		//#nosec G201 -- only placeholders are formatted into the statement
++		if err := tx.RawQuery(fmt.Sprintf(
++			"DELETE FROM courier_message_dispatches WHERE nid = ? AND message_id IN (%s)", in,
++		), args...).Exec(); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		//#nosec G201 -- only placeholders are formatted into the statement
++		if err := tx.RawQuery(fmt.Sprintf(
++			"DELETE FROM courier_messages WHERE nid = ? AND id IN (%s)", in,
++		), args...).Exec(); err != nil {
++			return sqlcon.HandleError(err)
++		}
++		return nil
++	})
++}
+diff --git a/persistence/sql/persister_courier_cleanup_test.go b/persistence/sql/persister_courier_cleanup_test.go
+new file mode 100644
+index 00000000..e91afcf1
+--- /dev/null
++++ b/persistence/sql/persister_courier_cleanup_test.go
+@@ -0,0 +1,74 @@
++// Copyright © 2026 Ory Corp
++// SPDX-License-Identifier: Apache-2.0
++
++package sql_test
++
++import (
++	"context"
++	"testing"
++	"time"
++
++	"github.com/gofrs/uuid"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++
++	"github.com/ory/kratos/courier"
++	"github.com/ory/kratos/pkg"
++	"github.com/ory/kratos/pkg/testhelpers"
++	"github.com/ory/kratos/persistence"
++)
++
++func TestPersister_CourierMessages_Cleanup(t *testing.T) {
++	t.Parallel()
++
++	_, reg := pkg.NewFastRegistryWithMocks(t)
++	ctx := context.Background()
++	p := reg.Persister()
++	now := time.Now()
++	old := now.Add(-48 * time.Hour)
++
++	add := func(p persistence.Persister, st courier.MessageStatus, created time.Time, attempts int) uuid.UUID {
++		m := courier.Message{Type: courier.MessageTypeEmail, Recipient: "a@example.org", Subject: "s", Body: "b", TemplateType: "stub"}
++		require.NoError(t, p.AddMessage(ctx, &m))
++		for range attempts {
++			require.NoError(t, p.RecordDispatch(ctx, m.ID, courier.CourierMessageDispatchStatusSuccess, nil))
++		}
++		require.NoError(t, p.GetConnection(ctx).RawQuery(
++			"UPDATE courier_messages SET status = ?, created_at = ?, updated_at = ? WHERE id = ?",
++			st, created.UTC(), created.UTC(), m.ID).Exec())
++		return m.ID
++	}
++	exists := func(id uuid.UUID) bool {
++		n, err := p.GetConnection(ctx).Where("id = ?", id).Count(&courier.Message{})
++		require.NoError(t, err)
++		return n == 1
++	}
++	attempts := func(id uuid.UUID) int {
++		n, err := p.GetConnection(ctx).Where("message_id = ?", id).Count(&courier.MessageDispatch{})
++		require.NoError(t, err)
++		return n
++	}
++
++	sent := add(p, courier.MessageStatusSent, old, 1)
++	abandoned := add(p, courier.MessageStatusAbandoned, old.Add(time.Minute), 2)
++	queued := add(p, courier.MessageStatusQueued, old, 1)
++	processing := add(p, courier.MessageStatusProcessing, old, 0)
++	recent := add(p, courier.MessageStatusSent, now.Add(-time.Hour), 1)
++
++	_, other := testhelpers.NewNetwork(t, ctx, p)
++	foreign := add(other, courier.MessageStatusSent, old, 1)
++
++	require.NoError(t, p.CleanupDatabase(ctx, 0, 24*time.Hour, 1))
++	assert.False(t, exists(sent), "the oldest finished message goes first")
++	assert.True(t, exists(abandoned), "one batch of size 1")
++
++	require.NoError(t, p.CleanupDatabase(ctx, 0, 24*time.Hour, 100))
++	assert.False(t, exists(abandoned))
++	assert.Zero(t, attempts(sent))
++	assert.Zero(t, attempts(abandoned))
++	assert.True(t, exists(queued))
++	assert.Equal(t, 1, attempts(queued))
++	assert.True(t, exists(processing))
++	assert.True(t, exists(recent))
++	assert.True(t, exists(foreign))
++}
+
+REFERENCE_PATCH

harbor/tasks/kratos_cleanup_stale_flows_courier_contract/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_contract/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-kratos: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/kratos_cleanup_stale_flows_courier_contract/tests/config.json

@@ -0,0 +1,127 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "kratos_cleanup_stale_flows_courier_contract",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-kratos:source-v10",
+  "source_image_id": "sha256:a3c3f9a393f79d72fff709b01e919ef72e0d7a3fba232533eb107875f006496b",
+  "provenance": {
+    "repository": "ory/kratos",
+    "environment_id": "4e12f395-6431-4c02-b211-fd3707822aba",
+    "build": 10,
+    "build_id": "36572f42-b5da-4777-8379-34459bff5575",
+    "hosted_task": "kratos_cleanup_stale_flows_courier_contract",
+    "task_version": 6,
+    "source_archive_sha256": "207a452f2c259f7f6474f2bd3ce7c1f1beaac49eafece386a0190498ee211d96",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "stranded_message_is_delivered_once",
+      0.0608,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "stranded_message_is_retried_then_abandoned",
+      0.0608,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "concurrent_poll_never_double_delivers",
+      0.1817,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "claimed_mail_is_not_sent_by_another_worker",
+      0.1817,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "claimed_mail_is_not_handed_to_another_worker",
+      0.1817,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "batch_is_released_only_when_the_worker_gives_up",
+      0.1817,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "cleanup_keeps_pending_messages",
+      0.0608,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "cleanup_removes_old_finished_with_attempts",
+      0.0608,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.03,
+      true,
+      "bash",
+      900
+    ]
+  ],
+  "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/env.py": "f500868545909809d90d32c59d3c484f2f2dfd401c5095a1d62e16604d9c8b77",
+    "/app/tasks.py": "e3b3f5fe4fec8e4d3f1c8261ef9ce13fc8058031634162dc72c17d8ee368dc5a",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/task/prompt.md": "239e21d58525fb1d4f03502a02aaf35855cfcdad5b16eb89547947c9b6b2780e",
+    "/hud/grader/board.json": "f58568b0e7d41942cd8311ae566e61fd1259291d93b2f4a8afcebee16b5b19e7",
+    "/hud/grader/cells_test.go": "cf3052230ff44491db7f191206603fb73cdf24c59de4331f7839bf3026cb7a7c",
+    "/hud/grader/run_grading.sh": "82c1ca34535b2da3c93e728229e508319224cd3e9f35f54139d38b8f98f1d913",
+    "/hud/grader/suite_gate.py": "de0fc10861f98f87af69bc34b8c49248f386cbb35d47396b1e37576f8962b688"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'go version' || go version"
+    ],
+    [
+      "/usr/local/bin/python3",
+      "--version"
+    ]
+  ]
+}

harbor/tasks/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_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/kratos_cleanup_stale_flows_courier_contract/tests/test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/kratos_cleanup_stale_flows_courier_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/manifest.json

@@ -5,6 +5,7 @@
     "bazel_remote_disk_eviction_accounting_contract",
     "celery_retry_expires_countdown_contract",
     "epicyon_deleted_post_announce_cache_contract",
+    "kratos_cleanup_stale_flows_courier_contract",
     "microblogpub_deleted_object_resurrect_lookup_contract",
     "openfire_userdeleting_last_owner_contract",
     "rope_rename_all_reexport_owners_contract",