@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/kernel/completion/entitySource.ts

@@ -4,97 +4,104 @@
  * browser (`info`, `doctor`, MCP prompts, the resource provider) shares.
  *
  * {@link indexCompletionEnv} is the one source-dispatched reader wired at the
- * `__complete` fast path (bin) and the `__complete` verb. It resolves five
+ * `__complete` fast path (bin) and the `__complete` verb. It resolves three
  * storeless sources — all disk-readable, never a store/SPARQL:
- * - `index`    → the active pack's `index.json` entity names of a prefixed type.
+ * - `index`    → the active pack's `index.json`, filtered by a prefixed `type`
+ *                and read from the declared `field` (`name` by default).
  * - `skills`   → SKILL.md names via {@link discoverSkills} (filesystem walk).
- * - `prompts`  → the pack index's `ds:Prompt` entities (`label || name`).
- * - `tiers`    → the pack index's `ds:Tier` entities (their `ds:name`, else
- *                `label ?? name` when the index carries no `ds:name`).
  * - `prefixes` → the pack index's prefixes ∪ the default display prefixes.
  *
+ * There is no per-family source. An entity family IS a `type` filter plus the
+ * field that family is addressed by, and both are declared at the verb, so this
+ * module names no entity type at all.
+ *
  * The index is loaded once (lazy `readFileSync` + plain `JSON.parse` — never a
  * store, facade, config evaluator, or zod schema; any I/O or parse error
- * degrades to `[]`) and shared across the index/prompts/tiers/prefixes sources;
+ * degrades to `[]`) and shared across the index and prefixes sources;
  * the skills walk is memoized to one walk per `__complete` process.
  * {@link createIndexEntityReader} exposes the index read for the storeless
  * behavioural/safety tests; {@link emptyNameSource} is the default (no names).
  *
  * {@link readPackIndex} and {@link entityTotal} expose the same storeless read
- * to `info`/`doctor` and the resource surfaces. Everything here relies only on
- * the FROZEN `{ name, type }` index minimum (plus optional enrichment like
- * `label`/`altNames`), so the index can grow without breaking completion.
+ * to `info`/`doctor` and the resource surfaces — but those callers are NOT on
+ * the fast path, so `readPackIndex` takes the boot decision rather than
+ * re-deriving one. Everything here relies only on the FROZEN `{ name, type }`
+ * index minimum (plus optional enrichment like `label`/`altNames`), so the
+ * index can grow without breaking completion.
  *
  * Storeless-graph notes:
  * - The embedded fallback is read from `pack.index.generated` — its OWN
  *   generated module (only the index string) — so the storeless `__complete`
- *   path never pulls the n-quads/schema/manifest strings that live in
- *   `pack.generated`.
- * - The pack-cache path is INLINED here rather than imported from
- *   `kernel/runtime/paths` — that module reaches `kernel/config`, which the
- *   storeless-guarantee test (`safety.test.ts`) forbids on the completion
- *   import graph. The two lines of XDG resolution are duplicated on purpose to
- *   keep the fast path free of the config layer; `PackIndex`/`PackIndexEntity`
- *   are imported type-only, so no zod schema is loaded at runtime.
- * - `discoverSkills` (`node:fs/os/path` only) and `DEFAULT_PREFIX_MAP` (a pure
- *   const) are the only new edges — both leaf-clean, so the fast path stays free
- *   of boot/config/store/zod. The `ds:Prompt`/`ds:Tier` filters are INLINED
- *   (importing `prompts/source.ts` would cycle back into this module).
+ *   path never EVALUATES the n-quads/schema/manifest strings that live in
+ *   `pack.generated`. Under the compiled binary it did not avoid PARSING them
+ *   either — one emitted script meant the whole embed was parsed at process
+ *   start on every invocation (~+25 ms, measured on `--version`; BUDGETS.md
+ *   records it), and the split bought only that a completion never allocated
+ *   the 1.87 MB. Shipping per-module output changed that: `pack.generated` is
+ *   a separate module the fast path never imports, so it is no longer parsed
+ *   at all there. The split now buys both.
+ * - The active pack is resolved through `kernel/runtime/paths` — a LEAF module
+ *   (node builtins only) that shares the pointer read with `resolveSources`.
+ *   `resolveSources` itself is unreachable from here: it pulls the graphpack
+ *   manifest schema (zod), which `safety.test.ts` forbids on this graph, and
+ *   `origins.packs` needs the config evaluator. So {@link loadActiveIndex}
+ *   implements only the POINTER half of the decision table — pointer → that
+ *   pack (else nothing), no pointer → the embedded snapshot. It cannot tell a
+ *   fresh install from a project that declared its own packs and never built
+ *   them, so a `__complete` in the latter still offers the snapshot's names.
+ *   That is the price of a config-free fast path, and it is bounded to
+ *   completion candidates: every read, and every surface that takes the
+ *   decision, refuses. `PackIndex`/`PackIndexEntity` are imported type-only, so
+ *   no zod schema is loaded at runtime.
+ * - `discoverSkills` (`node:fs/os/path` only) and `DEFAULT_PREFIX_MAP` (whose
+ *   domain half the distribution declares) are the only new edges — both
+ *   leaf-clean, so the fast path stays free of boot/config/store/zod.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { discoverSkills } from "../../capabilities/skill/discover.js";
 // Inlined embedded index — its OWN generated module (only the index string), so
 // the storeless `__complete` path never pulls the n-quads/schema/manifest
 // strings that live in `pack.generated.ts`.
-import { DEFAULT_PREFIX_MAP } from "../render/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../render/index.js";
 import { indexJson as EMBEDDED_INDEX_JSON } from "../runtime/graphpack/embedded/pack.index.generated.js";
 import type { PackIndex, PackIndexEntity } from "../runtime/graphpack/types.js";
-import type { CompletionSourceRef } from "../spec/types.js";
+import { packDir, readActivePack } from "../runtime/paths.js";
+import type { SourcesDecision } from "../runtime/resolveSources.js";
+import type { CompletionField, CompletionSourceRef } from "../spec/types.js";
 import type { CompletionEnv } from "./types.js";
 
-/** The prefixed KG type every prompt entity carries (inlined; no cycle). */
-const PROMPT_TYPE = "ds:Prompt";
-/** The prefixed KG type every tier entity carries (inlined; no cycle). */
-const TIER_TYPE = "ds:Tier";
-
 /** The default name source: no index tier, so no candidates. */
 export const emptyNameSource: CompletionEnv["names"] = () => [];
 
-/** The committed project lock basename (mirrors `kernel/runtime/paths`). */
-const LOCK_BASENAME = "pragma.lock.json";
 /** The pack index filename (kept local so this path never imports the zod schema). */
 const INDEX_FILE = "index.json";
 
 /**
- * `$XDG_CACHE_HOME/pragma/packs/<hash>` — a pack's cache directory.
+ * Read the storeless index of the pack the BOOT DECISION names — for `info`,
+ * `doctor`, the MCP resource browser, and native `prompts/list`. Never boots the
+ * store, never validates with zod — a plain `JSON.parse` off disk.
  *
- * Inlined from `kernel/config/paths` + `kernel/runtime/paths` so the completion
- * fast path stays off the config layer (see the module docblock).
- */
-function packDir(contentHash: string): string {
-  const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-  return join(base, "pragma", "packs", contentHash);
-}
-
-/** The committed project lock file for a working directory. */
-function lockPath(cwd: string): string {
-  return join(cwd, LOCK_BASENAME);
-}
-
-/**
- * Read the active pack's storeless index (the locked pack, else the embedded
- * fallback), for the resource browser's list/autocomplete. Never boots the
- * store, never validates with zod — a plain `JSON.parse` off disk. Returns
- * `undefined` when no index is reachable, so callers degrade to a recovery hint.
+ * It takes the decision rather than re-deriving one so these surfaces cannot
+ * list entities the same project's reads refuse: `unavailable` yields
+ * `undefined`, and callers degrade to a recovery hint (`buildResourceList`
+ * emits the `pragma:sources` entry, `info` omits the total).
  *
- * @param cwd - The project directory (to resolve the active pack).
- * @returns The active pack index, or `undefined` when none is reachable.
+ * @param decision - The boot decision from `resolveSources`.
+ * @returns The answering pack's index, or `undefined` when none answers.
  */
-export function readPackIndex(cwd: string): PackIndex | undefined {
-  return loadActiveIndex(cwd);
+export function readPackIndex(
+  decision: SourcesDecision,
+): PackIndex | undefined {
+  switch (decision.kind) {
+    case "pack":
+      return readIndexFile(decision.dir);
+    case "embedded":
+      return parseIndex(EMBEDDED_INDEX_JSON);
+    case "unavailable":
+      return undefined;
+  }
 }
 
 /**
@@ -120,33 +127,50 @@ export function entityTotal(index: PackIndex): number {
   return subjects.size;
 }
 
-/** Load the active pack's index: the locked pack, else the embedded fallback. */
-function loadActiveIndex(cwd: string): PackIndex | undefined {
+/** Parse an index JSON string; any malformed input degrades to `undefined`. */
+function parseIndex(json: string): PackIndex | undefined {
   try {
-    const path = lockPath(cwd);
-    if (existsSync(path)) {
-      const lock = JSON.parse(readFileSync(path, "utf-8")) as {
-        contentHash?: unknown;
-      };
-      if (typeof lock.contentHash === "string") {
-        const indexPath = join(packDir(lock.contentHash), INDEX_FILE);
-        if (existsSync(indexPath)) {
-          return JSON.parse(readFileSync(indexPath, "utf-8")) as PackIndex;
-        }
-      }
-    }
+    return JSON.parse(json) as PackIndex;
   } catch {
-    // Fall through to the embedded fallback on any read/parse failure.
+    return undefined;
   }
+}
+
+/** Read a pack directory's `index.json`; any I/O or parse error is `undefined`. */
+function readIndexFile(dir: string): PackIndex | undefined {
   try {
-    return JSON.parse(EMBEDDED_INDEX_JSON) as PackIndex;
+    return parseIndex(readFileSync(join(dir, INDEX_FILE), "utf-8"));
   } catch {
     return undefined;
   }
 }
 
-/** Whether an entity matches a prefixed type filter (primary type or any type). */
-function matchesType(entity: PackIndexEntity, type: string): boolean {
+/**
+ * The fast path's index — the POINTER half of the decision table (see the module
+ * docblock). A project with a pointer reads that pack and nothing else: a
+ * pointer whose pack the cache lost yields no candidates rather than the
+ * snapshot's, which is what the boot decision does with the same state.
+ */
+function loadActiveIndex(cwd: string): PackIndex | undefined {
+  const contentHash = readActivePack(cwd);
+  return contentHash === undefined
+    ? parseIndex(EMBEDDED_INDEX_JSON)
+    : readIndexFile(packDir(contentHash));
+}
+
+/**
+ * Whether an entity matches a prefixed type filter (primary type or any type).
+ *
+ * Exported because the MCP resource listing addresses the index by the SAME
+ * vocabulary a completion source does (`McpListableRef` reuses
+ * `CompletionSourceRef`'s fields), and "which entities is this type?" must be
+ * ONE rule — two would let a type list entities its completion refuses.
+ *
+ * @param entity - The indexed entity to test.
+ * @param type - A prefixed type filter; empty matches every entity.
+ * @returns Whether the entity carries that type.
+ */
+export function matchesType(entity: PackIndexEntity, type: string): boolean {
   if (!type) return true;
   if (entity.type === type) return true;
   return Array.isArray(entity.types) && entity.types.includes(type);
@@ -180,42 +204,45 @@ export function createIndexEntityReader(
   };
 }
 
-/** All names of a prefixed type in the index (empty type = any), sorted. */
-function indexNames(index: PackIndex | undefined, type: string): string[] {
-  if (!index) return [];
-  const names = new Set<string>();
-  for (const entity of index.entities) {
-    if (matchesType(entity, type)) names.add(entity.name);
-  }
-  return [...names].sort();
-}
-
-/** The `ds:Prompt` entities' completable names (`label || name`), sorted. */
-function promptNames(index: PackIndex | undefined): string[] {
-  if (!index) return [];
-  const names = new Set<string>();
-  for (const entity of index.entities) {
-    if (matchesType(entity, PROMPT_TYPE))
-      names.add(entity.label || entity.name);
+/**
+ * One entity's completable tokens for a declared field, with NO fallback.
+ *
+ * A verb declares the field because that is the one its lookup matches on, so
+ * an entity the pack did not enrich contributes nothing. Standing a label in
+ * for an absent alt name would offer a token the lookup provably cannot resolve
+ * — a completion that hands the user a value and then refuses it — which is the
+ * complete-but-cannot-resolve split this whole declaration exists to close.
+ * Offering nothing for an under-enriched entity is the honest answer.
+ *
+ * @param entity - One index entity.
+ * @param field - The declared field to read.
+ * @returns The tokens that entity contributes; empty when it carries none.
+ */
+function readEntityNames(
+  entity: PackIndexEntity,
+  field: CompletionField,
+): readonly string[] {
+  switch (field) {
+    case "name":
+      return [entity.name];
+    case "label":
+      return entity.label ? [entity.label] : [];
+    case "altNames":
+      return entity.altNames ?? [];
   }
-  return [...names].sort();
 }
 
-/**
- * The `ds:Tier` entities' completable names, sorted. `tier lookup` matches
- * `ds:name`, so when the index carries it (projected by `buildIndex` into
- * `altNames`) those are emitted exactly; a pack whose tiers were indexed without
- * `ds:name` falls back to `label ?? name` (empty rather than wrong).
- */
-function tierNames(index: PackIndex | undefined): string[] {
+/** A ref's candidates: entities of its type, read from its field, sorted. */
+function indexNames(
+  index: PackIndex | undefined,
+  ref: CompletionSourceRef,
+): string[] {
   if (!index) return [];
   const names = new Set<string>();
   for (const entity of index.entities) {
-    if (!matchesType(entity, TIER_TYPE)) continue;
-    if (entity.altNames && entity.altNames.length > 0) {
-      for (const alt of entity.altNames) names.add(alt);
-    } else {
-      names.add(entity.label || entity.name);
+    if (!matchesType(entity, ref.type ?? "")) continue;
+    for (const name of readEntityNames(entity, ref.field ?? "name")) {
+      names.add(name);
     }
   }
   return [...names].sort();
@@ -235,8 +262,8 @@ function prefixNames(index: PackIndex | undefined): string[] {
  * reader every name family shares. Wired at the `__complete` fast path (bin) and
  * the `__complete` verb; storeless throughout (see the module docblock).
  *
- * The pack index is loaded once, lazily, and reused across the index/prompts/
- * tiers/prefixes sources; the skills filesystem walk is memoized to one walk per
+ * The pack index is loaded once, lazily, and reused across the index and
+ * prefixes sources; the skills filesystem walk is memoized to one walk per
  * process (the design's perf caveat). Every source returns the FULL candidate
  * list in canonical casing — the resolver ranks/filters against the partial.
  *
@@ -262,13 +289,9 @@ export function indexCompletionEnv(cwd: string): CompletionEnv {
     names(ref: CompletionSourceRef): readonly string[] {
       switch (ref.from) {
         case "index":
-          return indexNames(getIndex(), ref.type ?? "");
+          return indexNames(getIndex(), ref);
         case "skills":
           return getSkills();
-        case "prompts":
-          return promptNames(getIndex());
-        case "tiers":
-          return tierNames(getIndex());
         case "prefixes":
           return prefixNames(getIndex());
       }

package/src/kernel/completion/model.test.ts

@@ -33,10 +33,9 @@ function moduleWith(overrides: Partial<VerbSpec>): CapabilityModule {
 }
 
 describe("buildCompletionModel — structure", () => {
-  it("collects nouns sorted, injecting the bin-served mcp", () => {
+  it("collects nouns sorted, from the declared verbs alone", () => {
     expect(model.nouns.map((n) => n.noun)).toEqual([
       "block",
-      "mcp",
       "standard",
       "status",
     ]);
@@ -62,17 +61,12 @@ describe("buildCompletionModel — structure", () => {
     expect(status?.verbs).toEqual([]);
   });
 
-  it("injects mcp as a bare self-verb noun with nothing to offer", () => {
-    const mcp = findNoun(model, "mcp");
-    expect(mcp?.selfVerb).toEqual({
-      label: "mcp",
-      mutates: false,
-      flags: [],
-      positionals: [],
-    });
-  });
+  it("offers the mcp noun from its declared verb, with no self-verb", () => {
+    // The noun used to be conjured here because the bin served it without a
+    // spec; nothing is conjured now, so a module that declares no mcp verb
+    // gets no mcp noun.
+    expect(findNoun(model, "mcp")).toBeUndefined();
 
-  it("does not inject mcp when a live mcp noun exists", () => {
     const withMcp = buildCompletionModel([
       moduleWith({ path: ["mcp", "serve"] }),
     ]);
@@ -121,6 +115,38 @@ describe("buildCompletionModel — flags and sources", () => {
     });
   });
 
+  it("marks a spec-declared repeatable string/enum flag repeatable", () => {
+    // `string[]` is not the only accumulating shape: a compiled pack marks
+    // every declared filter `repeatable`, so `--category css --category git`
+    // is the union. Reading the kind alone de-offered the flag after its
+    // first use, which is exactly when repetition becomes offerable.
+    const repeatables = buildCompletionModel([
+      moduleWith({
+        params: [
+          {
+            kind: "enum",
+            name: "category",
+            doc: "Filter by category.",
+            values: ["css", "git"],
+            repeatable: true,
+          },
+          {
+            kind: "string",
+            name: "search",
+            doc: "Free text.",
+            repeatable: true,
+          },
+          { kind: "string", name: "note", doc: "Once only." },
+        ],
+      }),
+    ]);
+    const thing = findNoun(repeatables, "thing")?.selfVerb;
+    const flagOf = (flag: string) => thing?.flags.find((f) => f.flag === flag);
+    expect(flagOf("--category")?.repeatable).toBe(true);
+    expect(flagOf("--search")?.repeatable).toBe(true);
+    expect(flagOf("--note")?.repeatable).toBe(false);
+  });
+
   it("resolves name positionals with required/variadic markers", () => {
     expect(get?.positionals).toEqual([
       {
@@ -236,7 +262,7 @@ describe("buildCompletionModel — flags and sources", () => {
             positional: true,
             complete: {
               kind: "names",
-              source: { from: "tiers" },
+              source: { from: "index", type: "ex:Tier", field: "altNames" },
               enabled: false,
             },
           },
@@ -270,6 +296,11 @@ describe("buildCompletionModel — flags and sources", () => {
       kind: "values",
       values: ["summary", "standard", "detailed"],
     });
+    // Every flag the global parser accepts is offered — a flag the surface
+    // advertises but completion omits is invisible at the TAB that would
+    // teach it.
+    expect(flags["--no-headers"]).toMatchObject({ takesValue: false });
+    expect(flags["--quiet"]).toMatchObject({ takesValue: false });
     expect(flags["--llm"]).toBeUndefined();
     expect(flags["--version"]?.rootOnly).toBe(true);
     expect(flags["--help"]?.rootOnly).toBeUndefined();
@@ -350,6 +381,22 @@ function expectAgreement(
     .filter((noun) => noun !== "mcp" || surfaceNouns.includes("mcp"));
   expect(modelNouns).toEqual(surfaceNouns);
 
+  // A module-owned mount REPLACES its verbs' completion surface with the
+  // flags/positionals the mounted tree actually registers, so agreement for
+  // those verbs is asserted against the module's declared projection data —
+  // not the covenant-facing surface flags (which record binding param names).
+  const mountedByNoun = new Map<
+    string,
+    Readonly<Record<string, import("../spec/types.js").CompletionChildSpec>>
+  >();
+  for (const module of modules) {
+    if (!module.cliProjection) continue;
+    const children = module.cliProjection.completionChildren();
+    for (const verb of module.verbs) {
+      mountedByNoun.set(verb.path[0], children);
+    }
+  }
+
   for (const noun of surfaceNouns) {
     const nounEntry = findNoun(completionModel, noun);
     expect(nounEntry).toBeDefined();
@@ -362,6 +409,7 @@ function expectAgreement(
     ].sort();
     expect(modelLabels).toEqual(surfaceVerbs.map((v) => v.v).sort());
 
+    const mounted = mountedByNoun.get(noun);
     for (const surfaceVerb of surfaceVerbs) {
       const modelVerb: VerbEntry | undefined =
         nounEntry.selfVerb?.label === surfaceVerb.v
@@ -370,6 +418,26 @@ function expectAgreement(
       expect(modelVerb).toBeDefined();
       if (!modelVerb) continue;
 
+      const mountedSpec = mounted?.[surfaceVerb.v];
+      if (mountedSpec) {
+        expect(modelVerb.flags.map((f) => f.flag)).toEqual(
+          mountedSpec.flags.map((f) => f.flag),
+        );
+        expect(modelVerb.positionals.map((p) => p.name)).toEqual(
+          mountedSpec.positionals.map((p) => p.name),
+        );
+        expect((modelVerb.children ?? []).map((c) => c.label)).toEqual(
+          (mountedSpec.children ?? []).map((c) => c.label),
+        );
+        // A namespace node (children) never mutates for completion: the
+        // mounted tree registers the mutation trio on runnable leaves only.
+        const isNamespace = (mountedSpec.children ?? []).length > 0;
+        expect(modelVerb.mutates).toBe(
+          !isNamespace && surfaceVerb.mutates === true,
+        );
+        continue;
+      }
+
       expect(modelVerb.flags.map((f) => f.flag)).toEqual(
         surfaceVerb.flags ?? [],
       );
@@ -393,6 +461,90 @@ describe("projection agreement with emitSurface (PROTECTED)", () => {
   });
 });
 
+describe("mounted create completion — literal candidate pins (PROTECTED)", () => {
+  // The mounted-tree branch of the agreement describe compares the model to
+  // completionChildren() — the same call the model was BUILT from, so it can
+  // never catch that surface going wrong (a garbage projection satisfies
+  // it). These pins are the INDEPENDENT source: literal candidate sets
+  // through the real resolver, shellDrive noun-tier style — the segment
+  // descent (parse.ts children walk) and a leaf's registered flags.
+
+  it("segment tier: `create component <TAB>` offers exactly the framework segments", async () => {
+    const { runComplete } = await import("./complete.js");
+    expect(
+      await runComplete(["create", "component", ""], capabilities),
+    ).toEqual(["lit", "react", "svelte"]);
+    expect(
+      await runComplete(["create", "application", ""], capabilities),
+    ).toEqual(["react"]);
+  });
+
+  it("namespace flag tier: `create component --<TAB>` offers NO leaf prompt or mutation flags", async () => {
+    const { runComplete } = await import("./complete.js");
+    // Prompt AND mutation flags are registered on the LEAVES; a pre-segment
+    // offer completes orderings Commander rejects (`create component
+    // --use-ts-stories svelte` and `create component --dry-run react` both
+    // exit 2 as unknown options). Until a framework segment is typed, only
+    // the global tier is offered.
+    expect(
+      await runComplete(["create", "component", "--"], capabilities),
+    ).toEqual([
+      "--detail",
+      "--format",
+      "--help",
+      "--no-headers",
+      "--quiet",
+      "--verbose",
+    ]);
+  });
+
+  it("leaf flag tier: `create component react --<TAB>` offers the REGISTERED flags", async () => {
+    const { runComplete } = await import("./complete.js");
+    // The leaf's prompt-derived flags in their registered spelling (--no-
+    // forms for default-true confirms, --component-path for the positional
+    // prompt — addPromptOptions registers EVERY prompt as an option), the
+    // mutation trio, and the root globals — as literals, so dropping the
+    // framework positional's values or a leaf prompt flag goes red instead
+    // of silently green.
+    expect(
+      await runComplete(["create", "component", "react", "--"], capabilities),
+    ).toEqual([
+      "--component-path",
+      "--detail",
+      "--dry-run",
+      "--format",
+      "--help",
+      "--no-headers",
+      "--no-with-ssr-tests",
+      "--no-with-stories",
+      "--no-with-styles",
+      "--quiet",
+      "--undo",
+      "--verbose",
+      "--yes",
+    ]);
+    // Svelte's leaf carries its own extra flag — per-leaf, not unioned.
+    expect(
+      await runComplete(["create", "component", "svelte", "--"], capabilities),
+    ).toEqual([
+      "--component-path",
+      "--detail",
+      "--dry-run",
+      "--format",
+      "--help",
+      "--no-headers",
+      "--no-with-ssr-tests",
+      "--no-with-stories",
+      "--no-with-styles",
+      "--quiet",
+      "--undo",
+      "--use-ts-stories",
+      "--verbose",
+      "--yes",
+    ]);
+  });
+});
+
 /** Regression pin: ParamSpec.complete stays optional on every param kind. */
 it("accepts params without a complete field", () => {
   const params: ParamSpec[] = [