@canonical/pragma-cli 0.31.0 → 0.33.0

package/src/testing/behavioral/docExamples.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Doc-example tests: every `pragma` command shown in the published README and
+ * the getting-started guide must be REAL. Two tiers, both driven off the live
+ * grammar (never a hand-copied list):
+ *
+ * - Tier 1 (grammar) — every extracted command's noun/verb resolves and every
+ *   `--flag` is one the verb (or the global/mutation set) declares. Storeless.
+ * - Tier 2 (execution) — a curated set of read commands is PARSED through the
+ *   real CLI grammar (so the param bag is derived from the documented string,
+ *   never hand-supplied) and then booted against the canonical fixture graph
+ *   and asserted to exit 0, proving the documented reads run, not just parse.
+ */
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { capabilities } from "../../capabilities/index.js";
+import {
+  executeVerb,
+  extractParams,
+} from "../../kernel/project/cli/dispatch.js";
+import {
+  nounVerbMap,
+  resolveUnknownCommand,
+} from "../../kernel/project/cli/suggest.js";
+import { kebabCase } from "../../kernel/spec/emitSurface.js";
+import type { VerbSpec } from "../../kernel/spec/types.js";
+import {
+  CANONICAL_CONFIG,
+  CANONICAL_TTL,
+} from "../fixtures/graph/canonical.js";
+import { extractPragmaCommands } from "../helpers/extractSnippets.js";
+import { bootFixtureRuntime } from "../helpers/fixtureGraph.js";
+import { projectCli } from "../helpers/projectCli.js";
+
+/** Read a shipped doc exactly as a reader (or lychee) would. */
+function readDoc(relPath: string): string {
+  return readFileSync(
+    fileURLToPath(new URL(relPath, import.meta.url)),
+    "utf-8",
+  );
+}
+
+/** Every hand-written doc whose fenced `pragma` examples must be real grammar. */
+const HAND_WRITTEN_DOCS = [
+  "../../../README.md",
+  "../../../docs/getting-started.md",
+  "../../../docs/mcp-integration.md",
+  "../../../docs/config-model.md",
+  "../../../docs/architecture.md",
+  "../../../docs/skills.md",
+];
+
+const commands = HAND_WRITTEN_DOCS.flatMap((doc) =>
+  extractPragmaCommands(readDoc(doc)),
+);
+
+/** Every non-hidden verb, flattened from the live catalog. */
+const allVerbs: VerbSpec[] = capabilities
+  .flatMap((module) => [...module.verbs])
+  .filter((verb) => !verb.hidden);
+const nouns = nounVerbMap(allVerbs);
+
+/** `"noun verb"` (or `"noun"` for a self-verb) → the runnable spec. */
+const specByKey = new Map<string, VerbSpec>();
+for (const verb of allVerbs) {
+  const sub = verb.path[1];
+  specByKey.set(
+    sub === undefined ? verb.path[0] : `${verb.path[0]} ${sub}`,
+    verb,
+  );
+}
+
+/** Flags valid on every command, beyond a verb's own declared flags. */
+const AMBIENT_FLAGS = new Set([
+  "--llm",
+  "--format",
+  "--verbose",
+  "--detail",
+  "--dry-run",
+  "--undo",
+  "--yes",
+  "--help",
+  "--version",
+]);
+
+/** The positional tokens of a command (drops `pragma` and every `-`-prefixed token). */
+function readPositionals(command: string): string[] {
+  return command
+    .split(/\s+/)
+    .slice(1)
+    .filter((token) => !token.startsWith("-"));
+}
+
+/** Resolve a command's `VerbSpec` from its positionals (verb pair, else self-verb). */
+function resolveSpec(positionals: readonly string[]): VerbSpec | undefined {
+  const noun = positionals.at(0);
+  const verb = positionals.at(1);
+  if (noun === undefined) return undefined;
+  const paired =
+    verb !== undefined ? specByKey.get(`${noun} ${verb}`) : undefined;
+  return paired ?? specByKey.get(noun);
+}
+
+/** The set of flags a verb accepts: its own declared flags plus the ambient set. */
+function collectValidFlags(verb: VerbSpec): Set<string> {
+  const flags = new Set(AMBIENT_FLAGS);
+  for (const param of verb.params) {
+    if (!param.positional) flags.add(`--${kebabCase(param.name)}`);
+  }
+  return flags;
+}
+
+describe("doc examples — Tier 1: every documented command is grammatical", () => {
+  it("extracts commands from the docs", () => {
+    // A guard against a broken extractor silently passing everything else.
+    expect(commands.length).toBeGreaterThan(0);
+  });
+
+  it("resolves every command's noun and verb", () => {
+    for (const command of commands) {
+      const unknown = resolveUnknownCommand(readPositionals(command), nouns);
+      expect(unknown, `unresolved command: ${command}`).toBeUndefined();
+    }
+  });
+
+  it("uses only flags the verb or the ambient set declares", () => {
+    for (const command of commands) {
+      const spec = resolveSpec(readPositionals(command));
+      expect(spec, `no spec for: ${command}`).toBeDefined();
+      if (!spec) continue;
+      const allowed = collectValidFlags(spec);
+      for (const token of command.split(/\s+/)) {
+        if (!token.startsWith("--")) continue;
+        const flag = token.split("=").at(0) ?? token;
+        expect(allowed.has(flag), `unknown flag ${flag} in: ${command}`).toBe(
+          true,
+        );
+      }
+    }
+  });
+});
+
+/**
+ * One curated read: its documented form, the verb key it must route to, and the
+ * param bag the real parser must derive from {@link ReadCase.command} (the
+ * oracle Tier 2 asserts the parse against before executing).
+ */
+interface ReadCase {
+  readonly command: string;
+  readonly key: string;
+  readonly params: Record<string, unknown>;
+}
+
+/** Reads that can run storelessly or against the canonical fixture graph. */
+const READ_CASES: readonly ReadCase[] = [
+  { command: "pragma block list", key: "block list", params: {} },
+  {
+    command: "pragma block lookup Button",
+    key: "block lookup",
+    params: { name: ["Button"] },
+  },
+  { command: "pragma standard list", key: "standard list", params: {} },
+  { command: "pragma token list", key: "token list", params: {} },
+  { command: "pragma tier list", key: "tier list", params: {} },
+  { command: "pragma ontology list", key: "ontology list", params: {} },
+  { command: "pragma config show", key: "config show", params: {} },
+  { command: "pragma sources status", key: "sources status", params: {} },
+  { command: "pragma doctor", key: "doctor", params: {} },
+  { command: "pragma info", key: "info", params: {} },
+  { command: "pragma capabilities", key: "capabilities", params: {} },
+  { command: "pragma colophon", key: "colophon", params: {} },
+];
+
+const NO_MUTATION = { dryRun: false, undo: false, yes: false };
+
+/**
+ * Thrown by the capture hook to halt a parse at the resolved verb — before the
+ * real dispatch (and its runtime boot) fires — carrying the routed path plus the
+ * Commander-parsed operands and options.
+ */
+class ParsedCommand extends Error {
+  constructor(
+    readonly path: readonly string[],
+    readonly positionals: string[],
+    readonly opts: Record<string, unknown>,
+  ) {
+    super("parsed");
+  }
+}
+
+/**
+ * Parse a documented `pragma …` line through the REAL CLI grammar and return the
+ * verb it routes to plus the coerced param bag {@link extractParams} derives —
+ * WITHOUT running it. A `preAction` hook captures the resolved command and
+ * throws before its action, so no runtime boots. Deriving the bag from the
+ * STRING (rather than hand-supplying it) is what closes the Tier-2 gap: a
+ * documented positional in the wrong slot now yields a different bag, instead of
+ * a hand-fed bag masking the mistake.
+ *
+ * @param command - The documented `pragma …` command line.
+ * @returns The routed verb key, its spec, and the parser-derived param bag.
+ */
+async function parseDocumented(
+  command: string,
+): Promise<{ key: string; spec: VerbSpec; params: Record<string, unknown> }> {
+  const program = projectCli(capabilities);
+  program.hook("preAction", (_root, action) => {
+    const parentName = action.parent?.name();
+    const routed =
+      parentName !== undefined && parentName !== "pragma"
+        ? [parentName, action.name()]
+        : [action.name()];
+    throw new ParsedCommand(routed, [...action.args], action.opts());
+  });
+
+  const argv = command.split(/\s+/).slice(1); // drop the leading `pragma`
+  try {
+    await program.parseAsync(argv, { from: "user" });
+  } catch (error) {
+    if (!(error instanceof ParsedCommand)) throw error;
+    const key = error.path.join(" ");
+    const spec = specByKey.get(key);
+    if (spec === undefined) {
+      throw new Error(`documented command routed to unknown verb: ${key}`);
+    }
+    return {
+      key,
+      spec,
+      params: extractParams(spec.params, error.positionals, error.opts),
+    };
+  }
+  throw new Error(`documented command reached no verb action: ${command}`);
+}
+
+describe("doc examples — Tier 2: curated read commands run green", () => {
+  let fixture: Awaited<ReturnType<typeof bootFixtureRuntime>> | undefined;
+  const documented = new Set(commands);
+
+  beforeAll(async () => {
+    fixture = await bootFixtureRuntime({
+      ttl: CANONICAL_TTL,
+      config: CANONICAL_CONFIG,
+    });
+  });
+
+  afterAll(async () => {
+    await fixture?.dispose();
+  });
+
+  for (const readCase of READ_CASES) {
+    it(`\`${readCase.command}\` parses to its verb and exits 0`, async () => {
+      expect(
+        documented.has(readCase.command),
+        `not documented: ${readCase.command}`,
+      ).toBe(true);
+
+      // Derive the verb + param bag from the DOCUMENTED string via the real
+      // grammar, then assert both against the oracle: a mis-slotted positional
+      // would route elsewhere or yield a different bag, failing here.
+      const parsed = await parseDocumented(readCase.command);
+      expect(parsed.key, `routed to the wrong verb: ${readCase.command}`).toBe(
+        readCase.key,
+      );
+      expect(
+        parsed.params,
+        `parsed bag ≠ expected for: ${readCase.command}`,
+      ).toEqual(readCase.params);
+
+      if (!fixture) return;
+      const outcome = await executeVerb(
+        parsed.spec,
+        parsed.params,
+        NO_MUTATION,
+        fixture.runtime,
+      );
+      expect(
+        outcome.exitCode,
+        `${readCase.command} → ${outcome.stderr ?? ""}`,
+      ).toBe(0);
+    });
+  }
+});

package/src/testing/behavioral/errorMatrix.mcp.test.ts

@@ -0,0 +1,120 @@
+/**
+ * B3 — the error/recovery MATRIX, fixture-backed half: per-read-noun lookup
+ * misses, an empty-filtered list, and `ontology_show`'s bad-prefix error.
+ * Parameterized over `liveReadSurface.ts` — never a hard-coded noun.
+ *
+ * TWO ADAPTATIONS from the plan's wording, both verified empirically against
+ * the live kernel (not assumed):
+ *
+ * 1. `<noun>_lookup` on a SINGLE or ALL-unknown batch FAILS the call
+ *    (`ok:false, error.code==="ENTITY_NOT_FOUND"`) — `makeLookupRun` throws on
+ *    a total miss; only a PARTIAL batch reports the miss while staying
+ *    `ok:true` (that shape is B1's job, `agentSession.mcp.test.ts`). See
+ *    PARITY_GAPS `single-lookup-miss-fails-batch-partial-reports`.
+ * 2. A filtered list narrowed to zero rows is `{ok:true, data:[], meta:{}}` —
+ *    there is no `meta.count` field on any read envelope (`dispatch.ts`
+ *    always renders reads with `meta:{}`). See PARITY_GAPS
+ *    `read-meta-always-empty`.
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { capabilities } from "../../capabilities/index.js";
+import {
+  ALL_VISIBLE_CONFIG,
+  CANONICAL_TTL,
+} from "../fixtures/graph/canonical.js";
+import {
+  bootFixtureRuntime,
+  type FixtureGraph,
+} from "../helpers/fixtureGraph.js";
+import { projectMcp } from "../helpers/projectMcp.js";
+import { listVerbs, lookupVerbs } from "./liveReadSurface.js";
+
+/**
+ * List verbs with a STRING or ENUM (narrowable, non-boolean) flag — e.g.
+ * `standard_list --category`. Excludes boolean escape hatches like `block
+ * list --all-tiers`, which reject a string value at the schema layer rather
+ * than narrowing to an empty result.
+ */
+const filteredListVerbs = listVerbs
+  .map((v) => {
+    const flag = v.spec.params.find(
+      (p) => !p.positional && (p.kind === "string" || p.kind === "enum"),
+    );
+    return flag
+      ? { noun: v.noun, tool: v.tool as string, param: flag.name }
+      : undefined;
+  })
+  .filter(
+    (v): v is { noun: string; tool: string; param: string } => v !== undefined,
+  );
+
+let fixture: FixtureGraph;
+let mcp: Awaited<ReturnType<typeof projectMcp>>;
+
+beforeAll(async () => {
+  fixture = await bootFixtureRuntime({
+    ttl: CANONICAL_TTL,
+    config: ALL_VISIBLE_CONFIG,
+  });
+  mcp = await projectMcp(capabilities, fixture.cwd);
+});
+
+afterAll(async () => {
+  await mcp.cleanup();
+  await fixture.dispose();
+});
+
+describe("lookup miss — total miss fails the call (B3, adapted)", () => {
+  it.each(
+    lookupVerbs.map((v) => v.noun),
+  )("%s_lookup: a single unknown name fails with ENTITY_NOT_FOUND", async (noun) => {
+    const result = await mcp.callTool(`${noun}_lookup`, {
+      name: ["zzz-definitely-not-a-real-entity"],
+    });
+    expect(result.ok).toBe(false);
+    expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
+  });
+
+  it.each(
+    lookupVerbs.map((v) => v.noun),
+  )("%s_lookup: an all-unknown batch ALSO fails (not a partial report)", async (noun) => {
+    const result = await mcp.callTool(`${noun}_lookup`, {
+      name: ["zzz-nope-one", "zzz-nope-two"],
+    });
+    expect(result.ok).toBe(false);
+    expect((result.error as { code: string }).code).toBe("ENTITY_NOT_FOUND");
+  });
+});
+
+describe("list — a narrowing filter to zero rows is a plain empty list (B3, adapted)", () => {
+  it("has at least one filtered list verb to sweep", () => {
+    // A guard, not a no-op: if this ever goes empty the sweep below silently
+    // covers nothing, which would be a silent coverage loss worth noticing.
+    expect(filteredListVerbs.length).toBeGreaterThan(0);
+  });
+
+  it.each(
+    filteredListVerbs,
+  )("$tool: an unmatched filter value narrows to [] (no EMPTY_RESULTS)", async ({
+    tool,
+    param,
+  }) => {
+    const result = await mcp.callTool(tool, {
+      [param]: "zzz-definitely-not-a-real-value",
+    });
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual([]);
+    expect(result.meta).toEqual({});
+  });
+});
+
+describe("ontology_show — an unknown prefix is INVALID_INPUT (B3)", () => {
+  it("fails with the enumerated valid prefixes", async () => {
+    const result = await mcp.callTool("ontology_show", { prefix: "nope" });
+    expect(result.ok).toBe(false);
+    const error = result.error as { code: string; validOptions: string[] };
+    expect(error.code).toBe("INVALID_INPUT");
+    expect(error.validOptions).toContain("ds");
+  });
+});

package/src/testing/behavioral/errorMatrix.storeless.test.ts

@@ -0,0 +1,124 @@
+/**
+ * A8 — the error/recovery MATRIX (shape), storeless half.
+ *
+ * `renderError{Plain,Llm,Json}` (`kernel/error/renderError.ts`) had NO dedicated
+ * test before this file (confirmed — only the `PragmaError` factories and the
+ * `recovery.cli` D5 invariant are unit-tested; the render layer's SECTION
+ * handling — "Did you mean?" / "Active filters:" / "Valid options:" /
+ * "Run `…`" / "Recovery: `…`" — was untested). This sweeps a representative
+ * MATRIX of error shapes (suggestions, filters, validOptions, a CLI recovery,
+ * an MCP-only recovery) across plain/llm/json, then grounds it with one REAL
+ * spawn (`skill lookup <unknown>`) so the matrix isn't purely synthetic.
+ *
+ * The `error.filters` shape has no LIVE trigger among PR3's read nouns yet (see
+ * PARITY_GAPS `no-empty-hook-on-free-filter`) — swept here with a directly
+ * constructed error so the render layer's handling of it is proven regardless.
+ */
+
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { PragmaError } from "../../kernel/error/PragmaError.js";
+import {
+  renderErrorJson,
+  renderErrorLlm,
+  renderErrorPlain,
+} from "../../kernel/error/renderError.js";
+import { freshXdgEnv, runCli } from "../helpers/runCli.js";
+
+const MATRIX: readonly {
+  readonly label: string;
+  readonly error: PragmaError;
+}[] = [
+  {
+    label: "suggestions",
+    error: PragmaError.notFound("block", "Buton", {
+      suggestions: ["Button"],
+    }),
+  },
+  {
+    label: "filters",
+    error: PragmaError.emptyResults("standard", {
+      filters: { category: "nonexistent" },
+    }),
+  },
+  {
+    label: "validOptions",
+    error: PragmaError.invalidInput("format", "yaml", {
+      // The live `--format` set (mirrors bin.ts): plain, llm, json.
+      validOptions: ["plain", "llm", "json"],
+    }),
+  },
+  {
+    label: "recovery.cli",
+    error: PragmaError.notFound("skill", "docs", {
+      recovery: {
+        message: "List discovered skills.",
+        cli: "pragma skill list",
+      },
+    }),
+  },
+  {
+    label: "recovery (mcp-only, no cli)",
+    error: PragmaError.storeUnavailable("no lock", {
+      recovery: { message: "Please report this issue." },
+    }),
+  },
+];
+
+describe("error/recovery matrix — render shapes (A8, storeless)", () => {
+  it.each(MATRIX)("plain renders the $label section", ({ error }) => {
+    const text = renderErrorPlain(error);
+    expect(text).toContain(`Error: ${error.message}`);
+    if (error.suggestions.length > 0) expect(text).toContain("Did you mean?");
+    if (error.filters) expect(text).toContain("Active filters:");
+    if (error.validOptions) expect(text).toContain("Valid options:");
+    if (error.recovery) {
+      // The human guidance is ALWAYS shown — even when a runnable `cli` is
+      // present (it used to be dropped, losing the WHY).
+      expect(text).toContain(error.recovery.message);
+      if (error.recovery.cli)
+        expect(text).toContain(`Run \`${error.recovery.cli}\``);
+    }
+  });
+
+  it.each(MATRIX)("llm renders the $label section", ({ error }) => {
+    const text = renderErrorLlm(error);
+    expect(text).toContain(`## Error: ${error.code}`);
+    if (error.suggestions.length > 0) expect(text).toContain("Suggestions:");
+    if (error.filters) expect(text).toContain("Filters:");
+    if (error.validOptions) expect(text).toContain("Valid options:");
+    if (error.recovery) {
+      expect(text).toContain(`Recovery: ${error.recovery.message}`);
+      if (error.recovery.cli)
+        expect(text).toContain(`\`${error.recovery.cli}\``);
+    }
+  });
+
+  it.each(MATRIX)("json renders the failure envelope for $label", ({
+    error,
+  }) => {
+    const envelope = JSON.parse(renderErrorJson(error)) as {
+      ok: boolean;
+      error: { code: string };
+    };
+    expect(envelope.ok).toBe(false);
+    expect(envelope.error.code).toBe(error.code);
+  });
+});
+
+describe("error/recovery matrix — grounded in a real spawn (A8, e2e)", () => {
+  it("skill lookup <unknown> renders suggestions + recovery on stderr", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pragma-errmatrix-skill-"));
+    const result = runCli(["skill", "lookup", "docz"], {
+      cwd,
+      // Force plain (not the piped-stdout auto-llm default) — this test grounds
+      // the PLAIN render shape; llm/json are already covered above.
+      env: { ...freshXdgEnv(), XDG_DATA_HOME: cwd, PRAGMA_NO_AUTO_LLM: "1" },
+    });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("Error:");
+    expect(result.stderr).toContain("Run `pragma skill list`");
+  });
+});

package/src/testing/behavioral/exitCodes.e2e.test.ts

@@ -0,0 +1,53 @@
+/**
+ * A4 — the 4-code exit covenant, observed through the REAL binary.
+ *
+ * `mapExitCode`'s table is PR1-protected (`kernel/project/cli/exitCodes.test.ts`,
+ * unit level). This is the spawn-observed pin: one representative real command
+ * per code, through the actual process exit path (`bin.ts`'s catch ladder →
+ * `dispatch`/`handleProgramError` → `process.exitCode`).
+ *
+ * DIVERGENCE NOTE (kept from the plan, verified against `exitCodes.ts`): v2
+ * COLLAPSED the old shell's 6-code exit map (NOT_FOUND=1, EMPTY=2,
+ * INVALID/AMBIGUOUS=3, CONFIG=4, STORE=5, INTERNAL=127) into 4 codes — success,
+ * a generic runtime failure (1), a usage failure (2), and an unavailable store
+ * (3). This test pins v2's table, not the old one.
+ */
+
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runCli } from "../helpers/runCli.js";
+
+describe("exit-code covenant, spawn-observed (A4, e2e)", () => {
+  it("0 — success", () => {
+    expect(runCli(["info"]).exitCode).toBe(0);
+  });
+
+  it("1 — runtime failure (entity not found)", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pragma-exit1-"));
+    const result = runCli(["skill", "lookup", "does-not-exist"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain("not found");
+  });
+
+  it("2 — usage failure (invalid input)", () => {
+    const result = runCli(["--format", "yaml", "info"]);
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain('Invalid format "yaml"');
+  });
+
+  it("3 — store unavailable (configured packages, never built)", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pragma-exit3-"));
+    // A pragma.config.ts with custom `packages` flips `origins.packages` to
+    // "project" — with no `pragma.lock.json`, resolveSources refuses to boot
+    // (no network probing) rather than fall back to the embedded pack.
+    writeFileSync(
+      join(cwd, "pragma.config.ts"),
+      'export default { packages: [{ name: "never-built", source: "file:///nonexistent" }] };\n',
+    );
+    const result = runCli(["block", "list"], { cwd });
+    expect(result.exitCode).toBe(3);
+    expect(result.stderr).toContain("sources update");
+  });
+});

package/src/testing/behavioral/firstRun.e2e.test.ts

@@ -0,0 +1,40 @@
+/**
+ * A1 — first-run onboarding, observed through the real compiled binary.
+ *
+ * Unit mechanics (`ensureFirstRun`/`firstRunTask`) are PR1-protected
+ * (`kernel/config/firstRun.test.ts`); this is the e2e pin: a fresh XDG config
+ * home produces the greeting on STDERR (never stdout — command output must stay
+ * uncorrupted), seeds `config.json`, and a second run is silent.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { freshXdgEnv, runCli } from "../helpers/runCli.js";
+
+describe("first-run onboarding (A1, e2e)", () => {
+  it("greets on stderr, seeds config.json, and stays silent on the second run", () => {
+    const env = freshXdgEnv();
+    const configPath = join(env.XDG_CONFIG_HOME, "pragma", "config.json");
+
+    const first = runCli(["info"], {
+      env: { ...env, PRAGMA_NO_AUTO_LLM: "1" },
+    });
+    expect(first.exitCode).toBe(0);
+    expect(first.stderr).toContain("Hello!");
+    expect(first.stderr).toContain("pre-release");
+    expect(first.stderr).toContain(configPath);
+    // Command output stays on stdout, untouched by the greeting.
+    expect(first.stdout).not.toContain("Hello!");
+    expect(first.stdout).toContain("pragma v");
+
+    expect(existsSync(configPath)).toBe(true);
+    expect(readFileSync(configPath, "utf-8")).toBe("{}\n");
+
+    const second = runCli(["info"], {
+      env: { ...env, PRAGMA_NO_AUTO_LLM: "1" },
+    });
+    expect(second.exitCode).toBe(0);
+    expect(second.stderr).toBe("");
+  });
+});