@intentius/chant 0.79.0 → 0.80.0

package/src/cli/commands/audit.ts

@@ -6,14 +6,15 @@
  */
 
 import { existsSync, readFileSync, statSync, writeFileSync } from "fs";
-import { join } from "path";
+import { join, resolve } from "path";
 import { auditFiles, type AuditInput, type AuditFinding, type ChecksProvider, type SuppressionStats } from "../../audit/core";
-import { AUDIT_LEXICONS, classifyFiles, collectCandidates, loadAuditPlugins, unclaimedFiles, type DetectPlugin, type RepoFile, type UnclaimedFile } from "../../audit/discover";
+import { AUDIT_LEXICONS, classifyFiles, loadAuditPlugins, unclaimedFiles, walkCandidates, type CandidateWalk, type DetectPlugin, type RepoFile, type UnclaimedFile } from "../../audit/discover";
 import { RULE_CATALOG, resolveAuditCatalog, type RuleMeta } from "../../audit/catalog";
 import { scanForSecrets, parseSecretsConfig, type SecretsScanOptions } from "../../audit/secrets";
 import { auditWranglerConfigs } from "../../audit/wrangler";
 import { auditNginxConfigs } from "../../audit/nginx";
-import { auditTerraformState } from "../../audit/terraform-state";
+import { auditTerraformState, isTerraformStatePath } from "../../audit/terraform-state";
+import { warnDiscoveryChanges } from "../../discovery/convergence";
 import { renderMarkdown } from "../../audit/report";
 import { renderHtml, type ReportTheme } from "../../audit/report-html";
 import { buildReportJson, REPORT_SCHEMA_VERSION, type AuditSnapshot } from "../../audit/report-model";
@@ -21,6 +22,8 @@ import { fetchRepoFiles, resolveActionSha, resolveImageDigest, resolveRepoCommit
 import { extractUnpinnedActions, extractUnpinnedImages } from "../../audit/proof";
 import type { ProveOptions } from "../../audit/proof";
 import type { Severity } from "../../lint/rule";
+import { formatWarning } from "../format";
+import { lexiconModulePath, lexiconPackagesToInstall, lexiconSourceLabel } from "../../lexicon-module";
 
 export type AuditFormat = "stylish" | "json" | "sarif" | "markdown" | "html";
 export type AuditTier = "merge-worthy" | "all";
@@ -68,6 +71,23 @@ export interface AuditCommandOptions {
    * present (URL targets have no local config file to read).
    */
   secretsScan?: SecretsScanOptions;
+  /**
+   * Files the local walk takes before it stops, counting every file
+   * (`--max-files`, #2528). Defaults to 1000. Local paths only.
+   */
+  maxFiles?: number;
+}
+
+/**
+ * A diagnostic about the run rather than the repository. Printed on stderr by
+ * `printAuditResult`, never part of `output`, so the report on stdout is the
+ * same with or without one.
+ */
+export interface AuditWarning {
+  /** The path the warning is about, when there is one. */
+  file?: string;
+  message: string;
+  hint?: string;
 }
 
 export interface AuditCommandResult {
@@ -96,14 +116,27 @@ export interface AuditCommandResult {
    * summary line.
    */
   suppressedCount?: number;
+  /** Run diagnostics for stderr (#2528). */
+  warnings?: AuditWarning[];
 }
 
 /** Exit code when the audit had no lexicons to look with. Distinct from 1 (findings / failure). */
 export const NO_LEXICONS_EXIT_CODE = 2;
 
-/** The npm package that provides an audit lexicon's detection and checks. */
-function lexiconPackage(name: string): string {
-  return `@intentius/chant-lexicon-${name}`;
+/**
+ * What to tell the user about lexicons that did not load: an `npm i` line for
+ * the package-backed ones, and the declared path for any lexicon
+ * `chant.config.ts` names by path (#2520), which has no package to install
+ * (chant#2578).
+ */
+function missingLexiconRemedy(names: readonly string[]): string {
+  const parts: string[] = [];
+  const pkgs = lexiconPackagesToInstall(names);
+  if (pkgs.length > 0) parts.push(`npm i ${pkgs.join(" ")}`);
+  for (const name of names) {
+    if (lexiconModulePath(name) !== undefined) parts.push(`${name} is declared by path: ${lexiconSourceLabel(name)}`);
+  }
+  return parts.join("; ");
 }
 
 /** Missing audit lexicons the unclaimed files pointed at, in first-seen order. */
@@ -117,7 +150,8 @@ function wantedLexicons(unclaimed: UnclaimedFile[]): string[] {
  * them on the same resolution path.
  */
 export function installLine(lexicons: string[], target: string): string {
-  const pkgs = ["@intentius/chant", ...lexicons.map(lexiconPackage)];
+  // chant#2578 — a lexicon declared by path has no package for npx to fetch.
+  const pkgs = ["@intentius/chant", ...lexiconPackagesToInstall(lexicons)];
   return `npx ${pkgs.map((p) => `-p ${p}`).join(" ")} chant audit ${target}`;
 }
 
@@ -127,7 +161,7 @@ function missingLexiconHint(unclaimed: UnclaimedFile[]): string | undefined {
   if (wanted.length === 0) return undefined;
   const n = unclaimed.length;
   return `${n} file${n === 1 ? " looks" : "s look"} like ${wanted.join("/")} but ${wanted.length === 1 ? "that lexicon is" : "those lexicons are"} not installed, so ${n === 1 ? "it was" : "they were"} skipped` +
-    ` (npm i ${wanted.map(lexiconPackage).join(" ")}).`;
+    ` (${missingLexiconRemedy(wanted)}).`;
 }
 
 /** Human-readable diagnostic for the zero-lexicon case. */
@@ -372,6 +406,34 @@ async function buildSnapshot(options: AuditCommandOptions, files: string[], isUr
   };
 }
 
+/**
+ * Warnings for the two level-0 changes #2528 makes in the next release, one
+ * release ahead of it (#2525). Neither changes today's report: a truncated walk
+ * is still reported as if it were whole, and TF023 still reads only the root
+ * `.gitignore`.
+ */
+export function walkWarnings(walk: CandidateWalk, target: string): AuditWarning[] {
+  const warnings: AuditWarning[] = [];
+  if (walk.truncated) {
+    warnings.push({
+      message:
+        `the scan of ${target} stopped at ${walk.maxFiles} files, so part of the tree was not audited. ` +
+        "The limit counts every file the walk reaches, not only the ones it audits.",
+      hint:
+        "Raise it with --max-files <n>. From the next release, text and JSON output will also report a truncated scan.",
+    });
+  }
+  for (const change of walk.nestedGitignore) {
+    warnings.push({
+      file: change.path,
+      message: `TF023 reports this path because chant audit reads only the root .gitignore, but ${change.gitignore} ignores it.`,
+      hint:
+        "From the next release chant audit reads every .gitignore between a file and the scan root, and TF023 will no longer report this path.",
+    });
+  }
+  return warnings;
+}
+
 /** Run the audit and produce a rendered result. */
 export async function auditCommand(options: AuditCommandOptions): Promise<AuditCommandResult> {
   const format = options.format ?? "stylish";
@@ -387,6 +449,7 @@ export async function auditCommand(options: AuditCommandOptions): Promise<AuditC
   // render the same way (#1623).
   const plugins = options.plugins ?? (await loadAuditPlugins());
   let candidates: RepoFile[];
+  let warnings: AuditWarning[] = [];
   if (isUrl) {
     try {
       // Fetch the whole repo's candidate files (all lexicons, not just CI) and
@@ -406,8 +469,21 @@ export async function auditCommand(options: AuditCommandOptions): Promise<AuditC
     // One walk, plugin-delegated detection. CI (path), Dockerfiles (name), and
     // Helm charts (bundle) are special-cased by the classifier since content
     // shape alone can't disambiguate them.
-    candidates = collectCandidates(options.path);
+    const walk = walkCandidates(options.path, { maxFiles: options.maxFiles });
+    candidates = walk.files;
+    warnings = walkWarnings(walk, options.path);
+    // #2527's warning release: the converged walk skips git-ignored files and,
+    // inside a project, child projects. Terraform state paths are TF023's own
+    // question and stay out of it. `candidates` is unchanged.
+    await warnDiscoveryChanges({
+      walker: "audit",
+      root: options.path,
+      files: candidates.filter((f) => !isTerraformStatePath(f.path)).map((f) => resolve(options.path, f.path)),
+    });
   }
+  // Only a non-empty list rides on the result, so a run with nothing to warn
+  // about returns exactly the object it did before #2528.
+  const withWarnings = warnings.length > 0 ? { warnings } : {};
   // A local target hands its directory to the classifier, so an input whose
   // path names a directory carries the directory itself (#2217): terraform's
   // parse-to-graph follows a root module's local `module` calls from there. A
@@ -439,14 +515,14 @@ export async function auditCommand(options: AuditCommandOptions): Promise<AuditC
 
   if (plugins.length === 0) {
     const output = format === "json" ? renderNoLexiconsJson(options.path, unclaimed) : renderNoLexicons(options.path, unclaimed);
-    return { success: true, status: "no-lexicons", output, findings: [...secretsFindings, ...wranglerFindings, ...nginxFindings, ...terraformStateFindings], scanned: [], unclaimed, exitCode: NO_LEXICONS_EXIT_CODE, stream: format === "json" ? "stdout" : "stderr" };
+    return { success: true, status: "no-lexicons", output, findings: [...secretsFindings, ...wranglerFindings, ...nginxFindings, ...terraformStateFindings], scanned: [], unclaimed, exitCode: NO_LEXICONS_EXIT_CODE, stream: format === "json" ? "stdout" : "stderr", ...withWarnings };
   }
 
   const missingLexiconNote = missingLexiconHint(unclaimed);
 
   if (inputs.length === 0 && secretsFindings.length === 0 && wranglerFindings.length === 0 && nginxFindings.length === 0 && terraformStateFindings.length === 0) {
     const output = `No auditable files found under ${options.path}.${missingLexiconNote ? ` ${missingLexiconNote}` : ""}`;
-    return { success: true, status: "ok", output, findings: [], scanned: [], unclaimed, exitCode: 0 };
+    return { success: true, status: "ok", output, findings: [], scanned: [], unclaimed, exitCode: 0, ...withWarnings };
   }
 
   let findings: AuditFinding[] = [];
@@ -545,22 +621,20 @@ export async function auditCommand(options: AuditCommandOptions): Promise<AuditC
     } catch (err) {
       return { success: false, output, findings, scanned, exitCode: 1, error: `Failed to write ${options.output}: ${err instanceof Error ? err.message : String(err)}` };
     }
-    return { success: true, status: "ok", output, findings, scanned, unclaimed, exitCode, wroteTo: options.output, suppressedCount: suppressionStats.count };
+    return { success: true, status: "ok", output, findings, scanned, unclaimed, exitCode, wroteTo: options.output, suppressedCount: suppressionStats.count, ...withWarnings };
   }
 
-  return { success: true, status: "ok", output, findings, scanned, unclaimed, exitCode, suppressedCount: suppressionStats.count };
+  return { success: true, status: "ok", output, findings, scanned, unclaimed, exitCode, suppressedCount: suppressionStats.count, ...withWarnings };
 }
 
-/** Print an audit result to stdout. */
+/** Print an audit result to stdout, and its warnings to stderr. */
 export function printAuditResult(result: AuditCommandResult): void {
   if (!result.success) {
     console.error(result.error ?? "Audit failed");
     return;
   }
-  if (result.wroteTo) {
-    console.error(`Wrote report to ${result.wroteTo}`);
-    return;
-  }
-  if (result.stream === "stderr") console.error(result.output);
+  if (result.wroteTo) console.error(`Wrote report to ${result.wroteTo}`);
+  else if (result.stream === "stderr") console.error(result.output);
   else console.log(result.output);
+  for (const w of result.warnings ?? []) console.error(formatWarning(w));
 }

package/src/cli/commands/check-lexicon-examples.ts

@@ -33,6 +33,7 @@
  * validates against its own schemas.
  */
 
+import { lexiconNames as declaredLexiconNames } from "../../lexicon-module";
 import { existsSync, readdirSync } from "fs";
 import { join } from "path";
 import { build, type BuildResult } from "../../build";
@@ -141,7 +142,7 @@ export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBui
       const { config: exampleConfig } = await loadChantConfig(join(examplesDir, entry.name));
       const lexiconNames =
         exampleConfig.lexicons && exampleConfig.lexicons.length > 0
-          ? exampleConfig.lexicons
+          ? declaredLexiconNames(exampleConfig.lexicons)
           : await detectLexicons(files);
       if (lexiconNames.length === 0) {
         results.push({

package/src/cli/commands/doctor.ts

@@ -95,6 +95,9 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
   const lexicons = config?.lexicons as string[] | undefined;
   if (lexicons && Array.isArray(lexicons)) {
     for (const lex of lexicons) {
+      // chant #2520 — a lexicon declared by module path is project source,
+      // not a package `chant update` copies types from.
+      if (typeof lex !== "string") continue;
       const lexDir = join(projectPath, ".chant", "types", `lexicon-${lex}`);
       if (!existsSync(lexDir)) {
         checks.push({ name: `lexicon-${lex}-types`, status: "fail", message: `.chant/types/lexicon-${lex}/ not found — run chant update` });

package/src/cli/commands/import-agents.ts

@@ -23,7 +23,8 @@ import { scanAgentConfigs } from "../../agents/discover";
 import type { AgentRuntime, AgentScope } from "../../agents/types";
 import type { AgentImportOutcome } from "../../agents/importer";
 import type { LexiconPlugin } from "../../lexicon";
-import { loadPlugin } from "../plugins";
+import { loadPlugin, recordProjectLexicons } from "../plugins";
+import { lexiconModulePath, lexiconSourceLabel } from "../../lexicon-module";
 
 /** The lexicon used when `--lexicon` isn't given: the one that models agent workloads. */
 export const DEFAULT_AGENT_LEXICON = "fountain";
@@ -91,18 +92,24 @@ export async function importAgentsCommand(opts: ImportAgentsOptions = {}): Promi
     };
   }
 
+  // chant#2578 — a lexicon the project's chant.config declares by path loads
+  // from that module, so read the declarations before loading the plugin.
+  if (!opts.pluginLoader) await recordProjectLexicons(process.cwd());
+
   let plugin: LexiconPlugin;
   try {
     plugin = await (opts.pluginLoader ?? loadPlugin)(lexiconName);
   } catch (err) {
+    const remedy =
+      lexiconModulePath(lexiconName) !== undefined
+        ? `The ${lexiconName} lexicon is declared by path in chant.config.ts: ${lexiconSourceLabel(lexiconName)}`
+        : `Install it with: npm i @intentius/chant-lexicon-${lexiconName}`;
     return {
       success: false,
       generatedFiles: [],
       summary: { discovered: scan.sites.length, mapped: 0 },
       warnings,
-      error:
-        `Could not load the ${lexiconName} lexicon: ${err instanceof Error ? err.message : String(err)}\n` +
-        `Install it with: npm i @intentius/chant-lexicon-${lexiconName}`,
+      error: `Could not load the ${lexiconName} lexicon: ${err instanceof Error ? err.message : String(err)}\n${remedy}`,
     };
   }
 

package/src/cli/commands/init.ts

@@ -3,7 +3,8 @@ import { join, resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 import { formatSuccess, formatWarning } from "../format";
-import { loadPlugin } from "../plugins";
+import { loadPlugin, recordProjectLexicons } from "../plugins";
+import { lexiconModulePath, lexiconSourceLabel } from "../../lexicon-module";
 import { MCP_CONFIG_FILENAME, detectPackageManager, generateMcpConfig, mcpConfigPath } from "../mcp-config";
 
 /** Read the current chant package version from our own package.json. */
@@ -53,16 +54,27 @@ export interface InitResult {
   warnings: string[];
   /** Error message if failed */
   error?: string;
+  /**
+   * chant#2578 — where the lexicon loads from when the directory's existing
+   * chant.config declares it by path. There is no package to depend on or
+   * install for it.
+   */
+  lexiconModule?: string;
 }
 
 /**
  * Generate package.json content
  */
-function generatePackageJson(lexicon: string, extraScripts?: Record<string, string>): string {
+function generatePackageJson(
+  lexicon: string,
+  extraScripts?: Record<string, string>,
+  lexiconIsPackage = true,
+): string {
   const ver = getChantVersion();
   const dependencies: Record<string, string> = {
     "@intentius/chant": `^${ver}`,
-    [`@intentius/chant-lexicon-${lexicon}`]: `^${ver}`,
+    // chant#2578 — a lexicon declared by path is not a package to depend on.
+    ...(lexiconIsPackage ? { [`@intentius/chant-lexicon-${lexicon}`]: `^${ver}` } : {}),
   };
 
   const pkg = {
@@ -252,6 +264,17 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     mkdirSync(targetDir, { recursive: true });
   }
 
+  // chant#2578 — `--force` into an existing project keeps its chant.config.
+  // When that config declares the lexicon by path, it loads from the module
+  // and there is no package to depend on or install.
+  let lexiconModule: string | undefined;
+  if (existsSync(join(targetDir, "chant.config.ts")) || existsSync(join(targetDir, "chant.config.json"))) {
+    await recordProjectLexicons(targetDir);
+    if (lexiconModulePath(options.lexicon) !== undefined) {
+      lexiconModule = lexiconSourceLabel(options.lexicon, targetDir);
+    }
+  }
+
   // Load plugin early to get template set (used for scripts + source files)
   let templateSet: import("../../lexicon").InitTemplateSet | undefined;
   try {
@@ -272,7 +295,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   // Generate package.json
   writeIfNotExists(
     join(targetDir, "package.json"),
-    generatePackageJson(options.lexicon, templateSet?.scripts),
+    generatePackageJson(options.lexicon, templateSet?.scripts, lexiconModule === undefined),
     "package.json",
     createdFiles,
     warnings,
@@ -361,29 +384,32 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Scaffold .chant/types/lexicon-{lexicon}/ stub
-  const lexiconTypesDir = join(targetDir, ".chant", "types", `lexicon-${options.lexicon}`);
-  mkdirSync(lexiconTypesDir, { recursive: true });
+  // Scaffold .chant/types/lexicon-{lexicon}/ stub. A lexicon declared by path
+  // is imported by its path, so it has no package name to stub (chant#2578).
+  if (lexiconModule === undefined) {
+    const lexiconTypesDir = join(targetDir, ".chant", "types", `lexicon-${options.lexicon}`);
+    mkdirSync(lexiconTypesDir, { recursive: true });
 
-  writeIfNotExists(
-    join(lexiconTypesDir, "package.json"),
-    JSON.stringify(
-      { name: `@intentius/chant-lexicon-${options.lexicon}`, version: "0.0.0", types: "./index.d.ts" },
-      null,
-      2,
-    ),
-    `.chant/types/lexicon-${options.lexicon}/package.json`,
-    createdFiles,
-    warnings,
-  );
+    writeIfNotExists(
+      join(lexiconTypesDir, "package.json"),
+      JSON.stringify(
+        { name: `@intentius/chant-lexicon-${options.lexicon}`, version: "0.0.0", types: "./index.d.ts" },
+        null,
+        2,
+      ),
+      `.chant/types/lexicon-${options.lexicon}/package.json`,
+      createdFiles,
+      warnings,
+    );
 
-  writeIfNotExists(
-    join(lexiconTypesDir, "index.d.ts"),
-    `// Lexicon type stubs — run "chant update" to sync full types\nexport {};\n`,
-    `.chant/types/lexicon-${options.lexicon}/index.d.ts`,
-    createdFiles,
-    warnings,
-  );
+    writeIfNotExists(
+      join(lexiconTypesDir, "index.d.ts"),
+      `// Lexicon type stubs — run "chant update" to sync full types\nexport {};\n`,
+      `.chant/types/lexicon-${options.lexicon}/index.d.ts`,
+      createdFiles,
+      warnings,
+    );
+  }
 
   // Generate the project's MCP config. It lands in the directory init was
   // pointed at, like everything else init produces, and at the path
@@ -425,6 +451,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     success: true,
     createdFiles,
     warnings,
+    ...(lexiconModule !== undefined ? { lexiconModule } : {}),
   };
 }
 
@@ -453,6 +480,11 @@ export async function printInitResult(
 
   console.log("");
 
+  if (result.lexiconModule !== undefined) {
+    console.log(`The lexicon loads from ${result.lexiconModule}, as chant.config.ts declares. It has no package to install.`);
+    console.log("");
+  }
+
   const pm = detectPackageManager(options?.cwd);
 
   // Interactive install prompt

package/src/cli/commands/lint.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
 import { lintCommand, isLintRule, loadPluginRules, LEXICON_RESOLUTION_RULE_ID, type LintOptions } from "./lint";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { mkdir, rm, writeFile } from "node:fs/promises";
@@ -6,6 +6,7 @@ import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { params, setBuildParams } from "../../params";
+import { resetDiscoveryWarnings } from "../../discovery/convergence";
 
 describe("lintCommand", () => {
   let testDir: string;
@@ -641,6 +642,62 @@ describe("lintCommand — git-ignored files are not linted", () => {
   });
 });
 
+/**
+ * chant#2527's warning release for lint: a child project is linted today and
+ * stops the converged walk next release; a scan root that is itself ignored
+ * lints nothing today and is linted next release. Both still lint exactly
+ * what they did, with a warning naming the files and the glob.
+ */
+describe("lintCommand — files the converged walker reads differently (#2527)", () => {
+  let testDir: string;
+  let stderr: string[];
+  const EVL003 = `const t = { a: 1 };\nexport function g(k: string) { return t[k]; }\n`;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-lint-2527-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+    process.env.NO_COLOR = "1";
+    resetDiscoveryWarnings();
+    stderr = [];
+    vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => void stderr.push(args.join(" ")));
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await rm(testDir, { recursive: true, force: true });
+    delete process.env.NO_COLOR;
+  });
+
+  test("a nested child project is still linted, and named with its include glob", async () => {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ knowledge: { dir: "knowledge" } }));
+    await writeFile(join(testDir, "index.ts"), `export const x = 1;\n`);
+    await mkdir(join(testDir, "stacks", "east"), { recursive: true });
+    await writeFile(join(testDir, "stacks", "east", "chant.config.ts"), `export default {};\n`);
+    await writeFile(join(testDir, "stacks", "east", "east.ts"), EVL003);
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+    expect(result.diagnostics.some((d) => d.file.includes("east.ts") && d.ruleId === "EVL003")).toBe(true);
+    const warning = stderr.find((l) => l.startsWith("warning: chant lint under"));
+    expect(warning).toContain("  stacks/east/chant.config.ts, stacks/east/east.ts: stacks/east/ is a child project");
+    expect(warning).toContain('To keep reading them after the change, add "stacks/east" to include in');
+  });
+
+  test("an ignored scan root lints nothing today, and says it will be linted", async () => {
+    execFileSync("git", ["init", "-q"], { cwd: testDir });
+    await writeFile(join(testDir, ".gitignore"), "/carveout/\n");
+    await mkdir(join(testDir, "carveout", "src"), { recursive: true });
+    await writeFile(join(testDir, "carveout", "src", "main.ts"), EVL003);
+
+    const result = await lintCommand({ path: join(testDir, "carveout", "src"), format: "stylish" });
+    expect(result.diagnostics.filter((d) => d.file.includes("main.ts"))).toHaveLength(0);
+    const warning = stderr.find((l) => l.startsWith("warning: chant lint under"));
+    expect(warning).toContain("  main.ts: ");
+    expect(warning).toContain("is itself git-ignored, so today nothing under it is linted. ");
+    expect(warning).toContain("so the files under it are linted.");
+    expect(warning).toContain('To keep skipping it, add "**" to exclude in');
+  });
+});
+
 /**
  * chant #2222 (epic #2215 sub-issue 7) — `chant lint` used to print "No
  * problems found" and exit 0 on a project whose declared lexicon could not be