Update dataset (part 3)

harbor/tasks/druid_lenient_script/instruction.md

@@ -0,0 +1,18 @@
+Please make your changes directly in /workspace/repo.
+
+A bad statement loses a whole SQL script at the first error.
+
+Add a lenient whole script read:
+
+- `SQLUtils.parseStatementsLenient(String sql, DbType dbType)` returns the statements in order. What the strict call reads comes back as today; the rest comes back as `SQLUnparsedStatement`, a new public statement class: `getSql()` is the statement's source text, `getError()` the message the strict call gives for that text on its own, with pos, line and column counted from the script start, `getLine()` and `getColumn()` those two numbers, and `toString()` the sql.
+- An unparsed statement is the whole top level statement the error lies in. A compound statement is one statement with everything the strict parser puts inside it, branches and bodies included, and ends at the semicolon that ends it as a top level statement. Keywords used as names, functions, modifiers or transaction commands open and close nothing.
+- The sql is the source exactly as written from the statement's first token to its last, whatever the text or line endings; delimiter, comments and whitespace around it are left out. When a string, quoted name or comment opened in a statement is never closed, it is unparsed and its text runs to the end of the input.
+- What follows an unparsed statement parses exactly as the script without it.
+- A script costs at most twice a strict parse of the same script with its unparsed statements removed, in tokens read, at 5,000 statements with 125 bad ones.
+- The strict calls and their messages are unchanged.
+
+Work in the core module. Build files and committed tests stay as they are and must keep passing; add no dependency; new tests go in new files.
+
+When the requirements hold you are done: stop and report what you changed.
+
+Finish with a final response when your changes are ready.

harbor/tasks/druid_lenient_script/solution/reference.patch

@@ -0,0 +1,795 @@
+diff --git a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
+index 2ad08d6..1ebbe21 100644
+--- a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
++++ b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
+@@ -677,6 +677,14 @@ public class SQLUtils {
+         return parseStatements(sql, DbType.of(dbType), features);
+     }
+ 
++    /**
++     * Reads a whole script; statements the strict parser cannot read come back as
++     * {@link com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement} in place, the rest as today.
++     */
++    public static List<SQLStatement> parseStatementsLenient(String sql, DbType dbType) {
++        return new com.alibaba.druid.sql.parser.LenientScriptParser(sql, dbType).parse();
++    }
++
+     public static List<SQLStatement> parseStatements(String sql, DbType dbType, SQLParserFeature... features) {
+         SQLStatementParser parser = SQLParserUtils.createSQLStatementParser(sql, dbType, features);
+         List<SQLStatement> stmtList = new ArrayList<SQLStatement>();
+diff --git a/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java
+new file mode 100644
+index 0000000..336039b
+--- /dev/null
++++ b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java
+@@ -0,0 +1,69 @@
++package com.alibaba.druid.sql.ast.statement;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.ast.SQLStatementImpl;
++import com.alibaba.druid.sql.visitor.SQLASTVisitor;
++import com.alibaba.druid.sql.visitor.VisitorFeature;
++
++/**
++ * A statement the strict parser could not read, kept as its source text by the lenient script read.
++ */
++public class SQLUnparsedStatement extends SQLStatementImpl {
++    private final String sql;
++    private final String error;
++    private final int line;
++    private final int column;
++
++    public SQLUnparsedStatement(DbType dbType, String sql, String error, int line, int column) {
++        super(dbType);
++        this.sql = sql;
++        this.error = error;
++        this.line = line;
++        this.column = column;
++    }
++
++    /** The statement's source text, exactly as written, without its delimiter. */
++    public String getSql() {
++        return sql;
++    }
++
++    /** The strict parser's message for this text, positions counted from the start of the whole script. */
++    public String getError() {
++        return error;
++    }
++
++    public int getLine() {
++        return line;
++    }
++
++    public int getColumn() {
++        return column;
++    }
++
++    @Override
++    protected void accept0(SQLASTVisitor v) {
++        // nothing to visit
++    }
++
++    @Override
++    public void output(StringBuilder buf) {
++        buf.append(sql);
++    }
++
++    @Override
++    public String toString() {
++        return sql;
++    }
++
++    @Override
++    public String toString(VisitorFeature... features) {
++        return sql;
++    }
++
++    @Override
++    public SQLUnparsedStatement clone() {
++        SQLUnparsedStatement x = new SQLUnparsedStatement(dbType, sql, error, line, column);
++        x.setAfterSemi(afterSemi);
++        return x;
++    }
++}
+diff --git a/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java
+new file mode 100644
+index 0000000..9fba816
+--- /dev/null
++++ b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java
+@@ -0,0 +1,462 @@
++package com.alibaba.druid.sql.parser;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.ast.SQLStatement;
++import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement;
++
++import java.util.ArrayList;
++import java.util.List;
++
++/**
++ * Reads a whole script in one lexer pass. Every statement the strict parser reads is returned as today; every
++ * statement it cannot read is returned as {@link SQLUnparsedStatement} holding its exact source text and the strict
++ * parser's message for that text, with positions moved to the script. The extent of an unparsed statement is found
++ * by scanning its tokens with the dialect's block structure (a compound statement is one statement) up to the
++ * semicolon that ends it at the top level; a statement whose lexer never recovers runs to the end of the input.
++ */
++public class LenientScriptParser {
++    /** the script as handed in */
++    private final String sql;
++    /** the text the lexer reads: the parser factory rewrites CRLF to LF, so lexer positions refer to this one */
++    private final String text;
++    private final DbType dbType;
++    private final SQLStatementParser parser;
++    private final Lexer lexer;
++
++    public LenientScriptParser(String sql, DbType dbType) {
++        this.sql = sql;
++        this.dbType = dbType == null ? DbType.other : dbType;
++        this.parser = SQLParserUtils.createSQLStatementParser(sql, this.dbType, new SQLParserFeature[0]);
++        this.lexer = parser.getLexer();
++        this.text = lexer.text;
++    }
++
++    /** original offset of a normalized offset; end = true maps the exclusive end of a slice */
++    private int orig(int idx, boolean end) {
++        if (text.length() == sql.length()) {
++            return idx;
++        }
++        if (end) {
++            if (idx <= 0) {
++                return 0;
++            }
++            return orig(idx - 1, false) + 1;
++        }
++        // walk both strings: every "\r\n" of the original is one "\n" of the text
++        int j = 0;
++        for (int i = 0; i < idx && j < sql.length(); i++) {
++            if (sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(i) == '\n') {
++                j++;
++            }
++            j++;
++        }
++        if (idx < text.length() && j < sql.length() && sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(idx) == '\n') {
++            j++;
++        }
++        return j;
++    }
++
++    public List<SQLStatement> parse() {
++        List<SQLStatement> out = new ArrayList<SQLStatement>();
++        while (true) {
++            // delimiters and comment tokens between statements, handled as the dialect's own loop handles them: the
++            // base loop hands the comments after a delimiter to the previous statement, Oracle's loop leaves them for
++            // the next one
++            try {
++                while (true) {
++                    while (lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) {
++                        lexer.nextToken();
++                    }
++                    if (lexer.token() != Token.SEMI) {
++                        break;
++                    }
++                    char ch = lexer.ch;
++                    lexer.nextToken();
++                    if (!out.isEmpty()) {
++                        SQLStatement last = out.get(out.size() - 1);
++                        last.setAfterSemi(true);
++                        if (!isOracle() && lexer.isKeepComments()) {
++                            if (ch == '\n' && lexer.getComments() != null && !lexer.getComments().isEmpty()
++                                    && !(last instanceof com.alibaba.druid.sql.ast.statement.SQLSetStatement)) {
++                                lexer.getComments().add(0, new String("\n"));
++                            }
++                            last.addAfterComment(lexer.readAndResetComments());
++                        }
++                    }
++                }
++            } catch (RuntimeException e) {
++                // the lexer failed on the first token after a delimiter: that statement runs to the end of the input
++                addUnparsed(out, firstTokenStart(lexer.mark), text.length());
++                return out;
++            }
++            if (lexer.token() == Token.EOF) {
++                break;
++            }
++            Lexer.SavePoint sp = lexer.mark();
++            int before = out.size();
++            boolean ok;
++            try {
++                // one statement through the dialect's own loop, which also consumes delimiters and comments as today
++                parser.parseStatementList(out, before + 1, null);
++                // what the strict loop accepted as one statement is one statement; only delimiters and comments
++                // followed by the end of the input add nothing
++                ok = out.size() == before + 1 || (out.size() == before && lexer.token() == Token.EOF);
++            } catch (RuntimeException e) {
++                ok = false;
++            }
++            if (ok) {
++                if (out.size() == before) {
++                    break;
++                }
++                continue;
++            }
++            while (out.size() > before) {
++                out.remove(out.size() - 1);
++            }
++            lexer.reset(sp);
++            int[] se = skipStatement();
++            addUnparsed(out, se[0], se[1]);
++            if (se[1] >= text.length()) {
++                return out;
++            }
++            // the lexer stands on the delimiter; the next round's strict loop consumes it as today
++        }
++        return out;
++    }
++
++    /**
++     * The lexer's startPos for a token that follows kept comments points at the first comment; the statement's text
++     * begins at its first token, so step over whitespace and comments from there (offsets in the lexer's text).
++     */
++    private int firstTokenStart(int from) {
++        int i = from < 0 ? 0 : from;
++        int n = text.length();
++        while (i < n) {
++            char c = text.charAt(i);
++            if (Character.isWhitespace(c)) {
++                i++;
++            } else if (c == '-' && i + 1 < n && text.charAt(i + 1) == '-') {
++                while (i < n && text.charAt(i) != '\n') {
++                    i++;
++                }
++            } else if (c == '#' && isMySql()) {
++                while (i < n && text.charAt(i) != '\n') {
++                    i++;
++                }
++            } else if (c == '/' && i + 1 < n && text.charAt(i + 1) == '*') {
++                int close = text.indexOf("*/", i + 2);
++                if (close < 0) {
++                    return i;
++                }
++                i = close + 2;
++            } else {
++                break;
++            }
++        }
++        return i;
++    }
++
++    /** start and end are offsets in the lexer's text; the item keeps the original characters */
++    private void addUnparsed(List<SQLStatement> out, int start, int end) {
++        if (start < 0) {
++            start = 0;
++        }
++        if (end > text.length()) {
++            end = text.length();
++        }
++        if (end < start) {
++            end = start;
++        }
++        int oStart = orig(start, false);
++        int oEnd = end >= text.length() ? sql.length() : orig(end, true);
++        if (oEnd < oStart) {
++            oEnd = oStart;
++        }
++        start = oStart;
++        String item = sql.substring(oStart, oEnd);
++        String msg = strictMessage(item);
++        int line = 1, col = 1;
++        for (int i = 0; i < start; i++) {
++            if (sql.charAt(i) == '\n') {
++                line++;
++                col = 1;
++            } else {
++                col++;
++            }
++        }
++        String moved = move(msg, start, line, col);
++        int[] lc = lineCol(moved);
++        SQLUnparsedStatement u = new SQLUnparsedStatement(dbType, item, moved, lc[0], lc[1]);
++        out.add(u);
++    }
++
++    /** The strict parser's message for the text on its own. */
++    private String strictMessage(String text) {
++        try {
++            SQLStatementParser p = SQLParserUtils.createSQLStatementParser(text, dbType, new SQLParserFeature[0]);
++            List<SQLStatement> l = new ArrayList<SQLStatement>();
++            p.parseStatementList(l, -1, null);
++            if (p.getLexer().token() != Token.EOF) {
++                return "syntax error : " + p.getLexer().info();
++            }
++            return "syntax error";
++        } catch (RuntimeException e) {
++            return e.getMessage() == null ? e.toString() : e.getMessage();
++        }
++    }
++
++    // ------------------------------------------------------------------ extent
++
++    private boolean isMySql() {
++        return dbType == DbType.mysql || dbType == DbType.mariadb || dbType == DbType.tidb || dbType == DbType.oceanbase
++                || dbType == DbType.polardbx || dbType == DbType.drds || dbType == DbType.ads;
++    }
++
++    private boolean isOracle() {
++        return dbType == DbType.oracle || dbType == DbType.oceanbase_oracle || dbType == DbType.polardb2;
++    }
++
++    private boolean isSqlServer() {
++        return dbType == DbType.sqlserver || dbType == DbType.jtds;
++    }
++
++    private boolean isPg() {
++        return dbType == DbType.postgresql || dbType == DbType.edb || dbType == DbType.greenplum || dbType == DbType.gaussdb
++                || dbType == DbType.hologres || dbType == DbType.redshift;
++    }
++
++    /**
++     * From the first token of a statement, scan to the delimiter ending it as a top level statement. Returns the end
++     * offset (exclusive) of its last token and leaves the lexer on that delimiter (or EOF). When the lexer cannot read
++     * on, the statement runs to the end of the input.
++     */
++    private int[] skipStatement() {
++        // leading delimiters and comment tokens belong to no statement
++        try {
++            while (lexer.token() == Token.SEMI || lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) {
++                lexer.nextToken();
++            }
++        } catch (RuntimeException e) {
++            // the lexer failed on the first token: that statement runs to the end of the input
++            return new int[] {firstTokenStart(lexer.mark), text.length()};
++        }
++        int start = firstTokenStart(lexer.startPos);
++        if (lexer.token() == Token.EOF) {
++            return new int[] {start, start};
++        }
++        int depth = 0;
++        // per depth: whether the next BEGIN at this level is the body of an already opened block (DECLARE, IS/AS)
++        boolean[] absorb = new boolean[256];
++        int end = lexer.pos();
++        boolean stmtStart = true;
++        boolean afterEnd = false;
++        boolean routinePending = false;
++        Token prev = null;
++        while (true) {
++            Token t = lexer.token();
++            if (t == Token.EOF) {
++                return new int[] {start, end};
++            }
++            if (t == Token.ERROR) {
++                // a literal, quoted name or comment the lexer could not close runs to the end of the input;
++                // any other unreadable character is just a token of the statement
++                char c = lexer.startPos < text.length() ? text.charAt(lexer.startPos) : ' ';
++                if (lexer.pos() >= text.length() || c == '\'' || c == '"' || c == '`' || c == '[' || c == '/') {
++                    return new int[] {start, text.length()};
++                }
++            }
++            if (t == Token.SEMI && depth == 0) {
++                if (isSqlServer()) {
++                    // IF cond stmt; ELSE stmt; is one statement
++                    Lexer.SavePoint sp = lexer.mark();
++                    try {
++                        lexer.nextToken();
++                    } catch (RuntimeException e) {
++                        return new int[] {start, text.length()};
++                    }
++                    if (lexer.token() == Token.ELSE) {
++                        prev = Token.SEMI;
++                        stmtStart = true;
++                        // fall through to treat ELSE as an ordinary token
++                    } else {
++                        lexer.reset(sp);
++                        return new int[] {start, end};
++                    }
++                } else {
++                    return new int[] {start, end};
++                }
++            }
++            t = lexer.token();
++            boolean startHere = stmtStart;
++            boolean opener = false;
++            boolean closerKeyword = false;
++            if (afterEnd) {
++                if (t == Token.IF || t == Token.LOOP || t == Token.CASE || t == Token.WHILE || t == Token.REPEAT
++                        || lexer.identifierEquals("TRY") || lexer.identifierEquals("CATCH")) {
++                    closerKeyword = true;
++                }
++                afterEnd = false;
++            }
++            if (!closerKeyword) {
++                if (t == Token.BEGIN) {
++                    opener = beginOpensBlock();
++                    if (opener && depth > 0 && absorb[depth]) {
++                        opener = false;
++                        absorb[depth] = false;
++                    }
++                } else if (t == Token.CASE || t == Token.LOOP) {
++                    opener = true;
++                } else if (t == Token.IF) {
++                    opener = startHere && !isSqlServer();
++                } else if (t == Token.WHILE || t == Token.REPEAT) {
++                    opener = startHere && isMySql();
++                } else if (t == Token.DECLARE) {
++                    if (startHere && (isOracle() || isPg())) {
++                        opener = true;
++                        if (depth + 1 < absorb.length) {
++                            absorb[depth + 1] = true;
++                        }
++                    }
++                } else if (t == Token.PROCEDURE || t == Token.FUNCTION || lexer.identifierEquals("PACKAGE")) {
++                    if (isOracle() && (startHere || prev == Token.CREATE || prev == Token.REPLACE)) {
++                        routinePending = true;
++                    }
++                } else if ((t == Token.IS || t == Token.AS) && routinePending) {
++                    routinePending = false;
++                    opener = true;
++                    if (depth + 1 < absorb.length) {
++                        absorb[depth + 1] = true;
++                    }
++                } else if (t == Token.END) {
++                    if (depth > 0) {
++                        absorb[depth] = false;
++                        depth--;
++                    }
++                    afterEnd = true;
++                }
++            }
++            if (opener) {
++                depth++;
++                if (t == Token.BEGIN || t == Token.LOOP || t == Token.CASE || t == Token.IF || t == Token.WHILE || t == Token.REPEAT) {
++                    // a fresh block: nothing pending to absorb at this level unless set above
++                    if (t != Token.BEGIN && depth < absorb.length && !(t == Token.DECLARE)) {
++                        absorb[depth] = absorb[depth] && false;
++                    }
++                }
++            }
++            stmtStart = t == Token.SEMI || t == Token.BEGIN || t == Token.THEN || t == Token.ELSE || t == Token.DO
++                    || t == Token.LOOP || t == Token.EXCEPTION || t == Token.ELSEIF
++                    || (t == Token.VARIANT && lexer.stringVal() != null && lexer.stringVal().startsWith("$"))
++                    || (t == Token.VARIANT && ":".equals(lexer.stringVal()))
++                    || (t == Token.IS || t == Token.AS) && opener
++                    || t == Token.GTGT;
++            prev = t;
++            end = lexer.pos();
++            try {
++                lexer.nextToken();
++            } catch (RuntimeException e) {
++                return new int[] {start, text.length()};
++            }
++        }
++    }
++
++    /** BEGIN opens a block unless the dialect reads it as a transaction command. Consumes nothing (peeks and resets). */
++    private boolean beginOpensBlock() {
++        if (isOracle()) {
++            return true;
++        }
++        Lexer.SavePoint sp = lexer.mark();
++        boolean block;
++        try {
++            lexer.nextToken();
++            Token n = lexer.token();
++            if (isMySql()) {
++                block = !(n == Token.SEMI || n == Token.EOF || n == Token.IDENTIFIER);
++            } else if (isSqlServer()) {
++                block = !(lexer.identifierEquals("TRANSACTION") || lexer.identifierEquals("TRAN") || lexer.identifierEquals("DISTRIBUTED"));
++            } else {
++                block = !(n == Token.SEMI || n == Token.EOF || lexer.identifierEquals("WORK") || lexer.identifierEquals("TRANSACTION")
++                        || lexer.identifierEquals("ISOLATION") || lexer.identifierEquals("READ") || lexer.identifierEquals("DEFERRABLE")
++                        || lexer.identifierEquals("NOT"));
++            }
++        } catch (RuntimeException e) {
++            block = true;
++        }
++        lexer.reset(sp);
++        return block;
++    }
++
++    // ------------------------------------------------------------------ positions
++
++    /** Rewrites every "pos N, line L, column C" in a message from the statement's frame to the script's. */
++    static String move(String m, int start, int sLine, int sCol) {
++        if (m == null) {
++            return null;
++        }
++        StringBuilder sb = new StringBuilder();
++        int i = 0;
++        while (true) {
++            int p = m.indexOf("pos ", i);
++            if (p < 0) {
++                sb.append(m.substring(i));
++                break;
++            }
++            int pe = p + 4;
++            while (pe < m.length() && Character.isDigit(m.charAt(pe))) {
++                pe++;
++            }
++            if (pe == p + 4 || !m.startsWith(", line ", pe)) {
++                sb.append(m, i, pe);
++                i = pe;
++                continue;
++            }
++            int le = pe + 7;
++            while (le < m.length() && Character.isDigit(m.charAt(le))) {
++                le++;
++            }
++            if (le == pe + 7 || !m.startsWith(", column ", le)) {
++                sb.append(m, i, le);
++                i = le;
++                continue;
++            }
++            int ce = le + 9;
++            while (ce < m.length() && Character.isDigit(m.charAt(ce))) {
++                ce++;
++            }
++            if (ce == le + 9) {
++                sb.append(m, i, ce);
++                i = ce;
++                continue;
++            }
++            int pos = Integer.parseInt(m.substring(p + 4, pe));
++            int line = Integer.parseInt(m.substring(pe + 7, le));
++            int col = Integer.parseInt(m.substring(le + 9, ce));
++            sb.append(m, i, p).append("pos ").append(pos + start).append(", line ").append(line + sLine - 1)
++                    .append(", column ").append(line == 1 ? col + sCol - 1 : col);
++            i = ce;
++        }
++        return sb.toString();
++    }
++
++    static int[] lineCol(String m) {
++        if (m == null) {
++            return new int[] {-1, -1};
++        }
++        int li = m.indexOf(", line ");
++        if (li < 0) {
++            return new int[] {-1, -1};
++        }
++        int l = num(m, li + 7);
++        int ci = m.indexOf(", column ", li);
++        int c = ci < 0 ? -1 : num(m, ci + 9);
++        return new int[] {l, c};
++    }
++
++    static int num(String m, int j) {
++        int k = j;
++        while (k < m.length() && Character.isDigit(m.charAt(k))) {
++            k++;
++        }
++        return k == j ? -1 : Integer.parseInt(m.substring(j, k));
++    }
++}
+diff --git a/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java
+new file mode 100644
+index 0000000..9bdc701
+--- /dev/null
++++ b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java
+@@ -0,0 +1,227 @@
++package com.alibaba.druid.bvt.sql;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.SQLUtils;
++import com.alibaba.druid.sql.ast.SQLStatement;
++import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement;
++import org.junit.jupiter.api.Test;
++
++import java.util.ArrayList;
++import java.util.List;
++import java.util.regex.Matcher;
++import java.util.regex.Pattern;
++
++import static org.junit.jupiter.api.Assertions.assertEquals;
++import static org.junit.jupiter.api.Assertions.assertFalse;
++import static org.junit.jupiter.api.Assertions.assertTrue;
++import static org.junit.jupiter.api.Assertions.fail;
++
++/**
++ * The lenient whole-script read: SQLUtils.parseStatementsLenient returns what the strict call reads as today and the
++ * rest as SQLUnparsedStatement carrying the statement's exact text and the strict message for that text on its own,
++ * with pos, line and column counted from the script start.
++ */
++public class LenientScriptReadTest {
++    private static final Pattern POS = Pattern.compile("pos (\\d+), line (\\d+), column (\\d+)");
++
++    private static List<SQLUnparsedStatement> unparsedOf(List<SQLStatement> list) {
++        List<SQLUnparsedStatement> out = new ArrayList<SQLUnparsedStatement>();
++        for (SQLStatement s : list) {
++            if (s instanceof SQLUnparsedStatement) {
++                out.add((SQLUnparsedStatement) s);
++            }
++        }
++        return out;
++    }
++
++    /** the message the strict call gives for a text on its own */
++    private static String strictMessage(String sql, DbType dbType) {
++        try {
++            SQLUtils.parseStatements(sql, dbType);
++        } catch (Exception e) {
++            return e.getMessage();
++        }
++        fail("the text should not parse on its own: " + sql);
++        return null;
++    }
++
++    /** the same message with pos, line and column counted from the script start, for a statement starting at (offset, line, column) */
++    private static String counted(String standalone, int offset, int line, int column) {
++        Matcher m = POS.matcher(standalone);
++        StringBuffer sb = new StringBuffer();
++        while (m.find()) {
++            int p = Integer.parseInt(m.group(1)), l = Integer.parseInt(m.group(2)), c = Integer.parseInt(m.group(3));
++            m.appendReplacement(sb, "pos " + (p + offset) + ", line " + (l + line - 1) + ", column " + (l == 1 ? c + column - 1 : c));
++        }
++        m.appendTail(sb);
++        return sb.toString();
++    }
++
++    private static int lineOf(String error) {
++        Matcher m = POS.matcher(error);
++        assertTrue(m.find(), error);
++        return Integer.parseInt(m.group(2));
++    }
++
++    private static int columnOf(String error) {
++        Matcher m = POS.matcher(error);
++        assertTrue(m.find(), error);
++        return Integer.parseInt(m.group(3));
++    }
++
++    @Test
++    public void allGoodComesBackAsStrict() {
++        String sql = "select id from t where x = 1; insert into t (a) values (2); update t set a = 3;";
++        List<SQLStatement> strict = SQLUtils.parseStatements(sql, DbType.mysql);
++        List<SQLStatement> lenient = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(strict.size(), lenient.size());
++        for (int i = 0; i < strict.size(); ++i) {
++            assertEquals(strict.get(i).toString(), lenient.get(i).toString());
++        }
++        assertTrue(unparsedOf(lenient).isEmpty());
++    }
++
++    @Test
++    public void badSimpleStatementBetweenGoodOnes() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1; " + bad + "; select 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(bad, u.toString());
++        String standalone = strictMessage(bad, DbType.mysql);
++        assertEquals(counted(standalone, 10, 1, 11), u.getError());
++        assertEquals(lineOf(u.getError()), u.getLine());
++        assertEquals(columnOf(u.getError()), u.getColumn());
++    }
++
++    @Test
++    public void errorLineCountedFromScriptStart() {
++        String sql = "select 1;\nselect * from t where a ==== 1;\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals("select * from t where a ==== 1", u.getSql());
++        assertEquals("ERROR. pos 38, line 2, column 27, token ==", u.getError());
++        assertEquals(2, u.getLine());
++        assertEquals(27, u.getColumn());
++    }
++
++    @Test
++    public void whatFollowsParsesAsTheScriptWithoutIt() {
++        String script = "select 1; nonsense here; select 2 from t; create table x (id bigint);";
++        String without = "select 1; select 2 from t; create table x (id bigint);";
++        List<SQLStatement> lenient = SQLUtils.parseStatementsLenient(script, DbType.mysql);
++        List<SQLStatement> strict = SQLUtils.parseStatements(without, DbType.mysql);
++        assertEquals(4, lenient.size());
++        assertTrue(lenient.get(1) instanceof SQLUnparsedStatement);
++        assertEquals(strict.get(0).toString(), lenient.get(0).toString());
++        assertEquals(strict.get(1).toString(), lenient.get(2).toString());
++        assertEquals(strict.get(2).toString(), lenient.get(3).toString());
++    }
++
++    @Test
++    public void compoundStatementIsOneStatement() {
++        String sql = "create procedure p() begin if x > 0 then begin select bad from; end; end if; end; select 7;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(0);
++        assertEquals("create procedure p() begin if x > 0 then begin select bad from; end; end if; end", u.getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void compoundLoopsAreOneStatement() {
++        String sql = "create procedure p() begin while i < 10 do set i = i + + ; end while; end; select 7;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        assertEquals("create procedure p() begin while i < 10 do set i = i + + ; end while; end",
++                ((SQLUnparsedStatement) list.get(0)).getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void oracleDeclareSectionBelongsToTheBlock() {
++        String sql = "begin null; end;\ndeclare x number; begin x := ; end;\nselect 1 from dual;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.oracle);
++        assertEquals(3, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals("declare x number; begin x := ; end", u.getSql());
++        assertEquals(2, u.getLine());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void sqlServerIfElseBranchesAreOneStatement() {
++        String sql = "if 1 = 1 select bad from; else select 2;\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.sqlserver);
++        assertEquals(2, list.size());
++        assertEquals("if 1 = 1 select bad from; else select 2", ((SQLUnparsedStatement) list.get(0)).getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void keywordsAsNamesFunctionsModifiersAndTransactionsOpenNothing() {
++        String sql = "begin; select 1; commit; select if(a, 1, 2) from t; select `end` from t; drop table if exists t2;"
++                + " delete from where a = 1; select 4;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        List<SQLUnparsedStatement> bad = unparsedOf(list);
++        assertEquals(1, bad.size());
++        assertEquals("delete from where a = 1", bad.get(0).getSql());
++        assertEquals(8, list.size());
++        assertFalse(list.get(7) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void unclosedStringRunsToTheEndOfTheInput() {
++        String tail = "select 'abc; select 3;";
++        String sql = "select 1; " + tail;
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(tail, u.getSql());
++        assertEquals(counted(strictMessage(tail, DbType.mysql), 10, 1, 11), u.getError());
++    }
++
++    @Test
++    public void textIsExactUnderCrlf() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1;\r\n" + bad + ";\r\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(2, u.getLine());
++        assertEquals(counted(strictMessage(bad, DbType.mysql), 11, 2, 1), u.getError());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void commentAheadOfABadStatementIsNotPartOfItsText() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1;\n-- note\n" + bad + ";\n/* block */ select 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(3, u.getLine());
++        assertEquals(counted(strictMessage(bad, DbType.mysql), 18, 3, 1), u.getError());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void strictEntryPointsUnchanged() {
++        try {
++            SQLUtils.parseStatements("select 1; select a from where a = 1; select 3;", DbType.mysql);
++            fail("the strict call must still fail on a bad statement");
++        } catch (Exception e) {
++            assertTrue(e.getMessage().contains("pos "), e.getMessage());
++        }
++    }
++}

harbor/tasks/druid_lenient_script/solution/solve.sh

@@ -0,0 +1,801 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
+index 2ad08d6..1ebbe21 100644
+--- a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
++++ b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java
+@@ -677,6 +677,14 @@ public class SQLUtils {
+         return parseStatements(sql, DbType.of(dbType), features);
+     }
+ 
++    /**
++     * Reads a whole script; statements the strict parser cannot read come back as
++     * {@link com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement} in place, the rest as today.
++     */
++    public static List<SQLStatement> parseStatementsLenient(String sql, DbType dbType) {
++        return new com.alibaba.druid.sql.parser.LenientScriptParser(sql, dbType).parse();
++    }
++
+     public static List<SQLStatement> parseStatements(String sql, DbType dbType, SQLParserFeature... features) {
+         SQLStatementParser parser = SQLParserUtils.createSQLStatementParser(sql, dbType, features);
+         List<SQLStatement> stmtList = new ArrayList<SQLStatement>();
+diff --git a/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java
+new file mode 100644
+index 0000000..336039b
+--- /dev/null
++++ b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java
+@@ -0,0 +1,69 @@
++package com.alibaba.druid.sql.ast.statement;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.ast.SQLStatementImpl;
++import com.alibaba.druid.sql.visitor.SQLASTVisitor;
++import com.alibaba.druid.sql.visitor.VisitorFeature;
++
++/**
++ * A statement the strict parser could not read, kept as its source text by the lenient script read.
++ */
++public class SQLUnparsedStatement extends SQLStatementImpl {
++    private final String sql;
++    private final String error;
++    private final int line;
++    private final int column;
++
++    public SQLUnparsedStatement(DbType dbType, String sql, String error, int line, int column) {
++        super(dbType);
++        this.sql = sql;
++        this.error = error;
++        this.line = line;
++        this.column = column;
++    }
++
++    /** The statement's source text, exactly as written, without its delimiter. */
++    public String getSql() {
++        return sql;
++    }
++
++    /** The strict parser's message for this text, positions counted from the start of the whole script. */
++    public String getError() {
++        return error;
++    }
++
++    public int getLine() {
++        return line;
++    }
++
++    public int getColumn() {
++        return column;
++    }
++
++    @Override
++    protected void accept0(SQLASTVisitor v) {
++        // nothing to visit
++    }
++
++    @Override
++    public void output(StringBuilder buf) {
++        buf.append(sql);
++    }
++
++    @Override
++    public String toString() {
++        return sql;
++    }
++
++    @Override
++    public String toString(VisitorFeature... features) {
++        return sql;
++    }
++
++    @Override
++    public SQLUnparsedStatement clone() {
++        SQLUnparsedStatement x = new SQLUnparsedStatement(dbType, sql, error, line, column);
++        x.setAfterSemi(afterSemi);
++        return x;
++    }
++}
+diff --git a/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java
+new file mode 100644
+index 0000000..9fba816
+--- /dev/null
++++ b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java
+@@ -0,0 +1,462 @@
++package com.alibaba.druid.sql.parser;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.ast.SQLStatement;
++import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement;
++
++import java.util.ArrayList;
++import java.util.List;
++
++/**
++ * Reads a whole script in one lexer pass. Every statement the strict parser reads is returned as today; every
++ * statement it cannot read is returned as {@link SQLUnparsedStatement} holding its exact source text and the strict
++ * parser's message for that text, with positions moved to the script. The extent of an unparsed statement is found
++ * by scanning its tokens with the dialect's block structure (a compound statement is one statement) up to the
++ * semicolon that ends it at the top level; a statement whose lexer never recovers runs to the end of the input.
++ */
++public class LenientScriptParser {
++    /** the script as handed in */
++    private final String sql;
++    /** the text the lexer reads: the parser factory rewrites CRLF to LF, so lexer positions refer to this one */
++    private final String text;
++    private final DbType dbType;
++    private final SQLStatementParser parser;
++    private final Lexer lexer;
++
++    public LenientScriptParser(String sql, DbType dbType) {
++        this.sql = sql;
++        this.dbType = dbType == null ? DbType.other : dbType;
++        this.parser = SQLParserUtils.createSQLStatementParser(sql, this.dbType, new SQLParserFeature[0]);
++        this.lexer = parser.getLexer();
++        this.text = lexer.text;
++    }
++
++    /** original offset of a normalized offset; end = true maps the exclusive end of a slice */
++    private int orig(int idx, boolean end) {
++        if (text.length() == sql.length()) {
++            return idx;
++        }
++        if (end) {
++            if (idx <= 0) {
++                return 0;
++            }
++            return orig(idx - 1, false) + 1;
++        }
++        // walk both strings: every "\r\n" of the original is one "\n" of the text
++        int j = 0;
++        for (int i = 0; i < idx && j < sql.length(); i++) {
++            if (sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(i) == '\n') {
++                j++;
++            }
++            j++;
++        }
++        if (idx < text.length() && j < sql.length() && sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(idx) == '\n') {
++            j++;
++        }
++        return j;
++    }
++
++    public List<SQLStatement> parse() {
++        List<SQLStatement> out = new ArrayList<SQLStatement>();
++        while (true) {
++            // delimiters and comment tokens between statements, handled as the dialect's own loop handles them: the
++            // base loop hands the comments after a delimiter to the previous statement, Oracle's loop leaves them for
++            // the next one
++            try {
++                while (true) {
++                    while (lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) {
++                        lexer.nextToken();
++                    }
++                    if (lexer.token() != Token.SEMI) {
++                        break;
++                    }
++                    char ch = lexer.ch;
++                    lexer.nextToken();
++                    if (!out.isEmpty()) {
++                        SQLStatement last = out.get(out.size() - 1);
++                        last.setAfterSemi(true);
++                        if (!isOracle() && lexer.isKeepComments()) {
++                            if (ch == '\n' && lexer.getComments() != null && !lexer.getComments().isEmpty()
++                                    && !(last instanceof com.alibaba.druid.sql.ast.statement.SQLSetStatement)) {
++                                lexer.getComments().add(0, new String("\n"));
++                            }
++                            last.addAfterComment(lexer.readAndResetComments());
++                        }
++                    }
++                }
++            } catch (RuntimeException e) {
++                // the lexer failed on the first token after a delimiter: that statement runs to the end of the input
++                addUnparsed(out, firstTokenStart(lexer.mark), text.length());
++                return out;
++            }
++            if (lexer.token() == Token.EOF) {
++                break;
++            }
++            Lexer.SavePoint sp = lexer.mark();
++            int before = out.size();
++            boolean ok;
++            try {
++                // one statement through the dialect's own loop, which also consumes delimiters and comments as today
++                parser.parseStatementList(out, before + 1, null);
++                // what the strict loop accepted as one statement is one statement; only delimiters and comments
++                // followed by the end of the input add nothing
++                ok = out.size() == before + 1 || (out.size() == before && lexer.token() == Token.EOF);
++            } catch (RuntimeException e) {
++                ok = false;
++            }
++            if (ok) {
++                if (out.size() == before) {
++                    break;
++                }
++                continue;
++            }
++            while (out.size() > before) {
++                out.remove(out.size() - 1);
++            }
++            lexer.reset(sp);
++            int[] se = skipStatement();
++            addUnparsed(out, se[0], se[1]);
++            if (se[1] >= text.length()) {
++                return out;
++            }
++            // the lexer stands on the delimiter; the next round's strict loop consumes it as today
++        }
++        return out;
++    }
++
++    /**
++     * The lexer's startPos for a token that follows kept comments points at the first comment; the statement's text
++     * begins at its first token, so step over whitespace and comments from there (offsets in the lexer's text).
++     */
++    private int firstTokenStart(int from) {
++        int i = from < 0 ? 0 : from;
++        int n = text.length();
++        while (i < n) {
++            char c = text.charAt(i);
++            if (Character.isWhitespace(c)) {
++                i++;
++            } else if (c == '-' && i + 1 < n && text.charAt(i + 1) == '-') {
++                while (i < n && text.charAt(i) != '\n') {
++                    i++;
++                }
++            } else if (c == '#' && isMySql()) {
++                while (i < n && text.charAt(i) != '\n') {
++                    i++;
++                }
++            } else if (c == '/' && i + 1 < n && text.charAt(i + 1) == '*') {
++                int close = text.indexOf("*/", i + 2);
++                if (close < 0) {
++                    return i;
++                }
++                i = close + 2;
++            } else {
++                break;
++            }
++        }
++        return i;
++    }
++
++    /** start and end are offsets in the lexer's text; the item keeps the original characters */
++    private void addUnparsed(List<SQLStatement> out, int start, int end) {
++        if (start < 0) {
++            start = 0;
++        }
++        if (end > text.length()) {
++            end = text.length();
++        }
++        if (end < start) {
++            end = start;
++        }
++        int oStart = orig(start, false);
++        int oEnd = end >= text.length() ? sql.length() : orig(end, true);
++        if (oEnd < oStart) {
++            oEnd = oStart;
++        }
++        start = oStart;
++        String item = sql.substring(oStart, oEnd);
++        String msg = strictMessage(item);
++        int line = 1, col = 1;
++        for (int i = 0; i < start; i++) {
++            if (sql.charAt(i) == '\n') {
++                line++;
++                col = 1;
++            } else {
++                col++;
++            }
++        }
++        String moved = move(msg, start, line, col);
++        int[] lc = lineCol(moved);
++        SQLUnparsedStatement u = new SQLUnparsedStatement(dbType, item, moved, lc[0], lc[1]);
++        out.add(u);
++    }
++
++    /** The strict parser's message for the text on its own. */
++    private String strictMessage(String text) {
++        try {
++            SQLStatementParser p = SQLParserUtils.createSQLStatementParser(text, dbType, new SQLParserFeature[0]);
++            List<SQLStatement> l = new ArrayList<SQLStatement>();
++            p.parseStatementList(l, -1, null);
++            if (p.getLexer().token() != Token.EOF) {
++                return "syntax error : " + p.getLexer().info();
++            }
++            return "syntax error";
++        } catch (RuntimeException e) {
++            return e.getMessage() == null ? e.toString() : e.getMessage();
++        }
++    }
++
++    // ------------------------------------------------------------------ extent
++
++    private boolean isMySql() {
++        return dbType == DbType.mysql || dbType == DbType.mariadb || dbType == DbType.tidb || dbType == DbType.oceanbase
++                || dbType == DbType.polardbx || dbType == DbType.drds || dbType == DbType.ads;
++    }
++
++    private boolean isOracle() {
++        return dbType == DbType.oracle || dbType == DbType.oceanbase_oracle || dbType == DbType.polardb2;
++    }
++
++    private boolean isSqlServer() {
++        return dbType == DbType.sqlserver || dbType == DbType.jtds;
++    }
++
++    private boolean isPg() {
++        return dbType == DbType.postgresql || dbType == DbType.edb || dbType == DbType.greenplum || dbType == DbType.gaussdb
++                || dbType == DbType.hologres || dbType == DbType.redshift;
++    }
++
++    /**
++     * From the first token of a statement, scan to the delimiter ending it as a top level statement. Returns the end
++     * offset (exclusive) of its last token and leaves the lexer on that delimiter (or EOF). When the lexer cannot read
++     * on, the statement runs to the end of the input.
++     */
++    private int[] skipStatement() {
++        // leading delimiters and comment tokens belong to no statement
++        try {
++            while (lexer.token() == Token.SEMI || lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) {
++                lexer.nextToken();
++            }
++        } catch (RuntimeException e) {
++            // the lexer failed on the first token: that statement runs to the end of the input
++            return new int[] {firstTokenStart(lexer.mark), text.length()};
++        }
++        int start = firstTokenStart(lexer.startPos);
++        if (lexer.token() == Token.EOF) {
++            return new int[] {start, start};
++        }
++        int depth = 0;
++        // per depth: whether the next BEGIN at this level is the body of an already opened block (DECLARE, IS/AS)
++        boolean[] absorb = new boolean[256];
++        int end = lexer.pos();
++        boolean stmtStart = true;
++        boolean afterEnd = false;
++        boolean routinePending = false;
++        Token prev = null;
++        while (true) {
++            Token t = lexer.token();
++            if (t == Token.EOF) {
++                return new int[] {start, end};
++            }
++            if (t == Token.ERROR) {
++                // a literal, quoted name or comment the lexer could not close runs to the end of the input;
++                // any other unreadable character is just a token of the statement
++                char c = lexer.startPos < text.length() ? text.charAt(lexer.startPos) : ' ';
++                if (lexer.pos() >= text.length() || c == '\'' || c == '"' || c == '`' || c == '[' || c == '/') {
++                    return new int[] {start, text.length()};
++                }
++            }
++            if (t == Token.SEMI && depth == 0) {
++                if (isSqlServer()) {
++                    // IF cond stmt; ELSE stmt; is one statement
++                    Lexer.SavePoint sp = lexer.mark();
++                    try {
++                        lexer.nextToken();
++                    } catch (RuntimeException e) {
++                        return new int[] {start, text.length()};
++                    }
++                    if (lexer.token() == Token.ELSE) {
++                        prev = Token.SEMI;
++                        stmtStart = true;
++                        // fall through to treat ELSE as an ordinary token
++                    } else {
++                        lexer.reset(sp);
++                        return new int[] {start, end};
++                    }
++                } else {
++                    return new int[] {start, end};
++                }
++            }
++            t = lexer.token();
++            boolean startHere = stmtStart;
++            boolean opener = false;
++            boolean closerKeyword = false;
++            if (afterEnd) {
++                if (t == Token.IF || t == Token.LOOP || t == Token.CASE || t == Token.WHILE || t == Token.REPEAT
++                        || lexer.identifierEquals("TRY") || lexer.identifierEquals("CATCH")) {
++                    closerKeyword = true;
++                }
++                afterEnd = false;
++            }
++            if (!closerKeyword) {
++                if (t == Token.BEGIN) {
++                    opener = beginOpensBlock();
++                    if (opener && depth > 0 && absorb[depth]) {
++                        opener = false;
++                        absorb[depth] = false;
++                    }
++                } else if (t == Token.CASE || t == Token.LOOP) {
++                    opener = true;
++                } else if (t == Token.IF) {
++                    opener = startHere && !isSqlServer();
++                } else if (t == Token.WHILE || t == Token.REPEAT) {
++                    opener = startHere && isMySql();
++                } else if (t == Token.DECLARE) {
++                    if (startHere && (isOracle() || isPg())) {
++                        opener = true;
++                        if (depth + 1 < absorb.length) {
++                            absorb[depth + 1] = true;
++                        }
++                    }
++                } else if (t == Token.PROCEDURE || t == Token.FUNCTION || lexer.identifierEquals("PACKAGE")) {
++                    if (isOracle() && (startHere || prev == Token.CREATE || prev == Token.REPLACE)) {
++                        routinePending = true;
++                    }
++                } else if ((t == Token.IS || t == Token.AS) && routinePending) {
++                    routinePending = false;
++                    opener = true;
++                    if (depth + 1 < absorb.length) {
++                        absorb[depth + 1] = true;
++                    }
++                } else if (t == Token.END) {
++                    if (depth > 0) {
++                        absorb[depth] = false;
++                        depth--;
++                    }
++                    afterEnd = true;
++                }
++            }
++            if (opener) {
++                depth++;
++                if (t == Token.BEGIN || t == Token.LOOP || t == Token.CASE || t == Token.IF || t == Token.WHILE || t == Token.REPEAT) {
++                    // a fresh block: nothing pending to absorb at this level unless set above
++                    if (t != Token.BEGIN && depth < absorb.length && !(t == Token.DECLARE)) {
++                        absorb[depth] = absorb[depth] && false;
++                    }
++                }
++            }
++            stmtStart = t == Token.SEMI || t == Token.BEGIN || t == Token.THEN || t == Token.ELSE || t == Token.DO
++                    || t == Token.LOOP || t == Token.EXCEPTION || t == Token.ELSEIF
++                    || (t == Token.VARIANT && lexer.stringVal() != null && lexer.stringVal().startsWith("$"))
++                    || (t == Token.VARIANT && ":".equals(lexer.stringVal()))
++                    || (t == Token.IS || t == Token.AS) && opener
++                    || t == Token.GTGT;
++            prev = t;
++            end = lexer.pos();
++            try {
++                lexer.nextToken();
++            } catch (RuntimeException e) {
++                return new int[] {start, text.length()};
++            }
++        }
++    }
++
++    /** BEGIN opens a block unless the dialect reads it as a transaction command. Consumes nothing (peeks and resets). */
++    private boolean beginOpensBlock() {
++        if (isOracle()) {
++            return true;
++        }
++        Lexer.SavePoint sp = lexer.mark();
++        boolean block;
++        try {
++            lexer.nextToken();
++            Token n = lexer.token();
++            if (isMySql()) {
++                block = !(n == Token.SEMI || n == Token.EOF || n == Token.IDENTIFIER);
++            } else if (isSqlServer()) {
++                block = !(lexer.identifierEquals("TRANSACTION") || lexer.identifierEquals("TRAN") || lexer.identifierEquals("DISTRIBUTED"));
++            } else {
++                block = !(n == Token.SEMI || n == Token.EOF || lexer.identifierEquals("WORK") || lexer.identifierEquals("TRANSACTION")
++                        || lexer.identifierEquals("ISOLATION") || lexer.identifierEquals("READ") || lexer.identifierEquals("DEFERRABLE")
++                        || lexer.identifierEquals("NOT"));
++            }
++        } catch (RuntimeException e) {
++            block = true;
++        }
++        lexer.reset(sp);
++        return block;
++    }
++
++    // ------------------------------------------------------------------ positions
++
++    /** Rewrites every "pos N, line L, column C" in a message from the statement's frame to the script's. */
++    static String move(String m, int start, int sLine, int sCol) {
++        if (m == null) {
++            return null;
++        }
++        StringBuilder sb = new StringBuilder();
++        int i = 0;
++        while (true) {
++            int p = m.indexOf("pos ", i);
++            if (p < 0) {
++                sb.append(m.substring(i));
++                break;
++            }
++            int pe = p + 4;
++            while (pe < m.length() && Character.isDigit(m.charAt(pe))) {
++                pe++;
++            }
++            if (pe == p + 4 || !m.startsWith(", line ", pe)) {
++                sb.append(m, i, pe);
++                i = pe;
++                continue;
++            }
++            int le = pe + 7;
++            while (le < m.length() && Character.isDigit(m.charAt(le))) {
++                le++;
++            }
++            if (le == pe + 7 || !m.startsWith(", column ", le)) {
++                sb.append(m, i, le);
++                i = le;
++                continue;
++            }
++            int ce = le + 9;
++            while (ce < m.length() && Character.isDigit(m.charAt(ce))) {
++                ce++;
++            }
++            if (ce == le + 9) {
++                sb.append(m, i, ce);
++                i = ce;
++                continue;
++            }
++            int pos = Integer.parseInt(m.substring(p + 4, pe));
++            int line = Integer.parseInt(m.substring(pe + 7, le));
++            int col = Integer.parseInt(m.substring(le + 9, ce));
++            sb.append(m, i, p).append("pos ").append(pos + start).append(", line ").append(line + sLine - 1)
++                    .append(", column ").append(line == 1 ? col + sCol - 1 : col);
++            i = ce;
++        }
++        return sb.toString();
++    }
++
++    static int[] lineCol(String m) {
++        if (m == null) {
++            return new int[] {-1, -1};
++        }
++        int li = m.indexOf(", line ");
++        if (li < 0) {
++            return new int[] {-1, -1};
++        }
++        int l = num(m, li + 7);
++        int ci = m.indexOf(", column ", li);
++        int c = ci < 0 ? -1 : num(m, ci + 9);
++        return new int[] {l, c};
++    }
++
++    static int num(String m, int j) {
++        int k = j;
++        while (k < m.length() && Character.isDigit(m.charAt(k))) {
++            k++;
++        }
++        return k == j ? -1 : Integer.parseInt(m.substring(j, k));
++    }
++}
+diff --git a/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java
+new file mode 100644
+index 0000000..9bdc701
+--- /dev/null
++++ b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java
+@@ -0,0 +1,227 @@
++package com.alibaba.druid.bvt.sql;
++
++import com.alibaba.druid.DbType;
++import com.alibaba.druid.sql.SQLUtils;
++import com.alibaba.druid.sql.ast.SQLStatement;
++import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement;
++import org.junit.jupiter.api.Test;
++
++import java.util.ArrayList;
++import java.util.List;
++import java.util.regex.Matcher;
++import java.util.regex.Pattern;
++
++import static org.junit.jupiter.api.Assertions.assertEquals;
++import static org.junit.jupiter.api.Assertions.assertFalse;
++import static org.junit.jupiter.api.Assertions.assertTrue;
++import static org.junit.jupiter.api.Assertions.fail;
++
++/**
++ * The lenient whole-script read: SQLUtils.parseStatementsLenient returns what the strict call reads as today and the
++ * rest as SQLUnparsedStatement carrying the statement's exact text and the strict message for that text on its own,
++ * with pos, line and column counted from the script start.
++ */
++public class LenientScriptReadTest {
++    private static final Pattern POS = Pattern.compile("pos (\\d+), line (\\d+), column (\\d+)");
++
++    private static List<SQLUnparsedStatement> unparsedOf(List<SQLStatement> list) {
++        List<SQLUnparsedStatement> out = new ArrayList<SQLUnparsedStatement>();
++        for (SQLStatement s : list) {
++            if (s instanceof SQLUnparsedStatement) {
++                out.add((SQLUnparsedStatement) s);
++            }
++        }
++        return out;
++    }
++
++    /** the message the strict call gives for a text on its own */
++    private static String strictMessage(String sql, DbType dbType) {
++        try {
++            SQLUtils.parseStatements(sql, dbType);
++        } catch (Exception e) {
++            return e.getMessage();
++        }
++        fail("the text should not parse on its own: " + sql);
++        return null;
++    }
++
++    /** the same message with pos, line and column counted from the script start, for a statement starting at (offset, line, column) */
++    private static String counted(String standalone, int offset, int line, int column) {
++        Matcher m = POS.matcher(standalone);
++        StringBuffer sb = new StringBuffer();
++        while (m.find()) {
++            int p = Integer.parseInt(m.group(1)), l = Integer.parseInt(m.group(2)), c = Integer.parseInt(m.group(3));
++            m.appendReplacement(sb, "pos " + (p + offset) + ", line " + (l + line - 1) + ", column " + (l == 1 ? c + column - 1 : c));
++        }
++        m.appendTail(sb);
++        return sb.toString();
++    }
++
++    private static int lineOf(String error) {
++        Matcher m = POS.matcher(error);
++        assertTrue(m.find(), error);
++        return Integer.parseInt(m.group(2));
++    }
++
++    private static int columnOf(String error) {
++        Matcher m = POS.matcher(error);
++        assertTrue(m.find(), error);
++        return Integer.parseInt(m.group(3));
++    }
++
++    @Test
++    public void allGoodComesBackAsStrict() {
++        String sql = "select id from t where x = 1; insert into t (a) values (2); update t set a = 3;";
++        List<SQLStatement> strict = SQLUtils.parseStatements(sql, DbType.mysql);
++        List<SQLStatement> lenient = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(strict.size(), lenient.size());
++        for (int i = 0; i < strict.size(); ++i) {
++            assertEquals(strict.get(i).toString(), lenient.get(i).toString());
++        }
++        assertTrue(unparsedOf(lenient).isEmpty());
++    }
++
++    @Test
++    public void badSimpleStatementBetweenGoodOnes() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1; " + bad + "; select 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(bad, u.toString());
++        String standalone = strictMessage(bad, DbType.mysql);
++        assertEquals(counted(standalone, 10, 1, 11), u.getError());
++        assertEquals(lineOf(u.getError()), u.getLine());
++        assertEquals(columnOf(u.getError()), u.getColumn());
++    }
++
++    @Test
++    public void errorLineCountedFromScriptStart() {
++        String sql = "select 1;\nselect * from t where a ==== 1;\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals("select * from t where a ==== 1", u.getSql());
++        assertEquals("ERROR. pos 38, line 2, column 27, token ==", u.getError());
++        assertEquals(2, u.getLine());
++        assertEquals(27, u.getColumn());
++    }
++
++    @Test
++    public void whatFollowsParsesAsTheScriptWithoutIt() {
++        String script = "select 1; nonsense here; select 2 from t; create table x (id bigint);";
++        String without = "select 1; select 2 from t; create table x (id bigint);";
++        List<SQLStatement> lenient = SQLUtils.parseStatementsLenient(script, DbType.mysql);
++        List<SQLStatement> strict = SQLUtils.parseStatements(without, DbType.mysql);
++        assertEquals(4, lenient.size());
++        assertTrue(lenient.get(1) instanceof SQLUnparsedStatement);
++        assertEquals(strict.get(0).toString(), lenient.get(0).toString());
++        assertEquals(strict.get(1).toString(), lenient.get(2).toString());
++        assertEquals(strict.get(2).toString(), lenient.get(3).toString());
++    }
++
++    @Test
++    public void compoundStatementIsOneStatement() {
++        String sql = "create procedure p() begin if x > 0 then begin select bad from; end; end if; end; select 7;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(0);
++        assertEquals("create procedure p() begin if x > 0 then begin select bad from; end; end if; end", u.getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void compoundLoopsAreOneStatement() {
++        String sql = "create procedure p() begin while i < 10 do set i = i + + ; end while; end; select 7;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        assertEquals("create procedure p() begin while i < 10 do set i = i + + ; end while; end",
++                ((SQLUnparsedStatement) list.get(0)).getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void oracleDeclareSectionBelongsToTheBlock() {
++        String sql = "begin null; end;\ndeclare x number; begin x := ; end;\nselect 1 from dual;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.oracle);
++        assertEquals(3, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals("declare x number; begin x := ; end", u.getSql());
++        assertEquals(2, u.getLine());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void sqlServerIfElseBranchesAreOneStatement() {
++        String sql = "if 1 = 1 select bad from; else select 2;\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.sqlserver);
++        assertEquals(2, list.size());
++        assertEquals("if 1 = 1 select bad from; else select 2", ((SQLUnparsedStatement) list.get(0)).getSql());
++        assertFalse(list.get(1) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void keywordsAsNamesFunctionsModifiersAndTransactionsOpenNothing() {
++        String sql = "begin; select 1; commit; select if(a, 1, 2) from t; select `end` from t; drop table if exists t2;"
++                + " delete from where a = 1; select 4;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        List<SQLUnparsedStatement> bad = unparsedOf(list);
++        assertEquals(1, bad.size());
++        assertEquals("delete from where a = 1", bad.get(0).getSql());
++        assertEquals(8, list.size());
++        assertFalse(list.get(7) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void unclosedStringRunsToTheEndOfTheInput() {
++        String tail = "select 'abc; select 3;";
++        String sql = "select 1; " + tail;
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(2, list.size());
++        assertFalse(list.get(0) instanceof SQLUnparsedStatement);
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(tail, u.getSql());
++        assertEquals(counted(strictMessage(tail, DbType.mysql), 10, 1, 11), u.getError());
++    }
++
++    @Test
++    public void textIsExactUnderCrlf() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1;\r\n" + bad + ";\r\nselect 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(2, u.getLine());
++        assertEquals(counted(strictMessage(bad, DbType.mysql), 11, 2, 1), u.getError());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void commentAheadOfABadStatementIsNotPartOfItsText() {
++        String bad = "select a from where a = 1";
++        String sql = "select 1;\n-- note\n" + bad + ";\n/* block */ select 3;";
++        List<SQLStatement> list = SQLUtils.parseStatementsLenient(sql, DbType.mysql);
++        assertEquals(3, list.size());
++        SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1);
++        assertEquals(bad, u.getSql());
++        assertEquals(3, u.getLine());
++        assertEquals(counted(strictMessage(bad, DbType.mysql), 18, 3, 1), u.getError());
++        assertFalse(list.get(2) instanceof SQLUnparsedStatement);
++    }
++
++    @Test
++    public void strictEntryPointsUnchanged() {
++        try {
++            SQLUtils.parseStatements("select 1; select a from where a = 1; select 3;", DbType.mysql);
++            fail("the strict call must still fail on a bad statement");
++        } catch (Exception e) {
++            assertTrue(e.getMessage().contains("pos "), e.getMessage());
++        }
++    }
++}
+
+REFERENCE_PATCH

harbor/tasks/druid_lenient_script/task.toml

@@ -0,0 +1,28 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "druid_lenient_script"
+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"
+env = { JUDGE_API_KEY = "${JUDGE_API_KEY:-}", JUDGE_BASE_URL = "${JUDGE_BASE_URL:-https://openrouter.ai/api/v1}", JUDGE_MODEL = "${JUDGE_MODEL:-anthropic/claude-sonnet-5.5}" }
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "allowlist"
+allowed_hosts = ["openrouter.ai"]
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/druid_lenient_script/tests/Dockerfile

@@ -0,0 +1,10 @@
+FROM ec-swe-druid:source-v9
+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 chown -R 1000:1000 /hud/grader-runner
+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 judge.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/druid_lenient_script/tests/config.json

@@ -0,0 +1,296 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "druid_lenient_script",
+  "arguments": {},
+  "grader_version": "0.6.17",
+  "source_image": "ec-swe-druid:source-v9",
+  "source_image_id": "sha256:5f1b83c229945b6e5b8a1967c326e74451ba8dcc61fac88bb8afb7c5f6f3631d",
+  "provenance": {
+    "repository": "alibaba/druid",
+    "environment_id": "4fce1a24-1403-4334-bf16-4501cb4c1d65",
+    "build": 9,
+    "build_id": "4b38f7d2-3002-4aaf-b77d-d99b6013d8e8",
+    "hosted_task": "druid_lenient_script",
+    "task_version": 1,
+    "source_archive_sha256": "d600f5069d646a71e959d38c9d27873c2cc6fb253ca1491111f71bd28f45c7fc",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "clean_equals_strict",
+      0.0417,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "simple_bad",
+      0.0417,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "block_extent",
+      0.1761,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "keyword_context",
+      0.1343,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "lexer_tail",
+      0.0927,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "error_identity",
+      0.0927,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "mixed",
+      0.0833,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "budget",
+      0.0833,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "line_endings",
+      0.0671,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "comments",
+      0.0671,
+      false,
+      "bash",
+      1800
+    ],
+    [
+      "wall",
+      0.1,
+      true,
+      "bash",
+      3000
+    ],
+    [
+      "maintainer_review",
+      0.02,
+      false,
+      "judge",
+      600
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "authored",
+  "local_hostname": false,
+  "fault_exit": null,
+  "grader_readable": [],
+  "grader_writable": [
+    "/hud/grader-runner"
+  ],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/tasks.py": "410424d675faa18b5da06b612d22b05fbdfe882c73ba41bbeb6eedd3b5b686c2",
+    "/app/env.py": "e77d13f90f806a82e710ce2df91341be5bab2ab83c477fa2fd178b8cc573cf64",
+    "/app/task/prompt.md": "196f1f60de0d46002f178a6540d15e71c2403c0aa69dd468fb770bd033939fc3",
+    "/hud/grader/maintainer_review.judge.json": "54c754dfc30eac8ed0fcc78ac988ae37f337b14ee2953b8470a4adf35f8f0413",
+    "/hud/grader/run_grading.sh": "b5595934139fff27473eb59ddfedbb4edf1891e93d3d1615784f893e7bd4d5f6",
+    "/hud/grader/lib/budget-agent.jar": "47e3e688e210baa701e90717544375ed2a1ecad2f3186cf0cd14840bb41165e5",
+    "/hud/grader/src/BudgetAgent.java": "ef84245cbbb4d8829f4305380db6733be919822744c294bc5813e353efee3ff4",
+    "/hud/grader/src/Hidden.java": "dc23fc5ee7be36101bd7bb717200333c8f667fc1394135111d268d13536e303e",
+    "/hud/grader/src/BudgetCounter.java": "b4d4ccae9a5fb774e10f49a9ca73256e065e582664dc444746d693b55269971f",
+    "/hud/grader/fixtures/keyword_context/keyword_context.sqlserver.expected": "f5f880a13db1857e6035f9a708f56c8bbab040b1a1d22b84ac6c7bf0bb4a16aa",
+    "/hud/grader/fixtures/keyword_context/keyword_context.postgresql.sql": "6f62d28b9294d904b2434b17ff3eb85f745f8e6522976e41df9d25a7094229b6",
+    "/hud/grader/fixtures/keyword_context/keyword_context.postgresql.clean.sql": "e2bf00f083927874c1099cf1c801f63f1053cbc3784d402520fa482c0ea7016d",
+    "/hud/grader/fixtures/keyword_context/keyword_context.postgresql.expected": "6445a61cfe16bb73565a9266fdf027f406fa775ab0308c26638b63ed9681ac6d",
+    "/hud/grader/fixtures/keyword_context/keyword_context.oracle.clean.sql": "f32f8a69c2b3f5379ca883590b12cf11ccc050aa1f922b5b6719fe4cc866dab3",
+    "/hud/grader/fixtures/keyword_context/keyword_context.sqlserver.sql": "2c296c6be24c3c7f4e468b4d887e4f2c067cd4664d48e5ab519714c8656226d4",
+    "/hud/grader/fixtures/keyword_context/keyword_context.oracle.expected": "c4a4a53e96d685fcc0c0cb5ff255b5770a839247663e7a3d9b7cf94dadfffd6a",
+    "/hud/grader/fixtures/keyword_context/keyword_context.sqlserver.clean.sql": "25f8b6e05eab128d43e1bd6c928df60c9a2278c2b12e13c0c8e76b88d8a71a03",
+    "/hud/grader/fixtures/keyword_context/keyword_context.mysql.sql": "fe647603715bddb5de037e6f91993d0e0ea047b2dd7ba1a320bac2d6f039a32c",
+    "/hud/grader/fixtures/keyword_context/keyword_context.oracle.sql": "450c5045a58ddd759c00f7af2c686412165dce75fa6997f7a832da7f913cba41",
+    "/hud/grader/fixtures/keyword_context/keyword_context.mysql.clean.sql": "ba2f50c5beffae404d8403aa8ded5b5aa374d9fe1f97988b2ff0fc233e9a62b5",
+    "/hud/grader/fixtures/keyword_context/keyword_context.mysql.expected": "9027f7f6d80629950f100316952bd44f55ab9b935fd8a91ca9b689bb1c7d4917",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.oracle.sql": "add4aedcaafe82f0f4e0864b120a7741ae29dc8109e4a5a27368e9740d48095e",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.sqlserver.clean.sql": "3024ae747d620baf53e7184674fe499b05b490478b7fd04ac7fc24bac1681d5a",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.postgresql.expected": "98b24706c0b955030ebd1dc296d30a43e7a4d1e1923fbabf955512ccde5e3d22",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.oracle.expected": "36d091f8fb9ae38e4b4162da379d94f39c59b97c4e73d802cd2c05c6ef38e2a9",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.postgresql.sql": "cca8796158ee25718a71251ad370f16c8626b2cf2ea572c86bdc14c214f6088a",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.postgresql.clean.sql": "cca8796158ee25718a71251ad370f16c8626b2cf2ea572c86bdc14c214f6088a",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.sqlserver.sql": "3024ae747d620baf53e7184674fe499b05b490478b7fd04ac7fc24bac1681d5a",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.oracle.clean.sql": "add4aedcaafe82f0f4e0864b120a7741ae29dc8109e4a5a27368e9740d48095e",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.mysql.sql": "16536841d0b038842cfed4fde2a1c176776a5f5d8cbe332fad25e32fcd4fdad5",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.mysql.clean.sql": "16536841d0b038842cfed4fde2a1c176776a5f5d8cbe332fad25e32fcd4fdad5",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.mysql.expected": "fb52855a3ab4ff82710595850f6d1ac2f15f01daffc3aacf71185002e439032f",
+    "/hud/grader/fixtures/clean_equals_strict/clean_equals_strict.sqlserver.expected": "96283d91327d3ec5d14f87a89abed4bc53f0ed5240814eae67dae5c1eb79a23e",
+    "/hud/grader/fixtures/simple_bad/simple_bad.oracle.sql": "86358dbd104f2a5a8b4c9bb80b4e63b43ebd34053390b18430295ff966e2d9bf",
+    "/hud/grader/fixtures/simple_bad/simple_bad.mysql.sql": "6a70eb2cfdfa29f43e7f93035be9f78d1b9ce0389cca1d877d448a9370b7a2d3",
+    "/hud/grader/fixtures/simple_bad/simple_bad.mysql.clean.sql": "67acb13d238d6e9fe368fa48e5059a76730d5daf6ad61e36a011bf717949b9ef",
+    "/hud/grader/fixtures/simple_bad/simple_bad.mysql.expected": "18fde8846a569793208e8c309a9c227a8eafa5875714356544ee8a1b6caeaec1",
+    "/hud/grader/fixtures/simple_bad/simple_bad.postgresql.sql": "cf24f7a7d75b08e8e78eb15bae48bfbca56e10cc123b8e7a62f57c4f7d4e6075",
+    "/hud/grader/fixtures/simple_bad/simple_bad.sqlserver.sql": "62d0676e1441d69034fb448877b8e881aeefff0686aaf684beabf5f224dbdd54",
+    "/hud/grader/fixtures/simple_bad/simple_bad.oracle.clean.sql": "99fe329aaa67b3bfa078c8edaa83276cb2ee2881bbc353d1c3ed1df4461e9268",
+    "/hud/grader/fixtures/simple_bad/simple_bad.sqlserver.clean.sql": "5ea4a602179735f1e56c2321d2a30bb3e8d3895ae45f307140d6dfb6348a501c",
+    "/hud/grader/fixtures/simple_bad/simple_bad.postgresql.clean.sql": "cb7fb4adb4ba2e514ce005865f0ec564d38f13da6e9059ade8d424949b94ff8c",
+    "/hud/grader/fixtures/simple_bad/simple_bad.sqlserver.expected": "bd924f7b9203b13ebf28d8512ee628ebdf8f35a7b8bf574989a15a2ab0457663",
+    "/hud/grader/fixtures/simple_bad/simple_bad.postgresql.expected": "a206593ca02a891afdbf01599c9f7e23b33144a74812aed7a9c4f6ac4d0a0ac6",
+    "/hud/grader/fixtures/simple_bad/simple_bad.oracle.expected": "10e45104ab2e52edbb60e9e5574b212d16e331ce32440100240eef97e1ff162b",
+    "/hud/grader/fixtures/block_extent/block_extent.postgresql.clean.sql": "6f8b13dc632e53b8fbbc66bcc7a7e22fdf36d1232c999c9fef064e0283c66dbf",
+    "/hud/grader/fixtures/block_extent/block_extent.mysql.clean.sql": "cbb3164274f0e6503bca21365ae1fdcc4f2ef0a124d75f3a92519018fda561e5",
+    "/hud/grader/fixtures/block_extent/block_extent.sqlserver.clean.sql": "d6e205602e295dfa60ca69f7e116f59f10e2070b24b6fb6b67f590f56f3af3dd",
+    "/hud/grader/fixtures/block_extent/block_extent.mysql.expected": "99e412d825fe24e8ce588ea0057c9e82880941b51793c403f2b2bd6223b10dbf",
+    "/hud/grader/fixtures/block_extent/block_extent.oracle.clean.sql": "e0fea6bc9aa58e939107749ab20ac20b75903b5759a9b2a1a5675f5f4c50cb35",
+    "/hud/grader/fixtures/block_extent/block_extent.oracle.sql": "c4d57a411781daecf57849f6d54b978bcfdeabc44ee6c17447f7e602043e48a6",
+    "/hud/grader/fixtures/block_extent/block_extent.sqlserver.expected": "90effc22535965223f0bcc2f55d83fcf4a4ca0df28aefefc998d612e3711dfa2",
+    "/hud/grader/fixtures/block_extent/block_extent.sqlserver.sql": "34d0684ff39d1270f6c11e5d8b4dfeb4f03df12329855aabb7f9836c1e2abe25",
+    "/hud/grader/fixtures/block_extent/block_extent.postgresql.sql": "1cca12ebd07a55a5bb5ebf5f63492f13e26e984d902f4f07d10b9f4c6cdc115d",
+    "/hud/grader/fixtures/block_extent/block_extent.mysql.sql": "75f23ccd11e80b3abac102becda459f5bf47d455021c91b94f55f863ac5cf49b",
+    "/hud/grader/fixtures/block_extent/block_extent.oracle.expected": "9956862d75d073bb1726dfb75d86e10305faa0c808437b5e705b1fa7ba68bae7",
+    "/hud/grader/fixtures/block_extent/block_extent.postgresql.expected": "ea3cc5fba461b8c352709a0d0bad6c8a1b33a404e3fd8e4737c2fdb25d0d28ff",
+    "/hud/grader/fixtures/comments/comments.sqlserver.expected": "b8cb3759c77bee28897da159187068292f998248b171dd97dada5307dbcb30fa",
+    "/hud/grader/fixtures/comments/comments.oracle.sql": "1a785a5295f1e3f806432c50b29007df68a071b588153d77eb94925b198c841d",
+    "/hud/grader/fixtures/comments/comments.mysql.sql": "1134594012868337098e29e878cf59430b41863ca5335c621675ba0142bc664d",
+    "/hud/grader/fixtures/comments/comments.sqlserver.clean.sql": "f26f79f328556f06cdaedb6290a1381fb1b5759b35299f905148bb63a43e9cef",
+    "/hud/grader/fixtures/comments/comments.oracle.clean.sql": "b89de53897ff885921ce516d8bfcf6a3a7ea8798cb39405dbd9b1dff37257d28",
+    "/hud/grader/fixtures/comments/comments.postgresql.sql": "08c130beeb2cc5dd7e2eee5cdbde06ead2d7b440a6a584aabfea31cd12a02407",
+    "/hud/grader/fixtures/comments/comments.oracle.expected": "7df627031e262f805de6a64f527eeddecef21aeff528c02923a01fcae7b6a7cd",
+    "/hud/grader/fixtures/comments/comments.sqlserver.sql": "ba1f8d95cccc201951b570653d66006bedb5b06c6e360e3e1c1c9053bca89a1d",
+    "/hud/grader/fixtures/comments/comments.mysql.clean.sql": "45fc52e95ae5bd7550d32d74e746d4220001bce017e1c1d8c0e3a80ad95ed8d7",
+    "/hud/grader/fixtures/comments/comments.postgresql.expected": "51558f1629294fb591011c6448a3f5fa03d2e2066e2e9af49d94d16e018c9438",
+    "/hud/grader/fixtures/comments/comments.postgresql.clean.sql": "fcb10ef1200b2bc7137b4f48bbd4a9137cfa99b5abd89c86cf95d8ebf74ee2ac",
+    "/hud/grader/fixtures/comments/comments.mysql.expected": "2dcbf978e509c56b97413e67c67510b63c9f248ad90cb065bece413f0d346721",
+    "/hud/grader/fixtures/mixed/mixed.sqlserver.expected": "fdda2566bf1a83139556afd34de4c9a3ae41be6d121548a21133da6b555b64b0",
+    "/hud/grader/fixtures/mixed/mixed.postgresql.expected": "dec9256dd2bf0b428704ee9a125aabd3a82ce679e0b5e974fba9e4b43615d3fe",
+    "/hud/grader/fixtures/mixed/mixed.oracle.expected": "f464879018a173ca6fb0566fcbe0df8b313fcc28268cb2fa7c4e096e82b6b9af",
+    "/hud/grader/fixtures/mixed/mixed.oracle.clean.sql": "5289adca97630e277e9907107e688f394037bfd454351b8acc351151a47c7cd1",
+    "/hud/grader/fixtures/mixed/mixed.postgresql.sql": "1de6a80b44ba9e54f59db3c09cdd918d21ae55db4700bbf6a1ce087b908ed853",
+    "/hud/grader/fixtures/mixed/mixed.mysql.expected": "521e9e48bf4c433a1e0059386e6989fed46ba472eef3f0e18b1de26de59942fd",
+    "/hud/grader/fixtures/mixed/mixed.sqlserver.sql": "ab3769eb7bc2a620d60b010f41fa28ad0d872da1ace192dee72f07e62b34b318",
+    "/hud/grader/fixtures/mixed/mixed.mysql.sql": "3c797df67335c00fe2626aabff3b2d3cd50b0f45475f18d7715bf72a526d2244",
+    "/hud/grader/fixtures/mixed/mixed.mysql.clean.sql": "c78d52eca76b94e9ae695d2fa92b9d379d74e7e9aecf5cc8c89272c573197261",
+    "/hud/grader/fixtures/mixed/mixed.postgresql.clean.sql": "3773327c9207cd0bffc6c6cd6d358f525ea1621ad55e5c1579091ce6b00c374a",
+    "/hud/grader/fixtures/mixed/mixed.oracle.sql": "aea596b0f04354ca83de0f02f8a37f9ef2b25e3820189f1821f136f652255150",
+    "/hud/grader/fixtures/mixed/mixed.sqlserver.clean.sql": "9ae85b0a289df63f0199dc4dd5099b54128f3e849937f2dbe491d669ea771fe2",
+    "/hud/grader/fixtures/line_endings/line_endings.sqlserver.sql": "4883eee6a6b4e1cf88af74a0ebe3b4df469303d4625f48fc42c0a25b948748e9",
+    "/hud/grader/fixtures/line_endings/line_endings.oracle.expected": "fc17dae0db0fc422f6e81f3f494ab98046d95dca0736be46801551d65710f9a1",
+    "/hud/grader/fixtures/line_endings/line_endings.mysql.expected": "8353c892f4a71fe583785fad8b3d69e317c9cf96f53cb463688ec83ff7159809",
+    "/hud/grader/fixtures/line_endings/line_endings.mysql.sql": "c255b176ab699aa49f5076dba8a10acb3effdd378851f8dc7e119dce1edf3245",
+    "/hud/grader/fixtures/line_endings/line_endings.sqlserver.clean.sql": "6ae2ed9b17d696c17f06347cc11aa0fb077c64c0317d44a6e789dd94f806dd66",
+    "/hud/grader/fixtures/line_endings/line_endings.sqlserver.expected": "1b8b73744b5094824dc8a5ae9ae71910597adc0976763f6ef6c86622ae38ac9b",
+    "/hud/grader/fixtures/line_endings/line_endings.oracle.sql": "f2f9702f45f1762a4df9cee57db6082471fe5d86663cc11d7f785cde570f891b",
+    "/hud/grader/fixtures/line_endings/line_endings.oracle.clean.sql": "d0d639b46d555a409082de1d59de6d6ad0434b21f178a1546d6a99583865ef88",
+    "/hud/grader/fixtures/line_endings/line_endings.postgresql.expected": "df42466380c25e23f5becc0afa306693c74371442c6d1f2358452a8c3aa5f358",
+    "/hud/grader/fixtures/line_endings/line_endings.postgresql.sql": "86f23839b192a4f93179a2a1c2f0e1d24a1d7bae996c2418461c53a160d889c7",
+    "/hud/grader/fixtures/line_endings/line_endings.postgresql.clean.sql": "9e2b2cd3d197b12abeff88d8d6b9a5102c102f42ebb944e6caee1111e6fa1271",
+    "/hud/grader/fixtures/line_endings/line_endings.mysql.clean.sql": "94957946316a79fcb8045b3144ccae66773b060777cb2fad5a9bfd0aad62e67a",
+    "/hud/grader/fixtures/budget/budget.mysql.expected": "07bee126cc83afc0c1fec82d58b6ad59b7a49d8ad56468f1cd0e5eca3210a7e0",
+    "/hud/grader/fixtures/budget/budget.mysql.clean.sql": "01483a80afd6fda225e58b49f564ba613a503b96c1051b5d28b0ea254107ad80",
+    "/hud/grader/fixtures/budget/budget.sqlserver.expected": "78cae58e75584566a870943619c588eba3eda6a3a973e0ee51525c87fc4ff0d6",
+    "/hud/grader/fixtures/budget/budget.oracle.sql": "a41aa27b241dba9c7690b5b21e256ca792f1234b15e9b41931811e2abca917ca",
+    "/hud/grader/fixtures/budget/budget.oracle.expected": "5eeba8ce0d49158efd361221f9db2c361b4b8ef80003c8161e93026631a83bde",
+    "/hud/grader/fixtures/budget/budget.sqlserver.clean.sql": "0c6d2048c4f1557540fa0f42d5875e14736c737af3eccecc0b88e8a837033a78",
+    "/hud/grader/fixtures/budget/budget.oracle.clean.sql": "c3f0172d6242aeca2b2d645afedfe752eeedb1a217bb394b1093c1bf7911e5f5",
+    "/hud/grader/fixtures/budget/budget.postgresql.clean.sql": "1a4f79a991ed90f1501ff3b82ce0201f26e4ae35ccdfb480636996921fb50e7b",
+    "/hud/grader/fixtures/budget/budget.postgresql.expected": "735e667a43f1f812e347d67096fb75ee8a3c253748dc3240e8c2ffb5d3a306a8",
+    "/hud/grader/fixtures/budget/budget.mysql.sql": "030e8475d8fe10f149eab41f9fba8e88eaf06a02535779b28dbe88730c2aa808",
+    "/hud/grader/fixtures/budget/budget.sqlserver.sql": "ff32b9f21b84311fb197453c964f3f4f0b27731cc134ecc773e2a7d7ff5a296d",
+    "/hud/grader/fixtures/budget/budget.postgresql.sql": "15fcb623b46dc7ee8c690f0c2ecd513637029daa026563f63a6eb09b6bd27d27",
+    "/hud/grader/fixtures/error_identity/error_identity.mysql.expected": "351dd6eed1361178bb680195c697d31d8b6c9a8529bfb7d05e2b9275a3240b7a",
+    "/hud/grader/fixtures/error_identity/error_identity.mysql.clean.sql": "01f11cbe6d7a8a8f366c4cf429f3650c047fa6ac45a7bc53ebe45a54cad022bb",
+    "/hud/grader/fixtures/error_identity/error_identity.postgresql.expected": "04ea1305d691b9614e20c4fc5375b8cd0ab69958c1370a223337ac4c6f9e3630",
+    "/hud/grader/fixtures/error_identity/error_identity.oracle.sql": "7bd557c883d7c230e4022ce844d8fea3dd5a1a40f15f233bd6839f65f2e43df0",
+    "/hud/grader/fixtures/error_identity/error_identity.sqlserver.clean.sql": "f35c01e5395098279f255e5d44bf19fc5a161c043e6579cc667cf7313a506622",
+    "/hud/grader/fixtures/error_identity/error_identity.sqlserver.sql": "489097faa36bee380409a2d735fbcab9e4e4d16d8258263cf65ec93fd02aa06c",
+    "/hud/grader/fixtures/error_identity/error_identity.sqlserver.expected": "893ca3c638cef458c7fa0f16b8cd07f3afada1cc53c21d97fe96820fc9485e55",
+    "/hud/grader/fixtures/error_identity/error_identity.oracle.expected": "4a59b303bf1ad531f92769609241806a3c1c5b89009d312f5441bbca50d695ac",
+    "/hud/grader/fixtures/error_identity/error_identity.postgresql.clean.sql": "4ac4be1dc824fd808a871f947059fedbe87817066e3cd1cc89903ea9eb0e2443",
+    "/hud/grader/fixtures/error_identity/error_identity.oracle.clean.sql": "8c378b64659bf194a2339d37b2700898a36600fd96d0d5690b3885d4a9f2ec9a",
+    "/hud/grader/fixtures/error_identity/error_identity.postgresql.sql": "c796ea82da70469a67c654c484154145d24ccbb049400229eaf64eb278324a48",
+    "/hud/grader/fixtures/error_identity/error_identity.mysql.sql": "dfc8aab9881b345fcb24413be752d9f19590357fca757f0c12e708a3f0329832",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.oracle.clean.sql": "b0ddb5ac8f574b1d1448bc02e6565333cafa377a618d6871b1767a8e12337f6d",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.sqlserver.clean.sql": "262e93498b82d72ffda9dce3b133a988c24e8d7023a168c22ffc0e9cd077e9f1",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.mysql.sql": "5900f2a965747f01dea3f54688f8fd6699efb87e07355dcc1bfb7d7f24271c88",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.oracle.sql": "0a9ff16972a47bcbd5ea92ee1bba9afdb9a6ae9fb5b09cc86348388c57aa4b9f",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.mysql.expected": "56d079ee888eb48f76ba1e6f21ea8654bf3c2aaf6c6d12ca00c0a889d78fc6c2",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.postgresql.sql": "2ce8d455b4f960554dfe28f6d1abe2a45239229059558102f493315865293af6",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.sqlserver.expected": "cfbfb6241a0aa89518ea2767ebd699735fc5df49eb190b6146c25e5a287a4328",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.oracle.sql": "324cfd3e4a2915790b4301c85bea8c92a11e332da8e3729af2d2dbc69e541313",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.postgresql.expected": "c4662ab2ccda5798c27a1bae6257ec43c338463ff9addf6d93d1fb5374e947a3",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.oracle.sql": "3311b4605059b19774a3c1f30b3dbeb64f4e86a7607deea81930fd72e2cfed57",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.mysql.sql": "e9038561f0478b143050d5a967cdb0662a51ea852b9cbfb36b0121cc66e49458",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.postgresql.sql": "8b202fe0bde93e6e0f4c78395c646c914db85bb9cd8c2b48cd73cdbbfa25283e",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.sqlserver.expected": "e06615849d50f44839a411a42b14d0d3b65b9262acbc09650b2e2b6838094fe0",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.postgresql.clean.sql": "313faf7f26f862b5f52ed232b5c9bc78685f9c70b7ab03c2c10bca9fba7e7466",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.sqlserver.expected": "b0ee43e8f7a55bd4d640fe9212252474ba48e5a6b60b1ad41c13de89d0f7b7f4",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.postgresql.expected": "5c61e19384359cc984153ca22cda9ce92c352036cd5c7020eba4930d593c1e52",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.oracle.expected": "5a5fad0fae2e6508047aefa831a92b4b41f5c2a66e3347169f5a8ae3a7e73df8",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.mysql.expected": "fe47de4fd9a9a60adaa00415357a0537e89f2e29208c5f49319aa009e14c55f7",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.sqlserver.clean.sql": "5e88795e075c5b40931ecdcef5c77ec37abadeb5f956370d1123c2aa3ff89361",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.mysql.clean.sql": "faa67f8f5f5728e03bbe7f3b4ae78c20930ba6d243b4c3d657d2e73730e313af",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.oracle.clean.sql": "8227d697b5f73f9bb736e6a53184059095f8167076bc16edb5f49e7fdfe83108",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.postgresql.clean.sql": "33cb36b3ae9be7ea2586daa6585235926718255a14e347271072ec37d5818082",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.sqlserver.sql": "913c7e50f0a2544dba2e52f578a27b5590bdd278c0787b657bf1294105562600",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.mysql.clean.sql": "c579e5a660d6901305098ddd794f56cb3037119da2d017d19e21c44991868198",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.postgresql.expected": "548df167b18e3a45276f3f33ed8ff15e854712eefc8eb43794176d43587e62ab",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.mysql.clean.sql": "f84dd92f038eea6960970dbcb61219938d06a3ba2358d4afc8b0ae7d8439eed9",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.oracle.expected": "6e4f011583a1233b72d1123dc702be492575acba49d2dcfa6a3cf9ebf740bc61",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.oracle.clean.sql": "9a829badaab95515a91ca1160c0ffb0f572a7fdbeeb2f6bb0cad56821ea38bf6",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.mysql.expected": "ed672295b2f2077c0c56125d5e3a92bfd4bab13b60d08fbbe09d6cbc841e79cb",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.sqlserver.sql": "86ed93179159b614bb4b8ead77aa044c2147cfcd8590c43d9ed8abb16ab38234",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-0.sqlserver.sql": "c49a90c5413c5d700148e92df86675be03ce5e6790c0a0f501ef1d187051a3d7",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.postgresql.sql": "8bdd3ac12f059918cde60a0a62e67689c3c3b1cefa3f2dafb5343b29e7b46347",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.oracle.expected": "1e4b77a64159dae00be3f085555cde8c5535716af092161711a9b928faee5e88",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.postgresql.clean.sql": "ced74b5e59c88d84dec58419448a90fed2efd0d4d33a5de92ce1ee959a8a09cd",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-1.sqlserver.clean.sql": "a98d78a2f6499fa7f7eac0ffe75d7faa67e5a3a1c9330c904e3048f7f21965d0",
+    "/hud/grader/fixtures/lexer_tail/lexer_tail-2.mysql.sql": "9d5e6977bfb3c88d15ccd708f1950c6cce9638e53d29e9e8a238b33201220621"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'java -version' || java -version"
+    ]
+  ],
+  "judge": {
+    "base_url": "https://openrouter.ai/api/v1",
+    "model": "anthropic/claude-sonnet-5.5",
+    "criteria": [
+      "maintainer_review"
+    ],
+    "fractional_rows": true
+  }
+}

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

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

harbor/tasks/druid_lenient_script/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/druid_lenient_script/tests/judge.py

@@ -0,0 +1,178 @@
+"""Verifier entry for a coding rubric with criteria judged by a language model.
+
+The packaged verifier (verify.py) grades offline. A rubric with a judged
+criterion runs this file instead, which runs the same grading with three
+differences:
+
+- the verifier container reaches the judge's endpoint through Harbor's host
+  allowlist, and the judge's key, model and endpoint come from the verifier's
+  environment (``JUDGE_API_KEY``, ``JUDGE_MODEL``, ``JUDGE_BASE_URL``);
+- the key is held by this process only. Grader commands run the submission's
+  code, so no environment they inherit carries it;
+- the evidence check accepts a criterion the judge answered. A judge that does
+  not answer makes the attempt invalid: there is no reward, as for any grader
+  that cannot reach a verdict.
+
+verify.py and evidence.py are unchanged; this file wraps them.
+"""
+
+from __future__ import annotations
+
+import importlib
+import math
+import os
+import sys
+from typing import Any
+from urllib.parse import urlsplit
+
+# The key leaves the environment before anything can start a subprocess.
+_KEY = os.environ.pop("JUDGE_API_KEY", "")
+for _name in ("HUD_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"):
+    os.environ.pop(_name, None)
+_BASE_URL = os.environ.get("JUDGE_BASE_URL") or "https://openrouter.ai/api/v1"
+os.environ["JUDGE_MODEL"] = os.environ.get("JUDGE_MODEL") or "anthropic/claude-sonnet-5.5"
+
+import evidence  # noqa: E402
+import verify  # noqa: E402
+
+_preflight = verify._preflight
+
+
+def _scenario_grade(task: Any) -> Any:
+    # A task whose scenario both prompts and grades (druid): its second item is the result.
+    async def _grade(validate_mode: str | None) -> Any:
+        steps = task._scenario(validate_mode)
+        await steps.__anext__()
+        return await steps.__anext__()
+
+    return _grade
+
+
+def _prepare_task(config: dict[str, Any]) -> None:
+    """Check the verifier as verify.py does, then point the judge at its endpoint."""
+    _preflight(config)
+    from hud.settings import settings
+
+    # The judge's client reads these when it is built, from this process alone.
+    settings.api_key = _KEY or None
+    settings.hud_gateway_url = _BASE_URL
+    sys.path.insert(0, "/app")
+    task = importlib.import_module("tasks")
+    if not hasattr(task, "_setup"):
+        task._setup = importlib.import_module("env")._setup
+    if not hasattr(task, "_grade"):
+        task._grade = _scenario_grade(task)
+
+
+def _judge_error(score: dict[str, Any], result: dict[str, Any]) -> str | None:
+    for field in ("metadata", "info"):
+        error = (score.get(field) or {}).get("judge_error")
+        if error:
+            return str(error)
+    return ((result.get("info") or {}).get("judge_errors") or {}).get(score["name"])
+
+
+def validate_judged_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check judged evidence as evidence.validate_report checks the rest.
+
+    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 or inconsistent, or the judge did not answer.
+
+    Notes
+    -----
+    Judged criteria have no grader command. Every other criterion keeps the
+    checks of evidence.py, under its rule for a task's own reward function:
+    the reward stays within the weighted criteria, and a criterion whose
+    command failed earns nothing unless the task scores that criterion from
+    its command's output (``fractional_rows``).
+    """
+    report["judge"] = {"model": os.environ["JUDGE_MODEL"], "endpoint": urlsplit(_BASE_URL).hostname}
+    if report.get("status") != "graded":
+        evidence.validate_report(report, config, digest)
+        return
+    if (
+        report.get("revision") != evidence.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 = evidence._number(result.get("reward"))
+    commands = report.get("commands", [])
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in commands
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    if (result.get("isError", False) and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    judged = {name for name, row in expected.items() if row[3] == "judge"}
+    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"]
+        error = _judge_error(score, result) if name in judged else None
+        if error:
+            raise ValueError(f"The judge did not answer for {name}: {error}")
+        value, weight = evidence._number(score["value"]), evidence._number(score["weight"])
+        if name in judged and value > 0 and not score.get("children"):
+            raise ValueError(f"{name} is credited without the judge's verdicts")
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    command_names = [row["name"] for row in commands]
+    if len(command_names) != len(set(command_names)) or set(command_names) != (
+        set(expected) - judged
+    ) | set(config["gates"]):
+        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 evidence._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")
+    passed = {row["name"]: row["value"] for row in commands}
+    if not config["judge"]["fractional_rows"] and any(
+        values[name] > passed[name] for name in expected if name not in judged
+    ):
+        raise ValueError("A criterion is credited although its command failed")
+    if reward > raw + 1e-9:
+        raise ValueError("Grader reward exceeds its weighted criteria")
+
+
+verify._preflight = _prepare_task
+verify.validate_report = validate_judged_report
+
+if __name__ == "__main__":
+    verify.main()

harbor/tasks/druid_lenient_script/tests/test.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -euo pipefail
+mkdir -p /workspace/repo
+git config --global gc.auto 0
+chmod 711 /root
+chmod -R a+rX /root/.m2
+cp -a /root/.m2 /home/agent/.m2
+chown -R 1000:1000 /home/agent/.m2
+/opt/hudenv/bin/python /tests/judge.py

harbor/tasks/druid_lenient_script/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/help_defaults/environment/Dockerfile

@@ -0,0 +1,15 @@
+FROM ec-swe-click:source-v9 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="/opt/agentvenv/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+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/help_defaults/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/help_defaults/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/help_defaults/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/help_defaults/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/help_defaults/instruction.md

@@ -0,0 +1,9 @@
+Please make your changes directly in /workspace/repo.
+
+The [default: ...] text that an option's help shows is wrong for a multi-valued default. A single default is rendered by rules that make it readable and typeable: an Enum member is shown by its name, an empty string is shown as "", a callable is shown as (dynamic). When the option takes several values (multiple, or several values per occurrence), those rules are not applied: an Enum member shows as E.Foo, which is not a value the user can pass and does not match the metavar next to it, and an empty string shows as nothing at all.
+
+Required behaviour: every value of a multi-valued default is rendered exactly as the same value would be rendered as a single default, and the rendered values are joined with ", " into one list. This holds at any nesting: when each occurrence takes several values, every value of every occurrence is rendered by the same rules and all of them appear in that one list. These rules apply wherever a default value or the accepted values are presented to the user, not only in the help text: whenever a prompt shows its default or lists its choices, whether it is an option asking for its value or the prompt function called directly, each is rendered as the help renders that value, so that what is shown is what the user can type back, and the value typed back that way is accepted. Typing a default back exactly as the prompt shows it, a single value or a whole list, gives the default itself, just as pressing Enter does; any other input is taken as typed. Nothing else observable changes: a show_default string is still shown verbatim in parentheses, in the help and in the prompt; single-valued defaults, numbers, strings, dynamic defaults, boolean flags, file defaults, plain string choices and the no-default case render exactly as before, in the help and in the prompt; a prompt that hides its choices keeps hiding them; and the public API is unchanged.
+
+Add tests under tests/ in new files, do not edit any pre-existing test file, and keep the existing suite green. If a test fails, fix the code rather than weakening the test. Add an entry to the changelog under the unreleased version. Everything you need is already installed and works offline; do not download or install anything. Run tests with python -m pytest from the repository root; the whole suite takes a few seconds.
+
+Finish with a final response when your changes are ready.

harbor/tasks/help_defaults/solution/reference.patch

@@ -0,0 +1,232 @@
+diff --git a/CHANGES.md b/CHANGES.md
+index 8853860..4976b6c 100644
+--- a/CHANGES.md
++++ b/CHANGES.md
+@@ -11,6 +11,10 @@ Unreleased
+ 
+ Unreleased
+ 
++- The `[default: ...]` shown in help for an option with `multiple=True`
++  renders each value the way a single value is rendered: `Enum` members by
++  name, empty strings as `""`. The prompt of an option lists its choices and
++  previews its default the same way, so what it shows can be typed back.
+ - Fix `copy.deepcopy()` and `pickle` on a `Parameter`, `Option` or `Command`. {pr}`3805`
+ - A `KeyboardInterrupt` arriving while `Command.main()` reports an abort or an error,
+   or while it exits, no longer escapes as an unhandled traceback. The command still
+diff --git a/src/click/_utils.py b/src/click/_utils.py
+index 2d4e8f2..e2811bb 100644
+--- a/src/click/_utils.py
++++ b/src/click/_utils.py
+@@ -1,7 +1,9 @@
+ from __future__ import annotations
+ 
+ import enum
++import inspect
+ import typing as t
++from gettext import gettext as _
+ 
+ 
+ class Sentinel(enum.Enum):
+@@ -43,3 +45,33 @@ T_UNSET: t.TypeAlias = t.Literal[Sentinel.UNSET]
+ 
+ T_FLAG_NEEDS_VALUE: t.TypeAlias = t.Literal[Sentinel.FLAG_NEEDS_VALUE]
+ """Type hint for the :data:`FLAG_NEEDS_VALUE` sentinel value."""
++
++
++def _format_default_value(value: t.Any) -> str:
++    """Render a value the way ``[default: ...]`` and prompts show it.
++
++    A list or tuple renders as its values, comma separated, each rendered by
++    the same rules as a single value: an Enum member by its name, an empty
++    string as ``""``, a plain function as ``(dynamic)``, anything else with
++    ``str()``.
++
++    :meta private:
++    """
++    if isinstance(value, (list, tuple)):
++        return ", ".join(_format_default_value(item) for item in value)
++    if isinstance(value, enum.Enum):
++        return value.name
++    if inspect.isfunction(value):
++        return _("(dynamic)")
++    if isinstance(value, str) and value == "":
++        return '""'
++    return str(value)
++
++
++def _format_choice(choice: t.Any) -> str:
++    """Render one choice the way prompts and help list it: an Enum member by
++    its name, anything else with ``str()``.
++
++    :meta private:
++    """
++    return choice.name if isinstance(choice, enum.Enum) else str(choice)
+diff --git a/src/click/core.py b/src/click/core.py
+index 1f9323a..e82eaa0 100644
+--- a/src/click/core.py
++++ b/src/click/core.py
+@@ -23,6 +23,7 @@ from types import TracebackType
+ 
+ from . import types
+ from ._utils import FLAG_NEEDS_VALUE
++from ._utils import _format_default_value
+ from ._utils import UNSET
+ from .exceptions import Abort
+ from .exceptions import BadParameter
+@@ -3564,12 +3565,13 @@ class Option(Parameter):
+         ):
+             if show_default_is_str:
+                 default_string = f"({self.show_default})"
+-            elif isinstance(default_value, (list, tuple)):
+-                default_string = ", ".join(str(d) for d in default_value)
+-            elif isinstance(default_value, enum.Enum):
+-                default_string = default_value.name
+-            elif inspect.isfunction(default_value):
+-                default_string = _("(dynamic)")
++            elif isinstance(default_value, (list, tuple)) or (
++                isinstance(default_value, enum.Enum)
++                or inspect.isfunction(default_value)
++            ):
++                # Multi-valued defaults render each value the way the same
++                # value renders for a single-valued option.
++                default_string = _format_default_value(default_value)
+             elif self.is_bool_flag and self.secondary_opts:
+                 # For boolean flags that have distinct True/False opts,
+                 # use the opt without prefix instead of the value.
+diff --git a/src/click/termui.py b/src/click/termui.py
+index 8fe0085..0caa7cd 100644
+--- a/src/click/termui.py
++++ b/src/click/termui.py
+@@ -15,6 +15,8 @@ from gettext import gettext as _
+ from . import _compat
+ from ._compat import isatty
+ from ._compat import strip_ansi
++from ._utils import _format_choice
++from ._utils import _format_default_value
+ from .exceptions import Abort
+ from .exceptions import UsageError
+ from .globals import resolve_color_default
+@@ -115,7 +117,9 @@ def _build_prompt(
+ ) -> str:
+     prompt = text
+     if type is not None and show_choices and isinstance(type, Choice):
+-        prompt += f" ({', '.join(map(str, type.choices))})"
++        # Each choice is listed the way it can be typed back, which for an
++        # Enum member is its name, as the help and the error message show it.
++        prompt += f" ({', '.join(_format_choice(choice) for choice in type.choices)})"
+     default_preview = ""
+     if show_default:
+         if isinstance(show_default, str):
+@@ -132,7 +136,9 @@ def _format_default(default: V) -> V | str:
+         if name is not None:
+             return str(name)
+ 
+-    return default
++    # The default is previewed the way the help renders it, so that what is
++    # shown is what the user can type back.
++    return _format_default_value(default)
+ 
+ 
+ @t.overload
+@@ -250,6 +256,15 @@ def prompt(
+     prompt = _build_prompt(
+         text, prompt_suffix, show_default, default, show_choices, type
+     )
++    # The default exactly as the prompt shows it. Typing that text back
++    # selects the default itself, as pressing Enter does, so that a value
++    # rendered for display (a quoted empty string, a list of values) can be
++    # typed back as shown.
++    shown_default = (
++        str(_format_default(default))
++        if default is not None and show_default and not isinstance(show_default, str)
++        else None
++    )
+ 
+     if confirmation_prompt:
+         if confirmation_prompt is True:
+@@ -269,7 +284,9 @@ def prompt(
+                 value = t.cast("str", default)
+                 break
+         try:
+-            result = value_proc(value)
++            result = value_proc(
++                default if shown_default is not None and value == shown_default else value
++            )
+         except UsageError as e:
+             message = _mask_hidden_input(e.message, value) if hide_input else e.message
+             echo(_("Error: {message}").format(message=message), err=err)
+diff --git a/tests/test_help_defaults_multiple.py b/tests/test_help_defaults_multiple.py
+new file mode 100644
+index 0000000..cb6eb77
+--- /dev/null
++++ b/tests/test_help_defaults_multiple.py
+@@ -0,0 +1,69 @@
++import enum
++
++import click
++from click.testing import CliRunner
++
++
++class Color(enum.Enum):
++    Red = "r"
++    Blue = "b"
++
++
++def _help(**kwargs):
++    @click.command()
++    @click.option("--opt", show_default=True, **kwargs)
++    def cmd(opt):
++        pass
++
++    return CliRunner().invoke(cmd, ["--help"]).output
++
++
++def test_multiple_enum_default_shows_names():
++    assert "[default: Red, Blue]" in _help(
++        type=click.Choice(Color), multiple=True, default=[Color.Red, Color.Blue]
++    )
++
++
++def test_multiple_empty_string_default_is_quoted():
++    assert '[default: "", x]' in _help(multiple=True, default=["", "x"])
++
++
++def test_nargs_with_multiple_renders_every_value():
++    assert "[default: 1, 2, 3, 4]" in _help(nargs=2, multiple=True, default=[(1, 2), (3, 4)])
++
++
++def _prompt_line(input_text="\n", **kwargs):
++    @click.command()
++    @click.option("--opt", prompt="Value", **kwargs)
++    def cmd(opt):
++        pass
++
++    return CliRunner().invoke(cmd, [], input=input_text).output.split("\n", 1)[0]
++
++
++def test_prompt_lists_enum_choices_and_default_by_name():
++    line = _prompt_line(type=click.Choice(Color), default=Color.Blue)
++    assert "(Red, Blue)" in line
++    assert "[Blue]" in line
++
++
++def test_prompt_previews_empty_string_default_quoted():
++    assert '[""]' in _prompt_line(default="")
++
++
++def test_prompt_default_typed_back_as_shown():
++    line = CliRunner().invoke(
++        _typed_back_cmd(multiple=True, default=["", "x"]), [], input='"", x\n'
++    ).output
++    assert "GOT=('', 'x')" in line
++    line = CliRunner().invoke(_typed_back_cmd(default=""), [], input='""\n').output
++    assert "GOT=''" in line
++
++
++def _typed_back_cmd(**kwargs):
++    @click.command()
++    @click.option("--opt", prompt="Value", **kwargs)
++    def cmd(opt):
++        click.echo(f"GOT={opt!r}")
++
++    return cmd

harbor/tasks/help_defaults/solution/solve.sh

@@ -0,0 +1,238 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/CHANGES.md b/CHANGES.md
+index 8853860..4976b6c 100644
+--- a/CHANGES.md
++++ b/CHANGES.md
+@@ -11,6 +11,10 @@ Unreleased
+ 
+ Unreleased
+ 
++- The `[default: ...]` shown in help for an option with `multiple=True`
++  renders each value the way a single value is rendered: `Enum` members by
++  name, empty strings as `""`. The prompt of an option lists its choices and
++  previews its default the same way, so what it shows can be typed back.
+ - Fix `copy.deepcopy()` and `pickle` on a `Parameter`, `Option` or `Command`. {pr}`3805`
+ - A `KeyboardInterrupt` arriving while `Command.main()` reports an abort or an error,
+   or while it exits, no longer escapes as an unhandled traceback. The command still
+diff --git a/src/click/_utils.py b/src/click/_utils.py
+index 2d4e8f2..e2811bb 100644
+--- a/src/click/_utils.py
++++ b/src/click/_utils.py
+@@ -1,7 +1,9 @@
+ from __future__ import annotations
+ 
+ import enum
++import inspect
+ import typing as t
++from gettext import gettext as _
+ 
+ 
+ class Sentinel(enum.Enum):
+@@ -43,3 +45,33 @@ T_UNSET: t.TypeAlias = t.Literal[Sentinel.UNSET]
+ 
+ T_FLAG_NEEDS_VALUE: t.TypeAlias = t.Literal[Sentinel.FLAG_NEEDS_VALUE]
+ """Type hint for the :data:`FLAG_NEEDS_VALUE` sentinel value."""
++
++
++def _format_default_value(value: t.Any) -> str:
++    """Render a value the way ``[default: ...]`` and prompts show it.
++
++    A list or tuple renders as its values, comma separated, each rendered by
++    the same rules as a single value: an Enum member by its name, an empty
++    string as ``""``, a plain function as ``(dynamic)``, anything else with
++    ``str()``.
++
++    :meta private:
++    """
++    if isinstance(value, (list, tuple)):
++        return ", ".join(_format_default_value(item) for item in value)
++    if isinstance(value, enum.Enum):
++        return value.name
++    if inspect.isfunction(value):
++        return _("(dynamic)")
++    if isinstance(value, str) and value == "":
++        return '""'
++    return str(value)
++
++
++def _format_choice(choice: t.Any) -> str:
++    """Render one choice the way prompts and help list it: an Enum member by
++    its name, anything else with ``str()``.
++
++    :meta private:
++    """
++    return choice.name if isinstance(choice, enum.Enum) else str(choice)
+diff --git a/src/click/core.py b/src/click/core.py
+index 1f9323a..e82eaa0 100644
+--- a/src/click/core.py
++++ b/src/click/core.py
+@@ -23,6 +23,7 @@ from types import TracebackType
+ 
+ from . import types
+ from ._utils import FLAG_NEEDS_VALUE
++from ._utils import _format_default_value
+ from ._utils import UNSET
+ from .exceptions import Abort
+ from .exceptions import BadParameter
+@@ -3564,12 +3565,13 @@ class Option(Parameter):
+         ):
+             if show_default_is_str:
+                 default_string = f"({self.show_default})"
+-            elif isinstance(default_value, (list, tuple)):
+-                default_string = ", ".join(str(d) for d in default_value)
+-            elif isinstance(default_value, enum.Enum):
+-                default_string = default_value.name
+-            elif inspect.isfunction(default_value):
+-                default_string = _("(dynamic)")
++            elif isinstance(default_value, (list, tuple)) or (
++                isinstance(default_value, enum.Enum)
++                or inspect.isfunction(default_value)
++            ):
++                # Multi-valued defaults render each value the way the same
++                # value renders for a single-valued option.
++                default_string = _format_default_value(default_value)
+             elif self.is_bool_flag and self.secondary_opts:
+                 # For boolean flags that have distinct True/False opts,
+                 # use the opt without prefix instead of the value.
+diff --git a/src/click/termui.py b/src/click/termui.py
+index 8fe0085..0caa7cd 100644
+--- a/src/click/termui.py
++++ b/src/click/termui.py
+@@ -15,6 +15,8 @@ from gettext import gettext as _
+ from . import _compat
+ from ._compat import isatty
+ from ._compat import strip_ansi
++from ._utils import _format_choice
++from ._utils import _format_default_value
+ from .exceptions import Abort
+ from .exceptions import UsageError
+ from .globals import resolve_color_default
+@@ -115,7 +117,9 @@ def _build_prompt(
+ ) -> str:
+     prompt = text
+     if type is not None and show_choices and isinstance(type, Choice):
+-        prompt += f" ({', '.join(map(str, type.choices))})"
++        # Each choice is listed the way it can be typed back, which for an
++        # Enum member is its name, as the help and the error message show it.
++        prompt += f" ({', '.join(_format_choice(choice) for choice in type.choices)})"
+     default_preview = ""
+     if show_default:
+         if isinstance(show_default, str):
+@@ -132,7 +136,9 @@ def _format_default(default: V) -> V | str:
+         if name is not None:
+             return str(name)
+ 
+-    return default
++    # The default is previewed the way the help renders it, so that what is
++    # shown is what the user can type back.
++    return _format_default_value(default)
+ 
+ 
+ @t.overload
+@@ -250,6 +256,15 @@ def prompt(
+     prompt = _build_prompt(
+         text, prompt_suffix, show_default, default, show_choices, type
+     )
++    # The default exactly as the prompt shows it. Typing that text back
++    # selects the default itself, as pressing Enter does, so that a value
++    # rendered for display (a quoted empty string, a list of values) can be
++    # typed back as shown.
++    shown_default = (
++        str(_format_default(default))
++        if default is not None and show_default and not isinstance(show_default, str)
++        else None
++    )
+ 
+     if confirmation_prompt:
+         if confirmation_prompt is True:
+@@ -269,7 +284,9 @@ def prompt(
+                 value = t.cast("str", default)
+                 break
+         try:
+-            result = value_proc(value)
++            result = value_proc(
++                default if shown_default is not None and value == shown_default else value
++            )
+         except UsageError as e:
+             message = _mask_hidden_input(e.message, value) if hide_input else e.message
+             echo(_("Error: {message}").format(message=message), err=err)
+diff --git a/tests/test_help_defaults_multiple.py b/tests/test_help_defaults_multiple.py
+new file mode 100644
+index 0000000..cb6eb77
+--- /dev/null
++++ b/tests/test_help_defaults_multiple.py
+@@ -0,0 +1,69 @@
++import enum
++
++import click
++from click.testing import CliRunner
++
++
++class Color(enum.Enum):
++    Red = "r"
++    Blue = "b"
++
++
++def _help(**kwargs):
++    @click.command()
++    @click.option("--opt", show_default=True, **kwargs)
++    def cmd(opt):
++        pass
++
++    return CliRunner().invoke(cmd, ["--help"]).output
++
++
++def test_multiple_enum_default_shows_names():
++    assert "[default: Red, Blue]" in _help(
++        type=click.Choice(Color), multiple=True, default=[Color.Red, Color.Blue]
++    )
++
++
++def test_multiple_empty_string_default_is_quoted():
++    assert '[default: "", x]' in _help(multiple=True, default=["", "x"])
++
++
++def test_nargs_with_multiple_renders_every_value():
++    assert "[default: 1, 2, 3, 4]" in _help(nargs=2, multiple=True, default=[(1, 2), (3, 4)])
++
++
++def _prompt_line(input_text="\n", **kwargs):
++    @click.command()
++    @click.option("--opt", prompt="Value", **kwargs)
++    def cmd(opt):
++        pass
++
++    return CliRunner().invoke(cmd, [], input=input_text).output.split("\n", 1)[0]
++
++
++def test_prompt_lists_enum_choices_and_default_by_name():
++    line = _prompt_line(type=click.Choice(Color), default=Color.Blue)
++    assert "(Red, Blue)" in line
++    assert "[Blue]" in line
++
++
++def test_prompt_previews_empty_string_default_quoted():
++    assert '[""]' in _prompt_line(default="")
++
++
++def test_prompt_default_typed_back_as_shown():
++    line = CliRunner().invoke(
++        _typed_back_cmd(multiple=True, default=["", "x"]), [], input='"", x\n'
++    ).output
++    assert "GOT=('', 'x')" in line
++    line = CliRunner().invoke(_typed_back_cmd(default=""), [], input='""\n').output
++    assert "GOT=''" in line
++
++
++def _typed_back_cmd(**kwargs):
++    @click.command()
++    @click.option("--opt", prompt="Value", **kwargs)
++    def cmd(opt):
++        click.echo(f"GOT={opt!r}")
++
++    return cmd
+
+REFERENCE_PATCH

harbor/tasks/help_defaults/task.toml

@@ -0,0 +1,28 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "help_defaults"
+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"
+env = { JUDGE_API_KEY = "${JUDGE_API_KEY:-}", JUDGE_BASE_URL = "${JUDGE_BASE_URL:-https://openrouter.ai/api/v1}", JUDGE_MODEL = "${JUDGE_MODEL:-anthropic/claude-sonnet-5.5}" }
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "allowlist"
+allowed_hosts = ["openrouter.ai"]
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/help_defaults/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-click:source-v9
+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 judge.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/help_defaults/tests/config.json

@@ -0,0 +1,152 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "help_defaults",
+  "arguments": {},
+  "grader_version": "0.6.13",
+  "source_image": "ec-swe-click:source-v9",
+  "source_image_id": "sha256:e8e795f66f12a38f30b7e9be2e430e4b4f8b6c2d11c0b9685a5b7f597dac403f",
+  "provenance": {
+    "repository": "pallets/click",
+    "environment_id": "29c14648-17d9-42d0-8d59-724a9c0d0feb",
+    "build": 9,
+    "build_id": "4505ff57-3be4-4ecc-aa01-decc9c8d8dce",
+    "hosted_task": "click-help-defaults",
+    "task_version": 5,
+    "source_archive_sha256": "19246fda734704552a40171add83070a3e3181c11aad73b24eff2244939a2400",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "multi_enum",
+      0.1875,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "multi_empty_string",
+      0.125,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "nested_values",
+      0.0625,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "prompt_rendering",
+      0.125,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "untouched_paths",
+      0.125,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "prompt_function",
+      0.0625,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "typeback_single",
+      0.0625,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "typeback_multi",
+      0.0625,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "no_regression",
+      0.0625,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "test_quality",
+      0.0625,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "maintainer_review",
+      0.0625,
+      false,
+      "judge",
+      0
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "authored",
+  "local_hostname": false,
+  "fault_exit": 2,
+  "grader_readable": [],
+  "grader_writable": [],
+  "blocker_cap": 0.1,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/tasks.py": "b0751721c15f44919283b1b0f82bc72711fa8ee79e0c441f8e6d2fc479c6d970",
+    "/app/env.py": "bacecba58799114163fb06badab8923c430fb577123b647d8ef6844231b9d770",
+    "/app/task/prompt.md": "bdcc4b7a286451ba09dfa4460d3e30e6097f05425c68b39974b1700ee15f864b",
+    "/app/coding/github.py": "5111a2264c70710a90ea6ecf154147eb7757311bca4f1bce7ea975c0da9525ae",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/repo.py": "f9b001028bb965a50740cdf90f84ba1dc93fda3daa831c42e58d712c6af74113",
+    "/hud/grader/maintainer_review.judge.json": "374ab90b38347f2dd0c2b4678b83ed443f20163ce9e94babfc4b1c435eb7173f",
+    "/hud/grader/run_grading.sh": "8cdaddf00bc1ba76f226900f2bb892724ea5707027cca0f0f2ae1998d52e382d",
+    "/hud/grader/tests/__hidden__nested_values.py": "0742b77e0b55f80c2f02fcc7ce1aa743baa589f79dc067b18c24c5ce7ae3f394",
+    "/hud/grader/tests/__hidden__multi_empty_string.py": "cc20a835b8c55766f7b62588bf3689b7ca63bc94cbfd106ec28cc736a02aa212",
+    "/hud/grader/tests/_fixtures.py": "77464690ab977f8c39e0704b061920a72ddd7982c54171b52ff9f6393a5b2202",
+    "/hud/grader/tests/__hidden__untouched_paths.py": "72f44182a4f38e5e7607b60ffd18f5b0f3c48086617f61d8725669428aa820f6",
+    "/hud/grader/tests/__hidden__multi_enum.py": "bc06c08b5f8fb9829bb65a1db01fc9ad1a885acbd3c6357303f94a5e67aa2ef9",
+    "/hud/grader/tests/__hidden__prompt_rendering.py": "2b98173cb8cd1618e1c9cad58838807863bce2c08ec92726d8c7521e016d74fe",
+    "/hud/grader/tests/__hidden__typeback_single.py": "707588128bd9a211a391add23f3512f2b3755f35356f12520a0a8def156e4f05",
+    "/hud/grader/tests/__hidden__typeback_multi.py": "ddcbf8a78634741148b509800221f4fa6b7f7281327cfb028be99a4f59a454cd",
+    "/hud/grader/tests/__hidden__prompt_function.py": "cc044df56a1bc062b7d4974c8b786b811fd6012be97a4de1a028b58d2fe90fb3"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'python --version' || python --version"
+    ]
+  ],
+  "judge": {
+    "base_url": "https://openrouter.ai/api/v1",
+    "model": "anthropic/claude-sonnet-5.5",
+    "criteria": [
+      "maintainer_review"
+    ],
+    "fractional_rows": false
+  }
+}

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

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

harbor/tasks/help_defaults/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/help_defaults/tests/judge.py

@@ -0,0 +1,178 @@
+"""Verifier entry for a coding rubric with criteria judged by a language model.
+
+The packaged verifier (verify.py) grades offline. A rubric with a judged
+criterion runs this file instead, which runs the same grading with three
+differences:
+
+- the verifier container reaches the judge's endpoint through Harbor's host
+  allowlist, and the judge's key, model and endpoint come from the verifier's
+  environment (``JUDGE_API_KEY``, ``JUDGE_MODEL``, ``JUDGE_BASE_URL``);
+- the key is held by this process only. Grader commands run the submission's
+  code, so no environment they inherit carries it;
+- the evidence check accepts a criterion the judge answered. A judge that does
+  not answer makes the attempt invalid: there is no reward, as for any grader
+  that cannot reach a verdict.
+
+verify.py and evidence.py are unchanged; this file wraps them.
+"""
+
+from __future__ import annotations
+
+import importlib
+import math
+import os
+import sys
+from typing import Any
+from urllib.parse import urlsplit
+
+# The key leaves the environment before anything can start a subprocess.
+_KEY = os.environ.pop("JUDGE_API_KEY", "")
+for _name in ("HUD_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"):
+    os.environ.pop(_name, None)
+_BASE_URL = os.environ.get("JUDGE_BASE_URL") or "https://openrouter.ai/api/v1"
+os.environ["JUDGE_MODEL"] = os.environ.get("JUDGE_MODEL") or "anthropic/claude-sonnet-5.5"
+
+import evidence  # noqa: E402
+import verify  # noqa: E402
+
+_preflight = verify._preflight
+
+
+def _scenario_grade(task: Any) -> Any:
+    # A task whose scenario both prompts and grades (druid): its second item is the result.
+    async def _grade(validate_mode: str | None) -> Any:
+        steps = task._scenario(validate_mode)
+        await steps.__anext__()
+        return await steps.__anext__()
+
+    return _grade
+
+
+def _prepare_task(config: dict[str, Any]) -> None:
+    """Check the verifier as verify.py does, then point the judge at its endpoint."""
+    _preflight(config)
+    from hud.settings import settings
+
+    # The judge's client reads these when it is built, from this process alone.
+    settings.api_key = _KEY or None
+    settings.hud_gateway_url = _BASE_URL
+    sys.path.insert(0, "/app")
+    task = importlib.import_module("tasks")
+    if not hasattr(task, "_setup"):
+        task._setup = importlib.import_module("env")._setup
+    if not hasattr(task, "_grade"):
+        task._grade = _scenario_grade(task)
+
+
+def _judge_error(score: dict[str, Any], result: dict[str, Any]) -> str | None:
+    for field in ("metadata", "info"):
+        error = (score.get(field) or {}).get("judge_error")
+        if error:
+            return str(error)
+    return ((result.get("info") or {}).get("judge_errors") or {}).get(score["name"])
+
+
+def validate_judged_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check judged evidence as evidence.validate_report checks the rest.
+
+    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 or inconsistent, or the judge did not answer.
+
+    Notes
+    -----
+    Judged criteria have no grader command. Every other criterion keeps the
+    checks of evidence.py, under its rule for a task's own reward function:
+    the reward stays within the weighted criteria, and a criterion whose
+    command failed earns nothing unless the task scores that criterion from
+    its command's output (``fractional_rows``).
+    """
+    report["judge"] = {"model": os.environ["JUDGE_MODEL"], "endpoint": urlsplit(_BASE_URL).hostname}
+    if report.get("status") != "graded":
+        evidence.validate_report(report, config, digest)
+        return
+    if (
+        report.get("revision") != evidence.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 = evidence._number(result.get("reward"))
+    commands = report.get("commands", [])
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in commands
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    if (result.get("isError", False) and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    judged = {name for name, row in expected.items() if row[3] == "judge"}
+    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"]
+        error = _judge_error(score, result) if name in judged else None
+        if error:
+            raise ValueError(f"The judge did not answer for {name}: {error}")
+        value, weight = evidence._number(score["value"]), evidence._number(score["weight"])
+        if name in judged and value > 0 and not score.get("children"):
+            raise ValueError(f"{name} is credited without the judge's verdicts")
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    command_names = [row["name"] for row in commands]
+    if len(command_names) != len(set(command_names)) or set(command_names) != (
+        set(expected) - judged
+    ) | set(config["gates"]):
+        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 evidence._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")
+    passed = {row["name"]: row["value"] for row in commands}
+    if not config["judge"]["fractional_rows"] and any(
+        values[name] > passed[name] for name in expected if name not in judged
+    ):
+        raise ValueError("A criterion is credited although its command failed")
+    if reward > raw + 1e-9:
+        raise ValueError("Grader reward exceeds its weighted criteria")
+
+
+verify._preflight = _prepare_task
+verify.validate_report = validate_judged_report
+
+if __name__ == "__main__":
+    verify.main()

harbor/tasks/help_defaults/tests/test.sh

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

harbor/tasks/help_defaults/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

@@ -1,12 +1,16 @@
 {
   "revision": "coding-rubric-v2",
   "tasks": [
+    "babylonjs_scene_remove_owner_refs_contract",
     "journal_recovery_after_unclean_stop",
     "bazel_remote_disk_eviction_accounting_contract",
     "celery_retry_expires_countdown_contract",
+    "help_defaults",
+    "druid_lenient_script",
     "epicyon_deleted_post_announce_cache_contract",
     "geode_oql_index_null_semantics_contract",
     "go_mysql_mariadb_compressed_columns",
+    "ahooks_request_cache_races",
     "kratos_cleanup_stale_flows_courier_contract",
     "microblogpub_deleted_object_resurrect_lookup_contract",
     "mongoose_syncindexes_contract",
@@ -16,6 +20,7 @@
     "pomerium_route_order_contract",
     "rope_rename_all_reexport_owners_contract",
     "shared_handle_abandoned_operations",
+    "bulkcreate_ignore_duplicates",
     "retained_top_level_names_keep_their_values",
     "xandikos_itip_recurrence_id_override_contract",
     "zettlr_clickable_keywords",