micro-models-agent 0.40.1 → 0.41.2

package/dist/modules/execution/stuck-detector.js

@@ -35,6 +35,36 @@ export function classifyError(output) {
     }
     return "systematic";
 }
+/**
+ * Tools that only observe state and never change it. A long run of only these
+ * with no write/exec in between means the model is reading/exploring without
+ * producing anything — a read-only loop that the stuck detector must surface
+ * (observed: 50+ read_file iterations with zero writes after a false-positive
+ * audit rejected a completed task).
+ */
+const READ_ONLY_TOOLS = new Set([
+    "read_file",
+    "glob",
+    "grep",
+    "list_dir",
+    "file_info",
+    "browser",
+    "web_search",
+    "web_fetch",
+    "web_browse",
+    "search_history",
+    "recall",
+    "project_map",
+    "chunk_query",
+    "process_list",
+    "process_log",
+    "plan",
+    "todo",
+    "verify",
+    "load_skill",
+]);
+/** Consecutive read-only tool calls that constitute a loop. */
+const READ_ONLY_LOOP_THRESHOLD = 10;
 export class StuckDetector {
     threshold;
     errorThreshold;
@@ -52,6 +82,10 @@ export class StuckDetector {
     escalationThreshold = 3;
     fileRewriteCount = new Map();
     fileRewriteThreshold = 3;
+    lastBashCommand = "";
+    lastBashOutput = "";
+    emptyBashRunCount = 0;
+    readOnlyStreak = 0;
     constructor(threshold = 6, errorThreshold = 3) {
         this.threshold = threshold;
         this.errorThreshold = errorThreshold;
@@ -70,6 +104,22 @@ export class StuckDetector {
         if (this.recentToolCalls.length > this.maxRecentCalls) {
             this.recentToolCalls.shift();
         }
+        // Track the consecutive read-only streak. A write/exec tool resets it;
+        // plan/todo bookkeeping counts as read-only (it is not real progress).
+        if (READ_ONLY_TOOLS.has(name)) {
+            this.readOnlyStreak++;
+        }
+        else {
+            this.readOnlyStreak = 0;
+        }
+    }
+    /**
+     * True after a long run of read-only tool calls with no write in between.
+     * The model is exploring/looping without producing anything — inject a
+     * recovery hint so it stops re-reading and actually edits files.
+     */
+    hasReadOnlyLoop() {
+        return this.readOnlyStreak >= READ_ONLY_LOOP_THRESHOLD;
     }
     recordToolError(toolName, output) {
         this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
@@ -81,6 +131,28 @@ export class StuckDetector {
     getLastErrorOutput() {
         return this.lastErrorOutput;
     }
+    /**
+     * Record every bash invocation (successful or not) so stuck detection can
+     * reason about repeated runs with empty output, entry-point issues, and
+     * platform mistakes (PowerShell cmdlets in cmd.exe, bash heredocs, ...).
+     */
+    recordBashOutput(command, output) {
+        const trimmed = output.trim();
+        if (command === this.lastBashCommand && !trimmed) {
+            this.emptyBashRunCount++;
+        }
+        else {
+            this.emptyBashRunCount = 0;
+        }
+        this.lastBashCommand = command;
+        this.lastBashOutput = output;
+    }
+    getLastBashCommand() {
+        return this.lastBashCommand;
+    }
+    getLastBashOutput() {
+        return this.lastBashOutput;
+    }
     getLastFailedTool() {
         return this.lastFailedTool;
     }
@@ -158,9 +230,7 @@ export class StuckDetector {
     getHints() {
         const hints = [];
         const desc = this.currentStepDescription.toLowerCase();
-        if (desc.includes("install") ||
-            desc.includes("npm") ||
-            desc.includes("pip")) {
+        if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
             hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
         }
         if (desc.includes("test") || desc.includes("spec")) {
@@ -172,17 +242,32 @@ export class StuckDetector {
         if (desc.includes("deploy") || desc.includes("publish")) {
             hints.push("Verify credentials and network access before deploying.");
         }
-        if (this.hasRepetitiveToolCalls()) {
+        // State-based bullets. The recovery message (getRecoveryMessage) already
+        // reports the PRIMARY reason (priority: stuck > tool-errors > consecutive
+        // > repetitive > read-only). Repeating that same state here as a hint
+        // would duplicate the guidance in the same cooldown block. Only add the
+        // bullet when the recovery message is NOT already covering that state.
+        const primary = this.getPrimaryReason();
+        if (this.hasRepetitiveToolCalls() && primary !== "repetitive") {
             hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
         }
-        if (this.hasConsecutiveFailures()) {
+        if (this.hasConsecutiveFailures() && primary !== "consecutive") {
             hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
         }
+        if (this.hasReadOnlyLoop() && primary !== "read-only") {
+            hints.push("You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps.");
+        }
         return hints;
     }
     getActionableHints() {
         const hints = [];
         const error = this.lastErrorOutput;
+        // Bash-specific hints do not depend on a tool failure — they fire even
+        // when the command "succeeded" with empty output (missing entry point).
+        const isScriptRun = /(^|[\s&])(bun|node|tsx|ts-node|deno|python|python3)\S*\s+[^|&]+\s+[^\s]+$/.test(this.lastBashCommand);
+        if (isScriptRun && !this.lastBashOutput.trim() && this.emptyBashRunCount >= 2) {
+            hints.push(`The command "${this.lastBashCommand}" ran ${this.emptyBashRunCount} times with EMPTY output. The program likely has no entry point — read the file with read_file and check that it actually calls its main function with process.argv / CLI arguments and prints results (console.log). Then run it again.`);
+        }
         if (!error)
             return hints;
         // Runtime incompatibility — tool/module crashes on this Node version
@@ -220,6 +305,25 @@ export class StuckDetector {
             const file = this.getExcessiveRewriteFile();
             hints.push(`File ${file} has been rewritten ${this.getFileRewriteCount(file)} times without success. Stop rewriting and try a fundamentally different approach.`);
         }
+        // Repeated identical bash runs with empty output — likely a missing
+        // entry point (the program never calls its main function).
+        // PowerShell cmdlets used inside cmd.exe (Windows shell mismatch).
+        if (/Write-Host|Get-Content|Select-String|Out-File|Set-Content/i.test(error)) {
+            hints.push("That looks like a PowerShell cmdlet — the shell here is cmd.exe. Use echo/type for output or the read_file/write_file tools instead.");
+        }
+        // Model invented a Bun API that does not exist.
+        if (/Bun\.\w+ is not a function|Bun\.\w+ is not defined|Bun\.\w+ is not a constructor/i.test(error)) {
+            hints.push("That Bun API does not exist. Verify the API name in the Bun docs — common ones are Bun.file, Bun.write, Bun.spawn, Bun.serve. For file checks use fs.existsSync from node:fs.");
+        }
+        // The model keeps writing a file whose output shows a type/syntax
+        // error — read the actual error and fix it, don't rewrite blindly.
+        if (/error TS\d+|typecheck failed|syntax check failed/i.test(error)) {
+            hints.push("The file still has a type/syntax error (see the error line in the output). Read the file with read_file around the reported line, fix the actual error, then re-run — rewriting the whole file blindly usually makes it worse.");
+        }
+        // Bash heredoc in cmd.exe.
+        if (/unexpected.*<<|Непредвиденное появление/i.test(error)) {
+            hints.push("Heredoc (<< EOF) is a bash feature — this shell is cmd.exe and does not support it. Write the file with write_file instead.");
+        }
         return hints;
     }
     getToolAlternative() {
@@ -287,10 +391,16 @@ export class StuckDetector {
         if (errorTool) {
             return t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
         }
+        if (this.hasReadOnlyLoop()) {
+            return t("exec.read_only_loop", {
+                count: String(this.readOnlyStreak),
+            });
+        }
         return "";
     }
     getRecoveryMessage() {
-        if (this.isStuck()) {
+        const reason = this.getPrimaryReason();
+        if (reason === "stuck") {
             return t("exec.stuck_recovery", {
                 iterations: this.iterationsOnCurrentStep,
                 stepId: String(this.currentStepId ?? "?"),
@@ -298,24 +408,50 @@ export class StuckDetector {
             });
         }
         // Per-tool error recovery (more specific — e.g., "bash failed 3 times")
-        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
-        if (errorTool) {
+        if (reason === "tool-errors") {
+            const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
             return t("exec.tool_errors_recovery", {
                 tool: errorTool[0],
                 count: errorTool[1],
             });
         }
         // Consecutive failures from different tools (generic — e.g., "5 consecutive failures")
-        if (this.hasConsecutiveFailures()) {
+        if (reason === "consecutive") {
             return t("exec.consecutive_failures_recovery", {
                 count: this.consecutiveFailures,
             });
         }
-        if (this.hasRepetitiveToolCalls()) {
+        if (reason === "repetitive") {
             return this.getRepetitiveToolMessage();
         }
+        if (reason === "read-only") {
+            return t("exec.read_only_loop_recovery", {
+                count: String(this.readOnlyStreak),
+            });
+        }
         return "";
     }
+    /**
+     * Single source of truth for the recovery reason priority. Used by BOTH
+     * getRecoveryMessage() and getHints() so the two cannot drift apart: the
+     * state bullet that getRecoveryMessage already reports is NOT repeated as a
+     * hint (priority: stuck > tool-errors > consecutive > repetitive >
+     * read-only).
+     */
+    getPrimaryReason() {
+        if (this.isStuck())
+            return "stuck";
+        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        if (errorTool)
+            return "tool-errors";
+        if (this.hasConsecutiveFailures())
+            return "consecutive";
+        if (this.hasRepetitiveToolCalls())
+            return "repetitive";
+        if (this.hasReadOnlyLoop())
+            return "read-only";
+        return null;
+    }
     reset() {
         this.currentStepId = null;
         this.iterationsOnCurrentStep = 0;
@@ -326,6 +462,29 @@ export class StuckDetector {
         this.recentToolCalls = [];
         this.fileRewriteCount.clear();
         this.escalationCount = 0;
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
+        this.readOnlyStreak = 0;
+    }
+    /**
+     * Reset only step-progress state, keeping the tool-call history and the
+     * read-only streak. Used when the plan is complete but the loop continues
+     * (e.g. the audit gate rejected a finished task): step-stuck warnings are
+     * silenced, but a read-without-write loop is still detected.
+     */
+    resetStepProgress() {
+        this.currentStepId = null;
+        this.iterationsOnCurrentStep = 0;
+        this.toolErrors.clear();
+        this.consecutiveFailures = 0;
+        this.lastFailedTool = "";
+        this.lastErrorOutput = "";
+        this.fileRewriteCount.clear();
+        this.escalationCount = 0;
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
     }
     /**
      * Reset all per-step state when moving to a new step. Prevents errors and
@@ -341,6 +500,10 @@ export class StuckDetector {
         this.lastErrorOutput = "";
         this.recentToolCalls = [];
         this.fileRewriteCount.clear();
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
+        this.readOnlyStreak = 0;
         // Preserve escalationCount — prevents agent from "gaming" stuck detection
         // by marking a step done and moving to the next one
     }

package/dist/modules/execution/verifier.js

@@ -1,8 +1,11 @@
-import { existsSync } from 'fs';
-import { resolve, extname } from 'path';
-import { spawn } from 'child_process';
-import { t } from '../../i18n/index';
-import { validateExpertConfig } from '../../config/experts';
+import { existsSync } from "fs";
+import { resolve, extname, join } from "path";
+import { spawn } from "child_process";
+import { t } from "../../i18n/index";
+import { validateExpertConfig } from "../../config/experts";
+import { findProjectRoot } from "../lsp/project-root";
+import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
+import { findExistingFile } from "./auditor";
 export class StepVerifier {
     baseDir;
     constructor(baseDir) {
@@ -13,26 +16,51 @@ export class StepVerifier {
         const exists = existsSync(resolved);
         return {
             passed: exists,
-            message: exists ? t('verify.file_exists', { path }) : t('verify.file_not_found', { path }),
+            message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path }),
         };
     }
     async runScript(scriptName) {
         try {
             await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60_000);
-            return { passed: true, message: t('verify.script_passed', { script: scriptName }) };
+            return { passed: true, message: t("verify.script_passed", { script: scriptName }) };
         }
         catch (e) {
-            return { passed: false, message: t('verify.script_failed', { script: scriptName, message: e.message }) };
+            return {
+                passed: false,
+                message: t("verify.script_failed", { script: scriptName, message: e.message }),
+            };
         }
     }
     async runTypeCheck() {
-        const tsconfigPath = resolve(this.baseDir, 'tsconfig.json');
+        const tsconfigPath = resolve(this.baseDir, "tsconfig.json");
         if (!existsSync(tsconfigPath)) {
-            return { passed: true, message: 'No tsconfig.json found — skipping type check' };
+            return { passed: true, message: "No tsconfig.json found — skipping type check" };
         }
         try {
-            await this.runAsync('npx tsc --noEmit', this.baseDir, 60_000);
-            return { passed: true, message: 'TypeScript type check passed' };
+            await this.runAsync("npx tsc --noEmit", this.baseDir, 60_000);
+            return { passed: true, message: "TypeScript type check passed" };
+        }
+        catch (e) {
+            const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
+            return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
+        }
+    }
+    /**
+     * Type-check a specific file, resolving the project root from the FILE's
+     * location (not the agent baseDir). For nested layouts (`baseDir/proj/` with
+     * its own tsconfig.json) the old baseDir-based check silently skipped every
+     * type error (observed in ses_mst2r0r5: zero type feedback for the whole
+     * session). Markers mirror the TypeScript LSP server config.
+     */
+    async runTypeCheckForFile(filePath) {
+        const projectRoot = findProjectRoot(filePath, this.baseDir, ["tsconfig.json", "package.json"]);
+        const tsconfigPath = join(projectRoot, "tsconfig.json");
+        if (!existsSync(tsconfigPath)) {
+            return { passed: true, message: "No tsconfig.json found — skipping type check" };
+        }
+        try {
+            await this.runAsync("npx tsc --noEmit --skipLibCheck", projectRoot, 60_000);
+            return { passed: true, message: "TypeScript type check passed" };
         }
         catch (e) {
             const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
@@ -40,21 +68,23 @@ export class StepVerifier {
         }
     }
     async runTests() {
-        const pkgPath = resolve(this.baseDir, 'package.json');
+        const pkgPath = resolve(this.baseDir, "package.json");
         if (!existsSync(pkgPath)) {
-            return { passed: true, message: 'No package.json found — skipping tests' };
+            return { passed: true, message: "No package.json found — skipping tests" };
         }
         try {
-            const pkg = JSON.parse(require('fs').readFileSync(pkgPath, 'utf-8'));
+            const pkg = JSON.parse(require("fs").readFileSync(pkgPath, "utf-8"));
             if (!pkg.scripts?.test) {
-                return { passed: true, message: 'No test script defined — skipping tests' };
+                return { passed: true, message: "No test script defined — skipping tests" };
             }
         }
-        catch { /* fall through — attempt to run */ }
-        return this.runScript('test');
+        catch {
+            /* fall through — attempt to run */
+        }
+        return this.runScript("test");
     }
     async verifyArtifactFiles(files) {
-        return Promise.all(files.map(f => this.checkFileExists(f)));
+        return Promise.all(files.map((f) => this.checkFileExists(f)));
     }
     async verifyMoEManifest(plan, config, allToolTags) {
         const errors = [];
@@ -87,45 +117,55 @@ export class StepVerifier {
         };
     }
     async verifyStep(stepDescription) {
-        const fileMatches = stepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [];
+        const fileMatches = extractFileLikeTokens(stripUrls(stepDescription));
+        // No named files — this step cannot be verified by file existence. Do NOT
+        // trivially pass (empty every() = true); signal noFiles so the tool guides
+        // the model to run a real check instead.
+        if (fileMatches.length === 0) {
+            return { passed: false, syntaxValid: true, failed: [], noFiles: true };
+        }
         const results = [];
         let syntaxValid = true;
         for (const filePath of fileMatches) {
-            const result = await this.checkFileExists(filePath);
-            results.push(result);
-            if (result.passed) {
-                const fullPath = resolve(this.baseDir, filePath);
-                if (!(await this.validateSyntax(fullPath))) {
-                    syntaxValid = false;
-                    results.push({ passed: false, message: t('verify.syntax_error', { path: filePath }) });
-                }
+            const resolved = findExistingFile(this.baseDir, filePath);
+            if (!resolved) {
+                results.push({ passed: false, message: t("verify.file_not_found", { path: filePath }) });
+                continue;
+            }
+            results.push({ passed: true, message: t("verify.file_exists", { path: filePath }) });
+            if (!(await this.validateSyntax(resolved))) {
+                syntaxValid = false;
+                results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
             }
         }
         return {
-            passed: results.every(r => r.passed),
+            passed: results.every((r) => r.passed),
             syntaxValid,
-            failed: results.filter(r => !r.passed),
+            failed: results.filter((r) => !r.passed),
+            noFiles: false,
         };
     }
     async validateSyntax(filePath) {
         const ext = extname(filePath);
-        if (ext === '.ts' || ext === '.tsx') {
+        if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
             try {
                 await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 10000);
                 return true;
             }
             catch (err) {
-                if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
+                if (err.status === 127 ||
+                    err.message.includes("not found") ||
+                    err.message.includes("ENOENT")) {
                     return true;
                 }
-                const stderr = err.stderr?.toString() || '';
-                if (stderr.includes('error TS') && !stderr.includes('Cannot find module')) {
+                const stderr = err.stderr?.toString() || "";
+                if (stderr.includes("error TS") && !stderr.includes("Cannot find module")) {
                     return false;
                 }
                 return true;
             }
         }
-        if (ext === '.js' || ext === '.jsx') {
+        if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
             try {
                 await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
                 return true;
@@ -146,21 +186,25 @@ export class StepVerifier {
                 cwd,
                 shell: true,
                 windowsHide: true,
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.on("data", (d) => {
+                stdout += d.toString();
+            });
+            child.stderr?.on("data", (d) => {
+                stderr += d.toString();
             });
-            let stdout = '';
-            let stderr = '';
-            child.stdout?.on('data', (d) => { stdout += d.toString(); });
-            child.stderr?.on('data', (d) => { stderr += d.toString(); });
             const timer = setTimeout(() => {
                 child.kill();
                 reject(new Error(`Command timed out after ${timeoutMs}ms`));
             }, timeoutMs);
-            child.on('error', (err) => {
+            child.on("error", (err) => {
                 clearTimeout(timer);
                 reject(err);
             });
-            child.on('close', (code) => {
+            child.on("close", (code) => {
                 clearTimeout(timer);
                 if (code === 0) {
                     resolve({ stdout, stderr });

package/dist/modules/execution/windows-commands.js

@@ -0,0 +1,41 @@
+/**
+ * Unix commands that do not exist (or have incompatible semantics) in Windows
+ * cmd.exe. The 9B model keeps reaching for grep/sed/ls/find via the bash tool;
+ * each failure returns a hint, but the model retries.
+ *
+ * This is a session-level, module-side companion to the bash tool's own
+ * per-command hard-stop (`UNIX_TO_WIN_HINTS` / `FAILING_FIRST_WORDS` /
+ * `HARD_BLOCK_THRESHOLD` in src/tools/bash.ts). That mechanism injects
+ * "STOP using X" INTO the tool output, which a 9B model tends to ignore; this
+ * one, gated to win32 like bash.ts, queues a <system-summary> that lands
+ * before the next model call. Keep the two command lists consistent.
+ *
+ * This is a command allow/deny list (like the security module's command
+ * blacklist), NOT task classification (rule #10).
+ */
+const FORBIDDEN_COMMANDS = new Set([
+    "grep",
+    "sed",
+    "ls",
+    "find",
+    "rm",
+    "touch",
+    "which",
+    "diff",
+    "cp",
+    "mv",
+]);
+function firstWord(command) {
+    const segs = command.trim().split(/[\s;|&]+/);
+    return (segs[0] || "").replace(/[^\w-]/g, "").toLowerCase();
+}
+/** The forbidden command name if `command` starts with one (handles `cd x && …`). */
+export function forbiddenWindowsCommand(command) {
+    const m = command.match(/^\s*cd\s+\S+\s*&&\s*(\S+)/);
+    if (m)
+        return forbiddenWindowsCommand(m[1]);
+    const word = firstWord(command);
+    if (word && FORBIDDEN_COMMANDS.has(word))
+        return word;
+    return null;
+}

package/dist/modules/hallucination/confidence.js

@@ -8,7 +8,11 @@ export class ConfidenceCheck {
     }
     validate(response) {
         if (!response || response.length < MIN_CHARS) {
-            return { status: "retry", reason: t("hall.short_response") };
+            return {
+                status: "retry",
+                kind: "short",
+                reason: t("hall.short_response"),
+            };
         }
         // Language-agnostic: very short response with no structured content
         const wordCount = response.split(/\s+/).filter(Boolean).length;
@@ -16,6 +20,7 @@ export class ConfidenceCheck {
         if (wordCount < MIN_WORDS && !hasStructure) {
             return {
                 status: "warn",
+                kind: "short",
                 reason: t("hall.short_response"),
             };
         }
@@ -25,6 +30,7 @@ export class ConfidenceCheck {
             if (overlap > 0.5) {
                 return {
                     status: "retry",
+                    kind: "repetition",
                     reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
                 };
             }
@@ -40,6 +46,7 @@ export class ConfidenceCheck {
             if (diversity < 0.25) {
                 return {
                     status: "warn",
+                    kind: "diversity",
                     reason: t("hall.repetitive", {
                         pct: Math.round((1 - diversity) * 100),
                     }),

package/dist/modules/hallucination/detector.js

@@ -21,8 +21,7 @@ export class HallucinationDetector {
     }
     async validate(response) {
         const confidenceResult = this.confidence.validate(response);
-        if (confidenceResult.status === "retry" ||
-            confidenceResult.status === "block") {
+        if (confidenceResult.status === "retry" || confidenceResult.status === "block") {
             return confidenceResult;
         }
         const factualResult = this.factual?.validate(response);
@@ -30,9 +29,7 @@ export class HallucinationDetector {
             return factualResult;
         }
         // LLM-as-judge consistency: fast path (no decisions) skips any LLM call.
-        const judgeResult = this.judge
-            ? await this.judge.validate(response, this.consistency)
-            : null;
+        const judgeResult = this.judge ? await this.judge.validate(response, this.consistency) : null;
         const warnings = [];
         if (judgeResult && judgeResult.status === "warn")
             warnings.push(judgeResult.reason || "");