@canonical/pragma-cli 0.38.0 → 0.40.0

package/src/kernel/spec/wireType.ts

@@ -0,0 +1,53 @@
+/**
+ * What a parameter accepts on the wire, stated once: the MCP schema is built
+ * from it and the reference prints it. A `string[]` positional and every
+ * `repeatable` flag are LISTS — advertised as an array, with one bare string
+ * coerced to a list of one. Pure and zod-free (the reference is storeless).
+ */
+
+import type { ParamSpec } from "./types.js";
+
+/** The type of one value of a parameter. */
+export type WireItem =
+  | { readonly kind: "string" | "number" | "boolean" }
+  | { readonly kind: "enum"; readonly values: readonly string[] };
+
+/** A parameter's wire type: what one value is, and whether several are taken. */
+export interface WireType {
+  readonly item: WireItem;
+  /** Several values are accepted (and one bare value is coerced to a list). */
+  readonly list: boolean;
+}
+
+/**
+ * Derive the wire type of a parameter from its spec.
+ *
+ * @param param - The parameter spec.
+ * @returns The one statement both the schema and the reference read.
+ */
+export function wireType(param: ParamSpec): WireType {
+  if (param.kind === "string[]") {
+    return { item: { kind: "string" }, list: true };
+  }
+  const item: WireItem =
+    param.kind === "enum"
+      ? { kind: "enum", values: param.values }
+      : { kind: param.kind };
+  return { item, list: param.repeatable === true };
+}
+
+/**
+ * Print a wire type as the reference's type label (`string[]`,
+ * `enum(a, b)[]`). Enum values are comma-joined, never pipe-joined, so the
+ * label is safe inside a Markdown table cell without escaping.
+ *
+ * @param wire - The wire type to print.
+ * @returns The label.
+ */
+export function formatWireType(wire: WireType): string {
+  const item =
+    wire.item.kind === "enum"
+      ? `enum(${wire.item.values.join(", ")})`
+      : wire.item.kind;
+  return wire.list ? `${item}[]` : item;
+}

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

@@ -225,7 +225,8 @@ describe("empty ≠ silence on the machine surfaces", () => {
     expect(result.data).toEqual([]);
     const notice = (result.meta as { notice?: string }).notice ?? "";
     expect(notice).toContain(
-      "No standard matches `--search zzz-nothing-matches-this`.",
+      // Spelled as the MCP argument, not the CLI flag: this is a tool result.
+      'No standard matches `search: "zzz-nothing-matches-this"`.',
     );
     expect(notice).toContain("Category slugs come from the graph");
   });

package/src/testing/behavioral/journeys.firstInstall.test.ts

@@ -13,9 +13,9 @@
  * hierarchy with no `Global`, is a change a human should be made to look at.
  */
 
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import { storyModules } from "../../capabilities/distribution.js";
 import { checkPackageRefs } from "../../capabilities/doctor/checks/checkPackageRefs.js";
@@ -24,8 +24,10 @@ import { collectStatus } from "../../capabilities/sources/collectStatus.js";
 import { PragmaError } from "../../kernel/error/PragmaError.js";
 import { executeVerb } from "../../kernel/project/cli/dispatch.js";
 import { bootRuntime } from "../../kernel/runtime/boot.js";
+import { activePackPath, packDir } from "../../kernel/runtime/paths.js";
 import type { GlobalFlags } from "../../kernel/runtime/types.js";
 import type { CapabilityModule, VerbSpec } from "../../kernel/spec/types.js";
+import { projectMcp } from "../helpers/projectMcp.js";
 
 // Every case here boots its own runtime — a fresh install is what is under test —
 // and the first read in the process parses the embedded pack cold: 65,000 triples,
@@ -235,3 +237,71 @@ describe("first install — the surfaces say where the answers come from", () =>
     expect(result.detail).toContain("pragma sources update");
   });
 });
+
+describe("after an upgrade — a pack an older CLI built does not answer", () => {
+  /**
+   * A cwd pointed at a complete pack that some older CLI built.
+   *
+   * Planted rather than built: the point is what the boot does with the
+   * POINTER, and the pack it names is never loaded — if it were, this pack's
+   * one-triple graph would answer instead of the snapshot, which is exactly the
+   * failure under test.
+   */
+  function stalePackCwd(): { cwd: string; hash: string } {
+    const cwd = mkdtempSync(join(tmpdir(), "pragma-stale-"));
+    const hash = "c".repeat(64);
+    const dir = packDir(hash);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "data.nq"), "<urn:s> <urn:p> <urn:o> .\n");
+    writeFileSync(join(dir, "schema.json"), "{}");
+    writeFileSync(join(dir, "index.json"), "{}");
+    writeFileSync(join(dir, "stories.json"), "[]");
+    writeFileSync(
+      join(dir, "manifest.json"),
+      JSON.stringify({
+        name: "pragma",
+        version: "0.1.0",
+        sourceRef: "@canonical/design-system@git:ac03466",
+        contentHash: hash,
+        prefixes: {},
+        createdAt: "2026-09-10T21:49:00.411Z",
+      }),
+    );
+    mkdirSync(dirname(activePackPath(cwd)), { recursive: true });
+    writeFileSync(activePackPath(cwd), hash);
+    return { cwd, hash };
+  }
+
+  it("the read answers from the shipped snapshot, and its meta names the pack", async () => {
+    const { cwd, hash } = stalePackCwd();
+    const outcome = await executeVerb(
+      verbOf(blockModule, "block list"),
+      {},
+      NO_MUTATION,
+      bootRuntime(JSON_FLAGS, cwd),
+    );
+    const envelope = JSON.parse(outcome.stdout as string) as {
+      data: { name: string }[];
+      meta: Record<string, unknown>;
+    };
+    // The upgrade's own graph answered — the planted pack holds one triple and
+    // no blocks at all, so a row named Button can only have come from the
+    // snapshot.
+    expect(envelope.data.map((row) => row.name)).toContain("Button");
+    // And the answer says, as data, which pack it did not come from.
+    expect(envelope.meta.ignoredPack).toEqual({
+      contentHash: hash,
+      builtBy: "0.1.0",
+      builtAt: "2026-09-10T21:49:00.411Z",
+    });
+  });
+
+  it("the same read over MCP carries the same meta", async () => {
+    const { cwd, hash } = stalePackCwd();
+    const mcp = await projectMcp([blockModule], cwd);
+    const envelope = await mcp.callTool("block_list");
+    expect(envelope.meta).toMatchObject({
+      ignoredPack: { contentHash: hash, builtBy: "0.1.0" },
+    });
+  });
+});

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

@@ -37,6 +37,7 @@ import {
   assertCliMcpParity,
   JSON_FLAGS,
   NO_MUTATION,
+  noticeOf,
 } from "../helpers/parity.js";
 import { projectMcp } from "../helpers/projectMcp.js";
 import { listVerbs, liveVerbs, lookupVerbs } from "./liveReadSurface.js";
@@ -78,6 +79,45 @@ describe("assertCliMcpParity — the shared helper, over stable-now nouns (A5)",
   });
 });
 
+describe("the one place the envelopes differ: the spelling inside meta.notice", () => {
+  it("an empty list is equal on both surfaces but for how its next step is spelled", async () => {
+    // A search that matches nothing: the empty answer names it, says how to
+    // widen, and keeps the story's next call — unless that call is the rebuild,
+    // which a miss on a healthy store must never advise.
+    const standardModule = capabilities.find(
+      (module) => module.name === "standard",
+    );
+    const verb = standardModule?.verbs.find(
+      (v) => v.path[1] === "list",
+    ) as VerbSpec;
+    const cwd = freshCwd();
+    const params = { search: "zzz-nothing-matches-this" };
+    const cliEnvelope = await assertCliMcpParity({
+      modules: capabilities,
+      verb,
+      tool: "standard_list",
+      cwd,
+      params,
+    });
+    expect(cliEnvelope.data).toEqual([]);
+    const cliNotice = noticeOf(cliEnvelope) as string;
+    expect(cliNotice).toContain("`--search zzz-nothing-matches-this`");
+    expect(cliNotice).toContain("Run `pragma standard categories`.");
+
+    const mcp = await projectMcp(capabilities, cwd);
+    const mcpNotice = noticeOf(await mcp.callTool("standard_list", params));
+    const rebuilt = noticeOf(await mcp.callTool("token_consumers", params));
+    await mcp.cleanup();
+    expect(mcpNotice).toContain('`search: "zzz-nothing-matches-this"`');
+    expect(mcpNotice).toContain("Call `standard_categories {}`.");
+    expect(mcpNotice).not.toContain("pragma ");
+    // A story whose next call IS the rebuild keeps its account and drops it.
+    expect(rebuilt).toContain("drop the argument, or loosen it");
+    expect(rebuilt).not.toContain("sources_update");
+    // Two full-registry MCP servers and a CLI dispatch: slow on a busy machine.
+  }, 30_000);
+});
+
 describe("plan-first is uniform across surfaces (A6)", () => {
   it("CLI --dry-run and MCP no-confirm describe the SAME effects, in different meta shapes", async () => {
     const cwd = freshCwd();

package/src/testing/eval/__snapshots__/eval.test.ts.snap

@@ -48,7 +48,7 @@ exports[`eval harness — seed gate > runs the full seed (stable + read-noun) ca
     "passed": true,
   },
   {
-    "id": "content-instructions-present-and-mentions-discovery",
+    "id": "content-instructions-present-and-index-tools-by-question",
     "kind": "content",
     "passed": true,
   },

package/src/testing/eval/cases/assembly.ts

@@ -93,15 +93,16 @@ export const assemblyEvalCases: readonly EvalCase[] = [
     },
   },
   {
-    id: "content-instructions-present-and-mentions-discovery",
+    id: "content-instructions-present-and-index-tools-by-question",
     kind: "content",
     input:
-      "the server sends handshake instructions that mention `capabilities` and the discovery flow.",
+      "the server sends handshake instructions that mention `capabilities` and index tools by the question each answers (the index replaced the prose discovery sequence).",
     async expect({ mcp }) {
       const instructions = mcp.instructions();
       assert.ok(instructions, "expected server instructions at initialize");
       assert.match(String(instructions), /capabilities/);
-      assert.match(String(instructions).toLowerCase(), /discovery/);
+      assert.match(String(instructions), /^When asked:$/m);
+      assert.match(String(instructions), /^token_consumers — /m);
     },
   },
   {

package/src/testing/eval/cases/stable.ts

@@ -9,6 +9,7 @@
 import assert from "node:assert/strict";
 import { compilePack } from "../../../kernel/packs/compile.js";
 import type { PackDefinition } from "../../../kernel/packs/types.js";
+import { CONDENSED_SDL_TOKEN_BUDGET } from "../../../kernel/spec/emitSurface.js";
 import type { CapabilityModule } from "../../../kernel/spec/types.js";
 import { bootFixtureRuntime } from "../../helpers/fixtureGraph.js";
 import { projectMcp } from "../../helpers/projectMcp.js";
@@ -58,8 +59,6 @@ const WIDGET_PACK: PackDefinition = {
   },
 };
 
-/** The condensed-SDL token-budget ceiling the covenant reserves (seeded, not enforced). */
-const CONDENSED_SDL_TOKEN_BUDGET = 8000;
 /** The old suite's one token anchor: ~1 token per 4 characters. */
 const CHARS_PER_TOKEN = 4;
 
@@ -83,7 +82,7 @@ export const stableEvalCases: readonly EvalCase[] = [
     id: "content-condensed-sdl-token-budget",
     kind: "content",
     input:
-      "the aggregate live MCP tool catalog (name + description + inputSchema, whatever it currently contains) stays under the condensedSDL budget (<=8000 tokens, ~1 token/4 chars).",
+      "the aggregate live MCP tool catalog (name + description + inputSchema, whatever it currently contains) stays under the condensedSDL budget (kernel/spec/emitSurface.ts#CONDENSED_SDL_TOKEN_BUDGET, ~1 token/4 chars).",
     async expect({ mcp }) {
       const tools = await mcp.listTools();
       assert.ok(tools.length > 0, "expected at least one registered tool");

package/src/testing/helpers/callSchema.ts

@@ -0,0 +1,40 @@
+/**
+ * The ONE validator of a call: the named verb's real MCP input schema.
+ *
+ * `capabilities/callRule.test.ts` runs the statically known calls through it,
+ * and `setupCallChecking.ts` installs the same function on the call renderer
+ * (which hands it the declared verb the call names),
+ * so a recovery built where an error is thrown is held to exactly the rule an
+ * example is.
+ */
+
+import { z } from "zod";
+import { buildToolShape } from "../../kernel/project/mcp/registerVerb.js";
+import type { Call, VerbSpec } from "../../kernel/spec/types.js";
+
+/**
+ * Say what is wrong with a call, or nothing.
+ *
+ * @param call - The call to check.
+ * @param verb - The verb it names, or `undefined` when none is registered.
+ * @returns The problem: it names no registered verb, or its params fail that
+ *   verb's tool schema.
+ */
+export function findCallProblem(
+  call: Call,
+  verb: VerbSpec | undefined,
+): string | undefined {
+  if (!verb) return "names no registered verb";
+  // A call is a next step or an example, and neither may skip the plan or pick
+  // a write root: `confirm` and `cwd` are the caller's to add, never a hint's.
+  const { confirm: _confirm, cwd: _cwd, ...shape } = buildToolShape(verb);
+  const parsed = z
+    .object(shape)
+    .strict()
+    .safeParse(call.params ?? {});
+  return parsed.success
+    ? undefined
+    : parsed.error.issues
+        .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+        .join("; ");
+}

package/src/testing/helpers/parity.ts

@@ -7,7 +7,14 @@
  * no separate condensed/text/tokens MCP shape in v2 (confirmed:
  * `mcp/envelope.ts` reuses the CLI's envelope builders verbatim), so parity
  * simplifies to structural data-equality — no byte-exact `condensed ===
- * fmt.llm(...)` comparison to reproduce. This generalizes the pattern already
+ * fmt.llm(...)` comparison to reproduce. The contract has ONE exception, and
+ * the asserter normalises exactly it: inside `meta.notice`, a call or argument
+ * is spelled as a command on the CLI and as a tool call over MCP. Only those
+ * spellings are normalised — the backticked spans and the `Run`/`Call` lead —
+ * so a scope or paging sentence missing from one surface still fails. What it
+ * CANNOT see: a span is blanked whole, so the two surfaces naming a different
+ * argument VALUE (or a different call) inside one goes unnoticed here — the
+ * renderers' own tests pin those spellings. This generalizes the pattern already
  * proven ad hoc in `mcp/parity.test.ts` (`probe echo`) and `sources.test.ts`
  * (`sources status`) into one reusable helper every read noun's tests drive.
  */
@@ -51,6 +58,30 @@ export interface ParityCase {
   readonly flags?: Partial<GlobalFlags>;
 }
 
+/** An envelope's `meta.notice` sentence, if it carries one. */
+export function noticeOf(
+  envelope: Record<string, unknown>,
+): string | undefined {
+  return (envelope.meta as { notice?: string } | undefined)?.notice;
+}
+
+/**
+ * The envelope with its notice's surface spellings blanked: every backticked
+ * span (a call, an argument) and the `Run`/`Call` lead before one. The prose
+ * around them — which sentences are present, in what order — is kept.
+ */
+function withNormalisedNotice(envelope: Record<string, unknown>): unknown {
+  const notice = noticeOf(envelope);
+  if (notice === undefined) return envelope;
+  const normalised = notice
+    .replace(/\b(Run|Call) (?=`)/g, "")
+    .replace(/``.*?``|`[^`]*`/g, "`…`");
+  return {
+    ...envelope,
+    meta: { ...(envelope.meta as object), notice: normalised },
+  };
+}
+
 /**
  * Run the same read through the CLI (`--format json`) and MCP, and assert the
  * two envelopes are deep-equal.
@@ -81,6 +112,8 @@ export async function assertCliMcpParity(
     await mcp.cleanup();
   }
 
-  expect(cliEnvelope).toEqual(mcpEnvelope);
+  expect(withNormalisedNotice(cliEnvelope)).toEqual(
+    withNormalisedNotice(mcpEnvelope),
+  );
   return cliEnvelope;
 }

package/src/testing/setupCallChecking.ts

@@ -0,0 +1,30 @@
+/**
+ * Per-file test setup: make every call rendered under test prove itself.
+ *
+ * A recovery is built where an error is thrown, from values only that line
+ * knows, so the recoveries cannot be listed ahead of time the way examples and
+ * pack empties can (`capabilities/callRule.test.ts` lists those). What can be
+ * done is to check each one as it is built, with the SAME validator the
+ * conformance test uses (`helpers/callSchema.ts` — the verb's real MCP input
+ * schema): a recovery naming a verb that does not exist, or params its schema
+ * rejects, throws. A fixture's verbs are not the distribution's, so a test that
+ * renders a call to one declares it first.
+ *
+ * The residual, stated plainly: this reaches a recovery only on a line some
+ * test executes, and with one set of values. A line no test runs is unchecked
+ * until one does.
+ *
+ * Imported inside the hook, not at the top: a setup file's static imports are
+ * evaluated before the test file's `vi.mock` calls register, which would hand
+ * `identity.test.ts` this distribution's constants instead of its fork's.
+ */
+
+import { beforeAll } from "vitest";
+
+beforeAll(async () => {
+  const { capabilities } = await import("../capabilities/index.js");
+  const call = await import("../kernel/spec/call.js");
+  const { findCallProblem } = await import("./helpers/callSchema.js");
+  call.declareVerbs(capabilities.flatMap((module) => module.verbs));
+  call.checkCallsWith(findCallProblem);
+});

package/dist/src/capabilities/capabilities/hints.js

@@ -1,223 +0,0 @@
-/**
- * The one authored input to the `capabilities` catalog: a `use_when` behavioural
- * hint + category per tool. Everything else (the tool SET, counts, discovery
- * samples) is DERIVED from the live grammar at build time, so this table is the
- * only thing to keep in sync — and the drift-guard test (`capabilities.test.ts`)
- * fails CI if a live tool has no hint, a hint names a tool that no longer
- * exists, or a hint's category disagrees with the tool's real `mutates` flag.
- *
- * `use_when` strings for the surviving tools are ported verbatim from the old
- * shell's `domains/llm/data/toolCatalog.ts`; the net-new v2 tools (config_set,
- * graph_query, setup, upgrade, doctor, capabilities, prompt_*, sources_*,
- * tier_lookup, create_*) are authored here.
- */
-import { BIN_NAME } from "../../constants.js";
-/**
- * Behavioural hints keyed by the LIVE tool name (`emitSurface` naming rule:
- * `noun` or `noun_verb`). Categories: `write` ⟺ the verb mutates; `orientation`
- * = the session-start map; `diagnostic` = environment/version reporting; else
- * `read`. The drift guard enforces every one of those invariants.
- */
-export const TOOL_HINTS = {
-    // — Orientation ————————————————————————————————————————————————————————————
-    capabilities: {
-        category: "orientation",
-        use_when: "Starting a session — understand conventions, available tools, and the discovery flow",
-    },
-    // — Diagnostic ————————————————————————————————————————————————————————————
-    doctor: {
-        category: "diagnostic",
-        use_when: "Diagnosing environment issues — config, store, completions, MCP health",
-    },
-    info: {
-        category: "diagnostic",
-        use_when: `Checking ${BIN_NAME} version, configuration summary, and store state`,
-    },
-    // — Read ——————————————————————————————————————————————————————————————————
-    block_list: {
-        category: "read",
-        use_when: "Browsing all components, patterns, layouts, and subcomponents in the store",
-    },
-    block_lookup: {
-        category: "read",
-        use_when: "Need full anatomy, modifiers, tokens, and standards for specific blocks by name or IRI",
-    },
-    block_sample: {
-        category: "read",
-        use_when: "See actual block data shapes before querying — returns random instances each call, prevents guessing at property names",
-    },
-    colophon: {
-        category: "read",
-        use_when: "Understanding how the active domain is built — its declared colophon, for onboarding or a demo",
-    },
-    config_get: {
-        category: "read",
-        use_when: "Reading ONE config field's effective value and the layer it came from — the single-value form of config_show",
-    },
-    config_show: {
-        category: "read",
-        use_when: "Checking the active configuration (tier, channel, detail) and which layer set each field",
-    },
-    graph_connect: {
-        category: "read",
-        use_when: "Deciding whether two entities are related at all — the shortest relation paths between them, or which kind of nothing there is",
-    },
-    graph_inspect: {
-        category: "read",
-        use_when: "Examining all triples for a specific URI — predicates, objects, and types",
-    },
-    graph_query: {
-        category: "read",
-        use_when: "Complex SPARQL joins or aggregations that other tools cannot express",
-    },
-    modifier_list: {
-        category: "read",
-        use_when: "Listing all modifier families and their allowed values",
-    },
-    modifier_lookup: {
-        category: "read",
-        use_when: "Need values and usage details for specific modifier families by name",
-    },
-    modifier_sample: {
-        category: "read",
-        use_when: "See actual modifier data shapes (with value lists) before querying — returns random instances each call",
-    },
-    ontology_list: {
-        category: "read",
-        use_when: "Discovering loaded namespaces, prefixes, and class/property counts",
-    },
-    ontology_lookup: {
-        category: "read",
-        use_when: "Exploring the full schema of a namespace by name — classes, properties, and hierarchy",
-    },
-    prompt_list: {
-        category: "read",
-        use_when: "Browsing the workflow prompt templates the active graph offers",
-    },
-    prompt_lookup: {
-        category: "read",
-        use_when: "Fetching a specific workflow prompt template's body and arguments by name",
-    },
-    skill_list: {
-        category: "read",
-        use_when: "Discovering agent skills provided by installed packs",
-    },
-    skill_lookup: {
-        category: "read",
-        use_when: "Loading full SKILL.md instructions for a specific agent skill by name",
-    },
-    sources_status: {
-        category: "read",
-        use_when: "Checking whether the local knowledge-graph pack is built and current",
-    },
-    standard_list: {
-        category: "read",
-        use_when: "Browsing code standards, optionally filtered by category or search term",
-    },
-    standard_lookup: {
-        category: "read",
-        use_when: "Need do/don't code examples for specific coding standards by name or IRI",
-    },
-    standard_categories: {
-        category: "read",
-        use_when: "Discovering which standard categories exist before filtering",
-    },
-    concept_list: {
-        category: "read",
-        use_when: "Browsing long-form design-system concepts (foundations, how-to guides, decision guides)",
-    },
-    concept_lookup: {
-        category: "read",
-        use_when: "Reading a concept's full Markdown documentation by name or IRI",
-    },
-    implementation_list: {
-        category: "read",
-        use_when: "Finding which library implements a block, on which platform, and where its source lives",
-    },
-    implementation_libraries: {
-        category: "read",
-        use_when: "Discovering which implementation libraries exist, and how much of the design system each covers",
-    },
-    standard_sample: {
-        category: "read",
-        use_when: "See actual standard data shapes (with dos/donts) before querying — returns random instances each call",
-    },
-    tier_list: {
-        category: "read",
-        use_when: "Picking the tier to scope a read to (the `tier` parameter)",
-    },
-    tier_lookup: {
-        category: "read",
-        use_when: "Need the blocks scoped to a specific tier by name",
-    },
-    token_list: {
-        category: "read",
-        use_when: "Browsing which token SYMBOLS exist (the logical dotted names), optionally by type or by the symbol a channel provisions",
-    },
-    token_lookup: {
-        category: "read",
-        use_when: "Need one symbol in full — its definitions, the families that may rebind it, and what it resolves to at each position",
-    },
-    token_values: {
-        category: "read",
-        use_when: "Need the value a symbol resolves to at a position, with the chain that produced it or the symbol it derives from",
-    },
-    token_consumers: {
-        category: "read",
-        use_when: "Need which blocks consume a symbol, at which style key, state and rank",
-    },
-    token_sample: {
-        category: "read",
-        use_when: "See actual token symbol data shapes before querying — returns random instances each call",
-    },
-    variable_list: {
-        category: "read",
-        use_when: "Browsing the platform names a stylesheet declares, by platform, symbol, tier, visibility or coordinate — including the 236 that stand for no symbol",
-    },
-    variable_lookup: {
-        category: "read",
-        use_when: "Need one platform variable in full — its symbol, tier, visibility, and every selector and at-rule it is declared under",
-    },
-    variable_chain: {
-        category: "read",
-        use_when: "Need what a variable finally means: the transitive walk to every symbol it reaches",
-    },
-    variable_sample: {
-        category: "read",
-        use_when: "See actual platform variable data shapes before querying — returns random instances each call",
-    },
-    // — Write ——————————————————————————————————————————————————————————————————
-    config_set: {
-        category: "write",
-        use_when: "Setting any config field by name — tier, channel, or detail (e.g. `config set tier apps/lxd`)",
-    },
-    config_unset: {
-        category: "write",
-        use_when: 'Clearing a config field so the built-in default applies again — no value means "remove", this tool does',
-    },
-    create_component: {
-        category: "write",
-        use_when: "Scaffolding a new component (React, Svelte, or Lit)",
-    },
-    create_package: {
-        category: "write",
-        use_when: "Scaffolding a new npm package with proper monorepo configuration",
-    },
-    create_application: {
-        category: "write",
-        use_when: "Scaffolding a new React application with routing, optional Relay, and either server-side rendering or a client-only SPA",
-    },
-    setup: {
-        category: "write",
-        use_when: `Installing ${BIN_NAME}'s shell completions, MCP config, skills, and LSP into the environment`,
-    },
-    sources_update: {
-        category: "write",
-        use_when: "Building or refreshing the knowledge-graph pack from the configured packs",
-    },
-    upgrade: {
-        category: "write",
-        use_when: `Upgrading the ${BIN_NAME} CLI itself to the latest release`,
-    },
-};
-//# sourceMappingURL=hints.js.map

package/dist/src/capabilities/capabilities/hints.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hints.js","sourceRoot":"","sources":["../../../../src/capabilities/capabilities/hints.ts"],"names":[],"mappings":"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"}