fix(cli): report engine failures in JSON and scan configs concurrently

`warn()` is a no-op under `--json`, so an engine that died reached the
machine consumer as `{"success":false,"results":[]}` — indistinguishable
from a clean run. Carry `failures` and `notices` in the envelope, omitted
when empty, the way `skipped` already is.

Scan the ast-grep configs with `Promise.all` instead of awaiting each in
turn, so a project holding both `sg/rules/` and the legacy `rules/` does
not pay two subprocess latencies in series.

Extract the "directory is absent" errno guard to `rules/errno.ts`, one
definition shared rather than a private set per caller.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Jwc9FFroR3mTZ4hLiSkkX3

Author: theCodeDrift

packages/cli/src/commands/check.ts

@@ -282,7 +282,10 @@ export const checkCommand = defineCommand({
     const telemetry = await getTelemetry(cwd);
 
     // Warnings/notices are advisory human output; suppress them under --json so
-    // the machine output stays the { success, results, skipped? } shape.
+    // the machine output stays the
+    // { success, results, skipped?, failures?, notices? } shape. Engine
+    // failures and notices are carried in that envelope instead, since a
+    // machine consumer cannot read stderr prose.
     const warn = (message: string) => {
       if (!args.json) console.error(message);
     };
@@ -422,6 +425,12 @@ export const checkCommand = defineCommand({
             success: exitCode === 0,
             results,
             ...(plan.skipped.length > 0 ? { skipped: plan.skipped } : {}),
+            ...(dispatched.failures.length > 0
+              ? { failures: dispatched.failures }
+              : {}),
+            ...(dispatched.notices.length > 0
+              ? { notices: dispatched.notices }
+              : {}),
           });
           console.log(JSON.stringify(output));
         } else {

packages/cli/src/rules/dispatch.ts

@@ -3,14 +3,12 @@ import { join } from "node:path";
 
 import type { CheckResult } from "../types/check";
 import { dedupeFindings, ENGINE_LAYOUTS, type EngineName } from "./engines";
+import { isMissingDirectory } from "./errno";
 import { executeRuntimeRules } from "./runtime/harness";
 import type { RuntimeRule } from "./runtime/discover";
 import { runAstGrepScan } from "./scan";
 import { runVale } from "./vale/run";
 
-/** Errno values that mean "the directory is not there", and nothing worse. */
-const ABSENT_DIRECTORY_CODES = new Set(["ENOENT", "ENOTDIR"]);
-
 /**
  * Whether `.taskless/vale/rules/` holds anything to run.
  *
@@ -34,8 +32,7 @@ export async function hasValeRules(cwd: string): Promise<boolean> {
     );
     return entries.some((entry) => entry.endsWith(".yml"));
   } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code !== undefined && ABSENT_DIRECTORY_CODES.has(code)) return false;
+    if (isMissingDirectory(error)) return false;
     throw error;
   }
 }
@@ -102,17 +99,22 @@ export interface DispatchResult {
  * `sg/rules/` and the legacy `.taskless/rules/` are scanned separately, so a
  * rule present in both reports twice; the finding is its own identity, so
  * identical matches collapse.
+ *
+ * The configs are scanned concurrently, for the same reason the engines are:
+ * each is an independent subprocess over the same paths, and a project holding
+ * both `sg/rules/` and the legacy `rules/` should not pay their latencies in
+ * series. `Promise.all` preserves input order in its output, so the flattened
+ * results are ordered by config exactly as the sequential loop left them.
  */
 async function runAstGrepEngine(
   options: DispatchOptions
 ): Promise<EngineOutcome> {
-  const results: CheckResult[] = [];
-  for (const configPath of options.astGrepConfigPaths) {
-    const scan = await runAstGrepScan(options.cwd, options.paths, {
-      configPath,
-    });
-    results.push(...scan.results);
-  }
+  const scans = await Promise.all(
+    options.astGrepConfigPaths.map((configPath) =>
+      runAstGrepScan(options.cwd, options.paths, { configPath })
+    )
+  );
+  const results: CheckResult[] = scans.flatMap((scan) => scan.results);
   return { engine: "sg", results: dedupeFindings(results) };
 }
 
@@ -221,4 +223,3 @@ export async function runEngines(
         : 0,
   };
 }
-

packages/cli/src/schemas/check.ts

@@ -38,6 +38,17 @@ export const outputSchema = z.object({
     .array(skippedRuntimeRuleSchema)
     .optional()
     .describe("Runtime rules present but not executed"),
+  // Human output for these is `warn()`, which is a no-op under `--json`. Absent
+  // from the envelope, a machine consumer reads `{"success":false,"results":[]}`
+  // for a Vale that died and cannot tell it from a clean run.
+  failures: z
+    .array(z.string())
+    .optional()
+    .describe("Engines that were present and failed"),
+  notices: z
+    .array(z.string())
+    .optional()
+    .describe("Advisory messages: engines that could not run"),
 });
 
 /** Error schema for `taskless check --json` on failure */

packages/cli/test/vale-orchestration.test.ts

@@ -1,3 +1,4 @@
+import { execFile } from "node:child_process";
 import {
   chmodSync,
   mkdirSync,
@@ -6,7 +7,8 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
 
 import { afterEach, describe, expect, it, vi } from "vitest";
 
@@ -79,6 +81,41 @@ function makeMixedProject(options?: {
 /** The committed config `makeMixedProject` writes, as `check` would resolve it. */
 const sgConfigPaths = [".taskless/sg/sgconfig.yml"];
 
+const execFileAsync = promisify(execFile);
+const binPath = resolve(import.meta.dirname, "../dist/index.js");
+
+/** Run the built CLI, tolerating a non-zero exit. */
+async function runCli(
+  args: string[]
+): Promise<{ stdout: string; exitCode: number }> {
+  try {
+    const { stdout } = await execFileAsync("node", [binPath, ...args]);
+    return { stdout, exitCode: 0 };
+  } catch (error) {
+    const execError = error as { stdout: string; code: number };
+    return { stdout: execError.stdout ?? "", exitCode: execError.code };
+  }
+}
+
+/** The `--json` line, ignoring any preceding migration notice. */
+function parseJson(stdout: string): {
+  success: boolean;
+  results: unknown[];
+  failures?: string[];
+  notices?: string[];
+} {
+  const line = stdout
+    .trim()
+    .split("\n")
+    .findLast((entry) => entry.trim().startsWith("{"));
+  return JSON.parse(line ?? "{}") as {
+    success: boolean;
+    results: unknown[];
+    failures?: string[];
+    notices?: string[];
+  };
+}
+
 describe("hasValeRules", () => {
   it("is false for a scaffolded-but-empty rules directory", async () => {
     // The common state after `taskless init`. Spawning Vale per check to
@@ -295,3 +332,38 @@ describe("runEngines when Vale is unavailable", () => {
     }
   );
 });
+
+describe("an engine failure under --json", () => {
+  it("reaches the machine envelope, not only the suppressed warning", async () => {
+    // `warn()` is a no-op under `--json`, so without a field for it the
+    // consumer sees `{"success":false,"results":[]}` and cannot tell a broken
+    // engine from a clean run. A CI script reading that treats a dead engine
+    // as a pass.
+    const cwd = makeMixedProject({ valeRules: false });
+    // An unparseable rule file: ast-grep exits non-zero and the engine fails
+    // with no findings, the exact shape that used to read as clean.
+    writeFileSync(
+      join(cwd, ".taskless", "sg", "rules", "broken.yml"),
+      "id: broken\nlanguage: javascript\nrule:\n  bogusKey: nope\n"
+    );
+
+    const { stdout, exitCode } = await runCli(["check", "-d", cwd, "--json"]);
+    const output = parseJson(stdout);
+
+    expect(exitCode).toBe(1);
+    expect(output.success).toBe(false);
+    expect(output.results).toEqual([]);
+    expect(output.failures).toHaveLength(1);
+    expect(output.failures?.[0]).toContain("sg engine failed");
+  });
+
+  it("omits both fields when nothing failed, as `skipped` does", async () => {
+    const cwd = makeMixedProject({ valeRules: false });
+    const { stdout } = await runCli(["check", "-d", cwd, "doc.md", "--json"]);
+    const output = parseJson(stdout);
+
+    expect(output.success).toBe(true);
+    expect(output.failures).toBeUndefined();
+    expect(output.notices).toBeUndefined();
+  });
+});