@mandujs/mcp 0.23.0 → 0.25.0

package/src/tools/ate-prompt.ts

@@ -0,0 +1,146 @@
+/**
+ * `mandu_ate_prompt` — Phase A.3 prompt catalog tool.
+ *
+ * See `docs/ate/roadmap-v2-agent-native.md` §4.2 and §7 (A.3 extension
+ * "Pre-composed prompts") for the design.
+ *
+ * Semantics:
+ *   - If `context` is provided, the handler composes the full prompt
+ *     (template + matched exemplars + serialized context) and returns
+ *     a single ready-to-send-to-LLM string.
+ *   - If `context` is omitted, the handler returns the raw template body +
+ *     sha256 + a peek at available exemplars — the agent composes.
+ *
+ * Snake_case tool name (§11 decision #4). Read-only.
+ */
+
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import {
+  loadPrompt,
+  scanExemplars,
+  composePrompt,
+  type Exemplar,
+} from "@mandujs/ate";
+
+export const atePromptToolDefinitions: Tool[] = [
+  {
+    name: "mandu_ate_prompt",
+    annotations: {
+      readOnlyHint: true,
+    },
+    description:
+      "Phase A.3 agent-native prompt catalog. Returns the system prompt for a " +
+      "given test kind, with Mandu-specific primitives, anti-patterns, and the " +
+      "selector convention baked in. When `context` is passed, the handler " +
+      "also injects up-to-3 matching exemplars (tagged with @ate-exemplar:) " +
+      "plus the JSON context block and returns a fully composed, ready-to-" +
+      "send-to-LLM string. When `context` is omitted, the handler returns the " +
+      "raw template + the separate exemplar list so the agent can compose. " +
+      "Kinds available in v1: filling_unit, filling_integration, e2e_playwright. " +
+      "The returned sha256 is stable per-version and safe as a cache key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoRoot: {
+          type: "string",
+          description:
+            "Absolute path to the Mandu project root. Required when context is " +
+            "omitted so we can scan exemplars from the repo.",
+        },
+        kind: {
+          type: "string",
+          description:
+            "Prompt kind. v1 catalog: filling_unit | filling_integration | e2e_playwright.",
+        },
+        version: {
+          type: "number",
+          description:
+            "Pin to a specific template version. Defaults to the highest available.",
+        },
+        context: {
+          type: "object",
+          description:
+            "Optional semantic context (usually the output of mandu_ate_context). " +
+            "When present, the returned `prompt` is pre-composed.",
+          additionalProperties: true,
+        },
+        maxPositive: {
+          type: "number",
+          description: "Max positive exemplars to inject. Default 3.",
+        },
+        maxAnti: {
+          type: "number",
+          description: "Max anti-exemplars to inject. Default 1.",
+        },
+      },
+      required: ["kind"],
+    },
+  },
+];
+
+export function atePromptTools(_projectRoot: string) {
+  return {
+    mandu_ate_prompt: async (args: Record<string, unknown>) => {
+      const kind = args.kind as string | undefined;
+      if (!kind || typeof kind !== "string") {
+        return { ok: false, error: "'kind' is required and must be a string" };
+      }
+
+      const version = typeof args.version === "number" ? args.version : undefined;
+      const repoRoot = typeof args.repoRoot === "string" ? args.repoRoot : undefined;
+      const context = args.context;
+      const maxPositive = typeof args.maxPositive === "number" ? args.maxPositive : undefined;
+      const maxAnti = typeof args.maxAnti === "number" ? args.maxAnti : undefined;
+
+      try {
+        // When context is given, return a pre-composed prompt.
+        if (context !== undefined) {
+          const composed = await composePrompt({
+            kind,
+            version,
+            context,
+            repoRoot,
+            ...(maxPositive !== undefined ? { maxPositive } : {}),
+            ...(maxAnti !== undefined ? { maxAnti } : {}),
+          });
+          return {
+            ok: true,
+            prompt: composed.prompt,
+            sha256: composed.sha256,
+            version: composed.version,
+            kind: composed.kind,
+            exemplarCount: composed.exemplarCount,
+            antiCount: composed.antiCount,
+            tokenEstimate: composed.tokenEstimate,
+          };
+        }
+
+        // Otherwise: raw template + exemplar peek so the agent composes.
+        const loaded = loadPrompt(kind, version);
+        let exemplars: Exemplar[] = [];
+        if (repoRoot) {
+          try {
+            const all = await scanExemplars(repoRoot);
+            exemplars = all.filter((e) => e.kind === kind).slice(0, 5);
+          } catch {
+            // non-fatal — caller may invoke without a repoRoot
+          }
+        }
+        return {
+          ok: true,
+          prompt: loaded.raw,
+          sha256: loaded.sha256,
+          version: loaded.frontmatter.version,
+          kind: loaded.frontmatter.kind,
+          exemplars,
+          exemplarCount: exemplars.filter((e) => !e.anti).length,
+          antiCount: exemplars.filter((e) => e.anti).length,
+          tokenEstimate: Math.ceil(loaded.raw.length / 4),
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: msg };
+      }
+    },
+  };
+}

package/src/tools/ate-recall.ts

@@ -0,0 +1,85 @@
+/**
+ * `mandu_ate_recall` — Phase B.2 memory read tool.
+ *
+ * See docs/ate/phase-b-spec.md §B.2. Agents call this BEFORE generating
+ * a spec so they can reference prior intent / rejected healing history.
+ *
+ * Snake_case (§11 decision #4). Read-only.
+ */
+
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { recallMemory, type MemoryEventKind } from "@mandujs/ate";
+
+export const ateRecallToolDefinitions: Tool[] = [
+  {
+    name: "mandu_ate_recall",
+    annotations: {
+      readOnlyHint: true,
+    },
+    description:
+      "Phase B.2 memory recall. Queries the project-local " +
+      ".mandu/ate-memory.jsonl append-only log with substring + token-" +
+      "overlap scoring (no embeddings). Useful BEFORE generation to see " +
+      "previously rejected specs, accepted heals, or intent history for " +
+      "the same route. Returns { events, totalMatching }. Default limit 10, " +
+      "default sinceDays 90. Filter by kind: intent_history | rejected_spec " +
+      "| accepted_healing | rejected_healing | prompt_version_drift | " +
+      "boundary_gap_filled | coverage_snapshot.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoRoot: {
+          type: "string",
+          description: "Absolute path to the Mandu project root.",
+        },
+        intent: {
+          type: "string",
+          description: "Natural-language intent to search (substring + token overlap).",
+        },
+        route: {
+          type: "string",
+          description: "Route id or pattern ('api-signup' or '/api/signup').",
+        },
+        kind: {
+          type: "string",
+          description: "Filter by event kind.",
+        },
+        limit: {
+          type: "number",
+          description: "Max events to return. Default 10.",
+        },
+        sinceDays: {
+          type: "number",
+          description: "Drop events older than N days. Default 90.",
+        },
+      },
+      required: ["repoRoot"],
+    },
+  },
+];
+
+export function ateRecallTools(_projectRoot: string) {
+  return {
+    mandu_ate_recall: async (args: Record<string, unknown>) => {
+      const repoRoot = args.repoRoot as string | undefined;
+      if (!repoRoot || typeof repoRoot !== "string") {
+        return { ok: false, error: "repoRoot is required" };
+      }
+      try {
+        const result = recallMemory(repoRoot, {
+          intent: typeof args.intent === "string" ? args.intent : undefined,
+          route: typeof args.route === "string" ? args.route : undefined,
+          kind:
+            typeof args.kind === "string"
+              ? (args.kind as MemoryEventKind)
+              : undefined,
+          limit: typeof args.limit === "number" ? args.limit : undefined,
+          sinceDays: typeof args.sinceDays === "number" ? args.sinceDays : undefined,
+        });
+        return { ok: true, ...result };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+  };
+}

package/src/tools/ate-remember.ts

@@ -0,0 +1,79 @@
+/**
+ * `mandu_ate_remember` — Phase B.2 memory write tool.
+ *
+ * Snake_case (§11 decision #4). Idempotent append.
+ */
+
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import {
+  appendMemoryEvent,
+  parseMemoryEvent,
+  type MemoryEvent,
+} from "@mandujs/ate";
+
+export const ateRememberToolDefinitions: Tool[] = [
+  {
+    name: "mandu_ate_remember",
+    description:
+      "Phase B.2 memory write. Appends one event to the project-local " +
+      ".mandu/ate-memory.jsonl. File auto-rotates to .bak when it crosses " +
+      "10 MB. Supported event kinds (discriminated union by `kind`): " +
+      "intent_history | rejected_spec | accepted_healing | rejected_healing " +
+      "| prompt_version_drift | boundary_gap_filled | coverage_snapshot. " +
+      "Timestamp defaults to now (ISO-8601 UTC) if omitted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoRoot: {
+          type: "string",
+          description: "Absolute path to the Mandu project root.",
+        },
+        event: {
+          type: "object",
+          description:
+            "MemoryEvent object. Must carry a `kind` discriminator plus the " +
+            "event-kind-specific required fields (see @mandujs/ate memory/schema.ts).",
+          additionalProperties: true,
+        },
+      },
+      required: ["repoRoot", "event"],
+    },
+  },
+];
+
+export function ateRememberTools(_projectRoot: string) {
+  return {
+    mandu_ate_remember: async (args: Record<string, unknown>) => {
+      const repoRoot = args.repoRoot as string | undefined;
+      const eventRaw = args.event;
+
+      if (!repoRoot || typeof repoRoot !== "string") {
+        return { ok: false, error: "repoRoot is required" };
+      }
+      if (!eventRaw || typeof eventRaw !== "object") {
+        return { ok: false, error: "event is required" };
+      }
+
+      // Default the timestamp if the caller omitted it (agents do).
+      const draft = { ...(eventRaw as Record<string, unknown>) };
+      if (typeof draft.timestamp !== "string") {
+        draft.timestamp = new Date().toISOString();
+      }
+      const parsed = parseMemoryEvent(draft);
+      if (!parsed) {
+        return {
+          ok: false,
+          error:
+            "Event failed validation. Check that `kind` and the kind-specific required fields are present.",
+        };
+      }
+
+      try {
+        const result = appendMemoryEvent(repoRoot, parsed as MemoryEvent);
+        return { ok: true, written: result.written, rotation: result.rotation ?? null };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+  };
+}

package/src/tools/ate-run.ts

@@ -0,0 +1,154 @@
+/**
+ * `mandu_ate_run` — Phase A.2 agent-facing spec runner.
+ *
+ * Wraps `@mandujs/ate`'s `runSpec` behind the MCP tool surface.
+ *
+ * Semantics: execute a single spec file (Playwright or bun:test,
+ * auto-detected from the path), then return the failure.v1-shaped
+ * JSON — `{ status: "pass", ... }` on green, full failure envelope
+ * on red. Shard argument is forwarded transparently.
+ *
+ * The handler validates the returned shape against the failure.v1
+ * Zod schema on failure (cheap, catches translator regressions).
+ * On pass we return the pass envelope as-is.
+ *
+ * Snake_case naming per §11 decision 4.
+ */
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { runSpec, failureV1Schema, type RunResult } from "@mandujs/ate";
+
+export const ateRunToolDefinitions: Tool[] = [
+  {
+    name: "mandu_ate_run",
+    annotations: {
+      readOnlyHint: false,
+    },
+    description:
+      "Phase A.2 agent-native spec runner. Executes ONE spec file " +
+      "(Playwright if the path matches tests/e2e/** or *.e2e.ts, otherwise bun:test) " +
+      "and returns structured JSON. On pass: { status: 'pass', durationMs, assertions, graphVersion, runId }. " +
+      "On fail: a failure.v1 envelope with discriminated `kind` (one of: selector_drift, " +
+      "contract_mismatch, redirect_unexpected, hydration_timeout, rate_limit_exceeded, " +
+      "csrf_invalid, fixture_missing, semantic_divergence), kind-specific `detail`, " +
+      "`healing.auto[]` (deterministic replacements when confidence >= threshold), " +
+      "`healing.requires_llm` (true for shape-level failures), `flakeScore`, `lastPassedAt`, " +
+      "`graphVersion` (agent cache invalidation key), and trace/screenshot/dom artifacts " +
+      "staged under .mandu/ate-artifacts/<runId>/. Use `shard: { current, total }` to " +
+      "distribute across CI workers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoRoot: {
+          type: "string",
+          description: "Absolute path to the Mandu project root",
+        },
+        spec: {
+          oneOf: [
+            { type: "string" },
+            {
+              type: "object",
+              properties: {
+                path: { type: "string" },
+              },
+              required: ["path"],
+            },
+          ],
+          description:
+            "Spec file — either a path string (relative to repoRoot) or { path }. " +
+            "Runner is auto-detected from the path (Playwright vs bun:test).",
+        },
+        headed: {
+          type: "boolean",
+          description: "Playwright only — run headed. Default: false (headless).",
+        },
+        trace: {
+          type: "boolean",
+          description: "Playwright only — capture trace. Default: true.",
+        },
+        shard: {
+          type: "object",
+          properties: {
+            current: { type: "number", minimum: 1 },
+            total: { type: "number", minimum: 1 },
+          },
+          required: ["current", "total"],
+          description:
+            "CI sharding — `current` is 1-based. Playwright receives --shard=current/total; " +
+            "bun:test falls back to hash-based partitioning.",
+        },
+      },
+      required: ["repoRoot", "spec"],
+    },
+  },
+];
+
+export function ateRunTools(_projectRoot: string) {
+  return {
+    mandu_ate_run: async (args: Record<string, unknown>) => {
+      const { repoRoot, spec, headed, trace, shard } = args as {
+        repoRoot: string;
+        spec: string | { path: string };
+        headed?: boolean;
+        trace?: boolean;
+        shard?: { current: number; total: number };
+      };
+      if (!repoRoot || typeof repoRoot !== "string") {
+        return { ok: false, error: "repoRoot is required" };
+      }
+      if (!spec) {
+        return { ok: false, error: "spec is required" };
+      }
+      const specPath = typeof spec === "string" ? spec : spec?.path;
+      if (!specPath || typeof specPath !== "string") {
+        return { ok: false, error: "spec.path or spec string is required" };
+      }
+      if (shard) {
+        if (
+          typeof shard.current !== "number" ||
+          typeof shard.total !== "number" ||
+          shard.current < 1 ||
+          shard.total < 1 ||
+          shard.current > shard.total
+        ) {
+          return {
+            ok: false,
+            error: `invalid shard: ${JSON.stringify(shard)} (current must be 1..total)`,
+          };
+        }
+      }
+
+      let result: RunResult;
+      try {
+        result = await runSpec({
+          repoRoot,
+          spec: specPath,
+          headed,
+          trace,
+          shard,
+        });
+      } catch (err) {
+        return {
+          ok: false,
+          error: `runSpec failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+      }
+
+      // On failure, re-validate the shape against failure.v1. The
+      // runSpec path already does this, but re-checking at the MCP
+      // boundary means a buggy translator is caught before the
+      // payload crosses the wire.
+      if (result.status === "fail") {
+        const parsed = failureV1Schema.safeParse(result);
+        if (!parsed.success) {
+          return {
+            ok: false,
+            error: `runSpec emitted invalid failure.v1: ${parsed.error.issues[0]?.message ?? "schema mismatch"}`,
+            result,
+          };
+        }
+        return { ok: true, result: parsed.data };
+      }
+      return { ok: true, result };
+    },
+  };
+}

package/src/tools/ate-save.ts

@@ -0,0 +1,160 @@
+/**
+ * `mandu_ate_save` — Phase A.3 spec persistence with lint-before-write.
+ *
+ * See `docs/ate/roadmap-v2-agent-native.md` §4.7 and the §7 extension
+ * ("mandu_ate_save lint-before-write").
+ *
+ * Semantics:
+ *   1. Run `lintSpecContent` (from @mandujs/ate) which:
+ *        - parses with ts-morph (syntax errors block),
+ *        - walks import declarations (banned typos, unknown @mandujs/* barrels),
+ *        - detects anti-patterns (bare localhost, hand-rolled CSRF, DB mocks).
+ *   2. If any *blocking* diagnostic fires, return { saved: false, ... } WITHOUT
+ *      writing. Otherwise write and return { saved: true, path }.
+ *
+ * Snake_case tool name (§11 decision #4).
+ */
+
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { writeFileSync, mkdirSync, existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+import {
+  lintSpecContent,
+  appendMemoryEvent,
+  nowTimestamp,
+  type LintDiagnostic,
+} from "@mandujs/ate";
+
+// Re-export the diagnostic shape so callers can type-check against it without
+// pulling @mandujs/ate directly.
+export type { LintDiagnostic, LintSeverity } from "@mandujs/ate";
+
+export const ateSaveToolDefinitions: Tool[] = [
+  {
+    name: "mandu_ate_save",
+    description:
+      "Phase A.3 persist-with-lint. Writes an agent-generated test file to " +
+      "disk, but first runs a small lint pass that blocks common LLM mistakes: " +
+      "ts-morph syntax errors, unresolved / banned import paths, hand-rolled " +
+      "CSRF cookies, DB mocks when createTestDb is available, and bare " +
+      "`localhost:<port>` URLs (prefer 127.0.0.1 per roadmap §9.2). Returns " +
+      "{ saved: true, path, lintDiagnostics: [warnings...] } on success or " +
+      "{ saved: false, blockingErrors: [...], lintDiagnostics: [...] } when " +
+      "a blocker fires (in which case no file is written).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description:
+            "Absolute path where the spec will be written. Parent directories are created if needed.",
+        },
+        content: {
+          type: "string",
+          description: "The full TypeScript test source to write.",
+        },
+        intent: {
+          type: "string",
+          description:
+            "Optional short description of what the test is verifying (logged to ATE memory).",
+        },
+        kind: {
+          type: "string",
+          description:
+            "Optional prompt kind this spec was generated for (filling_unit, filling_integration, e2e_playwright).",
+        },
+        sourcePrompt: {
+          type: "object",
+          description:
+            "Optional { kind, version } back-reference to the prompt that produced this spec (used by future memory queries).",
+          additionalProperties: true,
+        },
+        allowWarnings: {
+          type: "boolean",
+          description:
+            "When true, non-blocking warnings still allow the write (default true). When false, even warnings block.",
+        },
+      },
+      required: ["path", "content"],
+    },
+  },
+];
+
+export function ateSaveTools(projectRoot: string) {
+  return {
+    mandu_ate_save: async (args: Record<string, unknown>) => {
+      const path = args.path as string | undefined;
+      const content = args.content as string | undefined;
+      const intent = typeof args.intent === "string" ? args.intent : undefined;
+      const kind = typeof args.kind === "string" ? args.kind : undefined;
+      const allowWarnings = args.allowWarnings !== false;
+
+      if (!path || typeof path !== "string") {
+        return { saved: false, error: "'path' is required" };
+      }
+      if (!isAbsolute(path)) {
+        return {
+          saved: false,
+          error: "'path' must be absolute — relative paths are rejected to prevent cwd drift.",
+        };
+      }
+      if (typeof content !== "string") {
+        return { saved: false, error: "'content' is required and must be a string" };
+      }
+
+      const diagnostics = await lintSpecContent(path, content);
+
+      const blocking = diagnostics.filter((d) => d.blocking);
+      const warnings = diagnostics.filter((d) => !d.blocking);
+
+      if (blocking.length > 0 || (!allowWarnings && warnings.length > 0)) {
+        return {
+          saved: false,
+          path,
+          blockingErrors: blocking,
+          lintDiagnostics: diagnostics,
+        };
+      }
+
+      const parent = dirname(path);
+      if (!existsSync(parent)) {
+        mkdirSync(parent, { recursive: true });
+      }
+      if (!statSync(parent).isDirectory()) {
+        return { saved: false, path, error: `Parent path is not a directory: ${parent}` };
+      }
+
+      writeFileSync(path, content, "utf8");
+
+      // Phase B.2 — auto-record intent_history event. Non-fatal on failure.
+      try {
+        appendMemoryEvent(projectRoot, {
+          kind: "intent_history",
+          timestamp: nowTimestamp(),
+          intent: intent ?? "(no intent supplied)",
+          agent: typeof args.agent === "string" ? (args.agent as string) : "unknown",
+          resulting: { saved: [path] },
+          ...(kind ? { routeId: kind } : {}),
+        });
+      } catch {
+        // swallow
+      }
+
+      return {
+        saved: true,
+        path,
+        bytes: Buffer.byteLength(content, "utf8"),
+        lintDiagnostics: diagnostics,
+      };
+    },
+  };
+}
+
+// Re-export for tests that need direct access (package.json test patterns
+// already reach here).
+export async function lintContent(
+  path: string,
+  content: string,
+): Promise<LintDiagnostic[]> {
+  return lintSpecContent(path, content);
+}

package/src/tools/ate.ts

@@ -171,16 +171,27 @@ export const ateToolDefinitions: Tool[] = [
       readOnlyHint: true,
     },
     description:
-      "ATE Optimization — Impact Analysis: Calculate the minimal subset of routes affected by changed files using git diff. " +
-      "Avoids running the full test suite when only part of the codebase changed. " +
-      "Returns selectedRoutes to pass to mandu.ate.generate (onlyRoutes) or mandu.ate.run. " +
-      "Typical use: run after `git commit` to test only affected routes in CI.",
+      "ATE Impact Analysis (Phase B.3 v2). Calculates the minimal set of " +
+      "routes / specs affected by changed files using git diff, classifies " +
+      "contract changes (additive / breaking / renaming), and returns " +
+      "`affected.specsToReRun`, `affected.specsLikelyBroken`, " +
+      "`affected.missingCoverage`, plus a `suggestions` list keyed to " +
+      "re_run / heal / regenerate / add_boundary_test. Stamped with " +
+      "graphVersion for agent caching. Keeps v1 fields (changedFiles, " +
+      "selectedRoutes, warnings) for backwards compatibility. " +
+      "Pass `since: 'working'` for uncommitted changes, `since: 'staged'` " +
+      "for staged changes, or a git rev (default: HEAD~1) for committed diffs.",
     inputSchema: {
       type: "object",
       properties: {
         repoRoot: { type: "string", description: "Absolute path to the Mandu project root" },
-        base: { type: "string", description: "Git base ref for diff (default: HEAD~1 or main branch)" },
-        head: { type: "string", description: "Git head ref for diff (default: current working tree)" },
+        base: { type: "string", description: "Git base ref (legacy v1 — use `since` instead)" },
+        head: { type: "string", description: "Git head ref (legacy v1 — defaults to HEAD)" },
+        since: {
+          type: "string",
+          description:
+            "v2 diff source: 'HEAD~1' | 'staged' | 'working' | any git rev. Default 'HEAD~1'.",
+        },
       },
       required: ["repoRoot"],
     },
@@ -333,11 +344,27 @@ export function ateTools(projectRoot: string) {
       return ateHeal({ repoRoot, runId });
     },
     "mandu.ate.impact": async (args: Record<string, unknown>) => {
-      const { repoRoot, base, head } = args as {
+      const { repoRoot, base, head, since } = args as {
         repoRoot: string;
         base?: string;
         head?: string;
+        since?: "HEAD~1" | "staged" | "working" | string;
       };
+
+      // Phase B.3 — try the v2 impact pipeline first so callers get
+      // `affected`, `suggestions`, `contractDiffs`, `graphVersion` in
+      // addition to the v1 fields. Fall back to v1 on failure so the
+      // tool contract stays backwards compatible.
+      try {
+        const { computeImpactV2 } = await import("@mandujs/ate");
+        const v2 = await computeImpactV2({
+          repoRoot,
+          since: since ?? base,
+        });
+        return { ok: true, ...v2 };
+      } catch {
+        // Fall through to v1.
+      }
       return ateImpact({ repoRoot, base, head });
     },
     "mandu.ate.auto_pipeline": async (args: Record<string, unknown>) => {