micro-models-agent 0.41.2 → 0.43.0

package/dist/modules/execution/moe-executor.js

@@ -2,7 +2,6 @@ import { getExpertConfig } from "../../config/experts";
 import { filterToolsByTags } from "../../tools/filter-tools";
 import { StuckDetector } from "./stuck-detector";
 import { t } from "../../i18n/index";
-import { ArtifactStore } from "../artifacts/store";
 const TRANSIENT_ERROR_PATTERNS = [
     "timeout",
     "Timeout",
@@ -103,38 +102,14 @@ async function executeSubtask(subtask, deps, _sharedContext) {
                 read_only_files: readOnlyFiles,
                 tool_tags: expertConfig.tool_tags,
             };
-            if (deps.config.subagent?.resultMode === "file") {
-                subagentArgs.result_mode = "file";
-                subagentArgs.artifact_name = subtask.id;
-            }
             const result = await subagentTool.handler({
                 config: deps.config,
                 baseDir: deps.baseDir,
                 logger: deps.logger,
                 llmProvider: deps.llmProvider,
                 toolExecutor: deps.toolExecutor,
-                sessionId: "moe",
             }, subagentArgs);
             if (result.success) {
-                if (deps.config.subagent?.resultMode === "file") {
-                    const pathMatch = result.output.match(/saved to artifact: (.+)/);
-                    const abs = pathMatch ? pathMatch[1].trim() : "";
-                    if (abs) {
-                        const store = new ArtifactStore({
-                            baseDir: deps.baseDir,
-                            sessionId: "moe",
-                        });
-                        const full = store.read(abs.split(/[\\/]/).pop() || ""); // file name only, scoped to root
-                        deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
-                        return {
-                            subtaskId: subtask.id,
-                            success: true,
-                            summary: `Artifact: ${abs}`,
-                            result: full ?? result.output,
-                            durationMs: Date.now() - startTime,
-                        };
-                    }
-                }
                 return {
                     subtaskId: subtask.id,
                     success: true,

package/dist/modules/execution/plan-store.js

@@ -29,7 +29,9 @@ function listDir(dir, baseDir) {
     if (!existsSync(dir))
         return [];
     const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    return files.map((f) => readPlanFile(join(dir, f), baseDir)).filter((p) => p !== null);
+    return files
+        .map((f) => readPlanFile(join(dir, f), baseDir))
+        .filter((p) => p !== null);
 }
 function toMeta(plan, status) {
     return {

package/dist/modules/execution/plan-validator.js

@@ -3,7 +3,7 @@ export function validatePlan(plan, config) {
     const warnings = [];
     const autoFixes = [];
     if (!plan.subtasks || plan.subtasks.length === 0) {
-        return { valid: false, errors: ["Plan has no subtasks"], warnings: [], autoFixes: [] };
+        return { valid: false, errors: ['Plan has no subtasks'], warnings: [], autoFixes: [] };
     }
     errors.push(...expertTagsExist(plan.subtasks, config));
     errors.push(...hasCycle(plan.subtasks));
@@ -30,7 +30,7 @@ export function expertTagsExist(subtasks, config) {
     const knownExperts = new Set(Object.keys(config.experts || {}));
     for (const subtask of subtasks) {
         if (!knownExperts.has(subtask.expert_tag)) {
-            errors.push(`Subtask "${subtask.id}" references unknown expert_tag "${subtask.expert_tag}". Known experts: ${Array.from(knownExperts).join(", ")}`);
+            errors.push(`Subtask "${subtask.id}" references unknown expert_tag "${subtask.expert_tag}". Known experts: ${Array.from(knownExperts).join(', ')}`);
         }
     }
     return errors;
@@ -81,12 +81,12 @@ export function hasAllowedFilesOverlap(subtasks) {
     }
     for (const [file, writers] of writeFiles) {
         if (writers.length > 1) {
-            const noDep = writers.filter((w) => {
-                const sub = subtasks.find((s) => s.id === w);
-                return sub && !sub.depends_on?.some((d) => writers.includes(d));
+            const noDep = writers.filter(w => {
+                const sub = subtasks.find(s => s.id === w);
+                return sub && !sub.depends_on?.some(d => writers.includes(d));
             });
             if (noDep.length > 1) {
-                errors.push(`Write-write overlap on "${file}" between subtasks: ${writers.join(", ")} without dependency chain`);
+                errors.push(`Write-write overlap on "${file}" between subtasks: ${writers.join(', ')} without dependency chain`);
             }
         }
     }
@@ -104,7 +104,7 @@ export function deleteReadOverlap(subtasks) {
                 continue;
             const readFiles = new Set(reader.read_only_files);
             const writeFiles = writer.allowed_files;
-            const overlapping = writeFiles.filter((f) => {
+            const overlapping = writeFiles.filter(f => {
                 for (const rf of readFiles) {
                     if (f.startsWith(rf) || rf.startsWith(f))
                         return true;
@@ -125,7 +125,7 @@ export function deleteReadOverlap(subtasks) {
                         subtaskId: reader.id,
                         dependsOn: writer.id,
                         canAutoFix: false,
-                        error: `Read-after-write overlap between "${writer.id}" (writer) and "${reader.id}" (reader) on "${overlapping.join(", ")}" — add depends_on: [${writer.id}]`,
+                        error: `Read-after-write overlap between "${writer.id}" (writer) and "${reader.id}" (reader) on "${overlapping.join(', ')}" — add depends_on: [${writer.id}]`,
                     });
                 }
             }
@@ -134,9 +134,9 @@ export function deleteReadOverlap(subtasks) {
     return results;
 }
 export function applyAutoFixes(plan, autoFixes) {
-    const fixed = { ...plan, subtasks: plan.subtasks.map((s) => ({ ...s })) };
+    const fixed = { ...plan, subtasks: plan.subtasks.map(s => ({ ...s })) };
     for (const fix of autoFixes) {
-        const sub = fixed.subtasks.find((s) => s.id === fix.subtaskId);
+        const sub = fixed.subtasks.find(s => s.id === fix.subtaskId);
         if (!sub)
             continue;
         const dependsOnMatch = fix.fix.match(/depends_on:\s*(\S+)/);

package/dist/modules/execution/planner.js

@@ -26,7 +26,7 @@ export class PlanCreator {
         const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
         return hasActionWord && words.length > 8;
     }
-    static createPlan(title, stepDescriptions, baseDir, kinds) {
+    static createPlan(title, stepDescriptions, baseDir) {
         const stepCount = stepDescriptions.length;
         return {
             id: generatePlanId(),
@@ -35,7 +35,6 @@ export class PlanCreator {
                 id: i + 1,
                 description: desc,
                 status: "pending",
-                kind: kinds?.[i] ?? "create",
             })),
             createdAt: new Date().toISOString(),
             baseDir,
@@ -50,7 +49,6 @@ export class PlanCreator {
             id: kept.length + i + 1,
             description: desc,
             status: "pending",
-            kind: "create",
         }));
         return {
             id: plan.id,
@@ -81,9 +79,6 @@ export class PlanCreator {
                             : "[ ]";
             const note = step.note ? ` — ${step.note}` : "";
             lines.push(`${icon} ${step.id}. ${step.description}${note}`);
-            for (const sub of step.subtasks ?? []) {
-                lines.push(`    ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
-            }
         }
         return lines.join("\n");
     }

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

@@ -35,36 +35,6 @@ 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;
@@ -82,10 +52,6 @@ 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;
@@ -104,22 +70,6 @@ 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);
@@ -131,28 +81,6 @@ 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;
     }
@@ -230,7 +158,9 @@ 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")) {
@@ -242,32 +172,17 @@ export class StuckDetector {
         if (desc.includes("deploy") || desc.includes("publish")) {
             hints.push("Verify credentials and network access before deploying.");
         }
-        // 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") {
+        if (this.hasRepetitiveToolCalls()) {
             hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
         }
-        if (this.hasConsecutiveFailures() && primary !== "consecutive") {
+        if (this.hasConsecutiveFailures()) {
             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
@@ -305,25 +220,6 @@ 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() {
@@ -391,16 +287,10 @@ 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() {
-        const reason = this.getPrimaryReason();
-        if (reason === "stuck") {
+        if (this.isStuck()) {
             return t("exec.stuck_recovery", {
                 iterations: this.iterationsOnCurrentStep,
                 stepId: String(this.currentStepId ?? "?"),
@@ -408,50 +298,24 @@ export class StuckDetector {
             });
         }
         // Per-tool error recovery (more specific — e.g., "bash failed 3 times")
-        if (reason === "tool-errors") {
-            const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        if (errorTool) {
             return t("exec.tool_errors_recovery", {
                 tool: errorTool[0],
                 count: errorTool[1],
             });
         }
         // Consecutive failures from different tools (generic — e.g., "5 consecutive failures")
-        if (reason === "consecutive") {
+        if (this.hasConsecutiveFailures()) {
             return t("exec.consecutive_failures_recovery", {
                 count: this.consecutiveFailures,
             });
         }
-        if (reason === "repetitive") {
+        if (this.hasRepetitiveToolCalls()) {
             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;
@@ -462,29 +326,6 @@ 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
@@ -500,10 +341,6 @@ 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,11 +1,8 @@
-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";
+import { existsSync } from 'fs';
+import { resolve, extname } from 'path';
+import { spawn } from 'child_process';
+import { t } from '../../i18n/index';
+import { validateExpertConfig } from '../../config/experts';
 export class StepVerifier {
     baseDir;
     constructor(baseDir) {
@@ -16,51 +13,26 @@ 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" };
-        }
-        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" };
+            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;
@@ -68,23 +40,21 @@ 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 = [];
@@ -117,55 +87,45 @@ export class StepVerifier {
         };
     }
     async verifyStep(stepDescription) {
-        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 fileMatches = stepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [];
         const results = [];
         let syntaxValid = true;
         for (const filePath of fileMatches) {
-            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 }) });
+            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 }) });
+                }
             }
         }
         return {
-            passed: results.every((r) => r.passed),
+            passed: results.every(r => r.passed),
             syntaxValid,
-            failed: results.filter((r) => !r.passed),
-            noFiles: false,
+            failed: results.filter(r => !r.passed),
         };
     }
     async validateSyntax(filePath) {
         const ext = extname(filePath);
-        if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
+        if (ext === '.ts' || ext === '.tsx') {
             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" || ext === ".cjs" || ext === ".mjs") {
+        if (ext === '.js' || ext === '.jsx') {
             try {
                 await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
                 return true;
@@ -186,25 +146,21 @@ export class StepVerifier {
                 cwd,
                 shell: true,
                 windowsHide: true,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let stdout = "";
-            let stderr = "";
-            child.stdout?.on("data", (d) => {
-                stdout += d.toString();
-            });
-            child.stderr?.on("data", (d) => {
-                stderr += d.toString();
+                stdio: ['ignore', 'pipe', 'pipe'],
             });
+            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 });